[libcxx] [test] Add a MinGW target

[mstorsjo]

Summary

This can't easily be autodetected (unless LIBCXX_TARGET_TRIPLE is specified, or unless we query what the compiler's default target is, which only is supported by clang), but can be chosen manually via LIBCXX_TARGET_INFO.

This chooses mingw style lib naming, and uses -nostdlibc++ instead of -nodefaultlib -nostdlib (as the latter requires specifying a lot of details manually - this is done in the cmake config though).

[rnk]

lgtm

libcxx/utils/libcxx/test/target_info.py

25

I see, so the existing notion of target info is based on Python's sys.platform, which doesn't distinguish between mingw or MSVC environments.

[mstorsjo]

libcxx/utils/libcxx/test/target_info.py

25

Yes, and furthermore, as we might use a msys2/mingw based python to run tests for an msvc build, it isn't necessarily indicative anyway.

libcxx/utils/libcxx/test/config.py

def get_lit_bool(self, name, default=None, env_var=None):
                 self.lit_config.warning(
                     'Environment variable %s=%s is overriding explicit '
                     '--param=%s=%s' % (env_var, val, name, conf_val))
             return check_value(val, env_var)
         return check_value(conf_val, name)
 
     def make_static_lib_name(self, name):
         """Return the full filename for the specified library name"""
-        if self.target_info.is_windows():
+        if self.target_info.is_windows() and not self.target_info.is_mingw():
             assert name == 'c++'  # Only allow libc++ to use this function for now.
             return 'lib' + name + '.lib'
         else:
             return 'lib' + name + '.a'
 
     def configure(self):
         self.target_info = make_target_info(self)
         self.executor = self.get_lit_conf('executor')
class Configuration(object):
 
     def configure_link_flags(self):
         # Configure library path
         self.configure_link_flags_cxx_library_path()
         self.configure_link_flags_abi_library_path()
 
         # Configure libraries
         if self.cxx_stdlib_under_test == 'libc++':
+            if self.target_info.is_mingw():
+                self.cxx.link_flags += ['-nostdlib++']
+            else:
                 self.cxx.link_flags += ['-nodefaultlibs']
             # FIXME: Handle MSVCRT as part of the ABI library handling.
-            if self.target_info.is_windows():
+            if self.target_info.is_windows() and not self.target_info.is_mingw():
                 self.cxx.link_flags += ['-nostdlib']
             self.configure_link_flags_cxx_library()
             self.configure_link_flags_abi_library()
             self.configure_extra_library_flags()
         elif self.cxx_stdlib_under_test == 'libstdc++':
             self.cxx.link_flags += ['-lstdc++fs', '-lm', '-pthread']
         elif self.cxx_stdlib_under_test == 'msvc':
             # FIXME: Correctly setup debug/release flags here.

libcxx/utils/libcxx/test/target_info.py

 from libcxx.util import executeCommand
 
 class DefaultTargetInfo(object):
     def __init__(self, full_config):
         self.full_config = full_config
         self.executor = None
 
     def platform(self):
         return sys.platform.lower().strip()
 
     def is_windows(self):
         return self.platform() == 'win32'
 
+    def is_mingw(self):
+        return False
+
     def is_darwin(self):
         return self.platform() == 'darwin'
 
     def add_cxx_flags(self, flags): pass
     def add_cxx_compile_flags(self, flags): pass
     def add_cxx_link_flags(self, flags): pass
     def allow_cxxabi_link(self): return True
 

 class LinuxRemoteTI(LinuxLocalTI):
     def __init__(self, full_config):
         super(LinuxRemoteTI, self).__init__(full_config)
 
 class WindowsLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(WindowsLocalTI, self).__init__(full_config)
 
+class MingwLocalTI(WindowsLocalTI):
+    def __init__(self, full_config):
+        super(MingwLocalTI, self).__init__(full_config)
+
+    def is_mingw(self):
+        return True
+
 def make_target_info(full_config):
     default = "libcxx.test.target_info.LocalTI"
     info_str = full_config.get_lit_conf('target_info', default)
     if info_str != default:
         mod_path, _, info = info_str.rpartition('.')
         mod = importlib.import_module(mod_path)
         target_info = getattr(mod, info)(full_config)
         full_config.lit_config.note("inferred target_info as: %r" % info_str)
         return target_info
     target_system = platform.system()
     if target_system == 'Darwin':  return DarwinLocalTI(full_config)
     if target_system == 'FreeBSD': return FreeBSDLocalTI(full_config)
     if target_system == 'NetBSD':  return NetBSDLocalTI(full_config)
     if target_system == 'Linux':   return LinuxLocalTI(full_config)
     if target_system == 'Windows': return WindowsLocalTI(full_config)
     return DefaultTargetInfo(full_config)