Add support for building ancient Clang (2.6-4.0) (#84)

This PR adds support for building Clang 2.6 through 4.0 using Ubuntu 16.04, aiming to replace third-party binaries I provided for compiler-explorer/infra@8123801.

At the high level, changes are:
1. Support for Ubuntu 16.04 in the Dockerfile.
2. New mechanism to cherry-pick commits into the tree (`COMMITS_TO_CHERRYPICK`).
3. Special sections for 2.6-3.7, where we hardcode GCC version, commits to cherry-pick, patches to apply, and names of test targets.
4. Logic that translates `LLVM_ENABLE_PROJECTS` into the directory structure that old versions expect using symbolic links.
5. New testing that checks that just-built Clang is capable of compiling C++ hello world both with and without `-stdlib=libc++`, and that `libc++.so` is good enough for it to run successfully.
6. Patch files, mostly for cherry-picks that don't apply cleanly.

<details>
<summary>Test results (passes are the first number, failures are the fourth number):</summary>

The order is:
 - Expected Passes
 - Expected Failures
 - Unsupported Tests
 - Unexpected Failures
 - Unexpected Passes

</details>

|  Clang  | GCC   | LLVM tests          | Clang tests       | Libc++ tests       |
|---------|-------|---------------------|-------------------|--------------------|
|  2.6.0  | 4.4.7 |    N/A via CMake    |  1463  0  0  0    | N/A                |
|  2.7.0  | 4.4.7 |  4294  23 514 26    |  2090 13  0  0    | N/A                |
|  2.8.0  | 4.5.3 |  4562  28 552 94    |  2505 19  0  1    | N/A                | 
|  2.9.0  | 4.5.3 |  5262  46 542  0    |  2884 22  0  2    | N/A                |
|  3.0.0  | 4.4.7 |  5590  49  13  0    |  3913 25  1  2    | N/A                |
|  3.1.0  | 4.4.7 |  5823  51  13  0    |  4537 27  0  2    | N/A                |
|  3.2.0  | 4.4.7 |  6781  56  13  0    |  5565 25  2  1    |     Can't build    |
|  3.3.0  | 4.8.5 |  8483  54  99  0    |  6216 22  4  2    | 3315  0   0 1075 0 |
|  3.4.0  | 4.8.5 |  9239  51  34  0    |  6770 20  5  2    | 4058  0   0  585 0 |
|  3.5.0  | 4.9.4 | 11131  90  35  0    |  7492 14 11  0    | 4490  0   0  260 0 |
|  3.6.0  | 4.9.4 | 12138  83  55  0    |  7924 14 13  0    | 4640 11  69   68 3 |
|  3.7.0  | 5.5   | 14025 105  46  0    |  8374 14 15  0    | 4751 20 125   31 3 |
|  3.8.0  | 5.5   | 15387 129 100  0    |  8847 16 17  0    | 4869  4 107   42 4 |
|  3.9.0  | 5.5   | 17093 128 149  0    |  9597 16 23  0    | 5218  5 111   33 0 |
|  4.0.0  | 5.5   | 18806 151 381  0    | 10313 18 34  0    | 5038 24 645   19 0 |

(Note that libc++ runs its tests using the compiler it was built with, i.e. GCC, so bad results are not caused by a bad Clang build. Which means they are not representative of the experience people will have using `-stdlib=libc++`.)

Those results are directly comparable with those I have for the binaries that are currently deployed: https://gist.github.com/Endilll/d36e4080b68d682e2b9fd96980cfb40a. While libc++ seems to be worse, it doesn't really matter as outlined above. Overall, the builds this script produces should be on par, if not slightly better, than the ones I did 2 years ago.

Author: Endilll

.github/workflows/build.yml

@@ -15,6 +15,9 @@ jobs:
           # Some older clangs (<10) needs to be an older glibc, as comes with 18.04 in order to build 9.* and earlier.
           # otherwise we somehow need to apply 947f9692440836dcb8d88b74b69dd379d85974ce to get the sanitizer
           # to build.
+        - image: 16.04
+          suffix: -16.4
+          # Ancient Clang builds (2.6-4.0) assume 16.04 environment. 
     steps:
     - name: Docker Setup Buildx
       uses: docker/setup-buildx-action@v3

Dockerfile

@@ -28,15 +28,15 @@ RUN apt update -y -q && apt upgrade -y -q && apt update -y -q && \
     xz-utils \
     zlib1g-dev
 
-RUN bash -c "if [[ ${image} == 18.04 ]]; then apt install -y -q python; else apt install -y -q python-is-python3; fi"
+RUN bash -c "if [[ ${image} == 16.04 || ${image} == 18.04 ]]; then apt install -y -q python; else apt install -y -q python-is-python3; fi"
 
 WORKDIR /root
 
 RUN curl -sL https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-Linux-x86_64.tar.gz \
     | tar zxvf - -C /usr --strip-components=1
 
 # Workaround for older clangs that expect xlocale.h
-RUN ln -s /usr/include/locale.h /usr/include/xlocale.h
+RUN bash -c "if [[ ${image} != 16.04 ]]; then ln -s /usr/include/locale.h /usr/include/xlocale.h; fi"
 
 RUN mkdir -p /root
 COPY build /root/

build/build.sh

@@ -0,0 +1,38 @@
+This is 95b6f045f1f104b96d443c404755c2757b6f6cf7
+"Use a script for creating the clang++ executable.",
+backported to 2.7
+
+diff --git a/clang/tools/driver/CMakeLists.txt b/clang/tools/driver/CMakeLists.txt
+index c4320b0c905c..78789201438a 100644
+--- a/clang/tools/driver/CMakeLists.txt
++++ b/clang/tools/driver/CMakeLists.txt
+@@ -45,4 +45,4 @@ install(TARGETS clang
+   RUNTIME DESTINATION bin)
+
+ # Create the clang++ symlink at installation time.
+-install(CODE "execute_process(COMMAND \"${CMAKE_COMMAND}\" -E ${CLANGXX_LINK_OR_COPY} \"${CMAKE_INSTALL_PREFIX}/bin/clang${CMAKE_EXECUTABLE_SUFFIX}\" \"\$ENV{DESTDIR}/\${CMAKE_INSTALL_PREFIX}/bin/clang++${CMAKE_EXECUTABLE_SUFFIX}\")")
++install(SCRIPT clang_symlink.cmake -DCMAKE_INSTALL_PREFIX=\"${CMAKE_INSTALL_PREFIX}\")
+diff --git a/clang/tools/driver/clang_symlink.cmake b/clang/tools/driver/clang_symlink.cmake
+new file mode 100644
+index 00000000000000..d3f11d313ef49b
+--- /dev/null
++++ b/clang/tools/driver/clang_symlink.cmake
+@@ -0,0 +1,18 @@
++# We need to execute this script at installation time because the
++# DESTDIR environment variable may be unset at configuration time.
++# See PR8397.
++
++if(UNIX)
++  set(CLANGXX_LINK_OR_COPY create_symlink)
++  set(CLANGXX_DESTDIR $ENV{DESTDIR})
++else()
++  set(CLANGXX_LINK_OR_COPY copy)
++endif()
++
++set(bindir "${CLANGXX_DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/")
++set(clang "${bindir}clang${CMAKE_EXECUTABLE_SUFFIX}")
++set(clangxx "${bindir}clang++${CMAKE_EXECUTABLE_SUFFIX}")
++
++message("Creating clang++ executable based on ${clang}")
++
++execute_process(COMMAND "${CMAKE_COMMAND}" -E ${CLANGXX_LINK_OR_COPY} "${clang}" "${clangxx}")

build/patches/ce-clang-2.7-clang-symlink.patch

@@ -0,0 +1,19 @@
+Clang 2.7 was caught between removal of the old clang-cc driver
+(3c6d1b52a09a6a94384b27840d64451d4fa292f3), and proper implementation of
+`-mllvm` that passes arguments to backend
+(76fa840d0990314d1d1c160803ba9d014a6c01a9). There appears to be no way to pass
+`-x86-asm-syntax` to the backend, so we're forced to change the default.
+
+diff --git a/llvm/lib/Target/X86/X86MCAsmInfo.cpp b/llvm/lib/Target/X86/X86MCAsmInfo.cpp
+index ded9717..b828945 100644
+--- a/llvm/lib/Target/X86/X86MCAsmInfo.cpp
++++ b/llvm/lib/Target/X86/X86MCAsmInfo.cpp
+@@ -25,7 +25,7 @@ enum AsmWriterFlavorTy {
+ };
+ 
+ static cl::opt<AsmWriterFlavorTy>
+-AsmWriterFlavor("x86-asm-syntax", cl::init(ATT),
++AsmWriterFlavor("x86-asm-syntax", cl::init(Intel),
+   cl::desc("Choose style of code to emit from X86 backend:"),
+   cl::values(clEnumValN(ATT,   "att",   "Emit AT&T-style assembly"),
+              clEnumValN(Intel, "intel", "Emit Intel-style assembly"),

build/patches/ce-clang-2.7-default-to-intel-asm-syntax.patch

@@ -0,0 +1,91 @@
+This is 5a3d898758ed87f5d58e92d3ecdb75b567b059d6
+"Make the Linux support for finding libc++ somewhat less braindead.",
+backported to 3.3
+
+diff --git a/clang/lib/Driver/ToolChains.cpp b/clang/lib/Driver/ToolChains.cpp
+index fffba0e4e50f..87a5a9c99794 100644
+--- a/clang/lib/Driver/ToolChains.cpp
++++ b/clang/lib/Driver/ToolChains.cpp
+@@ -2555,9 +2555,24 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+
+   // Check if libc++ has been enabled and provide its include paths if so.
+   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
+-    // libc++ is always installed at a fixed path on Linux currently.
+-    addSystemInclude(DriverArgs, CC1Args,
+-                     getDriver().SysRoot + "/usr/include/c++/v1");
++    const std::string LibCXXIncludePathCandidates[] = {
++      // The primary location is within the Clang installation.
++      // FIXME: We shouldn't hard code 'v1' here to make Clang future proof to
++      // newer ABI versions.
++      getDriver().Dir + "/../include/c++/v1",
++
++      // We also check the system as for a long time this is the only place Clang looked.
++      // FIXME: We should really remove this. It doesn't make any sense.
++      getDriver().SysRoot + "/usr/include/c++/v1"
++    };
++    for (unsigned i = 0; i < llvm::array_lengthof(LibCXXIncludePathCandidates);
++         ++i) {
++      if (!llvm::sys::fs::exists(LibCXXIncludePathCandidates[i]))
++        continue;
++      // Add the first candidate that exists.
++      addSystemInclude(DriverArgs, CC1Args, LibCXXIncludePathCandidates[i]);
++      break;
++    }
+     return;
+   }
+
+@@ -2581,7 +2596,7 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+                                DriverArgs, CC1Args))
+     return;
+
+-  const std::string IncludePathCandidates[] = {
++  const std::string LibStdCXXIncludePathCandidates[] = {
+     // Gentoo is weird and places its headers inside the GCC install, so if the
+     // first attempt to find the headers fails, try this pattern.
+     InstallDir.str() + "/include/g++-v4",
+@@ -2592,8 +2607,8 @@ void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+     LibDir.str() + "/../include/c++",
+   };
+
+-  for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
+-    if (addLibStdCXXIncludePaths(IncludePathCandidates[i], (TripleStr +
++  for (unsigned i = 0; i < llvm::array_lengthof(LibStdCXXIncludePathCandidates); ++i) {
++    if (addLibStdCXXIncludePaths(LibStdCXXIncludePathCandidates[i], (TripleStr +
+                 GCCInstallation.getMultiarchSuffix()),
+             DriverArgs, CC1Args))
+       break;
+diff --git a/clang/test/Driver/linux-header-search.cpp b/clang/test/Driver/linux-header-search.cpp
+index d09f5b27ae9d..57e245baa3d8 100644
+--- a/clang/test/Driver/linux-header-search.cpp
++++ b/clang/test/Driver/linux-header-search.cpp
+@@ -1,6 +1,29 @@
+ // General tests that the header search paths detected by the driver and passed
+ // to CC1 are sane.
+ //
++// Test a simulated installation of libc++ on Linux, both through sysroot and
++// the installation path of Clang.
++// RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \
++// RUN:     -target x86_64-unknown-linux-gnu \
++// RUN:     -stdlib=libc++ \
++// RUN:     -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \
++// RUN:     --sysroot=%S/Inputs/basic_linux_libcxx_tree \
++// RUN:   | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-SYSROOT %s
++// CHECK-BASIC-LIBCXX-SYSROOT: "{{[^"]*}}clang{{[^"]*}}" "-cc1"
++// CHECK-BASIC-LIBCXX-SYSROOT: "-isysroot" "[[SYSROOT:[^"]+]]"
++// CHECK-BASIC-LIBCXX-SYSROOT: "-internal-isystem" "[[SYSROOT]]/usr/include/c++/v1"
++// CHECK-BASIC-LIBCXX-SYSROOT: "-internal-isystem" "[[SYSROOT]]/usr/local/include"
++// RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \
++// RUN:     -target x86_64-unknown-linux-gnu \
++// RUN:     -stdlib=libc++ \
++// RUN:     -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \
++// RUN:     --sysroot=%S/Inputs/basic_linux_libcxx_tree \
++// RUN:   | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-INSTALL %s
++// CHECK-BASIC-LIBCXX-INSTALL: "{{[^"]*}}clang{{[^"]*}}" "-cc1"
++// CHECK-BASIC-LIBCXX-INSTALL: "-isysroot" "[[SYSROOT:[^"]+]]"
++// CHECK-BASIC-LIBCXX-INSTALL: "-internal-isystem" "[[SYSROOT]]/usr/bin/../include/c++/v1"
++// CHECK-BASIC-LIBCXX-INSTALL: "-internal-isystem" "[[SYSROOT]]/usr/local/include"
++//
+ // Test a very broken version of multiarch that shipped in Ubuntu 11.04.
+ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \
+ // RUN:     -target i386-unknown-linux \
+ 

build/patches/ce-clang-3.3-libcxx-header-search-paths.patch

@@ -0,0 +1,194 @@
+This is 8241405ad42a8ce85c2a61baff5f96948f90cfa6
+"[libcxx] Make it drastically simpler to link libc++.",
+combined with a follow-up fix from
+a15785bb5b644d92ea27b247d01be4f87b46307c
+"Re-enable linker scripts after fixing bad CMake",
+backported to 3.5.
+
+diff --git a/libcxx/CMakeLists.txt b/libcxx/CMakeLists.txt
+index c20e5d1cc2a0..6cdfefb4e9e3 100644
+--- a/libcxx/CMakeLists.txt
++++ b/libcxx/CMakeLists.txt
+@@ -52,6 +52,11 @@ set(LIBCXX_CXX_ABI "${LIBCXX_CXX_ABI}" CACHE STRING
+     "Specify C++ ABI library to use." FORCE)
+ set_property(CACHE LIBCXX_CXX_ABI PROPERTY STRINGS ;${CXXABIS})
+
++# Generate and install a linker script inplace of libc++.so. The linker script
++# will link libc++ to the correct ABI library.
++option(LIBCXX_ENABLE_ABI_LINKER_SCRIPT
++      "Use and install a linker script for the given ABI library" OFF)
++
+ #===============================================================================
+ # Configure System
+ #===============================================================================
+@@ -71,6 +76,21 @@ get_target_triple(LIBCXX_TARGET_TRIPLE
+   )
+ set(LIBCXX_TARGET_TRIPLE ${LIBCXX_TARGET_TRIPLE} CACHE STRING "Target triple.")
+
++if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
++    if (APPLE)
++      message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT cannot be used on APPLE targets")
++    endif()
++    if (NOT PYTHONINTERP_FOUND)
++      message(FATAL_ERROR "LIBCXX_ENABLE_ABI_LINKER_SCRIPT requires python but it was not found.")
++    endif()
++endif()
++
++if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY AND LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
++    message(FATAL_ERROR "Conflicting options given.
++        LIBCXX_ENABLE_STATIC_ABI_LIBRARY cannot be specified with
++        LIBCXX_ENABLE_ABI_LINKER_SCRIPT")
++endif()
++
+ #===============================================================================
+ # Add an ABI library if appropriate
+ #===============================================================================
+diff --git a/libcxx/lib/CMakeLists.txt b/libcxx/lib/CMakeLists.txt
+index 70adcb722132..1c04b9b1b088 100644
+--- a/libcxx/lib/CMakeLists.txt
++++ b/libcxx/lib/CMakeLists.txt
+@@ -95,7 +95,36 @@ set_target_properties(cxx
+     SOVERSION     "1"
+   )
+
++# Generate a linker script inplace of a libc++.so symlink. Rerun this command
++# after cxx builds.
++if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
++  # Get the name of the ABI library and handle the case where CXXABI_LIBNAME
++  # is a target name and not a library. Ex cxxabi_shared.
++  set(SCRIPT_ABI_LIBNAME "${CXXABI_LIBNAME}")
++  if (SCRIPT_ABI_LIBNAME STREQUAL "cxxabi")
++    set(SCRIPT_ABI_LIBNAME "c++abi")
++  endif()
++  # Generate a linker script inplace of a libc++.so symlink. Rerun this command
++  # after cxx builds.
++  add_custom_command(TARGET cxx POST_BUILD
++    COMMAND
++      ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/../utils/gen_link_script/gen_link_script.py
++    ARGS
++      "$<TARGET_LINKER_FILE:cxx>"
++      "${SCRIPT_ABI_LIBNAME}"
++    WORKING_DIRECTORY ${LIBCXX_BUILD_DIR}
++  )
++endif()
++
++
+ install(TARGETS cxx
+   LIBRARY DESTINATION lib
+   ARCHIVE DESTINATION lib
+   )
++# NOTE: This install command must go after the cxx install command otherwise
++# it will not be executed after the library symlinks are installed.
++if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
++  install(FILES "$<TARGET_LINKER_FILE:cxx>"
++    DESTINATION lib${LIBCXX_LIBDIR_SUFFIX}
++    COMPONENT libcxx)
++endif()
+diff --git a/libcxx/test/CMakeLists.txt b/libcxx/test/CMakeLists.txt
+index 4810b2c57483..6673197b0d4e 100644
+--- a/libcxx/test/CMakeLists.txt
++++ b/libcxx/test/CMakeLists.txt
+@@ -30,6 +30,17 @@ if(PYTHONINTERP_FOUND)
+   pythonize_bool(LIBCXX_ENABLE_SHARED)
+   pythonize_bool(LIBCXX_HAS_STDCXX0X_FLAG)
+
++# The tests shouldn't link to any ABI library when it has been linked into
++# libc++ statically or via a linker script.
++if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY OR LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
++  set(LIBCXX_CXX_ABI_LIBNAME "none")
++endif()
++
++set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
++    "TargetInfo to use when setting up test environment.")
++set(LIBCXX_EXECUTOR "None" CACHE STRING
++    "Executor to use when running tests.")
++
+   set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
+
+   configure_file(
+diff --git a/libcxx/utils/gen_link_script/gen_link_script.py b/libcxx/utils/gen_link_script/gen_link_script.py
+new file mode 100755
+index 000000000000..5de18f9129c6
+--- /dev/null
++++ b/libcxx/utils/gen_link_script/gen_link_script.py
+@@ -0,0 +1,79 @@
++#!/usr/bin/env python
++import os
++import sys
++
++def print_and_exit(msg):
++    sys.stderr.write(msg + '\n')
++    sys.exit(1)
++
++def usage_and_exit():
++    print_and_exit("Usage: ./gen_link_script.py [--help] [--dryrun] <path/to/libcxx.so> <abi_libname>")
++
++def help_and_exit():
++    help_msg = \
++"""Usage
++
++  gen_link_script.py [--help] [--dryrun] <path/to/libcxx.so> <abi_libname>
++
++  Generate a linker script that links libc++ to the proper ABI library.
++  The script replaces the specified libc++ symlink.
++  An example script for c++abi would look like "INPUT(libc++.so.1 -lc++abi)".
++
++Arguments
++  <path/to/libcxx.so> - The top level symlink to the versioned libc++ shared
++                        library. This file is replaced with a linker script.
++  <abi_libname>       - The name of the ABI library to use in the linker script.
++                        The name must be one of [c++abi, stdc++, supc++, cxxrt].
++
++Exit Status:
++  0 if OK,
++  1 if the action failed.
++"""
++    print_and_exit(help_msg)
++
++def parse_args():
++    args = list(sys.argv)
++    del args[0]
++    if len(args) == 0:
++        usage_and_exit()
++    if args[0] == '--help':
++        help_and_exit()
++    dryrun = '--dryrun' == args[0]
++    if dryrun:
++        del args[0]
++    if len(args) != 2:
++        usage_and_exit()
++    symlink_file = args[0]
++    abi_libname = args[1]
++    return dryrun, symlink_file, abi_libname
++
++def main():
++    dryrun, symlink_file, abi_libname = parse_args()
++
++    # Check that the given libc++.so file is a valid symlink.
++    if not os.path.islink(symlink_file):
++        print_and_exit("symlink file %s is not a symlink" % symlink_file)
++
++    # Read the symlink so we know what libc++ to link to in the linker script.
++    linked_libcxx = os.readlink(symlink_file)
++
++    # Check that the abi_libname is one of the supported values.
++    supported_abi_list = ['c++abi', 'stdc++', 'supc++', 'cxxrt']
++    if abi_libname not in supported_abi_list:
++        print_and_exit("abi name '%s' is not supported: Use one of %r" %
++                        (abi_libname, supported_abi_list))
++
++    # Generate the linker script contents and print the script and destination
++    # information.
++    contents = "INPUT(%s -l%s)" % (linked_libcxx, abi_libname)
++    print("GENERATING SCRIPT: '%s' as file %s" % (contents, symlink_file))
++
++    # Remove the existing libc++ symlink and replace it with the script.
++    if not dryrun:
++        os.unlink(symlink_file)
++        with open(symlink_file, 'w') as f:
++            f.write(contents + "\n")
++
++
++if __name__ == '__main__':
++    main()
+ 

build/patches/ce-libcxx-3.5-linker-script.patch

@@ -0,0 +1,21 @@
+Fix for 4814291e17ef501afa4c19ca43fbb52cfe49957c,
+which was a bad backport of 6fe361c1efc9e7c38c164fc6469857a84d3cb299
+"Remove use of _[A-Z] identifiers and poison them to detect usage"
+against release/3.6.x branch.
+
+diff --git a/libcxx/test/libcxx/test/config.py b/libcxx/test/libcxx/test/config.py
+index 55916f0da53e..4342a797abad 100644
+--- a/libcxx/test/libcxx/test/config.py
++++ b/libcxx/test/libcxx/test/config.py
+@@ -269,8 +269,8 @@ class Configuration(object):
+         # Configure include paths
+         self.compile_flags += ['-nostdinc++']
+         support_path = os.path.join(self.src_root, 'test/support')
+-        self.cxx.compile_flags += ['-I' + support_path]
+-        self.cxx.compile_flags += ['-include', os.path.join(support_path, 'nasty_macros.hpp')]
++        self.compile_flags += ['-I' + support_path]
++        self.compile_flags += ['-include', os.path.join(support_path, 'nasty_macros.hpp')]
+         libcxx_headers = self.get_lit_conf('libcxx_headers',
+                                            self.src_root + '/include')
+         if not os.path.isdir(libcxx_headers):
+