Script checking that the observed function order matches an orderfile.

tools/cygprofile/patch_orderfile.py

 #!/usr/bin/python
 # Copyright 2013 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.
 
 """Patch an orderfile.
 
 Starting with a list of symbols in a binary and an orderfile (ordered list of
 symbols), matches the symbols in the orderfile and augments each symbol with the
 symbols residing at the same address (due to having identical code).
 
 Note: It is possible to have.
 - Several symbols mapping to the same offset in the binary.
 - Several offsets for a given symbol (because we strip the ".clone." suffix)
 
 TODO(lizeb): Since the suffix ".clone." is only used with -O3 that we don't
 currently use, simplify the logic by removing the suffix handling.
 
 The general pipeline is:
 1. Get the symbol infos (offset, length, name) from the binary

[pasko, 2015/02/02 14:32:37]

nit:
(name, offset, size, section)

[Benoit L, 2015/02/02 15:37:05]

Done.

 2. Get the symbol names from the orderfile
 3. Find the orderfile symbol names in the symbols coming from the binary
 4. For each symbol found, get all the symbols at the same address
 5. Output them to an updated orderfile, with several different prefixes
 """
 
 import collections
 import logging
 import sys
 
@@ skipping 84 matching lines @@
     line = _StripPrefix(line)
     name = _RemoveClone(line)
     if name == '' or name == '*' or name == '.text':
       continue
     if not line in unique_symbols:
       symbols.append(line)
       unique_symbols.add(line)
   return symbols
 
 
-def _GetSymbolsFromOrderfile(filename):
+def GetSymbolsFromOrderfile(filename):

[pasko, 2015/02/02 14:32:37]

thanks for this change. So this natirally leads me to ask for more :)

What order of functions should be used? Are there any python/google/whatever
guidelines? Maybe exported functions being on top/bottom?

In Chromium C++ we have a guideline of having the functions defined in the .cc
file in the _same_ order as declared in the header. I don't particularly like
it, but it leads to less surprises for _some_ devs.

[Benoit L, 2015/02/02 15:37:05]

I would argue that once a function has been written, it should not move within
its file for no reason, to keep the noise in "git blame" output low. So I would
leave this one alone for now.

[pasko, 2015/02/02 15:52:28]

git blame -C
?

but yeah, I don't like moving functions around unnecessarily either. Here it's a
bit of a special case, where refactoring moved a lot of things anyway, and, as
we know, the primary purpose of refactoring is how the final version of the code
looks, so .. spoiled git blame is really not an issue.

   """Return the symbols from an orderfile.
 
   Args:
     filename: The name of the orderfile.
 
   Returns:
     A list of symbol names.
   """
   with open(filename, 'r') as f:
     return _GetSymbolsFromStream(f.xreadlines())
@@ skipping 68 matching lines @@
 
 
 def main(argv):
   if len(argv) != 3:
     print 'Usage: %s <unpatched_orderfile> <libchrome.so>' % argv[0]
     return 1
   orderfile_filename = argv[1]
   binary_filename = argv[2]
   (offset_to_symbol_infos, name_to_symbol_infos) = _GroupSymbolInfosFromBinary(
       binary_filename)
-  profiled_symbols = _GetSymbolsFromOrderfile(orderfile_filename)
+  profiled_symbols = GetSymbolsFromOrderfile(orderfile_filename)
   expanded_symbols = _ExpandSymbols(
       profiled_symbols, name_to_symbol_infos, offset_to_symbol_infos)
   _PrintSymbolsWithPrefixes(expanded_symbols, sys.stdout)
   # The following is needed otherwise Gold only applies a partial sort.
   print '.text'    # gets methods not in a section, such as assembly
   print '.text.*'  # gets everything else
   return 0
 
 
 if __name__ == '__main__':
   logging.basicConfig(level=logging.INFO)
   sys.exit(main(sys.argv))