feat: Support GDB index

libwild/src/args/elf.rs

@@ -127,6 +127,7 @@ pub struct ElfArgs {
 
     pub(crate) nmagic: bool,
     pub(crate) rosegment: bool,
+    pub(crate) gdb_index: bool,
 
     rpath_set: IndexSet<String>,
 
@@ -233,7 +234,6 @@ const SILENTLY_IGNORED_SHORT_FLAGS: &[&str] = &[
 ];
 
 const IGNORED_FLAGS: &[&str] = &[
-    "gdb-index",
     "fix-cortex-a53-835769",
     "fix-cortex-a53-843419",
     "discard-all",
@@ -332,6 +332,7 @@ impl Default for ElfArgs {
 
             experimental_sframe: false,
             debug_compression_kind: None,
+            gdb_index: false,
         }
     }
 }
@@ -1117,6 +1118,24 @@ fn setup_argument_parser() -> ArgumentParser<ElfArgs> {
             Ok(())
         });
 
+    parser
+        .declare()
+        .long("gdb-index")
+        .help("Generate GDB index")
+        .execute(|args, _modifier_stack| {
+            args.gdb_index = true;
+            Ok(())
+        });
+
+    parser
+        .declare()
+        .long("no-gdb-index")
+        .help("Disable GDB index generation")
+        .execute(|args, _modifier_stack| {
+            args.gdb_index = false;
+            Ok(())
+        });
+
     parser
         .declare_with_param()
         .long("soname")
@@ -2057,6 +2076,10 @@ impl platform::Args for ElfArgs {
     fn should_output_partial_object(&self) -> bool {
         self.should_output_partial_object
     }
+
+    fn should_write_gdb_index(&self) -> bool {
+        self.gdb_index && !self.should_strip_debug()
+    }
 }
 
 #[cfg(test)]

libwild/src/elf.rs

@@ -1889,6 +1889,7 @@ impl platform::Platform for Elf {
         builder.add_sections(&custom.bss);
 
         builder.add_sections(&custom.nonalloc);
+        builder.add_section(output_section_id::GDB_INDEX);
         builder.add_section(output_section_id::COMMENT);
         builder.add_section(output_section_id::RISCV_ATTRIBUTES);
         builder.add_section(output_section_id::SHSTRTAB);
@@ -2099,6 +2100,14 @@ impl platform::Platform for Elf {
         total_sizes.merge(&extra_sizes);
     }
 
+    type GdbIndexScanResult = crate::gdb_index::GdbIndexScanResult;
+
+    fn compute_gdb_index_size(
+        groups: &[crate::layout::GroupState<Self>],
+    ) -> crate::error::Result<(u64, Option<Self::GdbIndexScanResult>)> {
+        crate::gdb_index::compute_gdb_index_size(groups)
+    }
+
     fn align_load_segment_start(
         _segment_def: Self::ProgramSegmentDef,
         segment_alignment: Alignment,
@@ -4757,6 +4766,11 @@ const SECTION_DEFINITIONS: [BuiltInSectionDetails; NUM_BUILT_IN_SECTIONS] = {
         kind: SectionKind::Secondary(output_section_id::SYMTAB_SHNDX_LOCAL),
         ..DEFAULT_DEFS
     };
+    defs[output_section_id::GDB_INDEX.as_usize()] = BuiltInSectionDetails {
+        kind: SectionKind::Primary(SectionName(GDB_INDEX_SECTION_NAME)),
+        ty: sht::PROGBITS,
+        ..DEFAULT_DEFS
+    };
     // Start of regular sections
     defs[output_section_id::RODATA.as_usize()] = BuiltInSectionDetails {
         kind: SectionKind::Primary(SectionName(RODATA_SECTION_NAME)),

libwild/src/elf_writer.rs

@@ -185,6 +185,9 @@ pub(crate) fn write<'data, A: Arch<Platform = Elf>>(
         crate::validation::validate_bytes(layout, &sized_output.out)?;
     }
 
+    // Write .gdb_index before splitting, since it needs to read .debug_info from the output.
+    write_gdb_index_section(&mut sized_output.out, layout)?;
+
     let mut section_buffers = split_output_into_sections(layout, &mut sized_output.out).0;
 
     if layout.args().should_write_eh_frame_hdr {
@@ -313,6 +316,27 @@ fn fill_padding(mut section_buffers: OutputSectionMap<&mut [u8]>) {
     });
 }
 
+fn write_gdb_index_section(output: &mut [u8], layout: &ElfLayout) -> Result {
+    use crate::platform::Args as _;
+    if !layout.args().should_write_gdb_index() {
+        return Ok(());
+    }
+    let Some(scan) = &layout.gdb_index_data else {
+        return Ok(());
+    };
+    let sl = layout.section_layouts.get(output_section_id::GDB_INDEX);
+    if sl.file_size == 0 {
+        return Ok(());
+    }
+    timing_phase!("Write .gdb_index");
+    let start = sl.file_offset;
+    // Split the output buffer so that the part before our section is readable (for .debug_info)
+    // and our section is writable.
+    let (before, rest) = output.split_at_mut(start);
+    let gdb_buf = &mut rest[..sl.file_size];
+    crate::gdb_index::write_gdb_index(gdb_buf, before, layout, scan)
+}
+
 fn write_sframe_section(sframe_buffer: &mut [u8], layout: &ElfLayout) -> Result {
     if layout.args().discard_sframe || sframe_buffer.is_empty() {
         return Ok(());