feat: Support -z pack-relative-relocs without actual packing

libwild/src/alignment.rs

@@ -31,6 +31,9 @@ pub(crate) const GOT_ENTRY: Alignment = Alignment { exponent: 3 };
 /// The minimum alignment of a rela entry.
 pub(crate) const RELA_ENTRY: Alignment = Alignment { exponent: 3 };
 
+/// The minimum alignment of a relr entry.
+pub(crate) const RELR_ENTRY: Alignment = Alignment { exponent: 3 };
+
 /// Alignment of the .gnu.hash section.
 pub(crate) const GNU_HASH: Alignment = Alignment { exponent: 3 };
 

libwild/src/args/elf.rs

@@ -113,6 +113,7 @@ pub struct ElfArgs {
     pub(crate) z_stack_size: Option<NonZeroU64>,
     pub(crate) max_page_size: Option<Alignment>,
     pub(crate) trace: bool,
+    pub(crate) pack_relative_relocs: bool,
 
     pub(crate) relocation_model: RelocationModel,
     pub(crate) should_output_executable: bool,
@@ -283,6 +284,7 @@ impl Default for ElfArgs {
             relax: true,
             hash_style: HashStyle::Both,
             trace: false,
+            pack_relative_relocs: false,
 
             unresolved_symbols: UnresolvedSymbols::ReportAll,
             error_unresolved_symbols: true,
@@ -597,6 +599,22 @@ fn setup_argument_parser() -> ArgumentParser<ElfArgs> {
                 Ok(())
             },
         )
+        .sub_option(
+            "pack-relative-relocs",
+            "Pack relative relocations into SHT_RELR",
+            |args, _| {
+                args.pack_relative_relocs = true;
+                Ok(())
+            },
+        )
+        .sub_option(
+            "nopack-relative-relocs",
+            "Do not pack relative relocations into SHT_RELR (default)",
+            |args, _| {
+                args.pack_relative_relocs = false;
+                Ok(())
+            },
+        )
         .sub_option(
             "x86-64-baseline",
             "Mark x86-64-baseline ISA as needed",

libwild/src/elf.rs

@@ -151,6 +151,7 @@ pub(crate) type SectionHeader = object::elf::SectionHeader64<LittleEndian>;
 pub(crate) type SymtabEntry = object::elf::Sym64<LittleEndian>;
 pub(crate) type DynamicEntry = object::elf::Dyn64<LittleEndian>;
 pub(crate) type Rela = object::elf::Rela64<LittleEndian>;
+pub(crate) type Relr = object::elf::Relr64<LittleEndian>;
 pub(crate) type GnuHashHeader = object::elf::GnuHashHeader<LittleEndian>;
 pub(crate) type Verdef = object::elf::Verdef<LittleEndian>;
 pub(crate) type Verdaux = object::elf::Verdaux<LittleEndian>;
@@ -549,7 +550,7 @@ impl platform::Platform for Elf {
     ) -> Result<Self::DynamicLayoutExt<'data>> {
         let mut is_last_verneed = false;
 
-        if let Some(v) = state.format_specific_state.verneed_info.as_ref()
+        if let Some(v) = &state.format_specific_state.verneed_info
             && v.version_count > 0
         {
             memory_offsets.increment(
@@ -764,13 +765,15 @@ impl platform::Platform for Elf {
         output_kind: OutputKind,
         mem_sizes: &OutputSectionPartMap<u64>,
         resolution: &layout::Resolution<Elf>,
+        args: &ElfArgs,
     ) -> Result {
         crate::elf_writer::verify_resolution_allocation(
             output_sections,
             output_order,
             output_kind,
             mem_sizes,
             resolution,
+            args,
         )
     }
 
@@ -908,6 +911,15 @@ impl platform::Platform for Elf {
             elf_symbol_type: stt::TLS,
             is_hidden: false,
         });
+
+        // When `-z pack-relative-relocs` is used, Glibc requires this special version to be
+        // defined.
+        if args.pack_relative_relocs {
+            symbols.add_symbol(InternalSymDefInfo::new(
+                SymbolPlacement::ImportDynamicSymbol,
+                b"GLIBC_ABI_DT_RELR",
+            ));
+        }
     }
 
     fn built_in_section_infos<'data>()
@@ -1369,6 +1381,7 @@ impl platform::Platform for Elf {
         flags: ValueFlags,
         mem_sizes: &mut OutputSectionPartMap<u64>,
         output_kind: OutputKind,
+        args: &Self::Args,
     ) {
         let has_dynamic_symbol = flags.is_dynamic() || flags.needs_export_dynamic();
 
@@ -1382,14 +1395,22 @@ impl platform::Platform for Elf {
             } else if flags.is_interposable() && has_dynamic_symbol {
                 mem_sizes.increment(part_id::RELA_DYN_GENERAL, elf::RELA_ENTRY_SIZE);
             } else if flags.is_address() && output_kind.is_relocatable() {
-                mem_sizes.increment(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                if args.pack_relative_relocs {
+                    mem_sizes.increment(part_id::RELR_DYN, elf::RELR_ENTRY_SIZE);
+                } else {
+                    mem_sizes.increment(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                }
             }
         }
 
         if flags.needs_ifunc_got_for_address() {
             mem_sizes.increment(part_id::GOT, elf::GOT_ENTRY_SIZE);
             if output_kind.is_relocatable() {
-                mem_sizes.increment(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                if args.pack_relative_relocs {
+                    mem_sizes.increment(part_id::RELR_DYN, elf::RELR_ENTRY_SIZE);
+                } else {
+                    mem_sizes.increment(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                }
             }
         }
 
@@ -1758,6 +1779,7 @@ impl platform::Platform for Elf {
         builder.add_section(output_section_id::GNU_VERSION_D);
         builder.add_section(output_section_id::GNU_VERSION_R);
         builder.add_section(output_section_id::RELA_DYN_RELATIVE);
+        builder.add_section(output_section_id::RELR_DYN);
         builder.add_section(output_section_id::RELA_PLT);
         builder.add_section(output_section_id::RODATA);
         builder.add_section(output_section_id::EH_FRAME_HDR);
@@ -2899,7 +2921,8 @@ pub(crate) const GOT_ENTRY_SIZE: u64 = 0x8;
 // TODO: Right now, both x86_64 and AArch64 have 16 byte long entries, but
 // the size should be generic over A: Arch.
 pub(crate) const PLT_ENTRY_SIZE: u64 = 0x10;
-pub(crate) const RELA_ENTRY_SIZE: u64 = 0x18;
+pub(crate) const RELA_ENTRY_SIZE: u64 = size_of::<Rela>() as u64;
+pub(crate) const RELR_ENTRY_SIZE: u64 = size_of::<Relr>() as u64;
 
 pub(crate) const SYMTAB_ENTRY_SIZE: u64 = size_of::<SymtabEntry>() as u64;
 pub(crate) const GNU_VERSION_ENTRY_SIZE: u64 = size_of::<Versym>() as u64;
@@ -4454,6 +4477,14 @@ const SECTION_DEFINITIONS: [BuiltInSectionDetails; NUM_BUILT_IN_SECTIONS] = {
         kind: SectionKind::Secondary(output_section_id::RELA_DYN_RELATIVE),
         ..DEFAULT_DEFS
     };
+    defs[output_section_id::RELR_DYN.as_usize()] = BuiltInSectionDetails {
+        kind: SectionKind::Primary(SectionName(RELR_DYN_SECTION_NAME)),
+        ty: sht::RELR,
+        section_flags: shf::ALLOC,
+        element_size: RELR_ENTRY_SIZE,
+        min_alignment: alignment::RELR_ENTRY,
+        ..DEFAULT_DEFS
+    };
     defs[output_section_id::RISCV_ATTRIBUTES.as_usize()] = BuiltInSectionDetails {
         kind: SectionKind::Primary(SectionName(RISCV_ATTRIBUTES_SECTION_NAME)),
         ty: sht::RISCV_ATTRIBUTES,
@@ -4714,7 +4745,12 @@ fn process_relocation<'data, 'scope, A: Arch<Platform = Elf>, R: Relocation>(
             && flags.is_address()
         {
             if section_is_writable {
-                common.allocate(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                // Odd offsets mean bitmaps in RELR, so we need to fall back to RELA for them.
+                if resources.symbol_db.args.pack_relative_relocs && rel.offset().is_multiple_of(2) {
+                    common.allocate(part_id::RELR_DYN, elf::RELR_ENTRY_SIZE);
+                } else {
+                    common.allocate(part_id::RELA_DYN_RELATIVE, elf::RELA_ENTRY_SIZE);
+                }
             } else if !is_debug_section {
                 bail!(
                     "Cannot apply relocation {} to read-only section. \