[SystemZ][z/OS] exclude nasty_macros.h from check-cxx

[zibi]

Summary

Need to exclude nasty_macros.h from check-cxx on z/OS due to conflicts within system headers.

Sample failure in random_shuffle.depr_in_cxx14.verify.cpp libcxx test.

error: 'error' diagnostics seen but not expected:
Line 1268: expected ')'
Line 1268: unknown type name 'This'
Line 1268: expected ')'

caused by the following macros in nasty_macros.h

#define NASTY_MACRO This should not be expanded!!!
#define _E NASTY_MACRO

The name collision is observed in the following code snippet whre _E is being used as parameter name:

inline int iswalnum(wint_t _E) {return __iswalnum(_E);}

It is reasonable to exclude nasty_macros.h on z/OS similarly as it was done on Windows.

[• Quuxplusone]

I think it'd be useful to put in your commit message (i.e. revision summary) an example of the kind of error that's getting fixed here: what doesn't work and how does it fail?

libcxx/utils/libcxx/test/config.py

def configure_default_compile_flags(self):
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_obj_root, 'generated_headers')]
             self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'test')]
             self.config.available_features.add('parallel-algorithms')
 
     def configure_compile_flags_header_includes(self):
         support_path = os.path.join(self.libcxx_src_root, 'test', 'support')
         self.configure_config_site_header()
         if self.cxx_stdlib_under_test != 'libstdc++' and \
-           not self.target_info.is_windows():
+           not self.target_info.is_windows() and \
+           not self.target_info.is_zos():
             self.cxx.compile_flags += [
                 '-include', os.path.join(support_path, 'nasty_macros.h')]
         if self.cxx_stdlib_under_test == 'msvc':
             self.cxx.compile_flags += [
                 '-include', os.path.join(support_path,
                                          'msvc_stdlib_force_include.h')]
             pass
         if self.target_info.is_windows() and self.debug_build and \

libcxx/utils/libcxx/test/target_info.py

 class DefaultTargetInfo(object):
     def __init__(self, full_config):
         self.full_config = full_config
         self.executor = None
 
     def is_windows(self):
         return False
 
+    def is_zos(self):
+        return False
+
     def is_mingw(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
 

 
 class WindowsLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(WindowsLocalTI, self).__init__(full_config)
 
     def is_windows(self):
         return True
 
+class ZOSLocalTI(DefaultTargetInfo):
+    def __init__(self, full_config):
+        super(ZOSLocalTI, self).__init__(full_config)
+
+    def is_zos(self):
+        return True
+
 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)
+    if target_system == 'OS/390':  return ZOSLocalTI(full_config)
     return DefaultTargetInfo(full_config)