dart::InductionVar Class Reference

#include <loops.h>

Inheritance diagram for dart::InductionVar:

Classes
struct	Bound

Public Types
enum	Kind { kInvariant , kLinear , kWrapAround , kPeriodic }

Public Member Functions
	InductionVar (int64_t offset, int64_t mult, Definition *def)
	InductionVar (int64_t offset)
	InductionVar (Kind kind, InductionVar *initial, InductionVar *next)
bool	IsEqual (const InductionVar *other) const
bool	CanComputeDifferenceWith (const InductionVar *other, int64_t *diff) const
bool	CanComputeBounds (LoopInfo *loop, Instruction *pos, InductionVar **min, InductionVar **max)
Kind	kind () const
int64_t	offset () const
int64_t	mult () const
Definition *	def () const
InductionVar *	initial () const
InductionVar *	next () const
const GrowableArray< Bound > &	bounds ()
void	PrintTo (BaseTextBuffer *f) const
const char *	ToCString () const
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static bool	IsInvariant (const InductionVar *x)
static bool	IsConstant (const InductionVar *x)
static bool	IsConstant (const InductionVar *x, int64_t *c)
static bool	IsLinear (const InductionVar *x)
static bool	IsLinear (const InductionVar *x, int64_t *s)
static bool	IsWrapAround (const InductionVar *x)
static bool	IsPeriodic (const InductionVar *x)
static bool	IsInduction (const InductionVar *x)

Friends
class	InductionVarAnalysis

Detailed Description

Definition at line 31 of file loops.h.

Member Enumeration Documentation

Kind

enum dart::InductionVar::Kind

Enumerator
kInvariant
kLinear
kWrapAround
kPeriodic

Definition at line 33 of file loops.h.

            {
    kInvariant,
    kLinear,
    kWrapAround,
    kPeriodic,
  };

Constructor & Destructor Documentation

InductionVar() [1/3]

dart::InductionVar::InductionVar ( int64_t  offset, int64_t  mult, Definition *  def  )

inline

Definition at line 50 of file loops.h.

      : kind_(kInvariant), offset_(offset), mult_(mult), def_(def), bounds_() {
    ASSERT(mult_ == 0 || def != nullptr);
  }

InductionVar() [2/3]

dart::InductionVar::InductionVar ( int64_t  offset )

inlineexplicit

Definition at line 56 of file loops.h.

: InductionVar(offset, 0, nullptr) {}

InductionVar() [3/3]

dart::InductionVar::InductionVar ( Kind  kind, InductionVar *  initial, InductionVar *  next  )

inline

Definition at line 59 of file loops.h.

      : kind_(kind), initial_(initial), next_(next), bounds_() {
    ASSERT(IsInvariant(initial));
    switch (kind) {
      case kLinear:
      case kPeriodic:
        ASSERT(IsInvariant(next));
        break;
      case kWrapAround:
        ASSERT(next != nullptr);
        break;
      default:
        UNREACHABLE();
    }
  }

Member Function Documentation

bounds()

const GrowableArray< Bound > & dart::InductionVar::bounds ( )

inline

Definition at line 128 of file loops.h.

{ return bounds_; }

CanComputeBounds()

bool dart::InductionVar::CanComputeBounds	(	LoopInfo *	loop,
		Instruction *	pos,
		InductionVar **	min,
		InductionVar **	max
	)

Definition at line 920 of file loops.cc.

                                                        {
  // Consult cache first.
  LoopInfo::MemoKV::Pair* pair1 = loop->memo_cache_.Lookup(this);
  if (pair1 != nullptr) {
    LoopInfo::MemoVal::PosKV::Pair* pair2 = pair1->value->memo_.Lookup(pos);
    if (pair2 != nullptr) {
      *min = pair2->value.first;
      *max = pair2->value.second;
      return true;
    }
  }
  // Compute and cache.
  if (CanComputeBoundsImpl(loop, pos, min, max)) {
    ASSERT(*min != nullptr && *max != nullptr);
    LoopInfo::MemoVal* memo = nullptr;
    if (pair1 != nullptr) {
      memo = pair1->value;
    } else {
      memo = new LoopInfo::MemoVal();
      loop->memo_cache_.Insert(LoopInfo::MemoKV::Pair(this, memo));
    }
    memo->memo_.Insert(
        LoopInfo::MemoVal::PosKV::Pair(pos, std::make_pair(*min, *max)));
    return true;
  }
  return false;
}

CanComputeDifferenceWith()

bool dart::InductionVar::CanComputeDifferenceWith	(	const InductionVar *	other,
		int64_t *	diff
	)		const

Definition at line 841 of file loops.cc.

                                                                 {
  if (IsInvariant(this) && IsInvariant(other)) {
    if (def_ == other->def_ && mult_ == other->mult_) {
      *diff = other->offset_ - offset_;
      return true;
    }
  } else if (IsLinear(this) && IsLinear(other)) {
    return next_->IsEqual(other->next_) &&
           initial_->CanComputeDifferenceWith(other->initial_, diff);
  }
  // TODO(ajcbik): examine other induction kinds too?
  return false;
}

def()

Definition * dart::InductionVar::def ( ) const

inline

Definition at line 116 of file loops.h.

                          {
    ASSERT(kind_ == kInvariant);
    return def_;
  }

initial()

InductionVar * dart::InductionVar::initial ( ) const

inline

Definition at line 120 of file loops.h.

                                {
    ASSERT(kind_ != kInvariant);
    return initial_;
  }

IsConstant() [1/2]

static bool dart::InductionVar::IsConstant ( const InductionVar *  x )

inlinestatic

Definition at line 140 of file loops.h.

                                                {
    return x != nullptr && x->kind_ == kInvariant && x->mult_ == 0;
  }

IsConstant() [2/2]

static bool dart::InductionVar::IsConstant ( const InductionVar *  x, int64_t *  c  )

inlinestatic

Definition at line 145 of file loops.h.

                                                            {
    if (IsConstant(x)) {
      *c = x->offset_;
      return true;
    }
    return false;
  }

IsEqual()

bool dart::InductionVar::IsEqual ( const InductionVar *  other ) const

inline

Definition at line 76 of file loops.h.

                                                {
    ASSERT(other != nullptr);
    if (kind_ == other->kind_) {
      switch (kind_) {
        case kInvariant:
          return offset_ == other->offset_ && mult_ == other->mult_ &&
                 (mult_ == 0 || def_ == other->def_);
        case kLinear:
        case kWrapAround:
        case kPeriodic:
          return initial_->IsEqual(other->initial_) &&
                 next_->IsEqual(other->next_);
      }
    }
    return false;
  }

IsInduction()

static bool dart::InductionVar::IsInduction ( const InductionVar *  x )

inlinestatic

Definition at line 177 of file loops.h.

                                                 {
    return x != nullptr && x->kind_ != kInvariant;
  }

IsInvariant()

static bool dart::InductionVar::IsInvariant ( const InductionVar *  x )

inlinestatic

Definition at line 135 of file loops.h.

                                                 {
    return x != nullptr && x->kind_ == kInvariant;
  }

IsLinear() [1/2]

static bool dart::InductionVar::IsLinear ( const InductionVar *  x )

inlinestatic

Definition at line 154 of file loops.h.

                                              {
    return x != nullptr && x->kind_ == kLinear;
  }

IsLinear() [2/2]

static bool dart::InductionVar::IsLinear ( const InductionVar *  x, int64_t *  s  )

inlinestatic

Definition at line 159 of file loops.h.

                                                          {
    if (IsLinear(x)) {
      return IsConstant(x->next_, s);
    }
    return false;
  }

IsPeriodic()

static bool dart::InductionVar::IsPeriodic ( const InductionVar *  x )

inlinestatic

Definition at line 172 of file loops.h.

                                                {
    return x != nullptr && x->kind_ == kPeriodic;
  }

IsWrapAround()

static bool dart::InductionVar::IsWrapAround ( const InductionVar *  x )

inlinestatic

Definition at line 167 of file loops.h.

                                                  {
    return x != nullptr && x->kind_ == kWrapAround;
  }

kind()

Kind dart::InductionVar::kind ( ) const

inline

Definition at line 107 of file loops.h.

{ return kind_; }

mult()

int64_t dart::InductionVar::mult ( ) const

inline

Definition at line 112 of file loops.h.

                       {
    ASSERT(kind_ == kInvariant);
    return mult_;
  }

next()

InductionVar * dart::InductionVar::next ( ) const

inline

Definition at line 124 of file loops.h.

                             {
    ASSERT(kind_ != kInvariant);
    return next_;
  }

offset()

int64_t dart::InductionVar::offset ( ) const

inline

Definition at line 108 of file loops.h.

                         {
    ASSERT(kind_ == kInvariant);
    return offset_;
  }

PrintTo()

void dart::InductionVar::PrintTo

(

BaseTextBuffer *

f

)

const

Definition at line 951 of file loops.cc.

                                                  {
  switch (kind_) {
    case kInvariant:
      if (mult_ != 0) {
        f->Printf("(%" Pd64 " + %" Pd64 " x %.4s)", offset_, mult_,
                  def_->ToCString());
      } else {
        f->Printf("%" Pd64, offset_);
      }
      break;
    case kLinear:
      f->Printf("LIN(%s + %s * i)", initial_->ToCString(), next_->ToCString());
      break;
    case kWrapAround:
      f->Printf("WRAP(%s, %s)", initial_->ToCString(), next_->ToCString());
      break;
    case kPeriodic:
      f->Printf("PERIOD(%s, %s)", initial_->ToCString(), next_->ToCString());
      break;
  }
}

ToCString()

const char * dart::InductionVar::ToCString

(

)

const

Definition at line 973 of file loops.cc.

                                          {
  char buffer[1024];
  BufferFormatter f(buffer, sizeof(buffer));
  PrintTo(&f);
  return Thread::Current()->zone()->MakeCopyOfString(buffer);
}

Friends And Related Symbol Documentation

InductionVarAnalysis

friend class InductionVarAnalysis

friend

Definition at line 182 of file loops.h.

Member Data Documentation

def_

Definition* dart::InductionVar::def_

Definition at line 190 of file loops.h.

initial_

InductionVar* dart::InductionVar::initial_

Definition at line 193 of file loops.h.

mult_

int64_t dart::InductionVar::mult_

Definition at line 189 of file loops.h.

next_

InductionVar* dart::InductionVar::next_

Definition at line 194 of file loops.h.

offset_

int64_t dart::InductionVar::offset_

Definition at line 188 of file loops.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/compiler/backend/loops.h
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/loops.cc