dart::LoadFieldInstr Class Reference

#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	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

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)

Additional Inherited Members
Public Types inherited from dart::TemplateDefinition< N, Throws >
using	BaseClass = typename NoCSE< Definition, PureDefinition >::Base
Protected Attributes inherited from dart::TemplateDefinition< N, Throws >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 8053 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 8055 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 8083 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

Definition at line 8162 of file il.h.

{ return slot_.is_immutable(); }

AttributesEqual()

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

virtual

Definition at line 1119 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

Definition at line 2859 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 8164 of file il.h.

{ return calls_initializer(); }

ComputeType()

CompileType dart::LoadFieldInstr::ComputeType ( ) const

virtual

Definition at line 1709 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 2855 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 8095 of file il.h.

{ return inputs_[0]; }

IsFixedLengthArrayCid()

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

static

Definition at line 2659 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 8139 of file il.h.

{ return slot().IsImmutableLengthSlot(); }

IsImmutableLoad()

bool dart::LoadFieldInstr::IsImmutableLoad ( ) const

inline

Definition at line 8129 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 2674 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 2698 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 8098 of file il.h.

                                                 {
    return loads_inner_pointer_;
  }

MayCreateUnsafeUntaggedPointer()

bool dart::LoadFieldInstr::MayCreateUnsafeUntaggedPointer ( ) const

virtual

Definition at line 2842 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 2826 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

Definition at line 919 of file il.cc.

                                                    {
  return slot().representation();
}

RequiredInputRepresentation()

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

inlinevirtual

Definition at line 8109 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 8101 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 8096 of file il.h.

{ return slot_; }

TryEvaluateLoad() [1/2]

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

static

Definition at line 2803 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 2727 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