dart::Value Class Reference

#include <il.h>

Inheritance diagram for dart::Value:

Classes
class	Iterator

Public Member Functions
	Value (Definition *definition)
Definition *	definition () const
void	set_definition (Definition *definition)
Value *	previous_use () const
void	set_previous_use (Value *previous)
Value *	next_use () const
void	set_next_use (Value *next)
bool	IsSingleUse () const
Instruction *	instruction () const
void	set_instruction (Instruction *instruction)
intptr_t	use_index () const
void	set_use_index (intptr_t index)
void	RemoveFromUseList ()
void	BindTo (Definition *definition)
void	BindToEnvironment (Definition *definition)
Value *	Copy (Zone *zone)
Value *	CopyWithType (Zone *zone)
Value *	CopyWithType ()
CompileType *	Type ()
CompileType *	reaching_type () const
void	SetReachingType (CompileType *type)
void	RefineReachingType (CompileType *type)
const char *	ToCString () const
bool	IsSmiValue ()
bool	BindsToConstant () const
bool	BindsToConstant (ConstantInstr **constant_defn) const
bool	BindsToConstantNull () const
const Object &	BoundConstant () const
bool	BindsToSmiConstant () const
intptr_t	BoundSmiConstant () const
bool	NeedsWriteBarrier ()
bool	Equals (const Value &other) const
bool	CanBe (const Object &value)
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 void	AddToList (Value *value, Value **list)

Friends
class	FlowGraphPrinter

Detailed Description

Definition at line 75 of file il.h.

Constructor & Destructor Documentation

Value()

dart::Value::Value ( Definition *  definition )

inlineexplicit

Definition at line 95 of file il.h.

      : definition_(definition),
        previous_use_(nullptr),
        next_use_(nullptr),
        instruction_(nullptr),
        use_index_(-1),
        reaching_type_(nullptr) {}

Member Function Documentation

AddToList()

void Value::AddToList ( Value *  value, Value **  list  )

static

Definition at line 1446 of file il.cc.

                                                {
  ASSERT(value->next_use() == nullptr);
  ASSERT(value->previous_use() == nullptr);
  Value* next = *list;
  ASSERT(value != next);
  *list = value;
  value->set_next_use(next);
  value->set_previous_use(nullptr);
  if (next != nullptr) next->set_previous_use(value);
}

BindsToConstant() [1/2]

bool Value::BindsToConstant

(

)

const

Definition at line 1183 of file il.cc.

                                  {
  return definition()->OriginalDefinition()->IsConstant();
}

BindsToConstant() [2/2]

bool Value::BindsToConstant

(

ConstantInstr **

constant_defn

)

const

Definition at line 1187 of file il.cc.

                                                               {
  if (auto constant = definition()->OriginalDefinition()->AsConstant()) {
    *constant_defn = constant;
    return true;
  }
  return false;
}

BindsToConstantNull()

bool Value::BindsToConstantNull

(

)

const

Definition at line 1196 of file il.cc.

                                      {
  ConstantInstr* constant = definition()->OriginalDefinition()->AsConstant();
  return (constant != nullptr) && constant->value().IsNull();
}

BindsToSmiConstant()

bool Value::BindsToSmiConstant

(

)

const

Definition at line 1208 of file il.cc.

                                     {
  return BindsToConstant() && BoundConstant().IsSmi();
}

BindTo()

void Value::BindTo ( Definition *  definition )

inline

Definition at line 2718 of file il.h.

                                         {
  RemoveFromUseList();
  set_definition(def);
  def->AddInputUse(this);
}

BindToEnvironment()

void Value::BindToEnvironment ( Definition *  definition )

inline

Definition at line 2724 of file il.h.

                                                    {
  RemoveFromUseList();
  set_definition(def);
  def->AddEnvUse(this);
}

BoundConstant()

const Object & Value::BoundConstant

(

)

const

Definition at line 1201 of file il.cc.

                                         {
  ASSERT(BindsToConstant());
  ConstantInstr* constant = definition()->OriginalDefinition()->AsConstant();
  ASSERT(constant != nullptr);
  return constant->value();
}

BoundSmiConstant()

intptr_t Value::BoundSmiConstant

(

)

const

Definition at line 1212 of file il.cc.

                                       {
  ASSERT(BindsToSmiConstant());
  return Smi::Cast(BoundConstant()).Value();
}

CanBe()

bool Value::CanBe ( const Object &  value )

inline

Definition at line 11887 of file il.h.

                                            {
  ConstantInstr* constant = definition()->AsConstant();
  return (constant == nullptr) || constant->value().ptr() == value.ptr();
}

Copy()

Value * dart::Value::Copy ( Zone *  zone )

inline

Definition at line 134 of file il.h.

{ return new (zone) Value(definition_); }

CopyWithType() [1/2]

Value * dart::Value::CopyWithType ( )

inline

Definition at line 143 of file il.h.

{ return CopyWithType(Thread::Current()->zone()); }

CopyWithType() [2/2]

Value * dart::Value::CopyWithType ( Zone *  zone )

inline

Definition at line 138 of file il.h.

                                  {
    Value* copy = new (zone) Value(definition_);
    copy->reaching_type_ = reaching_type_;
    return copy;
  }

definition()

Definition * dart::Value::definition ( ) const

inline

Definition at line 103 of file il.h.

{ return definition_; }

Equals()

bool Value::Equals

(

const Value &

other

)

const

Definition at line 633 of file il.cc.

                                           {
  return definition() == other.definition();
}

instruction()

Instruction * dart::Value::instruction ( ) const

inline

Definition at line 121 of file il.h.

{ return instruction_; }

IsSingleUse()

bool dart::Value::IsSingleUse ( ) const

inline

Definition at line 117 of file il.h.

                           {
    return (next_use_ == nullptr) && (previous_use_ == nullptr);
  }

IsSmiValue()

bool dart::Value::IsSmiValue ( )

inline

Definition at line 157 of file il.h.

{ return Type()->ToCid() == kSmiCid; }

NeedsWriteBarrier()

bool Value::NeedsWriteBarrier

(

)

Definition at line 1390 of file il.cc.

                              {
  Value* value = this;
  do {
    if (value->Type()->IsNull() ||
        (value->Type()->ToNullableCid() == kSmiCid) ||
        (value->Type()->ToNullableCid() == kBoolCid)) {
      return false;
    }
 
    // Strictly speaking, the incremental barrier can only be skipped for
    // immediate objects (Smis) or permanent objects (vm-isolate heap or
    // image pages). For AOT, we choose to skip the barrier for any constant on
    // the assumptions it will remain reachable through the object pool and it
    // is on a page created by snapshot loading that is marked so as to never be
    // evacuated.
    if (value->BindsToConstant()) {
      if (FLAG_precompiled_mode) {
        return false;
      } else {
        const Object& constant = value->BoundConstant();
        return constant.ptr()->IsHeapObject() && !constant.InVMIsolateHeap();
      }
    }
 
    // Follow the chain of redefinitions as redefined value could have a more
    // accurate type (for example, AssertAssignable of Smi to a generic T).
    value = value->definition()->RedefinedValue();
  } while (value != nullptr);
 
  return true;
}

next_use()

Value * dart::Value::next_use ( ) const

inline

Definition at line 114 of file il.h.

{ return next_use_; }

previous_use()

Value * dart::Value::previous_use ( ) const

inline

Definition at line 111 of file il.h.

{ return previous_use_; }

reaching_type()

CompileType * dart::Value::reaching_type ( ) const

inline

Definition at line 147 of file il.h.

{ return reaching_type_; }

RefineReachingType()

void Value::RefineReachingType

(

CompileType *

type

)

Definition at line 1088 of file type_propagator.cc.

                                                {
  SetReachingType(CompileType::ComputeRefinedType(reaching_type_, type));
}

RemoveFromUseList()

void Value::RemoveFromUseList

(

)

Definition at line 1457 of file il.cc.

                              {
  Definition* def = definition();
  Value* next = next_use();
  if (this == def->input_use_list()) {
    def->set_input_use_list(next);
    if (next != nullptr) next->set_previous_use(nullptr);
  } else if (this == def->env_use_list()) {
    def->set_env_use_list(next);
    if (next != nullptr) next->set_previous_use(nullptr);
  } else if (Value* prev = previous_use()) {
    prev->set_next_use(next);
    if (next != nullptr) next->set_previous_use(prev);
  }
 
  set_previous_use(nullptr);
  set_next_use(nullptr);
}

set_definition()

void dart::Value::set_definition ( Definition *  definition )

inline

Definition at line 104 of file il.h.

                                              {
    definition_ = definition;
    // Clone the reaching type if there was one and the owner no longer matches
    // this value's definition.
    SetReachingType(reaching_type_);
  }

set_instruction()

void dart::Value::set_instruction ( Instruction *  instruction )

inline

Definition at line 122 of file il.h.

{ instruction_ = instruction; }

set_next_use()

void dart::Value::set_next_use ( Value *  next )

inline

Definition at line 115 of file il.h.

{ next_use_ = next; }

set_previous_use()

void dart::Value::set_previous_use ( Value *  previous )

inline

Definition at line 112 of file il.h.

{ previous_use_ = previous; }

set_use_index()

void dart::Value::set_use_index ( intptr_t  index )

inline

Definition at line 125 of file il.h.

{ use_index_ = index; }

SetReachingType()

void Value::SetReachingType

(

CompileType *

type

)

Definition at line 1074 of file type_propagator.cc.

                                             {
  // If [type] is owned but not by the definition which flows into this use
  // then we need to disconnect the type from original owner by cloning it.
  // This is done to prevent situations when [type] is updated by its owner
  // but [owner] is no longer connected to this use through def-use chain
  // and as a result type propagator does not recompute type of the current
  // instruction.
  if (type != nullptr && type->owner() != nullptr &&
      type->owner() != definition()) {
    type = new CompileType(*type);
  }
  reaching_type_ = type;
}

ToCString()

const char * dart::Value::ToCString

(

)

const

Type()

CompileType * Value::Type

(

)

Definition at line 1067 of file type_propagator.cc.

                         {
  if (reaching_type_ == nullptr) {
    reaching_type_ = definition()->Type();
  }
  return reaching_type_;
}

use_index()

intptr_t dart::Value::use_index ( ) const

inline

Definition at line 124 of file il.h.

{ return use_index_; }

Friends And Related Function Documentation

FlowGraphPrinter

friend class FlowGraphPrinter

friend

Definition at line 187 of file il.h.

---

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

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