Lines Matching defs:object
29 #include "src/objects/maybe-object.h"
55 static SlotAccessorForHeapObject ForSlotIndex(Handle<HeapObject> object,
57 return SlotAccessorForHeapObject(object, index * kTaggedSize);
59 static SlotAccessorForHeapObject ForSlotOffset(Handle<HeapObject> object,
61 return SlotAccessorForHeapObject(object, offset);
65 Handle<HeapObject> object() const { return object_; }
108 SlotAccessorForHeapObject(Handle<HeapObject> object, int offset)
109 : object_(object), offset_(offset) {}
121 Handle<HeapObject> object() const { UNREACHABLE(); }
164 Handle<HeapObject> object() const { UNREACHABLE(); }
254 // kEmptyBackingStoreRefSentinel) in a deserialized object requiring fix-up.
384 // The following check will trigger if a function or object template
508 // Mutate the given object handle so that the backreference entry is
532 // Hence we only remember each individual code object when deserializing
655 // Filling an object's fields can cause GCs and heap walks, so this object has
657 // can happen. For this to be the case, the object is carefully deserialized
659 // * The space for the object is allocated.
660 // * The map is set on the object so that the GC knows what type the object
662 // * The rest of the object is filled with a fixed Smi value
668 // * The fields of the object are deserialized in order, under the
670 // required for object iteration (e.g. length fields) are deserialized
672 // - We ensure this is the case by DCHECKing on object allocation that the
673 // previously allocated object has a valid size (see `Allocate`).
786 HeapObject object = *objects_->at(current_object_++);
787 rinfo->set_target_address(Code::cast(object).raw_instruction_start());
792 HeapObject object = *objects_->at(current_object_++);
793 // Embedded object reference must be a strong one.
794 rinfo->set_target_object(isolate()->heap(), object);
907 void Deserializer<IsolateT>::ReadData(Handle<HeapObject> object,
914 data, SlotAccessorForHeapObject::ForSlotIndex(object, current));
937 // Deserialize a new object and write a pointer to it to the current
938 // object.
941 // Save the reference type before recursing down into reading the object.
947 // Find a recently deserialized object using its offset from the current
948 // allocation point and write a pointer to it to the current object.
954 // Reference an object in the read-only heap. This should be used when an
955 // object is read-only, but is not a root.
969 // Find an object in the roots array and write a pointer to it to the
970 // current object.
980 // Find an object in the startup object cache and write a pointer to it to
981 // the current object.
991 // Find an object in the read-only object cache and write a pointer to it
992 // to the current object.
1002 // Find an object in the shared heap object cache and write a pointer to it
1003 // to the current object.
1016 // object.
1023 // object.
1042 // Find an object in the attached references and write a pointer to it to
1043 // the current object.
1059 unresolved_forward_refs_.emplace_back(slot_accessor.object(),
1066 // Pending forward refs can only be resolved after the heap object's map
1070 Handle<HeapObject> obj = slot_accessor.object();
1073 SlotAccessorForHeapObject::ForSlotOffset(forward_ref.object,
1083 forward_ref.object = Handle<HeapObject>();
1105 // Deserialize raw code directly into the body of the code object.
1110 // CodeBody can only occur right after the heap object header.
1118 Code code = Code::cast(*slot_accessor.object());
1127 ReadData(slot_accessor.object(), HeapObject::kHeaderSize / kTaggedSize,
1147 Code code = Code::cast(*slot_accessor.object());
1158 // Advance to the end of the code object.
1224 // We shouldn't have weak refs without a current object.
1225 DCHECK_NE(slot_accessor.object()->address(), kNullAddress);
1315 // Make sure that the previous object is initialized sufficiently to