#include <il.h>

Inheritance diagram for dart::LoadFieldInstr:

Public Member Functions
	LoadFieldInstr (Value *instance, const Slot &slot, InnerPointerAccess loads_inner_pointer, const InstructionSource &source, bool calls_initializer=false, intptr_t deopt_id=DeoptId::kNone)

	LoadFieldInstr (Value *instance, const Slot &slot, const InstructionSource &source, bool calls_initializer=false, intptr_t deopt_id=DeoptId::kNone)

Value *	instance () const

const Slot &	slot () const

InnerPointerAccess	loads_inner_pointer () const

void	set_loads_inner_pointer (InnerPointerAccess value)

virtual Representation	RequiredInputRepresentation (intptr_t idx) const

virtual Representation	representation () const

virtual CompileType	ComputeType () const

virtual void	InferRange (RangeAnalysis analysis, Range range)

bool	MayCreateUntaggedAlias () const

virtual bool	MayCreateUnsafeUntaggedPointer () const

bool	IsImmutableLoad () const

bool	IsImmutableLengthLoad () const

bool	Evaluate (const Object &instance_value, Object *result)

virtual Definition *	Canonicalize (FlowGraph *flow_graph)

virtual bool	AllowsCSE () const

virtual bool	CanTriggerGC () const

virtual bool	AttributesEqual (const Instruction &other) const

DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadFieldInstr, TemplateLoadField, FIELD_LIST) private	DISALLOW_COPY_AND_ASSIGN (LoadFieldInstr)

Public Member Functions inherited from dart::TemplateLoadField< 1 >
	TemplateLoadField (const InstructionSource &source, bool calls_initializer=false, intptr_t deopt_id=DeoptId::kNone, const Field *field=nullptr)

virtual TokenPosition	token_pos () const

bool	calls_initializer () const

void	set_calls_initializer (bool value)

bool	throw_exception_on_initialization () const

virtual bool	UseSharedSlowPathStub (bool is_optimizing) const

virtual intptr_t	DeoptimizationTarget () const

virtual bool	ComputeCanDeoptimize () const

virtual bool	ComputeCanDeoptimizeAfterCall () const

virtual intptr_t	NumberOfInputsConsumedBeforeCall () const

virtual bool	HasUnknownSideEffects () const

virtual bool	CanCallDart () const

virtual bool	CanTriggerGC () const

virtual bool	MayThrow () const

Public Member Functions inherited from dart::TemplateDefinition< N, Throws >
	TemplateDefinition (intptr_t deopt_id=DeoptId::kNone)

	TemplateDefinition (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

virtual intptr_t	InputCount () const

virtual Value *	InputAt (intptr_t i) const

virtual bool	MayThrow () const

Public Member Functions inherited from dart::Instruction
	Instruction (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)

	Instruction (intptr_t deopt_id=DeoptId::kNone)

virtual	~Instruction ()

virtual Tag	tag () const =0

virtual intptr_t	statistics_tag () const

intptr_t	deopt_id () const

virtual TokenPosition	token_pos () const

InstructionSource	source () const

virtual intptr_t	InputCount () const =0

virtual Value *	InputAt (intptr_t i) const =0

void	SetInputAt (intptr_t i, Value *value)

InputsIterable	inputs ()

void	UnuseAllInputs ()

virtual intptr_t	ArgumentCount () const

Value *	ArgumentValueAt (intptr_t index) const

Definition *	ArgumentAt (intptr_t index) const

virtual void	SetMoveArguments (MoveArgumentsArray *move_arguments)

virtual MoveArgumentsArray *	GetMoveArguments () const

virtual void	ReplaceInputsWithMoveArguments (MoveArgumentsArray *move_arguments)

bool	HasMoveArguments () const

void	RepairArgumentUsesInEnvironment () const

virtual bool	ComputeCanDeoptimize () const =0

virtual bool	ComputeCanDeoptimizeAfterCall () const

bool	CanDeoptimize () const

virtual void	Accept (InstructionVisitor *visitor)=0

Instruction *	previous () const

void	set_previous (Instruction *instr)

Instruction *	next () const

void	set_next (Instruction *instr)

void	LinkTo (Instruction *next)

Instruction *	RemoveFromGraph (bool return_previous=true)

virtual intptr_t	SuccessorCount () const

virtual BlockEntryInstr *	SuccessorAt (intptr_t index) const

SuccessorsIterable	successors () const

void	Goto (JoinEntryInstr *entry)

virtual const char *	DebugName () const =0

void	CheckField (const Field &field) const

const char *	ToCString () const

	DECLARE_INSTRUCTION_TYPE_CHECK (BlockEntryWithInitialDefs, BlockEntryWithInitialDefs) template< typename T > T *Cast()

template<typename T >
const T *	Cast () const

LocationSummary *	locs ()

bool	HasLocs () const

virtual LocationSummary *	MakeLocationSummary (Zone *zone, bool is_optimizing) const =0

void	InitializeLocationSummary (Zone *zone, bool optimizing)

virtual void	EmitNativeCode (FlowGraphCompiler *compiler)

Environment *	env () const

void	SetEnvironment (Environment *deopt_env)

void	RemoveEnvironment ()

void	ReplaceInEnvironment (Definition current, Definition replacement)

virtual intptr_t	NumberOfInputsConsumedBeforeCall () const

intptr_t	GetPassSpecificId (CompilerPass::Id pass) const

void	SetPassSpecificId (CompilerPass::Id pass, intptr_t id)

bool	HasPassSpecificId (CompilerPass::Id pass) const

bool	HasUnmatchedInputRepresentations () const

virtual Representation	RequiredInputRepresentation (intptr_t idx) const

SpeculativeMode	SpeculativeModeOfInputs () const

virtual SpeculativeMode	SpeculativeModeOfInput (intptr_t index) const

virtual Representation	representation () const

bool	WasEliminated () const

virtual intptr_t	DeoptimizationTarget () const

virtual Instruction *	Canonicalize (FlowGraph *flow_graph)

void	InsertBefore (Instruction *next)

void	InsertAfter (Instruction *prev)

Instruction *	AppendInstruction (Instruction *tail)

virtual bool	AllowsCSE () const

virtual bool	HasUnknownSideEffects () const =0

virtual bool	CanCallDart () const

virtual bool	CanTriggerGC () const

virtual BlockEntryInstr *	GetBlock ()

virtual intptr_t	inlining_id () const

virtual void	set_inlining_id (intptr_t value)

virtual bool	has_inlining_id () const

virtual uword	Hash () const

bool	Equals (const Instruction &other) const

virtual bool	AttributesEqual (const Instruction &other) const

void	InheritDeoptTarget (Zone zone, Instruction other)

bool	NeedsEnvironment () const

virtual bool	CanBecomeDeoptimizationTarget () const

void	InheritDeoptTargetAfter (FlowGraph flow_graph, Definition call, Definition *result)

virtual bool	MayThrow () const =0

virtual bool	MayHaveVisibleEffect () const

virtual bool	CanEliminate (const BlockEntryInstr *block) const

bool	CanEliminate ()

bool	IsDominatedBy (Instruction *dom)

void	ClearEnv ()

void	Unsupported (FlowGraphCompiler *compiler)

virtual bool	UseSharedSlowPathStub (bool is_optimizing) const

Location::Kind	RegisterKindForResult () 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	TryEvaluateLoad (const Object &instance, const Field &field, Object *result)

static bool	TryEvaluateLoad (const Object &instance, const Slot &field, Object *result)

static bool	IsFixedLengthArrayCid (intptr_t cid)

static bool	IsTypedDataViewFactory (const Function &function)

static bool	IsUnmodifiableTypedDataViewFactory (const Function &function)

Static Public Member Functions inherited from dart::Instruction
static const ICData *	GetICData (const ZoneGrowableArray< const ICData * > &ic_data_array, intptr_t deopt_id, bool is_static_call)

static LocationSummary *	MakeCallSummary (Zone zone, const Instruction instr, LocationSummary *locs=nullptr)

static bool	SlowPathSharingSupported (bool is_optimizing)

Additional Inherited Members
Public Types inherited from dart::TemplateDefinition< N, Throws >
using	BaseClass = typename NoCSE< Definition, PureDefinition >::Base

Public Types inherited from dart::Instruction
enum	Tag { FOR_EACH_INSTRUCTION =(DECLARE_TAG) kNumInstructions }

enum	SpeculativeMode { kGuardInputs , kNotSpeculative }

using	InputsIterable = InstructionIndexedPropertyIterable< InputsTrait >

using	SuccessorsIterable = InstructionIndexedPropertyIterable< SuccessorsTrait >

Static Public Attributes inherited from dart::Instruction
static const intptr_t	kInstructionAttrs [kNumInstructions]

Protected Member Functions inherited from dart::Instruction
intptr_t	GetDeoptId () const

virtual void	CopyDeoptIdFrom (const Instruction &instr)

void	WriteExtraWithoutInputs (FlowGraphSerializer *s)

void	ReadExtraWithoutInputs (FlowGraphDeserializer *d)

Protected Attributes inherited from dart::TemplateDefinition< N, Throws >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 8101 of file il.h.

Constructor & Destructor Documentation

◆ LoadFieldInstr() [1/2]

dart::LoadFieldInstr::LoadFieldInstr	(	Value *	instance,
		const Slot &	slot,
		InnerPointerAccess	loads_inner_pointer,
		const InstructionSource &	source,
		bool	calls_initializer = `false`,
		intptr_t	deopt_id = `DeoptId::kNone`
	)

inline

Definition at line 8103 of file il.h.

      : TemplateLoadField(source,
                          calls_initializer,
                          deopt_id,
                          slot.IsDartField() ? &slot.field() : nullptr),
        slot_(slot),
        loads_inner_pointer_(loads_inner_pointer) {
    switch (loads_inner_pointer) {
      case InnerPointerAccess::kNotUntagged:
        ASSERT(slot.representation() != kUntagged);
        break;
      case InnerPointerAccess::kMayBeInnerPointer:
        ASSERT(slot.representation() == kUntagged);
        ASSERT(slot.may_contain_inner_pointer());
        break;
      case InnerPointerAccess::kCannotBeInnerPointer:
        ASSERT(slot.representation() == kUntagged);
        break;
    }
    SetInputAt(0, instance);
  }

◆ LoadFieldInstr() [2/2]

dart::LoadFieldInstr::LoadFieldInstr	(	Value *	instance,
		const Slot &	slot,
		const InstructionSource &	source,
		bool	calls_initializer = `false`,
		intptr_t	deopt_id = `DeoptId::kNone`
	)

inline

Definition at line 8131 of file il.h.

      : LoadFieldInstr(instance,
                       slot,
                       InnerPointerAccess::kNotUntagged,
                       source,
                       calls_initializer,
                       deopt_id) {}

Member Function Documentation

◆ AllowsCSE()

virtual bool dart::LoadFieldInstr::AllowsCSE ( ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 8210 of file il.h.

8210{ return slot_.is_immutable(); }

◆ AttributesEqual()

bool dart::LoadFieldInstr::AttributesEqual ( const Instruction & other ) const

virtual

Reimplemented from dart::Instruction.

Definition at line 1121 of file il.cc.

                                                                   {
  auto const other_load = other.AsLoadField();
  ASSERT(other_load != nullptr);
  return &this->slot_ == &other_load->slot_;
}

◆ Canonicalize()

Definition * dart::LoadFieldInstr::Canonicalize ( FlowGraph * flow_graph )

virtual

Reimplemented from dart::Instruction.

Definition at line 2868 of file il.cc.

                                                              {
  if (!HasUses() && !calls_initializer()) return nullptr;
 
  Definition* orig_instance = instance()->definition()->OriginalDefinition();
  if (IsImmutableLengthLoad()) {
    ASSERT(!calls_initializer());
    if (StaticCallInstr* call = orig_instance->AsStaticCall()) {
      // For fixed length arrays if the array is the result of a known
      // constructor call we can replace the length load with the length
      // argument passed to the constructor.
      if (call->is_known_list_constructor() &&
          IsFixedLengthArrayCid(call->Type()->ToCid())) {
        return call->ArgumentAt(1);
      } else if (call->function().recognized_kind() ==
                 MethodRecognizer::kByteDataFactory) {
        // Similarly, we check for the ByteData constructor and forward its
        // explicit length argument appropriately.
        return call->ArgumentAt(1);
      } else if (IsTypedDataViewFactory(call->function())) {
        // Typed data view factories all take three arguments (after
        // the implicit type arguments parameter):
        //
        // 1) _TypedList buffer -- the underlying data for the view
        // 2) int offsetInBytes -- the offset into the buffer to start viewing
        // 3) int length        -- the number of elements in the view
        //
        // Here, we forward the third.
        return call->ArgumentAt(3);
      }
    } else if (LoadFieldInstr* load_array = orig_instance->AsLoadField()) {
      // For arrays with guarded lengths, replace the length load
      // with a constant.
      const Slot& slot = load_array->slot();
      if (slot.IsDartField()) {
        if (slot.field().guarded_list_length() >= 0) {
          return flow_graph->GetConstant(
              Smi::Handle(Smi::New(slot.field().guarded_list_length())));
        }
      }
    }
  }
 
  switch (slot().kind()) {
    case Slot::Kind::kArray_length:
      if (CreateArrayInstr* create_array = orig_instance->AsCreateArray()) {
        return create_array->num_elements()->definition();
      }
      break;
    case Slot::Kind::kTypedDataBase_length:
      if (AllocateTypedDataInstr* alloc_typed_data =
              orig_instance->AsAllocateTypedData()) {
        return alloc_typed_data->num_elements()->definition();
      }
      break;
    case Slot::Kind::kTypedDataView_typed_data:
      // This case cover the first explicit argument to typed data view
      // factories, the data (buffer).
      ASSERT(!calls_initializer());
      if (StaticCallInstr* call = orig_instance->AsStaticCall()) {
        if (IsTypedDataViewFactory(call->function()) ||
            IsUnmodifiableTypedDataViewFactory(call->function())) {
          return call->ArgumentAt(1);
        }
      }
      break;
    case Slot::Kind::kTypedDataView_offset_in_bytes:
      // This case cover the second explicit argument to typed data view
      // factories, the offset into the buffer.
      ASSERT(!calls_initializer());
      if (StaticCallInstr* call = orig_instance->AsStaticCall()) {
        if (IsTypedDataViewFactory(call->function())) {
          return call->ArgumentAt(2);
        } else if (call->function().recognized_kind() ==
                   MethodRecognizer::kByteDataFactory) {
          // A _ByteDataView returned from the ByteData constructor always
          // has an offset of 0.
          return flow_graph->GetConstant(Object::smi_zero());
        }
      }
      break;
    case Slot::Kind::kRecord_shape:
      ASSERT(!calls_initializer());
      if (auto* alloc_rec = orig_instance->AsAllocateRecord()) {
        return flow_graph->GetConstant(Smi::Handle(alloc_rec->shape().AsSmi()));
      } else if (auto* alloc_rec = orig_instance->AsAllocateSmallRecord()) {
        return flow_graph->GetConstant(Smi::Handle(alloc_rec->shape().AsSmi()));
      } else {
        const AbstractType* type = instance()->Type()->ToAbstractType();
        if (type->IsRecordType()) {
          return flow_graph->GetConstant(
              Smi::Handle(RecordType::Cast(*type).shape().AsSmi()));
        }
      }
      break;
    case Slot::Kind::kTypeArguments:
      ASSERT(!calls_initializer());
      if (StaticCallInstr* call = orig_instance->AsStaticCall()) {
        if (call->is_known_list_constructor()) {
          return call->ArgumentAt(0);
        } else if (IsTypedDataViewFactory(call->function()) ||
                   IsUnmodifiableTypedDataViewFactory(call->function())) {
          return flow_graph->constant_null();
        }
        switch (call->function().recognized_kind()) {
          case MethodRecognizer::kByteDataFactory:
          case MethodRecognizer::kLinkedHashBase_getData:
          case MethodRecognizer::kImmutableLinkedHashBase_getData:
            return flow_graph->constant_null();
          default:
            break;
        }
      } else if (CreateArrayInstr* create_array =
                     orig_instance->AsCreateArray()) {
        return create_array->type_arguments()->definition();
      } else if (LoadFieldInstr* load_array = orig_instance->AsLoadField()) {
        const Slot& slot = load_array->slot();
        switch (slot.kind()) {
          case Slot::Kind::kDartField: {
            // For trivially exact fields we know that type arguments match
            // static type arguments exactly.
            const Field& field = slot.field();
            if (field.static_type_exactness_state().IsTriviallyExact()) {
              return flow_graph->GetConstant(TypeArguments::Handle(
                  Type::Cast(AbstractType::Handle(field.type()))
                      .GetInstanceTypeArguments(flow_graph->thread())));
            }
            break;
          }
 
          case Slot::Kind::kLinkedHashBase_data:
            return flow_graph->constant_null();
 
          default:
            break;
        }
      }
      break;
    case Slot::Kind::kPointerBase_data:
      ASSERT(!calls_initializer());
      if (loads_inner_pointer() == InnerPointerAccess::kMayBeInnerPointer) {
        const intptr_t cid = instance()->Type()->ToNullableCid();
        // Pointers and ExternalTypedData objects never contain inner pointers.
        if (cid == kPointerCid || IsExternalTypedDataClassId(cid)) {
          set_loads_inner_pointer(InnerPointerAccess::kCannotBeInnerPointer);
        }
      }
      break;
    default:
      break;
  }
 
  // Try folding away loads from constant objects.
  if (instance()->BindsToConstant()) {
    Object& result = Object::Handle();
    if (Evaluate(instance()->BoundConstant(), &result)) {
      if (result.IsSmi() || result.IsOld()) {
        return flow_graph->GetConstant(result);
      }
    }
  }
 
  if (instance()->definition()->IsAllocateObject() && IsImmutableLoad()) {
    StoreFieldInstr* initializing_store = nullptr;
    for (auto use : instance()->definition()->input_uses()) {
      if (auto store = use->instruction()->AsStoreField()) {
        if ((use->use_index() == StoreFieldInstr::kInstancePos) &&
            store->slot().IsIdentical(slot())) {
          if (initializing_store == nullptr) {
            initializing_store = store;
          } else {
            initializing_store = nullptr;
            break;
          }
        }
      }
    }
 
    // If we find an initializing store then it *must* by construction
    // dominate the load.
    if (initializing_store != nullptr &&
        initializing_store->is_initialization()) {
      ASSERT(IsDominatedBy(initializing_store));
      return initializing_store->value()->definition();
    }
  }
 
  return this;
}

◆ CanTriggerGC()

virtual bool dart::LoadFieldInstr::CanTriggerGC ( ) const

inlinevirtual

Reimplemented from dart::TemplateLoadField< 1 >.

Definition at line 8212 of file il.h.

8212{ return calls_initializer(); }

◆ ComputeType()

CompileType dart::LoadFieldInstr::ComputeType ( ) const

virtual

Definition at line 1701 of file type_propagator.cc.

                                              {
  if (slot().IsRecordField()) {
    const intptr_t index = compiler::target::Record::field_index_at_offset(
        slot().offset_in_bytes());
    if (auto* alloc = instance()->definition()->AsAllocateSmallRecord()) {
      if (index < alloc->num_fields()) {
        return *(alloc->InputAt(index)->Type());
      }
    }
    const AbstractType* instance_type = instance()->Type()->ToAbstractType();
    if (instance_type->IsRecordType()) {
      const auto& record_type = RecordType::Cast(*instance_type);
      if (index < record_type.NumFields()) {
        const auto& field_type =
            AbstractType::ZoneHandle(record_type.FieldTypeAt(index));
        return CompileType::FromAbstractType(field_type,
                                             CompileType::kCanBeNull,
                                             CompileType::kCannotBeSentinel);
      }
    }
  }
  CompileType type = slot().type();
  if (calls_initializer()) {
    type = type.CopyNonSentinel();
  }
  TraceStrongModeType(this, &type);
  return type;
}

◆ DISALLOW_COPY_AND_ASSIGN()

DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadFieldInstr, TemplateLoadField, FIELD_LIST) private dart::LoadFieldInstr::DISALLOW_COPY_AND_ASSIGN ( LoadFieldInstr )

◆ Evaluate()

bool dart::LoadFieldInstr::Evaluate	(	const Object &	instance_value,
		Object *	result
	)

Definition at line 2864 of file il.cc.

                                                                    {
  return TryEvaluateLoad(instance, slot(), result);
}

◆ InferRange()

void dart::LoadFieldInstr::InferRange	(	RangeAnalysis *	analysis,
		Range *	range
	)

virtual

Definition at line 2828 of file range_analysis.cc.

                                                                     {
  switch (slot().kind()) {
    case Slot::Kind::kArray_length:
    case Slot::Kind::kGrowableObjectArray_length:
      *range = Range(
          RangeBoundary::FromConstant(0),
          RangeBoundary::FromConstant(compiler::target::Array::kMaxElements));
      break;
 
    case Slot::Kind::kTypedDataBase_length:
    case Slot::Kind::kTypedDataView_offset_in_bytes:
      *range = Range(RangeBoundary::FromConstant(0), RangeBoundary::MaxSmi());
      break;
 
    case Slot::Kind::kAbstractType_hash:
    case Slot::Kind::kTypeArguments_hash:
      *range = Range(RangeBoundary::MinSmi(), RangeBoundary::MaxSmi());
      break;
 
    case Slot::Kind::kTypeArguments_length:
      *range = Range(RangeBoundary::FromConstant(0),
                     RangeBoundary::FromConstant(
                         compiler::target::TypeArguments::kMaxElements));
      break;
 
    case Slot::Kind::kRecord_shape:
      *range = Range(RangeBoundary::FromConstant(0), RangeBoundary::MaxSmi());
      break;
 
    case Slot::Kind::kString_length:
      *range = Range(
          RangeBoundary::FromConstant(0),
          RangeBoundary::FromConstant(compiler::target::String::kMaxElements));
      break;
 
    case Slot::Kind::kDartField:
    case Slot::Kind::kCapturedVariable:
    case Slot::Kind::kRecordField:
      // Use default value.
      Definition::InferRange(analysis, range);
      break;
 
    case Slot::Kind::kTypeArguments:
    case Slot::Kind::kTypeArgumentsIndex:
#define NATIVE_SLOT_CASE(ClassName, __, FieldName, ___, ____)                  \
  case Slot::Kind::k##ClassName##_##FieldName:
      NOT_INT_NATIVE_SLOTS_LIST(NATIVE_SLOT_CASE)
#undef NATIVE_SLOT_CASE
      // Not an integer valued field.
      UNREACHABLE();
      break;
 
    case Slot::Kind::kArrayElement:
      // Should not be used in LoadField instructions.
      UNREACHABLE();
      break;
 
#define UNBOXED_NATIVE_SLOT_CASE(Class, __, Field, ___, ____)                  \
  case Slot::Kind::k##Class##_##Field:
      UNBOXED_NATIVE_SLOTS_LIST(UNBOXED_NATIVE_SLOT_CASE)
#undef UNBOXED_NATIVE_SLOT_CASE
      *range = Range::Full(slot().representation());
      break;
 
    case Slot::Kind::kClosure_hash:
    case Slot::Kind::kLinkedHashBase_hash_mask:
    case Slot::Kind::kLinkedHashBase_used_data:
    case Slot::Kind::kLinkedHashBase_deleted_keys:
      *range = Range(RangeBoundary::FromConstant(0), RangeBoundary::MaxSmi());
      break;
 
    case Slot::Kind::kArgumentsDescriptor_type_args_len:
    case Slot::Kind::kArgumentsDescriptor_positional_count:
    case Slot::Kind::kArgumentsDescriptor_count:
    case Slot::Kind::kArgumentsDescriptor_size:
      *range = Range(RangeBoundary::FromConstant(0), RangeBoundary::MaxSmi());
      break;
  }
}

◆ instance()

Value * dart::LoadFieldInstr::instance ( ) const

inline

Definition at line 8143 of file il.h.

8143{ return inputs_[0]; }

dart::TemplateDefinition< N, Throws >::inputs_

EmbeddedArray< Value *, N > inputs_

Definition: il.h:2762

◆ IsFixedLengthArrayCid()

bool dart::LoadFieldInstr::IsFixedLengthArrayCid ( intptr_t cid )

static

Definition at line 2668 of file il.cc.

                                                       {
  if (IsTypedDataBaseClassId(cid)) {
    return true;
  }
 
  switch (cid) {
    case kArrayCid:
    case kImmutableArrayCid:
    case kTypeArgumentsCid:
      return true;
    default:
      return false;
  }
}

◆ IsImmutableLengthLoad()

bool dart::LoadFieldInstr::IsImmutableLengthLoad ( ) const

inline

Definition at line 8187 of file il.h.

8187{ return slot().IsImmutableLengthSlot(); }

dart::Slot::IsImmutableLengthSlot

bool IsImmutableLengthSlot() const

Definition: slot.cc:208

◆ IsImmutableLoad()

bool dart::LoadFieldInstr::IsImmutableLoad ( ) const

inline

Definition at line 8177 of file il.h.

                               {
    // The data() field in PointerBase is marked mutable, but is not actually
    // mutable if it doesn't contain an inner pointer (e.g., for external
    // typed data and Pointer objects).
    if (slot().IsIdentical(Slot::PointerBase_data())) {
      return loads_inner_pointer() != InnerPointerAccess::kMayBeInnerPointer;
    }
    return slot().is_immutable();
  }

◆ IsTypedDataViewFactory()

bool dart::LoadFieldInstr::IsTypedDataViewFactory ( const Function & function )

static

Definition at line 2683 of file il.cc.

                                                                    {
  auto kind = function.recognized_kind();
  switch (kind) {
    case MethodRecognizer::kTypedData_ByteDataView_factory:
    case MethodRecognizer::kTypedData_Int8ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint8ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint8ClampedArrayView_factory:
    case MethodRecognizer::kTypedData_Int16ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint16ArrayView_factory:
    case MethodRecognizer::kTypedData_Int32ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint32ArrayView_factory:
    case MethodRecognizer::kTypedData_Int64ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint64ArrayView_factory:
    case MethodRecognizer::kTypedData_Float32ArrayView_factory:
    case MethodRecognizer::kTypedData_Float64ArrayView_factory:
    case MethodRecognizer::kTypedData_Float32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_Int32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_Float64x2ArrayView_factory:
      return true;
    default:
      return false;
  }
}

◆ IsUnmodifiableTypedDataViewFactory()

bool dart::LoadFieldInstr::IsUnmodifiableTypedDataViewFactory ( const Function & function )

static

Definition at line 2707 of file il.cc.

                              {
  auto kind = function.recognized_kind();
  switch (kind) {
    case MethodRecognizer::kTypedData_UnmodifiableByteDataView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt8ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint8ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint8ClampedArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt16ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint16ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat64x2ArrayView_factory:
      return true;
    default:
      return false;
  }
}

◆ loads_inner_pointer()

InnerPointerAccess dart::LoadFieldInstr::loads_inner_pointer ( ) const

inline

Definition at line 8146 of file il.h.

                                                 {
    return loads_inner_pointer_;
  }

◆ MayCreateUnsafeUntaggedPointer()

bool dart::LoadFieldInstr::MayCreateUnsafeUntaggedPointer ( ) const

virtual

Definition at line 2851 of file il.cc.

                                                          {
  if (loads_inner_pointer() != InnerPointerAccess::kMayBeInnerPointer) {
    // The load is guaranteed to never retrieve a GC-moveable address.
    return false;
  }
  if (slot().IsIdentical(Slot::PointerBase_data())) {
    // If we know statically that the instance is an external array, then
    // the load retrieves a pointer to external memory.
    return !IsExternalPayloadClassId(instance()->Type()->ToNullableCid());
  }
  return true;
}

◆ MayCreateUntaggedAlias()

bool dart::LoadFieldInstr::MayCreateUntaggedAlias ( ) const

Definition at line 2835 of file il.cc.

                                                  {
  if (!MayCreateUnsafeUntaggedPointer()) {
    // If the load is guaranteed to never retrieve a GC-moveable address,
    // then the returned address can't alias the (GC-moveable) instance.
    return false;
  }
  if (slot().IsIdentical(Slot::PointerBase_data())) {
    // If we know statically that the instance is a typed data view, then the
    // data field doesn't alias the instance (but some other typed data object).
    const intptr_t cid = instance()->Type()->ToNullableCid();
    if (IsUnmodifiableTypedDataViewClassId(cid)) return false;
    if (IsTypedDataViewClassId(cid)) return false;
  }
  return true;
}

◆ representation()

Representation dart::LoadFieldInstr::representation ( ) const

virtual

Reimplemented from dart::Instruction.

Definition at line 921 of file il.cc.

                                                    {
  return slot().representation();
}

◆ RequiredInputRepresentation()

virtual Representation dart::LoadFieldInstr::RequiredInputRepresentation ( intptr_t idx ) const

inlinevirtual

Reimplemented from dart::Instruction.

Definition at line 8157 of file il.h.

                                                                         {
    ASSERT_EQUAL(idx, 0);
    return slot_.has_untagged_instance() ? kUntagged : kTagged;
  }

◆ set_loads_inner_pointer()

void dart::LoadFieldInstr::set_loads_inner_pointer ( InnerPointerAccess value )

inline

Definition at line 8149 of file il.h.

                                                         {
    // We should never change this for a non-untagged field.
    ASSERT(loads_inner_pointer_ != InnerPointerAccess::kNotUntagged);
    // We only convert from may to cannot, never the other direction.
    ASSERT(value == InnerPointerAccess::kCannotBeInnerPointer);
    loads_inner_pointer_ = value;
  }

◆ slot()

const Slot & dart::LoadFieldInstr::slot ( ) const

inline

Definition at line 8144 of file il.h.

8144{ return slot_; }

◆ TryEvaluateLoad() [1/2]

bool dart::LoadFieldInstr::TryEvaluateLoad	(	const Object &	instance,
		const Field &	field,
		Object *	result
	)

static

Definition at line 2812 of file il.cc.

                                                     {
  if (!field.is_final() || !instance.IsInstance()) {
    return false;
  }
 
  // Check that instance really has the field which we
  // are trying to load from.
  Class& cls = Class::Handle(instance.clazz());
  while (cls.ptr() != Class::null() && cls.ptr() != field.Owner()) {
    cls = cls.SuperClass();
  }
  if (cls.ptr() != field.Owner()) {
    // Failed to find the field in class or its superclasses.
    return false;
  }
 
  // Object has the field: execute the load.
  *result = Instance::Cast(instance).GetField(field);
  return true;
}

◆ TryEvaluateLoad() [2/2]

bool dart::LoadFieldInstr::TryEvaluateLoad	(	const Object &	instance,
		const Slot &	field,
		Object *	result
	)

static

Definition at line 2736 of file il.cc.

                                                     {
  switch (field.kind()) {
    case Slot::Kind::kDartField:
      return TryEvaluateLoad(instance, field.field(), result);
 
    case Slot::Kind::kArgumentsDescriptor_type_args_len:
      if (instance.IsArray() && Array::Cast(instance).IsImmutable()) {
        ArgumentsDescriptor desc(Array::Cast(instance));
        *result = Smi::New(desc.TypeArgsLen());
        return true;
      }
      return false;
 
    case Slot::Kind::kArgumentsDescriptor_count:
      if (instance.IsArray() && Array::Cast(instance).IsImmutable()) {
        ArgumentsDescriptor desc(Array::Cast(instance));
        *result = Smi::New(desc.Count());
        return true;
      }
      return false;
 
    case Slot::Kind::kArgumentsDescriptor_positional_count:
      if (instance.IsArray() && Array::Cast(instance).IsImmutable()) {
        ArgumentsDescriptor desc(Array::Cast(instance));
        *result = Smi::New(desc.PositionalCount());
        return true;
      }
      return false;
 
    case Slot::Kind::kArgumentsDescriptor_size:
      // If a constant arguments descriptor appears, then either it is from
      // a invocation dispatcher (which always has tagged arguments and so
      // [host]Size() ==  [target]Size() == Count()) or the constant should
      // have the correct Size() in terms of the target architecture if any
      // spill slots are involved.
      if (instance.IsArray() && Array::Cast(instance).IsImmutable()) {
        ArgumentsDescriptor desc(Array::Cast(instance));
        *result = Smi::New(desc.Size());
        return true;
      }
      return false;
 
    case Slot::Kind::kTypeArguments_length:
      if (instance.IsTypeArguments()) {
        *result = Smi::New(TypeArguments::Cast(instance).Length());
        return true;
      }
      return false;
 
    case Slot::Kind::kRecord_shape:
      if (instance.IsRecord()) {
        *result = Record::Cast(instance).shape().AsSmi();
        return true;
      }
      return false;
 
    case Slot::Kind::kRecordField:
      if (instance.IsRecord()) {
        const intptr_t index = compiler::target::Record::field_index_at_offset(
            field.offset_in_bytes());
        const Record& record = Record::Cast(instance);
        if (index < record.num_fields()) {
          *result = record.FieldAt(index);
        }
        return true;
      }
      return false;
 
    default:
      break;
  }
  return false;
}

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/range_analysis.cc
third_party/dart-lang/sdk/runtime/vm/compiler/backend/type_propagator.cc

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LoadFieldInstr() [1/2]

◆ LoadFieldInstr() [2/2]

Member Function Documentation

◆ AllowsCSE()

◆ AttributesEqual()

◆ Canonicalize()

◆ CanTriggerGC()

◆ ComputeType()

◆ DISALLOW_COPY_AND_ASSIGN()

◆ Evaluate()

◆ InferRange()

◆ instance()

◆ IsFixedLengthArrayCid()

◆ IsImmutableLengthLoad()

◆ IsImmutableLoad()

◆ IsTypedDataViewFactory()

◆ IsUnmodifiableTypedDataViewFactory()

◆ loads_inner_pointer()

◆ MayCreateUnsafeUntaggedPointer()

◆ MayCreateUntaggedAlias()

◆ representation()

◆ RequiredInputRepresentation()

◆ set_loads_inner_pointer()

◆ slot()

◆ TryEvaluateLoad() [1/2]

◆ TryEvaluateLoad() [2/2]