Check that the user doesn't try to run ASan-built binaries under Valgrind etc

tools/valgrind/chrome_tests.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.
 
 ''' Runs various chrome tests through valgrind_test.py.'''
 
 import glob
 import logging
 import multiprocessing
 import optparse
 import os
 import stat
+import subprocess
 import sys
 
 import logging_utils
 import path_utils
 
 import common
 import valgrind_test
 
 class TestNotFound(Exception): pass
 
 class MultipleGTestFiltersSpecified(Exception): pass
 
 class BuildDirNotFound(Exception): pass
 
 class BuildDirAmbiguous(Exception): pass
 
+class ExecutableNotFound(Exception): pass
+
+class BadBinary(Exception): pass
+
 class ChromeTests:
   SLOW_TOOLS = ["memcheck", "tsan", "tsan_rv", "drmemory"]
   LAYOUT_TESTS_DEFAULT_CHUNK_SIZE = 300
 
   def __init__(self, options, args, test):
     if ':' in test:
       (self._test, self._gtest_filter) = test.split(':', 1)
     else:
       self._test = test
       self._gtest_filter = options.gtest_filter
@@ skipping 68 matching lines @@
 
     if self._options.valgrind_tool_flags:
       cmd += self._options.valgrind_tool_flags.split(" ")
     if self._options.keep_logs:
       cmd += ["--keep_logs"]
     if valgrind_test_args != None:
       for arg in valgrind_test_args:
         cmd.append(arg)
     if exe:
       self._EnsureBuildDirFound()
-      cmd.append(os.path.join(self._options.build_dir, exe))
+      exe_path = os.path.join(self._options.build_dir, exe)
+      if not os.path.exists(exe_path):
+        raise ExecutableNotFound("Couldn't find '%s'" % exe_path)
+
+      # Make sure we don't try to test ASan-built binaries with other dynamic
+      # tools if `nm` is available.
+      if subprocess.call(["which", "nm"]) == 0:

[Alexander Potapenko, 2014/10/02 13:19:08]

just wrapping subprocess.check_output() into a try..catch block is enough.

+        nm_output = subprocess.check_output(["nm", exe_path])
+        if nm_output.find("__asan_init") != -1:
+          raise BadBinary("You're trying to run an executable instrumented "
+                          "with AddressSanitizer under %s. Please provide "
+                          "an uninstrumented executable." % tool_name)
+
+      cmd.append(exe_path)
       # Valgrind runs tests slowly, so slow tests hurt more; show elapased time
       # so we can find the slowpokes.
       cmd.append("--gtest_print_time")
       # Built-in test launcher for gtest-based executables runs tests using
       # multiple process by default. Force the single-process mode back.
       cmd.append("--single-process-tests")
     if self._options.gtest_repeat:
       cmd.append("--gtest_repeat=%s" % self._options.gtest_repeat)
     if self._options.gtest_shuffle:
       cmd.append("--gtest_shuffle")
@@ skipping 647 matching lines @@
 
   for t in options.test:
     tests = ChromeTests(options, args, t)
     ret = tests.Run()
     if ret: return ret
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(_main())