Bump mold version to 2.35.0

This reverts commit c7042f416e because it broke CI.

.github/workflows/build-all.yml

@@ -0,0 +1,46 @@
+name: Build all tarballs
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  release:
+    types: [ published ]
+  workflow_dispatch:
+
+jobs:
+  build-tarballs:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        target: [ x86_64, aarch64, arm, riscv64, ppc64le, s390x ]
+
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@v2
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v1
+      with:
+        registry: ghcr.io
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v1
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build a tarball
+      run: ./dist.sh ${{ matrix.target }}
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ matrix.target }}
+        path: mold-*.tar.gz

.github/workflows/build-x86.yml

@@ -0,0 +1,37 @@
+name: Build x86 tarball
+
+on:
+  push:
+    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  build-tarball:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@v2
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v1
+      with:
+        registry: ghcr.io
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build a tarball
+      run: ./dist.sh
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: tarball
+        path: mold-*.tar.gz

.github/workflows/ci.yml

@@ -1,105 +1,99 @@
 name: CI
 on:
   push:
-    branches: [ main ]
   pull_request:
-    branches: [ main ]
 env:
   UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
 jobs:
-  build-clang:
+  build-sanitizers:
     strategy:
       matrix:
         target:
-        # Disable PCH for the default configuration. This prevents relying on implicit includes.
-        - '-DCMAKE_DISABLE_PRECOMPILE_HEADERS=On'
+        - ''
         - '-DMOLD_USE_ASAN=On'
         - '-DMOLD_USE_TSAN=On'
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v3
     - uses: rui314/setup-mold@staging
-    - name: install-build-deps
-      run: sudo ./install-build-deps.sh update
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1
-    - name: build and test
+    - run: sudo ./install-build-deps.sh
+    - name: build
       run: |
-        echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
+        sudo apt-get install -y clang-18 clang gcc-multilib gdb dwarfdump zstd
         mkdir build
         cd build
-        cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ${{ matrix.target }} ..
+        cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang-18 -DCMAKE_CXX_COMPILER=clang++-18 ${{ matrix.target }} ..
         cmake --build . -j$(nproc)
-        ctest . -j$(nproc)
+    - run: cd build; ctest -j$(nproc)
+    - name: archive test results
+      uses: actions/upload-artifact@v3
+      if: failure()
+      with:
+        name: test-results-clang
+        path: |
+          build
+          !build/CMakeFiles
 
-  build-gcc:
-    runs-on: ubuntu-20.04
+  build-multi-archs:
+    runs-on: ubuntu-latest
     container: gcc:11.1.0
     steps:
     - uses: actions/checkout@v3
     - name: install-build-deps
+      shell: bash
       run: |
         # Install cross toolchains
-        dpkg --add-architecture i386
-        ./install-build-deps.sh update
-        apt-get install -y sudo qemu-user gdb zstd dwarfdump {gcc,g++}-10-{i686,aarch64,riscv64,powerpc,powerpc64,powerpc64le,s390x,sparc64,m68k,sh4,alpha}-linux-gnu {gcc,g++}-10-arm-linux-gnueabihf
-
-        for i in i686 aarch64 riscv64 powerpc powerpc64 powerpc64le s390x sparc64 m68k sh4 alpha; do
-          ln -sf /usr/bin/$i-linux-gnu-gcc-10 /usr/bin/$i-linux-gnu-gcc
-          ln -sf /usr/bin/$i-linux-gnu-g++-10 /usr/bin/$i-linux-gnu-g++
-        done
-
-        ln -sf /usr/bin/arm-linux-gnueabihf-gcc-10 /usr/bin/arm-linux-gnueabihf-gcc
-        ln -sf /usr/bin/arm-linux-gnueabihf-g++-10 /usr/bin/arm-linux-gnueabihf-g++
-
-        # Install a RV32 toolchain from third party since it's not available
-        # as an Ubuntu package.
-        mkdir /usr/local/rv32
-        wget -O- -q https://github.com/riscv-collab/riscv-gnu-toolchain/releases/download/2022.08.26/riscv32-glibc-ubuntu-20.04-nightly-2022.08.26-nightly.tar.gz | tar -C /usr/local/rv32 --strip-components=1 -xzf -
-
-        ln -sf /usr/local/rv32/sysroot /usr/riscv32-linux-gnu
-        ln -sf /usr/local/rv32/bin/riscv32-unknown-linux-gnu-objdump /usr/bin/riscv32-linux-gnu-objdump
-        echo '/usr/local/rv32/bin/riscv32-unknown-linux-gnu-gcc -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-gcc
-        echo '/usr/local/rv32/bin/riscv32-unknown-linux-gnu-g++ -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-g++
-        chmod 755 /usr/bin/riscv32-linux-gnu-gcc /usr/bin/riscv32-linux-gnu-g++
-      shell: bash
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1
-    - name: build and test
+        ./install-build-deps.sh
+        ./install-cross-tools.sh
+        .github/workflows/install-extras.sh
+    - name: build
       run: |
-        echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
         mkdir build
         cd build
-        cmake -DMOLD_ENABLE_QEMU_TESTS=On -DMOLD_ENABLE_QEMU_TESTS_RV32=On ..
+        cmake ..
         cmake --build . -j$(nproc)
-        ctest . -j$(nproc)
+    - run: cd build; ctest -j$(nproc)
     - name: archive test results
       uses: actions/upload-artifact@v3
-      if: always()
+      if: failure()
       with:
-        name: test-results
+        name: test-results-gcc
         path: |
-          build/out
-          build/Testing
+          build
+          !build/CMakeFiles
 
-  build-macos:
-    runs-on: macos-11
+  build-distros:
     strategy:
       matrix:
-        target:
-        # Disable PCH for the default configuration. This prevents relying on implicit includes.
-        - '-DCMAKE_DISABLE_PRECOMPILE_HEADERS=On'
-        - '-DMOLD_USE_ASAN=On'
+        distro:
+        - alpine
+        - archlinux
+        - fedora
+        - gentoo/stage3
+        - opensuse/tumbleweed
+        - ubuntu:22.04
+    runs-on: ubuntu-latest
+    container: ${{ matrix.distro }}
     steps:
-    - uses: actions/checkout@v3
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1
-    - name: build and test
+    - uses: actions/checkout@v2
+    - run: ./install-build-deps.sh
+    - name: build
       run: |
-        echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
         mkdir build
         cd build
-        cmake ${{ matrix.target }} ..
+        cmake ..
+        cmake --build . -j$(nproc)
+    - run: cd build; ctest -j$(nproc)
+
+  build-macos:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: build
+      run: |
+        mkdir build
+        cd build
+        cmake ..
         cmake --build . -j$(sysctl -n hw.physicalcpu)
 
   build-windows:
@@ -112,3 +106,37 @@ jobs:
         cd build
         cmake -T clangcl ..
         cmake --build . -j $Env:NUMBER_OF_PROCESSORS
+
+  build-msys:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup MSYS2
+      uses: msys2/setup-msys2@v2
+      with:
+        msystem: UCRT64
+        update: true
+        pacboy: gcc-libs:p libwinpthread-git:p tbb:p zlib:p zstd:p dlfcn:p cc:p cmake:p ninja:p
+    - name: build
+      shell: msys2 {0}
+      run: |
+        mkdir build
+        cd build
+        cmake -GNinja -DMOLD_USE_MIMALLOC=OFF -DMOLD_USE_SYSTEM_TBB=ON ..
+        cmake --build . -j $(nproc)
+
+  build-freebsd:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build and test
+      uses: vmactions/freebsd-vm@v1
+      with:
+        usesh: true
+        run: |
+          ./install-build-deps.sh
+          mkdir build
+          cd build
+          cmake ..
+          cmake --build . -j$(nproc)
+          ctest -j$(nproc)

.github/workflows/install-extras.sh

@@ -0,0 +1,61 @@
+#!/bin/bash -x
+
+apt-get update
+apt-get install -y wget xz-utils
+
+# Install a 32-bit RISC-V toolchain
+mkdir /rv32
+wget -O- -q https://github.com/riscv-collab/riscv-gnu-toolchain/releases/download/2023.07.07/riscv32-glibc-ubuntu-20.04-gcc-nightly-2023.07.07-nightly.tar.gz | tar -C /rv32 --strip-components=1 -xzf -
+
+ln -sf /rv32/sysroot /usr/riscv32-linux-gnu
+echo '/rv32/bin/riscv32-unknown-linux-gnu-gcc -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-gcc
+echo '/rv32/bin/riscv32-unknown-linux-gnu-g++ -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-g++
+chmod 755 /usr/bin/riscv32-linux-gnu-{gcc,g++}
+
+for i in objdump objcopy strip; do
+  ln -sf /rv32/bin/riscv32-unknown-linux-gnu-$i /usr/bin/riscv32-linux-gnu-$i
+done
+
+# Install a LoongArch toolchain
+mkdir /larch
+wget -O- -q https://github.com/loongson/build-tools/releases/download/2024.11.01/x86_64-cross-tools-loongarch64-binutils_2.43.1-gcc_14.2.0-glibc_2.40.tar.xz | tar -C /larch --strip-components=1 --xz -xf -
+
+cp -r /larch/loongarch64-unknown-linux-gnu/lib/* /larch/target/lib64
+ln -sf /larch/target /usr/loongarch64-linux-gnu
+
+for i in gcc g++ objdump objcopy strip; do
+  ln -sf /larch/bin/loongarch64-unknown-linux-gnu-$i /usr/bin/loongarch64-linux-gnu-$i
+done
+
+wget -O /usr/local/bin/qemu-loongarch64 -q https://github.com/loongson/build-tools/releases/download/2024.11.01/qemu-loongarch64
+chmod 755 /usr/local/bin/qemu-loongarch64
+
+# Install ARM64 big-endian toolchain
+mkdir /aarch64be
+wget -O- -q https://sources.buildroot.net/toolchain-external-arm-aarch64-be/arm-gnu-toolchain-13.3.rel1-x86_64-aarch64_be-none-linux-gnu.tar.xz | tar -C /aarch64be --strip-components=1 --xz -xf -
+
+ln -sf /aarch64be/aarch64_be-none-linux-gnu/libc /usr/aarch64_be-linux-gnu
+echo '/aarch64be/bin/aarch64_be-none-linux-gnu-gcc -L/usr/aarch64_be-linux-gnu "$@"' > /usr/bin/aarch64_be-linux-gnu-gcc
+echo '/aarch64be/bin/aarch64_be-none-linux-gnu-g++ -L/usr/aarch64_be-linux-gnu "$@"' > /usr/bin/aarch64_be-linux-gnu-g++
+chmod 755 /usr/bin/aarch64_be-linux-gnu-{gcc,g++}
+
+for i in objdump objcopy strip; do
+  ln -sf /aarch64be/bin/aarch64_be-none-linux-gnu-$i /usr/bin/aarch64_be-linux-gnu-$i
+done
+
+# Install SH4 big-endian toolchain
+mkdir /sh4aeb
+wget -O- -q https://toolchains.bootlin.com/downloads/releases/toolchains/sh-sh4aeb/tarballs/sh-sh4aeb--glibc--stable-2024.05-1.tar.xz | tar -C /sh4aeb --strip-components=1 --xz -xf -
+ln -sf /sh4aeb/sh4aeb-buildroot-linux-gnu/sysroot /usr/sh4aeb-linux-gnu
+echo '/sh4aeb/bin/sh4aeb-linux-gcc -L/usr/sh4aeb-linux-gnu "$@"' > /usr/bin/sh4aeb-linux-gnu-gcc
+echo '/sh4aeb/bin/sh4aeb-linux-g++ -L/usr/sh4aeb-linux-gnu "$@"' > /usr/bin/sh4aeb-linux-gnu-g++
+chmod 755 /usr/bin/sh4aeb-linux-gnu-{gcc,g++}
+
+for i in objdump objcopy strip; do
+  ln -sf /sh4aeb/bin/sh4aeb-linux-$i /usr/bin/sh4aeb-linux-gnu-$i
+done
+
+# Install Intel SDE CPU emulator for CET-related tests
+mkdir /sde
+wget -O- -q https://downloadmirror.intel.com/831748/sde-external-9.44.0-2024-08-22-lin.tar.xz | tar -C /sde --strip-components=1 --xz -xf -
+ln -s /sde/sde64 /usr/bin

.github/workflows/update-manpage.yml

@@ -0,0 +1,33 @@
+name: Update manpage
+
+on:
+  push:
+    paths:
+      - 'docs/mold.md'
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  update-manpage:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v2
+
+    - name: Install ronn
+      run: sudo apt-get update && sudo apt-get install -y ronn
+
+    - name: Generate mold.1 from mold.md
+      run: ronn --roff docs/mold.md
+
+    - name: Configure Git
+      run: |
+        git config --global user.name 'Rui Ueyama'
+        git config --global user.email '[email protected]'
+
+    - name: Commit and push if mold.1 is updated
+      run: |
+        git add docs/mold.1
+        git diff --staged --quiet || (git commit -m "Update mold.1 (automated commit)" && git push)

.gitignore

@@ -3,15 +3,8 @@
 *~
 **/.DS_Store
 .cache
-compile_commands.json
-/mold
-/test/tmp
-options.inc
 core
-ld
-ld64
-ld64.mold
 gentoo
-out
 /mold-*.tar.gz
 /build*
+/mold

CMakeLists.txt

@@ -1,31 +1,31 @@
 # You can customize a build by specifying CMake options. An option may be
 # given in the -Dvariable=value form. For a boolean variable, `ON` or `1`
-# means true while `OFF` or `0` means false.
+# means true, while `OFF` or `0` means false.
 #
 # Here are a couple of common cmake options:
 #
 #  -DCMAKE_C_COMPILER=<command-name>
 #
-#   Specifies a C compiler name to use. The default value is `cc`.
+#   Specifies the C compiler name to use. The default value is `cc`.
 #
 #  -DCMAKE_CXX_COMPILER=<command-name>
 #
-#   Specifies a C++ compiler name to use. The default value is `c++`.
+#   Specifies the C++ compiler name to use. The default value is `c++`.
 #
 #  -DCMAKE_INSTALL_PREFIX=<directory>
 #
-#   Specifies an install target directory. The default value is `/usr/local`.
+#   Specifies the install target directory. The default value is `/usr/local`.
 #
 #  -DCMAKE_BUILD_TYPE=[Debug | Release | RelWithDebInfo | MinSizeRel]
 #
-#   Specifies a build type. The default is `Release` which is the right
+#   Specifies the build type. The default is `Release`, which is the right
 #   option unless you are debugging mold.
 #
 # An example of a cmake command line is shown below:
 #
 #   $ cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_CXX_COMPILER=g++-12 ..
 #
-# where `..` refers this directory.
+# where `..` refers to this directory.
 #
 # With cmake, you may run `cmake --install .` instead of `make install` to
 # install build artifacts to system directories. If you want to install
@@ -39,33 +39,58 @@
 # how to build mold. However, as a policy, we do not provide a way to
 # enable/disable any individual mold's feature. In other words, we do not
 # provide options like `--enable-foo` or `--disable-foo`. The motivation
-# behind it is build reproducibility. We want to guarantees that all builds
-# of the mold linker of the same version will have the exactly same set of
+# behind this is build reproducibility. We want to guarantee that all builds
+# of the mold linker of the same version will have the exact same set of
 # features and behave exactly the same.
 
-cmake_minimum_required(VERSION 3.13)
-project(mold VERSION 1.8.0)
+cmake_minimum_required(VERSION 3.14)
+project(mold VERSION 2.35.0)
 
 include(CMakeDependentOption)
+include(CheckSymbolExists)
 include(GNUInstallDirs)
 
+add_executable(mold)
+target_compile_features(mold PRIVATE cxx_std_20)
+
+if(MINGW)
+  target_link_libraries(mold PRIVATE dl)
+else()
+  target_link_libraries(mold PRIVATE ${CMAKE_DL_LIBS})
+endif()
+
 # Build mold itself using mold if -DMOLD_USE_MOLD=ON
 option(MOLD_USE_MOLD "Use mold to build mold" OFF)
 if(MOLD_USE_MOLD)
-  add_link_options(-fuse-ld=mold)
-endif()
+  target_link_options(mold PRIVATE -fuse-ld=mold -Wl,--gdb-index)
 
-add_executable(mold)
-target_compile_features(mold PRIVATE cxx_std_20)
-target_link_libraries(mold PRIVATE ${CMAKE_DL_LIBS})
+  if(CMAKE_BUILD_TYPE MATCHES "^Rel")
+    target_link_options(mold PRIVATE -Wl,--gc-sections,--icf=safe)
+  endif()
+endif()
 
 if(NOT "${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC")
   target_compile_options(mold PRIVATE
     -fno-exceptions
     -fno-unwind-tables
     -fno-asynchronous-unwind-tables
+    -ffunction-sections
+    -fdata-sections
+    -Wall
+    -Wextra
     -Wno-sign-compare
-    -Wno-unused-function)
+    -Wno-unused-function
+    -Wno-unused-parameter
+    -Wno-missing-field-initializers
+    -ggnu-pubnames)
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  target_compile_options(mold PRIVATE -D_GLIBCXX_ASSERTIONS)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+  set(OPENBSD ON)
 endif()
 
 # Build mold with -flto if -DMOLD_LTO=ON
@@ -88,35 +113,51 @@ if(MOLD_USE_TSAN)
   target_link_options(mold PRIVATE -fsanitize=thread)
 endif()
 
-# Statically-link libstdc++ and libcrypto if -DMOLD_MOSTLY_STATIC=ON.
+# Statically-link libstdc++ if -DMOLD_MOSTLY_STATIC=ON.
 #
 # This option is intended to be used by `./dist.sh` script to create a
 # mold binary that works on various Linux distros. You probably don't
 # need nor want to set this to ON.
-option(MOLD_MOSTLY_STATIC "Statically link libstdc++ and libcrypto" OFF)
+option(MOLD_MOSTLY_STATIC "Statically link libstdc++ and some other libraries" OFF)
 if(MOLD_MOSTLY_STATIC)
   target_link_options(mold PRIVATE -static-libstdc++)
-  target_link_libraries(mold PRIVATE libcrypto.a)
 endif()
 
 # Find zlib. If libz.so is not found, we compile a bundled one and
 # statically-link it to mold.
 find_package(ZLIB QUIET)
-if(ZLIB_FOUND)
+if(ZLIB_FOUND AND NOT MOLD_MOSTLY_STATIC)
   target_link_libraries(mold PRIVATE ZLIB::ZLIB)
 else()
+  set(ZLIB_BUILD_EXAMPLES OFF CACHE INTERNAL "")
   add_subdirectory(third-party/zlib EXCLUDE_FROM_ALL)
   target_include_directories(zlibstatic INTERFACE third-party/zlib
     $<TARGET_PROPERTY:zlibstatic,BINARY_DIR>)
   target_link_libraries(mold PRIVATE zlibstatic)
 endif()
 
-# Find zstd compression library. Just like zlib, if libzstd.so is not
-# found, we compile a bundled one and statically-link it to mold.
+# Find BLAKE3 cryptographic hash library. Just like zlib, if libblkae3.so
+# is not found, we compile a bundled one and statically-link it to mold.
+find_package(BLAKE3 QUIET)
+if(BLAKE3_FOUND AND NOT MOLD_MOSTLY_STATIC)
+  target_link_libraries(mold PRIVATE BLAKE3::blake3)
+else()
+  function(mold_add_blake3)
+    set(BUILD_SHARED_LIBS OFF)
+    add_subdirectory(third-party/blake3/c EXCLUDE_FROM_ALL)
+    target_link_libraries(mold PRIVATE blake3)
+    target_include_directories(mold PUBLIC third-party/blake3/c)
+  endfunction()
+
+  mold_add_blake3()
+endif()
+
+# Find zstd compression library. If zstd.h is not found, we compile a
+# bundled one and statically-link it to mold.
 include(CheckIncludeFile)
 check_include_file(zstd.h HAVE_ZSTD_H)
 
-if(HAVE_ZSTD_H)
+if(HAVE_ZSTD_H AND NOT MOLD_MOSTLY_STATIC)
   target_link_libraries(mold PRIVATE zstd)
 else()
   add_subdirectory(third-party/zstd/build/cmake EXCLUDE_FROM_ALL)
@@ -137,12 +178,10 @@ endif()
 #
 # We enable mimalloc by default for 64-bit targets. It doesn't seem to
 # be stable on 32-bit targets.
-include(CheckCXXSourceCompiles)
-check_cxx_source_compiles(
-  "static_assert(sizeof(void *) == 4); int main() {}" P32)
+cmake_dependent_option(
+  MOLD_USE_MIMALLOC "Use mimalloc" ON
+  "CMAKE_SIZEOF_VOID_P EQUAL 8; NOT APPLE; NOT ANDROID; NOT OPENBSD" OFF)
 
-cmake_dependent_option(MOLD_USE_MIMALLOC "Use mimalloc" ON
-  "NOT APPLE; NOT ANDROID; NOT P32" OFF)
 cmake_dependent_option(
   MOLD_USE_SYSTEM_MIMALLOC "Use system or vendored mimalloc" OFF
   MOLD_USE_MIMALLOC OFF)
@@ -154,7 +193,6 @@ if(MOLD_USE_MIMALLOC)
   if(MOLD_USE_SYSTEM_MIMALLOC)
     find_package(mimalloc REQUIRED)
     target_link_libraries(mold PRIVATE mimalloc)
-    target_compile_definitions(mold PRIVATE USE_SYSTEM_MIMALLOC)
   else()
     function(mold_add_mimalloc)
       set(MI_BUILD_STATIC ON CACHE INTERNAL "")
@@ -191,19 +229,18 @@ else()
   mold_add_tbb()
 endif()
 
-# Check if this is a commercial version of mold (a.k.a. "sold")
-if(EXISTS "${CMAKE_SOURCE_DIR}/LICENSE.md")
-  set(MOLD_IS_SOLD ON)
-endif()
-
 # We always use Clang to build mold on Windows. MSVC can't compile mold.
 if(WIN32)
-  if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  if(MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     message(FATAL_ERROR
       "Your compiler is not supported; install Clang from Visual Studio Installer and re-run cmake with '-T clangcl'")
   endif()
 
   target_compile_definitions(mold PRIVATE NOGDI NOMINMAX)
+  if(MINGW)
+    target_compile_definitions(mold PRIVATE _WIN32_WINNT=0xA00)
+    target_link_libraries(mold PRIVATE bcrypt)
+  endif()
 else()
   include(CheckLibraryExists)
   check_library_exists(m pow "" LIBM_FOUND)
@@ -220,12 +257,7 @@ if(NOT APPLE AND NOT WIN32)
   # Remove the default `lib` prefix
   set_target_properties(mold-wrapper PROPERTIES PREFIX "")
   target_link_libraries(mold-wrapper PRIVATE ${CMAKE_DL_LIBS})
-  target_sources(mold-wrapper PRIVATE elf/mold-wrapper.c)
-endif()
-
-if(NOT APPLE AND NOT WIN32 AND NOT MOLD_MOSTLY_STATIC)
-  find_package(OpenSSL REQUIRED COMPONENTS Crypto)
-  target_link_libraries(mold PRIVATE OpenSSL::Crypto)
+  target_sources(mold-wrapper PRIVATE src/mold-wrapper.c)
 endif()
 
 # If atomics doesn't work by default, add -latomic.
@@ -245,25 +277,28 @@ if(NOT HAVE_FULL_ATOMIC_SUPPORT)
 endif()
 
 # Add -pthread
-if(NOT APPLE AND NOT WIN32)
+if(NOT APPLE AND NOT MSVC)
   target_compile_options(mold PRIVATE -pthread)
   target_link_options(mold PRIVATE -pthread)
 endif()
 
+check_symbol_exists(madvise sys/mman.h HAVE_MADVISE)
+check_symbol_exists(uname sys/utsname.h HAVE_UNAME)
+
 # Create a .cc file containing the current git hash for `mold --version`.
 add_custom_target(git_hash
   COMMAND ${CMAKE_COMMAND}
     -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
     -DOUTPUT_FILE=${CMAKE_BINARY_DIR}/git-hash.cc
-    -P ${CMAKE_SOURCE_DIR}/update-git-hash.cmake
-  DEPENDS update-git-hash.cmake
+    -P ${CMAKE_SOURCE_DIR}/lib/update-git-hash.cmake
+  DEPENDS lib/update-git-hash.cmake
   BYPRODUCTS git-hash.cc
   VERBATIM)
 
 add_dependencies(mold git_hash)
 
 # Create config.h file
-configure_file(config.h.in config.h)
+configure_file(lib/config.h.in config.h)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 # Almost all functions are template in mold which take a target type
@@ -275,47 +310,58 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 # compiler instances. This is hacky but greatly reduces compile time
 # on a multicore machine.
 list(APPEND MOLD_ELF_TARGETS
-  X86_64 I386 ARM64 ARM32 RV32LE RV32BE RV64LE RV64BE
-  PPC32 PPC64V1 PPC64V2 S390X SPARC64 M68K SH4 ALPHA)
+  X86_64 I386 ARM64LE ARM64BE ARM32 RV32LE RV32BE RV64LE RV64BE PPC32
+  PPC64V1 PPC64V2 S390X SPARC64 M68K SH4LE SH4BE LOONGARCH32 LOONGARCH64)
 
 list(APPEND MOLD_ELF_TEMPLATE_FILES
-  elf/cmdline.cc
-  elf/dwarf.cc
-  elf/gc-sections.cc
-  elf/icf.cc
-  elf/input-files.cc
-  elf/input-sections.cc
-  elf/linker-script.cc
-  elf/lto.cc
-  elf/main.cc
-  elf/mapfile.cc
-  elf/output-chunks.cc
-  elf/passes.cc
-  elf/relocatable.cc
-  elf/subprocess.cc
-  elf/thunks.cc
+  src/arch-arm64.cc
+  src/arch-loongarch.cc
+  src/arch-riscv.cc
+  src/arch-sh4.cc
+  src/cmdline.cc
+  src/filetype.cc
+  src/gc-sections.cc
+  src/gdb-index.cc
+  src/icf.cc
+  src/input-files.cc
+  src/input-sections.cc
+  src/linker-script.cc
+  src/main.cc
+  src/mapfile.cc
+  src/output-chunks.cc
+  src/passes.cc
+  src/relocatable.cc
+  src/shrink-sections.cc
+  src/thunks.cc
+  src/tls.cc
   )
 
-list(APPEND MOLD_MACHO_TARGETS X86_64 ARM64)
+if(WIN32 AND NOT MINGW)
+  list(APPEND MOLD_ELF_TEMPLATE_FILES src/lto-win32.cc)
+else()
+  list(APPEND MOLD_ELF_TEMPLATE_FILES src/lto-unix.cc)
+endif()
 
-list(APPEND MOLD_MACHO_TEMPLATE_FILES
-  macho/cmdline.cc
-  macho/dead-strip.cc
-  macho/input-files.cc
-  macho/input-sections.cc
-  macho/lto.cc
-  macho/main.cc
-  macho/mapfile.cc
-  macho/output-chunks.cc
-  macho/tapi.cc
+if(WIN32)
+  list(APPEND MOLD_ELF_TEMPLATE_FILES
+    src/output-file-win32.cc
+    src/subprocess-win32.cc
+    )
+else()
+  list(APPEND MOLD_ELF_TEMPLATE_FILES
+    src/output-file-unix.cc
+    src/subprocess-unix.cc
   )
+endif()
 
 function(mold_instantiate_templates SOURCE TARGET)
   set(PATH ${CMAKE_BINARY_DIR}/${SOURCE}.${TARGET}.cc)
-  file(WRITE ${PATH} "#define MOLD_${TARGET} 1
+  if(NOT EXISTS ${PATH})
+    file(WRITE ${PATH} "#define MOLD_${TARGET} 1
 #define MOLD_TARGET ${TARGET}
 #include \"${CMAKE_SOURCE_DIR}/${SOURCE}\"
 ")
+  endif()
   target_sources(mold PRIVATE ${PATH})
 endfunction()
 
@@ -325,73 +371,52 @@ foreach (SOURCE IN LISTS MOLD_ELF_TEMPLATE_FILES)
   endforeach()
 endforeach()
 
-if(MOLD_IS_SOLD)
-  foreach (SOURCE IN LISTS MOLD_MACHO_TEMPLATE_FILES)
-    foreach(TARGET IN LISTS MOLD_MACHO_TARGETS)
-      mold_instantiate_templates(${SOURCE} ${TARGET})
-    endforeach()
-  endforeach()
-endif()
-
 # Add other non-template source files.
 target_sources(mold PRIVATE
-  compress.cc
-  demangle.cc
-  elf/arch-alpha.cc
-  elf/arch-arm32.cc
-  elf/arch-arm64.cc
-  elf/arch-i386.cc
-  elf/arch-m68k.cc
-  elf/arch-ppc32.cc
-  elf/arch-ppc64v1.cc
-  elf/arch-ppc64v2.cc
-  elf/arch-riscv.cc
-  elf/arch-s390x.cc
-  elf/arch-sh4.cc
-  elf/arch-sparc64.cc
-  elf/arch-x86-64.cc
-  elf/elf.cc
-  filepath.cc
   git-hash.cc
-  glob.cc
-  hyperloglog.cc
-  main.cc
-  multi-glob.cc
-  perf.cc
-  tar.cc
+  lib/compress.cc
+  lib/crc32.cc
+  lib/demangle.cc
+  lib/filepath.cc
+  lib/glob.cc
+  lib/hyperloglog.cc
+  lib/mimalloc.cc
+  lib/multi-glob.cc
+  lib/perf.cc
+  lib/random.cc
+  lib/tar.cc
+  src/arch-arm32.cc
+  src/arch-i386.cc
+  src/arch-m68k.cc
+  src/arch-ppc32.cc
+  src/arch-ppc64v1.cc
+  src/arch-ppc64v2.cc
+  src/arch-s390x.cc
+  src/arch-sparc64.cc
+  src/arch-x86-64.cc
+  src/config.cc
+  src/elf.cc
   third-party/rust-demangle/rust-demangle.c
-  uuid.cc
   )
 
-if(MOLD_IS_SOLD)
+if(WIN32)
   target_sources(mold PRIVATE
-    macho/arch-arm64.cc
-    macho/arch-x86-64.cc
-    macho/yaml.cc
+    lib/jobs-win32.cc
+    lib/mapped-file-win32.cc
+    lib/signal-win32.cc
+    )
+else()
+  target_sources(mold PRIVATE
+    lib/jobs-unix.cc
+    lib/mapped-file-unix.cc
+    lib/signal-unix.cc
     )
-endif()
-
-# Add frequently included header files for pre-compiling.
-# target_precompile_headers is supported by CMake 3.16.0 or newer.
-if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16.0")
-  if(MOLD_IS_SOLD)
-    target_precompile_headers(mold PRIVATE
-      "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/elf/mold.h>"
-      "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/macho/mold.h>")
-  else()
-    target_precompile_headers(mold PRIVATE
-      "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/elf/mold.h>")
-  endif()
-
-  # ccache needs this flag along with `sloppiness = pch_defines,time_macros`
-  # to enable caching
-  target_compile_options(mold PRIVATE -fpch-preprocess)
 endif()
 
 include(CTest)
 
 if(BUILD_TESTING)
-  # Create the ld and ld64 symlinks required for testing
+  # Create the ld symlinks required for testing
   if(NOT WIN32)
     add_custom_command(
       TARGET mold POST_BUILD
@@ -399,30 +424,17 @@ if(BUILD_TESTING)
       BYPRODUCTS ld
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       VERBATIM)
-
-    if(MOLD_IS_SOLD)
-      add_custom_command(
-        TARGET mold POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E create_symlink mold ld64
-        BYPRODUCTS ld64
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-        VERBATIM)
-    endif()
   endif()
 
-  if(${APPLE})
-    if(MOLD_IS_SOLD)
-      add_subdirectory(test/macho)
-    endif()
-  elseif(${UNIX})
-    add_subdirectory(test/elf)
+  if(${UNIX})
+    add_subdirectory(test)
   endif()
 endif()
 
 if(NOT CMAKE_SKIP_INSTALL_RULES)
   install(TARGETS mold RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-  install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
   install(FILES docs/mold.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1/)
+  install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
 
   function(mold_install_relative_symlink OLD NEW)
     install(CODE "
@@ -436,19 +448,10 @@ if(NOT CMAKE_SKIP_INSTALL_RULES)
       file(CREATE_LINK \${OLD_REL} \$ENV{DESTDIR}\${NEW_ABS} SYMBOLIC)")
   endfunction()
 
-  mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
-    ${CMAKE_INSTALL_LIBEXECDIR}/mold/ld)
-  mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
-    ${CMAKE_INSTALL_BINDIR}/ld.mold)
+  mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold${CMAKE_EXECUTABLE_SUFFIX}
+    ${CMAKE_INSTALL_LIBEXECDIR}/mold/ld${CMAKE_EXECUTABLE_SUFFIX})
+  mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold${CMAKE_EXECUTABLE_SUFFIX}
+    ${CMAKE_INSTALL_BINDIR}/ld.mold${CMAKE_EXECUTABLE_SUFFIX})
   mold_install_relative_symlink(${CMAKE_INSTALL_MANDIR}/man1/mold.1
     ${CMAKE_INSTALL_MANDIR}/man1/ld.mold.1)
-
-  if(MOLD_IS_SOLD)
-    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
-      ${CMAKE_INSTALL_BINDIR}/ld64.mold)
-    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
-      ${CMAKE_INSTALL_BINDIR}/ld.sold)
-    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
-      ${CMAKE_INSTALL_BINDIR}/ld64.sold)
-  endif()
 endif()

CMakeSettings.json

@@ -1,15 +0,0 @@
-{
-  "configurations": [
-    {
-      "name": "x64-Debug",
-      "generator": "Ninja",
-      "configurationType": "Debug",
-      "inheritEnvironments": [ "clang_cl_x64" ],
-      "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "",
-      "buildCommandArgs": "",
-      "ctestCommandArgs": ""
-    }
-  ]
-}

CONTRIBUTING.md

@@ -1,44 +0,0 @@
-# Contributing to mold
-
-We request all patches to mold to be released under the dual license
-of the GNU AGPLv3 and the MIT license. Please read the following and
-sign-off your patch as an indication of agreement.
-
-> ## Developer's Certificate of Origin
->
-> By making a contribution to this project, I certify that:
->
->  1. The contribution was created in whole or in part by me and I
->     have the right to submit it under the Dual License of the GNU
->     AGPLv3 and the MIT license; or
->
->  2. The contribution is based upon previous work that, to the best
->     of my knowledge, is covered under the the Dual License and I
->     have the right under the Dual License to submit that work with
->     modifications, whether created in whole or in part by me, under
->     the Dual License (unless I am permitted to submit under
->     different licenses), as indicated in the file; or
->
->  3. The contribution was provided directly to me by some other
->     person who certified (1), (2) or (3) and I have not modified it.
->
->  4. I understand and agree that this project and the contribution
->     are public and that a record of the contribution (including all
->     personal information I submit with it, including my sign-off) is
->     maintained indefinitely and may be redistributed consistent with
->     this project or the open source license(s) involved.
-
-If you agree, you just add a line saying:
-
-```
-Signed-off-by: Random J Developer <[email protected]>
-```
-
-using your real name (sorry, no pseudonyms or anonymous contributions.)
-This will be done for you automatically if you use ``git commit -s``.
-Reverts should also include "Signed-off-by". ``git revert -s`` does that
-for you.
-
-We assume that any contribution that's 10 lines or less does not meet
-the threshold of originality and therefore copyright does not apply.
-You don't need to add a "Signed-off-by" line to such small patches.

Dockerfile

@@ -1,23 +0,0 @@
-# This dockerfile creates a reproducible build environment for mold.
-#
-# $ docker buildx create --use
-# $ docker buildx build --platform x86_64,aarch64,arm,ppc64le,s390x -t rui314/mold-builder:latest --push .
-
-FROM ubuntu:18.04
-ENV TZ=Europe/London
-RUN apt-get update && \
-  apt-get install -y --no-install-recommends software-properties-common && \
-  add-apt-repository -y ppa:ubuntu-toolchain-r/test && \
-  apt-get update && \
-  apt-get install -y --no-install-recommends build-essential wget libstdc++-11-dev zlib1g-dev gcc-10 g++-10 python3 && \
-  \
-  mkdir /openssl && cd /openssl && \
-  wget -O- -q https://www.openssl.org/source/openssl-3.0.7.tar.gz | tar --strip-components=1 -xzf - && \
-  ./Configure --prefix=/usr/local --libdir=lib && \
-  make -j$(nproc) && \
-  make -j$(nproc) install && \
-  ldconfig && \
-  mkdir /cmake && cd /cmake && \
-  wget -O- -q https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2.tar.gz | tar --strip-components=1 -xzf - && \
-  ./bootstrap --parallel=$(nproc) && make -j$(nproc) && make -j$(nproc) install && \
-  rm -rf /var/lib/apt/lists/* /cmake /openssl

README.md

@@ -1,133 +1,117 @@
 # mold: A Modern Linker
 
-[![CI](https://github.com/rui314/mold/actions/workflows/ci.yml/badge.svg)](https://github.com/rui314/mold/actions/workflows/ci.yml)
-[![build result](https://build.opensuse.org/projects/home:marxin:mold/packages/mold/badge.svg?type=default)](https://build.opensuse.org/package/show/home:marxin:mold/mold)
+mold is a faster drop-in replacement for existing Unix linkers. It is several
+times quicker than the LLVM lld linker, the second-fastest open-source linker,
+which I initially developed a few years ago. mold aims to enhance developer
+productivity by minimizing build time, particularly in rapid
+debug-edit-rebuild cycles.
 
-<i>This is a repo of a free, AGPL-licensed version of the linker.
-If you are looking for a commercial, non-AGPL version of the same linker,
-please visit the
-[repo of the sold linker](https://github.com/bluewhalesystems/sold).</i>
+Here is a performance comparison of GNU ld, GNU gold, LLVM lld, and
+mold when linking final debuginfo-enabled executables for major large
+programs on a simulated 16-core, 32-thread machine.
 
-mold is a faster drop-in replacement for existing Unix linkers.
-It is several times faster than the LLVM lld linker, the second-fastest
-open-source linker which I originally created a few years ago.
-mold is designed to increase developer productivity by reducing
-build time, especially in rapid debug-edit-rebuild cycles.
+![Link speed comparison](docs/chart.svg)
 
-Here is a performance comparison of GNU gold, LLVM lld, and mold for
-linking final debuginfo-enabled executables of major large programs
-on a simulated 8-core 16-threads machine.
+| Program (linker output size)  | GNU ld | GNU gold | LLVM lld | mold
+|-------------------------------|--------|----------|----------|------
+| MySQL 8.3 (0.47 GiB)          | 10.84s | 7.47s    | 1.64s    | 0.46s
+| Clang 19 (1.56 GiB)           | 42.07s | 33.13s   | 5.20s    | 1.35s
+| Chromium 124 (1.35 GiB)       | N/A    | 27.40s   | 6.10s    | 1.52s
 
-![Link speed comparison](docs/comparison.png)
-
-| Program (linker output size)  | GNU gold | LLVM lld | mold
-|-------------------------------|----------|----------|--------
-| Chrome 96 (1.89 GiB)          | 53.86s   | 11.74s   | 2.21s
-| Clang 13 (3.18 GiB)           | 64.12s   | 5.82s    | 2.90s
-| Firefox 89 libxul (1.64 GiB)  | 32.95s   | 6.80s    | 1.42s
-
-mold is so fast that it is only 2x _slower_ than `cp` on the same
-machine. Feel free to [file a bug](https://github.com/rui314/mold/issues)
-if you find mold is not faster than other linkers.
+mold is so fast that it is only 2x _slower_ than the `cp` command on the same
+machine. If you find that mold is not faster than other linkers, feel
+free to [file a bug report](https://github.com/rui314/mold/issues).
 
 mold supports x86-64, i386, ARM64, ARM32, 64-bit/32-bit little/big-endian
-RISC-V, 64-bit big-endian PowerPC ELFv1, 64-bit little-endian PowerPC ELFv2,
-s390x, SPARC64 and m68k.
+RISC-V, 32-bit PowerPC, 64-bit big-endian PowerPC ELFv1, 64-bit little-endian
+PowerPC ELFv2, s390x, 64-bit/32-bit LoongArch, SPARC64, m68k, and SH-4.
 
-mold/macOS is commercial software. For mold/macOS, please visit
-https://github.com/bluewhalesystems/sold.
+## Why does linking speed matter?
 
-## Why does the speed of linking matter?
+If you are using a compiled language such as C, C++, or Rust, a build consists
+of two phases. In the first phase, a compiler compiles source files into
+object files (`.o` files). In the second phase, a linker takes all object
+files and combines them into a single executable or shared library file.
 
-If you are using a compiled language such as C, C++ or Rust, a build
-consists of two phases. In the first phase, a compiler compiles
-source files into object files (`.o` files). In the second phase,
-a linker takes all object files to combine them into a single executable
-or a shared library file.
+The second phase can be time-consuming if your build output is large. mold can
+speed up this process, saving you time and preventing distractions while
+waiting for a lengthy build to finish. The difference is most noticeable
+during rapid debug-edit-rebuild cycles.
 
-The second phase takes a long time if your build output is large.
-mold can make it faster, saving your time and keeping you from being
-distracted while waiting for a long build to finish. The difference is
-most noticeable when you are in rapid debug-edit-rebuild cycles.
+## Installation
 
-## Install
-
-Binary packages for the following systems are currently available.
+Binary packages for the following systems are currently available:
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/mold.svg)](https://repology.org/project/mold/versions)
 
-## How to build
+## How to Build
 
-mold is written in C++20, so if you build mold yourself, you need a
-recent version of a C++ compiler and a C++ standard library. GCC 10.2
-or Clang 12.0.0 (or later) as well as libstdc++ 10 or libc++ 7 (or
-later) are recommended.
+mold is written in C++20, so if you build mold yourself, you will need a
+recent version of a C++ compiler and a C++ standard library. We recommend GCC
+10.2 or Clang 12.0.0 (or later) and libstdc++ 10 or libc++ 7 (or later).
 
-### Install dependencies
+### Install Dependencies
 
 To install build dependencies, run `./install-build-deps.sh` in this
-directory. It recognizes your Linux distribution and tries to install
-necessary packages. You may want to run it as root.
+directory. It will detect your Linux distribution and attempt to install the
+necessary packages. You may need to run it as root.
 
 ### Compile mold
 
 ```shell
-git clone https://github.com/rui314/mold.git
-mkdir mold/build
-cd mold/build
-git checkout v1.8.0
-../install-build-deps.sh
-cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=c++ ..
-cmake --build . -j $(nproc)
-sudo cmake --install .
+git clone --branch stable https://github.com/rui314/mold.git
+cd mold
+./install-build-deps.sh
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=c++ -B build
+cmake --build build -j$(nproc)
+sudo cmake --build build --target install
 ```
 
-You may need to pass a C++20 compiler command name to `cmake`.
-In the above case, `c++` is passed. If it doesn't work for you,
-try a specific version of a compiler such as `g++-10` or `clang++-12`.
+You might need to pass a C++20 compiler command name to `cmake`. In the
+example above, `c++` is passed. If that doesn't work for you, try a specific
+version of a compiler, such as `g++-10` or `clang++-12`.
 
-By default, `mold` is installed to `/usr/local/bin`. You can change
-that by passing `-DCMAKE_INSTALL_PREFIX=<directory>`. For other cmake
-options, see the comments in `CMakeLists.txt`.
+By default, `mold` is installed to `/usr/local/bin`. You can change the
+installation location by passing `-DCMAKE_INSTALL_PREFIX=<directory>`.
+For other cmake options, see the comments in `CMakeLists.txt`.
 
-If you don't use a recent enough Linux distribution, or if for any reason
-`cmake` in the above commands doesn't work for you, you can use Docker to
-build it in a Docker environment. To do so, just run `./dist.sh` in this
-directory instead of `cmake`. The shell script pulls a Docker image,
-builds mold and auxiliary files inside it, and packs them into a
-single tar file `mold-$version-$arch-linux.tar.gz`.  You can extract
-the tar file anywhere and use `mold` executable in it.
+If you are not using a recent enough Linux distribution, or if `cmake` does
+not work for you for any reason, you can use Docker to build mold in a Docker
+environment. To do so, run `./dist.sh` in this directory instead of using
+`cmake`. The shell script will pull a Docker image, build mold and auxiliary
+files inside it, and package them into a single tar file named
+`mold-$version-$arch-linux.tar.gz`. You can extract the tar file anywhere and
+use the mold executable within it.
 
 ## How to use
 
 <details><summary>A classic way to use mold</summary>
 
-On Unix, the linker command (which is usually `/usr/bin/ld`) is
-invoked indirectly by the compiler driver (which is usually `cc`,
-`gcc` or `clang`), which is typically in turn indirectly invoked by
-`make` or some other build system command.
+On Unix, the linker command (usually `/usr/bin/ld`) is indirectly invoked by
+the compiler driver (typically `cc`, `gcc`, or `clang`), which is in turn
+indirectly invoked by `make` or other build system commands.
 
-If you can specify an additional command line option to your compiler
-driver by modifying build system's config files, add one of the
-following flags to use `mold` instead of `/usr/bin/ld`:
+If you can specify an additional command line option for your compiler driver
+by modifying the build system's config files, add one of the following flags
+to use mold instead of `/usr/bin/ld`:
 
-- Clang: pass `-fuse-ld=mold`
+- For Clang: pass `-fuse-ld=mold`
 
-- GCC 12.1.0 or later: pass `-fuse-ld=mold`
+- For GCC 12.1.0 or later: pass `-fuse-ld=mold`
 
-- GCC before 12.1.0: `-fuse-ld` does not accept `mold` as a valid
-  argument, so you need to use `-B` option instead. `-B` is an option
-  to tell GCC where to look for external commands such as `ld`.
+- For GCC before 12.1.0: the `-fuse-ld` option does not accept `mold` as a
+  valid argument, so you need to use the `-B` option instead. The `-B` option
+  tells GCC where to look for external commands like `ld`.
 
-  If you have installed mold with `make install`, there should be a
-  directory named `/usr/libexec/mold` (or `/usr/local/libexec/mold`,
-  depending on your `$PREFIX`), and `ld` command should be there. The
-  `ld` is actually a symlink to `mold`. So, all you need is to pass
-  `-B/usr/libexec/mold` (or `-B/usr/local/libexec/mold`) to GCC.
+  If you have installed mold with `make install`, there should be a directory
+  named `/usr/libexec/mold` (or `/usr/local/libexec/mold`, depending on your
+  `$PREFIX`), and the `ld` command should be there. The `ld` is actually a
+  symlink to `mold`. So, all you need is to pass `-B/usr/libexec/mold` (or
+  `-B/usr/local/libexec/mold`) to GCC.
 
 If you haven't installed `ld.mold` to any `$PATH`, you can still pass
-`-fuse-ld=/absolute/path/to/mold` to clang to use mold. GCC does not
-take an absolute path as an argument for `-fuse-ld` though.
+`-fuse-ld=/absolute/path/to/mold` to clang to use mold. However, GCC does not
+accept an absolute path as an argument for `-fuse-ld`.
 
 </details>
 
@@ -141,32 +125,19 @@ linker = "clang"
 rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold"]
 ```
 
-where `/path/to/mold` is an absolute path to `mold` exectuable. In the
-above example, we use `clang` as a linker driver as it can always take
-the `-fuse-ld` option. If your GCC is recent enough to recognize the
-option, you may be able to remove the `linker = "clang"` line.
+where `/path/to/mold` is an absolute path to the mold executable. In the
+example above, we use `clang` as a linker driver since it always accepts the
+`-fuse-ld` option. If your GCC is recent enough to recognize the option, you
+may be able to remove the `linker = "clang"` line.
 
 ```toml
 [target.x86_64-unknown-linux-gnu]
-rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold"]
+rustflags = ["-C", "link-arg=-fuse-ld=mold"]
 ```
 
-If you want to use mold for all projects, put the above snippet to
+If you want to use mold for all projects, add the above snippet to
 `~/.cargo/config.toml`.
 
-If you are using macOS, you can modify `config.toml` in a similar manner.
-Here is an example with `mold` installed via [Homebrew](https://brew.sh).
-
-```toml
-[target.x86_64-apple-darwin]
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=mold"]
-
-[target.aarch64-apple-darwin]
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=mold"]
-```
-
 </details>
 
 <details><summary>If you are using Nim</summary>
@@ -178,67 +149,46 @@ when findExe("mold").len > 0 and defined(linux):
   switch("passL", "-fuse-ld=mold")
 ```
 
-where `mold` must be included in the PATH environment variable. In this example
-The above example uses `gcc` as the linker driver.
-Use the `fuse-ld` option. If your GCC is recent enough to recognize this option.
+where `mold` must be included in the `PATH` environment variable. In this
+example, `gcc` is used as the linker driver. Use the `-fuse-ld` option if your
+GCC is recent enough to recognize this option.
 
-If you want to use mold for all projects, put the above snippet to `~/.config/config.nims`.
-
-If you are using macOS, you can modify config.nims in a similar manner. Here is an example with mold installed via Homebrew.
-
-```nim
-when findExe("ld64.mold").len > 0 and defined(macosx):
-  switch("passL", "-fuse-ld=ld64.mold")
-```
+If you want to use mold for all projects, add the above snippet to
+`~/.config/config.nims`.
 
 </details>
 
 <details><summary>mold -run</summary>
 
-It is sometimes very hard to pass an appropriate command line option
-to `cc` to specify an alternative linker.  To deal with the situation,
-mold has a feature to intercept all invocations of `ld`, `ld.lld` or
-`ld.gold` and redirect it to itself. To use the feature, run `make`
-(or another build command) as a subcommand of mold as follows:
+It is sometimes very hard to pass an appropriate command line option to `cc`
+to specify an alternative linker. To address this situation, mold has a
+feature to intercept all invocations of `ld`, `ld.bfd`, `ld.lld`, or `ld.gold`
+and redirect them to itself. To use this feature, run `make` (or another build
+command) as a subcommand of mold as follows:
 
 ```shell
 mold -run make <make-options-if-any>
 ```
 
-Internally, mold invokes a given command with `LD_PRELOAD` environment
-variable set to its companion shared object file. The shared object
-file intercepts all function calls to `exec(3)`-family functions to
-replace `argv[0]` with `mold` if it is `ld`, `ld.gold` or `ld.lld`.
-
-</details>
-
-<details><summary>On macOS</summary>
-
-mold/macOS is available as an alpha version. It can be used to build not
-only macOS apps but also iOS apps because their binary formats are the same.
-
-The command name of mold/macOS is `ld64.mold`. If you build mold on macOS,
-it still produces `mold` and `ld.mold`, but these executables are useful
-only for cross compilation (i.e. building Linux apps on macOS.)
-
-If you find any issue with mold/macOS, please file it to
-<a href=https://github.com/rui314/mold/issues>our GitHub Issues</a>.
+Internally, mold invokes a given command with the `LD_PRELOAD` environment
+variable set to its companion shared object file. The shared object file
+intercepts all function calls to `exec(3)`-family functions to replace
+`argv[0]` with `mold` if it is `ld`, `ld.bf`, `ld.gold`, or `ld.lld`.
 
 </details>
 
 <details><summary>GitHub Actions</summary>
 
-You can use our <a href=https://github.com/rui314/setup-mold>setup-mold</a>
-GitHub Action to speed up GitHub-hosted continuous build. GitHub Actions
-runs on a two-core machine, but mold is still significantly faster than
-the default GNU linker there especially when a program being linked is
-large.
+You can use our [setup-mold](https://github.com/rui314/setup-mold) GitHub
+Action to speed up GitHub-hosted continuous builds. Although GitHub Actions
+run on a 4 core machine, mold is still significantly faster than the default
+GNU linker, especially when linking large programs.
 
 </details>
 
 <details><summary>Verify that you are using mold</summary>
 
-mold leaves its identification string in `.comment` section in an output
+mold leaves its identification string in the `.comment` section of an output
 file. You can print it out to verify that you are actually using mold.
 
 ```shell
@@ -249,75 +199,68 @@ String dump of section '.comment':
   [    2b]  mold 9a1679b47d9b22012ec7dfbda97c8983956716f7
 ```
 
-If `mold` is in `.comment`, the file is created by mold.
+If `mold` is present in the `.comment` section, the file was created by mold.
 
 </details>
 
 <details><summary>Online manual</summary>
 
-Since mold is a drop-in replacement, you should be able to use it
-without reading its manual. But just in case you need it, it's available
-online at <a href=https://rui314.github.io/mold.html>here</a>.
-You can also read the same manual by `man mold`.
+Since mold is a drop-in replacement, you should be able to use it without
+reading its manual. However, if you need it, [mold's man page](docs/mold.md)
+is available online. You can read the same manual by running `man mold`.
 
 </details>
 
 ## Why is mold so fast?
 
-One reason is because it simply uses faster algorithms and efficient
-data structures than other linkers do. The other reason is that the
-new linker is highly parallelized.
+One reason is that it utilizes faster algorithms and more efficient data
+structures compared to other linkers. Another reason is that mold is highly
+parallelized.
 
-Here is a side-by-side comparison of per-core CPU usage of lld (left)
-and mold (right). They are linking the same program, Chromium
-executable.
+Here is a side-by-side comparison of per-core CPU usage for lld (left) and
+mold (right), linking the same program, a Chromium executable.
 
 ![CPU usage comparison in htop animation](docs/htop.gif)
 
-As you can see, mold uses all available cores throughout its execution
-and finishes quickly. On the other hand, lld failed to use available
-cores most of the time. In this demo, the maximum parallelism is
-artificially capped to 16 so that the bars fit in the GIF.
+As you can see, mold uses all available cores throughout its execution and
+finishes quickly. In contrast, lld fails to utilize available cores most of
+the time. In this demo, the maximum parallelism is artificially capped at 16,
+so that the bars fit in the GIF.
 
-For details, please read [design notes](docs/design.md).
-
-## License
-
-mold is available under AGPL. Note that that does not mean that you
-have to license your program under AGPL if you use mold to link your
-program. An output of the mold linker is a derived work of the object
-files and libraries you pass to the linker but not a derived work of
-the mold linker itself.
-
-Besides that, you can also buy a commercial, non-AGPL license with
-technical support from our company, Blue Whale Systems PTE LTD. If you
-are a big company, please consider obtaining it before making hundreds
-or thousands of developers of your company to depend on mold. mold is
-mostly a single-person open-source project, and just like other
-open-source projects, we are not legally obligated to keep maintaining
-it. A legally-binding commercial license contract addresses the
-concern. By purchasing a license, you are guaranteed that mold will be
-maintained for you. Please [contact us](mailto:[email protected])
-for a commercial license inquiry.
+For details, please see the [design notes](docs/design.md).
 
 ## Sponsors
 
-We accept donations via [GitHub Sponsors](https://github.com/sponsors/rui314)
-and [OpenCollective](https://opencollective.com/mold-linker).
-We thank you to everybody who sponsors our project. In particular,
-we'd like to acknowledge the following people and organizations who
-have sponsored $128/month or more:
+It is taken for granted nowadays that compiler toolchains can be easily
+installed and used for free, and people may not think too much about the
+individuals behind these "free tools". mold supports many projects, but it
+is essentially a one-person project. This situation is similar to the one
+depicted in the following xkcd illustration.
+
+[![xkcd 2347](https://imgs.xkcd.com/comics/dependency.png)](https://xkcd.com/2347)
+
+If you think that the "Nebraska guy" should be rewarded, please consider
+becoming our [GitHub sponsor](https://github.com/sponsors/rui314)!
+
+We thank everyone who sponsors our project. In particular, we'd like to acknowledge
+the following people and organizations who have sponsored $128/month or more:
 
 ### Corporate sponsors
 
-<a href="https://mercury.com/"><img src="docs/mercury-logo.png" align=center height=120 width=400 alt=Mercury></a>
+<a href="https://mercury.com"><img src="docs/mercury-logo.png" align=center height=120 width=400 alt=Mercury></a>
 
-- [Uber](https://uber.com)
+<a href="https://cybozu-global.com"><img src="docs/cyboze-logo.png" align=center height=120 width=133 alt=Cybozu></a>
+
+<a href="https://www.emergetools.com"><img src="docs/emerge-tools-logo.png" align=center height=120 width=240 alt="Emerge Tools"></a><br>
+
+- [G-Research](https://www.gresearch.co.uk)
 - [Signal Slot Inc.](https://github.com/signal-slot)
+- [GlareDB](https://github.com/GlareDB)
 
 ### Individual sponsors
 
-- [300baud](https://github.com/300baud)
-- [Johan Andersson](https://github.com/repi)
 - [Wei Wu](https://github.com/lazyparser)
 - [kyle-elliott](https://github.com/kyle-elliott)
+- [Bryant Biggs](https://github.com/bryantbiggs)
+- [kraptor23](https://github.com/kraptor23)
+- [Jinkyu Yi](https://github.com/jincreator)

cmdline.h

@@ -1,90 +0,0 @@
-#pragma once
-
-#include "mold.h"
-
-namespace mold {
-
-template <typename C>
-std::vector<std::string_view>
-read_response_file(C &ctx, std::string_view path) {
-  std::vector<std::string_view> vec;
-  MappedFile<C> *mf = MappedFile<C>::must_open(ctx, std::string(path));
-  u8 *data = mf->data;
-
-  auto read_quoted = [&](i64 i, char quote) {
-    std::string buf;
-    while (i < mf->size && data[i] != quote) {
-      if (data[i] == '\\') {
-        buf.append(1, data[i + 1]);
-        i += 2;
-      } else {
-        buf.append(1, data[i++]);
-      }
-    }
-    if (i >= mf->size)
-      Fatal(ctx) << path << ": premature end of input";
-    vec.push_back(save_string(ctx, buf));
-    return i + 1;
-  };
-
-  auto read_unquoted = [&](i64 i) {
-    std::string buf;
-
-    while (i < mf->size) {
-      if (data[i] == '\\' && i + 1 < mf->size) {
-        buf.append(1, data[i + 1]);
-        i += 2;
-        continue;
-      }
-
-      if (!isspace(data[i])) {
-        buf.append(1, data[i++]);
-        continue;
-      }
-
-      break;
-    }
-
-    vec.push_back(save_string(ctx, buf));
-    return i;
-  };
-
-  for (i64 i = 0; i < mf->size;) {
-    if (isspace(data[i]))
-      i++;
-    else if (data[i] == '\'')
-      i = read_quoted(i + 1, '\'');
-    else if (data[i] == '\"')
-      i = read_quoted(i + 1, '\"');
-    else
-      i = read_unquoted(i);
-  }
-  return vec;
-}
-
-// Replace "@path/to/some/text/file" with its file contents.
-template <typename C>
-std::vector<std::string_view> expand_response_files(C &ctx, char **argv) {
-  std::vector<std::string_view> vec;
-  for (i64 i = 0; argv[i]; i++) {
-    if (argv[i][0] == '@')
-      append(vec, read_response_file(ctx, argv[i] + 1));
-    else
-      vec.push_back(argv[i]);
-  }
-  return vec;
-}
-
-static inline std::string_view string_trim(std::string_view str) {
-  size_t pos = str.find_first_not_of(" \t");
-  if (pos == str.npos)
-    return "";
-  str = str.substr(pos);
-
-  pos = str.find_last_not_of(" \t");
-  if (pos == str.npos)
-    return str;
-  return str.substr(0, pos + 1);
-}
-
-} // namespace mold

config.h.in

@@ -1,3 +0,0 @@
-#define MOLD_VERSION "@mold_VERSION@"
-#define MOLD_LIBDIR "@CMAKE_INSTALL_FULL_LIBDIR@"
-#cmakedefine01 MOLD_IS_SOLD

demangle.cc

@@ -1,51 +0,0 @@
-#include "mold.h"
-
-#include <cstdlib>
-
-#ifndef _WIN32
-#include <cxxabi.h>
-#endif
-
-#include "third-party/rust-demangle/rust-demangle.h"
-
-namespace mold {
-
-std::string_view demangle(std::string_view name) {
-  static thread_local char *p;
-  if (p)
-    free(p);
-
-  // Try to demangle as a Rust symbol. Since legacy-style Rust symbols
-  // are also valid as a C++ mangled name, we need to call this before
-  // cpp_demangle.
-  p = rust_demangle(std::string(name).c_str(), 0);
-  if (p)
-    return p;
-
-  // Try to demangle as a C++ symbol.
-  if (std::optional<std::string_view> s = cpp_demangle(name))
-    return *s;
-  return name;
-}
-
-std::optional<std::string_view> cpp_demangle(std::string_view name) {
-  static thread_local char *buf;
-  static thread_local size_t buflen;
-
-  // TODO(cwasser): Actually demangle Symbols on Windows using e.g.
-  // `UnDecorateSymbolName` from Dbghelp, maybe even Itanium symbols?
-#ifndef _WIN32
-  if (name.starts_with("_Z")) {
-    int status;
-    char *p = abi::__cxa_demangle(std::string(name).c_str(), buf, &buflen, &status);
-    if (status == 0) {
-      buf = p;
-      return p;
-    }
-  }
-#endif
-
-  return {};
-}
-
-} // namespace mold

dist.sh

@@ -1,33 +1,205 @@
 #!/bin/bash
-# This script creates a mold binary distribution. The output is
-# written in this directory as `mold-$version-$arch-linux.tar.gz`
-# (e.g. `mold-1.0.3-x86_64-linux.tar.gz`).
 #
-# The mold executable created by this script is statically-linked to
-# libstdc++ and libcrypto but dynamically-linked to libc, libm, libz
-# and librt, as they almost always exist on any Linux systems.
+# This script creates a mold binary distribution. The output is written in
+# this directory as `mold-$version-$arch-linux.tar.gz` (e.g.,
+# `mold-1.0.3-x86_64-linux.tar.gz`).
+#
+# The mold executable created by this script is statically linked to
+# libstdc++ but dynamically linked to libc, libm, libz, and librt, as
+# these libraries almost always exist on any Linux system. We can't
+# statically link libc because doing so would disable dlopen(), which is
+# necessary to open the LTO linker plugin.
+#
+# This script aims to produce reproducible outputs. That means if you run
+# the script twice on the same git commit, it should produce bit-by-bit
+# identical binary files. This property is crucial as a countermeasure
+# against supply chain attacks. With this, you can verify that the binary
+# files distributed on the GitHub release pages are created from the
+# commit with release tags by rebuilding the binaries yourself.
+#
+# Debian provides snapshot.debian.org to host all historical binary
+# packages. We use it to construct Docker images pinned to a
+# particular timestamp.
+#
+# We aim to use a reasonably old Debian version because we'll dynamically
+# link glibc to mold, and a binary linked against a newer version of glibc
+# won't work on a system with an older version of glibc.
+#
+# We want to build mold with Clang rather than GCC because mold's
+# Identical Code Folding works best with the LLVM address significance
+# table (.llvm_addrsig). Building a release binary with GCC yields a
+# slightly larger binary than Clang's.
+#
+# We need a recent version of Clang to build mold. If it's not available
+# via apt-get, we'll build it ourselves.
+#
+# You may need to run the following command to use Docker with Qemu:
+#
+#  $ docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
 
-if [ $# -ne 1 ]; then
-  echo "Usage: $0 [ x86_64 | aarch64 | arm | ppc64le | s390x ]"
+set -e -x
+cd "$(dirname $0)"
+
+usage() {
+  echo "Usage: $0 [ x86_64 | aarch64 | arm | riscv64 | ppc64le | s390x ]"
   exit 1
+}
+
+case $# in
+0)
+  arch=$(uname -m)
+  if [ $arch = arm64 ]; then
+    arch=aarch64
+  elif [[ $arch = arm* ]]; then
+    arch=arm
+  fi
+  ;;
+1)
+  arch="$1"
+  ;;
+*)
+  usage
+esac
+
+echo "$arch" | grep -Eq '^(x86_64|aarch64|arm|riscv64|ppc64le|s390x)$' || usage
+
+version=$(sed -n 's/^project(mold VERSION \(.*\))/\1/p' CMakeLists.txt)
+dest=mold-$version-$arch-linux
+
+if [ "$GITHUB_REPOSITORY" = '' ]; then
+  image=mold-builder-$arch
+  docker_build="docker build --platform linux/$arch -t $image -"
+else
+  # If this script is running on GitHub Actions, we want to cache
+  # the created Docker image in GitHub's Docker repostiory.
+  image=ghcr.io/$GITHUB_REPOSITORY/mold-builder-$arch
+  docker_build="docker buildx build --platform linux/$arch -t $image --push --cache-to type=inline --cache-from type=registry,ref=ghcr.io/$GITHUB_REPOSITORY/mold-builder-$arch -"
 fi
 
-arch=$1
-echo $arch | grep -Eq '^(x86_64|aarch64|arm|ppc64le|s390x)$' || \
-  { echo "Error: no docker image for $arch"; exit 1; }
+# Create a Docker image.
+case $arch in
+x86_64)
+  # Debian 8 (Jessie) released in April 2015
+  cat <<EOF | $docker_build
+FROM debian:jessie-20210326@sha256:32ad5050caffb2c7e969dac873bce2c370015c2256ff984b70c1c08b3a2816a0
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC
+RUN sed -i -e '/^deb/d' -e 's/^# deb /deb [trusted=yes] /g' /etc/apt/sources.list && \
+  echo 'Acquire::Retries "10"; Acquire::http::timeout "10"; Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/80-retries && \
+  apt-get update && \
+  apt-get install -y --no-install-recommends wget bzip2 file make autoconf gcc g++ libssl-dev && \
+  rm -rf /var/lib/apt/lists
 
-version=$(sed -n 's/^project(mold VERSION \(.*\))/\1/p' $(dirname $0)/CMakeLists.txt)
-dest=mold-$version-$arch-linux
-set -e -x
+# Build CMake 3.27
+RUN mkdir /build && \
+  cd /build && \
+  wget -O- --no-check-certificate https://cmake.org/files/v3.27/cmake-3.27.7.tar.gz | tar xzf - --strip-components=1 && \
+  ./bootstrap --parallel=\$(nproc) && \
+  make -j\$(nproc) && \
+  make install && \
+  rm -rf /build
 
-docker run --platform linux/$arch -it --rm -v "$(pwd):/mold" \
-  -e "OWNER=$(id -u):$(id -g)" rui314/mold-builder:latest \
-  bash -c "mkdir /tmp/build &&
-cd /tmp/build &&
-cmake -DCMAKE_C_COMPILER=gcc-10 -DCMAKE_CXX_COMPILER=g++-10 -DMOLD_MOSTLY_STATIC=On -DCMAKE_BUILD_TYPE=Release /mold &&
-cmake --build . -j\$(nproc) &&
-[ $arch = arm ] || ctest -j\$(nproc) &&
-cmake --install . --prefix $dest --strip &&
-tar czf /mold/$dest.tar.gz $dest &&
-cp mold mold-wrapper.so /mold &&
-chown \$OWNER /mold/mold /mold/mold-wrapper.so /mold/$dest.tar.gz"
+# Build GCC 10
+RUN mkdir /build && \
+  cd /build && \
+  wget -O- --no-check-certificate https://ftpmirror.gnu.org/gnu/gcc/gcc-10.5.0/gcc-10.5.0.tar.gz | tar xzf - --strip-components=1 && \
+  mkdir isl gmp mpc mpfr && \
+  wget -O- --no-check-certificate https://gcc.gnu.org/pub/gcc/infrastructure/isl-0.18.tar.bz2 | tar xjf - --strip-components=1 -C isl && \
+  wget -O- --no-check-certificate https://ftpmirror.gnu.org/gnu/gmp/gmp-6.1.2.tar.bz2 | tar xjf - --strip-components=1 -C gmp && \
+  wget -O- --no-check-certificate https://ftpmirror.gnu.org/gnu/mpc/mpc-1.2.1.tar.gz | tar xzf - --strip-components=1 -C mpc && \
+  wget -O- --no-check-certificate https://ftpmirror.gnu.org/gnu/mpfr/mpfr-4.1.0.tar.gz | tar xzf - --strip-components=1 -C mpfr && \
+  ./configure --prefix=/usr --enable-languages=c,c++ --disable-bootstrap --disable-multilib && \
+  make -j\$(nproc) && \
+  make install && \
+  ln -sf /usr/lib64/libstdc++.so.6 /usr/lib/x86_64-linux-gnu/libstdc++.so.6 && \
+  rm -rf /build
+
+# Build GNU binutils 2.43
+RUN mkdir /build && \
+  cd /build && \
+  wget -O- --no-check-certificate https://ftp.gnu.org/gnu/binutils/binutils-2.43.tar.gz | tar xzf - --strip-components=1 && \
+  ./configure --prefix=/usr && \
+  make -j\$(nproc) && \
+  make install && \
+  rm -fr /build
+
+# Build Python 3.12.7
+RUN mkdir /build && \
+  cd /build && \
+  wget -O- --no-check-certificate https://www.python.org/ftp/python/3.12.7/Python-3.12.7.tgz | tar xzf - --strip-components=1 && \
+  ./configure && \
+  make -j\$(nproc) && \
+  make install && \
+  ln -sf /usr/local/bin/python3 /usr/local/bin/python && \
+  rm -rf /build
+
+# Build LLVM 18.1.8
+RUN mkdir /build && \
+  cd /build && \
+  wget -O- --no-check-certificate https://github.com/llvm/llvm-project/archive/refs/tags/llvmorg-18.1.8.tar.gz | tar xzf - --strip-components=1 && \
+  mkdir b && \
+  cd b && \
+  cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS=clang ../llvm && \
+  cmake --build . -j\$(nproc) && \
+  cmake --install . --strip && \
+  rm -rf /build
+EOF
+  ;;
+aarch64 | arm | ppc64le | s390x)
+  # Debian 10 (Bullseye) released in July 2019
+  #
+  # We don't want to build Clang for these targets with Qemu becuase
+  # that'd take extremely long time. Also I believe old build machines
+  # are usually x86-64.
+  cat <<EOF | $docker_build
+FROM debian:bullseye-20240904@sha256:8ccc486c29a3ad02ad5af7f1156e2152dff3ba5634eec9be375269ef123457d8
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC
+RUN sed -i -e '/^deb/d' -e 's/^# deb /deb [trusted=yes] /g' /etc/apt/sources.list && \
+  echo 'Acquire::Retries "10"; Acquire::http::timeout "10"; Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/80-retries && \
+  apt-get update && \
+  apt-get install -y --no-install-recommends build-essential gcc-10 g++-10 clang-16 cmake && \
+  ln -sf /usr/bin/clang-16 /usr/bin/clang && \
+  ln -sf /usr/bin/clang++-16 /usr/bin/clang++ && \
+  rm -rf /var/lib/apt/lists
+EOF
+  ;;
+riscv64)
+  cat <<EOF | $docker_build
+FROM riscv64/debian:unstable-20240926@sha256:25654919c2926f38952cdd14b3300d83d13f2d820715f78c9f4b7a1d9399bf48
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC
+RUN sed -i -e '/^URIs/d' -e 's/^# http/URIs: http/' /etc/apt/sources.list.d/debian.sources && \
+  echo 'Acquire::Retries "10"; Acquire::http::timeout "10"; Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/80-retries && \
+  apt-get update && \
+  apt-get install -y --no-install-recommends build-essential gcc-14 g++-14 clang-18 cmake && \
+  ln -sf /usr/bin/clang-18 /usr/bin/clang && \
+  ln -sf /usr/bin/clang++-18 /usr/bin/clang++ && \
+  rm -rf /var/lib/apt/lists
+EOF
+  ;;
+esac
+
+# Source tarballs available on GitHub don't contain .git history.
+# Clone the repo if missing.
+[ -d .git ] || git clone --branch v$version --depth 1 --bare https://github.com/rui314/mold .git
+
+# We use the timestamp of the last Git commit as the file timestamp
+# for build artifacts.
+timestamp="$(git log -1 --format=%ci)"
+
+# Build mold in a container.
+docker run --platform linux/$arch -i --rm -v "$(pwd):/mold" $image bash -c "
+set -e
+mkdir /build
+cd /build
+cmake -DCMAKE_BUILD_TYPE=Release -DMOLD_MOSTLY_STATIC=1 -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ /mold
+cmake --build . -j\$(nproc)
+cmake --install .
+cmake -DMOLD_USE_MOLD=1 .
+cmake --build . -j\$(nproc)
+ctest -j\$(nproc)
+cmake --install . --prefix $dest --strip
+find $dest -print | xargs touch --no-dereference --date='$timestamp'
+find $dest -print | sort | tar -cf - --no-recursion --files-from=- | gzip -9nc > /mold/$dest.tar.gz
+cp mold /mold
+chown $(id -u):$(id -g) /mold/$dest.tar.gz /mold/mold
+sha256sum /mold/$dest.tar.gz
+"

docs/chart.svg

@@ -0,0 +1 @@
+<svg version="1.1" viewBox="0.0 0.0 600.0 371.0" fill="none" stroke="none" stroke-linecap="square" stroke-miterlimit="10" width="600" height="371" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg"><path fill="#ffffff" d="M0 0L600.0 0L600.0 371.0L0 371.0L0 0Z" fill-rule="nonzero"/><path stroke="#333333" stroke-width="1.0" stroke-linecap="butt" d="M82.5 275.5L581.5 275.5" fill-rule="nonzero"/><path stroke="#cccccc" stroke-width="1.0" stroke-linecap="butt" d="M82.5 231.5L581.5 231.5" fill-rule="nonzero"/><path stroke="#cccccc" stroke-width="1.0" stroke-linecap="butt" d="M82.5 186.5L581.5 186.5" fill-rule="nonzero"/><path stroke="#cccccc" stroke-width="1.0" stroke-linecap="butt" d="M82.5 142.5L581.5 142.5" fill-rule="nonzero"/><path stroke="#cccccc" stroke-width="1.0" stroke-linecap="butt" d="M82.5 98.5L581.5 98.5" fill-rule="nonzero"/><path stroke="#cccccc" stroke-width="1.0" stroke-linecap="butt" d="M82.5 53.5L581.5 53.5" fill-rule="nonzero"/><clipPath id="id_0"><path d="M82.55 53.916668L581.45 53.916668L581.45 275.45L82.55 275.45L82.55 53.916668Z" clip-rule="nonzero"/></clipPath><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M158.0 275.0L136.0 275.0L136.0 229.0C136.0 227.89543 136.89543 227.0 138.0 227.0L156.0 227.0C157.10457 227.0 158.0 227.89543 158.0 229.0Z" fill-rule="nonzero"/><path fill="#4285f4" clip-path="url(#id_0)" d="M158.0 275.0L136.0 275.0L136.0 229.0C136.0 227.89543 136.89543 227.0 138.0 227.0L156.0 227.0C157.10457 227.0 158.0 227.89543 158.0 229.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M307.0 275.0L285.0 275.0L285.0 91.0C285.0 89.89543 285.89542 89.0 287.0 89.0L305.0 89.0C306.10458 89.0 307.0 89.89543 307.0 91.0Z" fill-rule="nonzero"/><path fill="#4285f4" clip-path="url(#id_0)" d="M307.0 275.0L285.0 275.0L285.0 91.0C285.0 89.89543 285.89542 89.0 287.0 89.0L305.0 89.0C306.10458 89.0 307.0 89.89543 307.0 91.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M182.0 275.0L160.0 275.0L160.0 244.0C160.0 242.89543 160.89543 242.0 162.0 242.0L180.0 242.0C181.10457 242.0 182.0 242.89543 182.0 244.0Z" fill-rule="nonzero"/><path fill="#ea4335" clip-path="url(#id_0)" d="M182.0 275.0L160.0 275.0L160.0 244.0C160.0 242.89543 160.89543 242.0 162.0 242.0L180.0 242.0C181.10457 242.0 182.0 242.89543 182.0 244.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M331.0 275.0L309.0 275.0L309.0 131.0C309.0 129.89543 309.89542 129.0 311.0 129.0L329.0 129.0C330.10458 129.0 331.0 129.89543 331.0 131.0Z" fill-rule="nonzero"/><path fill="#ea4335" clip-path="url(#id_0)" d="M331.0 275.0L309.0 275.0L309.0 131.0C309.0 129.89543 309.89542 129.0 311.0 129.0L329.0 129.0C330.10458 129.0 331.0 129.89543 331.0 131.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M480.0 275.0L458.0 275.0L458.0 156.0C458.0 154.89543 458.89542 154.0 460.0 154.0L478.0 154.0C479.10458 154.0 480.0 154.89543 480.0 156.0Z" fill-rule="nonzero"/><path fill="#ea4335" clip-path="url(#id_0)" d="M480.0 275.0L458.0 275.0L458.0 156.0C458.0 154.89543 458.89542 154.0 460.0 154.0L478.0 154.0C479.10458 154.0 480.0 154.89543 480.0 156.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M206.0 275.0L184.0 275.0L184.0 270.0C184.0 268.89542 184.89543 268.0 186.0 268.0L204.0 268.0C205.10457 268.0 206.0 268.89542 206.0 270.0Z" fill-rule="nonzero"/><path fill="#fbbc04" clip-path="url(#id_0)" d="M206.0 275.0L184.0 275.0L184.0 270.0C184.0 268.89542 184.89543 268.0 186.0 268.0L204.0 268.0C205.10457 268.0 206.0 268.89542 206.0 270.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M355.0 275.0L333.0 275.0L333.0 254.0C333.0 252.89543 333.89542 252.0 335.0 252.0L353.0 252.0C354.10458 252.0 355.0 252.89543 355.0 254.0Z" fill-rule="nonzero"/><path fill="#fbbc04" clip-path="url(#id_0)" d="M355.0 275.0L333.0 275.0L333.0 254.0C333.0 252.89543 333.89542 252.0 335.0 252.0L353.0 252.0C354.10458 252.0 355.0 252.89543 355.0 254.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroke-opacity="0.0" clip-path="url(#id_0)" d="M504.0 275.0L482.0 275.0L482.0 250.0C482.0 248.89543 482.89542 248.0 484.0 248.0L502.0 248.0C503.10458 248.0 504.0 248.89543 504.0 250.0Z" fill-rule="nonzero"/><path fill="#fbbc04" clip-path="url(#id_0)" d="M504.0 275.0L482.0 275.0L482.0 250.0C482.0 248.89543 482.89542 248.0 484.0 248.0L502.0 248.0C503.10458 248.0 504.0 248.89543 504.0 250.0Z" fill-rule="nonzero"/><path stroke="#000000" stroke-width="2.0" stroke-linecap="butt" stroLine truncated

docs/design.md

@@ -1,3 +1,8 @@
+[This document was written in 2020, and the contents are outdated.
+Specifically, we no longer believe that object preloading is a good
+idea. That being said, most of the points in this document still hold
+even today. Therefore, I'll keep this document as-is.]
+
 ## Design and implementation of mold
 
 For the rest of this documentation, I'll explain the design and the

docs/mold.md

@@ -0,0 +1,920 @@
+mold(1) -- a modern linker
+==========================
+
+## SYNOPSIS
+
+`mold` [_option_...] _file_...
+
+## DESCRIPTION
+`mold` is a faster drop-in replacement for the default GNU ld(1).
+
+### How to use
+See <https://github.com/rui314/mold#how-to-use>.
+
+### Compatibility
+
+`mold` is designed to be a drop-in replacement for the GNU linkers for
+linking user-land programs. If your user-land program cannot be built due to
+missing command-line options, please file a bug at
+<https://github.com/rui314/mold/issues>.
+
+`mold` supports a very limited set of linker script features, which is just
+sufficient to read `/usr/lib/x86_64-linux-gnu/libc.so` on Linux systems (on
+Linux, that file is contrary to its name not a shared library but an ASCII
+linker script that loads a real `libc.so` file.)
+
+Beyond that, we have no plan to support any additional linker script features.
+The linker script is an ad-hoc, over-designed, complex language which we
+believe needs to be replaced by a simpler mechanism. We have a plan to add a
+replacement for the linker script to `mold` instead.
+
+### Archive symbol resolution
+
+Traditionally, Unix linkers are sensitive to the order in which input files
+appear on the command line. They process input files from the first (leftmost)
+file to the last (rightmost) file one-by-one. While reading input files, they
+maintain sets of defined and undefined symbols. When visiting an archive file
+(`.a` files), they pull out object files to resolve as many undefined symbols
+as possible and move on to the next input file. Object files that weren't
+pulled out will never have a chance for a second look.
+
+Due to this behavior, you usually have to add archive files at the end of a
+command line, so that when a linker reaches archive files, it knows what
+symbols remain as undefined.
+
+If you put archive files at the beginning of a command line, a linker doesn't
+have any undefined symbols, and thus no object files will be pulled out from
+archives. You can change the processing order by using the `--start-group` and
+`--end-group` options, though they make a linker slower.
+
+`mold`, as well as the LLVM lld(1) linker, takes a different approach. They
+remember which symbols can be resolved from archive files instead of
+forgetting them after processing each archive. Therefore, `mold` and lld(1)
+can "go back" in a command line to pull out object files from archives if they
+are needed to resolve remaining undefined symbols. They are not sensitive to
+the input file order.
+
+`--start-group` and `--end-group` are still accepted by `mold` and lld(1)
+for compatibility with traditional linkers, but they are silently ignored.
+
+### Dynamic symbol resolution
+
+Some Unix linker features are difficult to understand without comprehending
+the semantics of dynamic symbol resolution. Therefore, even though it's not
+specific to `mold`, we'll explain it here.
+
+We use "ELF module" or just "module" as a collective term to refer to an
+executable or a shared library file in the ELF format.
+
+An ELF module may have lists of imported symbols and exported symbols, as well
+as a list of shared library names from which imported symbols should be
+imported. The point is that imported symbols are not bound to any specific
+shared library until runtime.
+
+Here is how the Unix dynamic linker resolves dynamic symbols. Upon the start
+of an ELF program, the dynamic linker constructs a list of ELF modules which,
+as a whole, consist of a complete program. The executable file is always at
+the beginning of the list followed by its dependent shared libraries. An
+imported symbol is searched from the beginning of the list to the end. If two
+or more modules define the same symbol, the one that appears first in the list
+takes precedence over the others.
+
+This Unix semantics are contrary to systems such as Windows that have a
+two-level namespace for dynamic symbols. On Windows, for example, dynamic
+symbols are represented as a tuple of (`symbol-name`, `shared-library-name`),
+so that each dynamic symbol is guaranteed to be resolved from some specific
+library.
+
+Typically, an ELF module that exports a symbol also imports the same symbol.
+Such a symbol is usually resolved to itself, but that's not the case if a
+module that appears before it in the symbol search list provides another
+definition of the same symbol.
+
+Let's take `malloc` as an example. Assume that you define your version of
+`malloc` in your main executable file. Then, all `malloc` calls from any
+module are resolved to your function instead of the one in libc, because the
+executable is always at the beginning of the dynamic symbol search list. Note
+that even `malloc` calls within libc are resolved to your definition since
+libc exports and imports `malloc`. Therefore, by defining `malloc` yourself,
+you can overwrite a library function, and the `malloc` in libc becomes dead
+code.
+
+These Unix semantics are tricky and sometimes considered harmful. For example,
+assume that you accidentally define `atoi` as a global function in your
+executable that behaves completely differently from the one in the C standard.
+Then, all `atoi` function calls from any modules (even function calls within
+libc) are redirected to your function instead of the one in libc, which will
+very likely cause a problem. That is a somewhat surprising consequence for an
+accidental name conflict. On the other hand, this semantic is sometimes useful
+because it allows users to override library functions without rebuilding
+modules containing them.
+
+Whether good or bad, you should keep these semantics in mind to understand
+Unix linkers' behaviors.
+
+### Build reproducibility
+
+`mold`'s output is deterministic. That is, if you pass the same object files
+and the same command-line options to the same version of `mold`, it is
+guaranteed that `mold` produces the bit-for-bit identical output. The linker's
+internal randomness, such as the timing of thread scheduling or iteration
+orders of hash tables, doesn't affect the output.
+
+`mold` does not have any host-specific default settings. This is contrary to the
+GNU linkers, for which some configurable values, such as system-dependent
+library search paths, are hard-coded. `mold` depends only on its command-line
+arguments.
+
+## OPTION NOTATIONS
+
+Multi-letter long options may precede either a single dash or double dashes,
+except for those starting with the letter "o". For historical reasons, long
+options beginning with "o" must precede double dashes.
+
+For example, you can spell `--as-needed` as `-as-needed`, but `--omagic` must
+not be spelled as `-omagic`. `-omagic` will be interpreted not as `--omagic`
+but as `-o magic`.
+
+## MOLD-SPECIFIC OPTIONS
+
+* `--chroot`=_dir_:
+  Set _dir_ as the root directory.
+
+* `--color-diagnostics`=[ _auto_ | _always_ | _never_ ]:
+  Show diagnostic messages in color using ANSI escape sequences. `auto` means
+  that `mold` prints out messages in color only if the standard output is
+  connected to a TTY. Default is `auto`.
+
+* `--color-diagnostics`:
+  Synonym for `--color-diagnostics=auto`.
+
+* `--no-color-diagnostics`:
+  Synonym for `--color-diagnostics=never`.
+
+* `--detach`, `--no-detach`:
+  Permit or do not permit mold to create a debug info file in the background.
+
+* `--fork`, `--no-fork`:
+  Spawn a child process and let it do the actual linking. When linking a large
+  program, the OS kernel can take a few hundred milliseconds to terminate a
+  `mold` process. `--fork` hides that latency. By default, it does fork.
+
+* `--perf`:
+  Print performance statistics.
+
+* `--print-dependencies`:
+  Print out dependency information for input files.
+
+  Each line of the output for this option shows which file depends on which
+  file to use a specific symbol. This option is useful for debugging why some
+  object file in a static archive got linked or why some shared library is
+  kept in an output file's dependency list even with `--as-needed`.
+
+* `--relocatable-merge-sections`:
+  By default, `mold` doesn't merge input sections by name when merging input
+  object files into a single output object file for `-r`. For example,
+  `.text.foo` and `.text.bar` aren't merged for `-r` even though they are
+  merged into `.text` based on the default section merging rules.
+
+  This option changes the behavior so that `mold` merges input sections by
+  name by the default section merging rules.
+
+* `--repro`:
+  Archive input files, as well as a text file containing command line options,
+  in a tar file so that you can run `mold` with the exact same inputs again.
+  This is useful for reporting a bug with a reproducer. The output filename is
+  `path/to/output.tar`, where `path/to/output` is an output filename specified
+  by `-o`.
+
+* `--reverse-sections`:
+  Reverse the order of input sections before assigning them the offsets in the
+  output file.
+
+  This option is useful for finding bugs that depend on the initialization
+  order of global objects. In C++, constructors of global objects in a single
+  source file are guaranteed to be executed in the source order, but there's
+  no such guarantee across compilation units. Usually, constructors are
+  executed in the order given to the linker, but depending on it is a mistake.
+
+  By reversing the order of input sections using `--reverse-sections`, you can
+  easily test that your program works in the reversed initialization order.
+
+* `--run` _command_ _arg_...:
+  Run _command_ with `mold` as `/usr/bin/ld`. Specifically, `mold` runs a
+  given command with the `LD_PRELOAD` environment set to intercept exec(3)
+  family functions and replaces `argv[0]` with itself if it is `ld`,
+  `ld.gold`, or `ld.lld`.
+
+* `--separate-debug-file`, `--separate-debug-file`=_file_:
+  Bundle debug info sections into a separate file instead of embedding them in
+  an output executable or a shared library. mold creates a debug info file in
+  the background by default, so that you can start running your executable as
+  soon as possible.
+
+  By default, the debug info file is created in the same directory as is the
+  output file, with the `.dbg` file extension. That filename is embedded into
+  the output file so that `gdb` can automatically find the debug info file for
+  the output file. For more info about gdb features related to separate debug
+  files, see
+  <https://sourceware.org/gdb/current/onlinedocs/gdb.html/Separate-Debug-Files.html>.
+
+  mold holds a file lock with flock(2) while creating a debug info file in the
+  background.
+
+  If you don't want to create a debug info file in the background, pass the
+  `--no-detach` option.
+
+* `--shuffle-sections`, `--shuffle-sections`=_number_:
+  Randomize the output by shuffling the order of input sections before
+  assigning them the offsets in the output file. If a _number_ is given, it's
+  used as a seed for the random number generator, so that the linker produces
+  the same output for the same seed. If no seed is given, a random number is
+  used as a seed.
+
+  This option is useful for benchmarking. Modern CPUs are sensitive to a
+  program's memory layout. A seemingly benign change in program layout, such
+  as a small size increase of a function in the middle of a program, can
+  affect the program's performance. Therefore, even if you write new code and
+  get a good benchmark result, it is hard to say whether the new code improves
+  the program's performance; it is possible that the new memory layout happens
+  to perform better.
+
+  By running a benchmark multiple times with randomized memory layouts using
+  `--shuffle-sections`, you can isolate your program's real performance number
+  from the randomness caused by memory layout changes.
+
+* `--spare-program-headers`=_number_:
+  Append the given number of `PT_NULL` entries to the end of the program
+  header, so that post-link processing tools can easily add new segments by
+  overwriting the null entries.
+
+  Note that ELF requires all `PT_LOAD` segments to be sorted by `p_vaddr`.
+  Therefore, if you add a new LOAD segment, you may need to sort the entire
+  program header.
+
+* `--stats`:
+  Print input statistics.
+
+* `--thread-count`=_count_:
+  Use _count_ number of threads.
+
+* `--threads`, `--no-threads`:
+  Use multiple threads. By default, `mold` uses as many threads as the number of
+  cores or 32, whichever is smaller. The reason it is capped at 32 is because
+  `mold` doesn't scale well beyond that point. To use only one thread, pass
+  `--no-threads` or `--thread-count=1`.
+
+* `--quick-exit`, `--no-quick-exit`:
+  Use or do not use `quick_exit` to exit.
+
+* `-z rewrite-endbr`, `-z norewrite-endbr`:
+  As a security measure, some CPU instruction sets have recently gained a
+  feature to protect control flow integrity by disallowing indirect branches
+  by default. If the feature is enabled, the instruction that is executed
+  immediately after an indirect branch must be an branch target marker
+  instruction, or a CPU-level fault will raise. The marker instruction is also
+  known as "landing pad" instruction, to which indirect branches can land.
+  This feature makes ROP attacks harder to conduct.
+
+  To use the feature, a function whose pointer is taken needs to begin with a
+  landing pad because a function call via a function pointer is compiled to an
+  indirect branch. On the other hand, if a function is called only directly
+  (i.e. referred to only by _direct_ branch instructions), it doesn't have to
+  begin with it.
+
+  By default, the compiler always emits a landing pad at the beginning of each
+  global function because it doesn't know whether or not the function's
+  pointer is taken in another translation unit. As a result, the resulting
+  binary has more attack surface than necessary.
+
+  If `--rewrite-endbr` is given, mold conducts a whole program analysis
+  to identify functions whose addresses are actually taken and rewrites
+  landing pads with no-ops for non-address-taken functions, reducing the
+  attack surface.
+
+  This feature is currently available only on x86-64.
+
+## GNU-COMPATIBLE OPTIONS
+
+* `--help`:
+  Report usage information to stdout and exit.
+
+* `-v`, `--version`:
+  Report version information to stdout.
+
+* `-V`:
+  Report version and target information to stdout.
+
+* `-E`, `--export-dynamic`, `--no-export-dynamic`:
+  When creating an executable, using the `-E` option causes all global symbols
+  to be put into the dynamic symbol table, so that the symbols are visible
+  from other ELF modules at runtime.
+
+  By default, or if `--no-export-dynamic` is given, only symbols that are
+  referenced by DSOs at link-time are exported from an executable.
+
+* `-F` _libname_, `--filter`=_libname_:
+  Set the `DT_FILTER` dynamic section field to _libname_.
+
+* `-I` _file_, `--dynamic-linker`=_file_, `--no-dynamic-linker`:
+  Set the dynamic linker path to _file_. If no `-I` option is given, or if
+  `--no-dynamic-linker` is given, no dynamic linker path is set to an output
+  file. This is contrary to the GNU linkers which set a default dynamic linker
+  path in that case. This difference doesn't usually make any difference
+  because the compiler driver always passes `-I` to the linker.
+
+* `-L` _dir_, `--library-path`=_dir_:
+  Add _dir_ to the list of library search paths from which `mold` searches
+  libraries for the `-l` option.
+
+  Unlike the GNU linkers, `mold` does not have default search paths. This
+  difference doesn't usually make any difference because the compiler driver
+  always passes all necessary search paths to the linker.
+
+* `-M`, `--print-map`:
+  Write a map file to stdout.
+
+* `-N`, `--omagic`, `--no-omagic`:
+  Force `mold` to emit an output file with an old-fashioned memory layout.
+  First, it makes the first data segment not aligned to a page boundary.
+  Second, text segments are marked as writable if the option is given.
+
+* `-S`, `--strip-debug`:
+  Omit `.debug_*` sections from the output file.
+
+* `-T` _file_, `--script`=_file_:
+  Read linker script from _file_.
+
+* `-X`, `--discard-locals`:
+  Discard temporary local symbols to reduce the sizes of the symbol table and
+  the string table. Temporary local symbols are local symbols starting with
+  `.L`. Compilers usually generate such symbols for unnamed program elements
+  such as string literals or floating-point literals.
+
+* `-e` _symbol_, `--entry`=_symbol_:
+
+  Use _symbol_ as the entry point symbol instead of the default entry
+  point symbol _start.
+
+* `-f` _shlib_, `--auxiliary`=_shlib_:
+  Set the `DT_AUXILIARY` dynamic section field to _shlib_.
+
+* `-h` _libname_, `--soname`=_libname_:
+  Set the `DT_SONAME` dynamic section field to _libname_. This option is used
+  when creating a shared object file. Typically, when you create `libfoo.so`,
+  you want to pass `--soname=foo` to a linker.
+
+* `-l` _libname_:
+  Search for `lib`_libname_`.so` or `lib`_libname_`.a` from library search
+  paths.
+
+* `-m` _target_:
+  Choose a _target_.
+
+* `-o` _file_, `--output`=_file_:
+  Use _file_ as the output file name instead of the default name `a.out`.
+
+* `-r`, `--relocatable`:
+  Instead of generating an executable or a shared object file, combine input
+  object files to generate another object file that can be used as an input to
+  a linker.
+
+* `-s`, `--strip-all`:
+  Omit `.symtab` section from the output file.
+
+* `-u` _symbol_, `--undefined`=_symbol_:
+  If _symbol_ remains as an undefined symbol after reading all object files,
+  and if there is a static archive that contains an object file defining
+  _symbol_, pull out the object file and link it so that the output file
+  contains a definition of _symbol_.
+
+* `-y` _symbol_, `--trace-symbol`=_symbol_:
+  Trace references to _symbol_.
+
+* `--Bdynamic`:
+  Link against shared libraries.
+
+* `--Bstatic`:
+  Do not link against shared libraries.
+
+* `--Bsymbolic`:
+  When creating a shared library, make global symbols export-only (i.e. do not
+  import the same symbol). As a result, references within a shared library are
+  always resolved locally, negating symbol override at runtime. See "Dynamic
+  symbol resolution" for more information about symbol imports and exports.
+
+* `--Bsymbolic-functions`:
+  This option has the same effect as `--Bsymbolic` but works only for function
+  symbols. Data symbols remain being both imported and exported.
+
+* `--Bsymbolic-non-weak`:
+  This option has the same effect as `--Bsymbolic` but works only for non-weak
+  symbols. Weak symbols remain being both imported and exported.
+
+* `--Bsymbolic-non-weak-functions`:
+  This option has the same effect as `--Bsymbolic` but works only for non-weak
+  function symbols. Data symbols and weak function symbols remain being both
+  imported and exported.
+
+* `--Bno-symbolic`:
+  Cancel `--Bsymbolic`, `--Bsymbolic-functions`, `--Bsymbolic-non-weak` and
+  `--Bsymbolic-non-weak-functions`.
+
+* `--Map`=_file_:
+  Write map file to _file_.
+
+* `--Tbss`=_address_:
+  Alias for `--section-start=.bss=`_address_.
+
+* `--Tdata`=_address_:
+  Alias for `--section-start=.data=`_address_.
+
+* `--Ttext`=_address_:
+  Alias for `--section-start=.text=`_address_.
+
+* `--allow-multiple-definition`:
+  Normally, the linker reports an error if there are more than one definition
+  of a symbol. This option changes the default behavior so that it doesn't
+  report an error for duplicate definitions and instead use the first
+  definition.
+
+* `--allow-shlib-undefined`, `--no-allow-shlib-undefined`:
+  Even if mold succeeds in linking a main executable without undefined symbol
+  errors, you may still encounter symbol lookup errors at runtime because the
+  dynamic linker cannot find some symbols in shared libraries in any ELF
+  module. This occurs because mold ignores undefined symbols in shared
+  libraries by default.
+
+  If you pass `--no-allow-shlib-undefined`, mold verifies that undefined
+  symbols in shared libraries given to the linker can be resolved at
+  link-time. In other words, this converts the runtime error to a link-time
+  error.
+
+  Note that you need to pass all shared libraries, including indirectly
+  dependent ones, to the linker as arguments for `-l`. If a shared library
+  depends on a library that's not passed to the linker, the verification will
+  be skipped for that file.
+
+* `--as-needed`, `--no-as-needed`:
+  By default, shared libraries given to the linker are unconditionally added
+  to the list of required libraries in an output file. However, shared
+  libraries after `--as-needed` are added to the list only when at least one
+  symbol is actually used by the output file. In other words, shared libraries
+  after `--as-needed` are not added to the list of needed libraries if they
+  are not needed by a program.
+
+  The `--no-as-needed` option restores the default behavior for subsequent
+  files.
+
+* `--build-id`=[ `md5` | `sha1` | `sha256` | `fast` | `uuid` | `0x`_hexstring_ | `none` ]:
+  Create a `.note.gnu.build-id` section containing a byte string to uniquely
+  identify an output file. `sha256` compute a 256-bit cryptographic hash of an
+  output file and set it to build-id. `md5` and `sha1` compute the same hash
+  but truncate it to 128 and 160 bits, respectively, before setting it to
+  build-id. `uuid` sets a random 128-bit UUID. `0x`_hexstring_ sets
+  _hexstring_. `fast` is a synonym for `sha256`.
+
+* `--build-id`:
+  Synonym for `--build-id=sha256`.
+
+* `--no-build-id`:
+  Synonym for `--build-id=none`.
+
+* `--compress-debug-sections`=[ `zlib` | `zlib-gabi` | `zstd` | `none` ]:
+  Compress DWARF debug info (`.debug_*` sections) using the zlib or zstd
+  compression algorithm. `zlib-gabi` is an alias for `zlib`.
+
+* `--defsym`=_symbol_=_value_:
+  Define _symbol_ as an alias for _value_.
+
+  _value_ is either an integer (in decimal or hexadecimal with `0x` prefix) or
+  a symbol name. If an integer is given as a value, _symbol_ is defined as an
+  absolute symbol with the given value.
+
+* `--default-symver`:
+  Use soname as a symbol version and append that version to all symbols.
+
+* `--demangle`, `--no-demangle`:
+  Demangle C++ and Rust symbols in log messages.
+
+* `--dependency-file`=_file_:
+  Write a dependency file to _file_. The contents of the written file is
+  readable by make(1), which defines only one rule with the linker's output
+  file as a target and all input files as its prerequisites. Users are
+  expected to include the generated dependency file into a Makefile to
+  automate the dependency management. This option is analogous to the
+  compiler's `-MM -MF` options.
+
+* `--dynamic-list`=_file_:
+  Read a list of dynamic symbols from _file_. Same as
+  `--export-dynamic-symbol-list`, except that it implies `--Bsymbolic`. If
+  _file_ does not exist in the current directory, it is searched from library
+  search paths for the sake of compatibility with GNU ld.
+
+* `--eh-frame-hdr`, `--no-eh-frame-hdr`:
+  Create `.eh_frame_hdr` section.
+
+* `--emit-relocs`:
+  The linker usually "consumes" relocation sections. That is, the linker
+  applies relocations to other sections, and relocation sections themselves
+  are discarded.
+
+  The `--emit-relocs` instructs the linker to leave relocation sections in the
+  output file. Some post-link binary analysis or optimization tools such as
+  LLVM Bolt need them.
+
+* `--enable-new-dtags`, `--disable-new-dtags`:
+  By default, `mold` emits `DT_RUNPATH` for `--rpath`. If you pass
+  `--disable-new-dtags`, `mold` emits `DT_RPATH` for `--rpath` instead.
+
+* `--execute-only`:
+
+  Traditionally, setting the executable bit to 1 for a memory page implies
+  that the page also become readable, which allows machine code to be read
+  as data at runtime. That is actually what an attacker often does after
+  gaining a limited control of a process to find pieces of machine code
+  they can use to gain the full control of the process. As a mitigation,
+  recent processors including some ARM64 ones allows "execute-only" pages.
+  If a page is execute-only, you can call a function there as long as you
+  know its address but can't read it as data.
+
+  This option marks text segments as execute-only by setting just the "X"
+  bit instead of "RX". Note that on most systems, the absence of the "R"
+  bit in the text segment serves just as a hint. If you run a program
+  linked with `--execute-only` on a processor that doesn't support
+  execute-only pages, your executable will likely still function normally,
+  but the text segment will remain readable.
+
+* `--exclude-libs`=_libraries_ ...:
+  Mark all symbols in the given _libraries_ hidden.
+
+* `--export-dynamic-symbol`=_symbol_:
+  Put symbols matching _symbol_ in the dynamic symbol table. _symbol_ may be a
+  glob pattern in the same syntax as for the `--export-dynamic-symbol-list` or
+  `--version-script` options.
+
+* `--export-dynamic-symbol-list`=_file_:
+  Read a list of dynamic symbols from _file_.
+
+* `--fatal-warnings`, `--no-fatal-warnings`:
+  Treat warnings as errors.
+
+* `--fini`=_symbol_:
+  Call _symbol_ at unload-time.
+
+* `--gc-sections`, `--no-gc-sections`:
+  Remove unreferenced sections.
+
+* `--gdb-index`:
+  Create a `.gdb_index` section to speed up GNU debugger. To use this, you
+  need to compile source files with the `-ggnu-pubnames` compiler flag.
+
+* `--hash-style`=[ `sysv` | `gnu` | `both` | `none` ]:
+  Set hash style.
+
+* `--icf`=[ `safe` | `all` | `none` ], `--no-icf`:
+  It is not uncommon for a program to contain many identical functions that
+  differ only in name. For example, a C++ template `std::vector` is very
+  likely to be instantiated to the identical code for `std::vector<int>` and
+  `std::vector<unsigned>` because the container cares only about the size of
+  the parameter type. Identical Code Folding (ICF) is a size optimization to
+  identify and merge such identical functions.
+
+  If `--icf=all` is given, `mold` tries to merge all identical functions. This
+  reduces the size of the output most, but it is not a "safe" optimization. It
+  is guaranteed in C and C++ that two pointers pointing two different
+  functions will never be equal, but `--icf=all` breaks that assumption as two
+  identical functions have the same address after merging. So a care must be
+  taken when you use this flag that your program does not depend on the
+  function pointer uniqueness.
+
+  `--icf=safe` is a flag to merge functions only when it is safe to do so.
+  That is, if a program does not take an address of a function, it is safe to
+  merge that function with other function, as you cannot compare a function
+  pointer with something else without taking an address of a function.
+
+  `--icf=safe` needs to be used with a compiler that supports `.llvm_addrsig`
+  section which contains the information as to what symbols are address-taken.
+  LLVM/Clang supports that section by default. Since GCC does not support it
+  yet, you cannot use `--icf=safe` with GCC (it doesn't do any harm but can't
+  optimize at all.)
+
+  `--icf=none` and `--no-icf` disables ICF.
+
+* `--ignore-data-address-equality`:
+  Make ICF to merge not only functions but also data. This option should be
+  used in combination with `--icf=all`.
+
+* `--image-base`=_addr_:
+  Set the base address to _addr_.
+
+* `--init`=_symbol_:
+  Call _symbol_ at load-time.
+
+* `--no-undefined`:
+  Report undefined symbols (even with `--shared`).
+
+* `--noinhibit-exec`:
+  Create an output file even if errors occur.
+
+* `--pack-dyn-relocs`=[ `relr` | `none` ]:
+  If `relr` is specified, all `R_*_RELATIVE` relocations are put into
+  `.relr.dyn` section instead of `.rel.dyn` or `.rela.dyn` section. Since
+  `.relr.dyn` section uses a space-efficient encoding scheme, specifying this
+  flag can reduce the size of the output. This is typically most effective for
+  position-independent executable.
+
+  Note that a runtime loader has to support `.relr.dyn` to run executables or
+  shared libraries linked with `--pack-dyn-relocs=relr`. As of 2022, only
+  ChromeOS, Android and Fuchsia support it.
+
+* `--pie`, `--pic-executable`, `--no-pie`, `--no-pic-executable`:
+  Create a position-independent executable.
+
+* `--print-gc-sections`, `--no-print-gc-sections`:
+  Print removed unreferenced sections.
+
+* `--print-icf-sections`, `--no-print-icf-sections`:
+  Print folded identical sections.
+
+* `--push-state`, `--pop-state`:
+  `--push-state` saves the current values of `--as-needed`, `--whole-archive`,
+  `--static`, and `--start-lib`. The saved values can be restored by
+  pop-state.
+
+  `--push-state` and `--pop-state` pairs can nest.
+
+  These options are useful when you want to construct linker command line
+  options programmatically. For example, if you want to link `libfoo.so` by
+  as-needed basis but don't want to change the global state of `--as-needed`,
+  you can append `--push-state --as-needed -lfoo --pop-state` to the linker
+  command line options.
+
+* `--relax, --no-relax`:
+  Rewrite machine instructions with more efficient ones for some relocations.
+  The feature is enabled by default.
+
+* `--require-defined`=_symbol_:
+  Like `--undefined`, except the new symbol must be defined by the end of the
+  link.
+
+* `--retain-symbols-file`=_file_:
+  Keep only symbols listed in _file_. _file_ is a text file containing a
+  symbol name on each line. `mold` discards all local symbols as well as
+  global symbol that are not in _file_. Note that this option removes symbols
+  only from `.symtab` section and does not affect `.dynsym` section, which is
+  used for dynamic linking.
+
+* `--rpath`=_dir_:
+  Add _dir_ to runtime search paths.
+
+* `--section-start`=_section_=_address_:
+  Set _address_ to section. _address_ is a hexadecimal number that may start
+  with an optional `0x`.
+
+* `--shared`, `--Bshareable`:
+  Create a share library.
+
+* `--spare-dynamic-tags`=_number_:
+  Append the given number of `DT_NULL` entries to the end of the `.dynamic`
+  section, so that post-link processing tools can easily add new dynamic tags
+  by overwriting the null entries.
+
+* `--start-lib`, `--end-lib`:
+  Handle object files between `--start-lib` and `--end-lib` as if they were in
+  an archive file. That means object files between them are linked only when
+  they are needed to resolve undefined symbols. The options are useful if you
+  want to link object files only when they are needed but want to avoid the
+  overhead of running ar(3).
+
+* `--static`:
+  Do not link against shared libraries.
+
+* `--sysroot`=_dir_:
+  Set target system root directory to _dir_.
+
+* `--trace`:
+  Print name of each input file.
+
+* `--undefined-glob`=_pattern_:
+  Synonym for `--undefined`, except that `--undefined-glob` takes a glob
+  pattern instead of just a single symbol name.
+
+* `--undefined-version`, `--no-undefined-version`:
+  By default, `mold` warns on a symbol specified by a version script or by
+  `--export-dynamic-symbol` if it is not defined. You can silence the warning
+  by `--undefined-version`.
+
+* `--unique`=_pattern_:
+  Don't merge input sections that match the given glob pattern _pattern_.
+
+* `--unresolved-symbols`=[ `report-all` | `ignore-all` | `ignore-in-object-files` | `ignore-in-shared-libs` ]:
+  How to handle undefined symbols.
+
+* `--version-script`=_file_:
+  Read version script from _file_. If _file_ does not exist in the current
+  directory, it is searched from library search paths for the sake of
+  compatibility with GNU ld.
+
+* `--warn-common`, `--no-warn-common`:
+  Warn about common symbols.
+
+* `--warn-once`:
+  Only warn once for each undefined symbol instead of warn for each relocation
+  referring an undefined symbol.
+
+* `--warn-unresolved-symbols`, `--error-unresolved-symbols`:
+  Normally, the linker reports an error for unresolved symbols.
+  `--warn-unresolved-symbols` option turns it into a warning.
+  `--error-unresolved-symbols` option restores the default behavior.
+
+* `--whole-archive`, `--no-whole-archive`:
+  When archive files (`.a` files) are given to the linker, only object files
+  that are needed to resolve undefined symbols are extracted from them and
+  linked to an output file. `--whole-archive` changes that behavior for
+  subsequent archives so that the linker extracts all object files and links
+  them to an output. For example, if you are creating a shared object file and
+  you want to include all archive members to the output, you should pass
+  `--whole-archive`. `--no-whole-archive` restores the default behavior for
+  subsequent archives.
+
+* `--wrap`=_symbol_:
+  Make _symbol_ be resolved to `__wrap_`_symbol_. The original symbol can be
+  resolved as `__real_`_symbol_. This option is typically used for wrapping an
+  existing function.
+
+* `-z cet-report`=[ `warning` | `error` | `none` ]:
+  Intel Control-flow Enforcement Technology (CET) is a new x86 feature
+  available since Tiger Lake which is released in 2020. It defines new
+  instructions to harden security to protect programs from control hijacking
+  attacks. You can tell the compiler to use the feature by specifying the
+  `-fcf-protection` flag.
+
+  `-z cet-report` flag is used to make sure that all object files were
+  compiled with a correct `-fcf-protection` flag. If `warning` or `error` are
+  given, `mold` prints out a warning or an error message if an object file was
+  not compiled with the compiler flag.
+
+  `mold` looks for `GNU_PROPERTY_X86_FEATURE_1_IBT` bit and
+  `GNU_PROPERTY_X86_FEATURE_1_SHSTK` bit in `.note.gnu.property` section to
+  determine whether or not an object file was compiled with `-fcf-protection`.
+
+* `-z now`, `-z lazy`:
+  By default, functions referring to other ELF modules are resolved by the
+  dynamic linker when they are called for the first time. `-z now` marks an
+  executable or a shared library file so that all dynamic symbols are resolved
+  when a file is loaded to memory. `-z lazy` restores the default behavior.
+
+* `-z origin`:
+  Mark object requiring immediate `$ORIGIN` processing at runtime.
+
+* `-z ibt`:
+  Turn on `GNU_PROPERTY_X86_FEATURE_1_IBT` bit in `.note.gnu.property` section
+  to indicate that the output uses IBT-enabled PLT. This option implies `-z
+  ibtplt`.
+
+* `-z ibtplt`:
+  Generate Intel Branch Tracking (IBT)-enabled PLT which is the default on
+  x86-64. This is the default.
+
+* `-z execstack`, `-z noexecstack`:
+  By default, the pages for the stack area (i.e. the pages where local
+  variables reside) are not executable for security reasons. `-z execstack`
+  makes it executable. `-z noexecstack` restores the default behavior.
+
+* `-z keep-text-section-prefix`, `-z nokeep-text-section-prefix`:
+  Keep `.text.hot`, `.text.unknown`, `.text.unlikely`, `.text.startup`, and
+  `.text.exit` as separate sections in the final binary instead of merging
+  them as `.text`.
+
+* `-z rodynamic`:
+  Make the `.dynamic` section read-only.
+
+* `-z relro`, `-z norelro`:
+  Some sections such as `.dynamic` have to be writable only during a module is
+  being loaded to memory. Once the dynamic linker finishes its job, such
+  sections won't be mutated by anyone. As a security mitigation, it is
+  preferred to make such segments read-only during program execution.
+
+  `-z relro` puts such sections into a special segment called `relro`. The
+  dynamic linker makes a relro segment read-only after it finishes its job.
+
+  By default, `mold` generates a relro segment. `-z norelro` disables the
+  feature.
+
+* `-z sectionheader`, `-z nosectionheader`:
+  `-z nosectionheader` tell the linker to omit the section header.
+  By default, the linker does not omit the section header.
+
+* `-z separate-loadable-segments`, `-z separate-code`, `-z noseparate-code`:
+  If one memory page contains multiple segments, the page protection bits are
+  set in such a way that the needed attributes (writable or executable) are
+  satisfied for all segments. This usually happens at a boundary of two
+  segments with two different attributes.
+
+  `separate-loadable-segments` adds paddings between segments with different
+  attributes so that they do not share the same page. This is the default.
+
+  `separate-code` adds paddings only between executable and non-executable
+  segments.
+
+  `noseparate-code` does not add any paddings between segments.
+
+* `-z defs`, `-z nodefs`:
+  Report undefined symbols (even with `--shared`).
+
+* `-z shstk`:
+  Enforce shadow stack by turning `GNU_PROPERTY_X86_FEATURE_1_SHSTK` bit in
+  `.note.gnu.property` output section. Shadow stack is part of Intel
+  Control-flow Enforcement Technology (CET), which is available since Tiger
+  Lake (2020).
+
+* `-z start_stop_visibility`=[ `hidden` | `protected` ]:
+  If a section name is valid as a C identifier (i.e., it matches
+  `/^[_a-zA-Z][_a-zA-Z0-9]*$/`), mold creates `__start_SECNAME` and
+  `__stop_SECNAME` symbols to mark the beginning and end of the section,
+  where `SECNAME` is the section name.
+
+  You can make these marker symbols visible from other ELF modules by passing
+  `-z start_stop_visibility=protected`. Default is `hidden`.
+
+* `-z text`, `-z notext`, `-z textoff`:
+  `mold` by default reports an error if dynamic relocations are created in
+  read-only sections. If `-z notext` or `-z textoff` are given, `mold` creates
+  such dynamic relocations without reporting an error. `-z text` restores the
+  default behavior.
+
+* `-z max-page-size`=_number_:
+  Some CPU ISAs support multiple memory page sizes. This option specifies the
+  maximum page size that an output binary can run on. In general, binaries
+  built for a larger page size can run on a system with a smaller page size,
+  but not vice versa. The default value is 4 KiB for i386, x86-64, and RISC-V,
+  and 64 KiB for ARM64.
+
+* `-z nodefaultlib`:
+  Make the dynamic loader ignore default search paths.
+
+* `-z nodelete`:
+  Mark DSO non-deletable at runtime.
+
+* `-z nodlopen`:
+  Mark DSO not available to dlopen(3). This option makes it possible for the
+  linker to optimize thread-local variable accesses by rewriting instructions
+  for some targets.
+
+* `-z nodump`:
+  Mark DSO not available to dldump(3).
+
+* `-z nocopyreloc`:
+  Do not create copy relocations.
+
+* `-z initfirst`:
+  Mark DSO to be initialized first at runtime.
+
+* `-z interpose`:
+  Mark object to interpose all DSOs but executable.
+
+* `-(`, `-)`, `-EL`, `-O`_number_, `--dc`, `--dp`, `--end-group`, `--no-add-needed`, `--no-copy-dt-needed-entries`, `--nostdlib`, `--rpath-link=Ar dir`, `--sort-common`, `--sort-section`, `--start-group`, `--warn-constructors`, `--warn-once`, `--fix-cortex-a53-835769`, `--fix-cortex-a53-843419`, `-z combreloc`, `-z common-page-size`, `-z nocombreloc`:
+  Ignored
+
+## ENVIRONMENT VARIABLES
+
+* `MOLD_JOBS`:
+  If this variable is set to `1`, only one `mold` process will run at a time.
+  If a new mold process is initiated while another is already active, the new
+  process will wait until the active one completes before starting.
+
+  The primary reason for this environment variable is to minimize peak memory
+  usage. Since mold is designed to operate with high parallelism, running
+  multiple mold instances simultaneously may not be beneficial. If you execute
+  N instances of mold concurrently, it could require N times the time and N
+  times the memory. On the other hand, running them one after the other might
+  still take N times longer, but the peak memory usage would be the same as
+  running just a single instance.
+
+  If your build system invokes multiple linker processes simultaneously and
+  some of them often get killed due to out-of-memory errors, you might
+  consider setting this environment variable to `1` to see if it addresses the
+  OOM issue.
+
+  Currently, any value other than `1` is silently ignored.
+
+* `MOLD_DEBUG`:
+  If this variable is set to a non-empty string, `mold` embeds its
+  command-line options in the output file's `.comment` section.
+
+* `MOLD_REPRO`:
+  Setting this variable to a non-empty string has the same effect as passing
+  the `--repro` option.
+
+## SEE ALSO
+
+gold(1), ld(1), elf(5), ld.so(8)
+
+## AUTHOR
+
+Rui Ueyama <ruiu@cs.stanford.edu>
+
+## BUGS
+
+Report bugs to <https://github.com/rui314/mold/issues>.

elf/arch-alpha.cc

@@ -1,342 +0,0 @@
-// Alpha is a 64-bit RISC ISA developed by DEC (Digital Equipment
-// Corporation) in the early '90s. It aimed to be an ISA that would last
-// 25 years. DEC expected Alpha would become 1000x faster during that time
-// span. Since the ISA was developed from scratch for future machines,
-// it's 64-bit from the beginning. There's no 32-bit variant.
-//
-// DEC ported its own Unix (Tru64) to Alpha. Microsoft also ported Windows
-// NT to it. But it wasn't a huge commercial success.
-//
-// DEC was acquired by Compaq in 1997. In the late '90s, Intel and
-// Hewlett-Packard were advertising that their upcoming Itanium processor
-// would achieve significantly better performance than RISC processors, so
-// Compaq decided to discontinue the Alpha processor line to switch to
-// Itanium. Itanium resulted in a miserable failure, but it still suceeded
-// to wipe out several RISC processors just by promising overly optimistic
-// perf numbers. Alpha as an ISA would probably have been fine after 25
-// years since its introduction (which is 1992 + 25 = 2017), but the
-// company and its market didn't last that long.
-//
-// From the linker's point of view, there are a few peculiarities in its
-// psABI as shown below:
-//
-//  - Alpha lacks PC-relative memory load/store instructions, so it uses
-//    register-relative load/store instructions in position-independent
-//    code. Specifically, GP (which is an alias for $r29) is always
-//    maintained to refer to .got+0x8000, and global variables' addresses
-//    are loaded in a GP-relative manner.
-//
-//  - It looks like even function addresses are first loaded to register
-//    in a GP-relative manner before calling it. We can relax it to
-//    convert the instruction sequence with a direct branch instruction,
-//    but by default, object files don't use a direct branch to call a
-//    function. Therefore, by default, we don't need to create a PLT.
-//    Any function call is made by first reading its address from GOT and
-//    jump to the address.
-
-#include "mold.h"
-
-namespace mold::elf {
-
-using E = ALPHA;
-
-// A 32-bit immediate can be materialized in a register with a "load high"
-// and a "load low" instruction sequence. The first instruction sets the
-// upper 16 bits in a register, and the second one set the lower 16
-// bits. When doing so, they sign-extend an immediate.  Therefore, if the
-// 15th bit of an immediate happens to be 1, setting a "low half" value
-// negates the upper 16 bit values that has already been set in a
-// register. To compensate that, we need to add 0x8000 when setting the
-// upper 16 bits.
-static u32 hi(u32 val) {
-  return bits(val + 0x8000, 31, 16);
-}
-
-template <>
-void write_plt_header(Context<E> &ctx, u8 *buf) {}
-
-template <>
-void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
-
-template <>
-void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
-
-template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
-  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
-
-  switch (rel.r_type) {
-  case R_NONE:
-    break;
-  case R_ALPHA_SREL32:
-    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  default:
-    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
-  }
-}
-
-template <>
-void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    u64 S = sym.get_addr(ctx);
-    u64 A = rel.r_addend;
-    u64 P = get_addr() + rel.r_offset;
-    u64 G = sym.get_got_idx(ctx) * sizeof(Word<E>);
-    u64 GOT = ctx.got->shdr.sh_addr;
-    u64 GP = ctx.got->shdr.sh_addr + 0x8000;
-
-    switch (rel.r_type) {
-    case R_ALPHA_REFQUAD:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
-    case R_ALPHA_GPREL32:
-      *(ul32 *)loc = S + A - GP;
-      break;
-    case R_ALPHA_LITERAL:
-      if (A)
-        *(ul16 *)loc = ctx.extra.got->get_addr(sym, A) - GP;
-      else
-        *(ul16 *)loc = GOT + G - GP;
-      break;
-    case R_ALPHA_BRSGP:
-      *(ul32 *)loc |= bits(S + A - P - 4, 22, 0);
-      break;
-    case R_ALPHA_GPDISP:
-      *(ul16 *)loc = hi(GP - P);
-      *(ul16 *)(loc + A) = GP - P;
-      break;
-    case R_ALPHA_SREL32:
-      *(ul32 *)loc = S + A - P;
-      break;
-    case R_ALPHA_GPRELHIGH:
-      *(ul16 *)loc = hi(S + A - GP);
-      break;
-    case R_ALPHA_GPRELLOW:
-      *(ul16 *)loc = S + A - GP;
-      break;
-    case R_ALPHA_TLSGD:
-      *(ul16 *)loc = sym.get_tlsgd_addr(ctx) - GP;
-      break;
-    case R_ALPHA_TLSLDM:
-      *(ul16 *)loc = ctx.got->get_tlsld_addr(ctx) - GP;
-      break;
-    case R_ALPHA_DTPRELHI:
-      *(ul16 *)loc = hi(S + A - ctx.dtp_addr);
-      break;
-    case R_ALPHA_DTPRELLO:
-      *(ul16 *)loc = S + A - ctx.dtp_addr;
-      break;
-    case R_ALPHA_GOTTPREL:
-      *(ul16 *)loc = sym.get_gottp_addr(ctx) + A - GP;
-      break;
-    case R_ALPHA_TPRELHI:
-      *(ul16 *)loc = hi(S + A - ctx.tp_addr);
-      break;
-    case R_ALPHA_TPRELLO:
-      *(ul16 *)loc = S + A - ctx.tp_addr;
-      break;
-    case R_ALPHA_LITUSE:
-    case R_ALPHA_HINT:
-      break;
-    default:
-      unreachable();
-    }
-  }
-}
-
-template <>
-void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    SectionFragment<E> *frag;
-    i64 frag_addend;
-    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
-
-    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
-    u64 A = frag ? frag_addend : (i64)rel.r_addend;
-
-    switch (rel.r_type) {
-    case R_ALPHA_REFLONG:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul32 *)loc = *val;
-      else
-        *(ul32 *)loc = S + A;
-      break;
-    case R_ALPHA_REFQUAD:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul64 *)loc = *val;
-      else
-        *(ul64 *)loc = S + A;
-      break;
-    default:
-      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
-                 << rel;
-    }
-  }
-}
-
-template <>
-void InputSection<E>::scan_relocations(Context<E> &ctx) {
-  assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    if (sym.is_ifunc())
-      Error(ctx) << sym << ": GNU ifunc symbol is not supported on Alpha";
-
-    switch (rel.r_type) {
-    case R_ALPHA_REFQUAD:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
-    case R_ALPHA_LITERAL:
-      if (rel.r_addend) {
-        sym.flags.fetch_or(NEEDS_ALPHA_GOT, std::memory_order_relaxed);
-        ctx.extra.got->add_symbol(sym, rel.r_addend);
-      } else {
-        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      }
-      break;
-    case R_ALPHA_SREL32:
-      scan_pcrel(ctx, sym, rel);
-      break;
-    case R_ALPHA_BRSGP:
-      if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
-      break;
-    case R_ALPHA_TLSGD:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
-      break;
-    case R_ALPHA_TLSLDM:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
-      break;
-    case R_ALPHA_GOTTPREL:
-    case R_ALPHA_TPRELHI:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
-      break;
-    case R_ALPHA_GPREL32:
-    case R_ALPHA_LITUSE:
-    case R_ALPHA_GPDISP:
-    case R_ALPHA_HINT:
-    case R_ALPHA_GPRELHIGH:
-    case R_ALPHA_GPRELLOW:
-    case R_ALPHA_DTPRELHI:
-    case R_ALPHA_DTPRELLO:
-    case R_ALPHA_TPRELLO:
-      break;
-    default:
-      Fatal(ctx) << *this << ": unknown relocation: " << rel;
-    }
-  }
-}
-
-// An R_ALPHA_LITERAL relocation may request the linker to create a GOT
-// entry for an external symbol with a non-zero addend. This is an unusual
-// request which we cannot find in any other targets.
-//
-// Referring an external symbol with a non-zero addend is a bad practice.
-// To see why, assume that we have two R_ALPHA_LITERAL relocs to symbol X
-// with addend 8 and 16. To satisfy that request, we need to create not
-// only one but two GOT entries for symbol X with different addends.
-//
-// We don't want to mess up the implementation of the common GOT section
-// for Alpha. So we create another GOT-like section, .alpha_got. Any GOT
-// entry for an R_ALPHA_LITERAL reloc with a non-zero addends is created
-// not in .got but in .alpha_got.
-//
-// Since .alpha_got entries are accessed relative to GP, .alpha_got
-// needs to be close enough to .got. It's actually placed next to .got.
-void AlphaGotSection::add_symbol(Symbol<E> &sym, i64 addend) {
-  assert(addend);
-  std::scoped_lock lock(mu);
-  entries.push_back({&sym, addend});
-}
-
-bool operator<(const AlphaGotSection::Entry &a, const AlphaGotSection::Entry &b) {
-  return std::tuple(a.sym->file->priority, a.sym->sym_idx, a.addend) <
-         std::tuple(b.sym->file->priority, b.sym->sym_idx, b.addend);
-};
-
-u64 AlphaGotSection::get_addr(Symbol<E> &sym, i64 addend) {
-  auto it = std::lower_bound(entries.begin(), entries.end(), Entry{&sym, addend});
-  assert(it != entries.end());
-  return this->shdr.sh_addr + (it - entries.begin()) * sizeof(Word<E>);
-}
-
-i64 AlphaGotSection::get_reldyn_size(Context<E> &ctx) {
-  i64 n = 0;
-  for (Entry &e : entries)
-    if (e.sym->is_imported || (ctx.arg.pic && !e.sym->is_absolute()))
-      n++;
-  return n;
-}
-
-void AlphaGotSection::finalize() {
-  sort(entries);
-  remove_duplicates(entries);
-  shdr.sh_size = entries.size() * sizeof(Word<E>);
-}
-
-void AlphaGotSection::copy_buf(Context<E> &ctx) {
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset + reldyn_offset);
-
-  for (i64 i = 0; i < entries.size(); i++) {
-    Entry &e = entries[i];
-    u64 P = this->shdr.sh_addr + sizeof(Word<E>) * i;
-    ul64 *buf = (ul64 *)(ctx.buf + this->shdr.sh_offset + sizeof(Word<E>) * i);
-
-    if (e.sym->is_imported) {
-      *buf = ctx.arg.apply_dynamic_relocs ? e.addend : 0;
-      *dynrel++ = ElfRel<E>(P, E::R_ABS, e.sym->get_dynsym_idx(ctx), e.addend);
-    } else {
-      *buf = e.sym->get_addr(ctx) + e.addend;
-      if (ctx.arg.pic && !e.sym->is_absolute())
-        *dynrel++ = ElfRel<E>(P, E::R_RELATIVE, 0, *buf);
-    }
-  }
-}
-
-} // namespace mold::elf

elf/arch-ppc64v2.cc

@@ -1,461 +0,0 @@
-// This file implements the PowerPC ELFv2 ABI which was standardized in
-// 2014. Modern little-endian PowerPC systems are based on this ABI.
-// The ABI is often referred to as "ppc64le". This shouldn't be confused
-// with "ppc64" which refers the original, big-endian PowerPC systems.
-//
-// PPC64 is a bit tricky to support because PC-relative load/store
-// instructions are generally not available. Therefore, it's not easy
-// for position-independent code to load a value from, for example,
-// .got, as we can't do that with [PC + the offset to the .got entry].
-//
-// We can get the program counter by the following four instructions
-//
-//   mflr  r1  // save the current link register to r1
-//   bl    .+4 // branch to the next instruction as if it were a function
-//   mflr  r0  // copy the return address to r0
-//   mtlr  r1  // restore the original link register value
-//
-// , but that's too expensive to do if we do this for each load/store.
-//
-// As a workaround, most functions are compiled in such a way that r2 is
-// assumed to always contain the address of .got + 0x8000. With this, we
-// can for example load the first entry of .got with a single instruction
-// `lw r0, -0x8000(r2)`. r2 is called the TOC pointer.
-//
-// There's only one .got for each ELF module. Therefore, if a callee is in
-// the same ELF module, r2 doesn't have to be recomputed. Most function
-// calls are usually within the same ELF module, so this mechanism is
-// efficient.
-//
-// In PPC64, a function usually have two entry points, global and local.
-// The global entry point is usually 8 bytes precedes the local entry
-// point. In between is the following instructions:
-//
-//   addis r2, r12, .TOC.@ha
-//   addi  r2, r2,  .TOC.@lo + 4;
-//
-// The global entry point assumes that the address of itself is in r12,
-// and it computes its own TOC pointer from r12. It's easy to do so for
-// the callee because the offset between its .got + 0x8000 and the
-// function is known at link-time. The above code sequence then falls
-// through to the local entry point that assumes r2 is .got + 0x8000.
-//
-// So, if a callee's TOC pointer is different from the current one
-// (e.g. calling a function in another .so), we first load the callee's
-// address to r12 (e.g. from .got.plt with a r2-relative load) and branch
-// to that address. Then the callee computes its own TOC pointer using
-// r12.
-//
-// Note on section names: the PPC64 psABI uses a weird naming convention
-// which calls .got.plt .plt. We ignored that part because it's just
-// confusing. Since the runtime only cares about segments, we should be
-// able to name sections whatever we want.
-//
-// https://openpowerfoundation.org/specifications/64bitelfabi/
-
-#include "mold.h"
-
-namespace mold::elf {
-
-using E = PPC64V2;
-
-static u64 lo(u64 x)       { return x & 0xffff; }
-static u64 hi(u64 x)       { return x >> 16; }
-static u64 ha(u64 x)       { return (x + 0x8000) >> 16; }
-static u64 high(u64 x)     { return (x >> 16) & 0xffff; }
-static u64 higha(u64 x)    { return ((x + 0x8000) >> 16) & 0xffff; }
-static u64 higher(u64 x)   { return (x >> 32) & 0xffff; }
-static u64 highera(u64 x)  { return ((x + 0x8000) >> 32) & 0xffff; }
-static u64 highest(u64 x)  { return x >> 48; }
-static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
-
-// .plt is used only for lazy symbol resolution on PPC64. All PLT
-// calls are made via range extension thunks even if they are within
-// reach. Thunks read addresses from .got.plt and jump there.
-// Therefore, once PLT symbols are resolved and final addresses are
-// written to .got.plt, thunks just skip .plt and directly jump to the
-// resolved addresses.
-template <>
-void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ul32 insn[] = {
-    // Get PC
-    0x7c08'02a6, // mflr    r0
-    0x429f'0005, // bcl     20, 31, 4 // obtain PC
-    0x7d68'02a6, // mflr    r11
-    0x7c08'03a6, // mtlr    r0
-
-    // Compute the PLT entry index
-    0xe80b'002c, // ld      r0, 44(r11)
-    0x7d8b'6050, // subf    r12, r11, r12
-    0x7d60'5a14, // add     r11, r0, r11
-    0x380c'ffcc, // addi    r0, r12, -52
-    0x7800'f082, // rldicl  r0, r0, 62, 2
-
-    // Load .got.plt[0] and .got.plt[1] and branch to .got.plt[0]
-    0xe98b'0000, // ld      r12, 0(r11)
-    0x7d89'03a6, // mtctr   r12
-    0xe96b'0008, // ld      r11, 8(r11)
-    0x4e80'0420, // bctr
-
-    // .quad .got.plt - .plt - 8
-    0x0000'0000,
-    0x0000'0000,
-  };
-
-  memcpy(buf, insn, sizeof(insn));
-  *(ul64 *)(buf + 52) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 8;
-}
-
-template <>
-void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  // When the control is transferred to a PLT entry, the PLT entry's
-  // address is already set to %r12 by the caller.
-  i64 offset = ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx);
-  *(ul32 *)buf = 0x4b00'0000 | (offset & 0x00ff'ffff);        // b plt0
-}
-
-// .plt.got is not necessary on PPC64 because range extension thunks
-// directly read GOT entries and jump there.
-template <>
-void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
-
-template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
-  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
-
-  switch (rel.r_type) {
-  case R_NONE:
-    break;
-  case R_PPC64_ADDR64:
-    *(ul64 *)loc = val;
-    break;
-  case R_PPC64_REL32:
-    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  case R_PPC64_REL64:
-    *(ul64 *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  default:
-    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
-  }
-}
-
-static u64 get_local_entry_offset(Context<E> &ctx, Symbol<E> &sym) {
-  i64 val = sym.esym().ppc_local_entry;
-  assert(val <= 7);
-  if (val == 0 || val == 1)
-    return 0;
-  if (val == 7)
-    Fatal(ctx) << sym << ": local entry offset 7 is reserved";
-  return 1 << val;
-}
-
-template <>
-void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    auto check = [&](i64 val, i64 lo, i64 hi) {
-      if (val < lo || hi <= val)
-        Error(ctx) << *this << ": relocation " << rel << " against "
-                   << sym << " out of range: " << val << " is not in ["
-                   << lo << ", " << hi << ")";
-    };
-
-    u64 S = sym.get_addr(ctx);
-    u64 A = rel.r_addend;
-    u64 P = get_addr() + rel.r_offset;
-    u64 G = sym.get_got_idx(ctx) * sizeof(Word<E>);
-    u64 GOT = ctx.got->shdr.sh_addr;
-    u64 TOC = ctx.extra.TOC->value;
-
-    switch (rel.r_type) {
-    case R_PPC64_ADDR64:
-      if (name() == ".toc")
-        apply_toc_rel(ctx, sym, rel, loc, S, A, P, dynrel);
-      else
-        apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
-    case R_PPC64_TOC16_HA:
-      *(ul16 *)loc = ha(S + A - TOC);
-      break;
-    case R_PPC64_TOC16_LO:
-      *(ul16 *)loc = lo(S + A - TOC);
-      break;
-    case R_PPC64_TOC16_DS:
-    case R_PPC64_TOC16_LO_DS:
-      *(ul16 *)loc |= (S + A - TOC) & 0xfffc;
-      break;
-    case R_PPC64_REL24: {
-      i64 val = S + A - P + get_local_entry_offset(ctx, sym);
-      if (sym.has_plt(ctx) || sign_extend(val, 25) != val)
-        val = get_thunk_addr(i) + A - P;
-
-      check(val, -(1 << 25), 1 << 25);
-      *(ul32 *)loc |= bits(val, 25, 2) << 2;
-
-      // If a callee is an external function, PLT saves %r2 to the
-      // caller's r2 save slot. We need to restore it after function
-      // return. To do so, there's usually a NOP as a placeholder
-      // after a BL. 0x6000'0000 is a NOP.
-      if (sym.has_plt(ctx) && *(ul32 *)(loc + 4) == 0x6000'0000)
-        *(ul32 *)(loc + 4) = 0xe841'0018; // ld r2, 24(r1)
-      break;
-    }
-    case R_PPC64_REL64:
-      *(ul64 *)loc = S + A - P;
-      break;
-    case R_PPC64_REL16_HA:
-      *(ul16 *)loc = ha(S + A - P);
-      break;
-    case R_PPC64_REL16_LO:
-      *(ul16 *)loc = lo(S + A - P);
-      break;
-    case R_PPC64_PLT16_HA:
-      *(ul16 *)loc = ha(G + GOT - TOC);
-      break;
-    case R_PPC64_PLT16_HI:
-      *(ul16 *)loc = hi(G + GOT - TOC);
-      break;
-    case R_PPC64_PLT16_LO:
-      *(ul16 *)loc = lo(G + GOT - TOC);
-      break;
-    case R_PPC64_PLT16_LO_DS:
-      *(ul16 *)loc |= (G + GOT - TOC) & 0xfffc;
-      break;
-    case R_PPC64_GOT_TPREL16_HA:
-      *(ul16 *)loc = ha(sym.get_gottp_addr(ctx) - TOC);
-      break;
-    case R_PPC64_GOT_TLSGD16_HA:
-      *(ul16 *)loc = ha(sym.get_tlsgd_addr(ctx) - TOC);
-      break;
-    case R_PPC64_GOT_TLSGD16_LO:
-      *(ul16 *)loc = lo(sym.get_tlsgd_addr(ctx) - TOC);
-      break;
-    case R_PPC64_GOT_TLSLD16_HA:
-      *(ul16 *)loc = ha(ctx.got->get_tlsld_addr(ctx) - TOC);
-      break;
-    case R_PPC64_GOT_TLSLD16_LO:
-      *(ul16 *)loc = lo(ctx.got->get_tlsld_addr(ctx) - TOC);
-      break;
-    case R_PPC64_DTPREL16_HA:
-      *(ul16 *)loc = ha(S + A - ctx.dtp_addr);
-      break;
-    case R_PPC64_TPREL16_HA:
-      *(ul16 *)loc = ha(S + A - ctx.tp_addr);
-      break;
-    case R_PPC64_DTPREL16_LO:
-      *(ul16 *)loc = lo(S + A - ctx.dtp_addr);
-      break;
-    case R_PPC64_TPREL16_LO:
-      *(ul16 *)loc = lo(S + A - ctx.tp_addr);
-      break;
-    case R_PPC64_GOT_TPREL16_LO_DS:
-      *(ul16 *)loc |= (sym.get_gottp_addr(ctx) - TOC) & 0xfffc;
-      break;
-    case R_PPC64_PLTSEQ:
-    case R_PPC64_PLTCALL:
-    case R_PPC64_TLS:
-    case R_PPC64_TLSGD:
-    case R_PPC64_TLSLD:
-      break;
-    default:
-      unreachable();
-    }
-  }
-}
-
-template <>
-void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    auto check = [&](i64 val, i64 lo, i64 hi) {
-      if (val < lo || hi <= val)
-        Error(ctx) << *this << ": relocation " << rel << " against "
-                   << sym << " out of range: " << val << " is not in ["
-                   << lo << ", " << hi << ")";
-    };
-
-    SectionFragment<E> *frag;
-    i64 frag_addend;
-    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
-
-    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
-    u64 A = frag ? frag_addend : (i64)rel.r_addend;
-
-    switch (rel.r_type) {
-    case R_PPC64_ADDR64:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul64 *)loc = *val;
-      else
-        *(ul64 *)loc = S + A;
-      break;
-    case R_PPC64_ADDR32: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 32);
-      *(ul32 *)loc = val;
-      break;
-    }
-    case R_PPC64_DTPREL64:
-      *(ul64 *)loc = S + A - ctx.dtp_addr;
-      break;
-    default:
-      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
-                 << rel;
-    }
-  }
-}
-
-template <>
-void InputSection<E>::scan_relocations(Context<E> &ctx) {
-  assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  // Scan relocations
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
-
-    switch (rel.r_type) {
-    case R_PPC64_ADDR64:
-      if (name() == ".toc")
-        scan_toc_rel(ctx, sym, rel);
-      else
-        scan_dyn_absrel(ctx, sym, rel);
-      break;
-    case R_PPC64_GOT_TPREL16_HA:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
-      break;
-    case R_PPC64_REL24:
-      if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
-      break;
-    case R_PPC64_PLT16_HA:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      break;
-    case R_PPC64_GOT_TLSGD16_HA:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
-      break;
-    case R_PPC64_GOT_TLSLD16_HA:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
-      break;
-    case R_PPC64_REL64:
-    case R_PPC64_TOC16_HA:
-    case R_PPC64_TOC16_LO:
-    case R_PPC64_TOC16_LO_DS:
-    case R_PPC64_TOC16_DS:
-    case R_PPC64_REL16_HA:
-    case R_PPC64_REL16_LO:
-    case R_PPC64_PLT16_HI:
-    case R_PPC64_PLT16_LO:
-    case R_PPC64_PLT16_LO_DS:
-    case R_PPC64_PLTSEQ:
-    case R_PPC64_PLTCALL:
-    case R_PPC64_TPREL16_HA:
-    case R_PPC64_TPREL16_LO:
-    case R_PPC64_GOT_TPREL16_LO_DS:
-    case R_PPC64_GOT_TLSGD16_LO:
-    case R_PPC64_GOT_TLSLD16_LO:
-    case R_PPC64_TLS:
-    case R_PPC64_TLSGD:
-    case R_PPC64_TLSLD:
-    case R_PPC64_DTPREL16_HA:
-    case R_PPC64_DTPREL16_LO:
-      break;
-    default:
-      Error(ctx) << *this << ": unknown relocation: " << rel;
-    }
-  }
-}
-
-template <>
-void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
-
-  // If the destination is PLT, we read an address from .got.plt or .got
-  // and jump there.
-  static const ul32 plt_thunk[] = {
-    // Save r2 to the r2 save slot reserved in the caller's stack frame
-    0xf841'0018, // std   r2, 24(r1)
-
-    // Jump to a PLT entry
-    0x3d82'0000, // addis r12, r2, foo@gotplt@toc@ha
-    0xe98c'0000, // ld    r12, foo@gotplt@toc@lo(r12)
-    0x7d89'03a6, // mtctr r12
-    0x4e80'0420, // bctr
-  };
-
-  // If the destination is a non-imported function, we directly jump
-  // to its local entry point.
-  static const ul32 local_thunk[] = {
-    // Jump to a local entry point
-    0x3d82'0000, // addis r12, r2,  foo@toc@ha
-    0x398c'0000, // addi  r12, r12, foo@toc@lo
-    0x7d89'03a6, // mtctr r12
-    0x4e80'0420, // bctr
-    0x6000'0000, // nop
-  };
-
-  static_assert(E::thunk_size == sizeof(plt_thunk));
-  static_assert(E::thunk_size == sizeof(local_thunk));
-
-  for (i64 i = 0; i < symbols.size(); i++) {
-    Symbol<E> &sym = *symbols[i];
-    ul32 *loc = (ul32 *)(buf + i * E::thunk_size);
-
-    if (sym.has_plt(ctx)) {
-      memcpy(loc, plt_thunk, sizeof(plt_thunk));
-      u64 got = sym.has_got(ctx) ? sym.get_got_addr(ctx) : sym.get_gotplt_addr(ctx);
-      i64 val = got - ctx.extra.TOC->value;
-      loc[1] |= higha(val);
-      loc[2] |= lo(val);
-    } else {
-      memcpy(loc, local_thunk, sizeof(local_thunk));
-      i64 val = sym.get_addr(ctx) + get_local_entry_offset(ctx, sym) -
-                ctx.extra.TOC->value;
-      loc[0] |= higha(val);
-      loc[1] |= lo(val);
-    }
-  }
-}
-
-} // namespace mold::elf

elf/arch-riscv.cc

@@ -1,955 +0,0 @@
-// RISC-V is a clean RISC ISA. It supports PC-relative load/store for
-// position-independent code. Its 32-bit and 64-bit ISAs are almost
-// identical. That is, you can think RV32 as a RV64 without 64-bit
-// operations. In this file, we support both RV64 and RV32.
-//
-// RISC-V is essentially little-endian, but the big-endian version is
-// available as an extension. GCC supports `-mbig-endian` to generate
-// big-endian code. Even in big-endian mode, machine instructions are
-// defined to be encoded in little-endian, though. Only the behavior of
-// load/store instructions are different between LE RISC-V and BE RISC-V.
-//
-// From the linker's point of view, the RISC-V's psABI is unique because
-// sections in input object files can be shrunk while being copied to the
-// output file. That is contrary to other psABIs in which sections are an
-// atomic unit of copying. Let me explain it in more details.
-//
-// Since RISC-V instructions are 16-bit or 32-bit long, there's no way to
-// embed a very large immediate into a branch instruction. In fact, JAL
-// (jump and link) instruction can jump to only within PC ± 1 MiB because
-// its immediate is only 21 bits long. If the destination is out of its
-// reach, we need to use two instructions instead; the first instruction
-// being AUIPC which sets upper 20 bits to a register and the second being
-// JALR with a 12-bit immediate and the register. Combined, they specify a
-// 32 bits displacement.
-//
-// Other RISC ISAs have the same limitation, and they solved the problem by
-// letting the linker create so-called "range extension thunks". It works as
-// follows: the compiler optimistically emits single jump instructions for
-// function calls. If the linker finds that a branch target is out of reach,
-// it emits a small piece of machine code near the branch instruction and
-// redirect the branch to the linker-synthesized code. The code constructs a
-// full 32-bit address in a register and jump to the destination. That
-// linker-synthesized code is called "range extension thunks" or just
-// "thunks".
-//
-// The RISC-V psABI is unique that it works the other way around. That is,
-// for RISC-V, the compiler always emits two instructions (AUIPC + JAL) for
-// function calls. If the linker finds the destination is reachable with a
-// single instruction, it replaces the two instructions with the one and
-// shrink the section size by one instruction length, instead of filling the
-// gap with a nop.
-//
-// With the presence of this relaxation, sections can no longer be
-// considered as an atomic unit. If we delete 4 bytes from the middle of a
-// section, all contents after that point needs to be shifted by 4. Symbol
-// values and relocation offsets have to be adjusted accordingly if they
-// refer past the deleted bytes.
-//
-// In mold, we use `r_deltas` to memorize how many bytes have be adjusted
-// for relocations. For symbols, we directly mutate their `value` member.
-//
-// RISC-V object files tend to have way more relocations than those for
-// other targets. This is because all branches, including ones that jump
-// within the same section, are explicitly expressed with relocations.
-// Here is why we need them: all control-flow statements such as `if` or
-// `for` are implemented using branch instructions. For other targets, the
-// compiler doesn't emit relocations for such branches because they know
-// at compile-time exactly how many bytes has to be skipped. That's not
-// true to RISC-V because the linker may delete bytes between a branch and
-// its destination. Therefore, all branches including in-section ones have
-// to be explicitly expressed with relocations.
-//
-// Note that this mechanism only shrink sections and never enlarge, as
-// the compiler always emits the longest instruction sequence. This
-// makes the linker implementation a bit simpler because we don't need
-// to worry about oscillation.
-//
-// https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc
-
-#include "mold.h"
-
-#include <tbb/parallel_for.h>
-#include <tbb/parallel_for_each.h>
-
-namespace mold::elf {
-
-static u32 itype(u32 val) {
-  return val << 20;
-}
-
-static u32 stype(u32 val) {
-  return bits(val, 11, 5) << 25 | bits(val, 4, 0) << 7;
-}
-
-static u32 btype(u32 val) {
-  return bit(val, 12) << 31 | bits(val, 10, 5) << 25 |
-         bits(val, 4, 1) << 8 | bit(val, 11) << 7;
-}
-
-static u32 utype(u32 val) {
-  // U-type instructions are used in combination with I-type
-  // instructions. U-type insn sets an immediate to the upper 20-bits
-  // of a register. I-type insn sign-extends a 12-bits immediate and
-  // adds it to a register value to construct a complete value. 0x800
-  // is added here to compensate for the sign-extension.
-  return (val + 0x800) & 0xffff'f000;
-}
-
-static u32 jtype(u32 val) {
-  return bit(val, 20) << 31 | bits(val, 10, 1)  << 21 |
-         bit(val, 11) << 20 | bits(val, 19, 12) << 12;
-}
-
-static u32 cbtype(u32 val) {
-  return bit(val, 8) << 12 | bit(val, 4) << 11 | bit(val, 3) << 10 |
-         bit(val, 7) << 6  | bit(val, 6) << 5  | bit(val, 2) << 4  |
-         bit(val, 1) << 3  | bit(val, 5) << 2;
-}
-
-static u32 cjtype(u32 val) {
-  return bit(val, 11) << 12 | bit(val, 4)  << 11 | bit(val, 9) << 10 |
-         bit(val, 8)  << 9  | bit(val, 10) << 8  | bit(val, 6) << 7  |
-         bit(val, 7)  << 6  | bit(val, 3)  << 5  | bit(val, 2) << 4  |
-         bit(val, 1)  << 3  | bit(val, 5)  << 2;
-}
-
-static void write_itype(u8 *loc, u32 val) {
-  *(ul32 *)loc &= 0b000000'00000'11111'111'11111'1111111;
-  *(ul32 *)loc |= itype(val);
-}
-
-static void write_stype(u8 *loc, u32 val) {
-  *(ul32 *)loc &= 0b000000'11111'11111'111'00000'1111111;
-  *(ul32 *)loc |= stype(val);
-}
-
-static void write_btype(u8 *loc, u32 val) {
-  *(ul32 *)loc &= 0b000000'11111'11111'111'00000'1111111;
-  *(ul32 *)loc |= btype(val);
-}
-
-static void write_utype(u8 *loc, u32 val) {
-  *(ul32 *)loc &= 0b000000'00000'00000'000'11111'1111111;
-  *(ul32 *)loc |= utype(val);
-}
-
-static void write_jtype(u8 *loc, u32 val) {
-  *(ul32 *)loc &= 0b000000'00000'00000'000'11111'1111111;
-  *(ul32 *)loc |= jtype(val);
-}
-
-static void write_cbtype(u8 *loc, u32 val) {
-  *(ul16 *)loc &= 0b111'000'111'00000'11;
-  *(ul16 *)loc |= cbtype(val);
-}
-
-static void write_cjtype(u8 *loc, u32 val) {
-  *(ul16 *)loc &= 0b111'00000000000'11;
-  *(ul16 *)loc |= cjtype(val);
-}
-
-// Returns the rd register of an R/I/U/J-type instruction.
-static u32 get_rd(u32 val) {
-  return bits(val, 11, 7);
-}
-
-static void set_rs1(u8 *loc, u32 rs1) {
-  assert(rs1 < 32);
-  *(ul32 *)loc &= 0b111111'11111'00000'111'11111'1111111;
-  *(ul32 *)loc |= rs1 << 15;
-}
-
-template <typename E>
-void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ul32 insn_64[] = {
-    0x0000'0397, // auipc  t2, %pcrel_hi(.got.plt)
-    0x41c3'0333, // sub    t1, t1, t3               # .plt entry + hdr + 12
-    0x0003'be03, // ld     t3, %pcrel_lo(1b)(t2)    # _dl_runtime_resolve
-    0xfd43'0313, // addi   t1, t1, -44              # .plt entry
-    0x0003'8293, // addi   t0, t2, %pcrel_lo(1b)    # &.got.plt
-    0x0013'5313, // srli   t1, t1, 1                # .plt entry offset
-    0x0082'b283, // ld     t0, 8(t0)                # link map
-    0x000e'0067, // jr     t3
-  };
-
-  static const ul32 insn_32[] = {
-    0x0000'0397, // auipc  t2, %pcrel_hi(.got.plt)
-    0x41c3'0333, // sub    t1, t1, t3               # .plt entry + hdr + 12
-    0x0003'ae03, // lw     t3, %pcrel_lo(1b)(t2)    # _dl_runtime_resolve
-    0xfd43'0313, // addi   t1, t1, -44              # .plt entry
-    0x0003'8293, // addi   t0, t2, %pcrel_lo(1b)    # &.got.plt
-    0x0023'5313, // srli   t1, t1, 2                # .plt entry offset
-    0x0042'a283, // lw     t0, 4(t0)                # link map
-    0x000e'0067, // jr     t3
-  };
-
-  if constexpr (E::is_64)
-    memcpy(buf, insn_64, sizeof(insn_64));
-  else
-    memcpy(buf, insn_32, sizeof(insn_32));
-
-  u64 gotplt = ctx.gotplt->shdr.sh_addr;
-  u64 plt = ctx.plt->shdr.sh_addr;
-  write_utype(buf, gotplt - plt);
-  write_itype(buf + 8, gotplt - plt);
-  write_itype(buf + 16, gotplt - plt);
-}
-
-static const ul32 plt_entry_64[] = {
-  0x0000'0e17, // auipc   t3, %pcrel_hi([email protected])
-  0x000e'3e03, // ld      t3, %pcrel_lo(1b)(t3)
-  0x000e'0367, // jalr    t1, t3
-  0x0000'0013, // nop
-};
-
-static const ul32 plt_entry_32[] = {
-  0x0000'0e17, // auipc   t3, %pcrel_hi([email protected])
-  0x000e'2e03, // lw      t3, %pcrel_lo(1b)(t3)
-  0x000e'0367, // jalr    t1, t3
-  0x0000'0013, // nop
-};
-
-template <typename E>
-void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  if constexpr (E::is_64)
-    memcpy(buf, plt_entry_64, sizeof(plt_entry_64));
-  else
-    memcpy(buf, plt_entry_32, sizeof(plt_entry_32));
-
-  u64 gotplt = sym.get_gotplt_addr(ctx);
-  u64 plt = sym.get_plt_addr(ctx);
-  write_utype(buf, gotplt - plt);
-  write_itype(buf + 4, gotplt - plt);
-}
-
-template <typename E>
-void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  if constexpr (E::is_64)
-    memcpy(buf, plt_entry_64, sizeof(plt_entry_64));
-  else
-    memcpy(buf, plt_entry_32, sizeof(plt_entry_32));
-
-  u64 got = sym.get_got_addr(ctx);
-  u64 plt = sym.get_plt_addr(ctx);
-  write_utype(buf, got - plt);
-  write_itype(buf + 4, got - plt);
-}
-
-template <typename E>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
-  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
-
-  switch (rel.r_type) {
-  case R_NONE:
-    break;
-  case R_RISCV_ADD32:
-    *(U32<E> *)loc += val;
-    break;
-  case R_RISCV_SUB8:
-    *loc -= val;
-    break;
-  case R_RISCV_SUB16:
-    *(U16<E> *)loc -= val;
-    break;
-  case R_RISCV_SUB32:
-    *(U32<E> *)loc -= val;
-    break;
-  case R_RISCV_SUB6:
-    *loc = (*loc & 0b1100'0000) | ((*loc - val) & 0b0011'1111);
-    break;
-  case R_RISCV_SET6:
-    *loc = (*loc & 0b1100'0000) | (val & 0b0011'1111);
-    break;
-  case R_RISCV_SET8:
-    *loc = val;
-    break;
-  case R_RISCV_SET16:
-    *(U16<E> *)loc = val;
-    break;
-  case R_RISCV_SET32:
-    *(U32<E> *)loc = val;
-    break;
-  case R_RISCV_32_PCREL:
-    *(U32<E> *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  default:
-    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
-  }
-}
-
-template <typename E>
-void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  auto get_r_delta = [&](i64 idx) {
-    return extra.r_deltas.empty() ? 0 : extra.r_deltas[idx];
-  };
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE || rel.r_type == R_RISCV_RELAX)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    i64 r_offset = rel.r_offset - get_r_delta(i);
-    i64 removed_bytes = get_r_delta(i + 1) - get_r_delta(i);
-    u8 *loc = base + r_offset;
-
-    auto check = [&](i64 val, i64 lo, i64 hi) {
-      if (val < lo || hi <= val)
-        Error(ctx) << *this << ": relocation " << rel << " against "
-                   << sym << " out of range: " << val << " is not in ["
-                   << lo << ", " << hi << ")";
-    };
-
-    u64 S = sym.get_addr(ctx);
-    u64 A = rel.r_addend;
-    u64 P = get_addr() + r_offset;
-    u64 G = sym.get_got_idx(ctx) * sizeof(Word<E>);
-    u64 GOT = ctx.got->shdr.sh_addr;
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-      if constexpr (E::is_64)
-        *(U32<E> *)loc = S + A;
-      else
-        apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
-    case R_RISCV_64:
-      assert(E::is_64);
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
-    case R_RISCV_BRANCH: {
-      i64 val = S + A - P;
-      check(val, -(1 << 12), 1 << 12);
-      write_btype(loc, val);
-      break;
-    }
-    case R_RISCV_JAL: {
-      i64 val = S + A - P;
-      check(val, -(1 << 20), 1 << 20);
-      write_jtype(loc, val);
-      break;
-    }
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT: {
-      u32 rd = get_rd(*(ul32 *)(contents.data() + rel.r_offset + 4));
-
-      if (removed_bytes == 4) {
-        // auipc + jalr -> jal
-        *(ul32 *)loc = (rd << 7) | 0b1101111;
-        write_jtype(loc, S + A - P);
-      } else if (removed_bytes == 6 && rd == 0) {
-        // auipc + jalr -> c.j
-        *(ul16 *)loc = 0b101'00000000000'01;
-        write_cjtype(loc, S + A - P);
-      } else if (removed_bytes == 6 && rd == 1) {
-        // auipc + jalr -> c.jal
-        assert(!E::is_64);
-        *(ul16 *)loc = 0b001'00000000000'01;
-        write_cjtype(loc, S + A - P);
-      } else {
-        assert(removed_bytes == 0);
-        u64 val = sym.esym().is_undef_weak() ? 0 : S + A - P;
-        check(val, -(1LL << 31), 1LL << 31);
-        write_utype(loc, val);
-        write_itype(loc + 4, val);
-      }
-      break;
-    }
-    case R_RISCV_GOT_HI20:
-      *(ul32 *)loc = G + GOT + A - P;
-      break;
-    case R_RISCV_TLS_GOT_HI20:
-      *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - P;
-      break;
-    case R_RISCV_TLS_GD_HI20:
-      *(ul32 *)loc = sym.get_tlsgd_addr(ctx) + A - P;
-      break;
-    case R_RISCV_PCREL_HI20:
-      if (sym.esym().is_undef_weak()) {
-        // Calling an undefined weak symbol does not make sense.
-        // We make such call into an infinite loop. This should
-        // help debugging of a faulty program.
-        *(ul32 *)loc = 0;
-      } else {
-        *(ul32 *)loc = S + A - P;
-      }
-      break;
-    case R_RISCV_HI20: {
-      i64 val = S + A;
-      if (removed_bytes == 0) {
-        check(val, -(1LL << 31), 1LL << 31);
-        write_utype(loc, val);
-      } else {
-        assert(removed_bytes == 4);
-        assert(sign_extend(val, 11) == val);
-      }
-      break;
-    }
-    case R_RISCV_LO12_I:
-    case R_RISCV_LO12_S: {
-      i64 val = S + A;
-      if (rel.r_type == R_RISCV_LO12_I)
-        write_itype(loc, val);
-      else
-        write_stype(loc, val);
-
-      // Rewrite `lw t1, 0(t0)` with `lw t1, 0(x0)` if the address is
-      // accessible relative to the zero register. If the upper 20 bits
-      // are all zero, the corresponding LUI might have been removed.
-      if (sign_extend(val, 11) == val)
-        set_rs1(loc, 0);
-      break;
-    }
-    case R_RISCV_TPREL_HI20:
-      assert(removed_bytes == 0 || removed_bytes == 4);
-      if (removed_bytes == 0)
-        write_utype(loc, S + A - ctx.tp_addr);
-      break;
-    case R_RISCV_TPREL_ADD:
-      break;
-    case R_RISCV_TPREL_LO12_I:
-    case R_RISCV_TPREL_LO12_S: {
-      i64 val = S + A - ctx.tp_addr;
-      if (rel.r_type == R_RISCV_TPREL_LO12_I)
-        write_itype(loc, val);
-      else
-        write_stype(loc, val);
-
-      // Rewrite `lw t1, 0(t0)` with `lw t1, 0(tp)` if the address is
-      // directly accessible using tp. tp is x4.
-      if (sign_extend(val, 11) == val)
-        set_rs1(loc, 4);
-      break;
-    }
-    case R_RISCV_ADD8:
-      loc += S + A;
-      break;
-    case R_RISCV_ADD16:
-      *(U16<E> *)loc += S + A;
-      break;
-    case R_RISCV_ADD32:
-      *(U32<E> *)loc += S + A;
-      break;
-    case R_RISCV_ADD64:
-      *(U64<E> *)loc += S + A;
-      break;
-    case R_RISCV_SUB8:
-      loc -= S + A;
-      break;
-    case R_RISCV_SUB16:
-      *(U16<E> *)loc -= S + A;
-      break;
-    case R_RISCV_SUB32:
-      *(U32<E> *)loc -= S + A;
-      break;
-    case R_RISCV_SUB64:
-      *(U64<E> *)loc -= S + A;
-      break;
-    case R_RISCV_ALIGN: {
-      // A R_RISCV_ALIGN is followed by a NOP sequence. We need to remove
-      // zero or more bytes so that the instruction after R_RISCV_ALIGN is
-      // aligned to a given alignment boundary.
-      //
-      // We need to guarantee that the NOP sequence is valid after byte
-      // removal (e.g. we can't remove the first 2 bytes of a 4-byte NOP).
-      // For the sake of simplicity, we always rewrite the entire NOP sequence.
-      i64 padding_bytes = rel.r_addend - removed_bytes;
-      assert((padding_bytes & 1) == 0);
-
-      i64 i = 0;
-      for (; i <= padding_bytes - 4; i += 4)
-        *(ul32 *)(loc + i) = 0x0000'0013; // nop
-      if (i < padding_bytes)
-        *(ul16 *)(loc + i) = 0x0001;      // c.nop
-      break;
-    }
-    case R_RISCV_RVC_BRANCH: {
-      i64 val = S + A - P;
-      check(val, -(1 << 8), 1 << 8);
-      write_cbtype(loc, val);
-      break;
-    }
-    case R_RISCV_RVC_JUMP: {
-      i64 val = S + A - P;
-      check(val, -(1 << 11), 1 << 11);
-      write_cjtype(loc, val);
-      break;
-    }
-    case R_RISCV_SUB6:
-      *loc = (*loc & 0b1100'0000) | ((*loc - (S + A)) & 0b0011'1111);
-      break;
-    case R_RISCV_SET6:
-      *loc = (*loc & 0b1100'0000) | ((S + A) & 0b0011'1111);
-      break;
-    case R_RISCV_SET8:
-      *loc = S + A;
-      break;
-    case R_RISCV_SET16:
-      *(U16<E> *)loc = S + A;
-      break;
-    case R_RISCV_SET32:
-      *(U32<E> *)loc = S + A;
-      break;
-    case R_RISCV_32_PCREL:
-      *(U32<E> *)loc = S + A - P;
-      break;
-    case R_RISCV_PCREL_LO12_I:
-    case R_RISCV_PCREL_LO12_S:
-      // These relocations are handled in the next loop.
-      break;
-    default:
-      unreachable();
-    }
-  }
-
-  // Handle PC-relative LO12 relocations. In the above loop, pcrel HI20
-  // relocations overwrote instructions with full 32-bit values to allow
-  // their corresponding pcrel LO12 relocations to read their values.
-  for (i64 i = 0; i < rels.size(); i++) {
-    switch (rels[i].r_type) {
-    case R_RISCV_PCREL_LO12_I:
-    case R_RISCV_PCREL_LO12_S: {
-      Symbol<E> &sym = *file.symbols[rels[i].r_sym];
-      assert(sym.get_input_section() == this);
-
-      u8 *loc = base + rels[i].r_offset - get_r_delta(i);
-      u32 val = *(ul32 *)(base + sym.value);
-
-      if (rels[i].r_type == R_RISCV_PCREL_LO12_I)
-        write_itype(loc, val);
-      else
-        write_stype(loc, val);
-    }
-    }
-  }
-
-  // Restore the original instructions pcrel HI20 relocations overwrote.
-  for (i64 i = 0; i < rels.size(); i++) {
-    switch (rels[i].r_type) {
-    case R_RISCV_GOT_HI20:
-    case R_RISCV_PCREL_HI20:
-    case R_RISCV_TLS_GOT_HI20:
-    case R_RISCV_TLS_GD_HI20: {
-      u8 *loc = base + rels[i].r_offset - get_r_delta(i);
-      u32 val = *(ul32 *)loc;
-      memcpy(loc, contents.data() + rels[i].r_offset, 4);
-      write_utype(loc, val);
-    }
-    }
-  }
-}
-
-template <typename E>
-void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    SectionFragment<E> *frag;
-    i64 frag_addend;
-    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
-
-    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
-    u64 A = frag ? frag_addend : (i64)rel.r_addend;
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-      *(U32<E> *)loc = S + A;
-      break;
-    case R_RISCV_64:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(U64<E> *)loc = *val;
-      else
-        *(U64<E> *)loc = S + A;
-      break;
-    case R_RISCV_ADD8:
-      *loc += S + A;
-      break;
-    case R_RISCV_ADD16:
-      *(U16<E> *)loc += S + A;
-      break;
-    case R_RISCV_ADD32:
-      *(U32<E> *)loc += S + A;
-      break;
-    case R_RISCV_ADD64:
-      *(U64<E> *)loc += S + A;
-      break;
-    case R_RISCV_SUB8:
-      *loc -= S + A;
-      break;
-    case R_RISCV_SUB16:
-      *(U16<E> *)loc -= S + A;
-      break;
-    case R_RISCV_SUB32:
-      *(U32<E> *)loc -= S + A;
-      break;
-    case R_RISCV_SUB64:
-      *(U64<E> *)loc -= S + A;
-      break;
-    case R_RISCV_SUB6:
-      *loc = (*loc & 0b1100'0000) | ((*loc - (S + A)) & 0b0011'1111);
-      break;
-    case R_RISCV_SET6:
-      *loc = (*loc & 0b1100'0000) | ((S + A) & 0b0011'1111);
-      break;
-    case R_RISCV_SET8:
-      *loc = S + A;
-      break;
-    case R_RISCV_SET16:
-      *(U16<E> *)loc = S + A;
-      break;
-    case R_RISCV_SET32:
-      *(U32<E> *)loc = S + A;
-      break;
-    default:
-      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
-                 << rel;
-      break;
-    }
-  }
-}
-
-template <typename E>
-void InputSection<E>::copy_contents_riscv(Context<E> &ctx, u8 *buf) {
-  // If a section is not relaxed, we can copy it as a one big chunk.
-  if (extra.r_deltas.empty()) {
-    uncompress_to(ctx, buf);
-    return;
-  }
-
-  // Memory-allocated sections may be relaxed, so copy each segment
-  // individually.
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-  i64 pos = 0;
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    i64 delta = extra.r_deltas[i + 1] - extra.r_deltas[i];
-    if (delta == 0)
-      continue;
-    assert(delta > 0);
-
-    const ElfRel<E> &r = rels[i];
-    memcpy(buf, contents.data() + pos, r.r_offset - pos);
-    buf += r.r_offset - pos;
-    pos = r.r_offset + delta;
-  }
-
-  memcpy(buf, contents.data() + pos, contents.size() - pos);
-}
-
-template <typename E>
-void InputSection<E>::scan_relocations(Context<E> &ctx) {
-  assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  // Scan relocations
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-      if constexpr (E::is_64)
-        scan_absrel(ctx, sym, rel);
-      else
-        scan_dyn_absrel(ctx, sym, rel);
-      break;
-    case R_RISCV_HI20:
-      scan_absrel(ctx, sym, rel);
-      break;
-    case R_RISCV_64:
-      if constexpr (!E::is_64)
-        Fatal(ctx) << *this << ": R_RISCV_64 cannot be used on RV32";
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT:
-      if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
-      break;
-    case R_RISCV_GOT_HI20:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      break;
-    case R_RISCV_TLS_GOT_HI20:
-      ctx.has_gottp_rel.store(true, std::memory_order_relaxed);
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
-      break;
-    case R_RISCV_TLS_GD_HI20:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
-      break;
-    case R_RISCV_32_PCREL:
-      scan_pcrel(ctx, sym, rel);
-      break;
-    case R_RISCV_BRANCH:
-    case R_RISCV_JAL:
-    case R_RISCV_PCREL_HI20:
-    case R_RISCV_PCREL_LO12_I:
-    case R_RISCV_PCREL_LO12_S:
-    case R_RISCV_LO12_I:
-    case R_RISCV_LO12_S:
-    case R_RISCV_TPREL_HI20:
-    case R_RISCV_TPREL_LO12_I:
-    case R_RISCV_TPREL_LO12_S:
-    case R_RISCV_TPREL_ADD:
-    case R_RISCV_ADD8:
-    case R_RISCV_ADD16:
-    case R_RISCV_ADD32:
-    case R_RISCV_ADD64:
-    case R_RISCV_SUB8:
-    case R_RISCV_SUB16:
-    case R_RISCV_SUB32:
-    case R_RISCV_SUB64:
-    case R_RISCV_ALIGN:
-    case R_RISCV_RVC_BRANCH:
-    case R_RISCV_RVC_JUMP:
-    case R_RISCV_RELAX:
-    case R_RISCV_SUB6:
-    case R_RISCV_SET6:
-    case R_RISCV_SET8:
-    case R_RISCV_SET16:
-    case R_RISCV_SET32:
-      break;
-    default:
-      Error(ctx) << *this << ": unknown relocation: " << rel;
-    }
-  }
-}
-
-template <typename E>
-static bool is_resizable(Context<E> &ctx, InputSection<E> *isec) {
-  return isec && isec->is_alive && (isec->shdr().sh_flags & SHF_ALLOC) &&
-         (isec->shdr().sh_flags & SHF_EXECINSTR);
-}
-
-// Returns the distance between a relocated place and a symbol.
-template <typename E>
-static i64 compute_distance(Context<E> &ctx, Symbol<E> &sym,
-                            InputSection<E> &isec, const ElfRel<E> &rel) {
-  // We handle absolute symbols as if they were infinitely far away
-  // because `shrink_section` may increase a distance between a branch
-  // instruction and an absolute symbol. Branching to an absolute
-  // location is extremely rare in real code, though.
-  if (sym.is_absolute())
-    return INT32_MAX;
-
-  // Likewise, relocations against weak undefined symbols won't be relaxed.
-  if (sym.esym().is_undef_weak())
-    return INT32_MAX;
-
-  // Compute a distance between the relocated place and the symbol.
-  i64 S = sym.get_addr(ctx);
-  i64 A = rel.r_addend;
-  i64 P = isec.get_addr() + rel.r_offset;
-  return S + A - P;
-}
-
-// Scan relocations to shrink sections.
-template <typename E>
-static void shrink_section(Context<E> &ctx, InputSection<E> &isec, bool use_rvc) {
-  std::span<const ElfRel<E>> rels = isec.get_rels(ctx);
-  isec.extra.r_deltas.resize(rels.size() + 1);
-
-  i64 delta = 0;
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &r = rels[i];
-    Symbol<E> &sym = *isec.file.symbols[r.r_sym];
-    isec.extra.r_deltas[i] = delta;
-
-    // Handling R_RISCV_ALIGN is mandatory.
-    //
-    // R_RISCV_ALIGN refers NOP instructions. We need to eliminate some
-    // or all of the instructions so that the instruction that immediately
-    // follows the NOPs is aligned to a specified alignment boundary.
-    if (r.r_type == R_RISCV_ALIGN) {
-      // The total bytes of NOPs is stored to r_addend, so the next
-      // instruction is r_addend away.
-      u64 loc = isec.get_addr() + r.r_offset - delta;
-      u64 next_loc = loc + r.r_addend;
-      u64 alignment = bit_ceil(r.r_addend + 1);
-      assert(alignment <= (1 << isec.p2align));
-      delta += next_loc - align_to(loc, alignment);
-      continue;
-    }
-
-    // Handling other relocations is optional.
-    if (!ctx.arg.relax || i == rels.size() - 1 ||
-        rels[i + 1].r_type != R_RISCV_RELAX)
-      continue;
-
-    // Linker-synthesized symbols haven't been assigned their final
-    // values when we are shrinking sections because actual values can
-    // be computed only after we fix the file layout. Therefore, we
-    // assume that relocations against such symbols are always
-    // non-relaxable.
-    if (sym.file == ctx.internal_obj)
-      continue;
-
-    switch (r.r_type) {
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT: {
-      // These relocations refer an AUIPC + JALR instruction pair to
-      // allow to jump to anywhere in PC ± 2 GiB. If the jump target is
-      // close enough to PC, we can use C.J, C.JAL or JAL instead.
-      i64 dist = compute_distance(ctx, sym, isec, r);
-      if (dist & 1)
-        break;
-
-      std::string_view contents = isec.contents;
-      i64 rd = get_rd(*(ul32 *)(contents.data() + r.r_offset + 4));
-
-      if (rd == 0 && sign_extend(dist, 11) == dist && use_rvc) {
-        // If rd is x0 and the jump target is within ±2 KiB, we can use
-        // C.J, saving 6 bytes.
-        delta += 6;
-      } else if (rd == 1 && sign_extend(dist, 11) == dist && use_rvc && !E::is_64) {
-        // If rd is x1 and the jump target is within ±2 KiB, we can use
-        // C.JAL. This is RV32 only because C.JAL is RV32-only instruction.
-        delta += 6;
-      } else if (sign_extend(dist, 20) == dist) {
-        // If the jump target is within ±1 MiB, we can use JAL.
-        delta += 4;
-      }
-      break;
-    }
-    case R_RISCV_HI20: {
-      // If the upper 20 bits are all zero, we can remove LUI.
-      // The corresponding instructions referred by LO12_I/LO12_S
-      // relocations will use the zero register instead.
-      i64 val = sym.get_addr(ctx);
-      if (sign_extend(val, 11) == val)
-        delta += 4;
-      break;
-    }
-    case R_RISCV_TPREL_HI20:
-    case R_RISCV_TPREL_ADD: {
-      // These relocations are used to materialize the upper 20 bits of
-      // an address relative to the thread pointer as follows:
-      //
-      //  lui  a5,%tprel_hi(foo)         # R_RISCV_TPREL_HI20 (symbol)
-      //  add  a5,a5,tp,%tprel_add(foo)  # R_RISCV_TPREL_ADD (symbol)
-      //
-      // Then thread-local variable `foo` is accessed with a 12-bit offset
-      // like this:
-      //
-      //  sw   t0,%tprel_lo(foo)(a5)     # R_RISCV_TPREL_LO12_S (symbol)
-      //
-      // However, if the offset is ±2 KiB, we don't need to materialize
-      // the upper 20 bits in a register. We can instead access the
-      // thread-local variable directly with TP like this:
-      //
-      //  sw   t0,%tprel_lo(foo)(tp)
-      //
-      // Here, we remove `lui` and `add` if the offset is within ±2 KiB.
-      i64 val = sym.get_addr(ctx) + r.r_addend - ctx.tp_addr;
-      if (sign_extend(val, 11) == val)
-        delta += 4;
-      break;
-    }
-    }
-  }
-
-  isec.extra.r_deltas[rels.size()] = delta;
-  isec.sh_size -= delta;
-}
-
-// Shrink sections by interpreting relocations.
-//
-// This operation seems to be optional, because by default longest
-// instructions are being used. However, calling this function is actually
-// mandatory because of R_RISCV_ALIGN. R_RISCV_ALIGN is a directive to the
-// linker to align the location referred to by the relocation to a
-// specified byte boundary. We at least have to interpret them to satisfy
-// the alignment constraints.
-template <typename E>
-i64 riscv_resize_sections(Context<E> &ctx) {
-  Timer t(ctx, "riscv_resize_sections");
-
-  // True if we can use the 2-byte instructions. This is usually true on
-  // Unix because RV64GC is generally considered the baseline hardware.
-  bool use_rvc = get_eflags(ctx) & EF_RISCV_RVC;
-
-  // Find all the relocations that can be relaxed.
-  // This step should only shrink sections.
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    for (std::unique_ptr<InputSection<E>> &isec : file->sections)
-      if (is_resizable(ctx, isec.get()))
-        shrink_section(ctx, *isec, use_rvc);
-  });
-
-  // Fix symbol values.
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    for (Symbol<E> *sym : file->symbols) {
-      if (sym->file != file)
-        continue;
-
-      InputSection<E> *isec = sym->get_input_section();
-      if (!isec || isec->extra.r_deltas.empty())
-        continue;
-
-      std::span<const ElfRel<E>> rels = isec->get_rels(ctx);
-      auto it = std::lower_bound(rels.begin(), rels.end(), sym->value,
-                                 [&](const ElfRel<E> &r, u64 val) {
-        return r.r_offset < val;
-      });
-
-      sym->value -= isec->extra.r_deltas[it - rels.begin()];
-    }
-  });
-
-  // Re-compute section offset again to finalize them.
-  compute_section_sizes(ctx);
-  return set_osec_offsets(ctx);
-}
-
-#define INSTANTIATE(E)                                                       \
-  template void write_plt_header(Context<E> &, u8 *);                        \
-  template void write_plt_entry(Context<E> &, u8 *, Symbol<E> &);            \
-  template void write_pltgot_entry(Context<E> &, u8 *, Symbol<E> &);         \
-  template void                                                              \
-  EhFrameSection<E>::apply_reloc(Context<E> &, const ElfRel<E> &, u64, u64); \
-  template void InputSection<E>::apply_reloc_alloc(Context<E> &, u8 *);      \
-  template void InputSection<E>::apply_reloc_nonalloc(Context<E> &, u8 *);   \
-  template void InputSection<E>::copy_contents_riscv(Context<E> &, u8 *);    \
-  template void InputSection<E>::scan_relocations(Context<E> &);             \
-  template i64 riscv_resize_sections(Context<E> &);
-
-INSTANTIATE(RV64LE);
-INSTANTIATE(RV64BE);
-INSTANTIATE(RV32LE);
-INSTANTIATE(RV32BE);
-
-} // namespace mold::elf

elf/arch-x86-64.cc

@@ -1,752 +0,0 @@
-// Supporting x86-64 is straightforward. Unlike its predecessor, i386,
-// x86-64 supports PC-relative addressing for position-independent code.
-// Being CISC, its instructions are variable in size. Branch instructions
-// take 4 bytes offsets, so we don't need range extension thunks.
-//
-// The psABI specifies %r11 as neither caller- nor callee-saved. It's
-// intentionally left out so that we can use it as a scratch register in
-// PLT.
-//
-// Thread Pointer (TP) is stored not to a general-purpose register but to
-// FS segment register. Segment register is a 64-bits register which can
-// be used as a base address for memory access. Each thread has a unique
-// FS value, and they access their thread-local variables relative to FS
-// as %fs:offset_from_tp.
-//
-// The value of a segment register itself is not generally readable from
-// the user space. As a workaround, libc initializes %fs:0 (the first word
-// referenced by FS) to the value of %fs itself. So we can obtain TP just
-// by `mov %fs:0, %rax` if we need it.
-//
-// For historical reasons, TP points past the end of the TLS block on x86.
-// This is contrary to other psABIs which usually use the beginning of the
-// TLS block as TP (with some addend). As a result, offsets from TP to
-// thread-local variables (TLVs) in the main executable are all negative.
-//
-// https://github.com/rui314/mold/wiki/i386-psabi.pdf
-// https://github.com/rui314/mold/wiki/x86-64-psabi.pdf
-
-#include "mold.h"
-
-namespace mold::elf {
-
-using E = X86_64;
-
-// This is a security-enhanced version of the regular PLT. The PLT
-// header and each PLT entry starts with endbr64 for the Intel's
-// control-flow enforcement security mechanism.
-//
-// Note that our IBT-enabled PLT instruction sequence is different
-// from the one used in GNU ld. GNU's IBTPLT implementation uses two
-// separate sections (.plt and .plt.sec) in which one PLT entry takes
-// 32 bytes in total. Our IBTPLT consists of just .plt and each entry
-// is 16 bytes long.
-//
-// Our PLT entry clobbers %r11, but that's fine because the resolver
-// function (_dl_runtime_resolve) clobbers %r11 anyway.
-template <>
-void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const u8 insn[] = {
-    0xf3, 0x0f, 0x1e, 0xfa, // endbr64
-    0x41, 0x53,             // push %r11
-    0xff, 0x35, 0, 0, 0, 0, // push GOTPLT+8(%rip)
-    0xff, 0x25, 0, 0, 0, 0, // jmp *GOTPLT+16(%rip)
-    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
-    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
-    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
-    0xcc, 0xcc,             // (padding)
-  };
-
-  memcpy(buf, insn, sizeof(insn));
-  *(ul32 *)(buf + 8) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 4;
-  *(ul32 *)(buf + 14) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 2;
-}
-
-template <>
-void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  static const u8 insn[] = {
-    0xf3, 0x0f, 0x1e, 0xfa, // endbr64
-    0x41, 0xbb, 0, 0, 0, 0, // mov $index_in_relplt, %r11d
-    0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOTPLT
-  };
-
-  memcpy(buf, insn, sizeof(insn));
-  *(ul32 *)(buf + 6) = sym.get_plt_idx(ctx);
-  *(ul32 *)(buf + 12) = sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx) - 16;
-}
-
-template <>
-void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  static const u8 insn[] = {
-    0xf3, 0x0f, 0x1e, 0xfa, // endbr64
-    0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOT
-    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
-    0xcc, 0xcc,             // (padding)
-  };
-
-  memcpy(buf, insn, sizeof(insn));
-  *(ul32 *)(buf + 6) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 10;
-}
-
-template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
-  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
-
-  switch (rel.r_type) {
-  case R_NONE:
-    break;
-  case R_X86_64_32:
-    *(ul32 *)loc = val;
-    break;
-  case R_X86_64_64:
-    *(ul64 *)loc = val;
-    break;
-  case R_X86_64_PC32:
-    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  case R_X86_64_PC64:
-    *(ul64 *)loc = val - this->shdr.sh_addr - offset;
-    break;
-  default:
-    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
-  }
-}
-
-static u32 relax_gotpcrelx(u8 *loc) {
-  switch ((loc[0] << 8) | loc[1]) {
-  case 0xff15: return 0x90e8; // call *0(%rip) -> call 0
-  case 0xff25: return 0x90e9; // jmp  *0(%rip) -> jmp  0
-  }
-  return 0;
-}
-
-static u32 relax_rex_gotpcrelx(u8 *loc) {
-  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
-  case 0x488b05: return 0x488d05; // mov 0(%rip), %rax -> lea 0(%rip), %rax
-  case 0x488b0d: return 0x488d0d; // mov 0(%rip), %rcx -> lea 0(%rip), %rcx
-  case 0x488b15: return 0x488d15; // mov 0(%rip), %rdx -> lea 0(%rip), %rdx
-  case 0x488b1d: return 0x488d1d; // mov 0(%rip), %rbx -> lea 0(%rip), %rbx
-  case 0x488b25: return 0x488d25; // mov 0(%rip), %rsp -> lea 0(%rip), %rsp
-  case 0x488b2d: return 0x488d2d; // mov 0(%rip), %rbp -> lea 0(%rip), %rbp
-  case 0x488b35: return 0x488d35; // mov 0(%rip), %rsi -> lea 0(%rip), %rsi
-  case 0x488b3d: return 0x488d3d; // mov 0(%rip), %rdi -> lea 0(%rip), %rdi
-  case 0x4c8b05: return 0x4c8d05; // mov 0(%rip), %r8  -> lea 0(%rip), %r8
-  case 0x4c8b0d: return 0x4c8d0d; // mov 0(%rip), %r9  -> lea 0(%rip), %r9
-  case 0x4c8b15: return 0x4c8d15; // mov 0(%rip), %r10 -> lea 0(%rip), %r10
-  case 0x4c8b1d: return 0x4c8d1d; // mov 0(%rip), %r11 -> lea 0(%rip), %r11
-  case 0x4c8b25: return 0x4c8d25; // mov 0(%rip), %r12 -> lea 0(%rip), %r12
-  case 0x4c8b2d: return 0x4c8d2d; // mov 0(%rip), %r13 -> lea 0(%rip), %r13
-  case 0x4c8b35: return 0x4c8d35; // mov 0(%rip), %r14 -> lea 0(%rip), %r14
-  case 0x4c8b3d: return 0x4c8d3d; // mov 0(%rip), %r15 -> lea 0(%rip), %r15
-  }
-  return 0;
-}
-
-static u32 relax_gottpoff(u8 *loc) {
-  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
-  case 0x488b05: return 0x48c7c0; // mov 0(%rip), %rax -> mov $0, %rax
-  case 0x488b0d: return 0x48c7c1; // mov 0(%rip), %rcx -> mov $0, %rcx
-  case 0x488b15: return 0x48c7c2; // mov 0(%rip), %rdx -> mov $0, %rdx
-  case 0x488b1d: return 0x48c7c3; // mov 0(%rip), %rbx -> mov $0, %rbx
-  case 0x488b25: return 0x48c7c4; // mov 0(%rip), %rsp -> mov $0, %rsp
-  case 0x488b2d: return 0x48c7c5; // mov 0(%rip), %rbp -> mov $0, %rbp
-  case 0x488b35: return 0x48c7c6; // mov 0(%rip), %rsi -> mov $0, %rsi
-  case 0x488b3d: return 0x48c7c7; // mov 0(%rip), %rdi -> mov $0, %rdi
-  case 0x4c8b05: return 0x49c7c0; // mov 0(%rip), %r8  -> mov $0, %r8
-  case 0x4c8b0d: return 0x49c7c1; // mov 0(%rip), %r9  -> mov $0, %r9
-  case 0x4c8b15: return 0x49c7c2; // mov 0(%rip), %r10 -> mov $0, %r10
-  case 0x4c8b1d: return 0x49c7c3; // mov 0(%rip), %r11 -> mov $0, %r11
-  case 0x4c8b25: return 0x49c7c4; // mov 0(%rip), %r12 -> mov $0, %r12
-  case 0x4c8b2d: return 0x49c7c5; // mov 0(%rip), %r13 -> mov $0, %r13
-  case 0x4c8b35: return 0x49c7c6; // mov 0(%rip), %r14 -> mov $0, %r14
-  case 0x4c8b3d: return 0x49c7c7; // mov 0(%rip), %r15 -> mov $0, %r15
-  }
-  return 0;
-}
-
-static u32 relax_gotpc32_tlsdesc(u8 *loc) {
-  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
-  case 0x488d05: return 0x48c7c0; // lea 0(%rip), %rax -> mov $0, %rax
-  case 0x488d0d: return 0x48c7c1; // lea 0(%rip), %rcx -> mov $0, %rcx
-  case 0x488d15: return 0x48c7c2; // lea 0(%rip), %rdx -> mov $0, %rdx
-  case 0x488d1d: return 0x48c7c3; // lea 0(%rip), %rbx -> mov $0, %rbx
-  case 0x488d25: return 0x48c7c4; // lea 0(%rip), %rsp -> mov $0, %rsp
-  case 0x488d2d: return 0x48c7c5; // lea 0(%rip), %rbp -> mov $0, %rbp
-  case 0x488d35: return 0x48c7c6; // lea 0(%rip), %rsi -> mov $0, %rsi
-  case 0x488d3d: return 0x48c7c7; // lea 0(%rip), %rdi -> mov $0, %rdi
-  case 0x4c8d05: return 0x49c7c0; // lea 0(%rip), %r8  -> mov $0, %r8
-  case 0x4c8d0d: return 0x49c7c1; // lea 0(%rip), %r9  -> mov $0, %r9
-  case 0x4c8d15: return 0x49c7c2; // lea 0(%rip), %r10 -> mov $0, %r10
-  case 0x4c8d1d: return 0x49c7c3; // lea 0(%rip), %r11 -> mov $0, %r11
-  case 0x4c8d25: return 0x49c7c4; // lea 0(%rip), %r12 -> mov $0, %r12
-  case 0x4c8d2d: return 0x49c7c5; // lea 0(%rip), %r13 -> mov $0, %r13
-  case 0x4c8d35: return 0x49c7c6; // lea 0(%rip), %r14 -> mov $0, %r14
-  case 0x4c8d3d: return 0x49c7c7; // lea 0(%rip), %r15 -> mov $0, %r15
-  }
-  return 0;
-}
-
-// Apply relocations to SHF_ALLOC sections (i.e. sections that are
-// mapped to memory at runtime) based on the result of
-// scan_relocations().
-template <>
-void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    auto check = [&](i64 val, i64 lo, i64 hi) {
-      if (val < lo || hi <= val)
-        Error(ctx) << *this << ": relocation " << rel << " against "
-                   << sym << " out of range: " << val << " is not in ["
-                   << lo << ", " << hi << ")";
-    };
-
-    auto write32 = [&](u64 val) {
-      check(val, 0, 1LL << 32);
-      *(ul32 *)loc = val;
-    };
-
-    auto write32s = [&](u64 val) {
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ul32 *)loc = val;
-    };
-
-    u64 S = sym.get_addr(ctx);
-    u64 A = rel.r_addend;
-    u64 P = get_addr() + rel.r_offset;
-    u64 G = sym.get_got_addr(ctx) - ctx.gotplt->shdr.sh_addr;
-    u64 GOTPLT = ctx.gotplt->shdr.sh_addr;
-
-    switch (rel.r_type) {
-    case R_X86_64_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *loc = val;
-      break;
-    }
-    case R_X86_64_16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ul16 *)loc = val;
-      break;
-    }
-    case R_X86_64_32:
-      write32(S + A);
-      break;
-    case R_X86_64_32S:
-      write32s(S + A);
-      break;
-    case R_X86_64_64:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
-    case R_X86_64_PC8: {
-      i64 val = S + A - P;
-      check(val, -(1 << 7), 1 << 7);
-      *loc = val;
-      break;
-    }
-    case R_X86_64_PC16: {
-      i64 val = S + A - P;
-      check(val, -(1 << 15), 1 << 15);
-      *(ul16 *)loc = val;
-      break;
-    }
-    case R_X86_64_PC32:
-    case R_X86_64_PLT32:
-      write32s(S + A - P);
-      break;
-    case R_X86_64_PC64:
-      *(ul64 *)loc = S + A - P;
-      break;
-    case R_X86_64_GOT32:
-      write32s(G + A);
-      break;
-    case R_X86_64_GOT64:
-      *(ul64 *)loc = G + A;
-      break;
-    case R_X86_64_GOTOFF64:
-    case R_X86_64_PLTOFF64:
-      *(ul64 *)loc = S + A - GOTPLT;
-      break;
-    case R_X86_64_GOTPC32:
-      write32s(GOTPLT + A - P);
-      break;
-    case R_X86_64_GOTPC64:
-      *(ul64 *)loc = GOTPLT + A - P;
-      break;
-    case R_X86_64_GOTPCREL:
-      write32s(G + GOTPLT + A - P);
-      break;
-    case R_X86_64_GOTPCREL64:
-      *(ul64 *)loc = G + GOTPLT + A - P;
-      break;
-    case R_X86_64_GOTPCRELX:
-      if (sym.has_got(ctx)) {
-        write32s(G + GOTPLT + A - P);
-      } else {
-        u32 insn = relax_gotpcrelx(loc - 2);
-        loc[-2] = insn >> 8;
-        loc[-1] = insn;
-        write32s(S + A - P);
-      }
-      break;
-    case R_X86_64_REX_GOTPCRELX:
-      if (sym.has_got(ctx)) {
-        write32s(G + GOTPLT + A - P);
-      } else {
-        u32 insn = relax_rex_gotpcrelx(loc - 3);
-        loc[-3] = insn >> 16;
-        loc[-2] = insn >> 8;
-        loc[-1] = insn;
-        write32s(S + A - P);
-      }
-      break;
-    case R_X86_64_TLSGD:
-      if (sym.has_tlsgd(ctx)) {
-        write32s(sym.get_tlsgd_addr(ctx) + A - P);
-      } else {
-        // Relax GD to LE. If we are creating an exectuable, the offset of
-        // a thread-local variable from TP is a link-time constant. So we
-        // don't need to call __tls_get_addr to obtain the address of a TLV.
-        i64 val = S - ctx.tp_addr;
-        assert(A == -4);
-        check(val, -(1LL << 31), 1LL << 31);
-
-        switch (rels[i + 1].r_type) {
-        case R_X86_64_PLT32:
-        case R_X86_64_PC32:
-        case R_X86_64_GOTPCREL:
-        case R_X86_64_GOTPCRELX: {
-          // The original instructions are the following:
-          //
-          //  66 48 8d 3d 00 00 00 00    lea  foo@tlsgd(%rip), %rdi
-          //  66 66 48 e8 00 00 00 00    call __tls_get_addr
-          //
-          // or
-          //
-          //  66 48 8d 3d 00 00 00 00    lea foo@tlsgd(%rip), %rdi
-          //  66 48 ff 15 00 00 00 00    call *__tls_get_addr@GOT(%rip)
-          static const u8 insn[] = {
-            0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
-            0x48, 0x81, 0xc0, 0, 0, 0, 0,             // add $val, %rax
-          };
-          memcpy(loc - 4, insn, sizeof(insn));
-          *(ul32 *)(loc + 8) = val;
-          break;
-        }
-        case R_X86_64_PLTOFF64: {
-          // The original instructions are the following:
-          //
-          //  48 8d 3d 00 00 00 00           lea    foo@tlsgd(%rip), %rdi
-          //  48 b8 00 00 00 00 00 00 00 00  movabs __tls_get_addr, %rax
-          //  48 01 d8                       add    %rbx, %rax
-          //  ff d0                          call   *%rax
-          static const u8 insn[] = {
-            0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
-            0x48, 0x81, 0xc0, 0, 0, 0, 0,             // add $val, %rax
-            0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00,       // nop
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          *(ul32 *)(loc + 9) = val;
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        i++;
-      }
-      break;
-    case R_X86_64_TLSLD:
-      if (ctx.got->has_tlsld(ctx)) {
-        write32s(ctx.got->get_tlsld_addr(ctx) + A - P);
-      } else {
-        // Relax LD to LE. If we are creating an executable, we don't need
-        // to call __tls_get_addr to obtain the address of the beginning
-        // of the current TLS block. TP points past the end of the TLS
-        // block, and we know the exact size of the TLS block we have
-        // created, so we can just subtract it from TP.
-        switch (rels[i + 1].r_type) {
-        case R_X86_64_PLT32:
-        case R_X86_64_PC32: {
-          // The original instructions are the following:
-          //
-          //  48 8d 3d 00 00 00 00    lea    foo@tlsld(%rip), %rdi
-          //  e8 00 00 00 00          call   __tls_get_addr
-          static const u8 insn[] = {
-            0x31, 0xc0,                   // xor %eax, %eax
-            0x64, 0x48, 0x8b, 0x00,       // mov %fs:(%rax), %rax
-            0x48, 0x2d, 0, 0, 0, 0,       // sub $tls_size, %rax
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          break;
-        }
-        case R_X86_64_GOTPCREL:
-        case R_X86_64_GOTPCRELX: {
-          // The original instructions are the following:
-          //
-          //  48 8d 3d 00 00 00 00    lea    foo@tlsld(%rip), %rdi
-          //  ff 15 00 00 00 00       call   *__tls_get_addr@GOT(%rip)
-          static const u8 insn[] = {
-            0x31, 0xc0,                   // xor %eax, %eax
-            0x64, 0x48, 0x8b, 0x00,       // mov %fs:(%rax), %rax
-            0x48, 0x2d, 0, 0, 0, 0,       // sub $tls_size, %rax
-            0x90,                         // nop
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          break;
-        }
-        case R_X86_64_PLTOFF64: {
-          // The original instructions are the following:
-          //
-          //  48 8d 3d 00 00 00 00           lea    foo@tlsld(%rip), %rdi
-          //  48 b8 00 00 00 00 00 00 00 00  movabs __tls_get_addr@GOTOFF, %rax
-          //  48 01 d8                       add    %rbx, %rax
-          //  ff d0                          call   *%rax
-          static const u8 insn[] = {
-            0x31, 0xc0,                   // xor %eax, %eax
-            0x64, 0x48, 0x8b, 0x00,       // mov %fs:(%rax), %rax
-            0x48, 0x2d, 0, 0, 0, 0,       // sub $tls_size, %rax
-            0x0f, 0x1f, 0x44, 0x00, 0x00, // nop
-            0x0f, 0x1f, 0x44, 0x00, 0x00, // nop
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        *(ul32 *)(loc + 5) = ctx.tp_addr - ctx.tls_begin;
-        assert(A == -4);
-        i++;
-      }
-      break;
-    case R_X86_64_DTPOFF32:
-      write32s(S + A - ctx.dtp_addr);
-      break;
-    case R_X86_64_DTPOFF64:
-      *(ul64 *)loc = S + A - ctx.dtp_addr;
-      break;
-    case R_X86_64_TPOFF32:
-      write32s(S + A - ctx.tp_addr);
-      break;
-    case R_X86_64_TPOFF64:
-      *(ul64 *)loc = S + A - ctx.tp_addr;
-      break;
-    case R_X86_64_GOTTPOFF:
-      if (sym.has_gottp(ctx)) {
-        write32s(sym.get_gottp_addr(ctx) + A - P);
-      } else {
-        u32 insn = relax_gottpoff(loc - 3);
-        loc[-3] = insn >> 16;
-        loc[-2] = insn >> 8;
-        loc[-1] = insn;
-        write32s(S - ctx.tp_addr);
-        assert(A == -4);
-      }
-      break;
-    case R_X86_64_GOTPC32_TLSDESC:
-      if (sym.has_tlsdesc(ctx)) {
-        write32s(sym.get_tlsdesc_addr(ctx) + A - P);
-      } else {
-        u32 insn = relax_gotpc32_tlsdesc(loc - 3);
-        loc[-3] = insn >> 16;
-        loc[-2] = insn >> 8;
-        loc[-1] = insn;
-        write32s(S - ctx.tp_addr);
-        assert(A == -4);
-      }
-      break;
-    case R_X86_64_SIZE32:
-      write32(sym.esym().st_size + A);
-      break;
-    case R_X86_64_SIZE64:
-      *(ul64 *)loc = sym.esym().st_size + A;
-      break;
-    case R_X86_64_TLSDESC_CALL:
-      if (!sym.has_tlsdesc(ctx)) {
-        // call *(%rax) -> nop
-        loc[0] = 0x66;
-        loc[1] = 0x90;
-      }
-      break;
-    default:
-      unreachable();
-    }
-  }
-}
-
-// This function is responsible for applying relocations against
-// non-SHF_ALLOC sections (i.e. sections that are not mapped to memory
-// at runtime).
-//
-// Relocations against non-SHF_ALLOC sections are much easier to
-// handle than that against SHF_ALLOC sections. It is because, since
-// they are not mapped to memory, they don't contain any variable or
-// function and never need PLT or GOT. Non-SHF_ALLOC sections are
-// mostly debug info sections.
-//
-// Relocations against non-SHF_ALLOC sections are not scanned by
-// scan_relocations.
-template <>
-void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    auto check = [&](i64 val, i64 lo, i64 hi) {
-      if (val < lo || hi <= val)
-        Error(ctx) << *this << ": relocation " << rel << " against "
-                   << sym << " out of range: " << val << " is not in ["
-                   << lo << ", " << hi << ")";
-    };
-
-    auto write32 = [&](u64 val) {
-      check(val, 0, 1LL << 32);
-      *(ul32 *)loc = val;
-    };
-
-    auto write32s = [&](u64 val) {
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ul32 *)loc = val;
-    };
-
-    SectionFragment<E> *frag;
-    i64 frag_addend;
-    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
-
-    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
-    u64 A = frag ? frag_addend : (i64)rel.r_addend;
-
-    switch (rel.r_type) {
-    case R_X86_64_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *loc = val;
-      break;
-    }
-    case R_X86_64_16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ul16 *)loc = val;
-      break;
-    }
-    case R_X86_64_32:
-      write32(S + A);
-      break;
-    case R_X86_64_32S:
-      write32s(S + A);
-      break;
-    case R_X86_64_64:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul64 *)loc = *val;
-      else
-        *(ul64 *)loc = S + A;
-      break;
-    case R_X86_64_DTPOFF32:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul32 *)loc = *val;
-      else
-        write32s(S + A - ctx.dtp_addr);
-      break;
-    case R_X86_64_DTPOFF64:
-      if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul64 *)loc = *val;
-      else
-        *(ul64 *)loc = S + A - ctx.dtp_addr;
-      break;
-    case R_X86_64_SIZE32:
-      write32(sym.esym().st_size + A);
-      break;
-    case R_X86_64_SIZE64:
-      *(ul64 *)loc = sym.esym().st_size + A;
-      break;
-    default:
-      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
-                 << rel;
-      break;
-    }
-  }
-}
-
-// Linker has to create data structures in an output file to apply
-// some type of relocations. For example, if a relocation refers a GOT
-// or a PLT entry of a symbol, linker has to create an entry in .got
-// or in .plt for that symbol. In order to fix the file layout, we
-// need to scan relocations.
-template <>
-void InputSection<E>::scan_relocations(Context<E> &ctx) {
-  assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
-  std::span<const ElfRel<E>> rels = get_rels(ctx);
-
-  // Scan relocations
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = (u8 *)(contents.data() + rel.r_offset);
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
-    if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
-
-    switch (rel.r_type) {
-    case R_X86_64_8:
-    case R_X86_64_16:
-    case R_X86_64_32:
-    case R_X86_64_32S:
-      scan_absrel(ctx, sym, rel);
-      break;
-    case R_X86_64_64:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
-    case R_X86_64_PC8:
-    case R_X86_64_PC16:
-    case R_X86_64_PC32:
-    case R_X86_64_PC64:
-      scan_pcrel(ctx, sym, rel);
-      break;
-    case R_X86_64_GOT32:
-    case R_X86_64_GOT64:
-    case R_X86_64_GOTPC32:
-    case R_X86_64_GOTPC64:
-    case R_X86_64_GOTPCREL:
-    case R_X86_64_GOTPCREL64:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      break;
-    case R_X86_64_GOTPCRELX: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_GOTPCRELX";
-
-      bool do_relax = ctx.arg.relax && !sym.is_imported &&
-                      sym.is_relative() && relax_gotpcrelx(loc - 2);
-      if (!do_relax)
-        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_REX_GOTPCRELX: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_REX_GOTPCRELX";
-
-      bool do_relax = ctx.arg.relax && !sym.is_imported &&
-                      sym.is_relative() && relax_rex_gotpcrelx(loc - 3);
-      if (!do_relax)
-        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_PLT32:
-    case R_X86_64_PLTOFF64:
-      if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
-      break;
-    case R_X86_64_TLSGD: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_TLSGD";
-
-      if (i + 1 == rels.size())
-        Fatal(ctx) << *this << ": TLSGD reloc must be followed by PLT or GOTPCREL";
-
-      if (u32 ty = rels[i + 1].r_type;
-          ty != R_X86_64_PLT32 && ty != R_X86_64_PC32 &&
-          ty != R_X86_64_PLTOFF64 && ty != R_X86_64_GOTPCREL &&
-          ty != R_X86_64_GOTPCRELX)
-        Fatal(ctx) << *this << ": TLSGD reloc must be followed by PLT or GOTPCREL";
-
-      if (relax_tlsgd(ctx, sym))
-        i++;
-      else
-        sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_TLSLD: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_TLSLD";
-
-      if (i + 1 == rels.size())
-        Fatal(ctx) << *this << ": TLSLD reloc must be followed by PLT or GOTPCREL";
-
-      if (u32 ty = rels[i + 1].r_type;
-          ty != R_X86_64_PLT32 && ty != R_X86_64_PC32 &&
-          ty != R_X86_64_PLTOFF64 && ty != R_X86_64_GOTPCREL &&
-          ty != R_X86_64_GOTPCRELX)
-        Fatal(ctx) << *this << ": TLSLD reloc must be followed by PLT or GOTPCREL";
-
-      if (relax_tlsld(ctx))
-        i++;
-      else
-        ctx.needs_tlsld.store(true, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_GOTTPOFF: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_GOTTPOFF";
-
-      ctx.has_gottp_rel.store(true, std::memory_order_relaxed);
-
-      bool do_relax = ctx.arg.relax && !ctx.arg.shared &&
-                      !sym.is_imported && relax_gottpoff(loc - 3);
-      if (!do_relax)
-        sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_GOTPC32_TLSDESC: {
-      if (rel.r_addend != -4)
-        Fatal(ctx) << *this << ": bad r_addend for R_X86_64_GOTPC32_TLSDESC";
-
-      if (relax_gotpc32_tlsdesc(loc - 3) == 0)
-        Fatal(ctx) << *this << ": GOTPC32_TLSDESC relocation is used"
-                   << " against an invalid code sequence";
-
-      if (!relax_tlsdesc(ctx, sym))
-        sym.flags.fetch_or(NEEDS_TLSDESC, std::memory_order_relaxed);
-      break;
-    }
-    case R_X86_64_GOTOFF64:
-    case R_X86_64_DTPOFF32:
-    case R_X86_64_DTPOFF64:
-    case R_X86_64_TPOFF32:
-    case R_X86_64_TPOFF64:
-    case R_X86_64_SIZE32:
-    case R_X86_64_SIZE64:
-    case R_X86_64_TLSDESC_CALL:
-      break;
-    default:
-      Error(ctx) << *this << ": unknown relocation: " << rel;
-    }
-  }
-}
-
-} // namespace mold::elf

elf/dwarf.cc

@@ -1,554 +0,0 @@
-// This file contains code to read DWARF debug info to create .gdb_index.
-//
-// .gdb_index is an optional section to speed up GNU debugger. It contains
-// two maps: 1) a map from function/variable/type names to compunits, and
-// 2) a map from function address ranges to compunits. gdb uses these
-// maps to quickly find a compunit given a name or an instruction pointer.
-//
-// (Terminology: a compilation unit, which often abbreviated as compunit
-// or cu, is a unit of debug info. An input .debug_info section usually
-// contains one compunit, and thus an output .debug_info contains as
-// many compunits as the number of input files.)
-//
-// .gdb_index is not mandatory. All the information in .gdb_index is
-// also in other debug info sections. You can actually create an
-// executable without .gdb_index and later add it using `gdb-add-index`
-// post-processing tool that comes with gdb.
-//
-// The mapping from names to compunits is 1:n while the mapping from
-// address ranges to compunits is 1:1. That is, two object files may
-// define the same type name (with the same definition), while there
-// should be no two functions that overlap with each other in memory.
-//
-// .gdb_index contains an on-disk hash table for names, so gdb can
-// lookup names without loading all strings into memory and construct an
-// in-memory hash table.
-//
-// Names are in .debug_gnu_pubnames and .debug_gnu_pubtypes input
-// sections. These sections are created if `-ggnu-pubnames` is given.
-// Besides names, these sections contains attributes for each name so
-// that gdb can distinguish type names from function names, for example.
-//
-// A compunit contains one or more function address ranges. If an
-// object file is compiled without -ffunction-sections, it contains
-// only one .text section and therefore contains a single address range.
-// Such range is typically stored directly to the compunit.
-//
-// If an object file is compiled with -fucntion-sections, it contains
-// more than one .text section, and it has as many address ranges as
-// the number of .text sections. Such discontiguous address ranges are
-// stored to .debug_ranges in DWARF 2/3/4/5 and
-// .debug_rnglists/.debug_addr in DWARF 5.
-//
-// .debug_info section contains DWARF debug info. Although we don't need
-// to parse the whole .debug_info section to read address ranges, we
-// have to do a little bit. DWARF is complicated and often handled using
-// a library such as libdwarf. But we don't use any library because we
-// don't want to add an extra run-time dependency just for --gdb-index.
-//
-// This page explains the format of .gdb_index:
-// https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
-
-#include "mold.h"
-
-namespace mold::elf {
-
-// The hash function for .gdb_index.
-static u32 gdb_hash(std::string_view name) {
-  u32 h = 0;
-  for (u8 c : name) {
-    if ('A' <= c && c <= 'Z')
-      c = 'a' + c - 'A';
-    h = h * 67 + c - 113;
-  }
-  return h;
-}
-
-// Split .debug_info into so-called "compilation units". A .debug_info
-// section usually contains one compunit unless it was created by `ld -r`.
-// This is for --gdb-index.
-template <typename E>
-std::vector<std::string_view>
-read_compunits(Context<E> &ctx, ObjectFile<E> &file) {
-  file.debug_info->uncompress(ctx);
-  std::string_view data = file.debug_info->contents;
-  std::vector<std::string_view> vec;
-
-  while (!data.empty()) {
-    if (data.size() < 4)
-      Fatal(ctx) << *file.debug_info << ": corrupted .debug_info";
-    if (*(U32<E> *)data.data() == 0xffffffff)
-      Fatal(ctx) << *file.debug_info << ": --gdb-index: DWARF64 not supported";
-    i64 len = *(U32<E> *)data.data() + 4;
-    vec.push_back(data.substr(0, len));
-    data = data.substr(len);
-  }
-  return vec;
-}
-
-// Parses .debug_gnu_pubnames and .debug_gnu_pubtypes. These sections
-// start with a 14 bytes header followed by (4-byte offset, 1-byte type,
-// null-terminated string) tuples.
-//
-// The 4-byte offset is an offset into .debug_info that contains details
-// about the name. The 1-byte type is a type of the corresponding name
-// (e.g. function, variable or datatype). The string is a name of a
-// function, a variable or a type.
-template <typename E>
-std::vector<GdbIndexName> read_pubnames(Context<E> &ctx, ObjectFile<E> &file) {
-  std::vector<GdbIndexName> vec;
-
-  auto get_cu_idx = [&](InputSection<E> &isec, i64 offset) {
-    i64 off = 0;
-    for (i64 i = 0; i < file.compunits.size(); i++) {
-      if (offset == off)
-        return file.compunits_idx + i;
-      off += file.compunits[i].size();
-    }
-    Fatal(ctx) << isec << ": corrupted debug_info_offset";
-  };
-
-  auto read = [&](InputSection<E> &isec) {
-    isec.uncompress(ctx);
-    std::string_view contents = isec.contents;
-
-    while (!contents.empty()) {
-      if (contents.size() < 14)
-        Fatal(ctx) << isec << ": corrupted header";
-
-      u32 len = *(U32<E> *)contents.data() + 4;
-      u32 debug_info_offset = *(U32<E> *)(contents.data() + 6);
-      u32 cu_idx = get_cu_idx(isec, debug_info_offset);
-
-      std::string_view data = contents.substr(14, len - 14);
-      contents = contents.substr(len);
-
-      while (!data.empty()) {
-        u32 offset = *(U32<E> *)data.data();
-        data = data.substr(4);
-        if (offset == 0)
-          break;
-
-        u8 type = data[0];
-        data = data.substr(1);
-
-        std::string_view name = data.data();
-        data = data.substr(name.size() + 1);
-
-        vec.push_back({name, gdb_hash(name), (type << 24) | cu_idx});
-      }
-    }
-  };
-
-  if (file.debug_pubnames)
-    read(*file.debug_pubnames);
-  if (file.debug_pubtypes)
-    read(*file.debug_pubtypes);
-
-  // Uniquify elements because GCC 11 seems to emit one record for each
-  // comdat group which results in having a lot of duplicate records.
-  auto less = [](const GdbIndexName &a, const GdbIndexName &b) {
-    return std::tuple{a.hash, a.attr, a.name} <
-           std::tuple{b.hash, b.attr, b.name};
-  };
-
-  auto equal = [](const GdbIndexName &a, const GdbIndexName &b) {
-    return std::tuple{a.hash, a.attr, a.name} ==
-           std::tuple{b.hash, b.attr, b.name};
-  };
-
-  std::sort(vec.begin(), vec.end(), less);
-  vec.erase(std::unique(vec.begin(), vec.end(), equal), vec.end());
-  return vec;
-}
-
-template <typename E>
-static u8 *get_buffer(Context<E> &ctx, Chunk<E> *chunk) {
-  if (u8 *buf = chunk->get_uncompressed_data())
-    return buf;
-  return ctx.buf + chunk->shdr.sh_offset;
-}
-
-// Try to find a compilation unit from .debug_info and its
-// corresponding record from .debug_abbrev and returns them.
-template <typename E>
-static std::tuple<u8 *, u8 *, u32>
-find_compunit(Context<E> &ctx, ObjectFile<E> &file, i64 offset) {
-  // Read .debug_info to find the record at a given offset.
-  u8 *cu = get_buffer(ctx, ctx.debug_info) + offset;
-  u32 dwarf_version = *(U16<E> *)(cu + 4);
-  u32 abbrev_offset;
-
-  // Skip a header.
-  switch (dwarf_version) {
-  case 2:
-  case 3:
-  case 4:
-    abbrev_offset = *(U32<E> *)(cu + 6);
-    if (u32 address_size = cu[10]; address_size != sizeof(Word<E>))
-      Fatal(ctx) << file << ": --gdb-index: unsupported address size "
-                 << address_size;
-    cu += 11;
-    break;
-  case 5: {
-    abbrev_offset = *(U32<E> *)(cu + 8);
-    if (u32 address_size = cu[7]; address_size != sizeof(Word<E>))
-      Fatal(ctx) << file << ": --gdb-index: unsupported address size "
-                 << address_size;
-
-    switch (u32 unit_type = cu[6]; unit_type) {
-    case DW_UT_compile:
-    case DW_UT_partial:
-      cu += 12;
-      break;
-    case DW_UT_skeleton:
-    case DW_UT_split_compile:
-      cu += 20;
-      break;
-    default:
-      Fatal(ctx) << file << ": --gdb-index: unknown DW_UT_* value: 0x"
-                 << std::hex << unit_type;
-    }
-    break;
-  }
-  default:
-    Fatal(ctx) << file << ": --gdb-index: unknown DWARF version: "
-               << dwarf_version;
-  }
-
-  u32 abbrev_code = read_uleb(cu);
-
-  // Find a .debug_abbrev record corresponding to the .debug_info record.
-  // We assume the .debug_info record at a given offset is of
-  // DW_TAG_compile_unit which describes a compunit.
-  u8 *abbrev = get_buffer(ctx, ctx.debug_abbrev) + abbrev_offset;
-
-  for (;;) {
-    u32 code = read_uleb(abbrev);
-    if (code == 0)
-      Fatal(ctx) << file << ": --gdb-index: .debug_abbrev does not contain"
-                 << " a record for the first .debug_info record";
-
-    if (code == abbrev_code) {
-      // Found a record
-      u64 abbrev_tag = read_uleb(abbrev);
-      if (abbrev_tag != DW_TAG_compile_unit && abbrev_tag != DW_TAG_skeleton_unit)
-        Fatal(ctx) << file << ": --gdb-index: the first entry's tag is not"
-                   << " DW_TAG_compile_unit/DW_TAG_skeleton_unit but 0x"
-                   << std::hex << abbrev_tag;
-      break;
-    }
-
-    // Skip an uninteresting record
-    read_uleb(abbrev); // tag
-    abbrev++; // has_children byte
-    for (;;) {
-      u64 name = read_uleb(abbrev);
-      u64 form = read_uleb(abbrev);
-      if (name == 0 && form == 0)
-        break;
-      if (form == DW_FORM_implicit_const)
-        read_uleb(abbrev);
-    }
-  }
-
-  abbrev++; // skip has_children byte
-  return {cu, abbrev, dwarf_version};
-}
-
-// Estimate the number of address ranges contained in a given file.
-// It may over-estimate but never under-estimate.
-template <typename E>
-i64 estimate_address_areas(Context<E> &ctx, ObjectFile<E> &file) {
-  // Each CU contains zero or one address area.
-  i64 ret = file.compunits.size();
-
-  // In DWARF 4, a CU can refer address ranges in .debug_ranges.
-  // .debug_ranges contains a vector of [begin, end) address pairs.
-  // The last entry must be a null terminator, so we do -1.
-  if (file.debug_ranges)
-    ret += file.debug_ranges->sh_size / sizeof(Word<E>) / 2 - 1;
-
-  // In DWARF 5, a CU can refer address ranges in .debug_rnglists, which
-  // contains variable-length entries. The smallest possible range entry
-  // is one byte for the code and two ULEB128 values (each can be as
-  // small as one byte), so 3 bytes.
-  if (file.debug_rnglists)
-    ret += file.debug_rnglists->sh_size / 3;
-  return ret;
-}
-
-// .debug_info contains variable-length fields. This class reads them.
-template <typename E>
-class DebugInfoReader {
-public:
-  DebugInfoReader(Context<E> &ctx, ObjectFile<E> &file, u8 *cu)
-    : ctx(ctx), file(file), cu(cu) {}
-
-  u64 read(u64 form);
-
-  Context<E> &ctx;
-  ObjectFile<E> &file;
-  u8 *cu;
-};
-
-// Read value of the given DW_FORM_* form. If a value is not scalar,
-// returns a dummy value 0.
-template <typename E>
-inline u64 DebugInfoReader<E>::read(u64 form) {
-  switch (form) {
-  case DW_FORM_flag_present:
-    return 0;
-  case DW_FORM_data1:
-  case DW_FORM_flag:
-  case DW_FORM_strx1:
-  case DW_FORM_addrx1:
-  case DW_FORM_ref1:
-    return *cu++;
-  case DW_FORM_data2:
-  case DW_FORM_strx2:
-  case DW_FORM_addrx2:
-  case DW_FORM_ref2: {
-    u64 val = *(U16<E> *)cu;
-    cu += 2;
-    return val;
-  }
-  case DW_FORM_strx3:
-  case DW_FORM_addrx3: {
-    u64 val = *(U24<E> *)cu;
-    cu += 3;
-    return val;
-  }
-  case DW_FORM_data4:
-  case DW_FORM_strp:
-  case DW_FORM_sec_offset:
-  case DW_FORM_line_strp:
-  case DW_FORM_strx4:
-  case DW_FORM_addrx4:
-  case DW_FORM_ref4: {
-    u64 val = *(U32<E> *)cu;
-    cu += 4;
-    return val;
-  }
-  case DW_FORM_data8:
-  case DW_FORM_ref8: {
-    u64 val = *(U64<E> *)cu;
-    cu += 8;
-    return val;
-  }
-  case DW_FORM_addr:
-  case DW_FORM_ref_addr: {
-    u64 val = *(Word<E> *)cu;
-    cu += sizeof(Word<E>);
-    return val;
-  }
-  case DW_FORM_strx:
-  case DW_FORM_addrx:
-  case DW_FORM_udata:
-  case DW_FORM_ref_udata:
-  case DW_FORM_loclistx:
-  case DW_FORM_rnglistx:
-    return read_uleb(cu);
-  case DW_FORM_string:
-    cu += strlen((char *)cu) + 1;
-    return 0;
-  default:
-    Fatal(ctx) << file << ": --gdb-index: unhandled debug info form: 0x"
-               << std::hex << form;
-    return 0;
-  }
-}
-
-// Read a range list from .debug_ranges starting at the given offset.
-template <typename E>
-static std::vector<u64>
-read_debug_range(Context<E> &ctx, ObjectFile<E> &file, Word<E> *range) {
-  std::vector<u64> vec;
-  u64 base = 0;
-
-  for (i64 i = 0; range[i] || range[i + 1]; i += 2) {
-    if (range[i] + 1 == 0) {
-      // base address selection entry
-      base = range[i + 1];
-    } else {
-      vec.push_back(range[i] + base);
-      vec.push_back(range[i + 1] + base);
-    }
-  }
-  return vec;
-}
-
-// Read a range list from .debug_rnglists starting at the given offset.
-template <typename E>
-static std::vector<u64>
-read_rnglist_range(Context<E> &ctx, ObjectFile<E> &file, u8 *rnglist,
-                   Word<E> *addrx) {
-  std::vector<u64> vec;
-  u64 base = 0;
-
-  for (;;) {
-    switch (*rnglist++) {
-    case DW_RLE_end_of_list:
-      return vec;
-    case DW_RLE_base_addressx:
-      base = addrx[read_uleb(rnglist)];
-      break;
-    case DW_RLE_startx_endx:
-      vec.push_back(addrx[read_uleb(rnglist)]);
-      vec.push_back(addrx[read_uleb(rnglist)]);
-      break;
-    case DW_RLE_startx_length:
-      vec.push_back(addrx[read_uleb(rnglist)]);
-      vec.push_back(vec.back() + read_uleb(rnglist));
-      break;
-    case DW_RLE_offset_pair:
-      vec.push_back(base + read_uleb(rnglist));
-      vec.push_back(base + read_uleb(rnglist));
-      break;
-    case DW_RLE_base_address:
-      base = *(Word<E> *)rnglist;
-      rnglist += sizeof(Word<E>);
-      break;
-    case DW_RLE_start_end:
-      vec.push_back(*(Word<E> *)rnglist);
-      rnglist += sizeof(Word<E>);
-      vec.push_back(*(Word<E> *)rnglist);
-      rnglist += sizeof(Word<E>);
-      break;
-    case DW_RLE_start_length:
-      vec.push_back(*(Word<E> *)rnglist);
-      rnglist += sizeof(Word<E>);
-      vec.push_back(vec.back() + read_uleb(rnglist));
-      break;
-    }
-  }
-}
-
-// Returns a list of address ranges explained by a compunit at the
-// `offset` in an output .debug_info section.
-//
-// .debug_info contains DWARF debug info records, so this function
-// parses DWARF. If a designated compunit contains multiple ranges, the
-// ranges are read from .debug_ranges (or .debug_rnglists for DWARF5).
-// Otherwise, a range is read directly from .debug_info (or possibly
-// from .debug_addr for DWARF5).
-template <typename E>
-std::vector<u64>
-read_address_areas(Context<E> &ctx, ObjectFile<E> &file, i64 offset) {
-  u8 *cu;
-  u8 *abbrev;
-  u32 dwarf_version;
-  std::tie(cu, abbrev, dwarf_version) = find_compunit(ctx, file, offset);
-
-  DebugInfoReader<E> reader{ctx, file, cu};
-
-  struct Record {
-    u64 form = 0;
-    u64 value = 0;
-  };
-
-  Record low_pc;
-  Record high_pc;
-  Record ranges;
-  std::optional<u64> rnglists_base;
-  Word<E> *addrx = nullptr;
-
-  // Read all interesting debug records.
-  for (;;) {
-    u64 name = read_uleb(abbrev);
-    u64 form = read_uleb(abbrev);
-    if (name == 0 && form == 0)
-      break;
-
-    u64 val = reader.read(form);
-
-    switch (name) {
-    case DW_AT_low_pc:
-      low_pc = {form, val};
-      break;
-    case DW_AT_high_pc:
-      high_pc = {form, val};
-      break;
-    case DW_AT_rnglists_base:
-      rnglists_base = val;
-      break;
-    case DW_AT_addr_base:
-      addrx = (Word<E> *)(get_buffer(ctx, ctx.debug_addr) + val);
-      break;
-    case DW_AT_ranges:
-      ranges = {form, val};
-      break;
-    }
-  }
-
-  // Handle non-contiguous address ranges.
-  if (ranges.form) {
-    if (dwarf_version <= 4) {
-       Word<E> *range_begin =
-        (Word<E> *)(get_buffer(ctx, ctx.debug_ranges) + ranges.value);
-      return read_debug_range(ctx, file, range_begin);
-    }
-
-    assert(dwarf_version == 5);
-
-    u8 *buf = get_buffer(ctx, ctx.debug_rnglists);
-    if (ranges.form == DW_FORM_sec_offset)
-      return read_rnglist_range(ctx, file, buf + ranges.value, addrx);
-
-    if (!rnglists_base)
-      Fatal(ctx) << file << ": --gdb-index: missing DW_AT_rnglists_base";
-
-    u8 *base = buf + *rnglists_base;
-    return read_rnglist_range(ctx, file, base + *(U32<E> *)base, addrx);
-  }
-
-  // Handle a contiguous address range.
-  if (low_pc.form && high_pc.form) {
-    u64 lo;
-
-    switch (low_pc.form) {
-    case DW_FORM_addr:
-      lo = low_pc.value;
-      break;
-    case DW_FORM_addrx:
-    case DW_FORM_addrx1:
-    case DW_FORM_addrx2:
-    case DW_FORM_addrx4:
-      lo = addrx[low_pc.value];
-      break;
-    default:
-      Fatal(ctx) << file << ": --gdb-index: unhandled form for DW_AT_low_pc: 0x"
-                 << std::hex << high_pc.form;
-    }
-
-    switch (high_pc.form) {
-    case DW_FORM_addr:
-      return {lo, high_pc.value};
-    case DW_FORM_addrx:
-    case DW_FORM_addrx1:
-    case DW_FORM_addrx2:
-    case DW_FORM_addrx4:
-      return {lo, addrx[high_pc.value]};
-    case DW_FORM_udata:
-    case DW_FORM_data1:
-    case DW_FORM_data2:
-    case DW_FORM_data4:
-    case DW_FORM_data8:
-      return {lo, lo + high_pc.value};
-    default:
-      Fatal(ctx) << file << ": --gdb-index: unhandled form for DW_AT_high_pc: 0x"
-                 << std::hex << high_pc.form;
-    }
-  }
-
-  return {};
-}
-
-using E = MOLD_TARGET;
-
-template std::vector<std::string_view> read_compunits(Context<E> &, ObjectFile<E> &);
-template std::vector<GdbIndexName> read_pubnames(Context<E> &, ObjectFile<E> &);
-template i64 estimate_address_areas(Context<E> &, ObjectFile<E> &);
-template std::vector<u64> read_address_areas(Context<E> &, ObjectFile<E> &, i64);
-
-} // namespace mold::elf

elf/elf.cc

@@ -1,914 +0,0 @@
-#include "mold.h"
-
-namespace mold::elf {
-
-template <>
-std::string rel_to_string<X86_64>(u32 r_type) {
-  switch (r_type) {
-  case R_X86_64_NONE: return "R_X86_64_NONE";
-  case R_X86_64_64: return "R_X86_64_64";
-  case R_X86_64_PC32: return "R_X86_64_PC32";
-  case R_X86_64_GOT32: return "R_X86_64_GOT32";
-  case R_X86_64_PLT32: return "R_X86_64_PLT32";
-  case R_X86_64_COPY: return "R_X86_64_COPY";
-  case R_X86_64_GLOB_DAT: return "R_X86_64_GLOB_DAT";
-  case R_X86_64_JUMP_SLOT: return "R_X86_64_JUMP_SLOT";
-  case R_X86_64_RELATIVE: return "R_X86_64_RELATIVE";
-  case R_X86_64_GOTPCREL: return "R_X86_64_GOTPCREL";
-  case R_X86_64_32: return "R_X86_64_32";
-  case R_X86_64_32S: return "R_X86_64_32S";
-  case R_X86_64_16: return "R_X86_64_16";
-  case R_X86_64_PC16: return "R_X86_64_PC16";
-  case R_X86_64_8: return "R_X86_64_8";
-  case R_X86_64_PC8: return "R_X86_64_PC8";
-  case R_X86_64_DTPMOD64: return "R_X86_64_DTPMOD64";
-  case R_X86_64_DTPOFF64: return "R_X86_64_DTPOFF64";
-  case R_X86_64_TPOFF64: return "R_X86_64_TPOFF64";
-  case R_X86_64_TLSGD: return "R_X86_64_TLSGD";
-  case R_X86_64_TLSLD: return "R_X86_64_TLSLD";
-  case R_X86_64_DTPOFF32: return "R_X86_64_DTPOFF32";
-  case R_X86_64_GOTTPOFF: return "R_X86_64_GOTTPOFF";
-  case R_X86_64_TPOFF32: return "R_X86_64_TPOFF32";
-  case R_X86_64_PC64: return "R_X86_64_PC64";
-  case R_X86_64_GOTOFF64: return "R_X86_64_GOTOFF64";
-  case R_X86_64_GOTPC32: return "R_X86_64_GOTPC32";
-  case R_X86_64_GOT64: return "R_X86_64_GOT64";
-  case R_X86_64_GOTPCREL64: return "R_X86_64_GOTPCREL64";
-  case R_X86_64_GOTPC64: return "R_X86_64_GOTPC64";
-  case R_X86_64_GOTPLT64: return "R_X86_64_GOTPLT64";
-  case R_X86_64_PLTOFF64: return "R_X86_64_PLTOFF64";
-  case R_X86_64_SIZE32: return "R_X86_64_SIZE32";
-  case R_X86_64_SIZE64: return "R_X86_64_SIZE64";
-  case R_X86_64_GOTPC32_TLSDESC: return "R_X86_64_GOTPC32_TLSDESC";
-  case R_X86_64_TLSDESC_CALL: return "R_X86_64_TLSDESC_CALL";
-  case R_X86_64_TLSDESC: return "R_X86_64_TLSDESC";
-  case R_X86_64_IRELATIVE: return "R_X86_64_IRELATIVE";
-  case R_X86_64_GOTPCRELX: return "R_X86_64_GOTPCRELX";
-  case R_X86_64_REX_GOTPCRELX: return "R_X86_64_REX_GOTPCRELX";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<I386>(u32 r_type) {
-  switch (r_type) {
-  case R_386_NONE: return "R_386_NONE";
-  case R_386_32: return "R_386_32";
-  case R_386_PC32: return "R_386_PC32";
-  case R_386_GOT32: return "R_386_GOT32";
-  case R_386_PLT32: return "R_386_PLT32";
-  case R_386_COPY: return "R_386_COPY";
-  case R_386_GLOB_DAT: return "R_386_GLOB_DAT";
-  case R_386_JUMP_SLOT: return "R_386_JUMP_SLOT";
-  case R_386_RELATIVE: return "R_386_RELATIVE";
-  case R_386_GOTOFF: return "R_386_GOTOFF";
-  case R_386_GOTPC: return "R_386_GOTPC";
-  case R_386_32PLT: return "R_386_32PLT";
-  case R_386_TLS_TPOFF: return "R_386_TLS_TPOFF";
-  case R_386_TLS_IE: return "R_386_TLS_IE";
-  case R_386_TLS_GOTIE: return "R_386_TLS_GOTIE";
-  case R_386_TLS_LE: return "R_386_TLS_LE";
-  case R_386_TLS_GD: return "R_386_TLS_GD";
-  case R_386_TLS_LDM: return "R_386_TLS_LDM";
-  case R_386_16: return "R_386_16";
-  case R_386_PC16: return "R_386_PC16";
-  case R_386_8: return "R_386_8";
-  case R_386_PC8: return "R_386_PC8";
-  case R_386_TLS_GD_32: return "R_386_TLS_GD_32";
-  case R_386_TLS_GD_PUSH: return "R_386_TLS_GD_PUSH";
-  case R_386_TLS_GD_CALL: return "R_386_TLS_GD_CALL";
-  case R_386_TLS_GD_POP: return "R_386_TLS_GD_POP";
-  case R_386_TLS_LDM_32: return "R_386_TLS_LDM_32";
-  case R_386_TLS_LDM_PUSH: return "R_386_TLS_LDM_PUSH";
-  case R_386_TLS_LDM_CALL: return "R_386_TLS_LDM_CALL";
-  case R_386_TLS_LDM_POP: return "R_386_TLS_LDM_POP";
-  case R_386_TLS_LDO_32: return "R_386_TLS_LDO_32";
-  case R_386_TLS_IE_32: return "R_386_TLS_IE_32";
-  case R_386_TLS_LE_32: return "R_386_TLS_LE_32";
-  case R_386_TLS_DTPMOD32: return "R_386_TLS_DTPMOD32";
-  case R_386_TLS_DTPOFF32: return "R_386_TLS_DTPOFF32";
-  case R_386_TLS_TPOFF32: return "R_386_TLS_TPOFF32";
-  case R_386_SIZE32: return "R_386_SIZE32";
-  case R_386_TLS_GOTDESC: return "R_386_TLS_GOTDESC";
-  case R_386_TLS_DESC_CALL: return "R_386_TLS_DESC_CALL";
-  case R_386_TLS_DESC: return "R_386_TLS_DESC";
-  case R_386_IRELATIVE: return "R_386_IRELATIVE";
-  case R_386_GOT32X: return "R_386_GOT32X";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<ARM64>(u32 r_type) {
-  switch (r_type) {
-  case R_AARCH64_NONE: return "R_AARCH64_NONE";
-  case R_AARCH64_ABS64: return "R_AARCH64_ABS64";
-  case R_AARCH64_ABS32: return "R_AARCH64_ABS32";
-  case R_AARCH64_ABS16: return "R_AARCH64_ABS16";
-  case R_AARCH64_PREL64: return "R_AARCH64_PREL64";
-  case R_AARCH64_PREL32: return "R_AARCH64_PREL32";
-  case R_AARCH64_PREL16: return "R_AARCH64_PREL16";
-  case R_AARCH64_MOVW_UABS_G0: return "R_AARCH64_MOVW_UABS_G0";
-  case R_AARCH64_MOVW_UABS_G0_NC: return "R_AARCH64_MOVW_UABS_G0_NC";
-  case R_AARCH64_MOVW_UABS_G1: return "R_AARCH64_MOVW_UABS_G1";
-  case R_AARCH64_MOVW_UABS_G1_NC: return "R_AARCH64_MOVW_UABS_G1_NC";
-  case R_AARCH64_MOVW_UABS_G2: return "R_AARCH64_MOVW_UABS_G2";
-  case R_AARCH64_MOVW_UABS_G2_NC: return "R_AARCH64_MOVW_UABS_G2_NC";
-  case R_AARCH64_MOVW_UABS_G3: return "R_AARCH64_MOVW_UABS_G3";
-  case R_AARCH64_MOVW_SABS_G0: return "R_AARCH64_MOVW_SABS_G0";
-  case R_AARCH64_MOVW_SABS_G1: return "R_AARCH64_MOVW_SABS_G1";
-  case R_AARCH64_MOVW_SABS_G2: return "R_AARCH64_MOVW_SABS_G2";
-  case R_AARCH64_LD_PREL_LO19: return "R_AARCH64_LD_PREL_LO19";
-  case R_AARCH64_ADR_PREL_LO21: return "R_AARCH64_ADR_PREL_LO21";
-  case R_AARCH64_ADR_PREL_PG_HI21: return "R_AARCH64_ADR_PREL_PG_HI21";
-  case R_AARCH64_ADR_PREL_PG_HI21_NC: return "R_AARCH64_ADR_PREL_PG_HI21_NC";
-  case R_AARCH64_ADD_ABS_LO12_NC: return "R_AARCH64_ADD_ABS_LO12_NC";
-  case R_AARCH64_LDST8_ABS_LO12_NC: return "R_AARCH64_LDST8_ABS_LO12_NC";
-  case R_AARCH64_TSTBR14: return "R_AARCH64_TSTBR14";
-  case R_AARCH64_CONDBR19: return "R_AARCH64_CONDBR19";
-  case R_AARCH64_JUMP26: return "R_AARCH64_JUMP26";
-  case R_AARCH64_CALL26: return "R_AARCH64_CALL26";
-  case R_AARCH64_LDST16_ABS_LO12_NC: return "R_AARCH64_LDST16_ABS_LO12_NC";
-  case R_AARCH64_LDST32_ABS_LO12_NC: return "R_AARCH64_LDST32_ABS_LO12_NC";
-  case R_AARCH64_LDST64_ABS_LO12_NC: return "R_AARCH64_LDST64_ABS_LO12_NC";
-  case R_AARCH64_MOVW_PREL_G0: return "R_AARCH64_MOVW_PREL_G0";
-  case R_AARCH64_MOVW_PREL_G0_NC: return "R_AARCH64_MOVW_PREL_G0_NC";
-  case R_AARCH64_MOVW_PREL_G1: return "R_AARCH64_MOVW_PREL_G1";
-  case R_AARCH64_MOVW_PREL_G1_NC: return "R_AARCH64_MOVW_PREL_G1_NC";
-  case R_AARCH64_MOVW_PREL_G2: return "R_AARCH64_MOVW_PREL_G2";
-  case R_AARCH64_MOVW_PREL_G2_NC: return "R_AARCH64_MOVW_PREL_G2_NC";
-  case R_AARCH64_MOVW_PREL_G3: return "R_AARCH64_MOVW_PREL_G3";
-  case R_AARCH64_LDST128_ABS_LO12_NC: return "R_AARCH64_LDST128_ABS_LO12_NC";
-  case R_AARCH64_ADR_GOT_PAGE: return "R_AARCH64_ADR_GOT_PAGE";
-  case R_AARCH64_LD64_GOT_LO12_NC: return "R_AARCH64_LD64_GOT_LO12_NC";
-  case R_AARCH64_LD64_GOTPAGE_LO15: return "R_AARCH64_LD64_GOTPAGE_LO15";
-  case R_AARCH64_PLT32: return "R_AARCH64_PLT32";
-  case R_AARCH64_TLSGD_ADR_PREL21: return "R_AARCH64_TLSGD_ADR_PREL21";
-  case R_AARCH64_TLSGD_ADR_PAGE21: return "R_AARCH64_TLSGD_ADR_PAGE21";
-  case R_AARCH64_TLSGD_ADD_LO12_NC: return "R_AARCH64_TLSGD_ADD_LO12_NC";
-  case R_AARCH64_TLSGD_MOVW_G1: return "R_AARCH64_TLSGD_MOVW_G1";
-  case R_AARCH64_TLSGD_MOVW_G0_NC: return "R_AARCH64_TLSGD_MOVW_G0_NC";
-  case R_AARCH64_TLSLD_ADR_PREL21: return "R_AARCH64_TLSLD_ADR_PREL21";
-  case R_AARCH64_TLSLD_ADR_PAGE21: return "R_AARCH64_TLSLD_ADR_PAGE21";
-  case R_AARCH64_TLSLD_ADD_LO12_NC: return "R_AARCH64_TLSLD_ADD_LO12_NC";
-  case R_AARCH64_TLSLD_MOVW_G1: return "R_AARCH64_TLSLD_MOVW_G1";
-  case R_AARCH64_TLSLD_MOVW_G0_NC: return "R_AARCH64_TLSLD_MOVW_G0_NC";
-  case R_AARCH64_TLSLD_LD_PREL19: return "R_AARCH64_TLSLD_LD_PREL19";
-  case R_AARCH64_TLSLD_MOVW_DTPREL_G2: return "R_AARCH64_TLSLD_MOVW_DTPREL_G2";
-  case R_AARCH64_TLSLD_MOVW_DTPREL_G1: return "R_AARCH64_TLSLD_MOVW_DTPREL_G1";
-  case R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC: return "R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC";
-  case R_AARCH64_TLSLD_MOVW_DTPREL_G0: return "R_AARCH64_TLSLD_MOVW_DTPREL_G0";
-  case R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC: return "R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC";
-  case R_AARCH64_TLSLD_ADD_DTPREL_HI12: return "R_AARCH64_TLSLD_ADD_DTPREL_HI12";
-  case R_AARCH64_TLSLD_ADD_DTPREL_LO12: return "R_AARCH64_TLSLD_ADD_DTPREL_LO12";
-  case R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC: return "R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC";
-  case R_AARCH64_TLSLD_LDST8_DTPREL_LO12: return "R_AARCH64_TLSLD_LDST8_DTPREL_LO12";
-  case R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC: return "R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC";
-  case R_AARCH64_TLSLD_LDST16_DTPREL_LO12: return "R_AARCH64_TLSLD_LDST16_DTPREL_LO12";
-  case R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC: return "R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC";
-  case R_AARCH64_TLSLD_LDST32_DTPREL_LO12: return "R_AARCH64_TLSLD_LDST32_DTPREL_LO12";
-  case R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC: return "R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC";
-  case R_AARCH64_TLSLD_LDST64_DTPREL_LO12: return "R_AARCH64_TLSLD_LDST64_DTPREL_LO12";
-  case R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC: return "R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC";
-  case R_AARCH64_TLSIE_MOVW_GOTTPREL_G1: return "R_AARCH64_TLSIE_MOVW_GOTTPREL_G1";
-  case R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: return "R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC";
-  case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: return "R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21";
-  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: return "R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC";
-  case R_AARCH64_TLSIE_LD_GOTTPREL_PREL19: return "R_AARCH64_TLSIE_LD_GOTTPREL_PREL19";
-  case R_AARCH64_TLSLE_MOVW_TPREL_G2: return "R_AARCH64_TLSLE_MOVW_TPREL_G2";
-  case R_AARCH64_TLSLE_MOVW_TPREL_G1: return "R_AARCH64_TLSLE_MOVW_TPREL_G1";
-  case R_AARCH64_TLSLE_MOVW_TPREL_G1_NC: return "R_AARCH64_TLSLE_MOVW_TPREL_G1_NC";
-  case R_AARCH64_TLSLE_MOVW_TPREL_G0: return "R_AARCH64_TLSLE_MOVW_TPREL_G0";
-  case R_AARCH64_TLSLE_MOVW_TPREL_G0_NC: return "R_AARCH64_TLSLE_MOVW_TPREL_G0_NC";
-  case R_AARCH64_TLSLE_ADD_TPREL_HI12: return "R_AARCH64_TLSLE_ADD_TPREL_HI12";
-  case R_AARCH64_TLSLE_ADD_TPREL_LO12: return "R_AARCH64_TLSLE_ADD_TPREL_LO12";
-  case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC: return "R_AARCH64_TLSLE_ADD_TPREL_LO12_NC";
-  case R_AARCH64_TLSLE_LDST8_TPREL_LO12: return "R_AARCH64_TLSLE_LDST8_TPREL_LO12";
-  case R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC: return "R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC";
-  case R_AARCH64_TLSLE_LDST16_TPREL_LO12: return "R_AARCH64_TLSLE_LDST16_TPREL_LO12";
-  case R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC: return "R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC";
-  case R_AARCH64_TLSLE_LDST32_TPREL_LO12: return "R_AARCH64_TLSLE_LDST32_TPREL_LO12";
-  case R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC: return "R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC";
-  case R_AARCH64_TLSLE_LDST64_TPREL_LO12: return "R_AARCH64_TLSLE_LDST64_TPREL_LO12";
-  case R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC: return "R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC";
-  case R_AARCH64_TLSDESC_ADR_PAGE21: return "R_AARCH64_TLSDESC_ADR_PAGE21";
-  case R_AARCH64_TLSDESC_LD64_LO12: return "R_AARCH64_TLSDESC_LD64_LO12";
-  case R_AARCH64_TLSDESC_ADD_LO12: return "R_AARCH64_TLSDESC_ADD_LO12";
-  case R_AARCH64_TLSDESC_CALL: return "R_AARCH64_TLSDESC_CALL";
-  case R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC: return "R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC";
-  case R_AARCH64_COPY: return "R_AARCH64_COPY";
-  case R_AARCH64_GLOB_DAT: return "R_AARCH64_GLOB_DAT";
-  case R_AARCH64_JUMP_SLOT: return "R_AARCH64_JUMP_SLOT";
-  case R_AARCH64_RELATIVE: return "R_AARCH64_RELATIVE";
-  case R_AARCH64_TLS_DTPMOD64: return "R_AARCH64_TLS_DTPMOD64";
-  case R_AARCH64_TLS_DTPREL64: return "R_AARCH64_TLS_DTPREL64";
-  case R_AARCH64_TLS_TPREL64: return "R_AARCH64_TLS_TPREL64";
-  case R_AARCH64_TLSDESC: return "R_AARCH64_TLSDESC";
-  case R_AARCH64_IRELATIVE: return "R_AARCH64_IRELATIVE";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<ARM32>(u32 r_type) {
-  switch (r_type) {
-  case R_ARM_NONE: return "R_ARM_NONE";
-  case R_ARM_PC24: return "R_ARM_PC24";
-  case R_ARM_ABS32: return "R_ARM_ABS32";
-  case R_ARM_REL32: return "R_ARM_REL32";
-  case R_ARM_LDR_PC_G0: return "R_ARM_LDR_PC_G0";
-  case R_ARM_ABS16: return "R_ARM_ABS16";
-  case R_ARM_ABS12: return "R_ARM_ABS12";
-  case R_ARM_THM_ABS5: return "R_ARM_THM_ABS5";
-  case R_ARM_ABS8: return "R_ARM_ABS8";
-  case R_ARM_SBREL32: return "R_ARM_SBREL32";
-  case R_ARM_THM_CALL: return "R_ARM_THM_CALL";
-  case R_ARM_THM_PC8: return "R_ARM_THM_PC8";
-  case R_ARM_BREL_ADJ: return "R_ARM_BREL_ADJ";
-  case R_ARM_TLS_DESC: return "R_ARM_TLS_DESC";
-  case R_ARM_THM_SWI8: return "R_ARM_THM_SWI8";
-  case R_ARM_XPC25: return "R_ARM_XPC25";
-  case R_ARM_THM_XPC22: return "R_ARM_THM_XPC22";
-  case R_ARM_TLS_DTPMOD32: return "R_ARM_TLS_DTPMOD32";
-  case R_ARM_TLS_DTPOFF32: return "R_ARM_TLS_DTPOFF32";
-  case R_ARM_TLS_TPOFF32: return "R_ARM_TLS_TPOFF32";
-  case R_ARM_COPY: return "R_ARM_COPY";
-  case R_ARM_GLOB_DAT: return "R_ARM_GLOB_DAT";
-  case R_ARM_JUMP_SLOT: return "R_ARM_JUMP_SLOT";
-  case R_ARM_RELATIVE: return "R_ARM_RELATIVE";
-  case R_ARM_GOTOFF32: return "R_ARM_GOTOFF32";
-  case R_ARM_BASE_PREL: return "R_ARM_BASE_PREL";
-  case R_ARM_GOT_BREL: return "R_ARM_GOT_BREL";
-  case R_ARM_PLT32: return "R_ARM_PLT32";
-  case R_ARM_CALL: return "R_ARM_CALL";
-  case R_ARM_JUMP24: return "R_ARM_JUMP24";
-  case R_ARM_THM_JUMP24: return "R_ARM_THM_JUMP24";
-  case R_ARM_BASE_ABS: return "R_ARM_BASE_ABS";
-  case R_ARM_ALU_PCREL_7_0: return "R_ARM_ALU_PCREL_7_0";
-  case R_ARM_ALU_PCREL_15_8: return "R_ARM_ALU_PCREL_15_8";
-  case R_ARM_ALU_PCREL_23_15: return "R_ARM_ALU_PCREL_23_15";
-  case R_ARM_LDR_SBREL_11_0_NC: return "R_ARM_LDR_SBREL_11_0_NC";
-  case R_ARM_ALU_SBREL_19_12_NC: return "R_ARM_ALU_SBREL_19_12_NC";
-  case R_ARM_ALU_SBREL_27_20_CK: return "R_ARM_ALU_SBREL_27_20_CK";
-  case R_ARM_TARGET1: return "R_ARM_TARGET1";
-  case R_ARM_SBREL31: return "R_ARM_SBREL31";
-  case R_ARM_V4BX: return "R_ARM_V4BX";
-  case R_ARM_TARGET2: return "R_ARM_TARGET2";
-  case R_ARM_PREL31: return "R_ARM_PREL31";
-  case R_ARM_MOVW_ABS_NC: return "R_ARM_MOVW_ABS_NC";
-  case R_ARM_MOVT_ABS: return "R_ARM_MOVT_ABS";
-  case R_ARM_MOVW_PREL_NC: return "R_ARM_MOVW_PREL_NC";
-  case R_ARM_MOVT_PREL: return "R_ARM_MOVT_PREL";
-  case R_ARM_THM_MOVW_ABS_NC: return "R_ARM_THM_MOVW_ABS_NC";
-  case R_ARM_THM_MOVT_ABS: return "R_ARM_THM_MOVT_ABS";
-  case R_ARM_THM_MOVW_PREL_NC: return "R_ARM_THM_MOVW_PREL_NC";
-  case R_ARM_THM_MOVT_PREL: return "R_ARM_THM_MOVT_PREL";
-  case R_ARM_THM_JUMP19: return "R_ARM_THM_JUMP19";
-  case R_ARM_THM_JUMP6: return "R_ARM_THM_JUMP6";
-  case R_ARM_THM_ALU_PREL_11_0: return "R_ARM_THM_ALU_PREL_11_0";
-  case R_ARM_THM_PC12: return "R_ARM_THM_PC12";
-  case R_ARM_ABS32_NOI: return "R_ARM_ABS32_NOI";
-  case R_ARM_REL32_NOI: return "R_ARM_REL32_NOI";
-  case R_ARM_ALU_PC_G0_NC: return "R_ARM_ALU_PC_G0_NC";
-  case R_ARM_ALU_PC_G0: return "R_ARM_ALU_PC_G0";
-  case R_ARM_ALU_PC_G1_NC: return "R_ARM_ALU_PC_G1_NC";
-  case R_ARM_ALU_PC_G1: return "R_ARM_ALU_PC_G1";
-  case R_ARM_ALU_PC_G2: return "R_ARM_ALU_PC_G2";
-  case R_ARM_LDR_PC_G1: return "R_ARM_LDR_PC_G1";
-  case R_ARM_LDR_PC_G2: return "R_ARM_LDR_PC_G2";
-  case R_ARM_LDRS_PC_G0: return "R_ARM_LDRS_PC_G0";
-  case R_ARM_LDRS_PC_G1: return "R_ARM_LDRS_PC_G1";
-  case R_ARM_LDRS_PC_G2: return "R_ARM_LDRS_PC_G2";
-  case R_ARM_LDC_PC_G0: return "R_ARM_LDC_PC_G0";
-  case R_ARM_LDC_PC_G1: return "R_ARM_LDC_PC_G1";
-  case R_ARM_LDC_PC_G2: return "R_ARM_LDC_PC_G2";
-  case R_ARM_ALU_SB_G0_NC: return "R_ARM_ALU_SB_G0_NC";
-  case R_ARM_ALU_SB_G0: return "R_ARM_ALU_SB_G0";
-  case R_ARM_ALU_SB_G1_NC: return "R_ARM_ALU_SB_G1_NC";
-  case R_ARM_ALU_SB_G1: return "R_ARM_ALU_SB_G1";
-  case R_ARM_ALU_SB_G2: return "R_ARM_ALU_SB_G2";
-  case R_ARM_LDR_SB_G0: return "R_ARM_LDR_SB_G0";
-  case R_ARM_LDR_SB_G1: return "R_ARM_LDR_SB_G1";
-  case R_ARM_LDR_SB_G2: return "R_ARM_LDR_SB_G2";
-  case R_ARM_LDRS_SB_G0: return "R_ARM_LDRS_SB_G0";
-  case R_ARM_LDRS_SB_G1: return "R_ARM_LDRS_SB_G1";
-  case R_ARM_LDRS_SB_G2: return "R_ARM_LDRS_SB_G2";
-  case R_ARM_LDC_SB_G0: return "R_ARM_LDC_SB_G0";
-  case R_ARM_LDC_SB_G1: return "R_ARM_LDC_SB_G1";
-  case R_ARM_LDC_SB_G2: return "R_ARM_LDC_SB_G2";
-  case R_ARM_MOVW_BREL_NC: return "R_ARM_MOVW_BREL_NC";
-  case R_ARM_MOVT_BREL: return "R_ARM_MOVT_BREL";
-  case R_ARM_MOVW_BREL: return "R_ARM_MOVW_BREL";
-  case R_ARM_THM_MOVW_BREL_NC: return "R_ARM_THM_MOVW_BREL_NC";
-  case R_ARM_THM_MOVT_BREL: return "R_ARM_THM_MOVT_BREL";
-  case R_ARM_THM_MOVW_BREL: return "R_ARM_THM_MOVW_BREL";
-  case R_ARM_TLS_GOTDESC: return "R_ARM_TLS_GOTDESC";
-  case R_ARM_TLS_CALL: return "R_ARM_TLS_CALL";
-  case R_ARM_TLS_DESCSEQ: return "R_ARM_TLS_DESCSEQ";
-  case R_ARM_THM_TLS_CALL: return "R_ARM_THM_TLS_CALL";
-  case R_ARM_PLT32_ABS: return "R_ARM_PLT32_ABS";
-  case R_ARM_GOT_ABS: return "R_ARM_GOT_ABS";
-  case R_ARM_GOT_PREL: return "R_ARM_GOT_PREL";
-  case R_ARM_GOT_BREL12: return "R_ARM_GOT_BREL12";
-  case R_ARM_GOTOFF12: return "R_ARM_GOTOFF12";
-  case R_ARM_GOTRELAX: return "R_ARM_GOTRELAX";
-  case R_ARM_GNU_VTENTRY: return "R_ARM_GNU_VTENTRY";
-  case R_ARM_GNU_VTINHERIT: return "R_ARM_GNU_VTINHERIT";
-  case R_ARM_THM_JUMP11: return "R_ARM_THM_JUMP11";
-  case R_ARM_THM_JUMP8: return "R_ARM_THM_JUMP8";
-  case R_ARM_TLS_GD32: return "R_ARM_TLS_GD32";
-  case R_ARM_TLS_LDM32: return "R_ARM_TLS_LDM32";
-  case R_ARM_TLS_LDO32: return "R_ARM_TLS_LDO32";
-  case R_ARM_TLS_IE32: return "R_ARM_TLS_IE32";
-  case R_ARM_TLS_LE32: return "R_ARM_TLS_LE32";
-  case R_ARM_TLS_LDO12: return "R_ARM_TLS_LDO12";
-  case R_ARM_TLS_LE12: return "R_ARM_TLS_LE12";
-  case R_ARM_TLS_IE12GP: return "R_ARM_TLS_IE12GP";
-  case R_ARM_PRIVATE_0: return "R_ARM_PRIVATE_0";
-  case R_ARM_PRIVATE_1: return "R_ARM_PRIVATE_1";
-  case R_ARM_PRIVATE_2: return "R_ARM_PRIVATE_2";
-  case R_ARM_PRIVATE_3: return "R_ARM_PRIVATE_3";
-  case R_ARM_PRIVATE_4: return "R_ARM_PRIVATE_4";
-  case R_ARM_PRIVATE_5: return "R_ARM_PRIVATE_5";
-  case R_ARM_PRIVATE_6: return "R_ARM_PRIVATE_6";
-  case R_ARM_PRIVATE_7: return "R_ARM_PRIVATE_7";
-  case R_ARM_PRIVATE_8: return "R_ARM_PRIVATE_8";
-  case R_ARM_PRIVATE_9: return "R_ARM_PRIVATE_9";
-  case R_ARM_PRIVATE_10: return "R_ARM_PRIVATE_10";
-  case R_ARM_PRIVATE_11: return "R_ARM_PRIVATE_11";
-  case R_ARM_PRIVATE_12: return "R_ARM_PRIVATE_12";
-  case R_ARM_PRIVATE_13: return "R_ARM_PRIVATE_13";
-  case R_ARM_PRIVATE_14: return "R_ARM_PRIVATE_14";
-  case R_ARM_PRIVATE_15: return "R_ARM_PRIVATE_15";
-  case R_ARM_ME_TOO: return "R_ARM_ME_TOO";
-  case R_ARM_THM_TLS_DESCSEQ16: return "R_ARM_THM_TLS_DESCSEQ16";
-  case R_ARM_THM_TLS_DESCSEQ32: return "R_ARM_THM_TLS_DESCSEQ32";
-  case R_ARM_THM_BF16: return "R_ARM_THM_BF16";
-  case R_ARM_THM_BF12: return "R_ARM_THM_BF12";
-  case R_ARM_THM_BF18: return "R_ARM_THM_BF18";
-  case R_ARM_IRELATIVE: return "R_ARM_IRELATIVE";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<RV64LE>(u32 r_type) {
-  switch (r_type) {
-  case R_RISCV_NONE: return "R_RISCV_NONE";
-  case R_RISCV_32: return "R_RISCV_32";
-  case R_RISCV_64: return "R_RISCV_64";
-  case R_RISCV_RELATIVE: return "R_RISCV_RELATIVE";
-  case R_RISCV_COPY: return "R_RISCV_COPY";
-  case R_RISCV_JUMP_SLOT: return "R_RISCV_JUMP_SLOT";
-  case R_RISCV_TLS_DTPMOD32: return "R_RISCV_TLS_DTPMOD32";
-  case R_RISCV_TLS_DTPMOD64: return "R_RISCV_TLS_DTPMOD64";
-  case R_RISCV_TLS_DTPREL32: return "R_RISCV_TLS_DTPREL32";
-  case R_RISCV_TLS_DTPREL64: return "R_RISCV_TLS_DTPREL64";
-  case R_RISCV_TLS_TPREL32: return "R_RISCV_TLS_TPREL32";
-  case R_RISCV_TLS_TPREL64: return "R_RISCV_TLS_TPREL64";
-  case R_RISCV_BRANCH: return "R_RISCV_BRANCH";
-  case R_RISCV_JAL: return "R_RISCV_JAL";
-  case R_RISCV_CALL: return "R_RISCV_CALL";
-  case R_RISCV_CALL_PLT: return "R_RISCV_CALL_PLT";
-  case R_RISCV_GOT_HI20: return "R_RISCV_GOT_HI20";
-  case R_RISCV_TLS_GOT_HI20: return "R_RISCV_TLS_GOT_HI20";
-  case R_RISCV_TLS_GD_HI20: return "R_RISCV_TLS_GD_HI20";
-  case R_RISCV_PCREL_HI20: return "R_RISCV_PCREL_HI20";
-  case R_RISCV_PCREL_LO12_I: return "R_RISCV_PCREL_LO12_I";
-  case R_RISCV_PCREL_LO12_S: return "R_RISCV_PCREL_LO12_S";
-  case R_RISCV_HI20: return "R_RISCV_HI20";
-  case R_RISCV_LO12_I: return "R_RISCV_LO12_I";
-  case R_RISCV_LO12_S: return "R_RISCV_LO12_S";
-  case R_RISCV_TPREL_HI20: return "R_RISCV_TPREL_HI20";
-  case R_RISCV_TPREL_LO12_I: return "R_RISCV_TPREL_LO12_I";
-  case R_RISCV_TPREL_LO12_S: return "R_RISCV_TPREL_LO12_S";
-  case R_RISCV_TPREL_ADD: return "R_RISCV_TPREL_ADD";
-  case R_RISCV_ADD8: return "R_RISCV_ADD8";
-  case R_RISCV_ADD16: return "R_RISCV_ADD16";
-  case R_RISCV_ADD32: return "R_RISCV_ADD32";
-  case R_RISCV_ADD64: return "R_RISCV_ADD64";
-  case R_RISCV_SUB8: return "R_RISCV_SUB8";
-  case R_RISCV_SUB16: return "R_RISCV_SUB16";
-  case R_RISCV_SUB32: return "R_RISCV_SUB32";
-  case R_RISCV_SUB64: return "R_RISCV_SUB64";
-  case R_RISCV_ALIGN: return "R_RISCV_ALIGN";
-  case R_RISCV_RVC_BRANCH: return "R_RISCV_RVC_BRANCH";
-  case R_RISCV_RVC_JUMP: return "R_RISCV_RVC_JUMP";
-  case R_RISCV_RVC_LUI: return "R_RISCV_RVC_LUI";
-  case R_RISCV_RELAX: return "R_RISCV_RELAX";
-  case R_RISCV_SUB6: return "R_RISCV_SUB6";
-  case R_RISCV_SET6: return "R_RISCV_SET6";
-  case R_RISCV_SET8: return "R_RISCV_SET8";
-  case R_RISCV_SET16: return "R_RISCV_SET16";
-  case R_RISCV_SET32: return "R_RISCV_SET32";
-  case R_RISCV_32_PCREL: return "R_RISCV_32_PCREL";
-  case R_RISCV_IRELATIVE: return "R_RISCV_IRELATIVE";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<RV64BE>(u32 r_type) {
-  return rel_to_string<RV64LE>(r_type);
-}
-
-template <>
-std::string rel_to_string<RV32LE>(u32 r_type) {
-  return rel_to_string<RV64LE>(r_type);
-}
-
-template <>
-std::string rel_to_string<RV32BE>(u32 r_type) {
-  return rel_to_string<RV64LE>(r_type);
-}
-
-template <>
-std::string rel_to_string<PPC32>(u32 r_type) {
-  switch (r_type) {
-  case R_PPC_NONE: return "R_PPC_NONE";
-  case R_PPC_ADDR32: return "R_PPC_ADDR32";
-  case R_PPC_ADDR24: return "R_PPC_ADDR24";
-  case R_PPC_ADDR16: return "R_PPC_ADDR16";
-  case R_PPC_ADDR16_LO: return "R_PPC_ADDR16_LO";
-  case R_PPC_ADDR16_HI: return "R_PPC_ADDR16_HI";
-  case R_PPC_ADDR16_HA: return "R_PPC_ADDR16_HA";
-  case R_PPC_ADDR14: return "R_PPC_ADDR14";
-  case R_PPC_ADDR14_BRTAKEN: return "R_PPC_ADDR14_BRTAKEN";
-  case R_PPC_ADDR14_BRNTAKEN: return "R_PPC_ADDR14_BRNTAKEN";
-  case R_PPC_REL24: return "R_PPC_REL24";
-  case R_PPC_REL14: return "R_PPC_REL14";
-  case R_PPC_REL14_BRTAKEN: return "R_PPC_REL14_BRTAKEN";
-  case R_PPC_REL14_BRNTAKEN: return "R_PPC_REL14_BRNTAKEN";
-  case R_PPC_GOT16: return "R_PPC_GOT16";
-  case R_PPC_GOT16_LO: return "R_PPC_GOT16_LO";
-  case R_PPC_GOT16_HI: return "R_PPC_GOT16_HI";
-  case R_PPC_GOT16_HA: return "R_PPC_GOT16_HA";
-  case R_PPC_PLTREL24: return "R_PPC_PLTREL24";
-  case R_PPC_COPY: return "R_PPC_COPY";
-  case R_PPC_GLOB_DAT: return "R_PPC_GLOB_DAT";
-  case R_PPC_JMP_SLOT: return "R_PPC_JMP_SLOT";
-  case R_PPC_RELATIVE: return "R_PPC_RELATIVE";
-  case R_PPC_LOCAL24PC: return "R_PPC_LOCAL24PC";
-  case R_PPC_UADDR32: return "R_PPC_UADDR32";
-  case R_PPC_UADDR16: return "R_PPC_UADDR16";
-  case R_PPC_REL32: return "R_PPC_REL32";
-  case R_PPC_PLT32: return "R_PPC_PLT32";
-  case R_PPC_PLTREL32: return "R_PPC_PLTREL32";
-  case R_PPC_PLT16_LO: return "R_PPC_PLT16_LO";
-  case R_PPC_PLT16_HI: return "R_PPC_PLT16_HI";
-  case R_PPC_PLT16_HA: return "R_PPC_PLT16_HA";
-  case R_PPC_SDAREL16: return "R_PPC_SDAREL16";
-  case R_PPC_SECTOFF: return "R_PPC_SECTOFF";
-  case R_PPC_SECTOFF_LO: return "R_PPC_SECTOFF_LO";
-  case R_PPC_SECTOFF_HI: return "R_PPC_SECTOFF_HI";
-  case R_PPC_SECTOFF_HA: return "R_PPC_SECTOFF_HA";
-  case R_PPC_ADDR30: return "R_PPC_ADDR30";
-  case R_PPC_TLS: return "R_PPC_TLS";
-  case R_PPC_DTPMOD32: return "R_PPC_DTPMOD32";
-  case R_PPC_TPREL16: return "R_PPC_TPREL16";
-  case R_PPC_TPREL16_LO: return "R_PPC_TPREL16_LO";
-  case R_PPC_TPREL16_HI: return "R_PPC_TPREL16_HI";
-  case R_PPC_TPREL16_HA: return "R_PPC_TPREL16_HA";
-  case R_PPC_TPREL32: return "R_PPC_TPREL32";
-  case R_PPC_DTPREL16: return "R_PPC_DTPREL16";
-  case R_PPC_DTPREL16_LO: return "R_PPC_DTPREL16_LO";
-  case R_PPC_DTPREL16_HI: return "R_PPC_DTPREL16_HI";
-  case R_PPC_DTPREL16_HA: return "R_PPC_DTPREL16_HA";
-  case R_PPC_DTPREL32: return "R_PPC_DTPREL32";
-  case R_PPC_GOT_TLSGD16: return "R_PPC_GOT_TLSGD16";
-  case R_PPC_GOT_TLSGD16_LO: return "R_PPC_GOT_TLSGD16_LO";
-  case R_PPC_GOT_TLSGD16_HI: return "R_PPC_GOT_TLSGD16_HI";
-  case R_PPC_GOT_TLSGD16_HA: return "R_PPC_GOT_TLSGD16_HA";
-  case R_PPC_GOT_TLSLD16: return "R_PPC_GOT_TLSLD16";
-  case R_PPC_GOT_TLSLD16_LO: return "R_PPC_GOT_TLSLD16_LO";
-  case R_PPC_GOT_TLSLD16_HI: return "R_PPC_GOT_TLSLD16_HI";
-  case R_PPC_GOT_TLSLD16_HA: return "R_PPC_GOT_TLSLD16_HA";
-  case R_PPC_GOT_TPREL16: return "R_PPC_GOT_TPREL16";
-  case R_PPC_GOT_TPREL16_LO: return "R_PPC_GOT_TPREL16_LO";
-  case R_PPC_GOT_TPREL16_HI: return "R_PPC_GOT_TPREL16_HI";
-  case R_PPC_GOT_TPREL16_HA: return "R_PPC_GOT_TPREL16_HA";
-  case R_PPC_GOT_DTPREL16: return "R_PPC_GOT_DTPREL16";
-  case R_PPC_GOT_DTPREL16_LO: return "R_PPC_GOT_DTPREL16_LO";
-  case R_PPC_GOT_DTPREL16_HI: return "R_PPC_GOT_DTPREL16_HI";
-  case R_PPC_GOT_DTPREL16_HA: return "R_PPC_GOT_DTPREL16_HA";
-  case R_PPC_TLSGD: return "R_PPC_TLSGD";
-  case R_PPC_TLSLD: return "R_PPC_TLSLD";
-  case R_PPC_PLTSEQ: return "R_PPC_PLTSEQ";
-  case R_PPC_PLTCALL: return "R_PPC_PLTCALL";
-  case R_PPC_IRELATIVE: return "R_PPC_IRELATIVE";
-  case R_PPC_REL16: return "R_PPC_REL16";
-  case R_PPC_REL16_LO: return "R_PPC_REL16_LO";
-  case R_PPC_REL16_HI: return "R_PPC_REL16_HI";
-  case R_PPC_REL16_HA: return "R_PPC_REL16_HA";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<PPC64V1>(u32 r_type) {
-  switch (r_type) {
-  case R_PPC64_NONE: return "R_PPC64_NONE";
-  case R_PPC64_ADDR32: return "R_PPC64_ADDR32";
-  case R_PPC64_ADDR24: return "R_PPC64_ADDR24";
-  case R_PPC64_ADDR16: return "R_PPC64_ADDR16";
-  case R_PPC64_ADDR16_LO: return "R_PPC64_ADDR16_LO";
-  case R_PPC64_ADDR16_HI: return "R_PPC64_ADDR16_HI";
-  case R_PPC64_ADDR16_HA: return "R_PPC64_ADDR16_HA";
-  case R_PPC64_ADDR14: return "R_PPC64_ADDR14";
-  case R_PPC64_ADDR14_BRTAKEN: return "R_PPC64_ADDR14_BRTAKEN";
-  case R_PPC64_ADDR14_BRNTAKEN: return "R_PPC64_ADDR14_BRNTAKEN";
-  case R_PPC64_REL24: return "R_PPC64_REL24";
-  case R_PPC64_REL14: return "R_PPC64_REL14";
-  case R_PPC64_REL14_BRTAKEN: return "R_PPC64_REL14_BRTAKEN";
-  case R_PPC64_REL14_BRNTAKEN: return "R_PPC64_REL14_BRNTAKEN";
-  case R_PPC64_GOT16: return "R_PPC64_GOT16";
-  case R_PPC64_GOT16_LO: return "R_PPC64_GOT16_LO";
-  case R_PPC64_GOT16_HI: return "R_PPC64_GOT16_HI";
-  case R_PPC64_GOT16_HA: return "R_PPC64_GOT16_HA";
-  case R_PPC64_COPY: return "R_PPC64_COPY";
-  case R_PPC64_GLOB_DAT: return "R_PPC64_GLOB_DAT";
-  case R_PPC64_JMP_SLOT: return "R_PPC64_JMP_SLOT";
-  case R_PPC64_RELATIVE: return "R_PPC64_RELATIVE";
-  case R_PPC64_REL32: return "R_PPC64_REL32";
-  case R_PPC64_PLT16_LO: return "R_PPC64_PLT16_LO";
-  case R_PPC64_PLT16_HI: return "R_PPC64_PLT16_HI";
-  case R_PPC64_PLT16_HA: return "R_PPC64_PLT16_HA";
-  case R_PPC64_ADDR64: return "R_PPC64_ADDR64";
-  case R_PPC64_ADDR16_HIGHER: return "R_PPC64_ADDR16_HIGHER";
-  case R_PPC64_ADDR16_HIGHERA: return "R_PPC64_ADDR16_HIGHERA";
-  case R_PPC64_ADDR16_HIGHEST: return "R_PPC64_ADDR16_HIGHEST";
-  case R_PPC64_ADDR16_HIGHESTA: return "R_PPC64_ADDR16_HIGHESTA";
-  case R_PPC64_REL64: return "R_PPC64_REL64";
-  case R_PPC64_TOC16: return "R_PPC64_TOC16";
-  case R_PPC64_TOC16_LO: return "R_PPC64_TOC16_LO";
-  case R_PPC64_TOC16_HI: return "R_PPC64_TOC16_HI";
-  case R_PPC64_TOC16_HA: return "R_PPC64_TOC16_HA";
-  case R_PPC64_TOC: return "R_PPC64_TOC";
-  case R_PPC64_ADDR16_DS: return "R_PPC64_ADDR16_DS";
-  case R_PPC64_ADDR16_LO_DS: return "R_PPC64_ADDR16_LO_DS";
-  case R_PPC64_GOT16_DS: return "R_PPC64_GOT16_DS";
-  case R_PPC64_GOT16_LO_DS: return "R_PPC64_GOT16_LO_DS";
-  case R_PPC64_PLT16_LO_DS: return "R_PPC64_PLT16_LO_DS";
-  case R_PPC64_TOC16_DS: return "R_PPC64_TOC16_DS";
-  case R_PPC64_TOC16_LO_DS: return "R_PPC64_TOC16_LO_DS";
-  case R_PPC64_TLS: return "R_PPC64_TLS";
-  case R_PPC64_DTPMOD64: return "R_PPC64_DTPMOD64";
-  case R_PPC64_TPREL16: return "R_PPC64_TPREL16";
-  case R_PPC64_TPREL16_LO: return "R_PPC64_TPREL16_LO";
-  case R_PPC64_TPREL16_HI: return "R_PPC64_TPREL16_HI";
-  case R_PPC64_TPREL16_HA: return "R_PPC64_TPREL16_HA";
-  case R_PPC64_TPREL64: return "R_PPC64_TPREL64";
-  case R_PPC64_DTPREL16: return "R_PPC64_DTPREL16";
-  case R_PPC64_DTPREL16_LO: return "R_PPC64_DTPREL16_LO";
-  case R_PPC64_DTPREL16_HI: return "R_PPC64_DTPREL16_HI";
-  case R_PPC64_DTPREL16_HA: return "R_PPC64_DTPREL16_HA";
-  case R_PPC64_DTPREL64: return "R_PPC64_DTPREL64";
-  case R_PPC64_GOT_TLSGD16: return "R_PPC64_GOT_TLSGD16";
-  case R_PPC64_GOT_TLSGD16_LO: return "R_PPC64_GOT_TLSGD16_LO";
-  case R_PPC64_GOT_TLSGD16_HI: return "R_PPC64_GOT_TLSGD16_HI";
-  case R_PPC64_GOT_TLSGD16_HA: return "R_PPC64_GOT_TLSGD16_HA";
-  case R_PPC64_GOT_TLSLD16: return "R_PPC64_GOT_TLSLD16";
-  case R_PPC64_GOT_TLSLD16_LO: return "R_PPC64_GOT_TLSLD16_LO";
-  case R_PPC64_GOT_TLSLD16_HI: return "R_PPC64_GOT_TLSLD16_HI";
-  case R_PPC64_GOT_TLSLD16_HA: return "R_PPC64_GOT_TLSLD16_HA";
-  case R_PPC64_GOT_TPREL16_DS: return "R_PPC64_GOT_TPREL16_DS";
-  case R_PPC64_GOT_TPREL16_LO_DS: return "R_PPC64_GOT_TPREL16_LO_DS";
-  case R_PPC64_GOT_TPREL16_HI: return "R_PPC64_GOT_TPREL16_HI";
-  case R_PPC64_GOT_TPREL16_HA: return "R_PPC64_GOT_TPREL16_HA";
-  case R_PPC64_GOT_DTPREL16_DS: return "R_PPC64_GOT_DTPREL16_DS";
-  case R_PPC64_GOT_DTPREL16_LO_DS: return "R_PPC64_GOT_DTPREL16_LO_DS";
-  case R_PPC64_GOT_DTPREL16_HI: return "R_PPC64_GOT_DTPREL16_HI";
-  case R_PPC64_GOT_DTPREL16_HA: return "R_PPC64_GOT_DTPREL16_HA";
-  case R_PPC64_TPREL16_DS: return "R_PPC64_TPREL16_DS";
-  case R_PPC64_TPREL16_LO_DS: return "R_PPC64_TPREL16_LO_DS";
-  case R_PPC64_TPREL16_HIGHER: return "R_PPC64_TPREL16_HIGHER";
-  case R_PPC64_TPREL16_HIGHERA: return "R_PPC64_TPREL16_HIGHERA";
-  case R_PPC64_TPREL16_HIGHEST: return "R_PPC64_TPREL16_HIGHEST";
-  case R_PPC64_TPREL16_HIGHESTA: return "R_PPC64_TPREL16_HIGHESTA";
-  case R_PPC64_DTPREL16_DS: return "R_PPC64_DTPREL16_DS";
-  case R_PPC64_DTPREL16_LO_DS: return "R_PPC64_DTPREL16_LO_DS";
-  case R_PPC64_DTPREL16_HIGHER: return "R_PPC64_DTPREL16_HIGHER";
-  case R_PPC64_DTPREL16_HIGHERA: return "R_PPC64_DTPREL16_HIGHERA";
-  case R_PPC64_DTPREL16_HIGHEST: return "R_PPC64_DTPREL16_HIGHEST";
-  case R_PPC64_DTPREL16_HIGHESTA: return "R_PPC64_DTPREL16_HIGHESTA";
-  case R_PPC64_TLSGD: return "R_PPC64_TLSGD";
-  case R_PPC64_TLSLD: return "R_PPC64_TLSLD";
-  case R_PPC64_ADDR16_HIGH: return "R_PPC64_ADDR16_HIGH";
-  case R_PPC64_ADDR16_HIGHA: return "R_PPC64_ADDR16_HIGHA";
-  case R_PPC64_TPREL16_HIGH: return "R_PPC64_TPREL16_HIGH";
-  case R_PPC64_TPREL16_HIGHA: return "R_PPC64_TPREL16_HIGHA";
-  case R_PPC64_DTPREL16_HIGH: return "R_PPC64_DTPREL16_HIGH";
-  case R_PPC64_DTPREL16_HIGHA: return "R_PPC64_DTPREL16_HIGHA";
-  case R_PPC64_REL24_NOTOC: return "R_PPC64_REL24_NOTOC";
-  case R_PPC64_PLTSEQ: return "R_PPC64_PLTSEQ";
-  case R_PPC64_PLTCALL: return "R_PPC64_PLTCALL";
-  case R_PPC64_PCREL_OPT: return "R_PPC64_PCREL_OPT";
-  case R_PPC64_PCREL34: return "R_PPC64_PCREL34";
-  case R_PPC64_GOT_PCREL34: return "R_PPC64_GOT_PCREL34";
-  case R_PPC64_TPREL34: return "R_PPC64_TPREL34";
-  case R_PPC64_DTPREL34: return "R_PPC64_DTPREL34";
-  case R_PPC64_GOT_TLSGD_PCREL34: return "R_PPC64_GOT_TLSGD_PCREL34";
-  case R_PPC64_GOT_TLSLD_PCREL34: return "R_PPC64_GOT_TLSLD_PCREL34";
-  case R_PPC64_GOT_TPREL_PCREL34: return "R_PPC64_GOT_TPREL_PCREL34";
-  case R_PPC64_IRELATIVE: return "R_PPC64_IRELATIVE";
-  case R_PPC64_REL16: return "R_PPC64_REL16";
-  case R_PPC64_REL16_LO: return "R_PPC64_REL16_LO";
-  case R_PPC64_REL16_HI: return "R_PPC64_REL16_HI";
-  case R_PPC64_REL16_HA: return "R_PPC64_REL16_HA";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<PPC64V2>(u32 r_type) {
-  return rel_to_string<PPC64V1>(r_type);
-}
-
-template <>
-std::string rel_to_string<SPARC64>(u32 r_type) {
-  switch (r_type) {
-  case R_SPARC_NONE: return "R_SPARC_NONE";
-  case R_SPARC_8: return "R_SPARC_8";
-  case R_SPARC_16: return "R_SPARC_16";
-  case R_SPARC_32: return "R_SPARC_32";
-  case R_SPARC_DISP8: return "R_SPARC_DISP8";
-  case R_SPARC_DISP16: return "R_SPARC_DISP16";
-  case R_SPARC_DISP32: return "R_SPARC_DISP32";
-  case R_SPARC_WDISP30: return "R_SPARC_WDISP30";
-  case R_SPARC_WDISP22: return "R_SPARC_WDISP22";
-  case R_SPARC_HI22: return "R_SPARC_HI22";
-  case R_SPARC_22: return "R_SPARC_22";
-  case R_SPARC_13: return "R_SPARC_13";
-  case R_SPARC_LO10: return "R_SPARC_LO10";
-  case R_SPARC_GOT10: return "R_SPARC_GOT10";
-  case R_SPARC_GOT13: return "R_SPARC_GOT13";
-  case R_SPARC_GOT22: return "R_SPARC_GOT22";
-  case R_SPARC_PC10: return "R_SPARC_PC10";
-  case R_SPARC_PC22: return "R_SPARC_PC22";
-  case R_SPARC_WPLT30: return "R_SPARC_WPLT30";
-  case R_SPARC_COPY: return "R_SPARC_COPY";
-  case R_SPARC_GLOB_DAT: return "R_SPARC_GLOB_DAT";
-  case R_SPARC_JMP_SLOT: return "R_SPARC_JMP_SLOT";
-  case R_SPARC_RELATIVE: return "R_SPARC_RELATIVE";
-  case R_SPARC_UA32: return "R_SPARC_UA32";
-  case R_SPARC_PLT32: return "R_SPARC_PLT32";
-  case R_SPARC_HIPLT22: return "R_SPARC_HIPLT22";
-  case R_SPARC_LOPLT10: return "R_SPARC_LOPLT10";
-  case R_SPARC_PCPLT32: return "R_SPARC_PCPLT32";
-  case R_SPARC_PCPLT22: return "R_SPARC_PCPLT22";
-  case R_SPARC_PCPLT10: return "R_SPARC_PCPLT10";
-  case R_SPARC_10: return "R_SPARC_10";
-  case R_SPARC_11: return "R_SPARC_11";
-  case R_SPARC_64: return "R_SPARC_64";
-  case R_SPARC_OLO10: return "R_SPARC_OLO10";
-  case R_SPARC_HH22: return "R_SPARC_HH22";
-  case R_SPARC_HM10: return "R_SPARC_HM10";
-  case R_SPARC_LM22: return "R_SPARC_LM22";
-  case R_SPARC_PC_HH22: return "R_SPARC_PC_HH22";
-  case R_SPARC_PC_HM10: return "R_SPARC_PC_HM10";
-  case R_SPARC_PC_LM22: return "R_SPARC_PC_LM22";
-  case R_SPARC_WDISP16: return "R_SPARC_WDISP16";
-  case R_SPARC_WDISP19: return "R_SPARC_WDISP19";
-  case R_SPARC_7: return "R_SPARC_7";
-  case R_SPARC_5: return "R_SPARC_5";
-  case R_SPARC_6: return "R_SPARC_6";
-  case R_SPARC_DISP64: return "R_SPARC_DISP64";
-  case R_SPARC_PLT64: return "R_SPARC_PLT64";
-  case R_SPARC_HIX22: return "R_SPARC_HIX22";
-  case R_SPARC_LOX10: return "R_SPARC_LOX10";
-  case R_SPARC_H44: return "R_SPARC_H44";
-  case R_SPARC_M44: return "R_SPARC_M44";
-  case R_SPARC_L44: return "R_SPARC_L44";
-  case R_SPARC_REGISTER: return "R_SPARC_REGISTER";
-  case R_SPARC_UA64: return "R_SPARC_UA64";
-  case R_SPARC_UA16: return "R_SPARC_UA16";
-  case R_SPARC_TLS_GD_HI22: return "R_SPARC_TLS_GD_HI22";
-  case R_SPARC_TLS_GD_LO10: return "R_SPARC_TLS_GD_LO10";
-  case R_SPARC_TLS_GD_ADD: return "R_SPARC_TLS_GD_ADD";
-  case R_SPARC_TLS_GD_CALL: return "R_SPARC_TLS_GD_CALL";
-  case R_SPARC_TLS_LDM_HI22: return "R_SPARC_TLS_LDM_HI22";
-  case R_SPARC_TLS_LDM_LO10: return "R_SPARC_TLS_LDM_LO10";
-  case R_SPARC_TLS_LDM_ADD: return "R_SPARC_TLS_LDM_ADD";
-  case R_SPARC_TLS_LDM_CALL: return "R_SPARC_TLS_LDM_CALL";
-  case R_SPARC_TLS_LDO_HIX22: return "R_SPARC_TLS_LDO_HIX22";
-  case R_SPARC_TLS_LDO_LOX10: return "R_SPARC_TLS_LDO_LOX10";
-  case R_SPARC_TLS_LDO_ADD: return "R_SPARC_TLS_LDO_ADD";
-  case R_SPARC_TLS_IE_HI22: return "R_SPARC_TLS_IE_HI22";
-  case R_SPARC_TLS_IE_LO10: return "R_SPARC_TLS_IE_LO10";
-  case R_SPARC_TLS_IE_LD: return "R_SPARC_TLS_IE_LD";
-  case R_SPARC_TLS_IE_LDX: return "R_SPARC_TLS_IE_LDX";
-  case R_SPARC_TLS_IE_ADD: return "R_SPARC_TLS_IE_ADD";
-  case R_SPARC_TLS_LE_HIX22: return "R_SPARC_TLS_LE_HIX22";
-  case R_SPARC_TLS_LE_LOX10: return "R_SPARC_TLS_LE_LOX10";
-  case R_SPARC_TLS_DTPMOD32: return "R_SPARC_TLS_DTPMOD32";
-  case R_SPARC_TLS_DTPMOD64: return "R_SPARC_TLS_DTPMOD64";
-  case R_SPARC_TLS_DTPOFF32: return "R_SPARC_TLS_DTPOFF32";
-  case R_SPARC_TLS_DTPOFF64: return "R_SPARC_TLS_DTPOFF64";
-  case R_SPARC_TLS_TPOFF32: return "R_SPARC_TLS_TPOFF32";
-  case R_SPARC_TLS_TPOFF64: return "R_SPARC_TLS_TPOFF64";
-  case R_SPARC_GOTDATA_HIX22: return "R_SPARC_GOTDATA_HIX22";
-  case R_SPARC_GOTDATA_LOX10: return "R_SPARC_GOTDATA_LOX10";
-  case R_SPARC_GOTDATA_OP_HIX22: return "R_SPARC_GOTDATA_OP_HIX22";
-  case R_SPARC_GOTDATA_OP_LOX10: return "R_SPARC_GOTDATA_OP_LOX10";
-  case R_SPARC_GOTDATA_OP: return "R_SPARC_GOTDATA_OP";
-  case R_SPARC_IRELATIVE: return "R_SPARC_IRELATIVE";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<S390X>(u32 r_type) {
-  switch (r_type) {
-  case R_390_NONE: return "R_390_NONE";
-  case R_390_8: return "R_390_8";
-  case R_390_12: return "R_390_12";
-  case R_390_16: return "R_390_16";
-  case R_390_32: return "R_390_32";
-  case R_390_PC32: return "R_390_PC32";
-  case R_390_GOT12: return "R_390_GOT12";
-  case R_390_GOT32: return "R_390_GOT32";
-  case R_390_PLT32: return "R_390_PLT32";
-  case R_390_COPY: return "R_390_COPY";
-  case R_390_GLOB_DAT: return "R_390_GLOB_DAT";
-  case R_390_JMP_SLOT: return "R_390_JMP_SLOT";
-  case R_390_RELATIVE: return "R_390_RELATIVE";
-  case R_390_GOTOFF32: return "R_390_GOTOFF32";
-  case R_390_GOTPC: return "R_390_GOTPC";
-  case R_390_GOT16: return "R_390_GOT16";
-  case R_390_PC16: return "R_390_PC16";
-  case R_390_PC16DBL: return "R_390_PC16DBL";
-  case R_390_PLT16DBL: return "R_390_PLT16DBL";
-  case R_390_PC32DBL: return "R_390_PC32DBL";
-  case R_390_PLT32DBL: return "R_390_PLT32DBL";
-  case R_390_GOTPCDBL: return "R_390_GOTPCDBL";
-  case R_390_64: return "R_390_64";
-  case R_390_PC64: return "R_390_PC64";
-  case R_390_GOT64: return "R_390_GOT64";
-  case R_390_PLT64: return "R_390_PLT64";
-  case R_390_GOTENT: return "R_390_GOTENT";
-  case R_390_GOTOFF16: return "R_390_GOTOFF16";
-  case R_390_GOTOFF64: return "R_390_GOTOFF64";
-  case R_390_GOTPLT12: return "R_390_GOTPLT12";
-  case R_390_GOTPLT16: return "R_390_GOTPLT16";
-  case R_390_GOTPLT32: return "R_390_GOTPLT32";
-  case R_390_GOTPLT64: return "R_390_GOTPLT64";
-  case R_390_GOTPLTENT: return "R_390_GOTPLTENT";
-  case R_390_PLTOFF16: return "R_390_PLTOFF16";
-  case R_390_PLTOFF32: return "R_390_PLTOFF32";
-  case R_390_PLTOFF64: return "R_390_PLTOFF64";
-  case R_390_TLS_LOAD: return "R_390_TLS_LOAD";
-  case R_390_TLS_GDCALL: return "R_390_TLS_GDCALL";
-  case R_390_TLS_LDCALL: return "R_390_TLS_LDCALL";
-  case R_390_TLS_GD32: return "R_390_TLS_GD32";
-  case R_390_TLS_GD64: return "R_390_TLS_GD64";
-  case R_390_TLS_GOTIE12: return "R_390_TLS_GOTIE12";
-  case R_390_TLS_GOTIE32: return "R_390_TLS_GOTIE32";
-  case R_390_TLS_GOTIE64: return "R_390_TLS_GOTIE64";
-  case R_390_TLS_LDM32: return "R_390_TLS_LDM32";
-  case R_390_TLS_LDM64: return "R_390_TLS_LDM64";
-  case R_390_TLS_IE32: return "R_390_TLS_IE32";
-  case R_390_TLS_IE64: return "R_390_TLS_IE64";
-  case R_390_TLS_IEENT: return "R_390_TLS_IEENT";
-  case R_390_TLS_LE32: return "R_390_TLS_LE32";
-  case R_390_TLS_LE64: return "R_390_TLS_LE64";
-  case R_390_TLS_LDO32: return "R_390_TLS_LDO32";
-  case R_390_TLS_LDO64: return "R_390_TLS_LDO64";
-  case R_390_TLS_DTPMOD: return "R_390_TLS_DTPMOD";
-  case R_390_TLS_DTPOFF: return "R_390_TLS_DTPOFF";
-  case R_390_TLS_TPOFF: return "R_390_TLS_TPOFF";
-  case R_390_20: return "R_390_20";
-  case R_390_GOT20: return "R_390_GOT20";
-  case R_390_GOTPLT20: return "R_390_GOTPLT20";
-  case R_390_TLS_GOTIE20: return "R_390_TLS_GOTIE20";
-  case R_390_IRELATIVE: return "R_390_IRELATIVE";
-  case R_390_PC12DBL: return "R_390_PC12DBL";
-  case R_390_PLT12DBL: return "R_390_PLT12DBL";
-  case R_390_PC24DBL: return "R_390_PC24DBL";
-  case R_390_PLT24DBL: return "R_390_PLT24DBL";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<M68K>(u32 r_type) {
-  switch (r_type) {
-  case R_68K_NONE: return "R_68K_NONE";
-  case R_68K_32: return "R_68K_32";
-  case R_68K_16: return "R_68K_16";
-  case R_68K_8: return "R_68K_8";
-  case R_68K_PC32: return "R_68K_PC32";
-  case R_68K_PC16: return "R_68K_PC16";
-  case R_68K_PC8: return "R_68K_PC8";
-  case R_68K_GOTPCREL32: return "R_68K_GOTPCREL32";
-  case R_68K_GOTPCREL16: return "R_68K_GOTPCREL16";
-  case R_68K_GOTPCREL8: return "R_68K_GOTPCREL8";
-  case R_68K_GOTOFF32: return "R_68K_GOTOFF32";
-  case R_68K_GOTOFF16: return "R_68K_GOTOFF16";
-  case R_68K_GOTOFF8: return "R_68K_GOTOFF8";
-  case R_68K_PLT32: return "R_68K_PLT32";
-  case R_68K_PLT16: return "R_68K_PLT16";
-  case R_68K_PLT8: return "R_68K_PLT8";
-  case R_68K_PLTOFF32: return "R_68K_PLTOFF32";
-  case R_68K_PLTOFF16: return "R_68K_PLTOFF16";
-  case R_68K_PLTOFF8: return "R_68K_PLTOFF8";
-  case R_68K_COPY: return "R_68K_COPY";
-  case R_68K_GLOB_DAT: return "R_68K_GLOB_DAT";
-  case R_68K_JMP_SLOT: return "R_68K_JMP_SLOT";
-  case R_68K_RELATIVE: return "R_68K_RELATIVE";
-  case R_68K_TLS_GD32: return "R_68K_TLS_GD32";
-  case R_68K_TLS_GD16: return "R_68K_TLS_GD16";
-  case R_68K_TLS_GD8: return "R_68K_TLS_GD8";
-  case R_68K_TLS_LDM32: return "R_68K_TLS_LDM32";
-  case R_68K_TLS_LDM16: return "R_68K_TLS_LDM16";
-  case R_68K_TLS_LDM8: return "R_68K_TLS_LDM8";
-  case R_68K_TLS_LDO32: return "R_68K_TLS_LDO32";
-  case R_68K_TLS_LDO16: return "R_68K_TLS_LDO16";
-  case R_68K_TLS_LDO8: return "R_68K_TLS_LDO8";
-  case R_68K_TLS_IE32: return "R_68K_TLS_IE32";
-  case R_68K_TLS_IE16: return "R_68K_TLS_IE16";
-  case R_68K_TLS_IE8: return "R_68K_TLS_IE8";
-  case R_68K_TLS_LE32: return "R_68K_TLS_LE32";
-  case R_68K_TLS_LE16: return "R_68K_TLS_LE16";
-  case R_68K_TLS_LE8: return "R_68K_TLS_LE8";
-  case R_68K_TLS_DTPMOD32: return "R_68K_TLS_DTPMOD32";
-  case R_68K_TLS_DTPREL32: return "R_68K_TLS_DTPREL32";
-  case R_68K_TLS_TPREL32: return "R_68K_TLS_TPREL32";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<SH4>(u32 r_type) {
-  switch (r_type) {
-  case R_SH_NONE: return "R_SH_NONE";
-  case R_SH_DIR32: return "R_SH_DIR32";
-  case R_SH_REL32: return "R_SH_REL32";
-  case R_SH_DIR8WPN: return "R_SH_DIR8WPN";
-  case R_SH_IND12W: return "R_SH_IND12W";
-  case R_SH_DIR8WPL: return "R_SH_DIR8WPL";
-  case R_SH_DIR8WPZ: return "R_SH_DIR8WPZ";
-  case R_SH_DIR8BP: return "R_SH_DIR8BP";
-  case R_SH_DIR8W: return "R_SH_DIR8W";
-  case R_SH_DIR8L: return "R_SH_DIR8L";
-  case R_SH_TLS_GD_32: return "R_SH_TLS_GD_32";
-  case R_SH_TLS_LD_32: return "R_SH_TLS_LD_32";
-  case R_SH_TLS_LDO_32: return "R_SH_TLS_LDO_32";
-  case R_SH_TLS_IE_32: return "R_SH_TLS_IE_32";
-  case R_SH_TLS_LE_32: return "R_SH_TLS_LE_32";
-  case R_SH_TLS_DTPMOD32: return "R_SH_TLS_DTPMOD32";
-  case R_SH_TLS_DTPOFF32: return "R_SH_TLS_DTPOFF32";
-  case R_SH_TLS_TPOFF32: return "R_SH_TLS_TPOFF32";
-  case R_SH_GOT32: return "R_SH_GOT32";
-  case R_SH_PLT32: return "R_SH_PLT32";
-  case R_SH_COPY: return "R_SH_COPY";
-  case R_SH_GLOB_DAT: return "R_SH_GLOB_DAT";
-  case R_SH_JMP_SLOT: return "R_SH_JMP_SLOT";
-  case R_SH_RELATIVE: return "R_SH_RELATIVE";
-  case R_SH_GOTOFF: return "R_SH_GOTOFF";
-  case R_SH_GOTPC: return "R_SH_GOTPC";
-  case R_SH_GOTPLT32: return "R_SH_GOTPLT32";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-template <>
-std::string rel_to_string<ALPHA>(u32 r_type) {
-  switch (r_type) {
-  case R_ALPHA_NONE: return "R_ALPHA_NONE";
-  case R_ALPHA_REFLONG: return "R_ALPHA_REFLONG";
-  case R_ALPHA_REFQUAD: return "R_ALPHA_REFQUAD";
-  case R_ALPHA_GPREL32: return "R_ALPHA_GPREL32";
-  case R_ALPHA_LITERAL: return "R_ALPHA_LITERAL";
-  case R_ALPHA_LITUSE: return "R_ALPHA_LITUSE";
-  case R_ALPHA_GPDISP: return "R_ALPHA_GPDISP";
-  case R_ALPHA_BRADDR: return "R_ALPHA_BRADDR";
-  case R_ALPHA_HINT: return "R_ALPHA_HINT";
-  case R_ALPHA_SREL16: return "R_ALPHA_SREL16";
-  case R_ALPHA_SREL32: return "R_ALPHA_SREL32";
-  case R_ALPHA_SREL64: return "R_ALPHA_SREL64";
-  case R_ALPHA_GPRELHIGH: return "R_ALPHA_GPRELHIGH";
-  case R_ALPHA_GPRELLOW: return "R_ALPHA_GPRELLOW";
-  case R_ALPHA_GPREL16: return "R_ALPHA_GPREL16";
-  case R_ALPHA_COPY: return "R_ALPHA_COPY";
-  case R_ALPHA_GLOB_DAT: return "R_ALPHA_GLOB_DAT";
-  case R_ALPHA_JMP_SLOT: return "R_ALPHA_JMP_SLOT";
-  case R_ALPHA_RELATIVE: return "R_ALPHA_RELATIVE";
-  case R_ALPHA_BRSGP: return "R_ALPHA_BRSGP";
-  case R_ALPHA_TLSGD: return "R_ALPHA_TLSGD";
-  case R_ALPHA_TLSLDM: return "R_ALPHA_TLSLDM";
-  case R_ALPHA_DTPMOD64: return "R_ALPHA_DTPMOD64";
-  case R_ALPHA_GOTDTPREL: return "R_ALPHA_GOTDTPREL";
-  case R_ALPHA_DTPREL64: return "R_ALPHA_DTPREL64";
-  case R_ALPHA_DTPRELHI: return "R_ALPHA_DTPRELHI";
-  case R_ALPHA_DTPRELLO: return "R_ALPHA_DTPRELLO";
-  case R_ALPHA_DTPREL16: return "R_ALPHA_DTPREL16";
-  case R_ALPHA_GOTTPREL: return "R_ALPHA_GOTTPREL";
-  case R_ALPHA_TPREL64: return "R_ALPHA_TPREL64";
-  case R_ALPHA_TPRELHI: return "R_ALPHA_TPRELHI";
-  case R_ALPHA_TPRELLO: return "R_ALPHA_TPRELLO";
-  case R_ALPHA_TPREL16: return "R_ALPHA_TPREL16";
-  }
-  return "unknown (" + std::to_string(r_type) + ")";
-}
-
-} // namespace mold::elf

elf/input-sections.cc

@@ -1,475 +0,0 @@
-#include "mold.h"
-
-#include <limits>
-#include <zlib.h>
-#include <zstd.h>
-
-namespace mold::elf {
-
-typedef enum {
-  NONE, ERROR, COPYREL, DYN_COPYREL, PLT, CPLT, DYN_CPLT, DYNREL, BASEREL, IFUNC,
-} Action;
-
-template <typename E>
-bool CieRecord<E>::equals(const CieRecord<E> &other) const {
-  if (get_contents() != other.get_contents())
-    return false;
-
-  std::span<const ElfRel<E>> x = get_rels();
-  std::span<const ElfRel<E>> y = other.get_rels();
-  if (x.size() != y.size())
-    return false;
-
-  for (i64 i = 0; i < x.size(); i++) {
-    if (x[i].r_offset - input_offset != y[i].r_offset - other.input_offset ||
-        x[i].r_type != y[i].r_type ||
-        file.symbols[x[i].r_sym] != other.file.symbols[y[i].r_sym] ||
-        get_addend(input_section, x[i]) != get_addend(other.input_section, y[i]))
-      return false;
-  }
-  return true;
-}
-
-static i64 to_p2align(u64 alignment) {
-  if (alignment == 0)
-    return 0;
-  return std::countr_zero(alignment);
-}
-
-template <typename E>
-InputSection<E>::InputSection(Context<E> &ctx, ObjectFile<E> &file,
-                              std::string_view name, i64 shndx)
-  : file(file), shndx(shndx) {
-  if (shndx < file.elf_sections.size())
-    contents = {(char *)file.mf->data + shdr().sh_offset, (size_t)shdr().sh_size};
-
-  if (shdr().sh_flags & SHF_COMPRESSED) {
-    ElfChdr<E> &chdr = *(ElfChdr<E> *)&contents[0];
-    sh_size = chdr.ch_size;
-    p2align = to_p2align(chdr.ch_addralign);
-  } else {
-    sh_size = shdr().sh_size;
-    p2align = to_p2align(shdr().sh_addralign);
-  }
-
-  // Sections may have been compressed. We usually uncompress them
-  // directly into the mmap'ed output file, but we want to uncompress
-  // early for REL-type ELF types to read relocation addends from
-  // section contents. For RELA-type, we don't need to do this because
-  // addends are in relocations.
-  if constexpr (!E::is_rela)
-    uncompress(ctx);
-}
-
-template <typename E>
-void InputSection<E>::uncompress(Context<E> &ctx) {
-  if (!(shdr().sh_flags & SHF_COMPRESSED) || uncompressed)
-    return;
-
-  u8 *buf = new u8[sh_size];
-  uncompress_to(ctx, buf);
-  contents = std::string_view((char *)buf, sh_size);
-  ctx.string_pool.emplace_back(buf);
-  uncompressed = true;
-}
-
-template <typename E>
-void InputSection<E>::uncompress_to(Context<E> &ctx, u8 *buf) {
-  if (!(shdr().sh_flags & SHF_COMPRESSED) || uncompressed) {
-    memcpy(buf, contents.data(), contents.size());
-    return;
-  }
-
-  if (contents.size() < sizeof(ElfChdr<E>))
-    Fatal(ctx) << *this << ": corrupted compressed section";
-
-  ElfChdr<E> &hdr = *(ElfChdr<E> *)&contents[0];
-  std::string_view data = contents.substr(sizeof(ElfChdr<E>));
-
-  switch (hdr.ch_type) {
-  case ELFCOMPRESS_ZLIB: {
-    unsigned long size = sh_size;
-    if (::uncompress(buf, &size, (u8 *)data.data(), data.size()) != Z_OK)
-      Fatal(ctx) << *this << ": uncompress failed";
-    assert(size == sh_size);
-    break;
-  }
-  case ELFCOMPRESS_ZSTD:
-    if (ZSTD_decompress(buf, sh_size, (u8 *)data.data(), data.size()) != sh_size)
-      Fatal(ctx) << *this << ": ZSTD_decompress failed";
-    break;
-  default:
-    Fatal(ctx) << *this << ": unsupported compression type: 0x"
-               << std::hex << hdr.ch_type;
-  }
-}
-
-template <typename E>
-static Action get_rel_action(Context<E> &ctx, Symbol<E> &sym,
-                             const Action table[3][4]) {
-  auto get_output_type = [&] {
-    if (ctx.arg.shared)
-      return 0;
-    if (ctx.arg.pie)
-      return 1;
-    return 2;
-  };
-
-  auto get_sym_type = [&] {
-    if (sym.is_absolute())
-      return 0;
-    if (!sym.is_imported)
-      return 1;
-    if (sym.get_type() != STT_FUNC)
-      return 2;
-    return 3;
-  };
-
-  return table[get_output_type()][get_sym_type()];
-}
-
-template <typename E>
-static void scan_rel(Context<E> &ctx, InputSection<E> &isec, Symbol<E> &sym,
-                     const ElfRel<E> &rel, Action action) {
-  bool writable = (isec.shdr().sh_flags & SHF_WRITE);
-
-  auto error = [&] {
-    std::string msg = sym.is_absolute() ? "-fno-PIC" : "-fPIC";
-    Error(ctx) << isec << ": " << rel << " relocation at offset 0x"
-               << std::hex << rel.r_offset << " against symbol `"
-               << sym << "' can not be used; recompile with " << msg;
-  };
-
-  auto check_textrel = [&] {
-    if (!writable) {
-      if (ctx.arg.z_text) {
-        error();
-      } else if (ctx.arg.warn_textrel) {
-        Warn(ctx) << isec << ": relocation against symbol `" << sym
-                  << "' in read-only section";
-      }
-      ctx.has_textrel = true;
-    }
-  };
-
-  auto copyrel = [&] {
-    assert(sym.is_imported);
-    if (sym.esym().st_visibility == STV_PROTECTED) {
-      Error(ctx) << isec
-                 << ": cannot make copy relocation for protected symbol '" << sym
-                 << "', defined in " << *sym.file << "; recompile with -fPIC";
-    }
-    sym.flags |= NEEDS_COPYREL;
-  };
-
-  auto dynrel = [&] {
-    check_textrel();
-    isec.file.num_dynrel++;
-  };
-
-  switch (action) {
-  case NONE:
-    break;
-  case ERROR:
-    error();
-    break;
-  case COPYREL:
-    if (!ctx.arg.z_copyreloc)
-      error();
-    copyrel();
-    break;
-  case DYN_COPYREL:
-    if (writable || !ctx.arg.z_copyreloc)
-      dynrel();
-    else
-      copyrel();
-    break;
-  case PLT:
-    sym.flags |= NEEDS_PLT;
-    break;
-  case CPLT:
-    sym.flags |= NEEDS_CPLT;
-    break;
-  case DYN_CPLT:
-    if (writable)
-      dynrel();
-    else
-      sym.flags |= NEEDS_CPLT;
-    break;
-  case DYNREL:
-    dynrel();
-    break;
-  case BASEREL:
-    check_textrel();
-    if (!isec.is_relr_reloc(ctx, rel))
-      isec.file.num_dynrel++;
-    break;
-  case IFUNC:
-    dynrel();
-    ctx.num_ifunc_dynrels.fetch_add(1, std::memory_order_relaxed);
-    break;
-  default:
-    unreachable();
-  }
-}
-
-template <typename E>
-static Action get_pcrel_action(Context<E> &ctx, Symbol<E> &sym) {
-  // This is for PC-relative relocations (e.g. R_X86_64_PC32).
-  // We cannot promote them to dynamic relocations because the dynamic
-  // linker generally does not support PC-relative relocations.
-  constexpr static Action table[3][4] = {
-    // Absolute  Local    Imported data  Imported code
-    {  ERROR,    NONE,    ERROR,         PLT    },  // Shared object
-    {  ERROR,    NONE,    COPYREL,       PLT    },  // Position-independent exec
-    {  NONE,     NONE,    COPYREL,       CPLT   },  // Position-dependent exec
-  };
-
-  return get_rel_action(ctx, sym, table);
-}
-
-template <typename E>
-static Action get_absrel_action(Context<E> &ctx, Symbol<E> &sym) {
-  // This is a decision table for absolute relocations that is smaller
-  // than the word size (e.g. R_X86_64_32). Since the dynamic linker
-  // generally does not support dynamic relocations smaller than the
-  // word size, we need to report an error if a relocation cannot be
-  // resolved at link-time.
-  constexpr static Action table[3][4] = {
-    // Absolute  Local    Imported data  Imported code
-    {  NONE,     ERROR,   ERROR,         ERROR },  // Shared object
-    {  NONE,     ERROR,   ERROR,         ERROR },  // Position-independent exec
-    {  NONE,     NONE,    COPYREL,       CPLT  },  // Position-dependent exec
-  };
-
-  return get_rel_action(ctx, sym, table);
-}
-
-template <typename E>
-static Action get_dyn_absrel_action(Context<E> &ctx, Symbol<E> &sym) {
-  if (sym.is_ifunc())
-    return IFUNC;
-
-  // This is a decision table for absolute relocations for the word
-  // size data (e.g. R_X86_64_64). Unlike the absrel_table, we can emit
-  // a dynamic relocation if we cannot resolve an address at link-time.
-  constexpr static Action table[3][4] = {
-    // Absolute  Local    Imported data  Imported code
-    {  NONE,     BASEREL, DYNREL,        DYNREL   },  // Shared object
-    {  NONE,     BASEREL, DYNREL,        DYNREL   },  // Position-independent exec
-    {  NONE,     NONE,    DYN_COPYREL,   DYN_CPLT },  // Position-dependent exec
-  };
-
-  return get_rel_action(ctx, sym, table);
-}
-
-template <typename E>
-static Action get_ppc64_toc_action(Context<E> &ctx, Symbol<E> &sym) {
-  if (sym.is_ifunc())
-    return IFUNC;
-
-  // As a special case, we do not create copy relocations nor canonical
-  // PLTs for .toc sections. PPC64's .toc is a compiler-generated
-  // GOT-like section, and no user-generated code directly uses values
-  // in it.
-  constexpr static Action table[3][4] = {
-    // Absolute  Local    Imported data  Imported code
-    {  NONE,     BASEREL, DYNREL,        DYNREL },  // Shared object
-    {  NONE,     BASEREL, DYNREL,        DYNREL },  // Position-independent exec
-    {  NONE,     NONE,    DYNREL,        DYNREL },  // Position-dependent exec
-  };
-
-  return get_rel_action(ctx, sym, table);
-}
-
-template <typename E>
-void InputSection<E>::scan_pcrel(Context<E> &ctx, Symbol<E> &sym,
-                                 const ElfRel<E> &rel) {
-  scan_rel(ctx, *this, sym, rel, get_pcrel_action(ctx, sym));
-}
-
-template <typename E>
-void InputSection<E>::scan_absrel(Context<E> &ctx, Symbol<E> &sym,
-                                  const ElfRel<E> &rel) {
-  scan_rel(ctx, *this, sym, rel, get_absrel_action(ctx, sym));
-}
-
-template <typename E>
-void InputSection<E>::scan_dyn_absrel(Context<E> &ctx, Symbol<E> &sym,
-                                      const ElfRel<E> &rel) {
-  scan_rel(ctx, *this, sym, rel, get_dyn_absrel_action(ctx, sym));
-}
-
-template <typename E>
-void InputSection<E>::scan_toc_rel(Context<E> &ctx, Symbol<E> &sym,
-                                   const ElfRel<E> &rel) {
-  scan_rel(ctx, *this, sym, rel, get_ppc64_toc_action(ctx, sym));
-}
-
-template <typename E>
-static void apply_absrel(Context<E> &ctx, InputSection<E> &isec,
-                         Symbol<E> &sym, const ElfRel<E> &rel, u8 *loc,
-                         u64 S, i64 A, u64 P, ElfRel<E> *&dynrel,
-                         Action action) {
-  bool writable = (isec.shdr().sh_flags & SHF_WRITE);
-
-  auto apply_dynrel = [&] {
-    *dynrel++ = ElfRel<E>(P, E::R_ABS, sym.get_dynsym_idx(ctx), A);
-    if (ctx.arg.apply_dynamic_relocs)
-      *(Word<E> *)loc = A;
-  };
-
-  switch (action) {
-  case COPYREL:
-  case CPLT:
-  case NONE:
-    *(Word<E> *)loc = S + A;
-    break;
-  case BASEREL:
-    if (isec.is_relr_reloc(ctx, rel)) {
-      *(Word<E> *)loc = S + A;
-    } else {
-      *dynrel++ = ElfRel<E>(P, E::R_RELATIVE, 0, S + A);
-      if (ctx.arg.apply_dynamic_relocs)
-        *(Word<E> *)loc = S + A;
-    }
-    break;
-  case DYN_COPYREL:
-    if (writable || !ctx.arg.z_copyreloc)
-      apply_dynrel();
-    else
-      *(Word<E> *)loc = S + A;
-    break;
-  case DYN_CPLT:
-    if (writable)
-      apply_dynrel();
-    else
-      *(Word<E> *)loc = S + A;
-    break;
-  case DYNREL:
-    apply_dynrel();
-    break;
-  case IFUNC: {
-    u64 addr = sym.get_addr(ctx, NO_PLT) + A;
-    *dynrel++ = ElfRel<E>(P, E::R_IRELATIVE, 0, addr);
-    if (ctx.arg.apply_dynamic_relocs)
-      *(Word<E> *)loc = addr;
-    break;
-  }
-  default:
-    unreachable();
-  }
-}
-
-template <typename E>
-void InputSection<E>::apply_dyn_absrel(Context<E> &ctx, Symbol<E> &sym,
-                                       const ElfRel<E> &rel, u8 *loc,
-                                       u64 S, i64 A, u64 P,
-                                       ElfRel<E> *&dynrel) {
-  apply_absrel(ctx, *this, sym, rel, loc, S, A, P, dynrel,
-               get_dyn_absrel_action(ctx, sym));
-}
-
-template <typename E>
-void InputSection<E>::apply_toc_rel(Context<E> &ctx, Symbol<E> &sym,
-                                    const ElfRel<E> &rel, u8 *loc,
-                                    u64 S, i64 A, u64 P,
-                                    ElfRel<E> *&dynrel) {
-  apply_absrel(ctx, *this, sym, rel, loc, S, A, P, dynrel,
-               get_ppc64_toc_action(ctx, sym));
-}
-
-template <typename E>
-void InputSection<E>::write_to(Context<E> &ctx, u8 *buf) {
-  if (shdr().sh_type == SHT_NOBITS || sh_size == 0)
-    return;
-
-  // Copy data
-  if constexpr (is_riscv<E>) {
-    copy_contents_riscv(ctx, buf);
-  } else {
-    uncompress_to(ctx, buf);
-  }
-
-  // Apply relocations
-  if (!ctx.arg.relocatable) {
-    if (shdr().sh_flags & SHF_ALLOC)
-      apply_reloc_alloc(ctx, buf);
-    else
-      apply_reloc_nonalloc(ctx, buf);
-  }
-}
-
-// Get the name of a function containin a given offset.
-template <typename E>
-std::string_view InputSection<E>::get_func_name(Context<E> &ctx, i64 offset) {
-  for (const ElfSym<E> &esym : file.elf_syms) {
-    if (esym.st_shndx == shndx && esym.st_type == STT_FUNC &&
-        esym.st_value <= offset && offset < esym.st_value + esym.st_size) {
-      std::string_view name = file.symbol_strtab.data() + esym.st_name;
-      if (ctx.arg.demangle)
-        return demangle(name);
-      return name;
-    }
-  }
-  return "";
-}
-
-// Record an undefined symbol error which will be displayed all at
-// once by report_undef_errors().
-template <typename E>
-void InputSection<E>::record_undef_error(Context<E> &ctx, const ElfRel<E> &rel) {
-  std::stringstream ss;
-  if (std::string_view source = file.get_source_name(); !source.empty())
-    ss << ">>> referenced by " << source << "\n";
-  else
-    ss << ">>> referenced by " << *this << "\n";
-
-  ss << ">>>               " << file;
-  if (std::string_view func = get_func_name(ctx, rel.r_offset); !func.empty())
-    ss << ":(" << func << ")";
-
-  Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-  typename decltype(ctx.undef_errors)::accessor acc;
-  ctx.undef_errors.insert(acc, {sym.name(), {}});
-  acc->second.push_back(ss.str());
-}
-
-// Report all undefined symbols, grouped by symbol.
-template <typename E>
-void report_undef_errors(Context<E> &ctx) {
-  constexpr i64 max_errors = 3;
-
-  for (auto &pair : ctx.undef_errors) {
-    std::string_view sym_name = pair.first;
-    std::span<std::string> errors = pair.second;
-
-    if (ctx.arg.demangle)
-      sym_name = demangle(sym_name);
-
-    std::stringstream ss;
-    ss << "undefined symbol: " << sym_name << "\n";
-
-    for (i64 i = 0; i < errors.size() && i < max_errors; i++)
-      ss << errors[i];
-
-    if (errors.size() > max_errors)
-      ss << ">>> referenced " << (errors.size() - max_errors) << " more times\n";
-
-    if (ctx.arg.unresolved_symbols == UNRESOLVED_ERROR)
-      Error(ctx) << ss.str();
-    else if (ctx.arg.unresolved_symbols == UNRESOLVED_WARN)
-      Warn(ctx) << ss.str();
-  }
-
-  ctx.checkpoint();
-}
-
-using E = MOLD_TARGET;
-
-template struct CieRecord<E>;
-template class InputSection<E>;
-template void report_undef_errors(Context<E> &);
-
-} // namespace mold::elf

elf/linker-script.cc

@@ -1,424 +0,0 @@
-// On Linux, /usr/lib/x86_64-linux-gnu/libc.so is not actually
-// a shared object file but an ASCII text file containing a linker
-// script to include a "real" libc.so file. Therefore, we need to
-// support a (very limited) subset of the linker script language.
-
-#include "mold.h"
-
-#include <cctype>
-#include <iomanip>
-
-namespace mold::elf {
-
-template <typename E>
-static thread_local MappedFile<Context<E>> *current_file;
-
-template <typename E>
-void read_version_script(Context<E> &ctx, std::span<std::string_view> &tok);
-
-static std::string_view get_line(std::string_view input, const char *pos) {
-  assert(input.data() <= pos);
-  assert(pos < input.data() + input.size());
-
-  i64 start = input.rfind('\n', pos - input.data());
-  if (start == input.npos)
-    start = 0;
-  else
-    start++;
-
-  i64 end = input.find('\n', pos - input.data());
-  if (end == input.npos)
-    end = input.size();
-
-  return input.substr(start, end - start);
-}
-
-template <typename E>
-class SyntaxError {
-public:
-  SyntaxError(Context<E> &ctx, std::string_view errpos) : out(ctx) {
-    std::string_view contents = current_file<E>->get_contents();
-    std::string_view line = get_line(contents, errpos.data());
-
-    i64 lineno = 1;
-    for (i64 i = 0; contents.data() + i < line.data(); i++)
-      if (contents[i] == '\n')
-        lineno++;
-
-    i64 column = errpos.data() - line.data();
-
-    std::stringstream ss;
-    ss << current_file<E>->name << ":" << lineno << ": ";
-    i64 indent = (i64)ss.tellp() + strlen("mold: ");
-    ss << line << "\n" << std::setw(indent + column) << " " << "^ ";
-    out << ss.str();
-  }
-
-  template <class T> SyntaxError &operator<<(T &&val) {
-    out << std::forward<T>(val);
-    return *this;
-  }
-
-  [[noreturn]] ~SyntaxError() = default;
-
-  Fatal<Context<E>> out;
-};
-
-template <typename E>
-static std::vector<std::string_view>
-tokenize(Context<E> &ctx, std::string_view input) {
-  std::vector<std::string_view> vec;
-  while (!input.empty()) {
-    if (isspace(input[0])) {
-      input = input.substr(1);
-      continue;
-    }
-
-    if (input.starts_with("/*")) {
-      i64 pos = input.find("*/", 2);
-      if (pos == std::string_view::npos)
-        SyntaxError(ctx, input) << "unclosed comment";
-      input = input.substr(pos + 2);
-      continue;
-    }
-
-    if (input[0] == '#') {
-      i64 pos = input.find("\n", 1);
-      if (pos == std::string_view::npos)
-        break;
-      input = input.substr(pos + 1);
-      continue;
-    }
-
-    if (input[0] == '"') {
-      i64 pos = input.find('"', 1);
-      if (pos == std::string_view::npos)
-        SyntaxError(ctx, input) << "unclosed string literal";
-      vec.push_back(input.substr(0, pos + 1));
-      input = input.substr(pos + 1);
-      continue;
-    }
-
-    i64 pos = input.find_first_not_of(
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-      "0123456789_.$/\\~=+[]*?-!^:");
-
-    if (pos == 0)
-      pos = 1;
-    else if (pos == input.npos)
-      pos = input.size();
-
-    vec.push_back(input.substr(0, pos));
-    input = input.substr(pos);
-  }
-  return vec;
-}
-
-template <typename E>
-static std::span<std::string_view>
-skip(Context<E> &ctx, std::span<std::string_view> tok, std::string_view str) {
-  if (tok.empty())
-    Fatal(ctx) << current_file<E>->name << ": expected '" << str
-               << "', but got EOF";
-  if (tok[0] != str)
-    SyntaxError(ctx, tok[0]) << "expected '" << str << "'";
-  return tok.subspan(1);
-}
-
-static std::string_view unquote(std::string_view s) {
-  if (s.size() > 0 && s[0] == '"') {
-    assert(s[s.size() - 1] == '"');
-    return s.substr(1, s.size() - 2);
-  }
-  return s;
-}
-
-template <typename E>
-static std::span<std::string_view>
-read_output_format(Context<E> &ctx, std::span<std::string_view> tok) {
-  tok = skip(ctx, tok, "(");
-  while (!tok.empty() && tok[0] != ")")
-    tok = tok.subspan(1);
-  if (tok.empty())
-    Fatal(ctx) << current_file<E>->name << ": expected ')', but got EOF";
-  return tok.subspan(1);
-}
-
-template <typename E>
-static bool is_in_sysroot(Context<E> &ctx, std::string path) {
-  std::string rel = to_abs_path(path)
-                        .lexically_relative(to_abs_path(ctx.arg.sysroot))
-                        .string();
-  return rel != "." && !rel.starts_with("../");
-}
-
-template <typename E>
-static MappedFile<Context<E>> *resolve_path(Context<E> &ctx, std::string_view tok) {
-  std::string str(unquote(tok));
-
-  // GNU ld prepends the sysroot if a pathname starts with '/' and the
-  // script being processed is in the sysroot. We do the same.
-  if (str.starts_with('/') && is_in_sysroot(ctx, current_file<E>->name))
-    return MappedFile<Context<E>>::must_open(ctx, ctx.arg.sysroot + str);
-
-  if (str.starts_with('=')) {
-    std::string path;
-    if (ctx.arg.sysroot.empty())
-      path = str.substr(1);
-    else
-      path = ctx.arg.sysroot + str.substr(1);
-    return MappedFile<Context<E>>::must_open(ctx, path);
-  }
-
-  if (str.starts_with("-l"))
-    return find_library(ctx, str.substr(2));
-
-  if (MappedFile<Context<E>> *mf = open_library(ctx, str))
-    return mf;
-
-  for (std::string_view dir : ctx.arg.library_paths) {
-    std::string path = std::string(dir) + "/" + str;
-    if (MappedFile<Context<E>> *mf = open_library(ctx, path))
-      return mf;
-  }
-
-  SyntaxError(ctx, tok) << "library not found: " << str;
-}
-
-template <typename E>
-static std::span<std::string_view>
-read_group(Context<E> &ctx, std::span<std::string_view> tok) {
-  tok = skip(ctx, tok, "(");
-
-  while (!tok.empty() && tok[0] != ")") {
-    if (tok[0] == "AS_NEEDED") {
-      bool orig = ctx.as_needed;
-      ctx.as_needed = true;
-      tok = read_group(ctx, tok.subspan(1));
-      ctx.as_needed = orig;
-      continue;
-    }
-
-    MappedFile<Context<E>> *mf = resolve_path(ctx, tok[0]);
-    read_file(ctx, mf);
-    tok = tok.subspan(1);
-  }
-
-  if (tok.empty())
-    Fatal(ctx) << current_file<E>->name << ": expected ')', but got EOF";
-  return tok.subspan(1);
-}
-
-template <typename E>
-void parse_linker_script(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  current_file<E> = mf;
-
-  std::vector<std::string_view> vec = tokenize(ctx, mf->get_contents());
-  std::span<std::string_view> tok = vec;
-
-  while (!tok.empty()) {
-    if (tok[0] == "OUTPUT_FORMAT") {
-      tok = read_output_format(ctx, tok.subspan(1));
-    } else if (tok[0] == "INPUT" || tok[0] == "GROUP") {
-      tok = read_group(ctx, tok.subspan(1));
-    } else if (tok[0] == "VERSION") {
-      tok = tok.subspan(1);
-      tok = skip(ctx, tok, "{");
-      read_version_script(ctx, tok);
-      tok = skip(ctx, tok, "}");
-    } else if (tok.size() > 3 && tok[1] == "=" && tok[3] == ";") {
-      ctx.arg.defsyms.emplace_back(get_symbol(ctx, unquote(tok[0])),
-                                   get_symbol(ctx, unquote(tok[2])));
-      tok = tok.subspan(4);
-    } else if (tok[0] == ";") {
-      tok = tok.subspan(1);
-    } else {
-      SyntaxError(ctx, tok[0]) << "unknown linker script token";
-    }
-  }
-}
-
-template <typename E>
-std::string_view
-get_script_output_type(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  current_file<E> = mf;
-
-  std::vector<std::string_view> vec = tokenize(ctx, mf->get_contents());
-  std::span<std::string_view> tok = vec;
-
-  if (tok.size() >= 3 && tok[0] == "OUTPUT_FORMAT" && tok[1] == "(") {
-    if (tok[2] == "elf64-x86-64")
-      return X86_64::target_name;
-    if (tok[2] == "elf32-i386")
-      return I386::target_name;
-  }
-
-  if (tok.size() >= 3 && (tok[0] == "INPUT" || tok[0] == "GROUP") &&
-      tok[1] == "(")
-    if (MappedFile<Context<E>> *mf =
-        MappedFile<Context<E>>::open(ctx, std::string(unquote(tok[2]))))
-      return get_machine_type(ctx, mf);
-
-  return "";
-}
-
-static bool read_label(std::span<std::string_view> &tok,
-                       std::string label) {
-  if (tok.size() >= 1 && tok[0] == label + ":") {
-    tok = tok.subspan(1);
-    return true;
-  }
-
-  if (tok.size() >= 2 && tok[0] == label && tok[1] == ":") {
-    tok = tok.subspan(2);
-    return true;
-  }
-  return false;
-}
-
-template <typename E>
-static void
-read_version_script_commands(Context<E> &ctx, std::span<std::string_view> &tok,
-                             std::string_view ver_str, u16 ver_idx, bool is_cpp) {
-  bool is_global = true;
-
-  while (!tok.empty() && tok[0] != "}") {
-    if (read_label(tok, "global")) {
-      is_global = true;
-      continue;
-    }
-
-    if (read_label(tok, "local")) {
-      is_global = false;
-      continue;
-    }
-
-    if (tok[0] == "extern") {
-      tok = tok.subspan(1);
-
-      if (!tok.empty() && tok[0] == "\"C\"") {
-        tok = tok.subspan(1);
-        tok = skip(ctx, tok, "{");
-        read_version_script_commands( ctx, tok, ver_str, ver_idx, false);
-      } else {
-        tok = skip(ctx, tok, "\"C++\"");
-        tok = skip(ctx, tok, "{");
-        read_version_script_commands(ctx, tok, ver_str, ver_idx, true);
-      }
-
-      tok = skip(ctx, tok, "}");
-      tok = skip(ctx, tok, ";");
-      continue;
-    }
-
-    if (tok[0] == "*") {
-      ctx.default_version = (is_global ? ver_idx : (u32)VER_NDX_LOCAL);
-      ctx.default_version_from_version_script = true;
-    } else if (is_global) {
-      ctx.version_patterns.push_back({unquote(tok[0]), current_file<E>->name,
-                                      ver_str, ver_idx, is_cpp});
-    } else {
-      ctx.version_patterns.push_back({unquote(tok[0]), current_file<E>->name,
-                                      ver_str, VER_NDX_LOCAL, is_cpp});
-    }
-
-    tok = tok.subspan(1);
-
-    if (!tok.empty() && tok[0] == "}")
-      return;
-    tok = skip(ctx, tok, ";");
-  }
-}
-
-template <typename E>
-void read_version_script(Context<E> &ctx, std::span<std::string_view> &tok) {
-  u16 next_ver = VER_NDX_LAST_RESERVED + ctx.arg.version_definitions.size() + 1;
-
-  while (!tok.empty() && tok[0] != "}") {
-    std::string_view ver_str;
-    u16 ver_idx;
-
-    if (tok[0] == "{") {
-      ver_str = "global";
-      ver_idx = VER_NDX_GLOBAL;
-    } else {
-      ver_str = tok[0];
-      ver_idx = next_ver++;
-      ctx.arg.version_definitions.push_back(std::string(tok[0]));
-      tok = tok.subspan(1);
-    }
-
-    tok = skip(ctx, tok, "{");
-    read_version_script_commands(ctx, tok, ver_str, ver_idx, false);
-    tok = skip(ctx, tok, "}");
-    if (!tok.empty() && tok[0] != ";")
-      tok = tok.subspan(1);
-    tok = skip(ctx, tok, ";");
-  }
-}
-
-template <typename E>
-void parse_version_script(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  current_file<E> = mf;
-  std::vector<std::string_view> vec = tokenize(ctx, mf->get_contents());
-  std::span<std::string_view> tok = vec;
-  read_version_script(ctx, tok);
-  if (!tok.empty())
-    SyntaxError(ctx, tok[0]) << "trailing garbage token";
-}
-
-template <typename E>
-void read_dynamic_list_commands(Context<E> &ctx, std::span<std::string_view> &tok,
-                                bool is_cpp) {
-  while (!tok.empty() && tok[0] != "}") {
-    if (tok[0] == "extern") {
-      tok = tok.subspan(1);
-
-      if (!tok.empty() && tok[0] == "\"C\"") {
-        tok = tok.subspan(1);
-        tok = skip(ctx, tok, "{");
-        read_dynamic_list_commands(ctx, tok, false);
-      } else {
-        tok = skip(ctx, tok, "\"C++\"");
-        tok = skip(ctx, tok, "{");
-        read_dynamic_list_commands(ctx, tok, true);
-      }
-
-      tok = skip(ctx, tok, "}");
-      tok = skip(ctx, tok, ";");
-      continue;
-    }
-
-    if (tok[0] == "*")
-      ctx.default_version = VER_NDX_GLOBAL;
-    else
-      ctx.version_patterns.push_back({unquote(tok[0]), current_file<E>->name,
-                                      "global", VER_NDX_GLOBAL, is_cpp});
-
-    tok = skip(ctx, tok.subspan(1), ";");
-  }
-}
-
-template <typename E>
-void parse_dynamic_list(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  current_file<E> = mf;
-  std::vector<std::string_view> vec = tokenize(ctx, mf->get_contents());
-  std::span<std::string_view> tok = vec;
-
-  tok = skip(ctx, tok, "{");
-  read_dynamic_list_commands(ctx, tok, false);
-  tok = skip(ctx, tok, "}");
-  tok = skip(ctx, tok, ";");
-
-  if (!tok.empty())
-    SyntaxError(ctx, tok[0]) << "trailing garbage token";
-}
-
-using E = MOLD_TARGET;
-
-template void parse_linker_script(Context<E> &, MappedFile<Context<E>> *);
-template std::string_view get_script_output_type(Context<E> &, MappedFile<Context<E>> *);
-template void parse_version_script(Context<E> &, MappedFile<Context<E>> *);
-template void parse_dynamic_list(Context<E> &, MappedFile<Context<E>> *);
-
-} // namespace mold::elf

elf/lto.cc

@@ -1,5 +0,0 @@
-#ifdef _WIN32
-# include "lto-win32.cc"
-#else
-# include "lto-unix.cc"
-#endif

elf/main.cc

@@ -1,773 +0,0 @@
-#include "mold.h"
-#include "../archive-file.h"
-#include "../cmdline.h"
-#include "../output-file.h"
-
-#include <cstring>
-#include <functional>
-#include <iomanip>
-#include <map>
-#include <regex>
-#include <signal.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <tbb/global_control.h>
-#include <tbb/parallel_for_each.h>
-#include <unordered_set>
-
-#ifdef _WIN32
-# include <direct.h>
-# define _chdir chdir
-#else
-# include <unistd.h>
-#endif
-
-namespace mold::elf {
-
-// Read the beginning of a given file and returns its machine type
-// (e.g. EM_X86_64 or EM_386).
-template <typename E>
-std::string_view get_machine_type(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  auto get_elf_type = [&](u8 *buf) -> std::string_view {
-    bool is_le = (((ElfEhdr<I386> *)buf)->e_ident[EI_DATA] == ELFDATA2LSB);
-    bool is_64;
-    u32 e_machine;
-
-    if (is_le) {
-      auto &ehdr = *(ElfEhdr<I386> *)buf;
-      is_64 = (ehdr.e_ident[EI_CLASS] == ELFCLASS64);
-      e_machine = ehdr.e_machine;
-    } else {
-      auto &ehdr = *(ElfEhdr<M68K> *)buf;
-      is_64 = (ehdr.e_ident[EI_CLASS] == ELFCLASS64);
-      e_machine = ehdr.e_machine;
-    }
-
-    switch (e_machine) {
-    case EM_386:
-      return I386::target_name;
-    case EM_X86_64:
-      return X86_64::target_name;
-    case EM_ARM:
-      return ARM32::target_name;
-    case EM_AARCH64:
-      return ARM64::target_name;
-    case EM_RISCV:
-      if (is_le)
-        return is_64 ? RV64LE::target_name : RV32LE::target_name;
-      return is_64 ? RV64BE::target_name : RV32BE::target_name;
-    case EM_PPC:
-      return PPC32::target_name;
-    case EM_PPC64:
-      return is_le ? PPC64V2::target_name : PPC64V1::target_name;
-    case EM_S390X:
-      return S390X::target_name;
-    case EM_SPARC64:
-      return SPARC64::target_name;
-    case EM_68K:
-      return M68K::target_name;
-    case EM_SH:
-      return SH4::target_name;
-    case EM_ALPHA:
-      return ALPHA::target_name;
-    default:
-      return "";
-    }
-  };
-
-  bool opt_plugin = !ctx.arg.plugin.empty();
-
-  switch (get_file_type(mf, opt_plugin)) {
-  case FileType::ELF_OBJ:
-  case FileType::ELF_DSO:
-  case FileType::GCC_LTO_OBJ:
-    return get_elf_type(mf->data);
-  case FileType::AR:
-    for (MappedFile<Context<E>> *child : read_fat_archive_members(ctx, mf))
-      if (get_file_type(child, opt_plugin) == FileType::ELF_OBJ)
-        return get_elf_type(child->data);
-    return "";
-  case FileType::THIN_AR:
-    for (MappedFile<Context<E>> *child : read_thin_archive_members(ctx, mf))
-      if (get_file_type(child, opt_plugin) == FileType::ELF_OBJ)
-        return get_elf_type(child->data);
-    return "";
-  case FileType::TEXT:
-    return get_script_output_type(ctx, mf);
-  default:
-    return "";
-  }
-}
-
-template <typename E>
-static void
-check_file_compatibility(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  std::string_view target = get_machine_type(ctx, mf);
-  if (target != ctx.arg.emulation)
-    Fatal(ctx) << mf->name << ": incompatible file type: "
-               << ctx.arg.emulation << " is expected but got " << target;
-}
-
-template <typename E>
-static ObjectFile<E> *new_object_file(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                                      std::string archive_name) {
-  static Counter count("parsed_objs");
-  count++;
-
-  check_file_compatibility(ctx, mf);
-
-  bool in_lib = ctx.in_lib || (!archive_name.empty() && !ctx.whole_archive);
-  ObjectFile<E> *file = ObjectFile<E>::create(ctx, mf, archive_name, in_lib);
-  file->priority = ctx.file_priority++;
-  ctx.tg.run([file, &ctx] { file->parse(ctx); });
-  if (ctx.arg.trace)
-    SyncOut(ctx) << "trace: " << *file;
-  return file;
-}
-
-template <typename E>
-static ObjectFile<E> *new_lto_obj(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                                  std::string archive_name) {
-  static Counter count("parsed_lto_objs");
-  count++;
-
-  if (ctx.arg.ignore_ir_file.count(mf->get_identifier()))
-    return nullptr;
-
-  ObjectFile<E> *file = read_lto_object(ctx, mf);
-  file->priority = ctx.file_priority++;
-  file->archive_name = archive_name;
-  file->is_in_lib = ctx.in_lib || (!archive_name.empty() && !ctx.whole_archive);
-  file->is_alive = !file->is_in_lib;
-  ctx.has_lto_object = true;
-  if (ctx.arg.trace)
-    SyncOut(ctx) << "trace: " << *file;
-  return file;
-}
-
-template <typename E>
-static SharedFile<E> *
-new_shared_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  check_file_compatibility(ctx, mf);
-
-  SharedFile<E> *file = SharedFile<E>::create(ctx, mf);
-  file->priority = ctx.file_priority++;
-  ctx.tg.run([file, &ctx] { file->parse(ctx); });
-  if (ctx.arg.trace)
-    SyncOut(ctx) << "trace: " << *file;
-  return file;
-}
-
-template <typename E>
-void read_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  if (ctx.visited.contains(mf->name))
-    return;
-
-  bool opt_plugin = !ctx.arg.plugin.empty();
-  FileType type = get_file_type(mf, opt_plugin);
-  switch (type) {
-  case FileType::ELF_OBJ:
-    ctx.objs.push_back(new_object_file(ctx, mf, ""));
-    return;
-  case FileType::ELF_DSO:
-    ctx.dsos.push_back(new_shared_file(ctx, mf));
-    ctx.visited.insert(mf->name);
-    return;
-  case FileType::AR:
-  case FileType::THIN_AR:
-    for (MappedFile<Context<E>> *child : read_archive_members(ctx, mf)) {
-      switch (get_file_type(child, opt_plugin)) {
-      case FileType::ELF_OBJ:
-        ctx.objs.push_back(new_object_file(ctx, child, mf->name));
-        break;
-      case FileType::GCC_LTO_OBJ:
-      case FileType::LLVM_BITCODE:
-        if (ObjectFile<E> *file = new_lto_obj(ctx, child, mf->name))
-          ctx.objs.push_back(file);
-        break;
-      default:
-        break;
-      }
-    }
-    ctx.visited.insert(mf->name);
-    return;
-  case FileType::TEXT:
-    parse_linker_script(ctx, mf);
-    return;
-  case FileType::GCC_LTO_OBJ:
-  case FileType::LLVM_BITCODE:
-    if (ObjectFile<E> *file = new_lto_obj(ctx, mf, ""))
-      ctx.objs.push_back(file);
-    return;
-  default:
-    Fatal(ctx) << mf->name << ": unknown file type";
-  }
-}
-
-template <typename E>
-static std::string_view
-deduce_machine_type(Context<E> &ctx, std::span<std::string> args) {
-  for (std::string_view arg : args)
-    if (!arg.starts_with('-'))
-      if (auto *mf = MappedFile<Context<E>>::open(ctx, std::string(arg)))
-        if (std::string_view target = get_machine_type(ctx, mf);
-            !target.empty())
-          return target;
-  Fatal(ctx) << "-m option is missing";
-}
-
-template <typename E>
-MappedFile<Context<E>> *open_library(Context<E> &ctx, std::string path) {
-  MappedFile<Context<E>> *mf = MappedFile<Context<E>>::open(ctx, path);
-  if (!mf)
-    return nullptr;
-
-  std::string_view target = get_machine_type(ctx, mf);
-  if (target.empty() || target == E::target_name)
-    return mf;
-  Warn(ctx) << path << ": skipping incompatible file " << target
-            << " " << (int)E::e_machine;
-  return nullptr;
-}
-
-template <typename E>
-MappedFile<Context<E>> *find_library(Context<E> &ctx, std::string name) {
-  if (name.starts_with(':')) {
-    for (std::string_view dir : ctx.arg.library_paths) {
-      std::string path = std::string(dir) + "/" + name.substr(1);
-      if (MappedFile<Context<E>> *mf = open_library(ctx, path))
-        return mf;
-    }
-    Fatal(ctx) << "library not found: " << name;
-  }
-
-  for (std::string_view dir : ctx.arg.library_paths) {
-    std::string stem = std::string(dir) + "/lib" + name;
-    if (!ctx.is_static)
-      if (MappedFile<Context<E>> *mf = open_library(ctx, stem + ".so"))
-        return mf;
-    if (MappedFile<Context<E>> *mf = open_library(ctx, stem + ".a"))
-      return mf;
-  }
-  Fatal(ctx) << "library not found: " << name;
-}
-
-template <typename E>
-MappedFile<Context<E>> *find_from_search_paths(Context<E> &ctx, std::string name) {
-  if (MappedFile<Context<E>> *mf = MappedFile<Context<E>>::open(ctx, name))
-    return mf;
-
-  for (std::string_view dir : ctx.arg.library_paths)
-    if (MappedFile<Context<E>> *mf =
-        MappedFile<Context<E>>::open(ctx, std::string(dir) + "/" + name))
-      return mf;
-  return nullptr;
-}
-
-template <typename E>
-static void read_input_files(Context<E> &ctx, std::span<std::string> args) {
-  Timer t(ctx, "read_input_files");
-
-  std::vector<std::tuple<bool, bool, bool, bool>> state;
-  ctx.is_static = ctx.arg.is_static;
-
-  while (!args.empty()) {
-    std::string_view arg = args[0];
-    args = args.subspan(1);
-
-    if (arg == "--as-needed") {
-      ctx.as_needed = true;
-    } else if (arg == "--no-as-needed") {
-      ctx.as_needed = false;
-    } else if (arg == "--whole-archive") {
-      ctx.whole_archive = true;
-    } else if (arg == "--no-whole-archive") {
-      ctx.whole_archive = false;
-    } else if (arg == "--Bstatic") {
-      ctx.is_static = true;
-    } else if (arg == "--Bdynamic") {
-      ctx.is_static = false;
-    } else if (arg == "--start-lib") {
-      ctx.in_lib = true;
-    } else if (arg == "--end-lib") {
-      ctx.in_lib = false;
-    } else if (remove_prefix(arg, "--version-script=")) {
-      MappedFile<Context<E>> *mf = find_from_search_paths(ctx, std::string(arg));
-      if (!mf)
-        Fatal(ctx) << "--version-script: file not found: " << arg;
-      parse_version_script(ctx, mf);
-    } else if (remove_prefix(arg, "--dynamic-list=")) {
-      MappedFile<Context<E>> *mf = find_from_search_paths(ctx, std::string(arg));
-      if (!mf)
-        Fatal(ctx) << "--dynamic-list: file not found: " << arg;
-      parse_dynamic_list(ctx, mf);
-    } else if (remove_prefix(arg, "--export-dynamic-symbol=")) {
-      if (arg == "*")
-        ctx.default_version = VER_NDX_GLOBAL;
-      else
-        ctx.version_patterns.push_back({arg, "--export-dynamic-symbol",
-                                        "global", VER_NDX_GLOBAL, false});
-    } else if (remove_prefix(arg, "--export-dynamic-symbol-list=")) {
-      MappedFile<Context<E>> *mf = find_from_search_paths(ctx, std::string(arg));
-      if (!mf)
-        Fatal(ctx) << "--export-dynamic-symbol-list: file not found: " << arg;
-      parse_dynamic_list(ctx, mf);
-    } else if (arg == "--push-state") {
-      state.push_back({ctx.as_needed, ctx.whole_archive, ctx.is_static,
-                       ctx.in_lib});
-    } else if (arg == "--pop-state") {
-      if (state.empty())
-        Fatal(ctx) << "no state pushed before popping";
-      std::tie(ctx.as_needed, ctx.whole_archive, ctx.is_static, ctx.in_lib) =
-        state.back();
-      state.pop_back();
-    } else if (remove_prefix(arg, "-l")) {
-      MappedFile<Context<E>> *mf = find_library(ctx, std::string(arg));
-      mf->given_fullpath = false;
-      read_file(ctx, mf);
-    } else {
-      read_file(ctx, MappedFile<Context<E>>::must_open(ctx, std::string(arg)));
-    }
-  }
-
-  if (ctx.objs.empty())
-    Fatal(ctx) << "no input files";
-
-  ctx.tg.wait();
-}
-
-// Since elf_main is a template, we can't run it without a type parameter.
-// We speculatively run elf_main with X86_64, and if the speculation was
-// wrong, re-run it with an actual machine type.
-template <typename E>
-static int redo_main(int argc, char **argv, std::string_view target) {
-  if (target == I386::target_name)
-    return elf_main<I386>(argc, argv);
-  if (target == ARM64::target_name)
-    return elf_main<ARM64>(argc, argv);
-  if (target == ARM32::target_name)
-    return elf_main<ARM32>(argc, argv);
-  if (target == RV64LE::target_name)
-    return elf_main<RV64LE>(argc, argv);
-  if (target == RV64BE::target_name)
-    return elf_main<RV64BE>(argc, argv);
-  if (target == RV32LE::target_name)
-    return elf_main<RV32LE>(argc, argv);
-  if (target == RV32BE::target_name)
-    return elf_main<RV32BE>(argc, argv);
-  if (target == PPC32::target_name)
-    return elf_main<PPC32>(argc, argv);
-  if (target == PPC64V1::target_name)
-    return elf_main<PPC64V1>(argc, argv);
-  if (target == PPC64V2::target_name)
-    return elf_main<PPC64V2>(argc, argv);
-  if (target == S390X::target_name)
-    return elf_main<S390X>(argc, argv);
-  if (target == SPARC64::target_name)
-    return elf_main<SPARC64>(argc, argv);
-  if (target == M68K::target_name)
-    return elf_main<M68K>(argc, argv);
-  if (target == SH4::target_name)
-    return elf_main<SH4>(argc, argv);
-  if (target == ALPHA::target_name)
-    return elf_main<ALPHA>(argc, argv);
-  unreachable();
-}
-
-template <typename E>
-int elf_main(int argc, char **argv) {
-  Context<E> ctx;
-
-  // Process -run option first. process_run_subcommand() does not return.
-  if (argc >= 2 && (argv[1] == "-run"sv || argv[1] == "--run"sv)) {
-#if defined(_WIN32) || defined(__APPLE__)
-    Fatal(ctx) << "-run is supported only on Unix";
-#endif
-    process_run_subcommand(ctx, argc, argv);
-  }
-
-  // Parse non-positional command line options
-  ctx.cmdline_args = expand_response_files(ctx, argv);
-  std::vector<std::string> file_args = parse_nonpositional_args(ctx);
-
-  // If no -m option is given, deduce it from input files.
-  if (ctx.arg.emulation.empty())
-    ctx.arg.emulation = deduce_machine_type(ctx, file_args);
-
-  // Redo if -m is not x86-64.
-  if constexpr (is_x86_64<E>)
-    if (ctx.arg.emulation != X86_64::target_name)
-      return redo_main<E>(argc, argv, ctx.arg.emulation);
-
-  Timer t_all(ctx, "all");
-
-  install_signal_handler();
-
-  if (!ctx.arg.directory.empty())
-    if (chdir(ctx.arg.directory.c_str()) == -1)
-      Fatal(ctx) << "chdir failed: " << ctx.arg.directory
-                 << ": " << errno_string();
-
-  // Fork a subprocess unless --no-fork is given.
-  std::function<void()> on_complete;
-
-#if !defined(_WIN32) && !defined(__APPLE__)
-  if (ctx.arg.fork)
-    on_complete = fork_child();
-#endif
-
-  tbb::global_control tbb_cont(tbb::global_control::max_allowed_parallelism,
-                               ctx.arg.thread_count);
-
-  // Handle --wrap options if any.
-  for (std::string_view name : ctx.arg.wrap)
-    get_symbol(ctx, name)->is_wrapped = true;
-
-  // Handle --retain-symbols-file options if any.
-  if (ctx.arg.retain_symbols_file)
-    for (std::string_view name : *ctx.arg.retain_symbols_file)
-      get_symbol(ctx, name)->write_to_symtab = true;
-
-  for (std::string_view arg : ctx.arg.trace_symbol)
-    get_symbol(ctx, arg)->is_traced = true;
-
-  // Parse input files
-  read_input_files(ctx, file_args);
-
-  // Uniquify shared object files by soname
-  {
-    std::unordered_set<std::string_view> seen;
-    std::erase_if(ctx.dsos, [&](SharedFile<E> *file) {
-      return !seen.insert(file->soname).second;
-    });
-  }
-
-  Timer t_total(ctx, "total");
-  Timer t_before_copy(ctx, "before_copy");
-
-  // Apply -exclude-libs
-  apply_exclude_libs(ctx);
-
-  // Create a dummy file containing linker-synthesized symbols.
-  if (!ctx.arg.relocatable)
-    create_internal_file(ctx);
-
-  // resolve_symbols is 4 things in 1 phase:
-  //
-  // - Determine the set of object files to extract from archives.
-  // - Remove redundant COMDAT sections (e.g. duplicate inline functions).
-  // - Finally, the actual symbol resolution.
-  // - LTO, which requires preliminary symbol resolution before running
-  //   and a follow-up re-resolution after the LTO objects are emitted.
-  //
-  // These passes have complex interactions, and unfortunately has to be
-  // put together in a single phase.
-  resolve_symbols(ctx);
-
-  // Resolve mergeable section pieces to merge them.
-  resolve_section_pieces(ctx);
-
-  // Handle --relocatable. Since the linker's behavior is quite different
-  // from the normal one when the option is given, the logic is implemented
-  // to a separate file.
-  if (ctx.arg.relocatable) {
-    combine_objects(ctx);
-    return 0;
-  }
-
-  // Create .bss sections for common symbols.
-  convert_common_symbols(ctx);
-
-  // Apply version scripts.
-  apply_version_script(ctx);
-
-  // Parse symbol version suffixes (e.g. "foo@ver1").
-  parse_symbol_version(ctx);
-
-  // Set is_imported and is_exported bits for each symbol.
-  compute_import_export(ctx);
-
-  // Read address-significant section information.
-  if (ctx.arg.icf && !ctx.arg.icf_all)
-    mark_addrsig(ctx);
-
-  // Garbage-collect unreachable sections.
-  if (ctx.arg.gc_sections)
-    gc_sections(ctx);
-
-  // Merge identical read-only sections.
-  if (ctx.arg.icf)
-    icf_sections(ctx);
-
-  // Compute sizes of sections containing mergeable strings.
-  compute_merged_section_sizes(ctx);
-
-  // Create linker-synthesized sections such as .got or .plt.
-  create_synthetic_sections(ctx);
-
-  // Make sure that there's no duplicate symbol
-  if (!ctx.arg.allow_multiple_definition)
-    check_duplicate_symbols(ctx);
-
-  // Warn if symbols with different types are defined under the same name.
-  check_symbol_types(ctx);
-
-  if constexpr (is_ppc64v1<E>)
-    ppc64v1_rewrite_opd(ctx);
-
-  // Bin input sections into output sections.
-  create_output_sections(ctx);
-
-  // Add synthetic symbols such as __ehdr_start or __end.
-  add_synthetic_symbols(ctx);
-
-  // Beyond this point, no new files will be added to ctx.objs
-  // or ctx.dsos.
-
-  // Handle `-z cet-report`.
-  if (ctx.arg.z_cet_report != CET_REPORT_NONE)
-    check_cet_errors(ctx);
-
-  // Handle `-z execstack-if-needed`.
-  if (ctx.arg.z_execstack_if_needed)
-    for (ObjectFile<E> *file : ctx.objs)
-      if (file->needs_executable_stack)
-        ctx.arg.z_execstack = true;
-
-  // If we are linking a .so file, remaining undefined symbols does
-  // not cause a linker error. Instead, they are treated as if they
-  // were imported symbols.
-  //
-  // If we are linking an executable, weak undefs are converted to
-  // weakly imported symbols so that they'll have another chance to be
-  // resolved.
-  claim_unresolved_symbols(ctx);
-
-  // Beyond this point, no new symbols will be added to the result.
-
-  // Handle --print-dependencies
-  if (ctx.arg.print_dependencies == 1)
-    print_dependencies(ctx);
-  else if (ctx.arg.print_dependencies == 2)
-    print_dependencies_full(ctx);
-
-  // Handle -repro
-  if (ctx.arg.repro)
-    write_repro_file(ctx);
-
-  // Handle --require-defined
-  for (std::string_view name : ctx.arg.require_defined)
-    if (!get_symbol(ctx, name)->file)
-      Error(ctx) << "--require-defined: undefined symbol: " << name;
-
-  // .init_array and .fini_array contents have to be sorted by
-  // a special rule. Sort them.
-  sort_init_fini(ctx);
-
-  // Likewise, .ctors and .dtors have to be sorted. They are rare
-  // because they are superceded by .init_array/.fini_array, though.
-  sort_ctor_dtor(ctx);
-
-  // Handle --shuffle-sections
-  if (ctx.arg.shuffle_sections != SHUFFLE_SECTIONS_NONE)
-    shuffle_sections(ctx);
-
-  // Copy string referred by .dynamic to .dynstr.
-  for (SharedFile<E> *file : ctx.dsos)
-    ctx.dynstr->add_string(file->soname);
-  for (std::string_view str : ctx.arg.auxiliary)
-    ctx.dynstr->add_string(str);
-  for (std::string_view str : ctx.arg.filter)
-    ctx.dynstr->add_string(str);
-  if (!ctx.arg.rpaths.empty())
-    ctx.dynstr->add_string(ctx.arg.rpaths);
-  if (!ctx.arg.soname.empty())
-    ctx.dynstr->add_string(ctx.arg.soname);
-
-  if constexpr (is_ppc64v1<E>)
-    ppc64v1_scan_symbols(ctx);
-
-  // Scan relocations to find symbols that need entries in .got, .plt,
-  // .got.plt, .dynsym, .dynstr, etc.
-  scan_relocations(ctx);
-
-  // Compute sizes of output sections while assigning offsets
-  // within an output section to input sections.
-  compute_section_sizes(ctx);
-
-  // Sort sections by section attributes so that we'll have to
-  // create as few segments as possible.
-  sort_output_sections(ctx);
-
-  // If --packed_dyn_relocs=relr was given, base relocations are stored
-  // to a .relr.dyn section in a compressed form. Construct a compressed
-  // relocations now so that we can fix section sizes and file layout.
-  if (ctx.arg.pack_dyn_relocs_relr)
-    construct_relr(ctx);
-
-  // Reserve a space for dynamic symbol strings in .dynstr and sort
-  // .dynsym contents if necessary. Beyond this point, no symbol will
-  // be added to .dynsym.
-  ctx.dynsym->finalize(ctx);
-
-  // Print reports about undefined symbols, if needed.
-  if (ctx.arg.unresolved_symbols == UNRESOLVED_ERROR)
-    report_undef_errors(ctx);
-
-  // Fill .gnu.version_d section contents.
-  if (ctx.verdef)
-    ctx.verdef->construct(ctx);
-
-  // Fill .gnu.version_r section contents.
-  ctx.verneed->construct(ctx);
-
-  // Compute .symtab and .strtab sizes for each file.
-  create_output_symtab(ctx);
-
-  // .eh_frame is a special section from the linker's point of view,
-  // as its contents are parsed and reconstructed by the linker,
-  // unlike other sections that are regarded as opaque bytes.
-  // Here, we construct output .eh_frame contents.
-  ctx.eh_frame->construct(ctx);
-
-  // Handle --gdb-index.
-  if (ctx.arg.gdb_index)
-    ctx.gdb_index->construct(ctx);
-
-  // If --emit-relocs is given, we'll copy relocation sections from input
-  // files to an output file.
-  if (ctx.arg.emit_relocs)
-    create_reloc_sections(ctx);
-
-  // Compute the section header values for all sections.
-  compute_section_headers(ctx);
-
-  // Assign offsets to output sections
-  i64 filesize = set_osec_offsets(ctx);
-
-  // On RISC-V, branches are encode using multiple instructions so
-  // that they can jump to anywhere in ±2 GiB by default. They may
-  // be replaced with shorter instruction sequences if destinations
-  // are close enough. Do this optimization.
-  if constexpr (is_riscv<E>)
-    filesize = riscv_resize_sections(ctx);
-
-  // At this point, memory layout is fixed.
-
-  // Set actual addresses to linker-synthesized symbols.
-  fix_synthetic_symbols(ctx);
-
-  // Beyond this, you can assume that symbol addresses including their
-  // GOT or PLT addresses have a correct final value.
-
-  // If --compress-debug-sections is given, compress .debug_* sections
-  // using zlib.
-  if (ctx.arg.compress_debug_sections != COMPRESS_NONE)
-    filesize = compress_debug_sections(ctx);
-
-  // At this point, both memory and file layouts are fixed.
-
-  t_before_copy.stop();
-
-  // Create an output file
-  ctx.output_file =
-    OutputFile<Context<E>>::open(ctx, ctx.arg.output, filesize, 0777);
-  ctx.buf = ctx.output_file->buf;
-
-  Timer t_copy(ctx, "copy");
-
-  // Copy input sections to the output file and apply relocations.
-  copy_chunks(ctx);
-
-  // Some part of .gdb_index couldn't be computed until other debug
-  // sections are complete. We have complete debug sections now, so
-  // write the rest of .gdb_index.
-  if (ctx.gdb_index)
-    ctx.gdb_index->write_address_areas(ctx);
-
-  // Dynamic linker works better with sorted .rela.dyn section,
-  // so we sort them.
-  ctx.reldyn->sort(ctx);
-
-  // Zero-clear paddings between sections
-  clear_padding(ctx);
-
-  // .note.gnu.build-id section contains a cryptographic hash of the
-  // entire output file. Now that we wrote everything except build-id,
-  // we can compute it.
-  if (ctx.buildid)
-    ctx.buildid->write_buildid(ctx);
-
-  t_copy.stop();
-  ctx.checkpoint();
-
-  // Close the output file. This is the end of the linker's main job.
-  ctx.output_file->close(ctx);
-
-  // Handle --dependency-file
-  if (!ctx.arg.dependency_file.empty())
-    write_dependency_file(ctx);
-
-  if (ctx.has_lto_object)
-    lto_cleanup(ctx);
-
-  t_total.stop();
-  t_all.stop();
-
-  if (ctx.arg.print_map)
-    print_map(ctx);
-
-  // Show stats numbers
-  if (ctx.arg.stats)
-    show_stats(ctx);
-
-  if (ctx.arg.perf)
-    print_timer_records(ctx.timer_records);
-
-  std::cout << std::flush;
-  std::cerr << std::flush;
-  if (on_complete)
-    on_complete();
-
-  if (ctx.arg.quick_exit)
-    _exit(0);
-
-  for (std::function<void()> &fn : ctx.on_exit)
-    fn();
-  ctx.checkpoint();
-  return 0;
-}
-
-using E = MOLD_TARGET;
-
-template void read_file(Context<E> &, MappedFile<Context<E>> *);
-
-#ifdef MOLD_X86_64
-
-extern template int elf_main<I386>(int, char **);
-extern template int elf_main<ARM32>(int, char **);
-extern template int elf_main<ARM64>(int, char **);
-extern template int elf_main<RV32BE>(int, char **);
-extern template int elf_main<RV32LE>(int, char **);
-extern template int elf_main<RV64LE>(int, char **);
-extern template int elf_main<RV64BE>(int, char **);
-extern template int elf_main<PPC32>(int, char **);
-extern template int elf_main<PPC64V1>(int, char **);
-extern template int elf_main<PPC64V2>(int, char **);
-extern template int elf_main<S390X>(int, char **);
-extern template int elf_main<SPARC64>(int, char **);
-extern template int elf_main<M68K>(int, char **);
-extern template int elf_main<SH4>(int, char **);
-extern template int elf_main<ALPHA>(int, char **);
-
-int main(int argc, char **argv) {
-  return elf_main<X86_64>(argc, argv);
-}
-
-#else
-
-template int elf_main<E>(int, char **);
-
-#endif
-
-} // namespace mold::elf

filepath.cc

@@ -1,27 +0,0 @@
-#include "mold.h"
-
-#include <filesystem>
-#include <sys/stat.h>
-
-namespace mold {
-
-std::string get_realpath(std::string_view path) {
-  std::error_code ec;
-  std::string ret = std::filesystem::canonical(path, ec).string();
-  return ec ? std::string(path) : ret;
-}
-
-// Removes redundant '/..' or '/.' from a given path.
-// The transformation is done purely by lexical processing.
-// This function does not access file system.
-std::string path_clean(std::string_view path) {
-  return filepath(path).lexically_normal().string();
-}
-
-std::filesystem::path to_abs_path(std::filesystem::path path) {
-  if (path.is_absolute())
-    return path.lexically_normal();
-  return (std::filesystem::current_path() / path).lexically_normal();
-}
-
-} // namespace mold

filetype.h

@@ -1,191 +0,0 @@
-#pragma once
-
-#include "mold.h"
-#include "elf/elf.h"
-
-namespace mold {
-
-enum class FileType {
-  UNKNOWN,
-  EMPTY,
-  ELF_OBJ,
-  ELF_DSO,
-  MACH_OBJ,
-  MACH_EXE,
-  MACH_DYLIB,
-  MACH_BUNDLE,
-  MACH_UNIVERSAL,
-  AR,
-  THIN_AR,
-  TAPI,
-  TEXT,
-  GCC_LTO_OBJ,
-  LLVM_BITCODE,
-};
-
-template <typename C>
-bool is_text_file(MappedFile<C> *mf) {
-  u8 *data = mf->data;
-  return mf->size >= 4 && isprint(data[0]) && isprint(data[1]) &&
-         isprint(data[2]) && isprint(data[3]);
-}
-
-template <typename E, typename C>
-inline bool is_gcc_lto_obj(MappedFile<C> *mf, bool opt_plugin) {
-  using namespace mold::elf;
-
-  const char *data = mf->get_contents().data();
-  ElfEhdr<E> &ehdr = *(ElfEhdr<E> *)data;
-  ElfShdr<E> *sh_begin = (ElfShdr<E> *)(data + ehdr.e_shoff);
-  std::span<ElfShdr<E>> shdrs{(ElfShdr<E> *)(data + ehdr.e_shoff), ehdr.e_shnum};
-
-  // e_shstrndx is a 16-bit field. If .shstrtab's section index is
-  // too large, the actual number is stored to sh_link field.
-  i64 shstrtab_idx = (ehdr.e_shstrndx == SHN_XINDEX)
-    ? sh_begin->sh_link : ehdr.e_shstrndx;
-
-  for (ElfShdr<E> &sec : shdrs) {
-    // GCC LTO object contains only sections symbols followed by a common
-    // symbol whose name is `__gnu_lto_slim` (or `__gnu_lto_v1` for older
-    // GCC releases).
-    //
-    // However, FAT LTO objects don't have any of the above mentioned symbols
-    // and can identify LTO by `.gnu.lto_.symtab.` section, similarly
-    // to what lto-plugin does. However, if LTO linker plug-in is not available,
-    // use the emitted assembly instead.
-    std::string_view name = data + shdrs[shstrtab_idx].sh_offset + sec.sh_name;
-    if (opt_plugin && name.starts_with (".gnu.lto_.symtab."))
-      return true;
-
-    if (sec.sh_type != SHT_SYMTAB)
-      continue;
-
-    std::span<ElfSym<E>> elf_syms{(ElfSym<E> *)(data + sec.sh_offset),
-                                  (size_t)sec.sh_size / sizeof(ElfSym<E>)};
-
-    auto skip = [](u8 type) {
-      return type == STT_NOTYPE || type == STT_FILE || type == STT_SECTION;
-    };
-
-    i64 i = 1;
-    while (i < elf_syms.size() && skip(elf_syms[i].st_type))
-      i++;
-
-    if (i < elf_syms.size() && elf_syms[i].st_shndx == SHN_COMMON) {
-      std::string_view name =
-        data + shdrs[sec.sh_link].sh_offset + elf_syms[i].st_name;
-      if (name.starts_with("__gnu_lto_"))
-        return true;
-    }
-    break;
-  }
-
-  return false;
-}
-
-template <typename C>
-FileType get_file_type(MappedFile<C> *mf, bool opt_plugin) {
-  using namespace elf;
-
-  std::string_view data = mf->get_contents();
-
-  if (data.empty())
-    return FileType::EMPTY;
-
-  if (data.starts_with("\177ELF")) {
-    u8 byte_order = ((ElfEhdr<I386> *)data.data())->e_ident[EI_DATA];
-
-    if (byte_order == ELFDATA2LSB) {
-      auto &ehdr = *(ElfEhdr<I386> *)data.data();
-
-      if (ehdr.e_type == ET_REL) {
-        if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
-          if (is_gcc_lto_obj<I386>(mf, opt_plugin))
-            return FileType::GCC_LTO_OBJ;
-        } else {
-          if (is_gcc_lto_obj<X86_64>(mf, opt_plugin))
-            return FileType::GCC_LTO_OBJ;
-        }
-        return FileType::ELF_OBJ;
-      }
-
-      if (ehdr.e_type == ET_DYN)
-        return FileType::ELF_DSO;
-    } else {
-      auto &ehdr = *(ElfEhdr<M68K> *)data.data();
-
-      if (ehdr.e_type == ET_REL) {
-        if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
-          if (is_gcc_lto_obj<M68K>(mf, opt_plugin))
-            return FileType::GCC_LTO_OBJ;
-        } else {
-          if (is_gcc_lto_obj<SPARC64>(mf, opt_plugin))
-            return FileType::GCC_LTO_OBJ;
-        }
-        return FileType::ELF_OBJ;
-      }
-
-      if (ehdr.e_type == ET_DYN)
-        return FileType::ELF_DSO;
-    }
-    return FileType::UNKNOWN;
-  }
-
-  if (data.starts_with("\xcf\xfa\xed\xfe")) {
-    switch (*(ul32 *)(data.data() + 12)) {
-    case 1: // MH_OBJECT
-      return FileType::MACH_OBJ;
-    case 2: // MH_EXECUTE
-      return FileType::MACH_EXE;
-    case 6: // MH_DYLIB
-      return FileType::MACH_DYLIB;
-    case 8: // MH_BUNDLE
-      return FileType::MACH_BUNDLE;
-    }
-    return FileType::UNKNOWN;
-  }
-
-  if (data.starts_with("!<arch>\n"))
-    return FileType::AR;
-  if (data.starts_with("!<thin>\n"))
-    return FileType::THIN_AR;
-  if (data.starts_with("--- !tapi-tbd"))
-    return FileType::TAPI;
-  if (data.starts_with("\xca\xfe\xba\xbe"))
-    return FileType::MACH_UNIVERSAL;
-  if (is_text_file(mf))
-    return FileType::TEXT;
-  if (data.starts_with("\xde\xc0\x17\x0b"))
-    return FileType::LLVM_BITCODE;
-  if (data.starts_with("BC\xc0\xde"))
-    return FileType::LLVM_BITCODE;
-  return FileType::UNKNOWN;
-}
-
-inline std::string filetype_to_string(FileType type) {
-  switch (type) {
-  case FileType::UNKNOWN: return "UNKNOWN";
-  case FileType::EMPTY: return "EMPTY";
-  case FileType::ELF_OBJ: return "ELF_OBJ";
-  case FileType::ELF_DSO: return "ELF_DSO";
-  case FileType::MACH_EXE: return "MACH_EXE";
-  case FileType::MACH_OBJ: return "MACH_OBJ";
-  case FileType::MACH_DYLIB: return "MACH_DYLIB";
-  case FileType::MACH_BUNDLE: return "MACH_BUNDLE";
-  case FileType::MACH_UNIVERSAL: return "MACH_UNIVERSAL";
-  case FileType::AR: return "AR";
-  case FileType::THIN_AR: return "THIN_AR";
-  case FileType::TAPI: return "TAPI";
-  case FileType::TEXT: return "TEXT";
-  case FileType::GCC_LTO_OBJ: return "GCC_LTO_OBJ";
-  case FileType::LLVM_BITCODE: return "LLVM_BITCODE";
-  }
-  return "UNKNOWN";
-}
-
-inline std::ostream &operator<<(std::ostream &out, FileType type) {
-  out << filetype_to_string(type);
-  return out;
-}
-
-} // namespace mold

install-build-deps.sh

@@ -1,44 +1,48 @@
-#!/bin/bash
+#!/bin/sh
+# This script installs binary packages needed to build mold.
+# Feel free to send me a PR if your OS is not on this list.
+
 set -e
-source /etc/os-release
+. /etc/os-release
 
 set -x
 
-# The first line for each distro installs a build dependency.
-# The second line installs extra packages for unittests.
-#
-# Feel free to send me a PR if your OS is not on this list.
-
-case "$ID-$VERSION_ID" in
-ubuntu-20.* | pop-20.*)
+case "$ID" in
+ubuntu | pop | linuxmint | debian | raspbian | neon)
   apt-get update
-  apt-get install -y cmake libssl-dev zlib1g-dev gcc g++ g++-10
-  apt-get install -y file
+  apt-get install -y cmake gcc g++
+  if [ "$ID-$VERSION_ID" = ubuntu-20.04 ]; then apt-get install -y g++-10; fi
   ;;
-ubuntu-* | pop-* | linuxmint-* | debian-* | raspbian-*)
-  apt-get update
-  apt-get install -y cmake libssl-dev zlib1g-dev gcc g++
-  apt-get install -y file
+fedora | amzn | rhel)
+  dnf install -y gcc-g++ cmake glibc-static libstdc++-static diffutils util-linux
   ;;
-fedora-*)
-  dnf install -y gcc-g++ cmake openssl-devel zlib-devel
-  dnf install -y glibc-static file libstdc++-static diffutils util-linux
+opensuse-*)
+  zypper install -y make cmake gcc-c++ glibc-devel-static tar diffutils util-linux
   ;;
-opensuse-leap-*)
-  zypper install -y make cmake zlib-devel libopenssl-devel gcc-c++ gcc11-c++
-  zypper install -y glibc-devel-static tar diffutils util-linux
-  ;;
-opensuse-tumbleweed-*)
-  zypper install -y make cmake zlib-devel libopenssl-devel gcc-c++
-  zypper install -y glibc-devel-static tar diffutils util-linux
-  ;;
-gentoo-*)
+gentoo)
   emerge-webrsync
-  emerge dev-util/cmake sys-libs/zlib
+  FEATURES='getbinpkg binpkg-request-signature' emerge dev-build/cmake
   ;;
-arch-*)
-  pacman -Sy
-  pacman -S --needed --noconfirm base-devel zlib openssl cmake util-linux
+arch | archarm | artix | endeavouros)
+  pacman -Sy --needed --noconfirm base-devel cmake util-linux
+  ;;
+void)
+  xbps-install -Sy xbps bash make cmake gcc tar diffutils util-linux
+  ;;
+alpine)
+  apk update
+  apk add bash make linux-headers cmake gcc g++
+  ;;
+clear-linux-os)
+  swupd update
+  swupd bundle-add c-basic diffutils
+  ;;
+almalinux)
+  dnf install -y gcc-toolset-13-gcc-c++ gcc-toolset-13-libstdc++-devel cmake diffutils
+  ;;
+freebsd)
+  pkg update
+  pkg install -y cmake bash binutils gcc
   ;;
 *)
   echo "Error: don't know anything about build dependencies on $ID-$VERSION_ID"

install-cross-tools.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+. /etc/os-release
+
+set -x
+
+# This script install packages for -DMOLD_ENABLE_QEMU_TESTS=1
+# to enable cross-target tests.
+#
+# Feel free to send me a PR if your OS is not on this list.
+
+case "$ID" in
+ubuntu | pop | linuxmint | debian | raspbian)
+  apt-get install -y qemu-user {gcc,g++}-{i686,aarch64,riscv64,powerpc,powerpc64,powerpc64le,s390x,sparc64,m68k,sh4}-linux-gnu {gcc,g++}-arm-linux-gnueabihf
+  ;;
+*)
+  echo "Error: don't know anything about build dependencies on $ID-$VERSION_ID"
+  exit 1
+esac

integers.h

@@ -1,221 +0,0 @@
-// This file defines integral types for file input/output. We need to use
-// these types instead of the plain integers (such as uint32_t or int32_t)
-// when reading from/writing to an mmap'ed file area for the following
-// reasons:
-//
-// 1. mold is always a cross linker and should not depend on what host it
-//    is running on. Users should be able to run mold on a big-endian
-//    SPARC machine to create a little-endian RV64 binary, for example.
-//
-// 2. Even though data members in all ELF data strucutres are naturally
-//    aligned, they are not guaranteed to be aligned on memory. Because
-//    archive file (.a file) aligns each member only to a 2 byte boundary,
-//    anything larger than 2 bytes may be unaligned in an mmap'ed memory.
-//    Unaligned access is an undefined behavior in C/C++, so we shouldn't
-//    cast an arbitrary pointer to a uint32_t, for example, to read a
-//    32-bits value.
-//
-// The data types defined in this file don't depend on host byte order and
-// don't do unaligned access.
-
-#pragma once
-
-#include <bit>
-#include <cstdint>
-#include <cstring>
-
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#  define __LITTLE_ENDIAN__ 1
-# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#  define __BIG_ENDIAN__ 1
-# else
-#  error "unknown host byte order"
-# endif
-#endif
-
-namespace mold {
-
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-
-typedef int8_t i8;
-typedef int16_t i16;
-typedef int32_t i32;
-typedef int64_t i64;
-
-template <typename T>
-static inline T bswap(T val) {
-  switch (sizeof(T)) {
-  case 2:  return __builtin_bswap16(val);
-  case 4:  return __builtin_bswap32(val);
-  case 8:  return __builtin_bswap64(val);
-  default: __builtin_unreachable();
-  }
-}
-
-template <typename T, int SIZE = sizeof(T)>
-class LittleEndian {
-public:
-  LittleEndian() = default;
-  LittleEndian(T x) { *this = x; }
-
-  operator T() const {
-    if constexpr (sizeof(T) == SIZE) {
-      T x;
-      memcpy(&x, val, sizeof(T));
-      if constexpr (std::endian::native == std::endian::big)
-        x = bswap(x);
-      return x;
-    } else {
-      static_assert(SIZE == 3);
-      return (val[2] << 16) | (val[1] << 8) | val[0];
-    }
-  }
-
-  LittleEndian &operator=(T x) {
-    if constexpr (sizeof(T) == SIZE) {
-      if constexpr (std::endian::native == std::endian::big)
-        x = bswap(x);
-      memcpy(val, &x, sizeof(T));
-    } else {
-      static_assert(SIZE == 3);
-      val[2] = x >> 16;
-      val[1] = x >> 8;
-      val[0] = x;
-    }
-    return *this;
-  }
-
-  LittleEndian &operator++() {
-    return *this = *this + 1;
-  }
-
-  LittleEndian operator++(int) {
-    T ret = *this;
-    *this = *this + 1;
-    return ret;
-  }
-
-  LittleEndian &operator--() {
-    return *this = *this - 1;
-  }
-
-  LittleEndian operator--(int) {
-    T ret = *this;
-    *this = *this - 1;
-    return ret;
-  }
-
-  LittleEndian &operator+=(T x) {
-    return *this = *this + x;
-  }
-
-  LittleEndian &operator-=(T x) {
-    return *this = *this - x;
-  }
-
-  LittleEndian &operator&=(T x) {
-    return *this = *this & x;
-  }
-
-  LittleEndian &operator|=(T x) {
-    return *this = *this | x;
-  }
-
-private:
-  u8 val[SIZE];
-};
-
-using il16 = LittleEndian<i16>;
-using il32 = LittleEndian<i32>;
-using il64 = LittleEndian<i64>;
-using ul16 = LittleEndian<u16>;
-using ul24 = LittleEndian<u32, 3>;
-using ul32 = LittleEndian<u32>;
-using ul64 = LittleEndian<u64>;
-
-template <typename T, int SIZE = sizeof(T)>
-class BigEndian {
-public:
-  BigEndian() = default;
-  BigEndian(T x) { *this = x; }
-
-  operator T() const {
-    if constexpr (sizeof(T) == SIZE) {
-      T x;
-      memcpy(&x, val, sizeof(T));
-      if constexpr (std::endian::native == std::endian::little)
-        x = bswap(x);
-      return x;
-    } else {
-      static_assert(SIZE == 3);
-      return (val[0] << 16) | (val[1] << 8) | val[2];
-    }
-  }
-
-  BigEndian &operator=(T x) {
-    if constexpr (sizeof(T) == SIZE) {
-      if constexpr (std::endian::native == std::endian::little)
-        x = bswap(x);
-      memcpy(val, &x, sizeof(T));
-    } else {
-      static_assert(SIZE == 3);
-      val[0] = x >> 16;
-      val[1] = x >> 8;
-      val[2] = x;
-    }
-    return *this;
-  }
-
-  BigEndian &operator++() {
-    return *this = *this + 1;
-  }
-
-  BigEndian operator++(int) {
-    T ret = *this;
-    *this = *this + 1;
-    return ret;
-  }
-
-  BigEndian &operator--() {
-    return *this = *this - 1;
-  }
-
-  BigEndian operator--(int) {
-    T ret = *this;
-    *this = *this - 1;
-    return ret;
-  }
-
-  BigEndian &operator+=(T x) {
-    return *this = *this + x;
-  }
-
-  BigEndian &operator-=(T x) {
-    return *this = *this - x;
-  }
-
-  BigEndian &operator&=(T x) {
-    return *this = *this & x;
-  }
-
-  BigEndian &operator|=(T x) {
-    return *this = *this | x;
-  }
-
-private:
-  u8 val[SIZE];
-};
-
-using ib16 = BigEndian<i16>;
-using ib32 = BigEndian<i32>;
-using ib64 = BigEndian<i64>;
-using ub16 = BigEndian<u16>;
-using ub24 = BigEndian<u32, 3>;
-using ub32 = BigEndian<u32>;
-using ub64 = BigEndian<u64>;
-
-} // namespace mold

lib/archive-file.h

@@ -25,8 +25,7 @@
 
 #pragma once
 
-#include "mold.h"
-#include "filetype.h"
+#include "common.h"
 
 namespace mold {
 
@@ -76,12 +75,12 @@ struct ArHdr {
   }
 };
 
-template <typename C>
-std::vector<MappedFile<C> *>
-read_thin_archive_members(C &ctx, MappedFile<C> *mf) {
+template <typename Context>
+std::vector<MappedFile *>
+read_thin_archive_members(Context &ctx, MappedFile *mf) {
   u8 *begin = mf->data;
   u8 *data = begin + 8;
-  std::vector<MappedFile<C> *> vec;
+  std::vector<MappedFile *> vec;
   std::string_view strtab;
 
   while (data < begin + mf->size) {
@@ -116,20 +115,19 @@ read_thin_archive_members(C &ctx, MappedFile<C> *mf) {
       continue;
 
     std::string path = name.starts_with('/') ?
-      name : (filepath(mf->name).parent_path() / name).string();
-    vec.push_back(MappedFile<C>::must_open(ctx, path));
+      name : (path_dirname(mf->name) / name).string();
+    vec.push_back(must_open_file(ctx, path));
     vec.back()->thin_parent = mf;
     data = body;
   }
   return vec;
 }
 
-template <typename C>
-std::vector<MappedFile<C> *>
-read_fat_archive_members(C &ctx, MappedFile<C> *mf) {
+template <typename Context>
+std::vector<MappedFile *> read_fat_archive_members(Context &ctx, MappedFile *mf) {
   u8 *begin = mf->data;
   u8 *data = begin + 8;
-  std::vector<MappedFile<C> *> vec;
+  std::vector<MappedFile *> vec;
   std::string_view strtab;
 
   while (begin + mf->size - data >= 2) {
@@ -163,17 +161,13 @@ read_fat_archive_members(C &ctx, MappedFile<C> *mf) {
   return vec;
 }
 
-template <typename C>
-std::vector<MappedFile<C> *>
-read_archive_members(C &ctx, MappedFile<C> *mf) {
-  switch (get_file_type(mf, !ctx.arg.plugin.empty())) {
-  case FileType::AR:
+template <typename Context>
+std::vector<MappedFile *> read_archive_members(Context &ctx, MappedFile *mf) {
+  std::string_view str = mf->get_contents();
+  if (str.starts_with("!<arch>\n"))
     return read_fat_archive_members(ctx, mf);
-  case FileType::THIN_AR:
-    return read_thin_archive_members(ctx, mf);
-  default:
-    unreachable();
-  }
+  assert(str.starts_with("!<thin>\n"));
+  return read_thin_archive_members(ctx, mf);
 }
 
 } // namespace mold

lib/compress.cc

@@ -14,7 +14,7 @@
 // a little bit. However, if a shard size is large enough, that loss
 // is negligible in practice.
 
-#include "mold.h"
+#include "common.h"
 
 #include <tbb/parallel_for_each.h>
 #include <zlib.h>
@@ -132,7 +132,7 @@ void ZlibCompressor::write_to(u8 *buf) {
     offsets[i] = offsets[i - 1] + shards[i - 1].size();
 
   tbb::parallel_for((i64)0, (i64)shards.size(), [&](i64 i) {
-    memcpy(&buf[offsets[i]], shards[i].data(), shards[i].size());
+    memcpy(buf + offsets[i], shards[i].data(), shards[i].size());
   });
 
   // Write a trailer
@@ -146,10 +146,10 @@ void ZlibCompressor::write_to(u8 *buf) {
 
 static std::vector<u8> zstd_compress(std::string_view input) {
   std::vector<u8> buf(ZSTD_COMPRESSBOUND(input.size()));
-  constexpr int level = 3; // compression level; must be between 1 to 22
+  constexpr int LEVEL = 3; // compression level; must be between 1 to 22
 
   size_t sz = ZSTD_compress(buf.data(), buf.size(), input.data(), input.size(),
-                            level);
+                            LEVEL);
   assert(!ZSTD_isError(sz));
   buf.resize(sz);
   buf.shrink_to_fit();
@@ -178,7 +178,7 @@ void ZstdCompressor::write_to(u8 *buf) {
     offsets[i] = offsets[i - 1] + shards[i - 1].size();
 
   tbb::parallel_for((i64)0, (i64)shards.size(), [&](i64 i) {
-    memcpy(&buf[offsets[i]], shards[i].data(), shards[i].size());
+    memcpy(buf + offsets[i], shards[i].data(), shards[i].size());
   });
 }
 

lib/config.h.in

@@ -0,0 +1,7 @@
+#define MOLD_VERSION "@mold_VERSION@"
+#define MOLD_LIBDIR "@CMAKE_INSTALL_FULL_LIBDIR@"
+
+#cmakedefine HAVE_MADVISE 1
+#cmakedefine HAVE_UNAME 1
+#cmakedefine MOLD_USE_MIMALLOC 1
+#cmakedefine MOLD_USE_SYSTEM_MIMALLOC 1

lib/crc32.cc

@@ -0,0 +1,60 @@
+#include "common.h"
+
+#include <tbb/parallel_for_each.h>
+#include <zlib.h>
+
+namespace mold {
+
+// This function "forges" a CRC. That is, given the current and a desired
+// CRC32 value, crc32_solve() returns a binary blob to add to the end of
+// the original data to yield the desired CRC. Trailing garbage is ignored
+// by many bianry file formats, so you can create a file with a desired
+// CRC using crc32_solve(). We need it for --separate-debug-file.
+std::vector<u8> crc32_solve(u32 current, u32 desired) {
+  constexpr u32 poly = 0xedb88320;
+  u32 x = ~desired;
+
+  // Each iteration computes x = (x * x^-1) mod poly.
+  for (i64 i = 0; i < 32; i++) {
+    x = std::rotl(x, 1);
+    x ^= (x & 1) * (poly << 1);
+  }
+
+  x ^= ~current;
+
+  std::vector<u8> out(4);
+  out[0] = x;
+  out[1] = x >> 8;
+  out[2] = x >> 16;
+  out[3] = x >> 24;
+  return out;
+}
+
+// Compute a CRC for given data in parallel
+u32 compute_crc32(u32 crc, u8 *buf, i64 len) {
+  struct Shard {
+    u8 *buf;
+    i64 len;
+    u32 crc;
+  };
+
+  constexpr i64 shard_size = 1024 * 1024; // 1 MiB
+  std::vector<Shard> shards;
+
+  while (len > 0) {
+    i64 sz = std::min(len, shard_size);
+    shards.push_back({buf, sz, 0});
+    buf += sz;
+    len -= sz;
+  }
+
+  tbb::parallel_for_each(shards.begin(), shards.end(), [](Shard &shard) {
+    shard.crc = crc32(0, shard.buf, shard.len);
+  });
+
+  for (Shard &shard : shards)
+    crc = crc32_combine(crc, shard.crc, shard.len);
+  return crc;
+}
+
+} // namespace mold

lib/demangle.cc

@@ -0,0 +1,42 @@
+#include "common.h"
+
+#include <cstdlib>
+
+#ifndef _WIN32
+#include <cxxabi.h>
+#endif
+
+#include "../third-party/rust-demangle/rust-demangle.h"
+
+namespace mold {
+
+std::optional<std::string_view> demangle_cpp(std::string_view name) {
+  static thread_local char *buf;
+  static thread_local size_t buflen;
+
+  // TODO(cwasser): Actually demangle Symbols on Windows using e.g.
+  // `UnDecorateSymbolName` from Dbghelp, maybe even Itanium symbols?
+#ifndef _WIN32
+  if (name.starts_with("_Z")) {
+    int status;
+    char *p = abi::__cxa_demangle(std::string(name).c_str(), buf, &buflen, &status);
+    if (status == 0) {
+      buf = p;
+      return p;
+    }
+  }
+#endif
+
+  return {};
+}
+
+std::optional<std::string_view> demangle_rust(std::string_view name) {
+  static thread_local char *buf;
+  free(buf);
+  buf = rust_demangle(std::string(name).c_str(), 0);
+  if (buf)
+    return buf;
+  return {};
+}
+
+} // namespace mold

lib/filepath.cc

@@ -0,0 +1,42 @@
+#include "common.h"
+
+#include <filesystem>
+#include <sys/stat.h>
+
+#ifdef __APPLE__
+# include <mach-o/dyld.h>
+#endif
+
+#ifdef __FreeBSD__
+# include <sys/sysctl.h>
+#endif
+
+namespace mold {
+
+// Returns the path of the mold executable itself
+std::string get_self_path() {
+#if __APPLE__ || _WIN32
+  fprintf(stderr, "mold: get_self_path is not supported");
+  exit(1);
+#elif __FreeBSD__
+  // /proc may not be mounted on FreeBSD. The proper way to get the
+  // current executable's path is to use sysctl(2).
+  int mib[4];
+  mib[0] = CTL_KERN;
+  mib[1] = KERN_PROC;
+  mib[2] = KERN_PROC_PATHNAME;
+  mib[3] = -1;
+
+  size_t size;
+  sysctl(mib, 4, NULL, &size, NULL, 0);
+
+  std::string path;
+  path.resize(size);
+  sysctl(mib, 4, path.data(), &size, NULL, 0);
+  return path;
+#else
+  return std::filesystem::read_symlink("/proc/self/exe").string();
+#endif
+}
+
+} // namespace mold

lib/gentoo-test.sh

@@ -26,12 +26,13 @@ if ! docker image ls mold-gentoo | grep -q mold-gentoo; then
   cat <<EOF | docker build -t mold-gentoo -
 FROM gentoo/stage3
 RUN emerge-webrsync
-RUN echo 'USE="X ssl elogind -systemd corefonts truetype jpeg jpeg2k tiff zstd static-libs binary"' >> /etc/portage/make.conf && \
+RUN echo 'USE="X ssl elogind -systemd corefonts truetype jpeg jpeg2k tiff zstd static-libs binary -perl"' >> /etc/portage/make.conf && \
     echo 'ACCEPT_KEYWORDS="~amd64"' >> /etc/portage/make.conf && \
     echo 'ACCEPT_LICENSE="* -@EULA"' >> /etc/portage/make.conf && \
     echo 'FEATURES="\${FEATURE} noclean nostrip ccache -ipc-sandbox -network-sandbox -pid-sandbox -sandbox"' >> /etc/portage/make.conf && \
-    echo 'CCACHE_DIR="/ccache"' >> /etc/portage/make.conf
-RUN emerge gdb lld clang vim emacs strace ccache xeyes dev-util/cmake dev-vcs/git && rm -rf /var/tmp/portage
+    echo 'CCACHE_DIR="/ccache"' >> /etc/portage/make.conf && \
+    emerge gdb lld clang vim emacs strace ccache xeyes dev-build/cmake dev-vcs/git && \
+    rm -rf /var/tmp/portage
 EOF
   set +e
 fi
@@ -48,7 +49,7 @@ cmd1='(cd /usr/bin; ln -sf /mold/mold $(realpath ld))'
 cmd2="MAKEOPTS=-'j$(nproc) --load-average=100' emerge --onlydeps $package"
 cmd3="MAKEOPTS='-j$(nproc) --load-average=100' FEATURES=test emerge $package"
 filename=`echo "$package" | sed 's!/!_!g'`
-docker="docker run --rm --cap-add=SYS_PTRACE -v `pwd`:/mold -v /var/cache/ccache-gentoo:/ccache mold-gentoo timeout -v -k 15s 1h"
+docker="docker run --rm --cap-add=SYS_PTRACE -v `pwd`:/mold -v /var/cache/ccache-gentoo:/ccache mold-gentoo timeout -v -k 15s 3h"
 dir=gentoo/$git_hash
 
 mkdir -p "$dir"/success "$dir"/failure

lib/glob.cc

@@ -1,4 +1,4 @@
-#include "mold.h"
+#include "common.h"
 
 #include <cstring>
 
@@ -79,6 +79,14 @@ std::optional<Glob> Glob::compile(std::string_view pat) {
     case '*':
       vec.push_back({STAR});
       break;
+    case '\\':
+      if (pat.empty())
+        return {};
+      if (vec.empty() || vec.back().kind != STRING)
+        vec.push_back({STRING});
+      vec.back().str += pat[0];
+      pat = pat.substr(1);
+      break;
     default:
       if (vec.empty() || vec.back().kind != STRING)
         vec.push_back({STRING});
@@ -101,7 +109,7 @@ bool Glob::do_match(std::string_view str, std::span<Element> elements) {
 
     switch (e.kind) {
     case STRING:
-      if (str.empty() || !str.starts_with(e.str))
+      if (!str.starts_with(e.str))
         return false;
       str = str.substr(e.str.size());
       break;
@@ -116,13 +124,12 @@ bool Glob::do_match(std::string_view str, std::span<Element> elements) {
         for (;;) {
           size_t pos = str.find(elements[0].str);
           if (pos == str.npos)
-            break;
+            return false;
           if (do_match(str.substr(pos + elements[0].str.size()),
                        elements.subspan(1)))
             return true;
           str = str.substr(pos + 1);
         }
-        return false;
       }
 
       // Other cases are handled here.

lib/hyperloglog.cc

@@ -4,7 +4,7 @@
 // For more info, read
 // https://engineering.fb.com/2018/12/13/data-infrastructure/hyperloglog
 
-#include "mold.h"
+#include "common.h"
 
 #include <cmath>
 
@@ -13,7 +13,7 @@ namespace mold {
 i64 HyperLogLog::get_cardinality() const {
   double z = 0;
   for (i64 val : buckets)
-    z += pow(2, -val);
+    z += std::ldexp(1.0, -val);
   return ALPHA * NBUCKETS * NBUCKETS / z;
 }
 

lib/integers.h

@@ -0,0 +1,144 @@
+// This file defines integral types for file input/output. We need to use
+// these types instead of the plain integers (such as uint32_t or int32_t)
+// when reading from/writing to an mmap'ed file area for the following
+// reasons:
+//
+// 1. mold is always a cross linker and should not depend on what host it
+//    is running on. For example, users should be able to run mold on a
+//    big-endian SPARC machine to create a little-endian RV64 binary.
+//
+// 2. Even though data members in all ELF data strucutres are naturally
+//    aligned, they are not guaranteed to be aligned on memory because of
+//    archive files. Archive files (.a files) align each member only to a
+//    2 byte boundary, so anything larger than 2 bytes may be misaligned
+//    in an mmap'ed memory. Misaligned access is an undefined behavior in
+//    C/C++, so we shouldn't cast an arbitrary pointer to a uint32_t, for
+//    example, to read a 32 bit value.
+//
+// The data types defined in this file don't depend on host byte order and
+// don't do unaligned access. Note that modern compilers are smart enough
+// to recognize shift and bitwise OR patterns and compile them into a
+// single load instruction.
+
+#pragma once
+
+#include <cstdint>
+
+#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  define __LITTLE_ENDIAN__ 1
+# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  define __BIG_ENDIAN__ 1
+# else
+#  error "unknown host byte order"
+# endif
+#endif
+
+namespace mold {
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+
+template <typename T, bool is_le, int size = sizeof(T)>
+class Integer {
+public:
+  constexpr Integer() = default;
+
+  constexpr Integer(T x) requires (is_le && size == 2)
+    : buf{(u8)x, (u8)(x >> 8)} {}
+
+  constexpr Integer(T x) requires (is_le && size == 3)
+    : buf{(u8)x, (u8)(x >> 8), (u8)(x >> 16)} {}
+
+  constexpr Integer(T x) requires (is_le && size == 4)
+    : buf{(u8)x, (u8)(x >> 8), (u8)(x >> 16), (u8)(x >> 24)} {}
+
+  constexpr Integer(T x) requires (is_le && size == 8)
+    : buf{(u8)x,         (u8)(x >> 8),  (u8)(x >> 16), (u8)(x >> 24),
+          (u8)(x >> 32), (u8)(x >> 40), (u8)(x >> 48), (u8)(x >> 56)} {}
+
+  constexpr Integer(T x) requires (!is_le && size == 2)
+    : buf{(u8)(x >> 8), (u8)x} {}
+
+  constexpr Integer(T x) requires (!is_le && size == 3)
+    : buf{(u8)(x >> 16), (u8)(x >> 8), (u8)x} {}
+
+  constexpr Integer(T x) requires (!is_le && size == 4)
+    : buf{(u8)(x >> 24), (u8)(x >> 16), (u8)(x >> 8), (u8)x} {}
+
+  constexpr Integer(T x) requires (!is_le && size == 8)
+    : buf{(u8)(x >> 56), (u8)(x >> 48), (u8)(x >> 40), (u8)(x >> 32),
+          (u8)(x >> 24), (u8)(x >> 16), (u8)(x >> 8),  (u8)x} {}
+
+  operator T() const {
+    if constexpr (is_le) {
+      if constexpr (size == 2)
+        return buf[1] << 8 | buf[0];
+      else if constexpr (size == 3)
+        return buf[2] << 16 | buf[1] << 8 | buf[0];
+      else if constexpr (size == 4)
+        return buf[3] << 24 | buf[2] << 16 | buf[1] << 8 | buf[0];
+      else
+        return (u64)buf[7] << 56 | (u64)buf[6] << 48 |
+               (u64)buf[5] << 40 | (u64)buf[4] << 32 |
+               (u64)buf[3] << 24 | (u64)buf[2] << 16 |
+               (u64)buf[1] << 8  | (u64)buf[0];
+    } else {
+      if constexpr (size == 2)
+        return buf[0] << 8 | buf[1];
+      else if constexpr (size == 3)
+        return buf[0] << 16 | buf[1] << 8 | buf[2];
+      else if constexpr (size == 4)
+        return buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
+      else
+        return (u64)buf[0] << 56 | (u64)buf[1] << 48 |
+               (u64)buf[2] << 40 | (u64)buf[3] << 32 |
+               (u64)buf[4] << 24 | (u64)buf[5] << 16 |
+               (u64)buf[6] << 8  | (u64)buf[7];
+    }
+  }
+
+  Integer &operator=(T x) {
+    new (this) Integer(x);
+    return *this;
+  }
+
+  Integer &operator++()    { return *this = *this + 1; }
+  Integer operator++(int)  { return ++*this - 1; }
+  Integer &operator--()    { return *this = *this - 1; }
+  Integer operator--(int)  { return --*this + 1; }
+  Integer &operator+=(T x) { return *this = *this + x; }
+  Integer &operator-=(T x) { return *this = *this - x; }
+  Integer &operator&=(T x) { return *this = *this & x; }
+  Integer &operator|=(T x) { return *this = *this | x; }
+
+private:
+  u8 buf[size];
+};
+
+using il16 = Integer<i16, true>;
+using il32 = Integer<i32, true>;
+using il64 = Integer<i64, true>;
+
+using ul16 = Integer<u16, true>;
+using ul24 = Integer<u32, true, 3>;
+using ul32 = Integer<u32, true>;
+using ul64 = Integer<u64, true>;
+
+using ib16 = Integer<i16, false>;
+using ib32 = Integer<i32, false>;
+using ib64 = Integer<i64, false>;
+
+using ub16 = Integer<u16, false>;
+using ub24 = Integer<u32, false, 3>;
+using ub32 = Integer<u32, false>;
+using ub64 = Integer<u64, false>;
+
+} // namespace mold

lib/jobs-unix.cc

@@ -0,0 +1,50 @@
+// Many build systems attempt to invoke as many linker processes as there
+// are cores, based on the assumption that the linker is single-threaded.
+// However, since mold is multi-threaded, such build systems' behavior is
+// not beneficial and just increases the overall peak memory usage.
+// On machines with limited memory, this could lead to an out-of-memory
+// error.
+//
+// This file implements a feature that limits the number of concurrent
+// mold processes to just 1 for each user. It is intended to be used as
+// `MOLD_JOBS=1 ninja` or `MOLD_JOBS=1 make -j$(nproc)`.
+
+#include "common.h"
+
+#include <fcntl.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace mold {
+
+static int lock_fd = -1;
+
+void acquire_global_lock() {
+  char *jobs = getenv("MOLD_JOBS");
+  if (!jobs || jobs != "1"s)
+    return;
+
+  std::string path;
+  if (char *dir = getenv("XDG_RUNTIME_DIR"))
+    path = dir + "/mold-lock"s;
+  else
+    path = "/tmp/mold-lock-"s + getpwuid(getuid())->pw_name;
+
+  int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC, 0600);
+  if (fd == -1)
+    return;
+
+  if (lockf(fd, F_LOCK, 0) == -1)
+    return;
+  lock_fd = fd;
+}
+
+void release_global_lock() {
+  if (lock_fd != -1)
+    close(lock_fd);
+}
+
+} // namespace mold

lib/jobs-win32.cc

@@ -0,0 +1,6 @@
+namespace mold {
+
+void acquire_global_lock() {}
+void release_global_lock() {}
+
+} // namespace mold

lib/mapped-file-unix.cc

@@ -0,0 +1,51 @@
+#include "common.h"
+
+namespace mold {
+
+MappedFile *open_file_impl(const std::string &path, std::string &error) {
+  i64 fd = ::open(path.c_str(), O_RDONLY);
+  if (fd == -1) {
+    if (errno != ENOENT)
+      error = "opening " + path + " failed: " + errno_string();
+    return nullptr;
+  }
+
+  struct stat st;
+  if (fstat(fd, &st) == -1)
+    error = path + ": fstat failed: " + errno_string();
+
+  MappedFile *mf = new MappedFile;
+  mf->name = path;
+  mf->size = st.st_size;
+
+  if (st.st_size > 0) {
+    mf->data = (u8 *)mmap(nullptr, st.st_size, PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE, fd, 0);
+    if (mf->data == MAP_FAILED)
+      error = path + ": mmap failed: " + errno_string();
+  }
+
+  close(fd);
+  return mf;
+}
+
+void MappedFile::unmap() {
+  if (size == 0 || parent || !data)
+    return;
+  munmap(data, size);
+  data = nullptr;
+}
+
+void MappedFile::close_fd() {
+  if (fd == -1)
+    return;
+  close(fd);
+  fd = -1;
+}
+
+void MappedFile::reopen_fd(const std::string &path) {
+  if (fd == -1)
+    fd = open(path.c_str(), O_RDONLY);
+}
+
+} // namespace mold

lib/mapped-file-win32.cc

@@ -0,0 +1,81 @@
+#include "common.h"
+
+namespace mold {
+
+MappedFile *open_file_impl(const std::string &path, std::string &error) {
+  HANDLE fd = CreateFileA(path.c_str(), GENERIC_READ,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                          nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+
+  if (fd == INVALID_HANDLE_VALUE) {
+    auto err = GetLastError();
+    if (err != ERROR_FILE_NOT_FOUND)
+      error = "opening " + path + " failed: " + errno_string();
+    return nullptr;
+  }
+
+  if (GetFileType(fd) != FILE_TYPE_DISK) {
+    CloseHandle(fd);
+    return nullptr;
+  }
+
+  DWORD size_hi;
+  DWORD size_lo = GetFileSize(fd, &size_hi);
+
+  if (size_lo == INVALID_FILE_SIZE) {
+    error = path + ": GetFileSize failed: " + errno_string();
+    return nullptr;
+  }
+
+  u64 size = ((u64)size_hi << 32) + size_lo;
+
+  MappedFile *mf = new MappedFile;
+  mf->name = path;
+  mf->size = size;
+  mf->fd = fd;
+
+  if (size > 0) {
+    HANDLE h = CreateFileMapping(fd, nullptr, PAGE_READONLY, 0, size, nullptr);
+    if (!h) {
+      error = path + ": CreateFileMapping failed: " + errno_string();
+      return nullptr;
+    }
+
+    mf->data = (u8 *)MapViewOfFile(h, FILE_MAP_COPY, 0, 0, size);
+    CloseHandle(h);
+
+    if (!mf->data) {
+      error = path + ": MapViewOfFile failed: " + errno_string();
+      return nullptr;
+    }
+  }
+
+  return mf;
+}
+
+void MappedFile::unmap() {
+  if (size == 0 || parent || !data)
+    return;
+
+  UnmapViewOfFile(data);
+  if (fd != INVALID_HANDLE_VALUE)
+    CloseHandle(fd);
+
+  data = nullptr;
+}
+
+void MappedFile::close_fd() {
+  if (fd == INVALID_HANDLE_VALUE)
+    return;
+  CloseHandle(fd);
+  fd = INVALID_HANDLE_VALUE;
+}
+
+void MappedFile::reopen_fd(const std::string &path) {
+  if (fd == INVALID_HANDLE_VALUE)
+    fd = CreateFileA(path.c_str(), GENERIC_READ,
+                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                     nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+}
+
+} // namespace mold

lib/mimalloc.cc

@@ -0,0 +1,22 @@
+// Including mimalloc-new-delete.h overrides new/delete operators.
+// We need it only when we are using mimalloc as a dynamic library.
+#if MOLD_USE_SYSTEM_MIMALLOC
+# include <mimalloc-new-delete.h>
+#endif
+
+// Silence mimalloc warning messages that users can just ignore.
+#if MOLD_USE_MIMALLOC
+# include <mimalloc.h>
+
+namespace mold {
+void set_mimalloc_options() {
+  mi_option_disable(mi_option_verbose);
+  mi_option_disable(mi_option_show_errors);
+}
+}
+
+#else
+namespace mold {
+void set_mimalloc_options() {}
+}
+#endif

lib/multi-glob.cc

@@ -17,51 +17,61 @@
 // slow, but complex patterns are rare in practice, so it should be
 // OK.
 
-#include "mold.h"
+#include "common.h"
 
 #include <queue>
 #include <regex>
 
 namespace mold {
 
-std::optional<u32> MultiGlob::find(std::string_view str) {
+std::optional<i64> MultiGlob::find(std::string_view str) {
   std::call_once(once, [&] { compile(); });
-  u32 val = UINT32_MAX;
+  i64 val = -1;
 
-  if (root) {
-    // Match against simple glob patterns
-    TrieNode *node = root.get();
-
-    auto walk = [&](u8 c) {
-      for (;;) {
-        if (node->children[c]) {
-          node = node->children[c].get();
-          val = std::min(val, node->value);
-          return;
-        }
-
-        if (!node->suffix_link)
-          return;
-        node = node->suffix_link;
-      }
-    };
-
-    walk('\0');
-    for (u8 c : str)
-      walk(c);
-    walk('\0');
-  }
+  // Match against simple glob patterns
+  if (root)
+    val = find_aho_corasick(str);
 
   // Match against complex glob patterns
-  for (std::pair<Glob, u32> &glob : globs)
+  for (std::pair<Glob, i64> &glob : globs)
     if (glob.first.match(str))
-      val = std::min(val, glob.second);
+      val = std::max(val, glob.second);
 
-  if (val == UINT32_MAX)
+  if (val == -1)
     return {};
   return val;
 }
 
+i64 MultiGlob::find_aho_corasick(std::string_view str) {
+  TrieNode *node = root.get();
+  i64 val = -1;
+
+  auto walk = [&](u8 c) {
+    for (;;) {
+      if (node->children[c]) {
+        node = node->children[c].get();
+        val = std::max(val, node->value);
+        return;
+      }
+
+      if (!node->suffix_link)
+        return;
+      node = node->suffix_link;
+    }
+  };
+
+  walk('\0');
+
+  for (u8 c : str) {
+    if (prefix_match && node == root.get())
+      return val;
+    walk(c);
+  }
+
+  walk('\0');
+  return val;
+}
+
 static bool is_simple_pattern(std::string_view pat) {
   static std::regex re(R"(\*?[^*[?]+\*?)", std::regex_constants::optimize);
   return std::regex_match(pat.begin(), pat.end(), re);
@@ -82,7 +92,7 @@ static std::string handle_stars(std::string_view pat) {
   return "\0"s + str + "\0"s;
 }
 
-bool MultiGlob::add(std::string_view pat, u32 val) {
+bool MultiGlob::add(std::string_view pat, i64 val) {
   assert(!is_compiled);
   assert(!pat.empty());
 
@@ -108,7 +118,7 @@ bool MultiGlob::add(std::string_view pat, u32 val) {
     node = node->children[c].get();
   }
 
-  node->value = std::min(node->value, val);
+  node->value = std::max(node->value, val);
   return true;
 }
 
@@ -117,6 +127,16 @@ void MultiGlob::compile() {
   if (root) {
     fix_suffix_links(*root);
     fix_values();
+
+    // If no pattern starts with '*', set prefix_match to true.
+    // We'll use this flag for optimization.
+    prefix_match = true;
+    for (i64 i = 1; i < 256; i++) {
+      if (root->children[i]) {
+        prefix_match = false;
+        break;
+      }
+    }
   }
 }
 
@@ -157,7 +177,7 @@ void MultiGlob::fix_values() {
     for (std::unique_ptr<TrieNode> &child : node->children) {
       if (!child)
         continue;
-      child->value = std::min(child->value, child->suffix_link->value);
+      child->value = std::max(child->value, child->suffix_link->value);
       queue.push(child.get());
     }
   } while (!queue.empty());

lib/perf.cc

@@ -1,4 +1,4 @@
-#include "mold.h"
+#include "common.h"
 
 #include <functional>
 #include <iomanip>
@@ -26,19 +26,13 @@ void Counter::print() {
 }
 
 static i64 now_nsec() {
-#ifdef _WIN32
   return (i64)std::chrono::steady_clock::now().time_since_epoch().count();
-#else
-  struct timespec t;
-  clock_gettime(CLOCK_MONOTONIC, &t);
-  return (i64)t.tv_sec * 1000000000 + t.tv_nsec;
-#endif
 }
 
 static std::pair<i64, i64> get_usage() {
 #ifdef _WIN32
   auto to_nsec = [](FILETIME t) -> i64 {
-    return ((u64)t.dwHighDateTime << 32 + (u64)t.dwLowDateTime) * 100;
+    return (((u64)t.dwHighDateTime << 32) + (u64)t.dwLowDateTime) * 100;
   };
 
   FILETIME creation, exit, kernel, user;
@@ -46,7 +40,7 @@ static std::pair<i64, i64> get_usage() {
   return {to_nsec(user), to_nsec(kernel)};
 #else
   auto to_nsec = [](struct timeval t) -> i64 {
-    return (i64)t.tv_sec * 1000000000 + t.tv_usec * 1000;
+    return (i64)t.tv_sec * 1'000'000'000 + t.tv_usec * 1'000;
   };
 
   struct rusage ru;
@@ -79,9 +73,9 @@ void TimerRecord::stop() {
 
 static void print_rec(TimerRecord &rec, i64 indent) {
   printf(" % 8.3f % 8.3f % 8.3f  %s%s\n",
-         ((double)rec.user / 1000000000),
-         ((double)rec.sys / 1000000000),
-         (((double)rec.end - rec.start) / 1000000000),
+         ((double)rec.user / 1'000'000'000),
+         ((double)rec.sys / 1'000'000'000),
+         (((double)rec.end - rec.start) / 1'000'000'000),
          std::string(indent * 2, ' ').c_str(),
          rec.name.c_str());
 

lib/random.cc

@@ -0,0 +1,20 @@
+#include "common.h"
+
+#include <random>
+
+namespace mold {
+
+void get_random_bytes(u8 *buf, i64 size) {
+  std::random_device rand;
+  i64 i = 0;
+
+  for (; i < size - 4; i += 4) {
+    u32 val = rand();
+    memcpy(buf + i, &val, 4);
+  }
+
+  u32 val = rand();
+  memcpy(buf + i, &val, size - i);
+}
+
+} // namespace mold

lib/signal-unix.cc

@@ -0,0 +1,88 @@
+#include "common.h"
+
+#include <signal.h>
+#include <tbb/version.h>
+
+#ifdef __FreeBSD__
+# include <sys/sysctl.h>
+# include <unistd.h>
+#endif
+
+namespace mold {
+
+std::string errno_string() {
+  // strerror is not thread-safe, so guard it with a lock.
+  static std::mutex mu;
+  std::scoped_lock lock(mu);
+  return strerror(errno);
+}
+
+void cleanup() {
+  if (output_tmpfile)
+    unlink(output_tmpfile);
+}
+
+// mold mmap's an output file, and the mmap succeeds even if there's
+// no enough space left on the filesystem. The actual disk blocks are
+// not allocated on the mmap call but when the program writes to it
+// for the first time.
+//
+// If a disk becomes full as a result of a write to an mmap'ed memory
+// region, the failure of the write is reported as a SIGBUS or structured
+// exeption with code EXCEPTION_IN_PAGE_ERROR on Windows. This
+// signal handler catches that signal and prints out a user-friendly
+// error message. Without this, it is very hard to realize that the
+// disk might be full.
+static std::string sigabrt_msg;
+
+static void sighandler(int signo, siginfo_t *info, void *ucontext) {
+  static std::mutex mu;
+  std::scoped_lock lock{mu};
+
+  // Handle disk full error
+  switch (signo) {
+  case SIGSEGV:
+  case SIGBUS:
+    if (output_buffer_start <= info->si_addr &&
+        info->si_addr < output_buffer_end) {
+      const char msg[] = "mold: failed to write to an output file. Disk full?\n";
+      (void)!write(STDERR_FILENO, msg, sizeof(msg) - 1);
+    }
+    break;
+  case SIGABRT: {
+    (void)!write(STDERR_FILENO, &sigabrt_msg[0], sigabrt_msg.size());
+    break;
+  }
+  }
+
+  // Re-throw the signal
+  signal(SIGSEGV, SIG_DFL);
+  signal(SIGBUS, SIG_DFL);
+  signal(SIGABRT, SIG_DFL);
+
+  cleanup();
+  raise(signo);
+}
+
+void install_signal_handler() {
+  struct sigaction action;
+  action.sa_sigaction = sighandler;
+  sigemptyset(&action.sa_mask);
+  action.sa_flags = SA_SIGINFO;
+
+  sigaction(SIGSEGV, &action, NULL);
+  sigaction(SIGBUS, &action, NULL);
+
+  // OneTBB 2021.9.0 has the interface version 12090.
+  if (TBB_runtime_interface_version() < 12090) {
+    sigabrt_msg = "mold: aborted\n"
+      "mold: mold with libtbb version 2021.9.0 or older is known to be unstable "
+      "under heavy load. Your libtbb version is " +
+      std::string(TBB_runtime_version()) +
+      ". Please upgrade your libtbb library and try again.\n";
+
+    sigaction(SIGABRT, &action, NULL);
+  }
+}
+
+} // namespace mold

lib/signal-win32.cc

@@ -0,0 +1,55 @@
+#include "common.h"
+
+#include <windows.h>
+
+namespace mold {
+
+void cleanup() {
+  if (output_tmpfile)
+    _unlink(output_tmpfile);
+}
+
+std::string errno_string() {
+  LPVOID buf;
+  DWORD dw = GetLastError();
+
+  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                FORMAT_MESSAGE_FROM_SYSTEM |
+                FORMAT_MESSAGE_IGNORE_INSERTS,
+                nullptr, dw,
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                (LPTSTR)&buf, 0, nullptr);
+
+  std::string ret = (char *)buf;
+  LocalFree(buf);
+  return ret;
+}
+
+static LONG WINAPI vectored_handler(_EXCEPTION_POINTERS *exception_info) {
+  static std::mutex mu;
+  std::scoped_lock lock{mu};
+
+  PEXCEPTION_RECORD rec = exception_info->ExceptionRecord;
+  ULONG_PTR *p = rec->ExceptionInformation;
+
+  if (rec->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
+      (ULONG_PTR)output_buffer_start <= p[1] &&
+      p[1] < (ULONG_PTR)output_buffer_end) {
+    static const char msg[] =
+      "mold: failed to write to an output file. Disk full?\n";
+    (void)!_write(_fileno(stderr), msg, sizeof(msg) - 1);
+  } else if (rec->ExceptionCode == EXCEPTION_STACK_OVERFLOW) {
+    static const char msg[] =
+      "mold: stack overflow\n";
+    (void)!_write(_fileno(stderr), msg, sizeof(msg) - 1);
+  }
+
+  cleanup();
+  _exit(1);
+}
+
+void install_signal_handler() {
+  AddVectoredExceptionHandler(0, vectored_handler);
+}
+
+} // namespace mold

lib/siphash.h

@@ -0,0 +1,144 @@
+// This is a header-only C++20 implementation of SipHash based on the
+// reference implementation. To use, just copy this header file into
+// your project and #include it.
+//
+// https://github.com/rui314/siphash/blob/main/siphash.h
+
+#include <bit>
+#include <cstdint>
+#include <cstring>
+
+template <int C_ROUNDS, int D_ROUNDS, int OUTLEN>
+class SipHashTmpl {
+public:
+  static_assert(OUTLEN == 64 || OUTLEN == 128);
+
+  SipHashTmpl(void *key) {
+    uint64_t k0 = read64(key);
+    uint64_t k1 = read64((char *)key + 8);
+
+    v0 = 0x736f6d6570736575 ^ k0;
+    v1 = 0x646f72616e646f6d ^ k1;
+    v2 = 0x6c7967656e657261 ^ k0;
+    v3 = 0x7465646279746573 ^ k1;
+
+    if (OUTLEN == 128)
+      v1 ^= 0xee;
+  }
+
+  void update(void *msgp, int64_t msglen) {
+    char *msg = (char *)msgp;
+    sum += msglen;
+
+    if (buflen) {
+      if (buflen + msglen < 8) {
+        memcpy(buf + buflen, msg, msglen);
+        buflen += msglen;
+        return;
+      }
+
+      int j = 8 - buflen;
+      memcpy(buf + buflen, msg, j);
+      compress(read64(buf));
+
+      msg += j;
+      msglen -= j;
+      buflen = 0;
+    }
+
+    while (msglen >= 8) {
+      compress(read64(msg));
+      msg += 8;
+      msglen -= 8;
+    }
+
+    memcpy(buf, msg, msglen);
+    buflen = msglen;
+  }
+
+  void finish(void *out) {
+    memset(buf + buflen, 0, 8 - buflen);
+    compress(((uint64_t)sum << 56) | read64(buf));
+
+    v2 ^= (OUTLEN == 128) ? 0xee : 0xff;
+    finalize();
+    write64(out, v0 ^ v1 ^ v2 ^ v3);
+
+    if (OUTLEN == 128) {
+      v1 ^= 0xdd;
+      finalize();
+      write64((char *)out + 8, v0 ^ v1 ^ v2 ^ v3);
+    }
+  }
+
+  static void hash(void *out, void *key, void *in, int inlen) {
+    SipHashTmpl<C_ROUNDS, D_ROUNDS, OUTLEN> h(key);
+    h.update(in, inlen);
+    h.finish(out);
+  }
+
+private:
+  uint64_t v0, v1, v2, v3;
+  uint8_t buf[8];
+  uint8_t buflen = 0;
+  uint8_t sum = 0;
+
+  uint64_t read64(void *loc) {
+    uint64_t val;
+    memcpy(&val, loc, 8);
+    if (std::endian::native == std::endian::big)
+      val = bswap(val);
+    return val;
+  }
+
+  void write64(void *loc, uint64_t val) {
+    if (std::endian::native == std::endian::big)
+      val = bswap(val);
+    memcpy(loc, &val, 8);
+  }
+
+  uint64_t bswap(uint64_t val) {
+    return ((val << 56) & 0xff00000000000000) |
+           ((val << 40) & 0x00ff000000000000) |
+           ((val << 24) & 0x0000ff0000000000) |
+           ((val << 8)  & 0x000000ff00000000) |
+           ((val >> 8)  & 0x00000000ff000000) |
+           ((val >> 24) & 0x0000000000ff0000) |
+           ((val >> 40) & 0x000000000000ff00) |
+           ((val >> 56) & 0x00000000000000ff);
+  }
+
+  void round() {
+    v0 += v1;
+    v1 = std::rotl(v1, 13);
+    v1 ^= v0;
+    v0 = std::rotl(v0, 32);
+    v2 += v3;
+    v3 = std::rotl(v3, 16);
+    v3 ^= v2;
+    v0 += v3;
+    v3 = std::rotl(v3, 21);
+    v3 ^= v0;
+    v2 += v1;
+    v1 = std::rotl(v1, 17);
+    v1 ^= v2;
+    v2 = std::rotl(v2, 32);
+  }
+
+  void compress(uint64_t m) {
+    v3 ^= m;
+    for (int i = 0; i < C_ROUNDS; i++)
+      round();
+    v0 ^= m;
+  }
+
+  void finalize() {
+    for (int i = 0; i < D_ROUNDS; i++)
+      round();
+  }
+};
+
+using SipHash = SipHashTmpl<2, 4, 64>;
+using SipHash128 = SipHashTmpl<2, 4, 128>;
+using SipHash13 = SipHashTmpl<1, 3, 64>;
+using SipHash13_128 = SipHashTmpl<1, 3, 128>;

lib/tar.cc

@@ -1,7 +1,15 @@
-#include "mold.h"
+// This file contains functions to create a tar file.
+
+#include "common.h"
+
+#ifdef _WIN32
+# define ftruncate _chsize_s
+#endif
 
 namespace mold {
 
+static constexpr i64 BLOCK_SIZE = 512;
+
 // A tar file consists of one or more Ustar header followed by data.
 // Each Ustar header represents a single file in an archive.
 //
@@ -11,23 +19,6 @@ namespace mold {
 //
 // For simplicity, we always emit a PAX header even for a short filename.
 struct UstarHeader {
-  UstarHeader() {
-    memset(this, 0, sizeof(*this));
-  }
-
-  void finalize() {
-    memset(checksum, ' ', sizeof(checksum));
-    memcpy(magic, "ustar", 5);
-    memcpy(version, "00", 2);
-
-    // Compute checksum
-    int sum = 0;
-    for (i64 i = 0; i < sizeof(*this); i++)
-      sum += ((u8 *)this)[i];
-    assert(sum < 01000000);
-    snprintf(checksum, sizeof(checksum), "%06o", sum);
-  }
-
   char name[100];
   char mode[8];
   char uid[8];
@@ -47,6 +38,25 @@ struct UstarHeader {
   char pad[12];
 };
 
+static_assert(sizeof(UstarHeader) == BLOCK_SIZE);
+
+static void finalize(UstarHeader &hdr) {
+  memset(hdr.checksum, ' ', sizeof(hdr.checksum));
+  memcpy(hdr.magic, "ustar", 5);
+  memcpy(hdr.version, "00", 2);
+
+  // Compute checksum
+  int sum = 0;
+  for (i64 i = 0; i < sizeof(hdr); i++)
+    sum += ((u8 *)&hdr)[i];
+
+  // We need to convince the compiler that sum isn't too big to silence
+  // -Werror=format-truncation.
+  if (sum >= 01'000'000)
+    unreachable();
+  snprintf(hdr.checksum, sizeof(hdr.checksum), "%06o", sum);
+}
+
 static std::string encode_path(std::string basedir, std::string path) {
   path = path_clean(basedir + "/" + path);
 
@@ -73,13 +83,13 @@ TarWriter::~TarWriter() {
 
 void TarWriter::append(std::string path, std::string_view data) {
   // Write PAX header
-  static_assert(sizeof(UstarHeader) == BLOCK_SIZE);
-  UstarHeader pax;
+  UstarHeader pax = {};
 
   std::string attr = encode_path(basedir, path);
   snprintf(pax.size, sizeof(pax.size), "%011zo", attr.size());
+  pax.name[0] = '/';
   pax.typeflag[0] = 'x';
-  pax.finalize();
+  finalize(pax);
   fwrite(&pax, sizeof(pax), 1, out);
 
   // Write pathname
@@ -87,23 +97,18 @@ void TarWriter::append(std::string path, std::string_view data) {
   fseek(out, align_to(ftell(out), BLOCK_SIZE), SEEK_SET);
 
   // Write Ustar header
-  UstarHeader ustar;
+  UstarHeader ustar = {};
   memcpy(ustar.mode, "0000664", 8);
   snprintf(ustar.size, sizeof(ustar.size), "%011zo", data.size());
-  ustar.finalize();
+  finalize(ustar);
   fwrite(&ustar, sizeof(ustar), 1, out);
 
   // Write file contents
   fwrite(data.data(), data.size(), 1, out);
   fseek(out, align_to(ftell(out), BLOCK_SIZE), SEEK_SET);
 
-  // A tar file must ends with two empty blocks, so write such
-  // terminator and seek back.
-  u8 terminator[BLOCK_SIZE * 2] = {};
-  fwrite(&terminator, BLOCK_SIZE * 2, 1, out);
-  fseek(out, -BLOCK_SIZE * 2, SEEK_END);
-
-  assert(ftell(out) % BLOCK_SIZE == 0);
+  // A tar file must ends with two empty blocks
+  (void)!ftruncate(fileno(out), ftell(out) + BLOCK_SIZE * 2);
 }
 
 } // namespace mold

main.cc

@@ -1,156 +0,0 @@
-#include "mold.h"
-#include "config.h"
-
-#include <cstring>
-#include <filesystem>
-#include <signal.h>
-#include <tbb/global_control.h>
-
-#ifdef USE_SYSTEM_MIMALLOC
-#include <mimalloc-new-delete.h>
-#endif
-
-#ifdef __FreeBSD__
-# include <sys/sysctl.h>
-# include <unistd.h>
-#endif
-
-namespace mold {
-
-std::string mold_version_string = MOLD_VERSION;
-
-namespace elf {
-int main(int argc, char **argv);
-}
-
-namespace macho {
-int main(int argc, char **argv);
-}
-
-static std::string get_mold_version() {
-  std::string name = MOLD_IS_SOLD ? "mold (sold) " : "mold ";
-  if (mold_git_hash.empty())
-    return name + MOLD_VERSION + " (compatible with GNU ld)";
-  return name + MOLD_VERSION + " (" + mold_git_hash + "; compatible with GNU ld)";
-}
-
-void cleanup() {
-  if (output_tmpfile)
-    unlink(output_tmpfile);
-}
-
-std::string errno_string() {
-  // strerror is not thread-safe, so guard it with a lock.
-  static std::mutex mu;
-  std::scoped_lock lock(mu);
-  return strerror(errno);
-}
-
-// Returns the path of the mold executable itself
-std::string get_self_path() {
-#ifdef __FreeBSD__
-  // /proc may not be mounted on FreeBSD. The proper way to get the
-  // current executable's path is to use sysctl(2).
-  int mib[4];
-  mib[0] = CTL_KERN;
-  mib[1] = KERN_PROC;
-  mib[2] = KERN_PROC_PATHNAME;
-  mib[3] = -1;
-
-  size_t size;
-  sysctl(mib, 4, NULL, &size, NULL, 0);
-
-  std::string path;
-  path.resize(size);
-  sysctl(mib, 4, path.data(), &size, NULL, 0);
-  return path;
-#else
-  return std::filesystem::read_symlink("/proc/self/exe").string();
-#endif
-}
-
-// mold mmap's an output file, and the mmap succeeds even if there's
-// no enough space left on the filesystem. The actual disk blocks are
-// not allocated on the mmap call but when the program writes to it
-// for the first time.
-//
-// If a disk becomes full as a result of a write to an mmap'ed memory
-// region, the failure of the write is reported as a SIGBUS or structured
-// exeption with code EXCEPTION_IN_PAGE_ERROR on Windows. This
-// signal handler catches that signal and prints out a user-friendly
-// error message. Without this, it is very hard to realize that the
-// disk might be full.
-#ifdef _WIN32
-
-static LONG WINAPI vectored_handler(_EXCEPTION_POINTERS *exception_info) {
-  static std::mutex mu;
-  std::scoped_lock lock{mu};
-
-  PEXCEPTION_RECORD exception_record = exception_info->ExceptionRecord;
-  ULONG_PTR *exception_information = exception_record->ExceptionInformation;
-  if (exception_record->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
-      (ULONG_PTR)output_buffer_start <= exception_information[1] &&
-      exception_information[1] < (ULONG_PTR)output_buffer_end) {
-
-    const char msg[] = "mold: failed to write to an output file. Disk full?\n";
-    (void)!write(_fileno(stderr), msg, sizeof(msg) - 1);
-  }
-
-  cleanup();
-  _exit(1);
-}
-
-void install_signal_handler() {
-  AddVectoredExceptionHandler(0, vectored_handler);
-}
-
-#else
-
-static void sighandler(int signo, siginfo_t *info, void *ucontext) {
-  static std::mutex mu;
-  std::scoped_lock lock{mu};
-
-  if ((signo == SIGSEGV || signo == SIGBUS) &&
-      output_buffer_start <= info->si_addr &&
-      info->si_addr < output_buffer_end) {
-    const char msg[] = "mold: failed to write to an output file. Disk full?\n";
-    (void)!write(STDERR_FILENO, msg, sizeof(msg) - 1);
-  }
-
-  cleanup();
-  _exit(1);
-}
-
-void install_signal_handler() {
-  struct sigaction action;
-  action.sa_sigaction = sighandler;
-  sigemptyset(&action.sa_mask);
-  action.sa_flags = SA_SIGINFO;
-
-  sigaction(SIGINT, &action, NULL);
-  sigaction(SIGTERM, &action, NULL);
-  sigaction(SIGBUS, &action, NULL);
-}
-
-#endif
-
-i64 get_default_thread_count() {
-  // mold doesn't scale well above 32 threads.
-  int n = tbb::global_control::active_value(
-    tbb::global_control::max_allowed_parallelism);
-  return std::min(n, 32);
-}
-
-} // namespace mold
-
-int main(int argc, char **argv) {
-  mold::mold_version = mold::get_mold_version();
-
-#if MOLD_IS_SOLD
-  std::string cmd = mold::filepath(argv[0]).filename().string();
-  if (cmd == "ld64" || cmd == "ld64.mold")
-    return mold::macho::main(argc, argv);
-#endif
-
-  return mold::elf::main(argc, argv);
-}

output-file-unix.h

@@ -1,169 +0,0 @@
-#include "mold.h"
-
-#include <fcntl.h>
-#include <filesystem>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace mold {
-
-inline u32 get_umask() {
-  u32 orig_umask = umask(0);
-  umask(orig_umask);
-  return orig_umask;
-}
-
-template <typename C>
-static std::pair<i64, char *>
-open_or_create_file(C &ctx, std::string path, i64 filesize, i64 perm) {
-  std::string tmpl = filepath(path).parent_path() / ".mold-XXXXXX";
-  char *path2 = (char *)save_string(ctx, tmpl).data();
-
-  i64 fd = mkstemp(path2);
-  if (fd == -1)
-    Fatal(ctx) << "cannot open " << path2 <<  ": " << errno_string();
-
-  // Reuse an existing file if exists and writable because on Linux,
-  // writing to an existing file is much faster than creating a fresh
-  // file and writing to it.
-  if (ctx.overwrite_output_file && rename(path.c_str(), path2) == 0) {
-    ::close(fd);
-    fd = ::open(path2, O_RDWR | O_CREAT, perm);
-    if (fd != -1 && !ftruncate(fd, filesize) && !fchmod(fd, perm & ~get_umask()))
-      return {fd, path2};
-
-    unlink(path2);
-    fd = ::open(path2, O_RDWR | O_CREAT, perm);
-    if (fd == -1)
-      Fatal(ctx) << "cannot open " << path2 << ": " << errno_string();
-  }
-
-  if (ftruncate(fd, filesize))
-    Fatal(ctx) << "ftruncate failed: " << errno_string();
-
-  if (fchmod(fd, (perm & ~get_umask())) == -1)
-    Fatal(ctx) << "fchmod failed: " << errno_string();
-  return {fd, path2};
-}
-
-template <typename C>
-class MemoryMappedOutputFile : public OutputFile<C> {
-public:
-  MemoryMappedOutputFile(C &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<C>(path, filesize, true) {
-    i64 fd;
-    std::tie(fd, output_tmpfile) = open_or_create_file(ctx, path, filesize, perm);
-
-    this->buf = (u8 *)mmap(nullptr, filesize, PROT_READ | PROT_WRITE,
-                           MAP_SHARED, fd, 0);
-    if (this->buf == MAP_FAILED)
-      Fatal(ctx) << path << ": mmap failed: " << errno_string();
-    ::close(fd);
-
-    mold::output_buffer_start = this->buf;
-    mold::output_buffer_end = this->buf + filesize;
-  }
-
-  ~MemoryMappedOutputFile() {
-    if (fd2 != -1)
-      ::close(fd2);
-  }
-
-  void close(C &ctx) override {
-    Timer t(ctx, "close_file");
-
-    if (!this->is_unmapped)
-      munmap(this->buf, this->filesize);
-
-    // If an output file already exists, open a file and then remove it.
-    // This is the fastest way to unlink a file, as it does not make the
-    // system to immediately release disk blocks occupied by the file.
-    fd2 = ::open(this->path.c_str(), O_RDONLY);
-    if (fd2 != -1)
-      unlink(this->path.c_str());
-
-    if (rename(output_tmpfile, this->path.c_str()) == -1)
-      Fatal(ctx) << this->path << ": rename failed: " << errno_string();
-    output_tmpfile = nullptr;
-  }
-
-private:
-  int fd2 = -1;
-};
-
-template <typename C>
-class MallocOutputFile : public OutputFile<C> {
-public:
-  MallocOutputFile(C &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<C>(path, filesize, false), perm(perm) {
-    this->buf = (u8 *)mmap(NULL, filesize, PROT_READ | PROT_WRITE,
-                           MAP_SHARED | MAP_ANONYMOUS, -1, 0);
-    if (this->buf == MAP_FAILED)
-      Fatal(ctx) << "mmap failed: " << errno_string();
-  }
-
-  void close(C &ctx) override {
-    Timer t(ctx, "close_file");
-
-    if (this->path == "-") {
-      fwrite(this->buf, this->filesize, 1, stdout);
-      fclose(stdout);
-      return;
-    }
-
-    i64 fd = ::open(this->path.c_str(), O_RDWR | O_CREAT, perm);
-    if (fd == -1)
-      Fatal(ctx) << "cannot open " << this->path << ": " << errno_string();
-
-    FILE *fp = fdopen(fd, "w");
-    fwrite(this->buf, this->filesize, 1, fp);
-    fclose(fp);
-  }
-
-private:
-  i64 perm;
-};
-
-template <typename C>
-std::unique_ptr<OutputFile<C>>
-OutputFile<C>::open(C &ctx, std::string path, i64 filesize, i64 perm) {
-  Timer t(ctx, "open_file");
-
-  if (path.starts_with('/') && !ctx.arg.chroot.empty())
-    path = ctx.arg.chroot + "/" + path_clean(path);
-
-  bool is_special = false;
-  if (path == "-") {
-    is_special = true;
-  } else {
-    struct stat st;
-    if (stat(path.c_str(), &st) == 0 && (st.st_mode & S_IFMT) != S_IFREG)
-      is_special = true;
-  }
-
-  OutputFile<C> *file;
-  if (is_special)
-    file = new MallocOutputFile<C>(ctx, path, filesize, perm);
-  else
-    file = new MemoryMappedOutputFile<C>(ctx, path, filesize, perm);
-
-#ifdef MADV_HUGEPAGE
-  // Enable transparent huge page for an output memory-mapped file.
-  // On Linux, it has an effect only on tmpfs mounted with `huge=advise`,
-  // but it can make the linker ~10% faster. You can try it by creating
-  // a tmpfs with the following commands
-  //
-  //  $ mkdir tmp
-  //  $ sudo mount -t tmpfs -o size=2G,huge=advise none tmp
-  //
-  // and then specifying a path under the directory as an output file.
-  madvise(file->buf, filesize, MADV_HUGEPAGE);
-#endif
-
-  if (ctx.arg.filler != -1)
-    memset(file->buf, ctx.arg.filler, filesize);
-  return std::unique_ptr<OutputFile<C>>(file);
-}
-
-} // namespace mold

output-file-win32.h

@@ -1,57 +0,0 @@
-#include "mold.h"
-
-#include <fcntl.h>
-#include <filesystem>
-#include <windows.h>
-
-namespace mold {
-
-template <typename C>
-class MallocOutputFile : public OutputFile<C> {
-public:
-  MallocOutputFile(C &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<C>(path, filesize, false), perm(perm) {
-    this->buf = (u8 *)malloc(filesize);
-    if (!this->buf)
-      Fatal(ctx) << "malloc failed";
-  }
-
-  void close(C &ctx) override {
-    Timer t(ctx, "close_file");
-
-    if (this->path == "-") {
-      fwrite(this->buf, this->filesize, 1, stdout);
-      fclose(stdout);
-      return;
-    }
-
-    i64 fd = ::open(this->path.c_str(), O_RDWR | O_CREAT, perm);
-    if (fd == -1)
-      Fatal(ctx) << "cannot open " << this->path << ": " << errno_string();
-
-    FILE *fp = fdopen(fd, "w");
-    fwrite(this->buf, this->filesize, 1, fp);
-    fclose(fp);
-    free(this->buf);
-  }
-
-private:
-  i64 perm;
-};
-
-template <typename C>
-std::unique_ptr<OutputFile<C>>
-OutputFile<C>::open(C &ctx, std::string path, i64 filesize, i64 perm) {
-  Timer t(ctx, "open_file");
-
-  if (path.starts_with('/') && !ctx.arg.chroot.empty())
-    path = ctx.arg.chroot + "/" + path_clean(path);
-
-  OutputFile<C> *file = new MallocOutputFile<C>(ctx, path, filesize, perm);
-
-  if (ctx.arg.filler != -1)
-    memset(file->buf, ctx.arg.filler, filesize);
-  return std::unique_ptr<OutputFile<C>>(file);
-}
-
-} // namespace mold

output-file.h

@@ -1,5 +0,0 @@
-#if _WIN32
-# include "output-file-win32.h"
-#else
-# include "output-file-unix.h"
-#endif

sha.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-typedef uint8_t u8;
-static constexpr int64_t SHA256_SIZE = 32;
-
-#ifdef _WIN32
-// On Windows, we use Microsoft CNG.
-
-#include <Windows.h>
-#include <bcrypt.h>
-#include <ntstatus.h>
-
-inline static BCRYPT_ALG_HANDLE get_sha256_handle() {
-  static std::once_flag once;
-  static BCRYPT_ALG_HANDLE alg;
-
-  std::call_once(once, [&] {
-    BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, nullptr, 0);
-  });
-  return alg;
-}
-
-inline void sha256_hash(u8 *in, size_t len, u8 *out) {
-  BCryptHash(get_sha256_handle(), nullptr, 0, in, len, out, SHA256_SIZE);
-}
-
-class SHA256Hash {
-public:
-  SHA256Hash() {
-    BCryptCreateHash(get_sha256_handle(), &handle, nullptr, 0, nullptr, 0, 0);
-  }
-
-  void update(u8 *data, size_t len) {
-    BCryptHashData(handle, data, len, 0);
-  }
-
-  void finish(u8 *out) {
-    BCryptFinishHash(handle, out, SHA256_SIZE, 0);
-  }
-
-private:
-  BCRYPT_HASH_HANDLE handle;
-};
-
-#else
-// On Unix, we use OpenSSL or the Apple's OpenSSL-compatible API.
-
-#ifdef __APPLE__
-#  define COMMON_DIGEST_FOR_OPENSSL
-#  include <CommonCrypto/CommonDigest.h>
-#  define SHA256(data, len, md) CC_SHA256(data, len, md)
-#else
-#  define OPENSSL_SUPPRESS_DEPRECATED 1
-#  include <openssl/sha.h>
-#endif
-
-inline void sha256_hash(u8 *in, size_t len, u8 *out) {
-  SHA256(in, len, out);
-}
-
-class SHA256Hash {
-public:
-  SHA256Hash() {
-    SHA256_Init(&ctx);
-  }
-
-  void update(u8 *data, size_t len) {
-    SHA256_Update(&ctx, data, len);
-  }
-
-  void finish(u8 *out) {
-    SHA256_Final(out, &ctx);
-  }
-
-private:
-  SHA256_CTX ctx;
-};
-
-#endif

src/arch-arm32.cc

@@ -2,7 +2,7 @@
 // processors support two different instruction encodings: Thumb and
 // ARM (in a narrower sense). Thumb instructions are either 16 bits or
 // 32 bits, while ARM instructions are all 32 bits. Feature-wise,
-// thumb is a subset of ARM, so not all ARM instructions are
+// Thumb is a subset of ARM, so not all ARM instructions are
 // representable in Thumb.
 //
 // ARM processors originally supported only ARM instructions. Thumb
@@ -12,14 +12,16 @@
 // be switched using BX (branch and mode exchange)-family instructions.
 // We need to use that instructions to, for example, call a function
 // encoded in Thumb from a function encoded in ARM. Sometimes, the
-// linker even has to emit an interworking thunk code to switch mode.
+// linker even has to emit interworking thunk code to switch mode.
 //
 // ARM instructions are aligned to 4 byte boundaries. Thumb are to 2
-// byte boundaries.
+// byte boundaries. So the least significant bit of a function address
+// is always 0.
 //
-// You can distinguish Thumb functions from ARM functions by looking
-// at the least significant bit (LSB) of its "address". If LSB is 0,
-// it's ARM; otherwise, Thumb.
+// To distinguish Thumb functions from ARM fucntions, the LSB of a
+// function address is repurposed as a boolean flag. If the LSB is 0,
+// the function referred to by the address is encoded in ARM;
+// otherwise, Thumb.
 //
 // For example, if a symbol `foo` is of type STT_FUNC and has value
 // 0x2001, `foo` is a function using Thumb instructions whose address
@@ -35,18 +37,15 @@
 #include <tbb/parallel_for_each.h>
 #include <tbb/parallel_sort.h>
 
-namespace mold::elf {
+namespace mold {
 
 using E = ARM32;
 
 template <>
 i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   switch (rel.r_type) {
-  case R_ARM_NONE:
-    return 0;
   case R_ARM_ABS32:
   case R_ARM_REL32:
-  case R_ARM_TARGET1:
   case R_ARM_BASE_PREL:
   case R_ARM_GOTOFF32:
   case R_ARM_GOT_PREL:
@@ -76,8 +75,9 @@ i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   }
   case R_ARM_CALL:
   case R_ARM_JUMP24:
+  case R_ARM_PLT32:
   case R_ARM_TLS_CALL:
-    return sign_extend(*(ul32 *)loc & 0x00ff'ffff, 23) << 2;
+    return sign_extend(*(ul32 *)loc, 23) << 2;
   case R_ARM_MOVW_PREL_NC:
   case R_ARM_MOVW_ABS_NC:
   case R_ARM_MOVT_PREL:
@@ -100,7 +100,7 @@ i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
     return sign_extend(val, 15);
   }
   default:
-    unreachable();
+    return 0;
   }
 }
 
@@ -144,7 +144,6 @@ void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
     break;
   case R_ARM_ABS32:
   case R_ARM_REL32:
-  case R_ARM_TARGET1:
   case R_ARM_BASE_PREL:
   case R_ARM_GOTOFF32:
   case R_ARM_GOT_PREL:
@@ -167,8 +166,8 @@ void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
     write_thm_b_imm(loc, val);
     break;
   case R_ARM_CALL:
-  case R_ARM_PLT32:
   case R_ARM_JUMP24:
+  case R_ARM_PLT32:
     *(ul32 *)loc = (*(ul32 *)loc & 0xff00'0000) | bits(val, 25, 2);
     break;
   case R_ARM_MOVW_PREL_NC:
@@ -193,25 +192,25 @@ void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
 
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ul32 insn[] = {
-    0xe52d'e004, // push {lr}
-    0xe59f'e004, // ldr lr, 2f
+  constexpr ul32 insn[] = {
+    0xe52d'e004, //    push {lr}
+    0xe59f'e004, //    ldr lr, 2f
     0xe08f'e00e, // 1: add lr, pc, lr
-    0xe5be'f008, // ldr pc, [lr, #8]!
+    0xe5be'f008, //    ldr pc, [lr, #8]!
     0x0000'0000, // 2: .word .got.plt - 1b - 8
-    0xe320'f000, // nop
-    0xe320'f000, // nop
-    0xe320'f000, // nop
+    0x0000'0000, //    (padding)
+    0x0000'0000, //    (padding)
+    0x0000'0000, //    (padding)
   };
 
   memcpy(buf, insn, sizeof(insn));
   *(ul32 *)(buf + 16) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 16;
 }
 
-static const ul32 plt_entry[] = {
+constexpr ul32 plt_entry[] = {
   0xe59f'c004, // 1: ldr ip, 2f
-  0xe08c'c00f, // add ip, ip, pc
-  0xe59c'f000, // ldr pc, [ip]
+  0xe08c'c00f, //    add ip, ip, pc
+  0xe59c'f000, //    ldr pc, [ip]
   0x0000'0000, // 2: .word sym@GOT - 1b
 };
 
@@ -224,14 +223,27 @@ void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
 template <>
 void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   memcpy(buf, plt_entry, sizeof(plt_entry));
-  *(ul32 *)(buf + 12) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 12;
+  *(ul32 *)(buf + 12) = sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx) - 12;
 }
 
-// ARM does not use .eh_frame for exception handling. Instead, it uses
-// .ARM.exidx and .ARM.extab. So this function is empty.
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {}
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_ARM_ABS32:
+    *(ul32 *)loc = val;
+    break;
+  case R_ARM_REL32:
+    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  default:
+    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
+  }
+}
 
 // ARM and Thumb branch instructions can jump within ±16 MiB.
 static bool is_jump_reachable(i64 val) {
@@ -242,22 +254,14 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  std::span<std::unique_ptr<RangeExtensionThunk<E>>> thunks =
-    output_section->thunks;
-
-  auto get_trampoline_addr = [&](u64 addr) {
-    for (;;) {
-      assert(!thunks.empty());
-      i64 disp = output_section->shdr.sh_addr + thunks[0]->offset - addr;
+  auto get_tls_trampoline_addr = [&, i = 0](u64 addr) mutable {
+    for (; i < output_section->thunks.size(); i++) {
+      i64 disp = output_section->shdr.sh_addr + output_section->thunks[i]->offset -
+                 addr;
       if (is_jump_reachable(disp))
         return disp;
-      thunks = thunks.subspan(1);
     }
+    unreachable();
   };
 
   for (i64 i = 0; i < rels.size(); i++) {
@@ -287,16 +291,11 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
 
     switch (rel.r_type) {
     case R_ARM_ABS32:
-    case R_ARM_TARGET1:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
     case R_ARM_REL32:
       *(ul32 *)loc = S + A - P;
       break;
     case R_ARM_THM_CALL: {
-      // THM_CALL relocation refers either BL or BLX instruction.
-      // They are different in only one bit. We need to use BL if
-      // the jump target is Thumb. Otherwise, use BLX.
       if (sym.is_remaining_undef_weak()) {
         // On ARM, calling an weak undefined symbol jumps to the
         // next instruction.
@@ -304,6 +303,9 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
         break;
       }
 
+      // THM_CALL relocation refers either BL or BLX instruction.
+      // They are different in only one bit. We need to use BL if
+      // the jump target is Thumb. Otherwise, use BLX.
       i64 val = S + A - P;
       if (is_jump_reachable(val)) {
         if (T) {
@@ -332,54 +334,66 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_ARM_GOT_BREL:
       *(ul32 *)loc = G + A;
       break;
-    case R_ARM_CALL:
-    case R_ARM_PLT32: {
-      // Just like THM_CALL, ARM_CALL relocation refers either BL or
-      // BLX instruction. We may need to rewrite BL → BLX or BLX → BL.
-      bool is_bl = ((*(ul32 *)loc & 0xff00'0000) == 0xeb00'0000);
-      bool is_blx = ((*(ul32 *)loc & 0xfe00'0000) == 0xfa00'0000);
-      if (!is_bl && !is_blx)
-        Fatal(ctx) << *this << ": R_ARM_CALL refers neither BL nor BLX";
-
+    case R_ARM_CALL: {
       if (sym.is_remaining_undef_weak()) {
-        // On ARM, calling an weak undefined symbol jumps to the
-        // next instruction.
         *(ul32 *)loc = 0xe320'f000; // NOP
         break;
       }
 
+      // Just like THM_CALL, ARM_CALL relocation refers to either BL or
+      // BLX instruction. We may need to rewrite BL → BLX or BLX → BL.
+      bool is_bl = ((*(ul32 *)loc & 0xff00'0000) == 0xeb00'0000);
+      bool is_blx = ((*(ul32 *)loc & 0xfe00'0000) == 0xfa00'0000);
+      if (!is_bl && !is_blx)
+        Fatal(ctx) << *this << ": R_ARM_CALL refers to neither BL nor BLX";
+
       u64 val = S + A - P;
       if (is_jump_reachable(val)) {
-        if (T)
-          *(ul32 *)loc = 0xfa00'0000 | (bit(val, 1) << 24) | bits(val, 25, 2);
-        else
-          *(ul32 *)loc = 0xeb00'0000 | bits(val, 25, 2);
+        if (T) {
+          *(ul32 *)loc = 0xfa00'0000; // BLX
+          *(ul32 *)loc |= (bit(val, 1) << 24) | bits(val, 25, 2);
+        } else {
+          *(ul32 *)loc = 0xeb00'0000; // BL
+          *(ul32 *)loc |= bits(val, 25, 2);
+        }
       } else {
-        *(ul32 *)loc = 0xeb00'0000 | bits(get_arm_thunk_addr() + A - P, 25, 2);
+        *(ul32 *)loc = 0xeb00'0000; // BL
+        *(ul32 *)loc |= bits(get_arm_thunk_addr() + A - P, 25, 2);
       }
       break;
     }
-    case R_ARM_JUMP24:
+    case R_ARM_JUMP24: {
+      if (sym.is_remaining_undef_weak()) {
+        *(ul32 *)loc = 0xe320'f000; // NOP
+        break;
+      }
+
+      // These relocs refers to a B (unconditional branch) instruction.
+      // Unlike BL or BLX, we can't rewrite B to BX in place when the
+      // processor mode switch is required because BX doesn't takes an
+      // immediate; it takes only a register. So if mode switch is
+      // required, we jump to a linker-synthesized thunk which does the
+      // job with a longer code sequence.
+      u64 val = S + A - P;
+      if (!is_jump_reachable(val) || T)
+        val = get_arm_thunk_addr() + A - P;
+      *(ul32 *)loc = (*(ul32 *)loc & 0xff00'0000) | bits(val, 25, 2);
+      break;
+    }
+    case R_ARM_PLT32:
       if (sym.is_remaining_undef_weak()) {
         *(ul32 *)loc = 0xe320'f000; // NOP
       } else {
-        // Unlike BL and BLX, we can't rewrite B to BX because BX doesn't
-        // takes an immediate; it takes only a register. So if mode switch
-        // is required, we jump to a linker-synthesized thunk which constructs
-        // a branch destination in a register and branches to that address.
-        u64 val = S + A - P;
-        if (!is_jump_reachable(val) || T)
-          val = get_arm_thunk_addr() + A - P;
+        u64 val = (T ? get_arm_thunk_addr() : S) + A - P;
         *(ul32 *)loc = (*(ul32 *)loc & 0xff00'0000) | bits(val, 25, 2);
       }
       break;
-    case R_ARM_THM_JUMP11: {
+    case R_ARM_THM_JUMP11:
       assert(T);
-      i64 val = S + A - P;
-      check(val, -(1 << 11), 1 << 11);
-      *(ul16 *)loc = (*(ul16 *)loc & 0xf800) | bits(val, 11, 1);
+      check(S + A - P, -(1 << 11), 1 << 11);
+      *(ul16 *)loc &= 0xf800;
+      *(ul16 *)loc |= bits(S + A - P, 11, 1);
       break;
-    }
     case R_ARM_THM_JUMP19: {
       i64 val = S + A - P;
       check(val, -(1 << 19), 1 << 19);
@@ -398,18 +412,20 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul16 *)(loc + 2) |= (J2 << 13) | (J1 << 11) | imm11;
       break;
     }
-    case R_ARM_THM_JUMP24:
+    case R_ARM_THM_JUMP24: {
       if (sym.is_remaining_undef_weak()) {
-        *(ul32 *)loc = 0x8000'f3af; // NOP.W
-      } else {
-        // Just like R_ARM_JUMP24, we need to jump to a thunk if we need to
-        // switch processor mode.
-        u64 val = S + A - P;
-        if (!is_jump_reachable(val) || !T)
-          val = get_thumb_thunk_addr() + A - P;
-        write_thm_b_imm(loc, val);
+        *(ul32 *)loc = 0x8000'f3af; // NOP
+        break;
       }
+
+      // Just like R_ARM_JUMP24, we need to jump to a thunk if we need to
+      // switch processor mode.
+      u64 val = S + A - P;
+      if (!is_jump_reachable(val) || !T)
+        val = get_thumb_thunk_addr() + A - P;
+      write_thm_b_imm(loc, val);
       break;
+    }
     case R_ARM_MOVW_PREL_NC:
       write_mov_imm(loc, ((S + A) | T) - P);
       break;
@@ -419,12 +435,11 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_ARM_THM_MOVW_PREL_NC:
       write_thm_mov_imm(loc, ((S + A) | T) - P);
       break;
-    case R_ARM_PREL31: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 30), 1LL << 30);
-      *(ul32 *)loc = (*(ul32 *)loc & 0x8000'0000) | (val & 0x7fff'ffff);
+    case R_ARM_PREL31:
+      check(S + A - P, -(1LL << 30), 1LL << 30);
+      *(ul32 *)loc &= 0x8000'0000;
+      *(ul32 *)loc |= (S + A - P) & 0x7fff'ffff;
       break;
-    }
     case R_ARM_THM_MOVW_ABS_NC:
       write_thm_mov_imm(loc, (S + A) | T);
       break;
@@ -456,12 +471,35 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul32 *)loc = S + A - ctx.tp_addr;
       break;
     case R_ARM_TLS_GOTDESC:
+      // ARM32 TLSDESC uses the following code sequence to materialize
+      // a TP-relative address in r0.
+      //
+      //       ldr     r0, .L2
+      //  .L1: bl      foo
+      //           R_ARM_TLS_CALL
+      //  .L2: .word   foo + . - .L1
+      //           R_ARM_TLS_GOTDESC
+      //
+      // We may relax the instructions to the following if its TP-relative
+      // address is known at link-time
+      //
+      //       ldr     r0, .L2
+      //  .L1: nop
+      //       ...
+      //  .L2: .word   foo(tpoff)
+      //
+      // or to the following if the TP-relative address is known at
+      // process startup time.
+      //
+      //       ldr     r0, .L2
+      //  .L1: ldr r0, [pc, r0]
+      //       ...
+      //  .L2: .word   foo(gottpoff) + . - .L1
       if (sym.has_tlsdesc(ctx)) {
         // A is odd if the corresponding TLS_CALL is Thumb.
-        if (A & 1)
-          *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) - P + A - 6;
-        else
-          *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) - P + A - 4;
+        *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) - P + A - ((A & 1) ? 6 : 4);
+      } else if (sym.has_gottp(ctx)) {
+        *(ul32 *)loc = sym.get_gottp_addr(ctx) - P + A - ((A & 1) ? 5 : 8);
       } else {
         *(ul32 *)loc = S - ctx.tp_addr;
       }
@@ -469,20 +507,25 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_ARM_TLS_CALL:
       if (sym.has_tlsdesc(ctx)) {
         // BL <tls_trampoline>
-        *(ul32 *)loc = 0xeb00'0000 | bits(get_trampoline_addr(P + 8), 25, 2);
+        *(ul32 *)loc = 0xeb00'0000 | bits(get_tls_trampoline_addr(P + 8), 25, 2);
+      } else if (sym.has_gottp(ctx)) {
+        *(ul32 *)loc = 0xe79f'0000; // ldr r0, [pc, r0]
       } else {
-        // BL -> NOP
-        *(ul32 *)loc = 0xe320'f000;
+        *(ul32 *)loc = 0xe320'f000; // nop
       }
       break;
     case R_ARM_THM_TLS_CALL:
       if (sym.has_tlsdesc(ctx)) {
-        u64 val = align_to(get_trampoline_addr(P + 4), 4);
+        u64 val = align_to(get_tls_trampoline_addr(P + 4), 4);
         write_thm_b_imm(loc, val);
         *(ul16 *)(loc + 2) &= ~0x1000; // rewrite BL with BLX
+      } else if (sym.has_gottp(ctx)) {
+        // Since `ldr r0, [pc, r0]` is not representable in Thumb,
+        // we use two instructions instead.
+        *(ul16 *)loc = 0x4478;         // add r0, pc
+        *(ul16 *)(loc + 2) = 0x6800;   // ldr r0, [r0]
       } else {
-        // BL -> NOP.W
-        *(ul32 *)loc = 0x8000'f3af;
+        *(ul32 *)loc = 0x8000'f3af;    // nop.w
       }
       break;
     default:
@@ -497,17 +540,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     SectionFragment<E> *frag;
     i64 frag_addend;
     std::tie(frag, frag_addend) = get_fragment(ctx, rel);
@@ -539,45 +577,36 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
     switch (rel.r_type) {
-    case R_ARM_ABS32:
-    case R_ARM_MOVT_ABS:
-    case R_ARM_THM_MOVT_ABS:
-    case R_ARM_TARGET1:
-      scan_dyn_absrel(ctx, sym, rel);
+    case R_ARM_MOVW_ABS_NC:
+    case R_ARM_THM_MOVW_ABS_NC:
+      scan_absrel(ctx, sym, rel);
       break;
     case R_ARM_THM_CALL:
     case R_ARM_CALL:
-    case R_ARM_PLT32:
     case R_ARM_JUMP24:
+    case R_ARM_PLT32:
     case R_ARM_THM_JUMP24:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_ARM_GOT_PREL:
     case R_ARM_GOT_BREL:
     case R_ARM_TARGET2:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_ARM_MOVT_PREL:
     case R_ARM_THM_MOVT_PREL:
@@ -585,32 +614,34 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
       scan_pcrel(ctx, sym, rel);
       break;
     case R_ARM_TLS_GD32:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
     case R_ARM_TLS_LDM32:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      ctx.needs_tlsld = true;
       break;
     case R_ARM_TLS_IE32:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
-    case R_ARM_TLS_GOTDESC:
-      if (!relax_tlsdesc(ctx, sym))
-        sym.flags.fetch_or(NEEDS_TLSDESC, std::memory_order_relaxed);
+    case R_ARM_TLS_CALL:
+    case R_ARM_THM_TLS_CALL:
+      scan_tlsdesc(ctx, sym);
       break;
+    case R_ARM_TLS_LE32:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_ARM_ABS32:
+    case R_ARM_MOVT_ABS:
+    case R_ARM_THM_MOVT_ABS:
     case R_ARM_REL32:
     case R_ARM_BASE_PREL:
     case R_ARM_GOTOFF32:
     case R_ARM_THM_JUMP11:
     case R_ARM_THM_JUMP19:
     case R_ARM_MOVW_PREL_NC:
-    case R_ARM_MOVW_ABS_NC:
     case R_ARM_THM_MOVW_PREL_NC:
-    case R_ARM_THM_MOVW_ABS_NC:
     case R_ARM_TLS_LDO32:
-    case R_ARM_TLS_LE32:
-    case R_ARM_TLS_CALL:
-    case R_ARM_THM_TLS_CALL:
     case R_ARM_V4BX:
+    case R_ARM_TLS_GOTDESC:
       break;
     default:
       Error(ctx) << *this << ": unknown relocation: " << rel;
@@ -619,46 +650,91 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
 }
 
 template <>
-void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
-
+void Thunk<E>::copy_buf(Context<E> &ctx) {
   // TLS trampoline code. ARM32's TLSDESC is designed so that this
   // common piece of code is factored out from object files to reduce
   // output size. Since no one provide, the linker has to synthesize it.
-  static ul32 hdr[] = {
+  constexpr ul32 hdr[] = {
     0xe08e'0000, // add r0, lr, r0
     0xe590'1004, // ldr r1, [r0, #4]
     0xe12f'ff11, // bx  r1
+    0xe320'f000, // nop
   };
 
   // This is a range extension and mode switch thunk.
   // It has two entry points: +0 for Thumb and +4 for ARM.
-  const u8 entry[] = {
+  static const u8 entry[] = {
     // .thumb
-    0xfc, 0x46,             //    mov  ip, pc
-    0x60, 0x47,             //    bx   ip  # jumps to the following `ldr` insn
+    0x78, 0x47,             //    bx   pc  # jumps to 1f
+    0xc0, 0x46,             //    nop
     // .arm
-    0x04, 0xc0, 0x9f, 0xe5, //    ldr  ip, 2f
-    0x0f, 0xc0, 0x8c, 0xe0, // 1: add  ip, ip, pc
-    0x1c, 0xff, 0x2f, 0xe1, //    bx   ip
-    0x00, 0x00, 0x00, 0x00, // 2: .word sym - 1b
+    0x00, 0xc0, 0x9f, 0xe5, // 1: ldr  ip, 3f
+    0x0f, 0xf0, 0x8c, 0xe0, // 2: add  pc, ip, pc
+    0x00, 0x00, 0x00, 0x00, // 3: .word sym - 2b
   };
 
   static_assert(E::thunk_hdr_size == sizeof(hdr));
   static_assert(E::thunk_size == sizeof(entry));
 
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
   memcpy(buf, hdr, sizeof(hdr));
+  buf += sizeof(hdr);
 
-  for (i64 i = 0; i < symbols.size(); i++) {
-    u8 *loc = buf + sizeof(hdr) + i * sizeof(entry);
-    memcpy(loc, entry, sizeof(entry));
+  u64 P = output_section.shdr.sh_addr + offset + sizeof(hdr);
 
-    u64 S = symbols[i]->get_addr(ctx);
-    u64 P = output_section.shdr.sh_addr + offset + sizeof(hdr) + i * sizeof(entry);
-    *(ul32 *)(loc + 16) = S - P - 16;
+  for (Symbol<E> *sym : symbols) {
+    memcpy(buf, entry, sizeof(entry));
+    *(ul32 *)(buf + 12) = sym->get_addr(ctx) - P - 16;
+
+    buf += sizeof(entry);
+    P += sizeof(entry);
   }
 }
 
+template <>
+u64 get_eflags(Context<E> &ctx) {
+  return EF_ARM_EABI_VER5;
+}
+
+void create_arm_exidx_section(Context<E> &ctx) {
+  for (i64 i = 0; i < ctx.chunks.size(); i++) {
+    OutputSection<E> *osec = ctx.chunks[i]->to_osec();
+
+    if (osec && osec->shdr.sh_type == SHT_ARM_EXIDX) {
+      auto *sec = new Arm32ExidxSection(*osec);
+      ctx.extra.exidx = sec;
+      ctx.chunks[i] = sec;
+      ctx.chunk_pool.emplace_back(sec);
+
+      for (InputSection<E> *isec : osec->members)
+        isec->is_alive = false;
+      break;
+    }
+  }
+}
+
+void Arm32ExidxSection::compute_section_size(Context<E> &ctx) {
+  output_section.compute_section_size(ctx);
+  this->shdr.sh_size = output_section.shdr.sh_size;
+}
+
+void Arm32ExidxSection::update_shdr(Context<E> &ctx) {
+  // .ARM.exidx's sh_link should be set to the .text section index.
+  // Runtime doesn't care about it, but the binutils's strip command does.
+  if (Chunk<E> *chunk = find_chunk(ctx, ".text"))
+    this->shdr.sh_link = chunk->shndx;
+}
+
+void Arm32ExidxSection::remove_duplicate_entries(Context<E> &ctx) {
+  this->shdr.sh_size = get_contents(ctx).size();
+}
+
+void Arm32ExidxSection::copy_buf(Context<E> &ctx) {
+  std::vector<u8> contents = get_contents(ctx);
+  assert(this->shdr.sh_size == contents.size());
+  write_vector(ctx.buf + this->shdr.sh_offset, contents);
+}
+
 // ARM executables use an .ARM.exidx section to look up an exception
 // handling record for the current instruction pointer. The table needs
 // to be sorted by their addresses.
@@ -667,8 +743,13 @@ void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
 // I don't know why only ARM uses the different mechanism, but it's
 // likely that it's due to some historical reason.
 //
-// This function sorts .ARM.exidx records.
-static void sort_exidx(Context<E> &ctx, OutputSection<E> &osec) {
+// This function returns contents of .ARM.exidx.
+std::vector<u8> Arm32ExidxSection::get_contents(Context<E> &ctx) {
+  std::vector<u8> buf(output_section.shdr.sh_size);
+
+  output_section.shdr.sh_addr = this->shdr.sh_addr;
+  output_section.write_to(ctx, buf.data(), nullptr);
+
   // .ARM.exidx records consists of a signed 31-bit relative address
   // and a 32-bit value. The relative address indicates the start
   // address of a function that the record covers. The value is one of
@@ -681,24 +762,24 @@ static void sort_exidx(Context<E> &ctx, OutputSection<E> &osec) {
   //
   // CANTUNWIND is value 1. The most significant bit is set in (2) but
   // not in (3). So we can distinguished them just by looking at a value.
-  const u32 EXIDX_CANTUNWIND = 1;
+  const u32 CANTUNWIND = 1;
 
   struct Entry {
     ul32 addr;
     ul32 val;
   };
 
-  if (osec.shdr.sh_size % sizeof(Entry))
+  if (buf.size() % sizeof(Entry))
     Fatal(ctx) << "invalid .ARM.exidx section size";
 
-  Entry *ent = (Entry *)(ctx.buf + osec.shdr.sh_offset);
-  i64 num_entries = osec.shdr.sh_size / sizeof(Entry);
+  Entry *ent = (Entry *)buf.data();
+  i64 num_entries = buf.size() / sizeof(Entry);
 
   // Entry's addresses are relative to themselves. In order to sort
-  // records by addresses, we first translate them so that the addresses
+  // records by address, we first translate them so that the addresses
   // are relative to the beginning of the section.
   auto is_relative = [](u32 val) {
-    return val != EXIDX_CANTUNWIND && !(val & 0x8000'0000);
+    return val != CANTUNWIND && !(val & 0x8000'0000);
   };
 
   tbb::parallel_for((i64)0, num_entries, [&](i64 i) {
@@ -708,10 +789,21 @@ static void sort_exidx(Context<E> &ctx, OutputSection<E> &osec) {
       ent[i].val = 0x7fff'ffff & (ent[i].val + offset);
   });
 
-  tbb::parallel_sort(ent, ent + num_entries, [](const Entry &a, const Entry &b) {
+  std::sort(ent, ent + num_entries, [](const Entry &a, const Entry &b) {
     return a.addr < b.addr;
   });
 
+  // Remove duplicate adjacent entries. That is, if two adjacent functions
+  // have the same compact unwind info or are both CANTUNWIND, we can
+  // merge them into a single address range.
+  auto it = std::unique(ent, ent + num_entries,
+                        [](const Entry &a, const Entry &b) {
+    return a.val == b.val;
+  });
+
+  num_entries = it - ent;
+  buf.resize(num_entries * sizeof(Entry));
+
   // Make addresses relative to themselves.
   tbb::parallel_for((i64)0, num_entries, [&](i64 i) {
     i64 offset = sizeof(Entry) * i;
@@ -719,41 +811,8 @@ static void sort_exidx(Context<E> &ctx, OutputSection<E> &osec) {
     if (is_relative(ent[i].val))
       ent[i].val = 0x7fff'ffff & (ent[i].val - offset);
   });
+
+  return buf;
 }
 
-void fixup_arm_exidx_section(Context<E> &ctx) {
-  Timer t(ctx, "fixup_arm_exidx_section");
-
-  auto find_exidx = [&]() -> OutputSection<E> * {
-    for (Chunk<E> *chunk : ctx.chunks)
-      if (OutputSection<E> *osec = chunk->to_osec())
-        if (osec->shdr.sh_type == SHT_ARM_EXIDX)
-          return osec;
-    return nullptr;
-  };
-
-  OutputSection<E> *exidx = find_exidx();
-  if (!exidx)
-    return;
-
-  // Sort .ARM.exidx contents
-  sort_exidx(ctx, *exidx);
-
-  // .ARM.exidx's sh_link should be set to the .text section index.
-  // Runtime doesn't care about it, but the binutils's strip command does.
-  if (ctx.shdr) {
-    auto find_text = [&]() -> Chunk<E> * {
-      for (Chunk<E> *chunk : ctx.chunks)
-        if (chunk->name == ".text")
-          return chunk;
-      return nullptr;
-    };
-
-    if (Chunk<E> *text = find_text()) {
-      exidx->shdr.sh_link = text->shndx;
-      ctx.shdr->copy_buf(ctx);
-    }
-  }
-}
-
-} // namespace mold::elf
+} // namespace mold

src/arch-arm64.cc

@@ -17,11 +17,13 @@
 //
 // https://github.com/ARM-software/abi-aa/blob/main/aaelf64/aaelf64.rst
 
+#if MOLD_ARM64LE || MOLD_ARM64BE
+
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
-using E = ARM64;
+using E = MOLD_TARGET;
 
 static void write_adrp(u8 *buf, u64 val) {
   *(ul32 *)buf |= (bits(val, 13, 12) << 29) | (bits(val, 32, 14) << 5);
@@ -46,16 +48,16 @@ static u64 page(u64 val) {
 
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ul32 insn[] = {
+  constexpr ul32 insn[] = {
     0xa9bf'7bf0, // stp  x16, x30, [sp,#-16]!
     0x9000'0010, // adrp x16, .got.plt[2]
     0xf940'0211, // ldr  x17, [x16, .got.plt[2]]
     0x9100'0210, // add  x16, x16, .got.plt[2]
     0xd61f'0220, // br   x17
-    0xd503'201f, // nop
-    0xd503'201f, // nop
-    0xd503'201f, // nop
-  };
+    0xd420'7d00, // brk
+    0xd420'7d00, // brk
+    0xd420'7d00, // brk
+ };
 
   u64 gotplt = ctx.gotplt->shdr.sh_addr + 16;
   u64 plt = ctx.plt->shdr.sh_addr;
@@ -68,7 +70,7 @@ void write_plt_header(Context<E> &ctx, u8 *buf) {
 
 template <>
 void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  static const ul32 insn[] = {
+  constexpr ul32 insn[] = {
     0x9000'0010, // adrp x16, .got.plt[n]
     0xf940'0211, // ldr  x17, [x16, .got.plt[n]]
     0x9100'0210, // add  x16, x16, .got.plt[n]
@@ -86,14 +88,14 @@ void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
 
 template <>
 void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  static const ul32 insn[] = {
+  constexpr ul32 insn[] = {
     0x9000'0010, // adrp x16, GOT[n]
     0xf940'0211, // ldr  x17, [x16, GOT[n]]
     0xd61f'0220, // br   x17
-    0xd503'201f, // nop
+    0xd420'7d00, // brk
   };
 
-  u64 got = sym.get_got_addr(ctx);
+  u64 got = sym.get_got_pltgot_addr(ctx);
   u64 plt = sym.get_plt_addr(ctx);
 
   memcpy(buf, insn, sizeof(insn));
@@ -102,36 +104,49 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
   case R_NONE:
     break;
   case R_AARCH64_ABS64:
-    *(ul64 *)loc = val;
+    *(U64<E> *)loc = val;
     break;
   case R_AARCH64_PREL32:
-    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    *(U32<E> *)loc = val - this->shdr.sh_addr - offset;
     break;
   case R_AARCH64_PREL64:
-    *(ul64 *)loc = val - this->shdr.sh_addr - offset;
+    *(U64<E> *)loc = val - this->shdr.sh_addr - offset;
     break;
   default:
     Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
   }
 }
 
+static bool is_adrp(u8 *loc) {
+  // https://developer.arm.com/documentation/ddi0596/2021-12/Base-Instructions/ADRP--Form-PC-relative-address-to-4KB-page-
+  u32 insn = *(ul32 *)loc;
+  return (bits(insn, 31, 24) & 0b1001'1111) == 0b1001'0000;
+}
+
+static bool is_ldr(u8 *loc) {
+  // https://developer.arm.com/documentation/ddi0596/2021-12/Base-Instructions/LDR--immediate---Load-Register--immediate--
+  u32 insn = *(ul32 *)loc;
+  return (bits(insn, 31, 20) & 0b1111'1111'1100) == 0b1111'1001'0100;
+}
+
+static bool is_add(u8 *loc) {
+  // https://developer.arm.com/documentation/ddi0596/2021-12/Base-Instructions/ADD--immediate---Add--immediate--
+  u32 insn = *(ul32 *)loc;
+  return (bits(insn, 31, 20) & 0b1111'1111'1100) == 0b1001'0001'0000;
+}
+
 template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -155,9 +170,9 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
 
     switch (rel.r_type) {
     case R_AARCH64_ABS64:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
     case R_AARCH64_LDST8_ABS_LO12_NC:
+    case R_AARCH64_ADD_ABS_LO12_NC:
       *(ul32 *)loc |= bits(S + A, 11, 0) << 10;
       break;
     case R_AARCH64_LDST16_ABS_LO12_NC:
@@ -172,57 +187,86 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_AARCH64_LDST128_ABS_LO12_NC:
       *(ul32 *)loc |= bits(S + A, 11, 4) << 10;
       break;
-    case R_AARCH64_ADD_ABS_LO12_NC:
-      *(ul32 *)loc |= bits(S + A, 11, 0) << 10;
+    case R_AARCH64_MOVW_UABS_G0:
+      check(S + A, 0, 1 << 16);
+      *(ul32 *)loc |= bits(S + A, 15, 0) << 5;
       break;
-    case R_AARCH64_MOVW_UABS_G0: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ul32 *)loc |= bits(val, 15, 0) << 5;
-      break;
-    }
     case R_AARCH64_MOVW_UABS_G0_NC:
       *(ul32 *)loc |= bits(S + A, 15, 0) << 5;
       break;
-    case R_AARCH64_MOVW_UABS_G1: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 32);
-      *(ul32 *)loc |= bits(val, 31, 16) << 5;
+    case R_AARCH64_MOVW_UABS_G1:
+      check(S + A, 0, 1LL << 32);
+      *(ul32 *)loc |= bits(S + A, 31, 16) << 5;
       break;
-    }
     case R_AARCH64_MOVW_UABS_G1_NC:
       *(ul32 *)loc |= bits(S + A, 31, 16) << 5;
       break;
-    case R_AARCH64_MOVW_UABS_G2: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 48);
-      *(ul32 *)loc |= bits(val, 47, 32) << 5;
+    case R_AARCH64_MOVW_UABS_G2:
+      check(S + A, 0, 1LL << 48);
+      *(ul32 *)loc |= bits(S + A, 47, 32) << 5;
       break;
-    }
     case R_AARCH64_MOVW_UABS_G2_NC:
       *(ul32 *)loc |= bits(S + A, 47, 32) << 5;
       break;
     case R_AARCH64_MOVW_UABS_G3:
       *(ul32 *)loc |= bits(S + A, 63, 48) << 5;
       break;
-    case R_AARCH64_ADR_GOT_PAGE: {
-      i64 val = page(G + GOT + A) - page(P);
-      check(val, -(1LL << 32), 1LL << 32);
-      write_adrp(loc, val);
+    case R_AARCH64_ADR_GOT_PAGE:
+      if (sym.has_got(ctx)) {
+        i64 val = page(G + GOT + A) - page(P);
+        check(val, -(1LL << 32), 1LL << 32);
+        write_adrp(loc, val);
+      } else {
+        // Relax GOT-loading ADRP+LDR to an immediate ADRP+ADD
+        i64 val = page(S + A) - page(P);
+        check(val, -(1LL << 32), 1LL << 32);
+        write_adrp(loc, val);
+
+        u32 reg = bits(*(ul32 *)loc, 4, 0);
+        *(ul32 *)(loc + 4) = 0x9100'0000 | (reg << 5) | reg; // ADD
+        *(ul32 *)(loc + 4) |= bits(S + A, 11, 0) << 10;
+        i++;
+      }
       break;
-    }
-    case R_AARCH64_ADR_PREL_PG_HI21: {
+    case R_AARCH64_ADR_PREL_PG_HI21:
+    case R_AARCH64_ADR_PREL_PG_HI21_NC: {
+      // The ARM64 psABI defines that an `ADRP x0, foo` and `ADD x0, x0,
+      // :lo12: foo` instruction pair to materialize a PC-relative address
+      // in a register can be relaxed to `NOP` followed by `ADR x0, foo`
+      // if foo is in PC ± 1 MiB.
+      if (ctx.arg.relax && sym.is_pcrel_linktime_const(ctx) &&
+          i + 1 < rels.size()) {
+        i64 val = S + A - P - 4;
+        const ElfRel<E> &rel2 = rels[i + 1];
+        if (sign_extend(val, 20) == val &&
+            rel2.r_type == R_AARCH64_ADD_ABS_LO12_NC &&
+            rel2.r_sym == rel.r_sym &&
+            rel2.r_offset == rel.r_offset + 4 &&
+            rel2.r_addend == rel.r_addend &&
+            is_adrp(loc) &&
+            is_add(loc + 4)) {
+          u32 reg1 = bits(*(ul32 *)loc, 4, 0);
+          u32 reg2 = bits(*(ul32 *)(loc + 4), 4, 0);
+          if (reg1 == reg2) {
+            *(ul32 *)loc = 0xd503'201f;              // nop
+            *(ul32 *)(loc + 4) = 0x1000'0000 | reg1; // adr
+            write_adr(loc + 4, val);
+            i++;
+            break;
+          }
+        }
+      }
+
       i64 val = page(S + A) - page(P);
-      check(val, -(1LL << 32), 1LL << 32);
+      if (rel.r_type == R_AARCH64_ADR_PREL_PG_HI21)
+        check(val, -(1LL << 32), 1LL << 32);
       write_adrp(loc, val);
       break;
     }
-    case R_AARCH64_ADR_PREL_LO21: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 20), 1LL << 20);
-      write_adr(loc, val);
+    case R_AARCH64_ADR_PREL_LO21:
+      check(S + A - P, -(1LL << 20), 1LL << 20);
+      write_adr(loc, S + A - P);
       break;
-    }
     case R_AARCH64_CALL26:
     case R_AARCH64_JUMP26: {
       if (sym.is_remaining_undef_weak()) {
@@ -238,27 +282,25 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul32 *)loc |= bits(val, 27, 2);
       break;
     }
+    case R_AARCH64_PLT32:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      *(U32<E> *)loc = S + A - P;
+      break;
     case R_AARCH64_CONDBR19:
-    case R_AARCH64_LD_PREL_LO19: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 20), 1LL << 20);
-      *(ul32 *)loc |= bits(val, 20, 2) << 5;
+    case R_AARCH64_LD_PREL_LO19:
+      check(S + A - P, -(1LL << 20), 1LL << 20);
+      *(ul32 *)loc |= bits(S + A - P, 20, 2) << 5;
       break;
-    }
-    case R_AARCH64_PREL16: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 15), 1LL << 15);
-      *(ul16 *)loc = val;
+    case R_AARCH64_PREL16:
+      check(S + A - P, -(1LL << 15), 1LL << 15);
+      *(U16<E> *)loc = S + A - P;
       break;
-    }
-    case R_AARCH64_PREL32: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 31), 1LL << 32);
-      *(ul32 *)loc = val;
+    case R_AARCH64_PREL32:
+      check(S + A - P, -(1LL << 31), 1LL << 32);
+      *(U32<E> *)loc = S + A - P;
       break;
-    }
     case R_AARCH64_PREL64:
-      *(ul64 *)loc = S + A - P;
+      *(U64<E> *)loc = S + A - P;
       break;
     case R_AARCH64_LD64_GOT_LO12_NC:
       *(ul32 *)loc |= bits(G + GOT + A, 11, 3) << 10;
@@ -309,6 +351,9 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       break;
     }
     case R_AARCH64_TLSLE_ADD_TPREL_LO12:
+      check(S + A - ctx.tp_addr, 0, 1 << 12);
+      *(ul32 *)loc |= bits(S + A - ctx.tp_addr, 11, 0) << 10;
+      break;
     case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
       *(ul32 *)loc |= bits(S + A - ctx.tp_addr, 11, 0) << 10;
       break;
@@ -322,38 +367,67 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A, 11, 0) << 10;
       break;
     case R_AARCH64_TLSDESC_ADR_PAGE21:
+      // ARM64 TLSDESC uses the following code sequence to materialize
+      // a TP-relative address in x0.
+      //
+      //   adrp    x0, 0
+      //       R_AARCH64_TLSDESC_ADR_PAGE21 foo
+      //   ldr     x1, [x0]
+      //       R_AARCH64_TLSDESC_LD64_LO12  foo
+      //   add     x0, x0, #0
+      //       R_AARCH64_TLSDESC_ADD_LO12   foo
+      //   blr     x1
+      //       R_AARCH64_TLSDESC_CALL       foo
+      //
+      // We may relax the instructions to the following if its TP-relative
+      // address is known at link-time
+      //
+      //   nop
+      //   nop
+      //   movz    x0, :tls_offset_hi:foo, lsl #16
+      //   movk    x0, :tls_offset_lo:foo
+      //
+      // or to the following if the TP-relative address is known at
+      // process startup time.
+      //
+      //   nop
+      //   nop
+      //   adrp    x0, :gottprel:foo
+      //   ldr     x0, [x0, :gottprel_lo12:foo]
       if (sym.has_tlsdesc(ctx)) {
         i64 val = page(sym.get_tlsdesc_addr(ctx) + A) - page(P);
         check(val, -(1LL << 32), 1LL << 32);
         write_adrp(loc, val);
       } else {
-        // adrp x0, 0 -> movz x0, #tls_ofset_hi, lsl #16
-        i64 val = (S + A - ctx.tp_addr);
-        check(val, -(1LL << 32), 1LL << 32);
-        *(ul32 *)loc = 0xd2a0'0000 | (bits(val, 32, 16) << 5);
+        *(ul32 *)loc = 0xd503'201f; // nop
       }
       break;
     case R_AARCH64_TLSDESC_LD64_LO12:
-      if (sym.has_tlsdesc(ctx)) {
+      if (sym.has_tlsdesc(ctx))
         *(ul32 *)loc |= bits(sym.get_tlsdesc_addr(ctx) + A, 11, 3) << 10;
-      } else {
-        // ldr x2, [x0] -> movk x0, #tls_ofset_lo
-        u32 offset_lo = (S + A - ctx.tp_addr) & 0xffff;
-        *(ul32 *)loc = 0xf280'0000 | (offset_lo << 5);
-      }
+      else
+        *(ul32 *)loc = 0xd503'201f; // nop
       break;
     case R_AARCH64_TLSDESC_ADD_LO12:
       if (sym.has_tlsdesc(ctx)) {
         *(ul32 *)loc |= bits(sym.get_tlsdesc_addr(ctx) + A, 11, 0) << 10;
+      } else if (sym.has_gottp(ctx)) {
+        *(ul32 *)loc = 0x9000'0000; // adrp x0, 0
+        write_adrp(loc, page(sym.get_gottp_addr(ctx) + A) - page(P));
       } else {
-        // add x0, x0, #0 -> nop
-        *(ul32 *)loc = 0xd503'201f;
+        *(ul32 *)loc = 0xd2a0'0000; // movz x0, 0, lsl #16
+        *(ul32 *)loc |= bits(S + A - ctx.tp_addr, 32, 16) << 5;
       }
       break;
     case R_AARCH64_TLSDESC_CALL:
-      if (!sym.has_tlsdesc(ctx)) {
-        // blr x2 -> nop
-        *(ul32 *)loc = 0xd503'201f;
+      if (sym.has_tlsdesc(ctx)) {
+        // Do nothing
+      } else if (sym.has_gottp(ctx)) {
+        *(ul32 *)loc = 0xf940'0000; // ldr x0, [x0, 0]
+        *(ul32 *)loc |= bits(sym.get_gottp_addr(ctx) + A, 11, 3) << 10;
+      } else {
+        *(ul32 *)loc = 0xf280'0000; // movk x0, 0
+        *(ul32 *)loc |= bits(S + A - ctx.tp_addr, 15, 0) << 5;
       }
       break;
     default:
@@ -368,17 +442,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     auto check = [&](i64 val, i64 lo, i64 hi) {
       if (val < lo || hi <= val)
         Error(ctx) << *this << ": relocation " << rel << " against "
@@ -396,14 +465,14 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
     switch (rel.r_type) {
     case R_AARCH64_ABS64:
       if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul64 *)loc = *val;
+        *(U64<E> *)loc = *val;
       else
-        *(ul64 *)loc = S + A;
+        *(U64<E> *)loc = S + A;
       break;
     case R_AARCH64_ABS32: {
       i64 val = S + A;
       check(val, 0, 1LL << 32);
-      *(ul32 *)loc = val;
+      *(U32<E> *)loc = val;
       break;
     }
     default:
@@ -417,56 +486,81 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
+    u8 *loc = (u8 *)(contents.data() + rel.r_offset);
 
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
     switch (rel.r_type) {
-    case R_AARCH64_ABS64:
-      scan_dyn_absrel(ctx, sym, rel);
+    case R_AARCH64_MOVW_UABS_G3:
+      scan_absrel(ctx, sym, rel);
       break;
     case R_AARCH64_ADR_GOT_PAGE:
+      // An ADR_GOT_PAGE and GOT_LO12_NC relocation pair is used to load a
+      // symbol's address from GOT. If the GOT value is a link-time
+      // constant, we may be able to rewrite the ADRP+LDR instruction pair
+      // with an ADRP+ADD, eliminating a GOT memory load.
+      if (ctx.arg.relax && sym.is_pcrel_linktime_const(ctx) &&
+          i + 1 < rels.size()) {
+        // ADRP+LDR must be consecutive and use the same register to relax.
+        const ElfRel<E> &rel2 = rels[i + 1];
+        if (rel2.r_type == R_AARCH64_LD64_GOT_LO12_NC &&
+            rel2.r_offset == rel.r_offset + 4 &&
+            rel2.r_sym == rel.r_sym &&
+            rel.r_addend == 0 &&
+            rel2.r_addend == 0 &&
+            is_adrp(loc) &&
+            is_ldr(loc + 4)) {
+          u32 rd = bits(*(ul32 *)loc, 4, 0);
+          u32 rn = bits(*(ul32 *)(loc + 4), 9, 5);
+          u32 rt = bits(*(ul32 *)(loc + 4), 4, 0);
+          if (rd == rn && rn == rt) {
+            i++;
+            break;
+          }
+        }
+      }
+      sym.flags |= NEEDS_GOT;
+      break;
     case R_AARCH64_LD64_GOT_LO12_NC:
     case R_AARCH64_LD64_GOTPAGE_LO15:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_AARCH64_CALL26:
     case R_AARCH64_JUMP26:
+    case R_AARCH64_PLT32:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
     case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
     case R_AARCH64_ADR_PREL_PG_HI21:
+    case R_AARCH64_ADR_PREL_PG_HI21_NC:
       scan_pcrel(ctx, sym, rel);
       break;
     case R_AARCH64_TLSGD_ADR_PAGE21:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
-    case R_AARCH64_TLSDESC_ADR_PAGE21:
-    case R_AARCH64_TLSDESC_LD64_LO12:
-    case R_AARCH64_TLSDESC_ADD_LO12:
-      if (!relax_tlsdesc(ctx, sym))
-        sym.flags.fetch_or(NEEDS_TLSDESC, std::memory_order_relaxed);
+    case R_AARCH64_TLSDESC_CALL:
+      scan_tlsdesc(ctx, sym);
       break;
+    case R_AARCH64_TLSLE_MOVW_TPREL_G2:
+    case R_AARCH64_TLSLE_ADD_TPREL_LO12:
+    case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_AARCH64_ABS64:
     case R_AARCH64_ADD_ABS_LO12_NC:
     case R_AARCH64_ADR_PREL_LO21:
     case R_AARCH64_CONDBR19:
@@ -482,20 +576,18 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_AARCH64_MOVW_UABS_G1_NC:
     case R_AARCH64_MOVW_UABS_G2:
     case R_AARCH64_MOVW_UABS_G2_NC:
-    case R_AARCH64_MOVW_UABS_G3:
     case R_AARCH64_PREL16:
     case R_AARCH64_PREL32:
     case R_AARCH64_PREL64:
+    case R_AARCH64_TLSGD_ADD_LO12_NC:
     case R_AARCH64_TLSLE_MOVW_TPREL_G0:
     case R_AARCH64_TLSLE_MOVW_TPREL_G0_NC:
     case R_AARCH64_TLSLE_MOVW_TPREL_G1:
     case R_AARCH64_TLSLE_MOVW_TPREL_G1_NC:
-    case R_AARCH64_TLSLE_MOVW_TPREL_G2:
     case R_AARCH64_TLSLE_ADD_TPREL_HI12:
-    case R_AARCH64_TLSLE_ADD_TPREL_LO12:
-    case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
-    case R_AARCH64_TLSGD_ADD_LO12_NC:
-    case R_AARCH64_TLSDESC_CALL:
+    case R_AARCH64_TLSDESC_ADR_PAGE21:
+    case R_AARCH64_TLSDESC_LD64_LO12:
+    case R_AARCH64_TLSDESC_ADD_LO12:
       break;
     default:
       Error(ctx) << *this << ": unknown relocation: " << rel;
@@ -504,26 +596,30 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
 }
 
 template <>
-void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
-
-  static const ul32 data[] = {
+void Thunk<E>::copy_buf(Context<E> &ctx) {
+  constexpr ul32 insn[] = {
     0x9000'0010, // adrp x16, 0   # R_AARCH64_ADR_PREL_PG_HI21
     0x9100'0210, // add  x16, x16 # R_AARCH64_ADD_ABS_LO12_NC
     0xd61f'0200, // br   x16
+    0xd420'7d00, // brk
   };
 
-  static_assert(E::thunk_size == sizeof(data));
+  static_assert(E::thunk_size == sizeof(insn));
 
-  for (i64 i = 0; i < symbols.size(); i++) {
-    u64 S = symbols[i]->get_addr(ctx);
-    u64 P = output_section.shdr.sh_addr + offset + i * E::thunk_size;
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 P = output_section.shdr.sh_addr + offset;
 
-    u8 *loc = buf + i * E::thunk_size;
-    memcpy(loc , data, sizeof(data));
-    write_adrp(loc, page(S) - page(P));
-    *(ul32 *)(loc + 4) |= bits(S, 11, 0) << 10;
+  for (Symbol<E> *sym : symbols) {
+    u64 S = sym->get_addr(ctx);
+    memcpy(buf, insn, E::thunk_size);
+    write_adrp(buf, page(S) - page(P));
+    *(ul32 *)(buf + 4) |= bits(S, 11, 0) << 10;
+
+    buf += E::thunk_size;
+    P += E::thunk_size;
   }
 }
 
-} // namespace mold::elf
+} // namespace mold
+
+#endif

src/arch-i386.cc

@@ -31,19 +31,17 @@
 // assume that %ebx is set to .got. For PDE, we need to create position-
 // dependent PLT entries which don't use %ebx.
 //
-// https://github.com/rui314/mold/wiki/i386-psabi.pdf
+// https://github.com/rui314/psabi/blob/main/i386.pdf
 
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
 using E = I386;
 
 template <>
 i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   switch (rel.r_type) {
-  case R_386_NONE:
-    return 0;
   case R_386_8:
   case R_386_PC8:
     return *loc;
@@ -66,8 +64,9 @@ i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   case R_386_SIZE32:
   case R_386_TLS_GOTDESC:
     return *(ul32 *)loc;
+  default:
+    return 0;
   }
-  unreachable();
 }
 
 template <>
@@ -141,6 +140,7 @@ void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
       0xcc,                   // (padding)
     };
     memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 5) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
     *(ul32 *)(buf + 11) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
   } else {
     static const u8 insn[] = {
@@ -150,10 +150,9 @@ void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
       0xcc,                   // (padding)
     };
     memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 5) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
     *(ul32 *)(buf + 11) = sym.get_gotplt_addr(ctx);
   }
-
-  *(ul32 *)(buf + 5) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
 }
 
 template <>
@@ -165,7 +164,7 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
       0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // (padding)
     };
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr;
+    *(ul32 *)(buf + 6) = sym.get_got_pltgot_addr(ctx) - ctx.got->shdr.sh_addr;
   } else {
     static const u8 insn[] = {
       0xf3, 0x0f, 0x1e, 0xfb,             // endbr32
@@ -173,13 +172,13 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
       0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // (padding)
     };
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx);
+    *(ul32 *)(buf + 6) = sym.get_got_pltgot_addr(ctx);
   }
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -203,15 +202,90 @@ static u32 relax_got32x(u8 *loc) {
   return 0;
 }
 
+// Relax GD to LE
+static void relax_gd_to_le(u8 *loc, ElfRel<E> rel, u64 val) {
+  static const u8 insn[] = {
+    0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
+    0x81, 0xc0, 0, 0, 0, 0, // add $tp_offset, %eax
+  };
+
+  switch (rel.r_type) {
+  case R_386_PLT32:
+  case R_386_PC32:
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 5) = val;
+    break;
+  case R_386_GOT32:
+  case R_386_GOT32X:
+    memcpy(loc - 2, insn, sizeof(insn));
+    *(ul32 *)(loc + 6) = val;
+    break;
+  default:
+    unreachable();
+  }
+}
+
+// Relax LD to LE
+static void relax_ld_to_le(u8 *loc, ElfRel<E> rel, u64 tls_size) {
+  switch (rel.r_type) {
+  case R_386_PLT32:
+  case R_386_PC32: {
+    static const u8 insn[] = {
+      0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
+      0x2d, 0, 0, 0, 0,       // sub $tls_size, %eax
+    };
+    memcpy(loc - 2, insn, sizeof(insn));
+    *(ul32 *)(loc + 5) = tls_size;
+    break;
+  }
+  case R_386_GOT32:
+  case R_386_GOT32X: {
+    static const u8 insn[] = {
+      0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
+      0x2d, 0, 0, 0, 0,       // sub $tls_size, %eax
+      0x90,                   // nop
+    };
+    memcpy(loc - 2, insn, sizeof(insn));
+    *(ul32 *)(loc + 5) = tls_size;
+    break;
+  }
+  default:
+    unreachable();
+  }
+}
+
+static u32 relax_tlsdesc_to_ie(u8 *loc) {
+  switch ((loc[0] << 8) | loc[1]) {
+  case 0x8d83: return 0x8b83; // lea 0(%ebx), %eax -> mov 0(%ebx), %eax
+  case 0x8d9b: return 0x8b9b; // lea 0(%ebx), %ebx -> mov 0(%ebx), %ebx
+  case 0x8d8b: return 0x8b8b; // lea 0(%ebx), %ecx -> mov 0(%ebx), %ecx
+  case 0x8d93: return 0x8b93; // lea 0(%ebx), %edx -> mov 0(%ebx), %edx
+  case 0x8db3: return 0x8bb3; // lea 0(%ebx), %esi -> mov 0(%ebx), %esi
+  case 0x8dbb: return 0x8bbb; // lea 0(%ebx), %edi -> mov 0(%ebx), %edi
+  case 0x8da3: return 0x8ba3; // lea 0(%ebx), %esp -> mov 0(%ebx), %esp
+  case 0x8dab: return 0x8bab; // lea 0(%ebx), %ebp -> mov 0(%ebx), %ebp
+  }
+  return 0;
+}
+
+static u32 relax_tlsdesc_to_le(u8 *loc) {
+  switch ((loc[0] << 8) | loc[1]) {
+  case 0x8d83: return 0x90b8; // lea 0(%ebx), %eax -> mov $0, %eax
+  case 0x8d9b: return 0x90bb; // lea 0(%ebx), %ebx -> mov $0, %ebx
+  case 0x8d8b: return 0x90b9; // lea 0(%ebx), %ecx -> mov $0, %ecx
+  case 0x8d93: return 0x90ba; // lea 0(%ebx), %edx -> mov $0, %edx
+  case 0x8db3: return 0x90be; // lea 0(%ebx), %esi -> mov $0, %esi
+  case 0x8dbb: return 0x90bf; // lea 0(%ebx), %edi -> mov $0, %edi
+  case 0x8da3: return 0x90bc; // lea 0(%ebx), %esp -> mov $0, %esp
+  case 0x8dab: return 0x90bd; // lea 0(%ebx), %ebp -> mov $0, %ebp
+  }
+  return 0;
+}
+
 template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -234,33 +308,24 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     u64 GOT = ctx.got->shdr.sh_addr;
 
     switch (rel.r_type) {
-    case R_386_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *loc = val;
+    case R_386_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
       break;
-    }
-    case R_386_16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ul16 *)loc = val;
+    case R_386_16:
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
       break;
-    }
     case R_386_32:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
-    case R_386_PC8: {
-      i64 val = S + A - P;
-      check(val, -(1 << 7), 1 << 7);
-      *loc = val;
+    case R_386_PC8:
+      check(S + A - P, -(1 << 7), 1 << 7);
+      *loc = S + A - P;
       break;
-    }
-    case R_386_PC16: {
-      i64 val = S + A - P;
-      check(val, -(1 << 15), 1 << 15);
-      *(ul16 *)loc = val;
+    case R_386_PC16:
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = S + A - P;
       break;
-    }
     case R_386_PC32:
     case R_386_PLT32:
       *(ul32 *)loc = S + A - P;
@@ -295,72 +360,16 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul32 *)loc = sym.get_gottp_addr(ctx) + A;
       break;
     case R_386_TLS_GD:
-      if (sym.has_tlsgd(ctx)) {
+      if (sym.has_tlsgd(ctx))
         *(ul32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
-      } else {
-        // Relax GD to LE
-        switch (rels[i + 1].r_type) {
-        case R_386_PLT32:
-        case R_386_PC32: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
-            0x81, 0xe8, 0, 0, 0, 0, // sub $val, %eax
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          *(ul32 *)(loc + 5) = ctx.tp_addr - S - A;
-          break;
-        }
-        case R_386_GOT32:
-        case R_386_GOT32X: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
-            0x81, 0xe8, 0, 0, 0, 0, // sub $val, %eax
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          *(ul32 *)(loc + 6) = ctx.tp_addr - S - A;
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        i++;
-      }
+      else
+        relax_gd_to_le(loc, rels[++i], S - ctx.tp_addr);
       break;
     case R_386_TLS_LDM:
-      if (ctx.got->has_tlsld(ctx)) {
+      if (ctx.got->has_tlsld(ctx))
         *(ul32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
-      } else {
-        // Relax LD to LE
-        switch (rels[i + 1].r_type) {
-        case R_386_PLT32:
-        case R_386_PC32: {
-          static const u8 insn[] = {
-            0x31, 0xc0,             // xor %eax, %eax
-            0x65, 0x8b, 0x00,       // mov %gs:(%eax), %eax
-            0x81, 0xe8, 0, 0, 0, 0, // sub $tls_size, %eax
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          break;
-        }
-        case R_386_GOT32:
-        case R_386_GOT32X: {
-          static const u8 insn[] = {
-            0x31, 0xc0,             // xor %eax, %eax
-            0x65, 0x8b, 0x00,       // mov %gs:(%eax), %eax
-            0x81, 0xe8, 0, 0, 0, 0, // sub $tls_size, %eax
-            0x90,                   // nop
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        *(ul32 *)(loc + 5) = ctx.tp_addr - ctx.tls_begin;
-        i++;
-      }
+      else
+        relax_ld_to_le(loc, rels[++i], ctx.tp_addr - ctx.tls_begin);
       break;
     case R_386_TLS_LDO_32:
       *(ul32 *)loc = S + A - ctx.dtp_addr;
@@ -369,13 +378,49 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ul32 *)loc = sym.esym().st_size + A;
       break;
     case R_386_TLS_GOTDESC:
+      // i386 TLSDESC uses the following code sequence to materialize
+      // a TP-relative address in %eax.
+      //
+      //   lea    0(%ebx), %eax
+      //       R_386_TLS_GOTDESC   foo
+      //   call   *(%eax)
+      //       R_386_TLS_DESC_CALL foo
+      //
+      // We may relax the instructions to the following if its TP-relative
+      // address is known at link-time
+      //
+      //   mov     $foo@TPOFF, %eax
+      //   nop
+      //
+      // or to the following if the TP-relative address is known at
+      // process startup time.
+      //
+      //   mov     foo@GOTTPOFF(%ebx), %eax
+      //   nop
+      //
+      // We allow the following alternative code sequence too because
+      // LLVM emits such code.
+      //
+      //   lea    0(%ebx), %reg
+      //       R_386_TLS_GOTDESC   foo
+      //   mov    %reg, %eax
+      //   call   *(%eax)
+      //       R_386_TLS_DESC_CALL foo
       if (sym.has_tlsdesc(ctx)) {
         *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) + A - GOT;
+      } else if (sym.has_gottp(ctx)) {
+        u32 insn = relax_tlsdesc_to_ie(loc - 2);
+        if (!insn)
+          Fatal(ctx) << *this << ": illegal instruction sequence for TLSDESC";
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
+        *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
       } else {
-        static const u8 insn[] = {
-          0x8d, 0x05, 0, 0, 0, 0, // lea 0, %eax
-        };
-        memcpy(loc - 2, insn, sizeof(insn));
+        u32 insn = relax_tlsdesc_to_le(loc - 2);
+        if (!insn)
+          Fatal(ctx) << *this << ": illegal instruction sequence for TLSDESC";
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
         *(ul32 *)loc = S + A - ctx.tp_addr;
       }
       break;
@@ -398,17 +443,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     auto check = [&](i64 val, i64 lo, i64 hi) {
       if (val < lo || hi <= val)
         Error(ctx) << *this << ": relocation " << rel << " against "
@@ -425,36 +465,28 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
     u64 GOT = ctx.got->shdr.sh_addr;
 
     switch (rel.r_type) {
-    case R_386_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *loc = val;
+    case R_386_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
       break;
-    }
-    case R_386_16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ul16 *)loc = val;
+    case R_386_16:
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
       break;
-    }
     case R_386_32:
       if (std::optional<u64> val = get_tombstone(sym, frag))
         *(ul32 *)loc = *val;
       else
         *(ul32 *)loc = S + A;
       break;
-    case R_386_PC8: {
-      i64 val = S + A;
-      check(val, -(1 << 7), 1 << 7);
-      *loc = val;
+    case R_386_PC8:
+      check(S + A, -(1 << 7), 1 << 7);
+      *loc = S + A;
       break;
-    }
-    case R_386_PC16: {
-      i64 val = S + A;
-      check(val, -(1 << 15), 1 << 15);
-      *(ul16 *)loc = val;
+    case R_386_PC16:
+      check(S + A, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = S + A;
       break;
-    }
     case R_386_PC32:
       *(ul32 *)loc = S + A;
       break;
@@ -482,35 +514,35 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = (u8 *)(contents.data() + rel.r_offset);
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
+
+    if (rel.r_type == R_386_TLS_GD || rel.r_type == R_386_TLS_LDM) {
+      if (i + 1 == rels.size())
+        Fatal(ctx) << *this << ": " << rel << " must be followed by PLT or GOT32";
+
+      if (u32 ty = rels[i + 1].r_type;
+          ty != R_386_PLT32 && ty != R_386_PC32 &&
+          ty != R_386_GOT32 && ty != R_386_GOT32X)
+        Fatal(ctx) << *this << ": " << rel << " must be followed by PLT or GOT32";
+    }
 
     switch (rel.r_type) {
     case R_386_8:
     case R_386_16:
       scan_absrel(ctx, sym, rel);
       break;
-    case R_386_32:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_386_PC8:
     case R_386_PC16:
     case R_386_PC32:
@@ -518,56 +550,48 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
       break;
     case R_386_GOT32:
     case R_386_GOTPC:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
-    case R_386_GOT32X: {
-      bool do_relax = ctx.arg.relax && !sym.is_imported &&
-                      sym.is_relative() && relax_got32x(loc - 2);
-      if (!do_relax)
-        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+    case R_386_GOT32X:
+      // We always want to relax GOT32X even if --no-relax is given
+      // because static PIE doesn't work without it.
+      if (sym.is_pcrel_linktime_const(ctx) && relax_got32x(loc - 2)) {
+        // Do nothing
+      } else {
+        sym.flags |= NEEDS_GOT;
+      }
       break;
-    }
     case R_386_PLT32:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_386_TLS_GOTIE:
-    case R_386_TLS_LE:
     case R_386_TLS_IE:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
     case R_386_TLS_GD:
-      if (i + 1 == rels.size())
-        Fatal(ctx) << *this << ": TLS_GD reloc must be followed by PLT or GOT32";
-
-      if (u32 ty = rels[i + 1].r_type;
-          ty != R_386_PLT32 && ty != R_386_PC32 &&
-          ty != R_386_GOT32 && ty != R_386_GOT32X)
-        Fatal(ctx) << *this << ": TLS_GD reloc must be followed by PLT or GOT32";
-
-      if (relax_tlsgd(ctx, sym))
+      // We always relax if -static because libc.a doesn't contain
+      // __tls_get_addr().
+      if (ctx.arg.static_ || (ctx.arg.relax && sym.is_tprel_linktime_const(ctx)))
         i++;
       else
-        sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+        sym.flags |= NEEDS_TLSGD;
       break;
     case R_386_TLS_LDM:
-      if (i + 1 == rels.size())
-        Fatal(ctx) << *this << ": TLS_LDM reloc must be followed by PLT or GOT32";
-
-      if (u32 ty = rels[i + 1].r_type;
-          ty != R_386_PLT32 && ty != R_386_PC32 &&
-          ty != R_386_GOT32 && ty != R_386_GOT32X)
-        Fatal(ctx) << *this << ": TLS_LDM reloc must be followed by PLT or GOT32";
-
-      if (relax_tlsld(ctx))
+      // We always relax if -static because libc.a doesn't contain
+      // __tls_get_addr().
+      if (ctx.arg.static_ || (ctx.arg.relax && !ctx.arg.shared))
         i++;
       else
-        ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+        ctx.needs_tlsld = true;
       break;
     case R_386_TLS_GOTDESC:
-      if (!relax_tlsdesc(ctx, sym))
-        sym.flags.fetch_or(NEEDS_TLSDESC, std::memory_order_relaxed);
+      scan_tlsdesc(ctx, sym);
       break;
+    case R_386_TLS_LE:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_386_32:
     case R_386_GOTOFF:
     case R_386_TLS_LDO_32:
     case R_386_SIZE32:
@@ -579,4 +603,4 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
   }
 }
 
-} // namespace mold::elf
+} // namespace mold

src/arch-m68k.cc

@@ -12,11 +12,11 @@
 // access instructions and therefore can support position-independent
 // code without too much hassle.
 //
-// https://github.com/rui314/mold/wiki/m68k-psabi.pdf
+// https://github.com/rui314/psabi/blob/main/m68k.pdf
 
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
 using E = M68K;
 
@@ -52,12 +52,12 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   };
 
   memcpy(buf, insn, sizeof(insn));
-  *(ub32 *)(buf + 4) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 2;
+  *(ub32 *)(buf + 4) = sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx) - 2;
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -78,11 +78,6 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -126,7 +121,6 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
 
     switch (rel.r_type) {
     case R_68K_32:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
     case R_68K_16:
       write16(S + A);
@@ -221,17 +215,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     SectionFragment<E> *frag;
     i64 frag_addend;
     std::tie(frag, frag_addend) = get_fragment(ctx, rel);
@@ -256,29 +245,19 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
       Error(ctx) << sym << ": GNU ifunc symbol is not supported on m68k";
 
     switch (rel.r_type) {
-    case R_68K_32:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_68K_16:
     case R_68K_8:
       scan_absrel(ctx, sym, rel);
@@ -294,35 +273,38 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_68K_GOTOFF32:
     case R_68K_GOTOFF16:
     case R_68K_GOTOFF8:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_68K_PLT32:
     case R_68K_PLT16:
     case R_68K_PLT8:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_68K_TLS_GD32:
     case R_68K_TLS_GD16:
     case R_68K_TLS_GD8:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
     case R_68K_TLS_LDM32:
     case R_68K_TLS_LDM16:
     case R_68K_TLS_LDM8:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      ctx.needs_tlsld = true;
       break;
     case R_68K_TLS_IE32:
     case R_68K_TLS_IE16:
     case R_68K_TLS_IE8:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
-    case R_68K_TLS_LDO32:
-    case R_68K_TLS_LDO16:
-    case R_68K_TLS_LDO8:
     case R_68K_TLS_LE32:
     case R_68K_TLS_LE16:
     case R_68K_TLS_LE8:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_68K_32:
+    case R_68K_TLS_LDO32:
+    case R_68K_TLS_LDO16:
+    case R_68K_TLS_LDO8:
       break;
     default:
       Error(ctx) << *this << ": unknown relocation: " << rel;
@@ -330,4 +312,4 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
   }
 }
 
-} // namespace mold::elf
+} // namespace mold

src/arch-ppc32.cc

@@ -30,7 +30,7 @@
 // 0x10000 (or 65536) bytes.
 //
 // Since each object file has its own .got2, %r30 refers to different
-// places in a merged .got2 for two functions that are came from different
+// places in a merged .got2 for two functions that came from different
 // input files. Therefore, %r30 makes sense only within a single function.
 //
 // Technically, we can reuse a %r30 value in our PLT if we create a PLT
@@ -38,27 +38,23 @@
 // doesn't seems to be worth its complexity. Our PLT simply doesn't rely
 // on a %r30 value.
 //
-// https://github.com/rui314/mold/wiki/ppc32-psabi.pdf
+// https://github.com/rui314/psabi/blob/main/ppc32.pdf
 
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
 using E = PPC32;
 
-static u64 lo(u64 x)       { return x & 0xffff; }
-static u64 hi(u64 x)       { return x >> 16; }
-static u64 ha(u64 x)       { return (x + 0x8000) >> 16; }
-static u64 high(u64 x)     { return (x >> 16) & 0xffff; }
-static u64 higha(u64 x)    { return ((x + 0x8000) >> 16) & 0xffff; }
-static u64 higher(u64 x)   { return (x >> 32) & 0xffff; }
-static u64 highera(u64 x)  { return ((x + 0x8000) >> 32) & 0xffff; }
-static u64 highest(u64 x)  { return x >> 48; }
-static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
+static u64 lo(u64 x)    { return x & 0xffff; }
+static u64 hi(u64 x)    { return x >> 16; }
+static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
+static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
+static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
 
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ub32 insn[] = {
+  constexpr ub32 insn[] = {
     // Get the address of this PLT section
     0x7c08'02a6, //    mflr    r0
     0x429f'0005, //    bcl     20, 31, 4
@@ -92,7 +88,7 @@ void write_plt_header(Context<E> &ctx, u8 *buf) {
   loc[5] |= lo(ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr + 4);
 }
 
-static const ub32 plt_entry[] = {
+constexpr ub32 plt_entry[] = {
   // Get the address of this PLT entry
   0x7c08'02a6, // mflr    r0
   0x429f'0005, // bcl     20, 31, 4
@@ -124,14 +120,14 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   memcpy(buf, plt_entry, sizeof(plt_entry));
 
   ub32 *loc = (ub32 *)buf;
-  i64 offset = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 8;
+  i64 offset = sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx) - 8;
   loc[4] |= higha(offset);
   loc[5] |= lo(offset);
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -152,14 +148,7 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
-  u64 got2 = 0;
-  if (file.ppc32_got2)
-    got2 = file.ppc32_got2->output_section->shdr.sh_addr + file.ppc32_got2->offset;
+  u64 GOT2 = file.extra.got2 ? file.extra.got2->get_addr() : 0;
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
@@ -176,10 +165,6 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     u64 GOT = ctx.got->shdr.sh_addr;
 
     switch (rel.r_type) {
-    case R_PPC_ADDR32:
-    case R_PPC_UADDR32:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
     case R_PPC_ADDR14:
       *(ub32 *)loc |= bits(S + A, 15, 2) << 2;
       break;
@@ -201,16 +186,16 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ub32 *)loc |= bits(S + A, 31, 2) << 2;
       break;
     case R_PPC_PLT16_LO:
-      *(ub16 *)loc = lo(G + GOT - got2 - A);
+      *(ub16 *)loc = lo(G + GOT - A - GOT2);
       break;
     case R_PPC_PLT16_HI:
-      *(ub16 *)loc = hi(G + GOT - got2 - A);
+      *(ub16 *)loc = hi(G + GOT - A - GOT2);
       break;
     case R_PPC_PLT16_HA:
-      *(ub16 *)loc = ha(G + GOT - got2 - A);
+      *(ub16 *)loc = ha(G + GOT - A - GOT2);
       break;
     case R_PPC_PLT32:
-      *(ub32 *)loc = G + GOT - got2 - A;
+      *(ub32 *)loc = G + GOT - A - GOT2;
       break;
     case R_PPC_REL14:
       *(ub32 *)loc |= bits(S + A - P, 15, 2) << 2;
@@ -281,6 +266,8 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_PPC_GOT_TPREL16:
       *(ub16 *)loc = sym.get_gottp_addr(ctx) - GOT;
       break;
+    case R_PPC_ADDR32:
+    case R_PPC_UADDR32:
     case R_PPC_TLS:
     case R_PPC_TLSGD:
     case R_PPC_TLSLD:
@@ -299,17 +286,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     SectionFragment<E> *frag;
     i64 frag_addend;
     std::tie(frag, frag_addend) = get_fragment(ctx, rel);
@@ -334,31 +316,20 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
     switch (rel.r_type) {
-    case R_PPC_ADDR32:
-    case R_PPC_UADDR32:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_PPC_ADDR14:
     case R_PPC_ADDR16:
     case R_PPC_UADDR16:
@@ -385,30 +356,34 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_PPC_PLT16_HI:
     case R_PPC_PLT16_HA:
     case R_PPC_PLT32:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_PPC_REL24:
     case R_PPC_PLTREL24:
     case R_PPC_PLTREL32:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_PPC_GOT_TLSGD16:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
     case R_PPC_GOT_TLSLD16:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      ctx.needs_tlsld = true;
       break;
     case R_PPC_GOT_TPREL16:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
+    case R_PPC_TPREL16_LO:
+    case R_PPC_TPREL16_HI:
+    case R_PPC_TPREL16_HA:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_PPC_ADDR32:
+    case R_PPC_UADDR32:
     case R_PPC_LOCAL24PC:
     case R_PPC_TLS:
     case R_PPC_TLSGD:
     case R_PPC_TLSLD:
-    case R_PPC_TPREL16_LO:
-    case R_PPC_TPREL16_HI:
-    case R_PPC_TPREL16_HA:
     case R_PPC_DTPREL16_LO:
     case R_PPC_DTPREL16_HI:
     case R_PPC_DTPREL16_HA:
@@ -422,10 +397,8 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
 }
 
 template <>
-void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
-
-  static const ub32 local_thunk[] = {
+void Thunk<E>::copy_buf(Context<E> &ctx) {
+  constexpr ub32 local_thunk[] = {
     // Get this thunk's address
     0x7c08'02a6, // mflr    r0
     0x429f'0005, // bcl     20, 31, 4
@@ -443,23 +416,27 @@ void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
   static_assert(E::thunk_size == sizeof(plt_entry));
   static_assert(E::thunk_size == sizeof(local_thunk));
 
-  for (i64 i = 0; i < symbols.size(); i++) {
-    ub32 *loc = (ub32 *)(buf + i * E::thunk_size);
-    Symbol<E> &sym = *symbols[i];
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 P = output_section.shdr.sh_addr + offset;
 
-    if (sym.has_plt(ctx)) {
-      memcpy(loc, plt_entry, sizeof(plt_entry));
-      u64 got = sym.has_got(ctx) ? sym.get_got_addr(ctx) : sym.get_gotplt_addr(ctx);
-      i64 val = got - get_addr(i) - 8;
-      loc[4] |= higha(val);
-      loc[5] |= lo(val);
+  for (Symbol<E> *sym : symbols) {
+    if (sym->has_plt(ctx)) {
+      u64 got =
+        sym->has_got(ctx) ? sym->get_got_addr(ctx) : sym->get_gotplt_addr(ctx);
+      i64 val = got - P - 8;
+      memcpy(buf, plt_entry, sizeof(plt_entry));
+      *(ub32 *)(buf + 16) |= higha(val);
+      *(ub32 *)(buf + 20) |= lo(val);
     } else {
-      memcpy(loc, local_thunk, sizeof(local_thunk));
-      i64 val = sym.get_addr(ctx) - get_addr(i) - 8;
-      loc[4] |= higha(val);
-      loc[5] |= lo(val);
+      i64 val = sym->get_addr(ctx) - P - 8;
+      memcpy(buf, local_thunk, sizeof(local_thunk));
+      *(ub32 *)(buf + 16) |= higha(val);
+      *(ub32 *)(buf + 20) |= lo(val);
     }
+
+    buf += E::thunk_size;
+    P += E::thunk_size;
   }
 }
 
-} // namespace mold::elf
+} // namespace mold

src/arch-ppc64v1.cc

@@ -5,14 +5,15 @@
 //
 // Even though they are similiar, ELFv1 isn't only different from ELFv2 in
 // endianness. The most notable difference is, in ELFv1, a function
-// pointer doesn't directly refer the entry point of a function but
-// instead refers a data structure so-called "function descriptor".
+// pointer doesn't directly refer to the entry point of a function but
+// instead refers to a data structure so-called "function descriptor".
 //
 // The function descriptor is essentially a pair of a function entry point
 // address and a value that should be set to %r2 before calling that
-// function. There is actually a third member, but we don't need to know
-// what that is. In total, the function descriptor is 24 bytes long. Here
-// is why we need it.
+// function. There is also a third member for "the environment pointer for
+// languages such as Pascal and PL/1" according to the psABI, but it looks
+// like no one acutally uses it. In total, the function descriptor is 24
+// bytes long. Here is why we need it.
 //
 // PPC generally lacks PC-relative data access instructions. Position-
 // independent code sets GOT + 0x8000 to %r2 and access global variables
@@ -25,8 +26,8 @@
 //
 // In this way, you can't call a function just by knowing the function's
 // entry point address. You also need to know a proper %r2 value for the
-// function. This is why a function pointer refers a tuple of an address
-// and a %r2 value.
+// function. This is why a function pointer refers to a tuple of an
+// address and a %r2 value.
 //
 // If a function call is made through PLT, PLT takes care of restoring %r2.
 // Therefore, the caller has to restore %r2 only for function calls
@@ -39,27 +40,25 @@
 // few different addresses for different purposes. It may not only have an
 // entry point address but may also have PLT and/or GOT addresses.
 // In PPCV1, it may have an OPD address in addition to these. OPD address
-// is used for relocations that refers the address of a function as a
+// is used for relocations that refers to the address of a function as a
 // function pointer.
+//
+// https://github.com/rui314/psabi/blob/main/ppc64v1.pdf
 
 #include "mold.h"
 
 #include <algorithm>
 #include <tbb/parallel_for_each.h>
 
-namespace mold::elf {
+namespace mold {
 
 using E = PPC64V1;
 
-static u64 lo(u64 x)       { return x & 0xffff; }
-static u64 hi(u64 x)       { return x >> 16; }
-static u64 ha(u64 x)       { return (x + 0x8000) >> 16; }
-static u64 high(u64 x)     { return (x >> 16) & 0xffff; }
-static u64 higha(u64 x)    { return ((x + 0x8000) >> 16) & 0xffff; }
-static u64 higher(u64 x)   { return (x >> 32) & 0xffff; }
-static u64 highera(u64 x)  { return ((x + 0x8000) >> 32) & 0xffff; }
-static u64 highest(u64 x)  { return x >> 48; }
-static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
+static u64 lo(u64 x)    { return x & 0xffff; }
+static u64 hi(u64 x)    { return x >> 16; }
+static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
+static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
+static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
 
 // .plt is used only for lazy symbol resolution on PPC64. All PLT
 // calls are made via range extension thunks even if they are within
@@ -69,33 +68,59 @@ static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
 // resolved addresses.
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
-  static const ub32 insn[] = {
+  constexpr ub32 insn[] = {
     0x7d88'02a6, // mflr    r12
     0x429f'0005, // bcl     20, 31, 4 // obtain PC
     0x7d68'02a6, // mflr    r11
-    0xe84b'0024, // ld      r2,36(r11)
     0x7d88'03a6, // mtlr    r12
-    0x7d62'5a14, // add     r11,r2,r11
+    0x3d6b'0000, // addis   r11, r11, GOTPLT_OFFSET@ha
+    0x396b'0000, // addi    r11, r11, GOTPLT_OFFSET@lo
     0xe98b'0000, // ld      r12,0(r11)
     0xe84b'0008, // ld      r2,8(r11)
     0x7d89'03a6, // mtctr   r12
     0xe96b'0010, // ld      r11,16(r11)
     0x4e80'0420, // bctr
-    // .quad .got.plt - .plt - 8
-    0x0000'0000,
-    0x0000'0000,
   };
 
   static_assert(sizeof(insn) == E::plt_hdr_size);
   memcpy(buf, insn, sizeof(insn));
-  *(ub64 *)(buf + 44) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 8;
+
+  i64 val = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 8;
+  *(ub32 *)(buf + 16) |= higha(val);
+  *(ub32 *)(buf + 20) |= lo(val);
 }
 
 template <>
 void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
-  i64 offset = ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx) - 4;
-  *(ub32 *)(buf + 0) = 0x3800'0000 | sym.get_plt_idx(ctx);   // li %r0, PLT_INDEX
-  *(ub32 *)(buf + 4) = 0x4b00'0000 | (offset & 0x00ff'ffff); // b  plt0
+  ub32 *loc = (ub32 *)buf;
+  i64 idx = sym.get_plt_idx(ctx);
+
+  // The PPC64 ELFv1 ABI requires PLT entries to be vary in size depending
+  // on their indices. Unlike other targets, .got.plt is filled not by us
+  // but by the loader, so we don't have a control over where the initial
+  // call to the PLT entry jumps to. So we need to strictly follow the PLT
+  // section layout as the loader expect it to be.
+  if (idx < 0x8000) {
+    constexpr ub32 insn[] = {
+      0x3800'0000, // li      r0, PLT_INDEX
+      0x4b00'0000, // b       plt0
+    };
+
+    memcpy(loc, insn, sizeof(insn));
+    loc[0] |= idx;
+    loc[1] |= (ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx) - 4) & 0x00ff'ffff;
+  } else {
+    constexpr ub32 insn[] = {
+      0x3c00'0000, // lis     r0, PLT_INDEX@high
+      0x6000'0000, // ori     r0, r0, PLT_INDEX@lo
+      0x4b00'0000, // b       plt0
+    };
+
+    memcpy(loc, insn, sizeof(insn));
+    loc[0] |= high(idx);
+    loc[1] |= lo(idx);
+    loc[2] |= (ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx) - 8) & 0x00ff'ffff;
+  }
 }
 
 // .plt.got is not necessary on PPC64 because range extension thunks
@@ -104,8 +129,8 @@ template <>
 void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -129,11 +154,6 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -157,11 +177,7 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     u64 TOC = ctx.extra.TOC->value;
 
     switch (rel.r_type) {
-    case R_PPC64_ADDR64:
-      apply_toc_rel(ctx, sym, rel, loc, S, A, P, dynrel);
-      break;
     case R_PPC64_TOC:
-      apply_toc_rel(ctx, *ctx.extra.TOC, rel, loc, TOC, A, P, dynrel);
       break;
     case R_PPC64_TOC16_HA:
       *(ub16 *)loc = ha(S + A - TOC);
@@ -169,12 +185,10 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_PPC64_TOC16_LO:
       *(ub16 *)loc = lo(S + A - TOC);
       break;
-    case R_PPC64_TOC16_DS: {
-      i64 val = S + A - TOC;
-      check(val, -(1 << 15), 1 << 15);
-      *(ub16 *)loc |= val & 0xfffc;
+    case R_PPC64_TOC16_DS:
+      check(S + A - TOC, -(1 << 15), 1 << 15);
+      *(ub16 *)loc |= (S + A - TOC) & 0xfffc;
       break;
-    }
     case R_PPC64_TOC16_LO_DS:
       *(ub16 *)loc |= (S + A - TOC) & 0xfffc;
       break;
@@ -194,6 +208,9 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
         *(ub32 *)(loc + 4) = 0xe841'0028; // ld r2, 40(r1)
       break;
     }
+    case R_PPC64_REL32:
+      *(ub32 *)loc = S + A - P;
+      break;
     case R_PPC64_REL64:
       *(ub64 *)loc = S + A - P;
       break;
@@ -233,18 +250,25 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_PPC64_DTPREL16_HA:
       *(ub16 *)loc = ha(S + A - ctx.dtp_addr);
       break;
-    case R_PPC64_TPREL16_HA:
-      *(ub16 *)loc = ha(S + A - ctx.tp_addr);
-      break;
     case R_PPC64_DTPREL16_LO:
       *(ub16 *)loc = lo(S + A - ctx.dtp_addr);
       break;
+    case R_PPC64_DTPREL16_LO_DS:
+      *(ub16 *)loc |= (S + A - ctx.dtp_addr) & 0xfffc;
+      break;
+    case R_PPC64_TPREL16_HA:
+      *(ub16 *)loc = ha(S + A - ctx.tp_addr);
+      break;
     case R_PPC64_TPREL16_LO:
       *(ub16 *)loc = lo(S + A - ctx.tp_addr);
       break;
+    case R_PPC64_TPREL16_LO_DS:
+      *(ub16 *)loc |= (S + A - ctx.tp_addr) & 0xfffc;
+      break;
     case R_PPC64_GOT_TPREL16_LO_DS:
       *(ub16 *)loc |= (sym.get_gottp_addr(ctx) - TOC) & 0xfffc;
       break;
+    case R_PPC64_ADDR64:
     case R_PPC64_PLTSEQ:
     case R_PPC64_PLTCALL:
     case R_PPC64_TLS:
@@ -263,17 +287,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     auto check = [&](i64 val, i64 lo, i64 hi) {
       if (val < lo || hi <= val)
         Error(ctx) << *this << ": relocation " << rel << " against "
@@ -314,55 +333,49 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT | NEEDS_PPC_OPD,
-                         std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT | NEEDS_PPC_OPD;
 
     // Any relocation except R_PPC64_REL24 is considered as an
     // address-taking relocation.
     if (rel.r_type != R_PPC64_REL24 && sym.get_type() == STT_FUNC)
-      sym.flags.fetch_or(NEEDS_PPC_OPD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_PPC_OPD;
 
     switch (rel.r_type) {
-    case R_PPC64_ADDR64:
-      scan_toc_rel(ctx, sym, rel);
-      break;
-    case R_PPC64_TOC:
-      scan_toc_rel(ctx, sym, rel);
-      break;
     case R_PPC64_GOT_TPREL16_HA:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
     case R_PPC64_REL24:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_PPC64_PLT16_HA:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_PPC64_GOT_TLSGD16_HA:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
     case R_PPC64_GOT_TLSLD16_HA:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      ctx.needs_tlsld = true;
       break;
+    case R_PPC64_TPREL16_HA:
+    case R_PPC64_TPREL16_LO:
+    case R_PPC64_TPREL16_LO_DS:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_PPC64_ADDR64:
+    case R_PPC64_TOC:
+    case R_PPC64_REL32:
     case R_PPC64_REL64:
     case R_PPC64_TOC16_HA:
     case R_PPC64_TOC16_LO:
@@ -375,8 +388,6 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_PPC64_PLT16_LO_DS:
     case R_PPC64_PLTSEQ:
     case R_PPC64_PLTCALL:
-    case R_PPC64_TPREL16_HA:
-    case R_PPC64_TPREL16_LO:
     case R_PPC64_GOT_TPREL16_LO_DS:
     case R_PPC64_GOT_TLSGD16_LO:
     case R_PPC64_GOT_TLSLD16_LO:
@@ -385,6 +396,7 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_PPC64_TLSLD:
     case R_PPC64_DTPREL16_HA:
     case R_PPC64_DTPREL16_LO:
+    case R_PPC64_DTPREL16_LO_DS:
       break;
     default:
       Error(ctx) << *this << ": unknown relocation: " << rel;
@@ -393,13 +405,11 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
 }
 
 template <>
-void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
-
+void Thunk<E>::copy_buf(Context<E> &ctx) {
   // If the destination is .plt.got, we save the current r2, read an
   // address of a function descriptor from .got, restore %r2 and jump
   // to the function.
-  static const ub32 pltgot_thunk[] = {
+  constexpr ub32 pltgot_thunk[] = {
     // Store the caller's %r2
     0xf841'0028, // std   %r2, 40(%r1)
 
@@ -417,7 +427,7 @@ void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
   };
 
   // If the destination is .plt, read a function descriptor from .got.plt.
-  static const ub32 plt_thunk[] = {
+  constexpr ub32 plt_thunk[] = {
     // Store the caller's %r2
     0xf841'0028, // std   %r2, 40(%r1)
 
@@ -436,7 +446,7 @@ void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
 
   // If the destination is a non-imported function, we directly jump
   // to the function entry address.
-  static const ub32 local_thunk[] = {
+  constexpr ub32 local_thunk[] = {
     0x3d82'0000, // addis r12, r2,  foo@toc@ha
     0x398c'0000, // addi  r12, r12, foo@toc@lo
     0x7d89'03a6, // mtctr r12
@@ -450,26 +460,27 @@ void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
   static_assert(E::thunk_size == sizeof(plt_thunk));
   static_assert(E::thunk_size == sizeof(local_thunk));
 
-  for (i64 i = 0; i < symbols.size(); i++) {
-    Symbol<E> &sym = *symbols[i];
-    ub32 *loc = (ub32 *)(buf + i * E::thunk_size);
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
 
-    if (sym.has_got(ctx)) {
-      memcpy(loc, pltgot_thunk, sizeof(pltgot_thunk));
-      i64 val = sym.get_got_addr(ctx) - ctx.extra.TOC->value;
-      loc[1] |= higha(val);
-      loc[2] |= lo(val);
-    } else if(sym.has_plt(ctx)) {
-      memcpy(loc, plt_thunk, sizeof(plt_thunk));
-      i64 val = sym.get_gotplt_addr(ctx) - ctx.extra.TOC->value;
-      loc[1] |= higha(val);
-      loc[2] |= lo(val);
+  for (Symbol<E> *sym : symbols) {
+    if (sym->has_got(ctx)) {
+      i64 val = sym->get_got_addr(ctx) - ctx.extra.TOC->value;
+      memcpy(buf, pltgot_thunk, sizeof(pltgot_thunk));
+      *(ub32 *)(buf + 4) |= higha(val);
+      *(ub32 *)(buf + 8) |= lo(val);
+    } else if(sym->has_plt(ctx)) {
+      i64 val = sym->get_gotplt_addr(ctx) - ctx.extra.TOC->value;
+      memcpy(buf, plt_thunk, sizeof(plt_thunk));
+      *(ub32 *)(buf + 4) |= higha(val);
+      *(ub32 *)(buf + 8) |= lo(val);
     } else {
-      memcpy(loc, local_thunk, sizeof(local_thunk));
-      i64 val = sym.get_addr(ctx, NO_OPD) - ctx.extra.TOC->value;
-      loc[0] |= higha(val);
-      loc[1] |= lo(val);
+      i64 val = sym->get_addr(ctx, NO_OPD) - ctx.extra.TOC->value;
+      memcpy(buf, local_thunk, sizeof(local_thunk));
+      *(ub32 *)buf |= higha(val);
+      *(ub32 *)(buf + 4) |= lo(val);
     }
+
+    buf += E::thunk_size;
   }
 }
 
@@ -504,7 +515,7 @@ struct OpdSymbol {
 };
 
 static Symbol<E> *
-get_opd_sym_at(Context<E> &ctx, std::span<OpdSymbol> syms, u64 offset) {
+get_opd_sym_at(std::span<OpdSymbol> syms, u64 offset) {
   auto it = std::lower_bound(syms.begin(), syms.end(), OpdSymbol{offset});
   if (it == syms.end())
     return nullptr;
@@ -521,10 +532,10 @@ get_opd_sym_at(Context<E> &ctx, std::span<OpdSymbol> syms, u64 offset) {
 // However, in reality, .opd isn't a normal input section. It needs many
 // special treatments as follows:
 //
-// 1. A function symbol refers not a .text but an .opd. Its address works
-//    fine for address-taking relocations such as R_PPC64_ADDR64. However,
-//    R_PPC64_REL24 (which is used for branch instruction) needs a
-//    function's real address instead of the function's .opd address.
+// 1. A function symbol refers to not a .text but an .opd. Its address
+//    works fine for address-taking relocations such as R_PPC64_ADDR64.
+//    However, R_PPC64_REL24 (which is used for branch instruction) needs
+//    a function's real address instead of the function's .opd address.
 //    We need to read .opd contents to find out a function entry point
 //    address to apply R_PPC64_REL24.
 //
@@ -532,9 +543,9 @@ get_opd_sym_at(Context<E> &ctx, std::span<OpdSymbol> syms, u64 offset) {
 //    are taken. Just copying input .opd sections to an output would
 //    produces lots of dead .opd entries.
 //
-// 3. In this design, all function symbols refer an .opd section, and that
-//    doesn't work well with graph traversal optimizations such as garbage
-//    collection or identical comdat folding. For example, garbage
+// 3. In this design, all function symbols refer to an .opd section, and
+//    that doesn't work well with graph traversal optimizations such as
+//    garbage collection or identical comdat folding. For example, garbage
 //    collector would mark an .opd alive which in turn mark all functions
 //    thatare referenced by .opd as alive, effectively keeping all
 //    functions as alive.
@@ -547,9 +558,9 @@ get_opd_sym_at(Context<E> &ctx, std::span<OpdSymbol> syms, u64 offset) {
 //
 // So, in this function, we undo what the compiler did to .opd. We remove
 // function symbols from .opd and reattach them to their function entry
-// points. We also rewrite relocations that directly refer an input .opd
-// section so that they refer function symbols instead. We then mark input
-// .opd sections as dead.
+// points. We also rewrite relocations that directly refer to an input
+// .opd  section so that they refer to function symbols instead. We then
+// mark input .opd sections as dead.
 //
 // After this function, we mark symbols with the NEEDS_PPC_OPD flag if the
 // symbol needs an .opd entry. We then create an output .opd just like we
@@ -599,7 +610,7 @@ void ppc64v1_rewrite_opd(Context<E> &ctx) {
         if (sym.get_input_section() != opd)
           continue;
 
-        Symbol<E> *real_sym = get_opd_sym_at(ctx, opd_syms, r.r_addend);
+        Symbol<E> *real_sym = get_opd_sym_at(opd_syms, r.r_addend);
         if (!real_sym)
           Fatal(ctx) << *isec << ": cannot find a symbol in .opd for " << r
                      << " at offset 0x" << std::hex << (u64)r.r_addend;
@@ -612,8 +623,8 @@ void ppc64v1_rewrite_opd(Context<E> &ctx) {
 }
 
 // When a function is exported, the dynamic symbol for the function should
-// refers the function's .opd entry. This function marks such symbols with
-// NEEDS_PPC_OPD.
+// refers to the function's .opd entry. This function marks such symbols
+// with NEEDS_PPC_OPD.
 void ppc64v1_scan_symbols(Context<E> &ctx) {
   tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
     for (Symbol<E> *sym : file->symbols)
@@ -623,15 +634,14 @@ void ppc64v1_scan_symbols(Context<E> &ctx) {
   });
 
   // Functions referenced by the ELF header also have to have .opd entries.
-  auto mark = [&](std::string_view name) {
-    if (!name.empty())
-      if (Symbol<E> &sym = *get_symbol(ctx, name); !sym.is_imported)
-        sym.flags |= NEEDS_PPC_OPD;
-  };
+  if (!ctx.arg.entry->is_imported)
+    ctx.arg.entry->flags |= NEEDS_PPC_OPD;
 
-  mark(ctx.arg.entry);
-  mark(ctx.arg.init);
-  mark(ctx.arg.fini);
+  if (!ctx.arg.init->is_imported)
+    ctx.arg.init->flags |= NEEDS_PPC_OPD;
+
+  if (!ctx.arg.fini->is_imported)
+    ctx.arg.fini->flags |= NEEDS_PPC_OPD;
 }
 
 void PPC64OpdSection::add_symbol(Context<E> &ctx, Symbol<E> *sym) {
@@ -640,14 +650,31 @@ void PPC64OpdSection::add_symbol(Context<E> &ctx, Symbol<E> *sym) {
   this->shdr.sh_size += ENTRY_SIZE;
 }
 
+i64 PPC64OpdSection::get_reldyn_size(Context<E> &ctx) const {
+  if (ctx.arg.pic)
+    return symbols.size() * 2;
+  return 0;
+}
+
 void PPC64OpdSection::copy_buf(Context<E> &ctx) {
   ub64 *buf = (ub64 *)(ctx.buf + this->shdr.sh_offset);
 
+  ElfRel<E> *rel = nullptr;
+  if (ctx.arg.pic)
+    rel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset + reldyn_offset);
+
   for (Symbol<E> *sym : symbols) {
-    *buf++ = sym->get_addr(ctx, NO_PLT | NO_OPD);
+    u64 addr = sym->get_addr(ctx, NO_PLT | NO_OPD);
+    *buf++ = addr;
     *buf++ = ctx.extra.TOC->value;
     *buf++ = 0;
+
+    if (ctx.arg.pic) {
+      u64 loc = sym->get_opd_addr(ctx);
+      *rel++ = ElfRel<E>(loc, E::R_RELATIVE, 0, addr);
+      *rel++ = ElfRel<E>(loc + 8, E::R_RELATIVE, 0, ctx.extra.TOC->value);
+    }
   }
 }
 
-} // namespace mold::elf
+} // namespace mold

src/arch-ppc64v2.cc

@@ -0,0 +1,663 @@
+// This file implements the PowerPC ELFv2 ABI which was standardized in
+// 2014. Modern little-endian PowerPC systems are based on this ABI.
+// The ABI is often referred to as "ppc64le". This shouldn't be confused
+// with "ppc64" which refers to the original, big-endian PowerPC systems.
+//
+// PPC64 is a bit tricky to support because PC-relative load/store
+// instructions hadn't been available until Power10 which debuted in 2021.
+// Prior to Power10, it wasn't trivial for position-independent code (PIC)
+// to load a value from, for example, .got, as we can't do that with [PC +
+// the offset to the .got entry].
+//
+// In the following, I'll explain how PIC is supported on pre-Power10
+// systems first and then explain what has changed with Power10.
+//
+//
+// Position-independent code on Power9 or earlier:
+//
+// We can get the program counter on older PPC64 systems with the
+// following four instructions
+//
+//   mflr  r1  // save the current link register to r1
+//   bl    .+4 // branch to the next instruction as if it were a function
+//   mflr  r0  // copy the return address to r0
+//   mtlr  r1  // restore the original link register value
+//
+// , but it's too expensive to do if we do this for each load/store.
+//
+// As a workaround, most functions are compiled in such a way that r2 is
+// assumed to always contain the address of .got + 0x8000. With this, we
+// can for example load the first entry of .got with a single instruction
+// `lw r0, -0x8000(r2)`. r2 is called the TOC pointer.
+//
+// There's only one .got for each ELF module. Therefore, if a callee is in
+// the same ELF module, r2 doesn't have to be recomputed. Most function
+// calls are usually within the same ELF module, so this mechanism is
+// efficient.
+//
+// A function compiled for pre-Power10 usually has two entry points,
+// global and local. The global entry point usually 8 bytes precedes
+// the local entry point. In between is the following instructions:
+//
+//   addis r2, r12, .TOC.@ha
+//   addi  r2, r2,  .TOC.@lo + 4;
+//
+// The global entry point assumes that the address of itself is in r12,
+// and it computes its own TOC pointer from r12. It's easy to do so for
+// the callee because the offset between its .got + 0x8000 and the
+// function is known at link-time. The above code sequence then falls
+// through to the local entry point that assumes r2 is .got + 0x8000.
+//
+// So, if a callee's TOC pointer is different from the current one
+// (e.g. calling a function in another .so), we first load the callee's
+// address to r12 (e.g. from .got.plt with a r2-relative load) and branch
+// to that address. Then the callee computes its own TOC pointer using
+// r12.
+//
+//
+// Position-independent code on Power10:
+//
+// Power10 added 8-bytes-long instructions to the ISA. Some of them are
+// PC-relative load/store instructions that take 34 bits offsets.
+// Functions compiled with `-mcpu=power10` use these instructions for PIC.
+// r2 does not have a special meaning in such fucntions.
+//
+// When a fucntion compiled for Power10 calls a function that uses the TOC
+// pointer, we need to compute a correct value for TOC and set it to r2
+// before transferring the control to the callee. Thunks are responsible
+// for doing it.
+//
+// `_NOTOC` relocations such as `R_PPC64_REL24_NOTOC` indicate that the
+// callee does not use TOC (i.e. compiled with `-mcpu=power10`). If a
+// function using TOC is referenced via a `_NOTOC` relocation, that call
+// is made through a range extension thunk.
+//
+//
+// Note on section names: the PPC64 psABI uses a weird naming convention
+// which calls .got.plt .plt. We ignored that part because it's just
+// confusing. Since the runtime only cares about segments, we should be
+// able to name sections whatever we want.
+//
+// https://github.com/rui314/psabi/blob/main/ppc64v2.pdf
+
+#include "mold.h"
+
+namespace mold {
+
+using E = PPC64V2;
+
+static u64 lo(u64 x)    { return x & 0xffff; }
+static u64 hi(u64 x)    { return x >> 16; }
+static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
+static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
+static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
+
+static void write34(u8 *loc, u64 x) {
+  ul32 *buf = (ul32 *)loc;
+  buf[0] = (buf[0] & 0xfffc'0000) | bits(x, 33, 16);
+  buf[1] = (buf[1] & 0xffff'0000) | bits(x, 15, 0);
+}
+
+// .plt is used only for lazy symbol resolution on PPC64. All PLT
+// calls are made via range extension thunks even if they are within
+// reach. Thunks read addresses from .got.plt and jump there.
+// Therefore, once PLT symbols are resolved and final addresses are
+// written to .got.plt, thunks just skip .plt and directly jump to the
+// resolved addresses.
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  constexpr ul32 insn[] = {
+    // Get PC
+    0x7c08'02a6, // mflr    r0
+    0x429f'0005, // bcl     20, 31, 4 // obtain PC
+    0x7d68'02a6, // mflr    r11
+    0x7c08'03a6, // mtlr    r0
+
+    // Compute the PLT entry index
+    0x398c'ffd4, // addi    r12, r12, -44
+    0x7c0b'6050, // subf    r0, r11, r12
+    0x7800'f082, // rldicl  r0, r0, 62, 2
+
+    // Compute the address of .got.plt
+    0x3d6b'0000, // addis   r11, r11, GOTPLT_OFFSET@ha
+    0x396b'0000, // addi    r11, r11, GOTPLT_OFFSET@lo
+
+    // Load .got.plt[0] and .got.plt[1] and branch to .got.plt[0]
+    0xe98b'0000, // ld      r12, 0(r11)
+    0x7d89'03a6, // mtctr   r12
+    0xe96b'0008, // ld      r11, 8(r11)
+    0x4e80'0420, // bctr
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+
+  i64 val = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 8;
+  *(ul32 *)(buf + 28) |= higha(val);
+  *(ul32 *)(buf + 32) |= lo(val);
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  // When the control is transferred to a PLT entry, the PLT entry's
+  // address is already set to %r12 by the caller.
+  i64 offset = ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx);
+  *(ul32 *)buf = 0x4b00'0000 | (offset & 0x00ff'ffff);        // b plt0
+}
+
+// .plt.got is not necessary on PPC64 because range extension thunks
+// directly read GOT entries and jump there.
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
+
+template <>
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_PPC64_ADDR64:
+    *(ul64 *)loc = val;
+    break;
+  case R_PPC64_REL32:
+    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_PPC64_REL64:
+    *(ul64 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  default:
+    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
+  }
+}
+
+static u64 get_local_entry_offset(Context<E> &ctx, Symbol<E> &sym) {
+  i64 val = sym.esym().ppc64_local_entry;
+  assert(val <= 7);
+  if (val == 7)
+    Fatal(ctx) << sym << ": local entry offset 7 is reserved";
+
+  if (val == 0 || val == 1)
+    return 0;
+  return 1 << val;
+}
+
+template <>
+void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    u64 S = sym.get_addr(ctx);
+    u64 A = rel.r_addend;
+    u64 P = get_addr() + rel.r_offset;
+    u64 G = sym.get_got_idx(ctx) * sizeof(Word<E>);
+    u64 GOT = ctx.got->shdr.sh_addr;
+    u64 TOC = ctx.extra.TOC->value;
+
+    auto r2save_thunk_addr = [&] { return get_thunk_addr(i); };
+    auto no_r2save_thunk_addr = [&] { return get_thunk_addr(i) + 8; };
+
+    switch (rel.r_type) {
+    case R_PPC64_TOC16_HA:
+      *(ul16 *)loc = ha(S + A - TOC);
+      break;
+    case R_PPC64_TOC16_LO:
+      *(ul16 *)loc = lo(S + A - TOC);
+      break;
+    case R_PPC64_TOC16_DS:
+    case R_PPC64_TOC16_LO_DS:
+      *(ul16 *)loc |= (S + A - TOC) & 0xfffc;
+      break;
+    case R_PPC64_REL24:
+      if (sym.has_plt(ctx) || !sym.esym().ppc64_preserves_r2()) {
+        i64 val = r2save_thunk_addr() + A - P;
+        *(ul32 *)loc |= bits(val, 25, 2) << 2;
+
+        // The thunk saves %r2 to the caller's r2 save slot. We need to
+        // restore it after function return. To do so, there's usually a
+        // NOP as a placeholder after a BL. 0x6000'0000 is a NOP.
+        if (*(ul32 *)(loc + 4) == 0x6000'0000)
+          *(ul32 *)(loc + 4) = 0xe841'0018; // ld r2, 24(r1)
+      } else {
+        i64 val = S + get_local_entry_offset(ctx, sym) + A - P;
+        if (sign_extend(val, 25) != val)
+          val = no_r2save_thunk_addr() + A - P;
+        *(ul32 *)loc |= bits(val, 25, 2) << 2;
+      }
+      break;
+    case R_PPC64_REL24_NOTOC:
+      if (sym.has_plt(ctx) || sym.esym().ppc64_uses_toc()) {
+        i64 val = no_r2save_thunk_addr() + A - P;
+        *(ul32 *)loc |= bits(val, 25, 2) << 2;
+      } else {
+        i64 val = S + A - P;
+        if (sign_extend(val, 25) != val)
+          val = no_r2save_thunk_addr() + A - P;
+        *(ul32 *)loc |= bits(val, 25, 2) << 2;
+      }
+      break;
+    case R_PPC64_REL32:
+      *(ul32 *)loc = S + A - P;
+      break;
+    case R_PPC64_REL64:
+      *(ul64 *)loc = S + A - P;
+      break;
+    case R_PPC64_REL16_HA:
+      *(ul16 *)loc = ha(S + A - P);
+      break;
+    case R_PPC64_REL16_LO:
+      *(ul16 *)loc = lo(S + A - P);
+      break;
+    case R_PPC64_PLT16_HA:
+      *(ul16 *)loc = ha(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_HI:
+      *(ul16 *)loc = hi(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_LO:
+      *(ul16 *)loc = lo(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_LO_DS:
+      *(ul16 *)loc |= (G + GOT - TOC) & 0xfffc;
+      break;
+    case R_PPC64_PLT_PCREL34:
+    case R_PPC64_PLT_PCREL34_NOTOC:
+    case R_PPC64_GOT_PCREL34:
+      write34(loc, G + GOT - P);
+      break;
+    case R_PPC64_PCREL34:
+      write34(loc, S + A - P);
+      break;
+    case R_PPC64_GOT_TPREL16_HA:
+      *(ul16 *)loc = ha(sym.get_gottp_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TPREL16_LO_DS:
+      *(ul16 *)loc |= (sym.get_gottp_addr(ctx) - TOC) & 0xfffc;
+      break;
+    case R_PPC64_GOT_TPREL_PCREL34:
+      write34(loc, sym.get_gottp_addr(ctx) - P);
+      break;
+    case R_PPC64_GOT_TLSGD16_HA:
+      *(ul16 *)loc = ha(sym.get_tlsgd_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSGD16_LO:
+      *(ul16 *)loc = lo(sym.get_tlsgd_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSGD_PCREL34:
+      write34(loc, sym.get_tlsgd_addr(ctx) - P);
+      break;
+    case R_PPC64_GOT_TLSLD16_HA:
+      *(ul16 *)loc = ha(ctx.got->get_tlsld_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSLD16_LO:
+      *(ul16 *)loc = lo(ctx.got->get_tlsld_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSLD_PCREL34:
+      write34(loc, ctx.got->get_tlsld_addr(ctx) - P);
+      break;
+    case R_PPC64_DTPREL16_HA:
+      *(ul16 *)loc = ha(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC64_DTPREL16_LO:
+      *(ul16 *)loc = lo(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC64_DTPREL16_LO_DS:
+      *(ul16 *)loc |= (S + A - ctx.dtp_addr) & 0xfffc;
+      break;
+    case R_PPC64_DTPREL34:
+      write34(loc, S + A - ctx.dtp_addr);
+      break;
+    case R_PPC64_TPREL16_HA:
+      *(ul16 *)loc = ha(S + A - ctx.tp_addr);
+      break;
+    case R_PPC64_TPREL16_LO:
+      *(ul16 *)loc = lo(S + A - ctx.tp_addr);
+      break;
+    case R_PPC64_TPREL16_LO_DS:
+      *(ul16 *)loc |= (S + A - ctx.tp_addr) & 0xfffc;
+      break;
+    case R_PPC64_TPREL34:
+      write34(loc, S + A - ctx.tp_addr);
+      break;
+    case R_PPC64_ADDR64:
+    case R_PPC64_PLTSEQ:
+    case R_PPC64_PLTSEQ_NOTOC:
+    case R_PPC64_PLTCALL:
+    case R_PPC64_PLTCALL_NOTOC:
+    case R_PPC64_TLS:
+    case R_PPC64_TLSGD:
+    case R_PPC64_TLSLD:
+      break;
+    default:
+      unreachable();
+    }
+  }
+}
+
+template <>
+void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
+
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : (i64)rel.r_addend;
+
+    switch (rel.r_type) {
+    case R_PPC64_ADDR64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul64 *)loc = *val;
+      else
+        *(ul64 *)loc = S + A;
+      break;
+    case R_PPC64_ADDR32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ul32 *)loc = val;
+      break;
+    }
+    case R_PPC64_DTPREL64:
+      *(ul64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    default:
+      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
+                 << rel;
+    }
+  }
+}
+
+template <>
+void InputSection<E>::scan_relocations(Context<E> &ctx) {
+  assert(shdr().sh_flags & SHF_ALLOC);
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  // Scan relocations
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (sym.is_ifunc())
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
+
+    switch (rel.r_type) {
+    case R_PPC64_GOT_TPREL16_HA:
+    case R_PPC64_GOT_TPREL_PCREL34:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_PPC64_REL24:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_PPC64_REL24_NOTOC:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      ctx.extra.is_power10 = true;
+      break;
+    case R_PPC64_PLT16_HA:
+    case R_PPC64_PLT_PCREL34:
+    case R_PPC64_PLT_PCREL34_NOTOC:
+    case R_PPC64_GOT_PCREL34:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_PPC64_GOT_TLSGD16_HA:
+    case R_PPC64_GOT_TLSGD_PCREL34:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_PPC64_GOT_TLSLD16_HA:
+    case R_PPC64_GOT_TLSLD_PCREL34:
+      ctx.needs_tlsld = true;
+      break;
+    case R_PPC64_TPREL16_HA:
+    case R_PPC64_TPREL16_LO:
+    case R_PPC64_TPREL16_LO_DS:
+    case R_PPC64_TPREL34:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_PPC64_ADDR64:
+    case R_PPC64_REL32:
+    case R_PPC64_REL64:
+    case R_PPC64_TOC16_HA:
+    case R_PPC64_TOC16_LO:
+    case R_PPC64_TOC16_LO_DS:
+    case R_PPC64_TOC16_DS:
+    case R_PPC64_REL16_HA:
+    case R_PPC64_REL16_LO:
+    case R_PPC64_PLT16_HI:
+    case R_PPC64_PLT16_LO:
+    case R_PPC64_PLT16_LO_DS:
+    case R_PPC64_PCREL34:
+    case R_PPC64_PLTSEQ:
+    case R_PPC64_PLTSEQ_NOTOC:
+    case R_PPC64_PLTCALL:
+    case R_PPC64_PLTCALL_NOTOC:
+    case R_PPC64_GOT_TPREL16_LO_DS:
+    case R_PPC64_GOT_TLSGD16_LO:
+    case R_PPC64_GOT_TLSLD16_LO:
+    case R_PPC64_TLS:
+    case R_PPC64_TLSGD:
+    case R_PPC64_TLSLD:
+    case R_PPC64_DTPREL16_HA:
+    case R_PPC64_DTPREL16_LO:
+    case R_PPC64_DTPREL16_LO_DS:
+    case R_PPC64_DTPREL34:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void Thunk<E>::copy_buf(Context<E> &ctx) {
+  // If the destination is PLT, we read an address from .got.plt or .got
+  // and jump there.
+  constexpr ul32 plt_thunk[] = {
+    0xf841'0018, // std   r2, 24(r1)
+    0x6000'0000, // nop
+    0x3d82'0000, // addis r12, r2, foo@gotplt@toc@ha
+    0xe98c'0000, // ld    r12, foo@gotplt@toc@lo(r12)
+    0x7d89'03a6, // mtctr r12
+    0x4e80'0420, // bctr
+  };
+
+  constexpr ul32 plt_thunk_power10[] = {
+    0xf841'0018, // std   r2, 24(r1)
+    0x6000'0000, // nop
+    0x0410'0000, // pld   r12, foo@gotplt@pcrel
+    0xe580'0000,
+    0x7d89'03a6, // mtctr r12
+    0x4e80'0420, // bctr
+  };
+
+  // If the destination is a non-imported function, we directly jump
+  // to its local entry point.
+  constexpr ul32 local_thunk[] = {
+    0xf841'0018, // std   r2, 24(r1)
+    0x6000'0000, // nop
+    0x3d82'0000, // addis r12, r2,  foo@toc@ha
+    0x398c'0000, // addi  r12, r12, foo@toc@lo
+    0x7d89'03a6, // mtctr r12
+    0x4e80'0420, // bctr
+  };
+
+  constexpr ul32 local_thunk_power10[] = {
+    0xf841'0018, // std   r2, 24(r1)
+    0x6000'0000, // nop
+    0x0610'0000, // pla   r12, foo@pcrel
+    0x3980'0000,
+    0x7d89'03a6, // mtctr r12
+    0x4e80'0420, // bctr
+  };
+
+  static_assert(E::thunk_size == sizeof(plt_thunk));
+  static_assert(E::thunk_size == sizeof(plt_thunk_power10));
+  static_assert(E::thunk_size == sizeof(local_thunk));
+  static_assert(E::thunk_size == sizeof(local_thunk_power10));
+
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 P = output_section.shdr.sh_addr + offset;
+  u64 TOC = ctx.extra.TOC->value;
+
+  for (Symbol<E> *sym : symbols) {
+    if (sym->has_plt(ctx)) {
+      u64 got =
+        sym->has_got(ctx) ? sym->get_got_addr(ctx) : sym->get_gotplt_addr(ctx);
+
+      if (ctx.extra.is_power10) {
+        memcpy(buf, plt_thunk_power10, E::thunk_size);
+        write34(buf + 8, got - P - 8);
+      } else {
+        memcpy(buf, plt_thunk, E::thunk_size);
+        *(ul32 *)(buf + 8) |= higha(got - TOC);
+        *(ul32 *)(buf + 12) |= lo(got - TOC);
+      }
+    } else {
+      u64 S = sym->get_addr(ctx);
+      if (ctx.extra.is_power10) {
+        memcpy(buf, local_thunk_power10, E::thunk_size);
+        write34(buf + 8, S - P - 8);
+      } else {
+        memcpy(buf, local_thunk, E::thunk_size);
+        *(ul32 *)(buf + 8) |= higha(S - TOC);
+        *(ul32 *)(buf + 12) |= lo(S - TOC);
+      }
+    }
+
+    buf += E::thunk_size;
+    P += E::thunk_size;
+  }
+}
+
+// GCC may emit references to the following functions in function prologue
+// and epiilogue if -Os is specified. For some reason, these functions are
+// not in libgcc.a and expected to be synthesized by the linker.
+const std::vector<std::pair<std::string_view, u32>>
+ppc64_save_restore_insns = {
+  { "_savegpr0_14", 0xf9c1ff70 }, // std r14,-144(r1)
+  { "_savegpr0_15", 0xf9e1ff78 }, // std r15,-136(r1)
+  { "_savegpr0_16", 0xfa01ff80 }, // std r16,-128(r1)
+  { "_savegpr0_17", 0xfa21ff88 }, // std r17,-120(r1)
+  { "_savegpr0_18", 0xfa41ff90 }, // std r18,-112(r1)
+  { "_savegpr0_19", 0xfa61ff98 }, // std r19,-104(r1)
+  { "_savegpr0_20", 0xfa81ffa0 }, // std r20,-96(r1)
+  { "_savegpr0_21", 0xfaa1ffa8 }, // std r21,-88(r1)
+  { "_savegpr0_22", 0xfac1ffb0 }, // std r22,-80(r1)
+  { "_savegpr0_23", 0xfae1ffb8 }, // std r23,-72(r1)
+  { "_savegpr0_24", 0xfb01ffc0 }, // std r24,-64(r1)
+  { "_savegpr0_25", 0xfb21ffc8 }, // std r25,-56(r1)
+  { "_savegpr0_26", 0xfb41ffd0 }, // std r26,-48(r1)
+  { "_savegpr0_27", 0xfb61ffd8 }, // std r27,-40(r1)
+  { "_savegpr0_28", 0xfb81ffe0 }, // std r28,-32(r1)
+  { "_savegpr0_29", 0xfba1ffe8 }, // std r29,-24(r1)
+  { "_savegpr0_30", 0xfbc1fff0 }, // std r30,-16(r1)
+  { "_savegpr0_31", 0xfbe1fff8 }, // std r31,-8(r1)
+  { "",             0xf8010010 }, // std r0,16(r1)
+  { "",             0x4e800020 }, // blr
+
+  { "_restgpr0_14", 0xe9c1ff70 }, // ld r14,-144(r1)
+  { "_restgpr0_15", 0xe9e1ff78 }, // ld r15,-136(r1)
+  { "_restgpr0_16", 0xea01ff80 }, // ld r16,-128(r1)
+  { "_restgpr0_17", 0xea21ff88 }, // ld r17,-120(r1)
+  { "_restgpr0_18", 0xea41ff90 }, // ld r18,-112(r1)
+  { "_restgpr0_19", 0xea61ff98 }, // ld r19,-104(r1)
+  { "_restgpr0_20", 0xea81ffa0 }, // ld r20,-96(r1)
+  { "_restgpr0_21", 0xeaa1ffa8 }, // ld r21,-88(r1)
+  { "_restgpr0_22", 0xeac1ffb0 }, // ld r22,-80(r1)
+  { "_restgpr0_23", 0xeae1ffb8 }, // ld r23,-72(r1)
+  { "_restgpr0_24", 0xeb01ffc0 }, // ld r24,-64(r1)
+  { "_restgpr0_25", 0xeb21ffc8 }, // ld r25,-56(r1)
+  { "_restgpr0_26", 0xeb41ffd0 }, // ld r26,-48(r1)
+  { "_restgpr0_27", 0xeb61ffd8 }, // ld r27,-40(r1)
+  { "_restgpr0_28", 0xeb81ffe0 }, // ld r28,-32(r1)
+  { "_restgpr0_29", 0xe8010010 }, // ld r0,16(r1)
+  { "",             0xeba1ffe8 }, // ld r29,-24(r1)
+  { "",             0x7c0803a6 }, // mtlr r0
+  { "",             0xebc1fff0 }, // ld r30,-16(r1)
+  { "",             0xebe1fff8 }, // ld r31,-8(r1)
+  { "",             0x4e800020 }, // blr
+  { "_restgpr0_30", 0xebc1fff0 }, // ld r30,-16(r1)
+  { "_restgpr0_31", 0xe8010010 }, // ld r0,16(r1)
+  { "",             0xebe1fff8 }, // ld r31,-8(r1)
+  { "",             0x7c0803a6 }, // mtlr r0
+  { "",             0x4e800020 }, // blr
+
+  { "_savegpr1_14", 0xf9ccff70 }, // std r14,-144(r12)
+  { "_savegpr1_15", 0xf9ecff78 }, // std r15,-136(r12)
+  { "_savegpr1_16", 0xfa0cff80 }, // std r16,-128(r12)
+  { "_savegpr1_17", 0xfa2cff88 }, // std r17,-120(r12)
+  { "_savegpr1_18", 0xfa4cff90 }, // std r18,-112(r12)
+  { "_savegpr1_19", 0xfa6cff98 }, // std r19,-104(r12)
+  { "_savegpr1_20", 0xfa8cffa0 }, // std r20,-96(r12)
+  { "_savegpr1_21", 0xfaacffa8 }, // std r21,-88(r12)
+  { "_savegpr1_22", 0xfaccffb0 }, // std r22,-80(r12)
+  { "_savegpr1_23", 0xfaecffb8 }, // std r23,-72(r12)
+  { "_savegpr1_24", 0xfb0cffc0 }, // std r24,-64(r12)
+  { "_savegpr1_25", 0xfb2cffc8 }, // std r25,-56(r12)
+  { "_savegpr1_26", 0xfb4cffd0 }, // std r26,-48(r12)
+  { "_savegpr1_27", 0xfb6cffd8 }, // std r27,-40(r12)
+  { "_savegpr1_28", 0xfb8cffe0 }, // std r28,-32(r12)
+  { "_savegpr1_29", 0xfbacffe8 }, // std r29,-24(r12)
+  { "_savegpr1_30", 0xfbccfff0 }, // std r30,-16(r12)
+  { "_savegpr1_31", 0xfbecfff8 }, // std r31,-8(r12)
+  { "",             0x4e800020 }, // blr
+
+  { "_restgpr1_14", 0xe9ccff70 }, // ld r14,-144(r12)
+  { "_restgpr1_15", 0xe9ecff78 }, // ld r15,-136(r12)
+  { "_restgpr1_16", 0xea0cff80 }, // ld r16,-128(r12)
+  { "_restgpr1_17", 0xea2cff88 }, // ld r17,-120(r12)
+  { "_restgpr1_18", 0xea4cff90 }, // ld r18,-112(r12)
+  { "_restgpr1_19", 0xea6cff98 }, // ld r19,-104(r12)
+  { "_restgpr1_20", 0xea8cffa0 }, // ld r20,-96(r12)
+  { "_restgpr1_21", 0xeaacffa8 }, // ld r21,-88(r12)
+  { "_restgpr1_22", 0xeaccffb0 }, // ld r22,-80(r12)
+  { "_restgpr1_23", 0xeaecffb8 }, // ld r23,-72(r12)
+  { "_restgpr1_24", 0xeb0cffc0 }, // ld r24,-64(r12)
+  { "_restgpr1_25", 0xeb2cffc8 }, // ld r25,-56(r12)
+  { "_restgpr1_26", 0xeb4cffd0 }, // ld r26,-48(r12)
+  { "_restgpr1_27", 0xeb6cffd8 }, // ld r27,-40(r12)
+  { "_restgpr1_28", 0xeb8cffe0 }, // ld r28,-32(r12)
+  { "_restgpr1_29", 0xebacffe8 }, // ld r29,-24(r12)
+  { "_restgpr1_30", 0xebccfff0 }, // ld r30,-16(r12)
+  { "_restgpr1_31", 0xebecfff8 }, // ld r31,-8(r12)
+  { "",             0x4e800020 }, // blr
+};
+
+void PPC64SaveRestoreSection::copy_buf(Context<E> &ctx) {
+  ul32 *buf = (ul32 *)(ctx.buf + this->shdr.sh_offset);
+  for (auto [label, insn] : ppc64_save_restore_insns)
+    *buf++ = insn;
+}
+
+template <>
+u64 get_eflags(Context<E> &ctx) {
+  return 2;
+}
+
+} // namespace mold

src/arch-s390x.cc

@@ -12,7 +12,7 @@
 // As an instruction set, s390x isn't particularly odd. It has 16 general-
 // purpose registers. Instructions are 2, 4 or 6 bytes long and always
 // aligned to 2 bytes boundaries. Despite unfamiliarty, I found that it
-// just feels like a 64-bit i386 in a parallel universe.
+// just feels like an x86-64 in a parallel universe.
 //
 // Here is the register usage in this ABI:
 //
@@ -25,19 +25,19 @@
 //   a1:    upper 32 bits of TP (thread pointer)
 //   a2:    lower 32 bits of TP (thread pointer)
 //
-// TLS is supported on s390x in the same way as it is on other targets
-// with one exeption. On other targets, __tls_get_addr is used to get an
-// address of a thread-local variable. On s390x, __tls_get_offset is used
-// instead. The difference is __tls_get_offset returns an address of a
-// thread-local variable as an offset from TP. So we need to add TP to a
-// return value before use. I don't know why it is different, but that is
-// the way it is.
+// Thread-local storage (TLS) is supported on s390x in the same way as it
+// is on other targets with one exeption. On other targets, __tls_get_addr
+// is used to get an address of a thread-local variable. On s390x,
+// __tls_get_offset is used instead. The difference is __tls_get_offset
+// returns an address of a thread-local variable as an offset from TP. So
+// we need to add TP to a return value before use. I don't know why it is
+// different, but that is the way it is.
 //
-// https://github.com/IBM/s390x-abi/releases/download/v1.6/lzsabi_s390x.pdf
+// https://github.com/rui314/psabi/blob/main/s390x.pdf
 
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
 using E = S390X;
 
@@ -48,16 +48,23 @@ static void write_mid20(u8 *loc, u64 val) {
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
   static u8 insn[] = {
+    // Compute PLT_INDEX
+    0xb9, 0x09, 0x00, 0x01,             // sgr   %r0, %r1
+    0xa7, 0x0b, 0xff, 0xc2,             // aghi  %r0, -62
+    0xeb, 0x10, 0x00, 0x01, 0x00, 0x0c, // srlg  %r1, %r0, 1
+    0xb9, 0x08, 0x00, 0x01,             // agr   %r0, %r1
     0xe3, 0x00, 0xf0, 0x38, 0x00, 0x24, // stg   %r0, 56(%r15)
+    // Branch to _dl_runtime_resolve
     0xc0, 0x10, 0, 0, 0, 0,             // larl  %r1, GOTPLT_OFFSET
     0xd2, 0x07, 0xf0, 0x30, 0x10, 0x08, // mvc   48(8, %r15), 8(%r1)
     0xe3, 0x10, 0x10, 0x10, 0x00, 0x04, // lg    %r1, 16(%r1)
     0x07, 0xf1,                         // br    %r1
-    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
+    0x07, 0x00, 0x07, 0x00,             // nopr; nopr
   };
 
   memcpy(buf, insn, sizeof(insn));
-  *(ub32 *)(buf + 8) = (ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 6) >> 1;
+  *(ub32 *)(buf + 26) =
+    (ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 24) >> 1;
 }
 
 template <>
@@ -65,15 +72,12 @@ void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   static u8 insn[] = {
     0xc0, 0x10, 0, 0, 0, 0,             // larl  %r1, GOTPLT_ENTRY_OFFSET
     0xe3, 0x10, 0x10, 0x00, 0x00, 0x04, // lg    %r1, (%r1)
-    0xc0, 0x01, 0, 0, 0, 0,             // lgfi  %r0, PLT_INDEX
-    0x07, 0xf1,                         // br    %r1
-    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
-    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
+    0x0d, 0x01,                         // basr  %r0, %r1
+    0x07, 0x00,                         // nopr
   };
 
   memcpy(buf, insn, sizeof(insn));
   *(ub32 *)(buf + 2) = (sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx)) >> 1;
-  *(ub32 *)(buf + 14) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
 }
 
 template <>
@@ -86,12 +90,12 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   };
 
   memcpy(buf, insn, sizeof(insn));
-  *(ub32 *)(buf + 2) = (sym.get_got_addr(ctx) - sym.get_plt_addr(ctx)) >> 1;
+  *(ub32 *)(buf + 2) = (sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx)) >> 1;
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -112,11 +116,6 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -149,136 +148,96 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
 
     switch (rel.r_type) {
     case R_390_64:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
-    case R_390_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *loc = val;
+    case R_390_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
       break;
-    }
-    case R_390_12: {
-      i64 val = S + A;
-      check(val, 0, 1 << 12);
-      *(ul16 *)loc = bits(val, 11, 0);
+    case R_390_12:
+      check(S + A, 0, 1 << 12);
+      *(ul16 *)loc |= bits(S + A, 11, 0);
       break;
-    }
-    case R_390_16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ub16 *)loc = val;
+    case R_390_16:
+      check(S + A, 0, 1 << 16);
+      *(ub16 *)loc = S + A;
       break;
-    }
-    case R_390_20: {
-      i64 val = S + A;
-      check(val, 0, 1 << 20);
-      write_mid20(loc, val);
+    case R_390_20:
+      check(S + A, 0, 1 << 20);
+      write_mid20(loc, S + A);
       break;
-    }
     case R_390_32:
-    case R_390_PLT32: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 32);
-      *(ub32 *)loc = val;
+    case R_390_PLT32:
+      check(S + A, 0, 1LL << 32);
+      *(ub32 *)loc = S + A;
       break;
-    }
     case R_390_PLT64:
       *(ub64 *)loc = S + A;
       break;
     case R_390_PC12DBL:
-    case R_390_PLT12DBL: {
-      i64 val = S + A - P;
-      check_dbl(val, -(1 << 12), 1 << 12);
-      *(ul16 *)loc = (val >> 1) & 0x0fff;
+    case R_390_PLT12DBL:
+      check_dbl(S + A - P, -(1 << 12), 1 << 12);
+      *(ul16 *)loc |= bits(S + A - P, 12, 1);
       break;
-    }
-    case R_390_PC16: {
-      i64 val = S + A - P;
-      check(val, -(1 << 15), 1 << 15);
-      *(ub16 *)loc = val;
+    case R_390_PC16:
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = S + A - P;
       break;
-    }
-    case R_390_PC32: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ub32 *)loc = val;
+    case R_390_PC32:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = S + A - P;
       break;
-    }
     case R_390_PC64:
       *(ub64 *)loc = S + A - P;
       break;
     case R_390_PC16DBL:
-    case R_390_PLT16DBL: {
-      i64 val = S + A - P;
-      check_dbl(val, -(1 << 16), 1 << 16);
-      *(ub16 *)loc = val >> 1;
+    case R_390_PLT16DBL:
+      check_dbl(S + A - P, -(1 << 16), 1 << 16);
+      *(ub16 *)loc = (S + A - P) >> 1;
       break;
-    }
     case R_390_PC24DBL:
-    case R_390_PLT24DBL: {
-      i64 val = S + A - P;
-      check_dbl(val, -(1 << 24), 1 << 24);
-      *(ub32 *)loc |= bits(val, 24, 1);
+    case R_390_PLT24DBL:
+      check_dbl(S + A - P, -(1 << 24), 1 << 24);
+      *(ub32 *)loc |= bits(S + A - P, 24, 1);
       break;
-    }
     case R_390_PC32DBL:
     case R_390_PLT32DBL:
-      if (ctx.is_static && &sym == ctx.tls_get_offset) {
-        // __tls_get_offset() in libc.a is stub code that calls abort().
-        // So we provide a replacement function.
-        *(ub32 *)loc = (ctx.extra.tls_get_offset->shdr.sh_addr - P) >> 1;
-      } else {
-        i64 val = S + A - P;
-        check_dbl(val, -(1LL << 32), 1LL << 32);
-        *(ub32 *)loc = val >> 1;
-      }
+      check_dbl(S + A - P, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = (S + A - P) >> 1;
       break;
     case R_390_GOT12:
-    case R_390_GOTPLT12: {
-      i64 val = G + A;
-      check(val, 0, 1 << 12);
-      *(ul16 *)loc = bits(val, 11, 0);
+    case R_390_GOTPLT12:
+      check(G + A, 0, 1 << 12);
+      *(ul16 *)loc |= bits(G + A, 11, 0);
       break;
-    }
     case R_390_GOT16:
-    case R_390_GOTPLT16: {
-      i64 val = G + A;
-      check(val, 0, 1 << 16);
-      *(ub16 *)loc = val;
+    case R_390_GOTPLT16:
+      check(G + A, 0, 1 << 16);
+      *(ub16 *)loc = G + A;
       break;
-    }
     case R_390_GOT20:
-    case R_390_GOTPLT20: {
-      i64 val = G + A;
-      check(val, 0, 1 << 20);
-      write_mid20(loc, val);
+    case R_390_GOTPLT20:
+      check(G + A, 0, 1 << 20);
+      write_mid20(loc, G + A);
       break;
-    }
     case R_390_GOT32:
-    case R_390_GOTPLT32: {
-      i64 val = G + A;
-      check(val, 0, 1LL << 32);
-      *(ub32 *)loc = val;
+    case R_390_GOTPLT32:
+      check(G + A, 0, 1LL << 32);
+      *(ub32 *)loc = G + A;
       break;
-    }
     case R_390_GOT64:
     case R_390_GOTPLT64:
       *(ub64 *)loc = G + A;
       break;
     case R_390_GOTOFF16:
-    case R_390_PLTOFF16: {
-      i64 val = S + A - GOT;
-      check(val, -(1 << 15), 1 << 15);
-      *(ub16 *)loc = val;
+    case R_390_PLTOFF16:
+      check(S + A - GOT, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = S + A - GOT;
       break;
-    }
     case R_390_GOTOFF32:
-    case R_390_PLTOFF32: {
-      i64 val = S + A - GOT;
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ub32 *)loc = val;
+    case R_390_PLTOFF32:
+      check(S + A - GOT, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = S + A - GOT;
       break;
-    }
     case R_390_GOTOFF64:
     case R_390_PLTOFF64:
       *(ub64 *)loc = S + A - GOT;
@@ -286,18 +245,14 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_390_GOTPC:
       *(ub64 *)loc = GOT + A - P;
       break;
-    case R_390_GOTPCDBL: {
-      i64 val = GOT + A - P;
-      check_dbl(val, -(1LL << 32), 1LL << 32);
-      *(ub32 *)loc = val >> 1;
+    case R_390_GOTPCDBL:
+      check_dbl(GOT + A - P, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = (GOT + A - P) >> 1;
       break;
-    }
-    case R_390_GOTENT: {
-      i64 val = GOT + G + A - P;
-      check(val, -(1LL << 32), 1LL << 32);
-      *(ub32 *)loc = val >> 1;
+    case R_390_GOTENT:
+      check_dbl(GOT + G + A - P, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = (GOT + G + A - P) >> 1;
       break;
-    }
     case R_390_TLS_LE32:
       *(ub32 *)loc = S + A - ctx.tp_addr;
       break;
@@ -313,47 +268,57 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_390_TLS_GD32:
       if (sym.has_tlsgd(ctx))
         *(ub32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
+      else if (sym.has_gottp(ctx))
+        *(ub32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
       else
         *(ub32 *)loc = S + A - ctx.tp_addr;
       break;
     case R_390_TLS_GD64:
       if (sym.has_tlsgd(ctx))
         *(ub64 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
+      else if (sym.has_gottp(ctx))
+        *(ub64 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
       else
         *(ub64 *)loc = S + A - ctx.tp_addr;
       break;
     case R_390_TLS_GDCALL:
-      if (!sym.has_tlsgd(ctx)) {
-        static u8 nop[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
-        memcpy(loc, nop, sizeof(nop));
+      if (sym.has_tlsgd(ctx)) {
+        // do nothing
+      } else if (sym.has_gottp(ctx)) {
+        // lg %r2, 0(%r2, %r12)
+        static u8 insn[] = { 0xe3, 0x22, 0xc0, 0x00, 0x00, 0x04 };
+        memcpy(loc, insn, sizeof(insn));
+      } else {
+        // nop
+        static u8 insn[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
+        memcpy(loc, insn, sizeof(insn));
       }
       break;
     case R_390_TLS_LDM32:
       if (ctx.got->has_tlsld(ctx))
         *(ub32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
+      else
+        *(ub32 *)loc = ctx.dtp_addr - ctx.tp_addr;
       break;
     case R_390_TLS_LDM64:
       if (ctx.got->has_tlsld(ctx))
         *(ub64 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
-      break;
-    case R_390_TLS_LDO32:
-      if (ctx.got->has_tlsld(ctx))
-        *(ub32 *)loc = S + A - ctx.dtp_addr;
       else
-        *(ub32 *)loc = S + A - ctx.tp_addr;
-      break;
-    case R_390_TLS_LDO64:
-      if (ctx.got->has_tlsld(ctx))
-        *(ub64 *)loc = S + A - ctx.dtp_addr;
-      else
-        *(ub64 *)loc = S + A - ctx.tp_addr;
+        *(ub64 *)loc = ctx.dtp_addr - ctx.tp_addr;
       break;
     case R_390_TLS_LDCALL:
       if (!ctx.got->has_tlsld(ctx)) {
-        static u8 nop[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
-        memcpy(loc, nop, sizeof(nop));
+        // nop
+        static u8 insn[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
+        memcpy(loc, insn, sizeof(insn));
       }
       break;
+    case R_390_TLS_LDO32:
+      *(ub32 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_390_TLS_LDO64:
+      *(ub64 *)loc = S + A - ctx.dtp_addr;
+      break;
     default:
       unreachable();
     }
@@ -366,17 +331,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     auto check = [&](i64 val, i64 lo, i64 hi) {
       if (val < lo || hi <= val)
         Error(ctx) << *this << ": relocation " << rel << " against "
@@ -392,12 +352,10 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
     u64 A = frag ? frag_addend : (i64)rel.r_addend;
 
     switch (rel.r_type) {
-    case R_390_32: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 32);
-      *(ub32 *)loc = val;
+    case R_390_32:
+      check(S + A, 0, 1LL << 32);
+      *(ub32 *)loc = S + A;
       break;
-    }
     case R_390_64:
       if (std::optional<u64> val = get_tombstone(sym, frag))
         *(ub64 *)loc = *val;
@@ -419,30 +377,20 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
     switch (rel.r_type) {
-    case R_390_64:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_390_8:
     case R_390_12:
     case R_390_16:
@@ -473,7 +421,7 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_390_GOTPC:
     case R_390_GOTPCDBL:
     case R_390_GOTENT:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_390_PLT12DBL:
     case R_390_PLT16DBL:
@@ -485,57 +433,47 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_390_PLTOFF32:
     case R_390_PLTOFF64:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_390_TLS_GOTIE20:
     case R_390_TLS_IEENT:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
     case R_390_TLS_GD32:
     case R_390_TLS_GD64:
-      if (!relax_tlsgd(ctx, sym))
-        sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      // We always want to relax calls to __tls_get_offset() in statically-
+      // linked executables because __tls_get_offset() in libc.a just calls
+      // abort().
+      if (ctx.arg.static_ || (ctx.arg.relax && sym.is_tprel_linktime_const(ctx))) {
+        // Do nothing
+      } else if (ctx.arg.relax && sym.is_tprel_runtime_const(ctx)) {
+        sym.flags |= NEEDS_GOTTP;
+      } else {
+        sym.flags |= NEEDS_TLSGD;
+      }
       break;
     case R_390_TLS_LDM32:
     case R_390_TLS_LDM64:
-      if (!relax_tlsld(ctx))
-        ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      if (ctx.arg.static_ || (ctx.arg.relax && !ctx.arg.shared)) {
+        // Do nothing
+      } else {
+        ctx.needs_tlsld = true;
+      }
       break;
     case R_390_TLS_LE32:
     case R_390_TLS_LE64:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_390_64:
     case R_390_TLS_LDO32:
     case R_390_TLS_LDO64:
     case R_390_TLS_GDCALL:
     case R_390_TLS_LDCALL:
       break;
     default:
-      Fatal(ctx) << *this << ": scan_relocations: " << rel;
+      Error(ctx) << *this << ": unknown relocation: " << rel;
     }
   }
 }
 
-// __tls_get_offset() in libc.a just calls abort(), assuming that the
-// linker always relaxes TLS calls for statically-linkd executables.
-// We don't always do that because we believe --relax and --static
-// should be orthogonal.
-//
-// This section provides a replacement for __tls_get_offset() in libc.a.
-void S390XTlsGetOffsetSection::copy_buf(Context<E> &ctx) {
-  static const u8 insn[] = {
-    0xc0, 0x10, 0, 0, 0, 0,             // larl %r1, GOT
-    0xb9, 0x08, 0x00, 0x21,             // agr  %r2, %r1
-    0xe3, 0x20, 0x20, 0x08, 0x00, 0x04, // lg   %r2, 8(%r2)
-    0xc0, 0x11, 0, 0, 0, 0,             // lgfi %r1, TLS_BLOCK_SIZE
-    0xb9, 0x09, 0x00, 0x21,             // sgr  %r2, %r1
-    0x07, 0xfe,                         // br   %r14
-  };
-
-  assert(this->shdr.sh_size == sizeof(insn));
-
-  u8 *loc = ctx.buf + this->shdr.sh_offset;
-  memcpy(loc, insn, sizeof(insn));
-  *(ub32 *)(loc + 2) = (ctx.got->shdr.sh_addr - this->shdr.sh_addr) >> 1;
-  *(ub32 *)(loc + 18) = ctx.tp_addr - ctx.tls_begin;
-}
-
-} // namespace mold::elf
+} // namespace mold

src/arch-sh4.cc

@@ -26,6 +26,13 @@
 //    small to contain large immediates. On SH-4, large immediates are
 //    loaded from memory using `mov.l` PC-relative load instruction.
 //
+//  - Many RISC ISAs are, despite their name, actually fairly complex.
+//    They tend to have hundreds if not thousands of different instructions.
+//    SH-4 doesn't really have that many instructions because its 16-bit
+//    machine code simply can't encode many different opcodes. As a
+//    result, the number of relocations the linker has to support is also
+//    small.
+//
 // Beside these, SH-4 has a delay branch slot just like contemporary MIPS
 // and SPARC. That is, one instruction after a branch instruction will
 // always be executed even if the branch is taken. Delay branch slot allows
@@ -51,11 +58,13 @@
 //    output from the linker contains lots of text relocations. That's not
 //    a problem with embedded programming, I guess.
 
+#if MOLD_SH4LE || MOLD_SH4BE
+
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
-using E = SH4;
+using E = MOLD_TARGET;
 
 // Even though SH-4 uses RELA-type relocations, addends are stored to
 // relocated places for some reason.
@@ -77,120 +86,142 @@ i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   case R_SH_GOTOFF:
   case R_SH_GOTPC:
   case R_SH_GOTPLT32:
-    return *(ul32 *)loc;
+    return *(U32<E> *)loc;
   default:
     return 0;
   }
 }
 
+template <>
+void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
+  switch (rel.r_type) {
+  case R_SH_DIR32:
+  case R_SH_REL32:
+  case R_SH_TLS_GD_32:
+  case R_SH_TLS_LD_32:
+  case R_SH_TLS_LDO_32:
+  case R_SH_TLS_IE_32:
+  case R_SH_TLS_LE_32:
+  case R_SH_TLS_DTPMOD32:
+  case R_SH_TLS_DTPOFF32:
+  case R_SH_TLS_TPOFF32:
+  case R_SH_GOT32:
+  case R_SH_PLT32:
+  case R_SH_GOTOFF:
+  case R_SH_GOTPC:
+  case R_SH_GOTPLT32:
+    *(U32<E> *)loc = val;
+  }
+}
+
 template <>
 void write_plt_header(Context<E> &ctx, u8 *buf) {
   if (ctx.arg.pic) {
-    static const u8 insn[] = {
-      0x02, 0xd2, //    mov.l   1f, r2
-      0xcc, 0x32, //    add     r12, r2
-      0x22, 0x50, //    mov.l   @(8, r2), r0
-      0x21, 0x52, //    mov.l   @(4, r2), r2
-      0x2b, 0x40, //    jmp     @r0
-      0x00, 0xe0, //    mov     #0, r0
-      0, 0, 0, 0, // 1: .long GOTPLT
+    constexpr U16<E> insn[] = {
+      0xd202, //    mov.l   1f, r2
+      0x32cc, //    add     r12, r2
+      0x5022, //    mov.l   @(8, r2), r0
+      0x5221, //    mov.l   @(4, r2), r2
+      0x402b, //    jmp     @r0
+      0xe000, //    mov     #0, r0
+      0, 0,   // 1: .long GOTPLT
     };
 
     static_assert(sizeof(insn) == E::plt_hdr_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 12) = ctx.gotplt->shdr.sh_addr - ctx.got->shdr.sh_addr;
+    *(U32<E> *)(buf + 12) = ctx.gotplt->shdr.sh_addr - ctx.got->shdr.sh_addr;
   } else {
-    static const u8 insn[] = {
-      0x02, 0xd2, //    mov.l   1f, r2
-      0x22, 0x50, //    mov.l   @(8, r2), r0
-      0x21, 0x52, //    mov.l   @(4, r2), r2
-      0x2b, 0x40, //    jmp     @r0
-      0x00, 0xe0, //    mov     #0, r0
-      0x09, 0x00, //    nop
-      0, 0, 0, 0, // 1: .long GOTPLT
+    constexpr U16<E> insn[] = {
+      0xd202, //    mov.l   1f, r2
+      0x5022, //    mov.l   @(8, r2), r0
+      0x5221, //    mov.l   @(4, r2), r2
+      0x402b, //    jmp     @r0
+      0xe000, //    mov     #0, r0
+      0x0009, //    nop
+      0, 0,   // 1: .long GOTPLT
     };
 
     static_assert(sizeof(insn) == E::plt_hdr_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 12) = ctx.gotplt->shdr.sh_addr;
+    *(U32<E> *)(buf + 12) = ctx.gotplt->shdr.sh_addr;
   }
 }
 
 template <>
 void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   if (ctx.arg.pic) {
-    static const u8 insn[] = {
-      0x01, 0xd0, //    mov.l   1f, r0
-      0xce, 0x00, //    mov.l   @(r0, r12), r0
-      0x2b, 0x40, //    jmp     @r0
-      0x01, 0xd1, //    mov.l   2f, r1
-      0, 0, 0, 0, // 1: .long GOTPLT_ENTRY
-      0, 0, 0, 0, // 2: .long INDEX_IN_RELPLT
+    constexpr U16<E> insn[] = {
+      0xd001, //    mov.l   1f, r0
+      0x00ce, //    mov.l   @(r0, r12), r0
+      0x402b, //    jmp     @r0
+      0xd101, //    mov.l   2f, r1
+      0, 0,   // 1: .long GOTPLT_ENTRY
+      0, 0,   // 2: .long INDEX_IN_RELPLT
     };
 
     static_assert(sizeof(insn) == E::plt_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 8) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
-    *(ul32 *)(buf + 12) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
+    *(U32<E> *)(buf + 8) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
+    *(U32<E> *)(buf + 12) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
   } else {
-    static const u8 insn[] = {
-      0x01, 0xd0, //    mov.l   1f, r0
-      0x02, 0x60, //    mov.l   @r0, r0
-      0x2b, 0x40, //    jmp     @r0
-      0x01, 0xd1, //    mov.l   2f, r1
-      0, 0, 0, 0, // 1: .long GOTPLT_ENTRY
-      0, 0, 0, 0, // 2: .long INDEX_IN_RELPLT
+    constexpr U16<E> insn[] = {
+      0xd001, //    mov.l   1f, r0
+      0x6002, //    mov.l   @r0, r0
+      0x402b, //    jmp     @r0
+      0xd101, //    mov.l   2f, r1
+      0, 0,   // 1: .long GOTPLT_ENTRY
+      0, 0,   // 2: .long INDEX_IN_RELPLT
     };
 
     static_assert(sizeof(insn) == E::plt_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 8) = sym.get_gotplt_addr(ctx);
-    *(ul32 *)(buf + 12) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
+    *(U32<E> *)(buf + 8) = sym.get_gotplt_addr(ctx);
+    *(U32<E> *)(buf + 12) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
   }
 }
 
 template <>
 void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   if (ctx.arg.pic) {
-    static const u8 insn[] = {
-      0x01, 0xd0, //    mov.l   1f, r0
-      0xce, 0x00, //    mov.l   @(r0, r12), r0
-      0x2b, 0x40, //    jmp     @r0
-      0x09, 0x00, //    nop
-      0, 0, 0, 0, // 1: .long GOT_ENTRY
+    constexpr U16<E> insn[] = {
+      0xd001, //    mov.l   1f, r0
+      0x00ce, //    mov.l   @(r0, r12), r0
+      0x402b, //    jmp     @r0
+      0x0009, //    nop
+      0, 0,   // 1: .long GOT_ENTRY
     };
 
     static_assert(sizeof(insn) == E::pltgot_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 8) = sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr;
+    *(U32<E> *)(buf + 8) = sym.get_got_pltgot_addr(ctx) - ctx.got->shdr.sh_addr;
   } else {
-    static const u8 insn[] = {
-      0x01, 0xd0, //    mov.l   1f, r0
-      0x02, 0x60, //    mov.l   @r0, r0
-      0x2b, 0x40, //    jmp     @r0
-      0x09, 0x00, //    nop
-      0, 0, 0, 0, // 1: .long GOT_ENTRY
+    constexpr U16<E> insn[] = {
+      0xd001, //    mov.l   1f, r0
+      0x6002, //    mov.l   @r0, r0
+      0x402b, //    jmp     @r0
+      0x0009, //    nop
+      0, 0,   // 1: .long GOT_ENTRY
     };
 
     static_assert(sizeof(insn) == E::pltgot_size);
     memcpy(buf, insn, sizeof(insn));
-    *(ul32 *)(buf + 8) = sym.get_got_addr(ctx);
+    *(U32<E> *)(buf + 8) = sym.get_got_pltgot_addr(ctx);
   }
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
   case R_NONE:
     break;
   case R_SH_DIR32:
-    *(ul32 *)loc = val;
+    *(U32<E> *)loc = val;
     break;
   case R_SH_REL32:
-    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    *(U32<E> *)loc = val - this->shdr.sh_addr - offset;
     break;
   default:
     Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
@@ -201,11 +232,6 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -222,35 +248,34 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
 
     switch (rel.r_type) {
     case R_SH_DIR32:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
       break;
     case R_SH_REL32:
     case R_SH_PLT32:
-      *(ul32 *)loc = S + A - P;
+      *(U32<E> *)loc = S + A - P;
       break;
     case R_SH_GOT32:
-      *(ul32 *)loc = G;
+      *(U32<E> *)loc = G;
       break;
     case R_SH_GOTPC:
-      *(ul32 *)loc = GOT + A - P;
+      *(U32<E> *)loc = GOT + A - P;
       break;
     case R_SH_GOTOFF:
-      *(ul32 *)loc = S + A - GOT;
+      *(U32<E> *)loc = S + A - GOT;
       break;
     case R_SH_TLS_GD_32:
-      *(ul32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
+      *(U32<E> *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
       break;
     case R_SH_TLS_LD_32:
-      *(ul32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
+      *(U32<E> *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
       break;
     case R_SH_TLS_LDO_32:
-      *(ul32 *)loc = S + A - ctx.dtp_addr;
+      *(U32<E> *)loc = S + A - ctx.dtp_addr;
       break;
     case R_SH_TLS_IE_32:
-      *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
+      *(U32<E> *)loc = sym.get_gottp_addr(ctx) + A - GOT;
       break;
     case R_SH_TLS_LE_32:
-      *(ul32 *)loc = S + A - ctx.tp_addr;
+      *(U32<E> *)loc = S + A - ctx.tp_addr;
       break;
     default:
       unreachable();
@@ -264,17 +289,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     SectionFragment<E> *frag;
     i64 frag_addend;
     std::tie(frag, frag_addend) = get_fragment(ctx, rel);
@@ -285,9 +305,9 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
     switch (rel.r_type) {
     case R_SH_DIR32:
       if (std::optional<u64> val = get_tombstone(sym, frag))
-        *(ul32 *)loc = *val;
+        *(U32<E> *)loc = *val;
       else
-        *(ul32 *)loc = S + A;
+        *(U32<E> *)loc = S + A;
       break;
     default:
       Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
@@ -299,52 +319,45 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
       Error(ctx) << sym << ": GNU ifunc symbol is not supported on sh4";
 
     switch (rel.r_type) {
-    case R_SH_DIR32:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_SH_REL32:
       scan_pcrel(ctx, sym, rel);
       break;
     case R_SH_GOT32:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_SH_PLT32:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_SH_TLS_GD_32:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      sym.flags |= NEEDS_TLSGD;
       break;
     case R_SH_TLS_LD_32:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      ctx.needs_tlsld = true;
       break;
     case R_SH_TLS_IE_32:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
+    case R_SH_TLS_LE_32:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_SH_DIR32:
     case R_SH_GOTPC:
     case R_SH_GOTOFF:
     case R_SH_TLS_LDO_32:
-    case R_SH_TLS_LE_32:
       break;
     default:
       Fatal(ctx) << *this << ": unknown relocation: " << rel;
@@ -352,4 +365,6 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
   }
 }
 
-} // namespace mold::elf
+} // namespace mold
+
+#endif

src/arch-sparc64.cc

@@ -54,12 +54,11 @@
 // This scheme is very similar to i386. That may not be a coincidence
 // because the i386 ELF psABI is created by Sun Microsystems too.
 //
-// https://docs.oracle.com/cd/E36784_01/html/E36857/chapter6-62988.html
-// https://docs.oracle.com/cd/E19120-01/open.solaris/819-0690/chapter8-40/index.html
+// https://github.com/rui314/psabi/blob/main/sparc.pdf
 
 #include "mold.h"
 
-namespace mold::elf {
+namespace mold {
 
 using E = SPARC64;
 
@@ -116,12 +115,12 @@ void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   };
 
   memcpy(buf, entry, sizeof(entry));
-  *(ub64 *)(buf + 24) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 4;
+  *(ub64 *)(buf + 24) = sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx) - 4;
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
   u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
 
   switch (rel.r_type) {
@@ -143,11 +142,6 @@ template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
-  ElfRel<E> *dynrel = nullptr;
-  if (ctx.reldyn)
-    dynrel = (ElfRel<E> *)(ctx.buf + ctx.reldyn->shdr.sh_offset +
-                           file.reldyn_offset + this->reldyn_offset);
-
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
     if (rel.r_type == R_NONE)
@@ -170,100 +164,71 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     u64 GOT = ctx.got->shdr.sh_addr;
 
     switch (rel.r_type) {
-    case R_SPARC_64:
-      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
+    case R_SPARC_5:
+      check(S + A, 0, 1 << 5);
+      *(ub32 *)loc |= bits(S + A, 4, 0);
       break;
-    case R_SPARC_5: {
-      i64 val = S + A;
-      check(val, 0, 1 << 5);
-      *(ub32 *)loc |= bits(val, 4, 0);
+    case R_SPARC_6:
+      check(S + A, 0, 1 << 6);
+      *(ub32 *)loc |= bits(S + A, 5, 0);
       break;
-    }
-    case R_SPARC_6: {
-      i64 val = S + A;
-      check(val, 0, 1 << 6);
-      *(ub32 *)loc |= bits(val, 5, 0);
+    case R_SPARC_7:
+      check(S + A, 0, 1 << 7);
+      *(ub32 *)loc |= bits(S + A, 6, 0);
       break;
-    }
-    case R_SPARC_7: {
-      i64 val = S + A;
-      check(val, 0, 1 << 7);
-      *(ub32 *)loc |= bits(val, 6, 0);
+    case R_SPARC_8:
+      check(S + A, 0, 1 << 8);
+      *(u8 *)loc = S + A;
       break;
-    }
-    case R_SPARC_8: {
-      i64 val = S + A;
-      check(val, 0, 1 << 8);
-      *(u8 *)loc = val;
+    case R_SPARC_10:
+      check(S + A, 0, 1 << 10);
+      *(ub32 *)loc |= bits(S + A, 9, 0);
       break;
-    }
-    case R_SPARC_10: {
-      i64 val = S + A;
-      check(val, 0, 1 << 10);
-      *(ub32 *)loc |= bits(val, 9, 0);
-      break;
-    }
     case R_SPARC_LO10:
     case R_SPARC_LOPLT10:
       *(ub32 *)loc |= bits(S + A, 9, 0);
       break;
-    case R_SPARC_11: {
-      i64 val = S + A;
-      check(val, 0, 1 << 11);
-      *(ub32 *)loc |= bits(val, 10, 0);
+    case R_SPARC_11:
+      check(S + A, 0, 1 << 11);
+      *(ub32 *)loc |= bits(S + A, 10, 0);
       break;
-    }
-    case R_SPARC_13: {
-      i64 val = S + A;
-      check(val, 0, 1 << 13);
-      *(ub32 *)loc |= bits(val, 12, 0);
+    case R_SPARC_13:
+      check(S + A, 0, 1 << 13);
+      *(ub32 *)loc |= bits(S + A, 12, 0);
       break;
-    }
     case R_SPARC_16:
-    case R_SPARC_UA16: {
-      i64 val = S + A;
-      check(val, 0, 1 << 16);
-      *(ub16 *)loc = val;
+    case R_SPARC_UA16:
+      check(S + A, 0, 1 << 16);
+      *(ub16 *)loc = S + A;
       break;
-    }
-    case R_SPARC_22: {
-      i64 val = S + A;
-      check(val, 0, 1 << 22);
-      *(ub32 *)loc |= bits(val, 21, 0);
+    case R_SPARC_22:
+      check(S + A, 0, 1 << 22);
+      *(ub32 *)loc |= bits(S + A, 21, 0);
       break;
-    }
     case R_SPARC_32:
     case R_SPARC_UA32:
-    case R_SPARC_PLT32: {
-      i64 val = S + A;
-      check(val, 0, 1LL << 32);
-      *(ub32 *)loc = val;
+    case R_SPARC_PLT32:
+      check(S + A, 0, 1LL << 32);
+      *(ub32 *)loc = S + A;
       break;
-    }
     case R_SPARC_PLT64:
     case R_SPARC_UA64:
     case R_SPARC_REGISTER:
       *(ub64 *)loc = S + A;
       break;
-    case R_SPARC_DISP8: {
-      i64 val = S + A - P;
-      check(val, -(1 << 7), 1 << 7);
-      *(u8 *)loc = val;
+    case R_SPARC_DISP8:
+      check(S + A - P, -(1 << 7), 1 << 7);
+      *(u8 *)loc = S + A - P;
       break;
-    }
-    case R_SPARC_DISP16: {
-      i64 val = S + A - P;
-      check(val, -(1 << 15), 1 << 15);
-      *(ub16 *)loc = val;
+    case R_SPARC_DISP16:
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = S + A - P;
       break;
-    }
     case R_SPARC_DISP32:
-    case R_SPARC_PCPLT32: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ub32 *)loc = val;
+    case R_SPARC_PCPLT32:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = S + A - P;
       break;
-    }
     case R_SPARC_DISP64:
       *(ub64 *)loc = S + A - P;
       break;
@@ -273,25 +238,19 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ub16 *)loc |= (bit(val, 16) << 21) | bits(val, 15, 2);
       break;
     }
-    case R_SPARC_WDISP19: {
-      i64 val = S + A - P;
-      check(val, -(1 << 20), 1 << 20);
-      *(ub32 *)loc |= bits(val, 20, 2);
+    case R_SPARC_WDISP19:
+      check(S + A - P, -(1 << 20), 1 << 20);
+      *(ub32 *)loc |= bits(S + A - P, 20, 2);
       break;
-    }
-    case R_SPARC_WDISP22: {
-      i64 val = S + A - P;
-      check(val, -(1 << 23), 1 << 23);
-      *(ub32 *)loc |= bits(val, 23, 2);
+    case R_SPARC_WDISP22:
+      check(S + A - P, -(1 << 23), 1 << 23);
+      *(ub32 *)loc |= bits(S + A - P, 23, 2);
       break;
-    }
     case R_SPARC_WDISP30:
-    case R_SPARC_WPLT30: {
-      i64 val = S + A - P;
-      check(val, -(1LL << 31), 1LL << 31);
-      *(ub32 *)loc |= bits(val, 31, 2);
+    case R_SPARC_WPLT30:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc |= bits(S + A - P, 31, 2);
       break;
-    }
     case R_SPARC_HI22:
     case R_SPARC_HIPLT22:
     case R_SPARC_LM22:
@@ -321,36 +280,32 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       // We always have to relax a GOT load to a load immediate if a
       // symbol is local, because R_SPARC_GOTDATA_OP cannot represent
       // an addend for a local symbol.
-      if (sym.is_imported || sym.is_ifunc()) {
+      if (sym.is_absolute()) {
+        i64 val = S + A;
+        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
+      } else if (sym.is_pcrel_linktime_const(ctx)) {
+        i64 val = S + A - GOT;
+        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
+      } else {
         *(ub32 *)loc |= bits(G, 31, 10);
-      } else if (sym.is_absolute()) {
-        i64 val = S + A;
-        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
-      } else {
-        i64 val = S + A - GOT;
-        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
       }
       break;
-    case R_SPARC_GOTDATA_OP_LOX10: {
-      if (sym.is_imported || sym.is_ifunc()) {
+    case R_SPARC_GOTDATA_OP_LOX10:
+      if (sym.is_absolute()) {
+        i64 val = S + A;
+        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
+      } else if (sym.is_pcrel_linktime_const(ctx)) {
+        i64 val = S + A - GOT;
+        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
+      } else {
         *(ub32 *)loc |= bits(G, 9, 0);
-      } else if (sym.is_absolute()) {
-        i64 val = S + A;
-        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
-      } else {
-        i64 val = S + A - GOT;
-        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
       }
       break;
-    }
     case R_SPARC_GOTDATA_OP:
-      if (sym.is_imported || sym.is_ifunc())
-        break;
-
       if (sym.is_absolute()) {
         // ldx [ %g2 + %g1 ], %g1  →  nop
         *(ub32 *)loc = 0x0100'0000;
-      } else {
+      } else if (sym.is_pcrel_linktime_const(ctx)) {
         // ldx [ %g2 + %g1 ], %g1  →  add %g2, %g1, %g1
         *(ub32 *)loc &= 0b00'11111'000000'11111'1'11111111'11111;
         *(ub32 *)loc |= 0b10'00000'000000'00000'0'00000000'00000;
@@ -396,23 +351,75 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
       *(ub32 *)loc |= bits(S + A, 11, 0);
       break;
     case R_SPARC_TLS_GD_HI22:
-      *(ub32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A - GOT, 31, 10);
+      if (sym.has_tlsgd(ctx)) {
+        *(ub32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A - GOT, 31, 10);
+      } else if (sym.has_gottp(ctx)) {
+        *(ub32 *)loc |= bits(sym.get_gottp_addr(ctx) + A - GOT, 31, 10);
+      } else {
+        *(ub32 *)loc |= bits(~(S + A - ctx.tp_addr), 31, 10);
+      }
       break;
     case R_SPARC_TLS_GD_LO10:
-      *(ub32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A - GOT, 9, 0);
+      if (sym.has_tlsgd(ctx)) {
+        *(ub32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A - GOT, 9, 0);
+      } else if (sym.has_gottp(ctx)) {
+        u32 rd = bits(*(ub32 *)loc, 29, 25);
+        *(ub32 *)loc = 0x8010'2000 | (rd << 25) | (rd << 14); // or  %reg, $0, %reg
+        *(ub32 *)loc |= bits(sym.get_gottp_addr(ctx) + A - GOT, 9, 0);
+      } else {
+        u32 rd = bits(*(ub32 *)loc, 29, 25);
+        *(ub32 *)loc = 0x8018'2000 | (rd << 25) | (rd << 14); // xor %reg, $0, %reg
+        *(ub32 *)loc |= bits(S + A - ctx.tp_addr, 9, 0) | 0b1'1100'0000'0000;
+      }
+      break;
+    case R_SPARC_TLS_GD_ADD:
+      if (sym.has_tlsgd(ctx)) {
+        // do nothing
+      } else if (sym.has_gottp(ctx)) {
+        u32 rs2 = bits(*(ub32 *)loc, 4, 0);
+        *(ub32 *)loc = 0xd05d'c000 | rs2; // ldx [ %l7 + %reg ], %o0
+      } else {
+        u32 rs2 = bits(*(ub32 *)loc, 4, 0);
+        *(ub32 *)loc = 0x9001'c000 | rs2; // add %g7, %reg, %o0
+      }
       break;
     case R_SPARC_TLS_GD_CALL:
-    case R_SPARC_TLS_LDM_CALL:
-      if (ctx.arg.is_static)
-        *(ub32 *)loc |= bits(ctx.extra.tls_get_addr->shdr.sh_addr + A - P, 31, 2);
-      else
-        *(ub32 *)loc |= bits(ctx.tls_get_addr->get_addr(ctx) + A - P, 31, 2);
+      if (sym.has_tlsgd(ctx)) {
+        u64 addr = ctx.extra.tls_get_addr->get_addr(ctx);
+        *(ub32 *)loc |= bits(addr + A - P, 31, 2);
+      } else if (sym.has_gottp(ctx)) {
+        *(ub32 *)loc = 0x9001'c008; // add %g7, %o0, %o0
+      } else {
+        *(ub32 *)loc = 0x0100'0000; // nop
+      }
       break;
     case R_SPARC_TLS_LDM_HI22:
-      *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 31, 10);
+      if (ctx.got->has_tlsld(ctx))
+        *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 31, 10);
+      else
+        *(ub32 *)loc |= bits(ctx.tp_addr - ctx.tls_begin, 31, 10);
       break;
     case R_SPARC_TLS_LDM_LO10:
-      *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 9, 0);
+      if (ctx.got->has_tlsld(ctx))
+        *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 9, 0);
+      else
+        *(ub32 *)loc |= bits(ctx.tp_addr - ctx.tls_begin, 9, 0);
+      break;
+    case R_SPARC_TLS_LDM_ADD:
+      if (ctx.got->has_tlsld(ctx)) {
+        // do nothing
+      } else {
+        u32 rs2 = bits(*(ub32 *)loc, 4, 0);
+        *(ub32 *)loc = 0x9021'c000 | rs2; // sub %g7, %reg, %o0
+      }
+      break;
+    case R_SPARC_TLS_LDM_CALL:
+      if (ctx.got->has_tlsld(ctx)) {
+        u64 addr = ctx.extra.tls_get_addr->get_addr(ctx);
+        *(ub32 *)loc |= bits(addr + A - P, 31, 2);
+      } else {
+        *(ub32 *)loc = 0x0100'0000; // nop
+      }
       break;
     case R_SPARC_TLS_LDO_HIX22:
       *(ub32 *)loc |= bits(S + A - ctx.dtp_addr, 31, 10);
@@ -435,8 +442,7 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
     case R_SPARC_SIZE32:
       *(ub32 *)loc = sym.esym().st_size + A;
       break;
-    case R_SPARC_TLS_GD_ADD:
-    case R_SPARC_TLS_LDM_ADD:
+    case R_SPARC_64:
     case R_SPARC_TLS_LDO_ADD:
     case R_SPARC_TLS_IE_LD:
     case R_SPARC_TLS_IE_LDX:
@@ -454,17 +460,12 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     auto check = [&](i64 val, i64 lo, i64 hi) {
       if (val < lo || hi <= val)
         Error(ctx) << *this << ": relocation " << rel << " against "
@@ -509,30 +510,20 @@ void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
 template <>
 void InputSection<E>::scan_relocations(Context<E> &ctx) {
   assert(shdr().sh_flags & SHF_ALLOC);
-
-  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
   std::span<const ElfRel<E>> rels = get_rels(ctx);
 
   // Scan relocations
   for (i64 i = 0; i < rels.size(); i++) {
     const ElfRel<E> &rel = rels[i];
-    if (rel.r_type == R_NONE)
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
 
-    if (!sym.file) {
-      record_undef_error(ctx, rel);
-      continue;
-    }
-
     if (sym.is_ifunc())
-      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
     switch (rel.r_type) {
-    case R_SPARC_64:
-      scan_dyn_absrel(ctx, sym, rel);
-      break;
     case R_SPARC_8:
     case R_SPARC_5:
     case R_SPARC_6:
@@ -571,17 +562,17 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_SPARC_PCPLT10:
     case R_SPARC_PLT64:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_PLT;
       break;
     case R_SPARC_GOT13:
     case R_SPARC_GOT10:
     case R_SPARC_GOT22:
     case R_SPARC_GOTDATA_HIX22:
-      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOT;
       break;
     case R_SPARC_GOTDATA_OP_HIX22:
       if (sym.is_imported)
-        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+        sym.flags |= NEEDS_GOT;
       break;
     case R_SPARC_DISP16:
     case R_SPARC_DISP32:
@@ -597,19 +588,36 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
       scan_pcrel(ctx, sym, rel);
       break;
     case R_SPARC_TLS_GD_HI22:
-      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      if (ctx.arg.static_ || (ctx.arg.relax && sym.is_tprel_linktime_const(ctx))) {
+        // We always relax if -static because libc.a doesn't contain
+        // __tls_get_addr().
+      } else if (ctx.arg.relax && sym.is_tprel_runtime_const(ctx)) {
+        sym.flags |= NEEDS_GOTTP;
+      } else {
+        sym.flags |= NEEDS_TLSGD;
+      }
       break;
     case R_SPARC_TLS_LDM_HI22:
-      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      if (ctx.arg.static_ || (ctx.arg.relax && !ctx.arg.shared)) {
+        // We always relax if -static because libc.a doesn't contain
+        // __tls_get_addr().
+      } else {
+        ctx.needs_tlsld = true;
+      }
       break;
     case R_SPARC_TLS_IE_HI22:
-      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      sym.flags |= NEEDS_GOTTP;
       break;
     case R_SPARC_TLS_GD_CALL:
     case R_SPARC_TLS_LDM_CALL:
-      if (!ctx.arg.is_static && ctx.tls_get_addr->is_imported)
-        ctx.tls_get_addr->flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      if (Symbol<E> *sym = ctx.extra.tls_get_addr; sym->is_imported)
+        sym->flags |= NEEDS_PLT;
       break;
+    case R_SPARC_TLS_LE_HIX22:
+    case R_SPARC_TLS_LE_LOX10:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_SPARC_64:
     case R_SPARC_GOTDATA_OP_LOX10:
     case R_SPARC_GOTDATA_OP:
     case R_SPARC_GOTDATA_LOX10:
@@ -624,35 +632,12 @@ void InputSection<E>::scan_relocations(Context<E> &ctx) {
     case R_SPARC_TLS_IE_LD:
     case R_SPARC_TLS_IE_LDX:
     case R_SPARC_TLS_IE_LO10:
-    case R_SPARC_TLS_LE_HIX22:
-    case R_SPARC_TLS_LE_LOX10:
     case R_SPARC_SIZE32:
       break;
     default:
-      Fatal(ctx) << *this << ": scan_relocations: " << rel;
+      Error(ctx) << *this << ": unknown relocation: " << rel;
     }
   }
 }
 
-// __tls_get_addr is not defined by libc.a, so we can't use that function
-// in statically-linked executables. This section provides a replacement.
-void SparcTlsGetAddrSection::copy_buf(Context<E> &ctx) {
-  ub32 *buf = (ub32 *)(ctx.buf + this->shdr.sh_offset);
-
-  static const ub32 insn[] = {
-    0x0300'0000, // sethi  %hi(TP_SIZE), %g1
-    0x8210'6000, // or   %g1, %lo(TP_SIZE), %g1
-    0x8221'c001, // sub  %g7, %g1, %g1
-    0xd05a'2008, // ldx  [ %o0 + 8 ], %o0
-    0x81c3'e008, // retl
-    0x9000'4008, // add  %g1, %o0, %o0
-  };
-
-  assert(this->shdr.sh_size == sizeof(insn));
-  memcpy(buf, insn, sizeof(insn));
-
-  buf[0] |= bits(ctx.tp_addr - ctx.tls_begin, 31, 10);
-  buf[1] |= bits(ctx.tp_addr - ctx.tls_begin, 9, 0);
-}
-
-} // namespace mold::elf
+} // namespace mold

src/arch-x86-64.cc

@@ -0,0 +1,901 @@
+// Supporting x86-64 is straightforward. Unlike its predecessor, i386,
+// x86-64 supports PC-relative addressing for position-independent code.
+// Being CISC, its instructions are variable in size. Branch instructions
+// take 4 bytes offsets, so we don't need range extension thunks.
+//
+// The psABI specifies %r11 as neither caller- nor callee-saved. It's
+// intentionally left out so that we can use it as a scratch register in
+// PLT.
+//
+// Thread Pointer (TP) is stored not to a general-purpose register but to
+// FS segment register. Segment register is a 64-bits register which can
+// be used as a base address for memory access. Each thread has a unique
+// FS value, and they access their thread-local variables relative to FS
+// as %fs:offset_from_tp.
+//
+// The value of a segment register itself is not generally readable from
+// the user space. As a workaround, libc initializes %fs:0 (the first word
+// referenced by FS) to the value of %fs itself. So we can obtain TP just
+// by `mov %fs:0, %rax` if we need it.
+//
+// For historical reasons, TP points past the end of the TLS block on x86.
+// This is contrary to other psABIs which usually use the beginning of the
+// TLS block as TP (with some addend). As a result, offsets from TP to
+// thread-local variables (TLVs) in the main executable are all negative.
+//
+// https://github.com/rui314/psabi/blob/main/x86-64.pdf
+// https://github.com/rui314/psabi/blob/main/i386.pdf
+
+#include "mold.h"
+
+#include <tbb/parallel_for_each.h>
+
+namespace mold {
+
+using E = X86_64;
+
+// This is a security-enhanced version of the regular PLT. The PLT
+// header and each PLT entry starts with endbr64 for the Intel's
+// control-flow enforcement security mechanism.
+//
+// Note that our IBT-enabled PLT instruction sequence is different
+// from the one used in GNU ld. GNU's IBTPLT implementation uses two
+// separate sections (.plt and .plt.sec) in which one PLT entry takes
+// 32 bytes in total. Our IBTPLT consists of just .plt and each entry
+// is 16 bytes long.
+//
+// Our PLT entry clobbers %r11, but that's fine because the resolver
+// function (_dl_runtime_resolve) clobbers %r11 anyway.
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  static const u8 insn[] = {
+    0xf3, 0x0f, 0x1e, 0xfa, // endbr64
+    0x41, 0x53,             // push %r11
+    0xff, 0x35, 0, 0, 0, 0, // push GOTPLT+8(%rip)
+    0xff, 0x25, 0, 0, 0, 0, // jmp *GOTPLT+16(%rip)
+    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
+    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
+    0xcc, 0xcc, 0xcc, 0xcc, // (padding)
+    0xcc, 0xcc,             // (padding)
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ul32 *)(buf + 8) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 4;
+  *(ul32 *)(buf + 14) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 2;
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  // Only a canonical PLT can be address-taken; there's no way to take
+  // an address of a non-canonical PLT. Therefore, a non-canonical PLT
+  // doesn't have to start with an endbr64.
+  if (sym.is_canonical) {
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfa, // endbr64
+      0x41, 0xbb, 0, 0, 0, 0, // mov $index_in_relplt, %r11d
+      0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOTPLT
+    };
+
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = sym.get_plt_idx(ctx);
+    *(ul32 *)(buf + 12) = sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx) - 16;
+  } else {
+    static const u8 insn[] = {
+      0x41, 0xbb, 0, 0, 0, 0, // mov $index_in_relplt, %r11d
+      0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOTPLT
+      0xcc, 0xcc, 0xcc, 0xcc, // (padding)
+    };
+
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 2) = sym.get_plt_idx(ctx);
+    *(ul32 *)(buf + 8) = sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx) - 12;
+  }
+}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static const u8 insn[] = {
+    0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOT
+    0xcc, 0xcc,             // (padding)
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ul32 *)(buf + 2) = sym.get_got_pltgot_addr(ctx) - sym.get_plt_addr(ctx) - 6;
+}
+
+template <>
+void EhFrameSection<E>::apply_eh_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                       u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_X86_64_32:
+    *(ul32 *)loc = val;
+    break;
+  case R_X86_64_64:
+    *(ul64 *)loc = val;
+    break;
+  case R_X86_64_PC32:
+    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_X86_64_PC64:
+    *(ul64 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  default:
+    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
+  }
+}
+
+static u32 relax_gotpcrelx(u8 *loc) {
+  switch ((loc[0] << 8) | loc[1]) {
+  case 0xff15: return 0x90e8; // call *0(%rip) -> call 0
+  case 0xff25: return 0x90e9; // jmp  *0(%rip) -> jmp  0
+  }
+  return 0;
+}
+
+static u32 relax_rex_gotpcrelx(u8 *loc) {
+  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
+  case 0x488b05: return 0x488d05; // mov 0(%rip), %rax -> lea 0(%rip), %rax
+  case 0x488b0d: return 0x488d0d; // mov 0(%rip), %rcx -> lea 0(%rip), %rcx
+  case 0x488b15: return 0x488d15; // mov 0(%rip), %rdx -> lea 0(%rip), %rdx
+  case 0x488b1d: return 0x488d1d; // mov 0(%rip), %rbx -> lea 0(%rip), %rbx
+  case 0x488b25: return 0x488d25; // mov 0(%rip), %rsp -> lea 0(%rip), %rsp
+  case 0x488b2d: return 0x488d2d; // mov 0(%rip), %rbp -> lea 0(%rip), %rbp
+  case 0x488b35: return 0x488d35; // mov 0(%rip), %rsi -> lea 0(%rip), %rsi
+  case 0x488b3d: return 0x488d3d; // mov 0(%rip), %rdi -> lea 0(%rip), %rdi
+  case 0x4c8b05: return 0x4c8d05; // mov 0(%rip), %r8  -> lea 0(%rip), %r8
+  case 0x4c8b0d: return 0x4c8d0d; // mov 0(%rip), %r9  -> lea 0(%rip), %r9
+  case 0x4c8b15: return 0x4c8d15; // mov 0(%rip), %r10 -> lea 0(%rip), %r10
+  case 0x4c8b1d: return 0x4c8d1d; // mov 0(%rip), %r11 -> lea 0(%rip), %r11
+  case 0x4c8b25: return 0x4c8d25; // mov 0(%rip), %r12 -> lea 0(%rip), %r12
+  case 0x4c8b2d: return 0x4c8d2d; // mov 0(%rip), %r13 -> lea 0(%rip), %r13
+  case 0x4c8b35: return 0x4c8d35; // mov 0(%rip), %r14 -> lea 0(%rip), %r14
+  case 0x4c8b3d: return 0x4c8d3d; // mov 0(%rip), %r15 -> lea 0(%rip), %r15
+  }
+  return 0;
+}
+
+static u32 relax_gottpoff(u8 *loc) {
+  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
+  case 0x488b05: return 0x48c7c0; // mov 0(%rip), %rax -> mov $0, %rax
+  case 0x488b0d: return 0x48c7c1; // mov 0(%rip), %rcx -> mov $0, %rcx
+  case 0x488b15: return 0x48c7c2; // mov 0(%rip), %rdx -> mov $0, %rdx
+  case 0x488b1d: return 0x48c7c3; // mov 0(%rip), %rbx -> mov $0, %rbx
+  case 0x488b25: return 0x48c7c4; // mov 0(%rip), %rsp -> mov $0, %rsp
+  case 0x488b2d: return 0x48c7c5; // mov 0(%rip), %rbp -> mov $0, %rbp
+  case 0x488b35: return 0x48c7c6; // mov 0(%rip), %rsi -> mov $0, %rsi
+  case 0x488b3d: return 0x48c7c7; // mov 0(%rip), %rdi -> mov $0, %rdi
+  case 0x4c8b05: return 0x49c7c0; // mov 0(%rip), %r8  -> mov $0, %r8
+  case 0x4c8b0d: return 0x49c7c1; // mov 0(%rip), %r9  -> mov $0, %r9
+  case 0x4c8b15: return 0x49c7c2; // mov 0(%rip), %r10 -> mov $0, %r10
+  case 0x4c8b1d: return 0x49c7c3; // mov 0(%rip), %r11 -> mov $0, %r11
+  case 0x4c8b25: return 0x49c7c4; // mov 0(%rip), %r12 -> mov $0, %r12
+  case 0x4c8b2d: return 0x49c7c5; // mov 0(%rip), %r13 -> mov $0, %r13
+  case 0x4c8b35: return 0x49c7c6; // mov 0(%rip), %r14 -> mov $0, %r14
+  case 0x4c8b3d: return 0x49c7c7; // mov 0(%rip), %r15 -> mov $0, %r15
+  }
+  return 0;
+}
+
+static u32 relax_tlsdesc_to_ie(u8 *loc) {
+  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
+  case 0x488d05: return 0x488b05; // lea 0(%rip), %rax -> mov 0(%rip), %rax
+  case 0x488d0d: return 0x488b0d; // lea 0(%rip), %rcx -> mov 0(%rip), %rcx
+  case 0x488d15: return 0x488b15; // lea 0(%rip), %rdx -> mov 0(%rip), %rdx
+  case 0x488d1d: return 0x488b1d; // lea 0(%rip), %rbx -> mov 0(%rip), %rbx
+  case 0x488d25: return 0x488b25; // lea 0(%rip), %rsp -> mov 0(%rip), %rsp
+  case 0x488d2d: return 0x488b2d; // lea 0(%rip), %rbp -> mov 0(%rip), %rbp
+  case 0x488d35: return 0x488b35; // lea 0(%rip), %rsi -> mov 0(%rip), %rsi
+  case 0x488d3d: return 0x488b3d; // lea 0(%rip), %rdi -> mov 0(%rip), %rdi
+  case 0x4c8d05: return 0x4c8b05; // lea 0(%rip), %r8  -> mov 0(%rip), %r8
+  case 0x4c8d0d: return 0x4c8b0d; // lea 0(%rip), %r9  -> mov 0(%rip), %r9
+  case 0x4c8d15: return 0x4c8b15; // lea 0(%rip), %r10 -> mov 0(%rip), %r10
+  case 0x4c8d1d: return 0x4c8b1d; // lea 0(%rip), %r11 -> mov 0(%rip), %r11
+  case 0x4c8d25: return 0x4c8b25; // lea 0(%rip), %r12 -> mov 0(%rip), %r12
+  case 0x4c8d2d: return 0x4c8b2d; // lea 0(%rip), %r13 -> mov 0(%rip), %r13
+  case 0x4c8d35: return 0x4c8b35; // lea 0(%rip), %r14 -> mov 0(%rip), %r14
+  case 0x4c8d3d: return 0x4c8b3d; // lea 0(%rip), %r15 -> mov 0(%rip), %r15
+  }
+  return 0;
+}
+
+static u32 relax_tlsdesc_to_le(u8 *loc) {
+  switch ((loc[0] << 16) | (loc[1] << 8) | loc[2]) {
+  case 0x488d05: return 0x48c7c0; // lea 0(%rip), %rax -> mov $0, %rax
+  case 0x488d0d: return 0x48c7c1; // lea 0(%rip), %rcx -> mov $0, %rcx
+  case 0x488d15: return 0x48c7c2; // lea 0(%rip), %rdx -> mov $0, %rdx
+  case 0x488d1d: return 0x48c7c3; // lea 0(%rip), %rbx -> mov $0, %rbx
+  case 0x488d25: return 0x48c7c4; // lea 0(%rip), %rsp -> mov $0, %rsp
+  case 0x488d2d: return 0x48c7c5; // lea 0(%rip), %rbp -> mov $0, %rbp
+  case 0x488d35: return 0x48c7c6; // lea 0(%rip), %rsi -> mov $0, %rsi
+  case 0x488d3d: return 0x48c7c7; // lea 0(%rip), %rdi -> mov $0, %rdi
+  case 0x4c8d05: return 0x49c7c0; // lea 0(%rip), %r8  -> mov $0, %r8
+  case 0x4c8d0d: return 0x49c7c1; // lea 0(%rip), %r9  -> mov $0, %r9
+  case 0x4c8d15: return 0x49c7c2; // lea 0(%rip), %r10 -> mov $0, %r10
+  case 0x4c8d1d: return 0x49c7c3; // lea 0(%rip), %r11 -> mov $0, %r11
+  case 0x4c8d25: return 0x49c7c4; // lea 0(%rip), %r12 -> mov $0, %r12
+  case 0x4c8d2d: return 0x49c7c5; // lea 0(%rip), %r13 -> mov $0, %r13
+  case 0x4c8d35: return 0x49c7c6; // lea 0(%rip), %r14 -> mov $0, %r14
+  case 0x4c8d3d: return 0x49c7c7; // lea 0(%rip), %r15 -> mov $0, %r15
+  }
+  return 0;
+}
+
+// Rewrite a function call to __tls_get_addr to a cheaper instruction
+// sequence. We can do this when we know the thread-local variable's TP-
+// relative address at link-time.
+static void relax_gd_to_le(u8 *loc, ElfRel<E> rel, u64 val) {
+  switch (rel.r_type) {
+  case R_X86_64_PLT32:
+  case R_X86_64_PC32:
+  case R_X86_64_GOTPCREL:
+  case R_X86_64_GOTPCRELX: {
+    // The original instructions are the following:
+    //
+    //  66 48 8d 3d 00 00 00 00    lea  foo@tlsgd(%rip), %rdi
+    //  66 66 48 e8 00 00 00 00    call __tls_get_addr
+    //
+    // or
+    //
+    //  66 48 8d 3d 00 00 00 00    lea foo@tlsgd(%rip), %rdi
+    //  66 48 ff 15 00 00 00 00    call *__tls_get_addr@GOT(%rip)
+    static const u8 insn[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
+      0x48, 0x81, 0xc0, 0, 0, 0, 0,             // add $tp_offset, %rax
+    };
+    memcpy(loc - 4, insn, sizeof(insn));
+    *(ul32 *)(loc + 8) = val;
+    break;
+  }
+  case R_X86_64_PLTOFF64: {
+    // The original instructions are the following:
+    //
+    //  48 8d 3d 00 00 00 00           lea    foo@tlsgd(%rip), %rdi
+    //  48 b8 00 00 00 00 00 00 00 00  movabs __tls_get_addr, %rax
+    //  48 01 d8                       add    %rbx, %rax
+    //  ff d0                          call   *%rax
+    static const u8 insn[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
+      0x48, 0x81, 0xc0, 0, 0, 0, 0,             // add $tp_offset, %rax
+      0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00,       // nop
+    };
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 9) = val;
+    break;
+  }
+  default:
+    unreachable();
+  }
+}
+
+static void relax_gd_to_ie(u8 *loc, ElfRel<E> rel, u64 val) {
+  switch (rel.r_type) {
+  case R_X86_64_PLT32:
+  case R_X86_64_PC32:
+  case R_X86_64_GOTPCREL:
+  case R_X86_64_GOTPCRELX: {
+    static const u8 insn[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
+      0x48, 0x03, 0x05, 0, 0, 0, 0,             // add foo@gottpoff(%rip), %rax
+    };
+    memcpy(loc - 4, insn, sizeof(insn));
+    *(ul32 *)(loc + 8) = val - 12;
+    break;
+  }
+  case R_X86_64_PLTOFF64: {
+    static const u8 insn[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
+      0x48, 0x03, 0x05, 0, 0, 0, 0,             // add foo@gottpoff(%rip), %rax
+      0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00,       // nop
+    };
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 9) = val - 13;
+    break;
+  }
+  default:
+    unreachable();
+  }
+}
+
+// Rewrite a function call to __tls_get_addr to a cheaper instruction
+// sequence. The difference from relax_gd_to_le is that we are materializing
+// the address of the beginning of TLS block instead of an address of a
+// particular thread-local variable.
+static void relax_ld_to_le(u8 *loc, ElfRel<E> rel, i64 tls_size) {
+  switch (rel.r_type) {
+  case R_X86_64_PLT32:
+  case R_X86_64_PC32: {
+    // The original instructions are the following:
+    //
+    //  48 8d 3d 00 00 00 00    lea    foo@tlsld(%rip), %rdi
+    //  e8 00 00 00 00          call   __tls_get_addr
+    //
+    // Because the original instruction sequence is so short that we need a
+    // little bit of code golfing here. "mov %fs:0, %rax" is 9 byte long, so
+    // xor + mov is shorter. Note that `xor %eax, %eax` zero-clears %eax.
+    static const u8 insn[] = {
+      0x31, 0xc0,                   // xor %eax, %eax
+      0x64, 0x48, 0x8b, 0x00,       // mov %fs:(%rax), %rax
+      0x48, 0x2d, 0, 0, 0, 0,       // sub $tls_size, %rax
+    };
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 5) = tls_size;
+    break;
+  }
+  case R_X86_64_GOTPCREL:
+  case R_X86_64_GOTPCRELX: {
+    // The original instructions are the following:
+    //
+    //  48 8d 3d 00 00 00 00    lea    foo@tlsld(%rip), %rdi
+    //  ff 15 00 00 00 00       call   *__tls_get_addr@GOT(%rip)
+    static const u8 insn[] = {
+      0x48, 0x31, 0xc0,             // xor %rax, %rax
+      0x64, 0x48, 0x8b, 0x00,       // mov %fs:(%rax), %rax
+      0x48, 0x2d, 0, 0, 0, 0,       // sub $tls_size, %rax
+    };
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 6) = tls_size;
+    break;
+  }
+  case R_X86_64_PLTOFF64: {
+    // The original instructions are the following:
+    //
+    //  48 8d 3d 00 00 00 00           lea    foo@tlsld(%rip), %rdi
+    //  48 b8 00 00 00 00 00 00 00 00  movabs __tls_get_addr@GOTOFF, %rax
+    //  48 01 d8                       add    %rbx, %rax
+    //  ff d0                          call   *%rax
+    static const u8 insn[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // mov %fs:0, %rax
+      0x48, 0x2d, 0, 0, 0, 0,                   // sub $tls_size, %rax
+      0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00, // nop
+    };
+    memcpy(loc - 3, insn, sizeof(insn));
+    *(ul32 *)(loc + 8) = tls_size;
+    break;
+  }
+  default:
+    unreachable();
+  }
+}
+
+// Apply relocations to SHF_ALLOC sections (i.e. sections that are
+// mapped to memory at runtime) based on the result of
+// scan_relocations().
+template <>
+void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    auto write32 = [&](u64 val) {
+      check(val, 0, 1LL << 32);
+      *(ul32 *)loc = val;
+    };
+
+    auto write32s = [&](u64 val) {
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ul32 *)loc = val;
+    };
+
+    u64 S = sym.get_addr(ctx);
+    u64 A = rel.r_addend;
+    u64 P = get_addr() + rel.r_offset;
+    u64 G = sym.get_got_addr(ctx) - ctx.gotplt->shdr.sh_addr;
+    u64 GOT = ctx.gotplt->shdr.sh_addr;
+
+    switch (rel.r_type) {
+    case R_X86_64_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
+      break;
+    case R_X86_64_16:
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
+      break;
+    case R_X86_64_32:
+      write32(S + A);
+      break;
+    case R_X86_64_32S:
+      write32s(S + A);
+      break;
+    case R_X86_64_64:
+      break;
+    case R_X86_64_PC8:
+      check(S + A - P, -(1 << 7), 1 << 7);
+      *loc = S + A - P;
+      break;
+    case R_X86_64_PC16:
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = S + A - P;
+      break;
+    case R_X86_64_PC32:
+    case R_X86_64_PLT32:
+      write32s(S + A - P);
+      break;
+    case R_X86_64_PC64:
+      *(ul64 *)loc = S + A - P;
+      break;
+    case R_X86_64_GOT32:
+      write32(G + A);
+      break;
+    case R_X86_64_GOT64:
+      *(ul64 *)loc = G + A;
+      break;
+    case R_X86_64_GOTOFF64:
+    case R_X86_64_PLTOFF64:
+      *(ul64 *)loc = S + A - GOT;
+      break;
+    case R_X86_64_GOTPC32:
+      write32s(GOT + A - P);
+      break;
+    case R_X86_64_GOTPC64:
+      *(ul64 *)loc = GOT + A - P;
+      break;
+    case R_X86_64_GOTPCREL:
+      write32s(G + GOT + A - P);
+      break;
+    case R_X86_64_GOTPCREL64:
+      *(ul64 *)loc = G + GOT + A - P;
+      break;
+    case R_X86_64_GOTPCRELX:
+      // We always want to relax GOTPCRELX relocs even if --no-relax
+      // was given because some static PIE runtime code depends on these
+      // relaxations.
+      if (sym.is_pcrel_linktime_const(ctx)) {
+        u32 insn = relax_gotpcrelx(loc - 2);
+        i64 val = S + A - P;
+        if (insn && (i32)val == val) {
+          loc[-2] = insn >> 8;
+          loc[-1] = insn;
+          *(ul32 *)loc = val;
+          break;
+        }
+      }
+      write32s(G + GOT + A - P);
+      break;
+    case R_X86_64_REX_GOTPCRELX:
+      if (sym.is_pcrel_linktime_const(ctx)) {
+        u32 insn = relax_rex_gotpcrelx(loc - 3);
+        i64 val = S + A - P;
+        if (insn && (i32)val == val) {
+          loc[-3] = insn >> 16;
+          loc[-2] = insn >> 8;
+          loc[-1] = insn;
+          *(ul32 *)loc = val;
+          break;
+        }
+      }
+      write32s(G + GOT + A - P);
+      break;
+    case R_X86_64_TLSGD:
+      if (sym.has_tlsgd(ctx))
+        write32s(sym.get_tlsgd_addr(ctx) + A - P);
+      else if (sym.has_gottp(ctx))
+        relax_gd_to_ie(loc, rels[++i], sym.get_gottp_addr(ctx) - P);
+      else
+        relax_gd_to_le(loc, rels[++i], S - ctx.tp_addr);
+      break;
+    case R_X86_64_TLSLD:
+      if (ctx.got->has_tlsld(ctx))
+        write32s(ctx.got->get_tlsld_addr(ctx) + A - P);
+      else
+        relax_ld_to_le(loc, rels[++i], ctx.tp_addr - ctx.tls_begin);
+      break;
+    case R_X86_64_DTPOFF32:
+      write32s(S + A - ctx.dtp_addr);
+      break;
+    case R_X86_64_DTPOFF64:
+      *(ul64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_X86_64_TPOFF32:
+      write32s(S + A - ctx.tp_addr);
+      break;
+    case R_X86_64_TPOFF64:
+      *(ul64 *)loc = S + A - ctx.tp_addr;
+      break;
+    case R_X86_64_GOTTPOFF:
+      if (sym.has_gottp(ctx)) {
+        write32s(sym.get_gottp_addr(ctx) + A - P);
+      } else {
+        u32 insn = relax_gottpoff(loc - 3);
+        loc[-3] = insn >> 16;
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
+        write32s(S - ctx.tp_addr);
+        assert(A == -4);
+      }
+      break;
+    case R_X86_64_GOTPC32_TLSDESC:
+      // x86-64 TLSDESC uses the following code sequence to materialize
+      // a TP-relative address in %rax.
+      //
+      //   lea    0(%rip), %rax
+      //       R_X86_64_GOTPC32_TLSDESC    foo
+      //   call   *(%rax)
+      //       R_X86_64_TLSDESC_CALL       foo
+      //
+      // We may relax the instructions to the following if its TP-relative
+      // address is known at link-time
+      //
+      //   mov     $foo@TPOFF, %rax
+      //   nop
+      //
+      // or to the following if the TP-relative address is known at
+      // process startup time.
+      //
+      //   mov     foo@GOTTPOFF(%rip), %rax
+      //   nop
+      //
+      // We allow the following alternative code sequence too because
+      // LLVM emits such code.
+      //
+      //   lea    0(%rip), %reg
+      //       R_X86_64_GOTPC32_TLSDESC    foo
+      //   mov    %reg, %rax
+      //   call   *(%rax)
+      //       R_X86_64_TLSDESC_CALL       foo
+      if (sym.has_tlsdesc(ctx)) {
+        write32s(sym.get_tlsdesc_addr(ctx) + A - P);
+      } else if (sym.has_gottp(ctx)) {
+        u32 insn = relax_tlsdesc_to_ie(loc - 3);
+        if (!insn)
+          Fatal(ctx) << *this << ": illegal instruction sequence for TLSDESC";
+        loc[-3] = insn >> 16;
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
+        write32s(sym.get_gottp_addr(ctx) + A - P);
+      } else {
+        u32 insn = relax_tlsdesc_to_le(loc - 3);
+        if (!insn)
+          Fatal(ctx) << *this << ": illegal instruction sequence for TLSDESC";
+        loc[-3] = insn >> 16;
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
+        write32s(S - ctx.tp_addr);
+      }
+      break;
+    case R_X86_64_TLSDESC_CALL:
+      if (sym.has_tlsdesc(ctx)) {
+        // Do nothing
+      } else {
+        // call *(%rax) -> nop
+        loc[0] = 0x66;
+        loc[1] = 0x90;
+      }
+      break;
+    case R_X86_64_SIZE32:
+      write32(sym.esym().st_size + A);
+      break;
+    case R_X86_64_SIZE64:
+      *(ul64 *)loc = sym.esym().st_size + A;
+      break;
+    default:
+      unreachable();
+    }
+  }
+}
+
+// This function is responsible for applying relocations against
+// non-SHF_ALLOC sections (i.e. sections that are not mapped to memory
+// at runtime).
+//
+// Relocations against non-SHF_ALLOC sections are much easier to
+// handle than that against SHF_ALLOC sections. It is because, since
+// they are not mapped to memory, they don't contain any variable or
+// function and never need PLT or GOT. Non-SHF_ALLOC sections are
+// mostly debug info sections.
+//
+// Relocations against non-SHF_ALLOC sections are not scanned by
+// scan_relocations.
+template <>
+void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    auto write32 = [&](u64 val) {
+      check(val, 0, 1LL << 32);
+      *(ul32 *)loc = val;
+    };
+
+    auto write32s = [&](u64 val) {
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ul32 *)loc = val;
+    };
+
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
+
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : (i64)rel.r_addend;
+
+    switch (rel.r_type) {
+    case R_X86_64_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
+      break;
+    case R_X86_64_16:
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
+      break;
+    case R_X86_64_32:
+      write32(S + A);
+      break;
+    case R_X86_64_32S:
+      write32s(S + A);
+      break;
+    case R_X86_64_64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul64 *)loc = *val;
+      else
+        *(ul64 *)loc = S + A;
+      break;
+    case R_X86_64_DTPOFF32:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul32 *)loc = *val;
+      else
+        write32s(S + A - ctx.dtp_addr);
+      break;
+    case R_X86_64_DTPOFF64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul64 *)loc = *val;
+      else
+        *(ul64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_X86_64_GOTOFF64:
+      *(ul64 *)loc = S + A - ctx.gotplt->shdr.sh_addr;
+      break;
+    case R_X86_64_GOTPC64:
+      // PC-relative relocation doesn't make sense for non-memory-allocated
+      // section, but GCC 6.3.0 seems to create this reloc for
+      // _GLOBAL_OFFSET_TABLE_.
+      *(ul64 *)loc = ctx.gotplt->shdr.sh_addr + A;
+      break;
+    case R_X86_64_SIZE32:
+      write32(sym.esym().st_size + A);
+      break;
+    case R_X86_64_SIZE64:
+      *(ul64 *)loc = sym.esym().st_size + A;
+      break;
+    default:
+      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
+                 << rel;
+      break;
+    }
+  }
+}
+
+// Linker has to create data structures in an output file to apply
+// some type of relocations. For example, if a relocation refers a GOT
+// or a PLT entry of a symbol, linker has to create an entry in .got
+// or in .plt for that symbol. In order to fix the file layout, we
+// need to scan relocations.
+template <>
+void InputSection<E>::scan_relocations(Context<E> &ctx) {
+  assert(shdr().sh_flags & SHF_ALLOC);
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  // Scan relocations
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = (u8 *)(contents.data() + rel.r_offset);
+
+    if (sym.is_ifunc())
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
+
+    if (rel.r_type == R_X86_64_TLSGD || rel.r_type == R_X86_64_TLSLD) {
+      if (i + 1 == rels.size())
+        Fatal(ctx) << *this << ": " << rel
+                   << " must be followed by PLT or GOTPCREL";
+
+      if (u32 ty = rels[i + 1].r_type;
+          ty != R_X86_64_PLT32 && ty != R_X86_64_PC32 &&
+          ty != R_X86_64_PLTOFF64 && ty != R_X86_64_GOTPCREL &&
+          ty != R_X86_64_GOTPCRELX)
+        Fatal(ctx) << *this << ": " << rel
+                   << " must be followed by PLT or GOTPCREL";
+    }
+
+    switch (rel.r_type) {
+    case R_X86_64_8:
+    case R_X86_64_16:
+    case R_X86_64_32:
+    case R_X86_64_32S:
+      scan_absrel(ctx, sym, rel);
+      break;
+    case R_X86_64_PC8:
+    case R_X86_64_PC16:
+    case R_X86_64_PC32:
+    case R_X86_64_PC64:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_X86_64_GOT32:
+    case R_X86_64_GOT64:
+    case R_X86_64_GOTPC32:
+    case R_X86_64_GOTPC64:
+    case R_X86_64_GOTPCREL:
+    case R_X86_64_GOTPCREL64:
+    case R_X86_64_GOTPCRELX:
+    case R_X86_64_REX_GOTPCRELX:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_X86_64_PLT32:
+    case R_X86_64_PLTOFF64:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_X86_64_TLSGD:
+      if (ctx.arg.static_ || (ctx.arg.relax && sym.is_tprel_linktime_const(ctx))) {
+        // We always relax if -static because libc.a doesn't contain
+        // __tls_get_addr().
+        i++;
+      } else if (ctx.arg.relax && sym.is_tprel_runtime_const(ctx)) {
+        sym.flags |= NEEDS_GOTTP;
+        i++;
+      } else {
+        sym.flags |= NEEDS_TLSGD;
+      }
+      break;
+    case R_X86_64_TLSLD:
+      // We always relax if -static because libc.a doesn't contain
+      // __tls_get_addr().
+      if (ctx.arg.static_ || (ctx.arg.relax && !ctx.arg.shared))
+        i++;
+      else
+        ctx.needs_tlsld = true;
+      break;
+    case R_X86_64_GOTTPOFF:
+      if (ctx.arg.relax && relax_gottpoff(loc - 3) &&
+          sym.is_tprel_linktime_const(ctx)) {
+        // do nothing
+      } else {
+        sym.flags |= NEEDS_GOTTP;
+      }
+      break;
+    case R_X86_64_TLSDESC_CALL:
+      scan_tlsdesc(ctx, sym);
+      break;
+    case R_X86_64_TPOFF32:
+    case R_X86_64_TPOFF64:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_X86_64_64:
+    case R_X86_64_GOTOFF64:
+    case R_X86_64_DTPOFF32:
+    case R_X86_64_DTPOFF64:
+    case R_X86_64_SIZE32:
+    case R_X86_64_SIZE64:
+    case R_X86_64_GOTPC32_TLSDESC:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+// Intel CET is a relatively new CPU feature to enhance security by
+// protecting control flow integrity. If the feature is enabled, indirect
+// branches (i.e. branch instructions that take a register instead of an
+// immediate) must land on a "landing pad" instruction, or a CPU-level fault
+// will raise. That prevents an attacker to branch to a middle of a random
+// function, making ROP or JOP much harder to conduct.
+//
+// On x86-64, the landing pad instruction is ENDBR64. That is actually a
+// repurposed NOP instruction to provide binary compatibility with older
+// hardware that doesn't support CET.
+//
+// The problem here is that the compiler always emits a landing pad at the
+// beginning fo a global function because it doesn't know whether or not the
+// function's address is taken in other translation units. As a result, the
+// resulting binary contains more landing pads than necessary.
+//
+// This function rewrites a landing pad with a nop if the function's address
+// was not actually taken. We can do what the compiler cannot because we
+// know about all translation units.
+void rewrite_endbr(Context<E> &ctx) {
+  Timer t(ctx, "rewrite_endbr");
+
+  constexpr u8 endbr64[] = {0xf3, 0x0f, 0x1e, 0xfa};
+  constexpr u8 nop[] = {0x0f, 0x1f, 0x40, 0x00};
+
+  // Rewrite all endbr64 instructions referred to by function symbols with
+  // NOPs. We handle only global symbols because the compiler doesn't emit
+  // an endbr64 for a file-scoped function in the first place if its address
+  // is not taken within the file.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    for (Symbol<E> *sym : file->get_global_syms()) {
+      if (sym->file == file && sym->esym().st_type == STT_FUNC) {
+        if (InputSection<E> *isec = sym->get_input_section();
+            isec && (isec->shdr().sh_flags & SHF_EXECINSTR)) {
+          if (OutputSection<E> *osec = isec->output_section) {
+            u8 *buf = ctx.buf + osec->shdr.sh_offset + isec->offset + sym->value;
+            if (memcmp(buf, endbr64, 4) == 0)
+              memcpy(buf, nop, 4);
+          }
+        }
+      }
+    }
+  });
+
+  auto write_back = [&](InputSection<E> *isec, i64 offset) {
+    // If isec has an endbr64 at a given offset, copy that instruction to
+    // the output buffer, possibly overwriting a nop written in the above
+    // loop.
+    if (isec && isec->output_section &&
+        (isec->shdr().sh_flags & SHF_EXECINSTR) &&
+        0 <= offset && offset <= isec->contents.size() - 4 &&
+        memcmp(isec->contents.data() + offset, endbr64, 4) == 0)
+      memcpy(ctx.buf + isec->output_section->shdr.sh_offset + isec->offset + offset,
+             endbr64, 4);
+  };
+
+  // Write back endbr64 instructions if they are referred to by address-taking
+  // relocations.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
+      if (isec && isec->is_alive && (isec->shdr().sh_flags & SHF_ALLOC)) {
+        for (const ElfRel<E> &rel : isec->get_rels(ctx)) {
+          if (!is_func_call_rel(rel)) {
+            Symbol<E> *sym = file->symbols[rel.r_sym];
+            if (sym->esym().st_type == STT_SECTION)
+              write_back(sym->get_input_section(), rel.r_addend);
+            else
+              write_back(sym->get_input_section(), sym->value);
+          }
+        }
+      }
+    }
+  });
+
+  // We record addresses of some symbols in the ELF header, .dynamic or in
+  // .dynsym. We need to retain endbr64s for such symbols.
+  auto keep = [&](Symbol<E> *sym) {
+    if (sym)
+      write_back(sym->get_input_section(), sym->value);
+  };
+
+  keep(ctx.arg.entry);
+  keep(ctx.arg.init);
+  keep(ctx.arg.fini);
+
+  if (ctx.dynsym)
+    for (Symbol<E> *sym : ctx.dynsym->symbols)
+      if (sym && sym->is_exported)
+        keep(sym);
+}
+
+} // namespace mold

src/config.cc

@@ -0,0 +1,12 @@
+#include "mold.h"
+
+namespace mold {
+
+std::string get_mold_version() {
+  if (mold_git_hash.empty())
+    return "mold "s + MOLD_VERSION + " (compatible with GNU ld)";
+  return "mold "s + MOLD_VERSION + " (" + mold_git_hash +
+         "; compatible with GNU ld)";
+}
+
+} // namespace mold

src/filetype.cc

@@ -0,0 +1,204 @@
+#include "mold.h"
+#include "../lib/archive-file.h"
+
+namespace mold {
+
+static bool is_text_file(MappedFile *mf) {
+  auto istext = [](char c) {
+    return isprint(c) || c == '\n' || c == '\t';
+  };
+
+  u8 *data = mf->data;
+  return mf->size >= 4 && istext(data[0]) && istext(data[1]) &&
+         istext(data[2]) && istext(data[3]);
+}
+
+template <typename E>
+static bool is_gcc_lto_obj(MappedFile *mf, bool has_plugin) {
+  const char *data = mf->get_contents().data();
+  ElfEhdr<E> &ehdr = *(ElfEhdr<E> *)data;
+  ElfShdr<E> *sh_begin = (ElfShdr<E> *)(data + ehdr.e_shoff);
+  std::span<ElfShdr<E>> shdrs{(ElfShdr<E> *)(data + ehdr.e_shoff), ehdr.e_shnum};
+
+  // e_shstrndx is a 16-bit field. If .shstrtab's section index is
+  // too large, the actual number is stored to sh_link field.
+  i64 shstrtab_idx = (ehdr.e_shstrndx == SHN_XINDEX)
+    ? sh_begin->sh_link : ehdr.e_shstrndx;
+
+  for (ElfShdr<E> &sec : shdrs) {
+    // GCC FAT LTO objects contain both regular ELF sections and GCC-
+    // specific LTO sections, so that they can be linked as LTO objects if
+    // the LTO linker plugin is available and falls back as regular
+    // objects otherwise. GCC FAT LTO object can be identified by the
+    // presence of `.gcc.lto_.symtab` section.
+    if (has_plugin) {
+      std::string_view name = data + shdrs[shstrtab_idx].sh_offset + sec.sh_name;
+      if (name.starts_with(".gnu.lto_.symtab."))
+        return true;
+    }
+
+    if (sec.sh_type != SHT_SYMTAB)
+      continue;
+
+    // GCC non-FAT LTO object contains only sections symbols followed by
+    // a common symbol whose name is `__gnu_lto_slim` (or `__gnu_lto_v1`
+    // for older GCC releases).
+    std::span<ElfSym<E>> elf_syms{(ElfSym<E> *)(data + sec.sh_offset),
+                                  (size_t)sec.sh_size / sizeof(ElfSym<E>)};
+
+    auto skip = [](u8 type) {
+      return type == STT_NOTYPE || type == STT_FILE || type == STT_SECTION;
+    };
+
+    i64 i = 1;
+    while (i < elf_syms.size() && skip(elf_syms[i].st_type))
+      i++;
+
+    if (i < elf_syms.size() && elf_syms[i].st_shndx == SHN_COMMON) {
+      std::string_view name =
+        data + shdrs[sec.sh_link].sh_offset + elf_syms[i].st_name;
+      if (name.starts_with("__gnu_lto_"))
+        return true;
+    }
+    break;
+  }
+
+  return false;
+}
+
+template <typename E>
+FileType get_file_type(Context<E> &ctx, MappedFile *mf) {
+  std::string_view data = mf->get_contents();
+  bool has_plugin = !ctx.arg.plugin.empty();
+
+  if (data.empty())
+    return FileType::EMPTY;
+
+  if (data.starts_with("\177ELF")) {
+    u8 byte_order = ((ElfEhdr<I386> *)data.data())->e_ident[EI_DATA];
+
+    if (byte_order == ELFDATA2LSB) {
+      auto &ehdr = *(ElfEhdr<I386> *)data.data();
+
+      if (ehdr.e_type == ET_REL) {
+        if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
+          if (is_gcc_lto_obj<I386>(mf, has_plugin))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<X86_64>(mf, has_plugin))
+            return FileType::GCC_LTO_OBJ;
+        }
+        return FileType::ELF_OBJ;
+      }
+
+      if (ehdr.e_type == ET_DYN)
+        return FileType::ELF_DSO;
+    } else {
+      auto &ehdr = *(ElfEhdr<M68K> *)data.data();
+
+      if (ehdr.e_type == ET_REL) {
+        if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
+          if (is_gcc_lto_obj<M68K>(mf, has_plugin))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<SPARC64>(mf, has_plugin))
+            return FileType::GCC_LTO_OBJ;
+        }
+        return FileType::ELF_OBJ;
+      }
+
+      if (ehdr.e_type == ET_DYN)
+        return FileType::ELF_DSO;
+    }
+    return FileType::UNKNOWN;
+  }
+
+  if (data.starts_with("!<arch>\n"))
+    return FileType::AR;
+  if (data.starts_with("!<thin>\n"))
+    return FileType::THIN_AR;
+  if (is_text_file(mf))
+    return FileType::TEXT;
+  if (data.starts_with("\xde\xc0\x17\x0b"))
+    return FileType::LLVM_BITCODE;
+  if (data.starts_with("BC\xc0\xde"))
+    return FileType::LLVM_BITCODE;
+  return FileType::UNKNOWN;
+}
+
+static std::string_view get_elf_type(u8 *buf) {
+  bool is_le = (buf[EI_DATA] == ELFDATA2LSB);
+  bool is_64 = (buf[EI_CLASS] == ELFCLASS64);
+
+  auto *ehdr_le = (ElfEhdr<I386> *)buf;
+  auto *ehdr_be = (ElfEhdr<M68K> *)buf;
+
+  switch (is_le ? ehdr_le->e_machine : ehdr_be->e_machine) {
+  case EM_386:
+    return I386::name;
+  case EM_X86_64:
+    return X86_64::name;
+  case EM_ARM:
+    return ARM32::name;
+  case EM_AARCH64:
+    return is_le ? ARM64LE::name : ARM64BE::name;
+  case EM_RISCV:
+    if (is_le)
+      return is_64 ? RV64LE::name : RV32LE::name;
+    return is_64 ? RV64BE::name : RV32BE::name;
+  case EM_PPC:
+    return PPC32::name;
+  case EM_PPC64:
+    return is_le ? PPC64V2::name : PPC64V1::name;
+  case EM_S390X:
+    return S390X::name;
+  case EM_SPARC64:
+    return SPARC64::name;
+  case EM_68K:
+    return M68K::name;
+  case EM_SH:
+    return is_le ? SH4LE::name : SH4BE::name;
+  case EM_LOONGARCH:
+    return is_64 ? LOONGARCH64::name : LOONGARCH32::name;
+  default:
+    return "";
+  }
+}
+
+// Read the beginning of a given file and returns its machine type
+// (e.g. EM_X86_64 or EM_386).
+template <typename E>
+std::string_view
+get_machine_type(Context<E> &ctx, ReaderContext &rctx, MappedFile *mf) {
+  switch (get_file_type(ctx, mf)) {
+  case FileType::ELF_OBJ:
+  case FileType::ELF_DSO:
+  case FileType::GCC_LTO_OBJ:
+    return get_elf_type(mf->data);
+  case FileType::AR:
+    for (MappedFile *child : read_fat_archive_members(ctx, mf))
+      if (FileType ty = get_file_type(ctx, child);
+          ty == FileType::ELF_OBJ || ty == FileType::GCC_LTO_OBJ)
+        return get_elf_type(child->data);
+    return "";
+  case FileType::THIN_AR:
+    for (MappedFile *child : read_thin_archive_members(ctx, mf))
+      if (FileType ty = get_file_type(ctx, child);
+          ty == FileType::ELF_OBJ || ty == FileType::GCC_LTO_OBJ)
+        return get_elf_type(child->data);
+    return "";
+  case FileType::TEXT:
+    return Script(ctx, rctx, mf).get_script_output_type();
+  default:
+    return "";
+  }
+}
+
+using E = MOLD_TARGET;
+
+template FileType get_file_type(Context<E> &, MappedFile *);
+
+template std::string_view
+get_machine_type(Context<E> &, ReaderContext &, MappedFile *);
+
+} // namespace mold

src/gc-sections.cc

@@ -7,7 +7,7 @@
 #include <tbb/concurrent_vector.h>
 #include <tbb/parallel_for_each.h>
 
-namespace mold::elf {
+namespace mold {
 
 template <typename E>
 static bool should_keep(const InputSection<E> &isec) {
@@ -15,6 +15,10 @@ static bool should_keep(const InputSection<E> &isec) {
   u32 flags = isec.shdr().sh_flags;
   std::string_view name = isec.name();
 
+  if constexpr (is_ppc32<E>)
+    if (name == ".got2")
+      return true;
+
   return (flags & SHF_GNU_RETAIN) ||
          type == SHT_NOTE ||
          type == SHT_INIT_ARRAY ||
@@ -30,7 +34,65 @@ static bool should_keep(const InputSection<E> &isec) {
 
 template <typename E>
 static bool mark_section(InputSection<E> *isec) {
-  return isec && isec->is_alive && fast_mark(isec->is_visited);
+  return isec && isec->is_alive && !isec->is_visited.test_and_set();
+}
+
+template <typename E>
+static tbb::concurrent_vector<InputSection<E> *>
+collect_root_set(Context<E> &ctx) {
+  Timer t(ctx, "collect_root_set");
+  tbb::concurrent_vector<InputSection<E> *> rootset;
+
+  auto enqueue_section = [&](InputSection<E> *isec) {
+    if (mark_section(isec))
+      rootset.push_back(isec);
+  };
+
+  auto enqueue_symbol = [&](Symbol<E> *sym) {
+    if (sym) {
+      if (SectionFragment<E> *frag = sym->get_frag())
+        frag->is_alive = true;
+      else
+        enqueue_section(sym->get_input_section());
+    }
+  };
+
+  // Add sections that are not subject to garbage collection.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
+      if (!isec || !isec->is_alive)
+        continue;
+
+      // --gc-sections discards only SHF_ALLOC sections. If you want to
+      // reduce the amount of non-memory-mapped segments, you should
+      // use `strip` command, compile without debug info or use
+      // --strip-all linker option.
+      u32 flags = isec->shdr().sh_flags;
+      if (!(flags & SHF_ALLOC))
+        isec->is_visited = true;
+
+      if (should_keep(*isec))
+        enqueue_section(isec.get());
+    }
+  });
+
+  // Add sections containing gc root or exported symbols
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    for (Symbol<E> *sym : file->symbols)
+      if (sym->file == file && (sym->gc_root || sym->is_exported))
+        enqueue_symbol(sym);
+  });
+
+  // .eh_frame consists of variable-length records called CIE and FDE
+  // records, and they are a unit of inclusion or exclusion.
+  // We just keep all CIEs and everything that are referenced by them.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    for (CieRecord<E> &cie : file->cies)
+      for (const ElfRel<E> &rel : cie.get_rels())
+        enqueue_symbol(file->symbols[rel.r_sym]);
+  });
+
+  return rootset;
 }
 
 template <typename E>
@@ -50,87 +112,22 @@ static void visit(Context<E> &ctx, InputSection<E> *isec,
   for (const ElfRel<E> &rel : isec->get_rels(ctx)) {
     Symbol<E> &sym = *isec->file.symbols[rel.r_sym];
 
-    // Symbol can refer either a section fragment or an input section.
+    // Symbol can refer to either a section fragment or an input section.
     // Mark a fragment as alive.
     if (SectionFragment<E> *frag = sym.get_frag()) {
-      frag->is_alive.store(true, std::memory_order_relaxed);
+      frag->is_alive = true;
       continue;
     }
 
-    if (!mark_section(sym.get_input_section()))
-      continue;
-
     // Mark a section alive. For better performacne, we don't call
     // `feeder.add` too often.
-    if (depth < 3)
-      visit(ctx, sym.get_input_section(), feeder, depth + 1);
-    else
-      feeder.add(sym.get_input_section());
-  }
-}
-
-template <typename E>
-static void collect_root_set(Context<E> &ctx,
-                             tbb::concurrent_vector<InputSection<E> *> &rootset) {
-  Timer t(ctx, "collect_root_set");
-
-  auto enqueue_section = [&](InputSection<E> *isec) {
-    if (mark_section(isec))
-      rootset.push_back(isec);
-  };
-
-  auto enqueue_symbol = [&](Symbol<E> *sym) {
-    if (sym) {
-      if (SectionFragment<E> *frag = sym->get_frag())
-        frag->is_alive.store(true, std::memory_order_relaxed);
+    if (mark_section(sym.get_input_section())) {
+      if (depth < 3)
+        visit(ctx, sym.get_input_section(), feeder, depth + 1);
       else
-        enqueue_section(sym->get_input_section());
+        feeder.add(sym.get_input_section());
     }
-  };
-
-  // Add sections that are not subject to garbage collection.
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
-      if (!isec || !isec->is_alive)
-        continue;
-
-      // -gc-sections discards only SHF_ALLOC sections. If you want to
-      // reduce the amount of non-memory-mapped segments, you should
-      // use `strip` command, compile without debug info or use
-      // -strip-all linker option.
-      u32 flags = isec->shdr().sh_flags;
-      if (!(flags & SHF_ALLOC))
-        isec->is_visited = true;
-
-      if (should_keep(*isec))
-        enqueue_section(isec.get());
-    }
-  });
-
-  // Add sections containing exported symbols
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    for (Symbol<E> *sym : file->symbols)
-      if (sym->file == file && sym->is_exported)
-        enqueue_symbol(sym);
-  });
-
-  // Add sections referenced by root symbols.
-  enqueue_symbol(get_symbol(ctx, ctx.arg.entry));
-
-  for (std::string_view name : ctx.arg.undefined)
-    enqueue_symbol(get_symbol(ctx, name));
-
-  for (std::string_view name : ctx.arg.require_defined)
-    enqueue_symbol(get_symbol(ctx, name));
-
-  // .eh_frame consists of variable-length records called CIE and FDE
-  // records, and they are a unit of inclusion or exclusion.
-  // We just keep all CIEs and everything that are referenced by them.
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    for (CieRecord<E> &cie : file->cies)
-      for (const ElfRel<E> &rel : cie.get_rels())
-        enqueue_symbol(file->symbols[rel.r_sym]);
-  });
+  }
 }
 
 // Mark all reachable sections
@@ -140,7 +137,7 @@ static void mark(Context<E> &ctx,
   Timer t(ctx, "mark");
 
   tbb::parallel_for_each(rootset, [&](InputSection<E> *isec,
-                                    tbb::feeder<InputSection<E> *> &feeder) {
+                                      tbb::feeder<InputSection<E> *> &feeder) {
     visit(ctx, isec, feeder, 0);
   });
 }
@@ -155,7 +152,7 @@ static void sweep(Context<E> &ctx) {
     for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
       if (isec && isec->is_alive && !isec->is_visited) {
         if (ctx.arg.print_gc_sections)
-          SyncOut(ctx) << "removing unused section " << *isec;
+          Out(ctx) << "removing unused section " << *isec;
         isec->kill();
         counter++;
       }
@@ -163,29 +160,10 @@ static void sweep(Context<E> &ctx) {
   });
 }
 
-// Non-alloc section fragments are not subject of garbage collection.
-// This function marks such fragments.
-template <typename E>
-static void mark_nonalloc_fragments(Context<E> &ctx) {
-  Timer t(ctx, "mark_nonalloc_fragments");
-
-  tbb::parallel_for_each(ctx.objs, [](ObjectFile<E> *file) {
-    for (std::unique_ptr<MergeableSection<E>> &m : file->mergeable_sections)
-      if (m)
-        for (SectionFragment<E> *frag : m->fragments)
-          if (!(frag->output_section.shdr.sh_flags & SHF_ALLOC))
-            frag->is_alive.store(true, std::memory_order_relaxed);
-  });
-}
-
 template <typename E>
 void gc_sections(Context<E> &ctx) {
   Timer t(ctx, "gc");
-
-  mark_nonalloc_fragments(ctx);
-
-  tbb::concurrent_vector<InputSection<E> *> rootset;
-  collect_root_set(ctx, rootset);
+  tbb::concurrent_vector<InputSection<E> *> rootset = collect_root_set(ctx);
   mark(ctx, rootset);
   sweep(ctx);
 }
@@ -194,4 +172,4 @@ using E = MOLD_TARGET;
 
 template void gc_sections(Context<E> &ctx);
 
-} // namespace mold::elf
+} // namespace mold

src/gdb-index.cc

@@ -0,0 +1,794 @@
+// This file contains code to read DWARF debug info to create .gdb_index.
+//
+// .gdb_index is an optional section to speed up GNU debugger. It contains
+// two maps: 1) a map from function/variable/type names to compunits, and
+// 2) a map from function address ranges to compunits. gdb uses these
+// maps to quickly find a compunit given a name or an instruction pointer.
+//
+// (Terminology: a compilation unit, often abbreviated as compunit or
+// CU, is a unit of debug info. An input .debug_info section usually
+// contains one compunit, and thus an output .debug_info contains as
+// many compunits as the number of input files.)
+//
+// .gdb_index is not mandatory. All the information in .gdb_index is
+// also in other debug info sections. You can actually create an
+// executable without .gdb_index and later add it using the
+// `gdb-add-index` post-processing tool that comes with gdb.
+//
+// Post-relocated debug section contents are needed to create a
+// .gdb_index. Therefore, we create it after relocating all the other
+// sections. The size of the section is also hard to estimate before
+// applying relocations to debug info sections, so a .gdb_index is
+// placed at the very end of the output file, even after the section
+// header.
+//
+// The mapping from names to compunits is 1:n while the mapping from
+// address ranges to compunits is 1:1. That is, two object files may
+// define the same type name, while there should be no two functions
+// that overlap with each other in memory.
+//
+// .gdb_index contains an on-disk hash table for names, so gdb can
+// lookup names without loading all strings into memory and construct an
+// in-memory hash table.
+//
+// Names are in .debug_gnu_pubnames and .debug_gnu_pubtypes input
+// sections. These sections are created if `-ggnu-pubnames` is given.
+// Besides names, these sections contain attributes for each name so
+// that gdb can distinguish type names from function names, for example.
+//
+// A compunit contains one or more function address ranges. If an
+// object file is compiled without -ffunction-sections, it contains
+// only one .text section and therefore contains a single address range.
+// Such range is typically stored directly to the compunit.
+//
+// If an object file is compiled with -ffunction-sections, it contains
+// more than one .text section, and it has as many address ranges as
+// the number of .text sections. Such discontiguous address ranges are
+// stored to .debug_ranges in DWARF 2/3/4 and .debug_rnglists/.debug_addr
+// in DWARF 5.
+//
+// .debug_info section contains DWARF debug info. Although we don't need
+// to parse the whole .debug_info section to read address ranges, we
+// have to do a little bit. DWARF is complicated and often handled using
+// a library such as libdwarf. But we don't use any library because we
+// don't want to add an extra run-time dependency just for --gdb-index.
+//
+// This page explains the format of .gdb_index:
+// https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
+
+#include "mold.h"
+#include <tbb/parallel_for_each.h>
+#include <tbb/parallel_sort.h>
+
+namespace mold {
+
+enum DwarfKind { DWARF2_32, DWARF5_32, DWARF2_64, DWARF5_64 };
+
+template <typename E>
+struct CuHdrDwarf2_32 {
+  U32<E> size;
+  U16<E> version;
+  U32<E> abbrev_offset;
+  u8 address_size;
+};
+
+template <typename E>
+struct CuHdrDwarf5_32 {
+  U32<E> size;
+  U16<E> version;
+  u8 unit_type;
+  u8 address_size;
+  U32<E> abbrev_offset;
+};
+
+template <typename E>
+struct CuHdrDwarf2_64 {
+  U32<E> magic;
+  U64<E> size;
+  U16<E> version;
+  U64<E> abbrev_offset;
+  u8 address_size;
+};
+
+template <typename E>
+struct CuHdrDwarf5_64 {
+  U32<E> magic;
+  U64<E> size;
+  U16<E> version;
+  u8 unit_type;
+  u8 address_size;
+  U64<E> abbrev_offset;
+};
+
+template <typename E>
+struct PubnamesHdr32 {
+  U32<E> size;
+  U16<E> version;
+  U32<E> debug_info_offset;
+  U32<E> debug_info_size;
+};
+
+template <typename E>
+struct PubnamesHdr64 {
+  U32<E> magic;
+  U64<E> size;
+  U16<E> version;
+  U64<E> debug_info_offset;
+  U64<E> debug_info_size;
+};
+
+struct SectionHeader {
+  ul32 version = 7;
+  ul32 cu_list_offset = 0;
+  ul32 cu_types_offset = 0;
+  ul32 ranges_offset = 0;
+  ul32 symtab_offset = 0;
+  ul32 const_pool_offset = 0;
+};
+
+struct NameType {
+  bool operator==(const NameType &) const = default;
+
+  bool operator<(const NameType &other) const {
+    return std::tuple(hash, type, name) <
+           std::tuple(other.hash, other.type, other.name);
+  }
+
+  std::string_view name;
+  u64 hash;
+  u8 type;
+};
+
+struct MapValue {
+  u32 gdb_hash = 0;
+  Atomic<u32> count;
+  u32 name_offset = 0;
+  u32 type_offset = 0;
+};
+
+struct Compunit {
+  DwarfKind kind;
+  i64 offset;
+  i64 size;
+  std::vector<std::pair<u64, u64>> ranges;
+  std::vector<NameType> nametypes;
+  std::vector<MapValue *> entries;
+};
+
+// The hash function for .gdb_index.
+static u32 gdb_hash(std::string_view name) {
+  u32 h = 0;
+  for (u8 c : name) {
+    if ('A' <= c && c <= 'Z')
+      c = 'a' + c - 'A';
+    h = h * 67 + c - 113;
+  }
+  return h;
+}
+
+template <typename E>
+static DwarfKind get_dwarf_kind(Context<E> &ctx, u8 *p) {
+  if (*(U32<E> *)p == 0xffff'ffff) {
+    CuHdrDwarf2_64<E> &hdr = *(CuHdrDwarf2_64<E> *)p;
+    if (hdr.version > 5)
+      Fatal(ctx) << "--gdb-index: DWARF version " << hdr.version
+                 << " is not supported";
+    return (hdr.version == 5) ? DWARF5_64 : DWARF2_64;
+  }
+
+  CuHdrDwarf2_32<E> &hdr = *(CuHdrDwarf2_32<E> *)p;
+  if (hdr.version > 5)
+    Fatal(ctx) << "--gdb-index: DWARF version " << hdr.version
+               << " is not supported";
+  return (hdr.version == 5) ? DWARF5_32 : DWARF2_32;
+}
+
+template <typename E, typename CuHdr>
+u8 *find_cu_abbrev(Context<E> &ctx, u8 **p, const CuHdr &hdr) {
+  if (hdr.address_size != sizeof(Word<E>))
+    Fatal(ctx) << "--gdb-index: unsupported address size " << hdr.address_size;
+
+  if constexpr (requires { hdr.unit_type; }) {
+    switch (hdr.unit_type) {
+    case DW_UT_compile:
+    case DW_UT_partial:
+      break;
+    case DW_UT_skeleton:
+    case DW_UT_split_compile:
+      *p += 8;
+      break;
+    default:
+      Fatal(ctx) << "--gdb-index: unknown unit type: 0x"
+                 << std::hex << hdr.unit_type;
+    }
+  }
+
+  i64 abbrev_code = read_uleb(p);
+
+  // Find a .debug_abbrev record corresponding to the .debug_info record.
+  // We assume the .debug_info record at a given offset is of
+  // DW_TAG_compile_unit which describes a compunit.
+  u8 *abbrev = &ctx.debug_abbrev[0] + hdr.abbrev_offset;
+
+  for (;;) {
+    u32 code = read_uleb(&abbrev);
+    if (code == 0)
+      Fatal(ctx) << "--gdb-index: .debug_abbrev does not contain"
+                 << " a record for the first .debug_info record";
+
+    if (code == abbrev_code) {
+      // Found a record
+      u64 abbrev_tag = read_uleb(&abbrev);
+      if (abbrev_tag != DW_TAG_compile_unit && abbrev_tag != DW_TAG_skeleton_unit)
+        Fatal(ctx) << "--gdb-index: the first entry's tag is not"
+                   << " DW_TAG_compile_unit/DW_TAG_skeleton_unit but 0x"
+                   << std::hex << abbrev_tag;
+      break;
+    }
+
+    // Skip an uninteresting record
+    read_uleb(&abbrev); // tag
+    abbrev++; // has_children byte
+    for (;;) {
+      u64 name = read_uleb(&abbrev);
+      u64 form = read_uleb(&abbrev);
+      if (name == 0 && form == 0)
+        break;
+      if (form == DW_FORM_implicit_const)
+        read_uleb(&abbrev);
+    }
+  }
+
+  abbrev++; // skip has_children byte
+  return abbrev;
+}
+
+// .debug_info contains variable-length fields.
+// This function reads one scalar value from a given location.
+template <typename E, typename Offset>
+u64 read_scalar(Context<E> &ctx, u8 **p, u64 form) {
+  switch (form) {
+  case DW_FORM_flag_present:
+    return 0;
+  case DW_FORM_data1:
+  case DW_FORM_flag:
+  case DW_FORM_strx1:
+  case DW_FORM_addrx1:
+  case DW_FORM_ref1:
+    return *(*p)++;
+  case DW_FORM_data2:
+  case DW_FORM_strx2:
+  case DW_FORM_addrx2:
+  case DW_FORM_ref2: {
+    u64 val = *(U16<E> *)*p;
+    *p += 2;
+    return val;
+  }
+  case DW_FORM_strx3:
+  case DW_FORM_addrx3: {
+    u64 val = *(U24<E> *)*p;
+    *p += 3;
+    return val;
+  }
+  case DW_FORM_data4:
+  case DW_FORM_strx4:
+  case DW_FORM_addrx4:
+  case DW_FORM_ref4: {
+    u64 val = *(U32<E> *)*p;
+    *p += 4;
+    return val;
+  }
+  case DW_FORM_data8:
+  case DW_FORM_ref8: {
+    u64 val = *(U64<E> *)*p;
+    *p += 8;
+    return val;
+  }
+  case DW_FORM_strp:
+  case DW_FORM_sec_offset:
+  case DW_FORM_line_strp: {
+    u64 val = *(Offset *)*p;
+    *p += sizeof(Offset);
+    return val;
+  }
+  case DW_FORM_addr:
+  case DW_FORM_ref_addr: {
+    u64 val = *(Word<E> *)*p;
+    *p += sizeof(Word<E>);
+    return val;
+  }
+  case DW_FORM_strx:
+  case DW_FORM_addrx:
+  case DW_FORM_udata:
+  case DW_FORM_ref_udata:
+  case DW_FORM_loclistx:
+  case DW_FORM_rnglistx:
+    return read_uleb(p);
+  case DW_FORM_string:
+    *p += strlen((char *)*p) + 1;
+    return 0;
+  default:
+    Fatal(ctx) << "--gdb-index: unhandled debug info form: 0x"
+               << std::hex << form;
+  }
+}
+
+// Read a range list from .debug_ranges starting at the given offset.
+template <typename E>
+static std::vector<std::pair<u64, u64>>
+read_debug_range(Word<E> *range, u64 base) {
+  std::vector<std::pair<u64, u64>> vec;
+
+  for (i64 i = 0; range[i] || range[i + 1]; i += 2) {
+    if (range[i] + 1 == 0)
+      base = range[i + 1];
+    else
+      vec.emplace_back(range[i] + base, range[i + 1] + base);
+  }
+  return vec;
+}
+
+// Read a range list from .debug_rnglists starting at the given offset.
+template <typename E>
+static void
+read_rnglist_range(std::vector<std::pair<u64, u64>> &vec, u8 *p,
+                   Word<E> *addrx, u64 base) {
+  for (;;) {
+    switch (*p++) {
+    case DW_RLE_end_of_list:
+      return;
+    case DW_RLE_base_addressx:
+      base = addrx[read_uleb(&p)];
+      break;
+    case DW_RLE_startx_endx: {
+      u64 val1 = read_uleb(&p);
+      u64 val2 = read_uleb(&p);
+      vec.emplace_back(addrx[val1], addrx[val2]);
+      break;
+    }
+    case DW_RLE_startx_length: {
+      u64 val1 = read_uleb(&p);
+      u64 val2 = read_uleb(&p);
+      vec.emplace_back(addrx[val1], addrx[val1] + val2);
+      break;
+    }
+    case DW_RLE_offset_pair: {
+      u64 val1 = read_uleb(&p);
+      u64 val2 = read_uleb(&p);
+
+      // If the base is 0, this address range is for an eliminated
+      // section. We only emit it if it's alive.
+      if (base)
+        vec.emplace_back(base + val1, base + val2);
+      break;
+    }
+    case DW_RLE_base_address:
+      base = *(Word<E> *)p;
+      p += sizeof(Word<E>);
+      break;
+    case DW_RLE_start_end: {
+      u64 val1 = ((Word<E> *)p)[0];
+      u64 val2 = ((Word<E> *)p)[1];
+      p += sizeof(Word<E>) * 2;
+      vec.emplace_back(val1, val2);
+      break;
+    }
+    case DW_RLE_start_length: {
+      u64 val1 = *(Word<E> *)p;
+      p += sizeof(Word<E>);
+      u64 val2 = read_uleb(&p);
+      vec.emplace_back(val1, val1 + val2);
+      break;
+    }
+    }
+  }
+}
+
+// Returns a list of address ranges explained by a compunit at the
+// `offset` in an output .debug_info section.
+//
+// .debug_info contains DWARF debug info records, so this function
+// parses DWARF. If a designated compunit contains multiple ranges, the
+// ranges are read from .debug_ranges (or .debug_rnglists for DWARF5).
+// Otherwise, a range is read directly from .debug_info (or possibly
+// from .debug_addr for DWARF5).
+template <typename E, typename CuHdr>
+static std::vector<std::pair<u64, u64>>
+read_address_ranges(Context<E> &ctx, const Compunit &cu) {
+  // Read .debug_info to find the record at a given offset.
+  u8 *p = &ctx.debug_info[0] + cu.offset;
+  CuHdr &hdr = *(CuHdr *)p;
+  p += sizeof(hdr);
+
+  u8 *abbrev = find_cu_abbrev(ctx, &p, hdr);
+
+  // Now, read debug info records.
+  struct Record {
+    u64 form = 0;
+    u64 value = 0;
+  };
+
+  using Offset = decltype(hdr.size);
+
+  Record low_pc;
+  Record high_pc;
+  Record ranges;
+  u64 rnglists_base = -1;
+  Word<E> *addrx = nullptr;
+
+  // Read all interesting debug records.
+  for (;;) {
+    u64 name = read_uleb(&abbrev);
+    u64 form = read_uleb(&abbrev);
+    if (name == 0 && form == 0)
+      break;
+
+    u64 val = read_scalar<E, Offset>(ctx, &p, form);
+
+    switch (name) {
+    case DW_AT_low_pc:
+      low_pc = {form, val};
+      break;
+    case DW_AT_high_pc:
+      high_pc = {form, val};
+      break;
+    case DW_AT_rnglists_base:
+      rnglists_base = val;
+      break;
+    case DW_AT_addr_base:
+      addrx = (Word<E> *)(&ctx.debug_addr[0] + val);
+      break;
+    case DW_AT_ranges:
+      ranges = {form, val};
+      break;
+    }
+  }
+
+  // Handle non-contiguous address ranges.
+  if (ranges.form) {
+    if (hdr.version <= 4) {
+      Word<E> *p = (Word<E> *)(&ctx.debug_ranges[0] + ranges.value);
+      return read_debug_range<E>(p, low_pc.value);
+    }
+
+    assert(hdr.version == 5);
+
+    std::vector<std::pair<u64, u64>> vec;
+    u8 *buf = &ctx.debug_rnglists[0];
+
+    if (ranges.form == DW_FORM_sec_offset) {
+      read_rnglist_range<E>(vec, buf + ranges.value, addrx, low_pc.value);
+    } else {
+      if (rnglists_base == -1)
+        Fatal(ctx) << "--gdb-index: missing DW_AT_rnglists_base";
+
+      u8 *base = buf + rnglists_base;
+      i64 num_offsets = *(U32<E> *)(base - 4);
+      Offset *offsets = (Offset *)base;
+
+      for (i64 i = 0; i < num_offsets; i++)
+        read_rnglist_range<E>(vec, base + offsets[i], addrx, low_pc.value);
+    }
+    return vec;
+  }
+
+  // Handle a contiguous address range.
+  if (low_pc.form && high_pc.form) {
+    u64 lo;
+
+    switch (low_pc.form) {
+    case DW_FORM_addr:
+      lo = low_pc.value;
+      break;
+    case DW_FORM_addrx:
+    case DW_FORM_addrx1:
+    case DW_FORM_addrx2:
+    case DW_FORM_addrx4:
+      lo = addrx[low_pc.value];
+      break;
+    default:
+      Fatal(ctx) << "--gdb-index: unhandled form for DW_AT_low_pc: 0x"
+                 << std::hex << high_pc.form;
+    }
+
+    switch (high_pc.form) {
+    case DW_FORM_addr:
+      return {{lo, high_pc.value}};
+    case DW_FORM_addrx:
+    case DW_FORM_addrx1:
+    case DW_FORM_addrx2:
+    case DW_FORM_addrx4:
+      return {{lo, addrx[high_pc.value]}};
+    case DW_FORM_udata:
+    case DW_FORM_data1:
+    case DW_FORM_data2:
+    case DW_FORM_data4:
+    case DW_FORM_data8:
+      return {{lo, lo + high_pc.value}};
+    default:
+      Fatal(ctx) << "--gdb-index: unhandled form for DW_AT_high_pc: 0x"
+                 << std::hex << high_pc.form;
+    }
+  }
+
+  return {};
+}
+
+template <typename E, typename PubnamesHdr>
+static i64 read_pubnames_cu(Context<E> &ctx, const PubnamesHdr &hdr,
+                            std::vector<Compunit> &cus, ObjectFile<E> &file) {
+  using Offset = decltype(hdr.size);
+
+  auto get_cu = [&](i64 offset) {
+    for (i64 i = 0; i < cus.size(); i++)
+      if (cus[i].offset == offset)
+        return &cus[i];
+    Fatal(ctx) << file << ": corrupted debug_info_offset";
+  };
+
+  Compunit *cu = get_cu(file.debug_info->offset + hdr.debug_info_offset);
+  i64 size = hdr.size + offsetof(PubnamesHdr, size) + sizeof(hdr.size);
+  u8 *p = (u8 *)&hdr + sizeof(hdr);
+  u8 *end = (u8 *)&hdr + size;
+
+  while (p < end) {
+    if (*(Offset *)p == 0)
+      break;
+    p += sizeof(Offset);
+
+    u8 type = *p++;
+    std::string_view name = (char *)p;
+    p += name.size() + 1;
+    cu->nametypes.push_back({name, hash_string(name), type});
+  }
+
+  return size;
+}
+
+// Parses .debug_gnu_pubnames and .debug_gnu_pubtypes. These sections
+// start with a 14 bytes header followed by (4-byte offset, 1-byte type,
+// null-terminated string) tuples.
+//
+// The 4-byte offset is an offset into .debug_info that contains details
+// about the name. The 1-byte type is a type of the corresponding name
+// (e.g. function, variable or datatype). The string is a name of a
+// function, a variable or a type.
+template <typename E>
+static void read_pubnames(Context<E> &ctx, std::vector<Compunit> &cus,
+                          ObjectFile<E> &file) {
+  for (InputSection<E> *isec : { file.debug_pubnames, file.debug_pubtypes }) {
+    if (!isec)
+      continue;
+
+    isec->uncompress(ctx);
+    if (isec->contents.empty())
+      continue;
+
+    u8 *p = (u8*)&isec->contents[0];
+    u8 *end = p + isec->contents.size();
+
+    while (p < end) {
+      if (*(U32<E> *)p == 0xffff'ffff)
+        p += read_pubnames_cu(ctx, *(PubnamesHdr64<E> *)p, cus, file);
+      else
+        p += read_pubnames_cu(ctx, *(PubnamesHdr32<E> *)p, cus, file);
+    }
+  };
+}
+
+template <typename E>
+static std::vector<Compunit> read_compunits(Context<E> &ctx) {
+  std::vector<Compunit> cus;
+
+  // Read compunits from the output .debug_info section.
+  u8 *begin = &ctx.debug_info[0];
+  u8 *end = begin + ctx.debug_info.size();
+
+  for (u8 *p = begin; p < end;) {
+    DwarfKind kind = get_dwarf_kind(ctx, p);
+    i64 size;
+    if (kind == DWARF2_32 || kind == DWARF5_32)
+      size = ((CuHdrDwarf2_32<E> *)p)->size + 4;
+    else
+      size = ((CuHdrDwarf2_64<E> *)p)->size + 12;
+
+    cus.push_back(Compunit{kind, p - begin, size});
+    p += size;
+  }
+
+  // Read address ranges for each compunit.
+  tbb::parallel_for_each(cus, [&](Compunit &cu) {
+    switch (cu.kind) {
+    case DWARF2_32:
+      cu.ranges = read_address_ranges<E, CuHdrDwarf2_32<E>>(ctx, cu);
+      break;
+    case DWARF5_32:
+      cu.ranges = read_address_ranges<E, CuHdrDwarf5_32<E>>(ctx, cu);
+      break;
+    case DWARF2_64:
+      cu.ranges = read_address_ranges<E, CuHdrDwarf2_64<E>>(ctx, cu);
+      break;
+    case DWARF5_64:
+      cu.ranges = read_address_ranges<E, CuHdrDwarf5_64<E>>(ctx, cu);
+      break;
+    }
+
+    // Remove empty ranges
+    std::erase_if(cu.ranges, [](std::pair<u64, u64> p) {
+      return p.first == 0 || p.first == p.second;
+    });
+  });
+
+  // Read symbols from .debug_gnu_pubnames and .debug_gnu_pubtypes.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    read_pubnames(ctx, cus, *file);
+  });
+
+  // Uniquify elements because GCC 11 seems to emit one record for each
+  // comdat group which results in having a lot of duplicate records.
+  tbb::parallel_for_each(cus, [&](Compunit &cu) {
+    sort(cu.nametypes);
+    remove_duplicates(cu.nametypes);
+  });
+
+  return cus;
+}
+
+template <typename E>
+std::span<u8> get_buffer(Context<E> &ctx, Chunk<E> *chunk) {
+  if (chunk->is_compressed)
+    return chunk->uncompressed_data;
+  return {ctx.buf + chunk->shdr.sh_offset, (size_t)chunk->shdr.sh_size};
+}
+
+template <typename E>
+void write_gdb_index(Context<E> &ctx) {
+  Timer t(ctx, "write_gdb_index");
+
+  // Find debug info sections
+  for (Chunk<E> *chunk : ctx.chunks) {
+    std::string_view name = chunk->name;
+    if (name == ".debug_info")
+      ctx.debug_info = get_buffer(ctx, chunk);
+    if (name == ".debug_abbrev")
+      ctx.debug_abbrev = get_buffer(ctx, chunk);
+    if (name == ".debug_ranges")
+      ctx.debug_ranges = get_buffer(ctx, chunk);
+    if (name == ".debug_addr")
+      ctx.debug_addr = get_buffer(ctx, chunk);
+    if (name == ".debug_rnglists")
+      ctx.debug_rnglists = get_buffer(ctx, chunk);
+  }
+
+  if (ctx.debug_info.empty())
+    return;
+
+  // Read debug info
+  std::vector<Compunit> cus = read_compunits(ctx);
+
+  // Uniquify symbols
+  HyperLogLog estimator;
+
+  tbb::parallel_for_each(cus, [&](Compunit &cu) {
+    HyperLogLog e;
+    for (NameType &nt : cu.nametypes)
+      e.insert(nt.hash);
+    estimator.merge(e);
+  });
+
+  ConcurrentMap<MapValue> map(estimator.get_cardinality() * 3 / 2);
+
+  tbb::parallel_for_each(cus, [&](Compunit &cu) {
+    cu.entries.reserve(cu.nametypes.size());
+    for (NameType &nt : cu.nametypes) {
+      MapValue *ent;
+      bool inserted;
+      std::tie(ent, inserted) = map.insert(nt.name, nt.hash,
+                                           MapValue{gdb_hash(nt.name)});
+      ent->count++;
+      cu.entries.push_back(ent);
+    }
+  });
+
+  // Sort symbols for build reproducibility
+  using Entry = typename decltype(map)::Entry;
+  std::vector<Entry *> entries = map.get_sorted_entries_all();
+
+  // Compute sizes of each components
+  SectionHeader hdr;
+  hdr.cu_list_offset = sizeof(hdr);
+  hdr.cu_types_offset = hdr.cu_list_offset + cus.size() * 16;
+  hdr.ranges_offset = hdr.cu_types_offset;
+
+  hdr.symtab_offset = hdr.ranges_offset;
+  for (Compunit &cu : cus)
+    hdr.symtab_offset += cu.ranges.size() * 20;
+
+  i64 ht_size = bit_ceil(entries.size() * 5 / 4 + 1);
+  hdr.const_pool_offset = hdr.symtab_offset + ht_size * 8;
+
+  i64 offset = 0;
+  for (Entry *ent : entries) {
+    ent->value.type_offset = offset;
+    offset += ent->value.count * 4 + 4;
+  }
+
+  for (Entry *ent : entries) {
+    ent->value.name_offset = offset;
+    offset += ent->keylen + 1;
+  }
+
+  i64 bufsize = hdr.const_pool_offset + offset;
+
+  // Allocate an output buffer
+  ctx.output_file->buf2.resize(bufsize);
+  u8 *buf = ctx.output_file->buf2.data();
+
+  // Write a section header
+  memcpy(buf, &hdr, sizeof(hdr));
+
+  // Write a CU list
+  u8 *p = buf + sizeof(hdr);
+
+  for (Compunit &cu : cus) {
+    *(ul64 *)p = cu.offset;
+    *(ul64 *)(p + 8) = cu.size;
+    p += 16;
+  }
+
+  // Write address areas
+  for (i64 i = 0; i < cus.size(); i++) {
+    for (std::pair<u64, u64> range : cus[i].ranges) {
+      *(ul64 *)p = range.first;
+      *(ul64 *)(p + 8) = range.second;
+      *(ul32 *)(p + 16) = i;
+      p += 20;
+    }
+  }
+
+  // Write a symbol table
+  u32 mask = ht_size - 1;
+  ul32 *ht = (ul32 *)(buf + hdr.symtab_offset);
+
+  for (Entry *ent : entries) {
+    u32 hash = ent->value.gdb_hash;
+    u32 step = ((hash * 17) & mask) | 1;
+    u32 j = hash & mask;
+
+    while (ht[j * 2] || ht[j * 2 + 1])
+      j = (j + step) & mask;
+
+    ht[j * 2] = ent->value.name_offset;
+    ht[j * 2 + 1] = ent->value.type_offset;
+  }
+
+  // Write types
+  for (i64 i = 0; i < cus.size(); i++) {
+    Compunit &cu = cus[i];
+    u8 *base = buf + hdr.const_pool_offset;
+
+    for (i64 j = 0; j < cu.nametypes.size(); j++) {
+      ul32 *p = (ul32 *)(base + cu.entries[j]->type_offset);
+      i64 idx = ++p[0];
+      p[idx] = (cu.nametypes[j].type << 24) | i;
+    }
+  }
+
+  // Write names
+  tbb::parallel_for_each(entries, [&](Entry *ent) {
+    memcpy(buf + hdr.const_pool_offset + ent->value.name_offset,
+           ent->key, ent->keylen);
+  });
+
+  // Update the section size and rewrite the section header
+  if (ctx.shdr) {
+    ctx.gdb_index->shdr.sh_size = bufsize;
+    ctx.shdr->copy_buf(ctx);
+  }
+}
+
+using E = MOLD_TARGET;
+
+template void write_gdb_index(Context<E> &);
+
+} // namespace mold

src/icf.cc

@@ -65,7 +65,7 @@
 // conditions.
 
 #include "mold.h"
-#include "../sha.h"
+#include "../lib/siphash.h"
 
 #include <array>
 #include <cstdio>
@@ -78,44 +78,43 @@
 
 static constexpr int64_t HASH_SIZE = 16;
 
-typedef std::array<uint8_t, HASH_SIZE> Digest;
+using Digest = std::array<uint8_t, HASH_SIZE>;
 
 namespace std {
-template<> struct hash<Digest> {
+template <> struct hash<Digest> {
   size_t operator()(const Digest &k) const {
-    return *(int64_t *)&k[0];
+    static_assert(sizeof(size_t) <= HASH_SIZE);
+    size_t val;
+    memcpy(&val, k.data(), sizeof(size_t));
+    return val;
   }
 };
 }
 
-namespace mold::elf {
+namespace mold {
 
-class BitVector {
-public:
-  BitVector(u32 size) : vec((size + 7) / 8) {}
-  bool get(u32 idx) const { return vec[idx / 8] & (1 << (idx % 8)); }
-  void set(u32 idx) { vec[idx / 8] |= 1 << (idx % 8); }
-
-private:
-  std::vector<u8> vec;
-};
+static u8 hmac_key[16];
 
 template <typename E>
 static void uniquify_cies(Context<E> &ctx) {
   Timer t(ctx, "uniquify_cies");
   std::vector<CieRecord<E> *> cies;
 
+  auto find = [&](CieRecord<E> &cie) -> i64 {
+    for (i64 i = 0; i < cies.size(); i++)
+      if (cie_equals(cie, *cies[i]))
+        return i;
+    return -1;
+  };
+
   for (ObjectFile<E> *file : ctx.objs) {
     for (CieRecord<E> &cie : file->cies) {
-      for (i64 i = 0; i < cies.size(); i++) {
-        if (cie.equals(*cies[i])) {
-          cie.icf_idx = i;
-          goto found;
-        }
+      if (i64 idx = find(cie); idx != -1) {
+        cie.icf_idx = idx;
+      } else {
+        cie.icf_idx = cies.size();
+        cies.push_back(&cie);
       }
-      cie.icf_idx = cies.size();
-      cies.push_back(&cie);
-    found:;
     }
   }
 }
@@ -125,30 +124,18 @@ static bool is_eligible(Context<E> &ctx, InputSection<E> &isec) {
   const ElfShdr<E> &shdr = isec.shdr();
   std::string_view name = isec.name();
 
-  bool is_alloc = (shdr.sh_flags & SHF_ALLOC);
-  bool is_exec = (shdr.sh_flags & SHF_EXECINSTR) ||
-                 ctx.arg.ignore_data_address_equality;
-  bool is_relro = (name == ".data.rel.ro" ||
-                   name.starts_with(".data.rel.ro."));
-  bool is_readonly = !(shdr.sh_flags & SHF_WRITE) || is_relro;
-  bool is_bss = (shdr.sh_type == SHT_NOBITS);
-  bool is_empty = (shdr.sh_size == 0);
-  bool is_init = (shdr.sh_type == SHT_INIT_ARRAY || name == ".init");
-  bool is_fini = (shdr.sh_type == SHT_FINI_ARRAY || name == ".fini");
-  bool is_enumerable = is_c_identifier(name);
-  bool is_addr_taken = !ctx.arg.icf_all && isec.address_significant;
+  if (shdr.sh_size == 0 || !(shdr.sh_flags & SHF_ALLOC) ||
+      shdr.sh_type == SHT_NOBITS || is_c_identifier(name))
+    return false;
 
-  return is_alloc && is_exec && is_readonly && !is_bss && !is_empty &&
-         !is_init && !is_fini && !is_enumerable && !is_addr_taken;
-}
+  if (shdr.sh_flags & SHF_EXECINSTR)
+    return (ctx.arg.icf_all || !isec.address_taken) &&
+           name != ".init" && name != ".fini";
 
-static Digest digest_final(SHA256Hash &sha) {
-  u8 buf[SHA256_SIZE];
-  sha.finish(buf);
-
-  Digest digest;
-  memcpy(digest.data(), buf, HASH_SIZE);
-  return digest;
+  bool is_readonly = !(shdr.sh_flags & SHF_WRITE);
+  bool is_relro = isec.name().starts_with(".data.rel.ro");
+  return (ctx.arg.ignore_data_address_equality || !isec.address_taken) &&
+         (is_readonly || is_relro);
 }
 
 template <typename E>
@@ -244,15 +231,15 @@ static void merge_leaf_nodes(Context<E> &ctx) {
 
 template <typename E>
 static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
-  SHA256Hash sha;
+  SipHash13_128 hasher(hmac_key);
 
   auto hash = [&](auto val) {
-    sha.update((u8 *)&val, sizeof(val));
+    hasher.update((u8 *)&val, sizeof(val));
   };
 
   auto hash_string = [&](std::string_view str) {
     hash(str.size());
-    sha.update((u8 *)str.data(), str.size());
+    hasher.update((u8 *)str.data(), str.size());
   };
 
   auto hash_symbol = [&](Symbol<E> &sym) {
@@ -308,7 +295,9 @@ static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
     hash_symbol(*isec.file.symbols[rel.r_sym]);
   }
 
-  return digest_final(sha);
+  Digest digest;
+  hasher.finish(digest.data());
+  return digest;
 }
 
 template <typename E>
@@ -409,7 +398,7 @@ static void gather_edges(Context<E> &ctx,
 template <typename E>
 static i64 propagate(std::span<std::vector<Digest>> digests,
                      std::span<u32> edges, std::span<u32> edge_indices,
-                     bool &slot, BitVector &converged,
+                     bool &slot, std::span<u8> converged,
                      tbb::affinity_partitioner &ap) {
   static Counter round("icf_round");
   round++;
@@ -418,24 +407,24 @@ static i64 propagate(std::span<std::vector<Digest>> digests,
   tbb::enumerable_thread_specific<i64> changed;
 
   tbb::parallel_for((i64)0, num_digests, [&](i64 i) {
-    if (converged.get(i))
+    if (converged[i])
       return;
 
-    SHA256Hash sha;
-    sha.update(digests[2][i].data(), HASH_SIZE);
+    SipHash13_128 hasher(hmac_key);
+    hasher.update(digests[2][i].data(), HASH_SIZE);
 
     i64 begin = edge_indices[i];
     i64 end = (i + 1 == num_digests) ? edges.size() : edge_indices[i + 1];
 
     for (i64 j : edges.subspan(begin, end - begin))
-      sha.update(digests[slot][j].data(), HASH_SIZE);
+      hasher.update(digests[slot][j].data(), HASH_SIZE);
 
-    digests[!slot][i] = digest_final(sha);
+    hasher.finish(digests[!slot][i].data());
 
     if (digests[slot][i] == digests[!slot][i]) {
       // This node has converged. Skip further iterations as it will
       // yield the same hash.
-      converged.set(i);
+      converged[i] = true;
     } else {
       changed.local()++;
     }
@@ -487,17 +476,17 @@ static void print_icf_sections(Context<E> &ctx) {
     if (begin == end)
       continue;
 
-    SyncOut(ctx) << "selected section " << *leader;
+    Out(ctx) << "selected section " << *leader;
 
     i64 n = 0;
     for (auto it = begin; it != end; it++) {
-      SyncOut(ctx) << "  removing identical section " << *it->second;
+      Out(ctx) << "  removing identical section " << *it->second;
       n++;
     }
     saved_bytes += leader->contents.size() * n;
   }
 
-  SyncOut(ctx) << "ICF saved " << saved_bytes << " bytes";
+  Out(ctx) << "ICF saved " << saved_bytes << " bytes";
 }
 
 template <typename E>
@@ -506,6 +495,8 @@ void icf_sections(Context<E> &ctx) {
   if (ctx.objs.empty())
     return;
 
+  get_random_bytes(hmac_key, sizeof(hmac_key));
+
   uniquify_cies(ctx);
   merge_leaf_nodes(ctx);
 
@@ -530,7 +521,7 @@ void icf_sections(Context<E> &ctx) {
   std::vector<u32> edge_indices;
   gather_edges<E>(ctx, sections, edges, edge_indices);
 
-  BitVector converged(digests[0].size());
+  std::vector<u8> converged(digests[0].size());
   bool slot = 0;
 
   // Execute the propagation rounds until convergence is obtained.
@@ -573,7 +564,7 @@ void icf_sections(Context<E> &ctx) {
     }
   }
 
-  // Group sections by SHA digest.
+  // Group sections by hash values.
   {
     Timer t(ctx, "group");
 
@@ -608,7 +599,7 @@ void icf_sections(Context<E> &ctx) {
     static Counter eliminated("icf_eliminated");
     tbb::parallel_for_each(ctx.objs, [](ObjectFile<E> *file) {
       for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
-        if (isec && isec->is_alive && isec->is_killed_by_icf()) {
+        if (isec && isec->is_alive && isec->icf_removed()) {
           isec->kill();
           eliminated++;
         }
@@ -621,4 +612,4 @@ using E = MOLD_TARGET;
 
 template void icf_sections(Context<E> &ctx);
 
-} // namespace mold::elf
+} // namespace mold

src/input-sections.cc

@@ -0,0 +1,440 @@
+#include "mold.h"
+
+#include <limits>
+#include <zlib.h>
+#include <zstd.h>
+
+namespace mold {
+
+static i64 to_p2align(u64 alignment) {
+  if (alignment == 0)
+    return 0;
+  return std::countr_zero(alignment);
+}
+
+template <typename E>
+bool cie_equals(const CieRecord<E> &a, const CieRecord<E> &b) {
+  if (a.get_contents() != b.get_contents())
+    return false;
+
+  std::span<const ElfRel<E>> x = a.get_rels();
+  std::span<const ElfRel<E>> y = b.get_rels();
+  if (x.size() != y.size())
+    return false;
+
+  for (i64 i = 0; i < x.size(); i++)
+    if (x[i].r_offset - a.input_offset != y[i].r_offset - b.input_offset ||
+        x[i].r_type != y[i].r_type ||
+        a.file.symbols[x[i].r_sym] != b.file.symbols[y[i].r_sym] ||
+        get_addend(a.input_section, x[i]) != get_addend(b.input_section, y[i]))
+      return false;
+  return true;
+}
+
+template <typename E>
+InputSection<E>::InputSection(Context<E> &ctx, ObjectFile<E> &file, i64 shndx)
+  : file(file), shndx(shndx) {
+  if (shndx < file.elf_sections.size())
+    contents = {(char *)file.mf->data + shdr().sh_offset, (size_t)shdr().sh_size};
+
+  if (shdr().sh_flags & SHF_COMPRESSED) {
+    ElfChdr<E> &chdr = *(ElfChdr<E> *)&contents[0];
+    sh_size = chdr.ch_size;
+    p2align = to_p2align(chdr.ch_addralign);
+  } else {
+    sh_size = shdr().sh_size;
+    p2align = to_p2align(shdr().sh_addralign);
+  }
+
+  // Sections may have been compressed. We usually uncompress them
+  // directly into the mmap'ed output file, but we want to uncompress
+  // early for REL-type ELF types to read relocation addends from
+  // section contents. For RELA-type, we don't need to do this because
+  // addends are in relocations.
+  //
+  // SH-4 stores addends to sections despite being RELA, which is a
+  // special (and buggy) case.
+  if constexpr (!E::is_rela || is_sh4<E>)
+    uncompress(ctx);
+}
+
+template <typename E>
+void InputSection<E>::uncompress(Context<E> &ctx) {
+  if (!(shdr().sh_flags & SHF_COMPRESSED) || uncompressed)
+    return;
+
+  u8 *buf = new u8[sh_size];
+  copy_contents(ctx, buf);
+  contents = std::string_view((char *)buf, sh_size);
+  ctx.string_pool.emplace_back(buf);
+  uncompressed = true;
+}
+
+template <typename E>
+void InputSection<E>::copy_contents(Context<E> &ctx, u8 *buf) {
+  if (!(shdr().sh_flags & SHF_COMPRESSED) || uncompressed) {
+    memcpy(buf, contents.data(), contents.size());
+    return;
+  }
+
+  if (contents.size() < sizeof(ElfChdr<E>))
+    Fatal(ctx) << *this << ": corrupted compressed section";
+
+  ElfChdr<E> &hdr = *(ElfChdr<E> *)&contents[0];
+  std::string_view data = contents.substr(sizeof(ElfChdr<E>));
+
+  switch (hdr.ch_type) {
+  case ELFCOMPRESS_ZLIB: {
+    unsigned long size = sh_size;
+    if (::uncompress(buf, &size, (u8 *)data.data(), data.size()) != Z_OK)
+      Fatal(ctx) << *this << ": uncompress failed";
+    assert(size == sh_size);
+    break;
+  }
+  case ELFCOMPRESS_ZSTD:
+    if (ZSTD_decompress(buf, sh_size, (u8 *)data.data(), data.size()) != sh_size)
+      Fatal(ctx) << *this << ": ZSTD_decompress failed";
+    break;
+  default:
+    Fatal(ctx) << *this << ": unsupported compression type: 0x"
+               << std::hex << hdr.ch_type;
+  }
+}
+
+typedef enum : u8 { NONE, ERROR, COPYREL, PLT, CPLT } Action;
+
+template <typename E>
+static void do_action(Context<E> &ctx, Action action, InputSection<E> &isec,
+                      Symbol<E> &sym, const ElfRel<E> &rel) {
+  switch (action) {
+  case NONE:
+    break;
+  case ERROR:
+    Error(ctx) << isec << ": " << rel << " relocation at offset 0x"
+               << std::hex << rel.r_offset << " against symbol `"
+               << sym << "' can not be used; recompile with -fPIC";
+    break;
+  case COPYREL:
+    // Create a copy relocation
+    sym.flags |= NEEDS_COPYREL;
+    break;
+  case PLT:
+    // Create a PLT entry
+    sym.flags |= NEEDS_PLT;
+    break;
+  case CPLT:
+    // Create a canonical PLT entry
+    sym.flags |= NEEDS_CPLT;
+    break;
+  }
+}
+
+template <typename E>
+static inline i64 get_output_type(Context<E> &ctx) {
+  if (ctx.arg.shared)
+    return 0;
+  if (ctx.arg.pie)
+    return 1;
+  return 2;
+}
+
+template <typename E>
+static inline i64 get_sym_type(Symbol<E> &sym) {
+  if (sym.is_absolute())
+    return 0;
+  if (!sym.is_imported)
+    return 1;
+  if (sym.get_type() != STT_FUNC)
+    return 2;
+  return 3;
+}
+
+template <typename E>
+void InputSection<E>::scan_pcrel(Context<E> &ctx, Symbol<E> &sym,
+                                 const ElfRel<E> &rel) {
+  // This is for PC-relative relocations (e.g. R_X86_64_PC32).
+  // We cannot promote them to dynamic relocations because the dynamic
+  // linker generally does not support PC-relative relocations.
+  static Action table[][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  ERROR,    NONE,    ERROR,         PLT    },  // Shared object
+    {  ERROR,    NONE,    COPYREL,       CPLT   },  // Position-independent exec
+    {  NONE,     NONE,    COPYREL,       CPLT   },  // Position-dependent exec
+  };
+
+  Action action = table[get_output_type(ctx)][get_sym_type(sym)];
+  do_action(ctx, action, *this, sym, rel);
+}
+
+template <typename E>
+void InputSection<E>::scan_absrel(Context<E> &ctx, Symbol<E> &sym,
+                                  const ElfRel<E> &rel) {
+  // This is a decision table for absolute relocations that is smaller
+  // than the pointer size (e.g. R_X86_64_32). Since the dynamic linker
+  // generally does not support dynamic relocations smaller than the
+  // pointer size, we need to report an error if a relocation cannot be
+  // resolved at link-time.
+  static Action table[][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  NONE,     ERROR,   ERROR,         ERROR },  // Shared object
+    {  NONE,     ERROR,   ERROR,         ERROR },  // Position-independent exec
+    {  NONE,     NONE,    COPYREL,       CPLT  },  // Position-dependent exec
+  };
+
+  Action action = table[get_output_type(ctx)][get_sym_type(sym)];
+  do_action(ctx, action, *this, sym, rel);
+}
+
+template <typename E>
+void InputSection<E>::scan_tlsdesc(Context<E> &ctx, Symbol<E> &sym) {
+  if (ctx.arg.static_ || (ctx.arg.relax && sym.is_tprel_linktime_const(ctx))) {
+    // Relax TLSDESC to Local Exec. In this case, we directly materialize
+    // a TP-relative offset, so no dynamic relocation is needed.
+    //
+    // TLSDESC relocs must always be relaxed for statically-linked
+    // executables even if -no-relax is given. It is because a
+    // statically-linked executable doesn't contain a trampoline
+    // function needed for TLSDESC.
+  } else if (ctx.arg.relax && sym.is_tprel_runtime_const(ctx)) {
+    // In this condition, TP-relative offset of a thread-local variable
+    // is known at process startup time, so we can relax TLSDESC to the
+    // code that reads the TP-relative offset from GOT and add TP to it.
+    sym.flags |= NEEDS_GOTTP;
+  } else {
+    // If no relaxation is doable, we simply create a TLSDESC dynamic
+    // relocation.
+    sym.flags |= NEEDS_TLSDESC;
+  }
+}
+
+template <typename E>
+void InputSection<E>::check_tlsle(Context<E> &ctx, Symbol<E> &sym,
+                                  const ElfRel<E> &rel) {
+  if (ctx.arg.shared)
+    Error(ctx) << *this << ": relocation " << rel << " against `" << sym
+               << "` can not be used when making a shared object;"
+               << " recompile with -fPIC";
+}
+
+template <typename E>
+void InputSection<E>::write_to(Context<E> &ctx, u8 *buf) {
+  if (shdr().sh_type == SHT_NOBITS || sh_size == 0)
+    return;
+
+  // Copy data. In RISC-V and LoongArch object files, sections are not
+  // atomic unit of copying because of relaxation. That is, some
+  // relocations are allowed to remove bytes from the middle of a
+  // section and shrink the overall size of it.
+  if constexpr (is_riscv<E> || is_loongarch<E>) {
+    if (extra.r_deltas.empty()) {
+      // If a section is not relaxed, we can copy it as a one big chunk.
+      copy_contents(ctx, buf);
+    } else {
+      // A relaxed section is copied piece-wise.
+      std::span<const ElfRel<E>> rels = get_rels(ctx);
+      u8 *buf2 = buf;
+      i64 pos = 0;
+
+      for (i64 i = 0; i < rels.size(); i++) {
+        i64 delta = extra.r_deltas[i + 1] - extra.r_deltas[i];
+        if (delta == 0)
+          continue;
+        assert(delta > 0);
+
+        const ElfRel<E> &r = rels[i];
+        memcpy(buf2, contents.data() + pos, r.r_offset - pos);
+        buf2 += r.r_offset - pos;
+        pos = r.r_offset + delta;
+      }
+      memcpy(buf2, contents.data() + pos, contents.size() - pos);
+    }
+  } else {
+    copy_contents(ctx, buf);
+  }
+
+  // Apply relocations
+  if (!ctx.arg.relocatable) {
+    if (shdr().sh_flags & SHF_ALLOC)
+      apply_reloc_alloc(ctx, buf);
+    else
+      apply_reloc_nonalloc(ctx, buf);
+  }
+}
+
+// Get the name of a function containin a given offset.
+template <typename E>
+std::string_view
+InputSection<E>::get_func_name(Context<E> &ctx, i64 offset) const {
+  for (Symbol<E> *sym : file.symbols) {
+    if (sym->file == &file) {
+      const ElfSym<E> &esym = sym->esym();
+      if (esym.st_shndx == shndx && esym.st_type == STT_FUNC &&
+          esym.st_value <= offset && offset < esym.st_value + esym.st_size) {
+        if (ctx.arg.demangle)
+          return demangle(*sym);
+        return sym->name();
+      }
+    }
+  }
+  return "";
+}
+
+// Test if the symbol a given relocation refers to has already been resolved.
+// If not, record that error and returns true.
+template <typename E>
+bool InputSection<E>::record_undef_error(Context<E> &ctx, const ElfRel<E> &rel) {
+  // If a relocation refers to a linker-synthesized symbol for a
+  // section fragment, it's always been resolved.
+  if (file.elf_syms.size() <= rel.r_sym)
+    return false;
+
+  Symbol<E> &sym = *file.symbols[rel.r_sym];
+  const ElfSym<E> &esym = file.elf_syms[rel.r_sym];
+
+  // If a symbol is defined in a comdat group, and the comdat group is
+  // discarded, the symbol may not have an owner. It is technically an
+  // violation of the One Definition Rule, so it is a programmer's fault.
+  if (!sym.file) {
+    Error(ctx) << *this << ": " << sym << " refers to a discarded COMDAT section"
+               << " probably due to an ODR violation";
+    return true;
+  }
+
+  auto record = [&] {
+    std::stringstream ss;
+    if (std::string_view source = file.get_source_name(); !source.empty())
+      ss << ">>> referenced by " << source << "\n";
+    else
+      ss << ">>> referenced by " << *this << "\n";
+
+    ss << ">>>               " << file;
+    if (std::string_view func = get_func_name(ctx, rel.r_offset); !func.empty())
+      ss << ":(" << func << ")";
+    ss << '\n';
+
+    typename decltype(ctx.undef_errors)::accessor acc;
+    ctx.undef_errors.insert(acc, {&sym, {}});
+    acc->second.push_back(ss.str());
+  };
+
+  // A non-weak undefined symbol must be promoted to an imported symbol
+  // or resolved to an defined symbol. Otherwise, we need to report an
+  // error or warn on it.
+  //
+  // Every ELF file has an absolute local symbol as its first symbol.
+  // Referring to that symbol is always valid.
+  bool is_undef = esym.is_undef() && !esym.is_weak() && sym.sym_idx;
+
+  if (is_undef && sym.esym().is_undef()) {
+    if (ctx.arg.unresolved_symbols == UNRESOLVED_ERROR && !sym.is_imported) {
+      record();
+      return true;
+    }
+    if (ctx.arg.unresolved_symbols == UNRESOLVED_WARN) {
+      record();
+      return false;
+    }
+  }
+
+  return false;
+}
+
+template <typename E>
+MergeableSection<E>::MergeableSection(Context<E> &ctx, MergedSection<E> &parent,
+                                      std::unique_ptr<InputSection<E>> &isec)
+  : parent(parent), section(std::move(isec)), p2align(section->p2align) {
+  section->uncompress(ctx);
+
+  std::scoped_lock lock(parent.mu);
+  parent.members.push_back(this);
+}
+
+static size_t find_null(std::string_view data, i64 pos, i64 entsize) {
+  if (entsize == 1)
+    return data.find('\0', pos);
+
+  for (; pos <= data.size() - entsize; pos += entsize)
+    if (data.substr(pos, entsize).find_first_not_of('\0') == data.npos)
+      return pos;
+
+  return data.npos;
+}
+
+// Mergeable sections (sections with SHF_MERGE bit) typically contain
+// string literals. Linker is expected to split the section contents
+// into null-terminated strings, merge them with mergeable strings
+// from other object files, and emit uniquified strings to an output
+// file.
+//
+// This mechanism reduces the size of an output file. If two source
+// files happen to contain the same string literal, the output will
+// contain only a single copy of it.
+//
+// It is less common than string literals, but mergeable sections can
+// contain fixed-sized read-only records too.
+//
+// This function splits the section contents into small pieces that we
+// call "section fragments". Section fragment is a unit of merging.
+//
+// We do not support mergeable sections that have relocations.
+template <typename E>
+void MergeableSection<E>::split_contents(Context<E> &ctx) {
+  std::string_view data = section->contents;
+  if (data.size() > UINT32_MAX)
+    Fatal(ctx) << *section
+               << ": mergeable section too large";
+
+  i64 entsize = parent.shdr.sh_entsize;
+
+  // Split sections
+  if (parent.shdr.sh_flags & SHF_STRINGS) {
+    for (i64 pos = 0; pos < data.size();) {
+      frag_offsets.push_back(pos);
+      size_t end = find_null(data, pos, entsize);
+      if (end == data.npos)
+        Fatal(ctx) << *section << ": string is not null terminated";
+      pos = end + entsize;
+    }
+  } else {
+    if (data.size() % entsize)
+      Fatal(ctx) << *section << ": section size is not multiple of sh_entsize";
+    frag_offsets.reserve(data.size() / entsize);
+
+    for (i64 pos = 0; pos < data.size(); pos += entsize)
+      frag_offsets.push_back(pos);
+  }
+
+  // Compute hashes for section pieces
+  HyperLogLog estimator;
+  hashes.reserve(frag_offsets.size());
+
+  for (i64 i = 0; i < frag_offsets.size(); i++) {
+    u64 hash = hash_string(get_contents(i));
+    hashes.push_back(hash);
+    estimator.insert(hash);
+  }
+
+  parent.estimator.merge(estimator);
+
+  static Counter counter("string_fragments");
+  counter += frag_offsets.size();
+}
+
+template <typename E>
+void MergeableSection<E>::resolve_contents(Context<E> &ctx) {
+  fragments.reserve(frag_offsets.size());
+  for (i64 i = 0; i < frag_offsets.size(); i++)
+    fragments.push_back(parent.insert(ctx, get_contents(i), hashes[i], p2align));
+
+  // Reclaim memory as we'll never use this vector again
+  hashes.clear();
+  hashes.shrink_to_fit();
+}
+
+using E = MOLD_TARGET;
+
+template bool cie_equals(const CieRecord<E> &, const CieRecord<E> &);
+template class InputSection<E>;
+template class MergeableSection<E>;
+
+} // namespace mold

src/linker-script.cc

@@ -0,0 +1,423 @@
+// On Linux, /usr/lib/x86_64-linux-gnu/libc.so is not actually
+// a shared object file but an ASCII text file containing a linker
+// script to include a "real" libc.so file. Therefore, we need to
+// support a (very limited) subset of the linker script language.
+
+#include "mold.h"
+
+#include <cctype>
+#include <iomanip>
+
+namespace mold {
+
+static std::string_view get_line(std::string_view input, const char *pos) {
+  assert(input.data() <= pos);
+  assert(pos < input.data() + input.size());
+
+  i64 start = input.rfind('\n', pos - input.data());
+  if (start == input.npos)
+    start = 0;
+  else
+    start++;
+
+  i64 end = input.find('\n', pos - input.data());
+  if (end == input.npos)
+    end = input.size();
+
+  return input.substr(start, end - start);
+}
+
+template <typename E>
+void Script<E>::error(std::string_view pos, std::string msg) {
+  std::string_view input = mf->get_contents();
+  std::string_view line = get_line(input, pos.data());
+
+  i64 lineno = 1;
+  for (i64 i = 0; input.data() + i < line.data(); i++)
+    if (input[i] == '\n')
+      lineno++;
+
+  std::string label = mf->name + ":" + std::to_string(lineno) + ": ";
+  i64 indent = strlen("mold: fatal: ") + label.size();
+  i64 column = pos.data() - line.data();
+
+  Fatal(ctx) << label << line << "\n"
+             << std::string(indent + column, ' ') << "^ " << msg;
+}
+
+template <typename E>
+void Script<E>::tokenize() {
+  std::string_view input = mf->get_contents();
+
+  while (!input.empty()) {
+    if (isspace(input[0])) {
+      input = input.substr(1);
+      continue;
+    }
+
+    if (input.starts_with("/*")) {
+      i64 pos = input.find("*/", 2);
+      if (pos == std::string_view::npos)
+        error(input, "unclosed comment");
+      input = input.substr(pos + 2);
+      continue;
+    }
+
+    if (input[0] == '#') {
+      i64 pos = input.find("\n", 1);
+      if (pos == std::string_view::npos)
+        break;
+      input = input.substr(pos + 1);
+      continue;
+    }
+
+    if (input[0] == '"') {
+      i64 pos = input.find('"', 1);
+      if (pos == std::string_view::npos)
+        error(input, "unclosed string literal");
+      tokens.push_back(input.substr(0, pos + 1));
+      input = input.substr(pos + 1);
+      continue;
+    }
+
+    i64 pos = input.find_first_not_of(
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+      "0123456789_.$/\\~=+[]*?-!^:");
+
+    if (pos == 0)
+      pos = 1;
+    else if (pos == input.npos)
+      pos = input.size();
+
+    tokens.push_back(input.substr(0, pos));
+    input = input.substr(pos);
+  }
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::skip(std::span<std::string_view> tok, std::string_view str) {
+  if (tok.empty())
+    Fatal(ctx) << mf->name << ": expected '" << str << "', but got EOF";
+  if (tok[0] != str)
+    error(tok[0], "expected '" + std::string(str) + "'");
+  return tok.subspan(1);
+}
+
+static std::string_view unquote(std::string_view s) {
+  if (s.size() > 0 && s[0] == '"') {
+    assert(s[s.size() - 1] == '"');
+    return s.substr(1, s.size() - 2);
+  }
+  return s;
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::read_output_format(std::span<std::string_view> tok) {
+  tok = skip(tok, "(");
+  while (!tok.empty() && tok[0] != ")")
+    tok = tok.subspan(1);
+  if (tok.empty())
+    Fatal(ctx) << mf->name << ": expected ')', but got EOF";
+  return tok.subspan(1);
+}
+
+template <typename E>
+static bool is_in_sysroot(Context<E> &ctx, std::string path) {
+  std::string rel = std::filesystem::relative(path, ctx.arg.sysroot).string();
+  return rel != "." && !rel.starts_with("../");
+}
+
+template <typename E>
+MappedFile *Script<E>::resolve_path(std::string_view tok, bool check_target) {
+  std::string str(unquote(tok));
+
+  auto open = [&](const std::string &path) -> MappedFile * {
+    MappedFile *mf = open_file(ctx, path);
+    if (!mf)
+      return nullptr;
+
+    if (check_target) {
+      std::string_view target = get_machine_type(ctx, rctx, mf);
+      if (!target.empty() && target != E::name) {
+        Warn(ctx) << path << ": skipping incompatible file: " << target
+                  << " (e_machine " << (int)E::e_machine << ")";
+        return nullptr;
+      }
+    }
+    return mf;
+  };
+
+  // GNU ld prepends the sysroot if a pathname starts with '/' and the
+  // script being processed is in the sysroot. We do the same.
+  if (str.starts_with('/') && is_in_sysroot(ctx, mf->name))
+    return must_open_file(ctx, ctx.arg.sysroot + str);
+
+  if (str.starts_with('=')) {
+    std::string path;
+    if (ctx.arg.sysroot.empty())
+      path = str.substr(1);
+    else
+      path = ctx.arg.sysroot + str.substr(1);
+    return must_open_file(ctx, path);
+  }
+
+  if (str.starts_with("-l"))
+    return find_library(ctx, rctx, str.substr(2));
+
+  if (!str.starts_with('/'))
+    if (MappedFile *mf2 = open(path_clean(mf->name + "/../" + str)))
+      return mf2;
+
+  if (MappedFile *mf = open(str))
+    return mf;
+
+  for (std::string_view dir : ctx.arg.library_paths) {
+    std::string path = std::string(dir) + "/" + str;
+    if (MappedFile *mf = open(path))
+      return mf;
+  }
+
+  error(tok, "library not found: " + str);
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::read_group(std::span<std::string_view> tok) {
+  tok = skip(tok, "(");
+
+  while (!tok.empty() && tok[0] != ")") {
+    if (tok[0] == "AS_NEEDED") {
+      bool orig = rctx.as_needed;
+      rctx.as_needed = true;
+      tok = read_group(tok.subspan(1));
+      rctx.as_needed = orig;
+      continue;
+    }
+
+    MappedFile *mf = resolve_path(tok[0], true);
+    read_file(ctx, rctx, mf);
+    tok = tok.subspan(1);
+  }
+
+  if (tok.empty())
+    Fatal(ctx) << mf->name << ": expected ')', but got EOF";
+  return tok.subspan(1);
+}
+
+template <typename E>
+void Script<E>::parse_linker_script() {
+  std::call_once(once, [&] { tokenize(); });
+  std::span<std::string_view> tok = tokens;
+
+  while (!tok.empty()) {
+    if (tok[0] == "OUTPUT_FORMAT") {
+      tok = read_output_format(tok.subspan(1));
+    } else if (tok[0] == "INPUT" || tok[0] == "GROUP") {
+      tok = read_group(tok.subspan(1));
+    } else if (tok[0] == "VERSION") {
+      tok = tok.subspan(1);
+      tok = skip(tok, "{");
+      tok = read_version_script(tok);
+      tok = skip(tok, "}");
+    } else if (tok.size() > 3 && tok[1] == "=" && tok[3] == ";") {
+      ctx.arg.defsyms.emplace_back(get_symbol(ctx, unquote(tok[0])),
+                                   get_symbol(ctx, unquote(tok[2])));
+      tok = tok.subspan(4);
+    } else if (tok[0] == ";") {
+      tok = tok.subspan(1);
+    } else {
+      error(tok[0], "unknown linker script token");
+    }
+  }
+}
+
+template <typename E>
+std::string_view Script<E>::get_script_output_type() {
+  std::call_once(once, [&] { tokenize(); });
+  std::span<std::string_view> tok = tokens;
+
+  if (tok.size() >= 3 && tok[0] == "OUTPUT_FORMAT" && tok[1] == "(") {
+    if (tok[2] == "elf64-x86-64")
+      return X86_64::name;
+    if (tok[2] == "elf32-i386")
+      return I386::name;
+  }
+
+  if (tok.size() >= 3 && (tok[0] == "INPUT" || tok[0] == "GROUP") &&
+      tok[1] == "(")
+    if (MappedFile *mf = resolve_path(tok[2], false))
+      return get_machine_type(ctx, rctx, mf);
+  return "";
+}
+
+static bool read_label(std::span<std::string_view> &tok, std::string label) {
+  if (tok.size() >= 1 && tok[0] == label + ":") {
+    tok = tok.subspan(1);
+    return true;
+  }
+
+  if (tok.size() >= 2 && tok[0] == label && tok[1] == ":") {
+    tok = tok.subspan(2);
+    return true;
+  }
+  return false;
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::read_version_script_commands(std::span<std::string_view> tok,
+                                     std::string_view ver_str, u16 ver_idx,
+                                     bool is_global, bool is_cpp) {
+  while (!tok.empty() && tok[0] != "}") {
+    if (read_label(tok, "global")) {
+      is_global = true;
+      continue;
+    }
+
+    if (read_label(tok, "local")) {
+      is_global = false;
+      continue;
+    }
+
+    if (tok[0] == "extern") {
+      tok = tok.subspan(1);
+
+      if (!tok.empty() && tok[0] == "\"C\"") {
+        tok = tok.subspan(1);
+        tok = skip(tok, "{");
+        tok = read_version_script_commands(tok, ver_str, ver_idx, is_global, false);
+      } else {
+        tok = skip(tok, "\"C++\"");
+        tok = skip(tok, "{");
+        tok = read_version_script_commands(tok, ver_str, ver_idx, is_global, true);
+      }
+
+      tok = skip(tok, "}");
+      tok = skip(tok, ";");
+      continue;
+    }
+
+    if (tok[0] == "*") {
+      ctx.default_version = (is_global ? ver_idx : (u32)VER_NDX_LOCAL);
+    } else if (is_global) {
+      ctx.version_patterns.push_back({unquote(tok[0]), mf->name, ver_str,
+                                      ver_idx, is_cpp});
+    } else {
+      ctx.version_patterns.push_back({unquote(tok[0]), mf->name, ver_str,
+                                      VER_NDX_LOCAL, is_cpp});
+    }
+
+    tok = tok.subspan(1);
+
+    if (!tok.empty() && tok[0] == "}")
+      break;
+    tok = skip(tok, ";");
+  }
+  return tok;
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::read_version_script(std::span<std::string_view> tok) {
+  u16 next_ver = VER_NDX_LAST_RESERVED + ctx.arg.version_definitions.size() + 1;
+
+  while (!tok.empty() && tok[0] != "}") {
+    std::string_view ver_str;
+    u16 ver_idx;
+
+    if (tok[0] == "{") {
+      ver_str = "global";
+      ver_idx = VER_NDX_GLOBAL;
+    } else {
+      ver_str = tok[0];
+      ver_idx = next_ver++;
+      ctx.arg.version_definitions.push_back(std::string(tok[0]));
+      tok = tok.subspan(1);
+    }
+
+    tok = skip(tok, "{");
+    tok = read_version_script_commands(tok, ver_str, ver_idx, true, false);
+    tok = skip(tok, "}");
+    if (!tok.empty() && tok[0] != ";")
+      tok = tok.subspan(1);
+    tok = skip(tok, ";");
+  }
+  return tok;
+}
+
+template <typename E>
+void Script<E>::parse_version_script() {
+  std::call_once(once, [&] { tokenize(); });
+  std::span<std::string_view> tok = tokens;
+  tok = read_version_script(tok);
+  if (!tok.empty())
+    error(tok[0], "trailing garbage token");
+}
+
+template <typename E>
+std::span<std::string_view>
+Script<E>::read_dynamic_list_commands(std::span<std::string_view> tok,
+                                   std::vector<DynamicPattern> &result,
+                                   bool is_cpp) {
+  while (!tok.empty() && tok[0] != "}") {
+    if (tok[0] == "extern") {
+      tok = tok.subspan(1);
+
+      if (!tok.empty() && tok[0] == "\"C\"") {
+        tok = tok.subspan(1);
+        tok = skip(tok, "{");
+        tok = read_dynamic_list_commands(tok, result, false);
+      } else {
+        tok = skip(tok, "\"C++\"");
+        tok = skip(tok, "{");
+        tok = read_dynamic_list_commands(tok, result, true);
+      }
+
+      tok = skip(tok, "}");
+      tok = skip(tok, ";");
+      continue;
+    }
+
+    result.push_back({unquote(tok[0]), "", is_cpp});
+    tok = skip(tok.subspan(1), ";");
+  }
+  return tok;
+}
+
+template <typename E>
+std::vector<DynamicPattern> Script<E>::parse_dynamic_list() {
+  std::call_once(once, [&] { tokenize(); });
+  std::span<std::string_view> tok = tokens;
+  std::vector<DynamicPattern> result;
+
+  tok = skip(tok, "{");
+  tok = read_dynamic_list_commands(tok, result, false);
+  tok = skip(tok, "}");
+  tok = skip(tok, ";");
+
+  if (!tok.empty())
+    error(tok[0], "trailing garbage token");
+
+  for (DynamicPattern &p : result)
+    p.source = mf->name;
+  return result;
+}
+
+template <typename E>
+std::vector<DynamicPattern>
+parse_dynamic_list(Context<E> &ctx, std::string_view path) {
+  ReaderContext rctx;
+  MappedFile *mf = must_open_file(ctx, std::string(path));
+  return Script(ctx, rctx, mf).parse_dynamic_list();
+}
+
+using E = MOLD_TARGET;
+
+template class Script<E>;
+
+template
+std::vector<DynamicPattern> parse_dynamic_list(Context<E> &, std::string_view);
+
+} // namespace mold

src/lto-unix.cc

@@ -95,7 +95,7 @@
 # define LOG std::ostringstream()
 #endif
 
-namespace mold::elf {
+namespace mold {
 
 // Global variables
 // We store LTO-related information to global variables,
@@ -126,7 +126,7 @@ static PluginStatus message(PluginLevel level, const char *fmt, ...) {
 
   switch (level) {
   case LDPL_INFO:
-    SyncOut(ctx) << buf;
+    Out(ctx) << buf;
     break;
   case LDPL_WARNING:
     Warn(ctx) << buf;
@@ -176,9 +176,9 @@ static PluginStatus add_input_file(const char *path) {
   Context<E> &ctx = *gctx<E>;
   static i64 file_priority = 100;
 
-  MappedFile<Context<E>> *mf = MappedFile<Context<E>>::must_open(ctx, path);
+  MappedFile *mf = must_open_file(ctx, path);
 
-  ObjectFile<E> *file = ObjectFile<E>::create(ctx, mf, "", false);
+  ObjectFile<E> *file = new ObjectFile<E>(ctx, mf, "", false);
   ctx.obj_pool.emplace_back(file);
   lto_objects<E>.push_back(file);
 
@@ -200,10 +200,7 @@ static PluginStatus release_input_file(const void *handle) {
   LOG << "release_input_file\n";
 
   ObjectFile<E> &file = *(ObjectFile<E> *)handle;
-  if (file.mf->fd != -1) {
-    close(file.mf->fd);
-    file.mf->fd = -1;
-  }
+  file.mf->close_fd();
   return LDPS_OK;
 }
 
@@ -427,7 +424,7 @@ get_api_version(const char *plugin_identifier,
   if (LAPI_V1 < minimal_api_supported)
     Fatal(*gctx<E>) << "LTO plugin does not support V0 or V1 API";
 
-  std::string version = mold_version + "\0"s;
+  std::string version = get_mold_version() + "\0"s;
 
   *linker_identifier = "mold";
   *linker_version = version.data();
@@ -439,72 +436,77 @@ get_api_version(const char *plugin_identifier,
   return LAPI_V0;
 }
 
+// dlopen the linker plugin file
 template <typename E>
-static void load_plugin(Context<E> &ctx) {
-  assert(phase == 0);
-  phase = 1;
-  gctx<E> = &ctx;
+static void load_lto_plugin(Context<E> &ctx) {
+  static std::once_flag flag;
 
-  void *handle = dlopen(ctx.arg.plugin.c_str(), RTLD_NOW | RTLD_GLOBAL);
-  if (!handle)
-    Fatal(ctx) << "could not open plugin file: " << dlerror();
+  std::call_once(flag, [&] {
+    assert(phase == 0);
+    phase = 1;
+    gctx<E> = &ctx;
 
-  OnloadFn *onload = (OnloadFn *)dlsym(handle, "onload");
-  if (!onload)
-    Fatal(ctx) << "failed to load plugin " << ctx.arg.plugin << ": "
-               << dlerror();
+    void *handle = dlopen(ctx.arg.plugin.c_str(), RTLD_NOW | RTLD_LOCAL);
+    if (!handle)
+      Fatal(ctx) << "could not open plugin file: " << dlerror();
 
-  auto save = [&](std::string_view str) {
-    return save_string(ctx, std::string(str).c_str()).data();
-  };
+    OnloadFn *onload = (OnloadFn *)dlsym(handle, "onload");
+    if (!onload)
+      Fatal(ctx) << "failed to load plugin " << ctx.arg.plugin << ": "
+                 << dlerror();
 
-  std::vector<PluginTagValue> tv;
-  tv.emplace_back(LDPT_MESSAGE, message<E>);
+    auto save = [&](std::string_view str) {
+      return save_string(ctx, std::string(str).c_str()).data();
+    };
 
-  if (ctx.arg.shared)
-    tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_DYN);
-  else if (ctx.arg.pie)
-    tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_PIE);
-  else
-    tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_EXEC);
+    std::vector<PluginTagValue> tv;
+    tv.emplace_back(LDPT_MESSAGE, message<E>);
 
-  for (std::string_view opt : ctx.arg.plugin_opt)
-    tv.emplace_back(LDPT_OPTION, save(opt));
+    if (ctx.arg.shared)
+      tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_DYN);
+    else if (ctx.arg.pie)
+      tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_PIE);
+    else
+      tv.emplace_back(LDPT_LINKER_OUTPUT, LDPO_EXEC);
 
-  tv.emplace_back(LDPT_REGISTER_CLAIM_FILE_HOOK, register_claim_file_hook<E>);
-  tv.emplace_back(LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
-                  register_all_symbols_read_hook<E>);
-  tv.emplace_back(LDPT_REGISTER_CLEANUP_HOOK, register_cleanup_hook<E>);
-  tv.emplace_back(LDPT_ADD_SYMBOLS, add_symbols);
-  tv.emplace_back(LDPT_GET_SYMBOLS, get_symbols_v1);
-  tv.emplace_back(LDPT_ADD_INPUT_FILE, add_input_file<E>);
-  tv.emplace_back(LDPT_GET_INPUT_FILE, get_input_file);
-  tv.emplace_back(LDPT_RELEASE_INPUT_FILE, release_input_file<E>);
-  tv.emplace_back(LDPT_ADD_INPUT_LIBRARY, add_input_library);
-  tv.emplace_back(LDPT_OUTPUT_NAME, save(ctx.arg.output));
-  tv.emplace_back(LDPT_SET_EXTRA_LIBRARY_PATH, set_extra_library_path);
-  tv.emplace_back(LDPT_GET_VIEW, get_view<E>);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_COUNT, get_input_section_count);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_TYPE, get_input_section_type);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_NAME, get_input_section_name);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_CONTENTS, get_input_section_contents);
-  tv.emplace_back(LDPT_UPDATE_SECTION_ORDER, update_section_order);
-  tv.emplace_back(LDPT_ALLOW_SECTION_ORDERING, allow_section_ordering);
-  tv.emplace_back(LDPT_ADD_SYMBOLS_V2, add_symbols);
-  tv.emplace_back(LDPT_GET_SYMBOLS_V2, get_symbols_v2<E>);
-  tv.emplace_back(LDPT_ALLOW_UNIQUE_SEGMENT_FOR_SECTIONS,
-                  allow_unique_segment_for_sections);
-  tv.emplace_back(LDPT_UNIQUE_SEGMENT_FOR_SECTIONS, unique_segment_for_sections);
-  tv.emplace_back(LDPT_GET_SYMBOLS_V3, get_symbols_v3<E>);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_ALIGNMENT, get_input_section_alignment);
-  tv.emplace_back(LDPT_GET_INPUT_SECTION_SIZE, get_input_section_size);
-  tv.emplace_back(LDPT_REGISTER_NEW_INPUT_HOOK, register_new_input_hook<E>);
-  tv.emplace_back(LDPT_GET_WRAP_SYMBOLS, get_wrap_symbols);
-  tv.emplace_back(LDPT_GET_API_VERSION, get_api_version<E>);
-  tv.emplace_back(LDPT_NULL, 0);
+    for (std::string_view opt : ctx.arg.plugin_opt)
+      tv.emplace_back(LDPT_OPTION, save(opt));
 
-  [[maybe_unused]] PluginStatus status = onload(tv.data());
-  assert(status == LDPS_OK);
+    tv.emplace_back(LDPT_REGISTER_CLAIM_FILE_HOOK, register_claim_file_hook<E>);
+    tv.emplace_back(LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
+                    register_all_symbols_read_hook<E>);
+    tv.emplace_back(LDPT_REGISTER_CLEANUP_HOOK, register_cleanup_hook<E>);
+    tv.emplace_back(LDPT_ADD_SYMBOLS, add_symbols);
+    tv.emplace_back(LDPT_GET_SYMBOLS, get_symbols_v1);
+    tv.emplace_back(LDPT_ADD_INPUT_FILE, add_input_file<E>);
+    tv.emplace_back(LDPT_GET_INPUT_FILE, get_input_file);
+    tv.emplace_back(LDPT_RELEASE_INPUT_FILE, release_input_file<E>);
+    tv.emplace_back(LDPT_ADD_INPUT_LIBRARY, add_input_library);
+    tv.emplace_back(LDPT_OUTPUT_NAME, save(ctx.arg.output));
+    tv.emplace_back(LDPT_SET_EXTRA_LIBRARY_PATH, set_extra_library_path);
+    tv.emplace_back(LDPT_GET_VIEW, get_view<E>);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_COUNT, get_input_section_count);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_TYPE, get_input_section_type);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_NAME, get_input_section_name);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_CONTENTS, get_input_section_contents);
+    tv.emplace_back(LDPT_UPDATE_SECTION_ORDER, update_section_order);
+    tv.emplace_back(LDPT_ALLOW_SECTION_ORDERING, allow_section_ordering);
+    tv.emplace_back(LDPT_ADD_SYMBOLS_V2, add_symbols);
+    tv.emplace_back(LDPT_GET_SYMBOLS_V2, get_symbols_v2<E>);
+    tv.emplace_back(LDPT_ALLOW_UNIQUE_SEGMENT_FOR_SECTIONS,
+                    allow_unique_segment_for_sections);
+    tv.emplace_back(LDPT_UNIQUE_SEGMENT_FOR_SECTIONS, unique_segment_for_sections);
+    tv.emplace_back(LDPT_GET_SYMBOLS_V3, get_symbols_v3<E>);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_ALIGNMENT, get_input_section_alignment);
+    tv.emplace_back(LDPT_GET_INPUT_SECTION_SIZE, get_input_section_size);
+    tv.emplace_back(LDPT_REGISTER_NEW_INPUT_HOOK, register_new_input_hook<E>);
+    tv.emplace_back(LDPT_GET_WRAP_SYMBOLS, get_wrap_symbols);
+    tv.emplace_back(LDPT_GET_API_VERSION, get_api_version<E>);
+    tv.emplace_back(LDPT_NULL, 0);
+
+    [[maybe_unused]] PluginStatus status = onload(tv.data());
+    assert(status == LDPS_OK);
+  });
 }
 
 template <typename E>
@@ -565,7 +567,7 @@ static ElfSym<E> to_elf_sym(PluginSymbol &psym) {
 // Returns false if it's GCC.
 template <typename E>
 static bool is_llvm(Context<E> &ctx) {
-  return ctx.arg.plugin.ends_with("LLVMgold.so");
+  return ctx.arg.plugin.find("LLVMgold.") != ctx.arg.plugin.npos;
 }
 
 // Returns true if a given linker plugin supports the get_symbols_v3 API.
@@ -576,7 +578,28 @@ static bool supports_v3_api(Context<E> &ctx) {
 }
 
 template <typename E>
-ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+static PluginInputFile
+create_plugin_input_file(Context<E> &ctx, MappedFile *mf) {
+  PluginInputFile file;
+  MappedFile *mf2 = mf->parent ? mf->parent : mf;
+
+  file.name = save_string(ctx, mf2->name).data();
+  file.offset = mf->get_offset();
+  file.filesize = mf->size;
+
+  mf2->reopen_fd(file.name);
+
+  file.fd = mf2->fd;
+
+  if (!file.fd)
+    Fatal(ctx) << "cannot open " << file.name << ": " << errno_string();
+  return file;
+}
+
+template <typename E>
+ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile *mf) {
+  load_lto_plugin(ctx);
+
   // V0 API's claim_file is not thread-safe.
   static std::mutex mu;
   std::unique_lock lock(mu, std::defer_lock);
@@ -589,10 +612,6 @@ ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
                << "added -flto not only for creating object files but also for "
                << "creating the final executable.";
 
-  // dlopen the linker plugin file
-  static std::once_flag flag;
-  std::call_once(flag, [&] { load_plugin(ctx); });
-
   // Create mold's object instance
   ObjectFile<E> *obj = new ObjectFile<E>;
   ctx.obj_pool.emplace_back(obj);
@@ -602,23 +621,10 @@ ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
   obj->first_global = 1;
   obj->is_lto_obj = true;
   obj->mf = mf;
+  obj->archive_name = mf->parent ? mf->parent->name : "";
 
   // Create plugin's object instance
-  PluginInputFile file = {};
-
-  MappedFile<Context<E>> *mf2 = mf->parent ? mf->parent : mf;
-  file.name = save_string(ctx, mf2->name).data();
-  if (mf2->fd == -1)
-    mf2->fd = open(file.name, O_RDONLY);
-  file.fd = mf2->fd;
-  if (file.fd == -1)
-    Fatal(ctx) << "cannot open " << file.name << ": " << errno_string();
-
-  if (mf->parent)
-    obj->archive_name = mf->parent->name;
-
-  file.offset = mf->get_offset();
-  file.filesize = mf->size;
+  PluginInputFile file = create_plugin_input_file(ctx, mf);
   file.handle = (void *)obj;
 
   LOG << "read_lto_symbols: "<< mf->name << "\n";
@@ -635,28 +641,42 @@ ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
   // LLVM needs it and takes the ownership of fd. To prevent "too many
   // open files" issue, we close fd only for GCC. This is ugly, though.
   if (!is_llvm(ctx)) {
-    close(mf2->fd);
-    mf2->fd = -1;
+    MappedFile *mf2 = mf->parent ? mf->parent : mf;
+    mf2->close_fd();
   }
 
-  // Initialize object symbols
-  std::vector<ElfSym<E>> *esyms = new std::vector<ElfSym<E>>(1);
+  // Create a symbol strtab
+  i64 strtab_size = 1;
+  for (PluginSymbol &psym : plugin_symbols)
+    strtab_size += strlen(psym.name) + 1;
+  std::string strtab(strtab_size, '\0');
 
-  for (PluginSymbol &psym : plugin_symbols) {
-    esyms->push_back(to_elf_sym<E>(psym));
-    obj->symbols.push_back(get_symbol(ctx, save_string(ctx, psym.name)));
+  // Initialize esyms
+  obj->lto_elf_syms.resize(plugin_symbols.size() + 1);
+  i64 strtab_offset = 1;
+
+  for (i64 i = 0; i < plugin_symbols.size(); i++) {
+    PluginSymbol &psym = plugin_symbols[i];
+    obj->lto_elf_syms[i + 1] = to_elf_sym<E>(psym);
+    obj->lto_elf_syms[i + 1].st_name = strtab_offset;
+
+    i64 len = strlen(psym.name);
+    memcpy(strtab.data() + strtab_offset, psym.name, len);
+    strtab_offset += len + 1;
   }
 
-  obj->elf_syms = *esyms;
-  obj->symvers.resize(esyms->size());
+  obj->symbol_strtab = save_string(ctx, strtab);
+  obj->elf_syms = obj->lto_elf_syms;
+  obj->initialize_symbols(ctx);
   plugin_symbols.clear();
   return obj;
 }
 
 // Entry point
 template <typename E>
-std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
-  Timer t(ctx, "do_lto");
+std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &ctx) {
+  Timer t(ctx, "run_lto_plugin");
+  load_lto_plugin(ctx);
 
   if (!ctx.arg.lto_pass2 && !supports_v3_api(ctx))
     restart_process(ctx);
@@ -666,16 +686,13 @@ std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
 
   // Set `referenced_by_regular_obj` bit.
   tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    if (file->is_lto_obj)
-      return;
-
-    for (i64 i = file->first_global; i < file->symbols.size(); i++) {
-      Symbol<E> &sym = *file->symbols[i];
-
-      if (sym.file && !sym.file->is_dso &&
-          ((ObjectFile<E> *)sym.file)->is_lto_obj) {
-        std::scoped_lock lock(sym.mu);
-        sym.referenced_by_regular_obj = true;
+    if (!file->is_lto_obj) {
+      for (Symbol<E> *sym : file->get_global_syms()) {
+        if (sym->file && !sym->file->is_dso &&
+            ((ObjectFile<E> *)sym->file)->is_lto_obj) {
+          std::scoped_lock lock(sym->mu);
+          sym->referenced_by_regular_obj = true;
+        }
       }
     }
   });
@@ -692,6 +709,22 @@ std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
     get_symbol(ctx, y)->referenced_by_regular_obj = true;
   }
 
+  // Keep some symbols
+  for (Symbol<E> *sym : ctx.arg.undefined)
+    sym->referenced_by_regular_obj = true;
+
+  // Object files containing .gnu.offload_lto_.* sections need to be
+  // given to the LTO backend. Such sections contains code and data for
+  // peripherails (typically GPUs).
+  for (ObjectFile<E> *file : ctx.objs) {
+    if (file->is_alive && !file->is_lto_obj && file->is_gcc_offload_obj) {
+      PluginInputFile pfile = create_plugin_input_file(ctx, file->mf);
+      int claimed = false;
+      claim_file_hook(&pfile, &claimed);
+      assert(!claimed);
+    }
+  }
+
   // all_symbols_read_hook() calls add_input_file() and add_input_library()
   LOG << "all symbols read\n";
   if (PluginStatus st = all_symbols_read_hook(); st != LDPS_OK)
@@ -703,15 +736,14 @@ std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
 template <typename E>
 void lto_cleanup(Context<E> &ctx) {
   Timer t(ctx, "lto_cleanup");
-
   if (cleanup_hook)
     cleanup_hook();
 }
 
 using E = MOLD_TARGET;
 
-template ObjectFile<E> *read_lto_object(Context<E> &, MappedFile<Context<E>> *);
-template std::vector<ObjectFile<E> *> do_lto(Context<E> &);
+template ObjectFile<E> *read_lto_object(Context<E> &, MappedFile *);
+template std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &);
 template void lto_cleanup(Context<E> &);
 
-} // namespace mold::elf
+} // namespace mold

src/lto-win32.cc

@@ -1,15 +1,15 @@
 #include "mold.h"
 #include "lto.h"
 
-namespace mold::elf {
+namespace mold {
 
 template <typename E>
-ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile *mf) {
   Fatal(ctx) << "LTO is not supported on Windows";
 }
 
 template <typename E>
-std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
+std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &ctx) {
   return {};
 }
 
@@ -18,8 +18,8 @@ void lto_cleanup(Context<E> &ctx) {}
 
 using E = MOLD_TARGET;
 
-template ObjectFile<E> *read_lto_object(Context<E> &, MappedFile<Context<E>> *);
-template std::vector<ObjectFile<E> *> do_lto(Context<E> &);
+template ObjectFile<E> *read_lto_object(Context<E> &, MappedFile *);
+template std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &);
 template void lto_cleanup(Context<E> &);
 
-} // namespace mold::elf
+} // namespace mold

src/lto.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../integers.h"
+#include "../lib/integers.h"
 
 namespace mold {
 
@@ -55,9 +55,7 @@ enum PluginApiVersion {
 
 struct PluginTagValue {
   PluginTagValue(PluginTag tag, int val) : tag(tag), val(val) {}
-
-  template <typename T>
-  PluginTagValue(PluginTag tag, T *ptr) : tag(tag), ptr((void *)ptr) {}
+  PluginTagValue(PluginTag tag, auto *ptr) : tag(tag), ptr((void *)ptr) {}
 
   PluginTag tag;
   union {
@@ -75,7 +73,11 @@ enum PluginOutputFileType {
 
 struct PluginInputFile {
   const char *name;
-  i32 fd;
+#if __MINGW32__
+  HANDLE fd;
+#else
+  int fd;
+#endif
   u64 offset;
   u64 filesize;
   void *handle;

src/main.cc

@@ -0,0 +1,674 @@
+#include "mold.h"
+#include "../lib/archive-file.h"
+
+#include <cstring>
+#include <functional>
+#include <iomanip>
+#include <map>
+#include <regex>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <tbb/global_control.h>
+#include <tbb/parallel_for_each.h>
+#include <unordered_set>
+
+#ifdef _WIN32
+# include <direct.h>
+# define chdir _chdir
+#else
+# include <unistd.h>
+#endif
+
+#ifdef MOLD_X86_64
+int main(int argc, char **argv) {
+  mold::set_mimalloc_options();
+  return mold::mold_main<mold::X86_64>(argc, argv);
+}
+#endif
+
+namespace mold {
+
+template <typename E>
+static void
+check_file_compatibility(Context<E> &ctx, ReaderContext &rctx, MappedFile *mf) {
+  std::string_view target = get_machine_type(ctx, rctx, mf);
+  if (target != ctx.arg.emulation)
+    Fatal(ctx) << mf->name << ": incompatible file type: "
+               << ctx.arg.emulation << " is expected but got " << target;
+}
+
+template <typename E>
+static ObjectFile<E> *new_object_file(Context<E> &ctx, ReaderContext &rctx,
+                                      MappedFile *mf, std::string archive_name) {
+  static Counter count("parsed_objs");
+  count++;
+
+  check_file_compatibility(ctx, rctx, mf);
+
+  bool in_lib = rctx.in_lib || (!archive_name.empty() && !rctx.whole_archive);
+
+  ObjectFile<E> *file = new ObjectFile<E>(ctx, mf, archive_name, in_lib);
+  ctx.obj_pool.emplace_back(file);
+  file->priority = ctx.file_priority++;
+
+  rctx.tg->run([file, &ctx] { file->parse(ctx); });
+  if (ctx.arg.trace)
+    Out(ctx) << "trace: " << *file;
+  return file;
+}
+
+template <typename E>
+static ObjectFile<E> *new_lto_obj(Context<E> &ctx, ReaderContext &rctx,
+                                  MappedFile *mf, std::string archive_name) {
+  static Counter count("parsed_lto_objs");
+  count++;
+
+  if (ctx.arg.ignore_ir_file.count(mf->get_identifier()))
+    return nullptr;
+
+  ObjectFile<E> *file = read_lto_object(ctx, mf);
+  file->priority = ctx.file_priority++;
+  file->archive_name = archive_name;
+  file->is_in_lib = rctx.in_lib || (!archive_name.empty() && !rctx.whole_archive);
+  file->is_alive = !file->is_in_lib;
+  if (ctx.arg.trace)
+    Out(ctx) << "trace: " << *file;
+  return file;
+}
+
+template <typename E>
+static SharedFile<E> *
+new_shared_file(Context<E> &ctx, ReaderContext &rctx, MappedFile *mf) {
+  check_file_compatibility(ctx, rctx, mf);
+
+  SharedFile<E> *file = new SharedFile<E>(ctx, mf);
+  ctx.dso_pool.emplace_back(file);
+  file->priority = ctx.file_priority++;
+  file->is_alive = !rctx.as_needed;
+
+  rctx.tg->run([file, &ctx] { file->parse(ctx); });
+  if (ctx.arg.trace)
+    Out(ctx) << "trace: " << *file;
+  return file;
+}
+
+template <typename E>
+void read_file(Context<E> &ctx, ReaderContext &rctx, MappedFile *mf) {
+  switch (get_file_type(ctx, mf)) {
+  case FileType::ELF_OBJ:
+    ctx.objs.push_back(new_object_file(ctx, rctx, mf, ""));
+    return;
+  case FileType::ELF_DSO:
+    ctx.dsos.push_back(new_shared_file(ctx, rctx, mf));
+    return;
+  case FileType::AR:
+  case FileType::THIN_AR:
+    for (MappedFile *child : read_archive_members(ctx, mf)) {
+      switch (get_file_type(ctx, child)) {
+      case FileType::ELF_OBJ:
+        ctx.objs.push_back(new_object_file(ctx, rctx, child, mf->name));
+        break;
+      case FileType::GCC_LTO_OBJ:
+      case FileType::LLVM_BITCODE:
+        if (ObjectFile<E> *file = new_lto_obj(ctx, rctx, child, mf->name))
+          ctx.objs.push_back(file);
+        break;
+      case FileType::ELF_DSO:
+        Warn(ctx) << mf->name << "(" << child->name
+                  << "): shared object file in an archive is ignored";
+        break;
+      default:
+        break;
+      }
+    }
+    return;
+  case FileType::TEXT:
+    Script(ctx, rctx, mf).parse_linker_script();
+    return;
+  case FileType::GCC_LTO_OBJ:
+  case FileType::LLVM_BITCODE:
+    if (ObjectFile<E> *file = new_lto_obj(ctx, rctx, mf, ""))
+      ctx.objs.push_back(file);
+    return;
+  default:
+    Fatal(ctx) << mf->name << ": unknown file type";
+  }
+}
+
+template <typename E>
+static std::string_view
+detect_machine_type(Context<E> &ctx, std::vector<std::string> args) {
+  for (ReaderContext rctx; const std::string &arg : args) {
+    if (arg == "--Bstatic") {
+      rctx.static_ = true;
+    } else if (arg == "--Bdynamic") {
+      rctx.static_ = false;
+    } else if (!arg.starts_with('-')) {
+      if (MappedFile *mf = open_file(ctx, arg))
+        if (get_file_type(ctx, mf) != FileType::TEXT)
+          if (std::string_view target = get_machine_type(ctx, rctx, mf);
+              !target.empty())
+            return target;
+    }
+  }
+
+  for (ReaderContext rctx; const std::string &arg : args) {
+    if (arg == "--Bstatic") {
+      rctx.static_ = true;
+    } else if (arg == "--Bdynamic") {
+      rctx.static_ = false;
+    } else if (!arg.starts_with('-')) {
+      if (MappedFile *mf = open_file(ctx, arg))
+        if (get_file_type(ctx, mf) == FileType::TEXT)
+          if (std::string_view target =
+              Script(ctx, rctx, mf).get_script_output_type();
+              !target.empty())
+            return target;
+    }
+  }
+
+  Fatal(ctx) << "-m option is missing";
+}
+
+template <typename E>
+MappedFile *open_library(Context<E> &ctx, ReaderContext &rctx, std::string path) {
+  MappedFile *mf = open_file(ctx, path);
+  if (!mf)
+    return nullptr;
+
+  std::string_view target = get_machine_type(ctx, rctx, mf);
+  if (!target.empty() && target != E::name) {
+    Warn(ctx) << path << ": skipping incompatible file: " << target
+              << " (e_machine " << (int)E::e_machine << ")";
+    return nullptr;
+  }
+  return mf;
+}
+
+template <typename E>
+MappedFile *find_library(Context<E> &ctx, ReaderContext &rctx, std::string name) {
+  if (name.starts_with(':')) {
+    for (std::string_view dir : ctx.arg.library_paths) {
+      std::string path = std::string(dir) + "/" + name.substr(1);
+      if (MappedFile *mf = open_library(ctx, rctx, path))
+        return mf;
+    }
+    Fatal(ctx) << "library not found: " << name;
+  }
+
+  for (std::string_view dir : ctx.arg.library_paths) {
+    std::string stem = std::string(dir) + "/lib" + name;
+    if (!rctx.static_)
+      if (MappedFile *mf = open_library(ctx, rctx, stem + ".so"))
+        return mf;
+    if (MappedFile *mf = open_library(ctx, rctx, stem + ".a"))
+      return mf;
+  }
+  Fatal(ctx) << "library not found: " << name;
+}
+
+template <typename E>
+static void read_input_files(Context<E> &ctx, std::span<std::string> args) {
+  Timer t(ctx, "read_input_files");
+
+  ReaderContext rctx;
+  std::vector<ReaderContext> stack;
+  std::unordered_set<std::string_view> visited;
+
+  tbb::task_group tg;
+  rctx.tg = &tg;
+
+  while (!args.empty()) {
+    std::string_view arg = args[0];
+    args = args.subspan(1);
+
+    if (arg == "--as-needed") {
+      rctx.as_needed = true;
+    } else if (arg == "--no-as-needed") {
+      rctx.as_needed = false;
+    } else if (arg == "--whole-archive") {
+      rctx.whole_archive = true;
+    } else if (arg == "--no-whole-archive") {
+      rctx.whole_archive = false;
+    } else if (arg == "--Bstatic") {
+      rctx.static_ = true;
+    } else if (arg == "--Bdynamic") {
+      rctx.static_ = false;
+    } else if (arg == "--start-lib") {
+      rctx.in_lib = true;
+    } else if (arg == "--end-lib") {
+      rctx.in_lib = false;
+    } else if (arg == "--push-state") {
+      stack.push_back(rctx);
+    } else if (arg == "--pop-state") {
+      if (stack.empty())
+        Fatal(ctx) << "no state pushed before popping";
+      rctx = stack.back();
+      stack.pop_back();
+    } else if (arg.starts_with("-l")) {
+      arg = arg.substr(2);
+      if (visited.contains(arg))
+        continue;
+      visited.insert(arg);
+
+      MappedFile *mf = find_library(ctx, rctx, std::string(arg));
+      mf->given_fullpath = false;
+      read_file(ctx, rctx, mf);
+    } else {
+      read_file(ctx, rctx, must_open_file(ctx, std::string(arg)));
+    }
+  }
+
+  if (ctx.objs.empty())
+    Fatal(ctx) << "no input files";
+
+  tg.wait();
+}
+
+template <typename E>
+static bool has_lto_obj(Context<E> &ctx) {
+  for (ObjectFile<E> *file : ctx.objs)
+    if (file->is_alive && (file->is_lto_obj || file->is_gcc_offload_obj))
+      return true;
+  return false;
+}
+
+template <typename E>
+int mold_main(int argc, char **argv) {
+  Context<E> ctx;
+
+  // Process -run option first. process_run_subcommand() does not return.
+  if (argc >= 2 && (argv[1] == "-run"sv || argv[1] == "--run"sv))
+    process_run_subcommand(ctx, argc, argv);
+
+  // Parse non-positional command line options
+  ctx.cmdline_args = expand_response_files(ctx, argv);
+  std::vector<std::string> file_args = parse_nonpositional_args(ctx);
+
+  // If no -m option is given, deduce it from input files.
+  if (ctx.arg.emulation.empty())
+    ctx.arg.emulation = detect_machine_type(ctx, file_args);
+
+  // Redo if -m is not x86-64.
+  if constexpr (is_x86_64<E>)
+    if (ctx.arg.emulation != X86_64::name)
+      return redo_main(ctx, argc, argv);
+
+  Timer t_all(ctx, "all");
+
+  install_signal_handler();
+
+  if (!ctx.arg.directory.empty())
+    if (chdir(ctx.arg.directory.c_str()) == -1)
+      Fatal(ctx) << "chdir failed: " << ctx.arg.directory
+                 << ": " << errno_string();
+
+  // Fork a subprocess unless --no-fork is given.
+  if (ctx.arg.fork)
+    fork_child();
+
+  acquire_global_lock();
+
+  tbb::global_control tbb_cont(tbb::global_control::max_allowed_parallelism,
+                               ctx.arg.thread_count);
+
+  // Handle --wrap options if any.
+  for (std::string_view name : ctx.arg.wrap)
+    get_symbol(ctx, name)->is_wrapped = true;
+
+  // Handle --retain-symbols-file options if any.
+  if (ctx.arg.retain_symbols_file)
+    for (Symbol<E> *sym : *ctx.arg.retain_symbols_file)
+      sym->write_to_symtab = true;
+
+  for (std::string_view arg : ctx.arg.trace_symbol)
+    get_symbol(ctx, arg)->is_traced = true;
+
+  // Parse input files
+  read_input_files(ctx, file_args);
+
+  // Uniquify shared object files by soname
+  {
+    std::unordered_set<std::string_view> seen;
+    std::erase_if(ctx.dsos, [&](SharedFile<E> *file) {
+      return !seen.insert(file->soname).second;
+    });
+  }
+
+  Timer t_before_copy(ctx, "before_copy");
+
+  // Apply -exclude-libs
+  apply_exclude_libs(ctx);
+
+  // Create a dummy file containing linker-synthesized symbols.
+  if (!ctx.arg.relocatable)
+    create_internal_file(ctx);
+
+  // Resolve symbols by choosing the most appropriate file for each
+  // symbol. This pass also removes redundant comdat sections (e.g.
+  // duplicate inline functions).
+  resolve_symbols(ctx);
+
+  // If there's an object file compiled with -flto, do link-time
+  // optimization.
+  if (has_lto_obj(ctx))
+    do_lto(ctx);
+
+  // Now that we know which object files are to be included to the
+  // final output, we can remove unnecessary files.
+  std::erase_if(ctx.objs, [](InputFile<E> *file) { return !file->is_alive; });
+  std::erase_if(ctx.dsos, [](InputFile<E> *file) { return !file->is_alive; });
+
+  // Parse .eh_frame section contents.
+  parse_eh_frame_sections(ctx);
+
+  // Split mergeable section contents into section pieces.
+  create_merged_sections(ctx);
+
+  // Handle --relocatable. Since the linker's behavior is quite different
+  // from the normal one when the option is given, the logic is implemented
+  // to a separate file.
+  if (ctx.arg.relocatable) {
+    combine_objects(ctx);
+    return 0;
+  }
+
+  // Create .bss sections for common symbols.
+  convert_common_symbols(ctx);
+
+  // Apply version scripts.
+  apply_version_script(ctx);
+
+  // Parse symbol version suffixes (e.g. "foo@ver1").
+  parse_symbol_version(ctx);
+
+  // Set is_imported and is_exported bits for each symbol.
+  compute_import_export(ctx);
+
+  // Set "address-taken" bits for input sections.
+  if (ctx.arg.icf)
+    compute_address_significance(ctx);
+
+  // Garbage-collect unreachable sections.
+  if (ctx.arg.gc_sections)
+    gc_sections(ctx);
+
+  // Merge identical read-only sections.
+  if (ctx.arg.icf)
+    icf_sections(ctx);
+
+  // Create linker-synthesized sections such as .got or .plt.
+  create_synthetic_sections(ctx);
+
+  // Make sure that there's no duplicate symbol
+  if (!ctx.arg.allow_multiple_definition)
+    check_duplicate_symbols(ctx);
+
+  if (!ctx.arg.allow_shlib_undefined)
+    check_shlib_undefined(ctx);
+
+  // Warn if symbols with different types are defined under the same name.
+  check_symbol_types(ctx);
+
+  if constexpr (is_ppc64v1<E>)
+    ppc64v1_rewrite_opd(ctx);
+
+  // Bin input sections into output sections.
+  create_output_sections(ctx);
+
+  // Convert an .ARM.exidx to a synthetic section.
+  if constexpr (is_arm32<E>)
+    create_arm_exidx_section(ctx);
+
+  // Handle --section-align options.
+  if (!ctx.arg.section_align.empty())
+    apply_section_align(ctx);
+
+  // Add synthetic symbols such as __ehdr_start or __end.
+  add_synthetic_symbols(ctx);
+
+  // Beyond this point, no new files will be added to ctx.objs
+  // or ctx.dsos.
+
+  // Handle `-z cet-report`.
+  if (ctx.arg.z_cet_report != CET_REPORT_NONE)
+    check_cet_errors(ctx);
+
+  // Handle `-z execstack-if-needed`.
+  if (ctx.arg.z_execstack_if_needed)
+    for (ObjectFile<E> *file : ctx.objs)
+      if (file->needs_executable_stack)
+        ctx.arg.z_execstack = true;
+
+  // If we are linking a .so file, remaining undefined symbols does
+  // not cause a linker error. Instead, they are treated as if they
+  // were imported symbols.
+  //
+  // If we are linking an executable, weak undefs are converted to
+  // weakly imported symbols so that they'll have another chance to be
+  // resolved.
+  claim_unresolved_symbols(ctx);
+
+  // Beyond this point, no new symbols will be added to the result.
+
+  // Handle --print-dependencies
+  if (ctx.arg.print_dependencies)
+    print_dependencies(ctx);
+
+  // Handle -repro
+  if (ctx.arg.repro)
+    write_repro_file(ctx);
+
+  // Handle --require-defined
+  for (Symbol<E> *sym : ctx.arg.require_defined)
+    if (!sym->file)
+      Error(ctx) << "--require-defined: undefined symbol: " << *sym;
+
+  // .init_array and .fini_array contents have to be sorted by
+  // a special rule. Sort them.
+  sort_init_fini(ctx);
+
+  // Likewise, .ctors and .dtors have to be sorted. They are rare
+  // because they are superceded by .init_array/.fini_array, though.
+  sort_ctor_dtor(ctx);
+
+  // If .ctors/.dtors are to be placed to .init_array/.fini_array,
+  // we need to reverse their contents.
+  fixup_ctors_in_init_array(ctx);
+
+  // Handle --shuffle-sections
+  if (ctx.arg.shuffle_sections != SHUFFLE_SECTIONS_NONE)
+    shuffle_sections(ctx);
+
+  // Copy string referred by .dynamic to .dynstr.
+  for (SharedFile<E> *file : ctx.dsos)
+    ctx.dynstr->add_string(file->soname);
+  for (std::string_view str : ctx.arg.auxiliary)
+    ctx.dynstr->add_string(str);
+  for (std::string_view str : ctx.arg.filter)
+    ctx.dynstr->add_string(str);
+  if (!ctx.arg.rpaths.empty())
+    ctx.dynstr->add_string(ctx.arg.rpaths);
+  if (!ctx.arg.soname.empty())
+    ctx.dynstr->add_string(ctx.arg.soname);
+
+  if constexpr (is_ppc64v1<E>)
+    ppc64v1_scan_symbols(ctx);
+
+  // Scan relocations to find symbols that need entries in .got, .plt,
+  // .got.plt, .dynsym, .dynstr, etc.
+  scan_relocations(ctx);
+
+  // Compute the is_weak bit for each imported symbol.
+  compute_imported_symbol_weakness(ctx);
+
+  // Sort sections by section attributes so that we'll have to
+  // create as few segments as possible.
+  sort_output_sections(ctx);
+
+  if (!ctx.arg.separate_debug_file.empty())
+    separate_debug_sections(ctx);
+
+  // Compute sizes of output sections while assigning offsets
+  // within an output section to input sections.
+  compute_section_sizes(ctx);
+
+  // If --packed_dyn_relocs=relr was given, base relocations are stored
+  // to a .relr.dyn section in a compressed form. Construct a compressed
+  // relocations now so that we can fix section sizes and file layout.
+  if (ctx.arg.pack_dyn_relocs_relr)
+    construct_relr(ctx);
+
+  // Reserve a space for dynamic symbol strings in .dynstr and sort
+  // .dynsym contents if necessary. Beyond this point, no symbol will
+  // be added to .dynsym.
+  sort_dynsyms(ctx);
+
+  // Print reports about undefined symbols, if needed.
+  if (ctx.arg.unresolved_symbols == UNRESOLVED_ERROR)
+    report_undef_errors(ctx);
+
+  // Fill .gnu.version_d section contents.
+  if (ctx.verdef)
+    ctx.verdef->construct(ctx);
+
+  // Fill .gnu.version_r section contents.
+  ctx.verneed->construct(ctx);
+
+  // Compute .symtab and .strtab sizes for each file.
+  if (!ctx.arg.strip_all)
+    create_output_symtab(ctx);
+
+  // .eh_frame is a special section from the linker's point of view,
+  // as its contents are parsed and reconstructed by the linker,
+  // unlike other sections that are regarded as opaque bytes.
+  // Here, we construct output .eh_frame contents.
+  ctx.eh_frame->construct(ctx);
+
+  // If --emit-relocs is given, we'll copy relocation sections from input
+  // files to an output file.
+  if (ctx.arg.emit_relocs)
+    create_reloc_sections(ctx);
+
+  // Compute the section header values for all sections.
+  compute_section_headers(ctx);
+
+  // Assign offsets to output sections
+  i64 filesize = set_osec_offsets(ctx);
+
+  // On RISC-V, branches are encode using multiple instructions so
+  // that they can jump to anywhere in ±2 GiB by default. They may
+  // be replaced with shorter instruction sequences if destinations
+  // are close enough. Do this optimization.
+  if constexpr (is_riscv<E> || is_loongarch<E>) {
+    shrink_sections(ctx);
+    filesize = set_osec_offsets(ctx);
+  }
+
+  if constexpr (is_arm32<E>) {
+    if (ctx.extra.exidx) {
+      ctx.extra.exidx->remove_duplicate_entries(ctx);
+      filesize = set_osec_offsets(ctx);
+    }
+  }
+
+  // At this point, memory layout is fixed.
+
+  // Set actual addresses to linker-synthesized symbols.
+  fix_synthetic_symbols(ctx);
+
+  // Beyond this, you can assume that symbol addresses including their
+  // GOT or PLT addresses have a correct final value.
+
+  // If --compress-debug-sections is given, compress .debug_* sections
+  // using zlib.
+  if (ctx.arg.compress_debug_sections != COMPRESS_NONE) {
+    compress_debug_sections(ctx);
+    filesize = set_osec_offsets(ctx);
+  }
+
+  // At this point, both memory and file layouts are fixed.
+
+  t_before_copy.stop();
+
+  // Create an output file
+  ctx.output_file = OutputFile<E>::open(ctx, ctx.arg.output, filesize, 0777);
+  ctx.buf = ctx.output_file->buf;
+
+  Timer t_copy(ctx, "copy");
+
+  // Copy input sections to the output file and apply relocations.
+  copy_chunks(ctx);
+
+  if constexpr (is_x86_64<E>)
+    if (ctx.arg.z_rewrite_endbr)
+      rewrite_endbr(ctx);
+
+  // Dynamic linker works better with sorted .rela.dyn section,
+  // so we sort them.
+  ctx.reldyn->sort(ctx);
+
+  // .gdb_index's contents cannot be constructed before applying
+  // relocations to other debug sections. We have relocated debug
+  // sections now, so write the .gdb_index section.
+  if (ctx.gdb_index && ctx.arg.separate_debug_file.empty())
+    write_gdb_index(ctx);
+
+  // .note.gnu.build-id section contains a cryptographic hash of the
+  // entire output file. Now that we wrote everything except build-id,
+  // we can compute it.
+  if (ctx.buildid)
+    write_build_id(ctx);
+
+  if (!ctx.arg.separate_debug_file.empty())
+    write_gnu_debuglink(ctx);
+
+  t_copy.stop();
+  ctx.checkpoint();
+
+  // Close the output file. This is the end of the linker's main job.
+  ctx.output_file->close(ctx);
+
+  // Handle --dependency-file
+  if (!ctx.arg.dependency_file.empty())
+    write_dependency_file(ctx);
+
+  if (!ctx.arg.plugin.empty())
+    lto_cleanup(ctx);
+
+  t_all.stop();
+
+  if (ctx.arg.print_map)
+    print_map(ctx);
+
+  if (!ctx.arg.separate_debug_file.empty())
+    write_separate_debug_file(ctx);
+
+  // Show stats numbers
+  if (ctx.arg.stats)
+    show_stats(ctx);
+
+  if (ctx.arg.perf)
+    print_timer_records(ctx.timer_records);
+
+  std::cout << std::flush;
+  std::cerr << std::flush;
+
+  notify_parent();
+  release_global_lock();
+
+  if (ctx.arg.quick_exit)
+    _exit(0);
+
+  for (std::function<void()> &fn : ctx.on_exit)
+    fn();
+  ctx.checkpoint();
+  return 0;
+}
+
+using E = MOLD_TARGET;
+
+template int mold_main<E>(int, char **);
+
+} // namespace mold

src/mapfile.cc

@@ -7,21 +7,12 @@
 #include <tbb/parallel_for_each.h>
 #include <unordered_map>
 
-namespace mold::elf {
+namespace mold {
 
 template <typename E>
 using Map =
   tbb::concurrent_hash_map<InputSection<E> *, std::vector<Symbol<E> *>>;
 
-template <typename E>
-static std::unique_ptr<std::ofstream> open_output_file(Context<E> &ctx) {
-  std::unique_ptr<std::ofstream> file(new std::ofstream);
-  file->open(ctx.arg.Map.c_str());
-  if (!file->is_open())
-    Fatal(ctx) << "cannot open " << ctx.arg.Map << ": " << errno_string();
-  return file;
-}
-
 template <typename E>
 static Map<E> get_map(Context<E> &ctx) {
   Map<E> map;
@@ -54,12 +45,16 @@ static Map<E> get_map(Context<E> &ctx) {
 
 template <typename E>
 void print_map(Context<E> &ctx) {
+  Timer t(ctx, "print_map");
+
   std::ostream *out = &std::cout;
-  std::unique_ptr<std::ofstream> file;
+  std::ofstream file;
 
   if (!ctx.arg.Map.empty()) {
-    file = open_output_file(ctx);
-    out = file.get();
+    file.open(ctx.arg.Map);
+    if (!file.is_open())
+      Fatal(ctx) << "cannot open " << ctx.arg.Map << ": " << errno_string();
+    out = &file;
   }
 
   // Construct a section-to-symbol map.
@@ -68,29 +63,32 @@ void print_map(Context<E> &ctx) {
   // Print a mapfile.
   *out << "               VMA       Size Align Out     In      Symbol\n";
 
-  for (Chunk<E> *osec : ctx.chunks) {
+  for (Chunk<E> *chunk : ctx.chunks) {
     *out << std::showbase
-         << std::setw(18) << std::hex << (u64)osec->shdr.sh_addr << std::dec
-         << std::setw(11) << (u64)osec->shdr.sh_size
-         << std::setw(6) << (u64)osec->shdr.sh_addralign
-         << " " << osec->name << "\n";
+         << std::setw(18) << std::hex << (u64)chunk->shdr.sh_addr << std::dec
+         << std::setw(11) << (u64)chunk->shdr.sh_size
+         << std::setw(6) << (u64)chunk->shdr.sh_addralign
+         << " " << chunk->name << "\n";
 
-    if (osec->kind() != OUTPUT_SECTION)
+    OutputSection<E> *osec = chunk->to_osec();
+    if (!osec)
       continue;
 
-    std::span<InputSection<E> *> members = ((OutputSection<E> *)osec)->members;
+    std::span<InputSection<E> *> members = osec->members;
     std::vector<std::string> bufs(members.size());
 
     tbb::parallel_for((i64)0, (i64)members.size(), [&](i64 i) {
       InputSection<E> *mem = members[i];
       std::ostringstream ss;
-      opt_demangle = ctx.arg.demangle;
-      u64 addr = osec->shdr.sh_addr + mem->offset;
+
+      u64 addr = 0;
+      if (osec->shdr.sh_flags & SHF_ALLOC)
+        addr = osec->shdr.sh_addr + mem->offset;
 
       ss << std::showbase
          << std::setw(18) << std::hex << addr << std::dec
          << std::setw(11) << (u64)mem->sh_size
-         << std::setw(6) << (1 << (u64)mem->p2align)
+         << std::setw(6) << (1 << mem->p2align)
          << "         " << *mem << "\n";
 
       typename Map<E>::const_accessor acc;
@@ -113,4 +111,4 @@ using E = MOLD_TARGET;
 
 template void print_map(Context<E> &ctx);
 
-} // namespace mold::elf
+} // namespace mold

src/mold-wrapper.c

@@ -1,8 +1,5 @@
 #define _GNU_SOURCE 1
 
-#if !defined(__OpenBSD__) && !defined(__FreeBSD__)
-#  include <alloca.h>
-#endif
 #include <dlfcn.h>
 #include <spawn.h>
 #include <stdarg.h>
@@ -12,6 +9,10 @@
 #include <string.h>
 #include <unistd.h>
 
+#if __has_include(<alloca.h>)
+# include <alloca.h>
+#endif
+
 extern char **environ;
 
 static char *get_mold_path() {
@@ -61,7 +62,8 @@ static bool is_ld(const char *path) {
     ptr--;
 
   return !strcmp(ptr, "ld") || !strcmp(ptr, "ld.lld") ||
-         !strcmp(ptr, "ld.gold") || !strcmp(ptr, "ld.bfd");
+         !strcmp(ptr, "ld.gold") || !strcmp(ptr, "ld.bfd") ||
+         !strcmp(ptr, "ld.mold");
 }
 
 int execvpe(const char *file, char *const *argv, char *const *envp) {
@@ -131,3 +133,14 @@ int posix_spawn(pid_t *pid, const char *path,
   typeof(posix_spawn) *real = dlsym(RTLD_NEXT, "posix_spawn");
   return real(pid, path, file_actions, attrp, argv, envp);
 }
+
+int posix_spawnp(pid_t *pid, const char *file,
+		 const posix_spawn_file_actions_t *file_actions,
+		 const posix_spawnattr_t *attrp,
+		 char *const *argv, char *const *envp) {
+  debug_print("posix_spawnp %s\n", file);
+  if (is_ld(file))
+    file = get_mold_path();
+  typeof(posix_spawnp) *real = dlsym(RTLD_NEXT, "posix_spawnp");
+  return real(pid, file, file_actions, attrp, argv, envp);
+}

src/output-file-unix.cc

@@ -0,0 +1,200 @@
+#include "mold.h"
+
+#include <fcntl.h>
+#include <filesystem>
+#include <sys/file.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+namespace mold {
+
+static u32 get_umask() {
+  u32 orig_umask = umask(0);
+  umask(orig_umask);
+  return orig_umask;
+}
+
+template <typename E>
+static int
+open_or_create_file(Context<E> &ctx, std::string path, std::string tmpfile,
+                    int perm) {
+  // Reuse an existing file if exists and writable because on Linux,
+  // writing to an existing file is much faster than creating a fresh
+  // file and writing to it.
+  if (ctx.overwrite_output_file && rename(path.c_str(), tmpfile.c_str()) == 0) {
+    i64 fd = ::open(tmpfile.c_str(), O_RDWR | O_CREAT, perm);
+    if (fd != -1)
+      return fd;
+    unlink(tmpfile.c_str());
+  }
+
+  i64 fd = ::open(tmpfile.c_str(), O_RDWR | O_CREAT, perm);
+  if (fd == -1)
+    Fatal(ctx) << "cannot open " << tmpfile << ": " << errno_string();
+  return fd;
+}
+
+template <typename E>
+class MemoryMappedOutputFile : public OutputFile<E> {
+public:
+  MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesize, int perm)
+    : OutputFile<E>(path, filesize, true) {
+    std::string pid = std::to_string(getpid());
+    std::string tmpfile =
+      path_dirname(path) / ("." + path_filename(path) + "." + pid);
+
+    this->fd = open_or_create_file(ctx, path, tmpfile, perm);
+
+    if (fchmod(this->fd, perm & ~get_umask()) == -1)
+      Fatal(ctx) << "fchmod failed: " << errno_string();
+
+    if (ftruncate(this->fd, filesize) == -1)
+      Fatal(ctx) << "ftruncate failed: " << errno_string();
+
+    output_tmpfile = (char *)save_string(ctx, tmpfile).data();
+
+#ifdef __linux__
+    fallocate(this->fd, 0, 0, filesize);
+#endif
+
+    this->buf = (u8 *)mmap(nullptr, filesize, PROT_READ | PROT_WRITE,
+                           MAP_SHARED, this->fd, 0);
+    if (this->buf == MAP_FAILED)
+      Fatal(ctx) << path << ": mmap failed: " << errno_string();
+
+    mold::output_buffer_start = this->buf;
+    mold::output_buffer_end = this->buf + filesize;
+  }
+
+  ~MemoryMappedOutputFile() {
+    if (fd2 != -1)
+      ::close(fd2);
+  }
+
+  void close(Context<E> &ctx) override {
+    Timer t(ctx, "close_file");
+
+    if (!this->is_unmapped)
+      munmap(this->buf, this->filesize);
+
+    if (this->buf2.empty()) {
+      ::close(this->fd);
+    } else {
+      FILE *out = fdopen(this->fd, "w");
+      fseek(out, 0, SEEK_END);
+      fwrite(&this->buf2[0], this->buf2.size(), 1, out);
+      fclose(out);
+    }
+
+    // If an output file already exists, open a file and then remove it.
+    // This is the fastest way to unlink a file, as it does not make the
+    // system to immediately release disk blocks occupied by the file.
+    fd2 = ::open(this->path.c_str(), O_RDONLY);
+    if (fd2 != -1)
+      unlink(this->path.c_str());
+
+    if (rename(output_tmpfile, this->path.c_str()) == -1)
+      Fatal(ctx) << this->path << ": rename failed: " << errno_string();
+    output_tmpfile = nullptr;
+  }
+
+private:
+  int fd2 = -1;
+};
+
+template <typename E>
+std::unique_ptr<OutputFile<E>>
+OutputFile<E>::open(Context<E> &ctx, std::string path, i64 filesize, int perm) {
+  Timer t(ctx, "open_file");
+
+  if (path.starts_with('/') && !ctx.arg.chroot.empty())
+    path = ctx.arg.chroot + "/" + path_clean(path);
+
+  bool is_special = false;
+  if (path == "-") {
+    is_special = true;
+  } else {
+    struct stat st;
+    if (stat(path.c_str(), &st) == 0 && (st.st_mode & S_IFMT) != S_IFREG)
+      is_special = true;
+  }
+
+  OutputFile<E> *file;
+  if (is_special)
+    file = new MallocOutputFile(ctx, path, filesize, perm);
+  else
+    file = new MemoryMappedOutputFile(ctx, path, filesize, perm);
+
+#ifdef MADV_HUGEPAGE
+  // Enable transparent huge page for an output memory-mapped file.
+  // On Linux, it has an effect only on tmpfs mounted with `huge=advise`,
+  // but it can make the linker ~10% faster. You can try it by creating
+  // a tmpfs with the following commands
+  //
+  //  $ mkdir tmp
+  //  $ sudo mount -t tmpfs -o size=2G,huge=advise none tmp
+  //
+  // and then specifying a path under the directory as an output file.
+  madvise(file->buf, filesize, MADV_HUGEPAGE);
+#endif
+
+  if (ctx.arg.filler != -1)
+    memset(file->buf, ctx.arg.filler, filesize);
+  return std::unique_ptr<OutputFile>(file);
+}
+
+// LockingOutputFile is similar to MemoryMappedOutputFile, but it doesn't
+// rename output files and instead acquires file lock using flock().
+template <typename E>
+LockingOutputFile<E>::LockingOutputFile(Context<E> &ctx, std::string path,
+                                        int perm)
+  : OutputFile<E>(path, 0, true) {
+  this->fd = ::open(path.c_str(), O_RDWR | O_CREAT, perm);
+  if (this->fd == -1)
+    Fatal(ctx) << "cannot open " << path << ": " << errno_string();
+  flock(this->fd, LOCK_EX);
+
+  // We may be overwriting to an existing debug info file. We want to
+  // make the file unusable so that gdb won't use it by accident until
+  // it's ready.
+  u8 buf[256] = {};
+  (void)!!write(this->fd, buf, sizeof(buf));
+}
+
+template <typename E>
+void LockingOutputFile<E>::resize(Context<E> &ctx, i64 filesize) {
+  if (ftruncate(this->fd, filesize) == -1)
+    Fatal(ctx) << "ftruncate failed: " << errno_string();
+
+  this->buf = (u8 *)mmap(nullptr, filesize, PROT_READ | PROT_WRITE,
+                         MAP_SHARED, this->fd, 0);
+  if (this->buf == MAP_FAILED)
+    Fatal(ctx) << this->path << ": mmap failed: " << errno_string();
+
+  this->filesize = filesize;
+  mold::output_buffer_start = this->buf;
+  mold::output_buffer_end = this->buf + filesize;
+}
+
+template <typename E>
+void LockingOutputFile<E>::close(Context<E> &ctx) {
+  if (!this->is_unmapped)
+    munmap(this->buf, this->filesize);
+
+  if (!this->buf2.empty()) {
+    FILE *out = fdopen(this->fd, "w");
+    fseek(out, 0, SEEK_END);
+    fwrite(&this->buf2[0], this->buf2.size(), 1, out);
+    fclose(out);
+  }
+
+  ::close(this->fd);
+}
+
+using E = MOLD_TARGET;
+
+template class OutputFile<E>;
+template class LockingOutputFile<E>;
+
+} // namespace mold