Support 32-bit PA-RISC

Fixes https://github.com/rui314/mold/issues/945

.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,111 @@ 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
+        mkdir build
+        cd build
+        cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ${{ matrix.target }} ..
+        cmake --build . -j$(nproc)
+        ctest . -j$(nproc)
+
   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++
+        # Install cross toolchains
+        dpkg --add-architecture i386
+        ./install-build-deps.sh update
+        apt-get install -y sudo qemu-user gdb zstd dwarfdump {gcc,g++}-10-{i686,aarch64,riscv64,powerpc,powerpc64,powerpc64le,s390x,sparc64,m68k,sh4,alpha}-linux-gnu {gcc,g++}-10-arm-linux-gnueabihf
+
+        for i in i686 aarch64 riscv64 powerpc powerpc64 powerpc64le s390x sparc64 m68k sh4 alpha; do
+          ln -sf /usr/bin/$i-linux-gnu-gcc-10 /usr/bin/$i-linux-gnu-gcc
+          ln -sf /usr/bin/$i-linux-gnu-g++-10 /usr/bin/$i-linux-gnu-g++
+        done
+
         ln -sf /usr/bin/arm-linux-gnueabihf-gcc-10 /usr/bin/arm-linux-gnueabihf-gcc
         ln -sf /usr/bin/arm-linux-gnueabihf-g++-10 /usr/bin/arm-linux-gnueabihf-g++
-        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 a RV32 toolchain from third party since it's not available
+        # as an Ubuntu package.
+        mkdir /usr/local/rv32
+        wget -O- -q https://github.com/riscv-collab/riscv-gnu-toolchain/releases/download/2022.08.26/riscv32-glibc-ubuntu-20.04-nightly-2022.08.26-nightly.tar.gz | tar -C /usr/local/rv32 --strip-components=1 -xzf -
+
+        ln -sf /usr/local/rv32/sysroot /usr/riscv32-linux-gnu
+        ln -sf /usr/local/rv32/bin/riscv32-unknown-linux-gnu-objdump /usr/bin/riscv32-linux-gnu-objdump
+        echo '/usr/local/rv32/bin/riscv32-unknown-linux-gnu-gcc -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-gcc
+        echo '/usr/local/rv32/bin/riscv32-unknown-linux-gnu-g++ -L/usr/riscv32-linux-gnu "$@"' > /usr/bin/riscv32-linux-gnu-g++
+        chmod 755 /usr/bin/riscv32-linux-gnu-gcc /usr/bin/riscv32-linux-gnu-g++
+      shell: bash
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1
-    - name: 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 ..
+        cmake --build . -j$(nproc)
+        ctest . -j$(nproc)
+    - name: archive test results
+      uses: actions/upload-artifact@v3
+      if: always()
+      with:
+        name: test-results
+        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

.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,455 @@
+# 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.13)
+project(mold VERSION 1.8.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)
+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
+    -Wno-sign-compare
+    -Wno-unused-function)
+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++ and libcrypto 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++)
+  target_link_libraries(mold PRIVATE libcrypto.a)
+endif()
+
+# Find zlib. If libz.so is not found, we compile a bundled one and
+# statically-link it to mold.
+find_package(ZLIB QUIET)
+if(ZLIB_FOUND)
+  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 zstd compression library. Just like zlib, 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)
+  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 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(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)
+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(NOT APPLE AND NOT WIN32 AND NOT MOLD_MOSTLY_STATIC)
+  find_package(OpenSSL REQUIRED COMPONENTS Crypto)
+  target_link_libraries(mold PRIVATE OpenSSL::Crypto)
+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 WIN32)
+  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}/update-git-hash.cmake
+  DEPENDS update-git-hash.cmake
+  BYPRODUCTS git-hash.cc
+  VERBATIM)
+
+add_dependencies(mold git_hash)
+
+# Create config.h file
+configure_file(config.h.in config.h)
+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 HPPA32)
+
+list(APPEND MOLD_ELF_TEMPLATE_FILES
+  elf/cmdline.cc
+  elf/dwarf.cc
+  elf/gc-sections.cc
+  elf/icf.cc
+  elf/input-files.cc
+  elf/input-sections.cc
+  elf/linker-script.cc
+  elf/lto.cc
+  elf/main.cc
+  elf/mapfile.cc
+  elf/output-chunks.cc
+  elf/passes.cc
+  elf/relocatable.cc
+  elf/subprocess.cc
+  elf/thunks.cc
+  )
+
+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)
+  file(WRITE ${PATH} "#define MOLD_${TARGET} 1
+#define MOLD_TARGET ${TARGET}
+#include \"${CMAKE_SOURCE_DIR}/${SOURCE}\"
+")
+  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
+  compress.cc
+  demangle.cc
+  elf/arch-alpha.cc
+  elf/arch-arm32.cc
+  elf/arch-arm64.cc
+  elf/arch-hppa32.cc
+  elf/arch-i386.cc
+  elf/arch-m68k.cc
+  elf/arch-ppc32.cc
+  elf/arch-ppc64v1.cc
+  elf/arch-ppc64v2.cc
+  elf/arch-riscv.cc
+  elf/arch-s390x.cc
+  elf/arch-sh4.cc
+  elf/arch-sparc64.cc
+  elf/arch-x86-64.cc
+  elf/elf.cc
+  filepath.cc
+  git-hash.cc
+  glob.cc
+  hyperloglog.cc
+  main.cc
+  multi-glob.cc
+  perf.cc
+  tar.cc
+  third-party/rust-demangle/rust-demangle.c
+  uuid.cc
+  )
+
+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 LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
+  install(FILES docs/mold.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1/)
+
+  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_INSTALL_LIBEXECDIR}/mold/ld)
+  mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
+    ${CMAKE_INSTALL_BINDIR}/ld.mold)
+  mold_install_relative_symlink(${CMAKE_INSTALL_MANDIR}/man1/mold.1
+    ${CMAKE_INSTALL_MANDIR}/man1/ld.mold.1)
+
+  if(MOLD_IS_SOLD)
+    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
+      ${CMAKE_INSTALL_BINDIR}/ld64.mold)
+    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
+      ${CMAKE_INSTALL_BINDIR}/ld.sold)
+    mold_install_relative_symlink(${CMAKE_INSTALL_BINDIR}/mold
+      ${CMAKE_INSTALL_BINDIR}/ld64.sold)
+  endif()
+endif()

CMakeSettings.json

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

CONTRIBUTING.md

@@ -1,30 +1,16 @@
 # 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:
+We request all patches to mold to be released under the dual license
+of the GNU AGPLv3 and the MIT license. Please read the following and
+sign-off your patch as an indication of agreement.
 
 > ## Developer's Certificate of Origin
 >
 > By making a contribution to this project, I certify that:
 >
 >  1. The contribution was created in whole or in part by me and I
->     have the right to submit it under the Dual License; or
+>     have the right to submit it under the Dual License of the GNU
+>     AGPLv3 and the MIT license; or
 >
 >  2. The contribution is based upon previous work that, to the best
 >     of my knowledge, is covered under the the Dual License and I
@@ -42,7 +28,7 @@ rules are pretty simple: if you can certify the below:
 >     maintained indefinitely and may be redistributed consistent with
 >     this project or the open source license(s) involved.
 
-then you just add a line saying:
+If you agree, you just add a line saying:
 
 ```
 Signed-off-by: Random J Developer <[email protected]>
@@ -52,3 +38,7 @@ using your real name (sorry, no pseudonyms or anonymous contributions.)
 This will be done for you automatically if you use ``git commit -s``.
 Reverts should also include "Signed-off-by". ``git revert -s`` does that
 for you.
+
+We assume that any contribution that's 10 lines or less does not meet
+the threshold of originality and therefore copyright does not apply.
+You don't need to add a "Signed-off-by" line to such small patches.

Dockerfile

@@ -1,22 +1,23 @@
 # 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)
+# $ 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 && \
-  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)
+  apt-get update && \
+  apt-get install -y --no-install-recommends build-essential wget libstdc++-11-dev zlib1g-dev gcc-10 g++-10 python3 && \
+  \
+  mkdir /openssl && cd /openssl && \
+  wget -O- -q https://www.openssl.org/source/openssl-3.0.7.tar.gz | tar --strip-components=1 -xzf - && \
+  ./Configure --prefix=/usr/local --libdir=lib && \
+  make -j$(nproc) && \
+  make -j$(nproc) install && \
+  ldconfig && \
+  mkdir /cmake && cd /cmake && \
+  wget -O- -q https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2.tar.gz | tar --strip-components=1 -xzf - && \
+  ./bootstrap --parallel=$(nproc) && make -j$(nproc) && make -j$(nproc) install && \
+  rm -rf /var/lib/apt/lists/* /cmake /openssl

LICENSE

@@ -4,9 +4,9 @@ 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 rui[email protected].
+contact rui[email protected].
+
 
---
 
                     GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
@@ -669,3 +669,357 @@ specific requirements.
 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/>.
+
+
+
+
+MOLD SUBCOMPONENTS:
+
+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,5 +1,13 @@
 # mold: A Modern Linker
 
+[![CI](https://github.com/rui314/mold/actions/workflows/ci.yml/badge.svg)](https://github.com/rui314/mold/actions/workflows/ci.yml)
+[![build result](https://build.opensuse.org/projects/home:marxin:mold/packages/mold/badge.svg?type=default)](https://build.opensuse.org/package/show/home:marxin:mold/mold)
+
+<i>This is a repo of a free, AGPL-licensed version of the linker.
+If you are looking for a commercial, non-AGPL version of the same linker,
+please visit the
+[repo of the sold linker](https://github.com/bluewhalesystems/sold).</i>
+
 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.
@@ -22,13 +30,18 @@ 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 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, 64-bit big-endian PowerPC ELFv1, 64-bit little-endian PowerPC ELFv2,
+s390x, SPARC64 and m68k.
+
+mold/macOS is commercial software. For mold/macOS, please visit
+https://github.com/bluewhalesystems/sold.
 
 ## Why does the speed of linking matter?
 
 If you are using a compiled language such as C, C++ or Rust, a build
-consists of two phases. In the first phase, a compiler compiles a
-source file into an object file (`.o` files). In the second phase,
+consists of two phases. In the first phase, a compiler compiles
+source files into object files (`.o` files). In the second phase,
 a linker takes all object files to combine them into a single executable
 or a shared library file.
 
@@ -39,7 +52,7 @@ most noticeable when you are in rapid debug-edit-rebuild cycles.
 
 ## Install
 
-Binary packages for the following distros are currently available.
+Binary packages for the following systems are currently available.
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/mold.svg)](https://repology.org/project/mold/versions)
 
@@ -47,58 +60,43 @@ Binary packages for the following distros are currently available.
 
 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.
-
-I'm using Ubuntu 20.04 as a development platform. In that environment,
-you can build mold by the following commands.
+or Clang 12.0.0 (or later) as well as libstdc++ 10 or libc++ 7 (or
+later) are recommended.
 
 ### 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 recognizes your Linux distribution and tries to install
+necessary packages. You may want 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 v1.8.0
+../install-build-deps.sh
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=c++ ..
+cmake --build . -j $(nproc)
+sudo cmake --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,
+You may need to pass a C++20 compiler command name to `cmake`.
+In the above case, `c++` is passed. If it doesn't work for you,
 try a specific version of a compiler such as `g++-10` or `clang++-12`.
 
-By default, `mold` is installed to `/usr/local/bin`.
+By default, `mold` is installed to `/usr/local/bin`. You can change
+that by passing `-DCMAKE_INSTALL_PREFIX=<directory>`. For other cmake
+options, see the comments in `CMakeLists.txt`.
 
 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
+`cmake` in the above commands doesn't work for you, you can use Docker to
 build it in a Docker environment. To do so, just run `./dist.sh` in this
-directory instead of 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
-```
+directory instead of `cmake`. The shell script pulls a Docker image,
+builds mold and auxiliary files inside it, and packs them into a
+single tar file `mold-$version-$arch-linux.tar.gz`.  You can extract
+the tar file anywhere and use `mold` executable in it.
 
 ## How to use
 
@@ -115,7 +113,7 @@ following flags to use `mold` instead of `/usr/bin/ld`:
 
 - Clang: pass `-fuse-ld=mold`
 
-- GCC 12.1.0 (upcoming version) or later: pass `-fuse-ld=mold`
+- 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
@@ -123,11 +121,11 @@ following flags to use `mold` instead of `/usr/bin/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
+  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 haven't installed `mold` to any `$PATH`, you can still pass
+If you haven't installed `ld.mold` to any `$PATH`, you can still pass
 `-fuse-ld=/absolute/path/to/mold` to clang to use mold. GCC does not
 take an absolute path as an argument for `-fuse-ld` though.
 
@@ -137,18 +135,62 @@ 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 `mold` exectuable. In the
+above example, we use `clang` as a linker driver as it can always take
+the `-fuse-ld` option. If your GCC is recent enough to recognize the
+option, you may be able to remove the `linker = "clang"` line.
+
+```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, put the above snippet to
 `~/.cargo/config.toml`.
 
+If you are using macOS, you can modify `config.toml` in a similar manner.
+Here is an example with `mold` installed via [Homebrew](https://brew.sh).
+
+```toml
+[target.x86_64-apple-darwin]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+[target.aarch64-apple-darwin]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+```
+
+</details>
+
+<details><summary>If you are using Nim</summary>
+
+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
+The above example uses `gcc` as the linker driver.
+Use the `fuse-ld` option. If your GCC is recent enough to recognize this option.
+
+If you want to use mold for all projects, put the above snippet to `~/.config/config.nims`.
+
+If you are using macOS, you can modify config.nims in a similar manner. Here is an example with mold installed via Homebrew.
+
+```nim
+when findExe("ld64.mold").len > 0 and defined(macosx):
+  switch("passL", "-fuse-ld=ld64.mold")
+```
+
 </details>
 
 <details><summary>mold -run</summary>
@@ -170,12 +212,28 @@ 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>On macOS</summary>
+
+mold/macOS is available as an alpha version. It can be used to build not
+only macOS apps but also iOS apps because their binary formats are the same.
+
+The command name of mold/macOS is `ld64.mold`. If you build mold on macOS,
+it still produces `mold` and `ld.mold`, but these executables are useful
+only for cross compilation (i.e. building Linux apps on macOS.)
+
+If you find any issue with mold/macOS, please file it to
+<a href=https://github.com/rui314/mold/issues>our GitHub Issues</a>.
+
+</details>
+
+<details><summary>GitHub Actions</summary>
+
+You can use our <a href=https://github.com/rui314/setup-mold>setup-mold</a>
+GitHub Action to speed up GitHub-hosted continuous build. GitHub Actions
+runs on a two-core machine, but mold is still significantly faster than
+the default GNU linker there especially when a program being linked is
+large.
+
 </details>
 
 <details><summary>Verify that you are using mold</summary>
@@ -184,7 +242,7 @@ mold leaves its identification string in `.comment` section in 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
@@ -195,6 +253,15 @@ If `mold` is in `.comment`, the file is created by mold.
 
 </details>
 
+<details><summary>Online manual</summary>
+
+Since mold is a drop-in replacement, you should be able to use it
+without reading its manual. But just in case you need it, it's available
+online at <a href=https://rui314.github.io/mold.html>here</a>.
+You can also read the same manual by `man mold`.
+
+</details>
+
 ## Why is mold so fast?
 
 One reason is because it simply uses faster algorithms and efficient
@@ -214,6 +281,43 @@ artificially capped to 16 so that the bars fit in the GIF.
 
 For details, please read [design notes](docs/design.md).
 
-# Logo
+## License
 
--![mold image](docs/mold.jpg)
+mold is available under AGPL. Note that that does not mean that you
+have to license your program under AGPL if you use mold to link your
+program. An output of the mold linker is a derived work of the object
+files and libraries you pass to the linker but not a derived work of
+the mold linker itself.
+
+Besides that, you can also buy a commercial, non-AGPL license with
+technical support from our company, Blue Whale Systems PTE LTD. If you
+are a big company, please consider obtaining it before making hundreds
+or thousands of developers of your company to depend on mold. mold is
+mostly a single-person open-source project, and just like other
+open-source projects, we are not legally obligated to keep maintaining
+it. A legally-binding commercial license contract addresses the
+concern. By purchasing a license, you are guaranteed that mold will be
+maintained for you. Please [contact us](mailto:[email protected])
+for a commercial license inquiry.
+
+## Sponsors
+
+We accept donations via [GitHub Sponsors](https://github.com/sponsors/rui314)
+and [OpenCollective](https://opencollective.com/mold-linker).
+We thank you to everybody who sponsors our project. In particular,
+we'd like to acknowledge the following people and organizations who
+have sponsored $128/month or more:
+
+### Corporate sponsors
+
+<a href="https://mercury.com/"><img src="docs/mercury-logo.png" align=center height=120 width=400 alt=Mercury></a>
+
+- [Uber](https://uber.com)
+- [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)

archive-file.h

@@ -1,3 +1,28 @@
+// 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"
@@ -93,6 +118,7 @@ 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.back()->thin_parent = mf;
     data = body;
   }
   return vec;
@@ -140,7 +166,7 @@ read_fat_archive_members(C &ctx, MappedFile<C> *mf) {
 template <typename C>
 std::vector<MappedFile<C> *>
 read_archive_members(C &ctx, MappedFile<C> *mf) {
-  switch (get_file_type(mf)) {
+  switch (get_file_type(mf, !ctx.arg.plugin.empty())) {
   case FileType::AR:
     return read_fat_archive_members(ctx, mf);
   case FileType::THIN_AR:

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

@@ -29,8 +29,22 @@ read_response_file(C &ctx, std::string_view path) {
 
   auto read_unquoted = [&](i64 i) {
     std::string buf;
-    while (i < mf->size && !isspace(data[i]))
-      buf.append(1, data[i++]);
+
+    while (i < mf->size) {
+      if (data[i] == '\\' && i + 1 < mf->size) {
+        buf.append(1, data[i + 1]);
+        i += 2;
+        continue;
+      }
+
+      if (!isspace(data[i])) {
+        buf.append(1, data[i++]);
+        continue;
+      }
+
+      break;
+    }
+
     vec.push_back(save_string(ctx, buf));
     return i;
   };
@@ -48,6 +62,7 @@ read_response_file(C &ctx, std::string_view path) {
   return vec;
 }
 
+// Replace "@path/to/some/text/file" with its file contents.
 template <typename C>
 std::vector<std::string_view> expand_response_files(C &ctx, char **argv) {
   std::vector<std::string_view> vec;
@@ -60,4 +75,16 @@ std::vector<std::string_view> expand_response_files(C &ctx, char **argv) {
   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

compress.cc

@@ -1,11 +1,13 @@
-// 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
@@ -16,8 +18,13 @@
 
 #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

config.h.in

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

demangle.cc

@@ -1,15 +1,41 @@
 #include "mold.h"
 
 #include <cstdlib>
+
+#ifndef _WIN32
 #include <cxxabi.h>
+#endif
+
+#include "third-party/rust-demangle/rust-demangle.h"
 
 namespace mold {
 
 std::string_view demangle(std::string_view name) {
-  if (name.starts_with("_Z")) {
-    static thread_local char *buf;
-    static thread_local size_t buflen;
+  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) {
@@ -17,8 +43,9 @@ std::string_view demangle(std::string_view name) {
       return p;
     }
   }
+#endif
 
-  return name;
+  return {};
 }
 
 } // 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,27 @@
 # 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"
+if [ $# -ne 1 ]; then
+  echo "Usage: $0 [ x86_64 | aarch64 | arm | ppc64le | s390x ]"
   exit 1
 fi
 
-docker images -q $image 2> /dev/null || docker pull $image
+arch=$1
+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 -it --rm -v "$(pwd):/mold" \
+  -e "OWNER=$(id -u):$(id -g)" rui314/mold-builder:latest \
+  bash -c "mkdir /tmp/build &&
+cd /tmp/build &&
+cmake -DCMAKE_C_COMPILER=gcc-10 -DCMAKE_CXX_COMPILER=g++-10 -DMOLD_MOSTLY_STATIC=On -DCMAKE_BUILD_TYPE=Release /mold &&
+cmake --build . -j\$(nproc) &&
+[ $arch = arm ] || ctest -j\$(nproc) &&
+cmake --install . --prefix $dest --strip &&
 tar czf /mold/$dest.tar.gz $dest &&
-cp mold /mold"
+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.1

@@ -229,7 +229,119 @@ such as system-dependent library search paths, are hard-coded.
 depends only on its command-line arguments.
 .
 .\"=============================================================================
-.Sh OPTIONS
+.Sh MOLD-SPECIFIC OPTIONS
+.Bl -tag -width 6n -compact
+.Pp
+.It Fl -chroot Ns = Ns Ar dir
+Set
+.Ar dir
+to root directory.
+.Pp
+.It Fl -color-diagnostics Ns = Ns Op Sy auto | always | never
+.It Fl -color-diagnostics
+.It Fl -no-color-diagnostics
+.Pp
+Show diagnostics messages in color using ANSI escape sequences.
+.Ar auto
+means that
+.Nm
+prints out messages in color only if the standard output is connected to a TTY. \
+Default is
+.Ar auto .
+.Pp
+.It Fl -fork
+.It Fl -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
+.Nm
+process.
+.Fl -fork
+hides that latency. By default, it does fork.
+.Pp
+.It Fl -perf
+Print performance statistics.
+.Pp
+.It Fl -repro
+Archive input files as a tar file.
+.Pp
+.It Fl -reverse-sections
+Reverses the order of input sections before assigning them the offsets \
+in the output file.
+.Pp
+This option is useful for finding a bug that depends on an 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.
+.Pp
+By reversing the order of input sections using
+.Fl -reverse-sections ,
+you can easily test that your program works in the reversed initialization order.
+.Pp
+.It Fl -run Cm command Ar arg Ar
+Run
+.Cm command
+with
+.Nm
+as
+.Pa /usr/bin/ld .
+.Pp
+.It Fl -shuffle-sections
+.It Fl -shuffle-sections Ns = Ns Ar number
+Randomizes the output by shuffling the order of input sections before \
+assigning them the offsets in the output file. If
+.Ar number
+is given, it's used as a seed for the random number generator, so that \
+the linker produces the same output as for the same seed. If no seed \
+is given, a random number is used as a seed.
+.Pp
+This option is useful for benchmarking. Modern CPUs are sensitive to program's \
+memory layout. A seeming benign change in program layout (such as a small \
+size increase of a function in the middle of a program) can affect program's \
+performance. Therefore, \
+even if you write new code and get a good benchmark result, it is hard \
+to say whether or not the new code improves the programs performance. \
+It is possible that the new memory layout happens to perform better.
+.Pp
+By running a benchmark multiple time with shuffling memory layout using
+.Fl -shuffle-sections ,
+you can isolate your program's real performance number from the randomness \
+caused by memory layout changes.
+.Pp
+.It Fl -stats
+Print input statistics.
+.Pp
+.It Fl -thread-count Ns = Ns Ar count
+Use
+.Ar count
+number of threads.
+.Pp
+.It Fl -threads
+.It Fl -no-threads
+Use multiple threads.
+By default,
+.Nm
+uses as many threads as the number of cores or 32, whichever is the smallest.
+The reason why it is capped to 32 is because
+.Nm
+doesn't scale well beyond that point.
+To use only one thread, pass
+.Fl -no-threads
+or
+.Fl -thread-count Ns = Ns Sy 1 .
+.Pp
+.Pp
+.It Fl -quick-exit
+.It Fl -no-quick-exit
+Use or do not use
+.Dv quick_exit
+to exit.
+.
+.El \" End of options list
+.
+.\"-----------------------------------------------------------------------------
+.Sh GNU-COMPATIBLE OPTIONS
 .Bl -tag -width 6n -compact
 .It Fl -help
 Report usage information to stdout and exit.
@@ -352,7 +464,7 @@ or
 .Pf Sy lib Ar libname Ns Sy \.a
 from library search paths.
 .Pp
-.It Fl m Op Sy elf_x86_64 | elf_i386 | aarch64linux
+.It Fl m Op Ar target
 Choose a target.
 .Pp
 .It Fl o Ar file , Fl -output Ns = Ns Ar file
@@ -366,6 +478,26 @@ 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.
 .Pp
+.It Fl -relocatable-merge-sections
+By default,
+.Nm
+doesn't merge input sections by name when merging input object files into a \
+single output object file for
+.Fl r .
+For example,
+.Ar .text.foo
+and
+.Ar .text.bar
+aren't merged for
+.Fl r
+even though they are merged into
+.Ar .text
+according to the default section merging rules.
+.Pp
+This option changes the behavior so that
+.Nm
+merges input sections by name by the default section merging rules.
+.Pp
 .It Fl s , Fl -strip-all
 Omit
 .Li \.symtab
@@ -468,15 +600,15 @@ sets a random 128-bit UUID.
 sets
 .Ar hexstring .
 .Pp
-.It Fl -chroot Ns = Ns Ar dir
-Set
-.Ar dir
-to root directory.
+.It Fl -defsym Ns = Ns Ar symbol Ns = Ns Ar value
 .Pp
-.It Fl -compress-debug-sections Ns = Ns Op Sy none | zlib | zlib-gabi | zlib-gnu
+.It Fl -compress-debug-sections Ns = Ns Op Sy none | zlib | zlib-gabi | zstd
 Compress DWARF debug info
 .Pf ( Sy .debug_*
-sections) using the zlib compression algorithm.
+sections) using the zlib or zstd compression algorithm.
+.Fl zlib-gabi
+is an alias for
+.Fl zlib .
 .Pp
 .It Fl -defsym Ns = Ns Ar symbol Ns = Ns Ar value
 Define
@@ -506,7 +638,7 @@ Write a dependency file to
 The contents of the written file is readable by
 .Cm make ,
 which defines only one rule with the linker's output file as a target \
-and all input fiels as its prerequisite. Users are expected to include \
+and all input files as its prerequisite. 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
 .Fl MM Fl MF
@@ -515,6 +647,15 @@ options.
 .It Fl -dynamic-list Ns = Ns Ar file
 Read a list of dynamic symbols from
 .Ar file .
+Same as
+.Fl -export-dynamic-symbol-list ,
+except that it implies
+.Fl -Bsymbolic .
+.Pp
+If
+.Ar file
+does not exist in the current directory, it is searched from library \
+search paths for the sake of compatibility with GNU ld.
 .Pp
 .It Fl -eh-frame-hdr
 .It Fl -no-eh-frame-hdr
@@ -533,10 +674,6 @@ 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.
 .Pp
-.Nm
-always creates RELA-type relocation sections even if the native \
-ELF format is REL-type so that it is easy to read addends.
-.Pp
 .It Fl -enable-new-dtags
 .It Fl -disable-new-dtags
 By default,
@@ -549,37 +686,113 @@ mold emits DT_RPATH for
 .Fl -rpath
 instead.
 .Pp
+.It Fl -execute-only
+Traditionally, most processors require both executable and readable bits to 1 \
+to make the page executable, which allows machine code to read itself 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.
+.Pp
+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.
+.Pp
+This option marks text segments execute-only. This option currently works only \
+on some ARM64 processors.
 .Pp
 .It Fl -exclude-libs Ns = Ns Ar libraries Ns ...
 Mark all symbols in the given
 .Ar libraries
 hidden.
 .Pp
+.It Fl -export-dynamic-symbol Ns = Ns Ar sym
+Put symbols matching
+.Ar sym
+in the dynamic symbol table.
+.Ar sym
+may be a glob, with the same syntax as the globs used in
+.Fl -export-dynamic-symbol-list
+or
+.Fl -version-script .
+.Pp
+.It Fl -export-dynamic-symbol-list Ns = Ns Ar file
+Read a list of dynamic symbols from
+.Ar file .
+.Pp
+.It Fl -fatal-warnings
+.It Fl -no-fatal-warnings
+Treat warnings as errors.
+.Pp
 .It Fl -fini Ns = Ns Ar symbol
 Call
 .Ar symbol
 at unload-time.
 .Pp
-.It Fl -fork
-.It Fl -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
-.Nm
-process.
-.Fl -fork
-hides that latency.
-.Pp
 .It Fl -gc-sections
 .It Fl -no-gc-sections
 Remove unreferenced sections.
 .Pp
+.It Fl -gdb-index
+Create a
+.Li .gdb_index
+section to speed up GNU debugger. To use this, you need to compile source files \
+with the
+.Fl -ggnu-pubnames
+compiler flag.
+.Pp
 .It Fl -hash-style Ns = Ns Op Sy sysv | gnu | both
 Set hash style.
 .Pp
-.It Fl -icf Ns = Ns Sy all
+.It Fl -icf Ns = Ns Op Sy none | safe | all
 .It Fl -no-icf
-Fold identical code.
+It is not uncommon for a program to contain many identical functions that differ \
+only in name. For example, a C++ template
+.Sy std::vector
+is very likely to be instantiated to the identical code for
+.Sy std::vector<int>
+and
+.Sy 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.
+.Pp
+If
+.Fl -icf=all
+is given,
+.Nm
+tries to merge all identical functions. This reduces the size of the output \
+most, but it is not
+.Dq safe
+optimization. It is guaranteed in C and C++ that two pointers pointing two \
+different functions will never be equal, but
+.Fl -icf=all
+breaks that assumption as two functions have the same address after merging. \
+So a care must be taken when you use that flag that your program does not \
+depend on the function pointer uniqueness.
+.Pp
+.Fl -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.
+.FL -icf=safe
+needs to be used with a compiler that supports
+.Sy .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
+.Fl -icf=safe
+with GCC (it doesn't do any harm but can't optimize at all.)
+.Pp
+.Fl -icf=none
+and
+.Fl -no-icf
+disables ICF.
+.Pp
+.It Fl -ignore-data-address-equality
+Make ICF to merge not only functions but also data. This option should be \
+used in combination with
+.Fl -icf=all .
 .Pp
 .It Fl -image-base Ns = Ns Ar addr
 Set the base address to
@@ -620,16 +833,18 @@ to run executables or shared libraries linked with
 .Fl -pack-dyn-relocs=relr ,
 and only ChromeOS, Android and Fuchsia support it as of now in 2022.
 .Pp
-.It Fl -perf
-Print performance statistics.
+.It Fl -package-metadata Ns = Ns Ar string
+Embed
+.Ar string
+to a .note.package section. This option in intended to be used by a \
+package management command such as
+.Cm rpm
+to embed metadata regarding a package to each executable file.
 .Pp
 .It Fl -pie , -pic-executable
 .It Fl -no-pie , -no-pic-executable
 Create a position-independent executable.
 .Pp
-.It Fl -preload
-Preload object files.
-.Pp
 .It Fl -print-gc-sections
 .It Fl -no-print-gc-sections
 Print removed unreferenced sections.
@@ -663,12 +878,6 @@ by as-needed basis but don't want to change the global state of
 you can append "--push-state --as-needed -lfoo --pop-state" to the \
 linker command line options.
 .Pp
-.It Fl -quick-exit
-.It Fl -no-quick-exit
-Use
-.Dv quick_exit
-to exit.
-.Pp
 .It Fl -relax
 .It Fl -no-relax
 Rewrite machine instructions with more efficient ones for some relocations.
@@ -679,11 +888,6 @@ Like
 .Fl -undefined ,
 except the new symbol must be defined by the end of the link.
 .Pp
-.It Fl -repro
-Embed input files into
-.Dv .repro
-section.
-.Pp
 .It Fl -retain-symbols-file Ns = Ns Ar file
 Keep only symbols listed in
 .Ar file .
@@ -693,7 +897,7 @@ is a text file
 containing a symbol name on each line.
 .Nm
 discards all local
-symbols as well as global sybmol that are not in
+symbols as well as global symbol that are not in
 .Ar file .
 Note that this option removes symbols only from
 .Dv .symtab
@@ -701,23 +905,11 @@ section and does not affect
 .Dv .dynsym
 section, which is used for dynamic linking.
 .Pp
-.It Fl -reverse-sections
-Reverses the order of input sections before assigning them the offsets \
-in the output file.
-.Pp
 .It Fl -rpath Ns = Ns Ar dir
 Add
 .Ar dir
 to runtime search path.
 .Pp
-.It Fl -run Cm command Ar arg Ar
-Run
-.Cm command
-with
-.Nm
-as
-.Pa /usr/bin/ld .
-.Pp
 .It Fl -section-start Ns = Ns Ar section Ns = Ns Ar address
 Set
 .Ar address
@@ -730,15 +922,6 @@ is a hexadecimal number that may start with an optional
 .It Fl -shared , -Bshareable
 Create a share library.
 .Pp
-.It Fl -shuffle-sections
-.It Fl -shuffle-sections Ns = Ns Ar number
-Randomizes the output by shuffleing the order of input sections before \
-assigning them the offsets in the output file. If
-.Ar number
-is given, it's used as a seed for the random number generator, so that \
-the linker produces the same output as for the same seed. If no seed \
-is given, it uses a random number as a seed.
-.Pp
 .It Fl -spare-dynamic-tags Ns = Ns Ar number
 Reserve given
 .Ar number
@@ -761,35 +944,21 @@ needed but want to avoid the overhead of running
 .It Fl -static
 Do not link against shared libraries.
 .Pp
-.It Fl -stats
-Print input statistics.
-.Pp
 .It Fl -sysroot Ns = Ns Ar dir
 Set target system root directory to
 .Ar dir .
-.Pp
-.It Fl -thread-count Ns = Ns Ar count
-Use
-.Ar count
-number of threads.
-.Pp
-.It Fl -threads
-.It Fl -no-threads
-Use multiple threads.
-By default,
-.Nm
-uses as many threads as the number of cores or 32, whichever is the smallest.
-The reason why it is capped to 32 is because
-.Nm
-doesn't scale well beyond that point.
-To use only one thread, pass
-.Fl -no-threads
-or
-.Fl -thread-count Ns = Ns Sy 1 .
-.Pp
 .It Fl -trace
 Print name of each input file.
 .Pp
+.It Fl -undefined-version
+.It Fl -no-undefined-version
+By default,
+.Nm
+warns on a symbol specified by a version script or by
+.Fl -export-dynamic-symbol
+if it is not defined. You can silence the warning by
+.Fl -undefined-version .
+.Pp
 .It Fl -unique Ns = Ns Ar pattern
 Don't merge input sections that match
 .Ar pattern .
@@ -801,6 +970,10 @@ How to handle undefined symbols.
 .It Fl -version-script Ns = Ns Ar file
 Read version script from
 .Ar file .
+If
+.Ar file
+does not exist in the current directory, it is searched from library search paths \
+for the sake of compatibility with GNU ld.
 .Pp
 .It Fl -warn-common
 .It Fl -no-warn-common
@@ -898,23 +1071,7 @@ section to indicate that the output uses IBT-enabled PLT. This option implies
 .Fl z Cm ibtplt .
 .Pp
 .It Fl z Cm ibtplt
-Generate Intel Branch Tracking (IBT)-enabled PLT.
-.Pp
-IBT is part of Intel Control-flow Enforcement Technology (CET).
-IBT is a new x86 feature available since Tiger Lake which is released in 2020.
-If IBT is enabled, all indirect branch instructions have to branch to a \
-so-called "landing pad" instruction. Landing pad itself is a no-op, but \
-it works as a marker that branching to that instruction is expected.
-If there's no landing pad after branch, the CPU raises an exception.
-This mechanism makes ROP attacks difficult.
-.Pp
-Since PLT can be used as an indirect branch target, we need a different \
-instruction sequence for IBT-enabled PLT. If
-.Sy -z Cm ibtplt
-is specified,
-.Nm
-generates PLT entries that start with a landing pad. The size of IBT-enabled \
-PLT is 24 bytes as opposed to 16 bytes regular PLT.
+Generate Intel Branch Tracking (IBT)-enabled PLT which is the default on x86-64.
 .Pp
 .It Fl z Cm execstack
 .It Fl z Cm noexecstack
@@ -948,15 +1105,13 @@ As a security mitigation,
 it is preferred to make such segments read-only during program execution.
 .Pp
 .Fl z Cm relro
-puts such sections into a special section called
+puts such sections into a special segment called
 .Dv relro .
 The dynamic linker make a relro segment read-only after it finishes its job.
 .Pp
 By default,
 .Nm
-generates a
-.Sy relro
-segment.
+generates a relro segment.
 .Fl z Cm norelro
 disables the feature.
 .Pp
@@ -965,7 +1120,7 @@ disables the feature.
 .It Fl z Cm noseparate-code
 If one memory page contains multiple segments,
 the page protection bits are set in such a way that needed attributes \
-(writable or executable) are satisifed for all segments.
+(writable or executable) are satisfied for all segments.
 This usually happens at a boundary of two segments with two different \
 attributes.
 .Pp
@@ -1044,20 +1199,14 @@ Mark object to interpose all DSOs but executable.
 .It Fl EL
 .It Fl O Ns Ar number
 .It Fl -allow-shlib-undefined
-.It Fl -color-diagnostics
 .It Fl -dc
 .It Fl -dp
 .It Fl -end-group
-.It Fl -fatal-warnings
-.It Fl -gdb-index
 .It Fl -no-add-needed
 .It Fl -no-allow-shlib-undefined
 .It Fl -no-copy-dt-needed-entries
 .It Fl -no-fatal-warnings
-.It Fl -no-undefined-version
 .It Fl -nostdlib
-.It Fl -plugin
-.It Fl -plugin-opt
 .It Fl -rpath-link Ns = Ns Ar dir
 .It Fl -sort-common
 .It Fl -sort-section
@@ -1078,7 +1227,7 @@ Ignored
 .Sh SEE ALSO
 .Xr gold 1 ,
 .Xr ld 1 ,
-.Xr elf 5
+.Xr elf 5 ,
 .Xr ld.so 8
 .
 .\"=============================================================================

elf/arch-alpha.cc

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

elf/arch-hppa32.cc

@@ -0,0 +1,506 @@
+// HP/PA (Hewlett-Packard Precision Architecture), also known as PA-RISC,
+// is a RISC ISA developed by HP in the '80s. It was replaced by Itanium
+// which was a joint project between Intel and HP in the early 2000s. No
+// new HP/PA processors have been created after 2005.
+//
+// Thread pointer (TP) is stored to the control register cr27, which is an
+// alias for tr3.
+//
+// $ltp (linkage table pointer) is $r19
+// $dp is $r27
+
+
+#include "mold.h"
+
+namespace mold::elf {
+
+using E = HPPA32;
+
+static u64 RND(u64 x) { return (x + 0x1000) & ~(u64)0x1fff; }
+static u64 L(u64 x) { return x & 0xffff'f800; }
+static u64 R(u64 x) { return x & 0x0000'07ff; }
+static u64 LR(u64 x, u64 a) { return L(x + RND(a)); }
+static u64 RR(u64 x, u64 a) { return R(x + RND(a)) + a - RND(a); }
+
+static u64 get_gp(Context<E> &ctx) {
+  if (ctx.arg.pic)
+    return ctx.gotplt->shdr.sh_addr;
+  return ctx.extra.global->value;
+}
+
+static u32 dis_assemble_17(u32 val) {
+  return ((val & 0x10000) >> 16) |
+         ((val & 0x0f800) << 5)  |
+         ((val & 0x00400) >> 8)  |
+         ((val & 0x003ff) << 3);
+}
+
+static u32 dis_assemble_21(u32 val) {
+  return (bits(val, 6, 2) << 16) | (bits(val, 8, 7) << 14) |
+         (bits(val, 1, 0) << 12) | (bits(val, 19, 9) << 1) |
+         bit(val, 20);
+}
+
+static u32 dis_low_sign_ext(u32 val, u32 len) {
+  return (bits(val, len - 2, 0) << 1) | bit(val, len - 1);
+}
+
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
+
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
+
+template <>
+void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                    u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_PARISC_PCREL32:
+    *(ub32 *)loc = val - this->shdr.sh_addr - offset;
+    break;
+  case R_PARISC_SEGREL32:
+    *(ub32 *)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);
+
+  u64 SB = 0;
+  u64 GP = get_gp(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;
+
+#define S   sym.get_addr(ctx)
+#define A   get_addend(loc, rel)
+#define P   (get_addr() + rel.r_offset)
+#define G   (sym.get_got_idx(ctx) * sizeof(Word<E>))
+#define GOT ctx.got->shdr.sh_addr
+
+    switch (rel.r_type) {
+    case R_PARISC_DIR32:
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
+      break;
+    case R_PARISC_DIR21L:
+      *(ub32 *)loc |= dis_assemble_21(bits(LR(S, A), 31, 11));
+      break;
+    case R_PARISC_DIR14R:
+      *(ub32 *)loc |= dis_low_sign_ext(RR(S, A), 14);
+      break;
+    case R_PARISC_PCREL32: {
+      u64 addr = has_thunk(i) ? get_thunk_addr(i) : S;
+      *(ub32 *)loc = addr + A - P - 8;
+      break;
+    }
+    case R_PARISC_PCREL21L: {
+      u64 addr = has_thunk(i) ? get_thunk_addr(i) : S;
+      *(ub32 *)loc |= dis_assemble_21(bits(addr + A - P - 8, 31, 11));
+      break;
+    }
+    case R_PARISC_PCREL17F: {
+      u64 addr = has_thunk(i) ? get_thunk_addr(i) : S;
+      *(ub32 *)loc |= dis_assemble_17((addr + A - P - 8) >> 2);
+      break;
+    }
+    case R_PARISC_PCREL14R: {
+      u64 addr = has_thunk(i) ? get_thunk_addr(i) : S;
+      *(ub32 *)loc |= dis_low_sign_ext(R(addr - P - 8 + A), 14);
+      break;
+    }
+    case R_PARISC_DPREL21L:
+      *(ub32 *)loc |= dis_assemble_21(bits(LR(S - GP, A), 31, 11));
+      break;
+    case R_PARISC_DPREL14R:
+      *(ub32 *)loc |= dis_low_sign_ext(RR(S - GP, A), 14);
+      break;
+    case R_PARISC_DLTIND21L:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_assemble_21(bits(G + GOT - GP, 31, 11));
+      break;
+    case R_PARISC_DLTIND14R:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_low_sign_ext(R(G + GOT - GP), 14);
+      break;
+    case R_PARISC_SEGREL32:
+      *(ub32 *)loc = S + A - SB;
+      break;
+    case R_PARISC_PLABEL32:
+      if (sym.is_remaining_undef_weak()) {
+        *(ub32 *)loc = 0;
+      } else if (ctx.arg.pic) {
+        if (sym.is_imported)
+          *dynrel++ = ElfRel<E>(P, R_PARISC_PLABEL32, sym.get_dynsym_idx(ctx), 0);
+        else
+          *dynrel++ = ElfRel<E>(P, R_PARISC_PLABEL32, 0, sym.get_opd_addr(ctx) + 2);
+        *(ub32 *)loc = 0;
+      } else {
+        *(ub32 *)loc = sym.get_opd_addr(ctx) + 2;
+      }
+      break;
+    case R_PARISC_TPREL21L:
+      *(ub32 *)loc |= dis_assemble_21(bits(LR(S - ctx.tp_addr, A), 31, 11));
+      break;
+    case R_PARISC_TPREL14R:
+      *(ub32 *)loc |= dis_low_sign_ext(RR(S - ctx.tp_addr, A), 14);
+      break;
+    case R_PARISC_LTOFF_TP21L:
+      assert(A == 0);
+      *(ub32 *)loc |=
+        dis_assemble_21(bits(LR(sym.get_gottp_addr(ctx) - GP, A), 31, 11));
+      break;
+    case R_PARISC_LTOFF_TP14R:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_low_sign_ext(R(sym.get_gottp_addr(ctx) - GP), 14);
+      break;
+    case R_PARISC_TLS_GD21L:
+      assert(A == 0);
+      *(ub32 *)loc |=
+        dis_assemble_21(bits(LR(sym.get_tlsgd_addr(ctx) - GP, A), 31, 11));
+      break;
+    case R_PARISC_TLS_GD14R:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_low_sign_ext(R(sym.get_tlsgd_addr(ctx) - GP), 14);
+      break;
+    case R_PARISC_TLS_LDM21L:
+      assert(A == 0);
+      *(ub32 *)loc |=
+        dis_assemble_21(bits(LR(ctx.got->get_tlsld_addr(ctx) - GP, A), 31, 11));
+      break;
+    case R_PARISC_TLS_LDM14R:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_low_sign_ext(R(ctx.got->get_tlsld_addr(ctx) - GP), 14);
+      break;
+    case R_PARISC_TLS_LDO21L:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_assemble_21(bits(LR(S - ctx.dtp_addr, A), 31, 11));
+      break;
+    case R_PARISC_TLS_LDO14R:
+      assert(A == 0);
+      *(ub32 *)loc |= dis_low_sign_ext(R(S - ctx.dtp_addr), 14);
+      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<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);
+
+#define S (frag ? frag->get_addr(ctx) : sym.get_addr(ctx))
+#define A (frag ? frag_addend : get_addend(loc, rel))
+
+    switch (rel.r_type) {
+    case R_PARISC_DIR32:
+    case R_PARISC_SEGREL32:
+      *(ub32 *)loc = S + A;
+      break;
+    default:
+      Error(ctx) << *this << ": invalid relocation for non-allocated sections: "
+                 << rel;
+    }
+
+#undef S
+#undef A
+  }
+}
+
+template <>
+void InputSection<E>::scan_relocations(Context<E> &ctx) {
+  assert(shdr().sh_flags & SHF_ALLOC);
+
+  this->reldyn_offset = file.num_dynrel * sizeof(ElfRel<E>);
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      Error(ctx) << sym << ": GNU ifunc symbol is not supported on PA-RISC";
+
+    if (sym.is_func()) {
+      switch (rel.r_type) {
+      case R_PARISC_PCREL32:
+      case R_PARISC_PCREL21L:
+      case R_PARISC_PCREL17F:
+      case R_PARISC_PCREL14R:
+      case R_PARISC_PLABEL32:
+        break;
+      default:
+        Error(ctx) << *this << ": " << rel
+                   << " may not refer to a function symbol " << sym;
+      }
+    }
+
+    switch (rel.r_type) {
+    case R_PARISC_DIR32:
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_PARISC_DIR21L:
+    case R_PARISC_DIR14R:
+      scan_absrel(ctx, sym, rel);
+      break;
+    case R_PARISC_PCREL32:
+    case R_PARISC_PCREL21L:
+    case R_PARISC_PCREL17F:
+    case R_PARISC_PCREL14R:
+    case R_PARISC_DPREL21L:
+    case R_PARISC_DPREL14R:
+      if (sym.is_func() || sym.esym().is_undef_weak())
+        sym.flags.fetch_or(NEEDS_OPD, std::memory_order_relaxed);
+      else
+        scan_pcrel(ctx, sym, rel);
+      break;
+    case R_PARISC_DLTIND21L:
+    case R_PARISC_DLTIND14R:
+      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_PARISC_PLABEL32:
+      if (!sym.is_remaining_undef_weak()) {
+        if (ctx.arg.pic)
+          file.num_dynrel++;
+        sym.flags.fetch_or(NEEDS_OPD, std::memory_order_relaxed);
+      }
+      break;
+    case R_PARISC_LTOFF_TP21L:
+    case R_PARISC_LTOFF_TP14R:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_PARISC_TLS_GD21L:
+    case R_PARISC_TLS_GD14R:
+      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_PARISC_TLS_LDM21L:
+    case R_PARISC_TLS_LDM14R:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_PARISC_SEGREL32:
+    case R_PARISC_TPREL21L:
+    case R_PARISC_TPREL14R:
+    case R_PARISC_TLS_LDO21L:
+    case R_PARISC_TLS_LDO14R:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+  u64 gp = get_gp(ctx);
+
+  static const ub32 opd_pic_entry[] = {
+    0x2a60'0000, // addil LR'<OFFSET>, r19, r1
+    0x3436'0000, // ldo   RR'<OFFSET>(r1), r22
+    0x0ec0'1095, // ldw   0(r22), r21
+    0xeaa0'c000, // bv    r0(r21)
+    0x0ec8'1093, // ldw   4(r22), r19
+  };
+
+  static const ub32 opd_nopic_entry[] = {
+    0x2b60'0000, // addil LR'<OFFSET>, dp, r1
+    0x3436'0000, // ldo   RR'<OFFSET>(r1), r22
+    0x0ec0'1095, // ldw   0(r22), r21
+    0xeaa0'c000, // bv    r0(r21)
+    0x0ec8'1093, // ldw   4(r22), r19
+  };
+
+  static const ub32 local_pic_entry[] = {
+    0x2a60'0000, // addil L%0, r19, r1
+    0x3435'0000, // ldo   0(r1), r21
+    0xeaa0'c000, // bv    r0(r21)
+    0x0800'0240, // nop
+    0x0800'0240, // nop
+  };
+
+  static const ub32 local_nopic_entry[] = {
+    0x2b60'0000, // addil L%0, dp, r1
+    0x3435'0000, // ldo   0(r1), r21
+    0xeaa0'c000, // bv    r0(r21)
+    0x0800'0240, // nop
+    0x0800'0240, // nop
+  };
+
+  static_assert(E::thunk_size == sizeof(opd_pic_entry));
+  static_assert(E::thunk_size == sizeof(opd_nopic_entry));
+  static_assert(E::thunk_size == sizeof(local_pic_entry));
+  static_assert(E::thunk_size == sizeof(local_nopic_entry));
+
+  for (i64 i = 0; i < symbols.size(); i++) {
+    ub32 *loc = (ub32 *)(buf + i * E::thunk_size);
+    Symbol<E> &sym = *symbols[i];
+    i64 val;
+
+    if (sym.has_opd(ctx)) {
+      val = sym.get_opd_addr(ctx) - gp;
+      if (ctx.arg.pic)
+        memcpy(loc, opd_pic_entry, E::thunk_size);
+      else
+        memcpy(loc, opd_nopic_entry, E::thunk_size);
+    } else {
+      assert(!sym.is_imported);
+      val = sym.get_addr(ctx) - gp;
+      if (ctx.arg.pic)
+        memcpy(loc, local_pic_entry, E::thunk_size);
+      else
+        memcpy(loc, local_nopic_entry, E::thunk_size);
+    }
+
+    loc[0] |= dis_assemble_21(bits(LR(val, 0), 31, 11));
+    loc[1] |= dis_low_sign_ext(RR(val, 0), 14);
+  }
+}
+
+void HppaOpdSection::add_symbol(Context<E> &ctx, Symbol<E> *sym) {
+  sym->set_opd_idx(ctx, symbols.size());
+  symbols.push_back(sym);
+}
+
+void HppaOpdSection::update_shdr(Context<E> &ctx) {
+  if (!symbols.empty())
+    this->shdr.sh_size = symbols.size() * ENTRY_SIZE + TRAILER_SIZE;
+  this->shdr.sh_link = ctx.extra.opd->shndx;
+}
+
+void HppaOpdSection::copy_buf(Context<E> &ctx) {
+  ub32 *buf = (ub32 *)(ctx.buf + this->shdr.sh_offset);
+  u64 gp = get_gp(ctx);
+
+  memset(buf, 0, this->shdr.sh_size);
+
+  for (i64 i = 0; i < symbols.size(); i++) {
+    Symbol<E> &sym = *symbols[i];
+    if (!ctx.arg.pic && !sym.is_imported) {
+      buf[i * 2] = sym.get_addr(ctx, NO_OPD);
+      buf[i * 2 + 1] = gp;
+    }
+  }
+}
+
+void HppaRelOpdSection::update_shdr(Context<E> &ctx) {
+  this->shdr.sh_link = ctx.extra.opd->shndx;
+
+  if (ctx.arg.pic) {
+    this->shdr.sh_size = ctx.extra.opd->symbols.size() * sizeof(ElfRel<E>);
+  } else {
+    this->shdr.sh_size = 0;
+    for (Symbol<E> *sym : ctx.extra.opd->symbols)
+      if (sym->is_imported)
+        this->shdr.sh_size += sizeof(ElfRel<E>);
+  }
+}
+
+void HppaRelOpdSection::copy_buf(Context<E> &ctx) {
+  ElfRel<E> *rel = (ElfRel<E> *)(ctx.buf + this->shdr.sh_offset);
+
+  for (Symbol<E> *sym : ctx.extra.opd->symbols) {
+    if (ctx.arg.pic || sym->is_imported) {
+      memset(rel, 0, sizeof(*rel));
+      rel->r_offset = sym->get_opd_addr(ctx);
+      rel->r_type = R_PARISC_IPLT;
+      if (sym->is_imported)
+        rel->r_sym = sym->get_dynsym_idx(ctx);
+      else
+        rel->r_addend = sym->get_addr(ctx, NO_OPD);
+      rel++;
+    }
+  }
+
+  // This code stub must immediately follow the OPD element that the last
+  // .rela.plt relocation refers to, because that's how the runtime finds
+  // this piece of code on process startup.
+  //
+  // The code stub loads the _dl_runtime_resolve address to $r20 call the
+  // function with its GP in $r19. The magic bytes, 0xc0ffee and 0xdeadbeef,
+  // are used by the runtime to identify this code stub, so they must be
+  // exactly that bytes.
+  //
+  // HPPA's runtime assumes that this stub is immediately followed by .got.
+  // The files created by mold don't actually satisfy that constraint
+  // because we don't intermix executable code and data. So, instead, we
+  // reserve three padding words after the code stub and set
+  // _GLOBAL_OFFSET_TABLE_ there as if that particular place is the
+  // beginning of a .got. This trick works because the runtime only uses
+  // _GLOBAL_OFFSET_TABLE_ to access GOT[1],
+  //
+  // Due to the existence of this code stub, .opd must be readable,
+  // writable and executable. Writable executable segment is bad from the
+  // security standpoint, but we have no choice other than doing it.
+  //
+  // https://sourceware.org/git/?p=glibc.git;f=sysdeps/hppa/dl-machine.h;h=1d5194856601e025c#l223
+  ub32 insn[] = {
+    0x0e80'1095, // 1: ldw 0(r20), r21
+    0xeaa0'c000, //    bv r0(r21)
+    0x0e88'1095, //    ldw 4(r20), r21
+    0xea9f'1fdd, //    b,l 1b, r20
+    0xd680'1c1e, //    depwi 0, 31, 2, r20
+    0x00c0'ffee, //    (_dl_runtime_resolve's address)
+    0xdead'beef, //    (%r19 for _dl_runtime_resolve)
+    0x0000'0000, //    (_GLOBAL_OFFSET_TABLE_ is set to here)
+    0x0000'0000, //    (runtime uses this word to identify this ELF module)
+    0x0000'0000, //    (padding)
+  };
+
+  memcpy(ctx.buf + this->shdr.sh_offset +
+         ctx.extra.opd->symbols.size() * sizeof(ElfRel<E>),
+         insn, sizeof(insn));
+}
+
+} // namespace mold::elf

elf/arch-i386.cc

@@ -1,247 +1,323 @@
+// 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/mold/wiki/i386-psabi.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;
-  }
-}
-
-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;
-
-  if (ctx.arg.pic) {
-    static const u8 data[] = {
-      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
-    };
-    memcpy(ent, data, sizeof(data));
-    *(u32 *)(ent + 2) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
-  } else {
-    static const u8 data[] = {
-      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
-    };
-    memcpy(ent, data, sizeof(data));
-    *(u32 *)(ent + 2) = 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;
-
-  if (ctx.arg.pic) {
-    static const u8 data[] = {
-      0xff, 0xa3, 0, 0, 0, 0, // jmp   *foo@GOT(%ebx)
-      0x66, 0x90,             // nop
-    };
-
-    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;
-    }
-  } else {
-    static const u8 data[] = {
-      0xff, 0x25, 0, 0, 0, 0, // jmp   *foo@GOT
-      0x66, 0x90,             // nop
-    };
-
-    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);
-    }
-  }
-}
-
-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;
-
+i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
   switch (rel.r_type) {
   case R_386_NONE:
-    return;
+    return 0;
+  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:
-    *(u32 *)loc = val;
-    return;
   case R_386_PC32:
-    *(u32 *)loc = val - this->shdr.sh_addr - offset;
-    return;
+  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;
   }
   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;
+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 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)
+      0xcc,                   // (padding)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 11) = sym.get_gotplt_addr(ctx) - ctx.got->shdr.sh_addr;
+  } else {
+    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
+      0xcc,                   // (padding)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 11) = sym.get_gotplt_addr(ctx);
+  }
+
+  *(ul32 *)(buf + 5) = 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[] = {
+      0xf3, 0x0f, 0x1e, 0xfb,             // endbr32
+      0xff, 0xa3, 0, 0, 0, 0,             // jmp *foo@GOT(%ebx)
+      0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // (padding)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx) - ctx.got->shdr.sh_addr;
+  } else {
+    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)
+    };
+    memcpy(buf, insn, sizeof(insn));
+    *(ul32 *)(buf + 6) = sym.get_got_addr(ctx);
+  }
+}
+
+template <>
+void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                    u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_386_32:
+    *(ul32 *)loc = val;
+    break;
+  case R_386_PC32:
+    *(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;
+}
+
+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);
+                           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;
-    case R_386_16:
-      write16(S + A);
-      continue;
+    case R_386_8: {
+      i64 val = S + A;
+      check(val, 0, 1 << 8);
+      *loc = val;
+      break;
+    }
+    case R_386_16: {
+      i64 val = S + A;
+      check(val, 0, 1 << 16);
+      *(ul16 *)loc = val;
+      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;
-    case R_386_PC8:
-      write8s(S + A);
-      continue;
-    case R_386_PC16:
-      write16s(S + A);
-      continue;
+      apply_dyn_absrel(ctx, sym, rel, loc, S, A, P, dynrel);
+      break;
+    case R_386_PC8: {
+      i64 val = S + A - P;
+      check(val, -(1 << 7), 1 << 7);
+      *loc = val;
+      break;
+    }
+    case R_386_PC16: {
+      i64 val = S + A - P;
+      check(val, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = val;
+      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) {
+      if (sym.has_tlsgd(ctx)) {
+        *(ul32 *)loc = sym.get_tlsgd_addr(ctx) + A - GOT;
+      } else {
         // Relax GD to LE
         switch (rels[i + 1].r_type) {
-        case R_386_PLT32: {
+        case R_386_PLT32:
+        case R_386_PC32: {
           static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %rax
-            0x81, 0xe8, 0, 0, 0, 0, // add $0, %rax
+            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
+            0x81, 0xe8, 0, 0, 0, 0, // sub $val, %eax
           };
           memcpy(loc - 3, insn, sizeof(insn));
-          *(u32 *)(loc + 5) = ctx.tls_end - S - A;
+          *(ul32 *)(loc + 5) = ctx.tp_addr - S - A;
           break;
         }
-        case R_386_GOT32: {
+        case R_386_GOT32:
+        case R_386_GOT32X: {
           static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %rax
-            0x81, 0xe8, 0, 0, 0, 0, // add $0, %rax
+            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
+            0x81, 0xe8, 0, 0, 0, 0, // sub $val, %eax
           };
           memcpy(loc - 2, insn, sizeof(insn));
-          *(u32 *)(loc + 6) = ctx.tls_end - S - A;
+          *(ul32 *)(loc + 6) = ctx.tp_addr - S - A;
           break;
         }
         default:
@@ -249,177 +325,157 @@ void InputSection<E>::apply_reloc_alloc(Context<E> &ctx, u8 *base) {
         }
 
         i++;
-      } else {
-        write32(sym.get_tlsgd_addr(ctx) + A - GOT);
       }
-      continue;
+      break;
     case R_386_TLS_LDM:
-      if (ctx.got->tlsld_idx == -1) {
+      if (ctx.got->has_tlsld(ctx)) {
+        *(ul32 *)loc = ctx.got->get_tlsld_addr(ctx) + A - GOT;
+      } else {
         // Relax LD to LE
         switch (rels[i + 1].r_type) {
-        case R_386_PLT32: {
+        case R_386_PLT32:
+        case R_386_PC32: {
           static const u8 insn[] = {
-            0x65, 0xa1, 0, 0, 0, 0, // mov %gs:0, %eax
-            0x8d, 0x74, 0x26, 0x00, // lea (%esi,1), %esi
+            0x31, 0xc0,             // xor %eax, %eax
+            0x65, 0x8b, 0x00,       // mov %gs:(%eax), %eax
+            0x81, 0xe8, 0, 0, 0, 0, // sub $tls_size, %eax
+          };
+          memcpy(loc - 2, insn, sizeof(insn));
+          break;
+        }
+        case R_386_GOT32:
+        case R_386_GOT32X: {
+          static const u8 insn[] = {
+            0x31, 0xc0,             // xor %eax, %eax
+            0x65, 0x8b, 0x00,       // mov %gs:(%eax), %eax
+            0x81, 0xe8, 0, 0, 0, 0, // sub $tls_size, %eax
             0x90,                   // nop
           };
           memcpy(loc - 2, insn, sizeof(insn));
           break;
         }
-        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();
         }
 
+        *(ul32 *)(loc + 5) = ctx.tp_addr - ctx.tls_begin;
         i++;
-      } else {
-        write32(ctx.got->get_tlsld_addr(ctx) + A - GOT);
       }
-      continue;
+      break;
     case R_386_TLS_LDO_32:
-      if (ctx.got->tlsld_idx == -1)
-        write32(S + A - ctx.tls_end);
-      else
-        write32(S + A - ctx.tls_begin);
-      continue;
+      *(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) {
+      if (sym.has_tlsdesc(ctx)) {
+        *(ul32 *)loc = sym.get_tlsdesc_addr(ctx) + A - GOT;
+      } else {
         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);
-      } else {
-        write32(sym.get_tlsdesc_addr(ctx) + A - GOT);
+        *(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)
       continue;
 
     Symbol<E> &sym = *file.symbols[rel.r_sym];
     u8 *loc = base + rel.r_offset;
 
     if (!sym.file) {
-      report_undef(ctx, file, sym);
+      record_undef_error(ctx, rel);
       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;
-    case R_386_16:
-      write16(S + A);
-      continue;
+    case R_386_8: {
+      i64 val = S + A;
+      check(val, 0, 1 << 8);
+      *loc = val;
+      break;
+    }
+    case R_386_16: {
+      i64 val = S + A;
+      check(val, 0, 1 << 16);
+      *(ul16 *)loc = val;
+      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;
-    case R_386_PC8:
-      write8s(S + A);
-      continue;
-    case R_386_PC16:
-      write16s(S + A);
-      continue;
+        *(ul32 *)loc = S + A;
+      break;
+    case R_386_PC8: {
+      i64 val = S + A;
+      check(val, -(1 << 7), 1 << 7);
+      *loc = val;
+      break;
+    }
+    case R_386_PC16: {
+      i64 val = S + A;
+      check(val, -(1 << 15), 1 << 15);
+      *(ul16 *)loc = val;
+      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 +484,89 @@ 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)
       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);
+      record_undef_error(ctx, rel);
       continue;
     }
 
-    if (sym.get_type() == STT_GNU_IFUNC) {
-      sym.flags |= NEEDS_GOT;
-      sym.flags |= NEEDS_PLT;
-    }
+    if (sym.is_ifunc())
+      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
 
     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;
+      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
       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: {
+      bool do_relax = ctx.arg.relax && !sym.is_imported &&
+                      sym.is_relative() && relax_got32x(loc - 2);
+      if (!do_relax)
+        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
       break;
     }
+    case R_386_PLT32:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
     case R_386_TLS_GOTIE:
     case R_386_TLS_LE:
     case R_386_TLS_IE:
-      sym.flags |= NEEDS_GOTTP;
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
       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)
+          ty != R_386_PLT32 && ty != R_386_PC32 &&
+          ty != R_386_GOT32 && ty != R_386_GOT32X)
         Fatal(ctx) << *this << ": TLS_GD reloc must be followed by PLT or GOT32";
 
-      if (ctx.arg.relax && !ctx.arg.shared && !sym.is_imported)
+      if (relax_tlsgd(ctx, sym))
         i++;
       else
-        sym.flags |= NEEDS_TLSGD;
+        sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
       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)
+          ty != R_386_PLT32 && ty != R_386_PC32 &&
+          ty != R_386_GOT32 && ty != R_386_GOT32X)
         Fatal(ctx) << *this << ": TLS_LDM reloc must be followed by PLT or GOT32";
 
-      if (ctx.arg.relax && !ctx.arg.shared)
+      if (relax_tlsld(ctx))
         i++;
       else
-        ctx.needs_tlsld = true;
+        ctx.needs_tlsld.store(true, std::memory_order_relaxed);
       break;
     case R_386_TLS_GOTDESC:
-      if (!ctx.arg.relax || ctx.arg.shared)
-        sym.flags |= NEEDS_TLSDESC;
+      if (!relax_tlsdesc(ctx, sym))
+        sym.flags.fetch_or(NEEDS_TLSDESC, std::memory_order_relaxed);
       break;
     case R_386_GOTOFF:
     case R_386_TLS_LDO_32:

elf/arch-m68k.cc

@@ -0,0 +1,333 @@
+// 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/mold/wiki/m68k-psabi.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_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)
+      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_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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      Error(ctx) << sym << ": GNU ifunc symbol is not supported on m68k";
+
+    switch (rel.r_type) {
+    case R_68K_32:
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_68K_16:
+    case R_68K_8:
+      scan_absrel(ctx, sym, rel);
+      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.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_68K_PLT32:
+    case R_68K_PLT16:
+    case R_68K_PLT8:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_68K_TLS_GD32:
+    case R_68K_TLS_GD16:
+    case R_68K_TLS_GD8:
+      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_68K_TLS_LDM32:
+    case R_68K_TLS_LDM16:
+    case R_68K_TLS_LDM8:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_68K_TLS_IE32:
+    case R_68K_TLS_IE16:
+    case R_68K_TLS_IE8:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_68K_TLS_LDO32:
+    case R_68K_TLS_LDO16:
+    case R_68K_TLS_LDO8:
+    case R_68K_TLS_LE32:
+    case R_68K_TLS_LE16:
+    case R_68K_TLS_LE8:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-ppc32.cc

@@ -0,0 +1,465 @@
+// 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 are 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/mold/wiki/ppc32-psabi.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; }
+static u64 higher(u64 x)   { return (x >> 32) & 0xffff; }
+static u64 highera(u64 x)  { return ((x + 0x8000) >> 32) & 0xffff; }
+static u64 highest(u64 x)  { return x >> 48; }
+static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
+
+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_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 = 0;
+  if (file.ppc32_got2)
+    got2 = file.ppc32_got2->output_section->shdr.sh_addr + file.ppc32_got2->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;
+
+    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 - got2 - A);
+      break;
+    case R_PPC_PLT16_HI:
+      *(ub16 *)loc = hi(G + GOT - got2 - A);
+      break;
+    case R_PPC_PLT16_HA:
+      *(ub16 *)loc = ha(G + GOT - got2 - A);
+      break;
+    case R_PPC_PLT32:
+      *(ub32 *)loc = G + GOT - got2 - A;
+      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)
+      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_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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+
+    switch (rel.r_type) {
+    case R_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.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_PPC_REL24:
+    case R_PPC_PLTREL24:
+    case R_PPC_PLTREL32:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_PPC_GOT_TLSGD16:
+      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_PPC_GOT_TLSLD16:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_PPC_GOT_TPREL16:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_PPC_LOCAL24PC:
+    case R_PPC_TLS:
+    case R_PPC_TLSGD:
+    case R_PPC_TLSLD:
+    case R_PPC_TPREL16_LO:
+    case R_PPC_TPREL16_HI:
+    case R_PPC_TPREL16_HA:
+    case R_PPC_DTPREL16_LO:
+    case R_PPC_DTPREL16_HI:
+    case R_PPC_DTPREL16_HA:
+    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) {
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+
+  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));
+
+  for (i64 i = 0; i < symbols.size(); i++) {
+    ub32 *loc = (ub32 *)(buf + i * E::thunk_size);
+    Symbol<E> &sym = *symbols[i];
+
+    if (sym.has_plt(ctx)) {
+      memcpy(loc, plt_entry, sizeof(plt_entry));
+      u64 got = sym.has_got(ctx) ? sym.get_got_addr(ctx) : sym.get_gotplt_addr(ctx);
+      i64 val = got - get_addr(i) - 8;
+      loc[4] |= higha(val);
+      loc[5] |= lo(val);
+    } else {
+      memcpy(loc, local_thunk, sizeof(local_thunk));
+      i64 val = sym.get_addr(ctx) - get_addr(i) - 8;
+      loc[4] |= higha(val);
+      loc[5] |= lo(val);
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-ppc64v1.cc

@@ -0,0 +1,653 @@
+// 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 the entry point of a function but
+// instead refers a data structure so-called "function descriptor".
+//
+// The function descriptor is essentially a pair of a function entry point
+// address and a value that should be set to %r2 before calling that
+// function. There is actually a third member, but we don't need to know
+// what that is. In total, the function descriptor is 24 bytes long. Here
+// is why we need it.
+//
+// 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 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 the address of a function as a
+// function pointer.
+
+#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; }
+static u64 higher(u64 x)   { return (x >> 32) & 0xffff; }
+static u64 highera(u64 x)  { return ((x + 0x8000) >> 32) & 0xffff; }
+static u64 highest(u64 x)  { return x >> 48; }
+static u64 highesta(u64 x) { return (x + 0x8000) >> 48; }
+
+// .plt is used only for lazy symbol resolution on PPC64. All PLT
+// calls are made via range extension thunks even if they are within
+// reach. Thunks read addresses from .got.plt and jump there.
+// Therefore, once PLT symbols are resolved and final addresses are
+// written to .got.plt, thunks just skip .plt and directly jump to the
+// resolved addresses.
+template <>
+void write_plt_header(Context<E> &ctx, u8 *buf) {
+  static const ub32 insn[] = {
+    0x7d88'02a6, // mflr    r12
+    0x429f'0005, // bcl     20, 31, 4 // obtain PC
+    0x7d68'02a6, // mflr    r11
+    0xe84b'0024, // ld      r2,36(r11)
+    0x7d88'03a6, // mtlr    r12
+    0x7d62'5a14, // add     r11,r2,r11
+    0xe98b'0000, // ld      r12,0(r11)
+    0xe84b'0008, // ld      r2,8(r11)
+    0x7d89'03a6, // mtctr   r12
+    0xe96b'0010, // ld      r11,16(r11)
+    0x4e80'0420, // bctr
+    // .quad .got.plt - .plt - 8
+    0x0000'0000,
+    0x0000'0000,
+  };
+
+  static_assert(sizeof(insn) == E::plt_hdr_size);
+  memcpy(buf, insn, sizeof(insn));
+  *(ub64 *)(buf + 44) = ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 8;
+}
+
+template <>
+void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
+  i64 offset = ctx.plt->shdr.sh_addr - sym.get_plt_addr(ctx) - 4;
+  *(ub32 *)(buf + 0) = 0x3800'0000 | sym.get_plt_idx(ctx);   // li %r0, PLT_INDEX
+  *(ub32 *)(buf + 4) = 0x4b00'0000 | (offset & 0x00ff'ffff); // b  plt0
+}
+
+// .plt.got is not necessary on PPC64 because range extension thunks
+// directly read GOT entries and jump there.
+template <>
+void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
+
+template <>
+void EhFrameSection<E>::apply_reloc(Context<E> &ctx, const ElfRel<E> &rel,
+                                    u64 offset, u64 val) {
+  u8 *loc = ctx.buf + this->shdr.sh_offset + offset;
+
+  switch (rel.r_type) {
+  case R_NONE:
+    break;
+  case R_PPC64_ADDR64:
+    *(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: {
+      i64 val = S + A - TOC;
+      check(val, -(1 << 15), 1 << 15);
+      *(ub16 *)loc |= val & 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_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_TPREL16_HA:
+      *(ub16 *)loc = ha(S + A - ctx.tp_addr);
+      break;
+    case R_PPC64_DTPREL16_LO:
+      *(ub16 *)loc = lo(S + A - ctx.dtp_addr);
+      break;
+    case R_PPC64_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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
+
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : (i64)rel.r_addend;
+
+    switch (rel.r_type) {
+    case R_PPC64_ADDR64:
+      if (std::optional<u64> val = get_tombstone(sym, frag))
+        *(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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT | NEEDS_OPD,
+                         std::memory_order_relaxed);
+
+    // Any relocation except R_PPC64_REL24 is considered as an
+    // address-taking relocation.
+    if (rel.r_type != R_PPC64_REL24 && sym.get_type() == STT_FUNC)
+      sym.flags.fetch_or(NEEDS_OPD, std::memory_order_relaxed);
+
+    switch (rel.r_type) {
+    case R_PPC64_ADDR64:
+      scan_toc_rel(ctx, sym, rel);
+      break;
+    case R_PPC64_TOC:
+      scan_toc_rel(ctx, sym, rel);
+      break;
+    case R_PPC64_GOT_TPREL16_HA:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_PPC64_REL24:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_PPC64_PLT16_HA:
+      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_PPC64_GOT_TLSGD16_HA:
+      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_PPC64_GOT_TLSLD16_HA:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_PPC64_REL64:
+    case R_PPC64_TOC16_HA:
+    case R_PPC64_TOC16_LO:
+    case R_PPC64_TOC16_LO_DS:
+    case R_PPC64_TOC16_DS:
+    case R_PPC64_REL16_HA:
+    case R_PPC64_REL16_LO:
+    case R_PPC64_PLT16_HI:
+    case R_PPC64_PLT16_LO:
+    case R_PPC64_PLT16_LO_DS:
+    case R_PPC64_PLTSEQ:
+    case R_PPC64_PLTCALL:
+    case R_PPC64_TPREL16_HA:
+    case R_PPC64_TPREL16_LO:
+    case R_PPC64_GOT_TPREL16_LO_DS:
+    case R_PPC64_GOT_TLSGD16_LO:
+    case R_PPC64_GOT_TLSLD16_LO:
+    case R_PPC64_TLS:
+    case R_PPC64_TLSGD:
+    case R_PPC64_TLSLD:
+    case R_PPC64_DTPREL16_HA:
+    case R_PPC64_DTPREL16_LO:
+      break;
+    default:
+      Error(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+template <>
+void RangeExtensionThunk<E>::copy_buf(Context<E> &ctx) {
+  u8 *buf = ctx.buf + output_section.shdr.sh_offset + offset;
+
+  // If the destination is .plt.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));
+
+  for (i64 i = 0; i < symbols.size(); i++) {
+    Symbol<E> &sym = *symbols[i];
+    ub32 *loc = (ub32 *)(buf + i * E::thunk_size);
+
+    if (sym.has_got(ctx)) {
+      memcpy(loc, pltgot_thunk, sizeof(pltgot_thunk));
+      i64 val = sym.get_got_addr(ctx) - ctx.extra.TOC->value;
+      loc[1] |= higha(val);
+      loc[2] |= lo(val);
+    } else if(sym.has_plt(ctx)) {
+      memcpy(loc, plt_thunk, sizeof(plt_thunk));
+      i64 val = sym.get_gotplt_addr(ctx) - ctx.extra.TOC->value;
+      loc[1] |= higha(val);
+      loc[2] |= lo(val);
+    } else {
+      memcpy(loc, local_thunk, sizeof(local_thunk));
+      i64 val = sym.get_addr(ctx, NO_OPD) - ctx.extra.TOC->value;
+      loc[0] |= higha(val);
+      loc[1] |= lo(val);
+    }
+  }
+}
+
+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(Context<E> &ctx, 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 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 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 an input .opd
+// section so that they refer function symbols instead. We then mark input
+// .opd sections as dead.
+//
+// After this function, we mark symbols with the NEEDS_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(ctx, 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 the function's .opd entry. This function marks such symbols with
+// NEEDS_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_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_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;
+}
+
+void PPC64OpdSection::copy_buf(Context<E> &ctx) {
+  ub64 *buf = (ub64 *)(ctx.buf + this->shdr.sh_offset);
+
+  for (Symbol<E> *sym : symbols) {
+    *buf++ = sym->get_addr(ctx, NO_PLT | NO_OPD);
+    *buf++ = ctx.extra.TOC->value;
+    *buf++ = 0;
+  }
+}
+
+} // namespace mold::elf

elf/arch-ppc64v2.cc

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

elf/arch-riscv.cc

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

elf/arch-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,541 @@
+// 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 a 64-bit i386 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)
+//
+// TLS is supported on s390x in the same way as it is on other targets
+// with one exeption. On other targets, __tls_get_addr is used to get an
+// address of a thread-local variable. On s390x, __tls_get_offset is used
+// instead. The difference is __tls_get_offset returns an address of a
+// thread-local variable as an offset from TP. So we need to add TP to a
+// return value before use. I don't know why it is different, but that is
+// the way it is.
+//
+// https://github.com/IBM/s390x-abi/releases/download/v1.6/lzsabi_s390x.pdf
+
+#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[] = {
+    0xe3, 0x00, 0xf0, 0x38, 0x00, 0x24, // stg   %r0, 56(%r15)
+    0xc0, 0x10, 0, 0, 0, 0,             // larl  %r1, GOTPLT_OFFSET
+    0xd2, 0x07, 0xf0, 0x30, 0x10, 0x08, // mvc   48(8, %r15), 8(%r1)
+    0xe3, 0x10, 0x10, 0x10, 0x00, 0x04, // lg    %r1, 16(%r1)
+    0x07, 0xf1,                         // br    %r1
+    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 8) = (ctx.gotplt->shdr.sh_addr - ctx.plt->shdr.sh_addr - 6) >> 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)
+    0xc0, 0x01, 0, 0, 0, 0,             // lgfi  %r0, PLT_INDEX
+    0x07, 0xf1,                         // br    %r1
+    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
+    0x07, 0x00, 0x07, 0x00, 0x07, 0x00, // nopr; nopr; nopr
+  };
+
+  memcpy(buf, insn, sizeof(insn));
+  *(ub32 *)(buf + 2) = (sym.get_gotplt_addr(ctx) - sym.get_plt_addr(ctx)) >> 1;
+  *(ub32 *)(buf + 14) = sym.get_plt_idx(ctx) * sizeof(ElfRel<E>);
+}
+
+template <>
+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_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: {
+      i64 val = S + A;
+      check(val, 0, 1 << 8);
+      *loc = val;
+      break;
+    }
+    case R_390_12: {
+      i64 val = S + A;
+      check(val, 0, 1 << 12);
+      *(ul16 *)loc = bits(val, 11, 0);
+      break;
+    }
+    case R_390_16: {
+      i64 val = S + A;
+      check(val, 0, 1 << 16);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_390_20: {
+      i64 val = S + A;
+      check(val, 0, 1 << 20);
+      write_mid20(loc, val);
+      break;
+    }
+    case R_390_32:
+    case R_390_PLT32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_390_PLT64:
+      *(ub64 *)loc = S + A;
+      break;
+    case R_390_PC12DBL:
+    case R_390_PLT12DBL: {
+      i64 val = S + A - P;
+      check_dbl(val, -(1 << 12), 1 << 12);
+      *(ul16 *)loc = (val >> 1) & 0x0fff;
+      break;
+    }
+    case R_390_PC16: {
+      i64 val = S + A - P;
+      check(val, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_390_PC32: {
+      i64 val = S + A - P;
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_390_PC64:
+      *(ub64 *)loc = S + A - P;
+      break;
+    case R_390_PC16DBL:
+    case R_390_PLT16DBL: {
+      i64 val = S + A - P;
+      check_dbl(val, -(1 << 16), 1 << 16);
+      *(ub16 *)loc = val >> 1;
+      break;
+    }
+    case R_390_PC24DBL:
+    case R_390_PLT24DBL: {
+      i64 val = S + A - P;
+      check_dbl(val, -(1 << 24), 1 << 24);
+      *(ub32 *)loc |= bits(val, 24, 1);
+      break;
+    }
+    case R_390_PC32DBL:
+    case R_390_PLT32DBL:
+      if (ctx.is_static && &sym == ctx.tls_get_offset) {
+        // __tls_get_offset() in libc.a is stub code that calls abort().
+        // So we provide a replacement function.
+        *(ub32 *)loc = (ctx.extra.tls_get_offset->shdr.sh_addr - P) >> 1;
+      } else {
+        i64 val = S + A - P;
+        check_dbl(val, -(1LL << 32), 1LL << 32);
+        *(ub32 *)loc = val >> 1;
+      }
+      break;
+    case R_390_GOT12:
+    case R_390_GOTPLT12: {
+      i64 val = G + A;
+      check(val, 0, 1 << 12);
+      *(ul16 *)loc = bits(val, 11, 0);
+      break;
+    }
+    case R_390_GOT16:
+    case R_390_GOTPLT16: {
+      i64 val = G + A;
+      check(val, 0, 1 << 16);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_390_GOT20:
+    case R_390_GOTPLT20: {
+      i64 val = G + A;
+      check(val, 0, 1 << 20);
+      write_mid20(loc, val);
+      break;
+    }
+    case R_390_GOT32:
+    case R_390_GOTPLT32: {
+      i64 val = G + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_390_GOT64:
+    case R_390_GOTPLT64:
+      *(ub64 *)loc = G + A;
+      break;
+    case R_390_GOTOFF16:
+    case R_390_PLTOFF16: {
+      i64 val = S + A - GOT;
+      check(val, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_390_GOTOFF32:
+    case R_390_PLTOFF32: {
+      i64 val = S + A - GOT;
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = val;
+      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: {
+      i64 val = GOT + A - P;
+      check_dbl(val, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = val >> 1;
+      break;
+    }
+    case R_390_GOTENT: {
+      i64 val = GOT + G + A - P;
+      check(val, -(1LL << 32), 1LL << 32);
+      *(ub32 *)loc = val >> 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
+        *(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
+        *(ub64 *)loc = S + A - ctx.tp_addr;
+      break;
+    case R_390_TLS_GDCALL:
+      if (!sym.has_tlsgd(ctx)) {
+        static u8 nop[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
+        memcpy(loc, nop, sizeof(nop));
+      }
+      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)) {
+        static u8 nop[] = { 0xc0, 0x04, 0x00, 0x00, 0x00, 0x00 };
+        memcpy(loc, nop, sizeof(nop));
+      }
+      break;
+    default:
+      unreachable();
+    }
+  }
+}
+
+template <>
+void InputSection<E>::apply_reloc_nonalloc(Context<E> &ctx, u8 *base) {
+  std::span<const ElfRel<E>> rels = get_rels(ctx);
+
+  for (i64 i = 0; i < rels.size(); i++) {
+    const ElfRel<E> &rel = rels[i];
+    if (rel.r_type == R_NONE)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
+
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : (i64)rel.r_addend;
+
+    switch (rel.r_type) {
+    case R_390_32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+
+    switch (rel.r_type) {
+    case R_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.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      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.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_390_TLS_GOTIE20:
+    case R_390_TLS_IEENT:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_390_TLS_GD32:
+    case R_390_TLS_GD64:
+      if (!relax_tlsgd(ctx, sym))
+        sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_390_TLS_LDM32:
+    case R_390_TLS_LDM64:
+      if (!relax_tlsld(ctx))
+        ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_390_TLS_LE32:
+    case R_390_TLS_LE64:
+    case R_390_TLS_LDO32:
+    case R_390_TLS_LDO64:
+    case R_390_TLS_GDCALL:
+    case R_390_TLS_LDCALL:
+      break;
+    default:
+      Fatal(ctx) << *this << ": scan_relocations: " << rel;
+    }
+  }
+}
+
+// __tls_get_offset() in libc.a just calls abort(), assuming that the
+// linker always relaxes TLS calls for statically-linkd executables.
+// We don't always do that because we believe --relax and --static
+// should be orthogonal.
+//
+// This section provides a replacement for __tls_get_offset() in libc.a.
+void S390XTlsGetOffsetSection::copy_buf(Context<E> &ctx) {
+  static const u8 insn[] = {
+    0xc0, 0x10, 0, 0, 0, 0,             // larl %r1, GOT
+    0xb9, 0x08, 0x00, 0x21,             // agr  %r2, %r1
+    0xe3, 0x20, 0x20, 0x08, 0x00, 0x04, // lg   %r2, 8(%r2)
+    0xc0, 0x11, 0, 0, 0, 0,             // lgfi %r1, TLS_BLOCK_SIZE
+    0xb9, 0x09, 0x00, 0x21,             // sgr  %r2, %r1
+    0x07, 0xfe,                         // br   %r14
+  };
+
+  assert(this->shdr.sh_size == sizeof(insn));
+
+  u8 *loc = ctx.buf + this->shdr.sh_offset;
+  memcpy(loc, insn, sizeof(insn));
+  *(ub32 *)(loc + 2) = (ctx.got->shdr.sh_addr - this->shdr.sh_addr) >> 1;
+  *(ub32 *)(loc + 18) = ctx.tp_addr - ctx.tls_begin;
+}
+
+} // namespace mold::elf

elf/arch-sh4.cc

@@ -0,0 +1,355 @@
+// 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.
+//
+// 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_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)
+      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 : 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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      Error(ctx) << sym << ": GNU ifunc symbol is not supported on sh4";
+
+    switch (rel.r_type) {
+    case R_SH_DIR32:
+      scan_dyn_absrel(ctx, sym, rel);
+      break;
+    case R_SH_REL32:
+      scan_pcrel(ctx, sym, rel);
+      break;
+    case R_SH_GOT32:
+      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_SH_PLT32:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_SH_TLS_GD_32:
+      sym.flags.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_SH_TLS_LD_32:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_SH_TLS_IE_32:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_SH_GOTPC:
+    case R_SH_GOTOFF:
+    case R_SH_TLS_LDO_32:
+    case R_SH_TLS_LE_32:
+      break;
+    default:
+      Fatal(ctx) << *this << ": unknown relocation: " << rel;
+    }
+  }
+}
+
+} // namespace mold::elf

elf/arch-sparc64.cc

@@ -0,0 +1,658 @@
+// 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://docs.oracle.com/cd/E36784_01/html/E36857/chapter6-62988.html
+// https://docs.oracle.com/cd/E19120-01/open.solaris/819-0690/chapter8-40/index.html
+
+#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_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: {
+      i64 val = S + A;
+      check(val, 0, 1 << 5);
+      *(ub32 *)loc |= bits(val, 4, 0);
+      break;
+    }
+    case R_SPARC_6: {
+      i64 val = S + A;
+      check(val, 0, 1 << 6);
+      *(ub32 *)loc |= bits(val, 5, 0);
+      break;
+    }
+    case R_SPARC_7: {
+      i64 val = S + A;
+      check(val, 0, 1 << 7);
+      *(ub32 *)loc |= bits(val, 6, 0);
+      break;
+    }
+    case R_SPARC_8: {
+      i64 val = S + A;
+      check(val, 0, 1 << 8);
+      *(u8 *)loc = val;
+      break;
+    }
+    case R_SPARC_10: {
+      i64 val = S + A;
+      check(val, 0, 1 << 10);
+      *(ub32 *)loc |= bits(val, 9, 0);
+      break;
+    }
+    case R_SPARC_LO10:
+    case R_SPARC_LOPLT10:
+      *(ub32 *)loc |= bits(S + A, 9, 0);
+      break;
+    case R_SPARC_11: {
+      i64 val = S + A;
+      check(val, 0, 1 << 11);
+      *(ub32 *)loc |= bits(val, 10, 0);
+      break;
+    }
+    case R_SPARC_13: {
+      i64 val = S + A;
+      check(val, 0, 1 << 13);
+      *(ub32 *)loc |= bits(val, 12, 0);
+      break;
+    }
+    case R_SPARC_16:
+    case R_SPARC_UA16: {
+      i64 val = S + A;
+      check(val, 0, 1 << 16);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_SPARC_22: {
+      i64 val = S + A;
+      check(val, 0, 1 << 22);
+      *(ub32 *)loc |= bits(val, 21, 0);
+      break;
+    }
+    case R_SPARC_32:
+    case R_SPARC_UA32:
+    case R_SPARC_PLT32: {
+      i64 val = S + A;
+      check(val, 0, 1LL << 32);
+      *(ub32 *)loc = val;
+      break;
+    }
+    case R_SPARC_PLT64:
+    case R_SPARC_UA64:
+    case R_SPARC_REGISTER:
+      *(ub64 *)loc = S + A;
+      break;
+    case R_SPARC_DISP8: {
+      i64 val = S + A - P;
+      check(val, -(1 << 7), 1 << 7);
+      *(u8 *)loc = val;
+      break;
+    }
+    case R_SPARC_DISP16: {
+      i64 val = S + A - P;
+      check(val, -(1 << 15), 1 << 15);
+      *(ub16 *)loc = val;
+      break;
+    }
+    case R_SPARC_DISP32:
+    case R_SPARC_PCPLT32: {
+      i64 val = S + A - P;
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc = val;
+      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: {
+      i64 val = S + A - P;
+      check(val, -(1 << 20), 1 << 20);
+      *(ub32 *)loc |= bits(val, 20, 2);
+      break;
+    }
+    case R_SPARC_WDISP22: {
+      i64 val = S + A - P;
+      check(val, -(1 << 23), 1 << 23);
+      *(ub32 *)loc |= bits(val, 23, 2);
+      break;
+    }
+    case R_SPARC_WDISP30:
+    case R_SPARC_WPLT30: {
+      i64 val = S + A - P;
+      check(val, -(1LL << 31), 1LL << 31);
+      *(ub32 *)loc |= bits(val, 31, 2);
+      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_imported || sym.is_ifunc()) {
+        *(ub32 *)loc |= bits(G, 31, 10);
+      } else if (sym.is_absolute()) {
+        i64 val = S + A;
+        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
+      } else {
+        i64 val = S + A - GOT;
+        *(ub32 *)loc |= bits(val < 0 ? ~val : val, 31, 10);
+      }
+      break;
+    case R_SPARC_GOTDATA_OP_LOX10: {
+      if (sym.is_imported || sym.is_ifunc()) {
+        *(ub32 *)loc |= bits(G, 9, 0);
+      } else if (sym.is_absolute()) {
+        i64 val = S + A;
+        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
+      } else {
+        i64 val = S + A - GOT;
+        *(ub32 *)loc |= bits(val, 9, 0) | (val < 0 ? 0b1'1100'0000'0000 : 0);
+      }
+      break;
+    }
+    case R_SPARC_GOTDATA_OP:
+      if (sym.is_imported || sym.is_ifunc())
+        break;
+
+      if (sym.is_absolute()) {
+        // ldx [ %g2 + %g1 ], %g1  →  nop
+        *(ub32 *)loc = 0x0100'0000;
+      } else {
+        // 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:
+      if (ctx.arg.is_static)
+        *(ub32 *)loc |= bits(ctx.extra.tls_get_addr->shdr.sh_addr + A - P, 31, 2);
+      else
+        *(ub32 *)loc |= bits(ctx.tls_get_addr->get_addr(ctx) + A - P, 31, 2);
+      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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+    u8 *loc = base + rel.r_offset;
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    auto check = [&](i64 val, i64 lo, i64 hi) {
+      if (val < lo || hi <= val)
+        Error(ctx) << *this << ": relocation " << rel << " against "
+                   << sym << " out of range: " << val << " is not in ["
+                   << lo << ", " << hi << ")";
+    };
+
+    SectionFragment<E> *frag;
+    i64 frag_addend;
+    std::tie(frag, frag_addend) = get_fragment(ctx, rel);
+
+    u64 S = frag ? frag->get_addr(ctx) : sym.get_addr(ctx);
+    u64 A = frag ? frag_addend : (i64)rel.r_addend;
+
+    switch (rel.r_type) {
+    case R_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)
+      continue;
+
+    Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+    if (!sym.file) {
+      record_undef_error(ctx, rel);
+      continue;
+    }
+
+    if (sym.is_ifunc())
+      sym.flags.fetch_or(NEEDS_GOT | NEEDS_PLT, std::memory_order_relaxed);
+
+    switch (rel.r_type) {
+    case R_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.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      break;
+    case R_SPARC_GOT13:
+    case R_SPARC_GOT10:
+    case R_SPARC_GOT22:
+    case R_SPARC_GOTDATA_HIX22:
+      sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      break;
+    case R_SPARC_GOTDATA_OP_HIX22:
+      if (sym.is_imported)
+        sym.flags.fetch_or(NEEDS_GOT, std::memory_order_relaxed);
+      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.fetch_or(NEEDS_TLSGD, std::memory_order_relaxed);
+      break;
+    case R_SPARC_TLS_LDM_HI22:
+      ctx.needs_tlsld.store(true, std::memory_order_relaxed);
+      break;
+    case R_SPARC_TLS_IE_HI22:
+      sym.flags.fetch_or(NEEDS_GOTTP, std::memory_order_relaxed);
+      break;
+    case R_SPARC_TLS_GD_CALL:
+    case R_SPARC_TLS_LDM_CALL:
+      if (!ctx.arg.is_static && ctx.tls_get_addr->is_imported)
+        ctx.tls_get_addr->flags.fetch_or(NEEDS_PLT, std::memory_order_relaxed);
+      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_TLS_LE_HIX22:
+    case R_SPARC_TLS_LE_LOX10:
+    case R_SPARC_SIZE32:
+      break;
+    default:
+      Fatal(ctx) << *this << ": scan_relocations: " << 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/dwarf.cc

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

elf/gc-sections.cc

@@ -10,47 +10,44 @@
 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 && fast_mark(isec->is_visited);
 }
 
 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.
@@ -73,10 +70,9 @@ static void visit(Context<E> &ctx, InputSection<E> *isec,
 }
 
 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))
@@ -102,11 +98,11 @@ collect_root_set(Context<E> &ctx) {
       // 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;
+      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 +128,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 +153,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();
@@ -188,23 +182,16 @@ 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/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 <array>
+#include <cstdio>
 #include <tbb/concurrent_unordered_map.h>
 #include <tbb/concurrent_vector.h>
 #include <tbb/enumerable_thread_specific.h>
@@ -77,6 +90,16 @@ template<> struct hash<Digest> {
 
 namespace mold::elf {
 
+class BitVector {
+public:
+  BitVector(u32 size) : vec((size + 7) / 8) {}
+  bool get(u32 idx) const { return vec[idx / 8] & (1 << (idx % 8)); }
+  void set(u32 idx) { vec[idx / 8] |= 1 << (idx % 8); }
+
+private:
+  std::vector<u8> vec;
+};
+
 template <typename E>
 static void uniquify_cies(Context<E> &ctx) {
   Timer t(ctx, "uniquify_cies");
@@ -98,12 +121,13 @@ 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_exec = (shdr.sh_flags & SHF_EXECINSTR) ||
+                 ctx.arg.ignore_data_address_equality;
   bool is_relro = (name == ".data.rel.ro" ||
                    name.starts_with(".data.rel.ro."));
   bool is_readonly = !(shdr.sh_flags & SHF_WRITE) || is_relro;
@@ -112,15 +136,15 @@ static bool is_eligible(InputSection<E> &isec) {
   bool is_init = (shdr.sh_type == SHT_INIT_ARRAY || name == ".init");
   bool is_fini = (shdr.sh_type == SHT_FINI_ARRAY || name == ".fini");
   bool is_enumerable = is_c_identifier(name);
+  bool is_addr_taken = !ctx.arg.icf_all && isec.address_significant;
 
-  return is_alloc && is_executable && is_readonly && !is_bss &&
-         !is_empty && !is_init && !is_fini && !is_enumerable;
+  return is_alloc && is_exec && is_readonly && !is_bss && !is_empty &&
+         !is_init && !is_fini && !is_enumerable && !is_addr_taken;
 }
 
-static Digest digest_final(SHA256_CTX &sha) {
+static Digest digest_final(SHA256Hash &sha) {
   u8 buf[SHA256_SIZE];
-  int res = SHA256_Final(buf, &sha);
-  assert(res == 1);
+  sha.finish(buf);
 
   Digest digest;
   memcpy(digest.data(), buf, HASH_SIZE);
@@ -139,10 +163,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 +195,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 +213,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 +244,15 @@ 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);
+  SHA256Hash sha;
 
   auto hash = [&](auto val) {
-    SHA256_Update(&sha, &val, sizeof(val));
+    sha.update((u8 *)&val, sizeof(val));
   };
 
   auto hash_string = [&](std::string_view str) {
     hash(str.size());
-    SHA256_Update(&sha, str.data(), str.size());
+    sha.update((u8 *)str.data(), str.size());
   };
 
   auto hash_symbol = [&](Symbol<E> &sym) {
@@ -245,10 +266,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,30 +292,20 @@ 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);
@@ -309,7 +320,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 +335,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 +358,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 +376,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 +395,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 +418,27 @@ 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);
+    SHA256Hash sha;
+    sha.update(digests[2][i].data(), HASH_SIZE);
 
     i64 begin = edge_indices[i];
     i64 end = (i + 1 == num_digests) ? edges.size() : edge_indices[i + 1];
 
     for (i64 j : edges.subspan(begin, end - begin))
-      SHA256_Update(&sha, digests[slot][j].data(), HASH_SIZE);
+      sha.update(digests[slot][j].data(), HASH_SIZE);
 
     digests[!slot][i] = digest_final(sha);
 
-    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 +466,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 +503,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 +512,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 +530,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 +538,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)
@@ -558,7 +590,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 +600,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,13 +24,13 @@ 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);
@@ -36,223 +41,435 @@ InputSection<E>::InputSection(Context<E> &ctx, ObjectFile<E> &file,
                               std::string_view name, i64 shndx)
   : file(file), shndx(shndx) {
   if (shndx < file.elf_sections.size())
-    contents = {(char *)file.mf->data + shdr().sh_offset, 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.
+  if constexpr (!E::is_rela)
+    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) {
-  if (ctx.arg.shared)
-    return 0;
-  if (ctx.arg.pie)
-    return 1;
-  return 2;
-}
-
-template <typename E>
-static i64 get_sym_type(Symbol<E> &sym) {
-  if (sym.is_absolute())
-    return 0;
-  if (!sym.is_imported)
-    return 1;
-  if (sym.get_type() != STT_FUNC)
+static Action get_rel_action(Context<E> &ctx, Symbol<E> &sym,
+                             const Action table[3][4]) {
+  auto get_output_type = [&] {
+    if (ctx.arg.shared)
+      return 0;
+    if (ctx.arg.pie)
+      return 1;
     return 2;
-  return 3;
+  };
+
+  auto get_sym_type = [&] {
+    if (sym.is_absolute())
+      return 0;
+    if (!sym.is_imported)
+      return 1;
+    if (sym.get_type() != STT_FUNC)
+      return 2;
+    return 3;
+  };
+
+  return table[get_output_type()][get_sym_type()];
 }
 
 template <typename E>
-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);
+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) << *this << ": " << rel << " relocation at offset 0x"
+    Error(ctx) << isec << ": " << rel << " relocation at offset 0x"
                << std::hex << rel.r_offset << " against symbol `"
                << sym << "' can not be used; recompile with " << msg;
   };
 
-  auto warn_textrel = [&] {
-    if (ctx.arg.warn_textrel)
-      Warn(ctx) << *this << ": relocation against symbol `" << sym
-                << "' in read-only section";
+  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:
-    return;
+    break;
   case ERROR:
     error();
-    return;
+    break;
   case COPYREL:
-    if (!ctx.arg.z_copyreloc) {
+    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;
+    copyrel();
+    break;
+  case DYN_COPYREL:
+    if (writable || !ctx.arg.z_copyreloc)
+      dynrel();
+    else
+      copyrel();
+    break;
   case PLT:
     sym.flags |= NEEDS_PLT;
-    return;
-  case CPLT: {
-    std::scoped_lock lock(sym.mu);
-    sym.flags |= NEEDS_PLT;
-    sym.is_canonical = true;
-    return;
-  }
+    break;
+  case CPLT:
+    sym.flags |= NEEDS_CPLT;
+    break;
+  case DYN_CPLT:
+    if (writable)
+      dynrel();
+    else
+      sym.flags |= NEEDS_CPLT;
+    break;
   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;
+    dynrel();
+    break;
   case BASEREL:
-    if (!is_writable) {
-      if (ctx.arg.z_text) {
-        error();
-        return;
-      }
-      warn_textrel();
-      ctx.has_textrel = true;
-    }
-
-    if (!is_relr_reloc(ctx, rel))
-      file.num_dynrel++;
-    return;
+    check_textrel();
+    if (!isec.is_relr_reloc(ctx, rel))
+      isec.file.num_dynrel++;
+    break;
+  case IFUNC:
+    dynrel();
+    ctx.num_ifunc_dynrels.fetch_add(1, std::memory_order_relaxed);
+    break;
   default:
     unreachable();
   }
 }
 
+template <typename E>
+static Action get_pcrel_action(Context<E> &ctx, Symbol<E> &sym) {
+  // This is for PC-relative relocations (e.g. R_X86_64_PC32).
+  // We cannot promote them to dynamic relocations because the dynamic
+  // linker generally does not support PC-relative relocations.
+  constexpr static Action table[3][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  ERROR,    NONE,    ERROR,         PLT    },  // Shared object
+    {  ERROR,    NONE,    COPYREL,       PLT    },  // Position-independent exec
+    {  NONE,     NONE,    COPYREL,       CPLT   },  // Position-dependent exec
+  };
+
+  return get_rel_action(ctx, sym, table);
+}
+
+template <typename E>
+static Action get_absrel_action(Context<E> &ctx, Symbol<E> &sym) {
+  // This is a decision table for absolute relocations that is smaller
+  // than the word size (e.g. R_X86_64_32). Since the dynamic linker
+  // generally does not support dynamic relocations smaller than the
+  // word size, we need to report an error if a relocation cannot be
+  // resolved at link-time.
+  constexpr static Action table[3][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  NONE,     ERROR,   ERROR,         ERROR },  // Shared object
+    {  NONE,     ERROR,   ERROR,         ERROR },  // Position-independent exec
+    {  NONE,     NONE,    COPYREL,       CPLT  },  // Position-dependent exec
+  };
+
+  return get_rel_action(ctx, sym, table);
+}
+
+template <typename E>
+static Action get_dyn_absrel_action(Context<E> &ctx, Symbol<E> &sym) {
+  if (sym.is_ifunc())
+    return IFUNC;
+
+  // This is a decision table for absolute relocations for the word
+  // size data (e.g. R_X86_64_64). Unlike the absrel_table, we can emit
+  // a dynamic relocation if we cannot resolve an address at link-time.
+  constexpr static Action table[3][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  NONE,     BASEREL, DYNREL,        DYNREL   },  // Shared object
+    {  NONE,     BASEREL, DYNREL,        DYNREL   },  // Position-independent exec
+    {  NONE,     NONE,    DYN_COPYREL,   DYN_CPLT },  // Position-dependent exec
+  };
+
+  return get_rel_action(ctx, sym, table);
+}
+
+template <typename E>
+static Action get_ppc64_toc_action(Context<E> &ctx, Symbol<E> &sym) {
+  if (sym.is_ifunc())
+    return IFUNC;
+
+  // As a special case, we do not create copy relocations nor canonical
+  // PLTs for .toc sections. PPC64's .toc is a compiler-generated
+  // GOT-like section, and no user-generated code directly uses values
+  // in it.
+  constexpr static Action table[3][4] = {
+    // Absolute  Local    Imported data  Imported code
+    {  NONE,     BASEREL, DYNREL,        DYNREL },  // Shared object
+    {  NONE,     BASEREL, DYNREL,        DYNREL },  // Position-independent exec
+    {  NONE,     NONE,    DYNREL,        DYNREL },  // Position-dependent exec
+  };
+
+  return get_rel_action(ctx, sym, table);
+}
+
+template <typename E>
+void InputSection<E>::scan_pcrel(Context<E> &ctx, Symbol<E> &sym,
+                                 const ElfRel<E> &rel) {
+  scan_rel(ctx, *this, sym, rel, get_pcrel_action(ctx, sym));
+}
+
+template <typename E>
+void InputSection<E>::scan_absrel(Context<E> &ctx, Symbol<E> &sym,
+                                  const ElfRel<E> &rel) {
+  scan_rel(ctx, *this, sym, rel, get_absrel_action(ctx, sym));
+}
+
+template <typename E>
+void InputSection<E>::scan_dyn_absrel(Context<E> &ctx, Symbol<E> &sym,
+                                      const ElfRel<E> &rel) {
+  scan_rel(ctx, *this, sym, rel, get_dyn_absrel_action(ctx, sym));
+}
+
+template <typename E>
+void InputSection<E>::scan_toc_rel(Context<E> &ctx, Symbol<E> &sym,
+                                   const ElfRel<E> &rel) {
+  scan_rel(ctx, *this, sym, rel, get_ppc64_toc_action(ctx, sym));
+}
+
+template <typename E>
+static void apply_absrel(Context<E> &ctx, InputSection<E> &isec,
+                         Symbol<E> &sym, const ElfRel<E> &rel, u8 *loc,
+                         u64 S, i64 A, u64 P, ElfRel<E> *&dynrel,
+                         Action action) {
+  bool writable = (isec.shdr().sh_flags & SHF_WRITE);
+
+  auto apply_dynrel = [&] {
+    *dynrel++ = ElfRel<E>(P, E::R_ABS, sym.get_dynsym_idx(ctx), A);
+    if (ctx.arg.apply_dynamic_relocs)
+      *(Word<E> *)loc = A;
+  };
+
+  switch (action) {
+  case COPYREL:
+  case CPLT:
+  case NONE:
+    *(Word<E> *)loc = S + A;
+    break;
+  case BASEREL:
+    if (isec.is_relr_reloc(ctx, rel)) {
+      *(Word<E> *)loc = S + A;
+    } else {
+      *dynrel++ = ElfRel<E>(P, E::R_RELATIVE, 0, S + A);
+      if (ctx.arg.apply_dynamic_relocs)
+        *(Word<E> *)loc = S + A;
+    }
+    break;
+  case DYN_COPYREL:
+    if (writable || !ctx.arg.z_copyreloc)
+      apply_dynrel();
+    else
+      *(Word<E> *)loc = S + A;
+    break;
+  case DYN_CPLT:
+    if (writable)
+      apply_dynrel();
+    else
+      *(Word<E> *)loc = S + A;
+    break;
+  case DYNREL:
+    apply_dynrel();
+    break;
+  case IFUNC: {
+    u64 addr = sym.get_addr(ctx, NO_PLT) + A;
+    *dynrel++ = ElfRel<E>(P, E::R_IRELATIVE, 0, addr);
+    if (ctx.arg.apply_dynamic_relocs)
+      *(Word<E> *)loc = addr;
+    break;
+  }
+  default:
+    unreachable();
+  }
+}
+
+template <typename E>
+void InputSection<E>::apply_dyn_absrel(Context<E> &ctx, Symbol<E> &sym,
+                                       const ElfRel<E> &rel, u8 *loc,
+                                       u64 S, i64 A, u64 P,
+                                       ElfRel<E> *&dynrel) {
+  apply_absrel(ctx, *this, sym, rel, loc, S, A, P, dynrel,
+               get_dyn_absrel_action(ctx, sym));
+}
+
+template <typename E>
+void InputSection<E>::apply_toc_rel(Context<E> &ctx, Symbol<E> &sym,
+                                    const ElfRel<E> &rel, u8 *loc,
+                                    u64 S, i64 A, u64 P,
+                                    ElfRel<E> *&dynrel) {
+  apply_absrel(ctx, *this, sym, rel, loc, S, A, P, dynrel,
+               get_ppc64_toc_action(ctx, sym));
+}
+
 template <typename E>
 void InputSection<E>::write_to(Context<E> &ctx, u8 *buf) {
   if (shdr().sh_type == SHT_NOBITS || sh_size == 0)
     return;
 
   // Copy data
-  if constexpr (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());
+    uncompress_to(ctx, buf);
   }
 
   // Apply relocations
-  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 (!ctx.arg.relocatable) {
+    if (shdr().sh_flags & SHF_ALLOC)
+      apply_reloc_alloc(ctx, buf);
+    else
+      apply_reloc_nonalloc(ctx, buf);
   }
 }
 
-#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) {
+  for (const ElfSym<E> &esym : file.elf_syms) {
+    if (esym.st_shndx == shndx && esym.st_type == STT_FUNC &&
+        esym.st_value <= offset && offset < esym.st_value + esym.st_size) {
+      std::string_view name = file.symbol_strtab.data() + esym.st_name;
+      if (ctx.arg.demangle)
+        return demangle(name);
+      return name;
+    }
+  }
+  return "";
+}
 
+// Record an undefined symbol error which will be displayed all at
+// once by report_undef_errors().
+template <typename E>
+void InputSection<E>::record_undef_error(Context<E> &ctx, const ElfRel<E> &rel) {
+  std::stringstream ss;
+  if (std::string_view source = file.get_source_name(); !source.empty())
+    ss << ">>> referenced by " << source << "\n";
+  else
+    ss << ">>> referenced by " << *this << "\n";
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+  ss << ">>>               " << file;
+  if (std::string_view func = get_func_name(ctx, rel.r_offset); !func.empty())
+    ss << ":(" << func << ")";
+
+  Symbol<E> &sym = *file.symbols[rel.r_sym];
+
+  typename decltype(ctx.undef_errors)::accessor acc;
+  ctx.undef_errors.insert(acc, {sym.name(), {}});
+  acc->second.push_back(ss.str());
+}
+
+// Report all undefined symbols, grouped by symbol.
+template <typename E>
+void report_undef_errors(Context<E> &ctx) {
+  constexpr i64 max_errors = 3;
+
+  for (auto &pair : ctx.undef_errors) {
+    std::string_view sym_name = pair.first;
+    std::span<std::string> errors = pair.second;
+
+    if (ctx.arg.demangle)
+      sym_name = demangle(sym_name);
+
+    std::stringstream ss;
+    ss << "undefined symbol: " << sym_name << "\n";
+
+    for (i64 i = 0; i < errors.size() && i < max_errors; i++)
+      ss << errors[i];
+
+    if (errors.size() > max_errors)
+      ss << ">>> referenced " << (errors.size() - max_errors) << " more times\n";
+
+    if (ctx.arg.unresolved_symbols == UNRESOLVED_ERROR)
+      Error(ctx) << ss.str();
+    else if (ctx.arg.unresolved_symbols == UNRESOLVED_WARN)
+      Warn(ctx) << ss.str();
+  }
+
+  ctx.checkpoint();
+}
+
+using E = MOLD_TARGET;
+
+template struct CieRecord<E>;
+template class InputSection<E>;
+template void report_undef_errors(Context<E> &);
 
 } // namespace mold::elf

elf/linker-script.cc

@@ -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,7 +279,7 @@ 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) {
+                             std::string_view ver_str, u16 ver_idx, bool is_cpp) {
   bool is_global = true;
 
   while (!tok.empty() && tok[0] != "}") {
@@ -286,11 +299,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, 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, true);
       }
 
       tok = skip(ctx, tok, "}");
@@ -299,11 +312,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 +335,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, false);
     tok = skip(ctx, tok, "}");
     if (!tok.empty() && tok[0] != ";")
       tok = tok.subspan(1);
@@ -338,10 +358,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 +392,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 +414,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,717 @@
+// 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);
+
+  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->symvers.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)
+      return;
+
+    for (i64 i = file->first_global; i < file->symbols.size(); i++) {
+      Symbol<E> &sym = *file->symbols[i];
+
+      if (sym.file && !sym.file->is_dso &&
+          ((ObjectFile<E> *)sym.file)->is_lto_obj) {
+        std::scoped_lock lock(sym.mu);
+        sym.referenced_by_regular_obj = true;
+      }
+    }
+  });
+
+  // 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;
+  }
+
+  // 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 "../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 {
@@ -72,27 +75,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 +152,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,123 @@
 #include "mold.h"
 #include "../archive-file.h"
 #include "../cmdline.h"
+#include "../output-file.h"
 
 #include <cstring>
 #include <functional>
 #include <iomanip>
 #include <map>
+#include <regex>
 #include <signal.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <tbb/global_control.h>
 #include <tbb/parallel_for_each.h>
-#include <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_PARISC:
+      return HPPA32::target_name;
+    default:
+      return "";
+    }
+  };
+
+  bool opt_plugin = !ctx.arg.plugin.empty();
+
+  switch (get_file_type(mf, opt_plugin)) {
+  case FileType::ELF_OBJ:
+  case FileType::ELF_DSO:
+  case FileType::GCC_LTO_OBJ:
+    return get_elf_type(mf->data);
+  case FileType::AR:
+    for (MappedFile<Context<E>> *child : read_fat_archive_members(ctx, mf))
+      if (get_file_type(child, opt_plugin) == FileType::ELF_OBJ)
+        return get_elf_type(child->data);
+    return "";
+  case FileType::THIN_AR:
+    for (MappedFile<Context<E>> *child : read_thin_archive_members(ctx, mf))
+      if (get_file_type(child, opt_plugin) == FileType::ELF_OBJ)
+        return get_elf_type(child->data);
+    return "";
+  case FileType::TEXT:
+    return get_script_output_type(ctx, mf);
+  default:
+    return "";
+  }
+}
+
+template <typename E>
+static void
+check_file_compatibility(Context<E> &ctx, MappedFile<Context<E>> *mf) {
+  std::string_view target = get_machine_type(ctx, mf);
+  if (target != ctx.arg.emulation)
+    Fatal(ctx) << mf->name << ": incompatible file type: "
+               << ctx.arg.emulation << " is expected but got " << target;
+}
+
 template <typename E>
 static ObjectFile<E> *new_object_file(Context<E> &ctx, MappedFile<Context<E>> *mf,
                                       std::string archive_name) {
-  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 +134,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 +150,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,7 +165,8 @@ void read_file(Context<E> &ctx, MappedFile<Context<E>> *mf) {
   if (ctx.visited.contains(mf->name))
     return;
 
-  FileType type = get_file_type(mf);
+  bool opt_plugin = !ctx.arg.plugin.empty();
+  FileType type = get_file_type(mf, opt_plugin);
   switch (type) {
   case FileType::ELF_OBJ:
     ctx.objs.push_back(new_object_file(ctx, mf, ""));
@@ -84,13 +178,14 @@ 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(child, opt_plugin)) {
       case FileType::ELF_OBJ:
         ctx.objs.push_back(new_object_file(ctx, child, mf->name));
         break;
       case FileType::GCC_LTO_OBJ:
       case FileType::LLVM_BITCODE:
-        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;
       default:
         break;
@@ -103,47 +198,23 @@ void read_file(Context<E> &ctx, MappedFile<Context<E>> *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 +224,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 +255,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)));
     }
   }
 
@@ -238,179 +338,73 @@ static void read_input_files(Context<E> &ctx, std::span<std::string_view> args)
   ctx.tg.wait();
 }
 
+// Since elf_main is a template, we can't run it without a type parameter.
+// We speculatively run elf_main with X86_64, and if the speculation was
+// wrong, re-run it with an actual machine type.
 template <typename E>
-static 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;
+static int redo_main(int argc, char **argv, std::string_view target) {
+  if (target == I386::target_name)
+    return elf_main<I386>(argc, argv);
+  if (target == ARM64::target_name)
+    return elf_main<ARM64>(argc, argv);
+  if (target == ARM32::target_name)
+    return elf_main<ARM32>(argc, argv);
+  if (target == RV64LE::target_name)
+    return elf_main<RV64LE>(argc, argv);
+  if (target == RV64BE::target_name)
+    return elf_main<RV64BE>(argc, argv);
+  if (target == RV32LE::target_name)
+    return elf_main<RV32LE>(argc, argv);
+  if (target == RV32BE::target_name)
+    return elf_main<RV32BE>(argc, argv);
+  if (target == PPC32::target_name)
+    return elf_main<PPC32>(argc, argv);
+  if (target == PPC64V1::target_name)
+    return elf_main<PPC64V1>(argc, argv);
+  if (target == PPC64V2::target_name)
+    return elf_main<PPC64V2>(argc, argv);
+  if (target == S390X::target_name)
+    return elf_main<S390X>(argc, argv);
+  if (target == SPARC64::target_name)
+    return elf_main<SPARC64>(argc, argv);
+  if (target == M68K::target_name)
+    return elf_main<M68K>(argc, argv);
+  if (target == SH4::target_name)
+    return elf_main<SH4>(argc, argv);
+  if (target == ALPHA::target_name)
+    return elf_main<ALPHA>(argc, argv);
+  if (target == HPPA32::target_name)
+    return elf_main<HPPA32>(argc, argv);
+  unreachable();
 }
 
 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<E>(argc, argv, ctx.arg.emulation);
 
   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 +412,32 @@ 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
+
+  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;
@@ -466,15 +452,32 @@ static int elf_main(int argc, char **argv) {
   // 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);
+  resolve_section_pieces(ctx);
 
-  // Remove redundant comdat sections (e.g. duplicate inline functions).
-  eliminate_comdats(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 +488,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);
 
+  // Read address-significant section information.
+  if (ctx.arg.icf && !ctx.arg.icf_all)
+    mark_addrsig(ctx);
+
   // Garbage-collect unreachable sections.
   if (ctx.arg.gc_sections)
     gc_sections(ctx);
@@ -499,20 +506,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 +532,33 @@ 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 == 1)
+    print_dependencies(ctx);
+  else if (ctx.arg.print_dependencies == 2)
+    print_dependencies_full(ctx);
+
   // Handle -repro
   if (ctx.arg.repro)
     write_repro_file(ctx);
 
-  // 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 +576,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 +588,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 +614,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);
@@ -619,41 +643,22 @@ static int elf_main(int argc, char **argv) {
   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,35 +669,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);
+  // Copy input sections to the output file and apply relocations.
+  copy_chunks(ctx);
 
   // Some part of .gdb_index couldn't be computed until other debug
   // sections are complete. We have complete debug sections now, so
@@ -707,12 +696,14 @@ static int elf_main(int argc, char **argv) {
   // Zero-clear paddings between sections
   clear_padding(ctx);
 
-  if (ctx.buildid) {
-    Timer t(ctx, "build_id");
+  // .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,12 +712,6 @@ 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);
 
@@ -753,20 +738,41 @@ static int elf_main(int argc, char **argv) {
 
   for (std::function<void()> &fn : ctx.on_exit)
     fn();
+  ctx.checkpoint();
   return 0;
 }
 
+using E = MOLD_TARGET;
+
+template void read_file(Context<E> &, MappedFile<Context<E>> *);
+
+#ifdef MOLD_X86_64
+
+extern template int elf_main<I386>(int, char **);
+extern template int elf_main<ARM32>(int, char **);
+extern template int elf_main<ARM64>(int, char **);
+extern template int elf_main<RV32BE>(int, char **);
+extern template int elf_main<RV32LE>(int, char **);
+extern template int elf_main<RV64LE>(int, char **);
+extern template int elf_main<RV64BE>(int, char **);
+extern template int elf_main<PPC32>(int, char **);
+extern template int elf_main<PPC64V1>(int, char **);
+extern template int elf_main<PPC64V2>(int, char **);
+extern template int elf_main<S390X>(int, char **);
+extern template int elf_main<SPARC64>(int, char **);
+extern template int elf_main<M68K>(int, char **);
+extern template int elf_main<SH4>(int, char **);
+extern template int elf_main<ALPHA>(int, char **);
+extern template int elf_main<HPPA32>(int, char **);
+
 int main(int argc, char **argv) {
   return elf_main<X86_64>(argc, argv);
 }
 
-#define INSTANTIATE(E)                                                  \
-  template void read_file(Context<E> &, MappedFile<Context<E>> *);
+#else
 
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
+template int elf_main<E>(int, char **);
+
+#endif
 
 } // 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) {
@@ -52,10 +67,8 @@ static bool is_ld(const char *path) {
 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 +79,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 +88,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 +97,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 +106,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 +126,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/relocatable.cc

@@ -1,597 +1,197 @@
-// 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 = [&]<typename T>(T *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;
-
-  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);
+  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>);
 }
 
+// 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,291 @@
+// 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.
+
+#include "mold.h"
+
+#include <tbb/parallel_for.h>
+#include <tbb/parallel_for_each.h>
+
+namespace mold::elf {
+
+// Branch reach in bytes.
+//
+// ARM64's branch has 26 bits immediate, and it's scaled by 4 because all
+// instructions are 4 bytes aligned, so it's effectively 28 bits long.
+// That means the range is [-2^27, 2^27).
+//
+// ARM32's Thumb branch has 24 bits immediate, and the instructions are
+// aligned to 2, so it's effectively 25 bits. ARM32's non-Thumb branches
+// have twice longer range than its Thumb counterparts, but we
+// conservatively use the Thumb's limitation.
+//
+// PPC's branch has 24 bits immediate, and the instructions are aligned
+// to 4, therefore 26.
+//
+// Here is the summary of branch instructions reaches:
+//
+//   ARM64: PC ± 128 MiB
+//   ARM32: PC ± 16 MiB
+//   PPC:   PC ± 32 MiB
+template <typename E>
+static consteval i64 max_distance() {
+  if constexpr (is_arm64<E>) {
+    return 1LL << 27;
+  } else if constexpr (is_arm32<E>) {
+    return 1LL << 24;
+  } else if constexpr (is_ppc<E>) {
+    return 1LL << 25;
+  } else {
+    static_assert(is_hppa<E>);
+    return 1LL << 18;
+  }
+}
+
+// We create thunks for each 12.8/1.6/3.2 MiB code block for
+// ARM64/ARM32/PPC, respectively.
+template <typename E>
+static constexpr i64 batch_size = max_distance<E>() / 10;
+
+// We assume that a single thunk group is smaller than 100 KiB.
+static constexpr i64 max_thunk_size = 102400;
+
+// Returns true if a given relocation is of type used for function calls.
+template <typename E>
+static bool needs_thunk_rel(const ElfRel<E> &r) {
+  u32 ty = r.r_type;
+
+  if constexpr (is_arm64<E>) {
+    return ty == R_AARCH64_JUMP26 || ty == R_AARCH64_CALL26;
+  } else if constexpr (is_arm32<E>) {
+    return ty == R_ARM_JUMP24 || ty == R_ARM_THM_JUMP24 ||
+           ty == R_ARM_CALL   || ty == R_ARM_THM_CALL;
+  } else if constexpr (is_ppc32<E>) {
+    return ty == R_PPC_REL24  || ty == R_PPC_PLTREL24 || ty == R_PPC_LOCAL24PC;
+  } else if constexpr (is_ppc64<E>) {
+    return ty == R_PPC64_REL24;
+  } else {
+    static_assert(is_hppa<E>);
+    return ty == R_PARISC_PCREL17F || ty == R_PARISC_PCREL32;
+  }
+}
+
+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))
+      return false;
+  }
+
+  // (TODO)
+  if constexpr (is_hppa<E>)
+    if (sym.has_opd(ctx))
+      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<E>() <= val && val < max_distance<E>();
+}
+
+template <typename E>
+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.
+template <typename E>
+static void scan_rels(Context<E> &ctx, InputSection<E> &isec,
+                      RangeExtensionThunk<E> &thunk) {
+  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 (!needs_thunk_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.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 <typename E>
+void create_range_extension_thunks(Context<E> &ctx, OutputSection<E> &osec) {
+  std::span<InputSection<E> *> m = osec.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.
+  i64 a = 0;
+  i64 b = 0;
+  i64 c = 0;
+  i64 d = 0;
+  i64 offset = 0;
+
+  while (b < m.size()) {
+    // Move D foward as far as we can jump from B to anywhere in a thunk after D.
+    while (d < m.size() &&
+           align_to(offset, 1 << m[d]->p2align) + m[d]->sh_size + max_thunk_size <
+           m[b]->offset + max_distance<E>()) {
+      offset = align_to(offset, 1 << m[d]->p2align);
+      m[d]->offset = offset;
+      offset += m[d]->sh_size;
+      d++;
+    }
+
+    // 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<E>)
+      c++;
+
+    // Move A forward so that A is reachable from C.
+    i64 c_offset = (c == m.size()) ? offset : m[c]->offset;
+    while (a < osec.thunks.size() &&
+           osec.thunks[a]->offset + max_distance<E>() < c_offset)
+      reset_thunk(*osec.thunks[a++]);
+
+    // Create a thunk for input sections between B and C and place it at D.
+    osec.thunks.emplace_back(new RangeExtensionThunk<E>{osec});
+
+    RangeExtensionThunk<E> &thunk = *osec.thunks.back();
+    thunk.thunk_idx = osec.thunks.size() - 1;
+    offset = align_to(offset, thunk.alignment);
+    thunk.offset = offset;
+
+    // Scan relocations between B and C to collect symbols that need thunks.
+    tbb::parallel_for_each(m.begin() + b, m.begin() + c, [&](InputSection<E> *isec) {
+      scan_rels(ctx, *isec, thunk);
+    });
+
+    // Now that we know the number of symbols in the thunk, we can compute
+    // its 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; Symbol<E> *sym : thunk.symbols) {
+      sym->extra.thunk_idx = thunk.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.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 (a < osec.thunks.size())
+    reset_thunk(*osec.thunks[a++]);
+
+  osec.shdr.sh_size = offset;
+}
+
+#if MOLD_ARM32 || MOLD_ARM64 || MOLD_PPC32 || MOLD_PPC64V1 || MOLD_PPC64V2 || MOLD_HPPA32
+using E = MOLD_TARGET;
+template void create_range_extension_thunks(Context<E> &, OutputSection<E> &);
+#endif
+
+} // namespace mold::elf

filepath.cc

@@ -7,7 +7,7 @@ namespace mold {
 
 std::string get_realpath(std::string_view path) {
   std::error_code ec;
-  std::string ret = std::filesystem::canonical(path, ec);
+  std::string ret = std::filesystem::canonical(path, ec).string();
   return ec ? std::string(path) : ret;
 }
 
@@ -15,12 +15,12 @@ std::string get_realpath(std::string_view 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();
 }
 

filetype.h

@@ -11,7 +11,9 @@ enum class FileType {
   ELF_OBJ,
   ELF_DSO,
   MACH_OBJ,
+  MACH_EXE,
   MACH_DYLIB,
+  MACH_BUNDLE,
   MACH_UNIVERSAL,
   AR,
   THIN_AR,
@@ -29,26 +31,42 @@ bool is_text_file(MappedFile<C> *mf) {
 }
 
 template <typename E, typename C>
-inline bool is_gcc_lto_obj(MappedFile<C> *mf) {
+inline bool is_gcc_lto_obj(MappedFile<C> *mf, bool opt_plugin) {
   using namespace mold::elf;
 
   const char *data = mf->get_contents().data();
   ElfEhdr<E> &ehdr = *(ElfEhdr<E> *)data;
+  ElfShdr<E> *sh_begin = (ElfShdr<E> *)(data + ehdr.e_shoff);
   std::span<ElfShdr<E>> shdrs{(ElfShdr<E> *)(data + ehdr.e_shoff), ehdr.e_shnum};
 
+  // e_shstrndx is a 16-bit field. If .shstrtab's section index is
+  // too large, the actual number is stored to sh_link field.
+  i64 shstrtab_idx = (ehdr.e_shstrndx == SHN_XINDEX)
+    ? sh_begin->sh_link : ehdr.e_shstrndx;
+
   for (ElfShdr<E> &sec : shdrs) {
+    // GCC LTO object contains only sections symbols followed by a common
+    // symbol whose name is `__gnu_lto_slim` (or `__gnu_lto_v1` for older
+    // GCC releases).
+    //
+    // However, FAT LTO objects don't have any of the above mentioned symbols
+    // and can identify LTO by `.gnu.lto_.symtab.` section, similarly
+    // to what lto-plugin does. However, if LTO linker plug-in is not available,
+    // use the emitted assembly instead.
+    std::string_view name = data + shdrs[shstrtab_idx].sh_offset + sec.sh_name;
+    if (opt_plugin && name.starts_with (".gnu.lto_.symtab."))
+      return true;
+
     if (sec.sh_type != SHT_SYMTAB)
       continue;
 
     std::span<ElfSym<E>> elf_syms{(ElfSym<E> *)(data + sec.sh_offset),
-                                  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++;
@@ -66,40 +84,63 @@ inline bool is_gcc_lto_obj(MappedFile<C> *mf) {
 }
 
 template <typename C>
-FileType get_file_type(MappedFile<C> *mf) {
+FileType get_file_type(MappedFile<C> *mf, bool opt_plugin) {
+  using namespace elf;
+
   std::string_view data = mf->get_contents();
 
   if (data.empty())
     return FileType::EMPTY;
 
   if (data.starts_with("\177ELF")) {
-    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>(mf, opt_plugin))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<X86_64>(mf, opt_plugin))
+            return FileType::GCC_LTO_OBJ;
+        }
+        return FileType::ELF_OBJ;
       }
 
-      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>(mf, opt_plugin))
+            return FileType::GCC_LTO_OBJ;
+        } else {
+          if (is_gcc_lto_obj<SPARC64>(mf, opt_plugin))
+            return FileType::GCC_LTO_OBJ;
+        }
+        return FileType::ELF_OBJ;
+      }
+
+      if (ehdr.e_type == ET_DYN)
+        return FileType::ELF_DSO;
     }
     return FileType::UNKNOWN;
   }
 
   if (data.starts_with("\xcf\xfa\xed\xfe")) {
-    switch (*(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 +168,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";

glob.cc

@@ -2,9 +2,9 @@
 
 #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

install-build-deps.sh

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

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

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

main.cc

@@ -1,47 +1,156 @@
-#include "elf/mold.h"
-#include "macho/mold.h"
+#include "mold.h"
+#include "config.h"
 
 #include <cstring>
+#include <filesystem>
 #include <signal.h>
+#include <tbb/global_control.h>
 
 #ifdef USE_SYSTEM_MIMALLOC
 #include <mimalloc-new-delete.h>
 #endif
 
+#ifdef __FreeBSD__
+# include <sys/sysctl.h>
+# include <unistd.h>
+#endif
+
 namespace mold {
 
-#ifdef GIT_HASH
-const std::string mold_version =
-  "mold " MOLD_VERSION " (" GIT_HASH "; compatible with GNU ld)";
-#else
-const std::string mold_version =
-  "mold " MOLD_VERSION " (compatible with GNU ld)";
-#endif
+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);
-  if (socket_tmpfile)
-    unlink(socket_tmpfile);
 }
 
-static void signal_handler(int) {
+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() {
-  signal(SIGINT, signal_handler);
-  signal(SIGTERM, signal_handler);
+  AddVectoredExceptionHandler(0, vectored_handler);
+}
+
+#else
+
+static void sighandler(int signo, siginfo_t *info, void *ucontext) {
+  static std::mutex mu;
+  std::scoped_lock lock{mu};
+
+  if ((signo == SIGSEGV || signo == SIGBUS) &&
+      output_buffer_start <= info->si_addr &&
+      info->si_addr < output_buffer_end) {
+    const char msg[] = "mold: failed to write to an output file. Disk full?\n";
+    (void)!write(STDERR_FILENO, msg, sizeof(msg) - 1);
+  }
+
+  cleanup();
+  _exit(1);
+}
+
+void install_signal_handler() {
+  struct sigaction action;
+  action.sa_sigaction = sighandler;
+  sigemptyset(&action.sa_mask);
+  action.sa_flags = SA_SIGINFO;
+
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+  sigaction(SIGBUS, &action, NULL);
+}
+
+#endif
+
+i64 get_default_thread_count() {
+  // mold doesn't scale well above 32 threads.
+  int n = tbb::global_control::active_value(
+    tbb::global_control::max_allowed_parallelism);
+  return std::min(n, 32);
 }
 
 } // namespace mold
 
 int main(int argc, char **argv) {
-  std::string cmd = mold::filepath(argv[0]).filename();
+  mold::mold_version = mold::get_mold_version();
 
+#if MOLD_IS_SOLD
+  std::string cmd = mold::filepath(argv[0]).filename().string();
   if (cmd == "ld64" || cmd == "ld64.mold")
     return mold::macho::main(argc, argv);
+#endif
 
   return mold::elf::main(argc, argv);
 }

mold.h

@@ -1,9 +1,11 @@
 #pragma once
 
-#include "big-endian.h"
+#include "integers.h"
 
+#include <array>
 #include <atomic>
 #include <bit>
+#include <bitset>
 #include <cassert>
 #include <cstdio>
 #include <cstring>
@@ -11,50 +13,74 @@
 #include <filesystem>
 #include <iostream>
 #include <mutex>
+#include <optional>
 #include <span>
 #include <sstream>
 #include <string>
 #include <string_view>
-#include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <tbb/concurrent_vector.h>
 #include <tbb/enumerable_thread_specific.h>
-#include <unistd.h>
 #include <vector>
 
-#ifdef NDEBUG
-#  define unreachable() __builtin_unreachable()
+#ifdef _WIN32
+# include <io.h>
 #else
-#  define unreachable() assert(0 && "unreachable")
+# include <sys/mman.h>
+# include <unistd.h>
 #endif
 
+#define XXH_INLINE_ALL 1
+#include "third-party/xxhash/xxhash.h"
+
+#ifdef NDEBUG
+# define unreachable() __builtin_unreachable()
+#else
+# define unreachable() assert(0 && "unreachable")
+#endif
+
+inline uint64_t hash_string(std::string_view str) {
+  return XXH3_64bits(str.data(), str.size());
+}
+
+class HashCmp {
+public:
+  static size_t hash(const std::string_view &k) {
+    return hash_string(k);
+  }
+
+  static bool equal(const std::string_view &k1, const std::string_view &k2) {
+    return k1 == k2;
+  }
+};
+
 namespace mold {
 
 using namespace std::literals::string_literals;
 using namespace std::literals::string_view_literals;
 
-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 C> class OutputFile;
 
 inline char *output_tmpfile;
-inline char *socket_tmpfile;
 inline thread_local bool opt_demangle;
 
-extern const std::string mold_version;
+inline u8 *output_buffer_start = nullptr;
+inline u8 *output_buffer_end = nullptr;
 
-std::string_view errno_string();
+inline std::string mold_version;
+extern std::string mold_version_string;
+extern std::string mold_git_hash;
+
+std::string errno_string();
+std::string get_self_path();
 void cleanup();
 void install_signal_handler();
+i64 get_default_thread_count();
+
+static u64 combine_hash(u64 a, u64 b) {
+  return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
+}
 
 //
 // Error output
@@ -159,37 +185,68 @@ private:
 // Utility functions
 //
 
+// Some C++ libraries haven't implemented std::has_single_bit yet.
+inline bool has_single_bit(u64 val) {
+  return std::popcount(val) == 1;
+}
+
+// Some C++ libraries haven't implemented std::bit_ceil yet.
+inline u64 bit_ceil(u64 val) {
+  if (has_single_bit(val))
+    return val;
+  return 1LL << (64 - std::countl_zero(val));
+}
+
 inline u64 align_to(u64 val, u64 align) {
   if (align == 0)
     return val;
-  assert(std::popcount(align) == 1);
+  assert(has_single_bit(align));
   return (val + align - 1) & ~(align - 1);
 }
 
 inline u64 align_down(u64 val, u64 align) {
-  assert(std::popcount(align) == 1);
+  assert(has_single_bit(align));
   return val & ~(align - 1);
 }
 
-inline u64 next_power_of_two(u64 val) {
-  assert(val >> 63 == 0);
-  if (val == 0 || val == 1)
-    return 1;
-  return (u64)1 << (64 - std::countl_zero(val - 1));
+inline u64 bit(u64 val, i64 pos) {
+  return (val >> pos) & 1;
+};
+
+// Returns [hi:lo] bits of val.
+inline u64 bits(u64 val, u64 hi, u64 lo) {
+  return (val >> lo) & ((1LL << (hi - lo + 1)) - 1);
 }
 
+inline i64 sign_extend(u64 val, i64 size) {
+  return (i64)(val << (63 - size)) >> (63 - size);
+};
+
 template <typename T, typename Compare = std::less<T>>
 void update_minimum(std::atomic<T> &atomic, u64 new_val, Compare cmp = {}) {
-  T old_val = atomic;
+  T old_val = atomic.load(std::memory_order_relaxed);
   while (cmp(new_val, old_val) &&
-         !atomic.compare_exchange_weak(old_val, new_val));
+         !atomic.compare_exchange_weak(old_val, new_val,
+                                       std::memory_order_relaxed));
 }
 
 template <typename T, typename Compare = std::less<T>>
 void update_maximum(std::atomic<T> &atomic, u64 new_val, Compare cmp = {}) {
-  T old_val = atomic;
+  T old_val = atomic.load(std::memory_order_relaxed);
   while (cmp(old_val, new_val) &&
-         !atomic.compare_exchange_weak(old_val, new_val));
+         !atomic.compare_exchange_weak(old_val, new_val,
+                                       std::memory_order_relaxed));
+}
+
+// An optimized "mark" operation for parallel mark-and-sweep algorithms.
+// Returns true if `visited` was false and updated to true.
+inline bool fast_mark(std::atomic<bool> &visited) {
+  // A relaxed load + branch (assuming miss) takes only around 20 cycles,
+  // while an atomic RMW can easily take hundreds on x86. We note that it's
+  // common that another thread beat us in marking, so doing an optimistic
+  // early test tends to improve performance in the ~20% ballpark.
+  return !visited.load(std::memory_order_relaxed) &&
+         !visited.exchange(true, std::memory_order_relaxed);
 }
 
 template <typename T, typename U>
@@ -215,14 +272,19 @@ inline void sort(T &vec, U less) {
   std::stable_sort(vec.begin(), vec.end(), less);
 }
 
-inline i64 write_string(u8 *buf, std::string_view str) {
+template <typename T>
+inline void remove_duplicates(std::vector<T> &vec) {
+  vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
+}
+
+inline i64 write_string(void *buf, std::string_view str) {
   memcpy(buf, str.data(), str.size());
-  buf[str.size()] = '\0';
+  *((u8 *)buf + str.size()) = '\0';
   return str.size() + 1;
 }
 
 template <typename T>
-inline i64 write_vector(u8 *buf, const std::vector<T> &vec) {
+inline i64 write_vector(void *buf, const std::vector<T> &vec) {
   i64 sz = vec.size() * sizeof(T);
   memcpy(buf, vec.data(), sz);
   return sz;
@@ -236,6 +298,20 @@ inline void encode_uleb(std::vector<u8> &vec, u64 val) {
   } while (val);
 }
 
+inline void encode_sleb(std::vector<u8> &vec, i64 val) {
+  for (;;) {
+    u8 byte = val & 0x7f;
+    val >>= 7;
+
+    bool neg = (byte & 0x40);
+    if ((val == 0 && !neg) || (val == -1 && neg)) {
+      vec.push_back(byte);
+      break;
+    }
+    vec.push_back(byte | 0x80);
+  }
+}
+
 inline i64 write_uleb(u8 *buf, u64 val) {
   i64 i = 0;
   do {
@@ -258,13 +334,26 @@ inline u64 read_uleb(u8 *&buf) {
   return val;
 }
 
+inline u64 read_uleb(u8 const*&buf) {
+  return read_uleb(const_cast<u8 *&>(buf));
+}
+
+inline u64 read_uleb(std::string_view &str) {
+  u8 *start = (u8 *)&str[0];
+  u8 *ptr = start;
+  u64 val = read_uleb(ptr);
+  str = str.substr(ptr - start);
+  return val;
+}
+
 inline i64 uleb_size(u64 val) {
-  i64 i = 0;
-  do {
-    i++;
-    val >>= 7;
-  } while (val);
-  return i;
+#if __GNUC__
+#pragma GCC unroll 8
+#endif
+  for (int i = 1; i < 9; i++)
+    if (val < (1LL << (7 * i)))
+      return i;
+  return 9;
 }
 
 template <typename C>
@@ -276,6 +365,14 @@ std::string_view save_string(C &ctx, const std::string &str) {
   return {(char *)buf, str.size()};
 }
 
+inline bool remove_prefix(std::string_view &s, std::string_view prefix) {
+  if (s.starts_with(prefix)) {
+    s = s.substr(prefix.size());
+    return true;
+  }
+  return false;
+}
+
 //
 // Concurrent Map
 //
@@ -305,7 +402,7 @@ public:
   void resize(i64 nbuckets) {
     this->~ConcurrentMap();
 
-    nbuckets = std::max<i64>(MIN_NBUCKETS, next_power_of_two(nbuckets));
+    nbuckets = std::max<i64>(MIN_NBUCKETS, bit_ceil(nbuckets));
 
     this->nbuckets = nbuckets;
     keys = (std::atomic<const char *> *)calloc(nbuckets, sizeof(keys[0]));
@@ -317,23 +414,24 @@ public:
     if (!keys)
       return {nullptr, false};
 
-    assert(std::popcount<u64>(nbuckets) == 1);
+    assert(has_single_bit(nbuckets));
     i64 idx = hash & (nbuckets - 1);
     i64 retry = 0;
 
     while (retry < MAX_RETRY) {
-      const char *ptr = keys[idx];
+      const char *ptr = keys[idx].load(std::memory_order_acquire);
       if (ptr == marker) {
         pause();
         continue;
       }
 
       if (ptr == nullptr) {
-        if (!keys[idx].compare_exchange_weak(ptr, marker))
+        if (!keys[idx].compare_exchange_weak(ptr, marker,
+                                             std::memory_order_acq_rel))
           continue;
         new (values + idx) T(val);
         key_sizes[idx] = key.size();
-        keys[idx] = key.data();
+        keys[idx].store(key.data(), std::memory_order_release);
         return {values + idx, true};
       }
 
@@ -376,10 +474,28 @@ private:
 };
 
 //
-// threads.cc
+// output-file.h
 //
 
-void set_thread_count(i64 n);
+template <typename C>
+class OutputFile {
+public:
+  static std::unique_ptr<OutputFile<C>>
+  open(C &ctx, std::string path, i64 filesize, i64 perm);
+
+  virtual void close(C &ctx) = 0;
+  virtual ~OutputFile() = default;
+
+  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) {}
+};
 
 //
 // hyperloglog.cc
@@ -407,6 +523,65 @@ private:
   std::vector<std::atomic_uint8_t> buckets;
 };
 
+//
+// glob.cc
+//
+
+class Glob {
+  typedef enum { STRING, STAR, QUESTION, BRACKET } Kind;
+
+  struct Element {
+    Element(Kind k) : kind(k) {}
+    Kind kind;
+    std::string str;
+    std::bitset<256> bitset;
+  };
+
+public:
+  static std::optional<Glob> compile(std::string_view pat);
+  bool match(std::string_view str);
+
+private:
+  Glob(std::vector<Element> &&vec) : elements(vec) {}
+  static bool do_match(std::string_view str, std::span<Element> elements);
+
+  std::vector<Element> elements;
+};
+
+//
+// multi-glob.cc
+//
+
+class MultiGlob {
+public:
+  bool add(std::string_view pat, u32 val);
+  bool empty() const { return strings.empty(); }
+  std::optional<u32> find(std::string_view str);
+
+private:
+  struct TrieNode {
+    u32 value = -1;
+    TrieNode *suffix_link = nullptr;
+    std::unique_ptr<TrieNode> children[256];
+  };
+
+  void compile();
+  void fix_suffix_links(TrieNode &node);
+  void fix_values();
+
+  std::vector<std::string> strings;
+  std::unique_ptr<TrieNode> root;
+  std::vector<std::pair<Glob, u32>> globs;
+  std::once_flag once;
+  bool is_compiled = false;
+};
+
+//
+// uuid.cc
+//
+
+std::array<u8, 16> get_uuid_v4();
+
 //
 // filepath.cc
 //
@@ -425,32 +600,36 @@ std::filesystem::path to_abs_path(std::filesystem::path path);
 //
 
 std::string_view demangle(std::string_view name);
+std::optional<std::string_view> cpp_demangle(std::string_view name);
 
 //
 // compress.cc
 //
 
-class ZlibCompressor {
+class Compressor {
 public:
-  ZlibCompressor(std::string_view input);
-  void write_to(u8 *buf);
-  i64 size() const;
+  virtual void write_to(u8 *buf) = 0;
+  virtual ~Compressor() {}
+  i64 compressed_size = 0;
+};
+
+class ZlibCompressor : public Compressor {
+public:
+  ZlibCompressor(u8 *buf, i64 size);
+  void write_to(u8 *buf) override;
 
 private:
   std::vector<std::vector<u8>> shards;
   u64 checksum = 0;
 };
 
-class GzipCompressor {
+class ZstdCompressor : public Compressor {
 public:
-  GzipCompressor(std::string_view input);
-  void write_to(u8 *buf);
-  i64 size() const;
+  ZstdCompressor(u8 *buf, i64 size);
+  void write_to(u8 *buf) override;
 
 private:
   std::vector<std::vector<u8>> shards;
-  u32 checksum = 0;
-  u32 uncompressed_size = 0;
 };
 
 //
@@ -570,7 +749,8 @@ public:
   static MappedFile *open(C &ctx, std::string path);
   static MappedFile *must_open(C &ctx, std::string path);
 
-  ~MappedFile();
+  ~MappedFile() { unmap(); }
+  void unmap();
 
   MappedFile *slice(C &ctx, std::string name, u64 start, u64 size);
 
@@ -590,6 +770,12 @@ public:
       // because archive members may have the same name.
       return parent->name + ":" + std::to_string(get_offset());
     }
+
+    if (thin_parent) {
+      // If this is a thin archive member, the filename part is
+      // guaranteed to be unique.
+      return thin_parent->name + ":" + name;
+    }
     return name;
   }
 
@@ -599,7 +785,11 @@ public:
   i64 mtime = 0;
   bool given_fullpath = true;
   MappedFile *parent = nullptr;
+  MappedFile *thin_parent = nullptr;
   int fd = -1;
+#ifdef _WIN32
+  HANDLE file_handle = INVALID_HANDLE_VALUE;
+#endif
 };
 
 template <typename C>
@@ -607,7 +797,13 @@ MappedFile<C> *MappedFile<C>::open(C &ctx, std::string path) {
   if (path.starts_with('/') && !ctx.arg.chroot.empty())
     path = ctx.arg.chroot + "/" + path_clean(path);
 
-  i64 fd = ::open(path.c_str(), O_RDONLY);
+  i64 fd;
+#ifdef _WIN32
+    fd = ::_open(path.c_str(), O_RDONLY);
+#else
+    fd = ::open(path.c_str(), O_RDONLY);
+#endif
+
   if (fd == -1)
     return nullptr;
 
@@ -621,17 +817,32 @@ MappedFile<C> *MappedFile<C>::open(C &ctx, std::string path) {
   mf->name = path;
   mf->size = st.st_size;
 
-#ifdef __APPLE__
-  mf->mtime = (u64)st.st_mtimespec.tv_sec * 1000000000 + st.st_mtimespec.tv_nsec;
+#ifdef _WIN32
+    mf->mtime = st.st_mtime;
+#elif defined(__APPLE__)
+    mf->mtime = (u64)st.st_mtimespec.tv_sec * 1000000000 + st.st_mtimespec.tv_nsec;
 #else
-  mf->mtime = (u64)st.st_mtim.tv_sec * 1000000000 + st.st_mtim.tv_nsec;
+    mf->mtime = (u64)st.st_mtim.tv_sec * 1000000000 + st.st_mtim.tv_nsec;
 #endif
 
   if (st.st_size > 0) {
-    mf->data = (u8 *)mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+#ifdef _WIN32
+    HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(fd),
+                                      nullptr, PAGE_READWRITE, 0,
+                                      st.st_size, nullptr);
+    if (!handle)
+      Fatal(ctx) << path << ": CreateFileMapping failed: " << GetLastError();
+    mf->file_handle = handle;
+    mf->data = (u8 *)MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, st.st_size);
+    if (!mf->data)
+      Fatal(ctx) << path << ": MapViewOfFile failed: " << GetLastError();
+#else
+    mf->data = (u8 *)mmap(nullptr, st.st_size, PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE, fd, 0);
     if (mf->data == MAP_FAILED)
       Fatal(ctx) << path << ": mmap failed: " << errno_string();
-  }
+#endif
+    }
 
   close(fd);
   return mf;
@@ -658,9 +869,19 @@ MappedFile<C>::slice(C &ctx, std::string name, u64 start, u64 size) {
 }
 
 template <typename C>
-MappedFile<C>::~MappedFile() {
-  if (size && !parent)
-    munmap(data, size);
+void MappedFile<C>::unmap() {
+  if (size == 0 || parent || !data)
+    return;
+
+#ifdef _WIN32
+  UnmapViewOfFile(data);
+  if (file_handle != INVALID_HANDLE_VALUE)
+    CloseHandle(file_handle);
+#else
+  munmap(data, size);
+#endif
+
+  data = nullptr;
 }
 
 } // namespace mold

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 <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

output-file-unix.h

@@ -1,11 +1,12 @@
 #include "mold.h"
 
 #include <fcntl.h>
+#include <filesystem>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
-namespace mold::elf {
+namespace mold {
 
 inline u32 get_umask() {
   u32 orig_umask = umask(0);
@@ -23,8 +24,10 @@ open_or_create_file(C &ctx, std::string path, i64 filesize, i64 perm) {
   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) {
+  // 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()))
@@ -44,11 +47,11 @@ open_or_create_file(C &ctx, std::string path, i64 filesize, i64 perm) {
   return {fd, path2};
 }
 
-template <typename E>
-class MemoryMappedOutputFile : public OutputFile<E> {
+template <typename C>
+class MemoryMappedOutputFile : public OutputFile<C> {
 public:
-  MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(path, filesize, true) {
+  MemoryMappedOutputFile(C &ctx, std::string path, i64 filesize, i64 perm)
+    : OutputFile<C>(path, filesize, true) {
     i64 fd;
     std::tie(fd, output_tmpfile) = open_or_create_file(ctx, path, filesize, perm);
 
@@ -57,32 +60,50 @@ public:
     if (this->buf == MAP_FAILED)
       Fatal(ctx) << path << ": mmap failed: " << errno_string();
     ::close(fd);
+
+    mold::output_buffer_start = this->buf;
+    mold::output_buffer_end = this->buf + filesize;
   }
 
-  void close(Context<E> &ctx) override {
+  ~MemoryMappedOutputFile() {
+    if (fd2 != -1)
+      ::close(fd2);
+  }
+
+  void close(C &ctx) override {
     Timer t(ctx, "close_file");
 
     if (!this->is_unmapped)
       munmap(this->buf, this->filesize);
 
+    // If an output file already exists, open a file and then remove it.
+    // This is the fastest way to unlink a file, as it does not make the
+    // system to immediately release disk blocks occupied by the file.
+    fd2 = ::open(this->path.c_str(), O_RDONLY);
+    if (fd2 != -1)
+      unlink(this->path.c_str());
+
     if (rename(output_tmpfile, this->path.c_str()) == -1)
       Fatal(ctx) << this->path << ": rename failed: " << errno_string();
     output_tmpfile = nullptr;
   }
+
+private:
+  int fd2 = -1;
 };
 
-template <typename E>
-class MallocOutputFile : public OutputFile<E> {
+template <typename C>
+class MallocOutputFile : public OutputFile<C> {
 public:
-  MallocOutputFile(Context<E> &ctx, std::string path, i64 filesize, i64 perm)
-    : OutputFile<E>(path, filesize, false), perm(perm) {
+  MallocOutputFile(C &ctx, std::string path, i64 filesize, i64 perm)
+    : OutputFile<C>(path, filesize, false), perm(perm) {
     this->buf = (u8 *)mmap(NULL, filesize, PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);
     if (this->buf == MAP_FAILED)
       Fatal(ctx) << "mmap failed: " << errno_string();
   }
 
-  void close(Context<E> &ctx) override {
+  void close(C &ctx) override {
     Timer t(ctx, "close_file");
 
     if (this->path == "-") {
@@ -104,9 +125,9 @@ private:
   i64 perm;
 };
 
-template <typename E>
-std::unique_ptr<OutputFile<E>>
-OutputFile<E>::open(Context<E> &ctx, std::string path, i64 filesize, i64 perm) {
+template <typename C>
+std::unique_ptr<OutputFile<C>>
+OutputFile<C>::open(C &ctx, std::string path, i64 filesize, i64 perm) {
   Timer t(ctx, "open_file");
 
   if (path.starts_with('/') && !ctx.arg.chroot.empty())
@@ -121,24 +142,28 @@ OutputFile<E>::open(Context<E> &ctx, std::string path, i64 filesize, i64 perm) {
       is_special = true;
   }
 
-  std::unique_ptr<OutputFile<E>> file;
+  OutputFile<C> *file;
   if (is_special)
-    file = std::make_unique<MallocOutputFile<E>>(ctx, path, filesize, perm);
+    file = new MallocOutputFile<C>(ctx, path, filesize, perm);
   else
-    file = std::make_unique<MemoryMappedOutputFile<E>>(ctx, path, filesize, perm);
+    file = new MemoryMappedOutputFile<C>(ctx, path, filesize, perm);
+
+#ifdef MADV_HUGEPAGE
+  // Enable transparent huge page for an output memory-mapped file.
+  // On Linux, it has an effect only on tmpfs mounted with `huge=advise`,
+  // but it can make the linker ~10% faster. You can try it by creating
+  // a tmpfs with the following commands
+  //
+  //  $ mkdir tmp
+  //  $ sudo mount -t tmpfs -o size=2G,huge=advise none tmp
+  //
+  // and then specifying a path under the directory as an output file.
+  madvise(file->buf, filesize, MADV_HUGEPAGE);
+#endif
 
   if (ctx.arg.filler != -1)
     memset(file->buf, ctx.arg.filler, filesize);
-  return file;
+  return std::unique_ptr<OutputFile<C>>(file);
 }
 
-#define INSTANTIATE(E)                          \
-  template class OutputFile<E>;
-
-INSTANTIATE(X86_64);
-INSTANTIATE(I386);
-INSTANTIATE(ARM64);
-INSTANTIATE(ARM32);
-INSTANTIATE(RISCV64);
-
-} // namespace mold::elf
+} // namespace mold

output-file-win32.h

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

output-file.h

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

perf.cc

@@ -3,8 +3,11 @@
 #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;
+#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 * 1000000000 + t.tv_usec * 1000;
+  };
+
+  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,12 +68,13 @@ 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) {

sha.h

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

strerror.cc

@@ -1,20 +0,0 @@
-// GNU's strerror_r is different from POSIX's strerror_r.
-// In this file, we explicitly undefine _GNU_SOURCE to always
-// use the POSIX version.
-
-#define _POSIX_C_SOURCE 200809L
-#undef _GNU_SOURCE
-
-#include <cstring>
-#include <errno.h>
-#include <string_view>
-
-namespace mold {
-
-std::string_view errno_string() {
-  static thread_local char buf[200];
-  strerror_r(errno, buf, sizeof(buf));
-  return buf;
-}
-
-} // namespace mold

tar.cc

@@ -24,8 +24,8 @@ struct UstarHeader {
     int sum = 0;
     for (i64 i = 0; i < sizeof(*this); i++)
       sum += ((u8 *)this)[i];
-    assert(sum < 1000000);
-    sprintf(checksum, "%06o", sum);
+    assert(sum < 01000000);
+    snprintf(checksum, sizeof(checksum), "%06o", sum);
   }
 
   char name[100];
@@ -77,7 +77,7 @@ 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.typeflag[0] = 'x';
   pax.finalize();
   fwrite(&pax, sizeof(pax), 1, out);
@@ -89,7 +89,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);
 

test/Makefile.darwin

@@ -1,15 +0,0 @@
-TESTS = $(wildcard macho/*.sh)
-
-test: $(TESTS)
-
-# macOS's GNU make hasn't been updated since 3.8.1 perhaps due a concern
-# of GPLv3. The --output-sync flag was introduced in GNU Make 4.0, so we
-# can't use that flag on macOS.
-#
-# `tail -r | tail -r` is a poor-man's way to enable full buffering on a
-# command output. `tail -r` outputs an input from the last line to the
-# first.
-$(TESTS):
-	@./$@ 2>&1 | tail -r | tail -r
-
-.PHONY: test $(TESTS)

test/Makefile.linux

@@ -1,8 +0,0 @@
-TESTS = $(wildcard elf/*.sh)
-
-test: $(TESTS)
-
-$(TESTS):
-	@./$@
-
-.PHONY: test $(TESTS)

test/elf/CMakeLists.txt

@@ -0,0 +1,64 @@
+option(MOLD_ENABLE_QEMU_TESTS "Enable tests on non-native targets" OFF)
+option(MOLD_ENABLE_QEMU_TESTS_RV32 "Enable tests for RV32" OFF)
+
+function(add_target TRIPLE)
+  set(HOST ${CMAKE_HOST_SYSTEM_PROCESSOR})
+  if(${HOST} MATCHES "arm.*")
+    set(HOST arm)
+  endif()
+
+  if(${TRIPLE} MATCHES "${HOST}-.*")
+    set(IS_NATIVE 1)
+  endif()
+
+  if(${TRIPLE} MATCHES "([^-]+)-.")
+    set(MACHINE ${CMAKE_MATCH_1})
+  endif()
+
+  if(IS_NATIVE OR MOLD_ENABLE_QEMU_TESTS)
+    file(GLOB ALL_TESTS RELATIVE ${CMAKE_CURRENT_LIST_DIR} CONFIGURE_DEPENDS
+      "*.sh")
+
+    list(FILTER ALL_TESTS EXCLUDE REGEX "_")
+
+    file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_LIST_DIR} CONFIGURE_DEPENDS
+      "${MACHINE}_*.sh")
+
+    list(APPEND TESTS ${ALL_TESTS})
+
+    foreach(TEST IN LISTS TESTS)
+      string(REGEX REPLACE "\\.sh$" "" TESTNAME "${MACHINE}-${TEST}")
+
+      add_test(NAME ${TESTNAME}
+        COMMAND bash -x ${CMAKE_CURRENT_LIST_DIR}/${TEST}
+        WORKING_DIRECTORY ${mold_BINARY_DIR})
+
+      if(IS_NATIVE)
+        set_tests_properties(${TESTNAME} PROPERTIES
+          SKIP_REGULAR_EXPRESSION "skipped")
+      else()
+        set_tests_properties(${TESTNAME} PROPERTIES
+          ENVIRONMENT "TRIPLE=${TRIPLE}")
+      endif()
+    endforeach()
+  endif()
+endfunction()
+
+add_target(x86_64-linux-gnu)
+add_target(i686-linux-gnu)
+add_target(aarch64-linux-gnu)
+add_target(arm-linux-gnueabihf)
+add_target(riscv64-linux-gnu)
+add_target(powerpc-linux-gnu)
+add_target(powerpc64-linux-gnu)
+add_target(powerpc64le-linux-gnu)
+add_target(sparc64-linux-gnu)
+add_target(s390x-linux-gnu)
+add_target(m68k-linux-gnu)
+add_target(sh4-linux-gnu)
+add_target(alpha-linux-gnu)
+add_target(hppa-linux-gnu)
+
+if(MOLD_ENABLE_QEMU_TESTS_RV32)
+  add_target(riscv32-linux-gnu)
+endif()

test/elf/aarch64_range-extension-thunk-disassembly.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[ $MACHINE = aarch64 ] || skip
+
+cat <<EOF | $CC -c -o $t/a.o -fPIC -xc -
+#include <stdio.h>
+
+void fn1();
+void fn2();
+
+__attribute__((section(".low")))  void fn1() { fn2(); }
+__attribute__((section(".high"))) void fn2() { fn1(); }
+
+int main() {
+  fn1();
+}
+EOF
+
+$CC -B. -o $t/exe $t/a.o \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+
+$OBJDUMP -dr $t/exe | grep -Fq '<fn1$thunk>:'

test/elf/abs-error.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[ $MACHINE = aarch64 ] && skip
+[ $MACHINE = ppc64 ] && skip
+[ $MACHINE = ppc64le ] && skip
+[ $MACHINE = s390x ] && skip
+[ $MACHINE = alpha ] && skip
+
+cat <<EOF | $CC -fPIC -c -o $t/a.o -xassembler -
+.globl foo
+foo = 3;
+EOF
+
+cat <<EOF | $CC -fno-PIC -c -o $t/b.o -xc -
+#include <stdio.h>
+extern char foo;
+int main() { printf("foo=%p\n", &foo); }
+EOF
+
+! $CC -B. -o $t/exe -pie $t/a.o $t/b.o -Wl,-z,text >& $t/log
+grep -q 'recompile with -fPIC' $t/log

test/elf/absolute-symbols.sh

@@ -1,24 +1,14 @@
 #!/bin/bash
-export LC_ALL=C
-set -e
-CC="${CC:-cc}"
-CXX="${CXX:-c++}"
-GCC="${GCC:-gcc}"
-GXX="${GXX:-g++}"
-OBJDUMP="${OBJDUMP:-objdump}"
-MACHINE="${MACHINE:-$(uname -m)}"
-testname=$(basename "$0" .sh)
-echo -n "Testing $testname ... "
-cd "$(dirname "$0")"/../..
-mold="$(pwd)/mold"
-t=out/test/elf/$testname
-mkdir -p $t
+. $(dirname $0)/common.inc
 
-[ $MACHINE = x86_64 ] || { echo skipped; exit; }
+# This test crashes only on qemu-sparc64 running on GitHub Actions,
+# even though it works on a local x86-64 machine and on an actual
+# SPARC machine.
+[ $MACHINE = sparc64 ] && skip
 
 cat <<EOF | $CC -o $t/a.o -c -x assembler -
 .globl foo
-foo = 0x800000
+foo = 0x800008
 EOF
 
 cat <<EOF | $CC -o $t/b.o -c -fno-PIC -xc -
@@ -29,12 +19,11 @@ cat <<EOF | $CC -o $t/b.o -c -fno-PIC -xc -
 #include <ucontext.h>
 
 void handler(int signum, siginfo_t *info, void *ptr) {
-  ucontext_t *u = (ucontext_t *)ptr;
-  printf("ip=0x%llx\n", u->uc_mcontext.gregs[REG_RIP]);
+  printf("ip=%p\n", info->si_addr);
   exit(0);
 }
 
-void foo();
+extern volatile int foo;
 
 int main() {
   struct sigaction act;
@@ -42,11 +31,9 @@ int main() {
   act.sa_sigaction = handler;
   sigemptyset(&act.sa_mask);
   sigaction(SIGSEGV, &act, 0);
-  foo();
+  foo = 5;
 }
 EOF
 
 $CC -B. -o $t/exe -no-pie $t/a.o $t/b.o
-$QEMU $t/exe | grep -q '^ip=0x800000$'
-
-echo OK
+$QEMU $t/exe | grep -q '^ip=0x80000.$'

test/elf/allow-multiple-definition.sh

@@ -1,24 +1,9 @@
 #!/bin/bash
-export LC_ALL=C
-set -e
-CC="${CC:-cc}"
-CXX="${CXX:-c++}"
-GCC="${GCC:-gcc}"
-GXX="${GXX:-g++}"
-OBJDUMP="${OBJDUMP:-objdump}"
-MACHINE="${MACHINE:-$(uname -m)}"
-testname=$(basename "$0" .sh)
-echo -n "Testing $testname ... "
-cd "$(dirname "$0")"/../..
-mold="$(pwd)/mold"
-t=out/test/elf/$testname
-mkdir -p $t
+. $(dirname $0)/common.inc
 
-echo 'int main() { return 0; }' > $t/a.c
-echo 'int main() { return 0; }' > $t/b.c
+echo 'int main() { return 0; }' | $CC -c -o $t/a.o -xc -
+echo 'int main() { return 1; }' | $CC -c -o $t/b.o -xc -
 
-! $CC -B. -o $t/exe $t/a.c $t/b.c 2> /dev/null || false
-$CC -B. -o $t/exe $t/a.c $t/b.c -Wl,-allow-multiple-definition
-$CC -B. -o $t/exe $t/a.c $t/b.c -Wl,-z,muldefs
-
-echo OK
+! $CC -B. -o $t/exe $t/a.o $t/b.o 2> /dev/null || false
+$CC -B. -o $t/exe $t/a.o $t/b.o -Wl,-allow-multiple-definition
+$CC -B. -o $t/exe $t/a.o $t/b.o -Wl,-z,muldefs

test/elf/ar-alignment.sh

@@ -1,18 +1,5 @@
 #!/bin/bash
-export LC_ALL=C
-set -e
-CC="${CC:-cc}"
-CXX="${CXX:-c++}"
-GCC="${GCC:-gcc}"
-GXX="${GXX:-g++}"
-OBJDUMP="${OBJDUMP:-objdump}"
-MACHINE="${MACHINE:-$(uname -m)}"
-testname=$(basename "$0" .sh)
-echo -n "Testing $testname ... "
-cd "$(dirname "$0")"/../..
-mold="$(pwd)/mold"
-t=out/test/elf/$testname
-mkdir -p $t
+. $(dirname $0)/common.inc
 
 cat <<EOF | $CC -o $t/a.o -c -xc -
 int two() { return 2; }
@@ -39,5 +26,3 @@ rm -f $t/d.a
 ar rcs $t/d.a $t/a.o $t/b.o
 
 $CC -B. -o $t/exe $t/c.o $t/d.a
-
-echo OK

test/elf/arm_range-extension-thunk-disassembly.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[ $MACHINE = arm ] || skip
+
+cat <<EOF | $CC -c -o $t/a.o -fPIC -xc -
+#include <stdio.h>
+
+void fn1();
+void fn2();
+
+__attribute__((section(".low")))  void fn1() { fn2(); }
+__attribute__((section(".high"))) void fn2() { fn1(); }
+
+int main() {
+  fn1();
+}
+EOF
+
+$CC -B. -o $t/exe $t/a.o \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+
+$OBJDUMP -dr $t/exe | grep -F -A7 '<fn1$thunk>:' > $t/log
+
+grep -Eq 'mov\s+ip, pc' $t/log
+grep -Eq 'bx\s+ip' $t/log
+grep -Eq 'add\s+ip, ip, pc' $t/log

test/elf/arm_range-extension-thunk.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[ $MACHINE = arm ] || skip
+
+echo 'int main() {}' | $CC -c -o /dev/null -xc - -O0 -mthumb >& /dev/null \
+  || skip
+
+cat <<EOF > $t/a.c
+#include <stdio.h>
+
+void fn3();
+void fn4();
+
+__attribute__((section(".low"))) void fn1() { printf(" fn1"); fn3(); }
+__attribute__((section(".low"))) void fn2() { printf(" fn2"); fn4(); }
+
+int main() {
+  printf(" main");
+  fn1();
+  printf("\n");
+}
+EOF
+
+cat <<EOF > $t/b.c
+#include <stdio.h>
+
+void fn1();
+void fn2();
+
+__attribute__((section(".high"))) void fn3() { printf(" fn3"); fn2(); }
+__attribute__((section(".high"))) void fn4() { printf(" fn4"); }
+EOF
+
+$CC -c -o $t/c.o $t/a.c -O0 -mthumb
+$CC -c -o $t/d.o $t/b.c -O0 -marm
+
+$CC -B. -o $t/exe $t/c.o $t/d.o \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+$QEMU $t/exe | grep -q 'main fn1 fn3 fn2 fn4'
+
+$CC -c -o $t/e.o $t/a.c -O2 -mthumb
+$CC -c -o $t/f.o $t/b.c -O2 -marm
+
+$CC -B. -o $t/exe $t/e.o $t/f.o \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+$QEMU $t/exe | grep -q 'main fn1 fn3 fn2 fn4'

test/elf/arm_thumb-interwork.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[[ $MACHINE == arm* ]] || skip
+
+echo 'int foo() { return 0; }' | $CC -o /dev/null -c -xc - -mthumb 2> /dev/null || skip
+
+cat <<EOF | $CC -o $t/a.o -c -xc - -mthumb
+#include <stdio.h>
+int bar();
+int foo() {
+  printf(" foo");
+  bar();
+}
+EOF
+
+cat <<EOF | $CC -o $t/b.o -c -xc - -marm
+#include <stdio.h>
+int bar() {
+  printf(" bar\n");
+}
+
+int foo();
+
+int main() {
+  printf("main");
+  foo();
+}
+EOF
+
+$CC -B. -o $t/exe $t/a.o $t/b.o
+$QEMU $t/exe | grep -q 'main foo bar'

test/elf/arm_tlsdesc.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+[ $MACHINE = arm ] || skip
+
+echo 'int main() {}' | $GCC -c -o /dev/null -xc - -O0 -mthumb >& /dev/null \
+  || skip
+
+cat <<EOF > $t/a.c
+extern _Thread_local int foo;
+
+__attribute__((section(".low")))
+int get_foo() {
+  int y = foo;
+  return y;
+}
+
+static _Thread_local int bar = 5;
+
+__attribute__((section(".high")))
+int get_bar() {
+  return bar;
+}
+EOF
+
+cat <<EOF > $t/b.c
+#include <stdio.h>
+
+_Thread_local int foo;
+
+int get_foo();
+int get_bar();
+
+int main() {
+  foo = 42;
+  printf("%d %d\n", get_foo(), get_bar());
+  return 0;
+}
+EOF
+
+$GCC -fPIC -mtls-dialect=gnu2 -c -o $t/c.o $t/a.c -marm
+$GCC -fPIC -mtls-dialect=gnu2 -c -o $t/d.o $t/b.c -marm
+
+$CC -B. -o $t/exe1 $t/c.o $t/d.o
+$QEMU $t/exe1 | grep -q '42 5'
+
+$CC -B. -o $t/exe2 $t/c.o $t/d.o -Wl,-no-relax
+$QEMU $t/exe2 | grep -q '42 5'
+
+$CC -B. -o $t/exe3 $t/c.o $t/d.o -Wl,-no-relax \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+$QEMU $t/exe3 | grep -q '42 5'
+
+$GCC -fPIC -mtls-dialect=gnu2 -c -o $t/e.o $t/a.c -mthumb
+$GCC -fPIC -mtls-dialect=gnu2 -c -o $t/f.o $t/b.c -mthumb
+
+$CC -B. -o $t/exe4 $t/e.o $t/f.o
+$QEMU $t/exe4 | grep -q '42 5'
+
+$CC -B. -o $t/exe5 $t/e.o $t/f.o -Wl,-no-relax
+$QEMU $t/exe5 | grep -q '42 5'
+
+$CC -B. -o $t/exe6 $t/e.o $t/f.o -Wl,-no-relax \
+  -Wl,--section-start=.low=0x10000000,--section-start=.high=0x20000000
+$QEMU $t/exe6 | grep -q '42 5'