Various improvements to oom_dump and instance type lists.

tools/oom_dump/oom_dump.cc

 // Copyright 2010 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <algorithm>
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <algorithm>
+
 #include <google_breakpad/processor/minidump.h>
-#include <processor/logging.h>
 
 #define ENABLE_DEBUGGER_SUPPORT
 
 #include <v8.h>
 
 namespace {
 
 using google_breakpad::Minidump;
 using google_breakpad::MinidumpContext;
 using google_breakpad::MinidumpThread;
@@ skipping 77 matching lines @@
   u_int32_t exception_thread_id = 0;
   CHECK(exception->GetThreadID(&exception_thread_id));
 
   MinidumpThreadList* thread_list = minidump.GetThreadList();
   CHECK(thread_list);
 
   MinidumpThread* exception_thread =
       thread_list->GetThreadByID(exception_thread_id);
   CHECK(exception_thread);
 
+  // Currently only 32-bit Windows minidumps are supported.
+  CHECK_EQ(MD_CONTEXT_X86, crash_context->GetContextCPU());
+
   const MDRawContextX86* contextX86 = crash_context->GetContextX86();
   CHECK(contextX86);
 
   const u_int32_t esp = contextX86->esp;
 
   MinidumpMemoryRegion* memory_region = exception_thread->GetMemory();
   CHECK(memory_region);
 
   const u_int64_t last = memory_region->GetBase() + memory_region->GetSize();
 
   u_int64_t heap_stats_addr = 0;
   for (u_int64_t addr = esp; addr < last; addr += 4) {
     u_int32_t value = 0;
     CHECK(memory_region->GetMemoryAtAddress(addr, &value));
     if (value >= esp && value < last) {
       u_int32_t value2 = 0;
       CHECK(memory_region->GetMemoryAtAddress(value, &value2));
-      if (value2 == 0xdecade00) {
+      if (value2 == v8::internal::HeapStats::kStartMarker) {
         heap_stats_addr = addr;
         break;
       }
     }
   }
   CHECK(heap_stats_addr);
 
   // Read heap stats.
 
 #define READ_FIELD(offset) \
   ReadPointedValue(memory_region, heap_stats_addr, offset)
 
-  CHECK(READ_FIELD(0) == 0xdecade00);
-  CHECK(READ_FIELD(23) == 0xdecade01);
+  CHECK(READ_FIELD(0) == v8::internal::HeapStats::kStartMarker);
+  CHECK(READ_FIELD(23) == v8::internal::HeapStats::kEndMarker);
 
   const int new_space_size = READ_FIELD(1);
   const int new_space_capacity = READ_FIELD(2);
   const int old_pointer_space_size = READ_FIELD(3);
   const int old_pointer_space_capacity = READ_FIELD(4);
   const int old_data_space_size = READ_FIELD(5);
   const int old_data_space_capacity = READ_FIELD(6);
   const int code_space_size = READ_FIELD(7);
   const int code_space_capacity = READ_FIELD(8);
   const int map_space_size = READ_FIELD(9);
@@ skipping 33 matching lines @@
   std::stable_sort(indices, indices + sizeof(indices)/sizeof(indices[0]),
                   IndirectSorter(size_per_type));
 
   int total_size = 0;
   for (int i = 0; i <= v8::internal::LAST_TYPE; i++) {
     total_size += size_per_type[i];
   }
 
   // Print heap stats.
 
-  printf("exception thread ID: %d (%x)\n",
+  printf("exception thread ID: %" PRIu32 " (%#" PRIx32 ")\n",
          exception_thread_id, exception_thread_id);
-  printf("heap stats address: %p\n", (void*)heap_stats_addr);
+  printf("heap stats address: %#" PRIx64 "\n", heap_stats_addr);
 #define PRINT_INT_STAT(stat) \
     printf("\t%-25s\t% 10d\n", #stat ":", stat);
 #define PRINT_MB_STAT(stat) \
     printf("\t%-25s\t% 10.3f MB\n", #stat ":", toM(stat));
   PRINT_MB_STAT(new_space_size);
   PRINT_MB_STAT(new_space_capacity);
   PRINT_MB_STAT(old_pointer_space_size);
   PRINT_MB_STAT(old_pointer_space_capacity);
   PRINT_MB_STAT(old_data_space_size);
   PRINT_MB_STAT(old_data_space_capacity);
@@ skipping 19 matching lines @@
       "\tJS_GLOBAL_OBJECT_TYPE/JS_BUILTINS_OBJECT_TYPE/JS_GLOBAL_PROXY_TYPE: "
       "%d/%d/%d\n\n",
       js_global_objects, js_builtins_objects, js_global_proxies);
 
   int running_size = 0;
   for (int i = 0; i <= v8::internal::LAST_TYPE; i++) {
     int type = indices[i];
     const char* name = InstanceTypeToString(type);
     if (name == NULL) {
       // Unknown instance type.  Check that there is no objects of that type.
-      CHECK(objects_per_type[type] == 0);
-      CHECK(size_per_type[type] == 0);
+      CHECK_EQ(0, objects_per_type[type]);
+      CHECK_EQ(0, size_per_type[type]);
       continue;
     }
     int size = size_per_type[type];
     running_size += size;
     printf("\t%-37s% 9d% 11.3f MB% 10.3f%%% 10.3f%%\n",
            name, objects_per_type[type], toM(size),
-           100.*size/total_size, 100.*running_size/total_size);
+           100. * size / total_size, 100. * running_size / total_size);
   }
   printf("\t%-37s% 9d% 11.3f MB% 10.3f%%% 10.3f%%\n",
          "total", 0, toM(total_size), 100., 100.);
 }
 
 }  // namespace
 
 int main(int argc, char **argv) {
-  BPLOG_INIT(&argc, &argv);
-
   if (argc != 2) {
     fprintf(stderr, "usage: %s <minidump>\n", argv[0]);
     return 1;
   }
 
   DumpHeapStats(argv[1]);
 
   return 0;
 }