dart::ObjectCopy< Base > Class Template Reference

Inheritance diagram for dart::ObjectCopy< Base >:

Public Types
using	Types = typename Base::Types

Public Member Functions
	ObjectCopy (Thread *thread, IdentityMap *map)
void	CopyPredefinedInstance (typename Types::Object from, typename Types::Object to, intptr_t cid)
void	CopyUserdefinedInstance (typename Types::Object from, typename Types::Object to, UnboxedFieldBitmap bitmap)
void	CopyUserdefinedInstanceWithoutUnboxedFields (typename Types::Object from, typename Types::Object to)
void	CopyClosure (typename Types::Closure from, typename Types::Closure to)
void	CopyContext (typename Types::Context from, typename Types::Context to)
void	CopyArray (typename Types::Array from, typename Types::Array to)
void	CopyGrowableObjectArray (typename Types::GrowableObjectArray from, typename Types::GrowableObjectArray to)
void	CopyRecord (typename Types::Record from, typename Types::Record to)
template<intptr_t one_for_set_two_for_map, typename T >
void	CopyLinkedHashBase (T from, T to, UntaggedLinkedHashBase *from_untagged, UntaggedLinkedHashBase *to_untagged)
void	CopyMap (typename Types::Map from, typename Types::Map to)
void	CopySet (typename Types::Set from, typename Types::Set to)
void	CopyDouble (typename Types::Double from, typename Types::Double to)
void	CopyFloat32x4 (typename Types::Float32x4 from, typename Types::Float32x4 to)
void	CopyFloat64x2 (typename Types::Float64x2 from, typename Types::Float64x2 to)
void	CopyTypedData (TypedDataPtr from, TypedDataPtr to)
void	CopyTypedData (const TypedData &from, const TypedData &to)
void	CopyTypedDataView (typename Types::TypedDataView from, typename Types::TypedDataView to)
void	CopyExternalTypedData (typename Types::ExternalTypedData from, typename Types::ExternalTypedData to)
void	CopyTransferableTypedData (typename Types::TransferableTypedData from, typename Types::TransferableTypedData to)
void	CopyWeakProperty (typename Types::WeakProperty from, typename Types::WeakProperty to)
void	CopyWeakReference (typename Types::WeakReference from, typename Types::WeakReference to)
UntaggedObject *	UntagObject (typename Types::Object obj)
Public Member Functions inherited from dart::Base
	Base (int arg)

Additional Inherited Members
Public Attributes inherited from dart::Base
int	base

Detailed Description

template<typename Base>
class dart::ObjectCopy< Base >

Definition at line 1693 of file object_graph_copy.cc.

Member Typedef Documentation

Types

template<typename Base >

using dart::ObjectCopy< Base >::Types = typename Base::Types

Definition at line 1695 of file object_graph_copy.cc.

Constructor & Destructor Documentation

ObjectCopy()

template<typename Base >

dart::ObjectCopy< Base >::ObjectCopy ( Thread *  thread, IdentityMap *  map  )

inline

Definition at line 1697 of file object_graph_copy.cc.

: Base(thread, map) {}

Member Function Documentation

CopyArray()

template<typename Base >

void dart::ObjectCopy< Base >::CopyArray ( typename Types::Array  from, typename Types::Array  to  )

inline

Definition at line 1810 of file object_graph_copy.cc.

                                                                   {
    const intptr_t length = Smi::Value(UntagArray(from)->length());
    Base::StoreCompressedArrayPointers(
        length, from, to, OFFSET_OF(UntaggedArray, type_arguments_),
        OFFSET_OF(UntaggedArray, type_arguments_));
    Base::StoreCompressedPointersNoBarrier(from, to,
                                           OFFSET_OF(UntaggedArray, length_),
                                           OFFSET_OF(UntaggedArray, length_));
    Base::ForwardCompressedArrayPointers(
        length, from, to, Array::data_offset(),
        Array::data_offset() + kCompressedWordSize * length);
  }

CopyClosure()

template<typename Base >

void dart::ObjectCopy< Base >::CopyClosure ( typename Types::Closure  from, typename Types::Closure  to  )

inline

Definition at line 1785 of file object_graph_copy.cc.

                                                                         {
    Base::StoreCompressedPointers(
        from, to, OFFSET_OF(UntaggedClosure, instantiator_type_arguments_),
        OFFSET_OF(UntaggedClosure, function_));
    Base::ForwardCompressedPointer(from, to,
                                   OFFSET_OF(UntaggedClosure, context_));
    Base::StoreCompressedPointersNoBarrier(from, to,
                                           OFFSET_OF(UntaggedClosure, hash_),
                                           OFFSET_OF(UntaggedClosure, hash_));
    ONLY_IN_PRECOMPILED(UntagClosure(to)->entry_point_ =
                            UntagClosure(from)->entry_point_);
  }

CopyContext()

template<typename Base >

void dart::ObjectCopy< Base >::CopyContext ( typename Types::Context  from, typename Types::Context  to  )

inline

Definition at line 1798 of file object_graph_copy.cc.

                                                                         {
    const intptr_t length = Context::NumVariables(Types::GetContextPtr(from));
 
    UntagContext(to)->num_variables_ = UntagContext(from)->num_variables_;
 
    Base::ForwardCompressedPointer(from, to,
                                   OFFSET_OF(UntaggedContext, parent_));
    Base::ForwardCompressedContextPointers(
        length, from, to, Context::variable_offset(0),
        Context::variable_offset(0) + Context::kBytesPerElement * length);
  }

CopyDouble()

template<typename Base >

void dart::ObjectCopy< Base >::CopyDouble ( typename Types::Double  from, typename Types::Double  to  )

inline

Definition at line 1925 of file object_graph_copy.cc.

                                                                      {
#if !defined(DART_PRECOMPILED_RUNTIME)
    auto raw_from = UntagDouble(from);
    auto raw_to = UntagDouble(to);
    raw_to->value_ = raw_from->value_;
#else
    // Will be shared and not copied.
    UNREACHABLE();
#endif
  }

CopyExternalTypedData()

template<typename Base >

void dart::ObjectCopy< Base >::CopyExternalTypedData ( typename Types::ExternalTypedData  from, typename Types::ExternalTypedData  to  )

inline

Definition at line 2029 of file object_graph_copy.cc.

                                                                 {
    // The external typed data is initialized on the forwarding pass (where
    // normally allocation but not initialization happens), so views on it
    // can be initialized immediately.
#if defined(DEBUG)
    auto raw_from = UntagExternalTypedData(from);
    auto raw_to = UntagExternalTypedData(to);
    ASSERT(raw_to->data_ != nullptr);
    ASSERT(raw_to->length_ == raw_from->length_);
#endif
  }

CopyFloat32x4()

template<typename Base >

void dart::ObjectCopy< Base >::CopyFloat32x4 ( typename Types::Float32x4  from, typename Types::Float32x4  to  )

inline

Definition at line 1936 of file object_graph_copy.cc.

                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
    auto raw_from = UntagFloat32x4(from);
    auto raw_to = UntagFloat32x4(to);
    raw_to->value_[0] = raw_from->value_[0];
    raw_to->value_[1] = raw_from->value_[1];
    raw_to->value_[2] = raw_from->value_[2];
    raw_to->value_[3] = raw_from->value_[3];
#else
    // Will be shared and not copied.
    UNREACHABLE();
#endif
  }

CopyFloat64x2()

template<typename Base >

void dart::ObjectCopy< Base >::CopyFloat64x2 ( typename Types::Float64x2  from, typename Types::Float64x2  to  )

inline

Definition at line 1951 of file object_graph_copy.cc.

                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
    auto raw_from = UntagFloat64x2(from);
    auto raw_to = UntagFloat64x2(to);
    raw_to->value_[0] = raw_from->value_[0];
    raw_to->value_[1] = raw_from->value_[1];
#else
    // Will be shared and not copied.
    UNREACHABLE();
#endif
  }

CopyGrowableObjectArray()

template<typename Base >

void dart::ObjectCopy< Base >::CopyGrowableObjectArray ( typename Types::GrowableObjectArray  from, typename Types::GrowableObjectArray  to  )

inline

Definition at line 1823 of file object_graph_copy.cc.

                                                                     {
    Base::StoreCompressedPointers(
        from, to, OFFSET_OF(UntaggedGrowableObjectArray, type_arguments_),
        OFFSET_OF(UntaggedGrowableObjectArray, type_arguments_));
    Base::StoreCompressedPointersNoBarrier(
        from, to, OFFSET_OF(UntaggedGrowableObjectArray, length_),
        OFFSET_OF(UntaggedGrowableObjectArray, length_));
    Base::ForwardCompressedPointer(
        from, to, OFFSET_OF(UntaggedGrowableObjectArray, data_));
  }

CopyLinkedHashBase()

template<typename Base >

template<intptr_t one_for_set_two_for_map, typename T >

void dart::ObjectCopy< Base >::CopyLinkedHashBase ( T  from, T  to, UntaggedLinkedHashBase *  from_untagged, UntaggedLinkedHashBase *  to_untagged  )

inline

Definition at line 1846 of file object_graph_copy.cc.

                                                               {
    // We have to find out whether the map needs re-hashing on the receiver side
    // due to keys being copied and the keys therefore possibly having different
    // hash codes (e.g. due to user-defined hashCode implementation or due to
    // new identity hash codes of the copied objects).
    bool needs_rehashing = false;
    ArrayPtr data = from_untagged->data_.Decompress(Base::heap_base_);
    if (data != Array::null()) {
      UntaggedArray* untagged_data = data.untag();
      const intptr_t length = Smi::Value(untagged_data->length_);
      auto key_value_pairs = untagged_data->data();
      for (intptr_t i = 0; i < length; i += one_for_set_two_for_map) {
        ObjectPtr key = key_value_pairs[i].Decompress(Base::heap_base_);
        const bool is_deleted_entry = key == data;
        if (key->IsHeapObject()) {
          if (!is_deleted_entry && MightNeedReHashing(key)) {
            needs_rehashing = true;
            break;
          }
        }
      }
    }
 
    Base::StoreCompressedPointers(
        from, to, OFFSET_OF(UntaggedLinkedHashBase, type_arguments_),
        OFFSET_OF(UntaggedLinkedHashBase, type_arguments_));
 
    // Compared with the snapshot-based (de)serializer we do preserve the same
    // backing store (i.e. used_data/deleted_keys/data) and therefore do not
    // magically shrink backing store based on usage.
    //
    // We do this to avoid making assumptions about the object graph and the
    // linked hash map (e.g. assuming there's no other references to the data,
    // assuming the linked hashmap is in a consistent state)
    if (needs_rehashing) {
      to_untagged->hash_mask_ = Smi::New(0);
      to_untagged->index_ = TypedData::RawCast(Object::null());
      to_untagged->deleted_keys_ = Smi::New(0);
    }
 
    // From this point on we shouldn't use the raw pointers, since GC might
    // happen when forwarding objects.
    from_untagged = nullptr;
    to_untagged = nullptr;
 
    if (!needs_rehashing) {
      Base::ForwardCompressedPointer(from, to,
                                     OFFSET_OF(UntaggedLinkedHashBase, index_));
      Base::StoreCompressedPointersNoBarrier(
          from, to, OFFSET_OF(UntaggedLinkedHashBase, hash_mask_),
          OFFSET_OF(UntaggedLinkedHashBase, hash_mask_));
      Base::StoreCompressedPointersNoBarrier(
          from, to, OFFSET_OF(UntaggedMap, deleted_keys_),
          OFFSET_OF(UntaggedMap, deleted_keys_));
    }
    Base::ForwardCompressedPointer(from, to,
                                   OFFSET_OF(UntaggedLinkedHashBase, data_));
    Base::StoreCompressedPointersNoBarrier(
        from, to, OFFSET_OF(UntaggedLinkedHashBase, used_data_),
        OFFSET_OF(UntaggedLinkedHashBase, used_data_));
 
    if (Base::exception_msg_ == nullptr && needs_rehashing) {
      Base::EnqueueObjectToRehash(to);
    }
  }

CopyMap()

template<typename Base >

void dart::ObjectCopy< Base >::CopyMap ( typename Types::Map  from, typename Types::Map  to  )

inline

Definition at line 1915 of file object_graph_copy.cc.

                                                             {
    CopyLinkedHashBase<2, typename Types::Map>(from, to, UntagMap(from),
                                               UntagMap(to));
  }

CopyPredefinedInstance()

template<typename Base >

void dart::ObjectCopy< Base >::CopyPredefinedInstance ( typename Types::Object  from, typename Types::Object  to, intptr_t  cid  )

inline

Definition at line 1699 of file object_graph_copy.cc.

                                            {
    if (IsImplicitFieldClassId(cid)) {
      CopyUserdefinedInstanceWithoutUnboxedFields(from, to);
      return;
    }
    switch (cid) {
#define COPY_TO(clazz)                                                         \
  case clazz::kClassId: {                                                      \
    typename Types::clazz casted_from = Types::Cast##clazz(from);              \
    typename Types::clazz casted_to = Types::Cast##clazz(to);                  \
    Copy##clazz(casted_from, casted_to);                                       \
    return;                                                                    \
  }
 
      CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP(COPY_TO)
      COPY_TO(Array)
      COPY_TO(GrowableObjectArray)
      COPY_TO(Map)
      COPY_TO(Set)
#undef COPY_TO
 
      case ImmutableArray::kClassId: {
        typename Types::Array casted_from = Types::CastArray(from);
        typename Types::Array casted_to = Types::CastArray(to);
        CopyArray(casted_from, casted_to);
        return;
      }
 
#define COPY_TO(clazz) case kTypedData##clazz##Cid:
 
        CLASS_LIST_TYPED_DATA(COPY_TO) {
          typename Types::TypedData casted_from = Types::CastTypedData(from);
          typename Types::TypedData casted_to = Types::CastTypedData(to);
          CopyTypedData(casted_from, casted_to);
          return;
        }
#undef COPY_TO
 
      case kByteDataViewCid:
      case kUnmodifiableByteDataViewCid:
#define COPY_TO(clazz)                                                         \
  case kTypedData##clazz##ViewCid:                                             \
  case kUnmodifiableTypedData##clazz##ViewCid:
        CLASS_LIST_TYPED_DATA(COPY_TO) {
          typename Types::TypedDataView casted_from =
              Types::CastTypedDataView(from);
          typename Types::TypedDataView casted_to =
              Types::CastTypedDataView(to);
          CopyTypedDataView(casted_from, casted_to);
          return;
        }
#undef COPY_TO
 
#define COPY_TO(clazz) case kExternalTypedData##clazz##Cid:
 
        CLASS_LIST_TYPED_DATA(COPY_TO) {
          typename Types::ExternalTypedData casted_from =
              Types::CastExternalTypedData(from);
          typename Types::ExternalTypedData casted_to =
              Types::CastExternalTypedData(to);
          CopyExternalTypedData(casted_from, casted_to);
          return;
        }
#undef COPY_TO
      default:
        break;
    }
 
    const Object& obj = Types::HandlifyObject(from);
    FATAL("Unexpected object: %s\n", obj.ToCString());
  }

CopyRecord()

template<typename Base >

void dart::ObjectCopy< Base >::CopyRecord ( typename Types::Record  from, typename Types::Record  to  )

inline

Definition at line 1835 of file object_graph_copy.cc.

                                                                      {
    const intptr_t num_fields = Record::NumFields(Types::GetRecordPtr(from));
    Base::StoreCompressedPointersNoBarrier(from, to,
                                           OFFSET_OF(UntaggedRecord, shape_),
                                           OFFSET_OF(UntaggedRecord, shape_));
    Base::ForwardCompressedPointers(
        from, to, Record::field_offset(0),
        Record::field_offset(0) + Record::kBytesPerElement * num_fields);
  }

CopySet()

template<typename Base >

void dart::ObjectCopy< Base >::CopySet ( typename Types::Set  from, typename Types::Set  to  )

inline

Definition at line 1920 of file object_graph_copy.cc.

                                                             {
    CopyLinkedHashBase<1, typename Types::Set>(from, to, UntagSet(from),
                                               UntagSet(to));
  }

CopyTransferableTypedData()

template<typename Base >

void dart::ObjectCopy< Base >::CopyTransferableTypedData ( typename Types::TransferableTypedData  from, typename Types::TransferableTypedData  to  )

inline

Definition at line 2042 of file object_graph_copy.cc.

                                                                         {
    // The [TransferableTypedData] is an empty object with an associated heap
    // peer object.
    // -> We'll validate that there's a peer and enqueue the transferable to be
    // transferred if the transitive copy is successful.
    auto fpeer = static_cast<TransferableTypedDataPeer*>(
        Base::heap_->GetPeer(Types::GetTransferableTypedDataPtr(from)));
    ASSERT(fpeer != nullptr);
    if (fpeer->data() == nullptr) {
      Base::exception_msg_ =
          "Illegal argument in isolate message"
          " : (TransferableTypedData has been transferred already)";
      Base::exception_unexpected_object_ =
          Types::GetTransferableTypedDataPtr(from);
      return;
    }
    Base::EnqueueTransferable(from, to);
  }

CopyTypedData() [1/2]

template<typename Base >

void dart::ObjectCopy< Base >::CopyTypedData ( const TypedData &  from, const TypedData &  to  )

inline

Definition at line 1975 of file object_graph_copy.cc.

                                                                 {
    auto raw_from = from.ptr().untag();
    auto raw_to = to.ptr().untag();
    const intptr_t cid = Types::GetTypedDataPtr(from)->GetClassId();
    ASSERT(raw_to->length_ == raw_from->length_);
    raw_to->RecomputeDataField();
    const intptr_t length =
        TypedData::ElementSizeInBytes(cid) * Smi::Value(raw_from->length_);
    CopyTypedDataBaseWithSafepointChecks(Base::thread_, from, to, length);
  }

CopyTypedData() [2/2]

template<typename Base >

void dart::ObjectCopy< Base >::CopyTypedData ( TypedDataPtr  from, TypedDataPtr  to  )

inline

Definition at line 1964 of file object_graph_copy.cc.

                                                         {
    auto raw_from = from.untag();
    auto raw_to = to.untag();
    const intptr_t cid = Types::GetTypedDataPtr(from)->GetClassId();
    raw_to->length_ = raw_from->length_;
    raw_to->RecomputeDataField();
    const intptr_t length =
        TypedData::ElementSizeInBytes(cid) * Smi::Value(raw_from->length_);
    memmove(raw_to->data_, raw_from->data_, length);
  }

CopyTypedDataView()

template<typename Base >

void dart::ObjectCopy< Base >::CopyTypedDataView ( typename Types::TypedDataView  from, typename Types::TypedDataView  to  )

inline

Definition at line 1986 of file object_graph_copy.cc.

                                                         {
    // This will forward & initialize the typed data.
    Base::ForwardCompressedPointer(
        from, to, OFFSET_OF(UntaggedTypedDataView, typed_data_));
 
    auto raw_from = UntagTypedDataView(from);
    auto raw_to = UntagTypedDataView(to);
    raw_to->length_ = raw_from->length_;
    raw_to->offset_in_bytes_ = raw_from->offset_in_bytes_;
    raw_to->data_ = nullptr;
 
    auto forwarded_backing_store =
        raw_to->typed_data_.Decompress(Base::heap_base_);
    if (forwarded_backing_store == Marker() ||
        forwarded_backing_store == Object::null()) {
      // Ensure the backing store is never "sentinel" - the scavenger doesn't
      // like it.
      Base::StoreCompressedPointerNoBarrier(
          Types::GetTypedDataViewPtr(to),
          OFFSET_OF(UntaggedTypedDataView, typed_data_), Object::null());
      raw_to->length_ = Smi::New(0);
      raw_to->offset_in_bytes_ = Smi::New(0);
      ASSERT(Base::exception_msg_ != nullptr);
      return;
    }
 
    const bool is_external =
        raw_from->data_ != raw_from->DataFieldForInternalTypedData();
    if (is_external) {
      // The raw_to is fully initialized at this point (see handling of external
      // typed data in [ForwardCompressedPointer])
      raw_to->RecomputeDataField();
    } else {
      // The raw_to isn't initialized yet, but it's address is valid, so we can
      // compute the data field it would use.
      raw_to->RecomputeDataFieldForInternalTypedData();
    }
    const bool is_external2 =
        raw_to->data_ != raw_to->DataFieldForInternalTypedData();
    ASSERT(is_external == is_external2);
  }

CopyUserdefinedInstance()

template<typename Base >

void dart::ObjectCopy< Base >::CopyUserdefinedInstance ( typename Types::Object  from, typename Types::Object  to, UnboxedFieldBitmap  bitmap  )

inline

Definition at line 1773 of file object_graph_copy.cc.

                                                          {
    const intptr_t instance_size = UntagObject(from)->HeapSize();
    Base::ForwardCompressedPointers(from, to, kWordSize, instance_size, bitmap);
  }

CopyUserdefinedInstanceWithoutUnboxedFields()

template<typename Base >

void dart::ObjectCopy< Base >::CopyUserdefinedInstanceWithoutUnboxedFields ( typename Types::Object  from, typename Types::Object  to  )

inline

Definition at line 1780 of file object_graph_copy.cc.

                                                                            {
    const intptr_t instance_size = UntagObject(from)->HeapSize();
    Base::ForwardCompressedPointers(from, to, kWordSize, instance_size);
  }

CopyWeakProperty()

template<typename Base >

void dart::ObjectCopy< Base >::CopyWeakProperty ( typename Types::WeakProperty  from, typename Types::WeakProperty  to  )

inline

Definition at line 2062 of file object_graph_copy.cc.

                                                       {
    // We store `null`s as keys/values and let the main algorithm know that
    // we should check reachability of the key again after the fixpoint (if it
    // became reachable, forward the key/value).
    Base::StoreCompressedPointerNoBarrier(Types::GetWeakPropertyPtr(to),
                                          OFFSET_OF(UntaggedWeakProperty, key_),
                                          Object::null());
    Base::StoreCompressedPointerNoBarrier(
        Types::GetWeakPropertyPtr(to), OFFSET_OF(UntaggedWeakProperty, value_),
        Object::null());
    // To satisfy some ASSERT()s in GC we'll use Object:null() explicitly here.
    Base::StoreCompressedPointerNoBarrier(
        Types::GetWeakPropertyPtr(to),
        OFFSET_OF(UntaggedWeakProperty, next_seen_by_gc_), Object::null());
    Base::EnqueueWeakProperty(from);
  }

CopyWeakReference()

template<typename Base >

void dart::ObjectCopy< Base >::CopyWeakReference ( typename Types::WeakReference  from, typename Types::WeakReference  to  )

inline

Definition at line 2080 of file object_graph_copy.cc.

                                                         {
    // We store `null` as target and let the main algorithm know that
    // we should check reachability of the target again after the fixpoint (if
    // it became reachable, forward the target).
    Base::StoreCompressedPointerNoBarrier(
        Types::GetWeakReferencePtr(to),
        OFFSET_OF(UntaggedWeakReference, target_), Object::null());
    // Type argument should always be copied.
    Base::ForwardCompressedPointer(
        from, to, OFFSET_OF(UntaggedWeakReference, type_arguments_));
    // To satisfy some ASSERT()s in GC we'll use Object:null() explicitly here.
    Base::StoreCompressedPointerNoBarrier(
        Types::GetWeakReferencePtr(to),
        OFFSET_OF(UntaggedWeakReference, next_seen_by_gc_), Object::null());
    Base::EnqueueWeakReference(from);
  }

UntagObject()

template<typename Base >

UntaggedObject * dart::ObjectCopy< Base >::UntagObject ( typename Types::Object  obj )

inline

Definition at line 2109 of file object_graph_copy.cc.

                                                        {
    return Types::GetObjectPtr(obj).Decompress(Base::heap_base_).untag();
  }

---

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

• third_party/dart-lang/sdk/runtime/vm/object_graph_copy.cc