Fix several minor issues with grokdump.py tool.

tools/grokdump.py

 #!/usr/bin/env python
 #
 # 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
@@ skipping 505 matching lines @@
 # };
 # static P p;
 INSTANCE_TYPES = {
   64: "SYMBOL_TYPE",
   68: "ASCII_SYMBOL_TYPE",
   65: "CONS_SYMBOL_TYPE",
   69: "CONS_ASCII_SYMBOL_TYPE",
   66: "EXTERNAL_SYMBOL_TYPE",
   74: "EXTERNAL_SYMBOL_WITH_ASCII_DATA_TYPE",
   70: "EXTERNAL_ASCII_SYMBOL_TYPE",
+  82: "SHORT_EXTERNAL_SYMBOL_TYPE",
+  90: "SHORT_EXTERNAL_SYMBOL_WITH_ASCII_DATA_TYPE",
+  86: "SHORT_EXTERNAL_ASCII_SYMBOL_TYPE",
   0: "STRING_TYPE",
   4: "ASCII_STRING_TYPE",
   1: "CONS_STRING_TYPE",
   5: "CONS_ASCII_STRING_TYPE",
+  3: "SLICED_STRING_TYPE",
   2: "EXTERNAL_STRING_TYPE",
   10: "EXTERNAL_STRING_WITH_ASCII_DATA_TYPE",
   6: "EXTERNAL_ASCII_STRING_TYPE",
+  18: "SHORT_EXTERNAL_STRING_TYPE",
+  26: "SHORT_EXTERNAL_STRING_WITH_ASCII_DATA_TYPE",
+  22: "SHORT_EXTERNAL_ASCII_STRING_TYPE",
   6: "PRIVATE_EXTERNAL_ASCII_STRING_TYPE",
   128: "MAP_TYPE",
   129: "CODE_TYPE",
   130: "ODDBALL_TYPE",
   131: "JS_GLOBAL_PROPERTY_CELL_TYPE",
   132: "HEAP_NUMBER_TYPE",
   133: "FOREIGN_TYPE",
   134: "BYTE_ARRAY_TYPE",
-  135: "EXTERNAL_BYTE_ARRAY_TYPE",
-  136: "EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE",
-  137: "EXTERNAL_SHORT_ARRAY_TYPE",
-  138: "EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE",
-  139: "EXTERNAL_INT_ARRAY_TYPE",
-  140: "EXTERNAL_UNSIGNED_INT_ARRAY_TYPE",
-  141: "EXTERNAL_FLOAT_ARRAY_TYPE",
-  143: "EXTERNAL_PIXEL_ARRAY_TYPE",
-  145: "FILLER_TYPE",
-  146: "ACCESSOR_INFO_TYPE",
-  147: "ACCESS_CHECK_INFO_TYPE",
-  148: "INTERCEPTOR_INFO_TYPE",
-  149: "CALL_HANDLER_INFO_TYPE",
-  150: "FUNCTION_TEMPLATE_INFO_TYPE",
-  151: "OBJECT_TEMPLATE_INFO_TYPE",
-  152: "SIGNATURE_INFO_TYPE",
-  153: "TYPE_SWITCH_INFO_TYPE",
-  154: "SCRIPT_TYPE",
-  155: "CODE_CACHE_TYPE",
-  156: "POLYMORPHIC_CODE_CACHE_TYPE",
-  159: "FIXED_ARRAY_TYPE",
-  160: "SHARED_FUNCTION_INFO_TYPE",
-  161: "JS_MESSAGE_OBJECT_TYPE",
-  162: "JS_VALUE_TYPE",
-  163: "JS_OBJECT_TYPE",
-  164: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
-  165: "JS_GLOBAL_OBJECT_TYPE",
-  166: "JS_BUILTINS_OBJECT_TYPE",
-  167: "JS_GLOBAL_PROXY_TYPE",
-  168: "JS_ARRAY_TYPE",
-  169: "JS_PROXY_TYPE",
-  170: "JS_WEAK_MAP_TYPE",
-  171: "JS_REGEXP_TYPE",
-  172: "JS_FUNCTION_TYPE",
-  173: "JS_FUNCTION_PROXY_TYPE",
-  157: "DEBUG_INFO_TYPE",
-  158: "BREAK_POINT_INFO_TYPE",
+  135: "FREE_SPACE_TYPE",
+  136: "EXTERNAL_BYTE_ARRAY_TYPE",
+  137: "EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE",
+  138: "EXTERNAL_SHORT_ARRAY_TYPE",
+  139: "EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE",
+  140: "EXTERNAL_INT_ARRAY_TYPE",
+  141: "EXTERNAL_UNSIGNED_INT_ARRAY_TYPE",
+  142: "EXTERNAL_FLOAT_ARRAY_TYPE",
+  144: "EXTERNAL_PIXEL_ARRAY_TYPE",
+  146: "FILLER_TYPE",
+  147: "ACCESSOR_INFO_TYPE",
+  148: "ACCESS_CHECK_INFO_TYPE",
+  149: "INTERCEPTOR_INFO_TYPE",
+  150: "CALL_HANDLER_INFO_TYPE",
+  151: "FUNCTION_TEMPLATE_INFO_TYPE",
+  152: "OBJECT_TEMPLATE_INFO_TYPE",
+  153: "SIGNATURE_INFO_TYPE",
+  154: "TYPE_SWITCH_INFO_TYPE",
+  155: "SCRIPT_TYPE",
+  156: "CODE_CACHE_TYPE",
+  157: "POLYMORPHIC_CODE_CACHE_TYPE",
+  160: "FIXED_ARRAY_TYPE",
+  145: "FIXED_DOUBLE_ARRAY_TYPE",
+  161: "SHARED_FUNCTION_INFO_TYPE",
+  162: "JS_MESSAGE_OBJECT_TYPE",
+  165: "JS_VALUE_TYPE",
+  166: "JS_OBJECT_TYPE",
+  167: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
+  168: "JS_GLOBAL_OBJECT_TYPE",
+  169: "JS_BUILTINS_OBJECT_TYPE",
+  170: "JS_GLOBAL_PROXY_TYPE",
+  171: "JS_ARRAY_TYPE",
+  164: "JS_PROXY_TYPE",
+  174: "JS_WEAK_MAP_TYPE",
+  175: "JS_REGEXP_TYPE",
+  176: "JS_FUNCTION_TYPE",
+  163: "JS_FUNCTION_PROXY_TYPE",
+  158: "DEBUG_INFO_TYPE",
+  159: "BREAK_POINT_INFO_TYPE",
 }
 
 
 class Printer(object):
   """Printer with indentation support."""
 
   def __init__(self):
     self.indent = 0
 
   def Indent(self):
@@ skipping 57 matching lines @@
     field_value = self.heap.reader.ReadUIntPtr(self.address + offset)
     return self.heap.FindObjectOrSmi(field_value)
 
   def SmiField(self, offset):
     field_value = self.heap.reader.ReadUIntPtr(self.address + offset)
     assert (field_value & 1) == 0
     return field_value / 2
 
 
 class Map(HeapObject):
-  def InstanceTypeOffset():
+  def InstanceTypeOffset(self):
     return self.heap.PointerSize() + self.heap.IntSize()
 
   def __init__(self, heap, map, address):
     HeapObject.__init__(self, heap, map, address)
     self.instance_type = \
         heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
 
 
 class String(HeapObject):
   def LengthOffset(self):
@@ skipping 213 matching lines @@
 class Code(HeapObject):
   CODE_ALIGNMENT_MASK = (1 << 5) - 1
 
   def InstructionSizeOffset(self):
     return self.heap.PointerSize()
 
   @staticmethod
   def HeaderSize(heap):
     return (heap.PointerSize() + heap.IntSize() + \
         4 * heap.PointerSize() + 3 * heap.IntSize() + \
-        CODE_ALIGNMENT_MASK) & ~CODE_ALIGNMENT_MASK
+        Code.CODE_ALIGNMENT_MASK) & ~Code.CODE_ALIGNMENT_MASK
 
   def __init__(self, heap, map, address):
     HeapObject.__init__(self, heap, map, address)
     self.entry = self.address + Code.HeaderSize(heap)
     self.instruction_size = \
         heap.reader.ReadU32(self.address + self.InstructionSizeOffset())
 
   def Print(self, p):
     lines = self.heap.reader.GetDisasmLines(self.entry, self.instruction_size)
     p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
     p.Indent()
     p.Print("instruction_size: %d" % self.instruction_size)
     p.PrintLines(self._FormatLine(line) for line in lines)
     p.Dedent()
     p.Print("}")
 
   def _FormatLine(self, line):
     return FormatDisasmLine(self.entry, self.heap, line)
 
 
 class V8Heap(object):
   CLASS_MAP = {
     "SYMBOL_TYPE": SeqString,
     "ASCII_SYMBOL_TYPE": SeqString,
     "CONS_SYMBOL_TYPE": ConsString,
     "CONS_ASCII_SYMBOL_TYPE": ConsString,
     "EXTERNAL_SYMBOL_TYPE": ExternalString,
     "EXTERNAL_SYMBOL_WITH_ASCII_DATA_TYPE": ExternalString,
     "EXTERNAL_ASCII_SYMBOL_TYPE": ExternalString,
+    "SHORT_EXTERNAL_SYMBOL_TYPE": ExternalString,
+    "SHORT_EXTERNAL_SYMBOL_WITH_ASCII_DATA_TYPE": ExternalString,
+    "SHORT_EXTERNAL_ASCII_SYMBOL_TYPE": ExternalString,
     "STRING_TYPE": SeqString,
     "ASCII_STRING_TYPE": SeqString,
     "CONS_STRING_TYPE": ConsString,
     "CONS_ASCII_STRING_TYPE": ConsString,
     "EXTERNAL_STRING_TYPE": ExternalString,
     "EXTERNAL_STRING_WITH_ASCII_DATA_TYPE": ExternalString,
     "EXTERNAL_ASCII_STRING_TYPE": ExternalString,
 
     "MAP_TYPE": Map,
     "ODDBALL_TYPE": Oddball,
     "FIXED_ARRAY_TYPE": FixedArray,
     "JS_FUNCTION_TYPE": JSFunction,
     "SHARED_FUNCTION_INFO_TYPE": SharedFunctionInfo,
     "SCRIPT_TYPE": Script,
     "CODE_TYPE": Code
   }
 
   def __init__(self, reader, stack_map):
     self.reader = reader
     self.stack_map = stack_map
     self.objects = {}
 
   def FindObjectOrSmi(self, tagged_address):
     if (tagged_address & 1) == 0: return tagged_address / 2
     return self.FindObject(tagged_address)
 
+  def FindMap(self, tagged_address):

[Vyacheslav Egorov (Chromium), 2012/01/04 08:45:35]

One trick that might help to guess whether smth is map or not is maps alignment
--- it's bigger than alignment of normal objects.

[Michael Starzinger, 2012/01/05 14:26:30]

Done. I also added the alignment check for other heap objects.

+    if (tagged_address & 1) != 1: return None
+    address = tagged_address - 1
+    if not self.reader.IsValidAddress(address): return None
+    object = Map(self, None, address)
+    return object
+
   def FindObject(self, tagged_address):
     if tagged_address in self.objects:
       return self.objects[tagged_address]
     if (tagged_address & 1) != 1: return None
     address = tagged_address - 1
     if not self.reader.IsValidAddress(address): return None
     map_tagged_address = self.reader.ReadUIntPtr(address)
     if tagged_address == map_tagged_address:
       # Meta map?
       meta_map = Map(self, None, address)
       instance_type_name = INSTANCE_TYPES.get(meta_map.instance_type)
       if instance_type_name != "MAP_TYPE": return None
       meta_map.map = meta_map
       object = meta_map
     else:
-      map = self.FindObject(map_tagged_address)
+      map = self.FindMap(map_tagged_address)
       if map is None: return None
       instance_type_name = INSTANCE_TYPES.get(map.instance_type)
       if instance_type_name is None: return None
       cls = V8Heap.CLASS_MAP.get(instance_type_name, HeapObject)
       object = cls(self, map, address)
     self.objects[tagged_address] = object
     return object
 
+  def IntSize(self):
+    return 4
+
   def PointerSize(self):
     return self.reader.PointerSize()
 
 
 
 EIP_PROXIMITY = 64
 
 CONTEXT_FOR_ARCH = {
     MD_CPU_ARCHITECTURE_AMD64:
       ['rax', 'rbx', 'rcx', 'rdx', 'rdi', 'rsi', 'rbp', 'rsp', 'rip'],
@@ skipping 48 matching lines @@
   reader.Dispose()
 
 
 if __name__ == "__main__":
   parser = optparse.OptionParser(USAGE)
   options, args = parser.parse_args()
   if len(args) != 1:
     parser.print_help()
     sys.exit(1)
   AnalyzeMinidump(options, args[0])