Add '-d' flag to dump-static-initializers.py

tools/linux/dump-static-initializers.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Dump functions called by static intializers in a Linux Release binary.
 
 Usage example:
   tools/linux/dump-static-intializers.py out/Release/chrome
 
@@ skipping 78 matching lines @@
     if candidate != filename:  # More than one candidate; return bare filename.
       return filename
     candidate = line.strip()
   return candidate
 
 # Regex matching nm output for the symbols we're interested in.
 # Example line:
 #   0000000001919920 0000000000000008 b _ZN12_GLOBAL__N_119g_nine_box_prelightE
 nm_re = re.compile(r'(\S+) (\S+) t _GLOBAL__I_(.*)')
 def ParseNm(binary):
-  """Given a binary, yield static initializers as (start, size, file) pairs."""
+  """Given a binary, yield static initializers as (file, start, size) tuples."""

[Tyler Breisacher (Chromium), 2012/01/26 22:36:33]

I switched the order so that it would always be sorted by filename. The start is
likely to change from one build to the next, but the filename is not.

 
   nm = subprocess.Popen(['nm', '-S', binary], stdout=subprocess.PIPE)
+  files = []

[Lei Zhang, 2012/01/27 19:18:38]

This defeats the purpose of having the yield().

[Tyler Breisacher (Chromium), 2012/01/30 23:28:16]

Done. Also at line 135 in patchset 4.

   for line in nm.stdout:
     match = nm_re.match(line)
     if match:
       addr, size, filename = match.groups()
-      yield int(addr, 16), int(size, 16), filename
+      files.append((filename, int(addr, 16), int(size, 16)))
+
+  for f in sorted(files):

[Evan Martin, 2012/01/27 19:52:09]

I'd weakly prefer for this function to remain unsorted and have the caller sort
if it needs it.  That would allow you to keep the yield as well.

[Tyler Breisacher (Chromium), 2012/01/30 23:28:16]

Done.

+    yield f
 
 
 # Regex matching objdump output for the symbols we're interested in.
 # Example line:
 #     12354ab:  (disassembly, including <FunctionReference>)
 disassembly_re = re.compile(r'^\s+[0-9a-f]+:.*<(\S+)>')
 def ExtractSymbolReferences(binary, start, end):
   """Given a span of addresses, yields symbol references from disassembly."""
   cmd = ['objdump', binary, '--disassemble',
          '--start-address=0x%x' % start, '--stop-address=0x%x' % end]
   objdump = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 
   refs = set()
   for line in objdump.stdout:
     if '__static_initialization_and_destruction' in line:
       raise RuntimeError, ('code mentions '
                            '__static_initialization_and_destruction; '
                            'did you accidentally run this on a Debug binary?')
     match = disassembly_re.search(line)
     if match:
       (ref,) = match.groups()
       if ref.startswith('.LC') or ref.startswith('_DYNAMIC'):
         # Ignore these, they are uninformative.
         continue
       if ref.startswith('_GLOBAL__I_'):
         # Probably a relative jump within this function.
         continue
       refs.add(ref)
-      continue
 
   for ref in sorted(refs):
     yield ref
 
-
 def main():
-  parser = optparse.OptionParser(usage='%prog filename')
-  parser.add_option('-i', '--instances', dest='calculate_instances',
+  parser = optparse.OptionParser(usage='%prog [option] filename')
+  parser.add_option('-f', '--files', dest='count_files',
                     action='store_true', default=False,
-                    help='Only print out the number of static initializers')
+                    help='Print out the number of files containing static '
+                         'initializers')
+  parser.add_option('-i', '--instances', dest='count_initializers',
+                    action='store_true', default=False,
+                    help='Print out the number of static initializers')
+  parser.add_option('-d', '--diffable', dest='diffable',
+                    action='store_true', default=False,
+                    help='Prints the filename on each line, for more easily '
+                         'diff-able output.')
   opts, args = parser.parse_args()
   if len(args) != 1:
     parser.error('missing filename argument')
     return 1
   binary = args[0]
 
+  if opts.count_files and opts.count_initializers:
+    parser.error('-f and -i are mutually exclusive')
+    return 1
+
+  if opts.diffable and (opts.count_initializers or opts.count_files):
+    parser.error('-d cannot be used with -f or -i')
+    return 1
+
   demangler = Demangler()
-  static_initializers_count = 0
-  for addr, size, filename in ParseNm(binary):
-    if size == 2:

[Tyler Breisacher (Chromium), 2012/01/26 22:36:33]

I discussed this with fischman@ and he said that we *do* want to count these
little two-byte ctors, because they still get called at runtime, even though
they don't do anything. If I'm understanding
http://neugierig.org/software/chromium/notes/2011/08/static-initializers.html
correctly, what's important is reducing the *number* of SIs, not just getting
rid of the biggest ones.

[Lei Zhang, 2012/01/27 19:18:38]

From the comment, it sounds like many of these are accidentally generated in the
current version of gcc and there's nothing we can do to fix them. Counting them
won't do us any good.

[Tyler Breisacher (Chromium), 2012/01/27 19:44:19]

But we can make sure they're not called at load time. On the other hand, if
we're going to switch to GCC 4.6+ at some point, then maybe it doesn't matter.

[Evan Martin, 2012/01/27 19:52:09]

Yes, that is my belief.  Removing them will make the code needlessly cluttered
and it's really a compiler bug.

-      # gcc generates a two-byte 'repz retq' initializer when there is nothing
-      # to do.  jyasskin tells me this is fixed in gcc 4.6.
-      # Two bytes is too small to do anything, so just ignore it.
+  file_count = 0
+  initializer_count = 0
+  for filename, addr, size in ParseNm(binary):
+    if opts.count_files:
+      file_count += 1

[Lei Zhang, 2012/01/27 19:18:38]

Isn't this going to count a given file multiple times?

[Tyler Breisacher (Chromium), 2012/01/27 19:44:19]

I don't think so, because of the |continue| after it.

       continue
 
-    if (opts.calculate_instances):
-      static_initializers_count += 1
-      continue
-
-    ref_output = ''
+    ref_output = []
     qualified_filename = QualifyFilenameAsProto(filename)
     for ref in ExtractSymbolReferences(binary, addr, addr+size):
+      if opts.count_initializers:
+        initializer_count += 1
+        continue
+
       ref = demangler.Demangle(ref)
       if qualified_filename == filename:
         qualified_filename = QualifyFilename(filename, ref)
       if ref in NOTES:
-        ref_output = ref_output + '  %s [%s]\n' % (ref, NOTES[ref])
+        ref_output.append('  %s [%s]' % (ref, NOTES[ref]))
       else:
-        ref_output = ref_output + '  ' + ref + '\n'
-    print '%s (initializer offset 0x%x size 0x%x)' % (qualified_filename,
-                                                      addr, size)
-    print ref_output
+        ref_output.append('  ' + ref)
 
-  if opts.calculate_instances:
-    print static_initializers_count
+    if opts.count_initializers:
+      continue
+
+    if opts.diffable:
+      print '\n'.join(qualified_filename + r for r in ref_output)
+    else:
+      print '%s (initializer offset 0x%x size 0x%x)' % (qualified_filename,
+                                                        addr, size)
+      print '\n'.join(ref_output) + '\n'
+
+  if opts.count_files:
+    print file_count
+
+  if opts.count_initializers:
+    print initializer_count
   return 0
 
-
 if '__main__' == __name__:
   sys.exit(main())