Lines Matching defs:object
218 // This is an optimization to speed up the check for an object in the LO
219 // space by exclusion because we know that all object pointers passed in
290 Object* type_obj;
306 Object* space_obj;
322 Object* prop_obj;
373 // Object level iteration.
438 // Object level iteration.
481 // object we're looking at. We only generate specialized
573 Handle<Object> error) {
630 Handle<Object> error) = 0;
660 Handle<Object> error) {
671 // Fill the array with the lol object details.
728 Handle<Object> error;
747 Handle<Object> error) {
861 // Fill the summary with the lol object details.
891 Handle<Object> error;
961 // Adds an object to the lol.
964 // If the object is already accounted for in the prev list which we inherit
987 // to the same object (which gets culled later). Hence, we only care about
993 // Looks for the specified object in the lol, and returns its element if found.
1000 // Iterate through the chain of lol's to look for the object.
1022 // Iterate through the chain of lol's to look for the object.
1034 // NOTE: we sort the lol in increasing order. So, if an object has been
1038 // first occurence of a matching object and nullify that instance. This
1049 // Nullify the object.
1147 if (result->IsFailure()) return Object::cast(*result);
1281 if (elements_arr->IsFailure()) return Object::cast(*elements_arr);
1284 Handle<Object> error;
1290 if (!success) return Object::cast(*error);
1296 if (body->IsFailure()) return Object::cast(*body);
1326 if (elements->IsFailure()) return Object::cast(*elements);
1392 // desc: "<object type name>",
1410 if (summary_arr->IsFailure()) return Object::cast(*summary_arr);
1416 if (detail->IsFailure()) return Object::cast(*detail);
1448 if (summary_obj->IsFailure()) return Object::cast(*summary_obj);
1451 // Create the body object.
1453 if (body->IsFailure()) return Object::cast(*body);
1455 // Fill out the body object.
1523 if (list->IsFailure()) return Object::cast(*list);
1547 if (detail->IsFailure()) return Object::cast(*detail);
1575 if (result->IsFailure()) return Object::cast(*result);
1615 // Gets the object for the specified obj id.
1616 Object* LiveObjectList::GetObj(int obj_id) {
1619 return Object::cast(element->obj_);
1626 int LiveObjectList::GetObjId(Object* obj) {
1627 // Make a heap object pointer from the address.
1638 Object* LiveObjectList::GetObjId(Handle<String> address) {
1644 Object* obj = reinterpret_cast<Object*>(value);
1656 void VisitPointer(Object** p) { CheckPointer(p); }
1658 void VisitPointers(Object** start, Object** end) {
1660 for (Object** p = start; !found() && p < end; p++) CheckPointer(p);
1667 inline void CheckPointer(Object** p) {
1668 Object* object = *p;
1669 if (HeapObject::cast(object) == target_) {
1673 // a root that would have kept the target object alive.
1702 Handle<Object> error) {
1756 Handle<Object> error) {
1817 // Iterate the live object lists.
1832 // Check if the JS object has a reference to the object looked for.
1837 Object* V = obj;
1839 Object* prototype = V->GetPrototype();
1844 obj = NULL; // Don't add this object.
1887 // Check for circular reference only. This can happen when the object is only
1889 // object is not really alive and would have been garbage collected if not
1909 // Get the target object.
1932 Object* body_obj;
1953 Object* LiveObjectList::PrintObj(int obj_id) {
1954 Object* obj = GetObj(obj_id);
2004 Object* search_target,
2018 PrintF(out_, "==== Path to object ====\n");
2022 Object* prev = NULL;
2024 Object* obj = object_stack_[i];
2026 // Skip this object if it is basically the internals of the
2027 // previous object (which would have dumped its details already).
2034 // properties of the last object already.
2039 // elements of the last object already.
2047 // Print the object index.
2050 object ID:
2073 Object* LiveObjectList::GetPathPrivate(HeapObject* obj1, HeapObject* obj2) {
2097 // Check for ObjectGroups that references this object.
2106 List<Object**>& objects = group->objects_;
2108 Object* object = *objects[j];
2109 HeapObject* hobj = HeapObject::cast(object);
2118 "obj %p is a member of object group %p {\n",
2122 Object* object = *objects[j];
2123 if (!object->IsHeapObject()) continue;
2125 HeapObject* hobj = HeapObject::cast(object);
2153 tracer.VisitPointers(reinterpret_cast<Object**>(&symbol_table),
2154 reinterpret_cast<Object**>(&symbol_table)+1);
2172 tracer.TracePathFrom(reinterpret_cast<Object**>(&obj1));
2205 Object* LiveObjectList::GetPath(int obj_id1,
2210 // Get the target object.
2245 v->VisitPointer(reinterpret_cast<Object **>(p));
2269 // Copy all the object elements into a consecutive array.
2289 // Process if the element's object is still live after the current GC.
2297 continue; // Live object but no match. Move on.
2310 // object. We'll keep the oldest ref:
2316 // Either the object was already marked for purging, or we just marked
2339 // When we promote live objects from the youngGen, the object may be moved
2343 // object. Hence, we can get a duplicate address in the LOL again.
2346 // only have at most one unique LOL reference to any object at any time.
2364 // is a dead object. Copy the last element over this one.
2447 // Copy all the object elements into a consecutive array.
2460 // 1. object in LOL but not in heap i.e. error.
2461 // 2. object in heap but not in LOL (possibly not an error). Usually
2499 OS::Print("heap object %p NOT in lol database\n", heap_obj);
2516 OS::Print("lol database object [%d of %d] %p NOT in heap\n",
