Unverified Commit bfa7abf2 authored by vercel-fleet-prod[bot]'s avatar vercel-fleet-prod[bot] Committed by GitHub

Enable cross-language LTO on primary targets

Co-authored-by: 's avatarLuke Sandberg <210140+lukesandberg@users.noreply.github.com>
parent bc80691c
......@@ -305,6 +305,24 @@ jobs:
with:
targets: ${{ matrix.target }}
- name: Restore upstream LLVM for native LTO
if: ${{ matrix.target == 'aarch64-apple-darwin' && matrix.build_task == 'build-native-release' }}
uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
with:
path: ${{ runner.temp }}/llvm-18.1.8
key: native-llvm-18.1.8-${{ runner.os }}-${{ runner.arch }}
- name: Install upstream LLVM and cargo-rustflags
if: ${{ matrix.target == 'aarch64-apple-darwin' && matrix.build_task == 'build-native-release' }}
env:
LLVM_BIN_DIR: ${{ runner.temp }}/llvm-18.1.8/bin
LLVM_ROOT: ${{ runner.temp }}/llvm-18.1.8
run: |
if [[ ! -x "${LLVM_BIN_DIR}/clang" ]]; then
scripts/install-native-llvm.sh "${LLVM_ROOT}"
fi
cargo binstall --no-confirm cargo-rustflags@0.4.0
- name: normalize versions
run: node scripts/normalize-version-bump.js
......@@ -347,13 +365,25 @@ jobs:
- name: Build Docker builder image
if: ${{ matrix.docker && steps.native-cache.outputs.cache-hit != 'true' }}
env:
BUILD_TASK: ${{ matrix.build_task }}
IMAGE_NAME: ${{ matrix.docker }}
TARGET: ${{ matrix.target }}
run: |
docker buildx create --use --name next-swc-builder-buildx
# Minimal context: the Dockerfile only COPYs rust-toolchain.toml.
export NATIVE_LTO_DETECT_ONLY=1
source scripts/configure-native-lto.sh
unset NATIVE_LTO_DETECT_ONLY
INSTALL_NATIVE_LLVM=0
if native_lto_is_enabled; then
INSTALL_NATIVE_LLVM=1
fi
# Minimal context: include only files copied by the builder Dockerfile.
CTX_DIR="$(mktemp -d)"
mkdir -p "$CTX_DIR/scripts"
cp rust-toolchain.toml "$CTX_DIR/"
cp scripts/install-native-llvm.sh "$CTX_DIR/scripts/"
CACHE_ARGS=()
if [ -z "${NEXT_SKIP_BUILD_CACHE:-}" ]; then
......@@ -369,6 +399,7 @@ jobs:
docker buildx build \
--load \
--provenance=false \
--build-arg "INSTALL_NATIVE_LLVM=${INSTALL_NATIVE_LLVM}" \
-t "$IMAGE_NAME" \
-f scripts/native-builder.Dockerfile \
"${CACHE_ARGS[@]}" \
......@@ -425,6 +456,11 @@ jobs:
- name: 'Build'
if: ${{ !matrix.docker }}
env:
BUILD_TASK: ${{ matrix.build_task }}
MATRIX_OS: ${{ matrix.os }}
TARGET: ${{ matrix.target }}
LLVM_BIN_DIR: ${{ runner.temp }}/llvm-18.1.8/bin
run: |
echo "Host arch: $(uname -m)"
echo "Node arch: $(node -e 'console.log(process.arch)')"
......@@ -433,9 +469,27 @@ jobs:
rustc --version --verbose || true
node -v
npm i -g "@napi-rs/cli@${NAPI_CLI_VERSION}"
if [[ "${TARGET}" == "aarch64-apple-darwin" && "${BUILD_TASK}" == "build-native-release" ]]; then
RUSTFLAGS=$(cargo rustflags --target "${TARGET}")
export RUSTFLAGS
source scripts/configure-native-lto.sh
"${LLVM_BIN_DIR}/clang" --version | head -1
fi
TURBO_CACHE_FLAG="${NEXT_SKIP_BUILD_CACHE:+--force}"
pnpm dlx turbo@${TURBO_VERSION} run ${{ matrix.build_task }} ${TURBO_ARGS} ${TURBO_CACHE_FLAG} -- --target ${{ matrix.target }}
if [ "${{ matrix.os }}" != "windows" ]; then
pnpm dlx turbo@${TURBO_VERSION} run "${BUILD_TASK}" ${TURBO_ARGS} ${TURBO_CACHE_FLAG} -- --target "${TARGET}"
if [[ "${TARGET}" == "aarch64-apple-darwin" && "${BUILD_TASK}" == "build-native-release" ]]; then
scripts/verify-native-lto.sh
MIN_OS=$(otool -l packages/next-swc/native/next-swc.*.node | awk '$1 == "minos" { print $2; exit }')
if [[ "${MIN_OS}" != "${MACOSX_DEPLOYMENT_TARGET}" ]]; then
echo "Expected macOS ${MACOSX_DEPLOYMENT_TARGET}, found ${MIN_OS:-unknown}" >&2
exit 1
fi
fi
if [[ "${MATRIX_OS}" != "windows" ]]; then
strip -x packages/next-swc/native/next-swc.*.node
fi
......
......@@ -2,8 +2,9 @@
"$schema": "https://turborepo.org/schema.json",
"extends": ["//"],
"tasks": {
// Fingerprint all Rust inputs into a single stamp file so other tasks
// only need inputs: [stamp file] instead of repeating the full glob list.
// Fingerprint all Rust and native toolchain inputs into a single stamp file
// so other tasks only need inputs: [stamp file] instead of repeating the
// full list.
"rust-fingerprint": {
"inputs": [
"../../.cargo/**",
......@@ -14,6 +15,12 @@
"../../**/Cargo.toml",
"../../Cargo.lock",
"../../rust-toolchain.toml",
"../../scripts/configure-native-lto.sh",
"../../scripts/docker-native-build.sh",
"../../scripts/install-native-llvm.sh",
"../../scripts/native-builder.Dockerfile",
"../../scripts/verify-native-lto.sh",
"../../.github/workflows/build_and_deploy.yml",
],
"outputs": ["../../target/.rust-fingerprint"],
"cache": false,
......
#!/usr/bin/env bash
# Source this after resolving the existing target RUSTFLAGS and C/C++ flags.
# It enables cross-language ThinLTO only for primary production release targets.
native_lto_is_enabled() {
[[ "${BUILD_TASK:-}" == "build-native-release" ]] || return 1
case "${TARGET:-}" in
x86_64-unknown-linux-gnu | aarch64-unknown-linux-gnu | aarch64-apple-darwin)
return 0
;;
*)
return 1
;;
esac
}
native_lto_append_flag() {
local variable=$1
local flag=$2
local current=${!variable:-}
if [[ " ${current} " != *" ${flag} "* ]]; then
printf -v "${variable}" '%s%s%s' "${current}" "${current:+ }" "${flag}"
fi
export "${variable}"
}
native_lto_configure() {
native_lto_is_enabled || return 0
: "${LLVM_BIN_DIR:?LLVM_BIN_DIR must point to the pinned LLVM bin directory}"
local clang_major
local rust_llvm_major
clang_major=$("${LLVM_BIN_DIR}/clang" --version | sed -n 's/^.*clang version \([0-9][0-9]*\).*$/\1/p' | head -1)
rust_llvm_major=$("${RUSTC:-rustc}" -vV | sed -n 's/^LLVM version: \([0-9][0-9]*\).*$/\1/p')
if [[ "${clang_major}" != "18" ]]; then
echo "Cross-language LTO requires Clang 18, found ${clang_major:-unknown}" >&2
return 1
fi
if [[ -z "${rust_llvm_major}" || "${rust_llvm_major}" -lt "${clang_major}" ]]; then
echo "rustc LLVM ${rust_llvm_major:-unknown} cannot read Clang ${clang_major} bitcode" >&2
return 1
fi
local target_us=${TARGET//-/_}
export "CC_${target_us}=${LLVM_BIN_DIR}/clang"
export "CXX_${target_us}=${LLVM_BIN_DIR}/clang++"
export "AR_${target_us}=${LLVM_BIN_DIR}/llvm-ar"
export "RANLIB_${target_us}=${LLVM_BIN_DIR}/llvm-ranlib"
native_lto_append_flag RUSTFLAGS -Clinker-plugin-lto
local cflags_variable="CFLAGS_${target_us}"
local cxxflags_variable="CXXFLAGS_${target_us}"
if [[ -z "${!cxxflags_variable:-}" && -n "${!cflags_variable:-}" ]]; then
printf -v "${cxxflags_variable}" '%s' "${!cflags_variable}"
export "${cxxflags_variable}"
fi
native_lto_append_flag "${cflags_variable}" -flto=thin
native_lto_append_flag "${cxxflags_variable}" -flto=thin
if [[ "${TARGET}" == "aarch64-apple-darwin" ]]; then
: "${MACOSX_DEPLOYMENT_TARGET:?MACOSX_DEPLOYMENT_TARGET must be set for macOS builds}"
native_lto_append_flag "CFLAGS_${target_us}" "-mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}"
native_lto_append_flag "CXXFLAGS_${target_us}" "-mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET}"
fi
}
if [[ "${NATIVE_LTO_DETECT_ONLY:-}" != "1" ]]; then
native_lto_configure
fi
#!/usr/bin/env bash
set -euo pipefail
readonly REPO_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
readonly TMP=$(mktemp -d)
trap 'rm -rf "${TMP}"' EXIT
mkdir -p "${TMP}/llvm/bin"
cat > "${TMP}/llvm/bin/clang" <<'EOF'
#!/usr/bin/env bash
echo 'clang version 18.1.8'
EOF
cat > "${TMP}/rustc" <<'EOF'
#!/usr/bin/env bash
cat <<'VERSION'
rustc 1.99.0-nightly
LLVM version: 22.1.8
VERSION
EOF
chmod +x "${TMP}/llvm/bin/clang" "${TMP}/rustc"
for tool in clang++ llvm-ar llvm-ranlib; do
ln -s clang "${TMP}/llvm/bin/${tool}"
done
primary_targets=(
x86_64-unknown-linux-gnu
aarch64-unknown-linux-gnu
aarch64-apple-darwin
)
excluded_targets=(
x86_64-unknown-linux-musl
aarch64-unknown-linux-musl
x86_64-apple-darwin
x86_64-pc-windows-msvc
aarch64-pc-windows-msvc
)
assert_primary() (
set -euo pipefail
export TARGET=$1
export BUILD_TASK=build-native-release
export LLVM_BIN_DIR="${TMP}/llvm/bin"
export RUSTC="${TMP}/rustc"
export MACOSX_DEPLOYMENT_TARGET=11.0
export RUSTFLAGS='--cfg=tokio_unstable -Clink-arg=--icf=all'
target_us=${TARGET//-/_}
export "CFLAGS_${target_us}=--existing-c-flag"
export "CXXFLAGS_${target_us}=--existing-cxx-flag"
source "${REPO_ROOT}/scripts/configure-native-lto.sh"
[[ " ${RUSTFLAGS} " == *' -Clinker-plugin-lto '* ]]
cc_var="CC_${target_us}"
cxx_var="CXX_${target_us}"
ar_var="AR_${target_us}"
ranlib_var="RANLIB_${target_us}"
cflags_var="CFLAGS_${target_us}"
cxxflags_var="CXXFLAGS_${target_us}"
[[ "${!cc_var}" == "${LLVM_BIN_DIR}/clang" ]]
[[ "${!cxx_var}" == "${LLVM_BIN_DIR}/clang++" ]]
[[ "${!ar_var}" == "${LLVM_BIN_DIR}/llvm-ar" ]]
[[ "${!ranlib_var}" == "${LLVM_BIN_DIR}/llvm-ranlib" ]]
[[ " ${!cflags_var} " == *' --existing-c-flag '* ]]
[[ " ${!cflags_var} " == *' -flto=thin '* ]]
[[ " ${!cxxflags_var} " == *' --existing-cxx-flag '* ]]
[[ " ${!cxxflags_var} " == *' -flto=thin '* ]]
if [[ "${TARGET}" == "aarch64-apple-darwin" ]]; then
[[ " ${!cflags_var} " == *' -mmacosx-version-min=11.0 '* ]]
[[ " ${!cxxflags_var} " == *' -mmacosx-version-min=11.0 '* ]]
fi
)
assert_excluded() (
set -euo pipefail
export TARGET=$1
export BUILD_TASK=${2:-build-native-release}
export LLVM_BIN_DIR="${TMP}/llvm/bin"
export RUSTC="${TMP}/rustc"
export RUSTFLAGS='--cfg=tokio_unstable'
source "${REPO_ROOT}/scripts/configure-native-lto.sh"
[[ " ${RUSTFLAGS} " != *' -Clinker-plugin-lto '* ]]
target_us=${TARGET//-/_}
cc_var="CC_${target_us}"
cflags_var="CFLAGS_${target_us}"
[[ -z "${!cc_var:-}" ]]
[[ " ${!cflags_var:-} " != *' -flto=thin '* ]]
)
for target in "${primary_targets[@]}"; do
assert_primary "${target}"
done
(
set -euo pipefail
export TARGET=x86_64-unknown-linux-gnu
export BUILD_TASK=build-native-release
export NATIVE_LTO_DETECT_ONLY=1
source "${REPO_ROOT}/scripts/configure-native-lto.sh"
native_lto_is_enabled
[[ -z "${RUSTFLAGS:-}" ]]
)
for target in "${excluded_targets[@]}"; do
assert_excluded "${target}"
done
for target in "${primary_targets[@]}"; do
assert_excluded "${target}" build-native-release-with-assertions
assert_excluded "${target}" build-native
done
mkdir -p "${TMP}/llvm-newer/bin"
cat > "${TMP}/llvm-newer/bin/clang" <<'EOF'
#!/usr/bin/env bash
echo 'clang version 23.0.0'
EOF
chmod +x "${TMP}/llvm-newer/bin/clang"
if (
export TARGET=x86_64-unknown-linux-gnu
export BUILD_TASK=build-native-release
export LLVM_BIN_DIR="${TMP}/llvm-newer/bin"
export RUSTC="${TMP}/rustc"
source "${REPO_ROOT}/scripts/configure-native-lto.sh"
) 2>/dev/null; then
echo 'Expected an unpinned Clang version to fail' >&2
exit 1
fi
cat > "${TMP}/rustc-older" <<'EOF'
#!/usr/bin/env bash
cat <<'VERSION'
rustc 1.80.0
LLVM version: 17.0.0
VERSION
EOF
chmod +x "${TMP}/rustc-older"
if (
export TARGET=x86_64-unknown-linux-gnu
export BUILD_TASK=build-native-release
export LLVM_BIN_DIR="${TMP}/llvm/bin"
export RUSTC="${TMP}/rustc-older"
source "${REPO_ROOT}/scripts/configure-native-lto.sh"
) 2>/dev/null; then
echo 'Expected an older rustc LLVM reader to fail' >&2
exit 1
fi
echo 'native LTO target matrix passed'
......@@ -20,6 +20,7 @@ set -xeo pipefail
# container's root user; mark it safe so vergen's `git rev-parse` works.
git config --global --add safe.directory /build
export CARGO_TARGET_DIR="${CARGO_TARGET_DIR:-$PWD/target}"
BUILD_TASK="${BUILD_TASK:-build-native-release}"
# Node.js (installed via nodesource) is used only as a build tool (runs
......@@ -115,6 +116,10 @@ case "$TARGET" in
export "CFLAGS_${TARGET_US}=--target=aarch64-linux-musl --sysroot=/opt/aarch64-linux-musl-cross/aarch64-linux-musl --gcc-toolchain=/opt/aarch64-linux-musl-cross" ;;
esac
export LLVM_BIN_DIR="${NATIVE_LLVM_BIN:-/opt/llvm-18.1.8/bin}"
# shellcheck source=configure-native-lto.sh
source scripts/configure-native-lto.sh
# aarch64 needs larger page size for jemalloc
if [ "$ARCH" = "aarch64" ]; then
export JEMALLOC_SYS_WITH_LG_PAGE=16
......@@ -132,12 +137,18 @@ node -v
rustc --version
echo "Target: $TARGET"
echo "RUSTFLAGS: $RUSTFLAGS"
if native_lto_is_enabled; then
"${LLVM_BIN_DIR}/clang" --version | head -1
fi
echo "RUSTC_WRAPPER: ${RUSTC_WRAPPER:-<unset>}"
echo "-------------------------"
rustup target add "$TARGET"
cd packages/next-swc
npm run "$BUILD_TASK" -- --target "$TARGET"
if native_lto_is_enabled; then
../../scripts/verify-native-lto.sh
fi
llvm-strip -x native/next-swc.*.node
# Show sccache stats if available
......
#!/usr/bin/env bash
# Installs the small subset of upstream LLVM used to compile native dependencies.
# The target libc/SDK still comes from the existing GNU sysroot or Apple SDK.
set -euo pipefail
readonly LLVM_VERSION=18.1.8
readonly DESTINATION=${1:?usage: install-native-llvm.sh <destination>}
case "$(uname -s)-$(uname -m)" in
Linux-x86_64)
readonly ARCHIVE_NAME="clang+llvm-${LLVM_VERSION}-x86_64-linux-gnu-ubuntu-18.04.tar.xz"
readonly ARCHIVE_SHA256=54ec30358afcc9fb8aa74307db3046f5187f9fb89fb37064cdde906e062ebf36
readonly RESOURCE_LIB=""
;;
Darwin-arm64)
readonly ARCHIVE_NAME="clang+llvm-${LLVM_VERSION}-arm64-apple-macos11.tar.xz"
readonly ARCHIVE_SHA256=4573b7f25f46d2a9c8882993f091c52f416c83271db6f5b213c93f0bd0346a10
readonly RESOURCE_LIB="clang+llvm-${LLVM_VERSION}-arm64-apple-macos11/lib/clang/18/lib/darwin"
;;
*)
echo "Unsupported LLVM build host: $(uname -s)-$(uname -m)" >&2
exit 1
;;
esac
if [[ -x "${DESTINATION}/bin/clang" ]]; then
installed_version=$("${DESTINATION}/bin/clang" --version | sed -n 's/^.*clang version \([0-9][0-9.]*\).*$/\1/p' | head -1)
if [[ "${installed_version}" == "${LLVM_VERSION}" ]]; then
exit 0
fi
echo "Unexpected Clang version in ${DESTINATION}: ${installed_version:-unknown}" >&2
exit 1
fi
readonly DOWNLOAD_URL="https://github.com/llvm/llvm-project/releases/download/llvmorg-${LLVM_VERSION}/${ARCHIVE_NAME//+/%2B}"
readonly ARCHIVE_PATH=${LLVM_ARCHIVE_PATH:-"$(mktemp -t llvm-${LLVM_VERSION}.XXXXXX.tar.xz)"}
readonly ARCHIVE_ROOT=${ARCHIVE_NAME%.tar.xz}
cleanup() {
if [[ -z "${LLVM_ARCHIVE_PATH:-}" ]]; then
rm -f "${ARCHIVE_PATH}"
fi
}
trap cleanup EXIT
if [[ -z "${LLVM_ARCHIVE_PATH:-}" ]]; then
curl --retry 3 --fail --location "${DOWNLOAD_URL}" --output "${ARCHIVE_PATH}"
fi
if command -v sha256sum >/dev/null 2>&1; then
echo "${ARCHIVE_SHA256} ${ARCHIVE_PATH}" | sha256sum --check --status
else
actual_sha=$(shasum -a 256 "${ARCHIVE_PATH}" | awk '{print $1}')
[[ "${actual_sha}" == "${ARCHIVE_SHA256}" ]]
fi
mkdir -p "${DESTINATION}"
paths=(
"${ARCHIVE_ROOT}/bin/clang"
"${ARCHIVE_ROOT}/bin/clang++"
"${ARCHIVE_ROOT}/bin/clang-18"
"${ARCHIVE_ROOT}/bin/llvm-ar"
"${ARCHIVE_ROOT}/bin/llvm-objcopy"
"${ARCHIVE_ROOT}/bin/llvm-ranlib"
"${ARCHIVE_ROOT}/bin/llvm-strip"
"${ARCHIVE_ROOT}/lib/clang/18/include"
)
if [[ -n "${RESOURCE_LIB}" ]]; then
paths+=("${RESOURCE_LIB}")
fi
tar -xJf "${ARCHIVE_PATH}" -C "${DESTINATION}" --strip-components=1 "${paths[@]}"
"${DESTINATION}/bin/clang" --version
"${DESTINATION}/bin/llvm-ar" --version | head -1
......@@ -51,10 +51,21 @@ RUN HOST_ARCH=$(dpkg --print-architecture) && \
# works on either host architecture.
RUN apt-get update && apt-get install -y --no-install-recommends \
curl ca-certificates \
clang lld llvm pkg-config wget git xz-utils libssl-dev \
clang lld llvm file pkg-config wget git xz-utils libssl-dev libtinfo5 \
crossbuild-essential-amd64 crossbuild-essential-arm64 \
&& rm -rf /var/lib/apt/lists/*
# Primary release targets compile C/C++ dependencies with pinned upstream LLVM.
# Extract only the compiler, archive tools, and resource headers (~237 MB), not
# the full 7.5 GB SDK. Target libc and headers still come from the GNU sysroots.
# Excluded targets skip the large download and keep using the distro toolchain.
ARG INSTALL_NATIVE_LLVM=1
COPY scripts/install-native-llvm.sh /tmp/install-native-llvm.sh
RUN if [ "$INSTALL_NATIVE_LLVM" = "1" ]; then \
/tmp/install-native-llvm.sh /opt/llvm-18.1.8; \
fi && \
rm /tmp/install-native-llvm.sh
# Node.js 20 (glibc-linked, used as a build tool for all targets).
# Installed from the official nodejs.org static tarball rather than via
# NodeSource: the tarball bundles npm and corepack and does not depend on
......@@ -99,6 +110,7 @@ RUN TOOLCHAIN=$(grep 'channel' /tmp/rust-toolchain.toml | sed 's/.*"\(.*\)".*/\1
rm /tmp/rust-toolchain.toml
ENV PATH="/root/.cargo/bin:${PATH}"
ENV NATIVE_LLVM_BIN="/opt/llvm-18.1.8/bin"
# Add all 4 Linux rustup targets
RUN rustup target add \
......
#!/usr/bin/env bash
set -euo pipefail
: "${TARGET:?TARGET must be set}"
: "${LLVM_BIN_DIR:?LLVM_BIN_DIR must be set}"
readonly PROFILE_DIR="${CARGO_TARGET_DIR:-target}/${TARGET}/release"
readonly BUILD_DIR="${PROFILE_DIR}/build"
readonly LLVM_AR="${LLVM_BIN_DIR}/llvm-ar"
if [[ ! -d "${BUILD_DIR}" ]]; then
echo "Native build output not found: ${BUILD_DIR}" >&2
exit 1
fi
verify_archive() {
local label=$1
local package_glob=$2
local archive_name=$3
local allowed_native_regex=$4
local required=$5
local matches=()
local found_archives
found_archives=$(find "${BUILD_DIR}" -path "*/${package_glob}/out/${archive_name}" -type f -print)
if [[ -n "${found_archives}" ]]; then
while IFS= read -r archive; do
matches+=("${archive}")
done <<< "${found_archives}"
fi
if [[ ${#matches[@]} -eq 0 ]]; then
if [[ "${required}" == true ]]; then
echo "Required ${label} archive was not found under ${BUILD_DIR}" >&2
return 1
fi
echo "Skipping ${label}: not present for ${TARGET}"
return 0
fi
local archive
for archive in "${matches[@]}"; do
local bitcode_count=0
local native_count=0
local member
local members
members=$("${LLVM_AR}" t "${archive}")
while IFS= read -r member; do
[[ -n "${member}" ]] || continue
local description
description=$("${LLVM_AR}" p "${archive}" "${member}" | file -b -)
if [[ "${description}" == *"LLVM IR bitcode"* || "${description}" == *"LLVM bitcode"* ]]; then
((bitcode_count += 1))
else
((native_count += 1))
if [[ -z "${allowed_native_regex}" || ! "${member}" =~ ${allowed_native_regex} ]]; then
echo "${label} member is not LLVM bitcode or an allowed assembly object: ${archive}(${member}): ${description}" >&2
return 1
fi
echo "Allowed ${label} assembly member: ${member}: ${description}"
fi
done <<< "${members}"
if [[ ${bitcode_count} -eq 0 ]]; then
echo "${label} archive contains no LLVM bitcode: ${archive}" >&2
return 1
fi
echo "Verified ${label}: ${bitcode_count} bitcode member(s), ${native_count} allowed native member(s)"
done
}
verify_archive mimalloc 'libmimalloc-sys-*' libmimalloc.a '' true
verify_archive lz4 'lzzzz-*' liblz4.a '' true
verify_archive zstd 'zstd-sys-*' libzstd.a '(^|-)huf_decompress_amd64\.o$' true
# ring combines Clang-built C bitcode with checked-in/generated assembly objects
# whose names vary by architecture. Requiring at least one bitcode member still
# catches a missing -flto=thin while allowing those architecture-specific files.
if [[ "${TARGET}" == *-linux-gnu ]]; then
verify_archive ring 'ring-*' 'libring_core_*.a' '.*' true
else
verify_archive ring 'ring-*' 'libring_core_*.a' '.*' false
fi
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment