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,16 @@ fn setup_argument_parser() -> ArgumentParser<ElfArgs> {
                 Ok(())
             },
         )
+        .sub_option("pack-relative-relocs", "", |args, _| {
+            if args.arch != Architecture::RISCV64 {
+                args.pack_relative_relocs = true;
+            }
+            Ok(())
+        })
+        .sub_option("nopack-relative-relocs", "", |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(
@@ -803,13 +804,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,
         )
     }
 
@@ -947,6 +950,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::VersionImport,
+                b"GLIBC_ABI_DT_RELR",
+            ));
+        }
     }
 
     fn built_in_section_infos<'data>()
@@ -1101,9 +1113,12 @@ impl platform::Platform for Elf {
 
     fn apply_non_addressable_indexes<'data, 'groups>(
         symbol_db: &SymbolDb<'data, Self>,
-        counts: &NonAddressableCounts,
+        counts: &mut NonAddressableCounts,
+        indexes: &NonAddressableIndexes,
         mem_sizes_iter: impl Iterator<Item = &'groups mut OutputSectionPartMap<u64>>,
     ) {
+        counts.final_version_index = indexes.next_gnu_version_r_index - 1;
+
         // If we were going to output symbol versions, but we didn't actually use any, then we drop
         // all versym allocations. This is partly to avoid wasting unnecessary space in the output
         // file, but mostly in order match what GNU ld does.
@@ -1408,6 +1423,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();
 
@@ -1421,14 +1437,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);
+                }
             }
         }
 
@@ -1796,6 +1820,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);
@@ -2929,7 +2954,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;
@@ -3864,6 +3890,8 @@ pub(crate) struct NonAddressableCounts {
     pub(crate) verneed_count: u64,
     /// The number of verdef records provided in version script.
     pub(crate) verdef_count: u16,
+    /// LLD creates GLIBC_ABI_DT_RELR as the last version across all inputs, we mimic that.
+    pub(crate) final_version_index: u16,
 }
 
 #[derive(Debug)]
@@ -4484,6 +4512,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,
@@ -4779,7 +4815,13 @@ 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);
+                // Uneven 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. \