Estimates a path in host from a corresponding path in Android device.

tools/find_runtime_symbols/prepare_symbol_info.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.
 
 import json
 import logging
 import os
 import re
 import shutil
@@ skipping 37 matching lines @@
     return None
 
   if not os.path.exists(filename_out):
     return None
 
   return filename_out
 
 
 def prepare_symbol_info(maps_path,
                         output_dir_path=None,
-                        fake_directories=None,
+                        alternative_dirs=None,
                         use_tempdir=False,
                         use_source_file_name=False):
   """Prepares (collects) symbol information files for find_runtime_symbols.
 
   1) If |output_dir_path| is specified, it tries collecting symbol information
   files in the given directory |output_dir_path|.
   1-a) If |output_dir_path| doesn't exist, create the directory and use it.
   1-b) If |output_dir_path| is an empty directory, use it.
   1-c) If |output_dir_path| is a directory which has 'files.json', assumes that
        files are already collected and just ignores it.
   1-d) Otherwise, depends on |use_tempdir|.
 
   2) If |output_dir_path| is not specified, it tries to create a new directory
   depending on 'maps_path'.
 
   If it cannot create a new directory, creates a temporary directory depending
   on |use_tempdir|.  If |use_tempdir| is False, returns None.
 
   Args:
       maps_path: A path to a file which contains '/proc/<pid>/maps'.
-      fake_directories: A mapping from a directory '/path/on/target' where the
+      alternative_dirs: A mapping from a directory '/path/on/target' where the
           target process runs to a directory '/path/on/host' where the script
           reads the binary.  Considered to be used for Android binaries.
       output_dir_path: A path to a directory where files are prepared.
       use_tempdir: If True, it creates a temporary directory when it cannot
           create a new directory.
       use_source_file_name: If True, it adds reduced result of 'readelf -wL'
           to find source file names.
 
   Returns:
       A pair of a path to the prepared directory and a boolean representing
       if it created a temporary directory or not.
   """
-  fake_directories = fake_directories or {}
+  alternative_dirs = alternative_dirs or {}
   if not output_dir_path:
     matched = re.match('^(.*)\.maps$', os.path.basename(maps_path))
     if matched:
       output_dir_path = matched.group(1) + '.pre'
   if not output_dir_path:
     matched = re.match('^/proc/(.*)/maps$', os.path.realpath(maps_path))
     if matched:
       output_dir_path = matched.group(1) + '.pre'
   if not output_dir_path:
     output_dir_path = os.path.basename(maps_path) + '.pre'
@@ skipping 35 matching lines @@
 
   with open(maps_path, mode='r') as f:
     maps = ProcMaps.load(f)
 
   LOGGER.debug('Listing up symbols.')
   files = {}
   for entry in maps.iter(ProcMaps.executable):
     LOGGER.debug('  %016x-%016x +%06x %s' % (
         entry.begin, entry.end, entry.offset, entry.name))
     binary_path = entry.name
-    for target_path, host_path in fake_directories.iteritems():
+    for target_path, host_path in alternative_dirs.iteritems():
       if entry.name.startswith(target_path):
         binary_path = entry.name.replace(target_path, host_path, 1)
     nm_filename = _dump_command_result(
         'nm -n --format bsd %s | c++filt' % binary_path,
         output_dir_path, os.path.basename(binary_path), '.nm')
     if not nm_filename:
       continue
     readelf_e_filename = _dump_command_result(
         'readelf -eW %s' % binary_path,
         output_dir_path, os.path.basename(binary_path), '.readelf-e')
@@ skipping 28 matching lines @@
     sys.stderr.write('This script work only on Linux.')
     return 1
 
   LOGGER.setLevel(logging.DEBUG)
   handler = logging.StreamHandler()
   handler.setLevel(logging.INFO)
   formatter = logging.Formatter('%(message)s')
   handler.setFormatter(formatter)
   LOGGER.addHandler(handler)
 
-  # TODO(dmikurube): Specify |fake_directories| from command line.
+  # TODO(dmikurube): Specify |alternative_dirs| from command line.
   if len(sys.argv) < 2:
     sys.stderr.write("""Usage:
 %s /path/to/maps [/path/to/output_data_dir/]
 """ % sys.argv[0])
     return 1
   elif len(sys.argv) == 2:
     result, _ = prepare_symbol_info(sys.argv[1])
   else:
     result, _ = prepare_symbol_info(sys.argv[1], sys.argv[2])
 
   return not result
 
 
 if __name__ == '__main__':
   sys.exit(main())