Merge branch 'master' into ib/no_ctx

Author: fingolfin

Artifacts.toml

@@ -1,7 +1,7 @@
 name = "BinaryBuilderBase"
 uuid = "7f725544-6523-48cd-82d1-3fa08ff4056e"
 authors = ["Elliot Saba <[email protected]>"]
-version = "1.35.2"
+version = "1.37.0"
 
 [deps]
 Bzip2_jll = "6e34b625-4abd-537c-b88f-471c36dfa7a0"

Project.toml

@@ -94,6 +94,14 @@ function toolchain_file(bt::CMake, p::AbstractPlatform, host_platform::AbstractP
         set(CMAKE_SYSROOT /opt/$(aatarget)/$(aatarget)/sys-root/)
         """
     end
+
+    if arch(p) == "riscv64"
+        # RISCV libraries are in a subdirectory corresponding to the ABI of the processor
+        file *= """
+        set(CMAKE_SYSTEM_LIBRARY_PATH \${CMAKE_SYSROOT}/usr/lib64/lp64d)
+        """
+    end
+
     file *= """
         set(CMAKE_INSTALL_PREFIX \$ENV{prefix})
 

src/BuildToolchains.jl

@@ -407,6 +407,11 @@ const available_gcc_builds = [
     # GCCBuild(v"11.0.0-iains", (libgfortran_version = v"5", libstdcxx_version = v"3.4.28", cxxstring_abi = "cxx11")),
     GCCBuild(v"12.0.1-iains", (libgfortran_version = v"5", libstdcxx_version = v"3.4.29", cxxstring_abi = "cxx11")),
 ]
+
+# Since we read the Artifacts.toml at compile time, we need to make sure that we-reprecompile
+# if the file changes - let Julia know.
+Base.include_dependency(joinpath(dirname(@__DIR__), "Artifacts.toml"))
+
 const available_llvm_builds = LLVMBuild.(get_available_builds("LLVMBootstrap."))
 
 const available_go_builds = GoBuild.(get_available_builds("Go."))
@@ -469,9 +474,9 @@ function gcc_version(p::AbstractPlatform,
         GCC_builds = filter(b -> getversion(b) ≥ v"6", GCC_builds)
     end
 
-    # We don't have GCC 6 or older for FreeBSD AArch64
+    # We don't have GCC 8 or older for FreeBSD 14.1+ on AArch64
     if Sys.isfreebsd(p) && arch(p) == "aarch64"
-        GCC_builds = filter(b -> getversion(b) ≥ v"7", GCC_builds)
+        GCC_builds = filter(b -> getversion(b) ≥ v"9", GCC_builds)
     end
 
     # We only use GCC 14 or newer for riscv64.
@@ -576,7 +581,7 @@ function choose_shards(p::AbstractPlatform;
             compilers::Vector{Symbol} = [:c],
             # We always just use the latest Rootfs embedded within our Artifacts.toml
             rootfs_build::VersionNumber=last(BinaryBuilderBase.get_available_builds("Rootfs")),
-            ps_build::VersionNumber=v"2024.08.10",
+            ps_build::VersionNumber=v"2025.02.15",
             GCC_builds::Vector{GCCBuild}=available_gcc_builds,
             LLVM_builds::Vector{LLVMBuild}=available_llvm_builds,
             Rust_builds::Vector{RustBuild}=available_rust_builds,
@@ -809,10 +814,8 @@ function expand_gfortran_versions(platform::AbstractPlatform)
     # If this is an platform that has limited GCC support (such as aarch64-apple-darwin),
     # the libgfortran versions we can expand to are similarly limited.
     local libgfortran_versions
-    if Sys.isapple(platform) && arch(platform) == "aarch64"
+    if Sys.isbsd(platform) && arch(platform) == "aarch64"
         libgfortran_versions = [v"5"]
-    elseif Sys.isfreebsd(platform) && arch(platform) == "aarch64"
-        libgfortran_versions = [v"4", v"5"]
     elseif arch(platform) == "riscv64"
         # We don't have older GCC versions
         libgfortran_versions = [v"5"]

src/Rootfs.jl

@@ -382,9 +382,12 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
         return flags
     end
 
-    function min_macos_version_flags()
-        # Ask compilers to compile for a minimum macOS version, targeting that SDK.
-        return ("-mmacosx-version-min=\${MACOSX_DEPLOYMENT_TARGET}", "-Wl,-sdk_version,\${MACOSX_DEPLOYMENT_TARGET}")
+    # Ask compilers to compile for a minimum macOS version, targeting that SDK.
+    function min_macos_version_compiler_flags()
+        return ("-mmacosx-version-min=\${MACOSX_DEPLOYMENT_TARGET}",)
+    end
+    function min_macos_version_linker_flags()
+        return ("-Wl,-sdk_version,\${MACOSX_DEPLOYMENT_TARGET}",)
     end
 
     function add_system_includedir(flags::Vector{String})
@@ -455,9 +458,8 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
         ])
 
         if Sys.isapple(p)
-            macos_version_flags = clang_use_lld ? (min_macos_version_flags()[1],) : min_macos_version_flags()
             append!(flags, String[
-                macos_version_flags...,
+                min_macos_version_compiler_flags()...,
             ])
         end
 
@@ -529,10 +531,14 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
         end
         sanitize_link_flags!(p, flags)
 
-        # On macos, we need to pass `-headerpad_max_install_names` so that we have lots of space
-        # for `install_name_tool` shenanigans during audit fixups.
         if Sys.isapple(p)
+            # On macos, we need to pass `-headerpad_max_install_names` so that we have lots
+            # of space for `install_name_tool` shenanigans during audit fixups.
             push!(flags, "-headerpad_max_install_names")
+            if !clang_use_lld
+                # The `-sdk_version` flag is not implemented in lld yet.
+                append!(flags, min_macos_version_linker_flags())
+            end
         end
         return flags
     end
@@ -544,7 +550,7 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
         if gcc_version.major in (4, 5)
             push!(flags, "-Wl,-syslibroot,/opt/$(aatriplet(p))/$(aatriplet(p))/sys-root")
         end
-        append!(flags, min_macos_version_flags())
+        append!(flags, min_macos_version_compiler_flags())
         return flags
     end
 
@@ -617,6 +623,7 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
             ])
         elseif Sys.isapple(p)
             push!(flags, "-headerpad_max_install_names")
+            append!(flags, min_macos_version_linker_flags())
         elseif Sys.iswindows(p) && gcc_version ≥ v"5"
             # Do not embed timestamps, for reproducibility:
             # https://github.com/JuliaPackaging/BinaryBuilder.jl/issues/1232
@@ -1037,10 +1044,47 @@ function generate_compiler_wrappers!(platform::AbstractPlatform; bin_path::Abstr
         # `xcrun` is another macOS-specific tool, which is occasionally needed to run some
         # commands, for example for the CGO linker.  Ref:
         # <https://github.com/JuliaPackaging/Yggdrasil/pull/2962>.
+        # Cf. <https://www.unix.com/man-page/osx/1/xcrun/>
         xcrun_path = joinpath(bin_path, triplet(platform), "xcrun")
         write(xcrun_path, """
               #!/bin/sh
-              exec "\${@}"
+
+              sdk_path="\${SDKROOT}"
+
+              show_sdk_path() {
+                  echo "\${1}"
+              }
+
+              show_sdk_version() {
+                  plistutil -f xml -i "\${1}"/SDKSettings.plist \\
+                  | grep -A1 '<key>Version</key>' \\
+                  | tail -n1 \\
+                  | sed -E -e 's/\\s*<string>([^<]+)<\\/string>\\s*/\\1/'
+              }
+
+              while [ "\${#}" -gt 0 ]; do
+                  case "\${1}" in
+                      --sdk)
+                          sdk_path="\${2}"
+                          shift 2
+                          ;;
+                      --show-sdk-path)
+                          show_sdk_path "\${sdk_path}"
+                          shift
+                          ;;
+                      --show-sdk-version)
+                          show_sdk_version "\${sdk_path}"
+                          shift
+                          ;;
+                      *)
+                          break
+                          ;;
+                  esac
+              done
+
+              if [ "\${#}" -gt 0 ]; then
+                  exec "\${@}"
+              fi
               """)
         chmod(xcrun_path, 0o775)
     end
@@ -1294,6 +1338,7 @@ function platform_envs(platform::AbstractPlatform, src_name::AbstractString;
     if Sys.isapple(platform)
         mapping["LD"] = "/opt/bin/$(triplet(platform))/ld"
         mapping["MACOSX_DEPLOYMENT_TARGET"] = macos_version(platform)
+        mapping["SDKROOT"] = "/opt/$(aatriplet(platform))/$(aatriplet(platform))/sys-root"
     end
 
     # There is no broad agreement on what host compilers should be called,

src/Runner.jl

@@ -26,10 +26,8 @@ using BinaryBuilderBase: RustBuild, CompilerShard
         Platform("x86_64",  "macos"; libgfortran_version=v"5"),
         Platform("aarch64", "macos"; libgfortran_version=v"5"),
     ]
-    @test expand_gfortran_versions(Platform("aarch64", "freebsd")) == [
-        Platform("aarch64", "freebsd"; libgfortran_version=v"4"),
-        Platform("aarch64", "freebsd"; libgfortran_version=v"5"),
-    ]
+    @test expand_gfortran_versions(Platform("aarch64", "freebsd")) ==
+        [Platform("aarch64", "freebsd"; libgfortran_version=v"5")]
     @test expand_gfortran_versions([Platform("x86_64", "linux"; sanitize="memory")]) ==
         [Platform("x86_64", "linux"; sanitize="memory")]
     @test expand_gfortran_versions(Platform[]) isa Vector{Platform}
@@ -178,9 +176,9 @@ end
         # With LLVM 12 we can only use GCC 6+
         @test gcc_version(Platform("x86_64", "freebsd"), available_gcc_builds; llvm_version=v"12") ==
             filter(≥(v"6"), getversion.(available_gcc_builds))
-        # We can only use GCC 7+ on AArch64
+        # We can only use GCC 9+ on AArch64
         @test gcc_version(Platform("aarch64", "freebsd"), available_gcc_builds) ==
-            filter(≥(v"7"), getversion.(available_gcc_builds))
+            filter(≥(v"9"), getversion.(available_gcc_builds))
 
         # libgfortran v3 and libstdcxx 22 restrict us to only v4.8, v5.2 and v6.1
         p = Platform("x86_64", "linux"; libgfortran_version=v"3", libstdcxx_version=v"3.4.22")
@@ -219,52 +217,79 @@ end
 
     @testset "Compiler wrappers" begin
         platform = Platform("x86_64", "linux"; libc="musl")
-        mktempdir() do bin_path
-            platform_bin_dir = joinpath(bin_path, triplet(platform))
-            generate_compiler_wrappers!(platform; bin_path = bin_path)
-            # Make sure the C++ string ABI is not set
-            @test !occursin("-D_GLIBCXX_USE_CXX11_ABI", read(joinpath(platform_bin_dir, "gcc"), String))
-            # Make sure gfortran doesn't uses ccache when BinaryBuilderBase.use_ccache is true
-            BinaryBuilderBase.use_ccache[] && @test !occursin("ccache", read(joinpath(platform_bin_dir, "gfortran"), String))
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path)
+                # Make sure the C++ string ABI is not set
+                @test !occursin("-D_GLIBCXX_USE_CXX11_ABI", read(joinpath(platform_bin_dir, "gcc"), String))
+                # Make sure gfortran doesn't uses ccache when BinaryBuilderBase.use_ccache is true
+                BinaryBuilderBase.use_ccache[] && @test !occursin("ccache", read(joinpath(platform_bin_dir, "gfortran"), String))
+            end
         end
         platform = Platform("x86_64", "linux"; libc="musl", cxxstring_abi="cxx03")
-        mktempdir() do bin_path
-            platform_bin_dir = joinpath(bin_path, triplet(platform))
-            generate_compiler_wrappers!(platform; bin_path = bin_path)
-            gcc = read(joinpath(platform_bin_dir, "gcc"), String)
-            # Make sure the C++ string ABI is set as expected
-            @test occursin("-D_GLIBCXX_USE_CXX11_ABI=0", gcc)
-            # Make sure the unsafe flags check is there
-            @test occursin("You used one or more of the unsafe flags", gcc)
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path)
+                gcc = read(joinpath(platform_bin_dir, "gcc"), String)
+                # Make sure the C++ string ABI is set as expected
+                @test occursin("-D_GLIBCXX_USE_CXX11_ABI=0", gcc)
+                # Make sure the unsafe flags check is there
+                @test occursin("You used one or more of the unsafe flags", gcc)
+            end
         end
         platform = Platform("x86_64", "linux"; libc="musl", cxxstring_abi="cxx11")
-        mktempdir() do bin_path
-            platform_bin_dir = joinpath(bin_path, triplet(platform))
-            generate_compiler_wrappers!(platform; bin_path = bin_path, allow_unsafe_flags = true)
-            gcc = read(joinpath(platform_bin_dir, "gcc"), String)
-            # Make sure the C++ string ABI is set as expected
-            @test occursin("-D_GLIBCXX_USE_CXX11_ABI=1", gcc)
-            # Make sure the unsafe flags check is not there in this case
-            @test !occursin("You used one or more of the unsafe flags", gcc)
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path, allow_unsafe_flags = true)
+                gcc = read(joinpath(platform_bin_dir, "gcc"), String)
+                # Make sure the C++ string ABI is set as expected
+                @test occursin("-D_GLIBCXX_USE_CXX11_ABI=1", gcc)
+                # Make sure the unsafe flags check is not there in this case
+                @test !occursin("You used one or more of the unsafe flags", gcc)
+            end
+        end
+        platform = Platform("aarch64", "macos")
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path, gcc_version = v"4")
+                if Sys.isunix()
+                     cd(platform_bin_dir) do
+                         @test readchomp(`./xcrun echo foo`) == "foo"
+                         withenv("SDKROOT" => "/bar") do
+                             @test readchomp(`./xcrun --show-sdk-path`) == "/bar"
+                             @test readchomp(`./xcrun --show-sdk-path echo foo`) == "/bar\nfoo"
+                             @test readchomp(`./xcrun --sdk /baz --show-sdk-path echo foo`) == "/baz\nfoo"
+                        end
+                    end
+                end
+            end
         end
         platform = Platform("x86_64", "freebsd")
-        mktempdir() do bin_path
-            platform_bin_dir = joinpath(bin_path, triplet(platform))
-            generate_compiler_wrappers!(platform; bin_path = bin_path, compilers = [:c, :rust, :go])
-            clang = read(joinpath(platform_bin_dir, "clang"), String)
-            # Check link flags
-            @test occursin("-L/opt/$(triplet(platform))/$(triplet(platform))/lib", clang)
-            # Other compilers
-            @test occursin("GOOS=\"freebsd\"", read(joinpath(platform_bin_dir, "go"), String))
-            @test occursin("--target=x86_64-unknown-freebsd", read(joinpath(platform_bin_dir, "rustc"), String))
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path, compilers = [:c, :rust, :go])
+                clang = read(joinpath(platform_bin_dir, "clang"), String)
+                # Check link flags
+                @test occursin("-L/opt/$(triplet(platform))/$(triplet(platform))/lib", clang)
+                # Other compilers
+                @test occursin("GOOS=\"freebsd\"", read(joinpath(platform_bin_dir, "go"), String))
+                @test occursin("--target=x86_64-unknown-freebsd", read(joinpath(platform_bin_dir, "rustc"), String))
+            end
         end
         platform = Platform("x86_64", "linux"; libc="glibc", cxxstring_abi="cxx11")
-        mktempdir() do bin_path
-            platform_bin_dir = joinpath(bin_path, triplet(platform))
-            generate_compiler_wrappers!(platform; bin_path = bin_path, compilers = [:c], gcc_version=v"5")
-            clang = read(joinpath(platform_bin_dir, "clang"), String)
-            # Check link flags
-            @test occursin("-L/opt/$(aatriplet(platform))/lib/gcc/opt/$(aatriplet(platform))/lib/gcc", clang)
+        @testset "$(triplet(platform))" begin
+            mktempdir() do bin_path
+                platform_bin_dir = joinpath(bin_path, triplet(platform))
+                generate_compiler_wrappers!(platform; bin_path = bin_path, compilers = [:c], gcc_version=v"5")
+                clang = read(joinpath(platform_bin_dir, "clang"), String)
+                # Check link flags
+                @test occursin("-L/opt/$(aatriplet(platform))/lib/gcc/opt/$(aatriplet(platform))/lib/gcc", clang)
+            end
         end
     end
 end

test/rootfs.jl

@@ -458,12 +458,14 @@ end
             platform = Platform("x86_64", "macos")
             test_script = raw"""
             set -e
-            prog='int main(void) { return 0; }'
-            echo "${prog}" | clang -x c - -o test-clang
+            echo 'int main(void) { return 0; }' > test.c
+            clang -Wall -Werror -Werror=unused-command-line-argument test.c -c -o test-clang.o
+            clang -Wall -Werror -Werror=unused-command-line-argument test-clang.o -o test-clang
             otool -lV test-clang | grep sdk
             # Set `MACOSX_DEPLOYMENT_TARGET` to override the value of the SDK
             export MACOSX_DEPLOYMENT_TARGET=10.14
-            echo "${prog}" | gcc -x c - -o test-gcc
+            gcc -Wall -Werror test.c -c -o test-gcc.o
+            gcc -Wall -Werror test-gcc.o -o test-gcc
             otool -lV test-gcc | grep sdk
             """
             cmd = `/bin/bash -c "$(test_script)"`