Version 3.8.6

src/liveobjectlist.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 147 matching lines @@
   return name[type];
 }
 
 
 const char* GetObjectTypeDesc(HeapObject* heap_obj) {
   LiveObjectType type = GetObjectType(heap_obj);
   return GetObjectTypeDesc(type);
 }
 
 
-bool IsOfType(LiveObjectType type, HeapObject *obj) {
+bool IsOfType(LiveObjectType type, HeapObject* obj) {
   // Note: there are types that are more general (e.g. JSObject) that would
   // have passed the Is##type_() test for more specialized types (e.g.
   // JSFunction).  If we find a more specialized match but we're looking for
   // the general type, then we should reject the ones that matches the
   // specialized type.
 #define CHECK_OBJECT_TYPE(type_, name) \
   if (obj->Is##type_()) return (type == kType##type_);
 
   FOR_EACH_LIVE_OBJECT_TYPE(CHECK_OBJECT_TYPE)
 #undef CHECK_OBJECT_TYPE
@@ skipping 25 matching lines @@
       break;
     case 'o':
       if (strcmp(key_str, "old-pointer") == 0) return OLD_POINTER_SPACE;
       if (strcmp(key_str, "old-data") == 0) return OLD_DATA_SPACE;
       break;
   }
   return kInvalidSpace;
 }
 
 
-static bool InSpace(AllocationSpace space, HeapObject *heap_obj) {
+static bool InSpace(AllocationSpace space, HeapObject* heap_obj) {
   Heap* heap = ISOLATE->heap();
   if (space != LO_SPACE) {
     return heap->InSpace(heap_obj, space);
   }
 
   // This is an optimization to speed up the check for an object in the LO
   // space by exclusion because we know that all object pointers passed in
   // here are guaranteed to be in the heap.  Hence, it is safe to infer
   // using an exclusion test.
   // Note: calling Heap::InSpace(heap_obj, LO_SPACE) is too slow for our
@@ skipping 266 matching lines @@
   if (obj->IsJSArray()) {
     JSArray* jsarray = JSArray::cast(obj);
     double length = jsarray->length()->Number();
     OS::SNPrintF(buffer_v,
                  "%p <%s> len %g",
                  reinterpret_cast<void*>(obj),
                  GetObjectTypeDesc(obj),
                  length);
 
   } else if (obj->IsString()) {
-    String *str = String::cast(obj);
+    String* str = String::cast(obj);
     // Only grab up to 160 chars in case they are double byte.
     // We'll only dump 80 of them after we compact them.
     const int kMaxCharToDump = 80;
     const int kMaxBufferSize = kMaxCharToDump * 2;
     SmartArrayPointer<char> str_sp = str->ToCString(DISALLOW_NULLS,
                                                     ROBUST_STRING_TRAVERSAL,
                                                     0,
                                                     kMaxBufferSize);
     char* str_cstr = *str_sp;
     int length = CompactString(str_cstr);
@@ skipping 323 matching lines @@
   static const int kNumberOfEntries = kNumberOfTypes;
 
  private:
   int counts_[kNumberOfEntries];
   int sizes_[kNumberOfEntries];
   int total_count_;
   int total_size_;
   bool found_root_;
   bool found_weak_root_;
 
-  LolFilter *filter_;
+  LolFilter* filter_;
 };
 
 
 // Abstraction for a summary writer.
 class SummaryWriter {
  public:
   virtual ~SummaryWriter() {}
   virtual void Write(LiveObjectSummary* summary) = 0;
 };
 
 
 // A summary writer for filling in a summary of lol lists and diffs.
 class LolSummaryWriter: public SummaryWriter {
  public:
-  LolSummaryWriter(LiveObjectList *older_lol,
-                   LiveObjectList *newer_lol)
+  LolSummaryWriter(LiveObjectList* older_lol,
+                   LiveObjectList* newer_lol)
       : older_(older_lol), newer_(newer_lol) {
   }
 
   void Write(LiveObjectSummary* summary) {
     LolFilter* filter = summary->filter();
 
     // Fill the summary with the lol object details.
     LolIterator it(older_, newer_);
     for (it.Init(); !it.Done(); it.Next()) {
       HeapObject* heap_obj = it.Obj();
@@ skipping 65 matching lines @@
 
 LiveObjectList::~LiveObjectList() {
   DeleteArray<Element>(elements_);
   delete prev_;
 }
 
 
 int LiveObjectList::GetTotalObjCountAndSize(int* size_p) {
   int size = 0;
   int count = 0;
-  LiveObjectList *lol = this;
+  LiveObjectList* lol = this;
   do {
     // Only compute total size if requested i.e. when size_p is not null.
     if (size_p != NULL) {
       Element* elements = lol->elements_;
       for (int i = 0; i < lol->obj_count_; i++) {
         HeapObject* heap_obj = elements[i].obj_;
         size += heap_obj->Size();
       }
     }
     count += lol->obj_count_;
@@ skipping 218 matching lines @@
 
   return *result;
 }
 
 
 // Delete doesn't actually deletes an lol.  It just marks it as invisible since
 // its contents are considered to be part of subsequent lists as well.  The
 // only time we'll actually delete the lol is when we Reset() or if the lol is
 // invisible, and its element count reaches 0.
 bool LiveObjectList::Delete(int id) {
-  LiveObjectList *lol = last();
+  LiveObjectList* lol = last();
   while (lol != NULL) {
     if (lol->id() == id) {
       break;
     }
     lol = lol->prev_;
   }
 
   // If no lol is found for this id, then we fail to delete.
   if (lol == NULL) return false;
 
@@ skipping 42 matching lines @@
   if ((older_id < 0) || (newer_id < 0) || (last() == NULL)) {
     return Failure::Exception();  // Fail: 0 is not a valid lol id.
   }
   if (newer_id < older_id) {
     // They are not in the expected order.  Swap them.
     int temp = older_id;
     older_id = newer_id;
     newer_id = temp;
   }
 
-  LiveObjectList *newer_lol = FindLolForId(newer_id, last());
-  LiveObjectList *older_lol = FindLolForId(older_id, newer_lol);
+  LiveObjectList* newer_lol = FindLolForId(newer_id, last());
+  LiveObjectList* older_lol = FindLolForId(older_id, newer_lol);
 
   // If the id is defined, and we can't find a LOL for it, then we have an
   // invalid id.
   if ((newer_id != 0) && (newer_lol == NULL)) {
     return Failure::Exception();  // Fail: the newer lol id is invalid.
   }
   if ((older_id != 0) && (older_lol == NULL)) {
     return Failure::Exception();  // Fail: the older lol id is invalid.
   }
 
@@ skipping 97 matching lines @@
   if ((older_id < 0) || (newer_id < 0) || (last() == NULL)) {
     return Failure::Exception();  // Fail: 0 is not a valid lol id.
   }
   if (newer_id < older_id) {
     // They are not in the expected order.  Swap them.
     int temp = older_id;
     older_id = newer_id;
     newer_id = temp;
   }
 
-  LiveObjectList *newer_lol = FindLolForId(newer_id, last());
-  LiveObjectList *older_lol = FindLolForId(older_id, newer_lol);
+  LiveObjectList* newer_lol = FindLolForId(newer_id, last());
+  LiveObjectList* older_lol = FindLolForId(older_id, newer_lol);
 
   // If the id is defined, and we can't find a LOL for it, then we have an
   // invalid id.
   if ((newer_id != 0) && (newer_lol == NULL)) {
     return Failure::Exception();  // Fail: the newer lol id is invalid.
   }
   if ((older_id != 0) && (older_lol == NULL)) {
     return Failure::Exception();  // Fail: the older lol id is invalid.
   }
 
@@ skipping 239 matching lines @@
                                      NONE,
                                      kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *result;
 }
 
 
 // Deletes all captured lols.
 void LiveObjectList::Reset() {
-  LiveObjectList *lol = last();
+  LiveObjectList* lol = last();
   // Just delete the last.  Each lol will delete it's prev automatically.
   delete lol;
 
   next_element_id_ = 1;
   list_count_ = 0;
   last_id_ = 0;
   first_ = NULL;
   last_ = NULL;
 }
 
@@ skipping 68 matching lines @@
   }
 
   HeapObject* target_;
   Handle<HeapObject> handle_to_skip_;
   bool found_;
 };
 
 
 inline bool AddRootRetainerIfFound(const LolVisitor& visitor,
                                    LolFilter* filter,
-                                   LiveObjectSummary *summary,
-                                   void (*SetRootFound)(LiveObjectSummary *s),
+                                   LiveObjectSummary* summary,
+                                   void (*SetRootFound)(LiveObjectSummary* s),
                                    int start,
                                    int dump_limit,
                                    int* total_count,
                                    Handle<FixedArray> retainers_arr,
                                    int* count,
                                    int* index,
                                    const char* root_name,
                                    Handle<String> id_sym,
                                    Handle<String> desc_sym,
                                    Handle<String> size_sym,
@@ skipping 25 matching lines @@
                               desc,
                               error);
         }
       }
     }
   }
   return true;
 }
 
 
-inline void SetFoundRoot(LiveObjectSummary *summary) {
+inline void SetFoundRoot(LiveObjectSummary* summary) {
   summary->set_found_root();
 }
 
 
-inline void SetFoundWeakRoot(LiveObjectSummary *summary) {
+inline void SetFoundWeakRoot(LiveObjectSummary* summary) {
   summary->set_found_weak_root();
 }
 
 
 int LiveObjectList::GetRetainers(Handle<HeapObject> target,
                                  Handle<JSObject> instance_filter,
                                  Handle<FixedArray> retainers_arr,
                                  int start,
                                  int dump_limit,
                                  int* total_count,
                                  LolFilter* filter,
-                                 LiveObjectSummary *summary,
+                                 LiveObjectSummary* summary,
                                  JSFunction* arguments_function,
                                  Handle<Object> error) {
   HandleScope scope;
 
   // Scratch handles.
   Handle<JSObject> detail;
   Handle<String> desc;
   Handle<HeapObject> retainer;
 
   Isolate* isolate = Isolate::Current();
@@ skipping 467 matching lines @@
 
   HeapObject* obj2 = HeapObject::cast(GetObj(obj_id2));
   if (obj2 == HEAP->undefined_value()) {
     return obj2;
   }
 
   return GetPathPrivate(obj1, obj2);
 }
 
 
-void LiveObjectList::DoProcessNonLive(HeapObject *obj) {
+void LiveObjectList::DoProcessNonLive(HeapObject* obj) {
   // We should only be called if we have at least one lol to search.
   ASSERT(last() != NULL);
   Element* element = last()->Find(obj);
   if (element != NULL) {
     NullifyNonLivePointer(&element->obj_);
   }
 }
 
 
 void LiveObjectList::IterateElementsPrivate(ObjectVisitor* v) {
   LiveObjectList* lol = last();
   while (lol != NULL) {
     Element* elements = lol->elements_;
     int count = lol->obj_count_;
     for (int i = 0; i < count; i++) {
       HeapObject** p = &elements[i].obj_;
-      v->VisitPointer(reinterpret_cast<Object **>(p));
+      v->VisitPointer(reinterpret_cast<Object** >(p));
     }
     lol = lol->prev_;
   }
 }
 
 
 // Purpose: Called by GCEpilogue to purge duplicates.  Not to be called by
 // anyone else.
 void LiveObjectList::PurgeDuplicates() {
   bool is_sorted = false;
@@ skipping 84 matching lines @@
   // to the start of these free chunks.  Since there is no free or move event
   // for the free chunks, their addresses will show up 2 times: once for their
   // original free ByteArray selves, and once for the newly promoted youngGen
   // object.  Hence, we can get a duplicate address in the LOL again.
   //
   // We need to eliminate these dups because the LOL implementation expects to
   // only have at most one unique LOL reference to any object at any time.
   PurgeDuplicates();
 
   // After the GC, sweep away all free'd Elements and compact.
-  LiveObjectList *prev = NULL;
-  LiveObjectList *next = NULL;
+  LiveObjectList* prev = NULL;
+  LiveObjectList* next = NULL;
 
   // Iterating from the youngest lol to the oldest lol.
-  for (LiveObjectList *lol = last(); lol; lol = prev) {
+  for (LiveObjectList* lol = last(); lol; lol = prev) {
     Element* elements = lol->elements_;
     prev = lol->prev();  // Save the prev.
 
     // Remove any references to collected objects.
     int i = 0;
     while (i < lol->obj_count_) {
       Element& element = elements[i];
       if (!element.obj_->IsHeapObject()) {
         // If the HeapObject address was converted into a SMI, then this
         // is a dead object.  Copy the last element over this one.
@@ skipping 32 matching lines @@
         continue;
       }
 
     } else {
       // If the obj_count_ is less than the capacity and the difference is
       // greater than a specified threshold, then we should shrink the list.
       int diff = lol->capacity_ - new_count;
       const int kMaxUnusedSpace = 64;
       if (diff > kMaxUnusedSpace) {  // Threshold for shrinking.
         // Shrink the list.
-        Element *new_elements = NewArray<Element>(new_count);
+        Element* new_elements = NewArray<Element>(new_count);
         memcpy(new_elements, elements, new_count * sizeof(Element));
 
         DeleteArray<Element>(elements);
         lol->elements_ = new_elements;
         lol->capacity_ = new_count;
       }
       ASSERT(lol->obj_count_ == new_count);
 
       lol->Sort();  // We've moved objects.  Re-sort in case.
     }
@@ skipping 162 matching lines @@
                 i++, heap_obj, Heap::new_space()->FromSpaceStart());
     }
   }
 }
 #endif  // VERIFY_LOL
 
 
 } }  // namespace v8::internal
 
 #endif  // LIVE_OBJECT_LIST