[libcxx] Support for Objective-C++ tests

[erik.pilkington]

Summary

This patch adds lit testing support for Objective-C++. I'm going to be working on improving Objective-C++ support in libc++ this summer, and it would be nice to write tests. I tested this patch on Ubuntu 16.04 with gcc 5.4, and it works fine (the .mm tests become UNSUPPORTED).

Thanks for taking a look!
Erik

[dexonsmith]

utils/libcxx/compiler.py

110–114 ↗

(On Diff #98475)

Do we need/want a way to choose between ARC and no-ARC?

[erik.pilkington]

In this new patch:

• Add support for toggling -fobjc-arc, this is done by using file extensions, ie: foo.arc.pass.mm instead of foo.pass.mm. (Thanks @dexonsmith for the suggestion!)
• Clean up/simplify things a bit

Thanks,
Erik

[jroelofs]

Would be good to test for the presence/absence of the flag, too:

test/libcxx/selftest/test.arc.pass.mm

10 ↗

(On Diff #99628)

#if __has_feature(objc_arc) != 1
#error "arc should be enabled"
#endif

test/libcxx/selftest/test.pass.mm

10 ↗

(On Diff #99628)

#if __has_feature(objc_arc) == 1
#error "arc should *not* be enabled"
#endif

[erik.pilkington]

This new patch checks to make sure ARC is enabled in the tests, thanks for the suggestion!

[jroelofs]

LGTM

libcxx/trunk/test/libcxx/selftest/test.arc.fail.mm

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if __has_feature(objc_arc)
+#error This test should not compile.
+#endif

libcxx/trunk/test/libcxx/selftest/test.arc.pass.mm

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if __has_feature(objc_arc) == 0
+#error "arc should be enabled"
+#endif
+
+int main()
+{
+}

libcxx/trunk/test/libcxx/selftest/test.fail.mm

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if __has_feature(objc_arc) == 0
+#error This test should not compile.
+#endif

libcxx/trunk/test/libcxx/selftest/test.pass.mm

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if __has_feature(objc_arc)
+#error "arc should *not* be enabled"
+#endif
+
+int main()
+{
+}

libcxx/trunk/utils/libcxx/compiler.py

class CXXCompiler(object):
     CM_Link = 3
 
     def __init__(self, path, flags=None, compile_flags=None, link_flags=None,
                  warning_flags=None, verify_supported=None,
                  verify_flags=None, use_verify=False,
                  modules_flags=None, use_modules=False,
                  use_ccache=False, use_warnings=False, compile_env=None,
                  cxx_type=None, cxx_version=None):
+        self.source_lang = 'c++'
         self.path = path
         self.flags = list(flags or [])
         self.compile_flags = list(compile_flags or [])
         self.link_flags = list(link_flags or [])
         self.warning_flags = list(warning_flags or [])
         self.verify_supported = verify_supported
         self.use_verify = use_verify
         self.verify_flags = list(verify_flags or [])
def _basicCmd(self, source_files, out, mode=CM_Default, flags=[],
         if self.use_ccache \
                 and not mode == self.CM_Link \
                 and not mode == self.CM_PreProcess:
             cmd += ['ccache']
         cmd += [self.path]
         if out is not None:
             cmd += ['-o', out]
         if input_is_cxx:
-            cmd += ['-x', 'c++']
+            cmd += ['-x', self.source_lang]
         if isinstance(source_files, list):
             cmd += source_files
         elif isinstance(source_files, str):
             cmd += [source_files]
         else:
             raise TypeError('source_files must be a string or list')
         if mode == self.CM_PreProcess:
             cmd += ['-E']

libcxx/trunk/utils/libcxx/test/config.py

def configure_features(self):
         # in 'features.h'.
         macros = self.cxx.dumpMacros(flags=['-include', 'features.h'])
         if macros is not None and '__GLIBC__' in macros:
             maj_v, min_v = (macros['__GLIBC__'], macros['__GLIBC_MINOR__'])
             self.config.available_features.add('glibc')
             self.config.available_features.add('glibc-%s' % maj_v)
             self.config.available_features.add('glibc-%s.%s' % (maj_v, min_v))
 
+        # Support Objective-C++ only on MacOS and if the compiler supports it.
+        if self.target_info.platform() == "darwin" and \
+           self.target_info.is_host_macosx() and \
+           self.cxx.hasCompileFlag(["-x", "objective-c++", "-fobjc-arc"]):
+            self.config.available_features.add("objective-c++")
+
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.configure_default_compile_flags()
         # This include is always needed so add so add it regardless of
         # 'no_default_flags'.
         support_path = os.path.join(self.libcxx_src_root, 'test/support')
         self.cxx.compile_flags += ['-I' + support_path]

libcxx/trunk/utils/libcxx/test/format.py

def execute(self, test, lit_config):
                     raise
                 time.sleep(0.1)
 
     def _execute(self, test, lit_config):
         name = test.path_in_suite[-1]
         name_root, name_ext = os.path.splitext(name)
         is_libcxx_test = test.path_in_suite[0] == 'libcxx'
         is_sh_test = name_root.endswith('.sh')
-        is_pass_test = name.endswith('.pass.cpp')
-        is_fail_test = name.endswith('.fail.cpp')
-        assert is_sh_test or name_ext == '.cpp', 'non-cpp file must be sh test'
+        is_pass_test = name.endswith('.pass.cpp') or name.endswith('.pass.mm')
+        is_fail_test = name.endswith('.fail.cpp') or name.endswith('.fail.mm')
+        is_objcxx_test = name.endswith('.mm')
+        is_objcxx_arc_test = name.endswith('.arc.pass.mm') or \
+                             name.endswith('.arc.fail.mm')
+        assert is_sh_test or name_ext == '.cpp' or name_ext == '.mm', \
+            'non-cpp file must be sh test'
 
         if test.config.unsupported:
             return (lit.Test.UNSUPPORTED,
                     "A lit.local.cfg marked this unsupported")
 
+        if is_objcxx_test and not \
+           'objective-c++' in test.config.available_features:
+            return (lit.Test.UNSUPPORTED, "Objective-C++ is not supported")
+
         parsers = self._make_custom_parsers()
         script = lit.TestRunner.parseIntegratedTestScript(
             test, additional_parsers=parsers, require_script=is_sh_test)
         # Check if a result for the test was returned. If so return that
         # result.
         if isinstance(script, lit.Test.Result):
             return script
         if lit_config.noExecute:
def _execute(self, test, lit_config):
             # If we see this we need to build the test against uniquely built
             # modules.
             if is_libcxx_test:
                 with open(test.getSourcePath(), 'r') as f:
                     contents = f.read()
                 if '#define _LIBCPP_ASSERT' in contents:
                     test_cxx.useModules(False)
 
+        if is_objcxx_test:
+            test_cxx.source_lang = 'objective-c++'
+            if is_objcxx_arc_test:
+                test_cxx.compile_flags += ['-fobjc-arc']
+            else:
+                test_cxx.compile_flags += ['-fno-objc-arc']
+            test_cxx.link_flags += ['-framework', 'Foundation']
+
         # Dispatch the test based on its suffix.
         if is_sh_test:
             if not isinstance(self.executor, LocalExecutor):
                 # We can't run ShTest tests with a executor yet.
                 # For now, bail on trying to run them
                 return lit.Test.UNSUPPORTED, 'ShTest format not yet supported'
             test.config.environment = dict(self.exec_env)
             return lit.TestRunner._runShTest(test, lit_config,