Improve macOS handling

Add minimum os version to packaged outputs, fix some tools like
`llvm-objcopy`, `xcrun`, etc...

Author: staticfloat

BinaryBuilderToolchains.jl/src/toolchains/CToolchain.jl

@@ -266,7 +266,11 @@ function jll_source_selection(vendor::Symbol, platform::CrossPlatform,
             target=sysroot_path,
         )]
     elseif os(platform.target) == "macos"
-        @warn("Take in `macos_version(platform.target)` and feed that to `macOSSDK_jll.jl` here", maxlog=1)
+        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(
             "macOSSDK_jll",
             platform.target;
@@ -689,11 +693,23 @@ function toolchain_env(toolchain::CToolchain, deployed_prefix::String)
 
     sdk_jll = get_jll(toolchain, "macOSSDK_jll")
     if sdk_jll !== nothing
-        env["MACOSX_DEPLOYMENT_TARGET"] = string(
-            sdk_jll.package.version.major,
-            ".",
-            sdk_jll.package.version.minor,
+        # If toolchain platform already has an `os_version`, we need to obey that, otherwise we
+        # use the default deployment targets for the architecture being built:
+        function default_kernel_version(arch)
+            if arch == "x86_64"
+                return 14
+            elseif arch == "aarch64"
+                return 20
+            else
+                throw(ArgumentError("Unknown macOS architecture '$(arch)'!"))
+            end
+        end
+
+        kernel_version = something(
+            os_version(toolchain.platform.target),
+            default_kernel_version(arch(toolchain.platform.target))
         )
+        env["MACOSX_DEPLOYMENT_TARGET"] = macos_version(kernel_version)
     end
 
     return env
@@ -842,7 +858,7 @@ function add_macos_flags(io, toolchain)
                     append_flags(io, :PRE, "-D_DARWIN_FEATURE_CLOCK_GETTIME=0")
                 end
             end
-            
+
             # Always compile for a particular minimum macOS version
             if macos_ver !== nothing
                 append_flags(io, :PRE, "-mmacosx-version-min=$(macos_version(toolchain.platform.target))")
@@ -1058,6 +1074,24 @@ function clang_wrappers(toolchain::CToolchain, dir::String)
         add_ccache_preamble(io, toolchain)
     end
 
+    if Sys.isapple(p)
+        function _xcrun_wrapper(io)
+            flagmatch(io, [flag"--show-sdk-path"]) do io
+                println(io, raw"""
+                "${CC}" -print-sysroot
+                exit 0
+                """)
+            end
+            flagmatch(io, [flag"--show-sdk-version"]) do io
+                println(io, raw"""
+                echo "${MACOSX_DEPLOYMENT_TARGET}"
+                exit 0
+                """)
+            end
+        end
+        make_tool_wrappers(toolchain, dir, "xcrun", "exec"; wrapper=_xcrun_wrapper, toolchain_prefix)
+    end
+
     make_tool_wrappers(toolchain, dir, "clang", "clang"; wrapper=_clang_wrapper, toolchain_prefix)
     make_tool_wrappers(toolchain, dir, "clang++", "clang++"; wrapper=io -> _clang_wrapper(io; is_clangxx = true), toolchain_prefix)
     make_tool_wrappers(toolchain, dir, "clang-scan-deps", "clang-scan-deps"; toolchain_prefix)
@@ -1075,10 +1109,7 @@ function binutils_wrappers(toolchain::CToolchain, dir::String)
     gcc_version = get_gcc_version(toolchain)
 
     # These tools don't need anything fancy; just `compiler_wrapper()`
-    simple_tools = [
-        "objcopy",
-        "objdump",
-    ]
+    simple_tools = String[]
     @warn("TODO: Verify that `as` does not need adjusted MACOSX_DEPLOYMENT_TARGET", maxlog=1)
     @warn("TODO: Add in `ld.64` and `ld.target-triplet` again", maxlog=1)
     # Apple has some extra simple tools
@@ -1356,6 +1387,12 @@ function binutils_wrappers(toolchain::CToolchain, dir::String)
     ranlib_name = Sys.isapple(p) ? "llvm-ranlib" : "$(gcc_triplet)-ranlib"
     make_tool_wrappers(toolchain, dir, "ranlib", ranlib_name; wrapper=_ranlib_wrapper, toolchain_prefix=llvm_toolchain_prefix)
 
+    objcopy_name = Sys.isapple(p) ? "llvm-objcopy" : "$(gcc_triplet)-objcopy"
+    make_tool_wrappers(toolchain, dir, "objcopy", objcopy_name; toolchain_prefix=llvm_toolchain_prefix)
+
+    objdump_name = Sys.isapple(p) ? "llvm-objdump" : "$(gcc_triplet)-objdump"
+    make_tool_wrappers(toolchain, dir, "objdump", objdump_name; toolchain_prefix=llvm_toolchain_prefix)
+
     if Sys.isapple(p)
         # dsymutil is just called `dsymutil`
         make_tool_wrappers(toolchain, dir, "dsymutil", "dsymutil"; toolchain_prefix=llvm_toolchain_prefix)

bootstrap/LLVM/bundled/xcrun

@@ -28,11 +28,11 @@ build_tarballs(;
         JLLSource(
             "Zlib_jll";
             repo=Pkg.Types.GitRepo(
-                rev="bb2/GCC",
+                rev="main",
                 source="https://github.com/staticfloat/Zlib_jll.jl"
             ),
         ),
     ],
-    host_toolchains = [CToolchain(;vendor=:clang), CMakeToolchain(), HostToolsToolchain()],
-    target_toolchains = [CToolchain(;vendor=:clang, lock_microarchitecture=false), CMakeToolchain()],
+    host_toolchains = [CToolchain(;vendor=:clang_bootstrap), CMakeToolchain(), HostToolsToolchain()],
+    target_toolchains = [CToolchain(;vendor=:clang_bootstrap, lock_microarchitecture=false), CMakeToolchain()],
 )

bootstrap/LLVM/compiler_rt.jl

@@ -147,6 +147,7 @@ function SandboxConfig(config::ExtractConfig, output_dir::String, mounts = copy(
     return SandboxConfig(config.build.config, mounts; env, kwargs...)
 end
 
+
 function BinaryBuilderAuditor.audit!(config::ExtractConfig, artifact_dir::String; verbose::Bool = AbstractBuildMeta(config).verbose, kwargs...)
     build_config = config.build.config
     meta = AbstractBuildMeta(config)

src/build_api/ExtractConfig.jl

@@ -226,6 +226,56 @@ function JLLBuildLicenses(result::ExtractResult)
     return [JLLBuildLicense(f, String(read(joinpath(licenses_dir, package_name, f)))) for f in filenames]
 end
 
+
+
+"""
+    add_os_version(platform::AbstractPlatform, target_spec::BuildTargetSpec)
+
+Adds an `os_version` tag to `platform` according to the runtimes built against
+in `target_spec`.  Currently this is only done for macOS and FreeBSD but
+it is very possible this will be extended to glibc Linux in the future.
+
+This is done automatically as part of the `package!()` call.  There does not
+yet exist a way to opt out of this.
+"""
+function add_os_version(platform::Platform, target_spec::BuildTargetSpec)
+    if os_version(platform) !== nothing
+        return platform
+    end
+
+    # Make a copy, since we actually modify `platform` here.
+    platform = parse(Platform, triplet(platform))
+
+    if Sys.isapple(platform)
+        libc_jll_name = "macOSSDK_jll"
+        version_map = macos_kernel_version
+    elseif Sys.isfreebsd(platform)
+        libc_jll_name = "freebsd_something_jll"
+        version_map = freebsd_kernel_version
+    else
+        # Other platforms don't do versioning yet
+        return platform
+    end
+
+    for toolchain in target_spec.toolchains
+        if !isa(toolchain, CToolchain)
+            continue
+        end
+
+        tenv = toolchain_env(toolchain, "")
+        # Get the version that the JLL corresponds to, and return!
+        platform["os_version"] = string(version_map(tenv["MACOSX_DEPLOYMENT_TARGET"]))
+        return platform
+    end
+
+    # Unable to find an OS version, that's fine!
+    return nothing
+end
+
+function add_os_version(cp::CrossPlatform, target_spec::BuildTargetSpec)
+    return CrossPlatform(add_os_version(cp.host, target_spec) => cp.target)
+end
+
 function JLLGenerator.JLLBuildInfo(name::String, result::ExtractResult, extra_deps::Vector{PackageSpec})
     if result.status ∉ (:success, :cached)
         throw(ArgumentError("Cannot package failing result: $(result)"))
@@ -237,7 +287,7 @@ function JLLGenerator.JLLBuildInfo(name::String, result::ExtractResult, extra_de
         deps = JLLPackageDependencies(result, extra_deps),
         # Encode all sources that are mounted in `/workspace/srcdir`
         sources = JLLSourceRecords(result),
-        platform = result.config.platform,
+        platform = add_os_version(result.config.platform, result.config.target_spec),
         name,
         # TODO: Add links to our eventual deployment target
         artifact = JLLArtifactBinding(

src/build_api/PackageConfig.jl

@@ -46,4 +46,14 @@ using BinaryBuilder2: get_package_result
     uni = Universe(universe_name; persistent=false)
     jll_names = ["Zlib_jll", "Ncurses_jll", "Readline_jll"]
     @test all(BinaryBuilder2.contains_jll.((uni,), jll_names))
+
+
+    # All the tests above target a native linux; let's run a test on Windows and macOS, just so that
+    # we're exercising those troublesome platforms in at least some way:
+    @testset "Zlib on Windows and macOS" begin
+        meta = BuildMeta(;universe_name,target_list=[Platform("x86_64", "windows"), Platform("aarch64", "macos")])
+        run_build_tarballs(meta, joinpath(bootstrap_dir, "Zlib", "build_tarballs.jl"))
+        package_result = get_package_result(meta, "Zlib")
+        @test package_result.status == :success
+    end
 end