[Isolates] Merge 6700:7030 from bleeding_edge to isolates.

tools/ll_prof.py

 #!/usr/bin/env python
 #
 # 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
@@ skipping 12 matching lines @@
 # 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.
 
 import bisect
 import collections
 import ctypes
+import disasm
 import mmap
 import optparse
 import os
 import re
 import subprocess
 import sys
-import tempfile
 import time
 
 
 USAGE="""usage: %prog [OPTION]...
 
 Analyses V8 and perf logs to produce profiles.
 
 Perf logs can be collected using a command like:
   $ perf record -R -e cycles -c 10000 -f -i ./shell bench.js --ll-prof
   # -R: collect all data
@@ skipping 17 matching lines @@
   $ %prog --log=foo.log --snapshot-log=snap-foo.log --trace=foo.data --snapshot
 """
 
 
 # Must match kGcFakeMmap.
 V8_GC_FAKE_MMAP = "/tmp/__v8_gc__"
 
 JS_ORIGIN = "js"
 JS_SNAPSHOT_ORIGIN = "js-snapshot"
 
-# Avoid using the slow (google-specific) wrapper around objdump.
-OBJDUMP_BIN = "/usr/bin/objdump"
-if not os.path.exists(OBJDUMP_BIN):
-  OBJDUMP_BIN = "objdump"
+OBJDUMP_BIN = disasm.OBJDUMP_BIN
 
 
 class Code(object):
   """Code object."""
 
-  _COMMON_DISASM_OPTIONS = ["-M", "intel-mnemonic", "-C"]
-
-  _DISASM_HEADER_RE = re.compile(r"[a-f0-9]+\s+<.*:$")
-  _DISASM_LINE_RE = re.compile(r"\s*([a-f0-9]+):.*")
-
-  # Keys must match constants in Logger::LogCodeInfo.
-  _ARCH_MAP = {
-    "ia32": "-m i386",
-    "x64": "-m i386 -M x86-64",
-    "arm": "-m arm"  # Not supported by our objdump build.
-  }
-
   _id = 0
 
   def __init__(self, name, start_address, end_address, origin, origin_offset):
     self.id = Code._id
     Code._id += 1
     self.name = name
     self.other_names = None
     self.start_address = start_address
     self.end_address = end_address
     self.origin = origin
@@ skipping 35 matching lines @@
     if self.self_ticks_map is None:
       ticks_map = []
     else:
       ticks_map = self.self_ticks_map.items()
     # Convert the ticks map to offsets and counts arrays so that later
     # we can do binary search in the offsets array.
     ticks_map.sort(key=lambda t: t[0])
     ticks_offsets = [t[0] for t in ticks_map]
     ticks_counts = [t[1] for t in ticks_map]
     # Get a list of disassembled lines and their addresses.
-    lines = []
-    for line in self._GetDisasmLines(code_info, options):
-      match = Code._DISASM_LINE_RE.match(line)
-      if match:
-        line_address = int(match.group(1), 16)
-        lines.append((line_address, line))
+    lines = self._GetDisasmLines(code_info, options)
     if len(lines) == 0:
       return
     # Print annotated lines.
     address = lines[0][0]
     total_count = 0
     for i in xrange(len(lines)):
       start_offset = lines[i][0] - address
       if i == len(lines) - 1:
         end_offset = self.end_address - self.start_address
       else:
         end_offset = lines[i + 1][0] - address
       # Ticks (reported pc values) are not always precise, i.e. not
       # necessarily point at instruction starts. So we have to search
       # for ticks that touch the current instruction line.
       j = bisect.bisect_left(ticks_offsets, end_offset)
       count = 0
       for offset, cnt in reversed(zip(ticks_offsets[:j], ticks_counts[:j])):
         if offset < start_offset:
           break
         count += cnt
       total_count += count
       count = 100.0 * count / self.self_ticks
       if count >= 0.01:
-        print "%15.2f %s" % (count, lines[i][1])
+        print "%15.2f %x: %s" % (count, lines[i][0], lines[i][1])
       else:
-        print "%s %s" % (" " * 15, lines[i][1])
+        print "%s %x: %s" % (" " * 15, lines[i][0], lines[i][1])
     print
     assert total_count == self.self_ticks, \
         "Lost ticks (%d != %d) in %s" % (total_count, self.self_ticks, self)
 
   def __str__(self):
     return "%s [0x%x, 0x%x) size: %d origin: %s" % (
       self.name,
       self.start_address,
       self.end_address,
       self.end_address - self.start_address,
       self.origin)
 
   def _GetDisasmLines(self, code_info, options):
-    tmp_name = None
     if self.origin == JS_ORIGIN or self.origin == JS_SNAPSHOT_ORIGIN:
-      assert code_info.arch in Code._ARCH_MAP, \
-          "Unsupported architecture '%s'" % arch
-      arch_flags = Code._ARCH_MAP[code_info.arch]
-      # Create a temporary file just with this code object.
-      tmp_name = tempfile.mktemp(".v8code")
-      size = self.end_address - self.start_address
-      command = "dd if=%s.code of=%s bs=1 count=%d skip=%d && " \
-                "%s %s -D -b binary %s %s" % (
-        options.log, tmp_name, size, self.origin_offset,
-        OBJDUMP_BIN, ' '.join(Code._COMMON_DISASM_OPTIONS), arch_flags,
-        tmp_name)
+      inplace = False
+      filename = options.log + ".code"
     else:
-      command = "%s %s --start-address=%d --stop-address=%d -d %s " % (
-        OBJDUMP_BIN, ' '.join(Code._COMMON_DISASM_OPTIONS),
-        self.origin_offset,
-        self.origin_offset + self.end_address - self.start_address,
-        self.origin)
-    process = subprocess.Popen(command,
-                               shell=True,
-                               stdout=subprocess.PIPE,
-                               stderr=subprocess.STDOUT)
-    out, err = process.communicate()
-    lines = out.split("\n")
-    header_line = 0
-    for i, line in enumerate(lines):
-      if Code._DISASM_HEADER_RE.match(line):
-        header_line = i
-        break
-    if tmp_name:
-      os.unlink(tmp_name)
-    return lines[header_line + 1:]
+      inplace = True
+      filename = self.origin
+    return disasm.GetDisasmLines(filename,
+                                 self.origin_offset,
+                                 self.end_address - self.start_address,
+                                 code_info.arch,
+                                 inplace)
 
 
 class CodePage(object):
   """Group of adjacent code objects."""
 
   SHIFT = 12  # 4K pages
   SIZE = (1 << SHIFT)
   MASK = ~(SIZE - 1)
 
   @staticmethod
@@ skipping 105 matching lines @@
     self.header_size = header_size
 
 
 class CodeLogReader(object):
   """V8 code event log reader."""
 
   _CODE_INFO_RE = re.compile(
     r"code-info,([^,]+),(\d+)")
 
   _CODE_CREATE_RE = re.compile(
-    r"code-creation,([^,]+),(0x[a-f0-9]+),(\d+),\"(.*)\"(?:,(\d+))?")
+    r"code-creation,([^,]+),(0x[a-f0-9]+),(\d+),\"(.*)\"(?:,(0x[a-f0-9]+),([~*])?)?(?:,(\d+))?")
 
   _CODE_MOVE_RE = re.compile(
     r"code-move,(0x[a-f0-9]+),(0x[a-f0-9]+)")
 
   _CODE_DELETE_RE = re.compile(
     r"code-delete,(0x[a-f0-9]+)")
 
   _SNAPSHOT_POS_RE = re.compile(
     r"snapshot-pos,(0x[a-f0-9]+),(\d+)")
 
@@ skipping 26 matching lines @@
         return made_progress
 
       match = CodeLogReader._CODE_CREATE_RE.match(line)
       if match:
         start_address = int(match.group(2), 16) + code_header_size
         end_address = start_address + int(match.group(3)) - code_header_size
         if start_address in self.address_to_snapshot_name:
           name = self.address_to_snapshot_name[start_address]
           origin = JS_SNAPSHOT_ORIGIN
         else:
-          name = "%s:%s" % (match.group(1), match.group(4))
+          tag = match.group(1)
+          optimization_status = match.group(6)
+          func_name = match.group(4)
+          if optimization_status:
+            name = "%s:%s%s" % (tag, optimization_status, func_name)
+          else:
+            name = "%s:%s" % (tag, func_name)
           origin = JS_ORIGIN
         if self.is_snapshot:
           origin_offset = 0
         else:
-          origin_offset = int(match.group(5))
+          origin_offset = int(match.group(7))
         code = Code(name, start_address, end_address, origin, origin_offset)
         conficting_code = self.code_map.Find(start_address)
         if conficting_code:
           CodeLogReader._HandleCodeConflict(conficting_code, code)
           # TODO(vitalyr): this warning is too noisy because of our
           # attempts to reconstruct code log from the snapshot.
           # print >>sys.stderr, \
           #     "Warning: Skipping duplicate code log entry %s" % code
           continue
         self.code_map.Add(code)
@@ skipping 527 matching lines @@
       print "%10d total ticks" % ticks
       print "%10d ticks not in symbols" % missed_ticks
       print "%10d unaccounted ticks" % really_missed_ticks
       print "%10d total symbols" % len([c for c in code_map.AllCode()])
       print "%10d used symbols" % len([c for c in code_map.UsedCode()])
       print "%9.2fs library processing time" % mmap_time
       print "%9.2fs tick processing time" % sample_time
 
   log_reader.Dispose()
   trace_reader.Dispose()