Bump mold version to 2.3.0

Older versions of GNU assembler don't know `.variant_pcs` directive.

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [rui314] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/ci.yml

@@ -4,53 +4,139 @@ on:
     branches: [ main ]
   pull_request:
     branches: [ main ]
+env:
+  UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
 jobs:
   build-clang:
+    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
     steps:
-    - uses: actions/checkout@v2
-    - uses: rui314/setup-mold@v1
-      with:
-        make-default: false
-    - name: apt-get
-      run: sudo dpkg --add-architecture i386 && sudo apt-get update && sudo apt-get install git build-essential libstdc++-10-dev cmake clang libssl-dev zlib1g-dev libxxhash-dev libtbb-dev git bsdmainutils dwarfdump pkg-config
+    - 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: make
-      run: PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" make CC=clang CXX=clang++ LDFLAGS=-fuse-ld=mold -j$(nproc)
-    - name: make test
-      run: make -j$(nproc) test
+    - name: build and test
+      run: |
+        echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
+        sudo apt-get install -y clang++-12
+        mkdir build
+        cd build
+        cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++-12 ${{ matrix.target }} ..
+        cmake --build . -j$(nproc)
+        ctest . -j$(nproc)
+    - name: archive test results
+      uses: actions/upload-artifact@v3
+      if: failure()
+      with:
+        name: test-results-clang
+        path: |
+          build/out
+          build/Testing
+
   build-gcc:
     runs-on: ubuntu-20.04
     container: gcc:11.1.0
     steps:
-    - uses: actions/checkout@v2
-    - name: apt-get
+    - uses: actions/checkout@v3
+    - name: install-build-deps
       run: |
-        dpkg --add-architecture i386 && apt-get update && apt-get install -y sudo libssl-dev zlib1g-dev libxxhash-dev cmake clang bsdmainutils dwarfdump qemu-user gcc-10-i686-linux-gnu gcc-10-aarch64-linux-gnu gcc-10-riscv64-linux-gnu gcc-10-arm-linux-gnueabihf g++-10-i686-linux-gnu g++-10-aarch64-linux-gnu g++-10-riscv64-linux-gnu g++-10-arm-linux-gnueabihf
-        ln -sf /usr/bin/i686-linux-gnu-gcc-10 /usr/bin/i686-linux-gnu-gcc
-        ln -sf /usr/bin/i686-linux-gnu-g++-10 /usr/bin/i686-linux-gnu-g++
-        ln -sf /usr/bin/aarch64-linux-gnu-gcc-10 /usr/bin/aarch64-linux-gnu-gcc
-        ln -sf /usr/bin/aarch64-linux-gnu-g++-10 /usr/bin/aarch64-linux-gnu-g++
-        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++
-        ln -sf /usr/bin/riscv64-linux-gnu-gcc-10 /usr/bin/riscv64-linux-gnu-gcc
-        ln -sf /usr/bin/riscv64-linux-gnu-g++-10 /usr/bin/riscv64-linux-gnu-g++
+        # Install cross toolchains
+        dpkg --add-architecture i386
+        ./install-build-deps.sh update
+        apt-get install -y sudo qemu-user gdb zstd dwarfdump xz-utils {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}-linux-gnu arm-linux-gnueabihf; do
+          ln -sf /usr/bin/$i-gcc-10 /usr/bin/$i-gcc
+          ln -sf /usr/bin/$i-g++-10 /usr/bin/$i-g++
+        done
+
+        # 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/2023.07.07/riscv32-glibc-ubuntu-20.04-gcc-nightly-2023.07.07-nightly.tar.gz | tar -C /usr/local/rv32 --strip-components=1 -xzf -
+
+        ln -sf /usr/local/rv32/sysroot /usr/riscv32-linux-gnu
+        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,g++}
+
+        for i in objdump objcopy strip; do
+          ln -sf /usr/local/rv32/bin/riscv32-unknown-linux-gnu-$i /usr/bin/riscv32-linux-gnu-$i
+        done
+
+        # Install a LoongArch toolchain
+        mkdir /usr/local/larch
+        wget -O- -q https://github.com/loongson/build-tools/releases/download/2023.08.08/CLFS-loongarch64-8.1-x86_64-cross-tools-gcc-glibc.tar.xz | tar -C /usr/local/larch --strip-components=1 --xz -xf -
+
+        ln -sf /usr/local/larch/target /usr/loongarch64-linux-gnu
+        cp -r /usr/local/larch/loongarch64-unknown-linux-gnu/lib/* /usr/loongarch64-linux-gnu/lib64/
+
+        for i in objdump objcopy strip; do
+          ln -sf /usr/local/larch/bin/loongarch64-unknown-linux-gnu-$i /usr/bin/loongarch64-linux-gnu-$i
+        done
+
+        echo '/usr/local/larch/bin/loongarch64-unknown-linux-gnu-gcc -L/usr/local/larch/loongarch64-unknown-linux-gnu "$@"' > /usr/bin/loongarch64-linux-gnu-gcc
+        echo '/usr/local/larch/bin/loongarch64-unknown-linux-gnu-g++ -L/usr/local/larch/loongarch64-unknown-linux-gnu "$@"' > /usr/bin/loongarch64-linux-gnu-g++
+        chmod 755 /usr/bin/loongarch64-linux-gnu-{gcc,g++}
+
+        wget -O/usr/local/bin/qemu-loongarch64 -q https://github.com/loongson/build-tools/releases/download/2023.08.08/qemu-loongarch64
+        chmod 755 /usr/local/bin/qemu-loongarch64
+
+      shell: bash
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1
-    - name: make
-      run: PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" make CC=gcc CXX=g++ -j$(nproc)
-    - name: make test
-      run: make -j$(nproc) test-all
+    - name: build and test
+      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 -DMOLD_ENABLE_QEMU_TESTS_LOONGARCH=On ..
+        cmake --build . -j$(nproc)
+        ctest . -j$(nproc)
+    - name: archive test results
+      uses: actions/upload-artifact@v3
+      if: failure()
+      with:
+        name: test-results-gcc
+        path: |
+          build/out
+          build/Testing
+
   build-macos:
     runs-on: macos-11
+    strategy:
+      matrix:
+        target:
+        # Disable PCH for the default configuration. This prevents relying on implicit includes.
+        - '-DCMAKE_DISABLE_PRECOMPILE_HEADERS=On'
+        - '-DMOLD_USE_ASAN=On'
     steps:
-    - uses: actions/checkout@v2
-    - name: brew
-      run: brew install xxhash
+    - uses: actions/checkout@v3
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1
-    - name: make
-      run: PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" make -j$(sysctl -n hw.logicalcpu)
-    - name: make test
-      run: PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" make -j$(sysctl -n hw.logicalcpu) test
+    - name: build and test
+      run: |
+        echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
+        mkdir build
+        cd build
+        cmake ${{ matrix.target }} ..
+        cmake --build . -j$(sysctl -n hw.physicalcpu)
+
+  build-windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: build
+      run: |
+        mkdir build
+        cd build
+        cmake -T clangcl ..
+        cmake --build . -j $Env:NUMBER_OF_PROCESSORS

.github/workflows/linux-packages.yml

@@ -0,0 +1,15 @@
+name: linux-packages
+on:
+  push:
+    branches: [ main ]
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v3
+    - name: build
+      run: ./dist.sh x86_64
+    - name: upload
+      uses: actions/upload-artifact@v3
+      with:
+        path: mold-*-linux.tar.gz

.gitignore

@@ -1,6 +1,7 @@
 *.o
 *.so
 *~
+**/.DS_Store
 .cache
 compile_commands.json
 /mold
@@ -8,7 +9,9 @@ compile_commands.json
 options.inc
 core
 ld
+ld64
 ld64.mold
 gentoo
 out
 /mold-*.tar.gz
+/build*

CMakeLists.txt

@@ -0,0 +1,487 @@
+# 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.
+#
+# 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`.
+#
+#  -DCMAKE_CXX_COMPILER=<command-name>
+#
+#   Specifies a 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`.
+#
+#  -DCMAKE_BUILD_TYPE=[Debug | Release | RelWithDebInfo | MinSizeRel]
+#
+#   Specifies a 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.
+#
+# With cmake, you may run `cmake --install .` instead of `make install` to
+# install build artifacts to system directories. If you want to install
+# artifacts to a temporary target directory, run `cmake --install . --prefix
+# <dir>`.
+#
+# You can see the current cmake variables and their values by running
+# `cmake -N -L .` in a build directory.
+#
+# Note that in this file, we provide various dials and knobs to configure
+# 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
+# features and behave exactly the same.
+
+cmake_minimum_required(VERSION 3.14)
+project(mold VERSION 2.3.0)
+
+include(CMakeDependentOption)
+include(GNUInstallDirs)
+
+# 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 -Wl,--gdb-index)
+endif()
+
+add_executable(mold)
+target_compile_features(mold PRIVATE cxx_std_20)
+target_link_libraries(mold PRIVATE ${CMAKE_DL_LIBS})
+
+if(NOT "${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC")
+  target_compile_options(mold PRIVATE
+    -fno-exceptions
+    -fno-unwind-tables
+    -fno-asynchronous-unwind-tables
+    -Wall
+    -Wextra
+    -Wno-sign-compare
+    -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
+option(MOLD_LTO "Build mold with link-time optimization enabled")
+if(MOLD_LTO)
+  set_property(TARGET mold PROPERTY INTERPROCEDURAL_OPTIMIZATION ON)
+endif()
+
+# Enable AddressSanitizer if -DMOLD_USE_ASAN=ON
+option(MOLD_USE_ASAN "Build mold with AddressSanitizer" OFF)
+if(MOLD_USE_ASAN)
+  target_compile_options(mold PRIVATE -fsanitize=address -fsanitize=undefined)
+  target_link_options(mold PRIVATE -fsanitize=address -fsanitize=undefined)
+endif()
+
+# Enabled ThreadSanitizer if -DMOLD_USE_TSAN=ON
+option(MOLD_USE_TSAN "Build mold with ThreadSanitizer" OFF)
+if(MOLD_USE_TSAN)
+  target_compile_options(mold PRIVATE -fsanitize=thread)
+  target_link_options(mold PRIVATE -fsanitize=thread)
+endif()
+
+# 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)
+if(MOLD_MOSTLY_STATIC)
+  target_link_options(mold PRIVATE -static-libstdc++)
+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 AND NOT MOLD_MOSTLY_STATIC)
+  target_link_libraries(mold PRIVATE ZLIB::ZLIB)
+else()
+  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 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()
+  add_subdirectory(third-party/blake3/c EXCLUDE_FROM_ALL)
+  target_link_libraries(mold PRIVATE blake3)
+  target_include_directories(mold PUBLIC third-party/blake3/c)
+endif()
+
+# Find zstd compression library. If libzstd.so 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 AND NOT MOLD_MOSTLY_STATIC)
+  target_link_libraries(mold PRIVATE zstd)
+else()
+  add_subdirectory(third-party/zstd/build/cmake EXCLUDE_FROM_ALL)
+  target_compile_definitions(libzstd_static PRIVATE
+    ZSTD_BUILD_STATIC=1
+    ZSTD_BUILD_SHARED=0
+    ZSTD_BUILD_PROGRAMS=0
+    ZSTD_MULTITHREAD_SUPPORT=0
+    ZSTD_BUILD_TESTS=0)
+  target_include_directories(mold PUBLIC third-party/zstd/lib)
+  target_link_libraries(mold PRIVATE libzstd_static)
+endif()
+
+# Find mimalloc. mimalloc is an alternative malloc implementation
+# optimized for multi-threaded applications.
+#
+# If you want to use the usual libc's malloc, pass -DMOLD_USE_MIMALLOC=OFF.
+#
+# 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
+  "NOT APPLE; NOT ANDROID; NOT OPENBSD; NOT P32" OFF)
+cmake_dependent_option(
+  MOLD_USE_SYSTEM_MIMALLOC "Use system or vendored mimalloc" OFF
+  MOLD_USE_MIMALLOC OFF)
+
+# By default, we build a bundled mimalloc and statically-link it to
+# mold. If you want to dynamically link to the system's
+# libmimalloc.so, pass -DMOLD_USE_SYSTEM_MIMALLOC=ON.
+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 "")
+      set(MI_BUILD_TESTS OFF CACHE INTERNAL "")
+      add_subdirectory(third-party/mimalloc EXCLUDE_FROM_ALL)
+      target_compile_definitions(mimalloc-static PRIVATE MI_USE_ENVIRON=0)
+      target_link_libraries(mold PRIVATE mimalloc-static)
+    endfunction()
+
+    mold_add_mimalloc()
+  endif()
+endif()
+
+# Find TBB. TBB (OneTBB or Intel TBB) is a high-level threading library.
+# Use of this library is mandatory.
+#
+# By default, we build a bundled one and statically-link the library
+# to mold. If you want to link to the system's libtbb2.so, pass
+# -DMOLD_USE_SYSTEM_TBB=ON.
+option(MOLD_USE_SYSTEM_TBB "Use system or vendored TBB" OFF)
+if(MOLD_USE_SYSTEM_TBB)
+  find_package(TBB REQUIRED)
+  target_link_libraries(mold PRIVATE TBB::tbb)
+else()
+  function(mold_add_tbb)
+    set(BUILD_SHARED_LIBS OFF)
+    set(TBB_TEST OFF CACHE INTERNAL "")
+    set(TBB_STRICT OFF CACHE INTERNAL "")
+    add_subdirectory(third-party/tbb EXCLUDE_FROM_ALL)
+    target_compile_definitions(tbb PRIVATE __TBB_DYNAMIC_LOAD_ENABLED=0)
+    target_link_libraries(mold PRIVATE TBB::tbb)
+  endfunction()
+
+  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(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)
+  if(LIBM_FOUND)
+    target_link_libraries(mold PRIVATE m)
+  endif()
+endif()
+
+# Build mold-wrapper.so
+if(NOT APPLE AND NOT WIN32)
+  add_library(mold-wrapper SHARED)
+  install(TARGETS mold-wrapper DESTINATION ${CMAKE_INSTALL_LIBDIR}/mold)
+
+  # 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 atomics doesn't work by default, add -latomic.
+# We need the flag on riscv, armv6 and m68k.
+include(CheckCXXSourceCompiles)
+check_cxx_source_compiles("#include <atomic>
+int main() {
+  std::atomic_uint8_t  a;
+  std::atomic_uint16_t b;
+  std::atomic_uint32_t c;
+  std::atomic_uint64_t d;
+  return ++a + ++b + ++c + ++d;
+}" HAVE_FULL_ATOMIC_SUPPORT)
+
+if(NOT HAVE_FULL_ATOMIC_SUPPORT)
+  target_link_libraries(mold PRIVATE atomic)
+endif()
+
+# Add -pthread
+if(NOT APPLE AND NOT MSVC)
+  target_compile_options(mold PRIVATE -pthread)
+  target_link_options(mold PRIVATE -pthread)
+endif()
+
+# 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}/common/update-git-hash.cmake
+  DEPENDS common/update-git-hash.cmake
+  BYPRODUCTS git-hash.cc
+  VERBATIM)
+
+add_dependencies(mold git_hash)
+
+# Create config.h file
+configure_file(common/config.h.in config.h)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+# Almost all functions are template in mold which take a target type
+# (e.g. X86_64) as its type parameter. Since we suport more than 10
+# targets, compiling a single source file for all the targets is very
+# slow.
+#
+# As a workaround, we create a .cc file for each target and spawn many
+# 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 LOONGARCH32 LOONGARCH64)
+
+list(APPEND MOLD_ELF_TEMPLATE_FILES
+  elf/arch-loongarch.cc
+  elf/arch-riscv.cc
+  elf/cmdline.cc
+  elf/gc-sections.cc
+  elf/gdb-index.cc
+  elf/icf.cc
+  elf/input-files.cc
+  elf/input-sections.cc
+  elf/jobs.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
+  elf/tls.cc
+  )
+
+list(APPEND MOLD_MACHO_TARGETS X86_64 ARM64)
+
+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
+  )
+
+function(mold_instantiate_templates SOURCE TARGET)
+  set(PATH ${CMAKE_BINARY_DIR}/${SOURCE}.${TARGET}.cc)
+  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()
+
+foreach (SOURCE IN LISTS MOLD_ELF_TEMPLATE_FILES)
+  foreach(TARGET IN LISTS MOLD_ELF_TARGETS)
+    mold_instantiate_templates(${SOURCE} ${TARGET})
+  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
+  common/compress.cc
+  common/demangle.cc
+  common/filepath.cc
+  common/glob.cc
+  common/hyperloglog.cc
+  common/main.cc
+  common/multi-glob.cc
+  common/perf.cc
+  common/tar.cc
+  common/uuid.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-s390x.cc
+  elf/arch-sh4.cc
+  elf/arch-sparc64.cc
+  elf/arch-x86-64.cc
+  elf/elf.cc
+  git-hash.cc
+  third-party/rust-demangle/rust-demangle.c
+  )
+
+if(MOLD_IS_SOLD)
+  target_sources(mold PRIVATE
+    macho/arch-arm64.cc
+    macho/arch-x86-64.cc
+    macho/yaml.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
+  if(NOT WIN32)
+    add_custom_command(
+      TARGET mold POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E create_symlink mold ld
+      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)
+  endif()
+endif()
+
+if(NOT CMAKE_SKIP_INSTALL_RULES)
+  install(TARGETS mold RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+  install(FILES docs/mold.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1/)
+
+  if(EXISTS "${CMAKE_SOURCE_DIR}/LICENSE")
+    install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
+  endif()
+  if(EXISTS "${CMAKE_SOURCE_DIR}/LICENSE.third-party")
+    install(FILES "LICENSE.third-party" DESTINATION "${CMAKE_INSTALL_DOCDIR}")
+  endif()
+
+  function(mold_install_relative_symlink OLD NEW)
+    install(CODE "
+      get_filename_component(PREFIX_ABS \${CMAKE_INSTALL_PREFIX}/ ABSOLUTE)
+      get_filename_component(OLD_ABS ${OLD} ABSOLUTE BASE_DIR \${PREFIX_ABS})
+      get_filename_component(NEW_ABS ${NEW} ABSOLUTE BASE_DIR \${PREFIX_ABS})
+      get_filename_component(NEW_DIR \${NEW_ABS} DIRECTORY)
+      file(RELATIVE_PATH OLD_REL \${NEW_DIR} \${OLD_ABS})
+      message(STATUS \"Installing symlink: \$ENV{DESTDIR}\${NEW_ABS} -> \${OLD_REL}\")
+      file(MAKE_DIRECTORY \$ENV{DESTDIR}\${NEW_DIR})
+      file(CREATE_LINK \${OLD_REL} \$ENV{DESTDIR}\${NEW_ABS} SYMBOLIC)")
+  endfunction()
+
+  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()

CONTRIBUTING.md

@@ -1,54 +0,0 @@
-# Contributing to mold
-
-Summary: When you send a patch, you must agree that the patch is
-released under the dual license of the GNU AGPLv3 and the MIT license.
-As an indication of agreement, please add a `Signed-off-by` line to
-your commit message using `git commit -s`.
-
-Here is the long official version:
-
-mold is currently licensed under the GNU AGPLv3, but I want to relicense
-it under a more liberal license in the future. To make this possible,
-I want all patches to be submitted under the dual license of the GNU
-AGPLv3 and the MIT license (the "Dual License") from the beginning.
-
-To make it clear that contributors have agreed to release their
-patches under the Dual License, I introduced a sign-off procedure just
-like the Linux kernel project did. The sign-off is a simple line at
-the end of the git commit message, which certifies that you wrote it
-or otherwise have the right to pass it on as an open-source patch. The
-rules are pretty simple: if you can certify the below:
-
-> ## 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; 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.
-
-then 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.

Dockerfile

@@ -1,22 +0,0 @@
-# This dockerfile creates a reproducible build environment for mold.
-#
-# $ docker build -t rui314/mold-builder:v1-$(uname -m) .
-# $ docker push rui314/mold-builder:v1-$(uname -m)
-
-FROM ubuntu:18.04
-RUN apt-get update && \
-  TZ=Europe/London apt-get install -y tzdata && \
-  apt-get install -y --no-install-recommends software-properties-common && \
-  add-apt-repository -y ppa:ubuntu-toolchain-r/test && \
-  apt-get install -y --no-install-recommends build-essential git \
-    wget pkg-config cmake libstdc++-11-dev zlib1g-dev gpg gpg-agent && \
-  bash -c "$(wget -O- https://apt.llvm.org/llvm.sh)" && \
-  apt-get install -y --no-install-recommends clang-14 && \
-  apt clean && \
-  rm -rf /var/lib/apt/lists/* && \
-  cd / && \
-  wget -O- https://www.openssl.org/source/openssl-3.0.2.tar.gz | tar xzf - && \
-  mv openssl-3.0.2 openssl && \
-  cd openssl && \
-  ./Configure --prefix=/openssl && \
-  make -j$(nproc)

LICENSE

@@ -1,671 +1,21 @@
-Note: I'm looking for a sponsor who wants to purchase the copyright
-of this work and relicense it under a more liberal license such as
-the MIT license. For now, mold is released under the GNU AGPL v3.
-
-If you just want to use mold but do not want to use AGPL software
-in your organization, a commercial license is available. Please
-contact [email protected].
-
---
-
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+MIT License
+
+Copyright (c) 2023 Rui Ueyama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.third-party

@@ -0,0 +1,348 @@
+Mold includes a number of subcomponents with separate copyright notices
+and license terms. Your use of the source code for the these subcomponents
+is subject to the terms and conditions of the following licenses.
+
+
+=== For the third-party/mimalloc component:
+
+MIT License
+
+Copyright (c) 2018-2021 Microsoft Corporation, Daan Leijen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+=== For the third-party/rust-demangle component:
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+
+=== For the third-party/tbb component:
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+=== For the third-party/xxhash component:
+
+xxHash Library
+Copyright (c) 2012-2020 Yann Collet
+All rights reserved.
+
+BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+=== For the third-party/zlib component:
+
+ (C) 1995-2022 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  [email protected]          [email protected]
+
+
+=== For the third-party/zstd component:
+
+BSD License
+
+For Zstandard software
+
+Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name Facebook nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

@@ -1,224 +0,0 @@
-# If you want to enable ASAN, run `make` with the following options:
-#
-# make CXXFLAGS='-fsanitize=address -g' LDFLAGS=-fsanitize=address USE_MIMALLOC=0
-
-VERSION = 1.2.0
-
-PREFIX = /usr/local
-BINDIR = $(PREFIX)/bin
-LIBDIR = $(PREFIX)/lib
-LIBEXECDIR = $(PREFIX)/libexec
-MANDIR = $(PREFIX)/share/man
-
-INSTALL = install
-INSTALL_PROGRAM = $(INSTALL)
-INSTALL_DATA = $(INSTALL) -m 644
-
-D = $(DESTDIR)
-
-# CXX defaults to `g++`. Rewrite it with a vendor-neutral compiler
-# name `c++`.
-ifeq ($(origin CXX), default)
-  CXX = c++
-endif
-
-# Allow overriding pkg-config binary
-PKG_CONFIG = pkg-config
-
-# If you want to keep symbols in the installed binary, run make with
-# `STRIP=true` to run /bin/true instead of the strip command.
-STRIP = strip
-
-SRCS = $(wildcard *.cc elf/*.cc macho/*.cc)
-OBJS = $(SRCS:%.cc=out/%.o)
-
-OS := $(shell uname -s)
-ARCH := $(shell uname -m)
-
-IS_ANDROID = 0
-ifneq ($(findstring -android,$(shell $(CC) -dumpmachine)),)
-  IS_ANDROID = 1
-endif
-
-# If you want to compile mold for debugging, invoke make as
-# `make CXXFLAGS=-g`.
-CFLAGS = -O2
-CXXFLAGS = -O2
-
-MOLD_CXXFLAGS := -std=c++20 -fno-exceptions -fno-unwind-tables \
-                 -fno-asynchronous-unwind-tables -Ithird-party/xxhash \
-                 -DMOLD_VERSION=\"$(VERSION)\" -DLIBDIR="\"$(LIBDIR)\""
-
-MOLD_LDFLAGS := -pthread -lz -lm -ldl
-
-GIT_HASH := $(shell [ -d .git ] && git rev-parse HEAD)
-ifneq ($(GIT_HASH),)
-  MOLD_CXXFLAGS += -DGIT_HASH=\"$(GIT_HASH)\"
-endif
-
-LTO = 0
-ifeq ($(LTO), 1)
-  CXXFLAGS += -flto -O3
-  LDFLAGS  += -flto
-endif
-
-# By default, we want to use mimalloc as a memory allocator. mimalloc
-# is disabled on macOS and Android because it didn't work on those hosts.
-USE_MIMALLOC = 1
-ifeq ($(OS), Darwin)
-  USE_MIMALLOC = 0
-else ifeq ($(IS_ANDROID), 1)
-  USE_MIMALLOC = 0
-endif
-
-ifeq ($(USE_MIMALLOC), 1)
-  ifdef SYSTEM_MIMALLOC
-    MOLD_CXXFLAGS += -DUSE_SYSTEM_MIMALLOC
-    MOLD_LDFLAGS += -lmimalloc
-  else
-    MIMALLOC_LIB = out/mimalloc/libmimalloc.a
-    MOLD_CXXFLAGS += -Ithird-party/mimalloc/include
-    MOLD_LDFLAGS += -Wl,-whole-archive $(MIMALLOC_LIB) -Wl,-no-whole-archive
-  endif
-endif
-
-ifdef SYSTEM_TBB
-  MOLD_LDFLAGS += -ltbb
-else
-  TBB_LIB = out/tbb/libs/libtbb.a
-  MOLD_LDFLAGS += $(TBB_LIB)
-  MOLD_CXXFLAGS += -Ithird-party/tbb/include
-endif
-
-ifeq ($(OS), Linux)
-  ifeq ($(IS_ANDROID), 0)
-    # glibc before 2.17 need librt for clock_gettime
-    MOLD_LDFLAGS += -Wl,-push-state -Wl,-as-needed -lrt -Wl,-pop-state
-  endif
-endif
-
-NEEDS_LIBCRYPTO = 0
-ifneq ($(OS), Darwin)
-  NEEDS_LIBCRYPTO = 1
-endif
-
-ifeq ($(NEEDS_LIBCRYPTO), 1)
-  MOLD_CXXFLAGS += $(shell $(PKG_CONFIG) --cflags-only-I openssl)
-  MOLD_LDFLAGS += $(shell $(PKG_CONFIG) --libs-only-L openssl) -lcrypto
-endif
-
-# '-latomic' flag is needed building on riscv64 system
-# RV32 system doesn't tested yet
-# seems like '-atomic' would be better but not working.
-ifeq ($(ARCH), riscv64)
-  MOLD_LDFLAGS += -latomic
-endif
-
-# -Wc++11-narrowing is a fatal error on Android, so disable it.
-ifeq ($(IS_ANDROID), 1)
-  MOLD_CXXFLAGS += -Wno-c++11-narrowing
-endif
-
-ifeq ($(OS), Linux)
-  MOLD_WRAPPER_LDFLAGS = -Wl,-push-state -Wl,-no-as-needed -ldl -Wl,-pop-state
-endif
-
-DEPFLAGS = -MT $@ -MMD -MP -MF out/$*.d
-
-all: mold mold-wrapper.so
-
--include $(SRCS:%.cc=out/%.d)
-
-mold: $(OBJS) $(MIMALLOC_LIB) $(TBB_LIB)
-	$(CXX) $(OBJS) -o $@ $(MOLD_LDFLAGS) $(LDFLAGS)
-	ln -sf mold ld
-	ln -sf mold ld64.mold
-
-mold-wrapper.so: elf/mold-wrapper.c
-	$(CC) $(DEPFLAGS) $(CFLAGS) -fPIC -shared -o $@ $< $(MOLD_WRAPPER_LDFLAGS) $(LDFLAGS)
-
-out/%.o: %.cc out/elf/.keep out/macho/.keep
-	$(CXX) $(MOLD_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS) -c -o $@ $<
-
-out/elf/.keep out/macho/.keep:
-	mkdir -p $(@D)
-	touch $@
-
-$(MIMALLOC_LIB):
-	mkdir -p out/mimalloc
-	(cd out/mimalloc; CFLAGS=-DMI_USE_ENVIRON=0 cmake -G'Unix Makefiles' ../../third-party/mimalloc)
-	$(MAKE) -C out/mimalloc mimalloc-static
-
-$(TBB_LIB):
-	mkdir -p out/tbb
-	(cd out/tbb; cmake -G'Unix Makefiles' -DBUILD_SHARED_LIBS=OFF -DTBB_TEST=OFF -DCMAKE_CXX_FLAGS="$(CXXFLAGS) -D__TBB_DYNAMIC_LOAD_ENABLED=0" -DTBB_STRICT=OFF ../../third-party/tbb)
-	$(MAKE) -C out/tbb tbb
-	(cd out/tbb; ln -sf *_relwithdebinfo libs)
-
-test tests check: all
-ifeq ($(OS), Darwin)
-	$(MAKE) -C test -f Makefile.darwin --no-print-directory
-else
-	$(MAKE) -C test -f Makefile.linux --no-print-directory --output-sync
-endif
-	@if test -t 1; then \
-	  printf '\e[32mPassed all tests\e[0m\n'; \
-	else \
-	  echo 'Passed all tests'; \
-	fi
-
-test-x86-64: all
-	@echo x86_64
-	CC=x86_64-linux-gnu-gcc CXX=x86_64-linux-gnu-g++ GCC=x86_64-linux-gnu-gcc GXX=x86_64-linux-gnu-g++ OBJDUMP=x86_64-linux-gnu-objdump MACHINE=x86_64 QEMU='qemu-x86_64 -L /usr/x86_64-linux-gnu' $(MAKE) test
-
-test-i386: all
-	@echo i386
-	CC=i686-linux-gnu-gcc CXX=i686-linux-gnu-g++ GCC=i686-linux-gnu-gcc GXX=i686-linux-gnu-g++ OBJDUMP=x86_64-linux-gnu-objdump MACHINE=i386 QEMU='qemu-i386 -L /usr/i686-linux-gnu' $(MAKE) test
-
-test-arm64: all
-	@echo arm64
-	CC=aarch64-linux-gnu-gcc CXX=aarch64-linux-gnu-g++ GCC=aarch64-linux-gnu-gcc GXX=aarch64-linux-gnu-g++ OBJDUMP=aarch64-linux-gnu-objdump MACHINE=aarch64 QEMU='qemu-aarch64 -L /usr/aarch64-linux-gnu' $(MAKE) test
-
-test-arm32: all
-	@echo arm
-	CC=arm-linux-gnueabihf-gcc CXX=arm-linux-gnueabihf-g++ GCC=arm-linux-gnueabihf-gcc GXX=arm-linux-gnueabihf-g++ OBJDUMP=arm-linux-gnueabihf-objdump MACHINE=arm QEMU='qemu-arm -L /usr/arm-linux-gnueabihf' $(MAKE) test
-
-test-riscv64: all
-	@echo riscv64
-	CC=riscv64-linux-gnu-gcc CXX=riscv64-linux-gnu-g++ GCC=riscv64-linux-gnu-gcc GXX=riscv64-linux-gnu-g++ OBJDUMP=riscv64-linux-gnu-objdump MACHINE=riscv64 QEMU='qemu-riscv64 -L /usr/riscv64-linux-gnu' $(MAKE) test
-
-
-test-all:
-	$(MAKE) test-x86-64
-	$(MAKE) test-i386
-	$(MAKE) test-arm64
-	$(MAKE) test-arm32
-	$(MAKE) test-riscv64
-
-install: all
-	$(INSTALL) -d $D$(BINDIR)
-	$(INSTALL_PROGRAM) mold $D$(BINDIR)
-	$(STRIP) $D$(BINDIR)/mold
-
-	$(INSTALL) -d $D$(LIBDIR)/mold
-	$(INSTALL_DATA) mold-wrapper.so $D$(LIBDIR)/mold
-	$(STRIP) $D$(LIBDIR)/mold/mold-wrapper.so
-
-	$(INSTALL) -d $D$(LIBEXECDIR)/mold
-	ln -sf $(BINDIR)/mold $D$(LIBEXECDIR)/mold/ld
-
-	$(INSTALL) -d $D$(MANDIR)/man1
-	$(INSTALL_DATA) docs/mold.1 $D$(MANDIR)/man1
-
-	ln -sf mold $D$(BINDIR)/ld.mold
-	ln -sf mold $D$(BINDIR)/ld64.mold
-
-uninstall:
-	rm -f $D$(BINDIR)/mold $D$(BINDIR)/ld.mold $D$(BINDIR)/ld64.mold
-	rm -f $D$(MANDIR)/man1/mold.1
-	rm -rf $D$(LIBDIR)/mold
-
-clean:
-	rm -rf *~ mold mold-wrapper.so out ld ld64.mold mold-*-linux.tar.gz
-
-.PHONY: all test tests check clean test-x86-64 test-i386 test-arm64 test-arm32 test-riscv64 test-all

README.md

@@ -1,14 +1,19 @@
 # mold: A Modern Linker
 
-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.
+<i>This repository contains a free version of the mold linker.
+If you are looking for a commercial version that supports macOS
+please visit the
+[repository of the sold linker](https://github.com/bluewhalesystems/sold).</i>
 
-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.
+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.
+
+Here is a performance comparison of GNU gold, LLVM lld, and mold when linking
+final debuginfo-enabled executables for major large programs on a simulated
+8-core, 16-thread machine.
 
 ![Link speed comparison](docs/comparison.png)
 
@@ -18,118 +23,106 @@ on a simulated 8-core 16-threads machine.
 | 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, please feel
+free to [file a bug report](https://github.com/rui314/mold/issues).
 
-mold currently supports x86-64, i386, ARM32, ARM64 and 64-bit RISC-V.
+mold supports x86-64, i386, ARM64, ARM32, 64-bit/32-bit little/big-endian
+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, SH-4, and DEC
+Alpha.
 
-## Why does the speed of linking matter?
+mold/macOS is commercial software. For mold/macOS, please visit
+https://github.com/bluewhalesystems/sold.
 
-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 a
-source file into an object file (`.o` files). In the second phase,
-a linker takes all object files to combine them into a single executable
-or a shared library file.
+## Why does linking speed matter?
 
-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.
+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.
 
-## Install
+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.
 
-Binary packages for the following distros are currently available.
+## Installation
+
+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 as well as libstdc++ 10 or libc++ 7 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).
 
-I'm using Ubuntu 20.04 as a development platform. In that environment,
-you can build mold by the following commands.
+### Install Dependencies
 
-### Install dependencies
-
-#### Ubuntu 20.04 and later / Debian 11 and later
-
-```shell
-sudo apt-get update
-sudo apt-get install -y build-essential git clang cmake libstdc++-10-dev libssl-dev libxxhash-dev zlib1g-dev pkg-config
-```
-
-#### Fedora 34 and later
-
-```shell
-sudo dnf install -y git clang cmake openssl-devel xxhash-devel zlib-devel libstdc++-devel
-```
+To install build dependencies, run `./install-build-deps.sh` in this
+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
-cd mold
-git checkout v1.2.0
-make -j$(nproc) CXX=clang++
-sudo make install
+mkdir mold/build
+cd mold/build
+git checkout v2.3.0
+../install-build-deps.sh
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=c++ ..
+cmake --build . -j $(nproc)
+sudo cmake --build . --target install
 ```
 
-You may need to pass a C++20 compiler command name to `make`.
-In the above case, `clang++` 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`.
+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
-`make` 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 running `make -j$(nproc)`. The shell script creates a
-Ubuntu 18.04 Docker image, installs necessary tools and libraries to it,
-builds mold and auxiliary files, 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.
-
-`make test` depends on a few more packages. To install, run the following commands:
-
-```shell
-sudo dpkg --add-architecture i386
-sudo apt update
-sudo apt-get install bsdmainutils dwarfdump libc6-dev:i386 lib32gcc-10-dev libstdc++-10-dev-arm64-cross gcc-10-aarch64-linux-gnu g++-10-aarch64-linux-gnu
-```
+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 another build system command.
 
-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 (upcoming version) 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 `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.
+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. However, GCC does not
+accept an absolute path as an argument for `-fuse-ld`.
 
 </details>
 
@@ -137,83 +130,138 @@ take an absolute path as an argument for `-fuse-ld` though.
 
 Create `.cargo/config.toml` in your project directory with the following:
 
-```
+```toml
 [target.x86_64-unknown-linux-gnu]
 linker = "clang"
 rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold"]
 ```
 
-where `/path/to/mold` is an absolute path to `mold` exectuable.
-Please make sure you have installed `clang`.
+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.
 
-If you want to use mold for all projects, put the above snippet to
+```toml
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=/path/to/mold"]
+```
+
+If you want to use mold for all projects, add the above snippet to
 `~/.cargo/config.toml`.
 
 </details>
 
+<details><summary>If you are using Nim</summary>
+
+Create `config.nims` in your project directory with the following:
+
+```nim
+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, `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, 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.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`.
+Internally, mold invokes the 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.gold`, or `ld.lld`.
 
 </details>
 
-<details><summary>GitHub Action</summary>
-If you want to use mold in your GitHub-hosted CI to speed up continuous
-build, you can use <a href=https://github.com/rui314/setup-mold>setup-mold</a>
-GitHub Action. GitHub runs a CI 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.
+<details><summary>GitHub Actions</summary>
+
+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 two-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
-readelf -p .comment <executable-file>
+$ readelf -p .comment <executable-file>
 
 String dump of section '.comment':
   [     0]  GCC: (Ubuntu 10.2.0-5ubuntu1~20.04) 10.2.0
   [    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. However, if you need it, [mold's man page](docs/mold.md)
+is available. 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).
+For details, please see the [design notes](docs/design.md).
 
-# Logo
+## Sponsors
 
--![mold image](docs/mold.jpg)
+We accept donations via [GitHub Sponsors](https://github.com/sponsors/rui314)
+and [OpenCollective](https://opencollective.com/mold-linker). 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://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>
+
+- [Uber](https://uber.com)
+- [G-Research](https://www.gresearch.co.uk)
+- [Signal Slot Inc.](https://github.com/signal-slot)
+
+### 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)

big-endian.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstring>
-
-#ifdef __BIG_ENDIAN__
-#error "mold does not support big-endian hosts"
-#endif
-
-namespace mold {
-
-template <typename T>
-class BigEndian {
-public:
-  BigEndian() = delete;
-
-  operator T() const {
-    T x;
-    memcpy(&x, val, sizeof(T));
-    return bswap(x);
-  }
-
-  BigEndian &operator=(T x) {
-    x = bswap(x);
-    memcpy(&val, &x, sizeof(T));
-    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;
-  }
-
-private:
-  uint8_t val[sizeof(T)];
-
-  static T bswap(T x) {
-    if constexpr (sizeof(T) == 2)
-      return __builtin_bswap16(x);
-    else if constexpr (sizeof(T) == 4)
-      return __builtin_bswap32(x);
-    else
-      return __builtin_bswap64(x);
-  }
-};
-
-using ibig16 = BigEndian<int16_t>;
-using ibig32 = BigEndian<int32_t>;
-using ibig64 = BigEndian<int64_t>;
-using ubig16 = BigEndian<uint16_t>;
-using ubig32 = BigEndian<uint32_t>;
-using ubig64 = BigEndian<uint64_t>;
-
-} // namespace mold

cmdline.h

@@ -1,63 +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 && !isspace(data[i]))
-      buf.append(1, data[i++]);
-    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;
-}
-
-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;
-}
-
-} // namespace mold

common/Dockerfile

@@ -0,0 +1,17 @@
+# 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 libssl-dev && \
+  \
+  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

common/archive-file.h

@@ -1,6 +1,31 @@
+// This file contains functions to read an archive file (.a file).
+// An archive file is just a bundle of object files. It's similar to
+// tar or zip, but the contents are not compressed.
+//
+// An archive file is either "regular" or "thin". A regular archive
+// contains object files directly, while a thin archive contains only
+// pathnames. In the latter case, actual file contents have to be read
+// from given pathnames. A regular archive is sometimes called "fat"
+// archive as opposed to "thin".
+//
+// If an archive file is given to the linker, the linker pulls out
+// object files that are needed to resolve undefined symbols. So,
+// bunding object files as an archive and giving that archive to the
+// linker has a different meaning than directly giving the same set of
+// object files to the linker. The former links only needed object
+// files, while the latter links all the given object files.
+//
+// Therefore, if you link libc.a for example, not all the libc
+// functions are linked to your binary. Instead, only object files
+// that provides functions and variables used in your program get
+// linked. To make this efficient, static library functions are
+// usually separated to each object file in an archive file. You can
+// see the contents of libc.a by running `ar t
+// /usr/lib/x86_64-linux-gnu/libc.a`.
+
 #pragma once
 
-#include "mold.h"
+#include "common.h"
 #include "filetype.h"
 
 namespace mold {
@@ -51,12 +76,12 @@ struct ArHdr {
   }
 };
 
-template <typename C>
-std::vector<MappedFile<C> *>
-read_thin_archive_members(C &ctx, MappedFile<C> *mf) {
+template <typename Context, typename MappedFile>
+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) {
@@ -92,18 +117,18 @@ read_thin_archive_members(C &ctx, MappedFile<C> *mf) {
 
     std::string path = name.starts_with('/') ?
       name : (filepath(mf->name).parent_path() / name).string();
-    vec.push_back(MappedFile<C>::must_open(ctx, path));
+    vec.push_back(MappedFile::must_open(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, typename MappedFile>
+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) {
@@ -137,10 +162,9 @@ 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)) {
+template <typename Context, typename MappedFile>
+std::vector<MappedFile *> read_archive_members(Context &ctx, MappedFile *mf) {
+  switch (get_file_type(ctx, mf)) {
   case FileType::AR:
     return read_fat_archive_members(ctx, mf);
   case FileType::THIN_AR:

common/cmdline.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "common.h"
+
+namespace mold {
+
+template <typename Context>
+std::vector<std::string_view>
+read_response_file(Context &ctx, std::string_view path, i64 depth) {
+  if (depth > 10)
+    Fatal(ctx) << path << ": response file nesting too deep";
+
+  std::vector<std::string_view> vec;
+  MappedFile<Context> *mf = MappedFile<Context>::must_open(ctx, std::string(path));
+  std::string_view data((char *)mf->data, mf->size);
+
+  while (!data.empty()) {
+    if (isspace(data[0])) {
+      data = data.substr(1);
+      continue;
+    }
+
+    auto read_quoted = [&]() {
+      char quote = data[0];
+      data = data.substr(1);
+
+      std::string buf;
+      while (!data.empty() && data[0] != quote) {
+        if (data[0] == '\\' && data.size() >= 1) {
+          buf.append(1, data[1]);
+          data = data.substr(2);
+        } else {
+          buf.append(1, data[0]);
+          data = data.substr(1);
+        }
+      }
+      if (data.empty())
+        Fatal(ctx) << path << ": premature end of input";
+      data = data.substr(1);
+      return save_string(ctx, buf);
+    };
+
+    auto read_unquoted = [&] {
+      std::string buf;
+      while (!data.empty()) {
+        if (data[0] == '\\' && data.size() >= 1) {
+          buf.append(1, data[1]);
+          data = data.substr(2);
+          continue;
+        }
+
+        if (!isspace(data[0])) {
+          buf.append(1, data[0]);
+          data = data.substr(1);
+          continue;
+        }
+        break;
+      }
+      return save_string(ctx, buf);
+    };
+
+    std::string_view tok;
+    if (data[0] == '\'' || data[0] == '\"')
+      tok = read_quoted();
+    else
+      tok = read_unquoted();
+
+    if (tok.starts_with('@'))
+      append(vec, read_response_file(ctx, tok.substr(1), depth + 1));
+    else
+      vec.push_back(tok);
+  }
+  return vec;
+}
+
+// Replace "@path/to/some/text/file" with its file contents.
+template <typename Context>
+std::vector<std::string_view> expand_response_files(Context &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, 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

common/compress.cc

@@ -1,23 +1,30 @@
-// This file implements a multi-threaded zlib compression routine.
+// This file implements a multi-threaded zlib and zstd compression
+// routine.
 //
-// Multiple pieces of raw compressed data in zlib-format can be merged
-// just by concatenation as long as each zlib stream is flushed with
-// Z_SYNC_FLUSH. In this file, we split input data into multiple
-// shards, compress them individually and concatenate them. We then
-// append a header, a trailer and a checksum so that the concatenated
-// data is valid zlib-format data.
+// zlib-compressed data can be merged just by concatenation as long as
+// each piece of data is flushed with Z_SYNC_FLUSH. In this file, we
+// split input data into multiple shards, compress them individually
+// and concatenate them. We then append a header, a trailer and a
+// checksum so that the concatenated data is valid zlib-format data.
+//
+// zstd-compressed data can be merged in the same way.
 //
 // Using threads to compress data has a downside. Since the dictionary
 // is reset on boundaries of shards, compression ratio is sacrificed
 // 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>
+#include <zstd.h>
 
-#define CHECK(fn) do { int r = (fn); assert(r == Z_OK); } while (0)
+#define CHECK(fn)                               \
+  do {                                          \
+    [[maybe_unused]] int r = (fn);              \
+    assert(r == Z_OK);                          \
+  } while (0)
 
 namespace mold {
 
@@ -35,7 +42,7 @@ static std::vector<std::string_view> split(std::string_view input) {
   return shards;
 }
 
-static std::vector<u8> do_compress(std::string_view input) {
+static std::vector<u8> zlib_compress(std::string_view input) {
   // Initialize zlib stream. Since debug info is generally compressed
   // pretty well with lower compression levels, we chose compression
   // level 1.
@@ -85,11 +92,13 @@ static std::vector<u8> do_compress(std::string_view input) {
 
   assert(strm.avail_out > 0);
   buf.resize(buf.size() - strm.avail_out);
+  buf.shrink_to_fit();
   deflateEnd(&strm);
   return buf;
 }
 
-ZlibCompressor::ZlibCompressor(std::string_view input) {
+ZlibCompressor::ZlibCompressor(u8 *buf, i64 size) {
+  std::string_view input{(char *)buf, (size_t)size};
   std::vector<std::string_view> inputs = split(input);
   std::vector<u64> adlers(inputs.size());
   shards.resize(inputs.size());
@@ -97,20 +106,18 @@ ZlibCompressor::ZlibCompressor(std::string_view input) {
   // Compress each shard
   tbb::parallel_for((i64)0, (i64)inputs.size(), [&](i64 i) {
     adlers[i] = adler32(1, (u8 *)inputs[i].data(), inputs[i].size());
-    shards[i] = do_compress(inputs[i]);
+    shards[i] = zlib_compress(inputs[i]);
   });
 
   // Combine checksums
   checksum = adlers[0];
   for (i64 i = 1; i < inputs.size(); i++)
     checksum = adler32_combine(checksum, adlers[i], inputs[i].size());
-}
 
-i64 ZlibCompressor::size() const {
-  i64 size = 2;    // +2 for header
-  for (const std::vector<u8> &shard : shards)
-    size += shard.size();
-  return size + 6; // +6 for trailer and checksum
+  // Comput the total size
+  compressed_size = 8; // the header and the trailer
+  for (std::vector<u8> &shard : shards)
+    compressed_size += shard.size();
 }
 
 void ZlibCompressor::write_to(u8 *buf) {
@@ -129,64 +136,50 @@ void ZlibCompressor::write_to(u8 *buf) {
   });
 
   // Write a trailer
-  u8 *end = buf + size();
+  u8 *end = buf + compressed_size;
   end[-6] = 3;
   end[-5] = 0;
 
   // Write a checksum
-  *(ubig32 *)(end - 4) = checksum;
+  *(ub32 *)(end - 4) = checksum;
 }
 
-GzipCompressor::GzipCompressor(std::string_view input) {
+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
+
+  size_t sz = ZSTD_compress(buf.data(), buf.size(), input.data(), input.size(),
+                            level);
+  assert(!ZSTD_isError(sz));
+  buf.resize(sz);
+  buf.shrink_to_fit();
+  return buf;
+}
+
+ZstdCompressor::ZstdCompressor(u8 *buf, i64 size) {
+  std::string_view input{(char *)buf, (size_t)size};
   std::vector<std::string_view> inputs = split(input);
-  std::vector<u32> crc(inputs.size());
   shards.resize(inputs.size());
 
   // Compress each shard
   tbb::parallel_for((i64)0, (i64)inputs.size(), [&](i64 i) {
-    crc[i] = crc32(0, (u8 *)inputs[i].data(), inputs[i].size());
-    shards[i] = do_compress(inputs[i]);
+    shards[i] = zstd_compress(inputs[i]);
   });
 
-  // Combine checksums
-  checksum = crc[0];
-  for (i64 i = 1; i < inputs.size(); i++)
-    checksum = crc32_combine(checksum, crc[i], inputs[i].size());
-
-  uncompressed_size = input.size();
+  compressed_size = 0;
+  for (std::vector<u8> &shard : shards)
+    compressed_size += shard.size();
 }
 
-i64 GzipCompressor::size() const {
-  i64 size = 10;    // +10 for header
-  for (const std::vector<u8> &shard : shards)
-    size += shard.size();
-  return size + 10; // +10 for trailer and checksum
-}
-
-void GzipCompressor::write_to(u8 *buf) {
-  // Write a zlib-format header
-  memset(buf, 0, 10);
-  buf[0] = 0x1f; // magic
-  buf[1] = 0x8b; // magic
-  buf[2] = 0x08; // compression method is zlib
-  buf[9] = 0xff; // made on unknown OS
-
+void ZstdCompressor::write_to(u8 *buf) {
   // Copy compressed data
   std::vector<i64> offsets(shards.size());
-  offsets[0] = 10; // +10 for header
   for (i64 i = 1; i < shards.size(); i++)
     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());
   });
-
-  // Write a trailer
-  u8 *end = buf + size();
-  end[-10] = 0x3; // two-byte zlib stream terminator
-  end[-9] = 0;
-  *(u32 *)(end - 8) = checksum;
-  *(u32 *)(end - 4) = uncompressed_size;
 }
 
 } // namespace mold

common/config.h.in

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

common/demangle.cc

@@ -0,0 +1,51 @@
+#include "common.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

common/filepath.cc

@@ -1,4 +1,4 @@
-#include "mold.h"
+#include "common.h"
 
 #include <filesystem>
 #include <sys/stat.h>
@@ -7,20 +7,22 @@ namespace mold {
 
 std::string get_realpath(std::string_view path) {
   std::error_code ec;
-  std::string ret = std::filesystem::canonical(path, ec);
-  return ec ? std::string(path) : ret;
+  std::filesystem::path link = std::filesystem::read_symlink(path, ec);
+  if (ec)
+    return std::string(path);
+  return (filepath(path) / ".." / link).lexically_normal().string();
 }
 
 // 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();
+  return filepath(path).lexically_normal().string();
 }
 
 std::filesystem::path to_abs_path(std::filesystem::path path) {
   if (path.is_absolute())
-    return path;
+    return path.lexically_normal();
   return (std::filesystem::current_path() / path).lexically_normal();
 }
 

common/filetype.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "mold.h"
-#include "elf/elf.h"
+#include "common.h"
+#include "../elf/elf.h"
 
 namespace mold {
 
@@ -11,7 +11,9 @@ enum class FileType {
   ELF_OBJ,
   ELF_DSO,
   MACH_OBJ,
+  MACH_EXE,
   MACH_DYLIB,
+  MACH_BUNDLE,
   MACH_UNIVERSAL,
   AR,
   THIN_AR,
@@ -21,34 +23,52 @@ enum class FileType {
   LLVM_BITCODE,
 };
 
-template <typename C>
-bool is_text_file(MappedFile<C> *mf) {
+template <typename MappedFile>
+bool is_text_file(MappedFile *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) {
+template <typename E, typename Context, typename MappedFile>
+inline bool is_gcc_lto_obj(Context &ctx, MappedFile *mf) {
   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 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 (!ctx.arg.plugin.empty()) {
+      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),
-                                  sec.sh_size / sizeof(ElfSym<E>)};
+                                  (size_t)sec.sh_size / sizeof(ElfSym<E>)};
 
     auto skip = [](u8 type) {
       return type == STT_NOTYPE || type == STT_FILE || type == STT_SECTION;
     };
 
-    // GCC LTO object contains only sections symbols followed by a common
-    // symbol whose name is `__gnu_lto_v1` or `__gnu_lto_slim`.
     i64 i = 1;
     while (i < elf_syms.size() && skip(elf_syms[i].st_type))
       i++;
@@ -65,41 +85,64 @@ inline bool is_gcc_lto_obj(MappedFile<C> *mf) {
   return false;
 }
 
-template <typename C>
-FileType get_file_type(MappedFile<C> *mf) {
+template <typename Context, typename MappedFile>
+FileType get_file_type(Context &ctx, MappedFile *mf) {
+  using namespace elf;
+
   std::string_view data = mf->get_contents();
 
   if (data.empty())
     return FileType::EMPTY;
 
   if (data.starts_with("\177ELF")) {
-    switch (*(u16 *)(data.data() + 16)) {
-    case 1: {
-      // ET_REL
-      elf::Elf32Ehdr &ehdr = *(elf::Elf32Ehdr *)data.data();
+    u8 byte_order = ((ElfEhdr<I386> *)data.data())->e_ident[EI_DATA];
 
-      if (ehdr.e_ident[elf::EI_CLASS] == elf::ELFCLASS32) {
-        if (is_gcc_lto_obj<elf::I386>(mf))
-          return FileType::GCC_LTO_OBJ;
-      } else {
-        if (is_gcc_lto_obj<elf::X86_64>(mf))
-          return FileType::GCC_LTO_OBJ;
+    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>(ctx, mf))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<X86_64>(ctx, mf))
+            return FileType::GCC_LTO_OBJ;
+        }
+        return FileType::ELF_OBJ;
       }
 
-      return FileType::ELF_OBJ;
-    }
-    case 3: // ET_DYN
-      return FileType::ELF_DSO;
+      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>(ctx, mf))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<SPARC64>(ctx, mf))
+            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 (*(u32 *)(data.data() + 12)) {
+    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;
   }
@@ -127,8 +170,10 @@ inline std::string filetype_to_string(FileType type) {
   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";

common/glob.cc

@@ -1,10 +1,10 @@
-#include "mold.h"
+#include "common.h"
 
 #include <cstring>
 
-namespace mold::elf {
+namespace mold {
 
-std::optional<GlobPattern> GlobPattern::compile(std::string_view pat) {
+std::optional<Glob> Glob::compile(std::string_view pat) {
   std::vector<Element> vec;
 
   while (!pat.empty()) {
@@ -20,8 +20,7 @@ std::optional<GlobPattern> GlobPattern::compile(std::string_view pat) {
       // [a-czg-i]: a, b, c, z, g, h, or i
       // [^a-z]: Any character except lowercase letters
       vec.push_back({BRACKET});
-      std::vector<bool> &bitmap = vec.back().bitmap;
-      bitmap.resize(256);
+      std::bitset<256> &bitset = vec.back().bitset;
 
       bool negate = false;
       if (!pat.empty() && pat[0] == '^') {
@@ -60,9 +59,9 @@ std::optional<GlobPattern> GlobPattern::compile(std::string_view pat) {
             return {};
 
           for (i64 i = start; i <= end; i++)
-            bitmap[i] = true;
+            bitset[i] = true;
         } else {
-          bitmap[(u8)pat[0]] = true;
+          bitset[(u8)pat[0]] = true;
           pat = pat.substr(1);
         }
       }
@@ -71,8 +70,7 @@ std::optional<GlobPattern> GlobPattern::compile(std::string_view pat) {
         return {};
 
       if (negate)
-        for (i64 i = 0; i < 256; i++)
-          bitmap[i] = !bitmap[i];
+        bitset.flip();
       break;
     }
     case '?':
@@ -89,14 +87,14 @@ std::optional<GlobPattern> GlobPattern::compile(std::string_view pat) {
     }
   }
 
-  return {GlobPattern{std::move(vec)}};
+  return {Glob{std::move(vec)}};
 }
 
-bool GlobPattern::match(std::string_view str) {
+bool Glob::match(std::string_view str) {
   return do_match(str, elements);
 }
 
-bool GlobPattern::do_match(std::string_view str, std::span<Element> elements) {
+bool Glob::do_match(std::string_view str, std::span<Element> elements) {
   while (!elements.empty()) {
     Element &e = elements[0];
     elements = elements.subspan(1);
@@ -138,7 +136,7 @@ bool GlobPattern::do_match(std::string_view str, std::span<Element> elements) {
       str = str.substr(1);
       break;
     case BRACKET:
-      if (str.empty() || !e.bitmap[str[0]])
+      if (str.empty() || !e.bitset[str[0]])
         return false;
       str = str.substr(1);
       break;
@@ -148,4 +146,4 @@ bool GlobPattern::do_match(std::string_view str, std::span<Element> elements) {
   return str.empty();
 }
 
-} // namespace mold::elf
+} // namespace mold

common/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;
 }
 

common/integers.h

@@ -0,0 +1,221 @@
+// 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

common/main.cc

@@ -0,0 +1,169 @@
+#include "common.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};
+
+  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: {
+    const char msg[] =
+      "mold: aborted\n"
+      "mold: If mold failed due to a spurious failure of pthread_create, "
+      "it's likely because of https://github.com/oneapi-src/oneTBB/pull/824. "
+      "You should ensure that you are using 2021.9.0 or newer version of libtbb.\n";
+    (void)!write(STDERR_FILENO, msg, sizeof(msg) - 1);
+    break;
+  }
+  }
+
+  _exit(1);
+}
+
+void install_signal_handler() {
+  struct sigaction action;
+  action.sa_sigaction = sighandler;
+  sigemptyset(&action.sa_mask);
+  action.sa_flags = SA_SIGINFO;
+
+  sigaction(SIGABRT, &action, NULL);
+  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.starts_with("ld64."))
+    return mold::macho::main(argc, argv);
+#endif
+
+  return mold::elf::main(argc, argv);
+}

common/multi-glob.cc

@@ -1,34 +1,34 @@
-// This file implements the Aho-Corasick algorithm to match version
-// script patterns to symbol strings as quickly as possible.
+// This file implements the Aho-Corasick algorithm to match multiple
+// glob patterns to symbol strings as quickly as possible.
 //
-// Here are some examples of version script patterns:
+// Here are some examples of glob patterns:
 //
 //    qt_private_api_tag*
 //    *16QAccessibleCache*
 //    *32QAbstractFileIconProviderPrivate*
 //    *17QPixmapIconEngine*
 //
-// The pattern is a glob pattern, so `*` is a wildcard that matches
-// any substring. We sometimes have hundreds of version script
-// patterns and have to match them against millions of symbol strings.
+// `*` is a wildcard that matches any substring. We sometimes have
+// hundreds of glob patterns and have to match them against millions
+// of symbol strings.
 //
 // Aho-Corasick cannot handle complex patterns such as `*foo*bar*`.
-// We handle such patterns with GlobPattern. GlobPattern is relatively
-// slow, but complex patterns are rare in practice, so it should be OK.
+// We handle such patterns with the Glob class. Glob is relatively
+// 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::elf {
+namespace mold {
 
-std::optional<u16> VersionMatcher::find(std::string_view str) {
-  u32 idx = UINT32_MAX;
+std::optional<u32> MultiGlob::find(std::string_view str) {
+  std::call_once(once, [&] { compile(); });
+  u32 val = UINT32_MAX;
 
   if (root) {
-    std::call_once(once_flag, [&] { compile(); });
-
     // Match against simple glob patterns
     TrieNode *node = root.get();
 
@@ -36,7 +36,7 @@ std::optional<u16> VersionMatcher::find(std::string_view str) {
       for (;;) {
         if (node->children[c]) {
           node = node->children[c].get();
-          idx = std::min(idx, node->value);
+          val = std::min(val, node->value);
           return;
         }
 
@@ -53,13 +53,13 @@ std::optional<u16> VersionMatcher::find(std::string_view str) {
   }
 
   // Match against complex glob patterns
-  for (std::pair<GlobPattern, u32> &glob : globs)
+  for (std::pair<Glob, u32> &glob : globs)
     if (glob.first.match(str))
-      idx = std::min(idx, glob.second);
+      val = std::min(val, glob.second);
 
-  if (idx == UINT32_MAX)
+  if (val == UINT32_MAX)
     return {};
-  return versions[idx];
+  return val;
 }
 
 static bool is_simple_pattern(std::string_view pat) {
@@ -82,18 +82,16 @@ static std::string handle_stars(std::string_view pat) {
   return "\0"s + str + "\0"s;
 }
 
-bool VersionMatcher::add(std::string_view pat, u16 ver) {
-  assert(!compiled);
+bool MultiGlob::add(std::string_view pat, u32 val) {
+  assert(!is_compiled);
   assert(!pat.empty());
 
-  u32 idx = strings.size();
   strings.push_back(std::string(pat));
-  versions.push_back(ver);
 
   // Complex glob pattern
   if (!is_simple_pattern(pat)) {
-    if (std::optional<GlobPattern> glob = GlobPattern::compile(pat)) {
-      globs.push_back({std::move(*glob), idx});
+    if (std::optional<Glob> glob = Glob::compile(pat)) {
+      globs.push_back({std::move(*glob), val});
       return true;
     }
     return false;
@@ -110,17 +108,19 @@ bool VersionMatcher::add(std::string_view pat, u16 ver) {
     node = node->children[c].get();
   }
 
-  node->value = std::min(node->value, idx);
+  node->value = std::min(node->value, val);
   return true;
 }
 
-void VersionMatcher::compile() {
-  fix_suffix_links(*root);
-  fix_values();
-  compiled = true;
+void MultiGlob::compile() {
+  is_compiled = true;
+  if (root) {
+    fix_suffix_links(*root);
+    fix_values();
+  }
 }
 
-void VersionMatcher::fix_suffix_links(TrieNode &node) {
+void MultiGlob::fix_suffix_links(TrieNode &node) {
   for (i64 i = 0; i < 256; i++) {
     if (!node.children[i])
       continue;
@@ -146,7 +146,7 @@ void VersionMatcher::fix_suffix_links(TrieNode &node) {
   }
 }
 
-void VersionMatcher::fix_values() {
+void MultiGlob::fix_values() {
   std::queue<TrieNode *> queue;
   queue.push(root.get());
 
@@ -163,4 +163,4 @@ void VersionMatcher::fix_values() {
   } while (!queue.empty());
 }
 
-} // namespace mold::elf
+} // namespace mold

common/output-file-unix.h

@@ -0,0 +1,144 @@
+#include "common.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 Context>
+static std::pair<i64, char *>
+open_or_create_file(Context &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 Context>
+class MemoryMappedOutputFile : public OutputFile<Context> {
+public:
+  MemoryMappedOutputFile(Context &ctx, std::string path, i64 filesize, i64 perm)
+    : OutputFile<Context>(path, filesize, true) {
+    std::tie(this->fd, output_tmpfile) =
+      open_or_create_file(ctx, path, filesize, perm);
+
+    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 &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 Context>
+std::unique_ptr<OutputFile<Context>>
+OutputFile<Context>::open(Context &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<Context> *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);
+}
+
+} // namespace mold

common/output-file-win32.h

@@ -0,0 +1,24 @@
+#include "common.h"
+
+#include <fcntl.h>
+#include <filesystem>
+#include <windows.h>
+
+namespace mold {
+
+template <typename Context>
+std::unique_ptr<OutputFile<Context>>
+OutputFile<Context>::open(Context &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<Context> *file = new MallocOutputFile(ctx, path, filesize, perm);
+
+  if (ctx.arg.filler != -1)
+    memset(file->buf, ctx.arg.filler, filesize);
+  return std::unique_ptr<OutputFile<Context>>(file);
+}
+
+} // namespace mold

common/output-file.h

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

common/perf.cc

@@ -1,10 +1,13 @@
-#include "mold.h"
+#include "common.h"
 
 #include <functional>
 #include <iomanip>
 #include <ios>
+
+#ifndef _WIN32
 #include <sys/resource.h>
 #include <sys/time.h>
+#endif
 
 namespace mold {
 
@@ -23,24 +26,39 @@ 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;
+  return (i64)t.tv_sec * 1'000'000'000 + t.tv_nsec;
+#endif
 }
 
-static i64 to_nsec(struct timeval t) {
-  return (i64)t.tv_sec * 1000000000 + t.tv_usec * 1000;
+static std::pair<i64, i64> get_usage() {
+#ifdef _WIN32
+  auto to_nsec = [](FILETIME t) -> i64 {
+    return ((u64)t.dwHighDateTime << 32 + (u64)t.dwLowDateTime) * 100;
+  };
+
+  FILETIME creation, exit, kernel, user;
+  GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user);
+  return {to_nsec(user), to_nsec(kernel)};
+#else
+  auto to_nsec = [](struct timeval t) -> i64 {
+    return (i64)t.tv_sec * 1'000'000'000 + t.tv_usec * 1'000;
+  };
+
+  struct rusage ru;
+  getrusage(RUSAGE_SELF, &ru);
+  return {to_nsec(ru.ru_utime), to_nsec(ru.ru_stime)};
+#endif
 }
 
 TimerRecord::TimerRecord(std::string name, TimerRecord *parent)
   : name(name), parent(parent) {
-  struct rusage usage;
-  getrusage(RUSAGE_SELF, &usage);
-
   start = now_nsec();
-  user = to_nsec(usage.ru_utime);
-  sys = to_nsec(usage.ru_stime);
-
+  std::tie(user, sys) = get_usage();
   if (parent)
     parent->children.push_back(this);
 }
@@ -50,19 +68,20 @@ void TimerRecord::stop() {
     return;
   stopped = true;
 
-  struct rusage usage;
-  getrusage(RUSAGE_SELF, &usage);
+  i64 user2;
+  i64 sys2;
+  std::tie(user2, sys2) = get_usage();
 
   end = now_nsec();
-  user = to_nsec(usage.ru_utime) - user;
-  sys = to_nsec(usage.ru_stime) - sys;
+  user = user2 - user;
+  sys = sys2 - sys;
 }
 
 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());
 

common/tar.cc

@@ -1,4 +1,4 @@
-#include "mold.h"
+#include "common.h"
 
 namespace mold {
 
@@ -24,8 +24,11 @@ struct UstarHeader {
     int sum = 0;
     for (i64 i = 0; i < sizeof(*this); i++)
       sum += ((u8 *)this)[i];
-    assert(sum < 1000000);
-    sprintf(checksum, "%06o", sum);
+
+    // We need to convince the compiler that sum isn't too big to silence
+    // -Werror=format-truncation.
+    ASSUME(sum < 01'000'000);
+    snprintf(checksum, sizeof(checksum), "%06o", sum);
   }
 
   char name[100];
@@ -47,6 +50,8 @@ struct UstarHeader {
   char pad[12];
 };
 
+static_assert(sizeof(UstarHeader) == 512);
+
 static std::string encode_path(std::string basedir, std::string path) {
   path = path_clean(basedir + "/" + path);
 
@@ -77,7 +82,8 @@ void TarWriter::append(std::string path, std::string_view data) {
   UstarHeader pax;
 
   std::string attr = encode_path(basedir, path);
-  sprintf(pax.size, "%011zo", attr.size());
+  snprintf(pax.size, sizeof(pax.size), "%011zo", attr.size());
+  pax.name[0] = '/';
   pax.typeflag[0] = 'x';
   pax.finalize();
   fwrite(&pax, sizeof(pax), 1, out);
@@ -89,7 +95,7 @@ void TarWriter::append(std::string path, std::string_view data) {
   // Write Ustar header
   UstarHeader ustar;
   memcpy(ustar.mode, "0000664", 8);
-  sprintf(ustar.size, "%011zo", data.size());
+  snprintf(ustar.size, sizeof(ustar.size), "%011zo", data.size());
   ustar.finalize();
   fwrite(&ustar, sizeof(ustar), 1, out);
 

common/update-git-hash.cmake

@@ -0,0 +1,33 @@
+# Get a git hash value. We do not want to use git command here
+# because we don't want to make git a build-time dependency.
+if(EXISTS "${SOURCE_DIR}/.git/HEAD")
+  file(READ "${SOURCE_DIR}/.git/HEAD" HASH)
+  string(STRIP "${HASH}" HASH)
+
+  if(HASH MATCHES "^ref: (.*)")
+    set(HEAD "${CMAKE_MATCH_1}")
+    if(EXISTS "${SOURCE_DIR}/.git/${HEAD}")
+      file(READ "${SOURCE_DIR}/.git/${HEAD}" HASH)
+      string(STRIP "${HASH}" HASH)
+    else()
+      file(READ "${SOURCE_DIR}/.git/packed-refs" PACKED_REFS)
+      string(REGEX REPLACE ".*\n([0-9a-f]+) ${HEAD}\n.*" "\\1" HASH "\n${PACKED_REFS}")
+    endif()
+  endif()
+endif()
+
+# Create new file contents and update a given file if necessary.
+set(NEW_CONTENTS "#include <string>
+namespace mold {
+std::string mold_git_hash = \"${HASH}\";
+}
+")
+
+if(EXISTS "${OUTPUT_FILE}")
+  file(READ "${OUTPUT_FILE}" OLD_CONTENTS)
+  if(NOT "${NEW_CONTENTS}" STREQUAL "${OLD_CONTENTS}")
+    file(WRITE "${OUTPUT_FILE}" "${NEW_CONTENTS}")
+  endif()
+else()
+  file(WRITE "${OUTPUT_FILE}" "${NEW_CONTENTS}")
+endif()

common/uuid.cc

@@ -0,0 +1,20 @@
+#include "common.h"
+
+#include <random>
+
+namespace mold {
+
+std::array<u8, 16> get_uuid_v4() {
+  std::array<u8, 16> bytes;
+
+  std::random_device rand;
+  u32 buf[4] = { rand(), rand(), rand(), rand() };
+  memcpy(bytes.data(), buf, 16);
+
+  // Indicate that this is UUIDv4 as defined by RFC4122.
+  bytes[6] = (bytes[6] & 0b00001111) | 0b01000000;
+  bytes[8] = (bytes[8] & 0b00111111) | 0b10000000;
+  return bytes;
+}
+
+} // namespace mold

demangle.cc

@@ -1,24 +0,0 @@
-#include "mold.h"
-
-#include <cstdlib>
-#include <cxxabi.h>
-
-namespace mold {
-
-std::string_view demangle(std::string_view name) {
-  if (name.starts_with("_Z")) {
-    static thread_local char *buf;
-    static thread_local size_t buflen;
-
-    int status;
-    char *p = abi::__cxa_demangle(std::string(name).c_str(), buf, &buflen, &status);
-    if (status == 0) {
-      buf = p;
-      return p;
-    }
-  }
-
-  return name;
-}
-
-} // namespace mold

dist.sh

@@ -1,4 +1,4 @@
-#!/bin/bash -x
+#!/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`).
@@ -7,29 +7,34 @@
 # libstdc++ and libcrypto but dynamically-linked to libc, libm, libz
 # and librt, as they almost always exist on any Linux systems.
 
-set -e
-
-version=$(grep '^VERSION =' $(dirname $0)/Makefile | sed 's/.* = //')
-arch=$(uname -m)
-dest=mold-$version-$arch-linux
-
-if [ $arch = x86_64 ]; then
-  image=rui314/mold-builder:v1-x86_64
-elif [ $arch = aarch64 -o $arch = arm64 ]; then
-  image=rui314/mold-builder:v1-aarch64
-else
-  echo "Error: no docker image for $arch"
+case $# in
+0)
+  arch=$(uname -m)
+  [[ $arch = arm* ]] && arch=arm
+  ;;
+1)
+  arch="$1"
+  ;;
+*)
+  echo "Usage: $0 [ x86_64 | aarch64 | arm | ppc64le | s390x ]"
   exit 1
-fi
+esac
 
-docker images -q $image 2> /dev/null || docker pull $image
+echo "$arch" | grep -Eq '^(x86_64|aarch64|arm|ppc64le|s390x)$' || \
+  { echo "Error: no docker image for $arch"; exit 1; }
 
-docker run -it --rm -v "$(pwd):/mold:Z" -u "$(id -u):$(id -g)" $image \
-  bash -c "cp -r /mold /tmp/mold &&
-cd /tmp/mold &&
-make clean &&
-make -j\$(nproc) CXX=clang++-14 CXXFLAGS='-I/openssl/include -O2 $CXXFLAGS' LDFLAGS='-static-libstdc++ /openssl/libcrypto.a' NEEDS_LIBCRYPTO=0 LTO=${LTO:-0} &&
-make install PREFIX=/ DESTDIR=$dest &&
-ln -sfr $dest/bin/mold $dest/libexec/mold/ld &&
+version=$(sed -n 's/^project(mold VERSION \(.*\))/\1/p' $(dirname $0)/CMakeLists.txt)
+dest=mold-$version-$arch-linux
+set -e -x
+
+docker run --platform linux/$arch -i --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"
+cp mold mold-wrapper.so /mold &&
+chown \$OWNER /mold/mold /mold/mold-wrapper.so /mold/$dest.tar.gz"

docs/execstack.md

@@ -23,10 +23,10 @@ process.
 
 To prevent this type of attack, the stack area is no longer executable
 since the early 2000s. On Linux, the stack's executable-ness is
-controlled by a bit in an executable, and the loader respect that
+controlled by a bit in an executable, and the loader respects that
 bit. The bit is set by the linker.
 
-GCC had (and still have) a feature that depends on the executable
+GCC had (and still has) a feature that depends on the executable
 stack, so they invented a way to tell the linker to mark the stack
 executable. Specifically, if an object file contains a
 `.note.GNU-stack` section with the `SHF_EXECSTACK` bit, GNU linker
@@ -48,8 +48,8 @@ feature which still depends on the executable stack.
 
 # How to fix it?
 
-If you know what you are doing, pass `-z execstack` to mold. Beaware
+If you know what you are doing, pass `-z execstack` to mold. Beware
 that this will significantly weaken your program's security.
 
 If you don't want to pass `-z execstack`, rewrite your code so that
-your code does not depends on the executable stack.
+your code does not depend on the executable stack.

docs/mold.md

@@ -0,0 +1,802 @@
+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-by-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.
+
+## 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`.
+
+* `--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`.
+
+* `--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` `/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`.
+
+* `--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.
+
+* `--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.
+
+## 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.
+
+* `--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` according to the default section merging rules.
+
+  This option changes the behavior so that `mold` merges input sections by
+  name by the default section merging rules.
+
+* `-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_.
+
+* `--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.
+
+* `--Bno-symbolic`:
+  Cancel `--Bsymbolic` and `--Bsymbolic-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.
+
+* `--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` | `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_.
+
+* `--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, most processors require both executable and readable bits to
+  1 to make the page executable, which allows machine code to be read as data
+  at runtime. This 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, some recent
+  processors 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 execute-only. This option currently works
+  only on some ARM64 processors.
+
+* `--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.
+
+* `--package-metadata`=_string_:
+  Embed _string_ to a `.note.package` section. This option is intended to be
+  used by a package management command such as rpm(8) to embed metadata
+  regarding a package to each executable file.
+
+* `--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_:
+  Reserve the given _number_ of tags in `.dynamic` section.
+
+* `--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-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 relro`, `-z norelro`:
+  Some sections such as `.dynamic` have to be writable only during an
+  executable or a shared library file 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 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 different memory page sizes. This option
+  specifies the maximum page size that an output binary can run on. 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_, `--allow-shlib-undefined`, `--dc`, `--dp`, `--end-group`, `--no-add-needed`, `--no-allow-shlib-undefined`, `--no-copy-dt-needed-entries`, `--no-fatal-warnings`, `--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 process of `mold` runs actively. A
+  mold process invoked while another active mold process is running will wait
+  before doing anything until the active process exits.
+
+  The purpose of this environment variable is to reduce peak memory usage.
+  Since mold is highly parallelized, there's no point in running it
+  simultaneously. If you run N instances of mold in parallel, it would take N
+  times more time and N times more memory. If you run them serially, it would
+  still take N times more to finish, but their peak memory usage is reduced to
+  normal.
+
+  If your build system tends to invoke multiple linker processes
+  simultaneously, you may want to try to set this environment variable to
+  `1` to see if it could improve overall performance.
+
+  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

@@ -0,0 +1,330 @@
+// 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_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_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 || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    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 || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    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)
+        ctx.extra.got->add_symbol(sym, rel.r_addend);
+      else
+        sym.flags |= NEEDS_GOT;
+      break;
+    case R_ALPHA_SREL32:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_ALPHA_BRSGP:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_ALPHA_TLSGD:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_ALPHA_TLSLDM:
+      ctx.needs_tlsld = true;
+      break;
+    case R_ALPHA_GOTTPREL:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_ALPHA_TPRELHI:
+    case R_ALPHA_TPRELLO:
+      check_tlsle(ctx, sym, rel);
+      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:
+      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 is not found in any other targets.
+//
+// Referring an external symbol with a non-zero addend is a bad practice
+// because we need to create as many dynamic relocations as the number of
+// distinctive addends for the same symbol.
+//
+// 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 addend 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) const {
+  i64 n = 0;
+  for (const 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 = (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-i386.cc

@@ -1,425 +1,474 @@
+// i386 is similar to x86-64 but lacks PC-relative memory access
+// instructions. So it's not straightforward to support position-
+// independent code (PIC) on that target.
+//
+// If an object file is compiled with -fPIC, a function that needs to load
+// a value from memory first obtains its own address with the following
+// code
+//
+//   call __x86.get_pc_thunk.bx
+//
+// where __x86.get_pc_thunk.bx is defined as
+//
+//   __x86.get_pc_thunk.bx:
+//     mov (%esp), %ebx  # move the return address to %ebx
+//     ret
+//
+// . With the function's own address (or, more precisely, the address
+// immediately after the call instruction), the function can compute an
+// absolute address of a variable with its address + link-time constant.
+//
+// Executing call-mov-ret isn't very cheap, and allocating one register to
+// store PC isn't cheap too, especially given that i386 has only 8
+// general-purpose registers. But that's the cost of PIC on i386. You need
+// to pay it when creating a .so and a position-independent executable.
+//
+// When a position-independent function calls another function, it sets
+// %ebx to the address of .got. Position-independent PLT entries use that
+// register to load values from .got.plt/.got.
+//
+// If we are creating a position-dependent executable (PDE), we can't
+// 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/psabi/blob/main/i386.pdf
+
 #include "mold.h"
 
 namespace mold::elf {
 
 using E = I386;
 
-static void write_plt_header(Context<E> &ctx, u8 *buf) {
-  if (ctx.arg.pic) {
-    static const u8 plt0[] = {
-      0xff, 0xb3, 0, 0, 0, 0, // pushl GOTPLT+4(%ebx)
-      0xff, 0xa3, 0, 0, 0, 0, // jmp *GOTPLT+8(%ebx)
-      0x90, 0x90, 0x90, 0x90, // nop
-    };
-    memcpy(buf, plt0, sizeof(plt0));
-    *(u32 *)(buf + 2) = ctx.gotplt->shdr.sh_addr - ctx.got->shdr.sh_addr + 4;
-    *(u32 *)(buf + 8) = ctx.gotplt->shdr.sh_addr - ctx.got->shdr.sh_addr + 8;
-  } else {
-    static const u8 plt0[] = {
-      0xff, 0x35, 0, 0, 0, 0, // pushl GOTPLT+4
-      0xff, 0x25, 0, 0, 0, 0, // jmp *GOTPLT+8
-      0x90, 0x90, 0x90, 0x90, // nop
-    };
-    memcpy(buf, plt0, sizeof(plt0));
-    *(u32 *)(buf + 2) = ctx.gotplt->shdr.sh_addr + 4;
-    *(u32 *)(buf + 8) = ctx.gotplt->shdr.sh_addr + 8;
+template <>
+i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
+  switch (rel.r_type) {
+  case R_386_8:
+  case R_386_PC8:
+    return *loc;
+  case R_386_16:
+  case R_386_PC16:
+    return *(ul16 *)loc;
+  case R_386_32:
+  case R_386_PC32:
+  case R_386_GOT32:
+  case R_386_GOT32X:
+  case R_386_PLT32:
+  case R_386_GOTOFF:
+  case R_386_GOTPC:
+  case R_386_TLS_LDM:
+  case R_386_TLS_GOTIE:
+  case R_386_TLS_LE:
+  case R_386_TLS_IE:
+  case R_386_TLS_GD:
+  case R_386_TLS_LDO_32:
+  case R_386_SIZE32:
+  case R_386_TLS_GOTDESC:
+    return *(ul32 *)loc;
+  default:
+    return 0;
   }
 }
 
-static void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym,
-                            i64 idx) {
-  u8 *ent = buf + ctx.plt_hdr_size + sym.get_plt_idx(ctx) * ctx.plt_size;
+template <>
+void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
+  switch (rel.r_type) {
+  case R_386_NONE:
+    break;
+  case R_386_8:
+  case R_386_PC8:
+    *loc = val;
+    break;
+  case R_386_16:
+  case R_386_PC16:
+    *(ul16 *)loc = val;
+    break;
+  case R_386_32:
+  case R_386_PC32:
+  case R_386_GOT32:
+  case R_386_GOT32X:
+  case R_386_PLT32:
+  case R_386_GOTOFF:
+  case R_386_GOTPC:
+  case R_386_TLS_LDM:
+  case R_386_TLS_GOTIE:
+  case R_386_TLS_LE:
+  case R_386_TLS_IE:
+  case R_386_TLS_GD:
+  case R_386_TLS_LDO_32:
+  case R_386_SIZE32:
+  case R_386_TLS_GOTDESC:
+    *(ul32 *)loc = val;
+    break;
+  default:
+    unreachable();
+  }
+}
 
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
   if (ctx.arg.pic) {
-    static const u8 data[] = {
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb, // endbr32
+      0x51,                   // push   %ecx
+      0x8d, 0x8b, 0, 0, 0, 0, // lea    GOTPLT+4(%ebx), %ecx
+      0xff, 0x31,             // push   (%ecx)
+      0xff, 0x61, 0x04,       // jmp    *0x4(%ecx)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 7) = ctx.gotplt->shdr.sh_addr - ctx.got->shdr.sh_addr + 4;
+  } else {
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb, // endbr32
+      0x51,                   // push   %ecx
+      0xb9, 0, 0, 0, 0,       // mov    GOTPLT+4, %ecx
+      0xff, 0x31,             // push   (%ecx)
+      0xff, 0x61, 0x04,       // jmp    *0x4(%ecx)
+      0xcc,                   // (padding)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = ctx.gotplt->shdr.sh_addr + 4;
+  }
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  if (ctx.arg.pic) {
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb, // endbr32
+      0xb9, 0, 0, 0, 0,       // mov $reloc_offset, %ecx
       0xff, 0xa3, 0, 0, 0, 0, // jmp *foo@GOT(%ebx)
-      0x68, 0,    0, 0, 0,    // pushl $reloc_offset
-      0xe9, 0,    0, 0, 0,    // jmp .PLT0@PC
+      0xcc,                   // (padding)
     };
-    memcpy(ent, data, sizeof(data));
-    *(u32 *)(ent + 2) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
+    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 data[] = {
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb, // endbr32
+      0xb9, 0, 0, 0, 0,       // mov $reloc_offset, %ecx
       0xff, 0x25, 0, 0, 0, 0, // jmp *foo@GOT
-      0x68, 0,    0, 0, 0,    // pushl $reloc_offset
-      0xe9, 0,    0, 0, 0,    // jmp .PLT0@PC
+      0xcc,                   // (padding)
     };
-    memcpy(ent, data, sizeof(data));
-    *(u32 *)(ent + 2) = sym.get_gotplt_addr(ctx);
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 5) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
+    *(ul32 *)(buf + 11) = sym.get_gotplt_addr(ctx);
   }
-
-  *(u32 *)(ent + 7) = idx * sizeof(ElfRel<E>);
-  *(u32 *)(ent + 12) = ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx) - 16;
 }
 
 template <>
-void PltSection<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + this->shdr.sh_offset;
-  write_plt_header(ctx, buf);
-
-  for (i64 i = 0; i < symbols.size(); i++)
-    write_plt_entry(ctx, buf, *symbols[i], i);
-}
-
-template <>
-void PltGotSection<E>::copy_buf(Context<E> &ctx) {
-  u8 *buf = ctx.buf + this->shdr.sh_offset;
-
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
   if (ctx.arg.pic) {
-    static const u8 data[] = {
-      0xff, 0xa3, 0, 0, 0, 0, // jmp   *foo@GOT(%ebx)
-      0x66, 0x90,             // nop
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb,             // endbr32
+      0xff, 0xa3, 0, 0, 0, 0,             // jmp *foo@GOT(%ebx)
+      0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // (padding)
     };
-
-    for (i64 i = 0; i < symbols.size(); i++) {
-      u8 *ent = buf + i * sizeof(data);
-      memcpy(ent, data, sizeof(data));
-      *(u32 *)(ent + 2) = symbols[i]->get_got_addr(ctx) - ctx.got->shdr.sh_addr;
-    }
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr;
   } else {
-    static const u8 data[] = {
-      0xff, 0x25, 0, 0, 0, 0, // jmp   *foo@GOT
-      0x66, 0x90,             // nop
+    static const u8 insn[] = {
+      0xf3, 0x0f, 0x1e, 0xfb,             // endbr32
+      0xff, 0x25, 0, 0, 0, 0,             // jmp *foo@GOT
+      0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // (padding)
     };
-
-    for (i64 i = 0; i < symbols.size(); i++) {
-      u8 *ent = buf + i * sizeof(data);
-      memcpy(ent, data, sizeof(data));
-      *(u32 *)(ent + 2) = symbols[i]->get_got_addr(ctx);
-    }
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx);
   }
 }
 
 template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, 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_386_NONE:
-    return;
+  case R_NONE:
+    break;
   case R_386_32:
-    *(u32 *)loc = val;
-    return;
+    *(ul32 *)loc = val;
+    break;
   case R_386_PC32:
-    *(u32 *)loc = val - this->shdr.sh_addr - offset;
-    return;
+    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  default:
+    Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
+  }
+}
+
+static u32 relax_got32x(u8 *loc) {
+  // mov imm(%reg1), %reg2 -> lea imm(%reg1), %reg2
+  if (loc[0] == 0x8b)
+    return 0x8d00 | loc[1];
+  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 val) {
+  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) = val;
+    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) = val;
+    break;
+  }
+  default:
+    unreachable();
   }
-  unreachable();
 }
 
 template <>
 void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  ElfRel<E> *dynrel = nullptr;
-  std::span<ElfRel<E>> rels = get_rels(ctx);
-  i64 frag_idx = 0;
+  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);
+                           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_386_NONE)
+    if (rel.r_type == R_NONE)
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
-    const SectionFragmentRef<E> *frag_ref = nullptr;
-    if (rel_fragments && rel_fragments[frag_idx].idx == i)
-      frag_ref = &rel_fragments[frag_idx++];
-
-    auto overflow_check = [&](i64 val, i64 lo, i64 hi) {
+    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 write8 = [&](u64 val) {
-      overflow_check(val, 0, 1 << 8);
-      *loc = val;
-    };
-
-    auto write8s = [&](u64 val) {
-      overflow_check(val, -(1 << 7), 1 << 7);
-      *loc = val;
-    };
-
-    auto write16 = [&](u64 val) {
-      overflow_check(val, 0, 1 << 16);
-      *(u16 *)loc = val;
-    };
-
-    auto write16s = [&](u64 val) {
-      overflow_check(val, -(1 << 15), 1 << 15);
-      *(u16 *)loc = val;
-    };
-
-    auto write32 = [&](u64 val) {
-      *(u32 *)loc = val;
-    };
-
-#define S   (frag_ref ? frag_ref->frag->get_addr(ctx) : sym.get_addr(ctx))
-#define A   (frag_ref ? frag_ref->addend : this->get_addend(rel))
-#define P   (output_section->shdr.sh_addr + offset + rel.r_offset)
-#define G   (sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr)
-#define GOT ctx.got->shdr.sh_addr
+    u64 S = sym.get_addr(ctx);
+    u64 A = get_addend(*this, rel);
+    u64 P = get_addr() + rel.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_386_8:
-      write8(S + A);
-      continue;
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
+      break;
     case R_386_16:
-      write16(S + A);
-      continue;
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
+      break;
     case R_386_32:
-      if (sym.is_absolute() || !ctx.arg.pic) {
-        write32(S + A);
-      } else if (sym.is_imported) {
-        *dynrel++ = {P, R_386_32, (u32)sym.get_dynsym_idx(ctx)};
-        write32(A);
-      } else {
-        if (!is_relr_reloc(ctx, rel))
-          *dynrel++ = {P, R_386_RELATIVE, 0};
-        write32(S + A);
-      }
-      continue;
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, &dynrel);
+      break;
     case R_386_PC8:
-      write8s(S + A);
-      continue;
+      check(S + A - P, -(1 << 7), 1 << 7);
+      *loc = S + A - P;
+      break;
     case R_386_PC16:
-      write16s(S + A);
-      continue;
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = S + A - P;
+      break;
     case R_386_PC32:
-      if (sym.is_absolute() || !sym.is_imported || !ctx.arg.shared) {
-        write32(S + A - P);
-      } else {
-        *dynrel++ = {P, R_386_32, (u32)sym.get_dynsym_idx(ctx)};
-        write32(A);
-      }
-      continue;
     case R_386_PLT32:
-      write32(S + A - P);
-      continue;
+      *(ul32 *)loc = S + A - P;
+      break;
     case R_386_GOT32:
+      *(ul32 *)loc = G + A;
+      break;
     case R_386_GOT32X:
-      write32(G + A);
-      continue;
+      if (sym.has_got(ctx)) {
+        *(ul32 *)loc = G + A;
+      } else {
+        u32 insn = relax_got32x(loc - 2);
+        assert(insn);
+        loc[-2] = insn >> 8;
+        loc[-1] = insn;
+        *(ul32 *)loc = S + A - GOT;
+      }
+      break;
     case R_386_GOTOFF:
-      write32(S + A - GOT);
-      continue;
+      *(ul32 *)loc = S + A - GOT;
+      break;
     case R_386_GOTPC:
-      write32(GOT + A - P);
-      continue;
+      *(ul32 *)loc = GOT + A - P;
+      break;
     case R_386_TLS_GOTIE:
-      write32(sym.get_gottp_addr(ctx) + A - GOT);
-      continue;
+      *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
+      break;
     case R_386_TLS_LE:
-      write32(S + A - ctx.tls_end);
-      continue;
+      *(ul32 *)loc = S + A - ctx.tp_addr;
+      break;
     case R_386_TLS_IE:
-      write32(sym.get_gottp_addr(ctx) + A);
-      continue;
+      *(ul32 *)loc = sym.get_gottp_addr(ctx) + A;
+      break;
     case R_386_TLS_GD:
-      if (sym.get_tlsgd_idx(ctx) == -1) {
-        // Relax GD to LE
-        switch (rels[i + 1].r_type) {
-        case R_386_PLT32: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %rax
-            0x81, 0xe8, 0, 0, 0, 0, // add $0, %rax
-          };
-          memcpy(loc - 3, insn, sizeof(insn));
-          *(u32 *)(loc + 5) = ctx.tls_end - S - A;
-          break;
-        }
-        case R_386_GOT32: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %rax
-            0x81, 0xe8, 0, 0, 0, 0, // add $0, %rax
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          *(u32 *)(loc + 6) = ctx.tls_end - S - A;
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        i++;
-      } else {
-        write32(sym.get_tlsgd_addr(ctx) + A - GOT);
-      }
-      continue;
-    case R_386_TLS_LDM:
-      if (ctx.got->tlsld_idx == -1) {
-        // Relax LD to LE
-        switch (rels[i + 1].r_type) {
-        case R_386_PLT32: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
-            0x8d, 0x74, 0x26, 0x00, // lea (%esi,1), %esi
-            0x90,                   // nop
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          break;
-        }
-        case R_386_GOT32: {
-          static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
-            0x8d, 0x74, 0x26, 0x00, // lea (%esi,1), %esi
-            0x66, 0x90,
-          };
-          memcpy(loc - 2, insn, sizeof(insn));
-          break;
-        }
-        default:
-          unreachable();
-        }
-
-        i++;
-      } else {
-        write32(ctx.got->get_tlsld_addr(ctx) + A - GOT);
-      }
-      continue;
-    case R_386_TLS_LDO_32:
-      if (ctx.got->tlsld_idx == -1)
-        write32(S + A - ctx.tls_end);
+      if (sym.has_tlsgd(ctx))
+        *(ul32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
       else
-        write32(S + A - ctx.tls_begin);
-      continue;
+        relax_gd_to_le(loc, rels[++i], S - ctx.tp_addr);
+      break;
+    case R_386_TLS_LDM:
+      if (ctx.got->has_tlsld(ctx))
+        *(ul32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
+        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;
+      break;
     case R_386_SIZE32:
-      write32(sym.esym().st_size + A);
-      continue;
+      *(ul32 *)loc = sym.esym().st_size + A;
+      break;
     case R_386_TLS_GOTDESC:
-      if (sym.get_tlsdesc_idx(ctx) == -1) {
-        static const u8 insn[] = {
-          0x8d, 0x05, 0, 0, 0, 0, // lea 0, %eax
-        };
-        memcpy(loc - 2, insn, sizeof(insn));
-        write32(S + A - ctx.tls_end);
+      // 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 for non-dlopen'd DSO
+      //
+      //   mov     foo@GOTTPOFF(%ebx), %eax
+      //   nop
+      //
+      // or to the following for executable.
+      //
+      //   mov     $foo@TPOFF, %eax
+      //   nop
+      if (sym.has_tlsdesc(ctx)) {
+        *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) + A - GOT;
+      } else if (sym.has_gottp(ctx)) {
+        loc[-2] = 0x8b;
+        loc[-1] = 0x83;
+        *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
       } else {
-        write32(sym.get_tlsdesc_addr(ctx) + A - GOT);
+        loc[-2] = 0x90;
+        loc[-1] = 0xb8;
+        *(ul32 *)loc = S + A - ctx.tp_addr;
       }
-      continue;
+      break;
     case R_386_TLS_DESC_CALL:
-      if (ctx.arg.relax && !ctx.arg.shared) {
-        // call *(%rax) -> nop
+      if (!sym.has_tlsdesc(ctx)) {
+        // call *(%eax) -> nop
         loc[0] = 0x66;
         loc[1] = 0x90;
       }
-      continue;
+      break;
     default:
       unreachable();
     }
-
-#undef S
-#undef A
-#undef P
-#undef G
-#undef GOT
   }
 }
 
 template <>
 void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<ElfRel<E>> rels = get_rels(ctx);
+  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_386_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) {
-      report_undef(ctx, file, sym);
-      continue;
-    }
-
-    SectionFragment<E> *frag;
-    i64 addend;
-    std::tie(frag, addend) = get_fragment(ctx, rel);
-
-    auto overflow_check = [&](i64 val, i64 lo, i64 hi) {
+    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 write8 = [&](u64 val) {
-      overflow_check(val, 0, 1 << 8);
-      *loc = val;
-    };
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
 
-    auto write8s = [&](u64 val) {
-      overflow_check(val, -(1 << 7), 1 << 7);
-      *loc = val;
-    };
-
-    auto write16 = [&](u64 val) {
-      overflow_check(val, 0, 1 << 16);
-      *(u16 *)loc = val;
-    };
-
-    auto write16s = [&](u64 val) {
-      overflow_check(val, -(1 << 15), 1 << 15);
-      *(u16 *)loc = val;
-    };
-
-#define S   (frag ? frag->get_addr(ctx) : sym.get_addr(ctx))
-#define A   (frag ? addend : this->get_addend(rel))
-#define G   (sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr)
-#define GOT ctx.got->shdr.sh_addr
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : get_addend(*this, rel);
+    u64 GOT = ctx.got->shdr.sh_addr;
 
     switch (rel.r_type) {
     case R_386_8:
-      write8(S + A);
-      continue;
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
+      break;
     case R_386_16:
-      write16(S + A);
-      continue;
+      check(S + A, 0, 1 << 16);
+      *(ul16 *)loc = S + A;
+      break;
     case R_386_32:
-      if (std::optional<u64> val = get_tombstone(sym))
-        *(u32 *)loc = *val;
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul32 *)loc = *val;
       else
-        *(u32 *)loc = S + A;
-      continue;
+        *(ul32 *)loc = S + A;
+      break;
     case R_386_PC8:
-      write8s(S + A);
-      continue;
+      check(S + A, -(1 << 7), 1 << 7);
+      *loc = S + A;
+      break;
     case R_386_PC16:
-      write16s(S + A);
-      continue;
+      check(S + A, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = S + A;
+      break;
     case R_386_PC32:
-      *(u32 *)loc = S + A;
-      continue;
+      *(ul32 *)loc = S + A;
+      break;
     case R_386_GOTPC:
-      *(u32 *)loc = GOT + A;
-      continue;
+      *(ul32 *)loc = GOT + A;
+      break;
     case R_386_GOTOFF:
-      *(u32 *)loc = S + A - GOT;
-      continue;
+      *(ul32 *)loc = S + A - GOT;
+      break;
     case R_386_TLS_LDO_32:
-      if (std::optional<u64> val = get_tombstone(sym))
-        *(u32 *)loc = *val;
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul32 *)loc = *val;
       else
-        *(u32 *)loc = S + A - ctx.tls_begin;
-      continue;
+        *(ul32 *)loc = S + A - ctx.dtp_addr;
+      break;
     case R_386_SIZE32:
-      *(u32 *)loc = sym.esym().st_size + A;
-      continue;
+      *(ul32 *)loc = sym.esym().st_size + A;
+      break;
     default:
       unreachable();
     }
-
-#undef S
-#undef A
-#undef GOT
   }
 }
 
@@ -428,118 +477,86 @@ 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<ElfRel<E>> rels = get_rels(ctx);
+  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_386_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) {
-      report_undef(ctx, file, sym);
-      continue;
-    }
+    if (sym.is_ifunc())
+      sym.flags |= NEEDS_GOT | NEEDS_PLT;
 
-    if (sym.get_type() == STT_GNU_IFUNC) {
-      sym.flags |= NEEDS_GOT;
-      sym.flags |= 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: {
-      Action table[][4] = {
-        // Absolute  Local  Imported data  Imported code
-        {  NONE,     ERROR, ERROR,         ERROR },      // DSO
-        {  NONE,     ERROR, ERROR,         ERROR },      // PIE
-        {  NONE,     NONE,  COPYREL,       CPLT  },      // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
+    case R_386_16:
+      scan_absrel(ctx, sym, rel);
       break;
-    }
-    case R_386_32: {
-      Action table[][4] = {
-        // Absolute  Local    Imported data  Imported code
-        {  NONE,     BASEREL, DYNREL,        DYNREL },     // DSO
-        {  NONE,     BASEREL, DYNREL,        DYNREL },     // PIE
-        {  NONE,     NONE,    COPYREL,       CPLT   },     // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
+    case R_386_32:
+      scan_dyn_absrel(ctx, sym, rel);
       break;
-    }
     case R_386_PC8:
-    case R_386_PC16: {
-      Action table[][4] = {
-        // Absolute  Local  Imported data  Imported code
-        {  ERROR,    NONE,  ERROR,         ERROR },      // DSO
-        {  ERROR,    NONE,  COPYREL,       PLT   },      // PIE
-        {  NONE,     NONE,  COPYREL,       PLT   },      // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
+    case R_386_PC16:
+    case R_386_PC32:
+      scan_pcrel(ctx, sym, rel);
       break;
-    }
-    case R_386_PC32: {
-      Action table[][4] = {
-        // Absolute  Local  Imported data  Imported code
-        {  ERROR,    NONE,  DYNREL,        DYNREL },     // DSO
-        {  ERROR,    NONE,  COPYREL,       PLT    },     // PIE
-        {  NONE,     NONE,  COPYREL,       PLT    },     // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
-      break;
-    }
     case R_386_GOT32:
-    case R_386_GOT32X:
     case R_386_GOTPC:
       sym.flags |= NEEDS_GOT;
       break;
-    case R_386_PLT32: {
-      Action table[][4] = {
-        // Absolute  Local  Imported data  Imported code
-        {  NONE,     NONE,  PLT,           PLT    },     // DSO
-        {  NONE,     NONE,  PLT,           PLT    },     // PIE
-        {  NONE,     NONE,  PLT,           PLT    },     // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
+    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 |= NEEDS_PLT;
       break;
-    }
     case R_386_TLS_GOTIE:
-    case R_386_TLS_LE:
     case R_386_TLS_IE:
       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_GOT32)
-        Fatal(ctx) << *this << ": TLS_GD reloc must be followed by PLT or GOT32";
-
-      if (ctx.arg.relax && !ctx.arg.shared && !sym.is_imported)
+      // We always relax if -static because libc.a doesn't contain
+      // __tls_get_addr().
+      if ((ctx.arg.relax && sym.is_tprel_linktime_const(ctx)) ||
+          ctx.arg.is_static)
         i++;
       else
         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_GOT32)
-        Fatal(ctx) << *this << ": TLS_LDM reloc must be followed by PLT or GOT32";
-
-      if (ctx.arg.relax && !ctx.arg.shared)
+      // We always relax if -static because libc.a doesn't contain
+      // __tls_get_addr().
+      if (ctx.arg.is_static || (ctx.arg.relax && !ctx.arg.shared))
         i++;
       else
         ctx.needs_tlsld = true;
       break;
     case R_386_TLS_GOTDESC:
-      if (!ctx.arg.relax || ctx.arg.shared)
-        sym.flags |= NEEDS_TLSDESC;
+      scan_tlsdesc(ctx, sym);
+      break;
+    case R_386_TLS_LE:
+      check_tlsle(ctx, sym, rel);
       break;
     case R_386_GOTOFF:
     case R_386_TLS_LDO_32:

elf/arch-loongarch.cc

@@ -0,0 +1,686 @@
+// LoongArch is a new RISC ISA announced in 2021 by Loongson. The ISA
+// feels like a modernized MIPS with a hint of RISC-V flavor, although
+// it's not compatible with either one.
+//
+// While LoongArch is a fresh and clean ISA, its technological advantage
+// over other modern RISC ISAs such as RISC-V doesn't seem to be very
+// significant. It appears that the real selling point of LoongArch is
+// that the ISA is developed and controlled by a Chinese company,
+// reflecting a desire for domestic CPUs. Loongson is actively working on
+// bootstrapping the entire ecosystem for LoongArch, sending patches to
+// Linux, GCC, LLVM, etc.
+//
+// All instructions are 4 bytes long in LoongArch and aligned to 4-byte
+// boundaries. It has 32 general-purpose registers. Among these, $t0 - $t8
+// (aliases for $r12 - $r20) are temporary registers that we can use in
+// our PLT and range extension thunks.
+//
+// The psABI defines a few linker relaxations. We haven't supported them
+// yet.
+//
+// https://loongson.github.io/LoongArch-Documentation/LoongArch-ELF-ABI-EN.html
+
+#if MOLD_LOONGARCH64 || MOLD_LOONGARCH32
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = MOLD_TARGET;
+
+static u64 page(u64 val) {
+  return val & 0xffff'ffff'ffff'f000;
+}
+
+static u64 hi20(u64 val, u64 pc) {
+  // A PC-relative address with a 32 bit offset is materialized in a
+  // register with the following instructions:
+  //
+  //   pcalau12i $rN, %pc_hi20(sym)
+  //   addi.d    $rN, $rN, %lo12(sym)
+  //
+  // PCALAU12I materializes bits [63:12] by computing (pc + imm << 12)
+  // and zero-clear [11:0]. ADDI.D sign-extends its 12 bit immediate and
+  // add it to the register. To compensate the sign-extension, PCALAU12I
+  // needs to materialize a 0x1000 larger value than the desired [63:12]
+  // if [11:0] is sign-extended.
+  //
+  // This is similar but different from RISC-V because RISC-V's AUIPC
+  // doesn't zero-clear [11:0].
+  return bits(page(val + 0x800) - page(pc), 31, 12);
+}
+
+static u64 hi64(u64 val, u64 pc) {
+  // A PC-relative 64-bit address is materialized with the following
+  // instructions for the large code model:
+  //
+  //   pcalau12i $rN, %pc_hi20(sym)
+  //   addi.d    $rM, $zero, %lo12(sym)
+  //   lu32i.d   $rM, %pc64_lo20(sym)
+  //   lu52i.d   $rM, $r12, %pc64_hi12(sym)
+  //   add.d     $rN, $rN, $rM
+  //
+  // PCALAU12I computes (pc + imm << 12) to materialize a 64-bit value.
+  // ADDI.D adds a sign-extended 12 bit value to a register. LU32I.D and
+  // LU52I.D simply set bits to [51:31] and to [63:53], respectively.
+  //
+  // Compensating all the sign-extensions is a bit complicated.
+  bool x = val & 0x800;
+  bool y = (page(val + 0x800) - page(pc)) & 0x8000'0000;
+
+  if (x && !y)
+    return val - 0x1'0000'0000;
+  if (!x && y)
+    return val + 0x1'0000'0000;
+  return val;
+}
+
+static u64 higher20(u64 val, u64 pc) {
+  return bits(hi64(val, pc), 51, 32);
+}
+
+static u64 highest12(u64 val, u64 pc) {
+  return bits(hi64(val, pc), 63, 52);
+}
+
+static void write_k12(u8 *loc, u32 val) {
+  // opcode, [11:0], rj, rd
+  *(ul32 *)loc &= 0b1111111111'000000000000'11111'11111;
+  *(ul32 *)loc |= bits(val, 11, 0) << 10;
+}
+
+static void write_k16(u8 *loc, u32 val) {
+  // opcode, [15:0], rj, rd
+  *(ul32 *)loc &= 0b111111'0000000000000000'11111'11111;
+  *(ul32 *)loc |= bits(val, 15, 0) << 10;
+}
+
+static void write_j20(u8 *loc, u32 val) {
+  // opcode, [19:0], rd
+  *(ul32 *)loc &= 0b1111111'00000000000000000000'11111;
+  *(ul32 *)loc |= bits(val, 19, 0) << 5;
+}
+
+static void write_d5k16(u8 *loc, u32 val) {
+  // opcode, [15:0], rj, [20:16]
+  *(ul32 *)loc &= 0b111111'0000000000000000'11111'00000;
+  *(ul32 *)loc |= bits(val, 15, 0) << 10;
+  *(ul32 *)loc |= bits(val, 20, 16);
+}
+
+static void write_d10k16(u8 *loc, u32 val) {
+  // opcode, [15:0], [25:16]
+  *(ul32 *)loc &= 0b111111'0000000000000000'0000000000;
+  *(ul32 *)loc |= bits(val, 15, 0) << 10;
+  *(ul32 *)loc |= bits(val, 25, 16);
+}
+
+template <>
+void write_plt_header<E>(Context<E> &ctx, u8 *buf) {
+  static const ul32 insn_64[] = {
+    0x1a00'000e, // pcalau12i $t2, %pc_hi20(.got.plt)
+    0x0011'bdad, // sub.d     $t1, $t1, $t3
+    0x28c0'01cf, // ld.d      $t3, $t2, %lo12(.got.plt) # _dl_runtime_resolve
+    0x02ff'51ad, // addi.d    $t1, $t1, -44             # .plt entry
+    0x02c0'01cc, // addi.d    $t0, $t2, %lo12(.got.plt) # &.got.plt
+    0x0045'05ad, // srli.d    $t1, $t1, 1               # .plt entry offset
+    0x28c0'218c, // ld.d      $t0, $t0, 8               # link map
+    0x4c00'01e0, // jr        $t3
+  };
+
+  static const ul32 insn_32[] = {
+    0x1a00'000e, // pcalau12i $t2, %pc_hi20(.got.plt)
+    0x0011'3dad, // sub.w     $t1, $t1, $t3
+    0x2880'01cf, // ld.w      $t3, $t2, %lo12(.got.plt) # _dl_runtime_resolve
+    0x02bf'51ad, // addi.w    $t1, $t1, -44             # .plt entry
+    0x0280'01cc, // addi.w    $t0, $t2, %lo12(.got.plt) # &.got.plt
+    0x0044'89ad, // srli.w    $t1, $t1, 2               # .plt entry offset
+    0x2880'118c, // ld.w      $t0, $t0, 4               # link map
+    0x4c00'01e0, // jr        $t3
+  };
+
+  u64 gotplt = ctx.gotplt->shdr.sh_addr;
+  u64 plt = ctx.plt->shdr.sh_addr;
+
+  memcpy(buf, E::is_64 ? insn_64 : insn_32, E::plt_hdr_size);
+  write_j20(buf, hi20(gotplt, plt));
+  write_k12(buf + 8, gotplt);
+  write_k12(buf + 16, gotplt);
+}
+
+static const ul32 plt_entry_64[] = {
+  0x1a00'000f, // pcalau12i $t3, %pc_hi20([email protected])
+  0x28c0'01ef, // ld.d      $t3, $t3, %lo12([email protected])
+  0x4c00'01ed, // jirl      $t1, $t3, 0
+  0x0340'0000, // nop
+};
+
+static const ul32 plt_entry_32[] = {
+  0x1a00'000f, // pcalau12i $t3, %pc_hi20([email protected])
+  0x2880'01ef, // ld.w      $t3, $t3, %lo12([email protected])
+  0x4c00'01ed, // jirl      $t1, $t3, 0
+  0x0340'0000, // nop
+};
+
+template <>
+void write_plt_entry<E>(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  u64 gotplt = sym.get_gotplt_addr(ctx);
+  u64 plt = sym.get_plt_addr(ctx);
+
+  memcpy(buf, E::is_64 ? plt_entry_64 : plt_entry_32, E::plt_size);
+  write_j20(buf, hi20(gotplt, plt));
+  write_k12(buf + 4, gotplt);
+}
+
+template <>
+void write_pltgot_entry<E>(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  u64 got = sym.get_got_addr(ctx);
+  u64 plt = sym.get_plt_addr(ctx);
+
+  memcpy(buf, E::is_64 ? plt_entry_64 : plt_entry_32, E::plt_size);
+  write_j20(buf, hi20(got, plt));
+  write_k12(buf + 4, got);
+}
+
+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_LARCH_ADD6:
+    *loc = (*loc & 0b1100'0000) | ((*loc + val) & 0b0011'1111);
+    break;
+  case R_LARCH_ADD8:
+    *loc += val;
+    break;
+  case R_LARCH_ADD16:
+    *(ul16 *)loc += val;
+    break;
+  case R_LARCH_ADD32:
+    *(ul32 *)loc += val;
+    break;
+  case R_LARCH_ADD64:
+    *(ul64 *)loc += val;
+    break;
+  case R_LARCH_SUB6:
+    *loc = (*loc & 0b1100'0000) | ((*loc - val) & 0b0011'1111);
+    break;
+  case R_LARCH_SUB8:
+    *loc -= val;
+    break;
+  case R_LARCH_SUB16:
+    *(ul16 *)loc -= val;
+    break;
+  case R_LARCH_SUB32:
+    *(ul32 *)loc -= val;
+    break;
+  case R_LARCH_SUB64:
+    *(ul64 *)loc -= val;
+    break;
+  case R_LARCH_32_PCREL:
+    *(ul32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_LARCH_64_PCREL:
+    *(ul64 *)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 || rel.r_type == R_LARCH_RELAX ||
+        rel.r_type == R_LARCH_MARK_LA || rel.r_type == R_LARCH_MARK_PCREL ||
+        rel.r_type == R_LARCH_ALIGN)
+      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 check_branch = [&](i64 val, i64 lo, i64 hi) {
+      if (val & 0b11)
+        Error(ctx) << *this << ": misaligned symbol " << sym
+                   << " for relocation " << rel;
+      check(val, lo, hi);
+    };
+
+    // Unlike other psABIs, the LoongArch ABI uses the same relocation
+    // types to refer to GOT entries for thread-local symbols and regular
+    // ones. Therefore, G may refer to a TLSGD or a regular GOT slot
+    // depending on the symbol type.
+    //
+    // Note that as of August 2023, both GCC and Clang treat TLSLD relocs
+    // as if they were TLSGD relocs for LoongArch, which is a clear bug.
+    // We need to handle TLSLD relocs as synonyms for TLSGD relocs for the
+    // sake of bug compatibility.
+    auto get_got_idx = [&] {
+      if (sym.has_tlsgd(ctx))
+        return sym.get_tlsgd_idx(ctx);
+      return sym.get_got_idx(ctx);
+    };
+
+    u64 S = sym.get_addr(ctx);
+    u64 A = rel.r_addend;
+    u64 P = get_addr() + rel.r_offset;
+    u64 G = get_got_idx() * sizeof(Word<E>);
+    u64 GOT = ctx.got->shdr.sh_addr;
+
+    switch (rel.r_type) {
+    case R_LARCH_32:
+      if constexpr (E::is_64)
+        *(ul32 *)loc = S + A;
+      else
+        apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, &dynrel);
+      break;
+    case R_LARCH_64:
+      assert(E::is_64);
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, &dynrel);
+      break;
+    case R_LARCH_B16:
+      check_branch(S + A - P, -(1 << 17), 1 << 17);
+      write_k16(loc, (S + A - P) >> 2);
+      break;
+    case R_LARCH_B21:
+      check_branch(S + A - P, -(1 << 22), 1 << 22);
+      write_d5k16(loc, (S + A - P) >> 2);
+      break;
+    case R_LARCH_B26: {
+      i64 val = S + A - P;
+      if (val < -(1 << 27) || (1 << 27) <= val)
+        val = get_thunk_addr(i) + A - P;
+      write_d10k16(loc, val >> 2);
+      break;
+    }
+    case R_LARCH_ABS_LO12:
+      write_k12(loc, S + A);
+      break;
+    case R_LARCH_ABS_HI20:
+      write_j20(loc, (S + A) >> 12);
+      break;
+    case R_LARCH_ABS64_LO20:
+      write_j20(loc, (S + A) >> 32);
+      break;
+    case R_LARCH_ABS64_HI12:
+      write_k12(loc, (S + A) >> 52);
+      break;
+    case R_LARCH_PCALA_LO12:
+      write_k12(loc, S + A);
+      break;
+    case R_LARCH_PCALA_HI20:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      write_j20(loc, hi20(S + A, P));
+      break;
+    case R_LARCH_PCALA64_LO20:
+      write_j20(loc, higher20(S + A, P));
+      break;
+    case R_LARCH_PCALA64_HI12:
+      write_k12(loc, highest12(S + A, P));
+      break;
+    case R_LARCH_GOT_PC_LO12:
+      write_k12(loc, GOT + G + A);
+      break;
+    case R_LARCH_GOT_PC_HI20:
+      check(GOT + G + A - P, -(1LL << 31), 1LL << 31);
+      write_j20(loc, hi20(GOT + G + A, P));
+      break;
+    case R_LARCH_GOT64_PC_LO20:
+      write_j20(loc, higher20(GOT + G + A, P));
+      break;
+    case R_LARCH_GOT64_PC_HI12:
+      write_k12(loc, highest12(GOT + G + A, P));
+      break;
+    case R_LARCH_GOT_LO12:
+      write_k12(loc, GOT + G + A);
+      break;
+    case R_LARCH_GOT_HI20:
+      write_j20(loc, (GOT + G + A) >> 12);
+      break;
+    case R_LARCH_GOT64_LO20:
+      write_j20(loc, (GOT + G + A) >> 32);
+      break;
+    case R_LARCH_GOT64_HI12:
+      write_k12(loc, (GOT + G + A) >> 52);
+      break;
+    case R_LARCH_TLS_LE_LO12:
+      write_k12(loc, S + A - ctx.tp_addr);
+      break;
+    case R_LARCH_TLS_LE_HI20:
+      write_j20(loc, (S + A - ctx.tp_addr) >> 12);
+      break;
+    case R_LARCH_TLS_LE64_LO20:
+      write_j20(loc, (S + A - ctx.tp_addr) >> 32);
+      break;
+    case R_LARCH_TLS_LE64_HI12:
+      write_k12(loc, (S + A - ctx.tp_addr) >> 52);
+      break;
+    case R_LARCH_TLS_IE_PC_LO12:
+      write_k12(loc, sym.get_gottp_addr(ctx) + A);
+      break;
+    case R_LARCH_TLS_IE_PC_HI20:
+      check(sym.get_gottp_addr(ctx) + A - P, -(1LL << 31), 1LL << 31);
+      write_j20(loc, hi20(sym.get_gottp_addr(ctx) + A, P));
+      break;
+    case R_LARCH_TLS_IE64_PC_LO20:
+      write_j20(loc, higher20(sym.get_gottp_addr(ctx) + A, P));
+      break;
+    case R_LARCH_TLS_IE64_PC_HI12:
+      write_k12(loc, highest12(sym.get_gottp_addr(ctx) + A, P));
+      break;
+    case R_LARCH_TLS_IE_LO12:
+      write_k12(loc, sym.get_gottp_addr(ctx) + A);
+      break;
+    case R_LARCH_TLS_IE_HI20:
+      write_j20(loc, (sym.get_gottp_addr(ctx) + A) >> 12);
+      break;
+    case R_LARCH_TLS_IE64_LO20:
+      write_j20(loc, (sym.get_gottp_addr(ctx) + A) >> 32);
+      break;
+    case R_LARCH_TLS_IE64_HI12:
+      write_k12(loc, (sym.get_gottp_addr(ctx) + A) >> 52);
+      break;
+    case R_LARCH_TLS_LD_PC_HI20:
+    case R_LARCH_TLS_GD_PC_HI20:
+      check(sym.get_tlsgd_addr(ctx) + A - P, -(1LL << 31), 1LL << 31);
+      write_j20(loc, hi20(sym.get_tlsgd_addr(ctx) + A, P));
+      break;
+    case R_LARCH_TLS_LD_HI20:
+    case R_LARCH_TLS_GD_HI20:
+      write_j20(loc, (sym.get_tlsgd_addr(ctx) + A) >> 12);
+      break;
+    case R_LARCH_ADD6:
+      *loc = (*loc & 0b1100'0000) | ((*loc + S + A) & 0b0011'1111);
+      break;
+    case R_LARCH_ADD8:
+      *loc += S + A;
+      break;
+    case R_LARCH_ADD16:
+      *(ul16 *)loc += S + A;
+      break;
+    case R_LARCH_ADD32:
+      *(ul32 *)loc += S + A;
+      break;
+    case R_LARCH_ADD64:
+      *(ul64 *)loc += S + A;
+      break;
+    case R_LARCH_SUB6:
+      *loc = (*loc & 0b1100'0000) | ((*loc - S - A) & 0b0011'1111);
+      break;
+    case R_LARCH_SUB8:
+      *loc -= S + A;
+      break;
+    case R_LARCH_SUB16:
+      *(ul16 *)loc -= S + A;
+      break;
+    case R_LARCH_SUB32:
+      *(ul32 *)loc -= S + A;
+      break;
+    case R_LARCH_SUB64:
+      *(ul64 *)loc -= S + A;
+      break;
+    case R_LARCH_32_PCREL:
+      *(ul32 *)loc = S + A - P;
+      break;
+    case R_LARCH_64_PCREL:
+      *(ul64 *)loc = S + A - P;
+      break;
+    case R_LARCH_ADD_ULEB128:
+      overwrite_uleb(loc, read_uleb(loc) + S + A);
+      break;
+    case R_LARCH_SUB_ULEB128:
+      overwrite_uleb(loc, read_uleb(loc) - S - A);
+      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_LARCH_32:
+      *(ul32 *)loc = S + A;
+      break;
+    case R_LARCH_64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul64 *)loc = *val;
+      else
+        *(ul64 *)loc = S + A;
+      break;
+    case R_LARCH_ADD6:
+      *loc = (*loc & 0b1100'0000) | ((*loc + S + A) & 0b0011'1111);
+      break;
+    case R_LARCH_ADD8:
+      *loc += S + A;
+      break;
+    case R_LARCH_ADD16:
+      *(ul16 *)loc += S + A;
+      break;
+    case R_LARCH_ADD32:
+      *(ul32 *)loc += S + A;
+      break;
+    case R_LARCH_ADD64:
+      *(ul64 *)loc += S + A;
+      break;
+    case R_LARCH_SUB6:
+      *loc = (*loc & 0b1100'0000) | ((*loc - S - A) & 0b0011'1111);
+      break;
+    case R_LARCH_SUB8:
+      *loc -= S + A;
+      break;
+    case R_LARCH_SUB16:
+      *(ul16 *)loc -= S + A;
+      break;
+    case R_LARCH_SUB32:
+      *(ul32 *)loc -= S + A;
+      break;
+    case R_LARCH_SUB64:
+      *(ul64 *)loc -= S + A;
+      break;
+    case R_LARCH_TLS_DTPREL32:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul32 *)loc = *val;
+      else
+        *(ul32 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_LARCH_TLS_DTPREL64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul64 *)loc = *val;
+      else
+        *(ul64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_LARCH_ADD_ULEB128:
+      overwrite_uleb(loc, read_uleb(loc) + S + A);
+      break;
+    case R_LARCH_SUB_ULEB128:
+      overwrite_uleb(loc, read_uleb(loc) - S - A);
+      break;
+    default:
+      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
+                 << rel;
+      break;
+    }
+  }
+}
+
+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 || rel.r_type == R_LARCH_RELAX ||
+        rel.r_type == R_LARCH_MARK_LA || rel.r_type == R_LARCH_MARK_PCREL ||
+        rel.r_type == R_LARCH_ALIGN)
+      continue;
+
+    if (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 |= NEEDS_GOT | NEEDS_PLT;
+
+    switch (rel.r_type) {
+    case R_LARCH_32:
+      if constexpr (E::is_64)
+        scan_absrel(ctx, sym, rel);
+      else
+        scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_LARCH_64:
+      assert(E::is_64);
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_LARCH_B26:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_LARCH_GOT_HI20:
+    case R_LARCH_GOT_PC_HI20:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_LARCH_TLS_IE_HI20:
+    case R_LARCH_TLS_IE_PC_HI20:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_LARCH_TLS_LD_PC_HI20:
+    case R_LARCH_TLS_GD_PC_HI20:
+    case R_LARCH_TLS_LD_HI20:
+    case R_LARCH_TLS_GD_HI20:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_LARCH_32_PCREL:
+    case R_LARCH_64_PCREL:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_LARCH_TLS_LE_HI20:
+    case R_LARCH_TLS_LE_LO12:
+    case R_LARCH_TLS_LE64_LO20:
+    case R_LARCH_TLS_LE64_HI12:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_LARCH_B16:
+    case R_LARCH_B21:
+    case R_LARCH_ABS_HI20:
+    case R_LARCH_ABS_LO12:
+    case R_LARCH_ABS64_LO20:
+    case R_LARCH_ABS64_HI12:
+    case R_LARCH_PCALA_HI20:
+    case R_LARCH_PCALA_LO12:
+    case R_LARCH_PCALA64_LO20:
+    case R_LARCH_PCALA64_HI12:
+    case R_LARCH_GOT_PC_LO12:
+    case R_LARCH_GOT64_PC_LO20:
+    case R_LARCH_GOT64_PC_HI12:
+    case R_LARCH_GOT_LO12:
+    case R_LARCH_GOT64_LO20:
+    case R_LARCH_GOT64_HI12:
+    case R_LARCH_TLS_IE_PC_LO12:
+    case R_LARCH_TLS_IE64_PC_LO20:
+    case R_LARCH_TLS_IE64_PC_HI12:
+    case R_LARCH_TLS_IE_LO12:
+    case R_LARCH_TLS_IE64_LO20:
+    case R_LARCH_TLS_IE64_HI12:
+    case R_LARCH_ADD6:
+    case R_LARCH_SUB6:
+    case R_LARCH_ADD8:
+    case R_LARCH_SUB8:
+    case R_LARCH_ADD16:
+    case R_LARCH_SUB16:
+    case R_LARCH_ADD32:
+    case R_LARCH_SUB32:
+    case R_LARCH_ADD64:
+    case R_LARCH_SUB64:
+    case R_LARCH_ADD_ULEB128:
+    case R_LARCH_SUB_ULEB128:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
+  static const ul32 insn[] = {
+    0x1a00'000c, // pcalau12i $t0, 0
+    0x02c0'018c, // addi.d    $t0, $t0, 0
+    0x4c00'0180, // jirl      $zero, $t0, 0
+    0x0340'0000, // nop
+  };
+
+  static_assert(E::thunk_size == sizeof(insn));
+
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 P = output_section.shdr.sh_addr + offset;
+
+  for (Symbol<E> *sym : symbols) {
+    u64 S = sym->get_addr(ctx);
+
+    memcpy(buf, insn, sizeof(insn));
+    write_j20(buf, hi20(S, P));
+    write_k12(buf + 4, S);
+
+    buf += sizeof(insn);
+    P += sizeof(insn);
+  }
+}
+
+} // namespace mold::elf
+
+#endif

elf/arch-m68k.cc

@@ -0,0 +1,325 @@
+// This file contains code for the Motorola 68000 series microprocessors,
+// which is often abbreviated as m68k. Running a Unix-like system on a
+// m68k-based machine today is probably a retro-computing hobby activity,
+// but the processor was a popular choice to build Unix computers during
+// '80s. Early Sun workstations for example used m68k. Macintosh until
+// 1994 were based on m68k as well until they switched to PowerPC (and
+// then to x86 and to ARM.)
+//
+// From the linker's point of view, it is not hard to support m68k. It's
+// just a 32-bit big-endian CISC ISA. Compared to comtemporary i386,
+// m68k's psABI is actually simpler because m68k has PC-relative memory
+// access instructions and therefore can support position-independent
+// code without too much hassle.
+//
+// https://github.com/rui314/psabi/blob/main/m68k.pdf
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = M68K;
+
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  static const u8 insn[] = {
+    0x2f, 0x00,                         // move.l %d0, -(%sp)
+    0x2f, 0x3b, 0x01, 0x70, 0, 0, 0, 0, // move.l (GOTPLT+4, %pc), -(%sp)
+    0x4e, 0xfb, 0x01, 0x71, 0, 0, 0, 0, // jmp    ([GOTPLT+8, %pc])
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 6) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr;
+  *(ub32 *)(buf + 14) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 4;
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static const u8 insn[] = {
+    0x20, 0x3c, 0, 0, 0, 0,             // move.l PLT_OFFSET, %d0
+    0x4e, 0xfb, 0x01, 0x71, 0, 0, 0, 0, // jmp    ([GOTPLT_ENTRY, %pc])
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 2) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
+  *(ub32 *)(buf + 10) = sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx) - 8;
+}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static const u8 insn[] = {
+    0x4e, 0xfb, 0x01, 0x71, 0, 0, 0, 0, // jmp ([GOT_ENTRY, %pc])
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 4) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 2;
+}
+
+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_68K_32:
+    *(ub32 *)loc = val;
+    break;
+  case R_68K_PC32:
+    *(ub32 *)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;
+
+    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 write16 = [&](u64 val) {
+      check(val, 0, 1 << 16);
+      *(ub16 *)loc = val;
+    };
+
+    auto write16s = [&](u64 val) {
+      check(val, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = val;
+    };
+
+    auto write8 = [&](u64 val) {
+      check(val, 0, 1 << 8);
+      *loc = val;
+    };
+
+    auto write8s = [&](u64 val) {
+      check(val, -(1 << 7), 1 << 7);
+      *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_idx(ctx) * sizeof(Word<E>);
+    u64 GOT = ctx.got->shdr.sh_addr;
+
+    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);
+      break;
+    case R_68K_8:
+      write8(S + A);
+      break;
+    case R_68K_PC32:
+    case R_68K_PLT32:
+      *(ub32 *)loc = S + A - P;
+      break;
+    case R_68K_PC16:
+    case R_68K_PLT16:
+      write16s(S + A - P);
+      break;
+    case R_68K_PC8:
+    case R_68K_PLT8:
+      write8s(S + A - P);
+      break;
+    case R_68K_GOTPCREL32:
+      *(ub32 *)loc = GOT + A - P;
+      break;
+    case R_68K_GOTPCREL16:
+      write16s(GOT + A - P);
+      break;
+    case R_68K_GOTPCREL8:
+      write8s(GOT + A - P);
+      break;
+    case R_68K_GOTOFF32:
+      *(ub32 *)loc = G + A;
+      break;
+    case R_68K_GOTOFF16:
+      write16(G + A);
+      break;
+    case R_68K_GOTOFF8:
+      write8(G + A);
+      break;
+    case R_68K_TLS_GD32:
+      *(ub32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
+      break;
+    case R_68K_TLS_GD16:
+      write16(sym.get_tlsgd_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_GD8:
+      write8(sym.get_tlsgd_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_LDM32:
+      *(ub32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
+      break;
+    case R_68K_TLS_LDM16:
+      write16(ctx.got->get_tlsld_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_LDM8:
+      write8(ctx.got->get_tlsld_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_LDO32:
+      *(ub32 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_68K_TLS_LDO16:
+      write16s(S + A - ctx.dtp_addr);
+      break;
+    case R_68K_TLS_LDO8:
+      write8s(S + A - ctx.dtp_addr);
+      break;
+    case R_68K_TLS_IE32:
+      *(ub32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
+      break;
+    case R_68K_TLS_IE16:
+      write16(sym.get_gottp_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_IE8:
+      write8(sym.get_gottp_addr(ctx) + A - GOT);
+      break;
+    case R_68K_TLS_LE32:
+      *(ub32 *)loc = S + A - ctx.tp_addr;
+      break;
+    case R_68K_TLS_LE16:
+      write16(S + A - ctx.tp_addr);
+      break;
+    case R_68K_TLS_LE8:
+      write8(S + A - ctx.tp_addr);
+      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;
+
+    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_68K_32:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ub32 *)loc = *val;
+      else
+        *(ub32 *)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 || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    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);
+      break;
+    case R_68K_PC32:
+    case R_68K_PC16:
+    case R_68K_PC8:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_68K_GOTPCREL32:
+    case R_68K_GOTPCREL16:
+    case R_68K_GOTPCREL8:
+    case R_68K_GOTOFF32:
+    case R_68K_GOTOFF16:
+    case R_68K_GOTOFF8:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_68K_PLT32:
+    case R_68K_PLT16:
+    case R_68K_PLT8:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_68K_TLS_GD32:
+    case R_68K_TLS_GD16:
+    case R_68K_TLS_GD8:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_68K_TLS_LDM32:
+    case R_68K_TLS_LDM16:
+    case R_68K_TLS_LDM8:
+      ctx.needs_tlsld = true;
+      break;
+    case R_68K_TLS_IE32:
+    case R_68K_TLS_IE16:
+    case R_68K_TLS_IE8:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_68K_TLS_LE32:
+    case R_68K_TLS_LE16:
+    case R_68K_TLS_LE8:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_68K_TLS_LDO32:
+    case R_68K_TLS_LDO16:
+    case R_68K_TLS_LDO8:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-ppc32.cc

@@ -0,0 +1,453 @@
+// This file implements the PowerPC 32-bit ISA. For 64-bit PowerPC, see
+// arch-ppc64v1.cpp and arch-ppc64v2.cpp.
+//
+// PPC32 is a RISC ISA. It has 32 general-purpose registers (GPRs).
+// r0, r11 and r12 are reserved for static linkers, so we can use these
+// registers in PLTs and range extension thunks. In addition to that, it
+// has a few special registers. Notable ones are LR which holds a return
+// address and CTR which we can use to store a branch target address.
+//
+// It feels that the PPC32 psABI is unnecessarily complicated at first
+// glance, but that is mainly stemmed from the fact that the ISA lacks
+// PC-relative load/store instructions. Since machine instructions cannot
+// load data relative to its own address, it is not straightforward to
+// support position-independent code (PIC) on PPC32.
+//
+// A position-independent function typically contains the following code
+// in the prologue to obtain its own address:
+//
+//    mflr  r0        // save the current return address to %r0
+//    bcl   20, 31, 4 // call the next instruction as if it were a function
+//    mtlr  r12       // save the return address to %r12
+//    mtlr  r0        // restore the original return address
+//
+// An object file compiled with -fPIC contains a data section named
+// `.got2` to store addresses of locally-defined global variables and
+// constants. A PIC function usually computes its .got2+0x8000 and set it
+// to %r30. This scheme allows the function to access global objects
+// defined in the same input file with a single %r30-relative load/store
+// instruction with a 16-bit offset, given that .got2 is smaller than
+// 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 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
+// _for each input file_ (that's what GNU ld seems to be doing), but that
+// doesn't seems to be worth its complexity. Our PLT simply doesn't rely
+// on a %r30 value.
+//
+// https://github.com/rui314/psabi/blob/main/ppc32.pdf
+
+#include "mold.h"
+
+namespace mold::elf {
+
+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; }
+
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  static const ub32 insn[] = {
+    // Get the address of this PLT section
+    0x7c08'02a6, //    mflr    r0
+    0x429f'0005, //    bcl     20, 31, 4
+    0x7d88'02a6, // 1: mflr    r12
+    0x7c08'03a6, //    mtlr    r0
+
+    // Compute the runtime address of GOTPLT+12
+    0x3d8c'0000, //    addis   r12, r12, (GOTPLT - 1b)@higha
+    0x398c'0000, //    addi    r12, r12, (GOTPLT - 1b)@lo
+
+    // Compute the PLT entry offset
+    0x7d6c'5850, //    sub     r11, r11, r12
+    0x1d6b'0003, //    mulli   r11, r11, 3
+
+    // Load GOTPLT[2] and branch to GOTPLT[1]
+    0x800c'fff8, //    lwz     r0,  -8(r12)
+    0x7c09'03a6, //    mtctr   r0
+    0x818c'fffc, //    lwz     r12, -4(r12)
+    0x4e80'0420, //    bctr
+    0x6000'0000, //    nop
+    0x6000'0000, //    nop
+    0x6000'0000, //    nop
+    0x6000'0000, //    nop
+  };
+
+  static_assert(sizeof(insn) == E::plt_hdr_size);
+  memcpy(buf, insn, sizeof(insn));
+
+  ub32 *loc = (ub32 *)buf;
+  loc[4] |= higha(ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr + 4);
+  loc[5] |= lo(ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr + 4);
+}
+
+static const ub32 plt_entry[] = {
+  // Get the address of this PLT entry
+  0x7c08'02a6, // mflr    r0
+  0x429f'0005, // bcl     20, 31, 4
+  0x7d88'02a6, // mflr    r12
+  0x7c08'03a6, // mtlr    r0
+
+  // Load an address from the GOT/GOTPLT entry and jump to that address
+  0x3d6c'0000, // addis   r11, r12, OFFSET@higha
+  0x396b'0000, // addi    r11, r11, OFFSET@lo
+  0x818b'0000, // lwz     r12, 0(r11)
+  0x7d89'03a6, // mtctr   r12
+  0x4e80'0420, // bctr
+};
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static_assert(E::plt_size == sizeof(plt_entry));
+  memcpy(buf, plt_entry, sizeof(plt_entry));
+
+  ub32 *loc = (ub32 *)buf;
+  i64 offset = sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx) - 8;
+  loc[4] |= higha(offset);
+  loc[5] |= lo(offset);
+}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static_assert(E::pltgot_size == sizeof(plt_entry));
+  memcpy(buf, plt_entry, sizeof(plt_entry));
+
+  ub32 *loc = (ub32 *)buf;
+  i64 offset = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 8;
+  loc[4] |= higha(offset);
+  loc[5] |= lo(offset);
+}
+
+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_PPC_ADDR32:
+    *(ub32 *)loc = val;
+    break;
+  case R_PPC_REL32:
+    *(ub32 *)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);
+
+  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];
+    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;
+
+    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;
+    case R_PPC_ADDR16:
+    case R_PPC_UADDR16:
+    case R_PPC_ADDR16_LO:
+      *(ub16 *)loc = lo(S + A);
+      break;
+    case R_PPC_ADDR16_HI:
+      *(ub16 *)loc = hi(S + A);
+      break;
+    case R_PPC_ADDR16_HA:
+      *(ub16 *)loc = ha(S + A);
+      break;
+    case R_PPC_ADDR24:
+      *(ub32 *)loc |= bits(S + A, 25, 2) << 2;
+      break;
+    case R_PPC_ADDR30:
+      *(ub32 *)loc |= bits(S + A, 31, 2) << 2;
+      break;
+    case R_PPC_PLT16_LO:
+      *(ub16 *)loc = lo(G + GOT - A - GOT2);
+      break;
+    case R_PPC_PLT16_HI:
+      *(ub16 *)loc = hi(G + GOT - A - GOT2);
+      break;
+    case R_PPC_PLT16_HA:
+      *(ub16 *)loc = ha(G + GOT - A - GOT2);
+      break;
+    case R_PPC_PLT32:
+      *(ub32 *)loc = G + GOT - A - GOT2;
+      break;
+    case R_PPC_REL14:
+      *(ub32 *)loc |= bits(S + A - P, 15, 2) << 2;
+      break;
+    case R_PPC_REL16:
+    case R_PPC_REL16_LO:
+      *(ub16 *)loc = lo(S + A - P);
+      break;
+    case R_PPC_REL16_HI:
+      *(ub16 *)loc = hi(S + A - P);
+      break;
+    case R_PPC_REL16_HA:
+      *(ub16 *)loc = ha(S + A - P);
+      break;
+    case R_PPC_REL24:
+    case R_PPC_LOCAL24PC: {
+      i64 val = S + A - P;
+      if (sign_extend(val, 25) != val)
+        val = get_thunk_addr(i) - P;
+      *(ub32 *)loc |= bits(val, 25, 2) << 2;
+      break;
+    }
+    case R_PPC_PLTREL24: {
+      i64 val = S - P;
+      if (sym.has_plt(ctx) || sign_extend(val, 25) != val)
+        val = get_thunk_addr(i) - P;
+      *(ub32 *)loc |= bits(val, 25, 2) << 2;
+      break;
+    }
+    case R_PPC_REL32:
+    case R_PPC_PLTREL32:
+      *(ub32 *)loc = S + A - P;
+      break;
+    case R_PPC_GOT16:
+    case R_PPC_GOT16_LO:
+      *(ub16 *)loc = lo(G + A);
+      break;
+    case R_PPC_GOT16_HI:
+      *(ub16 *)loc = hi(G + A);
+      break;
+    case R_PPC_GOT16_HA:
+      *(ub16 *)loc = ha(G + A);
+      break;
+    case R_PPC_TPREL16_LO:
+      *(ub16 *)loc = lo(S + A - ctx.tp_addr);
+      break;
+    case R_PPC_TPREL16_HI:
+      *(ub16 *)loc = hi(S + A - ctx.tp_addr);
+      break;
+    case R_PPC_TPREL16_HA:
+      *(ub16 *)loc = ha(S + A - ctx.tp_addr);
+      break;
+    case R_PPC_DTPREL16_LO:
+      *(ub16 *)loc = lo(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC_DTPREL16_HI:
+      *(ub16 *)loc = hi(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC_DTPREL16_HA:
+      *(ub16 *)loc = ha(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC_GOT_TLSGD16:
+      *(ub16 *)loc = sym.get_tlsgd_addr(ctx) - GOT;
+      break;
+    case R_PPC_GOT_TLSLD16:
+      *(ub16 *)loc = ctx.got->get_tlsld_addr(ctx) - GOT;
+      break;
+    case R_PPC_GOT_TPREL16:
+      *(ub16 *)loc = sym.get_gottp_addr(ctx) - GOT;
+      break;
+    case R_PPC_TLS:
+    case R_PPC_TLSGD:
+    case R_PPC_TLSLD:
+    case R_PPC_PLTSEQ:
+    case R_PPC_PLTCALL:
+      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;
+
+    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_PPC_ADDR32:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ub32 *)loc = *val;
+      else
+        *(ub32 *)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);
+
+  // 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_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:
+    case R_PPC_ADDR16_LO:
+    case R_PPC_ADDR16_HI:
+    case R_PPC_ADDR16_HA:
+    case R_PPC_ADDR24:
+    case R_PPC_ADDR30:
+      scan_absrel(ctx, sym, rel);
+      break;
+    case R_PPC_REL14:
+    case R_PPC_REL16:
+    case R_PPC_REL16_LO:
+    case R_PPC_REL16_HI:
+    case R_PPC_REL16_HA:
+    case R_PPC_REL32:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_PPC_GOT16:
+    case R_PPC_GOT16_LO:
+    case R_PPC_GOT16_HI:
+    case R_PPC_GOT16_HA:
+    case R_PPC_PLT16_LO:
+    case R_PPC_PLT16_HI:
+    case R_PPC_PLT16_HA:
+    case R_PPC_PLT32:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_PPC_REL24:
+    case R_PPC_PLTREL24:
+    case R_PPC_PLTREL32:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_PPC_GOT_TLSGD16:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_PPC_GOT_TLSLD16:
+      ctx.needs_tlsld = true;
+      break;
+    case R_PPC_GOT_TPREL16:
+      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_LOCAL24PC:
+    case R_PPC_TLS:
+    case R_PPC_TLSGD:
+    case R_PPC_TLSLD:
+    case R_PPC_DTPREL16_LO:
+    case R_PPC_DTPREL16_HI:
+    case R_PPC_DTPREL16_HA:
+    case R_PPC_PLTSEQ:
+    case R_PPC_PLTCALL:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
+  static const ub32 local_thunk[] = {
+    // Get this thunk's address
+    0x7c08'02a6, // mflr    r0
+    0x429f'0005, // bcl     20, 31, 4
+    0x7d88'02a6, // mflr    r12
+    0x7c08'03a6, // mtlr    r0
+
+    // Materialize the destination's address in %r11 and jump to that address
+    0x3d6c'0000, // addis   r11, r12, OFFSET@higha
+    0x396b'0000, // addi    r11, r11, OFFSET@lo
+    0x7d69'03a6, // mtctr   r11
+    0x4e80'0420, // bctr
+    0x6000'0000, // nop
+  };
+
+  static_assert(E::thunk_size == sizeof(plt_entry));
+  static_assert(E::thunk_size == sizeof(local_thunk));
+
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 P = output_section.shdr.sh_addr + offset;
+
+  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 {
+      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

elf/arch-ppc64v1.cc

@@ -0,0 +1,685 @@
+// This file contains code for the 64-bit PowerPC ELFv1 ABI that is
+// commonly used for big-endian PPC systems. Modern PPC systems that use
+// the processor in the little-endian mode use the ELFv2 ABI instead. For
+// ELFv2, see arch-ppc64v2.cc.
+//
+// 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 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 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
+// relative to %r2.
+//
+// Each ELF file has its own GOT. If a function calls another function in
+// the same ELF file, it doesn't have to reset %r2. However, if it is in
+// other file (e.g. other .so), it has to set a new value to %r2 so that
+// the register contains the callee's GOT + 0x8000.
+//
+// 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 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
+// through function pointers.
+//
+// .opd (short for "official procedure descriptors") contains function
+// descriptors.
+//
+// You can think OPD as this: even in other targets, a function can have a
+// 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 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 {
+
+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; }
+
+// .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 ub32 insn[] = {
+    0x7d88'02a6, // mflr    r12
+    0x429f'0005, // bcl     20, 31, 4 // obtain PC
+    0x7d68'02a6, // mflr    r11
+    0x7d88'03a6, // mtlr    r12
+    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
+  };
+
+  static_assert(sizeof(insn) == E::plt_hdr_size);
+  memcpy(buf, insn, sizeof(insn));
+
+  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) {
+  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) {
+    static const 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 {
+    static const 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
+// 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:
+    *(ub64 *)loc = val;
+    break;
+  case R_PPC64_REL32:
+    *(ub32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_PPC64_REL64:
+    *(ub64 *)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;
+
+    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:
+      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);
+      break;
+    case R_PPC64_TOC16_LO:
+      *(ub16 *)loc = lo(S + A - TOC);
+      break;
+    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;
+    case R_PPC64_REL24: {
+      i64 val = sym.get_addr(ctx, NO_OPD) + A - P;
+      if (sym.has_plt(ctx) || sign_extend(val, 25) != val)
+        val = get_thunk_addr(i) + A - P;
+
+      check(val, -(1 << 25), 1 << 25);
+      *(ub32 *)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) && *(ub32 *)(loc + 4) == 0x6000'0000)
+        *(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;
+    case R_PPC64_REL16_HA:
+      *(ub16 *)loc = ha(S + A - P);
+      break;
+    case R_PPC64_REL16_LO:
+      *(ub16 *)loc = lo(S + A - P);
+      break;
+    case R_PPC64_PLT16_HA:
+      *(ub16 *)loc = ha(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_HI:
+      *(ub16 *)loc = hi(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_LO:
+      *(ub16 *)loc = lo(G + GOT - TOC);
+      break;
+    case R_PPC64_PLT16_LO_DS:
+      *(ub16 *)loc |= (G + GOT - TOC) & 0xfffc;
+      break;
+    case R_PPC64_GOT_TPREL16_HA:
+      *(ub16 *)loc = ha(sym.get_gottp_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSGD16_HA:
+      *(ub16 *)loc = ha(sym.get_tlsgd_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSGD16_LO:
+      *(ub16 *)loc = lo(sym.get_tlsgd_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSLD16_HA:
+      *(ub16 *)loc = ha(ctx.got->get_tlsld_addr(ctx) - TOC);
+      break;
+    case R_PPC64_GOT_TLSLD16_LO:
+      *(ub16 *)loc = lo(ctx.got->get_tlsld_addr(ctx) - TOC);
+      break;
+    case R_PPC64_DTPREL16_HA:
+      *(ub16 *)loc = ha(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC64_DTPREL16_LO:
+      *(ub16 *)loc = lo(S + A - ctx.dtp_addr);
+      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_GOT_TPREL16_LO_DS:
+      *(ub16 *)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 || 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))
+        *(ub64 *)loc = *val;
+      else
+        *(ub64 *)loc = S + A;
+      break;
+    case R_PPC64_ADDR32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_PPC64_DTPREL64:
+      *(ub64 *)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 || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (sym.is_ifunc())
+      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 |= NEEDS_PPC_OPD;
+
+    switch (rel.r_type) {
+    case R_PPC64_ADDR64:
+    case R_PPC64_TOC:
+      scan_toc_rel(ctx, sym, rel);
+      break;
+    case R_PPC64_GOT_TPREL16_HA:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_PPC64_REL24:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_PPC64_PLT16_HA:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_PPC64_GOT_TLSGD16_HA:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_PPC64_GOT_TLSLD16_HA:
+      ctx.needs_tlsld = true;
+      break;
+    case R_PPC64_TPREL16_HA:
+    case R_PPC64_TPREL16_LO:
+      check_tlsle(ctx, sym, rel);
+      break;
+    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_PLTSEQ:
+    case R_PPC64_PLTCALL:
+    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) {
+  // 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[] = {
+    // Store the caller's %r2
+    0xf841'0028, // std   %r2, 40(%r1)
+
+    // Load an address of a function descriptor
+    0x3d82'0000, // addis %r12, %r2,  foo@got@toc@ha
+    0xe98c'0000, // ld    %r12, foo@got@toc@lo(%r12)
+
+    // Restore the callee's %r2
+    0xe84c'0008, // ld    %r2,  8(%r12)
+
+    // Jump to the function
+    0xe98c'0000, // ld    %r12, 0(%r12)
+    0x7d89'03a6, // mtctr %r12
+    0x4e80'0420, // bctr
+  };
+
+  // If the destination is .plt, read a function descriptor from .got.plt.
+  static const ub32 plt_thunk[] = {
+    // Store the caller's %r2
+    0xf841'0028, // std   %r2, 40(%r1)
+
+    // Materialize an address of a function descriptor
+    0x3d82'0000, // addis %r12, %r2,  foo@gotplt@toc@ha
+    0x398c'0000, // addi  %r12, %r12, foo@gotplt@toc@lo
+
+    // Restore the callee's %r2
+    0xe84c'0008, // ld    %r2,  8(%r12)
+
+    // Jump to the function
+    0xe98c'0000, // ld    %r12, 0(%r12)
+    0x7d89'03a6, // mtctr %r12
+    0x4e80'0420, // bctr
+  };
+
+  // If the destination is a non-imported function, we directly jump
+  // to the function entry address.
+  static const ub32 local_thunk[] = {
+    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
+    0x6000'0000, // nop
+    0x6000'0000, // nop
+  };
+
+  static_assert(E::thunk_size == sizeof(pltgot_thunk));
+  static_assert(E::thunk_size == sizeof(plt_thunk));
+  static_assert(E::thunk_size == sizeof(local_thunk));
+
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+
+  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 {
+      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;
+  }
+}
+
+static InputSection<E> *get_opd_section(ObjectFile<E> &file) {
+  for (std::unique_ptr<InputSection<E>> &isec : file.sections)
+    if (isec && isec->name() == ".opd")
+      return isec.get();
+  return nullptr;
+}
+
+static ElfRel<E> *
+get_relocation_at(Context<E> &ctx, InputSection<E> &isec, i64 offset) {
+  std::span<ElfRel<E>> rels = isec.get_rels(ctx);
+
+  auto it = std::lower_bound(rels.begin(), rels.end(), offset,
+                             [](const ElfRel<E> &r, i64 offset) {
+    return r.r_offset < offset;
+  });
+
+  if (it == rels.end())
+    return nullptr;
+  if (it->r_offset != offset)
+    return nullptr;
+  return &*it;
+}
+
+struct OpdSymbol {
+  bool operator<(const OpdSymbol &x) const { return r_offset < x.r_offset; }
+
+  u64 r_offset = 0;
+  Symbol<E> *sym = nullptr;
+};
+
+static Symbol<E> *
+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;
+  if (it->r_offset != offset)
+    return nullptr;
+  return it->sym;
+}
+
+// Compiler creates an .opd entry for each function symbol. The intention
+// is to make it possible to create an output .opd section just by linking
+// input .opd sections in the same manner as we do to other normal input
+// sections.
+//
+// However, in reality, .opd isn't a normal input section. It needs many
+// special treatments as follows:
+//
+// 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.
+//
+// 2. Output .opd entries are needed only for functions whose addresses
+//    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 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.
+//
+// The problem is that the compiler creates a half-baked .opd section, and
+// the linker has to figure out what all these .opd entries and
+// relocations are trying to achieve. It's like the compiler would emit a
+// half-baked .plt section in an object file and the linker has to deal
+// with that. That's not a good design.
+//
+// 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 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
+// do for .plt or .got.
+void ppc64v1_rewrite_opd(Context<E> &ctx) {
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    InputSection<E> *opd = get_opd_section(*file);
+    if (!opd)
+      return;
+    opd->is_alive = false;
+
+    // Move symbols from .opd to .text.
+    std::vector<OpdSymbol> opd_syms;
+
+    for (Symbol<E> *sym : file->symbols) {
+      if (sym->file != file || sym->get_input_section() != opd)
+        continue;
+
+      if (u32 ty = sym->get_type(); ty != STT_FUNC && ty != STT_GNU_IFUNC)
+        continue;
+
+      ElfRel<E> *rel = get_relocation_at(ctx, *opd, sym->value);
+      if (!rel)
+        Fatal(ctx) << *file << ": cannot find a relocation in .opd for "
+                   << *sym << " at offset 0x" << std::hex << (u64)sym->value;
+
+      Symbol<E> *sym2 = file->symbols[rel->r_sym];
+      if (sym2->get_type() != STT_SECTION)
+        Fatal(ctx) << *file << ": bad relocation in .opd referring " << *sym2;
+
+      opd_syms.push_back({sym->value, sym});
+
+      sym->set_input_section(sym2->get_input_section());
+      sym->value = rel->r_addend;
+    }
+
+    // Sort symbols so that get_opd_sym_at() can do binary search.
+    sort(opd_syms);
+
+    // Rewrite relocations so that they directly refer to .opd.
+    for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
+      if (!isec || !isec->is_alive || isec.get() == opd)
+        continue;
+
+      for (ElfRel<E> &r : isec->get_rels(ctx)) {
+        Symbol<E> &sym = *file->symbols[r.r_sym];
+        if (sym.get_input_section() != opd)
+          continue;
+
+        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;
+
+        r.r_sym = real_sym->sym_idx;
+        r.r_addend = 0;
+      }
+    }
+  });
+}
+
+// When a function is exported, the dynamic symbol for the function should
+// 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)
+      if (sym->file == file && sym->is_exported)
+        if (u32 ty = sym->get_type(); ty == STT_FUNC || ty == STT_GNU_IFUNC)
+          sym->flags |= NEEDS_PPC_OPD;
+  });
+
+  // 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;
+  };
+
+  mark(ctx.arg.entry);
+  mark(ctx.arg.init);
+  mark(ctx.arg.fini);
+}
+
+void PPC64OpdSection::add_symbol(Context<E> &ctx, Symbol<E> *sym) {
+  sym->set_opd_idx(ctx, symbols.size());
+  symbols.push_back(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) {
+    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

elf/arch-ppc64v2.cc

@@ -0,0 +1,572 @@
+// 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::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 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) {
+  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
+    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().ppc_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);
+
+  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 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_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:
+      if (sym.has_plt(ctx) || !sym.esym().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().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_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_TPREL34:
+      write34(loc, S + A - ctx.tp_addr);
+      break;
+    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);
+
+  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 || 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_ADDR64:
+      if (name() == ".toc")
+        scan_toc_rel(ctx, sym, rel);
+      else
+        scan_dyn_absrel(ctx, sym, rel);
+      break;
+    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_TPREL34:
+      check_tlsle(ctx, sym, rel);
+      break;
+    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_DTPREL34:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
+  // If the destination is PLT, we read an address from .got.plt or .got
+  // and jump there.
+  static const 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
+  };
+
+  static const 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.
+  static const 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
+  };
+
+  static const 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;
+  }
+}
+
+template <>
+u64 get_eflags(Context<E> &ctx) {
+  return 2;
+}
+
+} // namespace mold::elf

elf/arch-riscv64.cc

@@ -1,813 +0,0 @@
-#include "mold.h"
-
-#include <tbb/parallel_for.h>
-#include <tbb/parallel_for_each.h>
-
-namespace mold::elf {
-
-using E = RISCV64;
-
-static u32 bit(u32 val, i64 pos) {
-  return (val >> pos) & 1;
-}
-
-// Returns [hi:lo] bits of val.
-static u32 bits(u32 val, i64 hi, i64 lo) {
-  return (val >> lo) & ((1LL << (hi - lo + 1)) - 1);
-}
-
-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
-  // add it to a register value to construct a complete value. 0x800
-  // is added here to compensate for the sign-extension.
-  return bits(val + 0x800, 31, 12) << 12;
-}
-
-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(u32 *loc, u32 val) {
-  u32 mask = 0b000000'00000'11111'111'11111'1111111;
-  *loc = (*loc & mask) | itype(val);
-}
-
-static void write_stype(u32 *loc, u32 val) {
-  u32 mask = 0b000000'11111'11111'111'00000'1111111;
-  *loc = (*loc & mask) | stype(val);
-}
-
-static void write_btype(u32 *loc, u32 val) {
-  u32 mask = 0b000000'11111'11111'111'00000'1111111;
-  *loc = (*loc & mask) | btype(val);
-}
-
-static void write_utype(u32 *loc, u32 val) {
-  u32 mask = 0b000000'00000'00000'000'11111'1111111;
-  *loc = (*loc & mask) | utype(val);
-}
-
-static void write_jtype(u32 *loc, u32 val) {
-  u32 mask = 0b000000'00000'00000'000'11111'1111111;
-  *loc = (*loc & mask) | jtype(val);
-}
-
-static void write_cbtype(u16 *loc, u32 val) {
-  u32 mask = 0b1110001110000011;
-  *loc = (*loc & mask) | cbtype(val);
-}
-
-static void write_cjtype(u16 *loc, u32 val) {
-  u32 mask = 0b1110000000000011;
-  *loc = (*loc & mask) | cjtype(val);
-}
-
-static void write_plt_header(Context<E> &ctx) {
-  u32 *buf = (u32 *)(ctx.buf + ctx.plt->shdr.sh_offset);
-
-  static const u32 plt0[] = {
-    0x00000397, // auipc  t2, %pcrel_hi(.got.plt)
-    0x41c30333, // sub    t1, t1, t3               # .plt entry + hdr + 12
-    0x0003be03, // ld     t3, %pcrel_lo(1b)(t2)    # _dl_runtime_resolve
-    0xfd430313, // addi   t1, t1, -44              # .plt entry
-    0x00038293, // addi   t0, t2, %pcrel_lo(1b)    # &.got.plt
-    0x00135313, // srli   t1, t1, 1                # .plt entry offset
-    0x0082b283, // ld     t0, 8(t0)                # link map
-    0x000e0067, // jr     t3
-  };
-
-  u64 gotplt = ctx.gotplt->shdr.sh_addr;
-  u64 plt = ctx.plt->shdr.sh_addr;
-
-  memcpy(buf, plt0, sizeof(plt0));
-  write_utype(buf, gotplt - plt);
-  write_itype(buf + 2, gotplt - plt);
-  write_itype(buf + 4, gotplt - plt);
-}
-
-static void write_plt_entry(Context<E> &ctx, Symbol<E> &sym) {
-  u32 *ent = (u32 *)(ctx.buf + ctx.plt->shdr.sh_offset + ctx.plt_hdr_size +
-                     sym.get_plt_idx(ctx) * ctx.plt_size);
-
-  static const u32 data[] = {
-    0x00000e17, // auipc   t3, %pcrel_hi([email protected])
-    0x000e3e03, // ld      t3, %pcrel_lo(1b)(t3)
-    0x000e0367, // jalr    t1, t3
-    0x00000013, // nop
-  };
-
-  u64 gotplt = sym.get_gotplt_addr(ctx);
-  u64 plt = sym.get_plt_addr(ctx);
-
-  memcpy(ent, data, sizeof(data));
-  write_utype(ent, gotplt - plt);
-  write_itype(ent + 1, gotplt - plt);
-}
-
-template <>
-void PltSection<E>::copy_buf(Context<E> &ctx) {
-  write_plt_header(ctx);
-  for (Symbol<E> *sym : symbols)
-    write_plt_entry(ctx, *sym);
-}
-
-template <>
-void PltGotSection<E>::copy_buf(Context<E> &ctx) {
-  u32 *buf = (u32 *)(ctx.buf + this->shdr.sh_offset);
-
-  static const u32 data[] = {
-    0x00000e17, // auipc   t3, %pcrel_hi([email protected])
-    0x000e3e03, // ld      t3, %pcrel_lo(1b)(t3)
-    0x000e0367, // jalr    t1, t3
-    0x00000013, // nop
-  };
-
-  for (Symbol<E> *sym : symbols) {
-    u32 *ent = buf + sym->get_pltgot_idx(ctx) * 4;
-    u64 got = sym->get_got_addr(ctx);
-    u64 plt = sym->get_plt_addr(ctx);
-
-    memcpy(ent, data, sizeof(data));
-    write_utype(ent, got - plt);
-    write_itype(ent + 1, got - plt);
-  }
-}
-
-template <>
-void EhFrameSection<E>::apply_reloc(Context<E> &ctx, ElfRel<E> &rel,
-                                    u64 offset, u64 val) {
-  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
-
-  switch (rel.r_type) {
-  case R_RISCV_ADD32:
-    *(u32 *)loc += val;
-    return;
-  case R_RISCV_SUB8:
-    *loc -= val;
-    return;
-  case R_RISCV_SUB16:
-    *(u16 *)loc -= val;
-    return;
-  case R_RISCV_SUB32:
-    *(u32 *)loc -= val;
-    return;
-  case R_RISCV_SUB6:
-    *loc = (*loc & 0b1100'0000) | ((*loc - val) & 0b0011'1111);
-    return;
-  case R_RISCV_SET6:
-    *loc = (*loc & 0b1100'0000) | (val & 0b0011'1111);
-    return;
-  case R_RISCV_SET8:
-    *loc = val;
-    return;
-  case R_RISCV_SET16:
-    *(u16 *)loc = val;
-    return;
-  case R_RISCV_32_PCREL:
-    *(u32 *)loc = val - this->shdr.sh_addr - offset;
-    return;
-  }
-  Fatal(ctx) << "unsupported relocation in .eh_frame: " << rel;
-}
-
-template <>
-void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
-  ElfRel<E> *dynrel = nullptr;
-  std::span<ElfRel<E>> rels = get_rels(ctx);
-  std::span<i32> r_deltas = get_r_deltas();
-
-  i64 frag_idx = 0;
-
-  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_RISCV_NONE || rel.r_type == R_RISCV_RELAX ||
-        rel.r_type == R_RISCV_ALIGN)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    i64 r_offset = rel.r_offset + r_deltas[i];
-    u8 *loc = base + r_offset;
-
-    const SectionFragmentRef<E> *frag_ref = nullptr;
-    if (rel_fragments && rel_fragments[frag_idx].idx == i)
-      frag_ref = &rel_fragments[frag_idx++];
-
-#define S   (frag_ref ? frag_ref->frag->get_addr(ctx) : sym.get_addr(ctx))
-#define A   (frag_ref ? frag_ref->addend : rel.r_addend)
-#define P   (output_section->shdr.sh_addr + offset + r_offset)
-#define G   (sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr)
-#define GOT ctx.got->shdr.sh_addr
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-      *(u32 *)loc = S + A;
-      break;
-    case R_RISCV_64:
-      if (sym.is_absolute() || !ctx.arg.pic) {
-        *(u64 *)loc = S + A;
-      } else if (sym.is_imported) {
-        *dynrel++ = {P, R_RISCV_64, (u32)sym.get_dynsym_idx(ctx), A};
-        *(u64 *)loc = A;
-      } else {
-        if (!is_relr_reloc(ctx, rel))
-          *dynrel++ = {P, R_RISCV_RELATIVE, 0, (i64)(S + A)};
-        *(u64 *)loc = S + A;
-      }
-      break;
-    case R_RISCV_TLS_DTPMOD32:
-    case R_RISCV_TLS_DTPMOD64:
-    case R_RISCV_TLS_DTPREL32:
-    case R_RISCV_TLS_DTPREL64:
-    case R_RISCV_TLS_TPREL32:
-    case R_RISCV_TLS_TPREL64:
-      Error(ctx) << *this << ": unsupported relocation: " << rel;
-      break;
-    case R_RISCV_BRANCH:
-      write_btype((u32 *)loc, S + A - P);
-      break;
-    case R_RISCV_JAL:
-      write_jtype((u32 *)loc, S + A - P);
-      break;
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT: {
-      if (r_deltas[i + 1] - r_deltas[i] != 0) {
-        // auipc + jalr -> jal
-        assert(r_deltas[i + 1] - r_deltas[i] == -4);
-        u32 jalr = *(u32 *)&contents[rels[i].r_offset + 4];
-        *(u32 *)loc = (0b11111'000000 & jalr) | 0b101111;
-        write_jtype((u32 *)loc, S + A - P);
-      } else {
-        u64 val = sym.esym().is_undef_weak() ? 0 : S + A - P;
-        write_utype((u32 *)loc, val);
-        write_itype((u32 *)(loc + 4), val);
-      }
-      break;
-    }
-    case R_RISCV_GOT_HI20:
-      *(u32 *)loc = G + GOT + A - P;
-      break;
-    case R_RISCV_TLS_GOT_HI20:
-      *(u32 *)loc = sym.get_gottp_addr(ctx) + A - P;
-      break;
-    case R_RISCV_TLS_GD_HI20:
-      *(u32 *)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.
-        *(u32 *)loc = P;
-      } else {
-        *(u32 *)loc = S + A - P;
-      }
-      break;
-    case R_RISCV_PCREL_LO12_I:
-      assert(sym.get_input_section() == this);
-      assert(sym.value < r_offset);
-      write_itype((u32 *)loc, *(u32 *)(base + sym.value));
-      break;
-    case R_RISCV_LO12_I:
-    case R_RISCV_TPREL_LO12_I:
-      write_itype((u32 *)loc, S + A);
-      break;
-    case R_RISCV_PCREL_LO12_S:
-      assert(sym.get_input_section() == this);
-      assert(sym.value < r_offset);
-      write_stype((u32 *)loc, *(u32 *)(base + sym.value));
-      break;
-    case R_RISCV_LO12_S:
-    case R_RISCV_TPREL_LO12_S:
-      write_stype((u32 *)loc, S + A);
-      break;
-    case R_RISCV_HI20:
-      write_utype((u32 *)loc, S + A);
-      break;
-    case R_RISCV_TPREL_HI20:
-      write_utype((u32 *)loc, S + A - ctx.tls_begin);
-      break;
-    case R_RISCV_TPREL_ADD:
-      break;
-    case R_RISCV_ADD8:
-      loc += S + A;
-      break;
-    case R_RISCV_ADD16:
-      *(u16 *)loc += S + A;
-      break;
-    case R_RISCV_ADD32:
-      *(u32 *)loc += S + A;
-      break;
-    case R_RISCV_ADD64:
-      *(u64 *)loc += S + A;
-      break;
-    case R_RISCV_SUB8:
-      loc -= S + A;
-      break;
-    case R_RISCV_SUB16:
-      *(u16 *)loc -= S + A;
-      break;
-    case R_RISCV_SUB32:
-      *(u32 *)loc -= S + A;
-      break;
-    case R_RISCV_SUB64:
-      *(u64 *)loc -= S + A;
-      break;
-    case R_RISCV_RVC_BRANCH:
-      write_cbtype((u16 *)loc, S + A - P);
-      break;
-    case R_RISCV_RVC_JUMP:
-      write_cjtype((u16 *)loc, S + A - P);
-      break;
-    case R_RISCV_RVC_LUI:
-      Error(ctx) << *this << ": unsupported relocation: " << rel;
-      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 *)loc = S + A;
-      break;
-    case R_RISCV_SET32:
-      *(u32 *)loc = S + A;
-      break;
-    case R_RISCV_32_PCREL:
-      *(u32 *)loc = S + A - P;
-      break;
-    default:
-      Error(ctx) << *this << ": unknown relocation: " << rel;
-    }
-
-#undef S
-#undef A
-#undef P
-#undef G
-#undef GOT
-  }
-
-  // In the above loop, PC-relative HI20 relocations overwrote
-  // instructions with full 32-bit values to allow their corresponding
-  // PCREL_LO12 relocations to read their values. This loop restore
-  // the original instructions.
-  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: {
-      u32 *loc = (u32 *)(base + rels[i].r_offset + r_deltas[i]);
-      u32 val = *loc;
-      *loc = *(u32 *)&contents[rels[i].r_offset];
-      write_utype(loc, val);
-    }
-    }
-  }
-}
-
-template <>
-void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
-  std::span<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_RISCV_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-    u8 *loc = base + rel.r_offset;
-
-    if (!sym.file) {
-      report_undef(ctx, file, sym);
-      continue;
-    }
-
-    SectionFragment<E> *frag;
-    i64 addend;
-    std::tie(frag, addend) = get_fragment(ctx, rel);
-
-#define S (frag ? frag->get_addr(ctx) : sym.get_addr(ctx))
-#define A (frag ? addend : rel.r_addend)
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-      *(u32 *)loc = S + A;
-      break;
-    case R_RISCV_64:
-      if (std::optional<u64> val = get_tombstone(sym))
-        *(u64 *)loc = *val;
-      else
-        *(u64 *)loc = S + A;
-      break;
-    case R_RISCV_ADD8:
-      *loc += S + A;
-      break;
-    case R_RISCV_ADD16:
-      *(u16 *)loc += S + A;
-      break;
-    case R_RISCV_ADD32:
-      *(u32 *)loc += S + A;
-      break;
-    case R_RISCV_ADD64:
-      *(u64 *)loc += S + A;
-      break;
-    case R_RISCV_SUB8:
-      *loc -= S + A;
-      break;
-    case R_RISCV_SUB16:
-      *(u16 *)loc -= S + A;
-      break;
-    case R_RISCV_SUB32:
-      *(u32 *)loc -= S + A;
-      break;
-    case R_RISCV_SUB64:
-      *(u64 *)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 *)loc = S + A;
-      break;
-    case R_RISCV_SET32:
-      *(u32 *)loc = S + A;
-      break;
-    default:
-      Fatal(ctx) << *this << ": invalid relocation for non-allocated sections: "
-                 << rel;
-      break;
-    }
-
-#undef S
-#undef A
-  }
-}
-
-template <>
-void InputSection<E>::copy_contents_riscv(Context<E> &ctx, u8 *buf) {
-  // A non-alloc section isn't relaxed, so just copy it as one big chunk.
-  if (!(shdr().sh_flags & SHF_ALLOC)) {
-    if (is_compressed())
-      uncompress(ctx, buf);
-    else
-      memcpy(buf, contents.data(), contents.size());
-    return;
-  }
-
-  // Memory-allocated sections may be relaxed, so copy each segment
-  // individually.
-  std::span<ElfRel<E>> rels = get_rels(ctx);
-  std::span<i32> r_deltas = get_r_deltas();
-  i64 pos = 0;
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    i64 delta = r_deltas[i + 1] - 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 <>
-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<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_RISCV_NONE)
-      continue;
-
-    Symbol<E> &sym = *file.symbols[rel.r_sym];
-
-    if (!sym.file) {
-      report_undef(ctx, file, sym);
-      continue;
-    }
-
-    if (sym.get_type() == STT_GNU_IFUNC) {
-      sym.flags |= NEEDS_GOT;
-      sym.flags |= NEEDS_PLT;
-    }
-
-    switch (rel.r_type) {
-    case R_RISCV_32:
-    case R_RISCV_HI20: {
-      Action table[][4] = {
-        // Absolute  Local    Imported data  Imported code
-        {  NONE,     ERROR,   ERROR,         ERROR },      // DSO
-        {  NONE,     ERROR,   ERROR,         ERROR },      // PIE
-        {  NONE,     NONE,    COPYREL,       CPLT  },      // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
-      break;
-    }
-    case R_RISCV_64: {
-      Action table[][4] = {
-        // Absolute  Local    Imported data  Imported code
-        {  NONE,     BASEREL, DYNREL,        DYNREL },     // DSO
-        {  NONE,     BASEREL, DYNREL,        DYNREL },     // PIE
-        {  NONE,     NONE,    COPYREL,       CPLT   },     // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
-      break;
-    }
-    case R_RISCV_TLS_DTPMOD32:
-    case R_RISCV_TLS_DTPMOD64:
-    case R_RISCV_TLS_DTPREL32:
-    case R_RISCV_TLS_DTPREL64:
-    case R_RISCV_TLS_TPREL32:
-    case R_RISCV_TLS_TPREL64:
-      Error(ctx) << *this << ": unsupported relocation: " << rel;
-      break;
-    case R_RISCV_BRANCH:
-    case R_RISCV_JAL:
-      break;
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT:
-      if (sym.is_imported)
-        sym.flags |= NEEDS_PLT;
-      break;
-    case R_RISCV_GOT_HI20:
-      sym.flags |= NEEDS_GOT;
-      break;
-    case R_RISCV_TLS_GOT_HI20:
-      ctx.has_gottp_rel = true;
-      sym.flags |= NEEDS_GOTTP;
-      break;
-    case R_RISCV_TLS_GD_HI20:
-      sym.flags |= NEEDS_TLSGD;
-      break;
-    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:
-      break;
-    case R_RISCV_RVC_BRANCH:
-    case R_RISCV_RVC_JUMP:
-      break;
-    case R_RISCV_RVC_LUI:
-      Error(ctx) << *this << ": unsupported relocation: " << rel;
-      break;
-    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;
-    case R_RISCV_32_PCREL: {
-      Action table[][4] = {
-        // Absolute  Local  Imported data  Imported code
-        {  ERROR,    NONE,  ERROR,         ERROR },      // DSO
-        {  ERROR,    NONE,  COPYREL,       PLT   },      // PIE
-        {  NONE,     NONE,  COPYREL,       PLT   },      // PDE
-      };
-      dispatch(ctx, table, i, rel, sym);
-      break;
-    }
-    default:
-      Error(ctx) << *this << ": unknown relocation: " << rel;
-    }
-  }
-}
-
-static bool is_resizable(Context<E> &ctx, InputSection<E> *isec) {
-  return isec && (isec->shdr().sh_flags & SHF_ALLOC);
-}
-
-// Initializes r_deltas and sorted_symbols.
-static void initialize_storage(Context<E> &ctx) {
-  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
-    file->r_deltas.resize(file->sections.size());
-    for (std::unique_ptr<InputSection<E>> &isec : file->sections)
-      if (is_resizable(ctx, isec.get()))
-        isec->get_r_deltas().resize(isec->get_rels(ctx).size() + 1);
-
-    file->sorted_symbols.resize(file->sections.size());
-
-    for (Symbol<E> *sym : file->symbols)
-      if (sym->file == file)
-        if (InputSection<E> *isec = sym->get_input_section())
-          file->sorted_symbols[isec->shndx].push_back(sym);
-
-    for (std::vector<Symbol<E> *> &vec : file->sorted_symbols)
-      sort(vec, [](Symbol<E> *a, Symbol<E> *b) { return a->value < b->value; });
-  });
-}
-
-// Returns the distance between a relocated place and a symbol.
-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 `relax_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;
-}
-
-// Relax R_RISCV_CALL and R_RISCV_CALL_PLT relocations.
-static void relax_section(Context<E> &ctx, InputSection<E> &isec) {
-  std::span<i32> r_deltas = isec.get_r_deltas();
-  std::span<Symbol<E> *> syms = isec.get_sorted_symbols();
-  i64 delta = 0;
-
-  std::span<ElfRel<E>> rels = isec.get_rels(ctx);
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    const ElfRel<E> &r = rels[i];
-    i64 delta2 = 0;
-
-    r_deltas[i] += delta;
-
-    switch (r.r_type) {
-    case R_RISCV_ALIGN: {
-      // 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.
-      u64 loc = isec.get_addr() + r.r_offset + delta;
-
-      // The total bytes of NOPs is stored to r_addend, so the next
-      // instruction is r_addend away.
-      u64 next_loc = loc + r.r_addend;
-
-      u64 alignment = (std::popcount<u64>(r.r_addend) == 1)
-        ? r.r_addend : next_power_of_two(r.r_addend);
-
-      if (next_loc % alignment)
-        delta2 = align_to(loc, alignment) - next_loc;
-      break;
-    }
-    case R_RISCV_CALL:
-    case R_RISCV_CALL_PLT:
-      if (ctx.arg.relax) {
-        if (i == rels.size() - 1 || rels[i + 1].r_type != R_RISCV_RELAX)
-          break;
-
-        // If the jump target is within ±1 MiB, we can replace AUIPC+JALR
-        // with JAL, saving 4 bytes.
-        Symbol<E> &sym = *isec.file.symbols[r.r_sym];
-        i64 dist = compute_distance(ctx, sym, isec, r);
-        if (dist % 2 == 0 && -(1 << 20) <= dist && dist < (1 << 20))
-          delta2 = -4;
-      }
-    }
-
-    if (delta2 == 0)
-      continue;
-
-    while (!syms.empty() && syms[0]->value <= r.r_offset) {
-      syms[0]->value += delta;
-      syms = syms.subspan(1);
-    }
-
-    delta += delta2;
-  }
-
-  for (Symbol<E> *sym : syms)
-    sym->value += delta;
-  r_deltas[rels.size()] += delta;
-
-  isec.sh_size += delta;
-}
-
-// RISC-V instructions are 16 or 32 bits long, so immediates encoded
-// in instructions can't be 32 bits long. Therefore, branch and load
-// instructions can't refer the 4 GiB address space unlike x86-64.
-// In fact, JAL (jump and link) instruction can jump to only within
-// ±1 MiB as their immediate is only 21 bits long.
-//
-// If you want to jump to somewhere further than that, you need to
-// construct a full 32-bit offset using multiple instruction and
-// branch to that place (e.g. AUIPC and JALR instead of JAL).
-// In this comment, we refer instructions such as JAL as the short
-// encoding and ones such as AUIPC+JALR as the long encoding.
-//
-// By default, compiler always uses the long encoding so that branch
-// targets are always encodable. This is a safe bet for them but
-// may result in inefficient code. Therefore, the RISC-V psABI defines
-// a mechanism for the linker to replace long encoding instructions
-// with short ones, shrinking the section and increasing the code
-// density.
-//
-// This is contrary to the psABIs for the other RISC processors such as
-// ARM64. Typically, they use short instructions by default, and a
-// linker creates so-called "thunks" to extend ranges of short jumps.
-// On RISC-V, instructions are in the long encoding by default, and
-// the linker shrinks them if it can.
-//
-// When we shrink a section, we need to adjust relocation offsets and
-// symbol values. For example, if we replace AUIPC+JALR with JAL
-// (which saves 4 bytes), all relocations pointing to anywhere after
-// that location need to be shifted by 4. In addition to that, any
-// symbol that refers anywhere after that locatioin need to be shifted
-// by 4 bytes as well.
-//
-// For relocations, we use `r_deltas` array to memorize how many bytes
-// have be adjusted. For symbols, we directly mutate their `value`
-// member.
-//
-// This operation seems to be optional, as by default instructions are
-// using the long encoding, but calling this function is actually
-// mandatory because of R_RISCV_ALIGN. R_RISCV_ALIGN relocation 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 satisfy the constraints imposed by R_RISCV_ALIGN
-// relocations.
-i64 riscv_resize_sections(Context<E> &ctx) {
-  Timer t(ctx, "riscv_resize_sections");
-  initialize_storage(ctx);
-
-  // Find R_RISCV_CALL AND R_RISCV_CALL_PLT 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()))
-        relax_section(ctx, *isec);
-  });
-
-  // Re-compute section offset again to finalize them.
-  compute_section_sizes(ctx);
-  return set_osec_offsets(ctx);
-}
-
-} // namespace mold::elf

elf/arch-s390x.cc

@@ -0,0 +1,492 @@
+// This file contains code for the IBM z/Architecture 64-bit ISA, which is
+// commonly referred to as "s390x" on Linux.
+//
+// z/Architecture is a 64-bit CISC ISA developed by IBM around 2000 for
+// IBM's "big iron" mainframe computers. The computers are direct
+// descendents of IBM System/360 all the way back in 1966. I've never
+// actually seen a mainframe, and you probaly haven't either, but it looks
+// like the mainframe market is still large enough to sustain its ecosystem.
+// Ubuntu for example provides the official support for s390x as of 2022.
+// Since they are being actively maintained, we need to support them.
+//
+// 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 an x86-64 in a parallel universe.
+//
+// Here is the register usage in this ABI:
+//
+//   r0-r1: reserved as scratch registers so we can use them in our PLT
+//   r2:    parameter passing and return values
+//   r3-r6: parameter passing
+//   r12:   address of GOT if position-independent code
+//   r14:   return address
+//   r15:   stack pointer
+//   a1:    upper 32 bits of TP (thread pointer)
+//   a2:    lower 32 bits of TP (thread pointer)
+//
+// 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/rui314/psabi/blob/main/s390x.pdf
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = S390X;
+
+static void write_mid20(u8 *loc, u64 val) {
+  *(ub32 *)loc |= (bits(val, 11, 0) << 16) | (bits(val, 19, 12) << 8);
+}
+
+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,             // nopr; nopr
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 26) =
+    (ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 24) >> 1;
+}
+
+template <>
+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)
+    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;
+}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static u8 insn[] = {
+    0xc0, 0x10, 0, 0, 0, 0,             // larl  %r1, GOT_ENTRY_OFFSET
+    0xe3, 0x10, 0x10, 0x00, 0x00, 0x04, // lg    %r1, (%r1)
+    0x07, 0xf1,                         // br    %r1
+    0x07, 0x00,                         // nopr
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 2) = (sym.get_got_addr(ctx) - sym.get_plt_addr(ctx)) >> 1;
+}
+
+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_390_PC32:
+    *(ub32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_390_64:
+    *(ub64 *)loc = val;
+    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;
+
+    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 check_dbl = [&](i64 val, i64 lo, i64 hi) {
+      check(val, lo, hi);
+
+      // R_390_*DBL relocs should never refer a symbol at an odd address
+      if (val & 1)
+        Error(ctx) << *this << ": misaligned symbol " << sym
+                   << " for relocation " << rel;
+    };
+
+    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;
+
+    switch (rel.r_type) {
+    case R_390_64:
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, &dynrel);
+      break;
+    case R_390_8:
+      check(S + A, 0, 1 << 8);
+      *loc = S + A;
+      break;
+    case R_390_12:
+      check(S + A, 0, 1 << 12);
+      *(ul16 *)loc |= bits(S + A, 11, 0);
+      break;
+    case R_390_16:
+      check(S + A, 0, 1 << 16);
+      *(ub16 *)loc = S + A;
+      break;
+    case R_390_20:
+      check(S + A, 0, 1 << 20);
+      write_mid20(loc, S + A);
+      break;
+    case R_390_32:
+    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:
+      check_dbl(S + A - P, -(1 << 12), 1 << 12);
+      *(ul16 *)loc |= bits(S + A - P, 12, 1);
+      break;
+    case R_390_PC16:
+      check(S + A - P, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = S + A - P;
+      break;
+    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:
+      check_dbl(S + A - P, -(1 << 16), 1 << 16);
+      *(ub16 *)loc = (S + A - P) >> 1;
+      break;
+    case R_390_PC24DBL:
+    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:
+      check_dbl(S + A - P, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = (S + A - P) >> 1;
+      break;
+    case R_390_GOT12:
+    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:
+      check(G + A, 0, 1 << 16);
+      *(ub16 *)loc = G + A;
+      break;
+    case R_390_GOT20:
+    case R_390_GOTPLT20:
+      check(G + A, 0, 1 << 20);
+      write_mid20(loc, G + A);
+      break;
+    case R_390_GOT32:
+    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:
+      check(S + A - GOT, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = S + A - GOT;
+      break;
+    case R_390_GOTOFF32:
+    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;
+      break;
+    case R_390_GOTPC:
+      *(ub64 *)loc = GOT + A - P;
+      break;
+    case R_390_GOTPCDBL:
+      check_dbl(GOT + A - P, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = (GOT + A - P) >> 1;
+      break;
+    case R_390_GOTENT:
+      check(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;
+    case R_390_TLS_LE64:
+      *(ub64 *)loc = S + A - ctx.tp_addr;
+      break;
+    case R_390_TLS_GOTIE20:
+      write_mid20(loc, sym.get_gottp_addr(ctx) + A - GOT);
+      break;
+    case R_390_TLS_IEENT:
+      *(ub32 *)loc = (sym.get_gottp_addr(ctx) + A - P) >> 1;
+      break;
+    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)) {
+        // 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;
+      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;
+      break;
+    case R_390_TLS_LDCALL:
+      if (!ctx.got->has_tlsld(ctx)) {
+        // nop
+        static u8 insn[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
+        memcpy(loc, insn, sizeof(insn));
+      }
+      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_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;
+      else
+        *(ub64 *)loc = S + A;
+      break;
+    case R_390_TLS_LDO64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ub64 *)loc = *val;
+      else
+        *(ub64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    default:
+      Fatal(ctx) << *this << ": apply_reloc_nonalloc: " << 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 || 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_390_64:
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_390_8:
+    case R_390_12:
+    case R_390_16:
+    case R_390_20:
+    case R_390_32:
+      scan_absrel(ctx, sym, rel);
+      break;
+    case R_390_PC16:
+    case R_390_PC16DBL:
+    case R_390_PC32:
+    case R_390_PC32DBL:
+    case R_390_PC64:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_390_GOT12:
+    case R_390_GOT16:
+    case R_390_GOT20:
+    case R_390_GOT32:
+    case R_390_GOT64:
+    case R_390_GOTOFF16:
+    case R_390_GOTOFF32:
+    case R_390_GOTOFF64:
+    case R_390_GOTPLT12:
+    case R_390_GOTPLT16:
+    case R_390_GOTPLT20:
+    case R_390_GOTPLT32:
+    case R_390_GOTPLT64:
+    case R_390_GOTPC:
+    case R_390_GOTPCDBL:
+    case R_390_GOTENT:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_390_PLT12DBL:
+    case R_390_PLT16DBL:
+    case R_390_PLT24DBL:
+    case R_390_PLT32:
+    case R_390_PLT32DBL:
+    case R_390_PLT64:
+    case R_390_PLTOFF16:
+    case R_390_PLTOFF32:
+    case R_390_PLTOFF64:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_390_TLS_GOTIE20:
+    case R_390_TLS_IEENT:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_390_TLS_GD32:
+    case R_390_TLS_GD64:
+      // 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.relax && sym.is_tprel_linktime_const(ctx)) ||
+          ctx.arg.is_static) {
+        // 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 (ctx.arg.is_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_TLS_LDO32:
+    case R_390_TLS_LDO64:
+    case R_390_TLS_GDCALL:
+    case R_390_TLS_LDCALL:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-sh4.cc

@@ -0,0 +1,354 @@
+// SH-4 (SuperH 4) is a 32-bit RISC ISA developed by Hitachi in the early
+// '90s. Some relatively powerful systems were developed with SH-4.
+// A notable example is Sega's Dreamcast game console which debuted in 1998.
+// Hitachi later spun off its semiconductor division as an independent
+// company, Renesas, and Renesas is still selling SH-4 processors for the
+// embedded market. It has never been as popular as ARM is, and its
+// popularity continues to decline though.
+//
+// SH-4's most distinctive feature compared to other RISC ISAs is that its
+// instructions are 16 bits in length instead of more common 32 bits for
+// better code density. This difference affects various aspects of its
+// instruction set as shown below:
+//
+//  - SH-4 has 16 general-purpose registers (GPRs) instead of the most
+//    commmon 32 GPR configuration to save one bit to specify a register.
+//
+//  - Binary instructions such as ADD normally take three register in
+//    RISC ISAs (e.g. x ← y ⊕ z where x, y and z are registers), but
+//    SH-4's instructions take only two registers. The result of an
+//    operation is written to one of the source registers (e.g. x ← x ⊕ y).
+//
+//  - Usual RISC ISAs have "load high" and "load low" instructions to set
+//    an immediate to most significant and least significant bits in a
+//    register to construct a full 32-bit value in a register. This
+//    technique is hard to use in SH-4, as 16 bit instructions are too
+//    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
+// a pipelined CPU to start and finish executing an instruction after a
+// branch regardless of the branch's condition, simplifying the processor's
+// implementation. It's considered a bad premature optimization nowadays,
+// though. Modern RISC processors don't have it.
+//
+// Here are notes about the SH-4 psABI:
+//
+//  - If a source file is compiled with -fPIC, each function starts
+//    with a piece of code to store the address of .got to %r12.
+//    We can use the register in our PLT for position-independent output.
+//
+//  - Even though it uses the RELA-type relocations, relocation addends
+//    are stored not to the r_addend field but to the relocated section
+//    contents for some reason. Therefore, it's effectively REL.
+//
+//  - It looks like the ecosystem has bit-rotted. Some tests, especially
+//    one using C++ exceptions, don't pass even with GNU ld.
+//
+//  - GCC/SH4 tends to write dynamically-relocated data into .text, so the
+//    output from the linker contains lots of text relocations. That's not
+//    a problem with embedded programming, I guess.
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = SH4;
+
+// Even though SH-4 uses RELA-type relocations, addends are stored to
+// relocated places for some reason.
+template <>
+i64 get_addend(u8 *loc, 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:
+    return *(ul32 *)loc;
+  default:
+    return 0;
+  }
+}
+
+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
+    };
+
+    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;
+  } 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
+    };
+
+    static_assert(sizeof(insn) == E::plt_hdr_size);
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(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
+    };
+
+    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>);
+  } 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
+    };
+
+    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>);
+  }
+}
+
+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
+    };
+
+    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;
+  } 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
+    };
+
+    static_assert(sizeof(insn) == E::pltgot_size);
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 8) = sym.get_got_addr(ctx);
+  }
+}
+
+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_SH_DIR32:
+    *(ul32 *)loc = val;
+    break;
+  case R_SH_REL32:
+    *(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 = get_addend(loc, rel);
+    u64 P = get_addr() + rel.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_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;
+      break;
+    case R_SH_GOT32:
+      *(ul32 *)loc = G;
+      break;
+    case R_SH_GOTPC:
+      *(ul32 *)loc = GOT + A - P;
+      break;
+    case R_SH_GOTOFF:
+      *(ul32 *)loc = S + A - GOT;
+      break;
+    case R_SH_TLS_GD_32:
+      *(ul32 *)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;
+      break;
+    case R_SH_TLS_LDO_32:
+      *(ul32 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_SH_TLS_IE_32:
+      *(ul32 *)loc = sym.get_gottp_addr(ctx) + A - GOT;
+      break;
+    case R_SH_TLS_LE_32:
+      *(ul32 *)loc = S + A - ctx.tp_addr;
+      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;
+
+    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 : get_addend(loc, rel);
+
+    switch (rel.r_type) {
+    case R_SH_DIR32:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ul32 *)loc = *val;
+      else
+        *(ul32 *)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 || record_undef_error(ctx, rel))
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    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 |= NEEDS_GOT;
+      break;
+    case R_SH_PLT32:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_SH_TLS_GD_32:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_SH_TLS_LD_32:
+      ctx.needs_tlsld = true;
+      break;
+    case R_SH_TLS_IE_32:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_SH_TLS_LE_32:
+      check_tlsle(ctx, sym, rel);
+      break;
+    case R_SH_GOTPC:
+    case R_SH_GOTOFF:
+    case R_SH_TLS_LDO_32:
+      break;
+    default:
+      Fatal(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-sparc64.cc

@@ -0,0 +1,618 @@
+// SPARC is a RISC ISA developed by Sun Microsystems.
+//
+// The byte order of the processor is big-endian. Anything larger than a
+// byte is stored in the "reverse" order compared to little-endian
+// processors such as x86-64.
+//
+// All instructions are 4 bytes long and aligned to 4 bytes boundaries.
+//
+// A notable feature of SPARC is that, unlike other RISC ISAs, it doesn't
+// need range extension thunks. It is because the SPARC's CALL instruction
+// contains a whopping 30 bits immediate. The processor scales it by 4 to
+// extend it to 32 bits (this is doable because all instructions are
+// aligned to 4 bytes boundaries, so the least significant two bits are
+// always zero). That means CALL's reach is PC ± 2 GiB, elinating the
+// need of range extension thunks. It comes with the cost that the CALL
+// instruction alone takes 1/4th of the instruction encoding space,
+// though.
+//
+// SPARC has 32 general purpose registers. CALL instruction saves a return
+// address to %o7, which is an alias for %r15. Thread pointer is stored to
+// %g7 which is %r7.
+//
+// SPARC does not have PC-relative load/store instructions. To access data
+// in the position-independent manner, we usually first set the address of
+// .got to, for example, %l7, with the following piece of code
+//
+//   sethi  %hi(. - _GLOBAL_OFFSET_TABLE_), %l7
+//   add  %l7, %lo(. - _GLOBAL_OFFSET_TABLE_), %l7
+//   call __sparc_get_pc_thunk.l7
+//   nop
+//
+// where __sparc_get_pc_thunk.l7 is defined as
+//
+//   retl
+//   add  %o7, %l7, %l7
+//
+// . SETHI and the following ADD materialize a 32 bits offset to .got.
+// CALL instruction sets a return address to $o7, and the subsequent ADD
+// adds it to the GOT offset to materialize the absolute address of .got.
+//
+// Note that we have a NOP after CALL and an ADD after RETL because of
+// SPARC's delay branch slots. That is, the SPARC processor always
+// executes one instruction after a branch even if the branch is taken.
+// This may seem like an odd behavior, and indeed it is considered as such
+// (that's a premature optimization for the early pipelined SPARC
+// processors), but that's been a part of the ISA's spec so that's what it
+// is.
+//
+// Note also that the .got address obtained this way is not shared between
+// functions, so functions can use an arbitrary register to hold the .got
+// address. That also means each function needs to execute the above piece
+// of code to become position-independent.
+//
+// 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://github.com/rui314/psabi/blob/main/sparc.pdf
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = SPARC64;
+
+// SPARC's PLT section is writable despite containing executable code.
+// We don't need to write the PLT header entry because the dynamic loader
+// will do that for us.
+//
+// We also don't need a .got.plt section to store the result of lazy PLT
+// symbol resolution because the dynamic symbol resolver directly mutates
+// instructions in PLT so that they jump to the right places next time.
+// That's why each PLT entry contains lots of NOPs; they are a placeholder
+// for the runtime to add more instructions.
+//
+// Self-modifying code is nowadays considered really bad from the security
+// point of view, though.
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  memset(buf, 0, E::plt_hdr_size);
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static ub32 insn[] = {
+    0x0300'0000, // sethi (. - .PLT0), %g1
+    0x3068'0000, // ba,a  %xcc, .PLT1
+    0x0100'0000, // nop
+    0x0100'0000, // nop
+    0x0100'0000, // nop
+    0x0100'0000, // nop
+    0x0100'0000, // nop
+    0x0100'0000, // nop
+  };
+
+  u64 plt0 = ctx.plt->shdr.sh_addr;
+  u64 plt1 = ctx.plt->shdr.sh_addr + E::plt_size;
+  u64 entry = sym.get_plt_addr(ctx);
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)buf |= bits(entry - plt0, 21, 0);
+  *(ub32 *)(buf + 4) |= bits(plt1 - entry - 4, 20, 2);
+}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  static ub32 entry[] = {
+    0x8a10'000f, // mov  %o7, %g5
+    0x4000'0002, // call . + 8
+    0xc25b'e014, // ldx  [ %o7 + 20 ], %g1
+    0xc25b'c001, // ldx  [ %o7 + %g1 ], %g1
+    0x81c0'4000, // jmp  %g1
+    0x9e10'0005, // mov  %g5, %o7
+    0x0000'0000, // .quad $plt_entry - $got_entry
+    0x0000'0000,
+  };
+
+  memcpy(buf, entry, sizeof(entry));
+  *(ub64 *)(buf + 24) = sym.get_got_addr(ctx) - sym.get_plt_addr(ctx) - 4;
+}
+
+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_SPARC_64:
+  case R_SPARC_UA64:
+    *(ub64 *)loc = val;
+    break;
+  case R_SPARC_DISP32:
+    *(ub32 *)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;
+
+    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;
+
+    switch (rel.r_type) {
+    case R_SPARC_64:
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, &dynrel);
+      break;
+    case R_SPARC_5:
+      check(S + A, 0, 1 << 5);
+      *(ub32 *)loc |= bits(S + A, 4, 0);
+      break;
+    case R_SPARC_6:
+      check(S + A, 0, 1 << 6);
+      *(ub32 *)loc |= bits(S + A, 5, 0);
+      break;
+    case R_SPARC_7:
+      check(S + A, 0, 1 << 7);
+      *(ub32 *)loc |= bits(S + A, 6, 0);
+      break;
+    case R_SPARC_8:
+      check(S + A, 0, 1 << 8);
+      *(u8 *)loc = S + A;
+      break;
+    case R_SPARC_10:
+      check(S + A, 0, 1 << 10);
+      *(ub32 *)loc |= bits(S + A, 9, 0);
+      break;
+    case R_SPARC_LO10:
+    case R_SPARC_LOPLT10:
+      *(ub32 *)loc |= bits(S + A, 9, 0);
+      break;
+    case R_SPARC_11:
+      check(S + A, 0, 1 << 11);
+      *(ub32 *)loc |= bits(S + A, 10, 0);
+      break;
+    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:
+      check(S + A, 0, 1 << 16);
+      *(ub16 *)loc = S + A;
+      break;
+    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:
+      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:
+      check(S + A - P, -(1 << 7), 1 << 7);
+      *(u8 *)loc = S + A - P;
+      break;
+    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:
+      check(S + A - P, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = S + A - P;
+      break;
+    case R_SPARC_DISP64:
+      *(ub64 *)loc = S + A - P;
+      break;
+    case R_SPARC_WDISP16: {
+      i64 val = S + A - P;
+      check(val, -(1 << 16), 1 << 16);
+      *(ub16 *)loc |= (bit(val, 16) << 21) | bits(val, 15, 2);
+      break;
+    }
+    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:
+      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:
+      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:
+      *(ub32 *)loc |= bits(S + A, 31, 10);
+      break;
+    case R_SPARC_GOT10:
+      *(ub32 *)loc |= bits(G, 9, 0);
+      break;
+    case R_SPARC_GOT13:
+      check(G, 0, 1 << 12);
+      *(ub32 *)loc |= bits(G, 12, 0);
+      break;
+    case R_SPARC_GOT22:
+      *(ub32 *)loc |= bits(G, 31, 10);
+      break;
+    case R_SPARC_GOTDATA_HIX22: {
+      i64 val = S + A - GOT;
+      *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
+      break;
+    }
+    case R_SPARC_GOTDATA_LOX10: {
+      i64 val = S + A - GOT;
+      *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
+      break;
+    }
+    case R_SPARC_GOTDATA_OP_HIX22:
+      // 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_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);
+      }
+      break;
+    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);
+      }
+      break;
+    case R_SPARC_GOTDATA_OP:
+      if (sym.is_absolute()) {
+        // ldx [ %g2 + %g1 ], %g1  →  nop
+        *(ub32 *)loc = 0x0100'0000;
+      } 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;
+      }
+      break;
+    case R_SPARC_PC10:
+    case R_SPARC_PCPLT10:
+      *(ub32 *)loc |= bits(S + A - P, 9, 0);
+      break;
+    case R_SPARC_PC22:
+    case R_SPARC_PCPLT22:
+    case R_SPARC_PC_LM22:
+      *(ub32 *)loc |= bits(S + A - P, 31, 10);
+      break;
+    case R_SPARC_OLO10:
+      *(ub32 *)loc |= bits(bits(S + A, 9, 0) + rel.r_type_data, 12, 0);
+      break;
+    case R_SPARC_HH22:
+      *(ub32 *)loc |= bits(S + A, 63, 42);
+      break;
+    case R_SPARC_HM10:
+      *(ub32 *)loc |= bits(S + A, 41, 32);
+      break;
+    case R_SPARC_PC_HH22:
+      *(ub32 *)loc |= bits(S + A - P, 63, 42);
+      break;
+    case R_SPARC_PC_HM10:
+      *(ub32 *)loc |= bits(S + A - P, 41, 32);
+      break;
+    case R_SPARC_HIX22:
+      *(ub32 *)loc |= bits(~(S + A), 31, 10);
+      break;
+    case R_SPARC_LOX10:
+      *(ub32 *)loc |= bits(S + A, 9, 0) | 0b1'1100'0000'0000;
+      break;
+    case R_SPARC_H44:
+      *(ub32 *)loc |= bits(S + A, 43, 22);
+      break;
+    case R_SPARC_M44:
+      *(ub32 *)loc |= bits(S + A, 21, 12);
+      break;
+    case R_SPARC_L44:
+      *(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);
+      break;
+    case R_SPARC_TLS_GD_LO10:
+      *(ub32 *)loc |= bits(sym.get_tlsgd_addr(ctx) + A - GOT, 9, 0);
+      break;
+    case R_SPARC_TLS_GD_CALL:
+    case R_SPARC_TLS_LDM_CALL: {
+      u64 addr;
+      if (ctx.arg.is_static)
+        addr = ctx.extra.tls_get_addr_sec->shdr.sh_addr;
+      else
+        addr = ctx.extra.tls_get_addr_sym->get_addr(ctx);
+
+      *(ub32 *)loc |= bits(addr + A - P, 31, 2);
+      break;
+    }
+    case R_SPARC_TLS_LDM_HI22:
+      *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 31, 10);
+      break;
+    case R_SPARC_TLS_LDM_LO10:
+      *(ub32 *)loc |= bits(ctx.got->get_tlsld_addr(ctx) + A - GOT, 9, 0);
+      break;
+    case R_SPARC_TLS_LDO_HIX22:
+      *(ub32 *)loc |= bits(S + A - ctx.dtp_addr, 31, 10);
+      break;
+    case R_SPARC_TLS_LDO_LOX10:
+      *(ub32 *)loc |= bits(S + A - ctx.dtp_addr, 9, 0);
+      break;
+    case R_SPARC_TLS_IE_HI22:
+      *(ub32 *)loc |= bits(sym.get_gottp_addr(ctx) + A - GOT, 31, 10);
+      break;
+    case R_SPARC_TLS_IE_LO10:
+      *(ub32 *)loc |= bits(sym.get_gottp_addr(ctx) + A - GOT, 9, 0);
+      break;
+    case R_SPARC_TLS_LE_HIX22:
+      *(ub32 *)loc |= bits(~(S + A - ctx.tp_addr), 31, 10);
+      break;
+    case R_SPARC_TLS_LE_LOX10:
+      *(ub32 *)loc |= bits(S + A - ctx.tp_addr, 9, 0) | 0b1'1100'0000'0000;
+      break;
+    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_TLS_LDO_ADD:
+    case R_SPARC_TLS_IE_LD:
+    case R_SPARC_TLS_IE_LDX:
+    case R_SPARC_TLS_IE_ADD:
+      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_SPARC_64:
+    case R_SPARC_UA64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(ub64 *)loc = *val;
+      else
+        *(ub64 *)loc = S + A;
+      break;
+    case R_SPARC_32:
+    case R_SPARC_UA32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_SPARC_TLS_DTPOFF32:
+      *(ub32 *)loc = S + A - ctx.dtp_addr;
+      break;
+    case R_SPARC_TLS_DTPOFF64:
+      *(ub64 *)loc = S + A - ctx.dtp_addr;
+      break;
+    default:
+      Fatal(ctx) << *this << ": apply_reloc_nonalloc: " << 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 || 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_SPARC_64:
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_SPARC_8:
+    case R_SPARC_5:
+    case R_SPARC_6:
+    case R_SPARC_7:
+    case R_SPARC_10:
+    case R_SPARC_11:
+    case R_SPARC_13:
+    case R_SPARC_16:
+    case R_SPARC_22:
+    case R_SPARC_32:
+    case R_SPARC_REGISTER:
+    case R_SPARC_UA16:
+    case R_SPARC_UA32:
+    case R_SPARC_UA64:
+    case R_SPARC_PC_HM10:
+    case R_SPARC_OLO10:
+    case R_SPARC_LOX10:
+    case R_SPARC_HM10:
+    case R_SPARC_M44:
+    case R_SPARC_HIX22:
+    case R_SPARC_LO10:
+    case R_SPARC_L44:
+    case R_SPARC_LM22:
+    case R_SPARC_HI22:
+    case R_SPARC_H44:
+    case R_SPARC_HH22:
+      scan_absrel(ctx, sym, rel);
+      break;
+    case R_SPARC_PLT32:
+    case R_SPARC_WPLT30:
+    case R_SPARC_WDISP30:
+    case R_SPARC_HIPLT22:
+    case R_SPARC_LOPLT10:
+    case R_SPARC_PCPLT32:
+    case R_SPARC_PCPLT22:
+    case R_SPARC_PCPLT10:
+    case R_SPARC_PLT64:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_PLT;
+      break;
+    case R_SPARC_GOT13:
+    case R_SPARC_GOT10:
+    case R_SPARC_GOT22:
+    case R_SPARC_GOTDATA_HIX22:
+      sym.flags |= NEEDS_GOT;
+      break;
+    case R_SPARC_GOTDATA_OP_HIX22:
+      if (sym.is_imported)
+        sym.flags |= NEEDS_GOT;
+      break;
+    case R_SPARC_DISP16:
+    case R_SPARC_DISP32:
+    case R_SPARC_DISP64:
+    case R_SPARC_DISP8:
+    case R_SPARC_PC10:
+    case R_SPARC_PC22:
+    case R_SPARC_PC_LM22:
+    case R_SPARC_WDISP16:
+    case R_SPARC_WDISP19:
+    case R_SPARC_WDISP22:
+    case R_SPARC_PC_HH22:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_SPARC_TLS_GD_HI22:
+      sym.flags |= NEEDS_TLSGD;
+      break;
+    case R_SPARC_TLS_LDM_HI22:
+      ctx.needs_tlsld = true;
+      break;
+    case R_SPARC_TLS_IE_HI22:
+      sym.flags |= NEEDS_GOTTP;
+      break;
+    case R_SPARC_TLS_GD_CALL:
+    case R_SPARC_TLS_LDM_CALL:
+      if (!ctx.arg.is_static)
+        if (Symbol<E> &sym = *ctx.extra.tls_get_addr_sym; 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_GOTDATA_OP_LOX10:
+    case R_SPARC_GOTDATA_OP:
+    case R_SPARC_GOTDATA_LOX10:
+    case R_SPARC_TLS_GD_LO10:
+    case R_SPARC_TLS_GD_ADD:
+    case R_SPARC_TLS_LDM_LO10:
+    case R_SPARC_TLS_LDM_ADD:
+    case R_SPARC_TLS_LDO_HIX22:
+    case R_SPARC_TLS_LDO_LOX10:
+    case R_SPARC_TLS_LDO_ADD:
+    case R_SPARC_TLS_IE_ADD:
+    case R_SPARC_TLS_IE_LD:
+    case R_SPARC_TLS_IE_LDX:
+    case R_SPARC_TLS_IE_LO10:
+    case R_SPARC_SIZE32:
+      break;
+    default:
+      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

elf/gc-sections.cc

@@ -10,73 +10,68 @@
 namespace mold::elf {
 
 template <typename E>
-static bool is_init_fini(const InputSection<E> &isec) {
+static bool should_keep(const InputSection<E> &isec) {
   u32 type = isec.shdr().sh_type;
+  u32 flags = isec.shdr().sh_flags;
   std::string_view name = isec.name();
 
-  return type == SHT_INIT_ARRAY ||
+  return (flags & SHF_GNU_RETAIN) ||
+         type == SHT_NOTE ||
+         type == SHT_INIT_ARRAY ||
          type == SHT_FINI_ARRAY ||
          type == SHT_PREINIT_ARRAY ||
-         (std::is_same_v<E, ARM32> && type == SHT_ARM_EXIDX) ||
+         (is_arm32<E> && type == SHT_ARM_EXIDX) ||
          name.starts_with(".ctors") ||
          name.starts_with(".dtors") ||
          name.starts_with(".init") ||
-         name.starts_with(".fini");
+         name.starts_with(".fini") ||
+         is_c_identifier(name);
 }
 
 template <typename E>
 static bool mark_section(InputSection<E> *isec) {
-  return isec && isec->is_alive && !isec->extra().is_visited.exchange(true);
+  return isec && isec->is_alive && !isec->is_visited.test_and_set();
 }
 
 template <typename E>
 static void visit(Context<E> &ctx, InputSection<E> *isec,
                   tbb::feeder<InputSection<E> *> &feeder, i64 depth) {
-  assert(isec->extra().is_visited);
-
-  // A relocation can refer either a section fragment (i.e. a piece of
-  // string in a mergeable string section) or a symbol. Mark all
-  // section fragments as alive.
-  if (SectionFragmentRef<E> *refs = isec->rel_fragments.get())
-    for (i64 i = 0; refs[i].idx >= 0; i++)
-      refs[i].frag->is_alive.store(true, std::memory_order_relaxed);
+  assert(isec->is_visited);
 
   // If this is a text section, .eh_frame may contain records
   // describing how to handle exceptions for that function.
   // We want to keep associated .eh_frame records.
   for (FdeRecord<E> &fde : isec->get_fdes())
-    for (ElfRel<E> &rel : fde.get_rels(isec->file).subspan(1))
+    for (const ElfRel<E> &rel : fde.get_rels(isec->file).subspan(1))
       if (Symbol<E> *sym = isec->file.symbols[rel.r_sym])
         if (mark_section(sym->get_input_section()))
           feeder.add(sym->get_input_section());
 
-  for (ElfRel<E> &rel : isec->get_rels(ctx)) {
+  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.
     // 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());
+    if (mark_section(sym.get_input_section())) {
+      if (depth < 3)
+        visit(ctx, sym.get_input_section(), feeder, depth + 1);
+      else
+        feeder.add(sym.get_input_section());
+    }
   }
 }
 
 template <typename E>
-static tbb::concurrent_vector<InputSection<E> *>
-collect_root_set(Context<E> &ctx) {
+static void collect_root_set(Context<E> &ctx,
+                             tbb::concurrent_vector<InputSection<E> *> &rootset) {
   Timer t(ctx, "collect_root_set");
-  tbb::concurrent_vector<InputSection<E> *> rootset;
 
   auto enqueue_section = [&](InputSection<E> *isec) {
     if (mark_section(isec))
@@ -86,7 +81,7 @@ collect_root_set(Context<E> &ctx) {
   auto enqueue_symbol = [&](Symbol<E> *sym) {
     if (sym) {
       if (SectionFragment<E> *frag = sym->get_frag())
-        frag->is_alive.store(true, std::memory_order_relaxed);
+        frag->is_alive = true;
       else
         enqueue_section(sym->get_input_section());
     }
@@ -98,15 +93,15 @@ collect_root_set(Context<E> &ctx) {
       if (!isec || !isec->is_alive)
         continue;
 
-      // -gc-sections discards only SHF_ALLOC sections. If you want to
+      // --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.
-      if (!(isec->shdr().sh_flags & SHF_ALLOC))
-        isec->extra().is_visited = true;
+      // --strip-all linker option.
+      u32 flags = isec->shdr().sh_flags;
+      if (!(flags & SHF_ALLOC))
+        isec->is_visited = true;
 
-      if (is_init_fini(*isec) || is_c_identifier(isec->name()) ||
-          isec->shdr().sh_type == SHT_NOTE)
+      if (should_keep(*isec))
         enqueue_section(isec.get());
     }
   });
@@ -132,11 +127,9 @@ collect_root_set(Context<E> &ctx) {
   // 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 (ElfRel<E> &rel : cie.get_rels())
+      for (const ElfRel<E> &rel : cie.get_rels())
         enqueue_symbol(file->symbols[rel.r_sym]);
   });
-
-  return rootset;
 }
 
 // Mark all reachable sections
@@ -159,7 +152,7 @@ static void sweep(Context<E> &ctx) {
 
   tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
     for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
-      if (isec && isec->is_alive && !isec->extra().is_visited) {
+      if (isec && isec->is_alive && !isec->is_visited) {
         if (ctx.arg.print_gc_sections)
           SyncOut(ctx) << "removing unused section " << *isec;
         isec->kill();
@@ -169,42 +162,18 @@ 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");
 
-  for (ObjectFile<E> *file : ctx.objs)
-    file->extras.resize(file->sections.size());
-
-  mark_nonalloc_fragments(ctx);
-
-  tbb::concurrent_vector<InputSection<E> *> rootset = collect_root_set(ctx);
+  tbb::concurrent_vector<InputSection<E> *> rootset;
+  collect_root_set(ctx, rootset);
   mark(ctx, rootset);
   sweep(ctx);
 }
 
-#define INSTANTIATE(E)                                  \
-  template void gc_sections(Context<E> &ctx);
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template void gc_sections(Context<E> &ctx);
 
 } // namespace mold::elf

elf/gdb-index.cc

@@ -0,0 +1,808 @@
+// 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::elf {
+
+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;
+  u32 hash;
+  u8 type;
+};
+
+struct MapValue {
+  std::string_view name;
+  u32 hash = 0;
+  Atomic<u32> count = 0;
+  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, gdb_hash(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, 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);
+  Atomic<i64> num_entries;
+
+  tbb::parallel_for_each(cus, [&](Compunit &cu) {
+    cu.entries.reserve(cu.nametypes.size());
+    i64 count = 0;
+
+    for (NameType &nt : cu.nametypes) {
+      MapValue *ent;
+      bool inserted;
+      MapValue value = {nt.name, nt.hash};
+      std::tie(ent, inserted) = map.insert(nt.name, nt.hash, value);
+      ent->count++;
+      if (inserted)
+        count++;
+      cu.entries.push_back(ent);
+    }
+    num_entries += count;
+  });
+
+  // Sort symbols for build reproducibility
+  std::vector<MapValue *> entries;
+  entries.reserve(num_entries);
+
+  for (i64 i = 0; i < map.nbuckets; i++)
+    if (map.entries[i].key)
+      entries.push_back(&map.entries[i].value);
+
+  tbb::parallel_sort(entries, [](MapValue *a, MapValue *b) {
+    return std::tuple(a->hash, a->name) < std::tuple(b->hash, b->name);
+  });
+
+  // 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(num_entries * 5 / 4 + 1);
+  hdr.const_pool_offset = hdr.symtab_offset + ht_size * 8;
+
+  i64 offset = 0;
+  for (MapValue *ent : entries) {
+    ent->type_offset = offset;
+    offset += ent->count * 4 + 4;
+  }
+
+  for (MapValue *ent : entries) {
+    ent->name_offset = offset;
+    offset += ent->name.size() + 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 (MapValue *ent : entries) {
+    u32 hash = ent->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->name_offset;
+    ht[j * 2 + 1] = ent->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, [&](MapValue *ent) {
+    write_string(buf + hdr.const_pool_offset + ent->name_offset, ent->name);
+  });
+
+  // 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::elf

elf/icf.cc

@@ -40,22 +40,35 @@
 // regular trees are equal. Given this formulation, we want to find as
 // many identical vertices as possible.
 //
-// Solving such problem is computationally intensive, but mold is quite fast.
-// For Chromium, mold's ICF finishes in less than 1 second with 20 threads.
-// This is contrary to lld and gold, which take about 5 and 50 seconds to
-// run ICF under the same condition, respectively.
+// Just like a lot of problems with graph, this problem doesn't have a
+// straightforward "optimal" solution, and we need to resort to heuristics.
 //
-// mold's ICF is faster because we are using a better algorithm.
-// It's actually me who developed and implemented the lld's ICF algorithm,
-// and I can say that mold's algorithm is better than that in all aspects.
-// It scales better for number of available cores, require less overall
-// computation, and has a smaller working set. So, it's better with a single
-// thread and even better with multiple threads.
+// mold approaches this problem by hashing program trees with increasing depth
+// on each iteration.
+// For example, when we start, we only hash individual functions with
+// their call into other functions omitted. From the second iteration, we
+// put the function they call into the hash by appending the hash of those
+// functions from the previous iteration. This means that the nth iteration
+// hashes call chain up to (n-1) levels deep.
+// We use a cryptographic hash function, so the unique number of hashes will
+// only monotonically increase as we take into account of deeper trees with
+// iterations (otherwise, that means we have found a hash collision). We stop
+// when the unique number of hashes stop increasing; this is based on the fact
+// that once we observe an iteration with the same amount of unique hashes as
+// the previous iteration, it will remain unchanged for further iterations.
+// This is provable, but here we omit the proof for brevity.
+//
+// When compared to other approaches, mold's approach has a relatively cheaper
+// cost per iteration, and as a bonus, is highly parallelizable.
+// For Chromium, mold's ICF finishes in less than 1 second with 20 threads,
+// whereas lld takes 5 seconds and gold takes 50 seconds under the same
+// conditions.
 
 #include "mold.h"
-#include "../sha.h"
+#include "blake3.h"
 
 #include <array>
+#include <cstdio>
 #include <tbb/concurrent_unordered_map.h>
 #include <tbb/concurrent_vector.h>
 #include <tbb/enumerable_thread_specific.h>
@@ -68,7 +81,7 @@ static constexpr int64_t HASH_SIZE = 16;
 typedef std::array<uint8_t, HASH_SIZE> Digest;
 
 namespace std {
-template<> struct hash<Digest> {
+template <> struct hash<Digest> {
   size_t operator()(const Digest &k) const {
     return *(int64_t *)&k[0];
   }
@@ -98,29 +111,30 @@ static void uniquify_cies(Context<E> &ctx) {
 }
 
 template <typename E>
-static bool is_eligible(InputSection<E> &isec) {
+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_executable = (shdr.sh_flags & SHF_EXECINSTR);
-  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);
+  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_executable && is_readonly && !is_bss &&
-         !is_empty && !is_init && !is_fini && !is_enumerable;
+  if (shdr.sh_flags & SHF_EXECINSTR) {
+    return (ctx.arg.icf_all || !isec.address_taken) &&
+           name != ".init" && name != ".fini";
+  } else {
+    bool is_readonly = !(shdr.sh_flags & SHF_WRITE);
+    bool is_relro = isec.output_section && isec.output_section->is_relro;
+    return (ctx.arg.ignore_data_address_equality || !isec.address_taken) &&
+           (is_readonly || is_relro);
+  }
 }
 
-static Digest digest_final(SHA256_CTX &sha) {
-  u8 buf[SHA256_SIZE];
-  int res = SHA256_Final(buf, &sha);
-  assert(res == 1);
+static Digest digest_final(blake3_hasher *hasher) {
+  assert(HASH_SIZE <= BLAKE3_OUT_LEN);
+
+  u8 buf[BLAKE3_OUT_LEN];
+  blake3_hasher_finalize(hasher, buf, BLAKE3_OUT_LEN);
 
   Digest digest;
   memcpy(digest.data(), buf, HASH_SIZE);
@@ -139,10 +153,6 @@ static bool is_leaf(Context<E> &ctx, InputSection<E> &isec) {
   return true;
 }
 
-static u64 combine_hash(u64 a, u64 b) {
-  return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
-}
-
 template <typename E>
 struct LeafHasher {
   size_t operator()(InputSection<E> *isec) const {
@@ -175,6 +185,8 @@ struct LeafEq {
   }
 };
 
+// Early merge of leaf nodes, which can be processed without constructing the
+// entire graph. This reduces the vertex count and improves memory efficiency.
 template <typename E>
 static void merge_leaf_nodes(Context<E> &ctx) {
   Timer t(ctx, "merge_leaf_nodes");
@@ -191,30 +203,30 @@ static void merge_leaf_nodes(Context<E> &ctx) {
       if (!isec || !isec->is_alive)
         continue;
 
-      if (!is_eligible(*isec)) {
+      if (!is_eligible(ctx, *isec)) {
         non_eligible++;
         continue;
       }
 
       if (is_leaf(ctx, *isec)) {
         leaf++;
-        isec->extra().icf_leaf = true;
+        isec->icf_leaf = true;
         auto [it, inserted] = map.insert({isec.get(), isec.get()});
         if (!inserted && isec->get_priority() < it->second->get_priority())
           it->second = isec.get();
       } else {
         eligible++;
-        isec->extra().icf_eligible = true;
+        isec->icf_eligible = true;
       }
     }
   });
 
   tbb::parallel_for((i64)0, (i64)ctx.objs.size(), [&](i64 i) {
     for (std::unique_ptr<InputSection<E>> &isec : ctx.objs[i]->sections) {
-      if (isec && isec->is_alive && isec->extra().icf_leaf) {
+      if (isec && isec->is_alive && isec->icf_leaf) {
         auto it = map.find(isec.get());
         assert(it != map.end());
-        isec->extra().leader = it->second;
+        isec->leader = it->second;
       }
     }
   });
@@ -222,16 +234,16 @@ static void merge_leaf_nodes(Context<E> &ctx) {
 
 template <typename E>
 static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
-  SHA256_CTX sha;
-  SHA256_Init(&sha);
+  blake3_hasher hasher;
+  blake3_hasher_init(&hasher);
 
   auto hash = [&](auto val) {
-    SHA256_Update(&sha, &val, sizeof(val));
+    blake3_hasher_update(&hasher, (u8 *)&val, sizeof(val));
   };
 
   auto hash_string = [&](std::string_view str) {
     hash(str.size());
-    SHA256_Update(&sha, str.data(), str.size());
+    blake3_hasher_update(&hasher, (u8 *)str.data(), str.size());
   };
 
   auto hash_symbol = [&](Symbol<E> &sym) {
@@ -245,10 +257,10 @@ static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
       hash((u64)frag);
     } else if (!isec) {
       hash('3');
-    } else if (isec->extra().leader) {
+    } else if (isec->leader) {
       hash('4');
-      hash((u64)isec->extra().leader);
-    } else if (isec->extra().icf_eligible) {
+      hash((u64)isec->leader);
+    } else if (isec->icf_eligible) {
       hash('5');
     } else {
       hash('6');
@@ -271,33 +283,23 @@ static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
 
     hash(fde.get_rels(isec.file).size());
 
-    for (ElfRel<E> &rel : fde.get_rels(isec.file).subspan(1)) {
+    for (const ElfRel<E> &rel : fde.get_rels(isec.file).subspan(1)) {
       hash_symbol(*isec.file.symbols[rel.r_sym]);
       hash(rel.r_type);
       hash(rel.r_offset - fde.input_offset);
-      hash(isec.file.cies[fde.cie_idx].input_section.get_addend(rel));
+      hash(get_addend(isec.file.cies[fde.cie_idx].input_section, rel));
     }
   }
 
-  i64 frag_idx = 0;
-
   for (i64 i = 0; i < isec.get_rels(ctx).size(); i++) {
-    ElfRel<E> &rel = isec.get_rels(ctx)[i];
+    const ElfRel<E> &rel = isec.get_rels(ctx)[i];
     hash(rel.r_offset);
     hash(rel.r_type);
-    hash(isec.get_addend(rel));
-
-    if (isec.rel_fragments && isec.rel_fragments[frag_idx].idx == i) {
-      SectionFragmentRef<E> &ref = isec.rel_fragments[frag_idx++];
-      hash('a');
-      isec.get_addend(rel);
-      hash((u64)ref.frag);
-    } else {
-      hash_symbol(*isec.file.symbols[rel.r_sym]);
-    }
+    hash(get_addend(isec, rel));
+    hash_symbol(*isec.file.symbols[rel.r_sym]);
   }
 
-  return digest_final(sha);
+  return digest_final(&hasher);
 }
 
 template <typename E>
@@ -309,7 +311,7 @@ static std::vector<InputSection<E> *> gather_sections(Context<E> &ctx) {
 
   tbb::parallel_for((i64)0, (i64)ctx.objs.size(), [&](i64 i) {
     for (std::unique_ptr<InputSection<E>> &isec : ctx.objs[i]->sections)
-      if (isec && isec->is_alive && isec->extra().icf_eligible)
+      if (isec && isec->is_alive && isec->icf_eligible)
         num_sections[i]++;
   });
 
@@ -324,12 +326,12 @@ static std::vector<InputSection<E> *> gather_sections(Context<E> &ctx) {
   tbb::parallel_for((i64)0, (i64)ctx.objs.size(), [&](i64 i) {
     i64 idx = section_indices[i];
     for (std::unique_ptr<InputSection<E>> &isec : ctx.objs[i]->sections)
-      if (isec && isec->is_alive && isec->extra().icf_eligible)
+      if (isec && isec->is_alive && isec->icf_eligible)
         sections[idx++] = isec.get();
   });
 
   tbb::parallel_for((i64)0, (i64)sections.size(), [&](i64 i) {
-    sections[i]->extra().icf_idx = i;
+    sections[i]->icf_idx = i;
   });
 
   return sections;
@@ -347,6 +349,9 @@ compute_digests(Context<E> &ctx, std::span<InputSection<E> *> sections) {
   return digests;
 }
 
+// Build a graph, treating every function as a vertex and every function call
+// as an edge. See the description at the top for a more detailed formulation.
+// We use u32 indices here to improve cache locality.
 template <typename E>
 static void gather_edges(Context<E> &ctx,
                          std::span<InputSection<E> *> sections,
@@ -362,20 +367,15 @@ static void gather_edges(Context<E> &ctx,
 
   tbb::parallel_for((i64)0, (i64)sections.size(), [&](i64 i) {
     InputSection<E> &isec = *sections[i];
-    assert(isec.extra().icf_eligible);
-    i64 frag_idx = 0;
+    assert(isec.icf_eligible);
 
     for (i64 j = 0; j < isec.get_rels(ctx).size(); j++) {
-      if (isec.rel_fragments && isec.rel_fragments[frag_idx].idx == j) {
-        frag_idx++;
-      } else {
-        ElfRel<E> &rel = isec.get_rels(ctx)[j];
-        Symbol<E> &sym = *isec.file.symbols[rel.r_sym];
-        if (!sym.get_frag())
-          if (InputSection<E> *isec = sym.get_input_section())
-            if (isec->extra().icf_eligible)
-              num_edges[i]++;
-      }
+      const ElfRel<E> &rel = isec.get_rels(ctx)[j];
+      Symbol<E> &sym = *isec.file.symbols[rel.r_sym];
+      if (!sym.get_frag())
+        if (InputSection<E> *isec = sym.get_input_section())
+          if (isec->icf_eligible)
+            num_edges[i]++;
     }
   });
 
@@ -386,27 +386,22 @@ static void gather_edges(Context<E> &ctx,
 
   tbb::parallel_for((i64)0, (i64)num_edges.size(), [&](i64 i) {
     InputSection<E> &isec = *sections[i];
-    i64 frag_idx = 0;
     i64 idx = edge_indices[i];
 
-    for (i64 j = 0; j < isec.get_rels(ctx).size(); j++) {
-      if (isec.rel_fragments && isec.rel_fragments[frag_idx].idx == j) {
-        frag_idx++;
-        ElfRel<E> &rel = isec.get_rels(ctx)[j];
-        Symbol<E> &sym = *isec.file.symbols[rel.r_sym];
-        if (!sym.get_frag())
-          if (InputSection<E> *isec = sym.get_input_section())
-            if (isec->extra().icf_eligible)
-              edges[idx++] = isec->extra().icf_idx;
-      }
-    }
+    for (ElfRel<E> &rel : isec.get_rels(ctx)) {
+      Symbol<E> &sym = *isec.file.symbols[rel.r_sym];
+      if (InputSection<E> *isec = sym.get_input_section())
+        if (isec->icf_eligible)
+          edges[idx++] = isec->icf_idx;
+  }
   });
 }
 
 template <typename E>
 static i64 propagate(std::span<std::vector<Digest>> digests,
                      std::span<u32> edges, std::span<u32> edge_indices,
-                     bool &slot, tbb::affinity_partitioner &ap) {
+                     bool &slot, BitVector &converged,
+                     tbb::affinity_partitioner &ap) {
   static Counter round("icf_round");
   round++;
 
@@ -414,23 +409,28 @@ 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 (digests[slot][i] == digests[!slot][i])
+    if (converged.get(i))
       return;
 
-    SHA256_CTX sha;
-    SHA256_Init(&sha);
-    SHA256_Update(&sha, digests[2][i].data(), HASH_SIZE);
+    blake3_hasher hasher;
+    blake3_hasher_init(&hasher);
+    blake3_hasher_update(&hasher, 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))
-      SHA256_Update(&sha, digests[slot][j].data(), HASH_SIZE);
+      blake3_hasher_update(&hasher, digests[slot][j].data(), HASH_SIZE);
 
-    digests[!slot][i] = digest_final(sha);
+    digests[!slot][i] = digest_final(&hasher);
 
-    if (digests[slot][i] != digests[!slot][i])
+    if (digests[slot][i] == digests[!slot][i]) {
+      // This node has converged. Skip further iterations as it will
+      // yield the same hash.
+      converged.set(i);
+    } else {
       changed.local()++;
+    }
   }, ap);
 
   slot = !slot;
@@ -458,11 +458,11 @@ static void print_icf_sections(Context<E> &ctx) {
 
   tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
     for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
-      if (isec && isec->is_alive && isec->extra().leader) {
-        if (isec.get() == isec->extra().leader)
+      if (isec && isec->is_alive && isec->leader) {
+        if (isec.get() == isec->leader)
           leaders.push_back(isec.get());
         else
-          map.insert({isec->extra().leader, isec.get()});
+          map.insert({isec->leader, isec.get()});
       }
     }
   });
@@ -495,9 +495,8 @@ static void print_icf_sections(Context<E> &ctx) {
 template <typename E>
 void icf_sections(Context<E> &ctx) {
   Timer t(ctx, "icf");
-
-  for (ObjectFile<E> *file : ctx.objs)
-    file->extras.resize(file->sections.size());
+  if (ctx.objs.empty())
+    return;
 
   uniquify_cies(ctx);
   merge_leaf_nodes(ctx);
@@ -505,6 +504,15 @@ void icf_sections(Context<E> &ctx) {
   // Prepare for the propagation rounds.
   std::vector<InputSection<E> *> sections = gather_sections(ctx);
 
+  // We allocate 3 arrays to store hashes for each vertex.
+  //
+  // Index 0 and 1 are used for tree hashes from the previous
+  // iteration and the current iteration. They switch roles every
+  // iteration. See `slot` below.
+  //
+  // Index 2 stores the initial, single-vertex hash. This is combined
+  // with hashes from the connected vertices to form the tree hash
+  // described above.
   std::vector<std::vector<Digest>> digests(3);
   digests[0] = compute_digests<E>(ctx, sections);
   digests[1].resize(digests[0].size());
@@ -514,6 +522,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());
   bool slot = 0;
 
   // Execute the propagation rounds until convergence is obtained.
@@ -521,18 +530,33 @@ void icf_sections(Context<E> &ctx) {
     Timer t(ctx, "propagate");
     tbb::affinity_partitioner ap;
 
+    // A cheap test that the graph hasn't converged yet.
+    // The loop after this one uses a strict condition, but it's expensive
+    // as it requires sorting the entire hash collection.
+    //
+    // For nodes that have a cycle in downstream (i.e. recursive
+    // functions and functions that calls recursive functions) will always
+    // change with the iterations. Nodes that doesn't (i.e. non-recursive
+    // functions) will stop changing as soon as the propagation depth reaches
+    // the call tree depth.
+    // Here, we test whether we have reached sufficient depth for the latter,
+    // which is a necessary (but not sufficient) condition for convergence.
     i64 num_changed = -1;
     for (;;) {
-      i64 n = propagate<E>(digests, edges, edge_indices, slot, ap);
+      i64 n = propagate<E>(digests, edges, edge_indices, slot, converged, ap);
       if (n == num_changed)
         break;
       num_changed = n;
     }
 
+    // Run the pass until the unique number of hashes stop increasing, at which
+    // point we have achieved convergence (proof omitted for brevity).
     i64 num_classes = -1;
     for (;;) {
+      // count_num_classes requires sorting which is O(n log n), so do a little
+      // more work beforehand to amortize that log factor.
       for (i64 i = 0; i < 10; i++)
-        propagate<E>(digests, edges, edge_indices, slot, ap);
+        propagate<E>(digests, edges, edge_indices, slot, converged, ap);
 
       i64 n = count_num_classes<E>(digests[slot], ap);
       if (n == num_classes)
@@ -541,7 +565,7 @@ void icf_sections(Context<E> &ctx) {
     }
   }
 
-  // Group sections by SHA digest.
+  // Group sections by BLAKE3 digest.
   {
     Timer t(ctx, "group");
 
@@ -558,7 +582,7 @@ void icf_sections(Context<E> &ctx) {
     tbb::parallel_for((i64)0, (i64)sections.size(), [&](i64 i) {
       auto it = map->find(digest[i]);
       assert(it != map->end());
-      sections[i]->extra().leader = it->second;
+      sections[i]->leader = it->second;
     });
 
     // Since free'ing the map is slow, postpone it.
@@ -568,30 +592,25 @@ void icf_sections(Context<E> &ctx) {
   if (ctx.arg.print_icf_sections)
     print_icf_sections(ctx);
 
-  // Re-assign input sections to symbols.
+  // Eliminate duplicate sections.
+  // Symbols pointing to eliminated sections will be redirected on the fly when
+  // exporting to the symtab.
   {
-    Timer t(ctx, "reassign");
+    Timer t(ctx, "sweep");
+    static Counter eliminated("icf_eliminated");
     tbb::parallel_for_each(ctx.objs, [](ObjectFile<E> *file) {
-      for (Symbol<E> *sym : file->symbols) {
-        if (sym->file == file) {
-          InputSection<E> *isec = sym->get_input_section();
-          if (isec && isec->extra().leader && isec->extra().leader != isec) {
-            isec->kill();
-            isec->killed_by_icf = true;
-          }
+      for (std::unique_ptr<InputSection<E>> &isec : file->sections) {
+        if (isec && isec->is_alive && isec->is_killed_by_icf()) {
+          isec->kill();
+          eliminated++;
         }
       }
     });
   }
 }
 
-#define INSTANTIATE(E)                          \
-  template void icf_sections(Context<E> &ctx);
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template void icf_sections(Context<E> &ctx);
 
 } // namespace mold::elf

elf/input-sections.cc

@@ -2,16 +2,21 @@
 
 #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<ElfRel<E>> x = get_rels();
-  std::span<ElfRel<E>> y = other.get_rels();
+  std::span<const ElfRel<E>> x = get_rels();
+  std::span<const ElfRel<E>> y = other.get_rels();
   if (x.size() != y.size())
     return false;
 
@@ -19,93 +24,202 @@ bool CieRecord<E>::equals(const CieRecord<E> &other) const {
     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] ||
-        input_section.get_addend(x[i]) != other.input_section.get_addend(y[i]))
+        get_addend(input_section, x[i]) != get_addend(other.input_section, y[i]))
       return false;
   }
   return true;
 }
 
-static inline i64 to_p2align(u64 alignment) {
+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)
+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, shdr().sh_size};
+    contents = {(char *)file.mf->data + shdr().sh_offset, (size_t)shdr().sh_size};
 
-  bool compressed;
-
-  if (name.starts_with(".zdebug")) {
-    sh_size = *(ubig64 *)&contents[4];
-    p2align = to_p2align(shdr().sh_addralign);
-    compressed = true;
-  } else if (shdr().sh_flags & SHF_COMPRESSED) {
+  if (shdr().sh_flags & SHF_COMPRESSED) {
     ElfChdr<E> &chdr = *(ElfChdr<E> *)&contents[0];
     sh_size = chdr.ch_size;
     p2align = to_p2align(chdr.ch_addralign);
-    compressed = true;
   } else {
     sh_size = shdr().sh_size;
     p2align = to_p2align(shdr().sh_addralign);
-    compressed = false;
   }
 
-  // Uncompress early if the relocation is REL-type so that we can read
-  // addends from section contents. If RELA-type, we don't need to do this
-  // because addends are in relocations.
-  if (compressed && E::is_rel) {
-    u8 *buf = new u8[sh_size];
-    uncompress(ctx, buf);
-    contents = {(char *)buf, sh_size};
-    ctx.string_pool.emplace_back(buf);
-  }
-
-  output_section =
-    OutputSection<E>::get_instance(ctx, name, shdr().sh_type, shdr().sh_flags);
+  // 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>
-bool InputSection<E>::is_compressed() {
-  return !E::is_rel &&
-         (name().starts_with(".zdebug") || (shdr().sh_flags & SHF_COMPRESSED));
+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(Context<E> &ctx, u8 *buf) {
-  auto do_uncompress = [&](std::string_view data) {
-    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);
-  };
-
-  if (name().starts_with(".zdebug")) {
-    // Old-style compressed section
-    if (!contents.starts_with("ZLIB") || contents.size() <= 12)
-      Fatal(ctx) << *this << ": corrupted compressed section";
-    do_uncompress(contents.substr(12));
+void InputSection<E>::uncompress_to(Context<E> &ctx, u8 *buf) {
+  if (!(shdr().sh_flags & SHF_COMPRESSED) || uncompressed) {
+    memcpy(buf, contents.data(), contents.size());
     return;
   }
 
-  assert(shdr().sh_flags & SHF_COMPRESSED);
-
-  // New-style compressed section
   if (contents.size() < sizeof(ElfChdr<E>))
     Fatal(ctx) << *this << ": corrupted compressed section";
 
   ElfChdr<E> &hdr = *(ElfChdr<E> *)&contents[0];
-  if (hdr.ch_type != ELFCOMPRESS_ZLIB)
-    Fatal(ctx) << *this << ": unsupported compression type";
-  do_uncompress(contents.substr(sizeof(ElfChdr<E>)));
+  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 i64 get_output_type(Context<E> &ctx) {
+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:
+    // Print out the "recompile with -fPIC" error message.
+    error();
+    break;
+  case COPYREL:
+    // Create a copy relocation.
+    if (!ctx.arg.z_copyreloc)
+      error();
+    copyrel();
+    break;
+  case DYN_COPYREL:
+    // Same as COPYREL but try to avoid creating a copy relocation by
+    // creating a dynamic relocation instead if the relocation is in
+    // a writable section.
+    //
+    // GHC (Glasgow Haskell Compiler) places a small amount of data in
+    // .text before each function and access that data with a fixed
+    // offset. The function breaks if we copy-relocate the data. For such
+    // programs, we should avoid copy relocations if possible.
+    //
+    // Besides GHC, copy relocation is a hacky solution, so if we can
+    // represent a relocation either with copyrel or dynrel, we prefer
+    // dynamic relocation.
+    if (writable || !ctx.arg.z_copyreloc)
+      dynrel();
+    else
+      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;
+  case DYN_CPLT:
+    // Same as CPLT but try to avoid creating a canonical PLT creating by
+    // creating a dynamic relocation instead if the relocation is in a
+    // writable section. The motivation behind it is hte same as DYN_COPYREL.
+    if (writable)
+      dynrel();
+    else
+      sym.flags |= NEEDS_CPLT;
+    break;
+  case DYNREL:
+    // Create a dynamic relocation.
+    dynrel();
+    break;
+  case BASEREL:
+    // Create a base relocation.
+    check_textrel();
+    if (!isec.is_relr_reloc(ctx, rel))
+      isec.file.num_dynrel++;
+    break;
+  case IFUNC:
+    // Create an IRELATIVE relocation for a GNU ifunc symbol.
+    //
+    // We usually create an IRELATIVE relocation in .got for each ifunc.
+    // However, if a statically-initialized pointer is initialized to an
+    // ifunc's address, we have no choice other than emitting an IRELATIVE
+    // relocation for each such pointer.
+    dynrel();
+    ctx.num_ifunc_dynrels++;
+    break;
+  default:
+    unreachable();
+  }
+}
+
+template <typename E>
+static inline i64 get_output_type(Context<E> &ctx) {
   if (ctx.arg.shared)
     return 0;
   if (ctx.arg.pie)
@@ -114,7 +228,7 @@ static i64 get_output_type(Context<E> &ctx) {
 }
 
 template <typename E>
-static i64 get_sym_type(Symbol<E> &sym) {
+static inline i64 get_sym_type(Symbol<E> &sym) {
   if (sym.is_absolute())
     return 0;
   if (!sym.is_imported)
@@ -125,134 +239,316 @@ static i64 get_sym_type(Symbol<E> &sym) {
 }
 
 template <typename E>
-void InputSection<E>::dispatch(Context<E> &ctx, Action table[3][4], i64 i,
-                               const ElfRel<E> &rel, Symbol<E> &sym) {
-  Action action = table[get_output_type(ctx)][get_sym_type(sym)];
-  bool is_writable = (shdr().sh_flags & SHF_WRITE);
-
-  auto error = [&] {
-    std::string msg = sym.is_absolute() ? "-fno-PIC" : "-fPIC";
-    Error(ctx) << *this << ": " << rel << " relocation at offset 0x"
-               << std::hex << rel.r_offset << " against symbol `"
-               << sym << "' can not be used; recompile with " << msg;
+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.
+  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
   };
 
-  auto warn_textrel = [&] {
-    if (ctx.arg.warn_textrel)
-      Warn(ctx) << *this << ": relocation against symbol `" << sym
-                << "' in read-only section";
+  return table[get_output_type(ctx)][get_sym_type(sym)];
+}
+
+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 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[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 table[get_output_type(ctx)][get_sym_type(sym)];
+}
+
+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 pointer
+  // 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.
+  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 table[get_output_type(ctx)][get_sym_type(sym)];
+}
+
+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.
+  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 table[get_output_type(ctx)][get_sym_type(sym)];
+}
+
+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>
+void InputSection<E>::scan_tlsdesc(Context<E> &ctx, Symbol<E> &sym) {
+  if (ctx.arg.is_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>
+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 emit_abs_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 NONE:
-    return;
-  case ERROR:
-    error();
-    return;
   case COPYREL:
-    if (!ctx.arg.z_copyreloc) {
-      error();
-      return;
-    }
-
-    if (sym.esym().st_visibility == STV_PROTECTED) {
-      Error(ctx) << *this
-                 << ": cannot make copy relocation for protected symbol '"
-                 << sym << "', defined in " << *sym.file
-                 << "; recompile with -fPIC";
-      return;
-    }
-
-    sym.flags |= NEEDS_COPYREL;
-    return;
-  case PLT:
-    sym.flags |= NEEDS_PLT;
-    return;
-  case CPLT: {
-    std::scoped_lock lock(sym.mu);
-    sym.flags |= NEEDS_PLT;
-    sym.is_canonical = true;
-    return;
-  }
-  case DYNREL:
-    if (!is_writable) {
-      if (ctx.arg.z_text) {
-        error();
-        return;
-      }
-      warn_textrel();
-      ctx.has_textrel = true;
-    }
-
-    assert(sym.is_imported);
-    file.num_dynrel++;
-    return;
+  case CPLT:
+  case NONE:
+    *(Word<E> *)loc = S + A;
+    break;
   case BASEREL:
-    if (!is_writable) {
-      if (ctx.arg.z_text) {
-        error();
-        return;
-      }
-      warn_textrel();
-      ctx.has_textrel = true;
+    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;
     }
-
-    if (!is_relr_reloc(ctx, rel))
-      file.num_dynrel++;
-    return;
+    break;
+  case DYN_COPYREL:
+    if (writable || !ctx.arg.z_copyreloc)
+      emit_abs_dynrel();
+    else
+      *(Word<E> *)loc = S + A;
+    break;
+  case DYN_CPLT:
+    if (writable)
+      emit_abs_dynrel();
+    else
+      *(Word<E> *)loc = S + A;
+    break;
+  case DYNREL:
+    emit_abs_dynrel();
+    break;
+  case IFUNC:
+    if constexpr (supports_ifunc<E>) {
+      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;
+    } else {
+      unreachable();
+    }
+    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 (std::is_same_v<E, RISCV64>) {
+  if constexpr (is_riscv<E>)
     copy_contents_riscv(ctx, buf);
-  } else if (is_compressed()) {
-    uncompress(ctx, buf);
-  } else {
-    memcpy(buf, contents.data(), contents.size());
-  }
+  else
+    uncompress_to(ctx, buf);
 
   // Apply relocations
-  if (shdr().sh_flags & SHF_ALLOC)
-    apply_reloc_alloc(ctx, buf);
-  else
-    apply_reloc_nonalloc(ctx, buf);
-}
+  if (!ctx.arg.relocatable) {
+    if (shdr().sh_flags & SHF_ALLOC)
+      apply_reloc_alloc(ctx, buf);
+    else
+      apply_reloc_nonalloc(ctx, buf);
 
-template <typename E>
-void report_undef(Context<E> &ctx, InputFile<E> &file, Symbol<E> &sym) {
-  if (ctx.arg.warn_once && !ctx.warned.insert({(void *)&sym, 1}))
-    return;
-
-  switch (ctx.arg.unresolved_symbols) {
-  case UNRESOLVED_ERROR:
-    Error(ctx) << "undefined symbol: " << file << ": " << sym;
-    break;
-  case UNRESOLVED_WARN:
-    Warn(ctx) << "undefined symbol: " << file << ": " << sym;
-    break;
-  case UNRESOLVED_IGNORE:
-    break;
+    if constexpr (is_x86_64<E>) {
+      if (ctx.arg.z_rewrite_endbr) {
+        // Rewrite the leading endbr instruction with a nop if the section
+        // is not address-taken.
+        u8 endbr[] = {0xf3, 0x0f, 0x1e, 0xfa};
+        u8 nop[] = {0x0f, 0x1f, 0x40, 0x00};
+        if (!address_taken && (shdr().sh_flags & SHF_EXECINSTR) &&
+            sh_size >= 4 && memcmp(buf, endbr, 4) == 0)
+          memcpy(buf, nop, 4);
+      }
+    }
   }
 }
 
-#define INSTANTIATE(E)                                                  \
-  template struct CieRecord<E>;                                         \
-  template class InputSection<E>;                                       \
-  template void report_undef(Context<E> &, InputFile<E> &, Symbol<E> &)
+// 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 (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 "";
+}
 
+// 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;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+  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 << ")";
+
+    typename decltype(ctx.undef_errors)::accessor acc;
+    ctx.undef_errors.insert(acc, {sym.name(), {}});
+    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, it's an
+  // undefined symbol error.
+  //
+  // 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 (!sym.is_imported && is_undef && sym.esym().is_undef()) {
+    record();
+    return true;
+  }
+
+  // If a protected/hidden undefined symbol is resolved to other .so,
+  // it's handled as if no symbols were found.
+  if (sym.file->is_dso &&
+      (sym.visibility == STV_PROTECTED || sym.visibility == STV_HIDDEN)) {
+    record();
+    return true;
+  }
+
+  return false;
+}
+
+using E = MOLD_TARGET;
+
+template struct CieRecord<E>;
+template class InputSection<E>;
 
 } // namespace mold::elf

elf/jobs.cc

@@ -0,0 +1,49 @@
+#include "mold.h"
+
+#ifndef _WIN32
+# include <fcntl.h>
+# include <pwd.h>
+# include <sys/stat.h>
+# include <sys/types.h>
+# include <unistd.h>
+#endif
+
+namespace mold::elf {
+
+template <typename E>
+void acquire_global_lock(Context<E> &ctx) {
+#ifndef _WIN32
+  char *jobs = getenv("MOLD_JOBS");
+  if (!jobs || std::string(jobs) != "1")
+    return;
+
+  char *home = getenv("HOME");
+  if (!home)
+    home = getpwuid(getuid())->pw_dir;
+
+  std::string path = std::string(home) + "/.mold-lock";
+  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;
+
+  ctx.global_lock_fd = fd;
+#endif
+}
+
+template <typename E>
+void release_global_lock(Context<E> &ctx) {
+#ifndef _WIN32
+  if (ctx.global_lock_fd)
+    close(*ctx.global_lock_fd);
+#endif
+}
+
+using E = MOLD_TARGET;
+
+template void acquire_global_lock(Context<E> &);
+template void release_global_lock(Context<E> &);
+
+} // namespace mold::elf

elf/linker-script.cc

@@ -146,8 +146,9 @@ read_output_format(Context<E> &ctx, std::span<std::string_view> tok) {
 
 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));
+  std::string rel = to_abs_path(path)
+                        .lexically_relative(to_abs_path(ctx.arg.sysroot))
+                        .string();
   return rel != "." && !rel.starts_with("../");
 }
 
@@ -225,6 +226,10 @@ void parse_linker_script(Context<E> &ctx, MappedFile<Context<E>> *mf) {
       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 {
@@ -234,7 +239,8 @@ void parse_linker_script(Context<E> &ctx, MappedFile<Context<E>> *mf) {
 }
 
 template <typename E>
-i64 get_script_output_type(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+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());
@@ -242,11 +248,18 @@ i64 get_script_output_type(Context<E> &ctx, MappedFile<Context<E>> *mf) {
 
   if (tok.size() >= 3 && tok[0] == "OUTPUT_FORMAT" && tok[1] == "(") {
     if (tok[2] == "elf64-x86-64")
-      return EM_X86_64;
+      return X86_64::target_name;
     if (tok[2] == "elf32-i386")
-      return EM_386;
+      return I386::target_name;
   }
-  return -1;
+
+  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,
@@ -266,9 +279,8 @@ static bool read_label(std::span<std::string_view> &tok,
 template <typename E>
 static void
 read_version_script_commands(Context<E> &ctx, std::span<std::string_view> &tok,
-                             u16 ver_idx, bool is_cpp) {
-  bool is_global = true;
-
+                             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;
@@ -286,11 +298,11 @@ read_version_script_commands(Context<E> &ctx, std::span<std::string_view> &tok,
       if (!tok.empty() && tok[0] == "\"C\"") {
         tok = tok.subspan(1);
         tok = skip(ctx, tok, "{");
-        read_version_script_commands( ctx, tok, ver_idx, false);
+        read_version_script_commands( ctx, tok, ver_str, ver_idx, is_global, false);
       } else {
         tok = skip(ctx, tok, "\"C++\"");
         tok = skip(ctx, tok, "{");
-        read_version_script_commands(ctx, tok, ver_idx, true);
+        read_version_script_commands(ctx, tok, ver_str, ver_idx, is_global, true);
       }
 
       tok = skip(ctx, tok, "}");
@@ -299,11 +311,14 @@ read_version_script_commands(Context<E> &ctx, std::span<std::string_view> &tok,
     }
 
     if (tok[0] == "*") {
-      ctx.default_version = (is_global ? ver_idx : VER_NDX_LOCAL);
+      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]), ver_idx, is_cpp});
+      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]), VER_NDX_LOCAL, is_cpp});
+      ctx.version_patterns.push_back({unquote(tok[0]), current_file<E>->name,
+                                      ver_str, VER_NDX_LOCAL, is_cpp});
     }
 
     tok = tok.subspan(1);
@@ -319,17 +334,21 @@ 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_idx, false);
+    read_version_script_commands(ctx, tok, ver_str, ver_idx, true, false);
     tok = skip(ctx, tok, "}");
     if (!tok.empty() && tok[0] != ";")
       tok = tok.subspan(1);
@@ -338,10 +357,9 @@ void read_version_script(Context<E> &ctx, std::span<std::string_view> &tok) {
 }
 
 template <typename E>
-void parse_version_script(Context<E> &ctx, std::string path) {
-  current_file<E> = MappedFile<Context<E>>::must_open(ctx, path);
-  std::vector<std::string_view> vec =
-    tokenize(ctx, current_file<E>->get_contents());
+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())
@@ -373,19 +391,19 @@ void read_dynamic_list_commands(Context<E> &ctx, std::span<std::string_view> &to
     if (tok[0] == "*")
       ctx.default_version = VER_NDX_GLOBAL;
     else
-      ctx.version_patterns.push_back({unquote(tok[0]), VER_NDX_GLOBAL, is_cpp});
+      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, std::string path) {
-  current_file<E> = MappedFile<Context<E>>::must_open(ctx, path);
-  std::vector<std::string_view> vec =
-    tokenize(ctx, current_file<E>->get_contents());
-
+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, "}");
@@ -395,20 +413,11 @@ void parse_dynamic_list(Context<E> &ctx, std::string path) {
     SyntaxError(ctx, tok[0]) << "trailing garbage token";
 }
 
-#define INSTANTIATE(E)                                                  \
-  template                                                              \
-  void parse_linker_script(Context<E> &ctx, MappedFile<Context<E>> *mf); \
-  template                                                              \
-  i64 get_script_output_type(Context<E> &ctx, MappedFile<Context<E>> *mf); \
-  template                                                              \
-  void parse_version_script(Context<E> &ctx, std::string path);         \
-  template                                                              \
-  void parse_dynamic_list(Context<E> &ctx, std::string path)
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+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-unix.cc

@@ -0,0 +1,737 @@
+// This file handles the linker plugin to support LTO (Link-Time
+// Optimization).
+//
+// LTO is a technique to do whole-program optimization to a program. Since
+// a linker sees the whole program as opposed to a single compilation
+// unit, it in theory can do some optimizations that cannot be done in the
+// usual separate compilation model. For example, LTO should be able to
+// inline functions that are defined in other compilation unit.
+//
+// In GCC and Clang, all you have to do to enable LTO is adding the
+// `-flto` flag to the compiler and the linker command lines. If `-flto`
+// is given, the compiler generates a file that contains not machine code
+// but the compiler's IR (intermediate representation). In GCC, the output
+// is an ELF file which wraps GCC's IR. In LLVM, it's not even an ELF file
+// but just a raw LLVM IR file.
+//
+// Here is what we have to do if at least one input file is not a usual
+// ELF file but an IR object file:
+//
+//  1. Read symbols both from usual ELF files and from IR object files and
+//     resolve symbols as usual.
+//
+//  2. Pass all IR objects to the compiler backend. The compiler backend
+//     compiles the IRs and returns a few big ELF object files as a
+//     result.
+//
+//  3. Parse the returned ELF files and overwrite IR object symbols with
+//     the returned ones, discarding IR object files.
+//
+//  4. Continue the rest of the linking process as usual.
+//
+// When gcc or clang inovkes ld, they pass `-plugin linker-plugin.so` to
+// the linker. The given .so file provides a way to call the compiler
+// backend.
+//
+// The linker plugin API is documented at
+// https://gcc.gnu.org/wiki/whopr/driver, though the document is a bit
+// outdated.
+//
+// Frankly, the linker plugin API is peculiar and is not very easy to use.
+// For some reason, the API functions don't return the result of a
+// function call as a return value but instead calls other function with
+// the result as its argument to "return" the result.
+//
+// For example, the first thing you need to do after dlopen()'ing a linker
+// plugin .so is to call `onload` function with a list of callback
+// functions. `onload` calls callbacks to notify about the pointers to
+// other functions the linker plugin provides. I don't know why `onload`
+// can't just return a list of functions or why the linker plugin can't
+// define not only `onload` but other functions, but that's what it is.
+//
+// Here is the steps to use the linker plugin:
+//
+//  1. dlopen() the linker plugin .so and call `onload` to obtain pointers
+//     to other functions provided by the plugin.
+//
+//  2. Call `claim_file_hook` with an IR object file to read its symbol
+//     table. `claim_file_hook` calls the `add_symbols` callback to
+//     "return" a list of symbols.
+//
+//  3. `claim_file_hook` returns LDPT_OK only when the plugin wants to
+//     handle a given file. Since we pass only IR object files to the
+//     plugin in mold, it always returns LDPT_OK in our case.
+//
+//  4. Once we made a decision as to which object file to include into the
+//     output file, we call `all_symbols_read_hook` to compile IR objects
+//     into a few big ELF files. That function calls the `get_symbols`
+//     callback to ask us about the symbol resolution results. (The
+//     compiler backend needs to know whether an undefined symbol in an IR
+//     object was resolved to a regular object file or a shared object to
+//     do whole program optimization, for example.)
+//
+//  5. `all_symbols_read_hook` "returns" the result by calling the
+//     `add_input_file` callback. The callback is called with a path to an
+//     LTO'ed ELF file. We parse that ELF file and override symbols
+//     defined by IR objects with the ELF file's ones.
+//
+//  6. Lastly, we call `cleanup_hook` to remove temporary files created by
+//     the compiler backend.
+
+#include "mold.h"
+#include "lto.h"
+
+#include <cstdarg>
+#include <cstring>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <sstream>
+#include <tbb/parallel_for_each.h>
+#include <unistd.h>
+
+#if 0
+# define LOG std::cerr
+#else
+# define LOG std::ostringstream()
+#endif
+
+namespace mold::elf {
+
+// Global variables
+// We store LTO-related information to global variables,
+// as the LTO plugin is not thread-safe by design anyway.
+
+template <typename E> static Context<E> *gctx;
+template <typename E> static std::vector<ObjectFile<E> *> lto_objects;
+
+static int phase = 0;
+static std::vector<PluginSymbol> plugin_symbols;
+static ClaimFileHandler *claim_file_hook;
+static AllSymbolsReadHandler *all_symbols_read_hook;
+static CleanupHandler *cleanup_hook;
+static bool is_gcc_linker_api_v1 = false;
+
+// Event handlers
+
+template <typename E>
+static PluginStatus message(PluginLevel level, const char *fmt, ...) {
+  LOG << "message\n";
+  Context<E> &ctx = *gctx<E>;
+
+  char buf[1000];
+  va_list ap;
+  va_start(ap, fmt);
+  vsnprintf(buf, sizeof(buf), fmt, ap);
+  va_end(ap);
+
+  switch (level) {
+  case LDPL_INFO:
+    SyncOut(ctx) << buf;
+    break;
+  case LDPL_WARNING:
+    Warn(ctx) << buf;
+    break;
+  case LDPL_ERROR:
+  case LDPL_FATAL:
+    Fatal(ctx) << buf;
+  }
+
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus register_claim_file_hook(ClaimFileHandler fn) {
+  LOG << "register_claim_file_hook\n";
+  claim_file_hook = fn;
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus
+register_all_symbols_read_hook(AllSymbolsReadHandler fn) {
+  LOG << "register_all_symbols_read_hook\n";
+  all_symbols_read_hook = fn;
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus register_cleanup_hook(CleanupHandler fn) {
+  LOG << "register_cleanup_hook\n";
+  cleanup_hook = fn;
+  return LDPS_OK;
+}
+
+static PluginStatus
+add_symbols(void *handle, int nsyms, const PluginSymbol *psyms) {
+  LOG << "add_symbols: " << nsyms << "\n";
+  assert(phase == 1);
+  plugin_symbols = {psyms, psyms + nsyms};
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus add_input_file(const char *path) {
+  LOG << "add_input_file: " << path << "\n";
+
+  Context<E> &ctx = *gctx<E>;
+  static i64 file_priority = 100;
+
+  MappedFile<Context<E>> *mf = MappedFile<Context<E>>::must_open(ctx, path);
+
+  ObjectFile<E> *file = ObjectFile<E>::create(ctx, mf, "", false);
+  ctx.obj_pool.emplace_back(file);
+  lto_objects<E>.push_back(file);
+
+  file->priority = file_priority++;
+  file->is_alive = true;
+  file->parse(ctx);
+  file->resolve_symbols(ctx);
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_file(const void *handle, struct PluginInputFile *file) {
+  LOG << "get_input_file\n";
+  return LDPS_OK;
+}
+
+template <typename E>
+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;
+  }
+  return LDPS_OK;
+}
+
+static PluginStatus add_input_library(const char *path) {
+  LOG << "add_input_library\n";
+  return LDPS_OK;
+}
+
+static PluginStatus set_extra_library_path(const char *path) {
+  LOG << "set_extra_library_path\n";
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus get_view(const void *handle, const void **view) {
+  LOG << "get_view\n";
+
+  ObjectFile<E> &file = *(ObjectFile<E> *)handle;
+  *view = (void *)file.mf->data;
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_count(const void *handle, int *count) {
+  LOG << "get_input_section_count\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_type(const PluginSection section, int *type) {
+  LOG << "get_input_section_type\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_name(const PluginSection section,
+                       char **section_name) {
+  LOG << "get_input_section_name\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_contents(const PluginSection section,
+                           const char **section_contents,
+                           size_t *len) {
+  LOG << "get_input_section_contents\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+update_section_order(const PluginSection *section_list,
+                     int num_sections) {
+  LOG << "update_section_order\n";
+  return LDPS_OK;
+}
+
+static PluginStatus allow_section_ordering() {
+  LOG << "allow_section_ordering\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_symbols_v1(const void *handle, int nsyms, PluginSymbol *psyms) {
+  unreachable();
+}
+
+// get_symbols teaches the LTO plugin as to how we have resolved symbols.
+// The plugin uses the symbol resolution info to optimize the program.
+//
+// For example, if a definition in an IR file is not referenced by
+// non-IR objects at all, the plugin may choose to completely inline
+// that definition within the IR objects and remove the symbol from the
+// LTO result. On the other hand, if a definition is referenced by a
+// non-IR object, it has to keep the symbol in the LTO result.
+template <typename E>
+static PluginStatus
+get_symbols(const void *handle, int nsyms, PluginSymbol *psyms, bool is_v2) {
+  ObjectFile<E> &file = *(ObjectFile<E> *)handle;
+  assert(file.is_lto_obj);
+
+  // If file is an archive member which was not chose to be included in
+  // to the final result, we need to make the plugin to ignore all
+  // symbols.
+  if (!file.is_alive) {
+    assert(!is_v2);
+    for (int i = 0; i < nsyms; i++)
+      psyms[i].resolution = LDPR_PREEMPTED_REG;
+    return LDPS_NO_SYMS;
+  }
+
+  auto get_resolution = [&](ElfSym<E> &esym, Symbol<E> &sym) {
+    if (!sym.file)
+      return LDPR_UNDEF;
+
+    if (sym.file == &file) {
+      if (sym.referenced_by_regular_obj)
+        return LDPR_PREVAILING_DEF;
+      if (sym.is_exported)
+        return is_v2 ? LDPR_PREVAILING_DEF : LDPR_PREVAILING_DEF_IRONLY_EXP;
+      return LDPR_PREVAILING_DEF_IRONLY;
+    }
+
+    if (sym.file->is_dso)
+      return LDPR_RESOLVED_DYN;
+
+    if (((ObjectFile<E> *)sym.file)->is_lto_obj && !sym.is_wrapped)
+      return esym.is_undef() ? LDPR_RESOLVED_IR : LDPR_PREEMPTED_IR;
+    return esym.is_undef() ? LDPR_RESOLVED_EXEC : LDPR_PREEMPTED_REG;
+  };
+
+  // Set the symbol resolution results to psyms.
+  for (i64 i = 0; i < nsyms; i++) {
+    ElfSym<E> &esym = file.elf_syms[i + 1];
+    Symbol<E> &sym = *file.symbols[i + 1];
+    psyms[i].resolution = get_resolution(esym, sym);
+  }
+  return LDPS_OK;
+}
+
+// This function restarts mold itself with `--:lto-pass2` and
+// `--:ignore-ir-file` flags. We do this as a workaround for the old
+// linker plugins that do not support the get_symbols_v3 API.
+//
+// get_symbols_v1 and get_symbols_v2 don't provide a way to ignore an
+// object file we previously passed to the linker plugin. So we can't
+// "unload" object files in archives that we ended up not choosing to
+// include into the final output.
+//
+// As a workaround, we restart the linker with a list of object files
+// the linker has to ignore, so that it won't read the object files
+// from archives next time.
+//
+// This is an ugly hack and should be removed once GCC adopts the v3 API.
+template <typename E>
+static void restart_process(Context<E> &ctx) {
+  std::vector<const char *> args;
+
+  for (std::string_view arg : ctx.cmdline_args)
+    args.push_back(strdup(std::string(arg).c_str()));
+
+  for (std::unique_ptr<ObjectFile<E>> &file : ctx.obj_pool)
+    if (file->is_lto_obj && !file->is_alive)
+      args.push_back(strdup(("--:ignore-ir-file=" +
+                             file->mf->get_identifier()).c_str()));
+
+  args.push_back("--:lto-pass2");
+  args.push_back(nullptr);
+
+  std::cout << std::flush;
+  std::cerr << std::flush;
+
+  std::string self = get_self_path();
+  execv(self.c_str(), (char * const *)args.data());
+  std::cerr << "execv failed: " << errno_string() << "\n";
+  _exit(1);
+}
+
+template <typename E>
+static PluginStatus
+get_symbols_v2(const void *handle, int nsyms, PluginSymbol *psyms) {
+  LOG << "get_symbols_v2\n";
+  return get_symbols<E>(handle, nsyms, psyms, true);
+}
+
+template <typename E>
+static PluginStatus
+get_symbols_v3(const void *handle, int nsyms, PluginSymbol *psyms) {
+  LOG << "get_symbols_v3\n";
+  return get_symbols<E>(handle, nsyms, psyms, false);
+}
+
+static PluginStatus allow_unique_segment_for_sections() {
+  LOG << "allow_unique_segment_for_sections\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+unique_segment_for_sections(const char *segment_name,
+                            uint64_t flags,
+                            uint64_t align,
+                            const PluginSection *section_list,
+                            int num_sections) {
+  LOG << "unique_segment_for_sections\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_alignment(const PluginSection section,
+                            int *addralign) {
+  LOG << "get_input_section_alignment\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_input_section_size(const PluginSection section, uint64_t *size) {
+  LOG << "get_input_section_size\n";
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginStatus
+register_new_input_hook(NewInputHandler fn) {
+  LOG << "register_new_input_hook\n";
+  return LDPS_OK;
+}
+
+static PluginStatus
+get_wrap_symbols(uint64_t *num_symbols, const char ***wrap_symbols) {
+  LOG << "get_wrap_symbols\n";
+  return LDPS_OK;
+}
+
+template <typename E>
+static PluginLinkerAPIVersion
+get_api_version(const char *plugin_identifier,
+                unsigned plugin_version,
+                int minimal_api_supported,
+                int maximal_api_supported,
+                const char **linker_identifier,
+                const char **linker_version) {
+  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;
+
+  *linker_identifier = "mold";
+  *linker_version = version.data();
+
+  if (LAPI_V1 <= maximal_api_supported) {
+    is_gcc_linker_api_v1 = true;
+    return LAPI_V1;
+  }
+  return LAPI_V0;
+}
+
+template <typename E>
+static void load_plugin(Context<E> &ctx) {
+  assert(phase == 0);
+  phase = 1;
+  gctx<E> = &ctx;
+
+  void *handle = dlopen(ctx.arg.plugin.c_str(), RTLD_NOW | RTLD_GLOBAL);
+  if (!handle)
+    Fatal(ctx) << "could not open plugin file: " << dlerror();
+
+  OnloadFn *onload = (OnloadFn *)dlsym(handle, "onload");
+  if (!onload)
+    Fatal(ctx) << "failed to load plugin " << ctx.arg.plugin << ": "
+               << dlerror();
+
+  auto save = [&](std::string_view str) {
+    return save_string(ctx, std::string(str).c_str()).data();
+  };
+
+  std::vector<PluginTagValue> tv;
+  tv.emplace_back(LDPT_MESSAGE, message<E>);
+
+  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);
+
+  for (std::string_view opt : ctx.arg.plugin_opt)
+    tv.emplace_back(LDPT_OPTION, save(opt));
+
+  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>
+static ElfSym<E> to_elf_sym(PluginSymbol &psym) {
+  ElfSym<E> esym;
+  memset(&esym, 0, sizeof(esym));
+
+  switch (psym.def) {
+  case LDPK_DEF:
+    esym.st_shndx = SHN_ABS;
+    break;
+  case LDPK_WEAKDEF:
+    esym.st_shndx = SHN_ABS;
+    esym.st_bind = STB_WEAK;
+    break;
+  case LDPK_UNDEF:
+    esym.st_shndx = SHN_UNDEF;
+    break;
+  case LDPK_WEAKUNDEF:
+    esym.st_shndx = SHN_UNDEF;
+    esym.st_bind = STB_WEAK;
+    break;
+  case LDPK_COMMON:
+    esym.st_shndx = SHN_COMMON;
+    break;
+  }
+
+  switch (psym.symbol_type) {
+  case LDST_UNKNOWN:
+    break;
+  case LDST_FUNCTION:
+    esym.st_type = STT_FUNC;
+    break;
+  case LDST_VARIABLE:
+    esym.st_type = STT_OBJECT;
+    break;
+  };
+
+  switch (psym.visibility) {
+  case LDPV_DEFAULT:
+    break;
+  case LDPV_PROTECTED:
+    esym.st_visibility = STV_PROTECTED;
+    break;
+  case LDPV_INTERNAL:
+    esym.st_visibility = STV_INTERNAL;
+    break;
+  case LDPV_HIDDEN:
+    esym.st_visibility = STV_HIDDEN;
+    break;
+  }
+
+  esym.st_size = psym.size;
+  return esym;
+}
+
+// Returns true if a given linker plugin looks like LLVM's one.
+// Returns false if it's GCC.
+template <typename E>
+static bool is_llvm(Context<E> &ctx) {
+  return ctx.arg.plugin.ends_with("LLVMgold.so");
+}
+
+// Returns true if a given linker plugin supports the get_symbols_v3 API.
+// Any version of LLVM and GCC 12 or newer support it.
+template <typename E>
+static bool supports_v3_api(Context<E> &ctx) {
+  return is_gcc_linker_api_v1 || is_llvm(ctx);
+}
+
+template <typename E>
+ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+  // V0 API's claim_file is not thread-safe.
+  static std::mutex mu;
+  std::unique_lock lock(mu, std::defer_lock);
+  if (!is_gcc_linker_api_v1)
+    lock.lock();
+
+  if (ctx.arg.plugin.empty())
+    Fatal(ctx) << mf->name << ": don't know how to handle this LTO object file "
+               << "because no -plugin option was given. Please make sure you "
+               << "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);
+
+  obj->filename = mf->name;
+  obj->symbols.push_back(new Symbol<E>);
+  obj->first_global = 1;
+  obj->is_lto_obj = true;
+  obj->mf = mf;
+
+  // 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;
+  file.handle = (void *)obj;
+
+  LOG << "read_lto_symbols: "<< mf->name << "\n";
+
+  // claim_file_hook() calls add_symbols() which initializes `plugin_symbols`
+  int claimed = false;
+  claim_file_hook(&file, &claimed);
+  if (!claimed)
+    Fatal(ctx) << mf->name << ": not claimed by the LTO plugin;"
+               << " please make sure you are using the same compiler of the"
+               << " same version for all object files";
+
+  // It looks like GCC doesn't need fd after claim_file_hook() while
+  // 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;
+  }
+
+  // Initialize object symbols
+  std::vector<ElfSym<E>> *esyms = new std::vector<ElfSym<E>>(1);
+  obj->has_symver.resize(plugin_symbols.size());
+  obj->lto_symbol_versions.resize(plugin_symbols.size());
+
+  for (i64 i = 0; i < plugin_symbols.size(); i++) {
+    PluginSymbol &psym = plugin_symbols[i];
+    esyms->push_back(to_elf_sym<E>(psym));
+
+    std::string_view key = save_string(ctx, psym.name);
+    std::string_view name = key;
+
+    // Parse symbol version after atsign
+    if (i64 pos = name.find('@'); pos != name.npos) {
+      std::string_view ver = name.substr(pos);
+      name = name.substr(0, pos);
+
+      if (ver != "@" && ver != "@@") {
+        if (ver.starts_with("@@"))
+          key = name;
+        obj->has_symver.set(i);
+        obj->lto_symbol_versions[i] = ver.substr(1);
+      }
+    }
+
+    obj->symbols.push_back(get_symbol(ctx, key, name));
+  }
+
+  obj->elf_syms = *esyms;
+  obj->has_symver.resize(esyms->size());
+  plugin_symbols.clear();
+  return obj;
+}
+
+// Entry point
+template <typename E>
+std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
+  Timer t(ctx, "do_lto");
+
+  if (!ctx.arg.lto_pass2 && !supports_v3_api(ctx))
+    restart_process(ctx);
+
+  assert(phase == 1);
+  phase = 2;
+
+  // Set `referenced_by_regular_obj` bit.
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    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;
+        }
+      }
+    }
+  });
+
+  // Symbols specified by the --wrap option needs to be visible from
+  // regular object files.
+  for (std::string_view name : ctx.arg.wrap) {
+    get_symbol(ctx, name)->referenced_by_regular_obj = true;
+
+    std::string_view x = save_string(ctx, "__wrap_" + std::string(name));
+    std::string_view y = save_string(ctx, "__real_" + std::string(name));
+
+    get_symbol(ctx, x)->referenced_by_regular_obj = true;
+    get_symbol(ctx, y)->referenced_by_regular_obj = true;
+  }
+
+  // Handle --entry
+  get_symbol(ctx, ctx.arg.entry)->referenced_by_regular_obj = true;
+
+  // 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)
+    Fatal(ctx) << "LTO: all_symbols_read_hook returns " << st;
+
+  return lto_objects<E>;
+}
+
+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 void lto_cleanup(Context<E> &);
+
+} // namespace mold::elf

elf/lto-win32.cc

@@ -0,0 +1,25 @@
+#include "mold.h"
+#include "lto.h"
+
+namespace mold::elf {
+
+template <typename E>
+ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+  Fatal(ctx) << "LTO is not supported on Windows";
+}
+
+template <typename E>
+std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
+  return {};
+}
+
+template <typename E>
+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 void lto_cleanup(Context<E> &);
+
+} // namespace mold::elf

elf/lto.cc

@@ -1,661 +1,5 @@
-// This file handles the linker plugin to support LTO (Link-Time
-// Optimization).
-//
-// LTO is a technique to do whole-program optimization to a program. Since
-// a linker sees the whole program as opposed to a single compilation
-// unit, it in theory can do some optimizations that cannot be done in the
-// usual separate compilation model. For example, LTO should be able to
-// inline functions that are defined in other compilation unit.
-//
-// In GCC and Clang, all you have to do to enable LTO is adding the
-// `-flto` flag to the compiler and the linker command lines. If `-flto`
-// is given, the compiler generates a file that contains not machine code
-// but the compiler's IR (intermediate representation). In GCC, the output
-// is an ELF file which wraps GCC's IR. In LLVM, it's not even an ELF file
-// but just a raw LLVM IR file.
-//
-// Here is what we have to do if at least one input file is not a usual
-// ELF file but an IR object file:
-//
-//  1. Read symbols both from usual ELF files and from IR object files and
-//     resolve symbols as usual.
-//
-//  2. Pass all IR objects to the compiler backend. The compiler backend
-//     compiles the IRs and returns a few big ELF object files as a
-//     result.
-//
-//  3. Parse the returned ELF files and overwrite IR object symbols with
-//     the returned ones, discarding IR object files.
-//
-//  4. Continue the rest of the linking process as usual.
-//
-// When gcc or clang inovkes ld, they pass `-plugin linker-plugin.so` to
-// the linker. The given .so file provides a way to call the compiler
-// backend.
-//
-// The linker plugin API is documented at
-// https://gcc.gnu.org/wiki/whopr/driver, though the document is a bit
-// outdated.
-//
-// Frankly, the linker plugin API is peculiar and is not very easy to use.
-// For some reason, the API functions don't return the result of a
-// function call as a return value but instead calls other function with
-// the result as its argument to "return" the result.
-//
-// For example, the first thing you need to do after dlopen()'ing a linker
-// plugin .so is to call `onload` function with a list of callback
-// functions. `onload` calls callbacks to notify about the pointers to
-// other functions the linker plugin provides. I don't know why `onload`
-// can't just return a list of functions or why the linker plugin can't
-// define not only `onload` but other functions, but that's how it works.
-//
-// Here is the steps to use the linker plugin:
-//
-//  1. dlopen() the linker plugin .so and call `onload` to obtain pointers
-//     to other functions provided by the plugin.
-//
-//  2. Call `claim_file_hook` with an IR object file to read its symbol
-//     table. `claim_file_hook` calls the `add_symbols` callback to
-//     "return" a list of symbols.
-//
-//  3. `claim_file_hook` returns LDPT_OK only when the plugin wants to
-//     handle a given file. Since we pass only IR object files to the
-//     plugin in mold, it always returns LDPT_OK in our case.
-//
-//  4. Once we made a decision as to which object file to include into the
-//     output file, we call `all_symbols_read_hook` to compile IR objects
-//     into a few big ELF files. That function calls the `get_symbols`
-//     callback to ask us about the symbol resolution results. (The
-//     compiler backend needs to know whether an undefined symbol in an IR
-//     object was resolved to a regular object file or a shared object to
-//     do whole program optimization, for example.)
-//
-//  5. `all_symbols_read_hook` "returns" the result by calling the
-//     `add_input_file` callback. The callback is called with a path to an
-//     LTO'ed ELF file. We parse that ELF file and override symbols
-//     defined by IR objects with the ELF file's ones.
-//
-//  6. Lastly, we call `cleanup_hook` to remove temporary files created by
-//     the compiler backend.
-
-#include "mold.h"
-#include "../lto.h"
-
-#include <cstdarg>
-#include <cstring>
-#include <dlfcn.h>
-#include <fcntl.h>
-#include <sstream>
-#include <unistd.h>
-
-#if 0
-# define LOG std::cerr
+#ifdef _WIN32
+# include "lto-win32.cc"
 #else
-# define LOG std::ostringstream()
+# include "lto-unix.cc"
 #endif
-
-namespace mold::elf {
-
-// Global variables
-// We store LTO-related information to global variables,
-// as the LTO plugin is not thread-safe by design anyway.
-
-template <typename E> static Context<E> *gctx;
-template <typename E> static std::vector<ObjectFile<E> *> lto_objects;
-
-static int phase = 0;
-static std::vector<PluginSymbol> plugin_symbols;
-static ClaimFileHandler *claim_file_hook;
-static AllSymbolsReadHandler *all_symbols_read_hook;
-static CleanupHandler *cleanup_hook;
-
-// Event handlers
-
-static PluginStatus message(int level, const char *fmt, ...) {
-  LOG << "message\n";
-  va_list ap;
-  va_start(ap, fmt);
-  fprintf(stderr, "mold: ");
-  vfprintf(stderr, fmt, ap);
-  fprintf(stderr, "\n");
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus register_claim_file_hook(ClaimFileHandler fn) {
-  LOG << "register_claim_file_hook\n";
-  claim_file_hook = fn;
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus
-register_all_symbols_read_hook(AllSymbolsReadHandler fn) {
-  LOG << "register_all_symbols_read_hook\n";
-  all_symbols_read_hook = fn;
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus register_cleanup_hook(CleanupHandler fn) {
-  LOG << "register_cleanup_hook\n";
-  cleanup_hook = fn;
-  return LDPS_OK;
-}
-
-static PluginStatus
-add_symbols(void *handle, int nsyms, const PluginSymbol *psyms) {
-  LOG << "add_symbols: " << nsyms << "\n";
-  assert(phase == 1);
-  plugin_symbols = {psyms, psyms + nsyms};
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus add_input_file(const char *path) {
-  LOG << "add_input_file: " << path << "\n";
-
-  Context<E> &ctx = *gctx<E>;
-  static i64 file_priority = 100;
-
-  MappedFile<Context<E>> *mf = MappedFile<Context<E>>::must_open(ctx, path);
-
-  ObjectFile<E> *file = ObjectFile<E>::create(ctx, mf, "", false);
-  ctx.obj_pool.emplace_back(file);
-  lto_objects<E>.push_back(file);
-
-  file->priority = file_priority++;
-  file->is_alive = true;
-  file->parse(ctx);
-  file->resolve_symbols(ctx);
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_file(const void *handle, struct PluginInputFile *file) {
-  LOG << "get_input_file\n";
-  return LDPS_OK;
-}
-
-template <typename E>
-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;
-  }
-  return LDPS_OK;
-}
-
-static PluginStatus add_input_library(const char *path) {
-  LOG << "add_input_library\n";
-  return LDPS_OK;
-}
-
-static PluginStatus set_extra_library_path(const char *path) {
-  LOG << "set_extra_library_path\n";
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus get_view(const void *handle, const void **view) {
-  LOG << "get_view\n";
-
-  ObjectFile<E> &file = *(ObjectFile<E> *)handle;
-  *view = (void *)file.mf->data;
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_count(const void *handle, int *count) {
-  LOG << "get_input_section_count\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_type(const PluginSection section, int *type) {
-  LOG << "get_input_section_type\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_name(const PluginSection section,
-                       char **section_name) {
-  LOG << "get_input_section_name\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_contents(const PluginSection section,
-                           const char **section_contents,
-		           size_t *len) {
-  LOG << "get_input_section_contents\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-update_section_order(const PluginSection *section_list,
-		     int num_sections) {
-  LOG << "update_section_order\n";
-  return LDPS_OK;
-}
-
-static PluginStatus allow_section_ordering() {
-  LOG << "allow_section_ordering\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_symbols_v1(const void *handle, int nsyms, PluginSymbol *psyms) {
-  unreachable();
-}
-
-// get_symbols teaches the LTO plugin as to how we resolved symbols.
-// The plugin uses the symbol resolution info to optimizes the program.
-//
-// For example, if a definition in an IR file is not referenced by
-// non-IR objects at all, the plugin may choose to completely inline
-// that definition within the IR objects and remove the symbol from the
-// LTO result. On the other hand, if a definition is referenced by a
-// non-IR object, it has to keep the symbol in the LTO result.
-template <typename E>
-static PluginStatus
-get_symbols(const void *handle, int nsyms, PluginSymbol *psyms, bool is_v2) {
-  ObjectFile<E> &file = *(ObjectFile<E> *)handle;
-  assert(file.is_lto_obj);
-
-  // If file is an archive member which was not chose to be included in
-  // to the final result, we need to make the plugin to ignore all
-  // symbols.
-  if (!file.is_alive) {
-    assert(!is_v2);
-    for (int i = 0; i < nsyms; i++)
-      psyms[i].resolution = LDPR_PREEMPTED_REG;
-    return LDPS_NO_SYMS;
-  }
-
-  auto get_resolution = [&](ElfSym<E> &esym, Symbol<E> &sym) {
-    if (!sym.file)
-      return LDPR_UNDEF;
-
-    if (sym.file == &file) {
-      if (sym.referenced_by_regular_obj)
-        return LDPR_PREVAILING_DEF;
-      if (sym.is_exported)
-        return is_v2 ? LDPR_PREVAILING_DEF : LDPR_PREVAILING_DEF_IRONLY_EXP;
-      return LDPR_PREVAILING_DEF_IRONLY;
-    }
-
-    if (sym.file->is_dso)
-      return LDPR_RESOLVED_DYN;
-    if (((ObjectFile<E> *)sym.file)->is_lto_obj)
-      return esym.is_undef() ? LDPR_RESOLVED_IR : LDPR_PREEMPTED_IR;
-    return esym.is_undef() ? LDPR_RESOLVED_EXEC : LDPR_PREEMPTED_REG;
-  };
-
-  // Set the symbol resolution results to psyms.
-  for (i64 i = 0; i < nsyms; i++) {
-    ElfSym<E> &esym = file.elf_syms[i + 1];
-    Symbol<E> &sym = *file.symbols[i + 1];
-    psyms[i].resolution = get_resolution(esym, sym);
-  }
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus
-get_symbols_v2(const void *handle, int nsyms, PluginSymbol *psyms) {
-  LOG << "get_symbols_v2\n";
-  return get_symbols<E>(handle, nsyms, psyms, true);
-}
-
-template <typename E>
-static PluginStatus
-get_symbols_v3(const void *handle, int nsyms, PluginSymbol *psyms) {
-  LOG << "get_symbols_v3\n";
-  return get_symbols<E>(handle, nsyms, psyms, false);
-}
-
-static PluginStatus allow_unique_segment_for_sections() {
-  LOG << "allow_unique_segment_for_sections\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-unique_segment_for_sections(const char *segment_name,
-			    uint64_t flags,
-			    uint64_t align,
-			    const PluginSection *section_list,
-			    int num_sections) {
-  LOG << "unique_segment_for_sections\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_alignment(const PluginSection section,
-                            int *addralign) {
-  LOG << "get_input_section_alignment\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_input_section_size(const PluginSection section, uint64_t *size) {
-  LOG << "get_input_section_size\n";
-  return LDPS_OK;
-}
-
-template <typename E>
-static PluginStatus
-register_new_input_hook(NewInputHandler fn) {
-  LOG << "register_new_input_hook\n";
-  return LDPS_OK;
-}
-
-static PluginStatus
-get_wrap_symbols(uint64_t *num_symbols, const char ***wrap_symbols) {
-  LOG << "get_wrap_symbols\n";
-  return LDPS_OK;
-}
-
-template <typename E>
-static void load_plugin(Context<E> &ctx) {
-  assert(phase == 0);
-  phase = 1;
-  gctx<E> = &ctx;
-
-  void *handle = dlopen(ctx.arg.plugin.c_str(), RTLD_NOW | RTLD_GLOBAL);
-  if (!handle)
-    Fatal(ctx) << "could not open plugin file: " << dlerror();
-
-  OnloadFn *onload = (OnloadFn *)dlsym(handle, "onload");
-  if (!onload)
-    Fatal(ctx) << "failed to load plugin " << ctx.arg.plugin << ": "
-               << dlerror();
-
-  auto save = [&](std::string_view str) {
-    return save_string(ctx, std::string(str).c_str()).data();
-  };
-
-  std::vector<PluginTagValue> tv;
-  tv.emplace_back(LDPT_MESSAGE, message);
-
-  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);
-
-  for (std::string_view opt : ctx.arg.plugin_opt)
-    tv.emplace_back(LDPT_OPTION, save(opt));
-
-  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_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_NULL, 0);
-
-  onload(tv.data());
-}
-
-template <typename E>
-static ElfSym<E> to_elf_sym(PluginSymbol &psym) {
-  ElfSym<E> esym = {};
-
-  switch (psym.def) {
-  case LDPK_DEF:
-    esym.st_shndx = SHN_ABS;
-    break;
-  case LDPK_WEAKDEF:
-    esym.st_shndx = SHN_ABS;
-    esym.st_bind = STB_WEAK;
-    break;
-  case LDPK_UNDEF:
-    esym.st_shndx = SHN_UNDEF;
-    break;
-  case LDPK_WEAKUNDEF:
-    esym.st_shndx = SHN_UNDEF;
-    esym.st_bind = STB_WEAK;
-    break;
-  case LDPK_COMMON:
-    esym.st_shndx = SHN_COMMON;
-    break;
-  }
-
-  switch (psym.symbol_type) {
-  case LDST_UNKNOWN:
-    break;
-  case LDST_FUNCTION:
-    esym.st_type = STT_FUNC;
-    break;
-  case LDST_VARIABLE:
-    esym.st_type = STT_OBJECT;
-    break;
-  };
-
-  switch (psym.visibility) {
-  case LDPV_DEFAULT:
-    break;
-  case LDPV_PROTECTED:
-    esym.st_visibility = STV_PROTECTED;
-    break;
-  case LDPV_INTERNAL:
-    esym.st_visibility = STV_INTERNAL;
-    break;
-  case LDPV_HIDDEN:
-    esym.st_visibility = STV_HIDDEN;
-    break;
-  }
-
-  esym.st_size = psym.size;
-  return esym;
-}
-
-// Returns true if a given linker plugin looks like LLVM's one.
-// Returns false if it's GCC.
-template <typename E>
-static bool is_llvm(Context<E> &ctx) {
-  return ctx.arg.plugin.ends_with("LLVMgold.so");
-}
-
-// Returns true if a given linker plugin supports the get_symbols_v3 API.
-// Currently, we simply assume that LLVM supports it and GCC does not.
-template <typename E>
-static bool suppots_v3_api(Context<E> &ctx) {
-  return is_llvm(ctx);
-}
-
-template <typename E>
-ObjectFile<E> *read_lto_object(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  LOG << "read_lto_object: " << mf->name << "\n";
-
-  if (ctx.arg.plugin.empty())
-    Fatal(ctx) << mf->name << ": don't know how to handle this LTO object file "
-               << "because no -plugin option was given. Please make sure you "
-               << "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);
-
-  obj->filename = mf->name;
-  obj->symbols.push_back(new Symbol<E>);
-  obj->first_global = 1;
-  obj->is_lto_obj = true;
-  obj->mf = mf;
-
-  // 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;
-  file.handle = (void *)obj;
-
-  LOG << "read_lto_symbols: "<< mf->name << "\n";
-
-  // claim_file_hook() calls add_symbols() which initializes `plugin_symbols`
-  int claimed = false;
-  claim_file_hook(&file, &claimed);
-  if (!claimed)
-    Fatal(ctx) << mf->name << ": not claimed by the LTO plugin";
-
-  // It looks like GCC doesn't need fd after claim_file_hook() while
-  // 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;
-  }
-
-  // Initialize object symbols
-  std::vector<ElfSym<E>> *esyms = new std::vector<ElfSym<E>>(1);
-
-  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)));
-  }
-
-  obj->elf_syms = *esyms;
-  obj->sym_fragments.resize(esyms->size());
-  obj->symvers.resize(esyms->size());
-  plugin_symbols.clear();
-  return obj;
-}
-
-// This function restarts mold itself with `--:lto-pass2` and
-// `--:ignore-ir-file` flags. We do this as a workaround for the old
-// linker plugins that do not support the get_symbols_v3 API.
-//
-// get_symbols_v1 and get_symbols_v2 don't provide a way to ignore an
-// object file we previously passed to the linker plugin. So we can't
-// "unload" object files in archives that we ended up not choosing to
-// include into the final output.
-//
-// As a workaround, we restart the linker with a list of object files
-// the linker has to ignore, so that it won't read the object files
-// from archives next time.
-//
-// This is an ugly hack and should be removed once GCC adopts the v3 API.
-template <typename E>
-static void restart_process(Context<E> &ctx) {
-  std::vector<const char *> args;
-
-  for (std::string_view arg : ctx.cmdline_args)
-    args.push_back(strdup(std::string(arg).c_str()));
-
-  for (std::unique_ptr<ObjectFile<E>> &file : ctx.obj_pool)
-    if (file->is_lto_obj && !file->is_alive)
-      args.push_back(strdup(("--:ignore-ir-file=" +
-                             file->mf->get_identifier()).c_str()));
-
-  args.push_back("--:lto-pass2");
-  args.push_back(nullptr);
-
-  std::string self = std::filesystem::read_symlink("/proc/self/exe");
-
-  std::cout << std::flush;
-  std::cerr << std::flush;
-  execv(self.c_str(), (char * const *)args.data());
-  std::cerr << "execv failed: " << errno_string() << "\n";
-  _exit(1);
-}
-
-// Entry point
-template <typename E>
-std::vector<ObjectFile<E> *> do_lto(Context<E> &ctx) {
-  Timer t(ctx, "do_lto");
-
-  if (!ctx.arg.lto_pass2 && !suppots_v3_api(ctx))
-    restart_process(ctx);
-
-  assert(phase == 1);
-  phase = 2;
-
-  // Set `referenced_by_regular_obj` bit.
-  for (ObjectFile<E> *file : ctx.objs) {
-    if (file->is_lto_obj)
-      continue;
-
-    for (i64 i = file->first_global; i < file->symbols.size(); i++) {
-      ElfSym<E> &esym = file->elf_syms[i];
-      Symbol<E> &sym = *file->symbols[i];
-
-      if (esym.is_undef() && sym.file && sym.file != file &&
-          !sym.file->is_dso && ((ObjectFile<E> *)sym.file)->is_lto_obj) {
-        std::scoped_lock lock(sym.mu);
-        sym.referenced_by_regular_obj = true;
-      }
-    }
-  }
-
-  // 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)
-    Fatal(ctx) << "LTO: all_symbols_read_hook returns " << st;
-
-  return lto_objects<E>;
-}
-
-template <typename E>
-void lto_cleanup(Context<E> &ctx) {
-  Timer t(ctx, "lto_cleanup");
-
-  if (cleanup_hook)
-    cleanup_hook();
-}
-
-#define INSTANTIATE(E)                                                  \
-  template ObjectFile<E> *                                              \
-    read_lto_object(Context<E> &, MappedFile<Context<E>> *);            \
-  template std::vector<ObjectFile<E> *> do_lto(Context<E> &);           \
-  template void lto_cleanup(Context<E> &)
-
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
-
-} // namespace mold::elf

elf/lto.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "../common/integers.h"
+
 namespace mold {
 
 enum PluginStatus {
@@ -44,6 +46,7 @@ enum PluginTag {
   LDPT_REGISTER_NEW_INPUT_HOOK,
   LDPT_GET_WRAP_SYMBOLS,
   LDPT_ADD_SYMBOLS_V2,
+  LDPT_GET_API_VERSION,
 };
 
 enum PluginApiVersion {
@@ -52,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 {
@@ -72,27 +73,35 @@ enum PluginOutputFileType {
 
 struct PluginInputFile {
   const char *name;
-  int fd;
-  off_t offset;
-  off_t filesize;
+  i32 fd;
+  u64 offset;
+  u64 filesize;
   void *handle;
 };
 
 struct PluginSection {
   const void *handle;
-  int shndx;
+  u32 shndx;
 };
 
 struct PluginSymbol {
   char *name;
   char *version;
-  char def;
-  char symbol_type;
-  char section_kind;
-  int visibility;
-  uint64_t size;
+#ifdef __LITTLE_ENDIAN__
+  u8 def;
+  u8 symbol_type;
+  u8 section_kind;
+  u8 padding;
+#else
+  u8 padding;
+  u8 section_kind;
+  u8 symbol_type;
+  u8 def;
+#endif
+  i32 visibility;
+  u64 size;
   char *comdat_key;
-  int resolution;
+  i32 resolution;
 };
 
 enum PluginSymbolKind {
@@ -141,6 +150,11 @@ enum PluginLevel {
   LDPL_FATAL,
 };
 
+enum PluginLinkerAPIVersion {
+  LAPI_V0,
+  LAPI_V1,
+};
+
 typedef PluginStatus OnloadFn(PluginTagValue *tv);
 typedef PluginStatus ClaimFileHandler(const PluginInputFile *, int *);
 typedef PluginStatus AllSymbolsReadHandler();

elf/main.cc

@@ -1,30 +1,121 @@
 #include "mold.h"
-#include "../archive-file.h"
-#include "../cmdline.h"
+#include "../common/archive-file.h"
+#include "../common/cmdline.h"
+#include "../common/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 <unistd.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;
+    case EM_LOONGARCH:
+      return is_64 ? LOONGARCH64::target_name : LOONGARCH32::target_name;
+    default:
+      return "";
+    }
+  };
+
+  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<Context<E>> *child : read_fat_archive_members(ctx, mf))
+      if (get_file_type(ctx, child) == 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(ctx, child) == 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) {
-  if (i64 type = ((ElfEhdr<E> *)mf->data)->e_machine; type != E::e_machine)
-    Fatal(ctx) << mf->name << ": incompatible file type: " << type;
-
   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++;
@@ -41,10 +132,11 @@ static ObjectFile<E> *new_lto_obj(Context<E> &ctx, MappedFile<Context<E>> *mf,
   count++;
 
   if (ctx.arg.ignore_ir_file.count(mf->get_identifier()))
-    return new ObjectFile<E>;
+    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;
@@ -56,8 +148,7 @@ static ObjectFile<E> *new_lto_obj(Context<E> &ctx, MappedFile<Context<E>> *mf,
 template <typename E>
 static SharedFile<E> *
 new_shared_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  if (i64 type = ((ElfEhdr<E> *)mf->data)->e_machine; type != E::e_machine)
-    Fatal(ctx) << mf->name << ": incompatible file type: " << type;
+  check_file_compatibility(ctx, mf);
 
   SharedFile<E> *file = SharedFile<E>::create(ctx, mf);
   file->priority = ctx.file_priority++;
@@ -72,8 +163,7 @@ void read_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
   if (ctx.visited.contains(mf->name))
     return;
 
-  FileType type = get_file_type(mf);
-  switch (type) {
+  switch (get_file_type(ctx, mf)) {
   case FileType::ELF_OBJ:
     ctx.objs.push_back(new_object_file(ctx, mf, ""));
     return;
@@ -84,66 +174,48 @@ void read_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
   case FileType::AR:
   case FileType::THIN_AR:
     for (MappedFile<Context<E>> *child : read_archive_members(ctx, mf)) {
-      switch (get_file_type(child)) {
+      switch (get_file_type(ctx, child)) {
       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:
-        ctx.objs.push_back(new_lto_obj(ctx, child, mf->name));
+        if (ObjectFile<E> *file = new_lto_obj(ctx, 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;
       }
     }
-    ctx.visited.insert(mf->name);
+    if (!ctx.whole_archive)
+      ctx.visited.insert(mf->name);
     return;
   case FileType::TEXT:
     parse_linker_script(ctx, mf);
     return;
   case FileType::GCC_LTO_OBJ:
   case FileType::LLVM_BITCODE:
-    ctx.objs.push_back(new_lto_obj(ctx, mf, ""));
+    if (ObjectFile<E> *file = new_lto_obj(ctx, mf, ""))
+      ctx.objs.push_back(file);
     return;
   default:
-    Fatal(ctx) << mf->name << ": unknown file type: " << type;
-  }
-}
-
-// Read the beginning of a given file and returns its machine type
-// (e.g. EM_X86_64 or EM_386). Return -1 if unknown.
-template <typename E>
-static i64 get_machine_type(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  switch (get_file_type(mf)) {
-  case FileType::ELF_OBJ:
-  case FileType::ELF_DSO:
-  case FileType::GCC_LTO_OBJ:
-    return ((ElfEhdr<E> *)mf->data)->e_machine;
-  case FileType::AR:
-    for (MappedFile<Context<E>> *child : read_fat_archive_members(ctx, mf))
-      if (get_file_type(child) == FileType::ELF_OBJ)
-        return ((ElfEhdr<E> *)child->data)->e_machine;
-    return -1;
-  case FileType::THIN_AR:
-    for (MappedFile<Context<E>> *child : read_thin_archive_members(ctx, mf))
-      if (get_file_type(child) == FileType::ELF_OBJ)
-        return ((ElfEhdr<E> *)child->data)->e_machine;
-    return -1;
-  case FileType::TEXT:
-    return get_script_output_type(ctx, mf);
-  default:
-    return -1;
+    Fatal(ctx) << mf->name << ": unknown file type";
   }
 }
 
 template <typename E>
-static i64
-deduce_machine_type(Context<E> &ctx, std::span<std::string_view> args) {
+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 (i64 type = get_machine_type(ctx, mf); type != -1)
-          return type;
+        if (std::string_view target = get_machine_type(ctx, mf);
+            !target.empty())
+          return target;
   Fatal(ctx) << "-m option is missing";
 }
 
@@ -153,10 +225,10 @@ MappedFile<Context<E>> *open_library(Context<E> &ctx, std::string path) {
   if (!mf)
     return nullptr;
 
-  i64 type = get_machine_type(ctx, mf);
-  if (type == -1 || type == E::e_machine)
+  std::string_view target = get_machine_type(ctx, mf);
+  if (target.empty() || target == E::target_name)
     return mf;
-  Warn(ctx) << path << ": skipping incompatible file " << (int)type
+  Warn(ctx) << path << ": skipping incompatible file " << target
             << " " << (int)E::e_machine;
   return nullptr;
 }
@@ -184,51 +256,80 @@ MappedFile<Context<E>> *find_library(Context<E> &ctx, std::string name) {
 }
 
 template <typename E>
-static void read_input_files(Context<E> &ctx, std::span<std::string_view> args) {
+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;
+    std::string_view arg = args[0];
+    args = args.subspan(1);
 
-    if (read_flag(args, "as-needed")) {
+    if (arg == "--as-needed") {
       ctx.as_needed = true;
-    } else if (read_flag(args, "no-as-needed")) {
+    } else if (arg == "--no-as-needed") {
       ctx.as_needed = false;
-    } else if (read_flag(args, "whole-archive")) {
+    } else if (arg == "--whole-archive") {
       ctx.whole_archive = true;
-    } else if (read_flag(args, "no-whole-archive")) {
+    } else if (arg == "--no-whole-archive") {
       ctx.whole_archive = false;
-    } else if (read_flag(args, "Bstatic")) {
+    } else if (arg == "--Bstatic") {
       ctx.is_static = true;
-    } else if (read_flag(args, "Bdynamic")) {
+    } else if (arg == "--Bdynamic") {
       ctx.is_static = false;
-    } else if (read_flag(args, "start-lib")) {
+    } else if (arg == "--start-lib") {
       ctx.in_lib = true;
-    } else if (read_flag(args, "end-lib")) {
+    } else if (arg == "--end-lib") {
       ctx.in_lib = false;
-    } else if (read_arg(ctx, args, arg, "version-script")) {
-      parse_version_script(ctx, std::string(arg));
-    } else if (read_arg(ctx, args, arg, "dynamic-list")) {
-      parse_dynamic_list(ctx, std::string(arg));
-    } else if (read_flag(args, "push-state")) {
+    } 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 (read_flag(args, "pop-state")) {
+    } 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 (read_arg(ctx, args, arg, "l")) {
+    } 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(args[0])));
-      args = args.subspan(1);
+      read_file(ctx, MappedFile<Context<E>>::must_open(ctx, std::string(arg)));
     }
   }
 
@@ -239,178 +340,32 @@ static void read_input_files(Context<E> &ctx, std::span<std::string_view> args)
 }
 
 template <typename E>
-static i64 get_mtime(Context<E> &ctx, std::string path) {
-  struct stat st;
-  if (stat(path.c_str(), &st) < 0)
-    Fatal(ctx) << path << ": stat failed: " << errno_string();
-  return st.st_mtime;
-}
-
-template <typename E>
-static bool reload_input_files(Context<E> &ctx) {
-  Timer t(ctx, "reload_input_files");
-
-  std::vector<ObjectFile<E> *> objs;
-  std::vector<SharedFile<E> *> dsos;
-
-  // Reload updated .o files
-  for (ObjectFile<E> *file : ctx.objs) {
-    if (file->mf->parent) {
-      if (get_mtime(ctx, file->mf->parent->name) != file->mf->parent->mtime)
-        return false;
-      objs.push_back(file);
-      continue;
-    }
-
-    if (get_mtime(ctx, file->mf->name) == file->mf->mtime) {
-      objs.push_back(file);
-      continue;
-    }
-
-    MappedFile<Context<E>> *mf =
-      MappedFile<Context<E>>::must_open(ctx, file->mf->name);
-    objs.push_back(new_object_file(ctx, mf, file->mf->name));
-  }
-
-  // Reload updated .so files
-  for (SharedFile<E> *file : ctx.dsos) {
-    if (get_mtime(ctx, file->mf->name) == file->mf->mtime) {
-      dsos.push_back(file);
-    } else {
-      MappedFile<Context<E>> *mf =
-        MappedFile<Context<E>>::must_open(ctx, file->mf->name);
-      dsos.push_back(new_shared_file(ctx, mf));
-    }
-  }
-
-  ctx.objs = objs;
-  ctx.dsos = dsos;
-  return true;
-}
-
-template <typename E>
-static void show_stats(Context<E> &ctx) {
-  for (ObjectFile<E> *obj : ctx.objs) {
-    static Counter defined("defined_syms");
-    defined += obj->first_global - 1;
-
-    static Counter undefined("undefined_syms");
-    undefined += obj->symbols.size() - obj->first_global;
-
-    for (std::unique_ptr<InputSection<E>> &sec : obj->sections) {
-      if (!sec || !sec->is_alive)
-        continue;
-
-      static Counter alloc("reloc_alloc");
-      static Counter nonalloc("reloc_nonalloc");
-
-      if (sec->shdr().sh_flags & SHF_ALLOC)
-        alloc += sec->get_rels(ctx).size();
-      else
-        nonalloc += sec->get_rels(ctx).size();
-    }
-
-    static Counter comdats("comdats");
-    comdats += obj->comdat_groups.size();
-
-    static Counter removed_comdats("removed_comdat_mem");
-    for (auto &pair : obj->comdat_groups)
-      if (ComdatGroup *group = pair.first; group->owner != obj->priority)
-        removed_comdats += pair.second.size();
-
-    static Counter num_cies("num_cies");
-    num_cies += obj->cies.size();
-
-    static Counter num_unique_cies("num_unique_cies");
-    for (CieRecord<E> &cie : obj->cies)
-      if (cie.is_leader)
-        num_unique_cies++;
-
-    static Counter num_fdes("num_fdes");
-    num_fdes +=  obj->fdes.size();
-  }
-
-  static Counter num_bytes("total_input_bytes");
-  for (std::unique_ptr<MappedFile<Context<E>>> &mf : ctx.mf_pool)
-    num_bytes += mf->size;
-
-  static Counter num_input_sections("input_sections");
-  for (ObjectFile<E> *file : ctx.objs)
-    num_input_sections += file->sections.size();
-
-  static Counter num_output_chunks("output_chunks", ctx.chunks.size());
-  static Counter num_objs("num_objs", ctx.objs.size());
-  static Counter num_dsos("num_dsos", ctx.dsos.size());
-
-  if constexpr (std::is_same_v<E, ARM64>) {
-    static Counter num_thunks("num_thunks");
-    for (std::unique_ptr<OutputSection<E>> &osec : ctx.output_sections)
-      for (std::unique_ptr<RangeExtensionThunk<E>> &thunk : osec->thunks)
-        num_thunks += thunk->symbols.size();
-  }
-
-  Counter::print();
-
-  for (std::unique_ptr<MergedSection<E>> &sec : ctx.merged_sections)
-    sec->print_stats(ctx);
-}
-
-static 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);
-}
-
-template <typename E>
-static int elf_main(int argc, char **argv) {
+int elf_main(int argc, char **argv) {
   Context<E> ctx;
 
   // Process -run option first. process_run_subcommand() does not return.
-  if (argc >= 2)
-    if (argv[1] == "-run"sv || argv[1] == "--run"sv)
-      process_run_subcommand(ctx, argc, argv);
+  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_view> file_args;
-  parse_nonpositional_args(ctx, file_args);
+  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 == -1)
+  if (ctx.arg.emulation.empty())
     ctx.arg.emulation = deduce_machine_type(ctx, file_args);
 
   // Redo if -m is not x86-64.
-  if (ctx.arg.emulation != E::e_machine) {
-    switch (ctx.arg.emulation) {
-    case EM_386:
-      return elf_main<I386>(argc, argv);
-    case EM_AARCH64:
-      return elf_main<ARM64>(argc, argv);
-    case EM_ARM:
-      return elf_main<ARM32>(argc, argv);
-    case EM_RISCV:
-      return elf_main<RISCV64>(argc, argv);
-    }
-    unreachable();
-  }
+  if constexpr (is_x86_64<E>)
+    if (ctx.arg.emulation != X86_64::target_name)
+      return redo_main(ctx, argc, argv);
 
   Timer t_all(ctx, "all");
 
-  if (ctx.arg.relocatable) {
-    combine_objects(ctx, file_args);
-    return 0;
-  }
-
-  if (!ctx.arg.preload)
-    try_resume_daemon(ctx);
-
-  i64 thread_count = ctx.arg.thread_count;
-  if (thread_count == 0)
-    thread_count = get_default_thread_count();
-  tbb::global_control tbb_cont(tbb::global_control::max_allowed_parallelism,
-                               thread_count);
-
   install_signal_handler();
 
   if (!ctx.arg.directory.empty())
@@ -418,40 +373,34 @@ static int elf_main(int argc, char **argv) {
       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
+
+  acquire_global_lock(ctx);
+
+  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)->wrap = true;
+    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;
 
-  // Preload input files
-  std::function<void()> on_complete;
-  std::function<void()> wait_for_client;
-
-  if (ctx.arg.preload)
-    daemonize(ctx, &wait_for_client, &on_complete);
-  else if (ctx.arg.fork)
-    on_complete = fork_child();
-
   for (std::string_view arg : ctx.arg.trace_symbol)
-    get_symbol(ctx, arg)->traced = true;
+    get_symbol(ctx, arg)->is_traced = true;
 
   // Parse input files
   read_input_files(ctx, file_args);
 
-  if (ctx.arg.preload) {
-    wait_for_client();
-    if (!reload_input_files(ctx)) {
-      std::vector<char *> args(argv, argv + argc);
-      args.push_back((char *)"--no-preload");
-      args.push_back(nullptr);
-      return elf_main<E>(argc + 1, args.data());
-    }
-  }
-
   // Uniquify shared object files by soname
   {
     std::unordered_set<std::string_view> seen;
@@ -460,21 +409,40 @@ static int elf_main(int argc, char **argv) {
     });
   }
 
-  Timer t_total(ctx, "total");
   Timer t_before_copy(ctx, "before_copy");
 
   // Apply -exclude-libs
   apply_exclude_libs(ctx);
 
-  // Resolve symbols and fix the set of object files that are
-  // included to the final output.
+  // 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.
-  register_section_pieces(ctx);
+  // "Kill" .eh_frame input sections after symbol resolution.
+  kill_eh_frame_sections(ctx);
 
-  // Remove redundant comdat sections (e.g. duplicate inline functions).
-  eliminate_comdats(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);
@@ -485,9 +453,13 @@ static int elf_main(int argc, char **argv) {
   // Parse symbol version suffixes (e.g. "foo@ver1").
   parse_symbol_version(ctx);
 
-  // Set is_import and is_export bits for each symbol.
+  // 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 || ctx.arg.z_rewrite_endbr)
+    compute_address_significance(ctx);
+
   // Garbage-collect unreachable sections.
   if (ctx.arg.gc_sections)
     gc_sections(ctx);
@@ -499,20 +471,24 @@ static int elf_main(int argc, char **argv) {
   // Compute sizes of sections containing mergeable strings.
   compute_merged_section_sizes(ctx);
 
-  // Create instances of linker-synthesized sections such as
-  // .got or .plt.
+  // 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.
-  bin_sections(ctx);
+  create_output_sections(ctx);
 
-  // Get a list of output sections.
-  append(ctx.chunks, collect_output_sections(ctx));
-
-  // Create a dummy file containing linker-synthesized symbols
-  // (e.g. `__bss_start`).
-  ctx.internal_obj = create_internal_file(ctx);
-  ctx.objs.push_back(ctx.internal_obj);
+  // 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.
@@ -521,25 +497,31 @@ static int elf_main(int argc, char **argv) {
   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 symbol so that they'll have another chance to be
+  // 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);
 
-  // Make sure that all symbols have been resolved.
-  if (!ctx.arg.allow_multiple_definition)
-    check_duplicate_symbols(ctx);
-
   // Handle --require-defined
   for (std::string_view name : ctx.arg.require_defined)
     if (!get_symbol(ctx, name)->file)
@@ -557,16 +539,6 @@ static int elf_main(int argc, char **argv) {
   if (ctx.arg.shuffle_sections != SHUFFLE_SECTIONS_NONE)
     shuffle_sections(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(ctx.chunks, [&](Chunk<E> *a, Chunk<E> *b) {
-    return get_section_rank(ctx, a) < get_section_rank(ctx, b);
-  });
-
   // Copy string referred by .dynamic to .dynstr.
   for (SharedFile<E> *file : ctx.dsos)
     ctx.dynstr->add_string(file->soname);
@@ -579,9 +551,20 @@ static int elf_main(int argc, char **argv) {
   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_rels(ctx);
+  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
@@ -594,6 +577,10 @@ static int elf_main(int argc, char **argv) {
   // 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);
@@ -610,50 +597,27 @@ static int elf_main(int argc, char **argv) {
   // 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);
 
-  // Update sh_size for each chunk and remove empty ones.
-  for (Chunk<E> *chunk : ctx.chunks)
-    chunk->update_shdr(ctx);
-
-  std::erase_if(ctx.chunks, [](Chunk<E> *chunk) {
-    return !chunk->is_output_section() && chunk->shdr.sh_size == 0;
-  });
-
-  // Set section indices.
-  for (i64 i = 0, shndx = 1; i < ctx.chunks.size(); i++)
-    if (!ctx.chunks[i]->is_header())
-      ctx.chunks[i]->shndx = shndx++;
-
-  // Some types of section header refer other section by index.
-  // Recompute the section header to fill such fields with correct values.
-  for (Chunk<E> *chunk : ctx.chunks)
-    chunk->update_shdr(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 ARM64, we may need to create so-called "range extension thunks"
-  // to extend branch instructions reach, as they can jump only to
-  // ±128 MiB.
-  if constexpr (std::is_same_v<E, ARM64>)
-    filesize = create_range_extension_thunks(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 (std::is_same_v<E, RISCV64>)
+  if constexpr (is_riscv<E>)
     filesize = riscv_resize_sections(ctx);
 
-  // Fix linker-synthesized symbol addresses.
+  // 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
@@ -664,41 +628,19 @@ static int elf_main(int argc, char **argv) {
   if (ctx.arg.compress_debug_sections != COMPRESS_NONE)
     filesize = compress_debug_sections(ctx);
 
-  // At this point, file layout is fixed.
+  // 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.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
-  {
-    Timer t(ctx, "copy_buf");
-
-    tbb::parallel_for_each(ctx.chunks, [&](Chunk<E> *chunk) {
-      std::string name =
-        chunk->name.empty() ? "(header)" : std::string(chunk->name);
-      Timer t2(ctx, name, &t);
-      chunk->copy_buf(ctx);
-    });
-
-    ctx.checkpoint();
-  }
-
-  if constexpr (std::is_same_v<E, ARM64>)
-    write_thunks(ctx);
-
-  if constexpr (std::is_same_v<E, ARM32>)
-    sort_arm_exidx(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);
+  // Copy input sections to the output file and apply relocations.
+  copy_chunks(ctx);
 
   // Dynamic linker works better with sorted .rela.dyn section,
   // so we sort them.
@@ -707,12 +649,20 @@ static int elf_main(int argc, char **argv) {
   // Zero-clear paddings between sections
   clear_padding(ctx);
 
-  if (ctx.buildid) {
-    Timer t(ctx, "build_id");
+  // .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)
+    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)
     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);
@@ -721,16 +671,9 @@ static int elf_main(int argc, char **argv) {
   if (!ctx.arg.dependency_file.empty())
     write_dependency_file(ctx);
 
-  // Handle --print-dependencies
-  if (ctx.arg.print_dependencies == 1)
-    print_dependencies(ctx);
-  else if (ctx.arg.print_dependencies == 2)
-    print_dependencies_full(ctx);
-
   if (ctx.has_lto_object)
     lto_cleanup(ctx);
 
-  t_total.stop();
   t_all.stop();
 
   if (ctx.arg.print_map)
@@ -748,25 +691,25 @@ static int elf_main(int argc, char **argv) {
   if (on_complete)
     on_complete();
 
+  release_global_lock(ctx);
+
   if (ctx.arg.quick_exit)
     _exit(0);
 
   for (std::function<void()> &fn : ctx.on_exit)
     fn();
+  ctx.checkpoint();
   return 0;
 }
 
+#ifdef MOLD_X86_64
 int main(int argc, char **argv) {
   return elf_main<X86_64>(argc, argv);
 }
+#endif
 
-#define INSTANTIATE(E)                                                  \
-  template void read_file(Context<E> &, MappedFile<Context<E>> *);
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template int elf_main<E>(int, char **);
 
 } // namespace mold::elf

elf/mapfile.cc

@@ -40,6 +40,9 @@ static Map<E> get_map(Context<E> &ctx) {
     }
   });
 
+  if (map.size() <= 1)
+    return map;
+
   tbb::parallel_for(map.range(), [](const typename Map<E>::range_type &range) {
     for (auto it = range.begin(); it != range.end(); it++) {
       std::vector<Symbol<E> *> &vec = it->second;
@@ -72,7 +75,7 @@ void print_map(Context<E> &ctx) {
          << std::setw(6) << (u64)osec->shdr.sh_addralign
          << " " << osec->name << "\n";
 
-    if (!osec->is_output_section())
+    if (osec->kind() != OUTPUT_SECTION)
       continue;
 
     std::span<InputSection<E> *> members = ((OutputSection<E> *)osec)->members;
@@ -106,13 +109,8 @@ void print_map(Context<E> &ctx) {
   }
 }
 
-#define INSTANTIATE(E)                          \
-  template void print_map(Context<E> &ctx);
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template void print_map(Context<E> &ctx);
 
 } // namespace mold::elf

elf/mold-wrapper.c

@@ -1,5 +1,8 @@
 #define _GNU_SOURCE 1
 
+#if !defined(__OpenBSD__) && !defined(__FreeBSD__)
+#  include <alloca.h>
+#endif
 #include <dlfcn.h>
 #include <spawn.h>
 #include <stdarg.h>
@@ -19,7 +22,7 @@ static char *get_mold_path() {
   exit(1);
 }
 
-static void debug_print(char *fmt, ...) {
+static void debug_print(const char *fmt, ...) {
   if (!getenv("MOLD_WRAPPER_DEBUG"))
     return;
 
@@ -31,13 +34,25 @@ static void debug_print(char *fmt, ...) {
   va_end(ap);
 }
 
-static void get_args(va_list *ap, int argc, char **argv) {
-  for (int i = 1; i < argc - 1; i++) {
-    char *arg = va_arg(*ap, char *);
-    if (!arg)
-      break;
-    argv[i] = arg;
-  }
+static int count_args(va_list *ap) {
+  va_list aq;
+  va_copy(aq, *ap);
+
+  int i = 0;
+  while (va_arg(aq, char *))
+    i++;
+  va_end(aq);
+  return i;
+}
+
+static void copy_args(char **argv, const char *arg0, va_list *ap) {
+  int i = 1;
+  char *arg;
+  while ((arg = va_arg(*ap, char *)))
+    argv[i++] = arg;
+
+  ((const char **)argv)[0] = arg0;
+  ((const char **)argv)[i] = NULL;
 }
 
 static bool is_ld(const char *path) {
@@ -46,16 +61,15 @@ 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) {
   debug_print("execvpe %s\n", file);
 
-  if (!strcmp(file, "ld") || is_ld(file)) {
+  if (!strcmp(file, "ld") || is_ld(file))
     file = get_mold_path();
-    ((const char **)argv)[0] = file;
-  }
 
   for (int i = 0; envp[i]; i++)
     putenv(envp[i]);
@@ -66,12 +80,8 @@ int execvpe(const char *file, char *const *argv, char *const *envp) {
 
 int execve(const char *path, char *const *argv, char *const *envp) {
   debug_print("execve %s\n", path);
-
-  if (is_ld(path)) {
+  if (is_ld(path))
     path = get_mold_path();
-    ((const char **)argv)[0] = path;
-  }
-
   typeof(execve) *real = dlsym(RTLD_NEXT, "execve");
   return real(path, argv, envp);
 }
@@ -79,8 +89,8 @@ int execve(const char *path, char *const *argv, char *const *envp) {
 int execl(const char *path, const char *arg0, ...) {
   va_list ap;
   va_start(ap, arg0);
-  char *argv[4096] = {(char *)arg0};
-  get_args(&ap, 4096, argv);
+  char **argv = alloca((count_args(&ap) + 2) * sizeof(char *));
+  copy_args(argv, arg0, &ap);
   va_end(ap);
   return execve(path, argv, environ);
 }
@@ -88,8 +98,8 @@ int execl(const char *path, const char *arg0, ...) {
 int execlp(const char *file, const char *arg0, ...) {
   va_list ap;
   va_start(ap, arg0);
-  char *argv[4096] = {(char *)arg0};
-  get_args(&ap, 4096, argv);
+  char **argv = alloca((count_args(&ap) + 2) * sizeof(char *));
+  copy_args(argv, arg0, &ap);
   va_end(ap);
   return execvpe(file, argv, environ);
 }
@@ -97,8 +107,8 @@ int execlp(const char *file, const char *arg0, ...) {
 int execle(const char *path, const char *arg0, ...) {
   va_list ap;
   va_start(ap, arg0);
-  char *argv[4096] = {(char *)arg0};
-  get_args(&ap, 4096, argv);
+  char **argv = alloca((count_args(&ap) + 2) * sizeof(char *));
+  copy_args(argv, arg0, &ap);
   char **env = va_arg(ap, char **);
   va_end(ap);
   return execve(path, argv, env);
@@ -117,12 +127,8 @@ int posix_spawn(pid_t *pid, const char *path,
                 const posix_spawnattr_t *attrp,
                 char *const *argv, char *const *envp) {
   debug_print("posix_spawn %s\n", path);
-
-  if (is_ld(path)) {
+  if (is_ld(path))
     path = get_mold_path();
-    ((const char **)argv)[0] = path;
-  }
-
   typeof(posix_spawn) *real = dlsym(RTLD_NEXT, "posix_spawn");
   return real(pid, path, file_actions, attrp, argv, envp);
 }

elf/output-file.cc

@@ -1,144 +0,0 @@
-#include "mold.h"
-
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace mold::elf {
-
-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.
-  if (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 E>
-class MemoryMappedOutputFile : public OutputFile<E> {
-public:
-  MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(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);
-  }
-
-  void close(Context<E> &ctx) override {
-    Timer t(ctx, "close_file");
-
-    if (!this->is_unmapped)
-      munmap(this->buf, this->filesize);
-
-    if (rename(output_tmpfile, this->path.c_str()) == -1)
-      Fatal(ctx) << this->path << ": rename failed: " << errno_string();
-    output_tmpfile = nullptr;
-  }
-};
-
-template <typename E>
-class MallocOutputFile : public OutputFile<E> {
-public:
-  MallocOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(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(Context<E> &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 E>
-std::unique_ptr<OutputFile<E>>
-OutputFile<E>::open(Context<E> &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;
-  }
-
-  std::unique_ptr<OutputFile<E>> file;
-  if (is_special)
-    file = std::make_unique<MallocOutputFile<E>>(ctx, path, filesize, perm);
-  else
-    file = std::make_unique<MemoryMappedOutputFile<E>>(ctx, path, filesize, perm);
-
-  if (ctx.arg.filler != -1)
-    memset(file->buf, ctx.arg.filler, filesize);
-  return file;
-}
-
-#define INSTANTIATE(E)                          \
-  template class OutputFile<E>;
-
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
-
-} // namespace mold::elf

elf/relocatable.cc

@@ -1,597 +1,200 @@
-// This file implements the -r or ---relocatable option. If the option
-// is given to a linker, the linker creates not an executable nor a
-// shared library file but instead create another object file by
-// combining input object files.
+// This file implements -r or --relocatable. That option forces the linker
+// to combine input object files into another single large object file.
+// Since the behavior of the linker when the option is given is quite
+// different from that of the normal execution mode, we separate code for
+// the feature into this separate file.
 //
-// The behavior of a linker with -r is pretty different from the one
-// without -r, and adding code for -r to the regular code path could
-// severely complicate it. Therefore, we implement -r as an
-// independent feature from others. That's why this file share only a
-// small amount of code with other files.
+// The --relocatable option isn't used very often. After all, if you want
+// to combine object files into a single file, you could use `ar`.
+// However, some programs use it in a creative manner which is hard to be
+// substituted with static archives, so we need to support this option in
+// the same way as GNU ld does. A notable example is GHC (Glasgow Haskell
+// Compiler). GHC has its own dynamic linker which can load a .o file (as
+// opposed to a .so) into memory. GHC's module is not a shared object file
+// but a combined object file.
 //
-// Since the -r option is a minor feature, we don't aim for speed in
-// this file. This is a "better than nothing" implementation of the -r
-// option.
+// There are many different ways to combine object files into a single file.
+// The simplest approach would be to just copy all sections from input files
+// to an output file as-is with a few exceptions for singleton sections such
+// as the symbol table or the string table. That works, but that's not
+// compatible with GNU ld.
 //
-// Here is the strategy as to how to combine multiple object files
-// into one:
+// To be compatible with GNU ld, we need to do the followings:
 //
-//  - Regular sections containing opaque data (e.g. ".text" or
-//    ".data") are just copied as-is without merging.
+//  - Regular sections containing opaque data (e.g. ".text" or ".data")
+//    are just copied as-is. Two sections with the same name are merged.
 //
 //  - .symtab, .strtab and .shstrtab are merged.
 //
 //  - COMDAT groups are uniquified.
 //
-//  - Relocation sections are copied one by one, but we need to fix
-//    symbol indices.
+//  - Relocations are copied, but we need to fix symbol indices.
 
 #include "mold.h"
-#include "../archive-file.h"
 
-#include <unordered_map>
-#include <unordered_set>
+#include <tbb/parallel_for.h>
+#include <tbb/parallel_for_each.h>
 
 namespace mold::elf {
 
-template <typename E> class RObjectFile;
-
+// Create linker-synthesized sections
 template <typename E>
-class RChunk {
-public:
-  RChunk() {
-    out_shdr.sh_addralign = 1;
-  }
+static void r_create_synthetic_sections(Context<E> &ctx) {
+  auto push = [&](auto *x) {
+    ctx.chunks.push_back(x);
+    ctx.chunk_pool.emplace_back(x);
+    return x;
+  };
 
-  virtual ~RChunk() = default;
-  virtual void update_shdr(Context<E> &ctx) {}
-  virtual void write_to(Context<E> &ctx) = 0;
+  ctx.ehdr = push(new OutputEhdr<E>(0));
+  ctx.shdr = push(new OutputShdr<E>);
+  ctx.eh_frame = push(new EhFrameSection<E>);
+  ctx.eh_frame_reloc = push(new EhFrameRelocSection<E>);
+  ctx.strtab = push(new StrtabSection<E>);
+  ctx.symtab = push(new SymtabSection<E>);
+  ctx.shstrtab = push(new ShstrtabSection<E>);
+  ctx.note_property = push(new NotePropertySection<E>);
 
-  std::string_view name;
-  i64 shndx = 0;
-  ElfShdr<E> in_shdr = {};
-  ElfShdr<E> out_shdr = {};
-};
-
-template <typename E>
-class RInputSection : public RChunk<E> {
-public:
-  RInputSection(Context<E> &ctx, RObjectFile<E> &file, const ElfShdr<E> &shdr);
-  void update_shdr(Context<E> &ctx) override;
-  void write_to(Context<E> &ctx) override;
-
-  RObjectFile<E> &file;
-};
-
-template <typename E>
-class RSymtabSection : public RChunk<E> {
-public:
-  RSymtabSection() {
-    this->name = ".symtab";
-    this->out_shdr.sh_type = SHT_SYMTAB;
-    this->out_shdr.sh_entsize = sizeof(ElfSym<E>);
-    this->out_shdr.sh_addralign = E::word_size;
-  }
-
-  void add_local_symbol(Context<E> &ctx, RObjectFile<E> &file, i64 idx);
-  void add_global_symbol(Context<E> &ctx, RObjectFile<E> &file, i64 idx);
-  void update_shdr(Context<E> &ctx) override;
-  void write_to(Context<E> &ctx) override;
-
-  std::unordered_map<std::string_view, i64> sym_map;
-  std::vector<ElfSym<E>> syms{1};
-};
-
-template <typename E>
-class RStrtabSection : public RChunk<E> {
-public:
-  RStrtabSection(std::string_view name) {
-    this->name = name;
-    this->out_shdr.sh_type = SHT_STRTAB;
-    this->out_shdr.sh_size = 1;
-  }
-
-  i64 add_string(std::string_view str);
-  void write_to(Context<E> &ctx) override;
-
-  std::unordered_map<std::string_view, i64> strings;
-};
-
-template <typename E>
-class ROutputEhdr : public RChunk<E> {
-public:
-  ROutputEhdr() {
-    this->out_shdr.sh_size = sizeof(ElfEhdr<E>);
-  }
-
-  void write_to(Context<E> &ctx) override;
-};
-
-template <typename E>
-class ROutputShdr : public RChunk<E> {
-public:
-  ROutputShdr() {
-    this->out_shdr.sh_size = sizeof(ElfShdr<E>);
-  }
-
-  void update_shdr(Context<E> &ctx) override;
-  void write_to(Context<E> &ctx) override;
-};
-
-template <typename E>
-class RObjectFile {
-public:
-  RObjectFile(Context<E> &ctx, MappedFile<Context<E>> &mf, bool is_alive);
-
-  void remove_comdats(Context<E> &ctx,
-                      std::unordered_set<std::string_view> &groups);
-
-  template <typename T>
-  std::span<T> get_data(Context<E> &ctx, const ElfShdr<E> &shdr);
-
-  MappedFile<Context<E>> &mf;
-  std::span<ElfShdr<E>> elf_sections;
-  std::vector<std::unique_ptr<RInputSection<E>>> sections;
-  std::span<const ElfSym<E>> syms;
-  std::vector<i64> symidx;
-  std::unordered_set<std::string_view> defined_syms;
-  std::unordered_set<std::string_view> undef_syms;
-  i64 symtab_shndx = 0;
-  i64 first_global = 0;
-  bool is_alive;
-  const char *strtab = nullptr;
-  const char *shstrtab = nullptr;
-};
-
-template <typename E>
-void RSymtabSection<E>::add_local_symbol(Context<E> &ctx, RObjectFile<E> &file,
-                                         i64 idx) {
-  ElfSym<E> sym = file.syms[idx];
-  assert(sym.st_bind == STB_LOCAL);
-
-  if (!sym.is_undef() && !sym.is_abs() && !sym.is_common()) {
-    if (!file.sections[sym.st_shndx])
-      return;
-    sym.st_shndx = file.sections[sym.st_shndx]->shndx;
-  }
-
-  std::string_view name = file.strtab + sym.st_name;
-  sym.st_name = ctx.r_strtab->add_string(name);
-
-  file.symidx[idx] = syms.size();
-  syms.push_back(sym);
+  if constexpr (is_riscv<E>)
+    ctx.extra.riscv_attributes = push(new RiscvAttributesSection<E>);
 }
 
+// Create SHT_GROUP (i.e. comdat group) sections. We uniquify comdat
+// sections by signature. We want to propagate input comdat groups as
+// output comdat groups if they are still alive after uniquification.
 template <typename E>
-void RSymtabSection<E>::add_global_symbol(Context<E> &ctx, RObjectFile<E> &file,
-                                          i64 idx) {
-  ElfSym<E> sym = file.syms[idx];
-  assert(sym.st_bind != STB_LOCAL);
+static void create_comdat_group_sections(Context<E> &ctx) {
+  Timer t(ctx, "create_comdat_group_sections");
 
-  std::string_view name = file.strtab + sym.st_name;
-  auto [it, inserted] = sym_map.insert({name, syms.size()});
+  std::vector<std::vector<Chunk<E> *>> vec{ctx.objs.size()};
 
-  if (inserted) {
-    if (!sym.is_undef() && !sym.is_abs() && !sym.is_common())
-      sym.st_shndx = file.sections[sym.st_shndx]->shndx;
-    sym.st_name = ctx.r_strtab->add_string(name);
-    file.symidx[idx] = syms.size();
-    syms.push_back(sym);
-    return;
-  }
+  tbb::parallel_for((i64)0, (i64)ctx.objs.size(), [&](i64 i) {
+    ObjectFile<E> &file = *ctx.objs[i];
 
-  file.symidx[idx] = it->second;
-
-  ElfSym<E> &existing = syms[it->second];
-  if (existing.is_undef() && !sym.is_undef()) {
-    if (!sym.is_abs() && !sym.is_common())
-      sym.st_shndx = file.sections[sym.st_shndx]->shndx;
-    sym.st_name = existing.st_name;
-    existing = sym;
-  }
-}
-
-template <typename E>
-void RSymtabSection<E>::update_shdr(Context<E> &ctx) {
-  this->out_shdr.sh_size = syms.size() * sizeof(ElfSym<E>);
-  this->out_shdr.sh_link = ctx.r_strtab->shndx;
-}
-
-template <typename E>
-void RSymtabSection<E>::write_to(Context<E> &ctx) {
-  ElfSym<E> *buf = (ElfSym<E> *)(ctx.buf + this->out_shdr.sh_offset);
-  for (i64 i = 1; i < syms.size(); i++)
-    buf[i] = syms[i];
-}
-
-template <typename E>
-RInputSection<E>::RInputSection(Context<E> &ctx, RObjectFile<E> &file,
-                                const ElfShdr<E> &shdr)
-  : file(file) {
-  this->name = file.shstrtab + shdr.sh_name;
-  this->in_shdr = shdr;
-  this->out_shdr = shdr;
-}
-
-template <typename E>
-void RInputSection<E>::update_shdr(Context<E> &ctx) {
-  switch (this->in_shdr.sh_type) {
-  case SHT_GROUP:
-    this->out_shdr.sh_link = ctx.r_symtab->shndx;
-    this->out_shdr.sh_info = file.symidx[this->in_shdr.sh_info];
-    break;
-  case SHT_REL:
-  case SHT_RELA:
-    this->out_shdr.sh_link = ctx.r_symtab->shndx;
-    this->out_shdr.sh_info = file.sections[this->in_shdr.sh_info]->shndx;
-    break;
-  default:
-    if (this->in_shdr.sh_link) {
-      std::unique_ptr<RInputSection<E>> &sec =
-        file.sections[this->in_shdr.sh_info];
-
-      if (sec)
-        this->out_shdr.sh_link = sec->shndx;
-      else if (this->in_shdr.sh_link == file.symtab_shndx)
-        this->out_shdr.sh_link = ctx.r_symtab->shndx;
-    }
-  }
-}
-
-template <typename E>
-void RInputSection<E>::write_to(Context<E> &ctx) {
-  if (this->in_shdr.sh_type == SHT_NOBITS)
-    return;
-
-  std::span<u8> contents = file.template get_data<u8>(ctx, this->in_shdr);
-  memcpy(ctx.buf + this->out_shdr.sh_offset, contents.data(), contents.size());
-
-  switch (this->in_shdr.sh_type) {
-  case SHT_GROUP: {
-    u32 *mem = (u32 *)(ctx.buf + this->out_shdr.sh_offset);
-    for (i64 i = 1; i < this->out_shdr.sh_size / sizeof(u32); i++)
-      mem[i] = file.sections[mem[i]]->shndx;
-    break;
-  }
-  case SHT_REL:
-  case SHT_RELA: {
-    ElfRel<E> *rel = (ElfRel<E> *)(ctx.buf + this->out_shdr.sh_offset);
-    i64 size = this->out_shdr.sh_size / sizeof(ElfRel<E>);
-
-    for (i64 i = 0; i < size; i++) {
-      const ElfSym<E> &sym = file.syms[rel[i].r_sym];
-      if (sym.is_undef() || sym.is_abs() || sym.is_common() ||
-          file.sections[sym.st_shndx])
-        rel[i].r_sym = file.symidx[rel[i].r_sym];
-      else
-        memset(rel + i, 0, sizeof(ElfRel<E>));
-    }
-
-    i64 i = 0;
-    i64 j = 0;
-    for (; j < size; j++)
-      if (rel[j].r_type)
-        rel[i++] = rel[j];
-    for (; i < size; i++)
-      memset(rel + i, 0, sizeof(ElfRel<E>));
-    break;
-  }
-  }
-}
-
-template <typename E>
-i64 RStrtabSection<E>::add_string(std::string_view str) {
-  auto [it, inserted] = strings.insert({str, this->out_shdr.sh_size});
-  if (inserted)
-    this->out_shdr.sh_size += str.size() + 1;
-  return it->second;
-}
-
-template <typename E>
-void RStrtabSection<E>::write_to(Context<E> &ctx) {
-  for (auto [str, offset] : strings)
-    memcpy(ctx.buf + this->out_shdr.sh_offset + offset, str.data(), str.size());
-}
-
-template <typename E>
-void ROutputEhdr<E>::write_to(Context<E> &ctx) {
-  ElfEhdr<E> &hdr = *(ElfEhdr<E> *)(ctx.buf + this->out_shdr.sh_offset);
-  memcpy(&hdr.e_ident, "\177ELF", 4);
-  hdr.e_ident[EI_CLASS] = (E::word_size == 8) ? ELFCLASS64 : ELFCLASS32;
-  hdr.e_ident[EI_DATA] = E::is_le ? ELFDATA2LSB : ELFDATA2MSB;
-  hdr.e_ident[EI_VERSION] = EV_CURRENT;
-  hdr.e_type = ET_REL;
-  hdr.e_machine = E::e_machine;
-  hdr.e_version = EV_CURRENT;
-  hdr.e_shoff = ctx.r_shdr->out_shdr.sh_offset;
-  hdr.e_ehsize = sizeof(ElfEhdr<E>);
-  hdr.e_shentsize = sizeof(ElfShdr<E>);
-  hdr.e_shstrndx = ctx.r_shstrtab->shndx;
-  hdr.e_shnum = ctx.r_shdr->out_shdr.sh_size / sizeof(ElfShdr<E>);
-  hdr.e_shstrndx = ctx.r_shstrtab->shndx;
-}
-
-template <typename E>
-void ROutputShdr<E>::update_shdr(Context<E> &ctx) {
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    if (chunk->shndx)
-      this->out_shdr.sh_size += sizeof(ElfShdr<E>);
-}
-
-template <typename E>
-void ROutputShdr<E>::write_to(Context<E> &ctx) {
-  ElfShdr<E> *hdr = (ElfShdr<E> *)(ctx.buf + this->out_shdr.sh_offset);
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    if (chunk->shndx)
-      hdr[chunk->shndx] = chunk->out_shdr;
-}
-
-template <typename E>
-RObjectFile<E>::RObjectFile(Context<E> &ctx, MappedFile<Context<E>> &mf,
-                            bool is_alive)
-  : mf(mf), is_alive(is_alive) {
-  // Read ELF header and section header
-  ElfEhdr<E> &ehdr = *(ElfEhdr<E> *)mf.data;
-  ElfShdr<E> *sh_begin = (ElfShdr<E> *)(mf.data + ehdr.e_shoff);
-  i64 num_sections = (ehdr.e_shnum == 0) ? sh_begin->sh_size : ehdr.e_shnum;
-  elf_sections = {sh_begin, sh_begin + num_sections};
-  sections.resize(num_sections);
-
-  // Read .shstrtab
-  i64 shstrtab_idx = (ehdr.e_shstrndx == SHN_XINDEX)
-    ? sh_begin->sh_link : ehdr.e_shstrndx;
-  shstrtab = (char *)(mf.data + elf_sections[shstrtab_idx].sh_offset);
-
-  // Read .symtab
-  for (i64 i = 1; i < elf_sections.size(); i++) {
-    ElfShdr<E> &shdr = elf_sections[i];
-    if (shdr.sh_type == SHT_SYMTAB) {
-      syms = get_data<const ElfSym<E>>(ctx, shdr);
-      strtab = (char *)(mf.data + elf_sections[shdr.sh_link].sh_offset);
-      symtab_shndx = i;
-      first_global = shdr.sh_info;
-      break;
-    }
-  }
-
-  symidx.resize(syms.size());
-
-  // Read sections
-  for (i64 i = 1; i < elf_sections.size(); i++) {
-    ElfShdr<E> &shdr = elf_sections[i];
-    switch (shdr.sh_type) {
-    case SHT_NULL:
-    case SHT_SYMTAB:
-    case SHT_STRTAB:
-      break;
-    default:
-      sections[i].reset(new RInputSection(ctx, *this, shdr));
-    }
-  }
-
-  // Read global symbols
-  for (i64 i = first_global; i < syms.size(); i++) {
-    std::string_view name = strtab + syms[i].st_name;
-    if (syms[i].is_defined())
-      defined_syms.insert(name);
-    else
-      undef_syms.insert(name);
-  }
-}
-
-// Remove duplicate comdat groups
-template <typename E>
-void RObjectFile<E>::remove_comdats(Context<E> &ctx,
-                                    std::unordered_set<std::string_view> &groups) {
-  for (i64 i = 1; i < sections.size(); i++) {
-    if (!sections[i])
-      continue;
-    ElfShdr<E> &shdr = sections[i]->in_shdr;
-    if (shdr.sh_type != SHT_GROUP)
-      continue;
-
-    // Get a comdat group signature and insert it into a set.
-    const ElfSym<E> &sym = syms[shdr.sh_info];
-    std::string_view signature = strtab + sym.st_name;
-    if (groups.insert(signature).second)
-      continue;
-
-    // If it is a duplicate, remove it and its members.
-    for (i64 j : this->template get_data<u32>(ctx, shdr).subspan(1))
-      sections[j] = nullptr;
-    sections[i] = nullptr;
-  }
-}
-
-template <typename E>
-template <typename T>
-std::span<T> RObjectFile<E>::get_data(Context<E> &ctx, const ElfShdr<E> &shdr) {
-  T *begin = (T *)(mf.data + shdr.sh_offset);
-  T *end   = (T *)(mf.data + shdr.sh_offset + shdr.sh_size);
-  return {begin, end};
-}
-
-template <typename E>
-static std::vector<std::unique_ptr<RObjectFile<E>>>
-open_files(Context<E> &ctx, std::span<std::string_view> args) {
-  std::vector<std::unique_ptr<RObjectFile<E>>> files;
-  bool whole_archive = false;
-
-  while (!args.empty()) {
-    if (read_flag(args, "whole-archive")) {
-      whole_archive = true;
-      continue;
-    }
-
-    if (read_flag(args, "no-whole-archive")) {
-      whole_archive = false;
-      continue;
-    }
-
-    std::string_view arg;
-    if (read_arg(ctx, args, arg, "version-script") ||
-        read_arg(ctx, args, arg, "dynamic-list"))
-      continue;
-
-    MappedFile<Context<E>> *mf = nullptr;
-
-    if (read_arg(ctx, args, arg, "l")) {
-      mf = find_library(ctx, std::string(arg));
-    } else {
-      if (arg.starts_with('-'))
+    for (ComdatGroupRef<E> &ref : file.comdat_groups) {
+      if (ref.group->owner != file.priority)
         continue;
-      arg = args[0];
-      args = args.subspan(1);
-      mf = MappedFile<Context<E>>::must_open(ctx, std::string(arg));
-    }
 
-    switch (get_file_type(mf)) {
-    case FileType::ELF_OBJ:
-      files.emplace_back(new RObjectFile<E>(ctx, *mf, true));
-      break;
-    case FileType::AR:
-    case FileType::THIN_AR:
-      for (MappedFile<Context<E>> *child : read_archive_members(ctx, mf))
-        if (get_file_type(child) == FileType::ELF_OBJ)
-          files.emplace_back(new RObjectFile<E>(ctx, *child, whole_archive));
-      break;
-    default:
-      break;
+      Symbol<E> *sym = file.symbols[file.elf_sections[ref.sect_idx].sh_info];
+      assert(sym);
+
+      std::vector<Chunk<E> *> members;
+      for (u32 j : ref.members) {
+        const ElfShdr<E> &shdr = file.elf_sections[j];
+        if (shdr.sh_type == (E::is_rela ? SHT_RELA : SHT_REL)) {
+          InputSection<E> &isec = *file.sections[shdr.sh_info];
+          members.push_back(isec.output_section->reloc_sec.get());
+        } else {
+          InputSection<E> &isec = *file.sections[j];
+          members.push_back(isec.output_section);
+        }
+      }
+
+      vec[i].push_back(new ComdatGroupSection<E>(*sym, std::move(members)));
+    }
+  });
+
+  for (std::vector<Chunk<E> *> &vec2 : vec) {
+    for (Chunk<E> *chunk : vec2) {
+      ctx.chunks.push_back(chunk);
+      ctx.chunk_pool.emplace_back(chunk);
     }
   }
-  return files;
 }
 
+// Unresolved undefined symbols in the -r mode are simply propagated to an
+// output file as undefined symbols. This function guarantees that
+// unresolved undefined symbols belongs to some input file.
 template <typename E>
-static i64 assign_offsets(Context<E> &ctx) {
-  i64 offset = 0;
-  for (RChunk<E> *chunk : ctx.r_chunks) {
-    offset = align_to(offset, chunk->out_shdr.sh_addralign);
-    chunk->out_shdr.sh_offset = offset;
-    offset += chunk->out_shdr.sh_size;
+static void r_claim_unresolved_symbols(Context<E> &ctx) {
+  Timer t(ctx, "r_claim_unresolved_symbols");
+
+  tbb::parallel_for_each(ctx.objs, [&](ObjectFile<E> *file) {
+    if (!file->is_alive)
+      return;
+
+    for (i64 i = file->first_global; i < file->elf_syms.size(); i++) {
+      const ElfSym<E> &esym = file->elf_syms[i];
+      Symbol<E> &sym = *file->symbols[i];
+      if (!esym.is_undef())
+        continue;
+
+      std::scoped_lock lock(sym.mu);
+
+      if (sym.file &&
+          (!sym.esym().is_undef() || sym.file->priority <= file->priority))
+        continue;
+
+      sym.file = file;
+      sym.origin = 0;
+      sym.value = 0;
+      sym.sym_idx = i;
+    }
+  });
+}
+
+// Set output section in-file offsets. Output section memory addresses
+// are left as zero.
+template <typename E>
+static u64 r_set_osec_offsets(Context<E> &ctx) {
+  u64 offset = 0;
+  for (Chunk<E> *chunk : ctx.chunks) {
+    offset = align_to(offset, chunk->shdr.sh_addralign);
+    chunk->shdr.sh_offset = offset;
+    offset += chunk->shdr.sh_size;
   }
   return offset;
 }
 
-static bool contains(std::unordered_set<std::string_view> &a,
-                     std::unordered_set<std::string_view> &b) {
-  for (std::string_view x : b)
-    if (a.contains(x))
-      return true;
-  return false;
-}
-
 template <typename E>
-void combine_objects(Context<E> &ctx, std::span<std::string_view> file_args) {
-  // Read object files
-  std::vector<std::unique_ptr<RObjectFile<E>>> files = open_files(ctx, file_args);
+void combine_objects(Context<E> &ctx) {
+  compute_merged_section_sizes(ctx);
 
-  // Identify needed objects
-  std::unordered_set<std::string_view> undef_syms;
-  auto add_syms = [&](RObjectFile<E> &file) {
-    undef_syms.insert(file.undef_syms.begin(), file.undef_syms.end());
-    for (std::string_view name : file.defined_syms)
-      undef_syms.erase(name);
-    file.is_alive = true;
-  };
+  create_output_sections(ctx);
 
-  for (std::unique_ptr<RObjectFile<E>> &file : files)
-    if (file->is_alive)
-      add_syms(*file);
+  r_create_synthetic_sections(ctx);
 
-  for (;;) {
-    bool added = false;
-    for (std::unique_ptr<RObjectFile<E>> &file : files) {
-      if (!file->is_alive && contains(undef_syms, file->defined_syms)) {
-        add_syms(*file);
-        added = true;
-      }
-    }
-    if (!added)
-      break;
-  }
+  r_claim_unresolved_symbols(ctx);
 
-  std::erase_if(files, [](std::unique_ptr<RObjectFile<E>> &file) {
-    return !file->is_alive;
-  });
+  compute_section_sizes(ctx);
 
-  // Remove duplicate comdat groups
-  std::unordered_set<std::string_view> comdat_groups;
-  for (std::unique_ptr<RObjectFile<E>> &file : files)
-    file->remove_comdats(ctx, comdat_groups);
+  sort_output_sections(ctx);
 
-  // Create headers and linker-synthesized sections
-  ROutputEhdr<E> ehdr;
-  ROutputShdr<E> shdr;
-  RSymtabSection<E> symtab;
-  RStrtabSection<E> shstrtab(".shstrtab");
-  RStrtabSection<E> strtab(".strtab");
+  create_output_symtab(ctx);
 
-  ctx.r_chunks.push_back(&ehdr);
-  ctx.r_chunks.push_back(&shstrtab);
-  ctx.r_chunks.push_back(&strtab);
+  ctx.eh_frame->construct(ctx);
 
-  ctx.r_ehdr = &ehdr;
-  ctx.r_shdr = &shdr;
-  ctx.r_shstrtab = &shstrtab;
-  ctx.r_strtab = &strtab;
-  ctx.r_symtab = &symtab;
+  create_reloc_sections(ctx);
 
-  // Add input sections to output sections
-  for (std::unique_ptr<RObjectFile<E>> &file : files)
-    for (std::unique_ptr<RInputSection<E>> &sec : file->sections)
-      if (sec)
-        ctx.r_chunks.push_back(sec.get());
+  create_comdat_group_sections(ctx);
 
-  ctx.r_chunks.push_back(&symtab);
-  ctx.r_chunks.push_back(&shdr);
+  compute_section_headers(ctx);
 
-  // Assign output section indices
-  i64 shndx = 1;
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    if (chunk != &ehdr && chunk != &shdr)
-      chunk->shndx = shndx++;
+  i64 filesize = r_set_osec_offsets(ctx);
+  ctx.output_file =
+    OutputFile<Context<E>>::open(ctx, ctx.arg.output, filesize, 0666);
+  ctx.buf = ctx.output_file->buf;
 
-  // Add section names to .shstrtab
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    if (chunk->shndx)
-      chunk->out_shdr.sh_name = shstrtab.add_string(chunk->name);
+  copy_chunks(ctx);
+  clear_padding(ctx);
+  ctx.output_file->close(ctx);
+  ctx.checkpoint();
 
-  // Copy symbols from input objects to an output object
-  for (std::unique_ptr<RObjectFile<E>> &file : files)
-    for (i64 i = 1; i < file->first_global; i++)
-      symtab.add_local_symbol(ctx, *file, i);
+  if (ctx.arg.print_map)
+    print_map(ctx);
 
-  symtab.out_shdr.sh_info = symtab.syms.size();
+  if (ctx.arg.stats)
+    show_stats(ctx);
 
-  for (std::unique_ptr<RObjectFile<E>> &file : files)
-    for (i64 i = file->first_global; i < file->syms.size(); i++)
-      symtab.add_global_symbol(ctx, *file, i);
+  if (ctx.arg.perf)
+    print_timer_records(ctx.timer_records);
 
-  // Finalize section header
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    chunk->update_shdr(ctx);
-
-  // Open an output file
-  i64 filesize = assign_offsets(ctx);
-  std::unique_ptr<OutputFile<E>> out =
-    OutputFile<E>::open(ctx, ctx.arg.output, filesize, 0666);
-  memset(out->buf, 0, filesize);
-  ctx.buf = out->buf;
-
-  // Write to the output file
-  for (RChunk<E> *chunk : ctx.r_chunks)
-    chunk->write_to(ctx);
-  out->close(ctx);
+  if (ctx.arg.quick_exit)
+    _exit(0);
 }
 
-#define INSTANTIATE(E)                                                  \
-  template void combine_objects(Context<E> &, std::span<std::string_view>);
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template void combine_objects(Context<E> &);
 
 } // namespace mold::elf

elf/subprocess.cc

@@ -1,21 +1,19 @@
+#if !defined(_WIN32) && !defined(__APPLE__)
+
 #include "mold.h"
-#include "../sha.h"
+#include "config.h"
 
 #include <filesystem>
 #include <signal.h>
-#include <sys/select.h>
-#include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <sys/un.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
-#define DAEMON_TIMEOUT 30
-
 namespace mold::elf {
 
+#ifdef MOLD_X86_64
 // Exiting from a program with large memory usage is slow --
 // it may take a few hundred milliseconds. To hide the latency,
 // we fork a child and let it do the actual linking work.
@@ -55,216 +53,25 @@ std::function<void()> fork_child() {
 
   return [=] {
     char buf[] = {1};
-    int n = write(pipefd[1], buf, 1);
+    [[maybe_unused]] int n = write(pipefd[1], buf, 1);
     assert(n == 1);
   };
 }
-
-static std::string base64(u8 *data, u64 size) {
-  static const char chars[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_";
-
-  std::ostringstream out;
-
-  auto encode = [&](u32 x) {
-    out << chars[x & 0b111111]
-        << chars[(x >> 6) & 0b111111]
-        << chars[(x >> 12) & 0b111111]
-        << chars[(x >> 18) & 0b111111];
-  };
-
-  i64 i = 0;
-  for (; i < size - 3; i += 3)
-    encode((data[i + 2] << 16) | (data[i + 1] << 8) | data[i]);
-
-  if (i == size - 1)
-    encode(data[i]);
-  else if (i == size - 2)
-    encode((data[i + 1] << 8) | data[i]);
-  return out.str();
-}
-
-static std::string compute_sha256(std::span<std::string_view> argv) {
-  SHA256_CTX sha;
-  SHA256_Init(&sha);
-
-  for (std::string_view arg : argv) {
-    if (arg != "-preload" && arg != "--preload") {
-      SHA256_Update(&sha, arg.data(), arg.size());
-      char buf[] = {0};
-      SHA256_Update(&sha, buf, 1);
-    }
-  }
-
-  u8 digest[SHA256_SIZE];
-  SHA256_Final(digest, &sha);
-  return base64(digest, SHA256_SIZE);
-}
+#endif
 
 template <typename E>
-static void send_fd(Context<E> &ctx, i64 conn, i64 fd) {
-  struct iovec iov;
-  char dummy = '1';
-  iov.iov_base = &dummy;
-  iov.iov_len = 1;
-
-  struct msghdr msg = {};
-  msg.msg_iov = &iov;
-  msg.msg_iovlen = 1;
-
-  char buf[CMSG_SPACE(sizeof(int))];
-  msg.msg_control = buf;
-  msg.msg_controllen = CMSG_LEN(sizeof(int));
-
-  struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
-  cmsg->cmsg_level = SOL_SOCKET;
-  cmsg->cmsg_type = SCM_RIGHTS;
-  cmsg->cmsg_len = CMSG_LEN(sizeof(int));
-  *(int *)CMSG_DATA(cmsg) = fd;
-
-  if (sendmsg(conn, &msg, 0) == -1)
-    Fatal(ctx) << "sendmsg failed: " << errno_string();
-}
-
-template <typename E>
-static i64 recv_fd(Context<E> &ctx, i64 conn) {
-  struct iovec iov;
-  char buf[1];
-  iov.iov_base = buf;
-  iov.iov_len = sizeof(buf);
-
-  struct msghdr msg = {};
-  msg.msg_iov = &iov;
-  msg.msg_iovlen = 1;
-
-  char cmsgbuf[CMSG_SPACE(sizeof(int))];
-  msg.msg_control = (caddr_t)cmsgbuf;
-  msg.msg_controllen = sizeof(cmsgbuf);
-
-  i64 len = recvmsg(conn, &msg, 0);
-  if (len <= 0)
-    Fatal(ctx) << "recvmsg failed: " << errno_string();
-
-  struct cmsghdr *cmsg;
-  cmsg = CMSG_FIRSTHDR(&msg);
-  return *(int *)CMSG_DATA(cmsg);
-}
-
-template <typename E>
-void try_resume_daemon(Context<E> &ctx) {
-  i64 conn = socket(AF_UNIX, SOCK_STREAM, 0);
-  if (conn == -1)
-    Fatal(ctx) << "socket failed: " << errno_string();
-
-  std::string path = "/tmp/mold-" + compute_sha256(ctx.cmdline_args);
-
-  struct sockaddr_un name = {};
-  name.sun_family = AF_UNIX;
-  memcpy(name.sun_path, path.data(), path.size());
-
-  if (connect(conn, (struct sockaddr *)&name, sizeof(name)) != 0) {
-    close(conn);
-    return;
-  }
-
-  send_fd(ctx, conn, STDOUT_FILENO);
-  send_fd(ctx, conn, STDERR_FILENO);
-
-  char buf[1];
-  i64 r = read(conn, buf, 1);
-  close(conn);
-  if (r == 1)
-    exit(0);
-}
-
-template <typename E>
-void daemonize(Context<E> &ctx, std::function<void()> *wait_for_client,
-               std::function<void()> *on_complete) {
-  if (daemon(1, 0) == -1)
-    Fatal(ctx) << "daemon failed: " << errno_string();
-
-  i64 sock = socket(AF_UNIX, SOCK_STREAM, 0);
-  if (sock == -1)
-    Fatal(ctx) << "socket failed: " << errno_string();
-
-  socket_tmpfile =
-    strdup(("/tmp/mold-" + compute_sha256(ctx.cmdline_args)).c_str());
-
-  struct sockaddr_un name = {};
-  name.sun_family = AF_UNIX;
-  strcpy(name.sun_path, socket_tmpfile);
-
-  u32 orig_mask = umask(0177);
-
-  if (bind(sock, (struct sockaddr *)&name, sizeof(name)) == -1) {
-    if (errno != EADDRINUSE)
-      Fatal(ctx) << "bind failed: " << errno_string();
-
-    unlink(socket_tmpfile);
-    if (bind(sock, (struct sockaddr *)&name, sizeof(name)) == -1)
-      Fatal(ctx) << "bind failed: " << errno_string();
-  }
-
-  umask(orig_mask);
-
-  if (listen(sock, 0) == -1)
-    Fatal(ctx) << "listen failed: " << errno_string();
-
-  static i64 conn = -1;
-
-  *wait_for_client = [=, &ctx] {
-    fd_set rfds;
-    FD_ZERO(&rfds);
-    FD_SET(sock, &rfds);
-
-    struct timeval tv;
-    tv.tv_sec = DAEMON_TIMEOUT;
-    tv.tv_usec = 0;
-
-    i64 res = select(sock + 1, &rfds, NULL, NULL, &tv);
-    if (res == -1)
-      Fatal(ctx) << "select failed: " << errno_string();
-
-    if (res == 0) {
-      std::cout << "timeout\n";
-      exit(0);
-    }
-
-    conn = accept(sock, NULL, NULL);
-    if (conn == -1)
-      Fatal(ctx) << "accept failed: " << errno_string();
-    unlink(socket_tmpfile);
-
-    dup2(recv_fd(ctx, conn), STDOUT_FILENO);
-    dup2(recv_fd(ctx, conn), STDERR_FILENO);
-  };
-
-  *on_complete = [=] {
-    char buf[] = {1};
-    int n = write(conn, buf, 1);
-    assert(n == 1);
-  };
-}
-
-static std::string get_self_path() {
-  return std::filesystem::read_symlink("/proc/self/exe");
-}
-
-template <typename E>
-std::string find_dso(Context<E> &ctx, std::filesystem::path self) {
+static std::string find_dso(Context<E> &ctx, std::filesystem::path self) {
   // Look for mold-wrapper.so from the same directory as the executable is.
   std::filesystem::path path = self.parent_path() / "mold-wrapper.so";
   std::error_code ec;
   if (std::filesystem::is_regular_file(path, ec) && !ec)
     return path;
 
-#ifdef LIBDIR
-  // If not found, search $(LIBDIR)/mold, which is /usr/local/lib/mold
+  // If not found, search $(MOLD_LIBDIR)/mold, which is /usr/local/lib/mold
   // by default.
-  path = LIBDIR "/mold/mold-wrapper.so";
+  path = MOLD_LIBDIR "/mold/mold-wrapper.so";
   if (std::filesystem::is_regular_file(path, ec) && !ec)
     return path;
-#endif
 
   // Look for ../lib/mold/mold-wrapper.so
   path = self.parent_path() / "../lib/mold/mold-wrapper.so";
@@ -277,8 +84,8 @@ std::string find_dso(Context<E> &ctx, std::filesystem::path self) {
 template <typename E>
 [[noreturn]]
 void process_run_subcommand(Context<E> &ctx, int argc, char **argv) {
-  std::string_view arg1 = argv[1];
-  assert(arg1 == "-run" || arg1 == "--run");
+  assert(argv[1] == "-run"s || argv[1] == "--run"s);
+
   if (!argv[2])
     Fatal(ctx) << "-run: argument missing";
 
@@ -306,16 +113,10 @@ void process_run_subcommand(Context<E> &ctx, int argc, char **argv) {
   Fatal(ctx) << "mold -run failed: " << argv[2] << ": " << errno_string();
 }
 
-#define INSTANTIATE(E)                                                  \
-  template void try_resume_daemon(Context<E> &);                        \
-  template void daemonize(Context<E> &, std::function<void()> *,        \
-                          std::function<void()> *);                     \
-  template void process_run_subcommand(Context<E> &, int, char **)
+using E = MOLD_TARGET;
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template void process_run_subcommand(Context<E> &, int, char **);
 
 } // namespace mold::elf
+
+#endif

elf/thunks.cc

@@ -0,0 +1,305 @@
+// RISC instructions are usually up to 4 bytes long, so the immediates of
+// their branch instructions are naturally smaller than 32 bits.  This is
+// contrary to x86-64 on which branch instructions take 4 bytes immediates
+// and can jump to anywhere within PC ± 2 GiB.
+//
+// In fact, ARM32's branch instructions can jump only within ±16 MiB and
+// ARM64's ±128 MiB, for example. If a branch target is further than that,
+// we need to let it branch to a linker-synthesized code sequence that
+// construct a full 32 bit address in a register and jump there. That
+// linker-synthesized code is called "thunk".
+//
+// The function in this file creates thunks.
+//
+// Note that although thunks play an important role in an executable, they
+// don't take up too much space in it. For example, among the clang-16's
+// text segment whose size is ~300 MiB on ARM64, thunks in total occupy
+// only ~30 KiB or 0.01%. Of course the number depends on an ISA; we would
+// need more thunks on ARM32 whose branch range is shorter than ARM64.
+// That said, the total size of thunks still isn't that much. Therefore,
+// we don't need to try too hard to reduce thunk size to the absolute
+// minimum.
+
+#if MOLD_ARM32 || MOLD_ARM64 || MOLD_PPC32 || MOLD_PPC64V1 || MOLD_PPC64V2 || \
+    MOLD_LOONGARCH64 || MOLD_LOONGARCH32
+
+#include "mold.h"
+
+#include <tbb/parallel_for.h>
+#include <tbb/parallel_for_each.h>
+
+namespace mold::elf {
+
+using E = MOLD_TARGET;
+
+// Returns a branch reach in bytes for a given target.
+static consteval i64 max_distance() {
+  // ARM64's branch has 26 bits immediate. The immediate is padded with
+  // implicit two-bit zeros because all instructions are 4 bytes aligned
+  // and therefore the least two bits are always zero. So the branch
+  // operand is effectively 28 bits long. That means the branch range is
+  // [-2^27, 2^27) or PC ± 128 MiB.
+  //
+  // LoongArch's BR instruction also takes a 26 bit immediate.
+  if (is_arm64<E> || is_loongarch<E>)
+    return 1 << 27;
+
+  // ARM32's Thumb branch has 24 bits immediate, and the instructions are
+  // aligned to 2, so it's effectively 25 bits. It's [-2^24, 2^24) or PC ±
+  // 16 MiB.
+  //
+  // ARM32's non-Thumb branches have twice longer range than its Thumb
+  // counterparts, but we conservatively use the Thumb's limitation.
+  if (is_arm32<E>)
+    return 1 << 24;
+
+  // PPC's branch has 24 bits immediate, and the instructions are aligned
+  // to 4, therefore the reach is [-2^25, 2^25) or PC ± 32 MiB.
+  assert(is_ppc<E>);
+  return 1 << 25;
+}
+
+// We create thunks for each 12.8/1.6/3.2 MiB code block for
+// ARM64/ARM32/PPC, respectively.
+static constexpr i64 batch_size = max_distance() / 10;
+
+// We assume that a single thunk group is smaller than 100 KiB.
+static constexpr i64 max_thunk_size = 102400;
+
+static_assert(max_thunk_size / E::thunk_size < INT16_MAX);
+
+template <typename E>
+static bool is_reachable(Context<E> &ctx, InputSection<E> &isec,
+                         Symbol<E> &sym, const ElfRel<E> &rel) {
+  // We create thunks with a pessimistic assumption that all
+  // out-of-section relocations would be out-of-range.
+  InputSection<E> *isec2 = sym.get_input_section();
+  if (!isec2 || isec.output_section != isec2->output_section)
+    return false;
+
+  // Even if the target is the same section, we branch to its PLT
+  // if it has one. So a symbol with a PLT is also considered an
+  // out-of-section reference.
+  if (sym.has_plt(ctx))
+    return false;
+
+  // If the target section is in the same output section but
+  // hasn't got any address yet, that's unreacahble.
+  if (isec2->offset == -1)
+    return false;
+
+  // Thumb and ARM B instructions cannot be converted to BX, so we
+  // always have to make them jump to a thunk to switch processor mode
+  // even if their destinations are within their ranges.
+  if constexpr (is_arm32<E>) {
+    bool is_thumb = sym.get_addr(ctx) & 1;
+    if ((rel.r_type == R_ARM_THM_JUMP24 && !is_thumb) ||
+        (rel.r_type == R_ARM_JUMP24 && is_thumb) ||
+        (rel.r_type == R_ARM_PLT32 && is_thumb))
+      return false;
+  }
+
+  // PowerPC before Power9 lacks PC-relative load/store instructions.
+  // Functions compiled for Power9 or earlier assume that r2 points to
+  // GOT+0x8000, while those for Power10 uses r2 as a scratch register.
+  // We need to a thunk to recompute r2 for interworking.
+  if constexpr (is_ppc64v2<E>) {
+    if (rel.r_type == R_PPC64_REL24 && !sym.esym().preserves_r2())
+      return false;
+    if (rel.r_type == R_PPC64_REL24_NOTOC && sym.esym().uses_toc())
+      return false;
+  }
+
+  // Compute a distance between the relocated place and the symbol
+  // and check if they are within reach.
+  i64 S = sym.get_addr(ctx, NO_OPD);
+  i64 A = get_addend(isec, rel);
+  i64 P = isec.get_addr() + rel.r_offset;
+  i64 val = S + A - P;
+  return -max_distance() <= val && val < max_distance();
+}
+
+static void reset_thunk(RangeExtensionThunk<E> &thunk) {
+  for (Symbol<E> *sym : thunk.symbols) {
+    sym->extra.thunk_idx = -1;
+    sym->extra.thunk_sym_idx = -1;
+    sym->flags = 0;
+  }
+}
+
+// Scan relocations to collect symbols that need thunks.
+static void scan_rels(Context<E> &ctx, InputSection<E> &isec,
+                      RangeExtensionThunk<E> &thunk, i64 thunk_idx) {
+  std::span<const ElfRel<E>> rels = isec.get_rels(ctx);
+  std::vector<RangeExtensionRef> &range_extn = isec.extra.range_extn;
+  range_extn.resize(rels.size());
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (!is_func_call_rel(rel))
+      continue;
+
+    // Skip if the symbol is undefined. apply_reloc() will report an error.
+    Symbol<E> &sym = *isec.file.symbols[rel.r_sym];
+    if (!sym.file)
+      continue;
+
+    // Skip if the destination is within reach.
+    if (is_reachable(ctx, isec, sym, rel))
+      continue;
+
+    // This relocation needs a thunk. If the symbol is already in a
+    // previous thunk, reuse it.
+    if (sym.extra.thunk_idx != -1) {
+      range_extn[i].thunk_idx = sym.extra.thunk_idx;
+      range_extn[i].sym_idx = sym.extra.thunk_sym_idx;
+      continue;
+    }
+
+    // Otherwise, add the symbol to the current thunk if it's not
+    // added already.
+    range_extn[i].thunk_idx = thunk_idx;
+    range_extn[i].sym_idx = -1;
+
+    if (sym.flags.exchange(-1) == 0) {
+      std::scoped_lock lock(thunk.mu);
+      thunk.symbols.push_back(&sym);
+    }
+  }
+}
+
+template <>
+void OutputSection<E>::create_range_extension_thunks(Context<E> &ctx) {
+  std::span<InputSection<E> *> m = members;
+  if (m.empty())
+    return;
+
+  m[0]->offset = 0;
+
+  // Initialize input sections with a dummy offset so that we can
+  // distinguish sections that have got an address with the one who
+  // haven't.
+  tbb::parallel_for((i64)1, (i64)m.size(), [&](i64 i) {
+    m[i]->offset = -1;
+  });
+
+  // We create thunks from the beginning of the section to the end.
+  // We manage progress using four offsets which increase monotonically.
+  // The locations they point to are always A <= B <= C <= D.
+  //
+  // Input sections between B and C are in the current batch.
+  //
+  // A is the input section with the smallest address than can reach
+  // anywhere from the current batch.
+  //
+  // D is the input section with the largest address such that the thunk
+  // is reachable from the current batch if it's inserted right before D.
+  //
+  //  ................................ <input sections> ............
+  //     A    B    C    D
+  //                    ^ We insert a thunk for the current batch just before D
+  //          <--->       The current batch, which is smaller than batch_size
+  //     <-------->       Smaller than max_distance
+  //          <-------->  Smaller than max_distance
+  //     <------------->  Reachable from the current batch
+  i64 a = 0;
+  i64 b = 0;
+  i64 c = 0;
+  i64 d = 0;
+  i64 offset = 0;
+
+  // The smallest thunk index that is reachable from the current batch.
+  i64 t = 0;
+
+  while (b < m.size()) {
+    // Move C forward so that C is apart from B by BATCH_SIZE. We want
+    // to make sure that there's at least one section between B and C
+    // to ensure progress.
+    c = b + 1;
+    while (c < m.size() &&
+           m[c]->offset + m[c]->sh_size < m[b]->offset + batch_size)
+      c++;
+
+    // Move D foward as far as we can jump from B to anywhere in a thunk at D.
+    d = c;
+    while (d < m.size() &&
+           align_to(offset, 1 << m[d]->p2align) + m[d]->sh_size + max_thunk_size <
+           m[b]->offset + max_distance())
+      d++;
+
+    // Move A forward so that A is reachable from C.
+    i64 c_offset = (c == m.size()) ? offset : m[c]->offset;
+    while (a < b && a < m.size() && m[a]->offset + max_distance() < c_offset)
+      a++;
+
+    // Assign offsets to all sections before D.
+    for (i64 i = b; i < d; i++) {
+      offset = align_to(offset, 1 << m[i]->p2align);
+      m[i]->offset = offset;
+      offset += m[i]->sh_size;
+    }
+
+    // Erase references to out-of-range thunks.
+    while (t < thunks.size() && thunks[t]->offset < m[a]->offset)
+      reset_thunk(*thunks[t++]);
+
+    // Create a new thunk and place it at D.
+    offset = align_to(offset, RangeExtensionThunk<E>::alignment);
+    i64 thunk_idx = thunks.size();
+    RangeExtensionThunk<E> *thunk = new RangeExtensionThunk<E>(*this, offset);
+    thunks.emplace_back(thunk);
+
+    // Scan relocations between B and C to collect symbols that need
+    // entries in the new thunk.
+    tbb::parallel_for_each(m.begin() + b, m.begin() + c,
+                           [&](InputSection<E> *isec) {
+      scan_rels(ctx, *isec, *thunk, thunk_idx);
+    });
+
+    // Now that we know the number of symbols in the thunk, we can compute
+    // the thunk's size.
+    assert(thunk->size() < max_thunk_size);
+    offset += thunk->size();
+
+    // Sort symbols added to the thunk to make the output deterministic.
+    sort(thunk->symbols, [](Symbol<E> *a, Symbol<E> *b) {
+      return std::tuple{a->file->priority, a->sym_idx} <
+             std::tuple{b->file->priority, b->sym_idx};
+    });
+
+    // Assign offsets within the thunk to the symbols.
+    for (i64 i = 0; i < thunk->symbols.size(); i++) {
+      Symbol<E> &sym = *thunk->symbols[i];
+      sym.extra.thunk_idx = thunk_idx;
+      sym.extra.thunk_sym_idx = i;
+    }
+
+    // Scan relocations again to fix symbol offsets in the last thunk.
+    tbb::parallel_for_each(m.begin() + b, m.begin() + c,
+                           [&](InputSection<E> *isec) {
+      std::span<Symbol<E> *> syms = isec->file.symbols;
+      std::span<const ElfRel<E>> rels = isec->get_rels(ctx);
+      std::span<RangeExtensionRef> range_extn = isec->extra.range_extn;
+
+      for (i64 i = 0; i < rels.size(); i++)
+        if (range_extn[i].thunk_idx == thunk_idx)
+          range_extn[i].sym_idx = syms[rels[i].r_sym]->extra.thunk_sym_idx;
+    });
+
+    // Move B forward to point to the begining of the next batch.
+    b = c;
+  }
+
+  while (t < thunks.size())
+    reset_thunk(*thunks[t++]);
+
+  this->shdr.sh_size = offset;
+
+  for (InputSection<E> *isec : members)
+    this->shdr.sh_addralign =
+      std::max<u32>(this->shdr.sh_addralign, 1 << isec->p2align);
+}
+
+} // namespace mold::elf
+
+#endif

elf/tls.cc

@@ -0,0 +1,213 @@
+// This file contains helper functions for thread-local storage (TLS).
+// TLS is probably the most obscure feature the linker has to support,
+// so I'll explain it in detail in this comment.
+//
+// TLS is a per-thread storage. Thread-local variables (TLVs) are in a TLS
+// so that each thread has its own set of thread-local variables. Taking
+// an address of a TLV returns a unique value for each thread. For example,
+// `&foo` for the following code returns different pointer values for
+// different threads.
+//
+//   thread_local int foo;
+//
+// TLV is a relatively new feature. C for example didn't provide the
+// official support for it through the keyword `thread_local` until C11.
+// TLV needs a coordination between the compiler, the linker and the
+// runtime to work correctly.
+//
+// An ELF exectuable or a shared library using TLV contains a "TLS template
+// image" in the PT_TLS segment. For each newly created thread including the
+// initial one, the runtime allocates a contiguous memory for an executable
+// and its depending shared libraries and copies template images there. That
+// per-thread memory is called the "initial TLS block". After allocating and
+// initializing the initial TLS block, the runtime sets a register to refer
+// to the initial TLS block, so that the thread-local variables are
+// accessible relative to the register.
+//
+// The register referring to the per-thread storage is called the Thread
+// Pointer (TP). TP is part of the thread's context. When the kernel
+// scheduler switches threads, TP is saved and restored automatically just
+// like other registers are.
+//
+// The TLS template image is read-only. It contains TLVs' initial values
+// for new threads, and no one writes to it at runtime.
+//
+// Now, let's think about how to access a TLV. We need to know the TLV's
+// address to access it which can be done in several different ways as
+// follows:
+//
+//  1. If we are creating an executable, we know the exact size of the TLS
+//     template image we are creating, and we know where the TP will be set
+//     to after the template is copied to the initial TLS block. Therefore,
+//     the TP-relative address of a TLV in the main executable is known at
+//     link-time. That means, computing a TLV's address can be as easy as
+//     `add %dst, %tp, <link-time constant>`.
+//
+//  2. If we are creating a shared library, we don't exactly know where
+//     its TLS template image will be copied to in terms of the
+//     TP-relative address, because we don't know how large the main
+//     executable's and other libraries' TLS template images are. Only the
+//     runtime knows the exact TP-relative address.
+//
+//     We can solve the problem with an indirection. Specifically, for
+//     each TLV whose TP-relative address is known only at process startup
+//     time, we create a GOT entry to store its TP-relative address. We
+//     then emit a dynamic relocation to let the runtime to fill the GOT
+//     entry with a TP-relative address.
+//
+//     Computing a TLV address in this scheme needs at least two machine
+//     instructions in most ISAs; the first instruction loads a value from
+//     the GOT entry, and the second one adds the loaded value to TP.
+//
+//  3. Now, think about libraries that are dynamically loaded with dlopen.
+//     The TLS block for such library may not be allocated next to the
+//     initial TLS block, so we can have two or more discontiguous TLS
+//     blocks. There's no easy formula to compute an address of a TLV in a
+//     separate TLS block.
+//
+//     The address of a TLV in a separate TLS block can be obtained by
+//     calling the libc-provided function, __tls_get_addr(). The function
+//     takes two arguments; a module ID to identify the ELF file and the
+//     TLV's offset within the ELF file's TLS template image. Accessing a
+//     TLV is sometimes compiled to a function call! The module ID and the
+//     offset are usually stored to GOT as two consecutive words.
+//
+// The last access method is the most generic, so the compiler emits such
+// code by default. But that's the most expensive one, so the linker
+// rewrites instructions if possible so that 3) is relaxed to 2) or even
+// to 1).
+//
+// 1) is called the Local Exec access model. 2) is Initial Exec, and 3) is
+// General Dynamic.
+//
+// There's another little trick that the compiler can use if it knows two
+// TLVs are in the same ELF file (usually in the same file as the code is).
+// In this case, we can call __tls_get_addr() only once with a module ID and
+// the offset 0 to obtain the base address of the ELF file's TLS block. The
+// base address obtained this way is sometimes called Dynamic Thread Pointer
+// or DTP. We can then compute TLVs' addresses by adding their DTP-relative
+// addresses to DTP. This access model is called the Local Dynamic.
+//
+// === TLS Descriptor access model ===
+//
+// As described above, there are arguably too many different TLS access
+// models from the most generic one you can use in any ELF file to the most
+// efficient one you can use only when building a main executable. Compiling
+// source code with an appropriate TLS access model is bothersome. To solve
+// the problem, a new TLS access model was proposed. That is called the TLS
+// Descriptor (TLSDESC) model.
+//
+// For a TLV compiled with TLSDESC, we allocate two consecutive GOT slots
+// and create a TLSDESC dynamic relocation for them. The dynamic linker
+// sets a function pointer to the first GOT slot and its argument to the
+// second slot.
+//
+// To access the TLV, we call the function pointer with the argument we
+// read from the second GOT slot. The function returns the TLV's
+// TP-relative address.
+//
+// The runtime chooses the best access method depending on the situation
+// and sets a pointer to the most efficient code to the first GOT slot.
+// For example, if a TLV's TP-relative address is known at process startup
+// time, the runtime sets that address to the second GOT slot and set a
+// function that just returns its argument to the first GOT slot.
+//
+// With TLSDECS, the compiler can always emit the same code for TLVs
+// without sacrificing runtime performance.
+//
+// TLSDESC is better than the traditional, non-TLSDESC TLS access models.
+// It's the default on ARM64, but on other targets, TLSDESC is
+// unfortunately either optional or even not supported at all. So we still
+// need to support both the traditional TLS models and the TLSDESC model.
+
+#include "mold.h"
+
+namespace mold::elf {
+
+template <typename E>
+static ElfPhdr<E> *get_tls_segment(Context<E> &ctx) {
+  if (ctx.phdr)
+    for (ElfPhdr<E> &phdr : ctx.phdr->phdrs)
+      if (phdr.p_type == PT_TLS)
+        return &phdr;
+  return nullptr;
+}
+
+template <typename E>
+u64 get_tls_begin(Context<E> &ctx) {
+  if (ElfPhdr<E> *phdr = get_tls_segment(ctx))
+    return phdr->p_vaddr;
+  return 0;
+}
+
+// Returns the TP address which can be used for efficient TLV accesses in
+// the main executable. TP at runtime refers to a per-process TLS block
+// whose address is not known at link-time. So the address returned from
+// this function is the TP if the TLS template image were a TLS block.
+template <typename E>
+u64 get_tp_addr(Context<E> &ctx) {
+  ElfPhdr<E> *phdr = get_tls_segment(ctx);
+  if (!phdr)
+    return 0;
+
+  if constexpr (is_x86<E> || is_sparc<E> || is_s390x<E>) {
+    // On x86, SPARC and s390x, TP (%gs on i386, %fs on x86-64, %g7 on SPARC
+    // and %a0/%a1 on s390x) refers to past the end of the TLS block for
+    // historical reasons. TLVs are accessed with negative offsets from TP.
+    return align_to(phdr->p_vaddr + phdr->p_memsz, phdr->p_align);
+  } else if constexpr (is_arm<E> || is_sh4<E> || is_alpha<E>) {
+    // On ARM, SH4 and Alpha, the runtime appends two words at the beginning
+    // of TLV template image when copying TLVs to the TLS block, so we need
+    // to offset it.
+    return align_down(phdr->p_vaddr - sizeof(Word<E>) * 2, phdr->p_align);
+  } else if constexpr (is_ppc<E> || is_m68k<E>) {
+    // On PowerPC and m68k, TP is 0x7000 (28 KiB) past the beginning
+    // of the TLV block to maximize the addressable range of load/store
+    // instructions with 16-bits signed immediates. It's not exactly 0x8000
+    // (32 KiB) off because there's a small implementation-defined piece of
+    // data before the initial TLV block, and the runtime wants to access
+    // them efficiently too.
+    return phdr->p_vaddr + 0x7000;
+  } else {
+    // RISC-V and LoongArch just uses the beginning of the main executable's
+    // TLV block as TP. Their load/store instructions usually take 12-bits
+    // signed immediates, so the beginning of the TLS block ± 2 KiB is
+    // accessible with a single load/store instruction.
+    static_assert(is_riscv<E> || is_loongarch<E>);
+    return phdr->p_vaddr;
+  }
+}
+
+// Returns the address __tls_get_addr() would return if it's called
+// with offset 0.
+template <typename E>
+u64 get_dtp_addr(Context<E> &ctx) {
+  ElfPhdr<E> *phdr = get_tls_segment(ctx);
+  if (!phdr)
+    return 0;
+
+  if constexpr (is_ppc<E> || is_m68k<E>) {
+    // On PowerPC and m68k, R_DTPOFF is resolved to the address 0x8000
+    // (32 KiB) past the start of the TLS block. The bias maximizes the
+    // accessible range of load/store instructions with 16-bits signed
+    // immediates. That is, if the offset were right at the beginning of the
+    // start of the TLS block, the half of addressible space (negative
+    // immediates) would have been wasted.
+    return phdr->p_vaddr + 0x8000;
+  } else if constexpr (is_riscv<E>) {
+    // On RISC-V, the bias is 0x800 as the load/store instructions in the
+    // ISA usually have a 12-bit immediate.
+    return phdr->p_vaddr + 0x800;
+  } else {
+    // On other targets, DTP simply refers to the beginning of the TLS block.
+    return phdr->p_vaddr;
+  }
+}
+
+using E = MOLD_TARGET;
+
+template u64 get_tls_begin<E>(Context<E> &);
+template u64 get_tp_addr<E>(Context<E> &);
+template u64 get_dtp_addr<E>(Context<E> &);
+
+} // namespace mold::elf

install-build-deps.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+set -e
+. /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.*)
+  apt-get update
+  apt-get install -y cmake gcc g++ g++-10
+  apt-get install -y file
+  ;;
+ubuntu-* | pop-* | linuxmint-* | debian-* | raspbian-*)
+  apt-get update
+  apt-get install -y cmake gcc g++
+  apt-get install -y file
+  ;;
+fedora-*)
+  dnf install -y gcc-g++ cmake
+  dnf install -y glibc-static file libstdc++-static diffutils util-linux
+  ;;
+opensuse-leap-*)
+  zypper install -y make cmake gcc-c++ gcc11-c++
+  zypper install -y glibc-devel-static tar diffutils util-linux
+  ;;
+opensuse-tumbleweed-*)
+  zypper install -y make cmake gcc-c++
+  zypper install -y glibc-devel-static tar diffutils util-linux
+  ;;
+gentoo-*)
+  emerge-webrsync
+  emerge dev-util/cmake
+  ;;
+arch-* | archarm-*)
+  pacman -Sy
+  pacman -S --needed --noconfirm base-devel cmake util-linux
+  ;;
+void-*)
+  xbps-install -Sy xbps
+  xbps-install -Sy bash make cmake gcc
+  xbps-install -Sy tar diffutils util-linux
+  ;;
+alpine-*)
+  apk update
+  apk add bash make linux-headers cmake gcc g++
+  ;;
+*)
+  echo "Error: don't know anything about build dependencies on $ID-$VERSION_ID"
+  exit 1
+esac

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-$VERSION_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,alpha}-linux-gnu {gcc,g++}-arm-linux-gnueabihf
+  ;;
+*)
+  echo "Error: don't know anything about build dependencies on $ID-$VERSION_ID"
+  exit 1
+esac

macho/arch-arm64.cc

@@ -1,258 +0,0 @@
-#include "mold.h"
-
-namespace mold::macho {
-
-// Returns [hi:lo] bits of val.
-static u64 bits(u64 val, u64 hi, u64 lo) {
-  return (val >> lo) & (((u64)1 << (hi - lo + 1)) - 1);
-}
-
-static u64 page(u64 val) {
-  return val & 0xffff'ffff'ffff'f000;
-}
-
-static u64 encode_page(u64 val) {
-  return (bits(val, 13, 12) << 29) | (bits(val, 32, 14) << 5);
-}
-
-template <>
-void StubsSection<ARM64>::copy_buf(Context<ARM64> &ctx) {
-  u32 *buf = (u32 *)(ctx.buf + this->hdr.offset);
-
-  for (i64 i = 0; i < syms.size(); i++) {
-    static const u32 insn[] = {
-      0x90000010, // adrp x16, $ptr@PAGE
-      0xf9400210, // ldr  x16, [x16, $ptr@PAGEOFF]
-      0xd61f0200, // br   x16
-    };
-
-    static_assert(sizeof(insn) == ARM64::stub_size);
-
-    u64 la_addr = ctx.lazy_symbol_ptr.hdr.addr + ARM64::word_size * i;
-    u64 this_addr = this->hdr.addr + ARM64::stub_size * i;
-
-    memcpy(buf, insn, sizeof(insn));
-    buf[0] |= encode_page(page(la_addr) - page(this_addr));
-    buf[1] |= bits(la_addr, 11, 3) << 10;
-    buf += 3;
-  }
-}
-
-template <>
-void StubHelperSection<ARM64>::copy_buf(Context<ARM64> &ctx) {
-  u32 *start = (u32 *)(ctx.buf + this->hdr.offset);
-  u32 *buf = start;
-
-  static const u32 insn0[] = {
-    0x90000011, // adrp x17, $__dyld_private@PAGE
-    0x91000231, // add  x17, x17, $__dyld_private@PAGEOFF
-    0xa9bf47f0, // stp	x16, x17, [sp, #-16]!
-    0x90000010, // adrp x16, $dyld_stub_binder@PAGE
-    0xf9400210, // ldr  x16, [x16, $dyld_stub_binder@PAGEOFF]
-    0xd61f0200, // br   x16
-  };
-
-  static_assert(sizeof(insn0) == ARM64::stub_helper_hdr_size);
-  memcpy(buf, insn0, sizeof(insn0));
-
-  u64 dyld_private = get_symbol(ctx, "__dyld_private")->get_addr(ctx);
-  buf[0] |= encode_page(page(dyld_private) - page(this->hdr.addr));
-  buf[1] |= bits(dyld_private, 11, 0) << 10;
-
-  u64 stub_binder = get_symbol(ctx, "dyld_stub_binder")->get_addr(ctx);
-  buf[3] |= encode_page(page(stub_binder) - page(this->hdr.addr - 12));
-  buf[4] |= bits(stub_binder, 11, 0) << 10;
-
-  buf += 6;
-
-  for (i64 i = 0; i < ctx.stubs.syms.size(); i++) {
-    static const u32 insn[] = {
-      0x18000050, // ldr  w16, addr
-      0x14000000, // b    stubHelperHeader
-      0x00000000, // addr: .long <idx>
-    };
-
-    static_assert(sizeof(insn) == ARM64::stub_helper_size);
-
-    memcpy(buf, insn, sizeof(insn));
-    buf[1] |= bits((start - buf - 1) * 4, 27, 2);
-    buf[2] = ctx.stubs.bind_offsets[i];
-    buf += 3;
-  }
-}
-
-static i64 read_addend(u8 *buf, const MachRel &r) {
-  if (r.p2size == 2)
-    return *(i32 *)(buf + r.offset);
-  if (r.p2size == 3)
-    return *(i64 *)(buf + r.offset);
-  unreachable();
-}
-
-static Relocation<ARM64>
-read_reloc(Context<ARM64> &ctx, ObjectFile<ARM64> &file,
-           const MachSection &hdr, MachRel *rels, i64 &idx) {
-  i64 addend = 0;
-
-  switch (rels[idx].type) {
-  case ARM64_RELOC_UNSIGNED:
-  case ARM64_RELOC_SUBTRACTOR:
-    addend = read_addend((u8 *)file.mf->data + hdr.offset, rels[idx]);
-    break;
-  case ARM64_RELOC_ADDEND:
-    addend = rels[idx++].offset;
-    break;
-  }
-
-  MachRel &r = rels[idx];
-  Relocation<ARM64> rel{r.offset, (u8)r.type, (u8)r.p2size, (bool)r.is_pcrel};
-
-  if (r.is_extern) {
-    rel.sym = file.syms[r.idx];
-    rel.addend = addend;
-    return rel;
-  }
-
-  u32 addr;
-  if (r.is_pcrel)
-    addr = hdr.addr + r.offset + addend;
-  else
-    addr = addend;
-
-  Subsection<ARM64> *target = file.find_subsection(ctx, addr);
-  if (!target)
-    Fatal(ctx) << file << ": bad relocation: " << r.offset;
-
-  rel.subsec = target;
-  rel.addend = addr - target->input_addr;
-  return rel;
-}
-
-template <>
-std::vector<Relocation<ARM64>>
-read_relocations(Context<ARM64> &ctx, ObjectFile<ARM64> &file,
-                 const MachSection &hdr) {
-  std::vector<Relocation<ARM64>> vec;
-
-  MachRel *rels = (MachRel *)(file.mf->data + hdr.reloff);
-  for (i64 i = 0; i < hdr.nreloc; i++)
-    vec.push_back(read_reloc(ctx, file, hdr, rels, i));
-  return vec;
-}
-
-template <>
-void Subsection<ARM64>::scan_relocations(Context<ARM64> &ctx) {
-  for (Relocation<ARM64> &r : get_rels()) {
-    Symbol<ARM64> *sym = r.sym;
-    if (!sym)
-      continue;
-
-    switch (r.type) {
-    case ARM64_RELOC_GOT_LOAD_PAGE21:
-    case ARM64_RELOC_GOT_LOAD_PAGEOFF12:
-    case ARM64_RELOC_POINTER_TO_GOT:
-      sym->flags |= NEEDS_GOT;
-      break;
-    case ARM64_RELOC_TLVP_LOAD_PAGE21:
-    case ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
-      sym->flags |= NEEDS_THREAD_PTR;
-      break;
-    }
-
-    if (sym->file && sym->file->is_dylib()) {
-      sym->flags |= NEEDS_STUB;
-      ((DylibFile<ARM64> *)sym->file)->is_needed = true;
-    }
-  }
-}
-
-template <>
-void Subsection<ARM64>::apply_reloc(Context<ARM64> &ctx, u8 *buf) {
-  std::span<Relocation<ARM64>> rels = get_rels();
-
-  for (i64 i = 0; i < rels.size(); i++) {
-    Relocation<ARM64> &r = rels[i];
-
-    if (r.sym && !r.sym->file) {
-      Error(ctx) << "undefined symbol: " << isec.file << ": " << *r.sym;
-      continue;
-    }
-
-    u64 val = 0;
-
-    switch (r.type) {
-    case ARM64_RELOC_UNSIGNED:
-    case ARM64_RELOC_BRANCH26:
-    case ARM64_RELOC_PAGE21:
-    case ARM64_RELOC_PAGEOFF12:
-      val = r.sym ? r.sym->get_addr(ctx) : r.subsec->get_addr(ctx);
-      break;
-    case ARM64_RELOC_SUBTRACTOR: {
-      Relocation<ARM64> s = rels[++i];
-      assert(s.type == ARM64_RELOC_UNSIGNED);
-      u64 val1 = r.sym ? r.sym->get_addr(ctx) : r.subsec->get_addr(ctx);
-      u64 val2 = s.sym ? s.sym->get_addr(ctx) : s.subsec->get_addr(ctx);
-      val = val2 - val1;
-      break;
-    }
-    case ARM64_RELOC_GOT_LOAD_PAGE21:
-    case ARM64_RELOC_GOT_LOAD_PAGEOFF12:
-    case ARM64_RELOC_POINTER_TO_GOT:
-      val = r.sym->get_got_addr(ctx);
-      break;
-    case ARM64_RELOC_TLVP_LOAD_PAGE21:
-    case ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
-      val = r.sym->get_tlv_addr(ctx);
-      break;
-    default:
-      Fatal(ctx) << isec << ": unknown reloc: " << (int)r.type;
-    }
-
-    val += r.addend;
-
-    switch (r.type) {
-    case ARM64_RELOC_UNSIGNED:
-    case ARM64_RELOC_SUBTRACTOR:
-    case ARM64_RELOC_POINTER_TO_GOT:
-      if (r.is_pcrel)
-        val -= get_addr(ctx) + r.offset;
-
-      if (r.p2size == 2)
-        *(i32 *)(buf + r.offset) = val;
-      else if (r.p2size == 3)
-        *(i64 *)(buf + r.offset) = val;
-      else
-        unreachable();
-      break;
-    case ARM64_RELOC_BRANCH26:
-      if (r.is_pcrel)
-        val -= get_addr(ctx) + r.offset;
-      *(u32 *)(buf + r.offset) |= bits(val, 27, 2);
-      break;
-    case ARM64_RELOC_PAGE21:
-    case ARM64_RELOC_GOT_LOAD_PAGE21:
-    case ARM64_RELOC_TLVP_LOAD_PAGE21:
-      assert(r.is_pcrel);
-      *(u32 *)(buf + r.offset) |=
-        encode_page(page(val) - page(get_addr(ctx) + r.offset));
-      break;
-    case ARM64_RELOC_PAGEOFF12:
-    case ARM64_RELOC_GOT_LOAD_PAGEOFF12:
-    case ARM64_RELOC_TLVP_LOAD_PAGEOFF12: {
-      if (r.is_pcrel)
-        val -= get_addr(ctx) + r.offset;
-
-      u32 insn = *(u32 *)(buf + r.offset);
-      i64 scale = 0;
-      if ((insn & 0x3b000000) == 0x39000000)
-        scale = insn >> 30;
-      *(u32 *)(buf + r.offset) |= bits(val, 11, scale) << 10;
-      break;
-    }
-    default:
-      Fatal(ctx) << isec << ": unknown reloc: " << (int)r.type;
-    }
-  }
-}
-
-} // namespace mold::macho

macho/arch-x86-64.cc

@@ -1,222 +0,0 @@
-#include "mold.h"
-
-namespace mold::macho {
-
-template <>
-void StubsSection<X86_64>::copy_buf(Context<X86_64> &ctx) {
-  u8 *buf = ctx.buf + this->hdr.offset;
-
-  for (i64 i = 0; i < syms.size(); i++) {
-    // `ff 25 xx xx xx xx` is a RIP-relative indirect jump instruction,
-    // i.e., `jmp *IMM(%rip)`. It loads an address from la_symbol_ptr
-    // and jump there.
-    static_assert(X86_64::stub_size == 6);
-    buf[i * 6] = 0xff;
-    buf[i * 6 + 1] = 0x25;
-    *(u32 *)(buf + i * 6 + 2) =
-      ctx.lazy_symbol_ptr.hdr.addr + i * X86_64::word_size -
-      (this->hdr.addr + i * 6 + 6);
-  }
-}
-
-template <>
-void StubHelperSection<X86_64>::copy_buf(Context<X86_64> &ctx) {
-  u8 *start = ctx.buf + this->hdr.offset;
-  u8 *buf = start;
-
-  static const u8 insn0[] = {
-    0x4c, 0x8d, 0x1d, 0, 0, 0, 0, // lea $__dyld_private(%rip), %r11
-    0x41, 0x53,                   // push %r11
-    0xff, 0x25, 0, 0, 0, 0,       // jmp *$dyld_stub_binder@GOT(%rip)
-    0x90,                         // nop
-  };
-
-  static_assert(sizeof(insn0) == X86_64::stub_helper_hdr_size);
-
-  memcpy(buf, insn0, sizeof(insn0));
-  *(u32 *)(buf + 3) =
-    get_symbol(ctx, "__dyld_private")->get_addr(ctx) - this->hdr.addr - 7;
-  *(u32 *)(buf + 11) =
-    get_symbol(ctx, "dyld_stub_binder")->get_got_addr(ctx) - this->hdr.addr - 15;
-
-  buf += 16;
-
-  for (i64 i = 0; i < ctx.stubs.syms.size(); i++) {
-    u8 insn[] = {
-      0x68, 0, 0, 0, 0, // push $bind_offset
-      0xe9, 0, 0, 0, 0, // jmp $__stub_helper
-    };
-
-    static_assert(sizeof(insn) == X86_64::stub_helper_size);
-
-    memcpy(buf, insn, sizeof(insn));
-    *(u32 *)(buf + 1) = ctx.stubs.bind_offsets[i];
-    *(u32 *)(buf + 6) = start - buf - 10;
-    buf += 10;
-  }
-}
-
-static i64 get_reloc_addend(u32 type) {
-  switch (type) {
-  case X86_64_RELOC_SIGNED_1:
-    return 1;
-  case X86_64_RELOC_SIGNED_2:
-    return 2;
-  case X86_64_RELOC_SIGNED_4:
-    return 4;
-  default:
-    return 0;
-  }
-}
-
-static i64 read_addend(u8 *buf, const MachRel &r) {
-  if (r.p2size == 2)
-    return *(i32 *)(buf + r.offset) + get_reloc_addend(r.type);
-  if (r.p2size == 3)
-    return *(i64 *)(buf + r.offset) + get_reloc_addend(r.type);
-  unreachable();
-}
-
-static Relocation<X86_64>
-read_reloc(Context<X86_64> &ctx, ObjectFile<X86_64> &file,
-           const MachSection &hdr, MachRel &r) {
-  if (r.p2size != 2 && r.p2size != 3)
-    Fatal(ctx) << file << ": invalid r.p2size: " << (u32)r.p2size;
-
-  if (r.is_pcrel) {
-    if (r.p2size != 2)
-      Fatal(ctx) << file << ": invalid PC-relative reloc: " << r.offset;
-  } else {
-    if (r.p2size != 3)
-      Fatal(ctx) << file << ": invalid non-PC-relative reloc: " << r.offset;
-  }
-
-  u8 *buf = (u8 *)file.mf->data + hdr.offset;
-  Relocation<X86_64> rel{r.offset, (u8)r.type, (u8)r.p2size, (bool)r.is_pcrel};
-  i64 addend = read_addend(buf, r);
-
-  if (r.is_extern) {
-    rel.sym = file.syms[r.idx];
-    rel.addend = addend;
-    return rel;
-  }
-
-  u32 addr;
-  if (r.is_pcrel)
-    addr = hdr.addr + r.offset + 4 + addend;
-  else
-    addr = addend;
-
-  Subsection<X86_64> *target = file.find_subsection(ctx, addr);
-  if (!target)
-    Fatal(ctx) << file << ": bad relocation: " << r.offset;
-
-  rel.subsec = target;
-  rel.addend = addr - target->input_addr;
-  return rel;
-}
-
-template <>
-std::vector<Relocation<X86_64>>
-read_relocations(Context<X86_64> &ctx, ObjectFile<X86_64> &file,
-                 const MachSection &hdr) {
-  std::vector<Relocation<X86_64>> vec;
-  vec.reserve(hdr.nreloc);
-
-  MachRel *rels = (MachRel *)(file.mf->data + hdr.reloff);
-  for (i64 i = 0; i < hdr.nreloc; i++)
-    vec.push_back(read_reloc(ctx, file, hdr, rels[i]));
-  return vec;
-}
-
-template <>
-void Subsection<X86_64>::scan_relocations(Context<X86_64> &ctx) {
-  for (Relocation<X86_64> &r : get_rels()) {
-    Symbol<X86_64> *sym = r.sym;
-    if (!sym)
-      continue;
-
-    switch (r.type) {
-    case X86_64_RELOC_GOT_LOAD:
-      if (sym->file && sym->file->is_dylib())
-        sym->flags |= NEEDS_GOT;
-      break;
-    case X86_64_RELOC_GOT:
-      sym->flags |= NEEDS_GOT;
-      break;
-    case X86_64_RELOC_TLV:
-      if (sym->file && sym->file->is_dylib())
-        sym->flags |= NEEDS_THREAD_PTR;
-      break;
-    }
-
-    if (sym->file && sym->file->is_dylib()) {
-      sym->flags |= NEEDS_STUB;
-      ((DylibFile<X86_64> *)sym->file)->is_needed = true;
-    }
-  }
-}
-
-template <>
-void Subsection<X86_64>::apply_reloc(Context<X86_64> &ctx, u8 *buf) {
-  for (const Relocation<X86_64> &r : get_rels()) {
-    if (r.sym && !r.sym->file) {
-      Error(ctx) << "undefined symbol: " << isec.file << ": " << *r.sym;
-      continue;
-    }
-
-    u64 val = 0;
-
-    switch (r.type) {
-    case X86_64_RELOC_UNSIGNED:
-    case X86_64_RELOC_SIGNED:
-    case X86_64_RELOC_BRANCH:
-    case X86_64_RELOC_SIGNED_1:
-    case X86_64_RELOC_SIGNED_2:
-    case X86_64_RELOC_SIGNED_4:
-      val = r.sym ? r.sym->get_addr(ctx) : r.subsec->get_addr(ctx);
-      break;
-    case X86_64_RELOC_GOT_LOAD:
-      if (r.sym->got_idx != -1) {
-        val = r.sym->get_got_addr(ctx);
-      } else {
-        // Relax MOVQ into LEAQ
-        if (buf[r.offset - 2] != 0x8b)
-          Error(ctx) << isec << ": invalid GOT_LOAD relocation";
-        buf[r.offset - 2] = 0x8d;
-        val = r.sym->get_addr(ctx);
-      }
-      break;
-    case X86_64_RELOC_GOT:
-      val = r.sym->get_got_addr(ctx);
-      break;
-    case X86_64_RELOC_TLV:
-      if (r.sym->tlv_idx != -1) {
-        val = r.sym->get_tlv_addr(ctx);
-      } else {
-        // Relax MOVQ into LEAQ
-        if (buf[r.offset - 2] != 0x8b)
-          Error(ctx) << isec << ": invalid TLV relocation";
-        buf[r.offset - 2] = 0x8d;
-        val = r.sym->get_addr(ctx);
-      }
-      break;
-    default:
-      Fatal(ctx) << isec << ": unknown reloc: " << (int)r.type;
-    }
-
-    val += r.addend;
-
-    if (r.is_pcrel)
-      val -= get_addr(ctx) + r.offset + 4 + get_reloc_addend(r.type);
-
-    if (r.p2size == 2)
-      *(u32 *)(buf + r.offset) = val;
-    else if (r.p2size == 3)
-      *(u64 *)(buf + r.offset) = val;
-    else
-      unreachable();
-  }
-}
-
-} // namespace mold::macho

macho/cmdline.cc

@@ -1,322 +0,0 @@
-#include "mold.h"
-#include "../cmdline.h"
-
-#include <optional>
-#include <sstream>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <regex>
-#include <unistd.h>
-#include <unordered_set>
-
-namespace mold::macho {
-
-static const char helpmsg[] = R"(
-Options:
-  -F<PATH>                    Add DIR to framework search path
-  -L<PATH>                    Add DIR to library search path
-  -Z                          Do not search the standard directories when
-                              searching for libraries and frameworks
-  -ObjC                       Load all static archive members that implement
-                              an Objective-C class or category
-  -adhoc_codesign             Add ad-hoc code signature to the output file
-    -no_adhoc_codesign
-  -arch <ARCH_NAME>           Specify target architecture
-  -bundle                     Produce a mach-o bundle
-  -dead_strip                 Remove unreachable functions and data
-  -dead_strip_dylibs          Remove unreachable dylibs from dependencies
-  -demangle                   Demangle C++ symbols in log messages (default)
-  -dylib                      Produce a dynamic library
-  -dynamic                    Link against dylibs (default)
-  -e <SYMBOL>                 Specify the entry point of a main executable
-  -execute                    Produce an executable (default)
-  -filelist <FILE>[,<DIR>]    Specify the list of input file names
-  -framework <NAME>,[,<SUFFIX>]
-                              Search for a given framework
-  -headerpad <SIZE>           Allocate the size of padding after load commands
-  -headerpad_max_install_names
-                              Allocate MAXPATHLEN byte padding after load commands
-  -help                       Report usage information
-  -l<LIB>                     Search for a given library
-  -lto_library <FILE>         Ignored
-  -map <FILE>                 Write map file to a given file
-  -needed-l<LIB>              Search for a given library
-  -needed-framework <NAME>[,<SUFFIX>]
-                              Search for a given framework
-  -no_deduplicate             Ignored
-  -o <FILE>                   Set output filename
-  -pagezero_size <SIZE>       Specify the size of the __PAGEZERO segment
-  -platform_version <PLATFORM> <MIN_VERSION> <SDK_VERSION>
-                              Set platform, platform version and SDK version
-  -rpath <PATH>               Add PATH to the runpath search path list
-  -syslibroot <DIR>           Prepend DIR to library search paths
-  -t                          Print out each file the linker loads
-  -v                          Report version information)";
-
-template <typename E>
-static i64 parse_platform(Context<E> &ctx, std::string_view arg) {
-  static std::regex re(R"(\d+)", std::regex_constants::ECMAScript);
-  if (std::regex_match(arg.begin(), arg.end(), re))
-    return stoi(std::string(arg));
-
-  if (arg == "macos")
-    return PLATFORM_MACOS;
-  if (arg == "ios")
-    return PLATFORM_IOS;
-  if (arg == "tvos")
-    return PLATFORM_TVOS;
-  if (arg == "watchos")
-    return PLATFORM_WATCHOS;
-  if (arg == "bridgeos")
-    return PLATFORM_BRIDGEOS;
-  if (arg == "mac-catalyst")
-    return PLATFORM_MACCATALYST;
-  if (arg == "ios-simulator")
-    return PLATFORM_IOSSIMULATOR;
-  if (arg == "tvos-simulator")
-    return PLATFORM_TVOSSIMULATOR;
-  if (arg == "watchos-simulator")
-    return PLATFORM_WATCHOSSIMULATOR;
-  if (arg == "driverkit")
-    return PLATFORM_DRIVERKIT;
-  Fatal(ctx) << "unknown -platform_version name: " << arg;
-}
-
-template <typename E>
-static i64 parse_version(Context<E> &ctx, std::string_view arg) {
-  static std::regex re(R"((\d+)(?:\.(\d+))?(?:\.(\d+))?)",
-                       std::regex_constants::ECMAScript);
-  std::cmatch m;
-  if (!std::regex_match(arg.begin(), arg.end(), m, re))
-    Fatal(ctx) << "malformed version number: " << arg;
-
-  i64 major = (m[1].length() == 0) ? 0 : stoi(m[1]);
-  i64 minor = (m[2].length() == 0) ? 0 : stoi(m[2]);
-  i64 patch = (m[3].length() == 0) ? 0 : stoi(m[3]);
-  return (major << 16) | (minor << 8) | patch;
-}
-
-static bool is_directory(std::filesystem::path path) {
-  std::error_code ec;
-  return std::filesystem::is_directory(path, ec) && !ec;
-}
-
-template <typename E>
-void parse_nonpositional_args(Context<E> &ctx,
-                              std::vector<std::string> &remaining) {
-  std::vector<std::string_view> &args = ctx.cmdline_args;
-  i64 i = 1;
-
-  std::vector<std::string> framework_paths;
-  std::vector<std::string> library_paths;
-  bool nostdlib = false;
-  std::optional<i64> pagezero_size;
-
-  while (i < args.size()) {
-    std::string_view arg;
-    std::string_view arg2;
-    std::string_view arg3;
-
-    auto read_arg = [&](std::string name) {
-      if (args[i] == name) {
-        if (args.size() <= i + 1)
-          Fatal(ctx) << "option -" << name << ": argument missing";
-        arg = args[i + 1];
-        i += 2;
-        return true;
-      }
-      return false;
-    };
-
-    auto read_arg3 = [&](std::string name) {
-      if (args[i] == name) {
-        if (args.size() <= i + 3)
-          Fatal(ctx) << "option -" << name << ": argument missing";
-        arg = args[i + 1];
-        arg2 = args[i + 2];
-        arg3 = args[i + 3];
-        i += 4;
-        return true;
-      }
-      return false;
-    };
-
-    auto read_joined = [&](std::string name) {
-      if (read_arg(name))
-        return true;
-      if (args[i].starts_with(name)) {
-        arg = args[i].substr(name.size());
-        i++;
-        return true;
-      }
-      return false;
-    };
-
-    auto read_flag = [&](std::string name) {
-      if (args[i] == name) {
-        i++;
-        return true;
-      }
-      return false;
-    };
-
-    if (args[i].starts_with('@')) {
-      std::vector<std::string_view> vec =
-        read_response_file(ctx, args[i].substr(1));
-      args.erase(args.begin() + i);
-      args.insert(args.begin() + i, vec.begin(), vec.end());
-      continue;
-    }
-
-    if (read_flag("-help") || read_flag("--help")) {
-      SyncOut(ctx) << "Usage: " << ctx.cmdline_args[i]
-                   << " [options] file...\n" << helpmsg;
-      exit(0);
-    }
-
-    if (read_joined("-F")) {
-      framework_paths.push_back(std::string(arg));
-    } else if (read_joined("-L")) {
-      library_paths.push_back(std::string(arg));
-    } else if (read_flag("-Z")) {
-      nostdlib = true;
-    } else if (read_flag("-ObjC")) {
-      ctx.arg.ObjC = true;
-    } else if (read_flag("-adhoc_codesign")) {
-      ctx.arg.adhoc_codesign = true;
-    } else if (read_flag("-no_adhoc_codesign")) {
-      ctx.arg.adhoc_codesign = false;
-    } else if (read_arg("-arch")) {
-      if (arg == "x86_64")
-        ctx.arg.arch = CPU_TYPE_X86_64;
-      else if (arg == "arm64")
-        ctx.arg.arch = CPU_TYPE_ARM64;
-      else
-        Fatal(ctx) << "unknown -arch: " << arg;
-    } else if (read_flag("-bundle")) {
-      ctx.output_type = MH_BUNDLE;
-    } else if (read_flag("-color-diagnostics") ||
-               read_flag("--color-diagnostics")) {
-    } else if (read_flag("-dead_strip")) {
-      ctx.arg.dead_strip = true;
-    } else if (read_flag("-dead_strip_dylibs")) {
-      ctx.arg.dead_strip_dylibs = true;
-    } else if (read_flag("-demangle")) {
-      ctx.arg.demangle = true;
-    } else if (read_flag("-dylib")) {
-      ctx.output_type = MH_DYLIB;
-    } else if (read_arg("-headerpad")) {
-      size_t pos;
-      ctx.arg.headerpad = std::stol(std::string(arg), &pos, 16);
-      if (pos != arg.size())
-        Fatal(ctx) << "malformed -headerpad: " << arg;
-    } else if (read_flag("-headerpad_max_install_names")) {
-      ctx.arg.headerpad = 1024;
-    } else if (read_flag("-dynamic")) {
-      ctx.arg.dynamic = true;
-    } else if (read_arg("-e")) {
-      ctx.arg.entry = arg;
-    } else if (read_flag("-execute")) {
-      ctx.output_type = MH_EXECUTE;
-    } else if (read_arg("-fatal_warnings")) {
-    } else if (read_arg("-filelist")) {
-      remaining.push_back("-filelist");
-      remaining.push_back(std::string(arg));
-    } else if (read_arg("-framework")) {
-      remaining.push_back("-framework");
-      remaining.push_back(std::string(arg));
-    } else if (read_arg("-lto_library")) {
-    } else if (read_joined("-l")) {
-      remaining.push_back("-l");
-      remaining.push_back(std::string(arg));
-    } else if (read_arg("-map")) {
-      ctx.arg.map = arg;
-    } else if (read_joined("-needed-l")) {
-      remaining.push_back("-needed-l");
-      remaining.push_back(std::string(arg));
-    } else if (read_arg("-needed_framework")) {
-      remaining.push_back("-needed_framework");
-      remaining.push_back(std::string(arg));
-    } else if (read_flag("-no_deduplicate")) {
-    } else if (read_arg("-o")) {
-      ctx.arg.output = arg;
-    } else if (read_arg("-pagezero_size")) {
-      size_t pos;
-      pagezero_size = std::stol(std::string(arg), &pos, 16);
-      if (pos != arg.size())
-        Fatal(ctx) << "malformed -pagezero_size: " << arg;
-    } else if (read_arg3("-platform_version")) {
-      ctx.arg.platform = parse_platform(ctx, arg);
-      ctx.arg.platform_min_version = parse_version(ctx, arg2);
-      ctx.arg.platform_sdk_version = parse_version(ctx, arg3);
-    } else if (read_arg("-rpath")) {
-      ctx.arg.rpath.push_back(std::string(arg));
-    } else if (read_flag("-search_dylibs_first")) {
-      Fatal(ctx) << "-search_dylibs_first is not supported";
-    } else if (read_flag("-search_paths_first")) {
-    } else if (read_arg("-syslibroot")) {
-      ctx.arg.syslibroot.push_back(std::string(arg));
-    } else if (read_flag("-t")) {
-      ctx.arg.trace = true;
-    } else if (read_flag("-v")) {
-      SyncOut(ctx) << mold_version;
-    } else {
-      if (args[i][0] == '-')
-        Fatal(ctx) << "unknown command line option: " << args[i];
-      remaining.push_back(std::string(args[i]));
-      i++;
-    }
-  }
-
-  auto add_search_path = [&](std::vector<std::string> &vec, std::string path) {
-    if (!path.starts_with('/') || ctx.arg.syslibroot.empty()) {
-      if (is_directory(path))
-        vec.push_back(path);
-      return;
-    }
-
-    bool found = false;
-    for (std::string &dir : ctx.arg.syslibroot) {
-      std::string str = path_clean(dir + "/" + path);
-      if (is_directory(str)) {
-        vec.push_back(str);
-        found = true;
-      }
-    }
-    if (!found && is_directory(path))
-      vec.push_back(path);
-  };
-
-  for (std::string &path : library_paths)
-    add_search_path(ctx.arg.library_paths, path);
-
-  if (!nostdlib) {
-    add_search_path(ctx.arg.library_paths, "/usr/lib");
-    add_search_path(ctx.arg.library_paths, "/usr/local/lib");
-  }
-
-  for (std::string &path : framework_paths)
-    add_search_path(ctx.arg.framework_paths, path);
-
-  if (!nostdlib) {
-    add_search_path(ctx.arg.framework_paths, "/Library/Frameworks");
-    add_search_path(ctx.arg.framework_paths, "/System/Library/Frameworks");
-  }
-
-  if (pagezero_size.has_value()) {
-    if (ctx.output_type != MH_EXECUTE)
-      Error(ctx) << "-pagezero_size option can only be used when"
-                 << " linking a main executable";
-    ctx.arg.pagezero_size = *pagezero_size;
-  } else {
-    ctx.arg.pagezero_size = (ctx.output_type == MH_EXECUTE) ? 0x100000000 : 0;
-  }
-}
-
-#define INSTANTIATE(E) \
-  template void parse_nonpositional_args(Context<E> &, std::vector<std::string> &)
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/dead-strip.cc

@@ -1,112 +0,0 @@
-#include "mold.h"
-
-namespace mold::macho {
-
-template <typename E>
-static std::vector<Subsection<E> *> collect_root_set(Context<E> &ctx) {
-  std::vector<Subsection<E> *> rootset;
-
-  auto mark = [&](Symbol<E> *sym) {
-    if (sym && sym->subsec)
-      rootset.push_back(sym->subsec);
-  };
-
-  mark(get_symbol(ctx, ctx.arg.entry));
-
-  if (ctx.output_type == MH_DYLIB || ctx.output_type == MH_BUNDLE)
-    for (ObjectFile<E> *file : ctx.objs)
-      for (Symbol<E> *sym : file->syms)
-        if (sym->file == file && sym->is_extern)
-          mark(sym);
-
-  return rootset;
-}
-
-template <typename E>
-static void visit(Context<E> &ctx, Subsection<E> &subsec) {
-  if (subsec.is_alive.exchange(true))
-    return;
-
-  for (Relocation<E> &rel : subsec.get_rels()) {
-    if (rel.sym) {
-      if (rel.sym->subsec)
-        visit(ctx, *rel.sym->subsec);
-    } else {
-      visit(ctx, *rel.subsec);
-    }
-  }
-
-  for (UnwindRecord<E> &rec : subsec.get_unwind_records()) {
-    rec.is_alive = true;
-    visit(ctx, *rec.subsec);
-    if (rec.lsda)
-      visit(ctx, *rec.lsda);
-    if (Symbol<E> *sym = rec.personality; sym && sym->subsec)
-      visit(ctx, *sym->subsec);
-  }
-}
-
-template <typename E>
-static bool refers_live_subsection(Subsection<E> &subsec) {
-  for (Relocation<E> &rel : subsec.get_rels()) {
-    if (rel.sym) {
-      if (!rel.sym->subsec || rel.sym->subsec->is_alive)
-        return true;
-    } else {
-      if (rel.subsec->is_alive)
-        return true;
-    }
-  }
-  return false;
-}
-
-template <typename E>
-static void mark(Context<E> &ctx, const std::vector<Subsection<E> *> &rootset) {
-  for (Subsection<E> *subsec : rootset)
-    visit(ctx, *subsec);
-
-  bool repeat;
-  do {
-    repeat = false;
-    for (ObjectFile<E> *file : ctx.objs) {
-      for (std::unique_ptr<Subsection<E>> &subsec : file->subsections) {
-        if ((subsec->isec.hdr.attr & S_ATTR_LIVE_SUPPORT) &&
-            !subsec->is_alive &&
-            refers_live_subsection(*subsec)) {
-          visit(ctx, *subsec);
-          repeat = true;
-        }
-      }
-    }
-  } while (repeat);
-}
-
-template <typename E>
-static void sweep(Context<E> &ctx) {
-  for (ObjectFile<E> *file : ctx.objs) {
-    std::erase_if(file->subsections,
-                  [](const std::unique_ptr<Subsection<E>> &subsec) {
-      return !subsec->is_alive;
-    });
-  }
-
-  for (ObjectFile<E> *file : ctx.objs)
-    for (Symbol<E> *&sym : file->syms)
-      if (sym->file == file && sym->subsec && !sym->subsec->is_alive)
-        sym = nullptr;
-}
-
-template <typename E>
-void dead_strip(Context<E> &ctx) {
-  std::vector<Subsection<E> *> rootset = collect_root_set(ctx);
-  mark(ctx, rootset);
-  sweep(ctx);
-}
-
-#define INSTANTIATE(E)                          \
-  template void dead_strip(Context<E> &)
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/dumper.cc

@@ -1,511 +0,0 @@
-#include "mold.h"
-
-#include <cstdlib>
-#include <fcntl.h>
-#include <iomanip>
-#include <iostream>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace mold::macho {
-
-static u8 *open_file(std::string path) {
-  i64 fd = ::open(path.c_str(), O_RDONLY);
-  if (fd == -1)
-    return nullptr;
-
-  struct stat st;
-  if (fstat(fd, &st) == -1) {
-    std::cerr << path << ": fstat failed: " << errno_string();
-    exit(1);
-  }
-
-  void *ptr = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
-  if (ptr == MAP_FAILED) {
-    std::cerr << path << ": mmap failed: " << errno_string();
-    exit(1);
-  }
-
-  close(fd);
-  return (u8 *)ptr;
-}
-
-static void print_bytes(u8 *buf, i64 size) {
-  if (size == 0) {
-    std::cout << "[]\n";
-    return;
-  }
-
-  std::cout << "[" << std::setw(2) << std::setfill('0') << (u32)buf[0];
-  for (i64 i = 1; i < size; i++)
-    std::cout << " " << std::setw(2) << std::setfill('0') << (u32)buf[i];
-  std::cout << "]\n";
-}
-
-struct ExportEntry {
-  std::string name;
-  u32 flags;
-  u64 addr;
-};
-
-static void read_trie(std::vector<ExportEntry> &vec, u8 *start, i64 offset = 0,
-                      const std::string &prefix = "") {
-  u8 *buf = start + offset;
-
-  if (read_uleb(buf)) {
-    ExportEntry ent;
-    ent.name = prefix;
-    ent.flags = read_uleb(buf);
-    ent.addr = read_uleb(buf);
-    vec.push_back(std::move(ent));
-  }
-
-  for (i64 i = 0, n = read_uleb(buf); i < n; i++) {
-    std::string suffix((char *)buf);
-    buf += suffix.size() + 1;
-    i64 off = read_uleb(buf);
-    read_trie(vec, start, off, prefix + suffix);
-  }
-}
-
-void dump_unwind_info(u8 *buf, MachSection &sec) {
-  UnwindSectionHeader &hdr = *(UnwindSectionHeader *)(buf + sec.offset);
-
-  std::cout << std::hex << "  Unwind info:"
-            << "\n   version: 0x"   << hdr.version
-            << "\n   encoding_offset: 0x"   << hdr.encoding_offset
-            << "\n   encoding_count: 0x"   << hdr.encoding_count
-            << "\n   personality_offset: 0x"   << hdr.personality_offset
-            << "\n   personality_count: 0x"   << hdr.personality_count
-            << "\n   page_offset: 0x"   << hdr.page_offset
-            << "\n   page_count: 0x"   << hdr.page_count;
-
-  std::cout << "\n   encoding:";
-  u32 *enc = (u32 *)(buf + sec.offset + hdr.encoding_offset);
-  for (i64 i = 0; i < hdr.encoding_count; i++)
-    std::cout << std::hex << "\n    0x" << enc[i];
-
-  std::cout << "\n   personality:";
-  u32 *pers = (u32 *)(buf + sec.offset + hdr.personality_offset);
-  for (i64 i = 0; i < hdr.personality_count; i++)
-    std::cout << std::hex << "\n    0x" << pers[i];
-
-  UnwindFirstLevelPage *ent =
-    (UnwindFirstLevelPage *)(buf + sec.offset + hdr.page_offset);
-
-  for (i64 i = 0; i < hdr.page_count; i++) {
-    std::cout << std::hex << "\n   function:"  
-              << "\n    func_addr: 0x"   << ent[i].func_addr
-              << "\n    page_offset: 0x"   << ent[i].page_offset
-              << "\n    lsda_offset: 0x"   << ent[i].lsda_offset;
-
-    if (i != hdr.page_count - 1) {
-      UnwindLsdaEntry *lsda =
-        (UnwindLsdaEntry *)(buf + sec.offset + ent[i].lsda_offset);
-      i64 lsda_size = ent[i + 1].lsda_offset - ent[i].lsda_offset;
-      for (i64 j = 0; j < lsda_size / sizeof(UnwindLsdaEntry); j++)
-        std::cout << std::hex
-                  << "\n    lsda:"
-                  << "\n     func_addr: 0x" << lsda[j].func_addr
-                  << "\n     lsda_addr: 0x" << lsda[j].lsda_addr;
-    }
-
-    if (ent[i].page_offset == 0)
-      break;
-
-    u8 *addr = buf + sec.offset + ent[i].page_offset;
-
-    switch (u32 kind = *addr; kind) {
-    case UNWIND_SECOND_LEVEL_REGULAR: {
-      std::cout << "\n    UNWIND_SECOND_LEVEL_REGULAR:"  ;
-      break;
-    }
-    case UNWIND_SECOND_LEVEL_COMPRESSED: {
-      std::cout << "\n    UNWIND_SECOND_LEVEL_COMPRESSED"  ;
-      UnwindSecondLevelPage &hdr2 = *(UnwindSecondLevelPage *)addr;
-      std::cout << std::hex
-                << "\n     page_offset: 0x"   << hdr2.page_offset
-                << "\n     page_count: 0x"   << hdr2.page_count
-                << "\n     encoding_offset: 0x"   << hdr2.encoding_offset
-                << "\n     encoding_count: 0x"   << hdr2.encoding_count;
-
-      UnwindPageEntry *ent2 = (UnwindPageEntry *)(addr + hdr2.page_offset);
-      for (i64 j = 0; j < hdr2.page_count; j++)
-        std::cout << std::hex << "\n      ent 0x"  
-                  << (ent[i].func_addr + ent2[j].func_addr)
-                  << " 0x" << ent2[j].encoding;
-
-      u32 *enc = (u32 *)(addr + hdr2.encoding_offset);
-      for (i64 j = 0; j < hdr2.encoding_count; j++)
-        std::cout << std::hex << "\n      0x"   << enc[j];
-      break;
-    }
-    default:
-      std::cout << "\n    bad 2nd-level unwind info header: " << kind;
-    }
-  }
-
-  std::cout << "\n";
-}
-
-void dump_compact_unwind(u8 *buf, MachSection &sec) {
-  CompactUnwindEntry *ent = (CompactUnwindEntry *)(buf + sec.offset);
-  i64 nentry = sec.size / sizeof(CompactUnwindEntry);
-
-  std::cout << "  Compact unwind:"
-            << "\n   num_entry: " << nentry;
-
-  for (i64 i = 0; i < nentry; i++) {
-    std::cout << std::hex
-              << "\n   entry: 0x" << (i * sizeof(CompactUnwindEntry))
-              << "\n    code_start: 0x" << ent[i].code_start
-              << "\n    code_len: 0x" << ent[i].code_len
-              << "\n    encoding: 0x" << ent[i].encoding
-              << "\n    personality: 0x" << ent[i].personality
-              << "\n    lsda: 0x" << ent[i].lsda;
-  }
-
-  std::cout << "\n";
-}
-
-void dump_file(std::string path) {
-  u8 *buf = open_file(path);
-  if (!buf) {
-    std::cerr << "cannot open " << path << "\n";
-    exit(1);
-  }
-
-  MachHeader &hdr = *(MachHeader *)buf;
-  std::cout << "magic: 0x" << std::hex << hdr.magic
-            << "\ncputype: 0x" << hdr.cputype
-            << "\ncpusubtype: 0x" << hdr.cpusubtype
-            << "\nfiletype: 0x" << hdr.filetype
-            << "\nncmds: 0x" << hdr.ncmds
-            << "\nsizeofcmds: 0x" << hdr.sizeofcmds
-            << "\nflags: 0x" << hdr.flags
-            << "\n\n";
-
-  u8 *p = buf + sizeof(MachHeader);
-
-  for (i64 i = 0; i < hdr.ncmds; i++) {
-    std::cout << "fileoff: 0x" << std::hex << (p - buf) << "\n";
-
-    LoadCommand &lc = *(LoadCommand *)p;
-    p += lc.cmdsize;
-
-    auto print_dylib = [&] {
-      DylibCommand &cmd = *(DylibCommand *)&lc;
-      std::cout << " cmdsize: 0x" << cmd.cmdsize
-                << "\n nameoff: 0x" << cmd.nameoff
-                << "\n timestamp: 0x" << cmd.timestamp
-                << "\n current_version: 0x" << cmd.current_version
-                << "\n compatibility_version: 0x" << cmd.compatibility_version
-                << "\n data: " << (char *)((char *)&cmd + cmd.nameoff)
-                << "\n";
-    };
-
-    switch (lc.cmd) {
-    case LC_SYMTAB: {
-      std::cout << "LC_SYMTAB\n";
-      SymtabCommand &cmd = *(SymtabCommand *)&lc;
-      std::cout << " cmdsize: " << cmd.cmdsize
-                << "\n symoff: 0x" << std::hex << cmd.symoff
-                << "\n nsyms: " << std::dec << cmd.nsyms
-                << "\n stroff: 0x" << std::hex << cmd.stroff
-                << "\n strsize: 0x" << cmd.strsize
-                << "\n symdata: ";
-      print_bytes(buf + cmd.symoff, cmd.nsyms * sizeof(MachSym));
-
-      std::cout << " strdata: ";
-      print_bytes(buf + cmd.stroff, cmd.strsize);
-
-      MachSym *syms = (MachSym *)(buf + cmd.symoff);
-      for (i64 j = 0; j < cmd.nsyms; j++) {
-        std::cout << " symbol:"
-                  << "\n  name: " << (char *)(buf + cmd.stroff + syms[j].stroff)
-                  << "\n  stub: " << (u32)syms[j].stub
-                  << "\n  pext: " << (u32)syms[j].pext
-                  << "\n  type: " << (u32)syms[j].type
-                  << "\n  ext: " << (u32)syms[j].ext
-                  << "\n  sect: 0x" << (u32)syms[j].sect
-                  << "\n  desc: 0x" << (u32)syms[j].desc
-                  << "\n  value: 0x" << syms[j].value
-                  << "\n";
-      }
-      break;
-    }
-    case LC_DYSYMTAB: {
-      std::cout << "LC_DYSYMTAB\n";
-      DysymtabCommand &cmd = *(DysymtabCommand *)&lc;
-      std::cout << " cmdsize: 0x" << cmd.cmdsize
-                << "\n ilocalsym: 0x" << cmd.ilocalsym
-                << "\n nlocalsym: 0x" << cmd.nlocalsym
-                << "\n iextdefsym: 0x" << cmd.iextdefsym
-                << "\n nextdefsym: 0x" << cmd.nextdefsym
-                << "\n iundefsym: 0x" << cmd.iundefsym
-                << "\n nundefsym: 0x" << cmd.nundefsym
-                << "\n tocoff: 0x" << cmd.tocoff
-                << "\n ntoc: 0x" << cmd.ntoc
-                << "\n modtaboff: 0x" << cmd.modtaboff
-                << "\n nmodtab: 0x" << cmd.nmodtab
-                << "\n extrefsymoff: 0x" << cmd.extrefsymoff
-                << "\n nextrefsyms: 0x" << cmd.nextrefsyms
-                << "\n indirectsymoff: 0x" << cmd.indirectsymoff
-                << "\n nindirectsyms: 0x" << cmd.nindirectsyms
-                << "\n extreloff: 0x" << cmd.extreloff
-                << "\n nextrel: 0x" << cmd.nextrel
-                << "\n locreloff: 0x" << cmd.locreloff
-                << "\n nlocrel: 0x" << cmd.nlocrel
-                << "\n";
-
-      if (cmd.indirectsymoff) {
-        std::cout << " indirectsymdata: ";
-        print_bytes(buf + cmd.indirectsymoff, 4 * cmd.nindirectsyms);
-      }
-      break;
-    }
-    case LC_LOAD_DYLIB:
-      std::cout << "LC_LOAD_DYLIB\n";
-      print_dylib();
-      break;
-    case LC_LOAD_WEAK_DYLIB:
-      std::cout << "LC_LOAD_WEAK_DYLIB\n";
-      print_dylib();
-      break;
-    case LC_ID_DYLIB:
-      std::cout << "LC_ID_DYLIB\n";
-      print_dylib();
-      break;
-    case LC_LOAD_DYLINKER: {
-      std::cout << "LC_LOAD_DYLINKER\n";
-      DylinkerCommand &cmd = *(DylinkerCommand *)&lc;
-      std::cout << " cmdsize: 0x" << cmd.cmdsize
-                << "\n nameoff: 0x" << cmd.nameoff
-                << "\n data: " << (char *)((char *)&cmd + cmd.nameoff)
-                << "\n";
-      break;
-    }
-    case LC_SEGMENT_64: {
-      std::cout << "LC_SEGMENT_64\n";
-      SegmentCommand &cmd = *(SegmentCommand *)&lc;
-      std::cout << " cmdsize: " << cmd.cmdsize
-                << "\n segname: " << cmd.get_segname()
-                << "\n vmaddr: 0x" << std::hex << cmd.vmaddr
-                << "\n vmsize: 0x" << cmd.vmsize
-                << "\n fileoff: 0x" << cmd.fileoff
-                << "\n filesize: 0x" << cmd.filesize
-                << "\n maxprot: " << std::dec << cmd.maxprot
-                << "\n initprot: " << cmd.initprot
-                << "\n nsects: " << cmd.nsects
-                << "\n flags: 0x" << std::hex << cmd.flags
-                << "\n";
-
-      MachSection *sec = (MachSection *)((u8 *)&lc + sizeof(cmd));
-      for (i64 j = 0; j < cmd.nsects; j++) {
-        std::cout << " section:\n  sectname: " << sec[j].get_sectname()
-                  << "\n  segname: " << sec[j].get_segname()
-                  << "\n  addr: 0x" << std::hex << sec[j].addr
-                  << "\n  size: 0x" << sec[j].size
-                  << "\n  offset: 0x" << sec[j].offset
-                  << "\n  p2align: " << std::dec << sec[j].p2align
-                  << "\n  reloff: " << std::hex << sec[j].reloff
-                  << "\n  nreloc: " << std::dec << sec[j].nreloc
-                  << "\n  type: 0x" << std::hex << sec[j].type
-                  << "\n  attr: 0x" << std::hex << sec[j].attr
-                  << "\n";
-
-        if (sec[j].type != S_ZEROFILL) {
-          std::cout << "  contents: ";
-          print_bytes(buf + sec[j].offset, sec[j].size);
-        }
-
-        if (sec[j].reloff) {
-          MachRel *rel = (MachRel *)(buf + sec[j].reloff);
-          for (i64 k = 0; k < sec[j].nreloc; k++) {
-            std::cout << "  reloc: "
-                      << "\n   offset: 0x" << rel[k].offset
-                      << "\n   idx: 0x" << rel[k].idx
-                      << "\n   is_pcrel: " << rel[k].is_pcrel
-                      << "\n   p2size: 0x" << rel[k].p2size
-                      << "\n   is_extern: " << rel[k].is_extern
-                      << "\n   type: " << rel[k].type
-                      << "\n";
-          }
-        }
-
-        if (sec[j].match("__TEXT", "__unwind_info"))
-          dump_unwind_info(buf, sec[j]);
-
-        if (sec[j].match("__LD", "__compact_unwind"))
-          dump_compact_unwind(buf, sec[j]);
-      }
-      break;
-    }
-    case LC_UUID: {
-      std::cout << "LC_UUID\n";
-      UUIDCommand &cmd = *(UUIDCommand *)&lc;
-      std::cout << " data: ";
-      print_bytes(cmd.uuid, sizeof(cmd.uuid));
-      break;
-    }
-    case LC_DYLD_INFO_ONLY: {
-      std::cout << "LC_DYLD_INFO_ONLY\n";
-      DyldInfoCommand &cmd = *(DyldInfoCommand *)&lc;
-
-      if (cmd.rebase_off) {
-        std::cout << "  rebase: ";
-        print_bytes(buf + cmd.rebase_off, cmd.rebase_size);
-        std::cout << "  rebase_off: 0x" << std::hex << cmd.rebase_off
-                  << "\n  rebase_size: 0x" << cmd.rebase_size
-                  << "\n";
-      }
-
-      if (cmd.bind_off) {
-        std::cout << "  bind: ";
-        print_bytes(buf + cmd.bind_off, cmd.bind_size);
-        std::cout << "  bind_off: 0x" << std::hex << cmd.bind_off
-                  << "\n  bind_size: 0x" << cmd.bind_size
-                  << "\n";
-      }
-
-      if (cmd.weak_bind_off) {
-        std::cout << "  weak_bind: ";
-        print_bytes(buf + cmd.weak_bind_off, cmd.weak_bind_size);
-        std::cout << "  weak_bind_off: 0x" << std::hex << cmd.weak_bind_off
-                  << "\n  weak_bind_size: 0x" << cmd.weak_bind_size
-                  << "\n";
-      }
-
-      if (cmd.lazy_bind_off) {
-        std::cout << "  lazy_bind: ";
-        print_bytes(buf + cmd.lazy_bind_off, cmd.lazy_bind_size);
-        std::cout << "  lazy_bind_off: 0x" << std::hex << cmd.lazy_bind_off
-                  << "\n  lazy_bind_size: 0x" << cmd.lazy_bind_size
-                  << "\n";
-      }
-
-      if (cmd.export_off) {
-        std::cout << "  export: ";
-        print_bytes(buf + cmd.export_off, cmd.export_size);
-        std::cout << "  export_off: 0x" << std::hex << cmd.export_off
-                  << "\n  export_size: 0x" << cmd.export_size
-                  << "\n";
-
-        std::vector<ExportEntry> vec;
-        read_trie(vec, buf + cmd.export_off);
-        for (ExportEntry &ent : vec)
-          std::cout << "  export_sym: " << ent.name << " 0x" << ent.addr << "\n";
-      }
-      break;
-    }
-    case LC_FUNCTION_STARTS: {
-      std::cout << "LC_FUNCTION_STARTS\n";
-      LinkEditDataCommand &cmd = *(LinkEditDataCommand *)&lc;
-      std::cout << " dataoff: 0x" << cmd.dataoff
-                << "\n datasize: 0x" << cmd.datasize
-                << "\n data:";
-
-      u8 *p = buf + cmd.dataoff;
-      u64 addr = 0;
-      for (;;) {
-        u64 delta = read_uleb(p);
-        if (!delta)
-          break;
-        addr += delta;
-        std::cout << std::hex << " 0x" << addr;
-      }
-      std::cout << "\n";
-      break;
-    }
-    case LC_MAIN: {
-      std::cout << "LC_MAIN\n";
-      EntryPointCommand &cmd = *(EntryPointCommand *)&lc;
-      std::cout << " cmdsize: 0x" << cmd.cmdsize
-                << "\n entryoff: 0x" << cmd.entryoff
-                << "\n stacksize: 0x" << cmd.stacksize
-                << "\n";
-      break;
-    }
-    case LC_DATA_IN_CODE: {
-      std::cout << "LC_DATA_IN_CODE\n";
-      LinkEditDataCommand &cmd = *(LinkEditDataCommand *)&lc;
-      std::cout << " dataoff: 0x" << cmd.dataoff
-                << "\n datasize: 0x" << cmd.datasize
-                << "\n";
-      break;
-    }
-    case LC_SOURCE_VERSION: {
-      std::cout << "LC_SOURCE_VERSION\n";
-      SourceVersionCommand &cmd = *(SourceVersionCommand *)&lc;
-      std::cout << " version: 0x" << cmd.version
-                << "\n";
-      break;
-    }
-      break;
-    case LC_BUILD_VERSION: {
-      std::cout << "LC_BUILD_VERSION\n";
-      BuildVersionCommand &cmd = *(BuildVersionCommand *)&lc;
-      std::cout << " cmdsize: 0x" << cmd.cmdsize
-                << "\n platform: 0x" << cmd.platform
-                << "\n minos: 0x" << cmd.minos
-                << "\n sdk: 0x" << cmd.sdk
-                << "\n ntools: 0x" << cmd.ntools
-                << "\n";
-
-      BuildToolVersion *tools =
-        (BuildToolVersion *)((u8 *)&lc + sizeof(BuildVersionCommand));
-      for (i64 i = 0; i < cmd.ntools; i++)
-        std::cout << "  tool: 0x" << tools[i].tool
-                  << "\n  version: 0x" << tools[i].version
-                  << "\n";
-      break;
-    }
-    case LC_VERSION_MIN_MACOSX: {
-      std::cout << "LC_VERSION_MIN_MACOSX\n";
-      VersionMinCommand &cmd = *(VersionMinCommand *)&lc;
-      std::cout << " version: " << (int)cmd.version
-                << "\n sdk: " << (int)cmd.sdk
-                << "\n";
-      break;
-    }
-    case LC_CODE_SIGNATURE: {
-      std::cout << "LC_CODE_SIGNATURE\n";
-      LinkEditDataCommand &cmd = *(LinkEditDataCommand *)&lc;
-
-      CodeSignatureHeader &sig = *(CodeSignatureHeader *)(buf + cmd.dataoff);
-      std::cout << " magic: " << sig.magic
-                << "\n length: " << sig.length
-                << "\n count: " << sig.count
-                << "\n";
-
-      for (i64 i = 0; i < sig.count; i++) {
-        CodeSignatureBlobIndex &idx = ((CodeSignatureBlobIndex *)(&sig + 1))[i];
-        std::cout << " idx type: " << idx.type
-                  << "\n idx offset: " << idx.offset
-                  << "\n";
-
-        CodeSignatureDirectory &dir =
-          *(CodeSignatureDirectory *)((u8 *)&sig + idx.offset);
-        std::cout << std::hex
-                  << " magic: 0x" << dir.magic
-                  << "\n version: 0x" << dir.version
-                  << "\n flags: 0x" << dir.flags
-                  << "\n hash_offset: 0x" << dir.hash_offset
-                  << "\n n_code_slots: 0x" << dir.n_code_slots
-                  << "\n hash_size: 0x" << (u32)dir.hash_size
-                  << "\n hash_type: 0x" << (u32)dir.hash_type
-                  << "\n page_size: 0x" << (1 << dir.page_size)
-                  << "\n";
-      }
-
-      break;
-    }
-    default:
-      std::cout << "UNKNOWN (0x" << std::hex << lc.cmd << ")\n";
-      break;
-    }
-  }
-}
-
-} // namespace mold::macho

macho/input-sections.cc

@@ -1,60 +0,0 @@
-#include "mold.h"
-
-namespace mold::macho {
-
-template <typename E>
-InputSection<E>::InputSection(Context<E> &ctx, ObjectFile<E> &file,
-                              const MachSection &hdr)
-  : file(file), hdr(hdr),
-    osec(*OutputSection<E>::get_instance(ctx, hdr.get_segname(),
-                                         hdr.get_sectname())) {
-  if (hdr.type != S_ZEROFILL)
-    contents = file.mf->get_contents().substr(hdr.offset, hdr.size);
-}
-
-template <typename E>
-void InputSection<E>::parse_relocations(Context<E> &ctx) {
-  rels.reserve(hdr.nreloc);
-
-  // Parse mach-o relocations to fill `rels` vector
-  rels = read_relocations(ctx, file, hdr);
-
-  // Sort `rels` vector
-  sort(rels, [](const Relocation<E> &a, const Relocation<E> &b) {
-    return a.offset < b.offset;
-  });
-
-  // Find subsections for this section
-  auto begin = std::lower_bound(
-      file.subsections.begin(), file.subsections.end(), hdr.addr,
-      [](std::unique_ptr<Subsection<E>> &subsec, u32 addr) {
-    return subsec->input_addr < addr;
-  });
-
-  auto end = std::lower_bound(
-      begin, file.subsections.end(), hdr.addr + hdr.size,
-      [](std::unique_ptr<Subsection<E>> &subsec, u32 addr) {
-    return subsec->input_addr < addr;
-  });
-
-  // Assign each subsection a group of relocations
-  i64 i = 0;
-  for (auto it = begin; it < end; it++) {
-    Subsection<E> &subsec = **it;
-    subsec.rel_offset = i;
-    while (i < rels.size() &&
-           rels[i].offset < subsec.input_offset + subsec.input_size) {
-      rels[i].offset -= subsec.input_offset;
-      i++;
-    }
-    subsec.nrels = i - subsec.rel_offset;
-  }
-}
-
-#define INSTANTIATE(E)                          \
-  template class InputSection<E>
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/macho.h

@@ -1,693 +0,0 @@
-#pragma once
-
-#include "../big-endian.h"
-
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-#include <string_view>
-
-namespace mold::macho {
-
-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;
-
-static constexpr u32 FAT_MAGIC = 0xcafebabe;
-
-static constexpr u32 MH_OBJECT = 0x1;
-static constexpr u32 MH_EXECUTE = 0x2;
-static constexpr u32 MH_FVMLIB = 0x3;
-static constexpr u32 MH_CORE = 0x4;
-static constexpr u32 MH_PRELOAD = 0x5;
-static constexpr u32 MH_DYLIB = 0x6;
-static constexpr u32 MH_DYLINKER = 0x7;
-static constexpr u32 MH_BUNDLE = 0x8;
-static constexpr u32 MH_DYLIB_STUB = 0x9;
-static constexpr u32 MH_DSYM = 0xa;
-static constexpr u32 MH_KEXT_BUNDLE = 0xb;
-
-static constexpr u32 MH_NOUNDEFS = 0x1;
-static constexpr u32 MH_INCRLINK = 0x2;
-static constexpr u32 MH_DYLDLINK = 0x4;
-static constexpr u32 MH_BINDATLOAD = 0x8;
-static constexpr u32 MH_PREBOUND = 0x10;
-static constexpr u32 MH_SPLIT_SEGS = 0x20;
-static constexpr u32 MH_LAZY_INIT = 0x40;
-static constexpr u32 MH_TWOLEVEL = 0x80;
-static constexpr u32 MH_FORCE_FLAT = 0x100;
-static constexpr u32 MH_NOMULTIDEFS = 0x200;
-static constexpr u32 MH_NOFIXPREBINDING = 0x400;
-static constexpr u32 MH_PREBINDABLE = 0x800;
-static constexpr u32 MH_ALLMODSBOUND = 0x1000;
-static constexpr u32 MH_SUBSECTIONS_VIA_SYMBOLS = 0x2000;
-static constexpr u32 MH_CANONICAL = 0x4000;
-static constexpr u32 MH_WEAK_DEFINES = 0x8000;
-static constexpr u32 MH_BINDS_TO_WEAK = 0x10000;
-static constexpr u32 MH_ALLOW_STACK_EXECUTION = 0x20000;
-static constexpr u32 MH_ROOT_SAFE = 0x40000;
-static constexpr u32 MH_SETUID_SAFE = 0x80000;
-static constexpr u32 MH_NO_REEXPORTED_DYLIBS = 0x100000;
-static constexpr u32 MH_PIE = 0x200000;
-static constexpr u32 MH_DEAD_STRIPPABLE_DYLIB = 0x400000;
-static constexpr u32 MH_HAS_TLV_DESCRIPTORS = 0x800000;
-static constexpr u32 MH_NO_HEAP_EXECUTION = 0x1000000;
-static constexpr u32 MH_APP_EXTENSION_SAFE = 0x02000000;
-static constexpr u32 MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000;
-static constexpr u32 MH_SIM_SUPPORT = 0x08000000;
-
-static constexpr u32 VM_PROT_READ = 0x1;
-static constexpr u32 VM_PROT_WRITE = 0x2;
-static constexpr u32 VM_PROT_EXECUTE = 0x4;
-static constexpr u32 VM_PROT_NO_CHANGE = 0x8;
-static constexpr u32 VM_PROT_COPY = 0x10;
-static constexpr u32 VM_PROT_WANTS_COPY = 0x10;
-
-static constexpr u32 LC_REQ_DYLD = 0x80000000;
-
-static constexpr u32 LC_SEGMENT = 0x1;
-static constexpr u32 LC_SYMTAB = 0x2;
-static constexpr u32 LC_SYMSEG = 0x3;
-static constexpr u32 LC_THREAD = 0x4;
-static constexpr u32 LC_UNIXTHREAD = 0x5;
-static constexpr u32 LC_LOADFVMLIB = 0x6;
-static constexpr u32 LC_IDFVMLIB = 0x7;
-static constexpr u32 LC_IDENT = 0x8;
-static constexpr u32 LC_FVMFILE = 0x9;
-static constexpr u32 LC_PREPAGE = 0xa;
-static constexpr u32 LC_DYSYMTAB = 0xb;
-static constexpr u32 LC_LOAD_DYLIB = 0xc;
-static constexpr u32 LC_ID_DYLIB = 0xd;
-static constexpr u32 LC_LOAD_DYLINKER = 0xe;
-static constexpr u32 LC_ID_DYLINKER = 0xf;
-static constexpr u32 LC_PREBOUND_DYLIB = 0x10;
-static constexpr u32 LC_ROUTINES = 0x11;
-static constexpr u32 LC_SUB_FRAMEWORK = 0x12;
-static constexpr u32 LC_SUB_UMBRELLA = 0x13;
-static constexpr u32 LC_SUB_CLIENT = 0x14;
-static constexpr u32 LC_SUB_LIBRARY = 0x15;
-static constexpr u32 LC_TWOLEVEL_HINTS = 0x16;
-static constexpr u32 LC_PREBIND_CKSUM = 0x17;
-static constexpr u32 LC_LOAD_WEAK_DYLIB = (0x18 | LC_REQ_DYLD);
-static constexpr u32 LC_SEGMENT_64 = 0x19;
-static constexpr u32 LC_ROUTINES_64 = 0x1a;
-static constexpr u32 LC_UUID = 0x1b;
-static constexpr u32 LC_RPATH = (0x1c | LC_REQ_DYLD);
-static constexpr u32 LC_CODE_SIGNATURE = 0x1d;
-static constexpr u32 LC_SEGMENT_SPLIT_INFO = 0x1e;
-static constexpr u32 LC_REEXPORT_DYLIB = (0x1f | LC_REQ_DYLD);
-static constexpr u32 LC_LAZY_LOAD_DYLIB = 0x20;
-static constexpr u32 LC_ENCRYPTION_INFO = 0x21;
-static constexpr u32 LC_DYLD_INFO = 0x22;
-static constexpr u32 LC_DYLD_INFO_ONLY = (0x22 | LC_REQ_DYLD);
-static constexpr u32 LC_LOAD_UPWARD_DYLIB = (0x23 | LC_REQ_DYLD);
-static constexpr u32 LC_VERSION_MIN_MACOSX = 0x24;
-static constexpr u32 LC_VERSION_MIN_IPHONEOS = 0x25;
-static constexpr u32 LC_FUNCTION_STARTS = 0x26;
-static constexpr u32 LC_DYLD_ENVIRONMENT = 0x27;
-static constexpr u32 LC_MAIN = (0x28 | LC_REQ_DYLD);
-static constexpr u32 LC_DATA_IN_CODE = 0x29;
-static constexpr u32 LC_SOURCE_VERSION = 0x2A;
-static constexpr u32 LC_DYLIB_CODE_SIGN_DRS = 0x2B;
-static constexpr u32 LC_ENCRYPTION_INFO_64 = 0x2C;
-static constexpr u32 LC_LINKER_OPTION = 0x2D;
-static constexpr u32 LC_LINKER_OPTIMIZATION_HINT = 0x2E;
-static constexpr u32 LC_VERSION_MIN_TVOS = 0x2F;
-static constexpr u32 LC_VERSION_MIN_WATCHOS = 0x30;
-static constexpr u32 LC_NOTE = 0x31;
-static constexpr u32 LC_BUILD_VERSION = 0x32;
-static constexpr u32 LC_DYLD_EXPORTS_TRIE = (0x33 | LC_REQ_DYLD);
-static constexpr u32 LC_DYLD_CHAINED_FIXUPS = (0x34 | LC_REQ_DYLD);
-
-static constexpr u32 SG_HIGHVM = 0x1;
-static constexpr u32 SG_FVMLIB = 0x2;
-static constexpr u32 SG_NORELOC = 0x4;
-static constexpr u32 SG_PROTECTED_VERSION_1 = 0x8;
-static constexpr u32 SG_READ_ONLY = 0x10;
-
-static constexpr u32 S_REGULAR = 0x0;
-static constexpr u32 S_ZEROFILL = 0x1;
-static constexpr u32 S_CSTRING_LITERALS = 0x2;
-static constexpr u32 S_4BYTE_LITERALS = 0x3;
-static constexpr u32 S_8BYTE_LITERALS = 0x4;
-static constexpr u32 S_LITERAL_POINTERS = 0x5;
-static constexpr u32 S_NON_LAZY_SYMBOL_POINTERS = 0x6;
-static constexpr u32 S_LAZY_SYMBOL_POINTERS = 0x7;
-static constexpr u32 S_SYMBOL_STUBS = 0x8;
-static constexpr u32 S_MOD_INIT_FUNC_POINTERS = 0x9;
-static constexpr u32 S_MOD_TERM_FUNC_POINTERS = 0xa;
-static constexpr u32 S_COALESCED = 0xb;
-static constexpr u32 S_GB_ZEROFILL = 0xc;
-static constexpr u32 S_INTERPOSING = 0xd;
-static constexpr u32 S_16BYTE_LITERALS = 0xe;
-static constexpr u32 S_DTRACE_DOF = 0xf;
-static constexpr u32 S_LAZY_DYLIB_SYMBOL_POINTERS = 0x10;
-static constexpr u32 S_THREAD_LOCAL_REGULAR = 0x11;
-static constexpr u32 S_THREAD_LOCAL_ZEROFILL = 0x12;
-static constexpr u32 S_THREAD_LOCAL_VARIABLES = 0x13;
-static constexpr u32 S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14;
-static constexpr u32 S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15;
-static constexpr u32 S_INIT_FUNC_OFFSETS = 0x16;
-
-static constexpr u32 S_ATTR_LOC_RELOC = 0x000001;
-static constexpr u32 S_ATTR_EXT_RELOC = 0x000002;
-static constexpr u32 S_ATTR_SOME_INSTRUCTIONS = 0x000004;
-
-static constexpr u32 S_ATTR_DEBUG = 0x020000;
-static constexpr u32 S_ATTR_SELF_MODIFYING_CODE = 0x040000;
-static constexpr u32 S_ATTR_LIVE_SUPPORT = 0x080000;
-static constexpr u32 S_ATTR_NO_DEAD_STRIP = 0x100000;
-static constexpr u32 S_ATTR_STRIP_STATIC_SYMS = 0x200000;
-static constexpr u32 S_ATTR_NO_TOC = 0x400000;
-static constexpr u32 S_ATTR_PURE_INSTRUCTIONS = 0x800000;
-
-static constexpr u32 CPU_TYPE_X86_64 = 0x1000007;
-static constexpr u32 CPU_TYPE_ARM64 = 0x100000c;
-
-static constexpr u32 CPU_SUBTYPE_X86_64_ALL = 3;
-static constexpr u32 CPU_SUBTYPE_ARM64_ALL = 0;
-
-static constexpr u32 REBASE_TYPE_POINTER = 1;
-static constexpr u32 REBASE_TYPE_TEXT_ABSOLUTE32 = 2;
-static constexpr u32 REBASE_TYPE_TEXT_PCREL32 = 3;
-
-static constexpr u32 REBASE_OPCODE_MASK = 0xf0;
-static constexpr u32 REBASE_IMMEDIATE_MASK = 0x0f;
-static constexpr u32 REBASE_OPCODE_DONE = 0x00;
-static constexpr u32 REBASE_OPCODE_SET_TYPE_IMM = 0x10;
-static constexpr u32 REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x20;
-static constexpr u32 REBASE_OPCODE_ADD_ADDR_ULEB = 0x30;
-static constexpr u32 REBASE_OPCODE_ADD_ADDR_IMM_SCALED = 0x40;
-static constexpr u32 REBASE_OPCODE_DO_REBASE_IMM_TIMES = 0x50;
-static constexpr u32 REBASE_OPCODE_DO_REBASE_ULEB_TIMES = 0x60;
-static constexpr u32 REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB = 0x70;
-static constexpr u32 REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80;
-
-static constexpr u32 BIND_TYPE_POINTER = 1;
-static constexpr u32 BIND_TYPE_TEXT_ABSOLUTE32 = 2;
-static constexpr u32 BIND_TYPE_TEXT_PCREL32 = 3;
-
-static constexpr u32 BIND_SPECIAL_DYLIB_SELF = 0;
-static constexpr u32 BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE = -1;
-static constexpr u32 BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2;
-static constexpr u32 BIND_SPECIAL_DYLIB_WEAK_LOOKUP = -3;
-
-static constexpr u32 BIND_SYMBOL_FLAGS_WEAK_IMPORT = 0x1;
-static constexpr u32 BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION = 0x8;
-
-static constexpr u32 BIND_OPCODE_MASK = 0xF0;
-static constexpr u32 BIND_IMMEDIATE_MASK = 0x0F;
-static constexpr u32 BIND_OPCODE_DONE = 0x00;
-static constexpr u32 BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10;
-static constexpr u32 BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20;
-static constexpr u32 BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30;
-static constexpr u32 BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40;
-static constexpr u32 BIND_OPCODE_SET_TYPE_IMM = 0x50;
-static constexpr u32 BIND_OPCODE_SET_ADDEND_SLEB = 0x60;
-static constexpr u32 BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70;
-static constexpr u32 BIND_OPCODE_ADD_ADDR_ULEB = 0x80;
-static constexpr u32 BIND_OPCODE_DO_BIND = 0x90;
-static constexpr u32 BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 0xA0;
-static constexpr u32 BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 0xB0;
-static constexpr u32 BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0;
-static constexpr u32 BIND_OPCODE_THREADED = 0xD0;
-static constexpr u32 BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0x00;
-static constexpr u32 BIND_SUBOPCODE_THREADED_APPLY = 0x01;
-
-static constexpr u32 EXPORT_SYMBOL_FLAGS_KIND_MASK = 0x03;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_KIND_REGULAR = 0x00;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL = 0x01;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE = 0x02;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION = 0x04;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_REEXPORT = 0x08;
-static constexpr u32 EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER = 0x10;
-
-static constexpr u32 DICE_KIND_DATA = 1;
-static constexpr u32 DICE_KIND_JUMP_TABLE8 = 2;
-static constexpr u32 DICE_KIND_JUMP_TABLE16 = 3;
-static constexpr u32 DICE_KIND_JUMP_TABLE32 = 4;
-static constexpr u32 DICE_KIND_ABS_JUMP_TABLE32 = 5;
-
-static constexpr u32 N_UNDF = 0;
-static constexpr u32 N_ABS = 1;
-static constexpr u32 N_INDR = 5;
-static constexpr u32 N_PBUD = 6;
-static constexpr u32 N_SECT = 7;
-
-static constexpr u32 N_GSYM = 0x20;
-static constexpr u32 N_FNAME = 0x22;
-static constexpr u32 N_FUN = 0x24;
-static constexpr u32 N_STSYM = 0x26;
-static constexpr u32 N_LCSYM = 0x28;
-static constexpr u32 N_BNSYM = 0x2e;
-static constexpr u32 N_AST = 0x32;
-static constexpr u32 N_OPT = 0x3c;
-static constexpr u32 N_RSYM = 0x40;
-static constexpr u32 N_SLINE = 0x44;
-static constexpr u32 N_ENSYM = 0x4e;
-static constexpr u32 N_SSYM = 0x60;
-static constexpr u32 N_SO = 0x64;
-static constexpr u32 N_OSO = 0x66;
-static constexpr u32 N_LSYM = 0x80;
-static constexpr u32 N_BINCL = 0x82;
-static constexpr u32 N_SOL = 0x84;
-static constexpr u32 N_PARAMS = 0x86;
-static constexpr u32 N_VERSION = 0x88;
-static constexpr u32 N_OLEVEL = 0x8A;
-static constexpr u32 N_PSYM = 0xa0;
-static constexpr u32 N_EINCL = 0xa2;
-static constexpr u32 N_ENTRY = 0xa4;
-static constexpr u32 N_LBRAC = 0xc0;
-static constexpr u32 N_EXCL = 0xc2;
-static constexpr u32 N_RBRAC = 0xe0;
-static constexpr u32 N_BCOMM = 0xe2;
-static constexpr u32 N_ECOMM = 0xe4;
-static constexpr u32 N_ECOML = 0xe8;
-static constexpr u32 N_LENG = 0xfe;
-static constexpr u32 N_PC = 0x30;
-
-static constexpr u32 REFERENCE_TYPE = 0xf;
-static constexpr u32 REFERENCE_FLAG_UNDEFINED_NON_LAZY = 0;
-static constexpr u32 REFERENCE_FLAG_UNDEFINED_LAZY = 1;
-static constexpr u32 REFERENCE_FLAG_DEFINED = 2;
-static constexpr u32 REFERENCE_FLAG_PRIVATE_DEFINED = 3;
-static constexpr u32 REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY = 4;
-static constexpr u32 REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY = 5;
-
-static constexpr u32 REFERENCED_DYNAMICALLY = 0x0010;
-
-static constexpr u32 N_NO_DEAD_STRIP = 0x0020;
-static constexpr u32 N_DESC_DISCARDED = 0x0020;
-static constexpr u32 N_WEAK_REF = 0x0040;
-static constexpr u32 N_WEAK_DEF = 0x0080;
-static constexpr u32 N_REF_TO_WEAK = 0x0080;
-static constexpr u32 N_ARM_THUMB_DEF = 0x0008;
-static constexpr u32 N_SYMBOL_RESOLVER = 0x0100;
-static constexpr u32 N_ALT_ENTRY = 0x0200;
-
-static constexpr u32 PLATFORM_MACOS = 1;
-static constexpr u32 PLATFORM_IOS = 2;
-static constexpr u32 PLATFORM_TVOS = 3;
-static constexpr u32 PLATFORM_WATCHOS = 4;
-static constexpr u32 PLATFORM_BRIDGEOS = 5;
-static constexpr u32 PLATFORM_MACCATALYST = 6;
-static constexpr u32 PLATFORM_IOSSIMULATOR = 7;
-static constexpr u32 PLATFORM_TVOSSIMULATOR = 8;
-static constexpr u32 PLATFORM_WATCHOSSIMULATOR = 9;
-static constexpr u32 PLATFORM_DRIVERKIT = 10;
-
-static constexpr u32 TOOL_CLANG = 1;
-static constexpr u32 TOOL_SWIFT = 2;
-static constexpr u32 TOOL_LD = 3;
-
-static constexpr u32 ARM64_RELOC_UNSIGNED = 0;
-static constexpr u32 ARM64_RELOC_SUBTRACTOR = 1;
-static constexpr u32 ARM64_RELOC_BRANCH26 = 2;
-static constexpr u32 ARM64_RELOC_PAGE21 = 3;
-static constexpr u32 ARM64_RELOC_PAGEOFF12 = 4;
-static constexpr u32 ARM64_RELOC_GOT_LOAD_PAGE21 = 5;
-static constexpr u32 ARM64_RELOC_GOT_LOAD_PAGEOFF12 = 6;
-static constexpr u32 ARM64_RELOC_POINTER_TO_GOT = 7;
-static constexpr u32 ARM64_RELOC_TLVP_LOAD_PAGE21 = 8;
-static constexpr u32 ARM64_RELOC_TLVP_LOAD_PAGEOFF12 = 9;
-static constexpr u32 ARM64_RELOC_ADDEND = 10;
-
-static constexpr u32 X86_64_RELOC_UNSIGNED = 0;
-static constexpr u32 X86_64_RELOC_SIGNED = 1;
-static constexpr u32 X86_64_RELOC_BRANCH = 2;
-static constexpr u32 X86_64_RELOC_GOT_LOAD = 3;
-static constexpr u32 X86_64_RELOC_GOT = 4;
-static constexpr u32 X86_64_RELOC_SUBTRACTOR = 5;
-static constexpr u32 X86_64_RELOC_SIGNED_1 = 6;
-static constexpr u32 X86_64_RELOC_SIGNED_2 = 7;
-static constexpr u32 X86_64_RELOC_SIGNED_4 = 8;
-static constexpr u32 X86_64_RELOC_TLV = 9;
-
-struct FatHeader {
-  ubig32 magic;
-  ubig32 nfat_arch;
-};
-
-struct FatArch {
-  ubig32 cputype;
-  ubig32 cpusubtype;
-  ubig32 offset;
-  ubig32 size;
-  ubig32 align;
-};
-
-struct MachHeader {
-  u32 magic;
-  u32 cputype;
-  u32 cpusubtype;
-  u32 filetype;
-  u32 ncmds;
-  u32 sizeofcmds;
-  u32 flags;
-  u32 reserved;
-};
-
-struct LoadCommand {
-  u32 cmd;
-  u32 cmdsize;
-};
-
-struct SegmentCommand {
-  std::string_view get_segname() const {
-    return {segname, strnlen(segname, sizeof(segname))};
-  }
-
-  u32 cmd;
-  u32 cmdsize;
-  char segname[16];
-  u64 vmaddr;
-  u64 vmsize;
-  u64 fileoff;
-  u64 filesize;
-  u32 maxprot;
-  u32 initprot;
-  u32 nsects;
-  u32 flags;
-};
-
-struct MachSection {
-  void set_segname(std::string_view name) {
-    assert(name.size() <= sizeof(segname));
-    memcpy(segname, name.data(), name.size());
-  }
-
-  std::string_view get_segname() const {
-    return {segname, strnlen(segname, sizeof(segname))};
-  }
-
-  void set_sectname(std::string_view name) {
-    assert(name.size() <= sizeof(sectname));
-    memcpy(sectname, name.data(), name.size());
-  }
-
-  std::string_view get_sectname() const {
-    return {sectname, strnlen(sectname, sizeof(sectname))};
-  }
-
-  bool match(std::string_view segname, std::string_view sectname) const {
-    return get_segname() == segname && get_sectname() == sectname;
-  }
-
-  char sectname[16];
-  char segname[16];
-  u64 addr;
-  u64 size;
-  u32 offset;
-  u32 p2align;
-  u32 reloff;
-  u32 nreloc;
-  u32 type : 8;
-  u32 attr : 24;
-  u32 reserved1;
-  u32 reserved2;
-  u32 reserved3;
-};
-
-struct DylibCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 nameoff;
-  u32 timestamp;
-  u32 current_version;
-  u32 compatibility_version;
-};
-
-struct DylinkerCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 nameoff;
-};
-
-struct SymtabCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 symoff;
-  u32 nsyms;
-  u32 stroff;
-  u32 strsize;
-};
-
-struct DysymtabCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 ilocalsym;
-  u32 nlocalsym;
-  u32 iextdefsym;
-  u32 nextdefsym;
-  u32 iundefsym;
-  u32 nundefsym;
-  u32 tocoff;
-  u32 ntoc;
-  u32 modtaboff;
-  u32 nmodtab;
-  u32 extrefsymoff;
-  u32 nextrefsyms;
-  u32 indirectsymoff;
-  u32 nindirectsyms;
-  u32 extreloff;
-  u32 nextrel;
-  u32 locreloff;
-  u32 nlocrel;
-};
-
-struct VersionMinCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 version;
-  u32 sdk;
-};
-
-struct DyldInfoCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 rebase_off;
-  u32 rebase_size;
-  u32 bind_off;
-  u32 bind_size;
-  u32 weak_bind_off;
-  u32 weak_bind_size;
-  u32 lazy_bind_off;
-  u32 lazy_bind_size;
-  u32 export_off;
-  u32 export_size;
-};
-
-struct UUIDCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u8 uuid[16];
-};
-
-struct RpathCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 path_off;
-};
-
-struct LinkEditDataCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 dataoff;
-  u32 datasize;
-};
-
-struct BuildToolVersion {
-  u32 tool;
-  u32 version;
-};
-
-struct BuildVersionCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u32 platform;
-  u32 minos;
-  u32 sdk;
-  u32 ntools;
-};
-
-struct EntryPointCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u64 entryoff;
-  u64 stacksize;
-};
-
-struct SourceVersionCommand {
-  u32 cmd;
-  u32 cmdsize;
-  u64 version;
-};
-
-struct DataInCodeEntry {
-  u32 offset;
-  u16 length;
-  u16 kind;
-};
-
-// This struct is named `n_list` on BSD and macOS.
-struct MachSym {
-  bool is_undef() const {
-    return type == N_UNDF && !is_common();
-  }
-
-  bool is_common() const {
-    return type == N_UNDF && ext && value;
-  }
-
-  u32 stroff;
-  u8 ext : 1;
-  u8 type : 3;
-  u8 pext : 1;
-  u8 stub : 3;
-  u8 sect;
-  union {
-    u16 desc;
-    struct {
-      u16 : 8;
-      u16 p2align : 4;
-      u16 : 4;
-    };
-  };
-  u64 value;
-};
-
-// This struct is named `relocation_info` on BSD and macOS.
-struct MachRel {
-  u32 offset;
-  u32 idx : 24;
-  u32 is_pcrel : 1;
-  u32 p2size : 2;
-  u32 is_extern : 1;
-  u32 type : 4;
-};
-
-// __TEXT,__unwind_info section contents
-
-static constexpr u32 UNWIND_SECTION_VERSION = 1;
-static constexpr u32 UNWIND_SECOND_LEVEL_REGULAR = 2;
-static constexpr u32 UNWIND_SECOND_LEVEL_COMPRESSED = 3;
-static constexpr u32 UNWIND_PERSONALITY_MASK = 0x30000000;
-
-struct UnwindSectionHeader {
-  u32 version;
-  u32 encoding_offset;
-  u32 encoding_count;
-  u32 personality_offset;
-  u32 personality_count;
-  u32 page_offset;
-  u32 page_count;
-};
-
-struct UnwindFirstLevelPage {
-  u32 func_addr;
-  u32 page_offset;
-  u32 lsda_offset;
-};
-
-struct UnwindSecondLevelPage {
-  u32 kind;
-  u16 page_offset;
-  u16 page_count;
-  u16 encoding_offset;
-  u16 encoding_count;
-};
-
-struct UnwindLsdaEntry {
-  u32 func_addr;
-  u32 lsda_addr;
-};
-
-struct UnwindPageEntry {
-  u32 func_addr : 24;
-  u32 encoding : 8;
-};
-
-// __LD,__compact_unwind section contents
-
-struct CompactUnwindEntry {
-  u64 code_start;
-  u32 code_len;
-  u32 encoding;
-  u64 personality;
-  u64 lsda;
-};
-
-// __LINKEDIT,__code_signature
-
-static constexpr u32 CSMAGIC_EMBEDDED_SIGNATURE = 0xfade0cc0;
-static constexpr u32 CS_SUPPORTSEXECSEG = 0x20400;
-static constexpr u32 CSMAGIC_CODEDIRECTORY = 0xfade0c02;
-static constexpr u32 CSSLOT_CODEDIRECTORY = 0;
-static constexpr u32 CS_ADHOC = 0x00000002;
-static constexpr u32 CS_LINKER_SIGNED = 0x00020000;
-static constexpr u32 CS_EXECSEG_MAIN_BINARY = 1;
-static constexpr u32 CS_HASHTYPE_SHA256 = 2;
-
-struct CodeSignatureHeader {
-  ubig32 magic;
-  ubig32 length;
-  ubig32 count;
-};
-
-struct CodeSignatureBlobIndex {
-  ubig32 type;
-  ubig32 offset;
-  u32 padding;
-};
-
-struct CodeSignatureDirectory {
-  ubig32 magic;
-  ubig32 length;
-  ubig32 version;
-  ubig32 flags;
-  ubig32 hash_offset;
-  ubig32 ident_offset;
-  ubig32 n_special_slots;
-  ubig32 n_code_slots;
-  ubig32 code_limit;
-  u8 hash_size;
-  u8 hash_type;
-  u8 platform;
-  u8 page_size;
-  ubig32 spare2;
-  ubig32 scatter_offset;
-  ubig32 team_offset;
-  ubig32 spare3;
-  ubig64 code_limit64;
-  ubig64 exec_seg_base;
-  ubig64 exec_seg_limit;
-  ubig64 exec_seg_flags;
-};
-
-struct ARM64 {
-  static constexpr u32 cputype = CPU_TYPE_ARM64;
-  static constexpr u32 cpusubtype = CPU_SUBTYPE_ARM64_ALL;
-  static constexpr u32 abs_rel = ARM64_RELOC_UNSIGNED;
-  static constexpr u32 word_size = 8;
-  static constexpr u32 stub_size = 12;
-  static constexpr u32 stub_helper_hdr_size = 24;
-  static constexpr u32 stub_helper_size = 12;
-};
-
-struct X86_64 {
-  static constexpr u32 cputype = CPU_TYPE_X86_64;
-  static constexpr u32 cpusubtype = CPU_SUBTYPE_X86_64_ALL;
-  static constexpr u32 abs_rel = X86_64_RELOC_UNSIGNED;
-  static constexpr u32 word_size = 8;
-  static constexpr u32 stub_size = 6;
-  static constexpr u32 stub_helper_hdr_size = 16;
-  static constexpr u32 stub_helper_size = 10;
-};
-
-} // namespace mold::macho

macho/main.cc

@@ -1,489 +0,0 @@
-#include "mold.h"
-#include "../archive-file.h"
-#include "../cmdline.h"
-
-#include <cstdlib>
-#include <fcntl.h>
-#include <iomanip>
-#include <iostream>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace mold::macho {
-
-static std::pair<std::string_view, std::string_view>
-split_string(std::string_view str, char sep) {
-  size_t pos = str.find(sep);
-  if (pos == str.npos)
-    return {str, ""};
-  return {str.substr(0, pos), str.substr(pos + 1)};
-}
-
-template <typename E>
-static void create_internal_file(Context<E> &ctx) {
-  ObjectFile<E> *obj = new ObjectFile<E>;
-  ctx.obj_pool.emplace_back(obj);
-  ctx.objs.push_back(obj);
-
-  auto add = [&](std::string_view name) {
-    Symbol<E> *sym = get_symbol(ctx, name);
-    sym->file = obj;
-    obj->syms.push_back(sym);
-    return sym;
-  };
-
-  add("__dyld_private");
-
-  switch (ctx.output_type) {
-  case MH_EXECUTE: {
-    Symbol<E> *sym = add("__mh_execute_header");
-    sym->is_extern = true;
-    sym->referenced_dynamically = true;
-    sym->value = ctx.arg.pagezero_size;
-    break;
-  }
-  case MH_DYLIB:
-    add("__mh_dylib_header");
-    break;
-  case MH_BUNDLE:
-    add("__mh_bundle_header");
-    break;
-  default:
-    unreachable();
-  }
-}
-
-template <typename E>
-static bool compare_segments(const std::unique_ptr<OutputSegment<E>> &a,
-                             const std::unique_ptr<OutputSegment<E>> &b) {
-  // We want to sort output segments in the following order:
-  // __TEXT, __DATA_CONST, __DATA, <other segments>, __LINKEDIT
-  auto get_rank = [](std::string_view name) {
-    if (name == "__TEXT")
-      return 0;
-    if (name == "__DATA_CONST")
-      return 1;
-    if (name == "__DATA")
-      return 2;
-    return INT_MAX;
-  };
-
-  std::string_view na = a->cmd.get_segname();
-  std::string_view nb = b->cmd.get_segname();
-  i64 ra = get_rank(na);
-  i64 rb = get_rank(nb);
-  if (ra != INT_MAX || rb != INT_MAX)
-    return ra < rb;
-
-  if (na == "__LINKEDIT" || nb == "__LINKEDIT")
-    return na != "__LINKEDIT";
-  return na < nb;
-}
-
-template <typename E>
-static bool compare_chunks(const Chunk<E> *a, const Chunk<E> *b) {
-  assert(a->hdr.get_segname() == b->hdr.get_segname());
-
-  if ((a->hdr.type == S_ZEROFILL) != (b->hdr.type == S_ZEROFILL))
-    return a->hdr.type != S_ZEROFILL;
-
-  static const std::string_view rank[] = {
-    // __TEXT
-    "__mach_header",
-    "__text",
-    "__stubs",
-    "__stub_helper",
-    "__gcc_except_tab",
-    "__cstring",
-    "__unwind_info",
-    // __DATA_CONST
-    "__got",
-    // __DATA
-    "__la_symbol_ptr",
-    "__data",
-    "__thread_ptr",
-    "__thread_data",
-    "__thread_vars",
-    "__thread_bss",
-    "__common",
-    "__bss",
-    // __LINKEDIT
-    "__rebase",
-    "__binding",
-    "__weak_binding",
-    "__lazy_binding",
-    "__export",
-    "__func_starts",
-    "__data_in_code",
-    "__symbol_table",
-    "__ind_sym_tab",
-    "__string_table",
-    "__code_signature",
-  };
-
-  auto get_rank = [](const Chunk<E> *chunk) -> i64 {
-    std::string_view name = chunk->hdr.get_sectname();
-    i64 i = 0;
-    for (; i < sizeof(rank) / sizeof(rank[0]); i++)
-      if (name == rank[i])
-        return i;
-    return INT_MAX;
-  };
-
-  i64 ra = get_rank(a);
-  i64 rb = get_rank(b);
-  if (ra == INT_MAX && rb == INT_MAX)
-    return a->hdr.get_sectname() < b->hdr.get_sectname();
-  return ra < rb;
-}
-
-template <typename E>
-static void create_synthetic_chunks(Context<E> &ctx) {
-  for (ObjectFile<E> *file : ctx.objs)
-    for (std::unique_ptr<Subsection<E>> &subsec : file->subsections)
-      subsec->isec.osec.add_subsec(subsec.get());
-
-  for (Chunk<E> *chunk : ctx.chunks) {
-    if (chunk != ctx.data && chunk->is_regular &&
-        ((OutputSection<E> *)chunk)->members.empty())
-      continue;
-
-    OutputSegment<E> *seg =
-      OutputSegment<E>::get_instance(ctx, chunk->hdr.get_segname());
-    seg->chunks.push_back(chunk);
-  }
-
-  sort(ctx.segments, compare_segments<E>);
-
-  for (std::unique_ptr<OutputSegment<E>> &seg : ctx.segments)
-    sort(seg->chunks, compare_chunks<E>);
-}
-
-template <typename E>
-static void scan_unwind_info(Context<E> &ctx) {
-  for (ObjectFile<E> *file : ctx.objs)
-    for (UnwindRecord<E> &rec : file->unwind_records)
-      if (!ctx.arg.dead_strip || rec.is_alive)
-        if (rec.personality)
-          rec.personality->flags |= NEEDS_GOT;
-}
-
-template <typename E>
-static void export_symbols(Context<E> &ctx) {
-  ctx.got.add(ctx, get_symbol(ctx, "dyld_stub_binder"));
-
-  for (ObjectFile<E> *file : ctx.objs) {
-    for (Symbol<E> *sym : file->syms) {
-      if (sym && sym->file == file) {
-        if (sym->flags & NEEDS_GOT)
-          ctx.got.add(ctx, sym);
-        if (sym->flags & NEEDS_THREAD_PTR)
-          ctx.thread_ptrs.add(ctx, sym);
-      }
-    }
-  }
-
-  for (DylibFile<E> *file : ctx.dylibs) {
-    for (Symbol<E> *sym : file->syms) {
-      if (sym && sym->file == file) {
-        if (sym->flags & NEEDS_STUB)
-          ctx.stubs.add(ctx, sym);
-        if (sym->flags & NEEDS_GOT)
-          ctx.got.add(ctx, sym);
-        if (sym->flags & NEEDS_THREAD_PTR)
-          ctx.thread_ptrs.add(ctx, sym);
-      }
-    }
-  }
-}
-
-template <typename E>
-static i64 assign_offsets(Context<E> &ctx) {
-  i64 sect_idx = 1;
-  for (std::unique_ptr<OutputSegment<E>> &seg : ctx.segments)
-    for (Chunk<E> *chunk : seg->chunks)
-      if (!chunk->is_hidden)
-        chunk->sect_idx = sect_idx++;
-
-  i64 fileoff = 0;
-  i64 vmaddr = ctx.arg.pagezero_size;
-
-  for (std::unique_ptr<OutputSegment<E>> &seg : ctx.segments) {
-    seg->set_offset(ctx, fileoff, vmaddr);
-    fileoff += seg->cmd.filesize;
-    vmaddr += seg->cmd.vmsize;
-  }
-  return fileoff;
-}
-
-template <typename E>
-static void fix_synthetic_symbol_values(Context<E> &ctx) {
-  get_symbol(ctx, "__dyld_private")->value = ctx.data->hdr.addr;
-  get_symbol(ctx, "__mh_dylib_header")->value = ctx.data->hdr.addr;
-  get_symbol(ctx, "__mh_bundle_header")->value = ctx.data->hdr.addr;
-}
-
-template <typename E>
-MappedFile<Context<E>> *find_framework(Context<E> &ctx, std::string name) {
-  std::string suffix;
-  std::tie(name, suffix) = split_string(name, ',');
-
-  for (std::string path : ctx.arg.framework_paths) {
-    path = get_realpath(path + "/" + name + ".framework/" + name);
-
-    if (!suffix.empty())
-      if (auto *mf = MappedFile<Context<E>>::open(ctx, path + suffix))
-        return mf;
-
-    if (auto *mf = MappedFile<Context<E>>::open(ctx, path + ".tbd"))
-      return mf;
-
-    if (auto *mf = MappedFile<Context<E>>::open(ctx, path))
-      return mf;
-  }
-  Fatal(ctx) << "-framework not found: " << name;
-}
-
-template <typename E>
-MappedFile<Context<E>> *find_library(Context<E> &ctx, std::string name) {
-  for (std::string dir : ctx.arg.library_paths) {
-    for (std::string ext : {".tbd", ".dylib", ".a"}) {
-      std::string path = dir + "/lib" + name + ext;
-      if (MappedFile<Context<E>> *mf = MappedFile<Context<E>>::open(ctx, path))
-        return mf;
-    }
-  }
-  return nullptr;
-}
-
-template <typename E>
-static MappedFile<Context<E>> *
-strip_universal_header(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  FatHeader &hdr = *(FatHeader *)mf->data;
-  assert(hdr.magic == FAT_MAGIC);
-
-  FatArch *arch = (FatArch *)(mf->data + sizeof(hdr));
-  for (i64 i = 0; i < hdr.nfat_arch; i++)
-    if (arch[i].cputype == E::cputype)
-      return mf->slice(ctx, mf->name, arch[i].offset, arch[i].size);
-  Fatal(ctx) << mf->name << ": fat file contains no matching file";
-}
-
-template <typename E>
-static void read_file(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                      bool is_needed = false) {
-  if (get_file_type(mf) == FileType::MACH_UNIVERSAL)
-    mf = strip_universal_header(ctx, mf);
-
-  switch (get_file_type(mf)) {
-  case FileType::TAPI:
-  case FileType::MACH_DYLIB:
-    ctx.dylibs.push_back(DylibFile<E>::create(ctx, mf));
-    if (is_needed || !ctx.arg.dead_strip_dylibs)
-      ctx.dylibs.back()->is_needed = true;
-    break;
-  case FileType::MACH_OBJ:
-    ctx.objs.push_back(ObjectFile<E>::create(ctx, mf, ""));
-    break;
-  case FileType::AR:
-    for (MappedFile<Context<E>> *child : read_archive_members(ctx, mf))
-      if (get_file_type(child) == FileType::MACH_OBJ)
-        ctx.objs.push_back(ObjectFile<E>::create(ctx, child, mf->name));
-    break;
-  default:
-    break;
-    // Fatal(ctx) << mf->name << ": unknown file type";
-  }
-}
-
-template <typename E>
-static std::vector<std::string>
-read_filelist(Context<E> &ctx, std::string arg) {
-  std::string path;
-  std::string dir;
-
-  if (size_t pos = arg.find(','); pos != arg.npos) {
-    path = arg.substr(0, pos);
-    dir = arg.substr(pos + 1) + "/";
-  } else {
-    path = arg;
-  }
-
-  MappedFile<Context<E>> *mf = MappedFile<Context<E>>::open(ctx, path);
-  if (!mf)
-    Fatal(ctx) << "-filepath: cannot open " << path;
-
-  std::vector<std::string> vec;
-  for (std::string_view str = mf->get_contents(); !str.empty();) {
-    std::string_view path;
-    std::tie(path, str) = split_string(str, '\n');
-    vec.push_back(path_clean(dir + std::string(path)));
-  }
-  return vec;
-}
-
-template <typename E>
-static void read_input_files(Context<E> &ctx, std::span<std::string> args) {
-  while (!args.empty()) {
-    if (args[0].starts_with("-filelist")) {
-      for (std::string &path : read_filelist(ctx, args[1])) {
-        MappedFile<Context<E>> *mf = MappedFile<Context<E>>::open(ctx, path);
-        if (!mf)
-          Fatal(ctx) << "-filepath " << args[1] << ": cannot open file: " << path;
-        read_file(ctx, mf);
-      }
-      args = args.subspan(2);
-    } else if (args[0] == "-framework" || args[0] == "-needed_framework") {
-      bool needed = (args[0] == "-needed_framework");
-      read_file(ctx, find_framework(ctx, args[1]), needed);
-      args = args.subspan(2);
-    } else if (args[0] == "-l" || args[0] == "-needed-l") {
-      MappedFile<Context<E>> *mf = find_library(ctx, args[1]);
-      if (!mf)
-        Fatal(ctx) << "library not found: -l" << args[1];
-      bool needed = (args[0] == "-needed-l");
-      read_file(ctx, mf, needed);
-      args = args.subspan(2);
-    } else {
-      read_file(ctx, MappedFile<Context<E>>::must_open(ctx, args[0]));
-      args = args.subspan(1);
-    }
-  }
-
-  if (ctx.objs.empty())
-    Fatal(ctx) << "no input files";
-}
-
-template <typename E>
-static int do_main(int argc, char **argv) {
-  Context<E> ctx;
-
-  if (argc > 1 && std::string_view(argv[1]) == "-dump") {
-    if (argc != 3)
-      Fatal(ctx) << "usage: ld64.mold -dump <executable-name>\n";
-    dump_file(argv[2]);
-    exit(0);
-  }
-
-  for (i64 i = 0; i < argc; i++)
-    ctx.cmdline_args.push_back(argv[i]);
-
-  std::vector<std::string> file_args;
-  parse_nonpositional_args(ctx, file_args);
-
-  if (ctx.arg.arch != E::cputype) {
-    if (ctx.arg.arch == CPU_TYPE_X86_64)
-      return do_main<X86_64>(argc, argv);
-  }
-
-  read_input_files(ctx, file_args);
-
-  i64 priority = 1;
-  for (ObjectFile<E> *file : ctx.objs)
-    file->priority = priority++;
-  for (DylibFile<E> *dylib : ctx.dylibs)
-    dylib->priority = priority++;
-
-  for (i64 i = 0; i < ctx.dylibs.size(); i++)
-    ctx.dylibs[i]->dylib_idx = i + 1;
-
-  for (ObjectFile<E> *file : ctx.objs)
-    file->parse(ctx);
-  for (DylibFile<E> *dylib : ctx.dylibs)
-    dylib->parse(ctx);
-
-  if (ctx.arg.ObjC)
-    for (ObjectFile<E> *file : ctx.objs)
-      if (!file->archive_name.empty() && file->is_objc_object(ctx))
-        file->is_alive = true;
-
-  for (ObjectFile<E> *file : ctx.objs) {
-    if (file->is_alive)
-      file->resolve_regular_symbols(ctx);
-    else
-      file->resolve_lazy_symbols(ctx);
-  }
-
-  std::vector<ObjectFile<E> *> live_objs;
-  for (ObjectFile<E> *file : ctx.objs)
-    if (file->is_alive)
-      live_objs.push_back(file);
-
-  for (i64 i = 0; i < live_objs.size(); i++)
-    append(live_objs, live_objs[i]->mark_live_objects(ctx));
-
-  for (DylibFile<E> *dylib : ctx.dylibs)
-    dylib->resolve_symbols(ctx);
-
-  if (ctx.output_type == MH_EXECUTE && !get_symbol(ctx, ctx.arg.entry)->file)
-    Error(ctx) << "undefined entry point symbol: " << ctx.arg.entry;
-
-  create_internal_file(ctx);
-
-  std::erase_if(ctx.objs, [](ObjectFile<E> *file) { return !file->is_alive; });
-  std::erase_if(ctx.dylibs, [](DylibFile<E> *file) { return !file->is_alive; });
-
-  if (ctx.arg.trace) {
-    for (ObjectFile<E> *file : ctx.objs)
-      SyncOut(ctx) << *file;
-    for (DylibFile<E> *file : ctx.dylibs)
-      SyncOut(ctx) << *file;
-  }
-
-  for (ObjectFile<E> *file : ctx.objs)
-    file->convert_common_symbols(ctx);
-
-  if (ctx.arg.dead_strip)
-    dead_strip(ctx);
-
-  create_synthetic_chunks(ctx);
-
-  for (ObjectFile<E> *file : ctx.objs)
-    file->check_duplicate_symbols(ctx);
-
-  for (i64 i = 0; i < ctx.segments.size(); i++)
-    ctx.segments[i]->seg_idx = i + 1;
-
-  for (ObjectFile<E> *file : ctx.objs)
-    for (std::unique_ptr<Subsection<E> > &subsec : file->subsections)
-      subsec->scan_relocations(ctx);
-
-  scan_unwind_info(ctx);
-
-  if (ctx.arg.dead_strip_dylibs)
-    std::erase_if(ctx.dylibs, [](DylibFile<E> *file) { return !file->is_needed; });
-
-  export_symbols(ctx);
-  i64 output_size = assign_offsets(ctx);
-  fix_synthetic_symbol_values(ctx);
-
-  ctx.output_file = OutputFile<E>::open(ctx, ctx.arg.output, output_size, 0777);
-  ctx.buf = ctx.output_file->buf;
-
-  for (std::unique_ptr<OutputSegment<E>> &seg : ctx.segments)
-    seg->copy_buf(ctx);
-  ctx.code_sig.write_signature(ctx);
-
-  ctx.output_file->close(ctx);
-  ctx.checkpoint();
-
-  if (!ctx.arg.map.empty())
-    print_map(ctx);
-  return 0;
-}
-
-int main(int argc, char **argv) {
-  if (!getenv("MOLD_SUPPRESS_MACHO_WARNING")) {
-    std::cerr <<
-R"(********************************************************************************
-mold for macOS is pre-alpha. Do not use unless you know what you are doing.
-Do not report bugs because it's too early to manage missing features as bugs.
-********************************************************************************
-)";
-  }
-
-  return do_main<ARM64>(argc, argv);
-}
-
-}

macho/mapfile.cc

@@ -1,80 +0,0 @@
-#include "mold.h"
-
-#include <iomanip>
-#include <fstream>
-
-namespace mold::macho {
-
-struct Sym {
-  u64 addr;
-  u32 size;
-  u32 fileidx;
-  std::string_view name;
-};
-
-template <typename E>
-void print_map(Context<E> &ctx) {
-  std::ofstream out(ctx.arg.map.c_str());
-  if (!out.is_open())
-    Fatal(ctx) << "cannot open " << ctx.arg.map << ": " << errno_string();
-
-  out << "# Path: " << ctx.arg.output << "\n"
-      << "# Arch: x86-64\n"
-      << "# Object files:\n";
-
-  std::vector<Sym> syms;
-
-  for (i64 i = 0; i < ctx.objs.size(); i++){
-    ObjectFile<E> &file = *ctx.objs[i];
-
-    if (file.is_alive) {
-      out << "[" << std::setw(3) << i << "] " << file << "\n";
-      for (Symbol<E> *sym : file.syms)
-        if (sym->file == &file)
-          syms.push_back({sym->get_addr(ctx), 0, (u32)i, sym->name});
-    }
-  }
-
-  sort(syms, [](const Sym &a, const Sym &b) {
-    return a.addr < b.addr;
-  });
-
-  out << "# Sections:\n"
-      << "# Address       Size            Segment Section\n";
-
-  for (std::unique_ptr<OutputSegment<E>> &seg : ctx.segments) {
-    for (Chunk<E> *chunk : seg->chunks) {
-      if (!chunk->is_hidden) {
-        out << "0x" << std::hex
-            << std::setw(8) << std::setfill('0') << chunk->hdr.addr
-            << "     0x"
-            << std::setw(8) << std::setfill('0') << chunk->hdr.size
-            << "      " << std::setw(7) << std::left << std::setfill(' ')
-            << chunk->hdr.get_segname()
-            << " " << chunk->hdr.get_sectname() << "\n";
-      }
-    }
-  }
-
-  out << "# Symbols:\n"
-      << "# Address       Size            File  Name\n";
-
-  for (Sym &sym : syms) {
-    out << "0x" << std::hex
-        << std::setw(8) << std::setfill('0') << sym.addr
-        << "     0x"
-        << std::setw(8) << std::setfill('0') << 0
-        << "      ["
-        << std::setw(3) << std::right << std::setfill(' ') << std::dec
-        << sym.fileidx
-        << "] " << sym.name << "\n";
-  }
-}
-
-#define INSTANTIATE(E)                          \
-  template void print_map(Context<E> &)
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/mold.h

@@ -1,920 +0,0 @@
-#pragma once
-
-#include "macho.h"
-#include "../mold.h"
-
-#include <map>
-#include <memory>
-#include <span>
-#include <tbb/concurrent_hash_map.h>
-#include <tbb/spin_mutex.h>
-#include <unordered_map>
-#include <variant>
-
-namespace mold::macho {
-
-static constexpr i64 COMMON_PAGE_SIZE = 0x4000;
-static constexpr i64 SHA256_SIZE = 32;
-
-template <typename E> class Chunk;
-template <typename E> class InputSection;
-template <typename E> class OutputSection;
-template <typename E> class Subsection;
-template <typename E> struct Context;
-template <typename E> struct Symbol;
-
-//
-// object-file.cc
-//
-
-template <typename E>
-struct Relocation {
-  u32 offset = 0;
-  u8 type = -1;
-  u8 p2size = 0;
-  bool is_pcrel = false;
-  i64 addend = 0;
-  Symbol<E> *sym = nullptr;
-  Subsection<E> *subsec = nullptr;
-};
-
-template <typename E>
-struct UnwindRecord {
-  UnwindRecord(u32 len, u32 enc) : code_len(len), encoding(enc) {}
-
-  inline u64 get_func_raddr(Context<E> &ctx) const;
-
-  Subsection<E> *subsec = nullptr;
-  u32 offset = 0;
-  u32 code_len;
-  u32 encoding;
-  Symbol<E> *personality = nullptr;
-  Subsection<E> *lsda = nullptr;
-  u32 lsda_offset = 0;
-  bool is_alive = false;
-};
-
-template <typename E>
-class InputFile {
-public:
-  virtual ~InputFile() = default;
-
-  MappedFile<Context<E>> *mf = nullptr;
-  std::vector<Symbol<E> *> syms;
-  i64 priority = 0;
-  std::atomic_bool is_alive = false;
-  std::string archive_name;
-
-  virtual bool is_dylib() const = 0;
-
-protected:
-  InputFile() = default;
-};
-
-template <typename E>
-class ObjectFile : public InputFile<E> {
-public:
-  ObjectFile() = default;
-
-  static ObjectFile *create(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                            std::string archive_name);
-  bool is_dylib() const override { return false; }
-  void parse(Context<E> &ctx);
-  Subsection<E> *find_subsection(Context<E> &ctx, u32 addr);
-  void parse_compact_unwind(Context<E> &ctx, MachSection &hdr);
-  void resolve_regular_symbols(Context<E> &ctx);
-  void resolve_lazy_symbols(Context<E> &ctx);
-  bool is_objc_object(Context<E> &ctx);
-  std::vector<ObjectFile *> mark_live_objects(Context<E> &ctx);
-  void convert_common_symbols(Context<E> &ctx);
-  void check_duplicate_symbols(Context<E> &ctx);
-
-  Relocation<E> read_reloc(Context<E> &ctx, const MachSection &hdr, MachRel r);
-
-  std::vector<std::unique_ptr<InputSection<E>>> sections;
-  std::vector<std::unique_ptr<Subsection<E>>> subsections;
-  std::vector<u32> sym_to_subsec;
-  std::span<MachSym> mach_syms;
-  std::vector<Symbol<E>> local_syms;
-  std::vector<UnwindRecord<E>> unwind_records;
-  std::span<DataInCodeEntry> data_in_code_entries;
-
-private:
-  void parse_sections(Context<E> &ctx);
-  void parse_symtab(Context<E> &ctx);
-  void split_subsections(Context<E> &ctx);
-  void parse_data_in_code(Context<E> &ctx);
-  LoadCommand *find_load_command(Context<E> &ctx, u32 type);
-  i64 find_subsection_idx(Context<E> &ctx, u32 addr);
-  void override_symbol(Context<E> &ctx, i64 symidx);
-  InputSection<E> *get_common_sec(Context<E> &ctx);
-
-  MachSection *unwind_sec = nullptr;
-  std::unique_ptr<MachSection> common_hdr;
-  InputSection<E> *common_sec = nullptr;
-};
-
-template <typename E>
-class DylibFile : public InputFile<E> {
-public:
-  static DylibFile *create(Context<E> &ctx, MappedFile<Context<E>> *mf);
-  void parse(Context<E> &ctx);
-  void resolve_symbols(Context<E> &ctx);
-
-  std::string_view install_name;
-  i64 dylib_idx = 0;
-  std::atomic_bool is_needed = false;
-
-  bool is_dylib() const override { return true; }
-
-private:
-  void parse_dylib(Context<E> &ctx);
-  void read_trie(Context<E> &ctx, u8 *start, i64 offset = 0,
-                 const std::string &prefix = "");
-
-  DylibFile() {
-    this->is_alive = true;
-  }
-};
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const InputFile<E> &file);
-
-//
-// input-sections.cc
-//
-
-template <typename E>
-class InputSection {
-public:
-  InputSection(Context<E> &ctx, ObjectFile<E> &file, const MachSection &hdr);
-  void parse_relocations(Context<E> &ctx);
-
-  ObjectFile<E> &file;
-  const MachSection &hdr;
-  OutputSection<E> &osec;
-  std::string_view contents;
-  std::vector<Symbol<E> *> syms;
-  std::vector<Relocation<E>> rels;
-};
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const InputSection<E> &sec);
-
-template <typename E>
-class Subsection {
-public:
-  inline u64 get_addr(Context<E> &ctx) const;
-
-  std::string_view get_contents() {
-    assert(isec.hdr.type != S_ZEROFILL);
-    return isec.contents.substr(input_offset, input_size);
-  }
-
-  std::span<UnwindRecord<E>> get_unwind_records() {
-    return std::span<UnwindRecord<E>>(isec.file.unwind_records)
-      .subspan(unwind_offset, nunwind);
-  }
-
-  std::span<Relocation<E>> get_rels() const {
-    return std::span<Relocation<E>>(isec.rels).subspan(rel_offset, nrels);
-  }
-
-  void scan_relocations(Context<E> &ctx);
-  void apply_reloc(Context<E> &ctx, u8 *buf);
-
-  InputSection<E> &isec;
-  u32 input_offset = 0;
-  u32 input_size = 0;
-  u32 input_addr = 0;
-  u32 rel_offset = 0;
-  u32 nrels = 0;
-  u32 unwind_offset = 0;
-  u32 nunwind = 0;
-  u32 raddr = -1;
-  u16 p2align = 0;
-  std::atomic_bool is_alive = false;
-};
-
-template <typename E>
-std::vector<Relocation<E>>
-read_relocations(Context<E> &ctx, ObjectFile<E> &file, const MachSection &hdr);
-
-//
-// Symbol
-//
-
-enum {
-  NEEDS_GOT        = 1 << 0,
-  NEEDS_STUB       = 1 << 1,
-  NEEDS_THREAD_PTR = 1 << 2,
-};
-
-template <typename E>
-struct Symbol {
-  Symbol() = default;
-  Symbol(std::string_view name) : name(name) {}
-  Symbol(const Symbol<E> &other) : name(other.name) {}
-
-  std::string_view name;
-  InputFile<E> *file = nullptr;
-  Subsection<E> *subsec = nullptr;
-  u64 value = 0;
-
-  i32 stub_idx = -1;
-  i32 got_idx = -1;
-  i32 tlv_idx = -1;
-
-  tbb::spin_mutex mu;
-
-  std::atomic_uint8_t flags = 0;
-
-  u8 is_extern : 1 = false;
-  u8 is_lazy : 1 = false;
-  u8 is_common : 1 = false;
-  u8 referenced_dynamically : 1 = false;
-
-  inline u64 get_addr(Context<E> &ctx) const;
-  inline u64 get_got_addr(Context<E> &ctx) const;
-  inline u64 get_tlv_addr(Context<E> &ctx) const;
-};
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const Symbol<E> &sym);
-
-//
-// output-chunks.cc
-//
-
-template <typename E>
-class OutputSegment {
-public:
-  static OutputSegment<E> *
-  get_instance(Context<E> &ctx, std::string_view name);
-
-  void set_offset(Context<E> &ctx, i64 fileoff, u64 vmaddr);
-  void copy_buf(Context<E> &ctx);
-
-  std::string_view name;
-  SegmentCommand cmd = {};
-  i32 seg_idx = -1;
-  std::vector<Chunk<E> *> chunks;
-
-private:
-  OutputSegment(std::string_view name);
-};
-
-template <typename E>
-class Chunk {
-public:
-  inline Chunk(Context<E> &ctx, std::string_view segname,
-               std::string_view sectname);
-
-  virtual ~Chunk() = default;
-  virtual void compute_size(Context<E> &ctx) {};
-  virtual void copy_buf(Context<E> &ctx) {}
-
-  MachSection hdr = {};
-  u32 sect_idx = 0;
-  bool is_hidden = false;
-  bool is_regular = false;
-};
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const Chunk<E> &chunk);
-
-template <typename E>
-class OutputMachHeader : public Chunk<E> {
-public:
-  OutputMachHeader(Context<E> &ctx)
-    : Chunk<E>(ctx, "__TEXT", "__mach_header") {
-    this->is_hidden = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-};
-
-template <typename E>
-class OutputSection : public Chunk<E> {
-public:
-  static OutputSection<E> *
-  get_instance(Context<E> &ctx, std::string_view segname,
-               std::string_view sectname);
-
-  OutputSection(Context<E> &ctx, std::string_view segname,
-                std::string_view sectname)
-    : Chunk<E>(ctx, segname, sectname) {
-    this->is_regular = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  void add_subsec(Subsection<E> *subsec) {
-    members.push_back(subsec);
-    this->hdr.p2align = std::max<u32>(this->hdr.p2align, subsec->p2align);
-    this->hdr.attr |= subsec->isec.hdr.attr;
-    this->hdr.type = subsec->isec.hdr.type;
-  }
-
-  std::vector<Subsection<E> *> members;
-};
-
-class RebaseEncoder {
-public:
-  RebaseEncoder();
-  void add(i64 seg_idx, i64 offset);
-  void flush();
-  void finish();
-
-  std::vector<u8> buf;
-
-private:
-  i64 cur_seg = -1;
-  i64 cur_off = 0;
-  i64 times = 0;
-};
-
-template <typename E>
-class OutputRebaseSection : public Chunk<E> {
-public:
-  OutputRebaseSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__rebase") {
-    this->is_hidden = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<u8> contents;
-};
-
-class BindEncoder {
-public:
-  BindEncoder();
-  void add(i64 dylib_idx, std::string_view sym, i64 flags, i64 seg_idx,
-           i64 offset);
-  void finish();
-
-  std::vector<u8> buf;
-
-private:
-  std::string_view last_sym;
-  i64 last_flags = -1;
-  i64 last_dylib = -1;
-  i64 last_seg = -1;
-  i64 last_off = -1;
-};
-
-template <typename E>
-class OutputBindSection : public Chunk<E> {
-public:
-  OutputBindSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__binding") {
-    this->is_hidden = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<u8> contents;
-};
-
-template <typename E>
-class OutputLazyBindSection : public Chunk<E> {
-public:
-  OutputLazyBindSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__lazy_binding") {
-    this->is_hidden = true;
-    this->hdr.p2align = std::countr_zero(8U);
-  }
-
-  void add(Context<E> &ctx, Symbol<E> &sym, i64 flags);
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<u8> contents;
-};
-
-class ExportEncoder {
-public:
-  void add(std::string_view name, u32 flags, u64 addr);
-  i64 finish();
-
-  void write_trie(u8 *buf) {
-    write_trie(buf, root);
-  }
-
-private:
-  struct Entry {
-    std::string_view name;
-    u32 flags;
-    u64 addr;
-  };
-
-  struct TrieNode {
-    std::string_view prefix;
-    bool is_leaf = false;
-    u32 flags = 0;
-    u64 addr = 0;
-    u32 offset = -1;
-    std::vector<TrieNode> children;
-  };
-
-  static i64 common_prefix_len(std::span<Entry> entries, i64 len);
-  static TrieNode construct_trie(std::span<Entry> entries, i64 len);
-  static i64 set_offset(TrieNode &node, i64 offset);
-  void write_trie(u8 *buf, TrieNode &node);
-
-  TrieNode root;
-  std::vector<Entry> entries;
-};
-
-template <typename E>
-class OutputExportSection : public Chunk<E> {
-public:
-  OutputExportSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__export") {
-    this->is_hidden = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-private:
-  ExportEncoder enc;
-};
-
-template <typename E>
-class OutputFunctionStartsSection : public Chunk<E> {
-public:
-  OutputFunctionStartsSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__func_starts") {
-    this->is_hidden = true;
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<u8> contents;
-};
-
-template <typename E>
-class OutputSymtabSection : public Chunk<E> {
-public:
-  OutputSymtabSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__symbol_table") {
-    this->is_hidden = true;
-    this->hdr.p2align = std::countr_zero(8U);
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  struct Entry {
-    Symbol<E> *sym;
-    i64 stroff;
-  };
-
-  std::vector<Entry> locals;
-  std::vector<Entry> globals;
-  std::vector<Entry> undefs;
-};
-
-template <typename E>
-class OutputStrtabSection : public Chunk<E> {
-public:
-  OutputStrtabSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__string_table") {
-    this->is_hidden = true;
-    this->hdr.p2align = std::countr_zero(8U);
-  }
-
-  i64 add_string(std::string_view str);
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::string contents{1, '\0'};
-};
-
-template <typename E>
-class OutputIndirectSymtabSection : public Chunk<E> {
-public:
-  OutputIndirectSymtabSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__ind_sym_tab") {
-    this->is_hidden = true;
-  }
-
-  static constexpr i64 ENTRY_SIZE = 4;
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  struct Entry {
-    Symbol<E> *sym;
-    i64 symtab_idx;
-  };
-
-  std::vector<Entry> stubs;
-  std::vector<Entry> gots;
-};
-
-template <typename E>
-class CodeSignatureSection : public Chunk<E> {
-public:
-  CodeSignatureSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__code_signature") {
-    this->is_hidden = true;
-    this->hdr.p2align = std::countr_zero(16U);
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void write_signature(Context<E> &ctx);
-
-  static constexpr i64 BLOCK_SIZE = 4096;
-};
-
-template <typename E>
-class DataInCodeSection : public Chunk<E> {
-public:
-  DataInCodeSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__LINKEDIT", "__data_in_code") {
-    this->is_hidden = true;
-    this->hdr.p2align = std::countr_zero(alignof(DataInCodeEntry));
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<DataInCodeEntry> contents;
-};
-
-template <typename E>
-class StubsSection : public Chunk<E> {
-public:
-  StubsSection(Context<E> &ctx) : Chunk<E>(ctx, "__TEXT", "__stubs") {
-    this->hdr.p2align = std::countr_zero(2U);
-    this->hdr.type = S_SYMBOL_STUBS;
-    this->hdr.attr = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
-    this->hdr.reserved2 = E::stub_size;
-  }
-
-  void add(Context<E> &ctx, Symbol<E> *sym);
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<Symbol<E> *> syms;
-  std::vector<u32> bind_offsets;
-};
-
-template <typename E>
-class StubHelperSection : public Chunk<E> {
-public:
-  StubHelperSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__TEXT", "__stub_helper") {
-    this->hdr.p2align = std::countr_zero(4U);
-    this->hdr.attr = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
-  }
-
-  void copy_buf(Context<E> &ctx) override;
-};
-
-template <typename E>
-class UnwindEncoder {
-public:
-  std::vector<u8> encode(Context<E> &ctx, std::span<UnwindRecord<E>> records);
-
-private:
-  u32 encode_personality(Context<E> &ctx, Symbol<E> *sym);
-
-  std::vector<std::span<UnwindRecord<E>>>
-  split_records(Context<E> &ctx, std::span<UnwindRecord<E>>);
-
-  std::vector<Symbol<E> *> personalities;
-};
-
-template <typename E>
-class UnwindInfoSection : public Chunk<E> {
-public:
-  UnwindInfoSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__TEXT", "__unwind_info") {
-    this->hdr.p2align = std::countr_zero(4U);
-  }
-
-  void compute_size(Context<E> &ctx) override;
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<u8> contents;
-};
-
-template <typename E>
-class GotSection : public Chunk<E> {
-public:
-  GotSection(Context<E> &ctx) : Chunk<E>(ctx, "__DATA_CONST", "__got") {
-    this->hdr.p2align = std::countr_zero(8U);
-    this->hdr.type = S_NON_LAZY_SYMBOL_POINTERS;
-  }
-
-  void add(Context<E> &ctx, Symbol<E> *sym);
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<Symbol<E> *> syms;
-};
-
-template <typename E>
-class LazySymbolPtrSection : public Chunk<E> {
-public:
-  LazySymbolPtrSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__DATA", "__la_symbol_ptr") {
-    this->hdr.p2align = std::countr_zero(8U);
-    this->hdr.type = S_LAZY_SYMBOL_POINTERS;
-  }
-
-  void copy_buf(Context<E> &ctx) override;
-};
-
-template <typename E>
-class ThreadPtrsSection : public Chunk<E> {
-public:
-  ThreadPtrsSection(Context<E> &ctx)
-    : Chunk<E>(ctx, "__DATA", "__thread_ptrs") {
-    this->hdr.p2align = std::countr_zero(8U);
-    this->hdr.type = S_THREAD_LOCAL_VARIABLE_POINTERS;
-  }
-
-  void add(Context<E> &ctx, Symbol<E> *sym);
-  void copy_buf(Context<E> &ctx) override;
-
-  std::vector<Symbol<E> *> syms;
-};
-
-//
-// mapfile.cc
-//
-
-template <typename E>
-void print_map(Context<E> &ctx);
-
-//
-// dumper.cc
-//
-
-void dump_file(std::string path);
-
-//
-// output-file.cc
-//
-
-template <typename E>
-class OutputFile {
-public:
-  static std::unique_ptr<OutputFile>
-  open(Context<E> &ctx, std::string path, i64 filesize, i64 perm);
-
-  virtual void close(Context<E> &ctx) = 0;
-  virtual ~OutputFile() {}
-
-  u8 *buf = nullptr;
-  std::string path;
-  i64 filesize;
-  bool is_mmapped;
-  bool is_unmapped = false;
-
-protected:
-  OutputFile(std::string path, i64 filesize, bool is_mmapped)
-    : path(path), filesize(filesize), is_mmapped(is_mmapped) {}
-};
-
-//
-// yaml.cc
-//
-
-struct YamlNode {
-  std::variant<std::string_view,
-               std::vector<YamlNode>,
-               std::map<std::string_view, YamlNode>> data;
-};
-
-struct YamlError {
-  std::string msg;
-  i64 pos;
-};
-
-std::variant<std::vector<YamlNode>, YamlError>
-parse_yaml(std::string_view str);
-
-//
-// tapi.cc
-//
-
-struct TextDylib {
-  std::string_view uuid;
-  std::string_view install_name;
-  std::string_view current_version = "1.0";
-  std::string_view parent_umbrella;
-  std::vector<std::string_view> reexported_libs;
-  std::vector<std::string_view> exports;
-};
-
-template <typename E>
-TextDylib parse_tbd(Context<E> &ctx, MappedFile<Context<E>> *mf);
-
-//
-// cmdline.cc
-//
-
-template <typename E>
-void parse_nonpositional_args(Context<E> &ctx,
-                              std::vector<std::string> &remaining);
-
-//
-// dead-strip.cc
-//
-
-template <typename E>
-void dead_strip(Context<E> &ctx);
-
-//
-// main.cc
-//
-
-template <typename E>
-struct Context {
-  Context() {
-    text_seg = OutputSegment<E>::get_instance(*this, "__TEXT");
-    data_const_seg = OutputSegment<E>::get_instance(*this, "__DATA_CONST");
-    data_seg = OutputSegment<E>::get_instance(*this, "__DATA");
-    linkedit_seg = OutputSegment<E>::get_instance(*this, "__LINKEDIT");
-
-    text = OutputSection<E>::get_instance(*this, "__TEXT", "__text");
-    data = OutputSection<E>::get_instance(*this, "__DATA", "__data");
-    bss = OutputSection<E>::get_instance(*this, "__DATA", "__bss");
-    cstring = OutputSection<E>::get_instance(*this, "__TEXT", "__cstring");
-    common = OutputSection<E>::get_instance(*this, "__DATA", "__common");
-
-    bss->hdr.type = S_ZEROFILL;
-    cstring->hdr.type = S_CSTRING_LITERALS;
-    common->hdr.type = S_ZEROFILL;
-  }
-
-  Context(const Context<E> &) = delete;
-
-  void checkpoint() {
-    if (has_error) {
-      cleanup();
-      _exit(1);
-    }
-  }
-
-  // Command-line arguments
-  struct {
-    bool ObjC = false;
-    bool adhoc_codesign = true;
-    bool color_diagnostics = false;
-    bool dead_strip = true;
-    bool dead_strip_dylibs = false;
-    bool deduplicate = true;
-    bool demangle = false;
-    bool dylib = false;
-    bool dynamic = true;
-    bool fatal_warnings = false;
-    bool noinhibit_exec = false;
-    bool trace = false;
-    i64 arch = CPU_TYPE_ARM64;
-    i64 headerpad = 256;
-    i64 pagezero_size = 0;
-    i64 platform = PLATFORM_MACOS;
-    i64 platform_min_version = 0;
-    i64 platform_sdk_version = 0;
-    std::string chroot;
-    std::string entry = "_main";
-    std::string map;
-    std::string output = "a.out";
-    std::vector<std::string> framework_paths;
-    std::vector<std::string> library_paths;
-    std::vector<std::string> rpath;
-    std::vector<std::string> syslibroot;
-  } arg;
-
-  std::vector<std::string_view> cmdline_args;
-  u32 output_type = MH_EXECUTE;
-
-  bool has_error = false;
-
-  tbb::concurrent_hash_map<std::string_view, Symbol<E>> symbol_map;
-
-  std::unique_ptr<OutputFile<E>> output_file;
-  u8 *buf;
-
-  tbb::concurrent_vector<std::unique_ptr<ObjectFile<E>>> obj_pool;
-  tbb::concurrent_vector<std::unique_ptr<DylibFile<E>>> dylib_pool;
-  tbb::concurrent_vector<std::unique_ptr<u8[]>> string_pool;
-  tbb::concurrent_vector<std::unique_ptr<MappedFile<Context<E>>>> mf_pool;
-  std::vector<std::unique_ptr<OutputSection<E>>> osec_pool;
-
-  tbb::concurrent_vector<std::unique_ptr<TimerRecord>> timer_records;
-
-  std::vector<ObjectFile<E> *> objs;
-  std::vector<DylibFile<E> *> dylibs;
-
-  OutputSegment<E> *text_seg = nullptr;
-  OutputSegment<E> *data_const_seg = nullptr;
-  OutputSegment<E> *data_seg = nullptr;
-  OutputSegment<E> *linkedit_seg = nullptr;
-
-  std::vector<std::unique_ptr<OutputSegment<E>>> segments;
-  std::vector<Chunk<E> *> chunks;
-
-  OutputMachHeader<E> mach_hdr{*this};
-  StubsSection<E> stubs{*this};
-  StubHelperSection<E> stub_helper{*this};
-  UnwindInfoSection<E> unwind_info{*this};
-  GotSection<E> got{*this};
-  LazySymbolPtrSection<E> lazy_symbol_ptr{*this};
-  CodeSignatureSection<E> code_sig{*this};
-  DataInCodeSection<E> data_in_code{*this};
-  ThreadPtrsSection<E> thread_ptrs{*this};
-
-  OutputRebaseSection<E> rebase{*this};
-  OutputBindSection<E> bind{*this};
-  OutputLazyBindSection<E> lazy_bind{*this};
-  OutputExportSection<E> export_{*this};
-  OutputFunctionStartsSection<E> function_starts{*this};
-  OutputSymtabSection<E> symtab{*this};
-  OutputIndirectSymtabSection<E> indir_symtab{*this};
-  OutputStrtabSection<E> strtab{*this};
-
-  OutputSection<E> *text = nullptr;
-  OutputSection<E> *data = nullptr;
-  OutputSection<E> *bss = nullptr;
-  OutputSection<E> *cstring = nullptr;
-  OutputSection<E> *common = nullptr;
-};
-
-int main(int argc, char **argv);
-
-//
-// Inline functions
-//
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const InputSection<E> &sec) {
-  out << sec.file << "(" << sec.hdr.get_segname() << ","
-      << sec.hdr.get_sectname() << ")";
-  return out;
-}
-
-template <typename E>
-u64 Subsection<E>::get_addr(Context<E> &ctx) const {
-  return ctx.arg.pagezero_size + raddr;
-}
-
-template <typename E>
-u64 Symbol<E>::get_addr(Context<E> &ctx) const {
-  if (subsec)
-    return subsec->get_addr(ctx) + value;
-  if (stub_idx != -1)
-    return ctx.stubs.hdr.addr + stub_idx * E::stub_size;
-  return value;
-}
-
-template <typename E>
-u64 Symbol<E>::get_got_addr(Context<E> &ctx) const {
-  assert(got_idx != -1);
-  return ctx.got.hdr.addr + got_idx * E::word_size;
-}
-
-template <typename E>
-u64 Symbol<E>::get_tlv_addr(Context<E> &ctx) const {
-  assert(tlv_idx != -1);
-  return ctx.thread_ptrs.hdr.addr + tlv_idx * E::word_size;
-}
-
-template <typename E>
-inline Symbol<E> *get_symbol(Context<E> &ctx, std::string_view name) {
-  typename decltype(ctx.symbol_map)::const_accessor acc;
-  ctx.symbol_map.insert(acc, {name, Symbol<E>(name)});
-  return (Symbol<E> *)(&acc->second);
-}
-
-template <typename E>
-inline std::ostream &operator<<(std::ostream &out, const Symbol<E> &sym) {
-  out << sym.name;
-  return out;
-}
-
-template <typename E>
-Chunk<E>::Chunk(Context<E> &ctx, std::string_view segname,
-                std::string_view sectname) {
-  ctx.chunks.push_back(this);
-  hdr.set_segname(segname);
-  hdr.set_sectname(sectname);
-}
-
-template <typename E>
-u64 UnwindRecord<E>::get_func_raddr(Context<E> &ctx) const {
-  return subsec->raddr + offset;
-}
-
-} // namespace mold::macho

macho/object-file.cc

@@ -1,622 +0,0 @@
-#include "mold.h"
-
-#include "../archive-file.h"
-
-namespace mold::macho {
-
-template <typename E>
-std::ostream &operator<<(std::ostream &out, const InputFile<E> &file) {
-  if (file.archive_name.empty())
-    out << path_clean(file.mf->name);
-  else
-    out << path_clean(file.archive_name) << "(" << path_clean(file.mf->name) + ")";
-  return out;
-}
-
-template <typename E>
-ObjectFile<E> *
-ObjectFile<E>::create(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                      std::string archive_name) {
-  ObjectFile<E> *obj = new ObjectFile<E>;
-  obj->mf = mf;
-  obj->archive_name = archive_name;
-  obj->is_alive = archive_name.empty();
-  ctx.obj_pool.emplace_back(obj);
-  return obj;
-};
-
-template <typename E>
-void ObjectFile<E>::parse(Context<E> &ctx) {
-  parse_sections(ctx);
-  parse_symtab(ctx);
-  split_subsections(ctx);
-  parse_data_in_code(ctx);
-
-  for (std::unique_ptr<InputSection<E>> &isec : sections)
-    if (isec)
-      isec->parse_relocations(ctx);
-
-  if (unwind_sec)
-    parse_compact_unwind(ctx, *unwind_sec);
-}
-
-template <typename E>
-void ObjectFile<E>::parse_sections(Context<E> &ctx) {
-  MachHeader &hdr = *(MachHeader *)this->mf->data;
-  u8 *p = this->mf->data + sizeof(hdr);
-
-  // Read all but a symtab section
-  for (i64 i = 0; i < hdr.ncmds; i++) {
-    LoadCommand &lc = *(LoadCommand *)p;
-    p += lc.cmdsize;
-    if (lc.cmd != LC_SEGMENT_64)
-      continue;
-
-    SegmentCommand &cmd = *(SegmentCommand *)&lc;
-    MachSection *mach_sec = (MachSection *)((u8 *)&lc + sizeof(cmd));
-
-    for (MachSection &msec : std::span(mach_sec, mach_sec + cmd.nsects)) {
-      sections.push_back(nullptr);
-
-      if (msec.match("__LD", "__compact_unwind")) {
-        unwind_sec = &msec;
-        continue;
-      }
-
-      if (msec.attr & S_ATTR_DEBUG)
-        continue;
-
-      sections.back().reset(new InputSection<E>(ctx, *this, msec));
-    }
-  }
-}
-
-template <typename E>
-void ObjectFile<E>::parse_symtab(Context<E> &ctx) {
-  SymtabCommand *cmd = (SymtabCommand *)find_load_command(ctx, LC_SYMTAB);
-  if (!cmd)
-    return;
-
-  mach_syms = {(MachSym *)(this->mf->data + cmd->symoff), cmd->nsyms};
-  this->syms.reserve(mach_syms.size());
-
-  i64 nlocal = 0;
-  for (MachSym &msym : mach_syms)
-    if (!msym.ext)
-      nlocal++;
-  local_syms.reserve(nlocal);
-
-  for (MachSym &msym : mach_syms) {
-    std::string_view name = (char *)(this->mf->data + cmd->stroff + msym.stroff);
-
-    if (msym.ext) {
-      this->syms.push_back(get_symbol(ctx, name));
-    } else {
-      local_syms.emplace_back(name);
-      this->syms.push_back(&local_syms.back());
-    }
-  }
-}
-
-struct SplitRegion {
-  u32 offset;
-  u32 size;
-  u32 symidx;
-  bool is_alt_entry;
-};
-
-template <typename E>
-struct SplitInfo {
-  SplitInfo(InputSection<E> *isec) : isec(isec) {}
-  InputSection<E> *isec;
-  std::vector<SplitRegion> regions;
-};
-
-template <typename E>
-static std::vector<SplitInfo<E>> split(Context<E> &ctx, ObjectFile<E> &file) {
-  std::vector<SplitInfo<E>> vec;
-
-  for (std::unique_ptr<InputSection<E>> &isec : file.sections)
-    vec.push_back({isec.get()});
-
-  for (i64 i = 0; i < file.mach_syms.size(); i++) {
-    MachSym &msym = file.mach_syms[i];
-    if (msym.type == N_SECT && file.sections[msym.sect - 1]) {
-      SplitRegion r;
-      r.offset = msym.value - file.sections[msym.sect - 1]->hdr.addr;
-      r.symidx = i;
-      r.is_alt_entry = (msym.desc & N_ALT_ENTRY);
-      vec[msym.sect - 1].regions.push_back(r);
-    }
-  }
-
-  std::erase_if(vec, [](const SplitInfo<E> &info) { return !info.isec; });
-
-  sort(vec, [](const SplitInfo<E> &a, const SplitInfo<E> &b) {
-    return a.isec->hdr.addr < b.isec->hdr.addr;
-  });
-
-  for (SplitInfo<E> &info : vec) {
-    std::vector<SplitRegion> &r = info.regions;
-
-    if (r.empty()) {
-      r.push_back({0, (u32)info.isec->hdr.size, (u32)-1, false});
-      continue;
-    }
-
-    sort(r, [](const SplitRegion &a, const SplitRegion &b) {
-      return a.offset < b.offset;
-    });
-
-    if (r[0].offset > 0)
-      r.insert(r.begin(), {0, r[0].offset, (u32)-1, false});
-
-    for (i64 i = 1; i < r.size(); i++)
-      if (r[i - 1].offset == r[i].offset)
-        r[i++].is_alt_entry = true;
-
-    i64 last = -1;
-    for (i64 i = 0; i < r.size(); i++) {
-      if (!r[i].is_alt_entry) {
-        if (last != -1)
-          r[last].size = r[i].offset - r[last].offset;
-        last = i;
-      }
-    }
-
-    if (last != -1)
-      r[last].size = info.isec->hdr.size - r[last].offset;
-  }
-  return vec;
-}
-
-template <typename E>
-void ObjectFile<E>::split_subsections(Context<E> &ctx) {
-  sym_to_subsec.resize(mach_syms.size());
-
-  for (SplitInfo<E> &info : split(ctx, *this)) {
-    InputSection<E> &isec = *info.isec;
-
-    for (SplitRegion &r : info.regions) {
-      if (!r.is_alt_entry) {
-        Subsection<E> *subsec = new Subsection<E>{
-          .isec = isec,
-          .input_offset = r.offset,
-          .input_size = r.size,
-          .input_addr = (u32)(isec.hdr.addr + r.offset),
-          .p2align = (u8)isec.hdr.p2align,
-        };
-        subsections.emplace_back(subsec);
-      }
-
-      if (r.symidx != -1)
-        sym_to_subsec[r.symidx] = subsections.size() - 1;
-    }
-  }
-
-  for (i64 i = 0; i < mach_syms.size(); i++)
-    if (!mach_syms[i].ext)
-      override_symbol(ctx, i);
-}
-
-template <typename E>
-void ObjectFile<E>::parse_data_in_code(Context<E> &ctx) {
-  if (auto *cmd = (LinkEditDataCommand *)find_load_command(ctx, LC_DATA_IN_CODE))
-    data_in_code_entries = {
-      (DataInCodeEntry *)(this->mf->data + cmd->dataoff),
-      cmd->datasize / sizeof(DataInCodeEntry)
-    };
-}
-
-template <typename E>
-LoadCommand *ObjectFile<E>::find_load_command(Context<E> &ctx, u32 type) {
-  MachHeader &hdr = *(MachHeader *)this->mf->data;
-  u8 *p = this->mf->data + sizeof(hdr);
-
-  for (i64 i = 0; i < hdr.ncmds; i++) {
-    LoadCommand &lc = *(LoadCommand *)p;
-    if (lc.cmd == type)
-      return &lc;
-    p += lc.cmdsize;
-  }
-  return nullptr;
-}
-
-template <typename E>
-i64 ObjectFile<E>::find_subsection_idx(Context<E> &ctx, u32 addr) {
-  auto it = std::upper_bound(
-      subsections.begin(), subsections.end(), addr,
-      [&](u32 addr, const std::unique_ptr<Subsection<E>> &subsec) {
-    return addr < subsec->input_addr;
-  });
-
-  if (it == subsections.begin())
-    return -1;
-  return it - subsections.begin() - 1;
-}
-
-template <typename E>
-Subsection<E> *ObjectFile<E>::find_subsection(Context<E> &ctx, u32 addr) {
-  i64 i = find_subsection_idx(ctx, addr);
-  return (i == -1) ? nullptr : subsections[i].get();
-}
-
-template <typename E>
-void ObjectFile<E>::parse_compact_unwind(Context<E> &ctx, MachSection &hdr) {
-  if (hdr.size % sizeof(CompactUnwindEntry))
-    Fatal(ctx) << *this << ": invalid __compact_unwind section size";
-
-  i64 num_entries = hdr.size / sizeof(CompactUnwindEntry);
-  unwind_records.reserve(num_entries);
-
-  CompactUnwindEntry *src = (CompactUnwindEntry *)(this->mf->data + hdr.offset);
-
-  // Read compact unwind entries
-  for (i64 i = 0; i < num_entries; i++)
-    unwind_records.emplace_back(src[i].code_len, src[i].encoding);
-
-  // Read relocations
-  MachRel *mach_rels = (MachRel *)(this->mf->data + hdr.reloff);
-  for (i64 i = 0; i < hdr.nreloc; i++) {
-    MachRel &r = mach_rels[i];
-    if (r.offset >= hdr.size)
-      Fatal(ctx) << *this << ": relocation offset too large: " << i;
-
-    i64 idx = r.offset / sizeof(CompactUnwindEntry);
-    UnwindRecord<E> &dst = unwind_records[idx];
-
-    auto error = [&] {
-      Fatal(ctx) << *this << ": __compact_unwind: unsupported relocation: " << i;
-    };
-
-    switch (r.offset % sizeof(CompactUnwindEntry)) {
-    case offsetof(CompactUnwindEntry, code_start): {
-      if (r.is_pcrel || r.p2size != 3 || r.is_extern || r.type)
-        error();
-
-      Subsection<E> *target = find_subsection(ctx, src[idx].code_start);
-      if (!target)
-        error();
-      dst.subsec = target;
-      dst.offset = src[idx].code_start - target->input_addr;
-      break;
-    }
-    case offsetof(CompactUnwindEntry, personality):
-      if (r.is_pcrel || r.p2size != 3 || !r.is_extern || r.type)
-        error();
-      dst.personality = this->syms[r.idx];
-      break;
-    case offsetof(CompactUnwindEntry, lsda): {
-      if (r.is_pcrel || r.p2size != 3 || r.is_extern || r.type)
-        error();
-
-      i32 addr = *(i32 *)((u8 *)this->mf->data + hdr.offset + r.offset);
-      Subsection<E> *target = find_subsection(ctx, addr);
-      if (!target)
-        error();
-      dst.lsda = target;
-      dst.lsda_offset = addr - target->input_addr;
-      break;
-    }
-    default:
-      Fatal(ctx) << *this << ": __compact_unwind: unsupported relocation: " << i;
-    }
-  }
-
-  for (i64 i = 0; i < num_entries; i++)
-    if (!unwind_records[i].subsec)
-      Fatal(ctx) << ": __compact_unwind: missing relocation at " << i;
-
-  // Sort unwind entries by offset
-  sort(unwind_records, [](const UnwindRecord<E> &a, const UnwindRecord<E> &b) {
-    return std::tuple(a.subsec->input_addr, a.offset) <
-           std::tuple(b.subsec->input_addr, b.offset);
-  });
-
-  // Associate unwind entries to subsections
-  for (i64 i = 0; i < num_entries;) {
-    Subsection<E> &subsec = *unwind_records[i].subsec;
-    subsec.unwind_offset = i;
-
-    i64 j = i + 1;
-    while (j < num_entries && unwind_records[j].subsec == &subsec)
-      j++;
-    subsec.nunwind = j - i;
-    i = j;
-  }
-}
-
-// Symbols with higher priorities overwrites symbols with lower priorities.
-// Here is the list of priorities, from the highest to the lowest.
-//
-//  1. Strong defined symbol
-//  2. Weak defined symbol
-//  3. Strong defined symbol in a DSO
-//  4. Weak defined symbol in a DSO
-//  5. Strong or weak defined symbol in an archive
-//  6. Common symbol
-//  7. Unclaimed (nonexistent) symbol
-//
-// Ties are broken by file priority.
-template <typename E>
-static u64 get_rank(InputFile<E> *file, MachSym &msym, bool is_lazy) {
-  if (msym.is_common())
-    return (6 << 24) + file->priority;
-  if (is_lazy)
-    return (5 << 24) + file->priority;
-  if (file->is_dylib())
-    return (3 << 24) + file->priority;
-  return (1 << 24) + file->priority;
-}
-
-template <typename E>
-static u64 get_rank(Symbol<E> &sym) {
-  InputFile<E> *file = sym.file;
-  if (!file)
-    return 7 << 24;
-  if (sym.is_common)
-    return (6 << 24) + file->priority;
-  if (!file->archive_name.empty())
-    return (5 << 24) + file->priority;
-  if (file->is_dylib())
-    return (3 << 24) + file->priority;
-  return (1 << 24) + file->priority;
-}
-
-template <typename E>
-void ObjectFile<E>::override_symbol(Context<E> &ctx, i64 idx) {
-  Symbol<E> &sym = *this->syms[idx];
-  MachSym &msym = mach_syms[idx];
-
-  sym.file = this;
-  sym.is_extern = msym.ext;
-  sym.is_lazy = false;
-
-  switch (msym.type) {
-  case N_UNDF:
-    assert(msym.is_common());
-    sym.subsec = nullptr;
-    sym.value = msym.value;
-    sym.is_common = true;
-    break;
-  case N_ABS:
-    sym.subsec = nullptr;
-    sym.value = msym.value;
-    sym.is_common = false;
-    break;
-  case N_SECT:
-    sym.subsec = subsections[sym_to_subsec[idx]].get();
-    sym.value = msym.value - sym.subsec->input_addr;
-    sym.is_common = false;
-    break;
-  default:
-    Fatal(ctx) << sym << ": unknown symbol type: " << (u64)msym.type;
-  }
-}
-
-template <typename E>
-void ObjectFile<E>::resolve_regular_symbols(Context<E> &ctx) {
-  for (i64 i = 0; i < this->syms.size(); i++) {
-    MachSym &msym = mach_syms[i];
-    if (!msym.ext || msym.is_undef())
-      continue;
-
-    Symbol<E> &sym = *this->syms[i];
-    std::scoped_lock lock(sym.mu);
-    if (get_rank(this, msym, false) < get_rank(sym))
-      override_symbol(ctx, i);
-  }
-}
-
-template <typename E>
-void ObjectFile<E>::resolve_lazy_symbols(Context<E> &ctx) {
-  for (i64 i = 0; i < this->syms.size(); i++) {
-    MachSym &msym = mach_syms[i];
-    if (!msym.ext || msym.is_undef() || msym.is_common())
-      continue;
-
-    Symbol<E> &sym = *this->syms[i];
-    std::scoped_lock lock(sym.mu);
-
-    if (get_rank(this, msym, true) < get_rank(sym)) {
-      sym.file = this;
-      sym.subsec = nullptr;
-      sym.value = 0;
-      sym.is_extern = false;
-      sym.is_lazy = true;
-      sym.is_common = false;
-    }
-  }
-}
-
-template <typename E>
-bool ObjectFile<E>::is_objc_object(Context<E> &ctx) {
-  for (std::unique_ptr<InputSection<E>> &isec : sections)
-    if (isec->hdr.match("__DATA", "__objc_catlist") ||
-        isec->hdr.match("__TEXT", "__swift"))
-      return true;
-
-  for (i64 i = 0; i < this->syms.size(); i++)
-    if (!mach_syms[i].is_undef() && mach_syms[i].ext &&
-        this->syms[i]->name.starts_with("_OBJC_CLASS_$_"))
-      return true;
-  return false;
-}
-
-template <typename E>
-std::vector<ObjectFile<E> *> ObjectFile<E>::mark_live_objects(Context<E> &ctx) {
-  std::vector<ObjectFile<E> *> vec;
-  assert(this->is_alive);
-
-  for (i64 i = 0; i < this->syms.size(); i++) {
-    MachSym &msym = mach_syms[i];
-    if (!msym.ext)
-      continue;
-
-    Symbol<E> &sym = *this->syms[i];
-    std::scoped_lock lock(sym.mu);
-
-    if (msym.is_undef()) {
-      if (sym.file && !sym.file->is_alive.exchange(true))
-        vec.push_back((ObjectFile<E> *)sym.file);
-      continue;
-    }
-
-    if (get_rank(this, msym, false) < get_rank(sym))
-      override_symbol(ctx, i);
-  }
-  return vec;
-}
-
-template <typename E>
-void ObjectFile<E>::convert_common_symbols(Context<E> &ctx) {
-  for (i64 i = 0; i < this->syms.size(); i++) {
-    Symbol<E> &sym = *this->syms[i];
-    MachSym &msym = mach_syms[i];
-
-    if (sym.file == this && sym.is_common) {
-      InputSection<E> *isec = get_common_sec(ctx);
-      Subsection<E> *subsec = new Subsection<E>{
-        .isec = *isec,
-        .input_size = (u32)msym.value,
-        .p2align = (u8)msym.p2align,
-      };
-
-      subsections.emplace_back(subsec);
-
-      sym.subsec = subsec;
-      sym.value = 0;
-      sym.is_common = false;
-    }
-  }
-}
-
-template <typename E>
-void ObjectFile<E>::check_duplicate_symbols(Context<E> &ctx) {
-  for (i64 i = 0; i < this->syms.size(); i++) {
-    Symbol<E> *sym = this->syms[i];
-    MachSym &msym = mach_syms[i];
-    if (sym && !msym.is_undef() && !msym.is_common() && sym->file != this)
-      Error(ctx) << "duplicate symbol: " << *this << ": " << *sym->file
-                 << ": " << *sym;
-  }
-}
-
-template <typename E>
-InputSection<E> *ObjectFile<E>::get_common_sec(Context<E> &ctx) {
-  if (!common_sec) {
-    MachSection *hdr = new MachSection;
-    common_hdr.reset(hdr);
-
-    memset(hdr, 0, sizeof(*hdr));
-    hdr->set_segname("__DATA");
-    hdr->set_sectname("__common");
-    hdr->type = S_ZEROFILL;
-
-    common_sec = new InputSection<E>(ctx, *this, *hdr);
-    sections.emplace_back(common_sec);
-  }
-  return common_sec;
-}
-
-template <typename E>
-DylibFile<E> *DylibFile<E>::create(Context<E> &ctx, MappedFile<Context<E>> *mf) {
-  DylibFile<E> *dylib = new DylibFile<E>;
-  dylib->mf = mf;
-  ctx.dylib_pool.emplace_back(dylib);
-  return dylib;
-};
-
-template <typename E>
-void DylibFile<E>::read_trie(Context<E> &ctx, u8 *start, i64 offset,
-                             const std::string &prefix) {
-  u8 *buf = start + offset;
-
-  if (*buf) {
-    read_uleb(buf); // size
-    read_uleb(buf); // flags
-    read_uleb(buf); // addr
-    this->syms.push_back(get_symbol(ctx, prefix));
-  } else {
-    buf++;
-  }
-
-  i64 nchild = *buf++;
-
-  for (i64 i = 0; i < nchild; i++) {
-    std::string suffix((char *)buf);
-    buf += suffix.size() + 1;
-    i64 off = read_uleb(buf);
-    read_trie(ctx, start, off, prefix + suffix);
-  }
-}
-
-template <typename E>
-void DylibFile<E>::parse_dylib(Context<E> &ctx) {
-  MachHeader &hdr = *(MachHeader *)this->mf->data;
-  u8 *p = this->mf->data + sizeof(hdr);
-
-  for (i64 i = 0; i < hdr.ncmds; i++) {
-    LoadCommand &lc = *(LoadCommand *)p;
-
-    switch (lc.cmd) {
-    case LC_ID_DYLIB: {
-      DylibCommand &cmd = *(DylibCommand *)p;
-      install_name = (char *)p + cmd.nameoff;
-      break;
-    }
-    case LC_DYLD_INFO_ONLY: {
-      DyldInfoCommand &cmd = *(DyldInfoCommand *)p;
-      if (cmd.export_off)
-        read_trie(ctx, this->mf->data + cmd.export_off);
-      break;
-    }
-    case LC_DYLD_EXPORTS_TRIE: {
-      LinkEditDataCommand &cmd = *(LinkEditDataCommand *)p;
-      read_trie(ctx, this->mf->data + cmd.dataoff);
-      break;
-    }
-    }
-
-    p += lc.cmdsize;
-  }
-}
-
-template <typename E>
-void DylibFile<E>::parse(Context<E> &ctx) {
-  switch (get_file_type(this->mf)) {
-  case FileType::TAPI: {
-    TextDylib tbd = parse_tbd(ctx, this->mf);
-    for (std::string_view sym : tbd.exports)
-      this->syms.push_back(get_symbol(ctx, sym));
-    install_name = tbd.install_name;
-    break;
-  }
-  case FileType::MACH_DYLIB:
-    parse_dylib(ctx);
-    break;
-  default:
-    Fatal(ctx) << this->mf->name << ": is not a dylib";
-  }
-}
-
-template <typename E>
-void DylibFile<E>::resolve_symbols(Context<E> &ctx) {
-  for (Symbol<E> *sym : this->syms) {
-    std::scoped_lock lock(sym->mu);
-    if (sym->file && sym->file->priority < this->priority)
-      continue;
-    sym->file = this;
-    sym->is_extern = true;
-  }
-}
-
-#define INSTANTIATE(E)                                                  \
-  template class ObjectFile<E>;                                         \
-  template class DylibFile<E>;                                          \
-  template std::ostream &operator<<(std::ostream &, const InputFile<E> &)
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/output-file.cc

@@ -1,120 +0,0 @@
-// This file implements the same functionality as elf/output-file.cc.
-// We have two different implemetntations for ELF and Mach-O because
-// we implemented a special optimization for ELF or Linux.
-//
-// On Linux, it is faster to write to an existing file than creating a
-// new file and writing to it. So, we overwrite an existing executable
-// if exists.
-//
-// On macOS, it looks like the system does not assume that an executable
-// is mutated once it is created. Due to some code signing mechanism or
-// something, we always have to create a fresh file.
-
-#include "mold.h"
-
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace mold::macho {
-
-template <typename E>
-class MemoryMappedOutputFile : public OutputFile<E> {
-public:
-  MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(path, filesize, true) {
-    std::string tmp_path = filepath(path).parent_path() / ".mold-XXXXXX";
-    output_tmpfile = (char *)save_string(ctx, tmp_path).data();
-
-    i64 fd = mkstemp(output_tmpfile);
-    if (fd == -1)
-      Fatal(ctx) << "cannot open " << output_tmpfile <<  ": " << errno_string();
-
-    if (ftruncate(fd, filesize))
-      Fatal(ctx) << "ftruncate failed: " << errno_string();
-    if (fchmod(fd, perm) == -1)
-      Fatal(ctx) << "fchmod failed: " << errno_string();
-
-    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);
-  }
-
-  void close(Context<E> &ctx) override {
-    Timer t(ctx, "close_file");
-
-    munmap(this->buf, this->filesize);
-    if (rename(output_tmpfile, this->path.c_str()) == -1)
-      Fatal(ctx) << this->path << ": rename failed: " << errno_string();
-    output_tmpfile = nullptr;
-  }
-};
-
-template <typename E>
-class MallocOutputFile : public OutputFile<E> {
-public:
-  MallocOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(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(Context<E> &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 E>
-std::unique_ptr<OutputFile<E>>
-OutputFile<E>::open(Context<E> &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;
-  }
-
-  std::unique_ptr<OutputFile> file;
-  if (is_special)
-    file = std::make_unique<MallocOutputFile<E>>(ctx, path, filesize, perm);
-  else
-    file = std::make_unique<MemoryMappedOutputFile<E>>(ctx, path, filesize, perm);
-  return file;
-}
-
-#define INSTANTIATE(E)                          \
-  template class OutputFile<E>
-
-INSTANTIATE(ARM64);
-INSTANTIATE(X86_64);
-
-} // namespace mold::macho

macho/tapi.cc

@@ -1,127 +0,0 @@
-#include "mold.h"
-
-#include <optional>
-
-namespace mold::macho {
-
-static std::vector<YamlNode>
-get_vector(YamlNode &node, std::string_view key) {
-  if (auto *map = std::get_if<std::map<std::string_view, YamlNode>>(&node.data))
-    if (auto it = map->find(key); it != map->end())
-      if (auto *vec = std::get_if<std::vector<YamlNode>>(&it->second.data))
-        return *vec;
-  return {};
-}
-
-static std::optional<std::string_view>
-get_string(YamlNode &node, std::string_view key) {
-  if (auto *map = std::get_if<std::map<std::string_view, YamlNode>>(&node.data))
-    if (auto it = map->find(key); it != map->end())
-      if (auto *str = std::get_if<std::string_view>(&it->second.data))
-        return *str;
-  return {};
-}
-
-static bool contains(const std::vector<YamlNode> &vec, std::string_view key) {
-  for (const YamlNode &mem : vec)
-    if (const std::string_view *s = std::get_if<std::string_view>(&mem.data))
-      if (*s == key)
-        return true;
-  return false;
-}
-
-static std::optional<TextDylib> to_tbd(YamlNode &node, std::string_view arch) {
-  if (!contains(get_vector(node, "targets"), arch))
-    return {};
-
-  TextDylib tbd;
-
-  for (YamlNode &mem : get_vector(node, "uuids"))
-    if (auto target = get_string(mem, "target"))
-      if (*target == arch)
-        if (auto value = get_string(mem, "value"))
-          tbd.uuid = *value;
-
-  if (auto val = get_string(node, "install-name"))
-    tbd.install_name = *val;
-
-  if (auto val = get_string(node, "current-version"))
-    tbd.current_version = *val;
-
-  for (YamlNode &mem : get_vector(node, "parent-umbrella"))
-    if (contains(get_vector(mem, "targets"), arch))
-      if (auto val = get_string(mem, "umbrella"))
-        tbd.parent_umbrella = *val;
-
-  for (YamlNode &mem : get_vector(node, "reexported-libraries"))
-    if (contains(get_vector(mem, "targets"), arch))
-      for (YamlNode &mem : get_vector(mem, "libraries"))
-        if (auto *lib = std::get_if<std::string_view>(&mem.data))
-          tbd.reexported_libs.push_back(*lib);
-
-  for (std::string_view key : {"exports", "reexports"})
-    for (YamlNode &mem : get_vector(node, key))
-      if (contains(get_vector(mem, "targets"), arch))
-        for (YamlNode &mem : get_vector(mem, "symbols"))
-          if (auto *sym = std::get_if<std::string_view>(&mem.data))
-            tbd.exports.push_back(*sym);
-
-  return tbd;
-}
-
-template <typename E>
-static TextDylib squash(Context<E> &ctx, std::span<TextDylib> tbds) {
-  std::unordered_map<std::string_view, TextDylib> map;
-
-  TextDylib main = std::move(tbds[0]);
-  for (TextDylib &tbd : tbds.subspan(1))
-    map[tbd.install_name] = std::move(tbd);
-
-  std::vector<std::string_view> libs;
-
-  for (std::string_view lib : main.reexported_libs) {
-    auto it = map.find(lib);
-    if (it != map.end())
-      append(main.exports, it->second.exports);
-    else
-      libs.push_back(lib);
-  }
-
-  main.reexported_libs = std::move(libs);
-  return main;
-}
-
-template <typename E>
-static TextDylib parse(Context<E> &ctx, MappedFile<Context<E>> *mf,
-                       std::string_view arch) {
-  std::string_view contents = mf->get_contents();
-  std::variant<std::vector<YamlNode>, YamlError> res = parse_yaml(contents);
-
-  if (YamlError *err = std::get_if<YamlError>(&res)) {
-    i64 lineno = std::count(contents.begin(), contents.begin() + err->pos, '\n');
-    Fatal(ctx) << mf->name << ":" << (lineno + 1)
-               << ": YAML parse error: " << err->msg;
-  }
-
-  std::vector<YamlNode> &nodes = std::get<std::vector<YamlNode>>(res);
-  if (nodes.empty())
-    Fatal(ctx) << mf->name << ": malformed TBD file";
-
-  std::vector<TextDylib> vec;
-  for (YamlNode &node : nodes)
-    if (std::optional<TextDylib> dylib = to_tbd(node, arch))
-      vec.push_back(*dylib);
-  return squash(ctx, vec);
-}
-
-template <>
-TextDylib parse_tbd(Context<ARM64> &ctx, MappedFile<Context<ARM64>> *mf) {
-  return parse(ctx, mf, "arm64-macos");
-}
-
-template <>
-TextDylib parse_tbd(Context<X86_64> &ctx, MappedFile<Context<X86_64>> *mf) {
-  return parse(ctx, mf, "x86_64-macos");
-}
-
-} // namespace mold::macho

macho/yaml.cc

@@ -1,360 +0,0 @@
-#include "mold.h"
-
-#include <optional>
-
-namespace mold::macho {
-
-struct Token {
-  enum { STRING = 1, INDENT, DEDENT, END };
-
-  u8 kind = 0;
-  std::string_view str;
-};
-
-class YamlParser {
-public:
-  YamlParser(std::string_view input) : input(input) {}
-
-  std::variant<std::vector<YamlNode>, YamlError> parse();
-
-private:
-  std::optional<YamlError> tokenize();
-
-  void tokenize_bare_string(std::string_view &str);
-
-  std::optional<YamlError> tokenize_list(std::string_view &str);
-  std::optional<YamlError> tokenize_string(std::string_view &str, char end);
-
-  std::variant<YamlNode, YamlError> parse_element(std::span<Token> &tok);
-  std::variant<YamlNode, YamlError> parse_list(std::span<Token> &tok);
-  std::variant<YamlNode, YamlError> parse_map(std::span<Token> &tok);
-  std::variant<YamlNode, YamlError> parse_flow_element(std::span<Token> &tok);
-  std::variant<YamlNode, YamlError> parse_flow_list(std::span<Token> &tok);
-
-  std::string_view input;
-  std::vector<Token> tokens;
-};
-
-std::optional<YamlError> YamlParser::tokenize() {
-  std::vector<i64> indents = {0};
-
-  auto indent = [&](std::string_view str, i64 depth) {
-    tokens.push_back({Token::INDENT, str});
-    indents.push_back(depth);
-  };
-
-  auto dedent = [&](std::string_view str) {
-    assert(indents.size() > 1);
-    tokens.push_back({Token::DEDENT, str});
-    indents.pop_back();
-  };
-
-  auto skip_line = [](std::string_view &str) {
-    size_t pos = str.find('\n');
-    if (pos == str.npos)
-      str = str.substr(str.size());
-    else
-      str = str.substr(pos + 1);
-  };
-
-  auto tokenize_line = [&](std::string_view &str) -> std::optional<YamlError> {
-    const char *start = str.data();
-
-    if (str.starts_with("---")) {
-      while (indents.size() > 1)
-        dedent(str);
-      tokens.push_back({Token::END, str.substr(0, 3)});
-      skip_line(str);
-      return {};
-    }
-
-    if (str.starts_with("...")) {
-      while (indents.size() > 1)
-        dedent(str);
-      tokens.push_back({Token::END, str.substr(0, 3)});
-      str = str.substr(str.size());
-      return {};
-    }
-
-    size_t pos = str.find_first_not_of(" \t");
-    if (pos == str.npos || str[pos] == '#' || str[pos] == '\n') {
-      skip_line(str);
-      return {};
-    }
-
-    if (indents.back() != pos) {
-      if (indents.back() < pos) {
-        indent(str, pos);
-      } else {
-        while (indents.back() != pos) {
-          if (pos < indents.back())
-            dedent(str);
-          else
-            return YamlError{"bad indentation", start - input.data()};
-        }
-      }
-    }
-
-    str = str.substr(pos);
-
-    while (!str.empty()) {
-      if (str[0] == '\n') {
-        str = str.substr(1);
-        return {};
-      }
-
-      if (str.starts_with("- ")) {
-        tokens.push_back({'-', str.substr(0, 1)});
-
-        size_t pos = str.find_first_not_of(" \t", 1);
-        if (pos == str.npos || str[pos] == '\n') {
-          skip_line(str);
-          return {};
-        }
-
-        str = str.substr(pos);
-        indent(str, str.data() - start);
-        continue;
-      }
-
-      if (str.starts_with('['))
-        return tokenize_list(str);
-
-      if (str.starts_with('\'')) {
-        if (std::optional<YamlError> err = tokenize_string(str, '\''))
-          return err;
-        continue;
-      }
-
-      if (str.starts_with('"')) {
-        if (std::optional<YamlError> err = tokenize_string(str, '"'))
-          return err;
-        continue;
-      }
-
-      if (str.starts_with('#')) {
-        skip_line(str);
-        return {};
-      }
-
-      if (str.starts_with(':')) {
-        tokens.push_back({':', str.substr(0, 1)});
-
-        size_t pos = str.find_first_not_of(" \t", 1);
-        if (pos == str.npos || str[pos] == '\n') {
-          skip_line(str);
-          return {};
-        }
-
-        str = str.substr(pos);
-        continue;
-      }
-
-      tokenize_bare_string(str);
-    }
-    return {};
-  };
-
-  std::string_view str = input;
-  while (!str.empty())
-    if (std::optional<YamlError> err = tokenize_line(str))
-      return err;
-  return {};
-}
-
-std::optional<YamlError> YamlParser::tokenize_list(std::string_view &str) {
-  const char *start = str.data();
-
-  tokens.push_back({'[', str.substr(0, 1)});
-  str = str.substr(1);
-
-  while (!str.empty() && str[0] != ']') {
-    if (size_t pos = str.find_first_not_of(" \t\n"); pos) {
-      str = str.substr(pos);
-      continue;
-    }
-
-    if (str.starts_with('\'')) {
-      if (std::optional<YamlError> err = tokenize_string(str, '\''))
-        return err;
-      continue;
-    }
-
-    if (str.starts_with('"')) {
-      if (std::optional<YamlError> err = tokenize_string(str, '"'))
-        return err;
-      continue;
-    }
-
-    if (str.starts_with(',')) {
-      tokens.push_back({',', str.substr(0, 1)});
-      str = str.substr(1);
-      continue;
-    }
-
-    tokenize_bare_string(str);
-  }
-
-  if (str.empty())
-    return YamlError{"unclosed list", start - input.data()};
-
-  const char *bracket = str.data();
-  tokens.push_back({']', str.substr(0, 1)});
-  str = str.substr(1);
-
-  while (!str.empty() && (str[0] == ' ' || str[0] == '\t'))
-    str = str.substr(1);
-  if (str.empty() || str[0] != '\n')
-    return YamlError{"no newline after ']'", bracket - input.data()};
-  str = str.substr(1);
-  return {};
-}
-
-std::optional<YamlError>
-YamlParser::tokenize_string(std::string_view &str, char end) {
-  const char *start = str.data();
-  size_t pos = str.find(end, 1);
-  if (pos == str.npos)
-    return YamlError{"unterminated string literal", start - input.data()};
-
-  tokens.push_back({Token::STRING, str.substr(1, pos - 1)});
-  str = str.substr(pos + 1);
-  return {};
-}
-
-void
-YamlParser::tokenize_bare_string(std::string_view &str) {
-  size_t pos = str.find_first_not_of(
-    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-/.");
-  if (pos == str.npos)
-    pos = str.size();
-  tokens.push_back({Token::STRING, str.substr(0, pos)});
-  str = str.substr(pos);
-}
-
-std::variant<std::vector<YamlNode>, YamlError> YamlParser::parse() {
-  if (std::optional<YamlError> err = tokenize())
-    return *err;
-
-  std::span<Token> tok(tokens);
-  std::vector<YamlNode> vec;
-
-  while (!tok.empty()) {
-    if (tok[0].kind == Token::END) {
-      tok = tok.subspan(1);
-      continue;
-    }
-
-    std::variant<YamlNode, YamlError> elem = parse_element(tok);
-    if (YamlError *err = std::get_if<YamlError>(&elem))
-      return *err;
-    vec.push_back(std::get<YamlNode>(elem));
-
-    if (tok[0].kind != Token::END)
-      return YamlError{"stray token", tok[0].str.data() - input.data()};
-  }
-  return vec;
-}
-
-std::variant<YamlNode, YamlError>
-YamlParser::parse_element(std::span<Token> &tok) {
-  if (tok[0].kind == Token::INDENT) {
-    tok = tok.subspan(1);
-
-    std::variant<YamlNode, YamlError> elem = parse_element(tok);
-    assert(tok[0].kind == Token::DEDENT);
-    tok = tok.subspan(1);
-    return elem;
-  }
-
-  if (tok[0].kind == '-')
-    return parse_list(tok);
-
-  if (tok.size() > 2 && tok[0].kind == Token::STRING && tok[1].kind == ':')
-    return parse_map(tok);
-
-  return parse_flow_element(tok);
-}
-
-std::variant<YamlNode, YamlError>
-YamlParser::parse_list(std::span<Token> &tok) {
-  std::vector<YamlNode> vec;
-
-  while (tok[0].kind != Token::END && tok[0].kind != Token::DEDENT) {
-    if (tok[0].kind != '-')
-      return YamlError{"list element expected", tok[0].str.data() - input.data()};
-    tok = tok.subspan(1);
-
-    std::variant<YamlNode, YamlError> elem = parse_element(tok);
-    if (YamlError *err = std::get_if<YamlError>(&elem))
-      return *err;
-    vec.push_back(std::get<YamlNode>(elem));
-  }
-  return YamlNode{vec};
-}
-
-std::variant<YamlNode, YamlError>
-YamlParser::parse_map(std::span<Token> &tok) {
-  std::map<std::string_view, YamlNode> map;
-
-  while (tok[0].kind != Token::END && tok[0].kind != Token::DEDENT) {
-    if (tok.size() < 2 || tok[0].kind != Token::STRING || tok[1].kind != ':')
-      return YamlError{"map key expected", tok[0].str.data() - input.data()};
-
-    std::string_view key = tok[0].str;
-    tok = tok.subspan(2);
-
-    std::variant<YamlNode, YamlError> elem = parse_element(tok);
-    if (YamlError *err = std::get_if<YamlError>(&elem))
-      return *err;
-    map[key] = std::get<YamlNode>(elem);
-  }
-  return YamlNode{map};
-}
-
-std::variant<YamlNode, YamlError>
-YamlParser::parse_flow_element(std::span<Token> &tok) {
-  if (tok[0].kind == '[') {
-    tok = tok.subspan(1);
-    return parse_flow_list(tok);
-  }
-
-  if (tok[0].kind != Token::STRING)
-    return YamlError{"scalar expected", tok[0].str.data() - input.data()};
-
-  std::string_view val = tok[0].str;
-  tok = tok.subspan(1);
-  return YamlNode{val};
-}
-
-std::variant<YamlNode, YamlError>
-YamlParser::parse_flow_list(std::span<Token> &tok) {
-  std::vector<YamlNode> vec;
-  const char *start = tok[0].str.data();
-
-  while (tok[0].kind != ']' && tok[0].kind != Token::END) {
-    std::variant<YamlNode, YamlError> elem = parse_flow_element(tok);
-    if (YamlError *err = std::get_if<YamlError>(&elem))
-      return *err;
-    vec.push_back(std::get<YamlNode>(elem));
-
-    if (tok[0].kind == ']')
-      break;
-    if (tok[0].kind != ',')
-      return YamlError{"comma expected", tok[0].str.data() - input.data()};
-    tok = tok.subspan(1);
-  }
-
-  if (tok[0].kind == Token::END)
-    return YamlError{"unterminated flow list", start - input.data()};
-
-  tok = tok.subspan(1);
-  return YamlNode{vec};
-}
-
-std::variant<std::vector<YamlNode>, YamlError>
-parse_yaml(std::string_view str) {
-  return YamlParser(str).parse();
-}
-
-} // namespace mold::macho