Make gen-postmortem-metadata.py more reliable

src/objects.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/allocation.h"
@@ skipping 991 matching lines @@
   V(ObjectHashTable)               \
   V(WeakHashTable)                 \
   V(OrderedHashTable)
 
 // Object is the abstract superclass for all classes in the
 // object hierarchy.
 // Object does not use any virtual functions to avoid the
 // allocation of the C++ vtable.
 // Since both Smi and HeapObject are subclasses of Object no
 // data members can be present in Object.
-class Object {
+class Object { /* POSTMORTEM */
  public:
   // Type testing.
   bool IsObject() const { return true; }
 
 #define IS_TYPE_FUNCTION_DECL(type_)  INLINE(bool Is##type_() const);
   OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
   HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
 #undef IS_TYPE_FUNCTION_DECL
 
   // A non-keyed store is of the form a.x = foo or a["x"] = foo whereas
@@ skipping 388 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const Brief& v);
 
 
 // Smi represents integer Numbers that can be stored in 31 bits.
 // Smis are immediate which means they are NOT allocated in the heap.
 // The this pointer has the following format: [31 bit signed int] 0
 // For long smis it has the following format:
 //     [32 bit signed int] [31 bits zero padding] 0
 // Smi stands for small integer.
-class Smi: public Object {
+class Smi: public Object { /* POSTMORTEM */
  public:
   // Returns the integer value.
   inline int value() const { return Internals::SmiValue(this); }
 
   // Convert a value to a Smi object.
   static inline Smi* FromInt(int value) {
     DCHECK(Smi::IsValid(value));
     return reinterpret_cast<Smi*>(Internals::IntToSmi(value));
   }
 
@@ skipping 74 matching lines @@
 
 // The content of an heap object (except for the map pointer). kTaggedValues
 // objects can contain both heap pointers and Smis, kMixedValues can contain
 // heap pointers, Smis, and raw values (e.g. doubles or strings), and kRawValues
 // objects can contain raw values and Smis.
 enum class HeapObjectContents { kTaggedValues, kMixedValues, kRawValues };
 
 
 // HeapObject is the superclass for all classes describing heap allocated
 // objects.
-class HeapObject: public Object {
+class HeapObject: public Object { /* POSTMORTEM */
  public:
   // [map]: Contains a map which contains the object's reflective
   // information.
   inline Map* map() const;
   inline void set_map(Map* value);
   // The no-write-barrier version.  This is OK if the object is white and in
   // new space, or if the value is an immortal immutable object, like the maps
   // of primitive (non-JS) objects like strings, heap numbers etc.
   inline void set_map_no_write_barrier(Map* value);
 
@@ skipping 104 matching lines @@
   inline void IteratePointer(ObjectVisitor* v, int offset);
   // as above, for the next code link of a code object.
   inline void IterateNextCodeLink(ObjectVisitor* v, int offset);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObject);
 };
 
 
 // This is the base class for object's body descriptors.
-class BodyDescriptorBase {
+class BodyDescriptorBase { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

  protected:
   static inline void IterateBodyImpl(HeapObject* obj, int start_offset,
                                      int end_offset, ObjectVisitor* v);
 
   template <typename StaticVisitor>
   static inline void IterateBodyImpl(HeapObject* obj, int start_offset,
                                      int end_offset);
 };
 
 
@@ skipping 43 matching lines @@
 // interval. The size of the object is taken from the map.
 template <int start_offset>
 class FlexibleBodyDescriptor : public FlexibleBodyDescriptorBase<start_offset> {
  public:
   static inline int SizeOf(Map* map, HeapObject* object);
 };
 
 
 // The HeapNumber class describes heap allocated numbers that cannot be
 // represented in a Smi (small integer)
-class HeapNumber: public HeapObject {
+class HeapNumber: public HeapObject { /* POSTMORTEM */
  public:
   // [value]: number value.
   inline double value() const;
   inline void set_value(double value);
 
   DECLARE_CAST(HeapNumber)
 
   // Dispatched behavior.
   bool HeapNumberBooleanValue();
 
@@ skipping 116 matching lines @@
 
 
 enum KeyFilter { SKIP_SYMBOLS, INCLUDE_SYMBOLS };
 
 
 enum GetKeysConversion { KEEP_NUMBERS, CONVERT_TO_STRING };
 
 
 // JSReceiver includes types on which properties can be defined, i.e.,
 // JSObject and JSProxy.
-class JSReceiver: public HeapObject {
+class JSReceiver: public HeapObject { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSReceiver)
 
   // ES6 section 7.1.1 ToPrimitive
   MUST_USE_RESULT static MaybeHandle<Object> ToPrimitive(
       Handle<JSReceiver> receiver,
       ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
   MUST_USE_RESULT static MaybeHandle<Object> OrdinaryToPrimitive(
       Handle<JSReceiver> receiver, OrdinaryToPrimitiveHint hint);
 
@@ skipping 110 matching lines @@
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);
 };
 
 
 // The JSObject describes real heap allocated JavaScript objects with
 // properties.
 // Note that the map of JSObject changes during execution to enable inline
 // caching.
-class JSObject: public JSReceiver {
+class JSObject: public JSReceiver { /* POSTMORTEM */
  public:
   // [properties]: Backing storage for properties.
   // properties is a FixedArray in the fast case and a Dictionary in the
   // slow case.
   DECL_ACCESSORS(properties, FixedArray)  // Get and set fast properties.
   inline void initialize_properties();
   inline bool HasFastProperties();
   // Gets slow properties for non-global objects.
   inline NameDictionary* property_dictionary();
   // Gets global object properties.
@@ skipping 149 matching lines @@
                                             PropertyAttributes attributes);
 
   static void OptimizeAsPrototype(Handle<JSObject> object,
                                   PrototypeOptimizationMode mode);
   static void ReoptimizeIfPrototype(Handle<JSObject> object);
   static void LazyRegisterPrototypeUser(Handle<Map> user, Isolate* isolate);
   static bool UnregisterPrototypeUser(Handle<Map> user, Isolate* isolate);
   static void InvalidatePrototypeChains(Map* map);
 
   // Alternative implementation of WeakFixedArray::NullCallback.
-  class PrototypeRegistryCompactionCallback {
+  class PrototypeRegistryCompactionCallback { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

    public:
     static void Callback(Object* value, int old_index, int new_index);
   };
 
   // Retrieve interceptors.
   InterceptorInfo* GetNamedInterceptor();
   InterceptorInfo* GetIndexedInterceptor();
 
   // Used from JSReceiver.
   MUST_USE_RESULT static Maybe<PropertyAttributes>
@@ skipping 274 matching lines @@
 
   static void PrintElementsTransition(
       FILE* file, Handle<JSObject> object,
       ElementsKind from_kind, Handle<FixedArrayBase> from_elements,
       ElementsKind to_kind, Handle<FixedArrayBase> to_elements);
 
   void PrintInstanceMigration(FILE* file, Map* original_map, Map* new_map);
 
 #ifdef DEBUG
   // Structure for collecting spill information about JSObjects.
-  class SpillInformation {
+  class SpillInformation { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

    public:
     void Clear();
     void Print();
     int number_of_objects_;
     int number_of_objects_with_fast_properties_;
     int number_of_objects_with_fast_elements_;
     int number_of_fast_used_fields_;
     int number_of_fast_unused_fields_;
     int number_of_slow_used_properties_;
     int number_of_slow_unused_properties_;
@@ skipping 130 matching lines @@
   MUST_USE_RESULT static Maybe<bool> SetPrototypeUnobserved(
       Handle<JSObject> object, Handle<Object> value, bool from_javascript,
       ShouldThrow should_throw);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSObject);
 };
 
 
 // Common superclass for FixedArrays that allow implementations to share
 // common accessors and some code paths.
-class FixedArrayBase: public HeapObject {
+class FixedArrayBase: public HeapObject { /* POSTMORTEM */
  public:
   // [length]: length of the array.
   inline int length() const;
   inline void set_length(int value);
 
   // Get and set the length using acquire loads and release stores.
   inline int synchronized_length() const;
   inline void synchronized_set_length(int value);
 
   DECLARE_CAST(FixedArrayBase)
 
   // Layout description.
   // Length is smi tagged when it is stored.
   static const int kLengthOffset = HeapObject::kHeaderSize;
   static const int kHeaderSize = kLengthOffset + kPointerSize;
 };
 
 
 class FixedDoubleArray;
 class IncrementalMarking;
 
 
 // FixedArray describes fixed-sized arrays with element type Object*.
-class FixedArray: public FixedArrayBase {
+class FixedArray: public FixedArrayBase { /* POSTMORTEM */
  public:
   // Setter and getter for elements.
   inline Object* get(int index) const;
   static inline Handle<Object> get(Handle<FixedArray> array, int index);
   // Setter that uses write barrier.
   inline void set(int index, Object* value);
   inline bool is_the_hole(int index);
 
   // Setter that doesn't need write barrier.
   inline void set(int index, Smi* value);
@@ skipping 75 matching lines @@
                                                   Object* value);
 
  private:
   STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray);
 };
 
 
 // FixedDoubleArray describes fixed-sized arrays with element type double.
-class FixedDoubleArray: public FixedArrayBase {
+class FixedDoubleArray: public FixedArrayBase { /* POSTMORTEM */
  public:
   // Setter and getter for elements.
   inline double get_scalar(int index);
   inline uint64_t get_representation(int index);
   static inline Handle<Object> get(Handle<FixedDoubleArray> array, int index);
   inline void set(int index, double value);
   inline void set_the_hole(int index);
 
   // Checking for the hole.
   inline bool is_the_hole(int index);
@@ skipping 22 matching lines @@
 
   // Dispatched behavior.
   DECLARE_PRINTER(FixedDoubleArray)
   DECLARE_VERIFIER(FixedDoubleArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray);
 };
 
 
-class WeakFixedArray : public FixedArray {
+class WeakFixedArray : public FixedArray { /* POSTMORTEM */
  public:
   // If |maybe_array| is not a WeakFixedArray, a fresh one will be allocated.
   // This function does not check if the value exists already, callers must
   // ensure this themselves if necessary.
   static Handle<WeakFixedArray> Add(Handle<Object> maybe_array,
                                     Handle<HeapObject> value,
                                     int* assigned_index = NULL);
 
   // Returns true if an entry was found and removed.
   bool Remove(Handle<HeapObject> value);
 
-  class NullCallback {
+  class NullCallback { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:11]

really?

    public:
     static void Callback(Object* value, int old_index, int new_index) {}
   };
 
   template <class CompactionCallback>
   void Compact();
 
   inline Object* Get(int index) const;
   inline void Clear(int index);
   inline int Length() const;
 
   inline bool IsEmptySlot(int index) const;
   static Object* Empty() { return Smi::FromInt(0); }
 
-  class Iterator {
+  class Iterator { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

    public:
     explicit Iterator(Object* maybe_array) : list_(NULL) { Reset(maybe_array); }
     void Reset(Object* maybe_array);
 
     template <class T>
     inline T* Next();
 
    private:
     int index_;
     WeakFixedArray* list_;
@@ skipping 22 matching lines @@
 
   // Disallow inherited setters.
   void set(int index, Smi* value);
   void set(int index, Object* value);
   void set(int index, Object* value, WriteBarrierMode mode);
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakFixedArray);
 };
 
 
 // Generic array grows dynamically with O(1) amortized insertion.
-class ArrayList : public FixedArray {
+class ArrayList : public FixedArray { /* POSTMORTEM */
  public:
   enum AddMode {
     kNone,
     // Use this if GC can delete elements from the array.
     kReloadLengthAfterAllocation,
   };
   static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj,
                                AddMode mode = kNone);
   static Handle<ArrayList> Add(Handle<ArrayList> array, Handle<Object> obj1,
                                Handle<Object> obj2, AddMode = kNone);
@@ skipping 14 matching lines @@
 
 
 // DescriptorArrays are fixed arrays used to hold instance descriptors.
 // The format of the these objects is:
 //   [0]: Number of descriptors
 //   [1]: Either Smi(0) if uninitialized, or a pointer to small fixed array:
 //          [0]: pointer to fixed array with enum cache
 //          [1]: either Smi(0) or pointer to fixed array with indices
 //   [2]: first key
 //   [2 + number of descriptors * kDescriptorSize]: start of slack
-class DescriptorArray: public FixedArray {
+class DescriptorArray: public FixedArray { /* POSTMORTEM */
  public:
   // Returns true for both shared empty_descriptor_array and for smis, which the
   // map uses to encode additional bit fields when the descriptor array is not
   // yet used.
   inline bool IsEmpty();
 
   // Returns the number of descriptors in the array.
   inline int number_of_descriptors();
 
   inline int number_of_descriptors_storage();
@@ skipping 139 matching lines @@
 
  private:
   // WhitenessWitness is used to prove that a descriptor array is white
   // (unmarked), so incremental write barriers can be skipped because the
   // marking invariant cannot be broken and slots pointing into evacuation
   // candidates will be discovered when the object is scanned. A witness is
   // always stack-allocated right after creating an array. By allocating a
   // witness, incremental marking is globally disabled. The witness is then
   // passed along wherever needed to statically prove that the array is known to
   // be white.
-  class WhitenessWitness {
+  class WhitenessWitness { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:11]

really?

    public:
     inline explicit WhitenessWitness(DescriptorArray* array);
     inline ~WhitenessWitness();
 
    private:
     IncrementalMarking* marking_;
   };
 
   // An entry in a DescriptorArray, represented as an (array, index) pair.
-  class Entry {
+  class Entry { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

    public:
     inline explicit Entry(DescriptorArray* descs, int index) :
         descs_(descs), index_(index) { }
 
     inline PropertyType type();
     inline Object* GetCallbackObject();
 
    private:
     DescriptorArray* descs_;
     int index_;
@@ skipping 67 matching lines @@
 //     // of the backing storage.
 //     static const int kPrefixSize = ..;
 //     // The Element size indicates number of elements per entry.
 //     static const int kEntrySize = ..;
 //   };
 // The prefix size indicates an amount of memory in the
 // beginning of the backing storage that can be used for non-element
 // information by subclasses.
 
 template<typename Key>
-class BaseShape {
+class BaseShape { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:11]

really?

  public:
   static const bool UsesSeed = false;
   static uint32_t Hash(Key key) { return 0; }
   static uint32_t SeededHash(Key key, uint32_t seed) {
     DCHECK(UsesSeed);
     return Hash(key);
   }
   static uint32_t HashForObject(Key key, Object* object) { return 0; }
   static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
     DCHECK(UsesSeed);
     return HashForObject(key, object);
   }
 };
 
 
-class HashTableBase : public FixedArray {
+class HashTableBase : public FixedArray { /* POSTMORTEM */
  public:
   // Returns the number of elements in the hash table.
   inline int NumberOfElements();
 
   // Returns the number of deleted elements in the hash table.
   inline int NumberOfDeletedElements();
 
   // Returns the capacity of the hash table.
   inline int Capacity();
 
@@ skipping 45 matching lines @@
   }
 
   inline static uint32_t NextProbe(
       uint32_t last, uint32_t number, uint32_t size) {
     return (last + number) & (size - 1);
   }
 };
 
 
 template <typename Derived, typename Shape, typename Key>
-class HashTable : public HashTableBase {
+class HashTable : public HashTableBase { /* POSTMORTEM */
  public:
   // Wrapper methods
   inline uint32_t Hash(Key key) {
     if (Shape::UsesSeed) {
       return Shape::SeededHash(key, GetHeap()->HashSeed());
     } else {
       return Shape::Hash(key);
     }
   }
 
@@ skipping 80 matching lines @@
   uint32_t EntryForProbe(Key key, Object* k, int probe, uint32_t expected);
 
   void Swap(uint32_t entry1, uint32_t entry2, WriteBarrierMode mode);
 
   // Rehashes this hash-table into the new table.
   void Rehash(Handle<Derived> new_table, Key key);
 };
 
 
 // HashTableKey is an abstract superclass for virtual key behavior.
-class HashTableKey {
+class HashTableKey { /* POSTMORTEM */

[Jakob Kummerow, 2015/11/10 15:12:12]

really?

  public:
   // Returns whether the other object matches this key.
   virtual bool IsMatch(Object* other) = 0;
   // Returns the hash value for this key.
   virtual uint32_t Hash() = 0;
   // Returns the hash value for object.
   virtual uint32_t HashForObject(Object* key) = 0;
   // Returns the key object for storing into the hash table.
   MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate) = 0;
   // Required.
@@ skipping 22 matching lines @@
 };
 
 class SeqOneByteString;
 
 // StringTable.
 //
 // No special elements in the prefix and the element size is 1
 // because only the string itself (the key) needs to be stored.
 class StringTable: public HashTable<StringTable,
                                     StringTableShape,
-                                    HashTableKey*> {
+                                    HashTableKey*> { /* POSTMORTEM */
  public:
   // Find string in the string table. If it is not there yet, it is
   // added. The return value is the string found.
   static Handle<String> LookupString(Isolate* isolate, Handle<String> key);
   static Handle<String> LookupKey(Isolate* isolate, HashTableKey* key);
   static String* LookupKeyIfExists(Isolate* isolate, HashTableKey* key);
 
   // Tries to internalize given string and returns string handle on success
   // or an empty handle otherwise.
   MUST_USE_RESULT static MaybeHandle<String> InternalizeStringIfExists(
@@ skipping 16 matching lines @@
 
  private:
   template <bool seq_one_byte>
   friend class JsonParser;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringTable);
 };
 
 
 template <typename Derived, typename Shape, typename Key>
-class Dictionary: public HashTable<Derived, Shape, Key> {
+class Dictionary: public HashTable<Derived, Shape, Key> { /* POSTMORTEM */
   typedef HashTable<Derived, Shape, Key> DerivedHashTable;
 
  public:
   // Returns the value at entry.
   Object* ValueAt(int entry) {
     return this->get(Derived::EntryToIndex(entry) + 1);
   }
 
   // Set the value for entry.
   void ValueAtPut(int entry, Object* value) {
@@ skipping 406 matching lines @@
 // table:
 //
 // Memory layout for obsolete table:
 //   [0]: bucket count
 //   [1]: Next newer table
 //   [2]: Number of removed holes or -1 when the table was cleared.
 //   [3..(3 + NumberOfRemovedHoles() - 1)]: The indexes of the removed holes.
 //   [3 + NumberOfRemovedHoles()..length]: Not used
 //
 template<class Derived, class Iterator, int entrysize>
-class OrderedHashTable: public FixedArray {
+class OrderedHashTable: public FixedArray { /* POSTMORTEM */
  public:
   // Returns an OrderedHashTable with a capacity of at least |capacity|.
   static Handle<Derived> Allocate(
       Isolate* isolate, int capacity, PretenureFlag pretenure = NOT_TENURED);
 
   // Returns an OrderedHashTable (possibly |table|) with enough space
   // to add at least one new element.
   static Handle<Derived> EnsureGrowable(Handle<Derived> table);
 
   // Returns an OrderedHashTable (possibly |table|) that's shrunken
@@ skipping 509 matching lines @@
   static inline int GetIndex(Handle<Map> map);
 
   // The following declarations hide base class methods.
   Object* get(int index);
   void set(int index, Object* value);
 };
 
 
 // ByteArray represents fixed sized byte arrays.  Used for the relocation info
 // that is attached to code objects.
-class ByteArray: public FixedArrayBase {
+class ByteArray: public FixedArrayBase { /* POSTMORTEM */
  public:
   inline int Size();
 
   // Setter and getter.
   inline byte get(int index);
   inline void set(int index, byte value);
 
   // Treat contents as an int array.
   inline int get_int(int index);
 
@@ skipping 91 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArray);
 };
 
 
 // FreeSpace are fixed-size free memory blocks used by the heap and GC.
 // They look like heap objects (are heap object tagged and have a map) so that
 // the heap remains iterable.  They have a size and a next pointer.
 // The next pointer is the raw address of the next FreeSpace object (or NULL)
 // in the free list.
-class FreeSpace: public HeapObject {
+class FreeSpace: public HeapObject { /* POSTMORTEM */
  public:
   // [size]: size of the free space including the header.
   inline int size() const;
   inline void set_size(int value);
 
   inline int nobarrier_size() const;
   inline void nobarrier_set_size(int value);
 
   inline int Size();
 
@@ skipping 365 matching lines @@
   static const int kReturnHandlerIndex = 1;
   static const int kReturnEntrySize = 2;
 
   // Encoding of the {handler} field.
   class HandlerPredictionField : public BitField<CatchPrediction, 0, 1> {};
   class HandlerOffsetField : public BitField<int, 1, 30> {};
 };
 
 
 // Code describes objects with on-the-fly generated machine code.
-class Code: public HeapObject {
+class Code: public HeapObject { /* POSTMORTEM */
  public:
   // Opaque data type for encapsulating code flags like kind, inline
   // cache state, and arguments count.
   typedef uint32_t Flags;
 
 #define NON_IC_KIND_LIST(V) \
   V(FUNCTION)               \
   V(OPTIMIZED_FUNCTION)     \
   V(STUB)                   \
   V(HANDLER)                \
@@ skipping 654 matching lines @@
 };
 
 
 class PrototypeInfo;
 
 
 // All heap objects have a Map that describes their structure.
 //  A Map contains information about:
 //  - Size information about the object
 //  - How to iterate over an object (for garbage collection)
-class Map: public HeapObject {
+class Map: public HeapObject { /* POSTMORTEM */
  public:
   // Instance size.
   // Size in bytes or kVariableSizeSentinel if instances do not have
   // a fixed size.
   inline int instance_size();
   inline void set_instance_size(int value);
 
   // Only to clear an unused byte, remove once byte is used.
   inline void clear_unused();
 
@@ skipping 743 matching lines @@
   static const int kScopeInfoOffset = HeapObject::kHeaderSize;
   static const int kExtensionOffset = kScopeInfoOffset + kPointerSize;
   static const int kSize = kExtensionOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SloppyBlockWithEvalContextExtension);
 };
 
 
 // Script describes a script which has been added to the VM.
-class Script: public Struct {
+class Script: public Struct { /* POSTMORTEM */
  public:
   // Script types.
   enum Type {
     TYPE_NATIVE = 0,
     TYPE_EXTENSION = 1,
     TYPE_NORMAL = 2
   };
 
   // Script compilation types.
   enum CompilationType {
@@ skipping 215 matching lines @@
 // Result of searching in an optimized code map of a SharedFunctionInfo. Note
 // that both {code} and {literals} can be NULL to pass search result status.
 struct CodeAndLiterals {
   Code* code;            // Cached optimized code.
   LiteralsArray* literals;  // Cached literals array.
 };
 
 
 // SharedFunctionInfo describes the JSFunction information that can be
 // shared by multiple instances of the function.
-class SharedFunctionInfo: public HeapObject {
+class SharedFunctionInfo: public HeapObject { /* POSTMORTEM */
  public:
   // [name]: Function name.
   DECL_ACCESSORS(name, Object)
 
   // [code]: Function code.
   DECL_ACCESSORS(code, Code)
   inline void ReplaceCode(Code* code);
 
   // [optimized_code_map]: Map from native context to optimized code
   // and a shared literals array or Smi(0) if none.
@@ skipping 645 matching lines @@
   explicit SourceCodeOf(SharedFunctionInfo* v, int max = -1)
       : value(v), max_length(max) {}
   const SharedFunctionInfo* value;
   int max_length;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
 
 
-class JSGeneratorObject: public JSObject {
+class JSGeneratorObject: public JSObject { /* POSTMORTEM */
  public:
   // [function]: The function corresponding to this generator object.
   DECL_ACCESSORS(function, JSFunction)
 
   // [context]: The context of the suspended computation.
   DECL_ACCESSORS(context, Context)
 
   // [receiver]: The receiver of the suspended computation.
   DECL_ACCESSORS(receiver, Object)
 
@@ skipping 31 matching lines @@
 
   // Resume mode, for use by runtime functions.
   enum ResumeMode { NEXT, THROW };
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
 };
 
 
 // Representation for module instance objects.
-class JSModule: public JSObject {
+class JSModule: public JSObject { /* POSTMORTEM */
  public:
   // [context]: the context holding the module's locals, or undefined if none.
   DECL_ACCESSORS(context, Object)
 
   // [scope_info]: Scope info.
   DECL_ACCESSORS(scope_info, ScopeInfo)
 
   DECLARE_CAST(JSModule)
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSModule)
   DECLARE_VERIFIER(JSModule)
 
   // Layout description.
   static const int kContextOffset = JSObject::kHeaderSize;
   static const int kScopeInfoOffset = kContextOffset + kPointerSize;
   static const int kSize = kScopeInfoOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSModule);
 };
 
 
 // JSFunction describes JavaScript functions.
-class JSFunction: public JSObject {
+class JSFunction: public JSObject { /* POSTMORTEM */
  public:
   // [prototype_or_initial_map]:
   DECL_ACCESSORS(prototype_or_initial_map, Object)
 
   // [shared]: The information about the function that
   // can be shared by instances.
   DECL_ACCESSORS(shared, SharedFunctionInfo)
 
   // [context]: The context for this function.
   inline Context* context();
@@ skipping 208 matching lines @@
   static const int kNativeContextOffset = JSObject::kHeaderSize;
   static const int kHashOffset = kNativeContextOffset + kPointerSize;
   static const int kSize = kHashOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
 };
 
 
 // JavaScript global object.
-class JSGlobalObject : public JSObject {
+class JSGlobalObject : public JSObject { /* POSTMORTEM */
  public:
   // [native context]: the natives corresponding to this global object.
   DECL_ACCESSORS(native_context, Context)
 
   // [global proxy]: the global proxy object of the context
   DECL_ACCESSORS(global_proxy, JSObject)
 
 
   static void InvalidatePropertyCell(Handle<JSGlobalObject> object,
                                      Handle<Name> name);
@@ skipping 14 matching lines @@
   static const int kGlobalProxyOffset = kNativeContextOffset + kPointerSize;
   static const int kHeaderSize = kGlobalProxyOffset + kPointerSize;
   static const int kSize = kHeaderSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
 };
 
 
 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
-class JSValue: public JSObject {
+class JSValue: public JSObject { /* POSTMORTEM */
  public:
   // [value]: the object being wrapped.
   DECL_ACCESSORS(value, Object)
 
   DECLARE_CAST(JSValue)
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSValue)
   DECLARE_VERIFIER(JSValue)
 
   // Layout description.
   static const int kValueOffset = JSObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
 };
 
 
 class DateCache;
 
 // Representation for JS date objects.
-class JSDate: public JSObject {
+class JSDate: public JSObject { /* POSTMORTEM */
  public:
   // If one component is NaN, all of them are, indicating a NaN time value.
   // [value]: the time value.
   DECL_ACCESSORS(value, Object)
   // [year]: caches year. Either undefined, smi, or NaN.
   DECL_ACCESSORS(year, Object)
   // [month]: caches month. Either undefined, smi, or NaN.
   DECL_ACCESSORS(month, Object)
   // [day]: caches day. Either undefined, smi, or NaN.
   DECL_ACCESSORS(day, Object)
@@ skipping 78 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
 };
 
 
 // Representation of message objects used for error reporting through
 // the API. The messages are formatted in JavaScript so this object is
 // a real JavaScript object. The information used for formatting the
 // error messages are not directly accessible from JavaScript to
 // prevent leaking information to user code called during error
 // formatting.
-class JSMessageObject: public JSObject {
+class JSMessageObject: public JSObject { /* POSTMORTEM */
  public:
   // [type]: the type of error message.
   inline int type() const;
   inline void set_type(int value);
 
   // [arguments]: the arguments for formatting the error message.
   DECL_ACCESSORS(argument, Object)
 
   // [script]: the script from which the error message originated.
   DECL_ACCESSORS(script, Object)
@@ skipping 39 matching lines @@
 // - reference to the original flag string
 // If it is an atom regexp
 // - a reference to a literal string to search for
 // If it is an irregexp regexp:
 // - a reference to code for Latin1 inputs (bytecode or compiled), or a smi
 // used for tracking the last usage (used for code flushing).
 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
 // used for tracking the last usage (used for code flushing)..
 // - max number of registers used by irregexp implementations.
 // - number of capture registers (output values) of the regexp.
-class JSRegExp: public JSObject {
+class JSRegExp: public JSObject { /* POSTMORTEM */
  public:
   // Meaning of Type:
   // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet.
   // ATOM: A simple string to match against using an indexOf operation.
   // IRREGEXP: Compiled with Irregexp.
   // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
   enum Type { NOT_COMPILED, ATOM, IRREGEXP };
   enum Flag {
     NONE = 0,
     GLOBAL = 1,
@@ skipping 177 matching lines @@
   void Age();
   static const int kHashGenerations = 10;
 
   DECLARE_CAST(CompilationCacheTable)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
 };
 
 
-class CodeCache: public Struct {
+class CodeCache: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(default_cache, FixedArray)
   DECL_ACCESSORS(normal_type_cache, Object)
 
   // Add the code object to the cache.
   static void Update(
       Handle<CodeCache> cache, Handle<Name> name, Handle<Code> code);
 
   // Lookup code object in the cache. Returns code object if found and undefined
   // if not.
@@ skipping 74 matching lines @@
   DECLARE_CAST(CodeCacheHashTable)
 
   // Initial size of the fixed array backing the hash table.
   static const int kInitialSize = 64;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
 };
 
 
-class PolymorphicCodeCache: public Struct {
+class PolymorphicCodeCache: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(cache, Object)
 
   static void Update(Handle<PolymorphicCodeCache> cache,
                      MapHandleList* maps,
                      Code::Flags flags,
                      Handle<Code> code);
 
 
   // Returns an undefined value if the entry is not found.
@@ skipping 27 matching lines @@
       Handle<Code> code);
 
   DECLARE_CAST(PolymorphicCodeCacheHashTable)
 
   static const int kInitialSize = 64;
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCacheHashTable);
 };
 
 
-class TypeFeedbackInfo: public Struct {
+class TypeFeedbackInfo: public Struct { /* POSTMORTEM */
  public:
   inline int ic_total_count();
   inline void set_ic_total_count(int count);
 
   inline int ic_with_type_info_count();
   inline void change_ic_with_type_info_count(int delta);
 
   inline int ic_generic_count();
   inline void change_ic_generic_count(int delta);
 
@@ skipping 34 matching lines @@
 };
 
 
 enum AllocationSiteMode {
   DONT_TRACK_ALLOCATION_SITE,
   TRACK_ALLOCATION_SITE,
   LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
 };
 
 
-class AllocationSite: public Struct {
+class AllocationSite: public Struct { /* POSTMORTEM */
  public:
   static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
   static const double kPretenureRatio;
   static const int kPretenureMinimumCreated = 100;
 
   // Values for pretenure decision field.
   enum PretenureDecision {
     kUndecided = 0,
     kDontTenure = 1,
     kMaybeTenure = 2,
@@ skipping 108 matching lines @@
                               kDependentCodeOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   inline bool PretenuringDecisionMade();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
 };
 
 
-class AllocationMemento: public Struct {
+class AllocationMemento: public Struct { /* POSTMORTEM */
  public:
   static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
   static const int kSize = kAllocationSiteOffset + kPointerSize;
 
   DECL_ACCESSORS(allocation_site, Object)
 
   inline bool IsValid();
   inline AllocationSite* GetAllocationSite();
 
   DECLARE_PRINTER(AllocationMemento)
   DECLARE_VERIFIER(AllocationMemento)
 
   DECLARE_CAST(AllocationMemento)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationMemento);
 };
 
 
 // Representation of a slow alias as part of a sloppy arguments objects.
 // For fast aliases (if HasSloppyArgumentsElements()):
 // - the parameter map contains an index into the context
 // - all attributes of the element have default values
 // For slow aliases (if HasDictionaryArgumentsElements()):
 // - the parameter map contains no fast alias mapping (i.e. the hole)
 // - this struct (in the slow backing store) contains an index into the context
 // - all attributes are available as part if the property details
-class AliasedArgumentsEntry: public Struct {
+class AliasedArgumentsEntry: public Struct { /* POSTMORTEM */
  public:
   inline int aliased_context_slot() const;
   inline void set_aliased_context_slot(int count);
 
   DECLARE_CAST(AliasedArgumentsEntry)
 
   // Dispatched behavior.
   DECLARE_PRINTER(AliasedArgumentsEntry)
   DECLARE_VERIFIER(AliasedArgumentsEntry)
 
@@ skipping 683 matching lines @@
   // truncating the original string.
   MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
                                                  int new_length);
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 
 // The OneByteString class captures sequential one-byte string objects.
 // Each character in the OneByteString is an one-byte character.
-class SeqOneByteString: public SeqString {
+class SeqOneByteString: public SeqString { /* POSTMORTEM */
  public:
   static const bool kHasOneByteEncoding = true;
 
   // Dispatched behavior.
   inline uint16_t SeqOneByteStringGet(int index);
   inline void SeqOneByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
@@ skipping 15 matching lines @@
   static const int kMaxSize = 512 * MB - 1;
   STATIC_ASSERT((kMaxSize - kHeaderSize) >= String::kMaxLength);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqOneByteString);
 };
 
 
 // The TwoByteString class captures sequential unicode string objects.
 // Each character in the TwoByteString is a two-byte uint16_t.
-class SeqTwoByteString: public SeqString {
+class SeqTwoByteString: public SeqString { /* POSTMORTEM */
  public:
   static const bool kHasOneByteEncoding = false;
 
   // Dispatched behavior.
   inline uint16_t SeqTwoByteStringGet(int index);
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
@@ skipping 25 matching lines @@
 
 
 // The ConsString class describes string values built by using the
 // addition operator on strings.  A ConsString is a pair where the
 // first and second components are pointers to other string values.
 // One or both components of a ConsString can be pointers to other
 // ConsStrings, creating a binary tree of ConsStrings where the leaves
 // are non-ConsString string values.  The string value represented by
 // a ConsString can be obtained by concatenating the leaf string
 // values in a left-to-right depth-first traversal of the tree.
-class ConsString: public String {
+class ConsString: public String { /* POSTMORTEM */
  public:
   // First string of the cons cell.
   inline String* first();
   // Doesn't check that the result is a string, even in debug mode.  This is
   // useful during GC where the mark bits confuse the checks.
   inline Object* unchecked_first();
   inline void set_first(String* first,
                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Second string of the cons cell.
@@ skipping 32 matching lines @@
 // a substring.  A Sliced String is described as a pointer to the parent,
 // the offset from the start of the parent string and the length.  Using
 // a Sliced String therefore requires unpacking of the parent string and
 // adding the offset to the start address.  A substring of a Sliced String
 // are not nested since the double indirection is simplified when creating
 // such a substring.
 // Currently missing features are:
 //  - handling externalized parent strings
 //  - external strings as parent
 //  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
-class SlicedString: public String {
+class SlicedString: public String { /* POSTMORTEM */
  public:
   inline String* parent();
   inline void set_parent(String* parent,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
   inline int offset() const;
   inline void set_offset(int offset);
 
   // Dispatched behavior.
   uint16_t SlicedStringGet(int index);
 
@@ skipping 20 matching lines @@
 
 // The ExternalString class describes string values that are backed by
 // a string resource that lies outside the V8 heap.  ExternalStrings
 // consist of the length field common to all strings, a pointer to the
 // external resource.  It is important to ensure (externally) that the
 // resource is not deallocated while the ExternalString is live in the
 // V8 heap.
 //
 // The API expects that all ExternalStrings are created through the
 // API.  Therefore, ExternalStrings should not be used internally.
-class ExternalString: public String {
+class ExternalString: public String { /* POSTMORTEM */
  public:
   DECLARE_CAST(ExternalString)
 
   // Layout description.
   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kShortSize = kResourceOffset + kPointerSize;
   static const int kResourceDataOffset = kResourceOffset + kPointerSize;
   static const int kSize = kResourceDataOffset + kPointerSize;
 
   static const int kMaxShortLength =
@@ skipping 40 matching lines @@
   template <typename StaticVisitor>
   inline void ExternalOneByteStringIterateBody();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalOneByteString);
 };
 
 
 // The ExternalTwoByteString class is an external string backed by a UTF-16
 // encoded string.
-class ExternalTwoByteString: public ExternalString {
+class ExternalTwoByteString: public ExternalString { /* POSTMORTEM */
  public:
   static const bool kHasOneByteEncoding = false;
 
   typedef v8::String::ExternalStringResource Resource;
 
   // The underlying string resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Update the pointer cache to the external character array.
@@ skipping 146 matching lines @@
   explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
   T GetNext() { return data_[index_++]; }
   bool has_more() { return index_ < data_.length(); }
  private:
   Vector<const T> data_;
   int index_;
 };
 
 
 // The Oddball describes objects null, undefined, true, and false.
-class Oddball: public HeapObject {
+class Oddball: public HeapObject { /* POSTMORTEM */
  public:
   // [to_string]: Cached to_string computed at startup.
   DECL_ACCESSORS(to_string, String)
 
   // [to_number]: Cached to_number computed at startup.
   DECL_ACCESSORS(to_number, Object)
 
   // [typeof]: Cached type_of computed at startup.
   DECL_ACCESSORS(type_of, String)
 
@@ skipping 36 matching lines @@
 
   STATIC_ASSERT(kKindOffset == Internals::kOddballKindOffset);
   STATIC_ASSERT(kNull == Internals::kNullOddballKind);
   STATIC_ASSERT(kUndefined == Internals::kUndefinedOddballKind);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
 };
 
 
-class Cell: public HeapObject {
+class Cell: public HeapObject { /* POSTMORTEM */
  public:
   // [value]: value of the cell.
   DECL_ACCESSORS(value, Object)
 
   DECLARE_CAST(Cell)
 
   static inline Cell* FromValueAddress(Address value) {
     Object* result = FromAddress(value - kValueOffset);
     return static_cast<Cell*>(result);
   }
@@ skipping 101 matching lines @@
   static const int kSize = kNextOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
 };
 
 
 // The JSProxy describes EcmaScript Harmony proxies
-class JSProxy: public JSReceiver {
+class JSProxy: public JSReceiver { /* POSTMORTEM */
  public:
   // [handler]: The handler property.
   DECL_ACCESSORS(handler, Object)
 
   // [hash]: The hash code property (undefined if not initialized yet).
   DECL_ACCESSORS(hash, Object)
 
   DECLARE_CAST(JSProxy)
 
   MUST_USE_RESULT static MaybeHandle<Object> GetPropertyWithHandler(
@@ skipping 64 matching lines @@
       Handle<JSProxy> proxy, Handle<Name> name, LanguageMode language_mode);
 
   MUST_USE_RESULT Object* GetIdentityHash();
 
   static Handle<Smi> GetOrCreateIdentityHash(Handle<JSProxy> proxy);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSProxy);
 };
 
 
-class JSFunctionProxy: public JSProxy {
+class JSFunctionProxy: public JSProxy { /* POSTMORTEM */
  public:
   // [call_trap]: The call trap.
   DECL_ACCESSORS(call_trap, JSReceiver)
 
   // [construct_trap]: The construct trap.
   DECL_ACCESSORS(construct_trap, Object)
 
   DECLARE_CAST(JSFunctionProxy)
 
   // Dispatched behavior.
@@ skipping 11 matching lines @@
 
   typedef FixedBodyDescriptor<kHandlerOffset,
                               kConstructTrapOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
 };
 
 
-class JSCollection : public JSObject {
+class JSCollection : public JSObject { /* POSTMORTEM */
  public:
   // [table]: the backing hash table
   DECL_ACCESSORS(table, Object)
 
   static const int kTableOffset = JSObject::kHeaderSize;
   static const int kSize = kTableOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSCollection);
 };
 
 
 // The JSSet describes EcmaScript Harmony sets
-class JSSet : public JSCollection {
+class JSSet : public JSCollection { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSSet)
 
   static void Initialize(Handle<JSSet> set, Isolate* isolate);
   static void Clear(Handle<JSSet> set);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSSet)
   DECLARE_VERIFIER(JSSet)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
 };
 
 
 // The JSMap describes EcmaScript Harmony maps
-class JSMap : public JSCollection {
+class JSMap : public JSCollection { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSMap)
 
   static void Initialize(Handle<JSMap> map, Isolate* isolate);
   static void Clear(Handle<JSMap> map);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSMap)
   DECLARE_VERIFIER(JSMap)
 
@@ skipping 136 matching lines @@
   // Indices of in-object properties.
   static const int kValueIndex = 0;
   static const int kDoneIndex = 1;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSIteratorResult);
 };
 
 
 // Base class for both JSWeakMap and JSWeakSet
-class JSWeakCollection: public JSObject {
+class JSWeakCollection: public JSObject { /* POSTMORTEM */
  public:
   // [table]: the backing hash table mapping keys to values.
   DECL_ACCESSORS(table, Object)
 
   // [next]: linked list of encountered weak maps during GC.
   DECL_ACCESSORS(next, Object)
 
   static void Initialize(Handle<JSWeakCollection> collection, Isolate* isolate);
   static void Set(Handle<JSWeakCollection> collection, Handle<Object> key,
                   Handle<Object> value, int32_t hash);
   static bool Delete(Handle<JSWeakCollection> collection, Handle<Object> key,
                      int32_t hash);
 
   static const int kTableOffset = JSObject::kHeaderSize;
   static const int kNextOffset = kTableOffset + kPointerSize;
   static const int kSize = kNextOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
 };
 
 
 // The JSWeakMap describes EcmaScript Harmony weak maps
-class JSWeakMap: public JSWeakCollection {
+class JSWeakMap: public JSWeakCollection { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSWeakMap)
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSWeakMap)
   DECLARE_VERIFIER(JSWeakMap)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
 };
 
 
 // The JSWeakSet describes EcmaScript Harmony weak sets
-class JSWeakSet: public JSWeakCollection {
+class JSWeakSet: public JSWeakCollection { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSWeakSet)
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSWeakSet)
   DECLARE_VERIFIER(JSWeakSet)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
 };
 
 
 // Whether a JSArrayBuffer is a SharedArrayBuffer or not.
 enum class SharedFlag { kNotShared, kShared };
 
 
-class JSArrayBuffer: public JSObject {
+class JSArrayBuffer: public JSObject { /* POSTMORTEM */
  public:
   // [backing_store]: backing memory for this array
   DECL_ACCESSORS(backing_store, void)
 
   // [byte_length]: length in bytes
   DECL_ACCESSORS(byte_length, Object)
 
   inline uint32_t bit_field() const;
   inline void set_bit_field(uint32_t bits);
 
@@ skipping 53 matching lines @@
   class IsExternal : public BitField<bool, 1, 1> {};
   class IsNeuterable : public BitField<bool, 2, 1> {};
   class WasNeutered : public BitField<bool, 3, 1> {};
   class IsShared : public BitField<bool, 4, 1> {};
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
 };
 
 
-class JSArrayBufferView: public JSObject {
+class JSArrayBufferView: public JSObject { /* POSTMORTEM */
  public:
   // [buffer]: ArrayBuffer that this typed array views.
   DECL_ACCESSORS(buffer, Object)
 
   // [byte_offset]: offset of typed array in bytes.
   DECL_ACCESSORS(byte_offset, Object)
 
   // [byte_length]: length of typed array in bytes.
   DECL_ACCESSORS(byte_length, Object)
 
@@ skipping 11 matching lines @@
  private:
 #ifdef VERIFY_HEAP
   DECL_ACCESSORS(raw_byte_offset, Object)
   DECL_ACCESSORS(raw_byte_length, Object)
 #endif
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
 };
 
 
-class JSTypedArray: public JSArrayBufferView {
+class JSTypedArray: public JSArrayBufferView { /* POSTMORTEM */
  public:
   // [length]: length of typed array in elements.
   DECL_ACCESSORS(length, Object)
   inline uint32_t length_value() const;
 
   DECLARE_CAST(JSTypedArray)
 
   ExternalArrayType type();
   size_t element_size();
 
@@ skipping 13 matching lines @@
   static Handle<JSArrayBuffer> MaterializeArrayBuffer(
       Handle<JSTypedArray> typed_array);
 #ifdef VERIFY_HEAP
   DECL_ACCESSORS(raw_length, Object)
 #endif
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
 };
 
 
-class JSDataView: public JSArrayBufferView {
+class JSDataView: public JSArrayBufferView { /* POSTMORTEM */
  public:
   DECLARE_CAST(JSDataView)
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSDataView)
   DECLARE_VERIFIER(JSDataView)
 
   static const int kSize = kViewSize;
 
   static const int kSizeWithInternalFields =
       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
 };
 
 
 // Foreign describes objects pointing from JavaScript to C structures.
-class Foreign: public HeapObject {
+class Foreign: public HeapObject { /* POSTMORTEM */
  public:
   // [address]: field containing the address.
   inline Address foreign_address();
   inline void set_foreign_address(Address value);
 
   DECLARE_CAST(Foreign)
 
   // Dispatched behavior.
   inline void ForeignIterateBody(ObjectVisitor* v);
 
@@ skipping 14 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign);
 };
 
 
 // The JSArray describes JavaScript Arrays
 //  Such an array can be in one of two modes:
 //    - fast, backing storage is a FixedArray and length <= elements.length();
 //       Please note: push and pop can be used to grow and shrink the array.
 //    - slow, backing storage is a HashTable with numbers as keys.
-class JSArray: public JSObject {
+class JSArray: public JSObject { /* POSTMORTEM */
  public:
   // [length]: The length property.
   DECL_ACCESSORS(length, Object)
 
   // Overload the length setter to skip write barrier when the length
   // is set to a smi. This matches the set function on FixedArray.
   inline void set_length(Smi* length);
 
   static bool HasReadOnlyLength(Handle<JSArray> array);
   static bool WouldChangeReadOnlyLength(Handle<JSArray> array, uint32_t index);
@@ skipping 60 matching lines @@
 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
                                        Handle<Map> initial_map);
 
 
 // JSRegExpResult is just a JSArray with a specific initial map.
 // This initial map adds in-object properties for "index" and "input"
 // properties, as assigned by RegExp.prototype.exec, which allows
 // faster creation of RegExp exec results.
 // This class just holds constants used when creating the result.
 // After creation the result must be treated as a JSArray in all regards.
-class JSRegExpResult: public JSArray {
+class JSRegExpResult: public JSArray { /* POSTMORTEM */
  public:
   // Offsets of object fields.
   static const int kIndexOffset = JSArray::kSize;
   static const int kInputOffset = kIndexOffset + kPointerSize;
   static const int kSize = kInputOffset + kPointerSize;
   // Indices of in-object properties.
   static const int kIndexIndex = 0;
   static const int kInputIndex = 1;
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSRegExpResult);
@@ skipping 55 matching lines @@
 
 // An accessor must have a getter, but can have no setter.
 //
 // When setting a property, V8 searches accessors in prototypes.
 // If an accessor was found and it does not have a setter,
 // the request is ignored.
 //
 // If the accessor in the prototype has the READ_ONLY property attribute, then
 // a new value is added to the derived object when the property is set.
 // This shadows the accessor in the prototype.
-class ExecutableAccessorInfo: public AccessorInfo {
+class ExecutableAccessorInfo: public AccessorInfo { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
   DECL_ACCESSORS(data, Object)
 
   DECLARE_CAST(ExecutableAccessorInfo)
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExecutableAccessorInfo)
   DECLARE_VERIFIER(ExecutableAccessorInfo)
 
   static const int kGetterOffset = AccessorInfo::kSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kDataOffset = kSetterOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
   static void ClearSetter(Handle<ExecutableAccessorInfo> info);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExecutableAccessorInfo);
 };
 
 
 // Support for JavaScript accessors: A pair of a getter and a setter. Each
 // accessor can either be
 //   * a pointer to a JavaScript function or proxy: a real accessor
 //   * undefined: considered an accessor by the spec, too, strangely enough
 //   * the hole: an accessor which has not been set
 //   * a pointer to a map: a transition used to ensure map sharing
-class AccessorPair: public Struct {
+class AccessorPair: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
 
   DECLARE_CAST(AccessorPair)
 
   static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
 
   inline Object* get(AccessorComponent component);
   inline void set(AccessorComponent component, Object* value);
@@ skipping 22 matching lines @@
   // requires us to consider undefined as a kind of accessor, too:
   //    var obj = {};
   //    Object.defineProperty(obj, "foo", {get: undefined});
   //    assertTrue("foo" in obj);
   inline bool IsJSAccessor(Object* obj);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
 };
 
 
-class AccessCheckInfo: public Struct {
+class AccessCheckInfo: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(named_callback, Object)
   DECL_ACCESSORS(indexed_callback, Object)
   DECL_ACCESSORS(callback, Object)
   DECL_ACCESSORS(data, Object)
 
   DECLARE_CAST(AccessCheckInfo)
 
   // Dispatched behavior.
   DECLARE_PRINTER(AccessCheckInfo)
   DECLARE_VERIFIER(AccessCheckInfo)
 
   static const int kNamedCallbackOffset   = HeapObject::kHeaderSize;
   static const int kIndexedCallbackOffset = kNamedCallbackOffset + kPointerSize;
   static const int kCallbackOffset = kIndexedCallbackOffset + kPointerSize;
   static const int kDataOffset = kCallbackOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessCheckInfo);
 };
 
 
-class InterceptorInfo: public Struct {
+class InterceptorInfo: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
   DECL_ACCESSORS(query, Object)
   DECL_ACCESSORS(deleter, Object)
   DECL_ACCESSORS(enumerator, Object)
   DECL_ACCESSORS(data, Object)
   DECL_BOOLEAN_ACCESSORS(can_intercept_symbols)
   DECL_BOOLEAN_ACCESSORS(all_can_read)
   DECL_BOOLEAN_ACCESSORS(non_masking)
@@ skipping 18 matching lines @@
 
   static const int kCanInterceptSymbolsBit = 0;
   static const int kAllCanReadBit = 1;
   static const int kNonMasking = 2;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
 };
 
 
-class CallHandlerInfo: public Struct {
+class CallHandlerInfo: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(callback, Object)
   DECL_ACCESSORS(data, Object)
 
   DECLARE_CAST(CallHandlerInfo)
 
   // Dispatched behavior.
   DECLARE_PRINTER(CallHandlerInfo)
   DECLARE_VERIFIER(CallHandlerInfo)
 
@@ skipping 23 matching lines @@
       kPropertyListOffset + kPointerSize;
   static const int kPropertyIntrinsicsOffset =
       kPropertyAccessorsOffset + kPointerSize;
   static const int kHeaderSize = kPropertyIntrinsicsOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
 };
 
 
-class FunctionTemplateInfo: public TemplateInfo {
+class FunctionTemplateInfo: public TemplateInfo { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(serial_number, Object)
   DECL_ACCESSORS(call_code, Object)
   DECL_ACCESSORS(prototype_template, Object)
   DECL_ACCESSORS(parent_template, Object)
   DECL_ACCESSORS(named_property_handler, Object)
   DECL_ACCESSORS(indexed_property_handler, Object)
   DECL_ACCESSORS(instance_template, Object)
   DECL_ACCESSORS(class_name, Object)
   DECL_ACCESSORS(signature, Object)
@@ skipping 59 matching lines @@
   static const int kReadOnlyPrototypeBit = 3;
   static const int kRemovePrototypeBit   = 4;
   static const int kDoNotCacheBit        = 5;
   static const int kInstantiatedBit      = 6;
   static const int kAcceptAnyReceiver = 7;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
 };
 
 
-class ObjectTemplateInfo: public TemplateInfo {
+class ObjectTemplateInfo: public TemplateInfo { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(constructor, Object)
   DECL_ACCESSORS(internal_field_count, Object)
 
   DECLARE_CAST(ObjectTemplateInfo)
 
   // Dispatched behavior.
   DECLARE_PRINTER(ObjectTemplateInfo)
   DECLARE_VERIFIER(ObjectTemplateInfo)
 
   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
   static const int kInternalFieldCountOffset =
       kConstructorOffset + kPointerSize;
   static const int kSize = kInternalFieldCountOffset + kPointerSize;
 };
 
 
-class TypeSwitchInfo: public Struct {
+class TypeSwitchInfo: public Struct { /* POSTMORTEM */
  public:
   DECL_ACCESSORS(types, Object)
 
   DECLARE_CAST(TypeSwitchInfo)
 
   // Dispatched behavior.
   DECLARE_PRINTER(TypeSwitchInfo)
   DECLARE_VERIFIER(TypeSwitchInfo)
 
   static const int kTypesOffset = Struct::kHeaderSize;
   static const int kSize        = kTypesOffset + kPointerSize;
 };
 
 
 // The DebugInfo class holds additional information for a function being
 // debugged.
-class DebugInfo: public Struct {
+class DebugInfo: public Struct { /* POSTMORTEM */
  public:
   // The shared function info for the source being debugged.
   DECL_ACCESSORS(shared, SharedFunctionInfo)
   // Code object for the patched code. This code object is the code object
   // currently active for the function.
   DECL_ACCESSORS(code, Code)
   // Fixed array holding status information for each active break point.
   DECL_ACCESSORS(break_points, FixedArray)
 
   // Check if there is a break point at a code position.
@@ skipping 35 matching lines @@
   // Lookup the index in the break_points array for a code position.
   int GetBreakPointInfoIndex(int code_position);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
 };
 
 
 // The BreakPointInfo class holds information for break points set in a
 // function. The DebugInfo object holds a BreakPointInfo object for each code
 // position with one or more break points.
-class BreakPointInfo: public Struct {
+class BreakPointInfo: public Struct { /* POSTMORTEM */
  public:
   // The position in the code for the break point.
   DECL_INT_ACCESSORS(code_position)
   // The position in the source for the break position.
   DECL_INT_ACCESSORS(source_position)
   // The position in the source for the last statement before this break
   // position.
   DECL_INT_ACCESSORS(statement_position)
   // List of related JavaScript break points.
   DECL_ACCESSORS(break_point_objects, Object)
@@ skipping 149 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_