build-llvm.sh

#!/usr/bin/env bash
set -e

# --- Configuration ---
REPO_ROOT=$(pwd)
LIBFFI_VERSION="3.5.2"
MIN_IOS_VERSION="12.0"
MIN_MACOS_VERSION="11.0" # Modern baseline
LLVM_VERSION="22.1.2"   # Latest stable release as of April 2026
BUILD_DIR="$REPO_ROOT/build"
OUTPUT_DIR="$REPO_ROOT/output"

mkdir -p "$BUILD_DIR"
mkdir -p "$OUTPUT_DIR"

# --- Utility Functions ---
log() { echo -e "\033[1;32m[INFO]\033[0m $1"; }
error() { echo -e "\033[1;31m[ERROR]\033[0m $1"; exit 1; }

# Toolchain resolution
resolve_toolchain() {
    local sdk=$1 arch=$2 host=$3
    local sdk_path=$(xcrun --sdk "$sdk" --show-sdk-path)
    local target="$arch-apple-ios$MIN_IOS_VERSION"
    [[ "$sdk" == "iphonesimulator" ]] && target="$arch-apple-ios$MIN_IOS_VERSION-simulator"
    
    export CC=$(xcrun --sdk "$sdk" -f clang)
    export CXX=$(xcrun --sdk "$sdk" -f clang++)
    export SDKROOT="$sdk_path"
    
    local flags="-arch $arch -isysroot $sdk_path -target $target"
    local build=$(./config.guess 2>/dev/null || echo "x86_64-apple-darwin")
    
    export CFLAGS="$flags" CXXFLAGS="$flags" LDFLAGS="$flags"
    echo "$build"
}

# --- libffi Functions ---

fetch_libffi() {
    if [ ! -d "$BUILD_DIR/libffi-src" ]; then
        log "Fetching libffi $LIBFFI_VERSION..."
        cd "$BUILD_DIR"
        curl -LSs "https://github.com/libffi/libffi/releases/download/v$LIBFFI_VERSION/libffi-$LIBFFI_VERSION.tar.gz" -o libffi.tar.gz
        tar xzf libffi.tar.gz
        mv "libffi-$LIBFFI_VERSION" "libffi-src"
        rm libffi.tar.gz
        
        # Patch libffi assembly for modern Apple CFI (Xcode 16+)
        log "Patching libffi assembly (stripping all .cfi_ directives)..."
        cd "$BUILD_DIR/libffi-src"
        find src -name "*.S" -exec sed -i.bak '/.cfi_/d' {} +
        
        # Standardize script permissions for CI
        chmod +x configure config.guess config.sub install-sh compile missing
    fi
}

build_libffi_arch() {
    local sdk=$1 arch=$2 host=$3
    local target="$OUTPUT_DIR/libffi-$sdk-$arch"
    mkdir -p "$target"
    log "Building libffi for $sdk ($arch)..."
    cd "$BUILD_DIR/libffi-src"
    make clean || true
    local build=$(resolve_toolchain "$sdk" "$arch" "$host")
    ./configure --host="$host" --build="$build" --prefix="$target" --enable-static --disable-shared --disable-dependency-tracking --disable-multi-os-directory || exit 1
    make -j$(sysctl -n hw.ncpu) install
}

make_universal_lib() {
    local base=$1 path=$2
    if [[ -d "$OUTPUT_DIR/libffi-$base-arm64" && -d "$OUTPUT_DIR/libffi-$base-x86_64" ]]; then
        log "Creating universal $base binary..."
        mkdir -p "$OUTPUT_DIR/libffi-$base-universal/$path"
        lipo -create "$OUTPUT_DIR/libffi-$base-arm64/$path/libffi.a" "$OUTPUT_DIR/libffi-$base-x86_64/$path/libffi.a" -output "$OUTPUT_DIR/libffi-$base-universal/$path/libffi.a"
        cp -R "$OUTPUT_DIR/libffi-$base-arm64/include" "$OUTPUT_DIR/libffi-$base-universal/"
    fi
}

create_libffi_xcframework() {
    log "Creating libffi.xcframework..."
    make_universal_lib "iphonesimulator" "lib"

    local fw_cmd="xcodebuild -create-xcframework"
    
    # Define potential components (Universal or single arch)
    local comps=(
        "libffi-iphoneos-arm64"
        "libffi-iphonesimulator-universal" "libffi-iphonesimulator-arm64" "libffi-iphonesimulator-x86_64"
    )
    
    local added_simulator=false
    local added_catalyst=false
    
    for comp in "${comps[@]}"; do
        local lib_path="$OUTPUT_DIR/$comp/lib/libffi.a"
        local header_path="$OUTPUT_DIR/$comp/include"
        
        if [ -f "$lib_path" ]; then
            if [[ "$comp" == *"simulator"* ]]; then
                [[ "$added_simulator" == true ]] && continue
                added_simulator=true
            fi
            fw_cmd="$fw_cmd -library $lib_path -headers $header_path"
        fi
    done

    rm -rf "$OUTPUT_DIR/libffi.xcframework"
    $fw_cmd -output "$OUTPUT_DIR/libffi.xcframework"
}

# --- LLVM Functions ---

fetch_llvm() {
    if [ ! -d "$REPO_ROOT/llvm-project" ]; then
        log "Fetching LLVM project..."
        cd "$REPO_ROOT"
        git clone --depth 1 -b "llvmorg-$LLVM_VERSION" https://github.com/llvm/llvm-project.git
    fi
}

build_host_tools() {
    if [ ! -d "$BUILD_DIR/llvm-host" ]; then
        log "Building LLVM TableGen for host..."
        mkdir -p "$BUILD_DIR/llvm-host"
        cd "$BUILD_DIR/llvm-host"
        cmake -G Ninja "$REPO_ROOT/llvm-project/llvm" \
            -DCMAKE_BUILD_TYPE=Release \
            -DLLVM_ENABLE_PROJECTS="clang"
        ninja llvm-tblgen clang-tblgen
    fi
}

build_llvm() {
    local sdk=$1 arch=$2 triple=$3
    fetch_llvm && build_host_tools
    local build_dir="$REPO_ROOT/LLVM-$sdk-$arch"
    local install_dir="$REPO_ROOT/output/LLVM-$sdk-$arch"
    mkdir -p "$build_dir" "$install_dir"
    
    # Skip if already installed and the build-llvm.sh hasn't changed (assumed by cache hit)
    if [ -f "$install_dir/lib/libLLVM.dylib" ]; then
        log "LLVM already built for $sdk ($arch), skipping..."
        return 0
    fi
    
    log "Building LLVM for $sdk ($arch)..."
    cd "$build_dir"
    resolve_toolchain "$sdk" "$arch" "$triple" >/dev/null
    
    local libffi_platform="$sdk-$arch"
    local libffi_root="$REPO_ROOT/output/libffi-$libffi_platform"
    [ ! -d "$libffi_root" ] && error "libffi build for $libffi_platform not found"
    
    cmake -G Ninja "$REPO_ROOT/llvm-project/llvm" -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="ARM;AArch64;X86" \
        -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS" -DCMAKE_ASM_FLAGS="$CFLAGS" \
        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
        -DLLVM_DEFAULT_TARGET_TRIPLE="$triple" -DLLVM_ENABLE_PROJECTS="clang" -DCMAKE_INSTALL_PREFIX="$install_dir" \
        -DLLVM_BUILD_LLVM_DYLIB=ON -DLLVM_LINK_LLVM_DYLIB=ON -DLLVM_ENABLE_FFI=ON -DFFI_INCLUDE_DIR="$libffi_root/include" \
        -DFFI_LIBRARY_DIR="$libffi_root/lib" -DCMAKE_OSX_SYSROOT="$(xcrun --sdk "$sdk" --show-sdk-path)" \
        -DCMAKE_OSX_ARCHITECTURES="$arch" -DLLVM_TABLEGEN="$BUILD_DIR/llvm-host/bin/llvm-tblgen" \
        -DCLANG_TABLEGEN="$BUILD_DIR/llvm-host/bin/clang-tblgen" -DLLVM_OPTIMIZED_TABLEGEN=ON -DLLVM_BUILD_DOCS=OFF \
        -DLLVM_INCLUDE_TESTS=OFF -DLLVM_ENABLE_ZSTD=OFF -DCMAKE_FIND_ROOT_PATH="$(xcrun --sdk "$sdk" --show-sdk-path)" \
        -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
        -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY
    ninja install
}

create_llvm_framework_wrapper() {
    local sdk=$1 arch=$2
    local install_dir="$REPO_ROOT/output/LLVM-$sdk-$arch"
    local fw_suffix="$sdk-$arch"
    local fw_path="$BUILD_DIR/$fw_suffix/LLVM.framework"
    
    mkdir -p "$fw_path"
    
    # Copy the main dylib as the framework binary
    if [ -f "$install_dir/lib/libLLVM.dylib" ]; then
        cp "$install_dir/lib/libLLVM.dylib" "$fw_path/LLVM"
    elif [ -f "$install_dir/lib/libLLVM.a" ]; then
        # If static, we might need a different approach, but for now assuming dylib
        cp "$install_dir/lib/libLLVM.a" "$fw_path/LLVM"
    fi
    
    mkdir -p "$fw_path/Headers"
    cp -R "$install_dir/include/"* "$fw_path/Headers/"
    
    # Create a basic Info.plist
    cat > "$fw_path/Info.plist" <<EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDevelopmentRegion</key>
	<string>en</string>
	<key>CFBundleExecutable</key>
	<string>LLVM</string>
	<key>CFBundleIdentifier</key>
	<string>org.llvm.LLVM</string>
	<key>CFBundleInfoDictionaryVersion</key>
	<string>6.0</string>
	<key>CFBundleName</key>
	<string>LLVM</string>
	<key>CFBundlePackageType</key>
	<string>FMWK</string>
	<key>CFBundleShortVersionString</key>
	<string>1.0</string>
	<key>CFBundleVersion</key>
	<string>1</string>
</dict>
</plist>
EOF

    # Update install name so it's loadable relative to the framework
    if [[ -f "$fw_path/LLVM" && "$fw_path/LLVM" == *.dylib ]]; then
        install_name_tool -id "@rpath/LLVM.framework/LLVM" "$fw_path/LLVM" || true
    fi
}

make_universal_fw() {
    local base=$1
    if [[ -d "$BUILD_DIR/$base-arm64/LLVM.framework" && -d "$BUILD_DIR/$base-x86_64/LLVM.framework" ]]; then
        log "Creating universal $base framework..."
        mkdir -p "$BUILD_DIR/$base-universal/LLVM.framework"
        lipo -create "$BUILD_DIR/$base-arm64/LLVM.framework/LLVM" "$BUILD_DIR/$base-x86_64/LLVM.framework/LLVM" -output "$BUILD_DIR/$base-universal/LLVM.framework/LLVM"
        cp -R "$BUILD_DIR/$base-arm64/LLVM.framework/Headers" "$BUILD_DIR/$base-arm64/LLVM.framework/Info.plist" "$BUILD_DIR/$base-universal/LLVM.framework/"
    fi
}

create_llvm_xcframework() {
    log "Creating LLVM.xcframework..."
    for arch in arm64 x86_64; do
        create_llvm_framework_wrapper "iphoneos" "arm64"
        create_llvm_framework_wrapper "iphonesimulator" "$arch"
    done
    make_universal_fw "iphonesimulator"
    
    local fw_cmd="xcodebuild -create-xcframework"
    
    # Add potential frameworks (iOS, Simulator) - favor universal if present
    local targets=("iphoneos-arm64" "iphonesimulator-universal" "iphonesimulator-arm64" "iphonesimulator-x86_64")
    local added_sim=false
    
    for t in "${targets[@]}"; do
        local fw="$BUILD_DIR/$t/LLVM.framework"
        if [ -d "$fw" ]; then
            if [[ "$t" == *"simulator"* ]]; then
                [[ "$added_sim" == true ]] && continue
                added_sim=true
            fi
            fw_cmd="$fw_cmd -framework $fw"
        fi
    done
    
    rm -rf "$OUTPUT_DIR/LLVM.xcframework"
    $fw_cmd -output "$OUTPUT_DIR/LLVM.xcframework"
}

# --- Main Logic ---

case "$1" in
    "libffi-all")
        fetch_libffi
        build_libffi_arch "iphoneos" "arm64" "aarch64-apple-ios"
        build_libffi_arch "iphonesimulator" "arm64" "aarch64-apple-ios"
        build_libffi_arch "iphonesimulator" "x86_64" "x86_64-apple-ios"
        build_libffi_arch "macosx" "arm64" "aarch64-apple-ios" "yes"
        build_libffi_arch "macosx" "x86_64" "x86_64-apple-ios" "yes"
        create_libffi_xcframework
        ;;
    "libffi-single")
        fetch_libffi
        case "$2" in
            iphoneos*) build_libffi_arch "iphoneos" "arm64" "aarch64-apple-ios" ;;
            iphonesimulator-arm64) build_libffi_arch "iphonesimulator" "arm64" "aarch64-apple-ios-simulator" ;;
            iphonesimulator-x86_64) build_libffi_arch "iphonesimulator" "x86_64" "x86_64-apple-ios-simulator" ;;
        esac ;;
    "llvm-single")
        case "$2" in
            iphoneos*) build_llvm "iphoneos" "arm64" "aarch64-apple-ios" ;;
            iphonesimulator-arm64) build_llvm "iphonesimulator" "arm64" "aarch64-apple-ios-simulator" ;;
            iphonesimulator-x86_64) build_llvm "iphonesimulator" "x86_64" "x86_64-apple-ios-simulator" ;;
        esac ;;
    "package-all") create_libffi_xcframework; create_llvm_xcframework ;;
    *)
        echo "Usage: $0 {libffi-all|libffi-single [platform]|llvm-single [platform]|llvm-all|package-all}"
        exit 1
        ;;
esac