Merge 18cacabec7 into 742ea87d41

This change should make our output for ARM32 a little bit smaller.

CMakeLists.txt

@@ -362,7 +362,6 @@ target_sources(mold PRIVATE
   lib/compress.cc
   lib/crc32.cc
   lib/demangle.cc
-  lib/elf.cc
   lib/filepath.cc
   lib/glob.cc
   lib/hyperloglog.cc
@@ -384,6 +383,7 @@ target_sources(mold PRIVATE
   src/arch-sparc64.cc
   src/arch-x86-64.cc
   src/config.cc
+  src/elf.cc
   third-party/rust-demangle/rust-demangle.c
   )
 

docs/glossary.md

@@ -116,7 +116,7 @@ A static file is created by `ar`, whose command line arguments are
 similar to `tar`. A static library contains the symbol table which
 offers a quick way to look up an object file for a defined symbol,
 but mold does not use the static library's symbol table. mold
-doesdn't need a symbol table to exist in an archive, and if exists,
+doesn't need a symbol table to exist in an archive, and if exists,
 mold just ignores it.
 
 See also: DSO (dynamic library)

lib/archive-file.h

@@ -26,7 +26,6 @@
 #pragma once
 
 #include "common.h"
-#include "filetype.h"
 
 namespace mold {
 
@@ -76,7 +75,7 @@ struct ArHdr {
   }
 };
 
-template <typename Context, typename MappedFile>
+template <typename Context>
 std::vector<MappedFile *>
 read_thin_archive_members(Context &ctx, MappedFile *mf) {
   u8 *begin = mf->data;
@@ -124,7 +123,7 @@ read_thin_archive_members(Context &ctx, MappedFile *mf) {
   return vec;
 }
 
-template <typename Context, typename MappedFile>
+template <typename Context>
 std::vector<MappedFile *> read_fat_archive_members(Context &ctx, MappedFile *mf) {
   u8 *begin = mf->data;
   u8 *data = begin + 8;
@@ -162,16 +161,13 @@ std::vector<MappedFile *> read_fat_archive_members(Context &ctx, MappedFile *mf)
   return vec;
 }
 
-template <typename Context, typename MappedFile>
+template <typename Context>
 std::vector<MappedFile *> read_archive_members(Context &ctx, MappedFile *mf) {
-  switch (get_file_type(ctx, mf)) {
-  case FileType::AR:
+  std::string_view str = mf->get_contents();
+  if (str.starts_with("!<arch>\n"))
     return read_fat_archive_members(ctx, mf);
-  case FileType::THIN_AR:
-    return read_thin_archive_members(ctx, mf);
-  default:
-    unreachable();
-  }
+  assert(str.starts_with("!<thin>\n"));
+  return read_thin_archive_members(ctx, mf);
 }
 
 } // namespace mold

lib/integers.h

@@ -8,12 +8,12 @@
 //    big-endian SPARC machine to create a little-endian RV64 binary.
 //
 // 2. Even though data members in all ELF data strucutres are naturally
-//    aligned, they are not guaranteed to be aligned on memory. Because
-//    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 bit value.
+//    aligned, they are not guaranteed to be aligned on memory because of
+//    archive files. Archive files (.a files) align each member only to a
+//    2 byte boundary, so anything larger than 2 bytes may be misaligned
+//    in an mmap'ed memory. Misaligned access is an undefined behavior in
+//    C/C++, so we shouldn't cast an arbitrary pointer to a uint32_t, for
+//    example, to read a 32 bit value.
 //
 // The data types defined in this file don't depend on host byte order and
 // don't do unaligned access.

lib/tar.cc

@@ -1,3 +1,5 @@
+// This file contains functions to create a tar file.
+
 #include "common.h"
 
 #ifdef _WIN32

src/arch-arm32.cc

@@ -710,6 +710,45 @@ u64 get_eflags(Context<E> &ctx) {
   return EF_ARM_EABI_VER5;
 }
 
+void create_arm_exidx_section(Context<E> &ctx) {
+  for (i64 i = 0; i < ctx.chunks.size(); i++) {
+    if (ctx.chunks[i]->shdr.sh_type == SHT_ARM_EXIDX) {
+      auto *sec = new Arm32ExidxSection(ctx, *ctx.chunks[i]->to_osec());
+      ctx.extra.exidx = sec;
+      ctx.chunks[i] = sec;
+      ctx.chunk_pool.emplace_back(sec);
+      break;
+    }
+  }
+}
+
+Arm32ExidxSection::Arm32ExidxSection(Context<ARM32> &ctx,
+                                     OutputSection<ARM32> &osec)
+  : output_section(osec) {
+  this->name = ".ARM.exidx";
+  this->shdr.sh_type = SHT_ARM_EXIDX;
+  this->shdr.sh_flags = SHF_ALLOC;
+  this->shdr.sh_addralign = 4;
+  this->shdr.sh_size = get_contents(ctx).size();
+  this->sect_order = osec.sect_order;
+
+  for (InputSection<E> *isec : osec.members)
+    isec->is_alive = false;
+}
+
+void Arm32ExidxSection::update_shdr(Context<E> &ctx) {
+  // .ARM.exidx's sh_link should be set to the .text section index.
+  // Runtime doesn't care about it, but the binutils's strip command does.
+  if (Chunk<E> *chunk = find_chunk(ctx, ".text"))
+    this->shdr.sh_link = chunk->shndx;
+}
+
+void Arm32ExidxSection::copy_buf(Context<E> &ctx) {
+  std::vector<u8> contents = get_contents(ctx);
+  assert(this->shdr.sh_size = contents.size());
+  write_vector(ctx.buf + this->shdr.sh_offset, contents);
+}
+
 // ARM executables use an .ARM.exidx section to look up an exception
 // handling record for the current instruction pointer. The table needs
 // to be sorted by their addresses.
@@ -718,13 +757,12 @@ u64 get_eflags(Context<E> &ctx) {
 // I don't know why only ARM uses the different mechanism, but it's
 // likely that it's due to some historical reason.
 //
-// This function sorts .ARM.exidx records.
-void fixup_arm_exidx_section(Context<E> &ctx) {
-  Timer t(ctx, "fixup_arm_exidx_section");
+// This function returns contents of .ARM.exidx.
+std::vector<u8> Arm32ExidxSection::get_contents(Context<E> &ctx) {
+  std::vector<u8> buf(output_section.shdr.sh_size);
 
-  OutputSection<E> *osec = find_section(ctx, SHT_ARM_EXIDX);
-  if (!osec)
-    return;
+  output_section.shdr.sh_addr = this->shdr.sh_addr;
+  output_section.write_to(ctx, buf.data());
 
   // .ARM.exidx records consists of a signed 31-bit relative address
   // and a 32-bit value. The relative address indicates the start
@@ -738,24 +776,24 @@ void fixup_arm_exidx_section(Context<E> &ctx) {
   //
   // CANTUNWIND is value 1. The most significant bit is set in (2) but
   // not in (3). So we can distinguished them just by looking at a value.
-  const u32 EXIDX_CANTUNWIND = 1;
+  const u32 CANTUNWIND = 1;
 
   struct Entry {
     ul32 addr;
     ul32 val;
   };
 
-  if (osec->shdr.sh_size % sizeof(Entry))
+  if (buf.size() % sizeof(Entry))
     Fatal(ctx) << "invalid .ARM.exidx section size";
 
-  Entry *ent = (Entry *)(ctx.buf + osec->shdr.sh_offset);
-  i64 num_entries = osec->shdr.sh_size / sizeof(Entry);
+  Entry *ent = (Entry *)buf.data();
+  i64 num_entries = buf.size() / sizeof(Entry);
 
   // Entry's addresses are relative to themselves. In order to sort
-  // records by addresses, we first translate them so that the addresses
+  // records by address, we first translate them so that the addresses
   // are relative to the beginning of the section.
   auto is_relative = [](u32 val) {
-    return val != EXIDX_CANTUNWIND && !(val & 0x8000'0000);
+    return val != CANTUNWIND && !(val & 0x8000'0000);
   };
 
   tbb::parallel_for((i64)0, num_entries, [&](i64 i) {
@@ -765,10 +803,21 @@ void fixup_arm_exidx_section(Context<E> &ctx) {
       ent[i].val = 0x7fff'ffff & (ent[i].val + offset);
   });
 
-  tbb::parallel_sort(ent, ent + num_entries, [](const Entry &a, const Entry &b) {
+  std::sort(ent, ent + num_entries, [](const Entry &a, const Entry &b) {
     return a.addr < b.addr;
   });
 
+  // Remove duplicate adjacent entries. That is, if two adjacent functions
+  // have the same compact unwind info or are both CANTUNWIND, we can
+  // merge them into a single range.
+  auto it = std::unique(ent, ent + num_entries,
+                        [](const Entry &a, const Entry &b) {
+    return a.val == b.val;
+  });
+
+  num_entries = it - ent;
+  buf.resize(num_entries * sizeof(Entry));
+
   // Make addresses relative to themselves.
   tbb::parallel_for((i64)0, num_entries, [&](i64 i) {
     i64 offset = sizeof(Entry) * i;
@@ -777,14 +826,7 @@ void fixup_arm_exidx_section(Context<E> &ctx) {
       ent[i].val = 0x7fff'ffff & (ent[i].val - offset);
   });
 
-  // .ARM.exidx's sh_link should be set to the .text section index.
-  // Runtime doesn't care about it, but the binutils's strip command does.
-  if (ctx.shdr) {
-    if (Chunk<E> *text = find_section(ctx, ".text")) {
-      osec->shdr.sh_link = text->shndx;
-      ctx.shdr->copy_buf(ctx);
-    }
-  }
+  return buf;
 }
 
 } // namespace mold

src/elf.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "integers.h"
+#include "../lib/integers.h"
 
 #include <concepts>
 #include <ostream>
@@ -191,6 +191,7 @@ enum : u32 {
   PT_GNU_EH_FRAME = 0x6474e550,
   PT_GNU_STACK = 0x6474e551,
   PT_GNU_RELRO = 0x6474e552,
+  PT_GNU_PROPERTY = 0x6474e553,
   PT_OPENBSD_RANDOMIZE = 0x65a3dbe6,
   PT_ARM_EXIDX = 0x70000001,
   PT_RISCV_ATTRIBUTES = 0x70000003,

src/filetype.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "common.h"
+#include "../lib/common.h"
 #include "elf.h"
 
 namespace mold {
@@ -17,8 +17,7 @@ enum class FileType {
   LLVM_BITCODE,
 };
 
-template <typename MappedFile>
-bool is_text_file(MappedFile *mf) {
+inline bool is_text_file(MappedFile *mf) {
   auto istext = [](char c) {
     return isprint(c) || c == '\n' || c == '\t';
   };
@@ -28,8 +27,8 @@ bool is_text_file(MappedFile *mf) {
          istext(data[2]) && istext(data[3]);
 }
 
-template <typename E, typename Context, typename MappedFile>
-inline bool is_gcc_lto_obj(Context &ctx, MappedFile *mf) {
+template <typename E>
+inline bool is_gcc_lto_obj(MappedFile *mf, bool has_plugin) {
   const char *data = mf->get_contents().data();
   ElfEhdr<E> &ehdr = *(ElfEhdr<E> *)data;
   ElfShdr<E> *sh_begin = (ElfShdr<E> *)(data + ehdr.e_shoff);
@@ -46,7 +45,7 @@ inline bool is_gcc_lto_obj(Context &ctx, MappedFile *mf) {
     // the LTO linker plugin is available and falls back as regular
     // objects otherwise. GCC FAT LTO object can be identified by the
     // presence of `.gcc.lto_.symtab` section.
-    if (!ctx.arg.plugin.empty()) {
+    if (has_plugin) {
       std::string_view name = data + shdrs[shstrtab_idx].sh_offset + sec.sh_name;
       if (name.starts_with(".gnu.lto_.symtab."))
         return true;
@@ -81,9 +80,10 @@ inline bool is_gcc_lto_obj(Context &ctx, MappedFile *mf) {
   return false;
 }
 
-template <typename Context, typename MappedFile>
-FileType get_file_type(Context &ctx, MappedFile *mf) {
+template <typename E>
+FileType get_file_type(Context<E> &ctx, MappedFile *mf) {
   std::string_view data = mf->get_contents();
+  bool has_plugin = !ctx.arg.plugin.empty();
 
   if (data.empty())
     return FileType::EMPTY;
@@ -96,10 +96,10 @@ FileType get_file_type(Context &ctx, MappedFile *mf) {
 
       if (ehdr.e_type == ET_REL) {
         if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
-          if (is_gcc_lto_obj<I386>(ctx, mf))
+          if (is_gcc_lto_obj<I386>(mf, has_plugin))
             return FileType::GCC_LTO_OBJ;
         } else {
-          if (is_gcc_lto_obj<X86_64>(ctx, mf))
+          if (is_gcc_lto_obj<X86_64>(mf, has_plugin))
             return FileType::GCC_LTO_OBJ;
         }
         return FileType::ELF_OBJ;
@@ -112,10 +112,10 @@ FileType get_file_type(Context &ctx, MappedFile *mf) {
 
       if (ehdr.e_type == ET_REL) {
         if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
-          if (is_gcc_lto_obj<M68K>(ctx, mf))
+          if (is_gcc_lto_obj<M68K>(mf, has_plugin))
             return FileType::GCC_LTO_OBJ;
         } else {
-          if (is_gcc_lto_obj<SPARC64>(ctx, mf))
+          if (is_gcc_lto_obj<SPARC64>(mf, has_plugin))
             return FileType::GCC_LTO_OBJ;
         }
         return FileType::ELF_OBJ;
@@ -140,23 +140,23 @@ FileType get_file_type(Context &ctx, MappedFile *mf) {
   return FileType::UNKNOWN;
 }
 
-inline std::string filetype_to_string(FileType type) {
-  switch (type) {
-  case FileType::UNKNOWN: return "UNKNOWN";
-  case FileType::EMPTY: return "EMPTY";
-  case FileType::ELF_OBJ: return "ELF_OBJ";
-  case FileType::ELF_DSO: return "ELF_DSO";
-  case FileType::AR: return "AR";
-  case FileType::THIN_AR: return "THIN_AR";
-  case FileType::TEXT: return "TEXT";
-  case FileType::GCC_LTO_OBJ: return "GCC_LTO_OBJ";
-  case FileType::LLVM_BITCODE: return "LLVM_BITCODE";
-  }
-  return "UNKNOWN";
-}
-
 inline std::ostream &operator<<(std::ostream &out, FileType type) {
-  out << filetype_to_string(type);
+  auto to_string = [&] {
+    switch (type) {
+    case FileType::UNKNOWN: return "UNKNOWN";
+    case FileType::EMPTY: return "EMPTY";
+    case FileType::ELF_OBJ: return "ELF_OBJ";
+    case FileType::ELF_DSO: return "ELF_DSO";
+    case FileType::AR: return "AR";
+    case FileType::THIN_AR: return "THIN_AR";
+    case FileType::TEXT: return "TEXT";
+    case FileType::GCC_LTO_OBJ: return "GCC_LTO_OBJ";
+    case FileType::LLVM_BITCODE: return "LLVM_BITCODE";
+    default: return "UNKNOWN";
+    }
+  };
+
+  out << to_string();
   return out;
 }
 

src/main.cc

@@ -1,4 +1,5 @@
 #include "mold.h"
+#include "filetype.h"
 #include "../lib/archive-file.h"
 #include "../lib/output-file.h"
 
@@ -578,6 +579,10 @@ int mold_main(int argc, char **argv) {
   if (ctx.arg.pack_dyn_relocs_relr)
     construct_relr(ctx);
 
+  // Convert an .ARM.exidx to a synthetic section.
+  if constexpr (is_arm32<E>)
+    create_arm_exidx_section(ctx);
+
   // Reserve a space for dynamic symbol strings in .dynstr and sort
   // .dynsym contents if necessary. Beyond this point, no symbol will
   // be added to .dynsym.

src/mold.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../lib/common.h"
-#include "../lib/elf.h"
+#include "elf.h"
 
 #include <atomic>
 #include <bitset>
@@ -341,10 +341,10 @@ template <typename E> u64 get_dtp_addr(const ElfPhdr<E> &);
 //
 
 template <typename E>
-OutputSection<E> *find_section(Context<E> &ctx, u32 sh_type);
+Chunk<E> *find_chunk(Context<E> &ctx, u32 sh_type);
 
 template <typename E>
-OutputSection<E> *find_section(Context<E> &ctx, std::string_view name);
+Chunk<E> *find_chunk(Context<E> &ctx, std::string_view name);
 
 template <typename E>
 u64 get_eflags(Context<E> &ctx) {
@@ -1528,7 +1528,20 @@ void rewrite_endbr(Context<X86_64> &ctx);
 // arch-arm32.cc
 //
 
+class Arm32ExidxSection : public Chunk<ARM32> {
+public:
+  Arm32ExidxSection(Context<ARM32> &ctx, OutputSection<ARM32> &osec);
+  void update_shdr(Context<ARM32> &ctx) override;
+  void copy_buf(Context<ARM32> &ctx) override;
+
+private:
+  std::vector<u8> get_contents(Context<ARM32> &ctx);
+
+  OutputSection<ARM32> &output_section;
+};
+
 template <> u64 get_eflags(Context<ARM32> &ctx);
+void create_arm_exidx_section(Context<ARM32> &ctx);
 void fixup_arm_exidx_section(Context<ARM32> &ctx);
 
 //
@@ -1705,6 +1718,11 @@ struct SectionOrder {
 template <typename E>
 struct ContextExtras {};
 
+template <>
+struct ContextExtras<ARM32> {
+  Arm32ExidxSection *exidx = nullptr;
+};
+
 template <is_riscv E>
 struct ContextExtras<E> {
   RiscvAttributesSection<E> *riscv_attributes = nullptr;

src/output-chunks.cc

@@ -25,20 +25,18 @@ static u32 elf_hash(std::string_view name) {
 }
 
 template <typename E>
-OutputSection<E> *find_section(Context<E> &ctx, u32 sh_type) {
+Chunk<E> *find_chunk(Context<E> &ctx, u32 sh_type) {
   for (Chunk<E> *chunk : ctx.chunks)
-    if (OutputSection<E> *osec = chunk->to_osec())
-      if (osec->shdr.sh_type == sh_type)
-        return osec;
+    if (chunk->shdr.sh_type == sh_type)
+      return chunk;
   return nullptr;
 }
 
 template <typename E>
-OutputSection<E> *find_section(Context<E> &ctx, std::string_view name) {
+Chunk<E> *find_chunk(Context<E> &ctx, std::string_view name) {
   for (Chunk<E> *chunk : ctx.chunks)
-    if (OutputSection<E> *osec = chunk->to_osec())
-      if (osec->name == name)
-        return osec;
+    if (chunk->name == name)
+      return chunk;
   return nullptr;
 }
 
@@ -267,6 +265,10 @@ static std::vector<ElfPhdr<E>> create_phdr(Context<E> &ctx) {
   if (ctx.eh_frame_hdr)
     define(PT_GNU_EH_FRAME, PF_R, ctx.eh_frame_hdr);
 
+  // Add PT_GNU_PROPERTY
+  if (Chunk<E> *chunk = find_chunk(ctx, ".note.gnu.property"))
+    define(PT_GNU_PROPERTY, PF_R, chunk);
+
   // Add PT_GNU_STACK, which is a marker segment that doesn't really
   // contain any segments. It controls executable bit of stack area.
   {
@@ -293,8 +295,8 @@ static std::vector<ElfPhdr<E>> create_phdr(Context<E> &ctx) {
 
   // Create a PT_ARM_EDXIDX
   if constexpr (is_arm32<E>)
-    if (OutputSection<E> *osec = find_section(ctx, SHT_ARM_EXIDX))
-      define(PT_ARM_EXIDX, PF_R, osec);
+    if (ctx.extra.exidx)
+      define(PT_ARM_EXIDX, PF_R, ctx.extra.exidx);
 
   // Create a PT_RISCV_ATTRIBUTES
   if constexpr (is_riscv<E>)
@@ -734,19 +736,19 @@ static std::vector<Word<E>> create_dynamic_section(Context<E> &ctx) {
     define(DT_STRSZ, ctx.dynstr->shdr.sh_size);
   }
 
-  if (find_section(ctx, SHT_INIT_ARRAY)) {
+  if (find_chunk(ctx, SHT_INIT_ARRAY)) {
     define(DT_INIT_ARRAY, ctx.__init_array_start->value);
     define(DT_INIT_ARRAYSZ,
            ctx.__init_array_end->value - ctx.__init_array_start->value);
   }
 
-  if (find_section(ctx, SHT_PREINIT_ARRAY)) {
+  if (find_chunk(ctx, SHT_PREINIT_ARRAY)) {
     define(DT_PREINIT_ARRAY, ctx.__preinit_array_start->value);
     define(DT_PREINIT_ARRAYSZ,
            ctx.__preinit_array_end->value - ctx.__preinit_array_start->value);
   }
 
-  if (find_section(ctx, SHT_FINI_ARRAY)) {
+  if (find_chunk(ctx, SHT_FINI_ARRAY)) {
     define(DT_FINI_ARRAY, ctx.__fini_array_start->value);
     define(DT_FINI_ARRAYSZ,
            ctx.__fini_array_end->value - ctx.__fini_array_start->value);
@@ -2949,8 +2951,8 @@ template class RelocSection<E>;
 template class ComdatGroupSection<E>;
 template class GnuDebuglinkSection<E>;
 
-template OutputSection<E> *find_section(Context<E> &, u32);
-template OutputSection<E> *find_section(Context<E> &, std::string_view);
+template Chunk<E> *find_chunk(Context<E> &, u32);
+template Chunk<E> *find_chunk(Context<E> &, std::string_view);
 template i64 to_phdr_flags(Context<E> &ctx, Chunk<E> *chunk);
 template ElfSym<E> to_output_esym(Context<E> &, Symbol<E> &, u32, U32<E> *);
 

src/passes.cc

@@ -1271,10 +1271,13 @@ void fixup_ctors_in_init_array(Context<E> &ctx) {
     }
   };
 
-  if (OutputSection<E> *osec = find_section(ctx, ".init_array"))
-    fixup(*osec);
-  if (OutputSection<E> *osec = find_section(ctx, ".fini_array"))
-    fixup(*osec);
+  if (Chunk<E> *chunk = find_chunk(ctx, ".init_array"))
+    if (OutputSection<E> *osec = chunk->to_osec())
+      fixup(*osec);
+
+  if (Chunk<E> *chunk = find_chunk(ctx, ".fini_array"))
+    if (OutputSection<E> *osec = chunk->to_osec())
+      fixup(*osec);
 }
 
 template <typename T>
@@ -1659,9 +1662,6 @@ void copy_chunks(Context<E> &ctx) {
   // undefined errors.
   report_undef_errors(ctx);
 
-  if constexpr (is_arm32<E>)
-    fixup_arm_exidx_section(ctx);
-
   // Zero-clear paddings between chunks
   auto zero = [&](Chunk<E> *chunk, i64 next_start) {
     i64 pos = chunk->shdr.sh_offset + chunk->shdr.sh_size;

src/tls.cc

@@ -186,7 +186,7 @@ u64 get_dtp_addr(const ElfPhdr<E> &phdr) {
 
 using E = MOLD_TARGET;
 
-template u64 get_tp_addr<E>(const ElfPhdr<E> &);
-template u64 get_dtp_addr<E>(const ElfPhdr<E> &);
+template u64 get_tp_addr(const ElfPhdr<E> &);
+template u64 get_dtp_addr(const ElfPhdr<E> &);
 
 } // namespace mold

test/gnu-property.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+cat <<EOF | $CC -o $t/a.o -c -xc -
+int main() {}
+EOF
+
+$CC -B. -o $t/exe $t/a.o -no-pie
+readelf -W --sections $t/exe | grep -Fqw .note.gnu.property || skip
+readelf -W --segments $t/exe | grep -qw GNU_PROPERTY