postmortem: export private field offsets

tools/gen-postmortem-metadata.py

 #!/usr/bin/env python
 
 #
 # Copyright 2012 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.
@@ skipping 163 matching lines @@
 
     { 'name': 'sharedfunctioninfo_start_position_mask',
         'value': 'SharedFunctionInfo::kStartPositionMask' },
     { 'name': 'sharedfunctioninfo_start_position_shift',
         'value': 'SharedFunctionInfo::kStartPositionShift' },
 
     { 'name': 'jsarray_buffer_was_neutered_mask',
         'value': 'JSArrayBuffer::WasNeutered::kMask' },
     { 'name': 'jsarray_buffer_was_neutered_shift',
         'value': 'JSArrayBuffer::WasNeutered::kShift' },
+
+    { 'name': 'new_space',
+        'value': 'AllocationSpace::NEW_SPACE' },
+    { 'name': 'old_space',
+        'value': 'AllocationSpace::OLD_SPACE' },
+    { 'name': 'code_space',
+        'value': 'AllocationSpace::CODE_SPACE' },
+    { 'name': 'map_space',
+        'value': 'AllocationSpace::MAP_SPACE' },
+    { 'name': 'lo_space',
+        'value': 'AllocationSpace::LO_SPACE' },
+    { 'name': 'first_space',
+        'value': 'AllocationSpace::FIRST_SPACE' },
+    { 'name': 'last_space',
+        'value': 'AllocationSpace::LAST_SPACE' },
+    { 'name': 'first_paged_space',
+        'value': 'AllocationSpace::FIRST_PAGED_SPACE' },
+    { 'name': 'last_paged_space',
+        'value': 'AllocationSpace::LAST_PAGED_SPACE' },
 ];
 
 #
 # The following useful fields are missing accessors, so we define fake ones.
 #
 extras_accessors = [
     'JSFunction, context, Context, kContextOffset',
     'Context, closure_index, int, CLOSURE_INDEX',
     'Context, global_object_index, int, GLOBAL_OBJECT_INDEX',
     'Context, previous_index, int, PREVIOUS_INDEX',
@@ skipping 22 matching lines @@
     'ConsString, first, String, kFirstOffset',
     'ConsString, second, String, kSecondOffset',
     'ExternalString, resource, Object, kResourceOffset',
     'SeqOneByteString, chars, char, kHeaderSize',
     'SeqTwoByteString, chars, char, kHeaderSize',
     'SharedFunctionInfo, code, Code, kCodeOffset',
     'SharedFunctionInfo, scope_info, ScopeInfo, kScopeInfoOffset',
     'SlicedString, parent, String, kParentOffset',
     'Code, instruction_start, uintptr_t, kHeaderSize',
     'Code, instruction_size, int, kInstructionSizeOffset',
+    'Heap, root_count, int, kRootListLength',
 ];
 
 #
 # The following is a whitelist of classes we expect to find when scanning the
 # source code. This list is not exhaustive, but it's still useful to identify
 # when this script gets out of sync with the source. See load_objects().
 #
 expected_classes = [
     'ConsString', 'FixedArray', 'HeapNumber', 'JSArray', 'JSFunction',
     'JSObject', 'JSRegExp', 'JSValue', 'Map', 'Oddball', 'Script',
     'SeqOneByteString', 'SharedFunctionInfo'
 ];
 
 
+private_fields = [
+    { 'class': 'Isolate', 'field': 'heap_' },
+
+    { 'class': 'Heap', 'field': 'amount_of_external_allocated_memory_' },
+    { 'class': 'Heap', 'field': 'roots_' },
+    { 'class': 'Heap', 'field': 'new_space_' },
+    { 'class': 'Heap', 'field': 'old_space_' },
+    { 'class': 'Heap', 'field': 'code_space_' },
+    { 'class': 'Heap', 'field': 'map_space_' },
+    { 'class': 'Heap', 'field': 'lo_space_' },
+
+    { 'class': 'NewSpace', 'field': 'heap_' },
+    { 'class': 'NewSpace', 'field': 'id_' },
+    { 'class': 'NewSpace', 'field': 'executable_' },
+    { 'class': 'NewSpace', 'field': 'to_space_' },
+    { 'class': 'NewSpace', 'field': 'from_space_' },
+    { 'class': 'NewSpace', 'field': 'pages_used_' },
+
+    { 'class': 'SemiSpace', 'field': 'heap_' },
+    { 'class': 'SemiSpace', 'field': 'id_' },
+    { 'class': 'SemiSpace', 'field': 'executable_' },
+    { 'class': 'SemiSpace', 'field': 'anchor_' },
+    { 'class': 'SemiSpace', 'field': 'current_page_' },
+    { 'class': 'SemiSpace', 'field': 'committed_' },
+
+    { 'class': 'OldSpace', 'field': 'heap_' },
+    { 'class': 'OldSpace', 'field': 'id_' },
+    { 'class': 'OldSpace', 'field': 'executable_' },
+    { 'class': 'OldSpace', 'field': 'anchor_' },
+
+    { 'class': 'MapSpace', 'field': 'heap_' },
+    { 'class': 'MapSpace', 'field': 'id_' },
+    { 'class': 'MapSpace', 'field': 'executable_' },
+    { 'class': 'MapSpace', 'field': 'anchor_' },
+
+    { 'class': 'LargeObjectSpace', 'field': 'heap_' },
+    { 'class': 'LargeObjectSpace', 'field': 'id_' },
+    { 'class': 'LargeObjectSpace', 'field': 'executable_' },
+    { 'class': 'LargeObjectSpace', 'field': 'size_' },
+    { 'class': 'LargeObjectSpace', 'field': 'objects_size_' },
+    { 'class': 'LargeObjectSpace', 'field': 'first_page_' },
+
+    { 'class': 'Page', 'field': 'size_' },
+    { 'class': 'Page', 'field': 'area_start_' },
+    { 'class': 'Page', 'field': 'area_end_' },
+    { 'class': 'Page', 'field': 'prev_chunk_' },
+    { 'class': 'Page', 'field': 'next_chunk_' },
+
+    { 'class': 'NewSpacePage', 'field': 'size_' },
+    { 'class': 'NewSpacePage', 'field': 'area_start_' },
+    { 'class': 'NewSpacePage', 'field': 'area_end_' },
+    { 'class': 'NewSpacePage', 'field': 'prev_chunk_' },
+    { 'class': 'NewSpacePage', 'field': 'next_chunk_' },
+
+    { 'class': 'LargePage', 'field': 'size_' },
+    { 'class': 'LargePage', 'field': 'area_start_' },
+    { 'class': 'LargePage', 'field': 'area_end_' },
+    { 'class': 'LargePage', 'field': 'prev_chunk_' },
+    { 'class': 'LargePage', 'field': 'next_chunk_' },
+];
+
 #
 # The following structures store high-level representations of the structures
 # for which we're going to emit descriptive constants.
 #
 types = {};             # set of all type names
 typeclasses = {};       # maps type names to corresponding class names
 klasses = {};           # known classes, including parents
 fields = [];            # field declarations
 
 header = '''
@@ skipping 281 matching lines @@
         # Fix up overzealous parses.  This could be done inside the
         # parsers but as there are several, it's easiest to do it here.
         ws = re.compile('\s+')
         for const in consts:
                 name = ws.sub('', const['name'])
                 value = ws.sub('', str(const['value']))  # Can be a number.
                 out.write('int v8dbg_%s = %s;\n' % (name, value))
         out.write('\n');
 
 #
+# Emit private fields class and values
+#
+def emit_private_fields(out, fields, consts):
+        # Fix up overzealous parses.  This could be done inside the
+        # parsers but as there are several, it's easiest to do it here.
+        ws = re.compile('\s+')
+        out.write('namespace v8 {\n');
+        out.write('namespace internal {\n\n');
+        out.write('class PostMortem {\n');
+        out.write(' public:\n');
+        for field in fields:
+                klass = ws.sub('', field['class'])
+                field = ws.sub('', field['field'])
+                out.write('  static const int k%s__%s = offsetof(%s, %s);\n' %
+                        (klass, field, klass, field));
+                consts.append({
+                    'name': 'field_%s__%s' % (klass, field),
+                    'value': 'v8::internal::PostMortem::k%s__%s' %
+                        (klass, field)
+                });
+        out.write('};\n');
+        out.write('}  // namespace internal\n');
+        out.write('}  // namespace v8\n\n');
+
+#
 # Emit the whole output file.
 #
 def emit_config():
         out = file(sys.argv[1], 'w');
 
         out.write(header);
 
         out.write('/* miscellaneous constants */\n');
         emit_set(out, consts_misc);
 
@@ skipping 22 matching lines @@
                 consts.append({
                     'name': 'parent_%s__%s' % (klassname, pklass),
                     'value': 0
                 });
 
         emit_set(out, consts);
 
         out.write('/* field information */\n');
         emit_set(out, fields);
 
+        out.write('/* private fields */\n');
+        consts = []
+        emit_private_fields(out, private_fields, consts);
+
+        emit_set(out, consts);
+
         out.write(footer);
 
 if (len(sys.argv) < 4):
         print('usage: %s output.cc objects.h objects-inl.h' % sys.argv[0]);
         sys.exit(2);
 
 load_objects();
 load_fields();
 emit_config();