[tools] Improve grokdump.py

- Add new address markers:
   T: tagged pointer in the minidump
   C: address into a module in the minidump
   S: pointer into the exception stack in the minidump
   *: other address in the minidump
- Show ASCII decoding of address in dd
- Display potential frame markers on the exception stack:
   00000032212fdae8: 0000000300000000   ........ Smi(3) EXIT frame marker
- Display relative addresses, useful to detect stack frames:
   00000032212fdb68: 00000032212fdb98 S ........  [+6]=00000032212fdcb0 S
   00000032212fdb70: 0000010ff5ca0a84   ........
   00000032212fdb78: 000001064c1fa881   ........
   00000032212fdb80: 0000016a8e52fcb1   ........
   00000032212fdb88: 0000010ff5ca0981   ........
   00000032212fdb90: 0000000d00000000   ........ Smi(13) INTERNAL frame marker
   00000032212fdb98: 00000032212fdcb0 S ........  [+35]=00000032212fdd61 S

Change-Id: I56bd7e6723a34bcb668719246dd5ff2898224928
Reviewed-on: https://chromium-review.googlesource.com/461862Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Commit-Queue: Camillo Bruni <cbruni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#44269}

src/d8.cc

@@ -2836,7 +2836,10 @@ void Shell::CleanupWorkers() {
 
 static void DumpHeapConstants(i::Isolate* isolate) {
   i::Heap* heap = isolate->heap();
-
+  printf(
+      "# Copyright 2017 the V8 project authors. All rights reserved.\n"
+      "# Use of this source code is governed by a BSD-style license that can\n"
+      "# be found in the LICENSE file.\n\n");
   // Dump the INSTANCE_TYPES table to the console.
   printf("# List of known V8 instance types.\n");
 #define DUMP_TYPE(T) printf("  %d: \"%s\",\n", i::T, #T);
@@ -2886,6 +2889,14 @@ static void DumpHeapConstants(i::Isolate* isolate) {
   }
   printf("}\n");
 #undef ROOT_LIST_CASE
+
+  // Dump frame markers
+  printf("\n# List of known V8 Frame Markers.\n");
+#define DUMP_MARKER(T, class) printf("  \"%s\",\n", #T);
+  printf("FRAME_MARKERS = (\n");
+  STACK_FRAME_TYPE_LIST(DUMP_MARKER)
+  printf(")\n");
+#undef DUMP_TYPE
 }
 
 

tools/grokdump.py

@@ -179,6 +179,7 @@ def FullDump(reader, heap):
 INSTANCE_TYPES = v8heapconst.INSTANCE_TYPES
 KNOWN_MAPS = v8heapconst.KNOWN_MAPS
 KNOWN_OBJECTS = v8heapconst.KNOWN_OBJECTS
+FRAME_MARKERS = v8heapconst.FRAME_MARKERS
 
 # Set of structures and constants that describe the layout of minidump
 # files. Based on MSDN and Google Breakpad.
@@ -687,6 +688,27 @@ class MinidumpReader(object):
   def IsValidAddress(self, address):
     return self.FindLocation(address) is not None
 
+  def IsAlignedAddress(self, address):
+    return (address % self.PointerSize()) == 0
+
+  def IsExceptionStackAddress(self, address):
+    if not self.IsAlignedAddress(address): return False
+    return self.StackTop() <= address <= self.StackBottom()
+
+  def IsValidExceptionStackAddress(self, address):
+    if not self.IsValidAddress(address): return False
+    return self.isExceptionStackAddress(address)
+
+  def IsModuleAddress(self, address):
+    return self.GetModuleForAddress(address) != None
+
+  def GetModuleForAddress(self, address):
+    for module in self.module_list.modules:
+      start = module.base_of_image
+      end = start + module.size_of_image
+      if start <= address < end: return module
+    return None
+
   def ReadU8(self, address):
     location = self.FindLocation(address)
     return ctypes.c_uint8.from_buffer(self.minidump, location).value
@@ -717,6 +739,11 @@ class MinidumpReader(object):
       return ctypes.c_uint64.from_buffer(self.minidump, location).value
     return ctypes.c_uint32.from_buffer(self.minidump, location).value
 
+  def ReadAsciiPtr(self, address):
+    ascii_content = [c if c >= '\x20' and c <  '\x7f' else '.'
+                       for c in self.ReadBytes(address, self.PointerSize())]
+    return ''.join(ascii_content)
+
   def IsProbableASCIIRegion(self, location, length):
     ascii_bytes = 0
     non_ascii_bytes = 0
@@ -807,7 +834,7 @@ class MinidumpReader(object):
         loc = location + i
         if reader._ReadWord(loc) == word:
           slot = start + (loc - location)
-          if slot % self.PointerSize() == 0:
+          if self.IsAlignedAddress(slot):
             aligned_res.append(slot)
           else:
             unaligned_res.append(slot)
@@ -890,6 +917,17 @@ class MinidumpReader(object):
     elif self.arch == MD_CPU_ARCHITECTURE_X86:
       return self.exception_context.ebp
 
+  def ExceptionThread(self):
+    return self.thread_map[self.exception.thread_id]
+
+  def StackTop(self):
+    return self.ExceptionSP()
+
+  def StackBottom(self):
+    exception_thread = self.ExceptionThread()
+    return exception_thread.stack.start + \
+        exception_thread.stack.memory.data_size
+
   def FormatIntPtr(self, value):
     if self.Is64():
       return "%016x" % value
@@ -1257,7 +1295,7 @@ class ConsString(String):
 
 
 class Oddball(HeapObject):
-  # Should match declarations in objects.h
+  #Should match declarations in objects.h
   KINDS = [
     "False",
     "True",
@@ -1633,7 +1671,7 @@ class V8Heap(object):
   def FindObject(self, tagged_address):
     if tagged_address in self.objects:
       return self.objects[tagged_address]
-    if (tagged_address & self.ObjectAlignmentMask()) != 1: return None
+    if not self.IsTaggedObjectAddress(tagged_address): return None
     address = tagged_address - 1
     if not self.reader.IsValidAddress(address): return None
     map_tagged_address = self.reader.ReadUIntPtr(address)
@@ -1670,6 +1708,9 @@ class V8Heap(object):
   def ObjectAlignmentMask(self):
     return self.PointerSize() - 1
 
+  def IsTaggedObjectAddress(self, address):
+    return (address & self.ObjectAlignmentMask()) == 1
+
   def MapAlignmentMask(self):
     if self.reader.arch == MD_CPU_ARCHITECTURE_AMD64:
       return (1 << 4) - 1
@@ -1683,15 +1724,41 @@ class V8Heap(object):
   def PageAlignmentMask(self):
     return (1 << 19) - 1
 
+  def IsTaggedAddress(self, address):
+    return (address & 1) == 1
+
   def IsSmi(self, tagged_address):
     if self.reader.Is64():
       return (tagged_address & 0xFFFFFFFF) == 0
-    return (tagged_address & 1) == 0
+    return not self.IsTaggedAddress(tagged_address)
 
   def SmiUntag(self, tagged_address):
     if self.reader.Is64(): return tagged_address >> 32
     return tagged_address >> 1
 
+  def AddressTypeMarker(self, address):
+    if not self.reader.IsValidAddress(address): return " "
+    if self.reader.IsExceptionStackAddress(address): return "S"
+    if self.reader.IsModuleAddress(address): return "C"
+    if self.IsTaggedAddress(address): return "T"
+    return "*"
+
+  def RelativeOffset(self, slot, address):
+    if not self.reader.IsValidAddress(slot): return None
+    if not self.reader.IsAlignedAddress(slot): return None
+    if not self.reader.IsValidAddress(address): return None
+    if not self.reader.IsAlignedAddress(address): return None
+    offset = (address - slot) / self.PointerSize()
+
+    lower_limit = -32
+    upper_limit = 128
+    if self.reader.IsExceptionStackAddress(address):
+      upper_limit = 0xFFFFFF
+
+    if offset < lower_limit or upper_limit < offset: return None
+    target_address = self.reader.ReadUIntPtr(address)
+    return "[%+02d]=%s %s" % (offset, self.reader.FormatIntPtr(target_address),
+                             self.AddressTypeMarker(target_address))
 
 class KnownObject(HeapObject):
   def __init__(self, heap, known_name):
@@ -1816,12 +1883,25 @@ class InspectionPadawan(object):
     if page_address == self.known_first_old_page: return "OLD_SPACE"
     return None
 
-  def FormatSmi(self, tagged_address):
-    return "Smi(%d)" % self.SmiUntag(tagged_address)
+  def FrameMarkerName(self, value):
+    if 0 < value <= len(FRAME_MARKERS):
+      return "Possible %s frame marker" % FRAME_MARKERS[value-1]
+    return ""
 
-  def SenseObject(self, tagged_address):
-    if self.heap.IsSmi(tagged_address):
-      return self.FormatSmi(tagged_address)
+  def FormatSmi(self, address, slot=None):
+    value = self.heap.SmiUntag(address)
+    marker = ""
+    if slot and self.reader.IsExceptionStackAddress(slot):
+      marker = self.FrameMarkerName(value)
+    # On 32-bit systems almost everything looks like a Smi.
+    if not self.reader.Is64() or value == 0: return marker
+    return "Smi(%d) %s" % (value, marker)
+
+  def SenseObject(self, address, slot=None):
+    if self.heap.IsSmi(address):
+      return self.FormatSmi(address, slot)
+    if not self.heap.IsTaggedAddress(address): return None
+    tagged_address = address
     if self.IsInKnownOldSpace(tagged_address):
       offset = self.GetPageOffset(tagged_address)
       lookup_key = (self.ContainingKnownOldSpaceName(tagged_address), offset)
@@ -1879,6 +1959,72 @@ class InspectionPadawan(object):
           self.reader.FormatIntPtr(self.known_first_map_page),
           self.reader.FormatIntPtr(self.known_first_old_page))
 
+  def TryInferFramePointer(self, slot, address):
+    """ Assume we have a framepointer if we find 4 consecutive links """
+    for i in range(0, 4):
+      if not self.reader.IsExceptionStackAddress(address): return 0
+      address = self.reader.ReadUIntPtr(address)
+    return slot
+
+  def InterpretMemory(self, start, end):
+    # On 64 bit we omit frame pointers, so we have to do some more guesswork.A
+    frame_pointer = 0
+    if not self.reader.Is64():
+      frame_pointer = self.reader.ExceptionFP()
+    in_oom_dump_area  = False
+
+    for slot in xrange(start, end, self.reader.PointerSize()):
+      if not self.reader.IsValidAddress(slot):
+        print "%s: Address is not contained within the minidump!" % slot
+        return
+      maybe_address = self.reader.ReadUIntPtr(slot)
+
+      address_info = []
+      heap_object = self.SenseObject(maybe_address, slot)
+      if heap_object:
+        address_info.append(heap_object)
+      relative_offset = self.heap.RelativeOffset(slot, maybe_address)
+      if relative_offset:
+        address_info.append(relative_offset)
+
+      maybe_address_contents = None
+      if self.reader.IsExceptionStackAddress(maybe_address):
+        maybe_address_contents = \
+            self.reader.ReadUIntPtr(maybe_address) & 0xFFFFFFFF
+        if maybe_address_contents == 0xdecade00:
+          in_oom_dump_area = True
+        if frame_pointer == 0:
+          frame_pointer = self.TryInferFramePointer(slot, maybe_address)
+      maybe_symbol = self.reader.FindSymbol(maybe_address)
+      if in_oom_dump_area:
+        if maybe_address_contents == 0xdecade00:
+          address_info = ["<==== HeapStats start marker"]
+        elif maybe_address_contents == 0xdecade01:
+          address_info = ["<==== HeapStats end marker"]
+        elif maybe_address_contents is not None:
+          address_info = [" %d (%d Mbytes)" % (maybe_address_contents,
+                                               maybe_address_contents >> 20)]
+      if slot == frame_pointer:
+        if not self.reader.IsExceptionStackAddress(maybe_address):
+          address_info.append("<==== BAD frame pointer")
+          frame_pointer = 0
+        else:
+          address_info.append("<==== Frame pointer")
+        frame_pointer = maybe_address
+      address_type_marker = self.heap.AddressTypeMarker(maybe_address)
+      string_value = self.reader.ReadAsciiPtr(slot)
+      print "%s: %s %s %s %s" % (self.reader.FormatIntPtr(slot),
+                           self.reader.FormatIntPtr(maybe_address),
+                           address_type_marker,
+                           string_value,
+                           ' | '.join(address_info))
+      if maybe_address_contents == 0xdecade01:
+        in_oom_dump_area = False
+      heap_object = self.heap.FindObject(maybe_address)
+      if heap_object:
+        heap_object.Print(Printer())
+        print ""
+
 WEB_HEADER = """
 <!DOCTYPE html>
 <html>
@@ -2962,20 +3108,31 @@ class InspectionShell(cmd.Cmd):
       sign = -1
     maybe_addr = expr[0]
     if maybe_addr[0] == "$":
-      # Referring to a register
-      address = self.reader.Register(maybe_addr[1:])
+      try:
+        # Referring to a register
+        address = self.reader.Register(maybe_addr[1:])
+      except:
+        print("**** Register %s does not exist." %  maybe_addr)
+        return 0
     else:
-      address = int(maybe_addr, 16)
+      try:
+        address = int(maybe_addr, 16)
+      except:
+        print("**** Invalid address: %s" % maybe_addr)
+        return 0
     if len(expr) > 1:
-      address += sign * int(expr[1], 16)
+      try:
+        address += sign * int(expr[1], 16)
+      except:
+        print("*** Invalid offset: %s" % expr[1])
+        return 0
     return address
 
-
   def do_dd(self, args):
     """
      Interpret memory in the given region [address, address + num * word_size)
      (if available) as a sequence of words. Automatic alignment is not performed.
-     If the num is not specified, a default value of 16 words is used.
+     If the num is not specified, a default value of 16 words is usif not self.Is
      If no address is given, dd continues printing at the next word.
      Synopsis: dd 0x<address>|$register [0x<num>]
     """
@@ -2985,22 +3142,10 @@ class InspectionShell(cmd.Cmd):
       self.dd_num = int(args[1], 16) if len(args) > 1 else 0x10
     else:
       self.dd_start += self.dd_num * self.reader.PointerSize()
-    if (self.dd_start & self.heap.ObjectAlignmentMask()) != 0:
+    if not self.reader.IsAlignedAddress(self.dd_start):
       print "Warning: Dumping un-aligned memory, is this what you had in mind?"
-    for i in xrange(0,
-                    self.reader.PointerSize() * self.dd_num,
-                    self.reader.PointerSize()):
-      slot = self.dd_start + i
-      if not self.reader.IsValidAddress(slot):
-        print "Address is not contained within the minidump!"
-        return
-      maybe_address = self.reader.ReadUIntPtr(slot)
-      heap_object = self.padawan.SenseObject(maybe_address)
-      valid_address = "*" if self.reader.IsValidAddress(maybe_address) else " "
-      print "%s: %s %s %s" % (self.reader.FormatIntPtr(slot),
-                           self.reader.FormatIntPtr(maybe_address),
-                           valid_address,
-                           heap_object or '')
+    end = self.dd_start + self.reader.PointerSize() * self.dd_num
+    self.padawan.InterpretMemory(self.dd_start, end)
 
   def do_do(self, address):
     """
@@ -3009,9 +3154,9 @@ class InspectionShell(cmd.Cmd):
      addresses.
     """
     address = self.ParseAddressExpr(address)
-    if (address & self.heap.ObjectAlignmentMask()) == 0:
+    if self.reader.IsAlignedAddress(address):
       address = address + 1
-    elif (address & self.heap.ObjectAlignmentMask()) != 1:
+    elif not self.IsTaggedObjectAddress(address):
       print "Address doesn't look like a valid pointer!"
       return
     heap_object = self.padawan.SenseObject(address)
@@ -3201,20 +3346,37 @@ def PrintModuleDetails(reader, module):
 def AnalyzeMinidump(options, minidump_name):
   reader = MinidumpReader(options, minidump_name)
   heap = None
+
+  stack_top = reader.ExceptionSP()
+  stack_bottom = reader.StackBottom()
+  stack_map = {reader.ExceptionIP(): -1}
+  for slot in xrange(stack_top, stack_bottom, reader.PointerSize()):
+    maybe_address = reader.ReadUIntPtr(slot)
+    if not maybe_address in stack_map:
+      stack_map[maybe_address] = slot
+  heap = V8Heap(reader, stack_map)
+
   DebugPrint("========================================")
   if reader.exception is None:
     print "Minidump has no exception info"
   else:
+    print "Address markers:"
+    print "  T = valid tagged pointer in the minidump"
+    print "  S = address on the exception stack"
+    print "  C = address in loaded C/C++ module"
+    print "  * = address in the minidump"
     print "Exception info:"
-    exception_thread = reader.thread_map[reader.exception.thread_id]
+    exception_thread = reader.ExceptionThread()
     print "  thread id: %d" % exception_thread.id
-    print "  code: %08X" % reader.exception.exception.code
+    print "  code:      %08X" % reader.exception.exception.code
     print "  context:"
     context = CONTEXT_FOR_ARCH[reader.arch]
     maxWidth = max(map(lambda s: len(s), context))
     for r in context:
-      print "    %s: %s" % (r.rjust(maxWidth),
-                            reader.FormatIntPtr(reader.Register(r)))
+      register_value = reader.Register(r)
+      print "    %s: %s %s" % (r.rjust(maxWidth),
+                            reader.FormatIntPtr(register_value ),
+                            heap.AddressTypeMarker(register_value))
     # TODO(vitalyr): decode eflags.
     if reader.arch in [MD_CPU_ARCHITECTURE_ARM, MD_CPU_ARCHITECTURE_ARM64]:
       print "    cpsr: %s" % bin(reader.exception_context.cpsr)[2:]
@@ -3230,16 +3392,6 @@ def AnalyzeMinidump(options, minidump_name):
         reader.TryLoadSymbolsFor(name, module)
     print
 
-    stack_top = reader.ExceptionSP()
-    stack_bottom = exception_thread.stack.start + \
-        exception_thread.stack.memory.data_size
-    stack_map = {reader.ExceptionIP(): -1}
-    for slot in xrange(stack_top, stack_bottom, reader.PointerSize()):
-      maybe_address = reader.ReadUIntPtr(slot)
-      if not maybe_address in stack_map:
-        stack_map[maybe_address] = slot
-    heap = V8Heap(reader, stack_map)
-
     print "Disassembly around exception.eip:"
     eip_symbol = reader.FindSymbol(reader.ExceptionIP())
     if eip_symbol is not None:
@@ -3278,43 +3430,9 @@ def AnalyzeMinidump(options, minidump_name):
       print "Kthxbye."
   elif not options.command:
     if reader.exception is not None:
-      frame_pointer = reader.ExceptionFP()
-      in_oom_dump_area = False
       print "Annotated stack (from exception.esp to bottom):"
-      for slot in xrange(stack_top, stack_bottom, reader.PointerSize()):
-        ascii_content = [c if c >= '\x20' and c <  '\x7f' else '.'
-                         for c in reader.ReadBytes(slot, reader.PointerSize())]
-        maybe_address = reader.ReadUIntPtr(slot)
-        maybe_address_contents = None
-        if maybe_address >= stack_top and maybe_address <= stack_bottom:
-          maybe_address_contents = reader.ReadUIntPtr(maybe_address)
-          if maybe_address_contents == 0xdecade00:
-            in_oom_dump_area = True
-        heap_object = heap.FindObject(maybe_address)
-        maybe_symbol = reader.FindSymbol(maybe_address)
-        oom_comment = ""
-        if in_oom_dump_area:
-          if maybe_address_contents == 0xdecade00:
-            oom_comment = " <----- HeapStats start marker"
-          elif maybe_address_contents == 0xdecade01:
-            oom_comment = " <----- HeapStats end marker"
-          elif maybe_address_contents is not None:
-            oom_comment = " %d (%d Mbytes)" % (maybe_address_contents,
-                                            maybe_address_contents >> 20)
-        if slot == frame_pointer:
-          maybe_symbol = "<---- frame pointer"
-          frame_pointer = maybe_address
-        print "%s: %s %s %s%s" % (reader.FormatIntPtr(slot),
-                                  reader.FormatIntPtr(maybe_address),
-                                   "".join(ascii_content),
-                                   maybe_symbol or "",
-                                   oom_comment)
-        if maybe_address_contents == 0xdecade01:
-          in_oom_dump_area = False
-        if heap_object:
-          heap_object.Print(Printer())
-          print
-
+      padawan = InspectionPadawan(reader, heap)
+      padawan.InterpretMemory(stack_top, stack_bottom)
   reader.Dispose()
 
 

tools/v8heapconst.py

 # Copyright 2017 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.
+# Use of this source code is governed by a BSD-style license that can
+# be found in the LICENSE file.
 
 # List of known V8 instance types.
 INSTANCE_TYPES = {
@@ -309,13 +309,34 @@ KNOWN_OBJECTS = {
   ("OLD_SPACE", 0x07969): "ExperimentalExtraNativesSourceCache",
   ("OLD_SPACE", 0x07981): "EmptyPropertiesDictionary",
   ("OLD_SPACE", 0x079d1): "ScriptList",
-  ("OLD_SPACE", 0x23709): "CodeStubs",
-  ("OLD_SPACE", 0x30781): "WeakObjectToCodeTable",
-  ("OLD_SPACE", 0x309a9): "WeakNewSpaceObjectToCodeList",
-  ("OLD_SPACE", 0x30a39): "NoScriptSharedFunctionInfos",
-  ("OLD_SPACE", 0x4cb11): "MessageListeners",
-  ("OLD_SPACE", 0x4cb31): "NoOpInterceptorInfo",
-  ("OLD_SPACE", 0x550e1): "StringTable",
-  ("CODE_SPACE", 0x2c4e1): "JsEntryCode",
-  ("CODE_SPACE", 0x30941): "JsConstructEntryCode",
+  ("OLD_SPACE", 0x22019): "CodeStubs",
+  ("OLD_SPACE", 0x2f199): "WeakObjectToCodeTable",
+  ("OLD_SPACE", 0x2f3c1): "WeakNewSpaceObjectToCodeList",
+  ("OLD_SPACE", 0x2f451): "NoScriptSharedFunctionInfos",
+  ("OLD_SPACE", 0x4abd9): "MessageListeners",
+  ("OLD_SPACE", 0x4abf9): "NoOpInterceptorInfo",
+  ("OLD_SPACE", 0x531d1): "StringTable",
+  ("CODE_SPACE", 0x2cde1): "JsEntryCode",
+  ("CODE_SPACE", 0x31241): "JsConstructEntryCode",
 }
+
+# List of known V8 Frame Markers.
+FRAME_MARKERS = (
+  "ENTRY",
+  "ENTRY_CONSTRUCT",
+  "EXIT",
+  "JAVA_SCRIPT",
+  "OPTIMIZED",
+  "WASM_COMPILED",
+  "WASM_TO_JS",
+  "JS_TO_WASM",
+  "WASM_INTERPRETER_ENTRY",
+  "INTERPRETED",
+  "STUB",
+  "STUB_FAILURE_TRAMPOLINE",
+  "INTERNAL",
+  "CONSTRUCT",
+  "ARGUMENTS_ADAPTOR",
+  "BUILTIN",
+  "BUILTIN_EXIT",
+)