Revert 222650 "Copy asan_rtl.* and agent_logger.exe to the syzyg..."

chrome/tools/build/win/syzygy_instrument.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.
 
 """A utility script to help building Syzygy-instrumented Chrome binaries."""
 
 import glob
 import logging
 import optparse
 import os
 import shutil
 import subprocess
 import sys
 
 
 # The default directory containing the Syzygy toolchain.
 _DEFAULT_SYZYGY_DIR = os.path.abspath(os.path.join(
     os.path.dirname(__file__), '../../../..',
     'third_party/syzygy/binaries/exe/'))
 
 # Basenames of various tools.
 _INSTRUMENT_EXE = 'instrument.exe'
 _GENFILTER_EXE = 'genfilter.exe'
+_ASAN_AGENT_DLL = 'asan_rtl.dll'
+
+# Default agents for known modes.
+_DEFAULT_AGENT_DLLS = { 'asan': _ASAN_AGENT_DLL }
 
 _LOGGER = logging.getLogger()
 
 
 def _Shell(*cmd, **kw):
   """Shells out to "cmd". Returns a tuple of cmd's stdout, stderr."""
   _LOGGER.info('Running command "%s".', cmd)
   prog = subprocess.Popen(cmd, **kw)
 
   stdout, stderr = prog.communicate()
@@ skipping 41 matching lines @@
   if mode == "asan":
     cmd.append('--no-augment-pdb')
 
   # If a filter was specified then pass it on to the instrumenter.
   if filter_file:
     cmd.append('--filter=%s' % os.path.abspath(filter_file))
 
   return _Shell(*cmd)
 
 
+def _CopyAgentDLL(agent_dll, destination_dir):
+  """Copy the agent DLL and PDB to the destination directory."""
+  dirname, agent_name = os.path.split(agent_dll);
+  agent_dst_name = os.path.join(destination_dir, agent_name);
+  shutil.copyfile(agent_dll, agent_dst_name)
+
+  # Search for the corresponding PDB file. We use this approach because
+  # the naming convention for PDBs has changed recently (from 'foo.pdb'
+  # to 'foo.dll.pdb') and we want to support both conventions during the
+  # transition.
+  agent_pdbs = glob.glob(os.path.splitext(agent_dll)[0] + '*.pdb')
+  if len(agent_pdbs) != 1:
+    raise RuntimeError('Failed to locate PDB file for %s' % agent_name)
+  agent_pdb = agent_pdbs[0]
+  agent_dst_pdb = os.path.join(destination_dir, os.path.split(agent_pdb)[1])
+  shutil.copyfile(agent_pdb, agent_dst_pdb)
+
+
 def main(options):
   # Make sure the destination directory exists.
   if not os.path.isdir(options.destination_dir):
     _LOGGER.info('Creating destination directory "%s".',
                  options.destination_dir)
     os.makedirs(options.destination_dir)
 
   # Compile the filter if one was provided.
   if options.filter:
     _CompileFilter(options.syzygy_dir,
                    options.input_executable,
                    options.input_symbol,
                    options.filter,
                    options.output_filter_file)
 
   # Instruments the binaries into the destination directory.
   _InstrumentBinary(options.syzygy_dir,
                     options.mode,
                     options.input_executable,
                     options.input_symbol,
                     options.destination_dir,
                     options.output_filter_file)
 
+  # Copy the agent DLL and PDB to the destination directory.
+  _CopyAgentDLL(options.agent_dll, options.destination_dir);
+
 
 def _ParseOptions():
   option_parser = optparse.OptionParser()
   option_parser.add_option('--input_executable',
       help='The path to the input executable.')
   option_parser.add_option('--input_symbol',
       help='The path to the input symbol file.')
   option_parser.add_option('--mode',
       help='Specifies which instrumentation mode is to be used.')
+  option_parser.add_option('--agent_dll',
+      help='The agent DLL used by this instrumentation. If not specified a '
+           'default will be searched for.')
   option_parser.add_option('--syzygy-dir', default=_DEFAULT_SYZYGY_DIR,
       help='Instrumenter executable to use, defaults to "%default".')
   option_parser.add_option('-d', '--destination_dir',
       help='Destination directory for instrumented files.')
   option_parser.add_option('--filter',
       help='An optional filter. This will be compiled and passed to the '
            'instrumentation executable.')
   option_parser.add_option('--output-filter-file',
       help='The path where the compiled filter will be written. This is '
            'required if --filter is specified.')
   options, args = option_parser.parse_args()
 
   if not options.mode:
     option_parser.error('You must provide an instrumentation mode.')
   if not options.input_executable:
     option_parser.error('You must provide an input executable.')
   if not options.input_symbol:
     option_parser.error('You must provide an input symbol file.')
   if not options.destination_dir:
     option_parser.error('You must provide a destination directory.')
   if options.filter and not options.output_filter_file:
     option_parser.error('You must provide a filter output file.')
 
+  if not options.agent_dll:
+    if not options.mode in _DEFAULT_AGENT_DLLS:
+      option_parser.error('No known default agent DLL for mode "%s".' %
+          options.mode)
+    options.agent_dll = os.path.abspath(os.path.join(options.syzygy_dir,
+        _DEFAULT_AGENT_DLLS[options.mode]))
+    _LOGGER.info('Using default agent DLL: %s' % options.agent_dll)
+
   return options
 
 
 if '__main__' == __name__:
   logging.basicConfig(level=logging.INFO)
   sys.exit(main(_ParseOptions()))