libv8 3.3.10.2

data/lib/libv8/v8/tools/logreader.js

@@ -0,0 +1,185 @@
+// Copyright 2009 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.
+
+/**
+ * @fileoverview Log Reader is used to process log file produced by V8.
+ */
+
+
+/**
+ * Base class for processing log files.
+ *
+ * @param {Array.<Object>} dispatchTable A table used for parsing and processing
+ *     log records.
+ * @constructor
+ */
+function LogReader(dispatchTable) {
+  /**
+   * @type {Array.<Object>}
+   */
+  this.dispatchTable_ = dispatchTable;
+
+  /**
+   * Current line.
+   * @type {number}
+   */
+  this.lineNum_ = 0;
+
+  /**
+   * CSV lines parser.
+   * @type {CsvParser}
+   */
+  this.csvParser_ = new CsvParser();
+};
+
+
+/**
+ * Used for printing error messages.
+ *
+ * @param {string} str Error message.
+ */
+LogReader.prototype.printError = function(str) {
+  // Do nothing.
+};
+
+
+/**
+ * Processes a portion of V8 profiler event log.
+ *
+ * @param {string} chunk A portion of log.
+ */
+LogReader.prototype.processLogChunk = function(chunk) {
+  this.processLog_(chunk.split('\n'));
+};
+
+
+/**
+ * Processes a line of V8 profiler event log.
+ *
+ * @param {string} line A line of log.
+ */
+LogReader.prototype.processLogLine = function(line) {
+  this.processLog_([line]);
+};
+
+
+/**
+ * Processes stack record.
+ *
+ * @param {number} pc Program counter.
+ * @param {number} func JS Function.
+ * @param {Array.<string>} stack String representation of a stack.
+ * @return {Array.<number>} Processed stack.
+ */
+LogReader.prototype.processStack = function(pc, func, stack) {
+  var fullStack = func ? [pc, func] : [pc];
+  var prevFrame = pc;
+  for (var i = 0, n = stack.length; i < n; ++i) {
+    var frame = stack[i];
+    var firstChar = frame.charAt(0);
+    if (firstChar == '+' || firstChar == '-') {
+      // An offset from the previous frame.
+      prevFrame += parseInt(frame, 16);
+      fullStack.push(prevFrame);
+    // Filter out possible 'overflow' string.
+    } else if (firstChar != 'o') {
+      fullStack.push(parseInt(frame, 16));
+    }
+  }
+  return fullStack;
+};
+
+
+/**
+ * Returns whether a particular dispatch must be skipped.
+ *
+ * @param {!Object} dispatch Dispatch record.
+ * @return {boolean} True if dispatch must be skipped.
+ */
+LogReader.prototype.skipDispatch = function(dispatch) {
+  return false;
+};
+
+
+/**
+ * Does a dispatch of a log record.
+ *
+ * @param {Array.<string>} fields Log record.
+ * @private
+ */
+LogReader.prototype.dispatchLogRow_ = function(fields) {
+  // Obtain the dispatch.
+  var command = fields[0];
+  if (!(command in this.dispatchTable_)) {
+    throw new Error('unknown command: ' + command);
+  }
+  var dispatch = this.dispatchTable_[command];
+
+  if (dispatch === null || this.skipDispatch(dispatch)) {
+    return;
+  }
+
+  // Parse fields.
+  var parsedFields = [];
+  for (var i = 0; i < dispatch.parsers.length; ++i) {
+    var parser = dispatch.parsers[i];
+    if (parser === null) {
+      parsedFields.push(fields[1 + i]);
+    } else if (typeof parser == 'function') {
+      parsedFields.push(parser(fields[1 + i]));
+    } else {
+      // var-args
+      parsedFields.push(fields.slice(1 + i));
+      break;
+    }
+  }
+
+  // Run the processor.
+  dispatch.processor.apply(this, parsedFields);
+};
+
+
+/**
+ * Processes log lines.
+ *
+ * @param {Array.<string>} lines Log lines.
+ * @private
+ */
+LogReader.prototype.processLog_ = function(lines) {
+  for (var i = 0, n = lines.length; i < n; ++i, ++this.lineNum_) {
+    var line = lines[i];
+    if (!line) {
+      continue;
+    }
+    try {
+      var fields = this.csvParser_.parseLine(line);
+      this.dispatchLogRow_(fields);
+    } catch (e) {
+      this.printError('line ' + (this.lineNum_ + 1) + ': ' + (e.message || e));
+    }
+  }
+};

data/lib/libv8/v8/tools/mac-nm

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# This script is a wrapper for OS X nm(1) tool. nm(1) perform C++ function
+# names demangling, so we're piping its output to c++filt(1) tool which does it.
+# But c++filt(1) comes with XCode (as a part of GNU binutils), so it doesn't
+# guaranteed to exist on a system.
+#
+# An alternative approach is to perform demangling in tick processor, but
+# for GNU C++ ABI this is a complex process (see cp-demangle.c sources), and
+# can't be done partially, because term boundaries are plain text symbols, such
+# as 'N', 'E', so one can't just do a search through a function name, it really
+# needs to be parsed, which requires a lot of knowledge to be coded in.
+
+if [ "`which c++filt`" == "" ]; then
+  nm "$@"
+else
+  nm "$@" | c++filt -p -i
+fi

data/lib/libv8/v8/tools/mac-tick-processor

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+# A wrapper script to call 'linux-tick-processor' with Mac-specific settings.
+
+tools_path=`cd $(dirname "$0");pwd`
+$tools_path/linux-tick-processor --mac --nm=$tools_path/mac-nm $@

data/lib/libv8/v8/tools/oom_dump/README

@@ -0,0 +1,31 @@
+oom_dump extracts useful information from Google Chrome OOM minidumps.
+
+To build one needs a google-breakpad checkout
+(http://code.google.com/p/google-breakpad/).
+
+First, one needs to build and install breakpad itself. For instructions
+check google-breakpad, but currently it's as easy as:
+
+  ./configure
+  make
+  sudo make install
+
+(the catch: breakpad installs .so into /usr/local/lib, so you might
+need some additional tweaking to make it discoverable, for example,
+put a soft link into /usr/lib directory).
+
+Next step is to build v8.  Note: you should build x64 version of v8,
+if you're on 64-bit platform, otherwise you would get a link error when
+building oom_dump.
+
+The last step is to build oom_dump itself.  The following command should work:
+
+  cd <v8 working copy>/tools/oom_dump
+  scons BREAKPAD_DIR=<path to google-breakpad working copy>
+
+(Additionally you can control v8 working copy dir, but the default should work.)
+
+If everything goes fine, oom_dump <path to minidump> should print
+some useful information about the OOM crash.
+
+Note: currently only 32-bit Windows minidumps are supported.

data/lib/libv8/v8/tools/oom_dump/SConstruct

@@ -0,0 +1,42 @@
+# 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.
+
+vars = Variables('custom.py')
+vars.Add(PathVariable('BREAKPAD_DIR',
+                      'Path to checkout of google-breakpad project',
+                      '~/google-breakpad',
+                      PathVariable.PathIsDir))
+vars.Add(PathVariable('V8_DIR',
+                      'Path to checkout of v8 project',
+                      '../..',
+                      PathVariable.PathIsDir))
+
+env = Environment(variables = vars,
+                  CPPPATH = ['${BREAKPAD_DIR}/src', '${V8_DIR}/src'],
+                  LIBPATH = ['/usr/local/lib', '${V8_DIR}'])
+
+env.Program('oom_dump.cc', LIBS = ['breakpad', 'v8', 'pthread'])

data/lib/libv8/v8/tools/oom_dump/oom_dump.cc

@@ -0,0 +1,288 @@
+// 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 <stdio.h>
+#include <stdlib.h>
+
+#include <algorithm>
+
+#include <google_breakpad/processor/minidump.h>
+
+#define ENABLE_DEBUGGER_SUPPORT
+
+#include <v8.h>
+
+namespace {
+
+using google_breakpad::Minidump;
+using google_breakpad::MinidumpContext;
+using google_breakpad::MinidumpThread;
+using google_breakpad::MinidumpThreadList;
+using google_breakpad::MinidumpException;
+using google_breakpad::MinidumpMemoryRegion;
+
+const char* InstanceTypeToString(int type) {
+  static char const* names[v8::internal::LAST_TYPE] = {0};
+  if (names[v8::internal::STRING_TYPE] == NULL) {
+    using namespace v8::internal;
+#define SET(type) names[type] = #type;
+    INSTANCE_TYPE_LIST(SET)
+#undef SET
+  }
+  return names[type];
+}
+
+
+u_int32_t ReadPointedValue(MinidumpMemoryRegion* region,
+                           u_int64_t base,
+                           int offset) {
+  u_int32_t ptr = 0;
+  CHECK(region->GetMemoryAtAddress(base + 4 * offset, &ptr));
+  u_int32_t value = 0;
+  CHECK(region->GetMemoryAtAddress(ptr, &value));
+  return value;
+}
+
+
+void ReadArray(MinidumpMemoryRegion* region,
+               u_int64_t array_ptr,
+               int size,
+               int* output) {
+  for (int i = 0; i < size; i++) {
+    u_int32_t value;
+    CHECK(region->GetMemoryAtAddress(array_ptr + 4 * i, &value));
+    output[i] = value;
+  }
+}
+
+
+u_int32_t ReadArrayFrom(MinidumpMemoryRegion* region,
+                        u_int64_t base,
+                        int offset,
+                        int size,
+                        int* output) {
+  u_int32_t ptr = 0;
+  CHECK(region->GetMemoryAtAddress(base + 4 * offset, &ptr));
+  ReadArray(region, ptr, size, output);
+}
+
+
+double toM(int size) {
+  return size / (1024. * 1024.);
+}
+
+
+class IndirectSorter {
+ public:
+  explicit IndirectSorter(int* a) : a_(a) { }
+
+  bool operator() (int i0, int i1) {
+    return a_[i0] > a_[i1];
+  }
+
+ private:
+  int* a_;
+};
+
+void DumpHeapStats(const char *minidump_file) {
+  Minidump minidump(minidump_file);
+  CHECK(minidump.Read());
+
+  MinidumpException *exception = minidump.GetException();
+  CHECK(exception);
+
+  MinidumpContext* crash_context = exception->GetContext();
+  CHECK(crash_context);
+
+  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 == 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) == v8::internal::HeapStats::kStartMarker);
+  CHECK(READ_FIELD(24) == 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);
+  const int map_space_capacity = READ_FIELD(10);
+  const int cell_space_size = READ_FIELD(11);
+  const int cell_space_capacity = READ_FIELD(12);
+  const int lo_space_size = READ_FIELD(13);
+  const int global_handle_count = READ_FIELD(14);
+  const int weak_global_handle_count = READ_FIELD(15);
+  const int pending_global_handle_count = READ_FIELD(16);
+  const int near_death_global_handle_count = READ_FIELD(17);
+  const int destroyed_global_handle_count = READ_FIELD(18);
+  const int memory_allocator_size = READ_FIELD(19);
+  const int memory_allocator_capacity = READ_FIELD(20);
+  const int os_error = READ_FIELD(23);
+#undef READ_FIELD
+
+  int objects_per_type[v8::internal::LAST_TYPE + 1] = {0};
+  ReadArrayFrom(memory_region, heap_stats_addr, 21,
+                v8::internal::LAST_TYPE + 1, objects_per_type);
+
+  int size_per_type[v8::internal::LAST_TYPE + 1] = {0};
+  ReadArrayFrom(memory_region, heap_stats_addr, 22, v8::internal::LAST_TYPE + 1,
+                size_per_type);
+
+  int js_global_objects =
+      objects_per_type[v8::internal::JS_GLOBAL_OBJECT_TYPE];
+  int js_builtins_objects =
+      objects_per_type[v8::internal::JS_BUILTINS_OBJECT_TYPE];
+  int js_global_proxies =
+      objects_per_type[v8::internal::JS_GLOBAL_PROXY_TYPE];
+
+  int indices[v8::internal::LAST_TYPE + 1];
+  for (int i = 0; i <= v8::internal::LAST_TYPE; i++) {
+    indices[i] = i;
+  }
+
+  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: %" PRIu32 " (%#" PRIx32 ")\n",
+         exception_thread_id, exception_thread_id);
+  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);
+  PRINT_MB_STAT(code_space_size);
+  PRINT_MB_STAT(code_space_capacity);
+  PRINT_MB_STAT(map_space_size);
+  PRINT_MB_STAT(map_space_capacity);
+  PRINT_MB_STAT(cell_space_size);
+  PRINT_MB_STAT(cell_space_capacity);
+  PRINT_MB_STAT(lo_space_size);
+  PRINT_INT_STAT(global_handle_count);
+  PRINT_INT_STAT(weak_global_handle_count);
+  PRINT_INT_STAT(pending_global_handle_count);
+  PRINT_INT_STAT(near_death_global_handle_count);
+  PRINT_INT_STAT(destroyed_global_handle_count);
+  PRINT_MB_STAT(memory_allocator_size);
+  PRINT_MB_STAT(memory_allocator_capacity);
+  PRINT_INT_STAT(os_error);
+#undef PRINT_STAT
+
+  printf("\n");
+
+  printf(
+      "\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_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);
+  }
+  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) {
+  if (argc != 2) {
+    fprintf(stderr, "usage: %s <minidump>\n", argv[0]);
+    return 1;
+  }
+
+  DumpHeapStats(argv[1]);
+
+  return 0;
+}