grokdump: Add simple support for non-full minudumps.

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 273 matching lines @@
       print >>sys.stderr, "Warning: unsupported minidump header magic"
     DebugPrint(self.header)
     directories = []
     offset = self.header.stream_directories_rva
     for _ in xrange(self.header.stream_count):
       directories.append(MINIDUMP_DIRECTORY.Read(self.minidump, offset))
       offset += MINIDUMP_DIRECTORY.size
     self.exception = None
     self.exception_context = None
     self.memory_list = None
+    self.memory_list64 = None
     self.thread_map = {}
     for d in directories:
       DebugPrint(d)
       # TODO(vitalyr): extract system info including CPU features.
       if d.stream_type == MD_EXCEPTION_STREAM:
         self.exception = MINIDUMP_EXCEPTION_STREAM.Read(
           self.minidump, d.location.rva)
         DebugPrint(self.exception)
         self.exception_context = MINIDUMP_CONTEXT_X86.Read(
           self.minidump, self.exception.thread_context.rva)
         DebugPrint(self.exception_context)
       elif d.stream_type == MD_THREAD_LIST_STREAM:
         thread_list = MINIDUMP_THREAD_LIST.Read(self.minidump, d.location.rva)
         assert ctypes.sizeof(thread_list) == d.location.data_size
         DebugPrint(thread_list)
         for thread in thread_list.threads:
           DebugPrint(thread)
           self.thread_map[thread.id] = thread
       elif d.stream_type == MD_MEMORY_LIST_STREAM:
         print >>sys.stderr, "Warning: not a full minidump"
-        ml = MINIDUMP_MEMORY_LIST.Read(self.minidump, d.location.rva)
-        DebugPrint(ml)
-        for m in ml.ranges:
-          DebugPrint(m)
-      elif d.stream_type == MD_MEMORY_64_LIST_STREAM:
         assert self.memory_list is None
-        self.memory_list = MINIDUMP_MEMORY_LIST64.Read(
+        self.memory_list = MINIDUMP_MEMORY_LIST.Read(
           self.minidump, d.location.rva)
         assert ctypes.sizeof(self.memory_list) == d.location.data_size
         DebugPrint(self.memory_list)
+      elif d.stream_type == MD_MEMORY_64_LIST_STREAM:
+        assert self.memory_list64 is None
+        self.memory_list64 = MINIDUMP_MEMORY_LIST64.Read(
+          self.minidump, d.location.rva)
+        assert ctypes.sizeof(self.memory_list64) == d.location.data_size
+        DebugPrint(self.memory_list64)
 
   def IsValidAddress(self, address):
     return self.FindLocation(address) is not None
 
   def ReadU8(self, address):
     location = self.FindLocation(address)
     return ctypes.c_uint8.from_buffer(self.minidump, location).value
 
   def ReadU32(self, address):
     location = self.FindLocation(address)
     return ctypes.c_uint32.from_buffer(self.minidump, location).value
 
   def ReadBytes(self, address, size):
     location = self.FindLocation(address)
     return self.minidump[location:location + size]
 
   def FindLocation(self, address):
-    # TODO(vitalyr): only works for full minidumps (...64 structure variants).
     offset = 0
-    for r in self.memory_list.ranges:
-      if r.start <= address < r.start + r.size:
-        return self.memory_list.base_rva + offset + address - r.start
+    if self.memory_list64 is not None:
+      for r in self.memory_list64.ranges:
+        if r.start <= address < r.start + r.size:
+          return self.memory_list64.base_rva + offset + address - r.start
       offset += r.size
+    if self.memory_list is not None:
+      for r in self.memory_list.ranges:
+        if r.start <= address < r.start + r.memory.data_size:
+          return r.memory.rva + address - r.start
     return None
 
   def GetDisasmLines(self, address, size):
     location = self.FindLocation(address)
     if location is None: return []
     return disasm.GetDisasmLines(self.minidump_name,
                                  location,
                                  size,
                                  "ia32",
                                  False)
@@ skipping 477 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])