[SystemZ][z/OS] Move several exception derived classes to c++abi library

[fanbo-meng]

Summary

The following classes derived from std::exception have member function what() which will be moved to c++abi along with some destructors.

• std::__1::bad_weak_ptr
• std::bad_variant_access
• std::bad_any_cast
• std::bad_optional_access

In addition, we will drop the version namespace for bad_weak_ptr and have std::bad_weak_ptr to be consistent with other classes.

This change is the base for the following patch addressing the encoding for strings representing the exception types.

[muiez]

LGTM

[fanbo-meng]

ping :)

[fanbo-meng]

Update zos cmake cache

[SeanP]

LGTM

[fanbo-meng]

rebase to latest main

[fanbo-meng]

run clang-format

[fanbo-meng]

formatting __config; rename new sources files to have unique names

[zibi]

LGTM

libcxx/cmake/caches/zos.cmake

9 ↗

(On Diff #409631)

This suggestion reflects the recent removal of standalone build.

[ldionne]

libcxx/src/exceptions/exception_any.cpp

9 ↗

(On Diff #409631)

Please use <any> instead of "any". Also applies below.

11 ↗

(On Diff #409631)

I think this should be using _LIBCPP_BEGIN_NAMESPACE_STD_EXCEPTION. Same for others below.

[ldionne]

libcxx/include/__config

690–693

It seems to me that we *always* want the namespace for exceptions to be namespace std only, without the ABI namespace.

I think it only falls down for bad_weak_ptr, which we seem to have defined in std::__1 instead of std::. Is that correct?

libcxx/src/CMakeLists.txt

299

I think there's something greater trying to emerge here. We already define some exception types inside libc++abi in namespace std. We should have a consistent approach with all those. In fact, perhaps what we want is to create either a static archive or a shared library with all those exception types, from libc++ and libc++abi. The default configuration would be to statically link that library into libc++, but other configurations could be possible, like leaving it be its own dylib (your use case).

libcxx/src/exceptions/variant.cpp

15

Please don't change the formatting needlessly. Applies everywhere.

libcxx/utils/libcxx/test/config.py

377

Please define a configuration file in the likes of libcxx/test/configs/apple-libc++-shared.cfg.in for testing. We're trying to move away from this config.py.

[fanbo-meng]

libcxx/include/__config

690–693

That's correct, in our case we want them to have std:: namespace only so we define _LIBCPP_BEGIN_NAMESPACE_STD_EXCEPTION for bad_weak_ptr .
For the other three classes they are already using only std:: namespace, that's why we kept their existing std:: namespace in the new files to avoid inconsistency.

libcxx/src/CMakeLists.txt

299

Our initial approach was to move all exception symbols from libc++ to libc++abi, but then we discovered some exception classes have dependencies on libcxx symbols, for example runtime_error(const string& msg) requires access to string methods. Therefore they have to be left in libc++ so I don't think it would be possible to move everything into a unified library.

[fanbo-meng]

libcxx/src/exceptions/exception_any.cpp

11 ↗

(On Diff #409631)

We used std namespace here to preserve the original behaviour of this class. The exception derived classes aren't really consistent with namespace as some uses std:: and others uses std::__1::, so our use of _LIBCPP_BEGIN_NAMESPACE_STD_EXCEPTION is intended for those that originally uses std::__1:: namespace, like bad_weak_ptr class.

libcxx/utils/libcxx/test/config.py

377

https://reviews.llvm.org/D118503#3354937 @muiez will have another patch for this.

[fanbo-meng]

Addressing comments

[zibi]

LGTM

[zibi]

libcxx/src/CMakeLists.txt

315

I just noticed that we are missing the change for renaming dll name inside the side deck file. However this can be done in a separate patch.

[fanbo-meng]

ping :) @libcxx

[philnik]

libcxx/include/__memory/shared_ptr.h

50

Is it possible that this was just an oversight? If that's the case, maybe this should just be an ABI flag instead of getting it's own namespace macros?

[zibi]

• Rebase and move recipe to build c++_exception to separate cmake.

[zibi]

• config.py should not be part of this change

[zibi]

• formating changes and make set_target_properties for cxx_exception be consistent with cxx_shared

[zibi]

more formating

[zibi]

• switch to use override in place of virtual

[fanbo-meng]

libcxx/include/__memory/shared_ptr.h

50

This is intended, as we want std namespace for bad_weak_ptr for z/OS.

[zibi]

• use system notation for #include directive

[zibi]

@ldionne @philnik Please have a look again and let me know if you want to change anything.

[philnik]

LGTM with comments applied. Leaving final approval to @ldionne.

libcxx/src/exceptions/any.cpp

2

I wouldn't bother with putting every one of these into it's own file.

libcxx/src/exceptions/memory.cpp

3–10

The license headers seem to be broken in a few places.

[zibi]

• consolidate multiple exceptions files into a single file

[zibi]

Thank you for all reviews which are not addressed.
@ldionne Can you have a look? I just need your stamp of approval.

[zibi]

ping @ldionne

[zibi]

Louis, this has been reviewed by others including yourself and is waiting for your stamp of approval, @ldionne

[zibi]

ping @ldionne

[zibi]

ping

[EricWF]

I don't really like the state this leaves variant, any and friends in when exception vtables aren't compiled into the dylib.
There's no way to know only from the headers that using any of these types will result in linker errors.

Yes, is the Z/OS case you provide these symbols via a different means, but that's not clear anywhere in the CMake files as written.

I think the source changes look acceptable, but the changes to the build system may not be changes we want in upstream. There has been a enormous amount of work to simply and remove all sorts of cryptic build-time switches in order to make our CMake files understandable, and I see this change as going backwards in that respect.

libcxx/include/__memory/shared_ptr.h

50

I don't think we want to formalize this different exception namespace. Especially as a versioned one (which it is by default).

The correct thing to do is place these types directly in namespace std, so their mangling never changes. bad_weak_ptr should have never gone in the versioned namespace, but that mistake was made, and now we're stuck with it (for now).

I'm OK with this change, but lets be verbose and do the ugly #ifdef blocks and namespace switching directly around bad_weak_ptr.

libcxx/src/CMakeLists.txt

138

This should be gated on the other CMake switch you're introducing, no?

[zibi]

• Remove _LIBCPP_BEGIN_NAMESPACE_EXCEPTION and _LIBCPP_END_NAMESPACE_EXCEPTION

[zibi]

Addressing comments...

libcxx/include/__memory/shared_ptr.h

50

sure

libcxx/src/CMakeLists.txt

138

Not really, we build the library multiple times to support ASCII and EBCDIC but the exception is being build only once in EBCDIC encoding. Using other CMake switch will build cxx with and without exception. On z/OS we don't want to build exception as part of cxx. This is the fundamental reason why we doing this change.

[zibi]

• correct typo

[EricWF]

Sorry, I'm going to have to let @ldionne weigh in on this too. I'm just not sure introducing this whole new build mode with a separate exception library is something we want to do -- so I would like input from the other maintainers.

I think the correct approach here is to define the required exception symbols in libc++abi, like we do already for most exception types.

I think we're inventing something novel here because it's easy, not because it's the best approach.

libcxx/include/__memory/shared_ptr.h

50

Let's create an ABI macro, since other users might want to have the bad_weak_ptr exception too, that will make this code more readable and then you can just turn it on for your platform.

Sorry for not suggesting that earlier.

libcxx/src/CMakeLists.txt

138

Right, then these things should go into libc++abi. Not a third separate library.

[zibi]

@EricWF Thank you for the review.

@ldionne Can you weigh on this as requested by Eric?

libcxx/include/__memory/shared_ptr.h

50

@ldionne Do you agree with Eric's suggestion?
Also I believe we HAD a macro before but it was suggested to remove it and just use namespace std directly. If the recommendation is to go back to macro idea I wonder where should it go since it is needed here as well in libcxx/src/exceptions.cpp.

libcxx/src/CMakeLists.txt

138

See the discussion below between Fanbo and Loius why we created 3rd library. We really cannot undo this change.

[ldionne]

Recording the conclusion of our live meeting w/ Eric today: We're asking that these be moved into libcxxabi like the other exception types, which should not require any z/OS specific configuration option.

[zibi]

Moving several exception derived classes c++abi to address review comments.

[zibi]

• trying to fix CI.

[zibi]

• fix formatting

[zibi]

@fanbo-meng Can you close this review?
I'm going to continue in D138951.

libcxx/cmake/Modules/HandleExceptionLibrary.cmake

+#===============================================================================
+# Define targets for linking against the selected ABI library
+#
+# After including this file, the following targets are defined:
+# - cxx_exception: A target representing the shared c++_exception library.
+#                  constituting the split from c++ shared library.
+#                  The LIBCXX_EXCEPTION_ZOS_BUILD, which can be defined in
+#                  cache, determines if the library will be built or not.
+#===============================================================================
+
+
+if (LIBCXX_EXCEPTION_ZOS_BUILD)
+  add_library(cxx_exception SHARED ${exclude_from_all} ${LIBCXX_EXCEPTION_SOURCES} ${LIBCXX_HEADERS})
+  target_link_libraries(cxx_exception PUBLIC cxx-headers
+                                      PRIVATE ${LIBCXX_LIBRARIES})
+  set_target_properties(cxx_exception
+    PROPERTIES
+      COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS} -D_LIBCPP_BUILD_EXCEPTION_STANDALONE"
+      LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
+      OUTPUT_NAME   "c++_exception"
+      VERSION       "${LIBCXX_ABI_VERSION}.0"
+      SOVERSION     "${LIBCXX_ABI_VERSION}"
+      DEFINE_SYMBOL ""
+      POSITION_INDEPENDENT_CODE ON
+  )
+  cxx_add_common_build_flags(cxx_exception)
+  cxx_set_common_defines(cxx_exception)
+
+  add_custom_command(TARGET cxx_exception POST_BUILD
+    COMMAND
+      ${LIBCXX_SOURCE_DIR}/utils/zos_rename_dll_side_deck.sh
+      $<TARGET_LINKER_FILE_NAME:cxx_exception> $<TARGET_FILE_NAME:cxx_exception> "${LIBCXX_EXCEPTION_DLL_NAME}"
+    COMMENT "Rename dll name inside the side deck file"
+    WORKING_DIRECTORY $<TARGET_FILE_DIR:cxx_exception>
+  )
+
+  target_link_libraries(cxx_exception PUBLIC libcxx-abi-shared)
+  list(APPEND LIBCXX_BUILD_TARGETS "cxx_exception")
+endif()

libcxx/cmake/caches/s390x-ibm-zos-ascii.cmake

 set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
 set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXXABI_INCLUDE_TESTS OFF CACHE BOOL "")
 
 # Target Specific
 set(LIBCXX_DLL_NAME CRTEQCXS CACHE STRING "")
 set(LIBCXX_SHARED_OUTPUT_NAME "c++_a" CACHE STRING
     "Output name for the shared libc++ runtime library.")
+set(LIBCXX_EXCEPTION_ZOS_BUILD OFF CACHE BOOL
+    "Build libcxx exception library on z/OS as standalone.")
 set(LIBCXX_CXX_ABI system-libcxxabi CACHE STRING "")
 
 set(LIBCXX_ADDITIONAL_COMPILE_FLAGS "-fzos-le-char-mode=ascii" CACHE STRING "")
 set(LIBCXX_ADDITIONAL_LIBRARIES "-L../s390x-ibm-zos/lib -Wl,../s390x-ibm-zos/lib/libunwind.x" CACHE STRING "")

libcxx/cmake/caches/s390x-ibm-zos.cmake

 set(CMAKE_BUILD_TYPE Release CACHE STRING "")
 
 # Common
 set(LIBCXX_ENABLE_ABI_LINKER_SCRIPT OFF CACHE BOOL "")
 set(LIBCXX_ENABLE_SHARED ON CACHE BOOL "")
 set(LIBCXX_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXX_INCLUDE_TESTS ON CACHE BOOL "")
 
 set(LIBCXXABI_ENABLE_SHARED ON CACHE BOOL "")
 set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXXABI_INCLUDE_TESTS ON CACHE BOOL "")
 
 # Target Specific
 set(LIBCXX_DLL_NAME CRTEQCXE CACHE STRING "")
+set(LIBCXX_EXCEPTION_DLL_NAME CRTEQCXP CACHE STRING "")
+set(LIBCXX_EXCEPTION_ZOS_BUILD ON CACHE BOOL
+      "Build libcxx exception library on z/OS as standalone.")
 
 set(LIBCXXABI_DLL_NAME CRTEQCXA CACHE STRING "")
 set(LIBCXXABI_ADDITIONAL_LIBRARIES "-Wl,lib/libunwind.x" CACHE STRING "")

libcxx/cmake/caches/s390x32-ibm-zos-ascii.cmake

 set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "")
 set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXXABI_INCLUDE_TESTS OFF CACHE BOOL "")
 
 # Target Specific
 set(LIBCXX_DLL_NAME CRTEHCXS CACHE STRING "")
 set(LIBCXX_SHARED_OUTPUT_NAME "c++_a" CACHE STRING
     "Output name for the shared libc++ runtime library.")
+set(LIBCXX_EXCEPTION_ZOS_BUILD OFF CACHE BOOL
+    "Build libcxx exception library on z/OS as standalone.")
 set(LIBCXX_CXX_ABI system-libcxxabi CACHE STRING "")
 
 set(LIBCXX_ADDITIONAL_COMPILE_FLAGS "-fzos-le-char-mode=ascii" CACHE STRING "")
 set(LIBCXX_ADDITIONAL_LIBRARIES "-L../s390x32-ibm-zos/lib -Wl,../s390x32-ibm-zos/lib/libunwind.x" CACHE STRING "")

libcxx/cmake/caches/s390x32-ibm-zos.cmake

 # Common
 set(CMAKE_BUILD_TYPE Release CACHE STRING "")
 
 set(LIBCXX_ENABLE_ABI_LINKER_SCRIPT OFF CACHE BOOL "")
 set(LIBCXX_ENABLE_SHARED ON CACHE BOOL "")
 set(LIBCXX_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXX_INCLUDE_TESTS ON CACHE BOOL "")
 
 set(LIBCXXABI_ENABLE_SHARED ON CACHE BOOL "")
 set(LIBCXXABI_ENABLE_STATIC OFF CACHE BOOL "")
 set(LIBCXXABI_INCLUDE_TESTS ON CACHE BOOL "")
 
 # Target Specific
 set(LIBCXX_DLL_NAME CRTEHCXE CACHE STRING "")
+set(LIBCXX_EXCEPTION_DLL_NAME CRTEHCXP CACHE STRING "")
+set(LIBCXX_EXCEPTION_ZOS_BUILD ON CACHE BOOL
+    "Build libcxx exception library on z/OS as standalone.")
 
 set(LIBCXXABI_DLL_NAME CRTEHCXA CACHE STRING "")
 
 set(LIBCXXABI_ADDITIONAL_LIBRARIES "-Wl,lib/libunwind.x" CACHE STRING "")

libcxx/include/__config

 
 // Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
 // clang-format off
 #  define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE {
 #  define _LIBCPP_END_NAMESPACE_STD }}
 #  define _VSTD std
 
 _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
+#if defined(__MVS__)
+#define _LIBCPP_BEGIN_NAMESPACE_EXCEPTION namespace std {
+#define _LIBCPP_END_NAMESPACE_EXCEPTION }
+#else
+#define _LIBCPP_BEGIN_NAMESPACE_EXCEPTION _LIBCPP_BEGIN_NAMESPACE_STD
+#define _LIBCPP_END_NAMESPACE_EXCEPTION _LIBCPP_END_NAMESPACE_STD
+#endif
 
 #  if _LIBCPP_STD_VER > 14
 #    define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM                                                                         \
        _LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
 #  else
 #    define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM                                                                         \
       _LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
 #  endif

 #    define _LIBCPP_USING_IF_EXISTS __attribute__((__using_if_exists__))
 #  else
 #    define _LIBCPP_USING_IF_EXISTS
 #  endif
 
 #  ifdef _LIBCPP_CXX03_LANG
 #    define _LIBCPP_DECLARE_STRONG_ENUM(x)                                                                             \
       struct _LIBCPP_TYPE_VIS x {                                                                                      \
         enum __lx
 // clang-format off
 #    define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)                                                                      \
       __lx __v_;                                                                                                       \
       _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {}                                                             \
       _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {}                                  \
       _LIBCPP_INLINE_VISIBILITY operator int() const { return __v_; }                                                  \
       };
 // clang-format on
 
 #  else // _LIBCPP_CXX03_LANG
 #    define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x

libcxx/include/__memory/shared_ptr.h

 #  include <atomic>
 #endif
 
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_BEGIN_NAMESPACE_EXCEPTION
+
+class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
+    : public std::exception
+{
+public:
+    bad_weak_ptr() _NOEXCEPT = default;
+    bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
+    virtual ~bad_weak_ptr() _NOEXCEPT;
+    virtual const char* what() const  _NOEXCEPT;
+};
+
+_LIBCPP_END_NAMESPACE_EXCEPTION
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Alloc>
 class __allocator_destructor
 {
     typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
 public:
     typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;

 {
 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
     return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
 #else
     return __t -= 1;
 #endif
 }
 
-class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
-    : public std::exception
-{
-public:
-    bad_weak_ptr() _NOEXCEPT = default;
-    bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
-    ~bad_weak_ptr() _NOEXCEPT override;
-    const char* what() const  _NOEXCEPT override;
-};
-
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_weak_ptr();
 #else
     _VSTD::abort();
 #endif

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   support/runtime/new_handler_fallback.ipp
   support/runtime/stdexcept_default.ipp
   support/runtime/stdexcept_vcruntime.ipp
   system_error.cpp
   thread.cpp
   typeinfo.cpp
   utility.cpp
   valarray.cpp
-  variant.cpp
   vector.cpp
   verbose_abort.cpp
   )
 
 if (LIBCXX_ENABLE_DEBUG_MODE OR LIBCXX_ENABLE_BACKWARDS_COMPATIBILITY_DEBUG_MODE_SYMBOLS)
   list(APPEND LIBCXX_SOURCES
     debug.cpp
     legacy_debug_handler.cpp
if (LIBCXX_ENABLE_FILESYSTEM)
   # definitions. See filesystem/int128_builtins.cpp.
   if (NOT LIBCXX_USE_COMPILER_RT)
     list(APPEND LIBCXX_SOURCES
       filesystem/int128_builtins.cpp
       )
   endif()
 endif()
 
+set(LIBCXX_EXCEPTION_SOURCES
+  exceptions/memory.cpp
+  exceptions/any.cpp
+  exceptions/optional.cpp
+  exceptions/variant.cpp
+  )
+
+if (NOT ZOS)
+  list(APPEND LIBCXX_SOURCES ${LIBCXX_EXCEPTION_SOURCES})
+endif()
+
 # Add all the headers to the project for IDEs.
 if (LIBCXX_CONFIGURE_IDE)
   file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
   if(WIN32)
     file( GLOB LIBCXX_WIN32_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/__support/win32/*.h)
     list(APPEND LIBCXX_HEADERS ${LIBCXX_WIN32_HEADERS})
   endif()
   # Force them all into the headers dir on MSVC, otherwise they end up at
if(WIN32 AND NOT MINGW AND NOT "${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows")
     # Since we most likely do not have a mt.exe replacement, disable the
     # manifest bundling.  This allows a normal cmake invocation to pass which
     # will attempt to use the manifest tool to generate the bundled manifest
     set_target_properties(cxx_shared PROPERTIES
                           APPEND_STRING PROPERTY LINK_FLAGS " /MANIFEST:NO")
   endif()
 endif()
 
+include(HandleExceptionLibrary)
+
 set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
 
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
   add_library(cxx_static STATIC ${exclude_from_all} ${LIBCXX_SOURCES} ${LIBCXX_HEADERS})
   target_include_directories(cxx_static PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
   target_link_libraries(cxx_static PUBLIC cxx-headers
                                    PRIVATE ${LIBCXX_LIBRARIES}
                                    PRIVATE libcxx-abi-static)
   set_target_properties(cxx_static
     PROPERTIES
       COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
       OUTPUT_NAME   "c++"
   )
   cxx_add_common_build_flags(cxx_static)
   cxx_set_common_defines(cxx_static)
 
   if (LIBCXX_HERMETIC_STATIC_LIBRARY)
     # If the hermetic library doesn't define the operator new/delete functions
     # then its code shouldn't declare them with hidden visibility.  They might
     # actually be provided by a shared library at link time.
     if (LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS)

libcxx/src/any.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <any>
 
-namespace std {
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
-}
-
-
 #include <experimental/__config>
 
 //  Preserve std::experimental::any_bad_cast for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {

libcxx/src/exceptions/any.cpp

+//===----------------------------------------------------------------------===//
+////
+//// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+//// See https://llvm.org/LICENSE.txt for license information.
+//// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+////
+////===----------------------------------------------------------------------===//
+
+#include "any"
+
+namespace std {
+const char* bad_any_cast::what() const noexcept { return "bad any cast"; }
+}

libcxx/src/exceptions/memory.cpp

+
+//===----------------------------------------------------------------------===//
+////
+//// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+//// See https://llvm.org/LICENSE.txt for license information.
+//// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+////
+////===----------------------------------------------------------------------===//
+//
+
+#include "memory"
+
+_LIBCPP_BEGIN_NAMESPACE_EXCEPTION
+
+bad_weak_ptr::~bad_weak_ptr() noexcept {}
+
+const char* bad_weak_ptr::what() const noexcept { return "bad_weak_ptr"; }
+
+_LIBCPP_END_NAMESPACE_EXCEPTION

libcxx/src/exceptions/optional.cpp

+
+//===----------------------------------------------------------------------===//
+////
+//// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+//// See https://llvm.org/LICENSE.txt for license information.
+//// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+////
+////===----------------------------------------------------------------------===//
+
+#include "optional"
+
+namespace std
+{
+
+bad_optional_access::~bad_optional_access() noexcept = default;
+
+const char* bad_optional_access::what() const noexcept { return "bad_optional_access"; }
+
+} // std

libcxx/src/exceptions/variant.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <variant>
 
 namespace std {
 
 const char* bad_variant_access::what() const noexcept {
   return "bad_variant_access";
 }
 
 }  // namespace std

libcxx/src/memory.cpp

 #endif
 
 #include "include/atomic_support.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const allocator_arg_t allocator_arg = allocator_arg_t();
 
-bad_weak_ptr::~bad_weak_ptr() noexcept {}
-
-const char*
-bad_weak_ptr::what() const noexcept
-{
-    return "bad_weak_ptr";
-}
-
 __shared_count::~__shared_count()
 {
 }
 
 __shared_weak_count::~__shared_weak_count()
 {
 }
 

libcxx/src/optional.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <__availability>
 #include <optional>
 
-namespace std
-{
-
-bad_optional_access::~bad_optional_access() noexcept = default;
-
-const char* bad_optional_access::what() const noexcept {
-  return "bad_optional_access";
-}
-
-} // std
-
-
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
   : public std::logic_error

libcxx/src/variant.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <variant>
-
-namespace std {
-
-const char* bad_variant_access::what() const noexcept {
-  return "bad_variant_access";
-}
-
-}  // namespace std

libcxx/utils/libcxx/test/config.py

+#===----------------------------------------------------------------------===##
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+#===----------------------------------------------------------------------===##
+
+import copy
+import os
+import pkgutil
+import pipes
+import platform
+import re
+import shlex
+import shutil
+import sys
+
+from libcxx.compiler import CXXCompiler
+from libcxx.test.target_info import make_target_info
+import libcxx.util
+import libcxx.test.features
+import libcxx.test.newconfig
+import libcxx.test.params
+import lit
+
+def loadSiteConfig(lit_config, config, param_name, env_name):
+    # We haven't loaded the site specific configuration (the user is
+    # probably trying to run on a test file directly, and either the site
+    # configuration hasn't been created by the build system, or we are in an
+    # out-of-tree build situation).
+    site_cfg = lit_config.params.get(param_name,
+                                     os.environ.get(env_name))
+    if not site_cfg:
+        lit_config.warning('No site specific configuration file found!'
+                           ' Running the tests in the default configuration.')
+    elif not os.path.isfile(site_cfg):
+        lit_config.fatal(
+            "Specified site configuration file does not exist: '%s'" %
+            site_cfg)
+    else:
+        lit_config.note('using site specific configuration at %s' % site_cfg)
+        ld_fn = lit_config.load_config
+
+        # Null out the load_config function so that lit.site.cfg doesn't
+        # recursively load a config even if it tries.
+        # TODO: This is one hell of a hack. Fix it.
+        def prevent_reload_fn(*args, **kwargs):
+            pass
+        lit_config.load_config = prevent_reload_fn
+        ld_fn(config, site_cfg)
+        lit_config.load_config = ld_fn
+
+# Extract the value of a numeric macro such as __cplusplus or a feature-test
+# macro.
+def intMacroValue(token):
+    return int(token.rstrip('LlUu'))
+
+class Configuration(object):
+    # pylint: disable=redefined-outer-name
+    def __init__(self, lit_config, config):
+        self.lit_config = lit_config
+        self.config = config
+        self.cxx = None
+        self.cxx_is_clang_cl = None
+        self.cxx_stdlib_under_test = None
+        self.project_obj_root = None
+        self.libcxx_src_root = None
+        self.libcxx_obj_root = None
+        self.cxx_library_root = None
+        self.cxx_runtime_root = None
+        self.abi_library_root = None
+        self.link_shared = self.get_lit_bool('enable_shared', default=True)
+        self.debug_build = self.get_lit_bool('debug_build',   default=False)
+        self.exec_env = dict()
+        self.use_clang_verify = False
+
+    def get_lit_conf(self, name, default=None):
+        val = self.lit_config.params.get(name, None)
+        if val is None:
+            val = getattr(self.config, name, None)
+            if val is None:
+                val = default
+        return val
+
+    def get_lit_bool(self, name, default=None, env_var=None):
+        def check_value(value, var_name):
+            if value is None:
+                return default
+            if isinstance(value, bool):
+                return value
+            if not isinstance(value, str):
+                raise TypeError('expected bool or string')
+            if value.lower() in ('1', 'true'):
+                return True
+            if value.lower() in ('', '0', 'false'):
+                return False
+            self.lit_config.fatal(
+                "parameter '{}' should be true or false".format(var_name))
+
+        conf_val = self.get_lit_conf(name)
+        if env_var is not None and env_var in os.environ and \
+                os.environ[env_var] is not None:
+            val = os.environ[env_var]
+            if conf_val is not 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() 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')
+        self.configure_cxx()
+        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') 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_coverage()
+        self.configure_substitutions()
+        self.configure_features()
+
+        libcxx.test.newconfig.configure(
+            libcxx.test.params.DEFAULT_PARAMETERS,
+            libcxx.test.features.DEFAULT_FEATURES,
+            self.config,
+            self.lit_config
+        )
+
+        self.lit_config.note("All available features: {}".format(self.config.available_features))
+
+    def print_config_info(self):
+        if self.cxx.use_modules:
+            self.lit_config.note('Using modules flags: %s' %
+                                 self.cxx.modules_flags)
+        if len(self.cxx.warning_flags):
+            self.lit_config.note('Using warnings: %s' % self.cxx.warning_flags)
+        show_env_vars = {}
+        for k,v in self.exec_env.items():
+            if k not in os.environ or os.environ[k] != v:
+                show_env_vars[k] = v
+        self.lit_config.note('Adding environment variables: %r' % show_env_vars)
+        self.lit_config.note("Linking against the C++ Library at {}".format(self.cxx_library_root))
+        self.lit_config.note("Running against the C++ Library at {}".format(self.cxx_runtime_root))
+        self.lit_config.note("Linking against the ABI Library at {}".format(self.abi_library_root))
+        self.lit_config.note("Running against the ABI Library at {}".format(self.abi_runtime_root))
+
+    def configure_cxx(self):
+        # Gather various compiler parameters.
+        cxx = self.get_lit_conf('cxx_under_test')
+        self.cxx_is_clang_cl = cxx is not None and \
+                               os.path.basename(cxx).startswith('clang-cl')
+        # If no specific cxx_under_test was given, attempt to infer it as
+        # clang++.
+        if cxx is None or self.cxx_is_clang_cl:
+            search_paths = self.config.environment['PATH']
+            if cxx is not None and os.path.isabs(cxx):
+                search_paths = os.path.dirname(cxx)
+            clangxx = libcxx.util.which('clang++', search_paths)
+            if clangxx:
+                cxx = clangxx
+                self.lit_config.note(
+                    "inferred cxx_under_test as: %r" % cxx)
+            elif self.cxx_is_clang_cl:
+                self.lit_config.fatal('Failed to find clang++ substitution for'
+                                      ' clang-cl')
+        if not cxx:
+            self.lit_config.fatal('must specify user parameter cxx_under_test '
+                                  '(e.g., --param=cxx_under_test=clang++)')
+        self.cxx = CXXCompiler(self, cxx) if not self.cxx_is_clang_cl else \
+                   self._configure_clang_cl(cxx)
+        self.cxx.compile_env = dict(os.environ)
+
+    def _configure_clang_cl(self, clang_path):
+        def _split_env_var(var):
+            return [p.strip() for p in os.environ.get(var, '').split(';') if p.strip()]
+
+        def _prefixed_env_list(var, prefix):
+            from itertools import chain
+            return list(chain.from_iterable((prefix, path) for path in _split_env_var(var)))
+
+        assert self.cxx_is_clang_cl
+        flags = []
+        compile_flags = []
+        link_flags = _prefixed_env_list('LIB', '-L')
+        return CXXCompiler(self, clang_path, flags=flags,
+                           compile_flags=compile_flags,
+                           link_flags=link_flags)
+
+    def configure_src_root(self):
+        self.libcxx_src_root = self.get_lit_conf(
+            'libcxx_src_root', os.path.dirname(self.config.test_source_root))
+
+    def configure_obj_root(self):
+        self.project_obj_root = self.get_lit_conf('project_obj_root')
+        self.libcxx_obj_root = self.get_lit_conf('libcxx_obj_root')
+        if not self.libcxx_obj_root and self.project_obj_root is not None:
+            possible_roots = [
+                os.path.join(self.project_obj_root, 'libcxx'),
+                os.path.join(self.project_obj_root, 'projects', 'libcxx'),
+                os.path.join(self.project_obj_root, 'runtimes', 'libcxx'),
+            ]
+            for possible_root in possible_roots:
+                if os.path.isdir(possible_root):
+                    self.libcxx_obj_root = possible_root
+                    break
+            else:
+                self.libcxx_obj_root = self.project_obj_root
+
+    def configure_features(self):
+        if self.target_info.is_windows():
+            if self.cxx_stdlib_under_test == 'libc++':
+                # LIBCXX-WINDOWS-FIXME is the feature name used to XFAIL the
+                # initial Windows failures until they can be properly diagnosed
+                # and fixed. This allows easier detection of new test failures
+                # and regressions. Note: New failures should not be suppressed
+                # using this feature. (Also see llvm.org/PR32730)
+                self.config.available_features.add('LIBCXX-WINDOWS-FIXME')
+
+    def configure_compile_flags(self):
+        self.configure_default_compile_flags()
+        # Configure extra flags
+        compile_flags_str = self.get_lit_conf('compile_flags', '')
+        self.cxx.compile_flags += shlex.split(compile_flags_str)
+        if self.target_info.is_windows():
+            self.cxx.compile_flags += ['-D_CRT_SECURE_NO_WARNINGS']
+            # Don't warn about using common but nonstandard unprefixed functions
+            # like chdir, fileno.
+            self.cxx.compile_flags += ['-D_CRT_NONSTDC_NO_WARNINGS']
+            # Build the tests in the same configuration as libcxx itself,
+            # to avoid mismatches if linked statically.
+            self.cxx.compile_flags += ['-D_CRT_STDIO_ISO_WIDE_SPECIFIERS']
+            # Required so that tests using min/max don't fail on Windows,
+            # and so that those tests don't have to be changed to tolerate
+            # this insanity.
+            self.cxx.compile_flags += ['-DNOMINMAX']
+        additional_flags = self.get_lit_conf('test_compiler_flags')
+        if additional_flags:
+            self.cxx.compile_flags += shlex.split(additional_flags)
+
+    def configure_default_compile_flags(self):
+        # Configure include paths
+        self.configure_compile_flags_header_includes()
+        self.target_info.add_cxx_compile_flags(self.cxx.compile_flags)
+        self.target_info.add_cxx_flags(self.cxx.flags)
+        # Use verbose output for better errors
+        self.cxx.flags += ['-v']
+        sysroot = self.get_lit_conf('sysroot')
+        if sysroot:
+            self.cxx.flags += ['--sysroot=' + sysroot]
+        gcc_toolchain = self.get_lit_conf('gcc_toolchain')
+        if gcc_toolchain:
+            self.cxx.flags += ['--gcc-toolchain=' + gcc_toolchain]
+        # NOTE: the _DEBUG definition must preceed the triple check because for
+        # the Windows build of libc++, the forced inclusion of a header requires
+        # that _DEBUG is defined.  Incorrect ordering will result in -target
+        # being elided.
+        if self.target_info.is_windows() and self.debug_build:
+            self.cxx.compile_flags += ['-D_DEBUG']
+
+        # Add includes for support headers used in the tests.
+        support_path = os.path.join(self.libcxx_src_root, 'test/support')
+        self.cxx.compile_flags += ['-I' + support_path]
+
+        # Add includes for the PSTL headers
+        pstl_src_root = self.get_lit_conf('pstl_src_root')
+        pstl_obj_root = self.get_lit_conf('pstl_obj_root')
+        if pstl_src_root is not None and pstl_obj_root is not None:
+            self.cxx.compile_flags += ['-I' + os.path.join(pstl_src_root, 'include')]
+            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')
+        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 \
+                self.cxx_stdlib_under_test != 'msvc':
+            self.cxx.compile_flags += [
+                '-include', os.path.join(support_path,
+                                         'set_windows_crt_report_mode.h')
+            ]
+        cxx_headers = self.get_lit_conf('cxx_headers')
+        if cxx_headers is None and self.cxx_stdlib_under_test != 'libc++':
+            self.lit_config.note('using the system cxx headers')
+            return
+        self.cxx.compile_flags += ['-nostdinc++']
+        if not os.path.isdir(cxx_headers):
+            self.lit_config.fatal("cxx_headers='{}' is not a directory.".format(cxx_headers))
+        (path, version) = os.path.split(cxx_headers)
+        (path, cxx) = os.path.split(path)
+        triple = self.get_lit_conf('target_triple', None)
+        if triple is not None:
+            cxx_target_headers = os.path.join(path, triple, cxx, version)
+            if os.path.isdir(cxx_target_headers):
+                self.cxx.compile_flags += ['-I' + cxx_target_headers]
+        self.cxx.compile_flags += ['-I' + cxx_headers]
+        if self.libcxx_obj_root is not None:
+            cxxabi_headers = os.path.join(self.libcxx_obj_root, 'include',
+                                          'c++build')
+            if os.path.isdir(cxxabi_headers):
+                self.cxx.compile_flags += ['-I' + cxxabi_headers]
+
+    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() 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.
+            pass
+        elif self.cxx_stdlib_under_test == 'cxx_default':
+            self.cxx.link_flags += ['-pthread']
+        else:
+            self.lit_config.fatal('invalid stdlib under test')
+
+        link_flags_str = self.get_lit_conf('link_flags', '')
+        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():
+                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():
+                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++']
+            if self.target_info.is_zos():
+                self.cxx.link_flags += ['-lc++_exception']
+        else:
+            if self.cxx_library_root:
+                libname = self.make_static_lib_name('c++')
+                abs_path = os.path.join(self.cxx_library_root, libname)
+                assert os.path.exists(abs_path) and \
+                       "static libc++ library does not exist"
+                self.cxx.link_flags += [abs_path]
+            else:
+                self.cxx.link_flags += ['-lc++']
+
+    def configure_link_flags_abi_library(self):
+        cxx_abi = self.get_lit_conf('cxx_abi', 'libcxxabi')
+        if cxx_abi == 'libstdc++':
+            self.cxx.link_flags += ['-lstdc++']
+        elif cxx_abi == 'libsupc++':
+            self.cxx.link_flags += ['-lsupc++']
+        elif cxx_abi == 'libcxxabi':
+            # If the C++ library requires explicitly linking to libc++abi, or
+            # if we're testing libc++abi itself (the test configs are shared),
+            # then link it.
+            testing_libcxxabi = self.get_lit_conf('name', '') == 'libc++abi'
+            if self.target_info.allow_cxxabi_link() or testing_libcxxabi:
+                libcxxabi_shared = self.get_lit_bool('libcxxabi_shared', default=True)
+                if libcxxabi_shared:
+                    self.cxx.link_flags += ['-lc++abi']
+                else:
+                    if self.abi_library_root:
+                        libname = self.make_static_lib_name('c++abi')
+                        abs_path = os.path.join(self.abi_library_root, libname)
+                        self.cxx.link_flags += [abs_path]
+                    else:
+                        self.cxx.link_flags += ['-lc++abi']
+        elif cxx_abi == 'libcxxrt':
+            self.cxx.link_flags += ['-lcxxrt']
+        elif cxx_abi == 'vcruntime':
+            debug_suffix = 'd' if self.debug_build else ''
+            # This matches the set of libraries linked in the toplevel
+            # libcxx CMakeLists.txt if building targeting msvc.
+            self.cxx.link_flags += ['-l%s%s' % (lib, debug_suffix) for lib in
+                                    ['vcruntime', 'ucrt', 'msvcrt', 'msvcprt']]
+            # The compiler normally links in oldnames.lib too, but we've
+            # specified -nostdlib above, so we need to specify it manually.
+            self.cxx.link_flags += ['-loldnames']
+        elif cxx_abi == 'none' or cxx_abi == 'default':
+            if self.target_info.is_windows():
+                debug_suffix = 'd' if self.debug_build else ''
+                self.cxx.link_flags += ['-lmsvcrt%s' % debug_suffix]
+        else:
+            self.lit_config.fatal(
+                'C++ ABI setting %s unsupported for tests' % cxx_abi)
+
+    def configure_extra_library_flags(self):
+        if self.get_lit_bool('cxx_ext_threads', default=False):
+            self.cxx.link_flags += ['-lc++external_threads']
+        self.target_info.add_cxx_link_flags(self.cxx.link_flags)
+
+    def configure_coverage(self):
+        self.generate_coverage = self.get_lit_bool('generate_coverage', False)
+        if self.generate_coverage:
+            self.cxx.flags += ['-g', '--coverage']
+            self.cxx.compile_flags += ['-O0']
+
+    def quote(self, s):
+        if platform.system() == 'Windows':
+            return lit.TestRunner.quote_windows_command([s])
+        return pipes.quote(s)
+
+    def configure_substitutions(self):
+        sub = self.config.substitutions
+        sub.append(('%{cxx}', self.quote(self.cxx.path)))
+        flags = self.cxx.flags + (self.cxx.modules_flags if self.cxx.use_modules else [])
+        compile_flags = self.cxx.compile_flags + (self.cxx.warning_flags if self.cxx.use_warnings else [])
+        sub.append(('%{flags}',         ' '.join(map(self.quote, flags))))
+        sub.append(('%{compile_flags}', ' '.join(map(self.quote, compile_flags))))
+        sub.append(('%{link_flags}',    ' '.join(map(self.quote, self.cxx.link_flags))))
+        sub.append(('%{install}',       self.quote(self.config.install_root)))
+
+        codesign_ident = self.get_lit_conf('llvm_codesign_identity', '')
+        env_vars = ' '.join('%s=%s' % (k, self.quote(v)) for (k, v) in self.exec_env.items())
+        exec_args = [
+            '--execdir %T',
+            '--codesign_identity "{}"'.format(codesign_ident),
+            '--env {}'.format(env_vars)
+        ]
+        sub.append(('%{exec}', '{} {} -- '.format(self.executor, ' '.join(exec_args))))
+
+    def configure_env(self):
+        self.config.environment = dict(os.environ)
+
+    def add_path(self, dest_env, new_path):
+        self.target_info.add_path(dest_env, new_path)