[libc++] Add a CI configuration with static libc++/libc++abi

[curdeius]

libcxx/utils/ci/run-buildbot

89–90

Does it change anything for other (non-static) test configurations?
IIUC, without installing first, tests would find a possibly different instance of libc++.a (if there's one somewhere in link dirs) or find none, right?
Was it the case with the dynamic lib?

[ldionne]

libcxx/utils/ci/run-buildbot

89–90

I don't expect there should be any difference. This is only a cheap way to fix the issue that dependencies are not properly specified with the static library, i.e. check-cxx won't build the static library first when you run it. I looked into solving the underlying issue and it would complicate the CMake quite a bit in the current state of things, so I wanted to start by simplifying the CMake configuration (https://reviews.llvm.org/D97565 will enable that as a follow-up step).

[curdeius]

OK, thanks for the explanation.
LGTM.

[ldionne]

Fix a few issues with the experimental tests.

libcxx/cmake/caches/Generic-static.cmake

+set(LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
+set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
+set(LIBUNWIND_ENABLE_SHARED OFF CACHE BOOL "")
+
+# TODO: We should switch this to a from-sratch config with static libraries
+# instead and get rid of these options.
+set(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI OFF CACHE BOOL "")
+set(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX OFF CACHE BOOL "")
+set(LIBCXXABI_LINK_TESTS_WITH_SHARED_LIBCXXABI OFF CACHE BOOL "")
+set(LIBCXXABI_LINK_TESTS_WITH_SHARED_LIBCXX OFF CACHE BOOL "")

libcxx/utils/ci/buildkite-pipeline.yml

artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
+  - label: "Static libraries"
+    command: "libcxx/utils/ci/run-buildbot generic-static"
+    artifact_paths:
+      - "**/test-results.xml"
+    agents:
+      queue: "libcxx-builders"
+    retry:
+      automatic:
+        - exit_status: -1  # Agent was lost
+          limit: 2
+
   - label: "GCC/C++20"
     command: "libcxx/utils/ci/run-buildbot generic-gcc"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
     retry:
       automatic:

libcxx/utils/ci/run-buildbot

cmake -S "${MONOREPO_ROOT}/llvm" \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DLLVM_ENABLE_PROJECTS="libcxx;libunwind;libcxxabi" \
           -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml" \
           -DLIBCXX_CXX_ABI=libcxxabi \
           "${@}"
 }
 
 function check-cxx-cxxabi() {
+    echo "--- Installing libc++ and libc++abi to a fake location"
+    ${NINJA} -vC "${BUILD_DIR}" install-cxx install-cxxabi
+
     echo "+++ Running the libc++ tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx
 
     echo "+++ Running the libc++abi tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxxabi
-
-    echo "--- Installing libc++ and libc++abi to a fake location"
-    ${NINJA} -vC "${BUILD_DIR}" install-cxx install-cxxabi
 }
 
 # TODO: The goal is to test this against all configurations. We should also move
 #       this to the Lit test suite instead of being a separate CMake target.
 function check-abi-list() {
     echo "+++ Running the libc++ ABI list test"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx-abilist || (
         echo "+++ Generating the libc++ ABI list after failed check"

 ;;
 generic-noexceptions)
     export CC=clang
     export CXX=clang++
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-noexceptions.cmake"
     check-cxx-cxxabi
 ;;
+generic-static)
+    export CC=clang
+    export CXX=clang++
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-static.cmake"
+    check-cxx-cxxabi
+;;
 generic-32bit)
     export CC=clang
     export CXX=clang++
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-32bits.cmake"
     check-cxx-cxxabi
 ;;
 generic-gcc)
     export CC=gcc
     export CXX=g++
     clean
-    # FIXME: Re-enable experimental testing on GCC. GCC cares about the order
-    #        in which we link -lc++experimental, which causes issues.
-    generate-cmake -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF
+    generate-cmake
     check-cxx-cxxabi
 ;;
 generic-asan)
     export CC=clang
     export CXX=clang++
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-asan.cmake"
     check-cxx-cxxabi

libcxx/utils/libcxx/test/config.py

def configure(self):
         self.target_info = make_target_info(self)
         self.executor = self.get_lit_conf('executor')
         self.configure_cxx()
         self.configure_triple()
         self.configure_src_root()
         self.configure_obj_root()
         self.cxx_stdlib_under_test = self.get_lit_conf('cxx_stdlib_under_test', 'libc++')
         self.cxx_library_root = self.get_lit_conf('cxx_library_root', self.libcxx_obj_root)
-        self.abi_library_root = self.get_lit_conf('abi_library_root', None)
+        self.abi_library_root = self.get_lit_conf('abi_library_root') or self.cxx_library_root
         self.cxx_runtime_root = self.get_lit_conf('cxx_runtime_root', self.cxx_library_root)
         self.abi_runtime_root = self.get_lit_conf('abi_runtime_root', self.abi_library_root)
         self.configure_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_debug_mode()
         self.configure_sanitizer()
         self.configure_coverage()

libcxx/utils/libcxx/test/dsl.py

def featureTestMacros(config, flags=''):
 
   The keys are strings representing feature test macros, and the values are
   integers representing the value of the macro.
   """
   allMacros = compilerMacros(config, flags)
   return {m: int(v.rstrip('LlUu')) for (m, v) in allMacros.items() if m.startswith('__cpp_')}
 
 
-def _addToSubstitution(substitutions, key, value):
+def _appendToSubstitution(substitutions, key, value):
   return [(k, v + ' ' + value) if k == key else (k, v) for (k, v) in substitutions]
 
+def _prependToSubstitution(substitutions, key, value):
+  return [(k, value + ' ' + v) if k == key else (k, v) for (k, v) in substitutions]
+
 
 class ConfigAction(object):
   """
   This class represents an action that can be performed on a Lit TestingConfig
   object.
 
   Examples of such actions are adding or modifying substitutions, Lit features,
   etc. This class only provides the interface of such actions, and it is meant
class AddFlag(ConfigAction):
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable flag {}, which is not supported".format(flag)
-    config.substitutions = _addToSubstitution(config.substitutions, '%{flags}', flag)
+    config.substitutions = _appendToSubstitution(config.substitutions, '%{flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{flags}}'.format(self._getFlag(config))
 
 
 class AddCompileFlag(ConfigAction):
   """
   This action adds the given flag to the %{compile_flags} substitution.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable compile flag {}, which is not supported".format(flag)
-    config.substitutions = _addToSubstitution(config.substitutions, '%{compile_flags}', flag)
+    config.substitutions = _appendToSubstitution(config.substitutions, '%{compile_flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{compile_flags}}'.format(self._getFlag(config))
 
 
 class AddLinkFlag(ConfigAction):
   """
-  This action adds the given flag to the %{link_flags} substitution.
+  This action appends the given flag to the %{link_flags} substitution.
+
+  The flag can be a string or a callable, in which case it is called with the
+  configuration to produce the actual flag (as a string).
+  """
+  def __init__(self, flag):
+    self._getFlag = lambda config: flag(config) if callable(flag) else flag
+
+  def applyTo(self, config):
+    flag = self._getFlag(config)
+    assert hasCompileFlag(config, flag), "Trying to enable link flag {}, which is not supported".format(flag)
+    config.substitutions = _appendToSubstitution(config.substitutions, '%{link_flags}', flag)
+
+  def pretty(self, config, litParams):
+    return 'append {} to %{{link_flags}}'.format(self._getFlag(config))
+
+
+class PrependLinkFlag(ConfigAction):
+  """
+  This action prepends the given flag to the %{link_flags} substitution.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable link flag {}, which is not supported".format(flag)
-    config.substitutions = _addToSubstitution(config.substitutions, '%{link_flags}', flag)
+    config.substitutions = _prependToSubstitution(config.substitutions, '%{link_flags}', flag)
 
   def pretty(self, config, litParams):
-    return 'add {} to %{{link_flags}}'.format(self._getFlag(config))
+    return 'prepend {} to %{{link_flags}}'.format(self._getFlag(config))
 
 
 class AddOptionalWarningFlag(ConfigAction):
   """
   This action adds the given warning flag to the %{compile_flags} substitution,
   if it is supported by the compiler.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
     flag = self._getFlag(config)
     # Use -Werror to make sure we see an error about the flag being unsupported.
     if hasCompileFlag(config, '-Werror ' + flag):
-      config.substitutions = _addToSubstitution(config.substitutions, '%{compile_flags}', flag)
+      config.substitutions = _appendToSubstitution(config.substitutions, '%{compile_flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{compile_flags}}'.format(self._getFlag(config))
 
 
 class AddSubstitution(ConfigAction):
   """
   This action adds the given substitution to the Lit configuration.

libcxx/utils/libcxx/test/params.py

Parameter(name='use_system_cxx_lib', choices=[True, False], type=bool, default=False,
               AddCompileFlag('-D_LIBCPP_DISABLE_AVAILABILITY')
             ]),
 
   # Parameters to enable or disable parts of the test suite
   Parameter(name='enable_experimental', choices=[True, False], type=bool, default=False,
             help="Whether to enable tests for experimental C++ libraries (typically Library Fundamentals TSes).",
             actions=lambda experimental: [] if not experimental else [
               AddFeature('c++experimental'),
-              AddLinkFlag('-lc++experimental')
+              PrependLinkFlag('-lc++experimental')
             ]),
 
   Parameter(name='long_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",
             actions=lambda enabled: [] if not enabled else [
               AddFeature('long_tests')
             ]),
 
   Parameter(name='enable_debug_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that exercise the libc++ debugging mode.",
             actions=lambda enabled: [] if enabled else [
               AddFeature('libcxx-no-debug-mode')
             ]),
 ]