Build libcxx against a newer minimum macOS version

Also fix all the plumbing for `os_version` in our build system

Author: staticfloat

BinaryBuilderPlatformExtensions.jl/src/Utils.jl

@@ -6,7 +6,7 @@ export gcc_platform, gcc_target_triplet
 Strip out any tags that are not the basic annotations like `libc` and `call_abi`.
 """
 function gcc_platform(p::Platform)
-    keeps = ("libc", "call_abi", "os_version")
+    keeps = ("libc", "call_abi")
     filtered_tags = Dict{Symbol,String}(Symbol(k) => v for (k, v) in tags(p) if k ∈ keeps)
     return Platform(arch(p)::String, os(p)::String; filtered_tags...)
 end

BinaryBuilderSources.jl/src/JLLSource.jl

@@ -24,7 +24,9 @@ function JLLSource(package::PkgSpec, platform::AbstractPlatform; target = "")
     noabspath!(target)
     return JLLSource(
         package,
-        platform,
+        # Make sure our artifact matching happens as if we're a host platform,
+        # e.g. `os_version` gets interpreted as a lower bound, etc...
+        HostPlatform(platform),
         string(target),
         String[],
     )

BinaryBuilderToolchains.jl/src/toolchains/CToolchain.jl

@@ -266,12 +266,7 @@ function jll_source_selection(vendor::Symbol, platform::CrossPlatform,
             target=sysroot_path,
         )]
     elseif os(platform.target) == "macos"
-        if macos_version(platform.target) !== nothing
-            if macos_version(platform.target) > v"11.1"
-                throw(ArgumentError("We need to upgrade our macOSSDK_jll to support such a new version: $(triplet(platform.target))"))
-            end
-        end
-        libc_jlls = [JLLSource(
+        macos_sdk_jll = JLLSource(
             "macOSSDK_jll",
             platform.target;
             repo=Pkg.Types.GitRepo(
@@ -280,7 +275,13 @@ function jll_source_selection(vendor::Symbol, platform::CrossPlatform,
             ),
             version=v"11.1",
             target=sysroot_path,
-        )]
+        )
+        if macos_version(platform.target) !== nothing
+            if VersionNumber(macos_version(platform.target)) > macos_sdk_jll.package.version
+                throw(ArgumentError("We need to upgrade our macOSSDK_jll to support such a new version: $(triplet(platform.target))"))
+            end
+        end
+        libc_jlls = [macos_sdk_jll]
     elseif os(platform.target) == "windows"
         libc_jlls = [JLLSource(
             "Mingw_jll",
@@ -685,7 +686,7 @@ function toolchain_env(toolchain::CToolchain, deployed_prefix::String)
 
     # We can have multiple wrapper prefixes, we always use the longest one
     # as that's typically the most specific.
-    wrapper_prefixes = replace.(toolchain.wrapper_prefixes, ("\${triplet}" => triplet(toolchain.platform.target),))
+    wrapper_prefixes = replace.(toolchain.wrapper_prefixes, ("\${triplet}" => triplet(gcc_platform(toolchain.platform.target)),))
     wrapper_prefix = wrapper_prefixes[argmax(length.(wrapper_prefixes))]
     for env_prefix in toolchain.env_prefixes
         set_envvars(env_prefix, wrapper_prefix)
@@ -754,7 +755,7 @@ function make_tool_wrappers(toolchain, output_dir, tool, tool_target;
                             post_func::Function = identity,
                             toolchain_prefix::String = "\$(dirname \"\${WRAPPER_DIR}\")")
     for wrapper_prefix in toolchain.wrapper_prefixes
-        tool_prefixed = string(replace(wrapper_prefix, "\${triplet}" => triplet(toolchain.platform.target)), tool)
+        tool_prefixed = string(replace(wrapper_prefix, "\${triplet}" => triplet(gcc_platform(toolchain.platform.target))), tool)
         compiler_wrapper(wrapper,
             post_func,
             joinpath(output_dir, "$(tool_prefixed)"),

bootstrap/LLVM/libcxx.jl

@@ -1,31 +1,53 @@
 include("llvm_common.jl")
+using BinaryBuilderPlatformExtensions: macos_kernel_version
+
+platforms = supported_platforms()
+platforms = map(platforms) do p
+    # x86_64-apple-darwin needs to target at least 10.13
+    if Sys.isapple(p) && arch(p) == "x86_64"
+        p["os_version"] = string(macos_kernel_version("10.13"))
+    end
+    return p
+end
 
 build_tarballs(;
     src_name = "LLVMLibcxx",
     src_version = llvm_version,
     sources = llvm_sources,
     script = llvm_script_prefix * raw"""
     # Configure libcxx
-    CMAKE_FLAGS+=("-DLIBCXX_INCLUDE_BENCHMARKS=OFF")
-    CMAKE_FLAGS+=("-DLIBCXX_HAS_ATOMIC_LIB=NO")
     CMAKE_FLAGS+=("-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi;libunwind")
 
+    # Use lld to dodge annoying symbol resolution issues on mingw
+    CMAKE_FLAGS+=("-DLLVM_USE_LINKER=lld")
+
     if [[ "${target}" == *musl* ]]; then
         CMAKE_FLAGS+=("-DLIBCXX_HAS_MUSL_LIBC=ON")
     fi
 
+    # Tell HandleCompilerRT.cmake that we're compiling for macOS
+    if [[ "${target}" == *darwin* ]]; then
+        ln -s "$($CC -print-sysroot)" "/tmp/MacOSX.sdk"
+        CMAKE_FLAGS+=( "-DCMAKE_OSX_SYSROOT=/tmp/MacOSX.sdk/" )
+
+        # I don't know why this isn't working, some kind of bug?
+        CMAKE_FLAGS+=( "-DCXX_SUPPORTS_FNO_EXCEPTIONS_FLAG=TRUE" )
+    fi
+
     # Configure libcxxabi
     CMAKE_FLAGS+=( "-DLIBCXX_USE_COMPILER_RT=ON" )
     CMAKE_FLAGS+=( "-DLIBCXX_ENABLE_SHARED=ON" )
     CMAKE_FLAGS+=( "-DLIBCXX_ENABLE_STATIC=ON" )
     CMAKE_FLAGS+=( "-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON" )
     CMAKE_FLAGS+=( "-DLIBCXX_INSTALL_MODULES=ON" )
-    if [[ "${target}" == *mingw* ]]; then
-        CMAKE_FLAGS+=( "-DLIBCXX_HAS_WIN32_THREAD_API=ON" )
-        CMAKE_FLAGS+=( "-DLIBCXXABI_HAS_WIN32_THREAD_API=ON" )
-        CMAKE_FLAGS+=( "-DLIBCXX_ENABLE_NEW_DELETE_DEFINITIONS=ON" )
-        CMAKE_FLAGS+=( "-DLIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS=OFF" )
-    fi
+    #CMAKE_FLAGS+=("-DLIBCXX_HAS_ATOMIC_LIB=NO")
+    CMAKE_FLAGS+=( "-DLIBCXX_CXX_ABI=libcxxabi" )
+    #if [[ "${target}" == *mingw* ]]; then
+        #CMAKE_FLAGS+=( "-DLIBCXX_HAS_WIN32_THREAD_API=ON" )
+        #CMAKE_FLAGS+=( "-DLIBCXXABI_HAS_WIN32_THREAD_API=ON" )
+        #CMAKE_FLAGS+=( "-DLIBCXX_ENABLE_NEW_DELETE_DEFINITIONS=ON" )
+        #CMAKE_FLAGS+=( "-DLIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS=OFF" )
+    #fi
 
     CMAKE_FLAGS+=( "-DLIBCXXABI_USE_COMPILER_RT=ON" )
     CMAKE_FLAGS+=( "-DLIBCXXABI_USE_LLVM_UNWINDER=ON" )
@@ -39,20 +61,20 @@ build_tarballs(;
     CMAKE_FLAGS+=( "-DLIBUNWIND_ENABLE_STATIC=ON" )
 
     # configure, build, install!
-    mkcd build
+    mkcd "${WORKSPACE}/srcdir/build"
     ${CMAKE} ${WORKSPACE}/srcdir/llvm-project/runtimes "${CMAKE_FLAGS[@]}"
     ninja
     ninja install
     """,
-    platforms=supported_platforms(),
+    platforms,
     host,
     # We need python, and we need to build with clang
     host_dependencies = [JLLSource("Python_jll")],
     target_dependencies = [
         JLLSource(
             "Zlib_jll";
             repo=Pkg.Types.GitRepo(
-                rev="bb2/GCC",
+                rev="main",
                 source="https://github.com/staticfloat/Zlib_jll.jl",
             ),
         ),
@@ -77,7 +99,6 @@ build_tarballs(;
                 """,
                 [
                     LibraryProduct("libc++", :libcxx),
-                    #LibraryProduct("libc++abi", :libcxxabi),
                 ],
                 get_default_target_spec(build_config);
                 platform,

bootstrap/LLVM/llvm_common.jl

@@ -247,12 +247,10 @@ CMAKE_FLAGS+=(
     -DLIBCXX_INCLUDE_BENCHMARKS=OFF
     -DLLVM_ENABLE_LIBEDIT=OFF
     -DLLVM_ENABLE_TERMINFO=OFF
+    -DLLVM_ENABLE_LIBXML2=OFF
     -DLLVM_HAVE_LIBXAR=OFF
 )
 
-# Turn off XML2
-CMAKE_FLAGS+=(-DLLVM_ENABLE_LIBXML2=OFF)
-
 # Manually point to `zlib`, because it doesn't find it automatically properly.
 export LDFLAGS="-L ${host_shlibdir}"