diff options
Diffstat (limited to 'deps/v8/src/liveobjectlist.h')
| -rw-r--r-- | deps/v8/src/liveobjectlist.h | 319 |
1 files changed, 0 insertions, 319 deletions
diff --git a/deps/v8/src/liveobjectlist.h b/deps/v8/src/liveobjectlist.h deleted file mode 100644 index 1aa919605..000000000 --- a/deps/v8/src/liveobjectlist.h +++ /dev/null @@ -1,319 +0,0 @@ -// 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 -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef V8_LIVEOBJECTLIST_H_ -#define V8_LIVEOBJECTLIST_H_ - -#include "v8.h" - -#include "checks.h" -#include "heap.h" -#include "objects.h" -#include "globals.h" - -namespace v8 { -namespace internal { - -#ifdef LIVE_OBJECT_LIST - -#ifdef DEBUG -// The following symbol when defined enables thorough verification of lol data. -// FLAG_verify_lol will also need to set to true to enable the verification. -#define VERIFY_LOL -#endif - - -typedef int LiveObjectType; -class LolFilter; -class LiveObjectSummary; -class DumpWriter; -class SummaryWriter; - - -// The LiveObjectList is both a mechanism for tracking a live capture of -// objects in the JS heap, as well as is the data structure which represents -// each of those captures. Unlike a snapshot, the lol is live. For example, -// if an object in a captured lol dies and is collected by the GC, the lol -// will reflect that the object is no longer available. The term -// LiveObjectList (and lol) is used to describe both the mechanism and the -// data structure depending on context of use. -// -// In captured lols, objects are tracked using their address and an object id. -// The object id is unique. Once assigned to an object, the object id can never -// be assigned to another object. That is unless all captured lols are deleted -// which allows the user to start over with a fresh set of lols and object ids. -// The uniqueness of the object ids allows the user to track specific objects -// and inspect its longevity while debugging JS code in execution. -// -// The lol comes with utility functions to capture, dump, summarize, and diff -// captured lols amongst other functionality. These functionality are -// accessible via the v8 debugger interface. -class LiveObjectList { - public: - inline static void GCEpilogue(); - inline static void GCPrologue(); - inline static void IterateElements(ObjectVisitor* v); - inline static void ProcessNonLive(HeapObject* obj); - inline static void UpdateReferencesForScavengeGC(); - - // Note: LOLs can be listed by calling Dump(0, <lol id>), and 2 LOLs can be - // compared/diff'ed using Dump(<lol id1>, <lol id2>, ...). This will yield - // a verbose dump of all the objects in the resultant lists. - // Similarly, a summarized result of a LOL listing or a diff can be - // attained using the Summarize(0, <lol id>) and Summarize(<lol id1, - // <lol id2>, ...) respectively. - - static MaybeObject* Capture(); - static bool Delete(int id); - static MaybeObject* Dump(int id1, - int id2, - int start_idx, - int dump_limit, - Handle<JSObject> filter_obj); - static MaybeObject* Info(int start_idx, int dump_limit); - static MaybeObject* Summarize(int id1, int id2, Handle<JSObject> filter_obj); - - static void Reset(); - static Object* GetObj(int obj_id); - static int GetObjId(Object* obj); - static Object* GetObjId(Handle<String> address); - static MaybeObject* GetObjRetainers(int obj_id, - Handle<JSObject> instance_filter, - bool verbose, - int start, - int count, - Handle<JSObject> filter_obj); - - static Object* GetPath(int obj_id1, - int obj_id2, - Handle<JSObject> instance_filter); - static Object* PrintObj(int obj_id); - - private: - struct Element { - int id_; - HeapObject* obj_; - }; - - explicit LiveObjectList(LiveObjectList* prev, int capacity); - ~LiveObjectList(); - - static void GCEpiloguePrivate(); - static void IterateElementsPrivate(ObjectVisitor* v); - - static void DoProcessNonLive(HeapObject* obj); - - static int CompareElement(const Element* a, const Element* b); - - static Object* GetPathPrivate(HeapObject* obj1, HeapObject* obj2); - - static int GetRetainers(Handle<HeapObject> target, - Handle<JSObject> instance_filter, - Handle<FixedArray> retainers_arr, - int start, - int dump_limit, - int* total_count, - LolFilter* filter, - LiveObjectSummary* summary, - JSFunction* arguments_function, - Handle<Object> error); - - static MaybeObject* DumpPrivate(DumpWriter* writer, - int start, - int dump_limit, - LolFilter* filter); - static MaybeObject* SummarizePrivate(SummaryWriter* writer, - LolFilter* filter, - bool is_tracking_roots); - - static bool NeedLOLProcessing() { return (last() != NULL); } - static void NullifyNonLivePointer(HeapObject** p) { - // Mask out the low bit that marks this as a heap object. We'll use this - // cleared bit as an indicator that this pointer needs to be collected. - // - // Meanwhile, we still preserve its approximate value so that we don't - // have to resort the elements list all the time. - // - // Note: Doing so also makes this HeapObject* look like an SMI. Hence, - // GC pointer updater will ignore it when it gets scanned. - *p = reinterpret_cast<HeapObject*>((*p)->address()); - } - - LiveObjectList* prev() { return prev_; } - LiveObjectList* next() { return next_; } - int id() { return id_; } - - static int list_count() { return list_count_; } - static LiveObjectList* last() { return last_; } - - inline static LiveObjectList* FindLolForId(int id, LiveObjectList* start_lol); - int TotalObjCount() { return GetTotalObjCountAndSize(NULL); } - int GetTotalObjCountAndSize(int* size_p); - - bool Add(HeapObject* obj); - Element* Find(HeapObject* obj); - static void NullifyMostRecent(HeapObject* obj); - void Sort(); - static void SortAll(); - - static void PurgeDuplicates(); // Only to be called by GCEpilogue. - -#ifdef VERIFY_LOL - static void Verify(bool match_heap_exactly = false); - static void VerifyNotInFromSpace(); -#endif - - // Iterates the elements in every lol and returns the one that matches the - // specified key. If no matching element is found, then it returns NULL. - template <typename T> - inline static LiveObjectList::Element* - FindElementFor(T (*GetValue)(LiveObjectList::Element*), T key); - - inline static int GetElementId(Element* element); - inline static HeapObject* GetElementObj(Element* element); - - // Instance fields. - LiveObjectList* prev_; - LiveObjectList* next_; - int id_; - int capacity_; - int obj_count_; - Element* elements_; - - // Statics for managing all the lists. - static uint32_t next_element_id_; - static int list_count_; - static int last_id_; - static LiveObjectList* first_; - static LiveObjectList* last_; - - friend class LolIterator; - friend class LolForwardIterator; - friend class LolDumpWriter; - friend class RetainersDumpWriter; - friend class RetainersSummaryWriter; - friend class UpdateLiveObjectListVisitor; -}; - - -// Helper class for updating the LiveObjectList HeapObject pointers. -class UpdateLiveObjectListVisitor: public ObjectVisitor { - public: - void VisitPointer(Object** p) { UpdatePointer(p); } - - void VisitPointers(Object** start, Object** end) { - // Copy all HeapObject pointers in [start, end). - for (Object** p = start; p < end; p++) UpdatePointer(p); - } - - private: - // Based on Heap::ScavengeObject() but only does forwarding of pointers - // to live new space objects, and not actually keep them alive. - void UpdatePointer(Object** p) { - Object* object = *p; - if (!HEAP->InNewSpace(object)) return; - - HeapObject* heap_obj = HeapObject::cast(object); - ASSERT(HEAP->InFromSpace(heap_obj)); - - // We use the first word (where the map pointer usually is) of a heap - // object to record the forwarding pointer. A forwarding pointer can - // point to an old space, the code space, or the to space of the new - // generation. - MapWord first_word = heap_obj->map_word(); - - // If the first word is a forwarding address, the object has already been - // copied. - if (first_word.IsForwardingAddress()) { - *p = first_word.ToForwardingAddress(); - return; - - // Else, it's a dead object. - } else { - LiveObjectList::NullifyNonLivePointer(reinterpret_cast<HeapObject**>(p)); - } - } -}; - - -#else // !LIVE_OBJECT_LIST - - -class LiveObjectList { - public: - inline static void GCEpilogue() {} - inline static void GCPrologue() {} - inline static void IterateElements(ObjectVisitor* v) {} - inline static void ProcessNonLive(HeapObject* obj) {} - inline static void UpdateReferencesForScavengeGC() {} - - inline static MaybeObject* Capture() { return HEAP->undefined_value(); } - inline static bool Delete(int id) { return false; } - inline static MaybeObject* Dump(int id1, - int id2, - int start_idx, - int dump_limit, - Handle<JSObject> filter_obj) { - return HEAP->undefined_value(); - } - inline static MaybeObject* Info(int start_idx, int dump_limit) { - return HEAP->undefined_value(); - } - inline static MaybeObject* Summarize(int id1, - int id2, - Handle<JSObject> filter_obj) { - return HEAP->undefined_value(); - } - - inline static void Reset() {} - inline static Object* GetObj(int obj_id) { return HEAP->undefined_value(); } - inline static Object* GetObjId(Handle<String> address) { - return HEAP->undefined_value(); - } - inline static MaybeObject* GetObjRetainers(int obj_id, - Handle<JSObject> instance_filter, - bool verbose, - int start, - int count, - Handle<JSObject> filter_obj) { - return HEAP->undefined_value(); - } - - inline static Object* GetPath(int obj_id1, - int obj_id2, - Handle<JSObject> instance_filter) { - return HEAP->undefined_value(); - } - inline static Object* PrintObj(int obj_id) { return HEAP->undefined_value(); } -}; - - -#endif // LIVE_OBJECT_LIST - -} } // namespace v8::internal - -#endif // V8_LIVEOBJECTLIST_H_ |