[libcxx/cxxabi/unwind][AIX] Add an AIX target and config for testing.

[sfertile]

Summary

Adds a target info for local AIX testing, and adjusts some of the link option to enable running testing on AIX for libcxx, libcxxabi and libunwind.

[sfertile]

Ping.

[jasonliu]

LGTM on AIX perspective.
FYI, we will need two reviewers from libc++ review group or the maintainer of libc++ project to approve before we could land.

libcxx/utils/libcxx/test/target_info.py

163

Just noting that this setup only works when we use libc++/libc++abi/libunwind stack.
In theory, libc++ could work with gcc and use what's in libstdc++ to replace libc++abi and libunwind. If that's the case, then this won't work any more. And we would need something similar to LinuxLocalTI above.
But I guess people have intention to make the above combination work could change this setup later when they needed.

[sfertile]

In D102632#2787406, @jasonliu wrote:

LGTM on AIX perspective.
FYI, we will need two reviewers from libc++ review group or the maintainer of libc++ project to approve before we could land.

Thanks for the review Jason. @ldionne Can we get a review from you or someone else familiar with the libc++ project?

libcxx/utils/libcxx/test/target_info.py

163

Valid point. I think we need to start somewhere though, and we need to enable testing in both libc++abi and libunwind on AIX so we can test Xings patches, so this is the natural first step.

[ldionne]

Is there any way you folks could try to use configuration files like libcxx/test/configs/libcxx-trunk-shared.cfg.in instead of augmenting the old config.py? I'm trying to move all of the testing infrastructure over to those, since they are a lot more flexible and straightforward to define. Right now there's a bit of boilerplate in those config files, but the gist of it is that you define exactly how the compiler is to be called on the test files:

config.substitutions.append(('%{cxx}', COMPILER))
config.substitutions.append(('%{flags}',
    '-isysroot {}'.format(CMAKE_OSX_SYSROOT) if CMAKE_OSX_SYSROOT else ''
))
config.substitutions.append(('%{compile_flags}',
    '-nostdinc++ -isystem {} -I {}'.format(
        os.path.join(INSTALL_ROOT, 'include', 'c++', 'v1'),
        os.path.join(LIBCXX_ROOT, 'test', 'support'))
))
config.substitutions.append(('%{link_flags}',
    '-nostdlib++ -L {0} -lc++ -Wl,-rpath,{0} -pthread'.format(
        os.path.join(INSTALL_ROOT, 'lib'))
))
config.substitutions.append(('%{exec}',
    '{} {} --execdir %T -- '.format(
        pipes.quote(sys.executable),
        pipes.quote(runPy))
))

You can see how to select your testing configuration here: https://libcxx.llvm.org/TestingLibcxx.html#using-a-custom-site-configuration

libcxx/utils/libcxx/test/config.py

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():
+            if self.target_info.is_mingw() or self.target_info.is_aix():
                 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() and not self.target_info.is_mingw():
                 self.cxx.link_flags += ['-nostdlib']
             self.configure_link_flags_cxx_library()
             self.configure_link_flags_abi_library()
def configure_link_flags(self):
         self.cxx.link_flags += shlex.split(link_flags_str)
 
     def configure_link_flags_cxx_library_path(self):
         if self.cxx_library_root:
             self.cxx.link_flags += ['-L' + self.cxx_library_root]
             if self.target_info.is_windows() and self.link_shared:
                 self.add_path(self.cxx.compile_env, self.cxx_library_root)
         if self.cxx_runtime_root:
-            if not self.target_info.is_windows():
+            if self.target_info.is_aix():
+                self.exec_env['LIBPATH'] = self.cxx_runtime_root
+            elif not self.target_info.is_windows():
                 self.cxx.link_flags += ['-Wl,-rpath,' +
                                         self.cxx_runtime_root]
             elif self.target_info.is_windows() and self.link_shared:
                 self.add_path(self.exec_env, self.cxx_runtime_root)
         additional_flags = self.get_lit_conf('test_linker_flags')
         if additional_flags:
             self.cxx.link_flags += shlex.split(additional_flags)
 
     def configure_link_flags_abi_library_path(self):
         # Configure ABI library paths.
         if self.abi_library_root:
             self.cxx.link_flags += ['-L' + self.abi_library_root]
         if self.abi_runtime_root:
-            if not self.target_info.is_windows():
+            if self.target_info.is_aix():
+                self.exec_env['LIBPATH'] = self.abi_runtime_root
+            elif not self.target_info.is_windows():
                 self.cxx.link_flags += ['-Wl,-rpath,' + self.abi_runtime_root]
             else:
                 self.add_path(self.exec_env, self.abi_runtime_root)
 
     def configure_link_flags_cxx_library(self):
         if self.link_shared:
             self.cxx.link_flags += ['-lc++']
         else:

libcxx/utils/libcxx/test/target_info.py

def is_windows(self):
         return False
 
     def is_zos(self):
         return False
 
     def is_mingw(self):
         return False
 
+    def is_aix(self):
+        return False
+
     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
 
     def add_path(self, dest_env, new_path):
         if not new_path:
             return

 
 class MingwLocalTI(WindowsLocalTI):
     def __init__(self, full_config):
         super(MingwLocalTI, self).__init__(full_config)
 
     def is_mingw(self):
         return True
 
+class AIXLocalTI(DefaultTargetInfo):
+    def __init__(self, full_config):
+        super(AIXLocalTI, self).__init__(full_config)
+
+    def add_cxx_link_flags(self, flags):
+        flags += ['-lpthread', '-lc++abi', '-lunwind', '-latomic']
+
+    def is_aix(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)
     if target_system == 'OS/390':  return ZOSLocalTI(full_config)
+    if target_system == "AIX":     return AIXLocalTI(full_config)
     return DefaultTargetInfo(full_config)