Run dsymutil before valgrind (Mac)

tools/valgrind/valgrind_test.py

 #!/usr/bin/python
 # Copyright (c) 2006-2008 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.
 
 # purify_test.py
 
 '''Runs an exe through Valgrind and puts the intermediate files in a
 directory.
 '''
 
 import datetime
 import glob
 import logging
 import optparse
 import os
+import re
 import shutil
 import stat
 import sys
 import tempfile
 
 import common
 
 import valgrind_analyze
 
 import google.logging_utils
@@ skipping 66 matching lines @@
     if self._options.verbose:
       google.logging_utils.config_root(logging.DEBUG)
     else:
       google.logging_utils.config_root()
 
     return True
 
   def Setup(self):
     return self.ParseArgv()
 
+  def PrepareForTest(self):
+    """Perform necessary tasks prior to executing the test."""
+    pass
+
   def ValgrindCommand(self):
     """Get the valgrind command to run."""
     raise RuntimeError, "Never use Valgrind directly. Always subclass and " \
                         "implement ValgrindCommand() at least"
 
   def Execute(self):
     ''' Execute the app to be tested after successful instrumentation.
     Full execution command-line provided by subclassers via proc.'''
     logging.info("starting execution...")
 
@@ skipping 16 matching lines @@
     analyzer = valgrind_analyze.ValgrindAnalyze(self._source_dir, filenames, self._options.show_all_leaks)
     return analyzer.Report()
 
   def Cleanup(self):
     # Right now, we can cleanup by deleting our temporary directory. Other
     # cleanup is still a TODO?
     shutil.rmtree(self.TMP_DIR)
     return True
 
   def RunTestsAndAnalyze(self):
+    self.PrepareForTest()
+
     self.Execute()
     if self._generate_suppressions:
       logging.info("Skipping analysis to let you look at the raw output...")
       return 0
 
     retcode = self.Analyze()
     if retcode:
       logging.error("Analyze failed.")
       return retcode
     logging.info("Execution and analysis completed successfully.")
@@ skipping 84 matching lines @@
 class ValgrindMac(Valgrind):
 
   """Valgrind on Mac OS X.
 
   Valgrind on OS X does not support suppressions (yet).
   """
 
   def __init__(self):
     Valgrind.__init__(self)
 
+  def PrepareForTest(self):
+    """Runs dsymutil if needed.
+
+    Valgrind for Mac OS X requires that debugging information be in a .dSYM
+    bundle generated by dsymutil.  It is not currently able to chase DWARF
+    data into .o files like gdb does, so executables without .dSYM bundles or
+    with the Chromium-specific "fake_dsym" bundles generated by
+    build/mac/strip_save_dsym won't give source file and line number
+    information in valgrind.
+
+    This function will run dsymutil if the .dSYM bundle is missing or if
+    it looks like a fake_dsym.  A non-fake dsym that already exists is assumed
+    to be up-to-date.
+    """
+
+    test_command = self._args[0]
+    dsym_bundle = self._args[0] + '.dSYM'
+    dsym_file = os.path.join(dsym_bundle, 'Contents', 'Resources', 'DWARF',
+                             os.path.basename(test_command))
+    dsym_info_plist = os.path.join(dsym_bundle, 'Contents', 'Info.plist')
+
+    needs_dsymutil = True
+    saved_test_command = None
+
+    if os.path.exists(dsym_file) and os.path.exists(dsym_info_plist):
+      # Look for the special fake_dsym tag in dsym_info_plist.
+      dsym_info_plist_contents = open(dsym_info_plist).read()
+
+      if not re.search('^\s*<key>fake_dsym</key>$', dsym_info_plist_contents,
+                       re.MULTILINE):
+        # fake_dsym is not set, this is a real .dSYM bundle produced by
+        # dsymutil.  dsymutil does not need to be run again.
+        needs_dsymutil = False
+      else:
+        # fake_dsym is set.  dsym_file is a copy of the original test_command
+        # before it was stripped.  Copy it back to test_command so that
+        # dsymutil has unstripped input to work with.  Move the stripped
+        # test_command out of the way, it will be restored when this is
+        # done.
+        saved_test_command = test_command + '.stripped'
+        os.rename(test_command, saved_test_command)
+        shutil.copyfile(dsym_file, test_command)
+
+    if needs_dsymutil:
+      # Remove the .dSYM bundle if it exists.
+      shutil.rmtree(dsym_bundle, True)
+
+      dsymutil_command = ['dsymutil', test_command]
+
+      # dsymutil is crazy slow.  Let it run for up to a half hour.  I hope
+      # that's enough.
+      common.RunSubprocess(dsymutil_command, 30 * 60)
+
+      if saved_test_command:
+        os.rename(saved_test_command, test_command)

[TVL, 2009/03/27 20:04:31]

do you want an exception handler on any of this to make sure you clean up?

+
   def ValgrindCommand(self):
     """Get the valgrind command to run."""
     proc = ["valgrind", "--smc-check=all", "--leak-check=full",
             "--num-callers=30"]
 
     if self._options.show_all_leaks:
       proc += ["--show-reachable=yes"];
 
     # Either generate suppressions or load them.
     # TODO(nirnimesh): Enable when Analyze() is implemented
@@ skipping 28 matching lines @@
     valgrind = ValgrindMac()
     retcode = valgrind.Main()
     sys.exit(retcode)
   elif sys.platform == 'linux2': # Linux
     valgrind = ValgrindLinux()
     retcode = valgrind.Main()
     sys.exit(retcode)
   else:
     logging.error("Unknown platform: %s" % sys.platform)
     sys.exit(1)