.github/workflows/libc-overlay-tests.yml

# This workflow is for pre-commit testing of the LLVM-libc project.
name: LLVM-libc Pre-commit Overlay Tests
permissions:
  contents: read
on:
  pull_request:
    paths:
      - 'libc/**'
      - '.github/workflows/libc-overlay-tests.yml'

jobs:
  native:
    if: github.repository_owner == 'llvm'
    name: ${{ matrix.name }}
    timeout-minutes: 60
    runs-on: ${{ matrix.os }}
    container: ${{ matrix.container || null }}
    strategy:
      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations.
      fail-fast: false
      matrix:
        include:
          # TODO: add linux gcc when it is fixed
          - name: linux-x86_64
            os: llvm-premerge-linux-32-runners
            container: 'ghcr.io/llvm/libc-ubuntu-26.04:latest@sha256:fffa8d515b48be0367b0bd09ef8cf64c622367e3b0e3426e4c4f12c8fa667063'
            compiler:
              c_compiler: clang-23
              cpp_compiler: clang++-23
            linker: lld-23
          - name: linux-aarch64
            os: ubuntu-26.04-arm
            container: 'ghcr.io/llvm/arm64v8/libc-ubuntu-26.04:latest@sha256:8597b484c4041a6f61374ad12820d7786e3279111a94dc13ccba0b57a3c508da'
            compiler:
              c_compiler: clang-23
              cpp_compiler: clang++-23
            linker: lld-23
          - name: windows2022-x86_64
            os: windows-2022
            compiler:
              c_compiler: clang-cl
              cpp_compiler: clang-cl
          - name: windows2025-x86_64
            os: windows-2025
            compiler:
              c_compiler: clang-cl
              cpp_compiler: clang-cl
          - name: macos-aarch64
            os: macos-15
            compiler:
              c_compiler: clang
              cpp_compiler: clang++
    
    steps:
    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      with:
        persist-credentials: false
      # TODO(#226230): Remove this once we have resolved the underlying issue
      # causing actions/checkout to be prematurely killed.
      env:
        GIT_TRACE: "true"
        GIT_CURL_VERBOSE: "true"
    
    # Libc's build is relatively small comparing with other components of LLVM.
    # A fresh linux overlay takes about 180MiB of uncompressed disk space, which can
    # be compressed into ~40MiB. MacOS and Windows overlay builds are less than 10MiB
    # after compression. Limiting the cache size to 1G should be enough.
    # Prefer sccache as it is modern and it has a guarantee to work with MSVC.
    # Do not use direct GHAC access even though it is supported by sccache. GHAC rejects
    # frequent small object writes.
    - name: Setup ccache
      uses: hendrikmuhs/ccache-action@f09c25b45002a07be2955cbe52e8cee55643f89d # v1.2.24
      with:
        max-size: 1G
        key: libc_overlay_build_v2_${{ matrix.os }}_${{ matrix.compiler.c_compiler }}
        variant: sccache
    
    # Chocolatey is shipped with Windows runners. Windows Server 2025 recommends WinGet.
    # Consider migrating to WinGet when Windows Server 2025 is available.
    - name: Prepare dependencies (Windows)
      if: runner.os == 'Windows'
      run: |
        choco install ninja
    
    - name: Prepare dependencies (macOS)
      if: runner.os == 'macOS'
      run: |
        brew install ninja

    # Use MinSizeRel to reduce the size of the build.
    # Notice that CMP0141=NEW and MSVC_DEBUG_INFORMATION_FORMAT=Embedded are required
    # by the sccache tool.
    - name: Configure CMake
      run: >
        cmake -B build
        -DCMAKE_CXX_COMPILER=${{ matrix.compiler.cpp_compiler }}
        -DCMAKE_C_COMPILER=${{ matrix.compiler.c_compiler }}
        -DCMAKE_BUILD_TYPE=RelWithDebInfo
        -DCMAKE_C_COMPILER_LAUNCHER=sccache
        -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
        -DCMAKE_POLICY_DEFAULT_CMP0141=NEW
        -DCMAKE_MSVC_DEBUG_INFORMATION_FORMAT=Embedded
        -DLIBC_COMPILE_OPTIONS_NATIVE=""
        -DLLVM_ENABLE_RUNTIMES=libc
        -DLLVM_USE_LINKER="${{ matrix.linker }}"
        -G Ninja
        -S runtimes

    - name: Build
      run: >
        cmake 
        --build build
        --parallel 
        --target libc

    - name: Build Test
      run: >
        cmake 
        --build build 
        --parallel 
        --target check-libc-build

    - name: Test
      run: >
        cmake 
        --build build 
        --parallel 
        --target check-libc

  qemu:
    if: github.repository_owner == 'llvm'
    name: qemu - ${{ matrix.arch }} - ${{ matrix.c_compiler }}
    runs-on: ubuntu-26.04
    timeout-minutes: 60
    container:
      image: 'ghcr.io/llvm/libc-ubuntu-26.04:latest@sha256:fffa8d515b48be0367b0bd09ef8cf64c622367e3b0e3426e4c4f12c8fa667063'
      # We need to enable privileged containers so that certain libc tests
      # have the necessary permissions (like SYS_TIME). There are no security
      # implications as we are already running in an isolated VM.
      options: --privileged
    strategy:
      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations.
      fail-fast: false
      matrix:
        include:
          - arch: armhf
            target_triple: arm-linux-gnueabihf
            c_compiler: clang-23
            cxx_compiler: clang++-23
          - arch: riscv64
            target_triple: riscv64-linux-gnu
            c_compiler: clang-23
            cxx_compiler: clang++-23
            mpfr_path: /usr/riscv64-linux-gnu
            mpc_path: riscv64-linux-gnu
    steps:
      - name: Checkout LLVM
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false

      - name: Setup ccache
        uses: hendrikmuhs/ccache-action@f09c25b45002a07be2955cbe52e8cee55643f89d # v1.2.24
        with:
          max-size: 1G
          key: libc_qemu_overlay_${{ matrix.arch }}_${{ matrix.c_compiler }}
          variant: sccache

      - name: Create QEMU wrapper
        run: |
          mkdir build
          cat << 'EOF' > /__w/llvm-project/llvm-project/build/qemu-wrapper.sh
          #!/bin/bash
          qemu-${{ matrix.arch }} -L /usr/${{ matrix.target_triple }} "$@"
          EOF
          chmod +x /__w/llvm-project/llvm-project/build/qemu-wrapper.sh

      - name: Configure CMake
        run: |
          cmake -B build -S runtimes -G Ninja \
            -DLLVM_ENABLE_RUNTIMES=libc \
            -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} \
            -DCMAKE_CXX_COMPILER=${{ matrix.cxx_compiler }} \
            -DCMAKE_BUILD_TYPE=Release \
            -DLLVM_USE_LINKER=lld-23 \
            -DLIBC_TARGET_TRIPLE=${{ matrix.target_triple}} \
            -DLLVM_LIBC_MPFR_INSTALL_PATH="${{ matrix.mpfr_path }}" \
            -DLIBC_MPC_INSTALL_PATH="${{ matrix.mpc_path }}" \
            -DCMAKE_CROSSCOMPILING_EMULATOR=/__w/llvm-project/llvm-project/build/qemu-wrapper.sh

      - name: Build
        run: |
          cmake --build build --parallel --target libc

      - name: Build Test
        run: |
          cmake --build build --parallel --target check-libc-build

      - name: Run Test
        run: |
          cmake --build build --parallel --target check-libc