dart::Slot Class Reference

#include <slot.h>

Inheritance diagram for dart::Slot:

Public Types
enum class	Kind : uint8_t {   DECLARE_KIND , kTypeArguments , kTypeArgumentsIndex , kArrayElement ,   kRecordField , kCapturedVariable , kDartField }

Public Member Functions
Kind	kind () const
bool	IsDartField () const
bool	IsLocalVariable () const
bool	IsTypeArguments () const
bool	IsArgumentOfType () const
bool	IsArrayElement () const
bool	IsRecordField () const
bool	IsImmutableLengthSlot () const
const char *	Name () const
intptr_t	offset_in_bytes () const
Representation	representation () const
bool	is_immutable () const
bool	is_weak () const
bool	is_guarded_field () const
bool	is_compressed () const
bool	may_contain_inner_pointer () const
CompileType	type () const
const Field &	field () const
bool	Equals (const Slot &other) const
uword	Hash () const
bool	IsIdentical (const Slot &other) const
bool	IsContextSlot () const
bool	is_tagged () const
bool	has_untagged_instance () const
void	Write (FlowGraphSerializer *s) 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 const Slot &	GetLengthFieldForArrayCid (intptr_t array_cid)
static const Slot &	GetTypeArgumentsSlotFor (Thread *thread, const Class &cls)
static const Slot &	GetTypeArgumentsIndexSlot (Thread *thread, intptr_t index)
static const Slot &	GetArrayElementSlot (Thread *thread, intptr_t offset_in_bytes)
static const Slot &	GetRecordFieldSlot (Thread *thread, intptr_t offset_in_bytes)
static const Slot &	GetContextVariableSlotFor (Thread *thread, const LocalVariable &var)
static const Slot &	Get (const Field &field, const ParsedFunction *parsed_function)
static const Slot &	Read (FlowGraphDeserializer *d)

Friends
class	SlotCache

Detailed Description

Definition at line 431 of file slot.h.

Member Enumeration Documentation

Kind

enum class dart::Slot::Kind : uint8_t

strong

Enumerator
DECLARE_KIND
kTypeArguments
kTypeArgumentsIndex
kArrayElement
kRecordField
kCapturedVariable
kDartField

Definition at line 434 of file slot.h.

                  : uint8_t {
    // Native slots are identified by their kind - each native slot has its own.
#define DECLARE_KIND(ClassName, __, FieldName, ___, ____)                      \
  k##ClassName##_##FieldName,
    NATIVE_SLOTS_LIST(DECLARE_KIND)
#undef DECLARE_KIND
 
    // A slot used to store type arguments.
    kTypeArguments,
 
    // A slot at a specific [index] in a [UntaggedTypeArgument] vector.
    kTypeArgumentsIndex,
 
    // A slot corresponding to an array element at given offset.
    // Only used during allocation sinking and in MaterializeObjectInstr.
    kArrayElement,
 
    // A slot corresponding to a record field at the given offset.
    kRecordField,
 
    // A slot within a Context object that contains a value of a captured
    // local variable.
    kCapturedVariable,
 
    // A slot that corresponds to a Dart field (has corresponding Field object).
    kDartField,
  };

Member Function Documentation

Equals()

bool dart::Slot::Equals

(

const Slot &

other

)

const

Definition at line 483 of file slot.cc.

                                         {
  if (kind_ != other.kind_ || offset_in_bytes_ != other.offset_in_bytes_) {
    return false;
  }
 
  switch (kind_) {
    case Kind::kTypeArguments:
    case Kind::kTypeArgumentsIndex:
    case Kind::kArrayElement:
    case Kind::kRecordField:
      return true;
 
    case Kind::kCapturedVariable: {
      auto other_type = other.type();
      return (flags_ == other.flags_) &&
             (DataAs<const String>()->ptr() ==
              other.DataAs<const String>()->ptr()) &&
             type().IsEqualTo(&other_type);
    }
 
    case Kind::kDartField:
      return other.DataAs<const Field>()->Original() ==
             DataAs<const Field>()->Original();
 
    default:
      UNREACHABLE();
      return false;
  }
}

field()

const Field & dart::Slot::field ( ) const

inline

Definition at line 540 of file slot.h.

                             {
    ASSERT(IsDartField());
    ASSERT(data_ != nullptr);
    return *DataAs<const Field>();
  }

Get()

const Slot & dart::Slot::Get ( const Field &  field, const ParsedFunction *  parsed_function  )

static

Definition at line 351 of file slot.cc.

                                                             {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Representation rep = kTagged;
  intptr_t nullable_cid = kDynamicCid;
  bool is_nullable = true;
 
  if (field.has_pragma()) {
    const intptr_t cid = MethodRecognizer::ResultCidFromPragma(field);
    if (cid != kDynamicCid) {
      nullable_cid = cid;
      is_nullable = false;
    } else if (MethodRecognizer::HasNonNullableResultTypeFromPragma(field)) {
      is_nullable = false;
    }
  }
 
  AbstractType& field_type = AbstractType::ZoneHandle(zone, field.type());
  if (field_type.IsStrictlyNonNullable()) {
    is_nullable = false;
  }
 
  FieldGuardState field_guard_state(field);
 
  bool used_guarded_state = false;
  if (field_guard_state.guarded_cid() != kIllegalCid &&
      field_guard_state.guarded_cid() != kDynamicCid) {
    // Use guarded state if it is more precise then what we already have.
    if (nullable_cid == kDynamicCid) {
      nullable_cid = field_guard_state.guarded_cid();
      used_guarded_state = true;
    }
 
    if (is_nullable && !field_guard_state.is_nullable()) {
      is_nullable = false;
      used_guarded_state = true;
    }
  }
 
  const bool needs_load_guard = field.needs_load_guard();
  const bool is_unboxed = field.is_unboxed();
  ASSERT(!(needs_load_guard && is_unboxed));
 
  if (needs_load_guard) {
    // Should be kept in sync with LoadStaticFieldInstr::ComputeType.
    field_type = Type::DynamicType();
    nullable_cid = kDynamicCid;
    is_nullable = true;
    used_guarded_state = false;
  }
 
  if (is_unboxed) {
    // The decision to unbox is made based on static types (or TFA annotations).
    // It is therefore not part of the dynamically initialized & updated guarded
    // state.
    used_guarded_state = false;
    is_nullable = false;
    nullable_cid = field_guard_state.guarded_cid();
    switch (nullable_cid) {
      case kDoubleCid:
        rep = kUnboxedDouble;
        break;
      case kFloat32x4Cid:
        rep = kUnboxedFloat32x4;
        break;
      case kFloat64x2Cid:
        rep = kUnboxedFloat64x2;
        break;
      default:
        rep = kUnboxedInt64;
        break;
    }
  }
 
  const bool is_sentinel_visible =
      field.is_late() && field.is_final() && !field.has_initializer();
 
  CompileType type = (rep != kTagged)
                         ? CompileType::FromUnboxedRepresentation(rep)
                         : CompileType(is_nullable, is_sentinel_visible,
                                       nullable_cid, &field_type);
 
  Class& owner = Class::Handle(zone, field.Owner());
  const Slot& slot = GetCanonicalSlot(
      thread, Kind::kDartField,
      IsImmutableBit::encode((field.is_final() && !field.is_late()) ||
                             field.is_const()) |
          IsGuardedBit::encode(used_guarded_state) |
          IsCompressedBit::encode(
              compiler::target::Class::HasCompressedPointers(owner)) |
          IsNonTaggedBit::encode(is_unboxed),
      compiler::target::Field::OffsetOf(field), &field, type, rep,
      field_guard_state);
 
  // If properties of this slot were based on the guarded state make sure
  // to add the field to the list of guarded fields. Note that during background
  // compilation we might have two field clones that have incompatible guarded
  // state - however both of these clones would correspond to the same slot.
  // That is why we check the is_guarded_field() property of the slot rather
  // than look at the current guarded state of the field, because current
  // guarded state of the field might be set to kDynamicCid, while it was
  // set to something more concrete when the slot was created.
  // Note that we could have created this slot during an unsuccessful inlining
  // attempt where we built and discarded the graph, in this case guarded
  // fields associated with that graph are also discarded. However the slot
  // itself stays behind in the compilation global cache. Thus we must always
  // try to add it to the list of guarded fields of the current function.
  if (slot.is_guarded_field()) {
    if (thread->isolate_group()->use_field_guards()) {
      ASSERT(parsed_function != nullptr);
      parsed_function->AddToGuardedFields(&slot.field());
    } else {
      // In precompiled mode we use guarded_cid field for type information
      // inferred by TFA.
      ASSERT(CompilerState::Current().is_aot());
    }
  }
 
  return slot;
}

GetArrayElementSlot()

const Slot & dart::Slot::GetArrayElementSlot ( Thread *  thread, intptr_t  offset_in_bytes  )

static

Definition at line 316 of file slot.cc.

                                                                {
  return GetCanonicalSlot(
      thread, Kind::kArrayElement,
      IsCompressedBit::encode(Array::ContainsCompressedPointers()),
      offset_in_bytes, ":array_element", CompileType::Dynamic(), kTagged);
}

GetContextVariableSlotFor()

const Slot & dart::Slot::GetContextVariableSlotFor ( Thread *  thread, const LocalVariable &  var  )

static

Definition at line 292 of file slot.cc.

                                                                           {
  ASSERT(variable.is_captured());
  return GetCanonicalSlot(
      thread, Kind::kCapturedVariable,
      IsImmutableBit::encode(variable.is_final() && !variable.is_late()) |
          IsCompressedBit::encode(Context::ContainsCompressedPointers()),
      compiler::target::Context::variable_offset(variable.index().value()),
      &variable.name(), *(variable.inferred_type()), kTagged);
}

GetLengthFieldForArrayCid()

const Slot & dart::Slot::GetLengthFieldForArrayCid ( intptr_t  array_cid )

static

Definition at line 249 of file slot.cc.

                                                              {
  if (IsExternalTypedDataClassId(array_cid) || IsTypedDataClassId(array_cid) ||
      IsTypedDataViewClassId(array_cid) ||
      IsUnmodifiableTypedDataViewClassId(array_cid)) {
    return GetNativeSlot(Kind::kTypedDataBase_length);
  }
  switch (array_cid) {
    case kGrowableObjectArrayCid:
      return GetNativeSlot(Kind::kGrowableObjectArray_length);
 
    case kOneByteStringCid:
    case kTwoByteStringCid:
      return GetNativeSlot(Kind::kString_length);
 
    case kArrayCid:
    case kImmutableArrayCid:
      return GetNativeSlot(Kind::kArray_length);
 
    case kTypeArgumentsCid:
      return GetNativeSlot(Kind::kTypeArguments_length);
 
    default:
      UNREACHABLE();
      return GetNativeSlot(Kind::kArray_length);
  }
}

GetRecordFieldSlot()

const Slot & dart::Slot::GetRecordFieldSlot ( Thread *  thread, intptr_t  offset_in_bytes  )

static

Definition at line 324 of file slot.cc.

                                                                             {
  return GetCanonicalSlot(
      thread, Kind::kRecordField,
      IsCompressedBit::encode(Record::ContainsCompressedPointers()),
      offset_in_bytes, ":record_field", CompileType::Dynamic(), kTagged);
}

GetTypeArgumentsIndexSlot()

const Slot & dart::Slot::GetTypeArgumentsIndexSlot ( Thread *  thread, intptr_t  index  )

static

Definition at line 303 of file slot.cc.

                                                                          {
  const intptr_t offset =
      compiler::target::TypeArguments::type_at_offset(index);
  return GetCanonicalSlot(
      thread, Kind::kTypeArgumentsIndex,
      IsImmutableBit::encode(true) |
          IsCompressedBit::encode(TypeArguments::ContainsCompressedPointers()),
      offset, ":argument",
      CompileType(CompileType::kCannotBeNull, CompileType::kCannotBeSentinel,
                  kDynamicCid, nullptr),
      kTagged);
}

GetTypeArgumentsSlotFor()

const Slot & dart::Slot::GetTypeArgumentsSlotFor ( Thread *  thread, const Class &  cls  )

static

Definition at line 276 of file slot.cc.

                                                                          {
  if (cls.id() == kArrayCid || cls.id() == kImmutableArrayCid) {
    return Slot::Array_type_arguments();
  }
  const intptr_t offset =
      compiler::target::Class::TypeArgumentsFieldOffset(cls);
  ASSERT(offset != Class::kNoTypeArguments);
  return GetCanonicalSlot(
      thread, Kind::kTypeArguments,
      IsImmutableBit::encode(true) |
          IsCompressedBit::encode(
              compiler::target::Class::HasCompressedPointers(cls)),
      offset, ":type_arguments", CompileType::FromCid(kTypeArgumentsCid),
      kTagged);
}

has_untagged_instance()

bool dart::Slot::has_untagged_instance ( ) const

inline

Definition at line 556 of file slot.h.

                                     {
    return HasUntaggedInstanceBit::decode(flags_);
  }

Hash()

uword dart::Slot::Hash

(

)

const

Definition at line 513 of file slot.cc.

                       {
  uword result = (static_cast<int8_t>(kind_) * 63 + offset_in_bytes_) * 31;
  if (IsDartField()) {
    result += String::Handle(DataAs<const Field>()->name()).Hash();
  } else if (IsLocalVariable()) {
    result += DataAs<const String>()->Hash();
  }
  return result;
}

is_compressed()

bool dart::Slot::is_compressed ( ) const

inline

Definition at line 529 of file slot.h.

{ return IsCompressedBit::decode(flags_); }

is_guarded_field()

bool dart::Slot::is_guarded_field ( ) const

inline

Definition at line 527 of file slot.h.

{ return IsGuardedBit::decode(flags_); }

is_immutable()

bool dart::Slot::is_immutable ( ) const

inline

Definition at line 521 of file slot.h.

{ return IsImmutableBit::decode(flags_); }

is_tagged()

bool dart::Slot::is_tagged ( ) const

inline

Definition at line 555 of file slot.h.

{ return !IsNonTaggedBit::decode(flags_); }

is_weak()

bool dart::Slot::is_weak ( ) const

inline

Definition at line 523 of file slot.h.

{ return IsWeakBit::decode(flags_); }

IsArgumentOfType()

bool dart::Slot::IsArgumentOfType ( ) const

inline

Definition at line 506 of file slot.h.

{ return kind() == Kind::kTypeArgumentsIndex; }

IsArrayElement()

bool dart::Slot::IsArrayElement ( ) const

inline

Definition at line 507 of file slot.h.

{ return kind() == Kind::kArrayElement; }

IsContextSlot()

bool dart::Slot::IsContextSlot ( ) const

inline

Definition at line 551 of file slot.h.

                             {
    return kind() == Kind::kCapturedVariable || kind() == Kind::kContext_parent;
  }

IsDartField()

bool dart::Slot::IsDartField ( ) const

inline

Definition at line 503 of file slot.h.

{ return kind() == Kind::kDartField; }

IsIdentical()

bool dart::Slot::IsIdentical ( const Slot &  other ) const

inline

Definition at line 549 of file slot.h.

{ return this == &other; }

IsImmutableLengthSlot()

bool dart::Slot::IsImmutableLengthSlot

(

)

const

Definition at line 208 of file slot.cc.

                                       {
  switch (kind()) {
    case Slot::Kind::kArray_length:
    case Slot::Kind::kTypedDataBase_length:
    case Slot::Kind::kString_length:
    case Slot::Kind::kTypeArguments_length:
      return true;
    case Slot::Kind::kGrowableObjectArray_length:
      return false;
 
      // Not length loads.
    case Slot::Kind::kArrayElement:
    case Slot::Kind::kCapturedVariable:
    case Slot::Kind::kDartField:
    case Slot::Kind::kRecordField:
    case Slot::Kind::kTypeArguments:
    case Slot::Kind::kTypeArgumentsIndex:
#define NOT_TAGGED_INT_NATIVE_SLOT_CASE(Class, __, Field, ___, ____)           \
  case Slot::Kind::k##Class##_##Field:
      NOT_INT_NATIVE_SLOTS_LIST(NOT_TAGGED_INT_NATIVE_SLOT_CASE)
      UNBOXED_NATIVE_SLOTS_LIST(NOT_TAGGED_INT_NATIVE_SLOT_CASE)
#undef NONTAGGED_NATIVE_DART_SLOT_CASE
    case Slot::Kind::kLinkedHashBase_hash_mask:
    case Slot::Kind::kLinkedHashBase_used_data:
    case Slot::Kind::kLinkedHashBase_deleted_keys:
    case Slot::Kind::kArgumentsDescriptor_type_args_len:
    case Slot::Kind::kArgumentsDescriptor_positional_count:
    case Slot::Kind::kArgumentsDescriptor_count:
    case Slot::Kind::kArgumentsDescriptor_size:
    case Slot::Kind::kTypeArguments_hash:
    case Slot::Kind::kTypedDataView_offset_in_bytes:
    case Slot::Kind::kClosure_hash:
    case Slot::Kind::kRecord_shape:
    case Slot::Kind::kAbstractType_hash:
      return false;
  }
  UNREACHABLE();
  return false;
}

IsLocalVariable()

bool dart::Slot::IsLocalVariable ( ) const

inline

Definition at line 504 of file slot.h.

{ return kind() == Kind::kCapturedVariable; }

IsRecordField()

bool dart::Slot::IsRecordField ( ) const

inline

Definition at line 508 of file slot.h.

{ return kind() == Kind::kRecordField; }

IsTypeArguments()

bool dart::Slot::IsTypeArguments ( ) const

inline

Definition at line 505 of file slot.h.

{ return kind() == Kind::kTypeArguments; }

kind()

Kind dart::Slot::kind ( ) const

inline

Definition at line 502 of file slot.h.

{ return kind_; }

may_contain_inner_pointer()

bool dart::Slot::may_contain_inner_pointer ( ) const

inline

Definition at line 533 of file slot.h.

                                         {
    return MayContainInnerPointerBit::decode(flags_);
  }

Name()

const char * dart::Slot::Name

(

)

const

Definition at line 473 of file slot.cc.

                             {
  if (IsLocalVariable()) {
    return DataAs<const String>()->ToCString();
  } else if (IsDartField()) {
    return String::Handle(field().name()).ToCString();
  } else {
    return DataAs<const char>();
  }
}

offset_in_bytes()

intptr_t dart::Slot::offset_in_bytes ( ) const

inline

Definition at line 513 of file slot.h.

{ return offset_in_bytes_; }

Read()

const Slot & dart::Slot::Read ( FlowGraphDeserializer *  d )

static

Definition at line 2329 of file il_serializer.cc.

                                               {
  const Kind kind = static_cast<Kind>(d->Read<serializable_type_t<Kind>>());
  int8_t flags = 0;
  intptr_t offset = -1;
  const void* data = nullptr;
  CompileType type = CompileType::None();
  Representation representation = kTagged;
 
  switch (kind) {
    case Kind::kTypeArguments:
      flags = d->Read<int8_t>();
      offset = d->Read<intptr_t>();
      data = ":type_arguments";
      type = CompileType::FromCid(kTypeArgumentsCid);
      break;
    case Kind::kTypeArgumentsIndex:
      flags =
          IsImmutableBit::encode(true) |
          IsCompressedBit::encode(TypeArguments::ContainsCompressedPointers());
      offset = d->Read<intptr_t>();
      data = ":argument";
      type = CompileType(CompileType::kCannotBeNull,
                         CompileType::kCannotBeSentinel, kDynamicCid, nullptr);
      break;
    case Kind::kArrayElement:
      flags = IsCompressedBit::encode(Array::ContainsCompressedPointers());
      offset = d->Read<intptr_t>();
      data = ":array_element";
      type = CompileType::Dynamic();
      break;
    case Kind::kRecordField:
      flags = IsCompressedBit::encode(Record::ContainsCompressedPointers());
      offset = d->Read<intptr_t>();
      data = ":record_field";
      type = CompileType::Dynamic();
      break;
    case Kind::kCapturedVariable:
      flags = d->Read<int8_t>();
      offset = d->Read<intptr_t>();
      data = &d->Read<const String&>();
      type = CompileType(d);
      break;
    case Kind::kDartField: {
      const Field& field = d->Read<const Field&>();
      return Slot::Get(field, &d->parsed_function());
    }
    default:
      return Slot::GetNativeSlot(kind);
  }
 
  return GetCanonicalSlot(d->thread(), kind, flags, offset, data, type,
                          representation);
}

representation()

Representation dart::Slot::representation ( ) const

inline

Definition at line 519 of file slot.h.

{ return representation_; }

type()

CompileType dart::Slot::type ( ) const

inline

Definition at line 538 of file slot.h.

{ return type_; }

Write()

void dart::Slot::Write

(

FlowGraphSerializer *

s

)

const

Definition at line 2297 of file il_serializer.cc.

                                             {
  s->Write<serializable_type_t<Kind>>(
      static_cast<serializable_type_t<Kind>>(kind_));
 
  switch (kind_) {
    case Kind::kTypeArguments:
      s->Write<int8_t>(flags_);
      s->Write<intptr_t>(offset_in_bytes_);
      break;
    case Kind::kTypeArgumentsIndex:
      s->Write<intptr_t>(offset_in_bytes_);
      break;
    case Kind::kArrayElement:
      s->Write<intptr_t>(offset_in_bytes_);
      break;
    case Kind::kRecordField:
      s->Write<intptr_t>(offset_in_bytes_);
      break;
    case Kind::kCapturedVariable:
      s->Write<int8_t>(flags_);
      s->Write<intptr_t>(offset_in_bytes_);
      s->Write<const String&>(*DataAs<const String>());
      type_.Write(s);
      break;
    case Kind::kDartField:
      s->Write<const Field&>(field());
      break;
    default:
      break;
  }
}

Friends And Related Symbol Documentation

SlotCache

friend class SlotCache

friend

Definition at line 638 of file slot.h.

---

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

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