Split the TargetInfo stuff from D7380 into its own patch.

[jroelofs]

Summary

@danalbert already LGTM'd this part, but I'll give another chance to give it a once-over.

[danalbert]

LGTM

libcxx/test/config.py

111

I'd prefer importlib + getattr instead of eval.

[jroelofs]

Committed r229111.

CMakeLists.txt

set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
       "Configuration variant to use for LIT.")
 
   pythonize_bool(LIBCXX_ENABLE_EXCEPTIONS)
   pythonize_bool(LIBCXX_ENABLE_RTTI)
   pythonize_bool(LIBCXX_ENABLE_SHARED)
   pythonize_bool(LIBCXX_BUILD_32_BITS)
   pythonize_bool(LIBCXX_ENABLE_THREADS)
   pythonize_bool(LIBCXX_ENABLE_MONOTONIC_CLOCK)
+  set(LIBCXX_TARGET_INFO "None" CACHE STRING
+      "TargetInfo to use when setting up test environment.")
 
   set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
 
   configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
     @ONLY)
 

libcxx/test/config.py

 import locale
 import os
 import platform
 import pkgutil
 import re
 import shlex
 import sys
 
 import lit.Test  # pylint: disable=import-error,no-name-in-module
 import lit.util  # pylint: disable=import-error,no-name-in-module
 
 from libcxx.test.format import LibcxxTestFormat
 from libcxx.compiler import CXXCompiler
-
+from libcxx.test.target_info import *
 
 def loadSiteConfig(lit_config, config, param_name, env_name):
     # We haven't loaded the site specific configuration (the user is
     # probably trying to run on a test file directly, and either the site
     # configuration hasn't been created by the build system, or we are in an
     # out-of-tree build situation).
     site_cfg = lit_config.params.get(param_name,
                                      os.environ.get(env_name))
def __init__(self, lit_config, config):
         self.cxx_library_root = None
         self.env = {}
         self.use_target = False
         self.use_system_cxx_lib = False
         self.use_clang_verify = False
         self.long_tests = None
         self.execute_external = False
 
-        if platform.system() not in ('Darwin', 'FreeBSD', 'Linux'):
-            self.lit_config.fatal("unrecognized system")
-
     def get_lit_conf(self, name, default=None):
         val = self.lit_config.params.get(name, None)
         if val is None:
             val = getattr(self.config, name, None)
             if val is None:
                 val = default
         return val
 
     def get_lit_bool(self, name, default=None):
         conf = self.get_lit_conf(name)
         if conf is None:
             return default
         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):
+        self.configure_target_info()
         self.configure_cxx()
         self.configure_triple()
         self.configure_src_root()
         self.configure_obj_root()
         self.configure_cxx_library_root()
         self.configure_use_system_cxx_lib()
         self.configure_use_clang_verify()
         self.configure_execute_external()
def print_config_info(self):
         self.lit_config.note('Using compile flags: %s'
                              % self.cxx.compile_flags)
         self.lit_config.note('Using link flags: %s' % self.cxx.link_flags)
         # Print as list to prevent "set([...])" from being printed.
         self.lit_config.note('Using available_features: %s' %
                              list(self.config.available_features))
         self.lit_config.note('Using environment: %r' % self.env)
 
+    def configure_target_info(self):
+        info_str = self.get_lit_conf('target_info', "None")
+        self.target_info = eval(info_str)
+        if self.target_info:
+            self.lit_config.note("inferred target_info as: %r" % info_str)
+        else:
+            self.target_info = LocalTI()
+
     def get_test_format(self):
         return LibcxxTestFormat(
             self.cxx,
             self.use_clang_verify,
             self.execute_external,
             exec_env=self.env)
 
     def configure_cxx(self):
def configure_features(self):
                 'cs_CZ.ISO8859-2': 'Czech_Czech Republic.1250',
                 'fr_FR.UTF-8': 'French_France.1252',
                 'fr_CA.ISO8859-1': 'French_Canada.1252',
                 'ru_RU.UTF-8': 'Russian_Russia.1251',
                 'zh_CN.UTF-8': 'Chinese_China.936',
             },
         }
 
+        target_system = self.target_info.system()
+        target_platform = self.target_info.platform()
+
         default_locale = locale.setlocale(locale.LC_ALL)
-        for feature, loc in locales[platform.system()].items():
+        for feature, loc in locales[target_system].items():
             try:
                 locale.setlocale(locale.LC_ALL, loc)
                 self.config.available_features.add(
                     'locale.{0}'.format(feature))
             except locale.Error:
                 self.lit_config.warning('The locale {0} is not supported by '
                                         'your platform. Some tests will be '
                                         'unsupported.'.format(loc))
         locale.setlocale(locale.LC_ALL, default_locale)
 
         # Write an "available feature" that combines the triple when
         # use_system_cxx_lib is enabled. This is so that we can easily write
         # XFAIL markers for tests that are known to fail with versions of
         # libc++ as were shipped with a particular triple.
         if self.use_system_cxx_lib:
             self.config.available_features.add(
                 'with_system_cxx_lib=%s' % self.config.target_triple)
 
         # Insert the platform name into the available features as a lower case.
-        # Strip the '2' from linux2.
-        if sys.platform.startswith('linux'):
-            platform_name = 'linux'
-        else:
-            platform_name = sys.platform
-        self.config.available_features.add(platform_name.lower())
+        self.config.available_features.add(target_platform)
 
         # Some linux distributions have different locale data than others.
         # Insert the distributions name and name-version into the available
         # features to allow tests to XFAIL on them.
-        if sys.platform.startswith('linux'):
-            name, ver, _ = platform.linux_distribution()
-            name = name.lower().strip()
-            ver = ver.lower().strip()
+        if target_platform == 'linux':
+            name = self.target_info.platform_name()
+            ver = self.target_info.platform_ver()
             if name:
                 self.config.available_features.add(name)
             if name and ver:
                 self.config.available_features.add('%s-%s' % (name, ver))
 
         # Simulator testing can take a really long time for some of these tests
         # so add a feature check so we can REQUIRES: long_tests in them
         self.long_tests = self.get_lit_bool('long_tests')
def configure_link_flags_abi_library(self):
             pass
         else:
             self.lit_config.fatal(
                 'C++ ABI setting %s unsupported for tests' % cxx_abi)
 
     def configure_extra_library_flags(self):
         enable_threads = self.get_lit_bool('enable_threads', True)
         llvm_unwinder = self.get_lit_bool('llvm_unwinder', False)
-        if sys.platform == 'darwin':
+        target_platform = self.target_info.platform()
+        if target_platform == 'darwin':
             self.cxx.link_flags += ['-lSystem']
-        elif sys.platform.startswith('linux'):
+        elif target_platform == 'linux':
             if not llvm_unwinder:
                 self.cxx.link_flags += ['-lgcc_eh']
             self.cxx.link_flags += ['-lc', '-lm']
             if enable_threads:
                 self.cxx.link_flags += ['-lpthread']
             self.cxx.link_flags += ['-lrt']
             if llvm_unwinder:
                 self.cxx.link_flags += ['-lunwind', '-ldl']
             else:
                 self.cxx.link_flags += ['-lgcc_s']
-        elif sys.platform.startswith('freebsd'):
+        elif target_platform.startswith('freebsd'):
             self.cxx.link_flags += ['-lc', '-lm', '-lpthread', '-lgcc_s']
         else:
-            self.lit_config.fatal("unrecognized system: %r" % sys.platform)
+            self.lit_config.fatal("unrecognized system: %r" % target_platform)
 
     def configure_warnings(self):
         enable_warnings = self.get_lit_bool('enable_warnings', False)
         if enable_warnings:
             self.cxx.compile_flags += ['-Wsystem-headers', '-Wall', '-Werror']
             if ('clang' in self.config.available_features or
                 'apple-clang' in self.config.available_features):
                 self.cxx.compile_flags += ['-Wno-user-defined-literals']
 
     def configure_sanitizer(self):
         san = self.get_lit_conf('use_sanitizer', '').strip()
         if san:
             # Search for llvm-symbolizer along the compiler path first
             # and then along the PATH env variable.
             symbolizer_search_paths = os.environ.get('PATH', '')
             cxx_path = lit.util.which(self.cxx.path)
             if cxx_path is not None:
                 symbolizer_search_paths = (
                     os.path.dirname(cxx_path) +
                     os.pathsep + symbolizer_search_paths)
             llvm_symbolizer = lit.util.which('llvm-symbolizer',
                                              symbolizer_search_paths)
             # Setup the sanitizer compile flags
             self.cxx.flags += ['-g', '-fno-omit-frame-pointer']
-            if sys.platform.startswith('linux'):
+            if self.target_info.platform() == 'linux':
                 self.cxx.link_flags += ['-ldl']
             if san == 'Address':
                 self.cxx.flags += ['-fsanitize=address']
                 if llvm_symbolizer is not None:
                     self.env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
                 self.config.available_features.add('asan')
             elif san == 'Memory' or san == 'MemoryWithOrigins':
                 self.cxx.flags += ['-fsanitize=memory']

libcxx/test/target_info.py

+import locale
+import platform
+import sys
+
+class TargetInfo(object):
+    def platform(self):
+        raise NotImplementedError
+
+    def system(self):
+        raise NotImplementedError
+
+    def platform_ver(self):
+        raise NotImplementedError
+
+    def platform_name(self):
+        raise NotImplementedError
+
+    def supports_locale(self, loc):
+        raise NotImplementedError
+
+
+class LocalTI(TargetInfo):
+    def platform(self):
+        platform_name = sys.platform.lower().strip()
+        # Strip the '2' from linux2.
+        if platform_name.startswith('linux'):
+            platform_name = 'linux'
+        return platform_name
+
+    def system(self):
+        return platform.system()
+
+    def platform_name(self):
+        if platform() == 'linux':
+            name, _, _ = platform.linux_distribution()
+            name = name.lower().strip()
+            if name:
+                return name
+        return None
+
+    def platform_ver(self):
+        if platform() == 'linux':
+            _, ver, _ = platform.linux_distribution()
+            ver = ver.lower().strip()
+            if ver:
+                return ver
+        return None
+
+    def supports_locale(self, loc):
+        try:
+            locale.setlocale(locale.LC_ALL, loc)
+            return True
+        except locale.Error:
+            return False
+

lit.site.cfg.in

 config.enable_monotonic_clock   = "@LIBCXX_ENABLE_MONOTONIC_CLOCK@"
 config.cxx_abi                  = "@LIBCXX_CXX_ABI_LIBNAME@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.abi_library_path         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.target_triple            = "@LIBCXX_TARGET_TRIPLE@"
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
+config.target_info              = "@LIBCXX_TARGET_INFO@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXX_SOURCE_DIR@/test/lit.cfg")