Rebased localmods in libcxx to 223109.

test/lit.cfg

 # -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
 
 # Configuration file for the 'lit' test runner.
 
 import errno
 import locale
 import os
 import platform
 import re
 import shlex
@@ skipping 11 matching lines @@
     """
     Custom test format handler for use with the test format use by libc++.
 
     Tests fall into two categories:
       FOO.pass.cpp - Executable test which should compile, run, and exit with
                      code 0.
       FOO.fail.cpp - Negative test case which is expected to fail compilation.
     """
 
     def __init__(self, cxx_under_test, use_verify_for_fail,
-                 cpp_flags, ld_flags, exec_env):
+                 cpp_flags, ld_flags, exec_env,
+                 # @LOCALMOD
+                 exe_suffix, shell_prefix):
         self.cxx_under_test = cxx_under_test
         self.use_verify_for_fail = use_verify_for_fail
         self.cpp_flags = list(cpp_flags)
         self.ld_flags = list(ld_flags)
         self.exec_env = dict(exec_env)
+        # @LOCALMOD-START
+        self.exe_suffix = exe_suffix
+        self.shell_prefix = shell_prefix
+        # @LOCALMOD-END
 
     def execute(self, test, lit_config):
         while True:
             try:
                 return self._execute(test, lit_config)
             except OSError, oe:
                 if oe.errno != errno.ETXTBSY:
                     raise
                 time.sleep(0.1)
 
@@ skipping 61 matching lines @@
     def _clean(self, exec_path):
         os.remove(exec_path)
 
     def _run(self, exec_path, lit_config, in_dir=None):
         cmd = []
         if self.exec_env:
             cmd.append('env')
             cmd.extend('%s=%s' % (name, value)
                        for name,value in self.exec_env.items())
         cmd.append(exec_path)
+        # @LOCALMOD-START
+        if self.shell_prefix:
+            cmd = self.shell_prefix + cmd
+        # @LOCALMOD-END
         if lit_config.useValgrind:
             cmd = lit_config.valgrindArgs + cmd
         out, err, exitCode = lit.util.executeCommand(cmd, cwd=in_dir)
         return cmd, out, err, exitCode
 
     def _evaluate_test(self, test, use_verify, lit_config):
         name = test.path_in_suite[-1]
         source_path = test.getSourcePath()
         source_dir = os.path.dirname(source_path)
 
@@ skipping 13 matching lines @@
                 report = """Command: %s\n""" % ' '.join(["'%s'" % a
                                                          for a in cmd])
                 report += """Exit Code: %d\n""" % rc
                 if out:
                     report += """Standard Output:\n--\n%s--""" % out
                 if err:
                     report += """Standard Error:\n--\n%s--""" % err
                 report += "\n\nExpected compilation to fail!"
                 return lit.Test.FAIL, report
         else:
-            exec_file = tempfile.NamedTemporaryFile(suffix="exe", delete=False)
+            # @LOCALMOD-START
+            exec_file = tempfile.NamedTemporaryFile(
+                suffix=self.exe_suffix, delete=False)
+            # @LOCALMOD-END
             exec_path = exec_file.name
             exec_file.close()
 
             try:
                 cmd, out, err, rc = self._build(exec_path, source_path)
                 compile_cmd = cmd
                 if rc != 0:
                     report = """Command: %s\n""" % ' '.join(["'%s'" % a
                                                              for a in cmd])
                     report += """Exit Code: %d\n""" % rc
@@ skipping 25 matching lines @@
                     self._clean(exec_path)
                 except:
                     pass
         return lit.Test.PASS, ""
 
 
 class Configuration(object):
     def __init__(self, lit_config, config):
         self.lit_config = lit_config
         self.config = config
+        # @LOCALMOD-START
+        self.exe_suffix = None
+        self.shell_prefix = None
+        # @LOCALMOD-END
         self.cxx = None
         self.src_root = None
         self.obj_root = None
         self.env = {}
         self.compile_flags = ['-nostdinc++']
         self.link_flags = ['-nodefaultlibs']
         self.use_system_lib = False
         self.use_clang_verify = False
 
         if platform.system() not in ('Darwin', 'FreeBSD', 'Linux'):
@@ skipping 12 matching lines @@
         if conf is None:
             return None
         if conf.lower() in ('1', 'true'):
             return True
         if conf.lower() in ('', '0', 'false'):
             return False
         self.lit_config.fatal(
             "parameter '{}' should be true or false".format(name))
 
     def configure(self):
+        # @LOCALMOD
+        self.configure_exe_wrappers()
         self.configure_cxx()
         self.configure_triple()
         self.configure_src_root()
         self.configure_obj_root()
         self.configure_use_system_lib()
         self.configure_use_clang_verify()
         self.configure_env()
         self.configure_std_flag()
         self.configure_compile_flags()
         self.configure_link_flags()
         self.configure_sanitizer()
         self.configure_features()
+        # @LOCALMOD-START -- filter out nostdinc++ and nodefaultlibs if needed.
+        if self.use_system_lib:
+            self.compile_flags = [flag for flag in self.compile_flags
+                                  if flag != '-nostdinc++']
+            self.link_flags = [flag for flag in self.link_flags
+                               if flag != '-nodefaultlibs']
+        # @LOCALMOD-END
         # Print the final compile and link flags.
         self.lit_config.note('Using compile flags: %s' % self.compile_flags)
         self.lit_config.note('Using link flags: %s' % self.link_flags)
         # Print as list to prevent "set([...])" from being printed.
         self.lit_config.note('Using available_features: %s' %
                              list(self.config.available_features))
 
     def get_test_format(self):
         return LibcxxTestFormat(
             self.cxx,
             self.use_clang_verify,
             cpp_flags=self.compile_flags,
             ld_flags=self.link_flags,
-            exec_env=self.env)
+            exec_env=self.env,
+            # @LOCALMOD
+            exe_suffix=self.exe_suffix,
+            shell_prefix=self.shell_prefix)
+
+    # @LOCALMOD-START
+    def configure_exe_wrappers(self):
+        # Allow customizing the resulting executable's suffix
+        # as well as an wrapper around how to run the executable
+        # via a shell_prefix.
+        self.exe_suffix = self.get_lit_conf('exe_suffix', 'exe')
+        self.shell_prefix = self.get_lit_conf('shell_prefix', None)
+        if self.shell_prefix:
+            self.shell_prefix = shlex.split(self.shell_prefix)
+    # @LOCALMOD-END
 
     def configure_cxx(self):
         # Gather various compiler parameters.
         self.cxx = self.get_lit_conf('cxx_under_test')
 
         # If no specific cxx_under_test was given, attempt to infer it as
         # clang++.
         if self.cxx is None:
             clangxx = lit.util.which('clang++',
                                      self.config.environment['PATH'])
@@ skipping 255 matching lines @@
 config.test_source_root = os.path.dirname(__file__)
 
 cfg_variant = getattr(config, 'configuration_variant', '')
 if cfg_variant:
     print 'Using configuration variant: %s' % cfg_variant
 
 # Construct an object of the type named `<VARIANT>Configuration`.
 configuration = globals()['%sConfiguration' % cfg_variant](lit_config, config)
 configuration.configure()
 config.test_format = configuration.get_test_format()