afs-ld Public

Notifications Fork 0 Star 0

Comparing changes

Choose two branches to see what's changed or to start a new pull request.

Create pull request

Able to merge. These branches can be automatically merged.

9 commits 13 files changed 1 contributor

Commits on runtime-hello-parity

Tighten runtime hello parity c3ed31d espadonne committed 3 weeks ago
Scale vector pageoff loads a76003a espadonne committed 3 weeks ago
Normalize TLS section alignment cbb10cf espadonne committed 3 weeks ago
Sort local symbols deterministically aadc47d espadonne committed 3 weeks ago
Skip stale tlv direct binds 35b26d0 espadonne committed 3 weeks ago
Preserve runtime tlv descriptor offsets f28a8ca espadonne committed 3 weeks ago
Support local GOT slots 1e37b16 espadonne committed 3 weeks ago
Wrap lingering formatting d63e94e espadonne committed 3 weeks ago
Cache atom section lookups 0a63838 espadonne committed 3 weeks ago

src/layout.rsmodified

  use crate::macho::constants::SG_READ_ONLY;
  use crate::resolve::InputId;
  use crate::section::{
 -    is_zerofill, OutputAtom, OutputSection, OutputSectionId, OutputSegment, Prot,
 +    is_zerofill, InputSection, OutputAtom, OutputSection, OutputSectionId, OutputSegment, Prot,
  };
  use crate::synth::SyntheticPlan;
  use crate::OutputKind;
  pub struct LayoutInput<'a> {
      pub id: InputId,
      pub object: &'a ObjectFile,
 +    pub load_order: usize,
 +    pub archive_member_offset: Option<u32>,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      name: String,
+ }
 +fn output_section_key(input_section: &InputSection) -> SectionKey {
 +    match (
 +        input_section.segname.as_str(),
 +        input_section.sectname.as_str(),
 +    ) {
 +        ("__DATA", "__const") => SectionKey {
 +            segment: "__DATA_CONST".to_string(),
 +            name: "__const".to_string(),
 +        },
 +        _ => SectionKey {
 +            segment: input_section.segname.clone(),
 +            name: input_section.sectname.clone(),
 +        },
 +    }
 +}
++
  impl Layout {
      pub fn empty(kind: OutputKind, header_size: u64) -> Self {
          Self::build(kind, &[], &AtomTable::new(), header_size)
          header_size: u64,
          synthetic_plan: Option<&SyntheticPlan>,
      ) -> Self {
 -        let input_map: HashMap<InputId, &ObjectFile> = inputs
 -            .iter()
 -            .map(|input| (input.id, input.object))
 -            .collect();
 +        let input_map: HashMap<InputId, LayoutInput<'_>> =
 +            inputs.iter().map(|input| (input.id, *input)).collect();
          let mut sections: Vec<OutputSection> = Vec::new();
          let mut section_index: HashMap<SectionKey, usize> = HashMap::new();
          for (atom_id, atom) in atoms.iter() {
 -            let obj = input_map
 +            let input = input_map
                  .get(&atom.origin)
                  .unwrap_or_else(|| panic!("missing object for input {:?}", atom.origin));
 -            let input_section = obj
 +            let input_section = input
 +                .object
                  .sections
                  .get((atom.input_section as usize).saturating_sub(1))
                  .unwrap_or_else(|| {
                      panic!(
                          "input {} section {} missing for atom {:?}",
 -                        obj.path.display(),
 +                        input.object.path.display(),
                          atom.input_section,
                          atom_id
+                     )
                  });
 -            let key = SectionKey {
 -                segment: input_section.segname.clone(),
 -                name: input_section.sectname.clone(),
 -            };
 +            let key = output_section_key(input_section);
              let idx = match section_index.get(&key) {
                  Some(&idx) => idx,
                  None => {
                          segment: key.segment.clone(),
                          name: key.name.clone(),
                          kind: input_section.kind,
 -                        align_pow2: input_section.align_pow2.min(u8::MAX as u32) as u8,
 +                        align_pow2: normalize_output_alignment(
 +                            input_section.kind,
 +                            input_section.align_pow2.min(u8::MAX as u32) as u8,
 +                        ),
                          flags: input_section.flags,
                          reserved1: input_section.reserved1,
                          reserved2: input_section.reserved2,
              };
              let out = &mut sections[idx];
 -            out.align_pow2 = out.align_pow2.max(atom.align_pow2);
 +            out.align_pow2 =
 +                normalize_output_alignment(out.kind, out.align_pow2.max(atom.align_pow2));
              out.atoms.push(OutputAtom {
                  atom: atom_id,
                  offset: 0,
              section.atoms.sort_by(|a, b| {
                  let lhs = atoms.get(a.atom);
                  let rhs = atoms.get(b.atom);
 -                lhs.origin
 -                    .cmp(&rhs.origin)
 +                let lhs_input = input_map
 +                    .get(&lhs.origin)
 +                    .unwrap_or_else(|| panic!("missing object for input {:?}", lhs.origin));
 +                let rhs_input = input_map
 +                    .get(&rhs.origin)
 +                    .unwrap_or_else(|| panic!("missing object for input {:?}", rhs.origin));
 +                lhs_input
 +                    .load_order
 +                    .cmp(&rhs_input.load_order)
 +                    .then_with(|| {
 +                        lhs_input
 +                            .archive_member_offset
 +                            .unwrap_or(0)
 +                            .cmp(&rhs_input.archive_member_offset.unwrap_or(0))
 +                    })
 +                    .then_with(|| lhs.origin.cmp(&rhs.origin))
                      .then_with(|| lhs.input_offset.cmp(&rhs.input_offset))
                      .then_with(|| a.atom.cmp(&b.atom))
              });
  fn merge_synthetic_section(existing: &mut OutputSection, synthetic: OutputSection) {
      debug_assert_eq!(existing.segment, synthetic.segment);
      debug_assert_eq!(existing.name, synthetic.name);
 -    existing.align_pow2 = existing.align_pow2.max(synthetic.align_pow2);
 +    existing.align_pow2 =
 +        normalize_output_alignment(existing.kind, existing.align_pow2.max(synthetic.align_pow2));
      existing.flags = synthetic.flags;
      existing.reserved1 = synthetic.reserved1;
      existing.reserved2 = synthetic.reserved2;
+     }
+ }
 +fn normalize_output_alignment(kind: crate::section::SectionKind, align_pow2: u8) -> u8 {
 +    match kind {
 +        crate::section::SectionKind::ThreadLocalRegular
 +        | crate::section::SectionKind::ThreadLocalZeroFill
 +        | crate::section::SectionKind::ThreadLocalVariables
 +        | crate::section::SectionKind::ThreadLocalVariablePointers
 +        | crate::section::SectionKind::ThreadLocalInitPointers => align_pow2.max(3),
 +        _ => align_pow2,
 +    }
 +}
++
  fn build_segments(kind: OutputKind, sections: &[OutputSection]) -> Vec<OutputSegment> {
      let names: &[&str] = match kind {
          OutputKind::Executable => &EXEC_SEGMENTS,
              "__thread_ptrs",
              "__thread_data",
              "__thread_bss",
 +            "__common",
              "__bss",
          ],
          "__LINKEDIT" => &[],
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x200,
          );
+     }
 +    #[test]
 +    fn layout_promotes_data_const_into_data_const_segment() {
 +        let object = ObjectFile {
 +            path: PathBuf::from("/tmp/layout-const.o"),
 +            header: MachHeader64 {
 +                magic: MH_MAGIC_64,
 +                cputype: CPU_TYPE_ARM64,
 +                cpusubtype: CPU_SUBTYPE_ARM64_ALL,
 +                filetype: MH_OBJECT,
 +                ncmds: 0,
 +                sizeofcmds: 0,
 +                flags: 0,
 +                reserved: 0,
 +            },
 +            commands: Vec::new(),
 +            sections: vec![input_section(
 +                "__DATA",
 +                "__const",
 +                SectionKind::ConstData,
 +                3,
 +                S_REGULAR,
 +            )],
 +            symbols: Vec::new(),
 +            strings: crate::string_table::StringTable::from_bytes(vec![0]),
 +            symtab: None,
 +            dysymtab: None,
 +            data_in_code: Vec::new(),
 +        };
++
 +        let mut atoms = AtomTable::new();
 +        atoms.push(atom(
 +            InputId(0),
 +            1,
 +            AtomSection::ConstData,
 +            0,
 +            16,
 +            3,
 +            vec![1; 16],
 +        ));
++
 +        let layout = Layout::build(
 +            OutputKind::Executable,
 +            &[LayoutInput {
 +                id: InputId(0),
 +                object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
 +            }],
 +            &atoms,
 +            0x200,
 +        );
++
 +        assert!(layout
 +            .sections
 +            .iter()
 +            .any(|section| section.segment == "__DATA_CONST" && section.name == "__const"));
 +        assert!(!layout
 +            .sections
 +            .iter()
 +            .any(|section| section.segment == "__DATA" && section.name == "__const"));
 +    }
++
      #[test]
      fn executable_layout_has_pagezero_and_zerofill_has_no_file_offset() {
          let object = ObjectFile {
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x300,
          assert!(bss.addr >= EXECUTABLE_TEXT_BASE + PAGE_SIZE);
+     }
 +    #[test]
 +    fn layout_orders_common_before_bss() {
 +        let object = ObjectFile {
 +            path: PathBuf::from("/tmp/layout-common-bss.o"),
 +            header: MachHeader64 {
 +                magic: MH_MAGIC_64,
 +                cputype: CPU_TYPE_ARM64,
 +                cpusubtype: CPU_SUBTYPE_ARM64_ALL,
 +                filetype: MH_OBJECT,
 +                ncmds: 0,
 +                sizeofcmds: 0,
 +                flags: 0,
 +                reserved: 0,
 +            },
 +            commands: Vec::new(),
 +            sections: vec![
 +                input_section("__DATA", "__common", SectionKind::ZeroFill, 3, S_ZEROFILL),
 +                input_section("__DATA", "__bss", SectionKind::ZeroFill, 3, S_ZEROFILL),
 +            ],
 +            symbols: Vec::new(),
 +            strings: crate::string_table::StringTable::from_bytes(vec![0]),
 +            symtab: None,
 +            dysymtab: None,
 +            data_in_code: Vec::new(),
 +        };
++
 +        let mut atoms = AtomTable::new();
 +        atoms.push(atom(
 +            InputId(0),
 +            1,
 +            AtomSection::ZeroFill,
 +            0,
 +            16,
 +            3,
 +            Vec::new(),
 +        ));
 +        atoms.push(atom(
 +            InputId(0),
 +            2,
 +            AtomSection::ZeroFill,
 +            0,
 +            32,
 +            3,
 +            Vec::new(),
 +        ));
++
 +        let layout = Layout::build(
 +            OutputKind::Executable,
 +            &[LayoutInput {
 +                id: InputId(0),
 +                object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
 +            }],
 +            &atoms,
 +            0x200,
 +        );
++
 +        let names: Vec<(&str, &str)> = layout
 +            .sections
 +            .iter()
 +            .map(|section| (section.segment.as_str(), section.name.as_str()))
 +            .collect();
 +        assert_eq!(names, vec![("__DATA", "__common"), ("__DATA", "__bss")]);
 +    }
++
      #[test]
      fn file_backed_segments_round_to_page_boundaries() {
          let object = ObjectFile {
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x200,
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x200,
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x200,
              &[LayoutInput {
                  id: InputId(0),
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
 x200,

src/lib.rsmodified

+         }
          let mut inputs = Inputs::new();
 -        for path in &opts.inputs {
 -            register_input(&mut inputs, path)?;
 +        for (load_order, path) in opts.inputs.iter().enumerate() {
 +            register_input(&mut inputs, path, load_order)?;
+         }
          let mut sym_table = SymbolTable::new();
          let layout_inputs: Vec<LayoutInput<'_>> = objects
              .iter()
 -            .map(|(id, object)| LayoutInput { id: *id, object })
 +            .map(|(id, object)| {
 +                let input = inputs.object(*id);
 +                LayoutInput {
 +                    id: *id,
 +                    object,
 +                    load_order: input.load_order,
 +                    archive_member_offset: input.archive_member_offset,
 +                }
 +            })
              .collect();
          let mut dylib_loads = Vec::new();
          let mut seen_ordinals = std::collections::BTreeSet::new();
          .unwrap_or_else(|| PathBuf::from("a.out"))
+ }
 -fn register_input(inputs: &mut Inputs, path: &std::path::Path) -> Result<(), LinkError> {
 +fn register_input(
 +    inputs: &mut Inputs,
 +    path: &std::path::Path,
 +    load_order: usize,
 +) -> Result<(), LinkError> {
      let bytes = fs::read(path)?;
      match path.extension().and_then(|ext| ext.to_str()) {
          Some("a") => {
 -            let _ = inputs.add_archive(path.to_path_buf(), bytes)?;
 +            let _ = inputs.add_archive(path.to_path_buf(), bytes, load_order)?;
+         }
          Some("dylib") => {
              let _ = inputs.add_dylib(path.to_path_buf(), bytes)?;
+             }
+         }
          _ => {
 -            let _ = inputs.add_object(path.to_path_buf(), bytes)?;
 +            let _ = inputs.add_object(path.to_path_buf(), bytes, load_order)?;
+         }
+     }
      Ok(())
  fn symbol_defined(sym_table: &SymbolTable, name: &str) -> bool {
      sym_table.iter().any(|(_, symbol)| {
 -        sym_table.interner.resolve(symbol.name()) == name && matches!(symbol, Symbol::Defined { .. })
 +        sym_table.interner.resolve(symbol.name()) == name
 +            && matches!(symbol, Symbol::Defined { .. })
      })
+ }

src/macho/constants.rsmodified

  /// `alt_entries` during atomization.
  pub const N_ALT_ENTRY: u16 = 0x0200;
 +// Indirect symbol table sentinels (<mach-o/loader.h>)
 +pub const INDIRECT_SYMBOL_LOCAL: u32 = 0x8000_0000;
 +pub const INDIRECT_SYMBOL_ABS: u32 = 0x4000_0000;
++
  // ARM64 relocation kinds
  pub const ARM64_RELOC_UNSIGNED: u8 = 0;
  pub const ARM64_RELOC_SUBTRACTOR: u8 = 1;

src/macho/writer.rsmodified

          .map(|record| (record.symbol, record))
          .collect();
      let symbol_plan = build_output_symbols(layout, kind, opts.strip_locals, inputs, &imports)?;
+-
      let mut symtab_bytes = Vec::new();
      write_nlist_table(&symbol_plan.symbols, &mut symtab_bytes);
          &mut indirect_symbols,
          &mut indirect_starts,
          ("__TEXT", "__stubs"),
 -        synthetic_plan
 -            .stubs
 -            .entries
 -            .iter()
 -            .map(|entry| entry.symbol),
 -        &symbol_plan.symbol_indices,
 +        synthetic_plan.stubs.entries.iter().map(|entry| {
 +            indirect_symbol_index(entry.symbol, &import_lookup, &symbol_plan.symbol_indices)
 +        }),
      );
      push_indirect_section(
          &mut indirect_symbols,
          &mut indirect_starts,
          ("__DATA_CONST", "__got"),
 -        synthetic_plan.got.entries.iter().map(|entry| entry.symbol),
 -        &symbol_plan.symbol_indices,
 +        synthetic_plan.got.entries.iter().map(|entry| {
 +            indirect_symbol_index(entry.symbol, &import_lookup, &symbol_plan.symbol_indices)
 +        }),
      );
      push_indirect_section(
          &mut indirect_symbols,
          &mut indirect_starts,
          ("__DATA", "__la_symbol_ptr"),
 -        synthetic_plan
 -            .lazy_pointers
 -            .entries
 -            .iter()
 -            .map(|entry| entry.symbol),
 -        &symbol_plan.symbol_indices,
 +        synthetic_plan.lazy_pointers.entries.iter().map(|entry| {
 +            indirect_symbol_index(entry.symbol, &import_lookup, &symbol_plan.symbol_indices)
 +        }),
      );
      let mut indirect_bytes = Vec::with_capacity(indirect_symbols.len() * 4);
      inputs: LinkEditInputs<'_>,
  ) -> Result<Vec<RebaseSite>, WriteError> {
      let mut sites = collect_lazy_pointer_rebase_sites(layout, synthetic_plan)?;
 +    sites.extend(collect_local_got_rebase_sites(
 +        layout,
 +        synthetic_plan,
 +        inputs.0.sym_table,
 +    )?);
      let mut reloc_cache: HashMap<(InputId, u8), Vec<Reloc>> = HashMap::new();
      let input_map: HashMap<InputId, &ObjectFile> = inputs
          .0
          .collect())
+ }
 +fn collect_local_got_rebase_sites(
 +    layout: &Layout,
 +    synthetic_plan: &SyntheticPlan,
 +    sym_table: &SymbolTable,
 +) -> Result<Vec<RebaseSite>, WriteError> {
 +    if synthetic_plan.got.entries.is_empty() {
 +        return Ok(Vec::new());
 +    }
++
 +    let segment_index = segment_index(layout, "__DATA_CONST")?;
 +    let segment = layout
 +        .segment("__DATA_CONST")
 +        .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
 +    let section = layout
 +        .sections
 +        .iter()
 +        .find(|section| section.segment == "__DATA_CONST" && section.name == "__got")
 +        .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
++
 +    Ok(synthetic_plan
 +        .got
 +        .entries
 +        .iter()
 +        .enumerate()
 +        .filter(|(_, entry)| !matches!(sym_table.get(entry.symbol), Symbol::DylibImport { .. }))
 +        .map(|(idx, _)| RebaseSite {
 +            segment_index,
 +            segment_offset: section.addr + (idx as u64) * 8 - segment.vm_addr,
 +        })
 +        .collect())
 +}
++
  fn relocs_for_rebase<'a>(
      relocs: &'a [Reloc],
      atom: &crate::atom::Atom,
      match reloc.referent {
          Referent::Section(_) => true,
 -        Referent::Symbol(_) => match symbol_referent_id(obj, reloc.referent, sym_table) {
 -            Some(symbol_id) => match sym_table.get(symbol_id) {
 -                Symbol::DylibImport { .. } => false,
 -                Symbol::Defined { atom, .. } => atom.0 != 0,
 -                Symbol::Common { .. } => true,
 -                _ => false,
 -            },
 -            None => false,
 -        },
 +        Referent::Symbol(sym_idx) => {
 +            let Some(input_sym) = obj.symbols.get(sym_idx as usize) else {
 +                return false;
 +            };
 +            match symbol_referent_id(obj, reloc.referent, sym_table) {
 +                Some(symbol_id) => match sym_table.get(symbol_id) {
 +                    Symbol::DylibImport { .. } => false,
 +                    Symbol::Defined { atom, .. } => atom.0 != 0,
 +                    Symbol::Common { .. } => true,
 +                    _ => false,
 +                },
 +                None => matches!(input_sym.kind(), SymKind::Sect),
 +            }
 +        }
+     }
+ }
          kind: u16,
+     }
 +    let atoms_by_input_section = atom_table.by_input_section();
      let mut remapped = Vec::new();
      for (input_order, input) in inputs.iter().enumerate() {
          for (input_entry_index, entry) in input.object.data_in_code.iter().copied().enumerate() {
                  remap_data_in_code_to_section(input.object, entry)?;
              let (atom_id, atom_delta) = find_containing_atom_range(
                  atom_table,
 +                &atoms_by_input_section,
                  input.id,
                  section_index,
                  section_relative,
              ..
          } = symbol
          else {
 -            return Err(WriteError::ImportSymbolWrongKind(id));
 +            continue;
          };
          out.push(ImportSymbolRecord {
              symbol: id,
  ) -> Result<SymbolTablePlan, WriteError> {
      let sym_table = inputs.0.sym_table;
      let atom_sections = atom_section_ordinals(layout);
 +    let atoms_by_input_section = inputs.0.atom_table.by_input_section();
      let image_base = layout.segment("__TEXT").map(|seg| seg.vm_addr).unwrap_or(0);
      let mut locals = Vec::new();
      let mut external_defineds = Vec::new();
          collect_local_symbols(
              layout,
              inputs.0.atom_table,
 +            &atoms_by_input_section,
              &atom_sections,
              input.id,
              input.object,
          )?;
+     }
      collect_synthetic_local_symbols(layout, inputs.0.synthetic_plan, &mut locals)?;
 +    sort_local_symbols(&mut locals);
      for (symbol_id, symbol) in sym_table.iter() {
          let Symbol::Defined {
      })
+ }
 +fn sort_local_symbols(locals: &mut [OutputSymbolSpec]) {
 +    locals.sort_by(|lhs, rhs| {
 +        lhs.n_sect
 +            .cmp(&rhs.n_sect)
 +            .then_with(|| lhs.n_value.cmp(&rhs.n_value))
 +            .then_with(|| lhs.n_type.cmp(&rhs.n_type))
 +            .then_with(|| lhs.name.cmp(&rhs.name))
 +    });
 +}
++
  fn collect_synthetic_local_symbols(
      layout: &Layout,
      synthetic_plan: &SyntheticPlan,
  fn collect_local_symbols(
      layout: &Layout,
      atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      atom_sections: &HashMap<crate::resolve::AtomId, u8>,
      input_id: InputId,
      object: &ObjectFile,
                      .section_for_symbol(input_sym)
                      .expect("section symbol without section");
                  let offset = input_sym.value().saturating_sub(section.addr) as u32;
 -                let (atom_id, delta) =
 -                    find_containing_atom(atom_table, input_id, input_sym.sect_idx(), offset)
 -                        .ok_or(WriteError::MissingSegment("__UNKNOWN"))?;
 +                let (atom_id, delta) = find_containing_atom(
 +                    atom_table,
 +                    atoms_by_input_section,
 +                    input_id,
 +                    input_sym.sect_idx(),
 +                    offset,
 +                )
 +                .ok_or(WriteError::MissingSegment("__UNKNOWN"))?;
                  let addr =
                      layout
                          .atom_addr(atom_id)
  fn find_containing_atom(
      atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      input_id: InputId,
      input_section: u8,
      offset: u32,
  ) -> Option<(crate::resolve::AtomId, u32)> {
 -    find_containing_atom_range(atom_table, input_id, input_section, offset, 1)
 +    find_containing_atom_range(
 +        atom_table,
 +        atoms_by_input_section,
 +        input_id,
 +        input_section,
 +        offset,
 +        1,
 +    )
+ }
  fn find_containing_atom_range(
      atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      input_id: InputId,
      input_section: u8,
      offset: u32,
      len: u32,
  ) -> Option<(crate::resolve::AtomId, u32)> {
 -    let atoms = atom_table.by_input_section();
 -    atoms.get(&(input_id, input_section)).and_then(|ids| {
 -        ids.iter().find_map(|atom_id| {
 -            let atom = atom_table.get(*atom_id);
 -            let start = atom.input_offset;
 -            let end = atom.input_offset.saturating_add(atom.size);
 -            let range_end = offset.checked_add(len)?;
 -            (start <= offset && range_end <= end).then_some((*atom_id, offset - start))
 +    atoms_by_input_section
 +        .get(&(input_id, input_section))
 +        .and_then(|ids| {
 +            ids.iter().find_map(|atom_id| {
 +                let atom = atom_table.get(*atom_id);
 +                let start = atom.input_offset;
 +                let end = atom.input_offset.saturating_add(atom.size);
 +                let range_end = offset.checked_add(len)?;
 +                (start <= offset && range_end <= end).then_some((*atom_id, offset - start))
 +            })
          })
 -    })
+ }
  fn input_symbol_type(input_sym: &InputSymbol) -> u8 {
      indirect_symbols: &mut Vec<u32>,
      indirect_starts: &mut HashMap<(String, String), u32>,
      key: (&str, &str),
 -    symbols: impl Iterator<Item = SymbolId>,
 -    symbol_indices: &HashMap<SymbolId, u32>,
 +    symbols: impl Iterator<Item = u32>,
  ) {
      let start = indirect_symbols.len() as u32;
      let mut saw_any = false;
      for symbol in symbols {
          saw_any = true;
 -        indirect_symbols.push(*symbol_indices.get(&symbol).expect("symbol index missing"));
 +        indirect_symbols.push(symbol);
+     }
      if saw_any {
          indirect_starts.insert((key.0.to_string(), key.1.to_string()), start);
+     }
+ }
 +fn indirect_symbol_index(
 +    symbol: SymbolId,
 +    import_lookup: &HashMap<SymbolId, &ImportSymbolRecord>,
 +    symbol_indices: &HashMap<SymbolId, u32>,
 +) -> u32 {
 +    if import_lookup.contains_key(&symbol) {
 +        symbol_indices
 +            .get(&symbol)
 +            .copied()
 +            .unwrap_or(INDIRECT_SYMBOL_LOCAL)
 +    } else {
 +        INDIRECT_SYMBOL_LOCAL
 +    }
 +}
++
  fn build_bind_streams(
      layout: &Layout,
      synthetic_plan: &SyntheticPlan,
      let mut lazy_bind = OpcodeStream::new();
      let mut lazy_offsets = HashMap::new();
 -    if !synthetic_plan.got.entries.is_empty() {
 -        let segment_index = segment_index(layout, "__DATA_CONST")?;
 -        let segment = layout
 -            .segment("__DATA_CONST")
 -            .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
 -        let section = layout
 -            .sections
 -            .iter()
 -            .find(|section| section.segment == "__DATA_CONST" && section.name == "__got")
 -            .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
 -        for (idx, entry) in synthetic_plan.got.entries.iter().enumerate() {
 -            let import = imports
 -                .get(&entry.symbol)
 -                .copied()
 -                .ok_or(WriteError::ImportSymbolMissing(entry.symbol))?;
 -            let slot_addr = section.addr + (idx as u64) * 8;
 -            bind_specs.push(BindRecordSpec {
 -                segment_index,
 -                segment_offset: slot_addr - segment.vm_addr,
 -                ordinal: import.ordinal,
 -                name: &import.name,
 -                weak_import: import.weak_import,
 -                addend: 0,
 -                terminate: false,
 -            });
 -        }
 -    }
+-
      if let Some(tlv_bootstrap) = synthetic_plan.tlv_bootstrap_symbol {
          let segment_index = segment_index(layout, "__DATA")?;
          let segment = layout
+         }
+     }
 +    if !synthetic_plan.got.entries.is_empty() {
 +        let segment_index = segment_index(layout, "__DATA_CONST")?;
 +        let segment = layout
 +            .segment("__DATA_CONST")
 +            .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
 +        let section = layout
 +            .sections
 +            .iter()
 +            .find(|section| section.segment == "__DATA_CONST" && section.name == "__got")
 +            .ok_or(WriteError::MissingSegment("__DATA_CONST"))?;
 +        for (idx, entry) in synthetic_plan.got.entries.iter().enumerate() {
 +            let Some(import) = imports.get(&entry.symbol).copied() else {
 +                continue;
 +            };
 +            let slot_addr = section.addr + (idx as u64) * 8;
 +            bind_specs.push(BindRecordSpec {
 +                segment_index,
 +                segment_offset: slot_addr - segment.vm_addr,
 +                ordinal: import.ordinal,
 +                name: &import.name,
 +                weak_import: import.weak_import,
 +                addend: 0,
 +                terminate: false,
 +            });
 +        }
 +    }
++
      for entry in &synthetic_plan.direct_binds {
          let import = imports
              .get(&entry.symbol)
              .iter()
              .find(|section| section.atoms.iter().any(|placed| placed.atom == entry.atom))
              .ok_or(WriteError::DirectBindSectionMissing(entry.atom))?;
 +        if section.segment == "__DATA" && section.name == "__thread_vars" {
 +            // `__thread_vars` starts are emitted through the dedicated
 +            // `__tlv_bootstrap` pass above. Descriptor tails are rewritten to
 +            // template offsets before write, so any generic direct bind landing
 +            // back in this section is stale and would override the TLV bind.
 +            continue;
 +        }
          let segment_index = segment_index(layout, &section.segment)?;
          let segment = layout
              .segment(&section.segment)
              vec![0x1000, 0x1008, 0x1040]
          );
+     }
++
 +    #[test]
 +    fn containing_atom_lookup_reuses_precomputed_section_index() {
 +        let mut atoms = AtomTable::new();
 +        let first = atoms.push(Atom {
 +            id: AtomId(0),
 +            origin: InputId(7),
 +            input_section: 3,
 +            section: AtomSection::Text,
 +            input_offset: 0,
 +            size: 8,
 +            align_pow2: 2,
 +            owner: None,
 +            alt_entries: Vec::new(),
 +            data: vec![0; 8],
 +            flags: AtomFlags::NONE,
 +            parent_of: None,
 +        });
 +        let second = atoms.push(Atom {
 +            id: AtomId(0),
 +            origin: InputId(7),
 +            input_section: 3,
 +            section: AtomSection::Text,
 +            input_offset: 8,
 +            size: 12,
 +            align_pow2: 2,
 +            owner: None,
 +            alt_entries: Vec::new(),
 +            data: vec![0; 12],
 +            flags: AtomFlags::NONE,
 +            parent_of: None,
 +        });
++
 +        let by_input_section = atoms.by_input_section();
 +        assert_eq!(
 +            find_containing_atom(&atoms, &by_input_section, InputId(7), 3, 4),
 +            Some((first, 4))
 +        );
 +        assert_eq!(
 +            find_containing_atom_range(&atoms, &by_input_section, InputId(7), 3, 10, 2),
 +            Some((second, 2))
 +        );
 +    }
+ }

src/reloc/arm64.rsmodified

  struct ResolveView<'a> {
      sym_table: &'a SymbolTable,
 +    atom_table: &'a AtomTable,
      atom_addrs: &'a HashMap<crate::resolve::AtomId, u64>,
 +    atoms_by_input_section: &'a HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      section_addrs: &'a HashMap<(InputId, u8), u64>,
      stub_addrs: &'a HashMap<SymbolId, u64>,
      got_addrs: &'a HashMap<SymbolId, u64>,
+     }
      let atom_addrs = atom_address_map(layout);
 +    let atoms_by_input_section = atoms.by_input_section();
      let section_addrs = input_section_address_map(layout, atoms);
      let synth_addrs = synthetic_address_maps(layout, synthetic_plan);
      let resolve = ResolveView {
          sym_table,
 +        atom_table: atoms,
          atom_addrs: &atom_addrs,
 +        atoms_by_input_section: &atoms_by_input_section,
          section_addrs: &section_addrs,
          stub_addrs: &synth_addrs.stub_addrs,
          got_addrs: &synth_addrs.got_addrs,
+     }
      if let Some(plan) = synthetic_plan {
 -        synthesize_thread_variable_section(layout, plan)?;
 +        synthesize_thread_variable_section(
 +            layout,
 +            plan,
 +            atoms,
 +            &input_map,
 +            &reloc_cache,
 +            &resolve,
 +        )?;
 +        synthesize_got_section(layout, plan, &resolve)?;
          synthesize_stub_section(layout, plan, &resolve)?;
          synthesize_lazy_pointer_section(layout, plan, &resolve)?;
          synthesize_stub_helper_section(layout, plan, &resolve, linkedit)?;
              local_offset,
              reloc,
              place,
 -            resolve_got_target(obj, atom, reloc, resolve)?,
 -        ),
 -        RelocKind::GotLoadPageOff12 => patch_pageoff12(
 -            bytes,
 -            atom,
 -            obj,
 -            local_offset,
 -            reloc,
 -            resolve_got_target(obj, atom, reloc, resolve)?,
 +            if got_reloc_relaxes_locally(obj, reloc, resolve) {
 +                resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)?
 +            } else {
 +                resolve_got_target(obj, atom, reloc, resolve)?
 +            },
          ),
 +        RelocKind::GotLoadPageOff12 => {
 +            let target = if got_reloc_relaxes_locally(obj, reloc, resolve) {
 +                resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)?
 +            } else {
 +                resolve_got_target(obj, atom, reloc, resolve)?
 +            };
 +            if got_reloc_relaxes_locally(obj, reloc, resolve) {
 +                patch_got_pageoff12_relaxed(bytes, atom, obj, local_offset, reloc, target)
 +            } else {
 +                patch_pageoff12(bytes, atom, obj, local_offset, reloc, target)
 +            }
 +        }
          RelocKind::PointerToGot => patch_unsigned(
              bytes,
              atom,
      reloc: Reloc,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
 -    let Some(symbol_id) = dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table) else {
 +    let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, resolve.sym_table) else {
          return Err(reloc_error(
              atom,
              &obj.path,
              reloc.offset.saturating_sub(atom.input_offset),
              reloc.kind,
              &describe_referent(obj, reloc.referent),
 -            "GOT relocations currently require a dylib import target".to_string(),
 +            "GOT relocations require a symbol target".to_string(),
          ));
      };
      resolve.got_addrs.get(&symbol_id).copied().ok_or_else(|| {
              reloc.offset.saturating_sub(atom.input_offset),
              reloc.kind,
              &describe_referent(obj, reloc.referent),
 -            "dylib import is missing synthetic GOT slot".to_string(),
 +            "symbol is missing synthetic GOT slot".to_string(),
+         )
      })
+ }
 +fn got_reloc_relaxes_locally(obj: &ObjectFile, reloc: Reloc, resolve: &ResolveView<'_>) -> bool {
 +    symbol_referent_id(obj, reloc.referent, resolve.sym_table)
 +        .map(|symbol_id| !matches!(resolve.sym_table.get(symbol_id), Symbol::DylibImport { .. }))
 +        .unwrap_or(false)
 +}
++
  fn resolve_tlvp_target(
      obj: &ObjectFile,
      atom: &Atom,
      obj: &ObjectFile,
      referent: Referent,
      sym_table: &SymbolTable,
 +) -> Option<SymbolId> {
 +    let symbol_id = symbol_referent_id(obj, referent, sym_table)?;
 +    matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. }).then_some(symbol_id)
 +}
++
 +fn symbol_referent_id(
 +    obj: &ObjectFile,
 +    referent: Referent,
 +    sym_table: &SymbolTable,
  ) -> Option<SymbolId> {
      let Referent::Symbol(sym_idx) = referent else {
          return None;
      let (symbol_id, symbol) = sym_table
          .iter()
          .find(|(_, symbol)| sym_table.interner.resolve(symbol.name()) == name)?;
 -    matches!(symbol, Symbol::DylibImport { .. }).then_some(symbol_id)
 +    let _ = symbol;
 +    Some(symbol_id)
+ }
  fn resolve_global_symbol(
      kind: RelocKind,
      input_sym: &InputSymbol,
      resolve: &ResolveView<'_>,
 +) -> Result<u64, RelocError> {
 +    resolve_input_symbol_at_origin(atom.origin, obj, atom, kind, input_sym, resolve)
 +}
++
 +fn resolve_input_symbol_at_origin(
 +    origin: InputId,
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    kind: RelocKind,
 +    input_sym: &InputSymbol,
 +    resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
      match input_sym.kind() {
          SymKind::Abs => Ok(input_sym.value()),
                      "section-backed symbol did not resolve to an input section".to_string(),
+                 )
              })?;
 -            let section_addr = resolve
 -                .section_addrs
 -                .get(&(atom.origin, input_sym.sect_idx()))
 -                .copied()
 -                .ok_or_else(|| {
 -                    reloc_error(
 -                        atom,
 -                        &obj.path,
 -                        0,
 -                        kind,
 -                        &describe_input_symbol(obj, input_sym),
 -                        "section-backed symbol's output section is missing".to_string(),
 -                    )
 -                })?;
 -            Ok(section_addr + input_sym.value().saturating_sub(section.addr))
 +            let section_offset = input_sym.value().saturating_sub(section.addr) as u32;
 +            resolve_input_section_offset(
 +                origin,
 +                obj,
 +                atom,
 +                kind,
 +                input_sym.sect_idx(),
 +                section_offset,
 +                &describe_input_symbol(obj, input_sym),
 +                resolve,
 +            )
+         }
          SymKind::Undef => Err(reloc_error(
              atom,
+     }
+ }
 +fn resolve_input_section_offset(
 +    origin: InputId,
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    kind: RelocKind,
 +    input_section: u8,
 +    input_offset: u32,
 +    referent: &str,
 +    resolve: &ResolveView<'_>,
 +) -> Result<u64, RelocError> {
 +    if let Some(atom_ids) = resolve.atoms_by_input_section.get(&(origin, input_section)) {
 +        if let Some((target_atom, delta)) = atom_ids.iter().find_map(|atom_id| {
 +            let candidate = resolve.atom_table.get(*atom_id);
 +            let start = candidate.input_offset;
 +            let end = candidate.input_offset.saturating_add(candidate.size);
 +            if start <= input_offset && input_offset < end {
 +                Some((*atom_id, input_offset - start))
 +            } else if input_offset == end {
 +                Some((*atom_id, candidate.size))
 +            } else {
 +                None
 +            }
 +        }) {
 +            let atom_addr = resolve
 +                .atom_addrs
 +                .get(&target_atom)
 +                .copied()
 +                .ok_or_else(|| {
 +                    reloc_error(
 +                        atom,
 +                        &obj.path,
 +                        0,
 +                        kind,
 +                        referent,
 +                        "section-backed symbol's containing atom is missing a final address"
 +                            .to_string(),
 +                    )
 +                })?;
 +            return Ok(atom_addr + delta as u64);
 +        }
 +    }
++
 +    let section_addr = resolve
 +        .section_addrs
 +        .get(&(origin, input_section))
 +        .copied()
 +        .ok_or_else(|| {
 +            reloc_error(
 +                atom,
 +                &obj.path,
 +                0,
 +                kind,
 +                referent,
 +                "section-backed symbol's output section is missing".to_string(),
 +            )
 +        })?;
 +    Ok(section_addr + input_offset as u64)
 +}
++
  fn patch_unsigned(
      bytes: &mut [u8],
      atom: &Atom,
      let imm = if is_add_immediate(insn) {
          pageoff
      } else {
 -        let shift = ((insn >> 30) & 0b11) as u64;
 +        let shift = pageoff_load_store_shift(insn);
          let scale = 1u64 << shift;
          if !pageoff.is_multiple_of(scale) {
              return Err(reloc_error(
+     )
+ }
 +fn pageoff_load_store_shift(insn: u32) -> u64 {
 +    if is_simd_fp_pageoff(insn) {
 +        simd_fp_pageoff_shift(insn)
 +    } else {
 +        ((insn >> 30) & 0b11) as u64
 +    }
 +}
++
 +fn is_simd_fp_pageoff(insn: u32) -> bool {
 +    ((insn >> 24) & 0b111) == 0b101
 +}
++
 +fn simd_fp_pageoff_shift(insn: u32) -> u64 {
 +    let size = ((insn >> 30) & 0b11) as u64;
 +    let opc = ((insn >> 22) & 0b11) as u64;
 +    if size == 0 && (opc & 0b10) != 0 {
 +        4
 +    } else {
 +        size
 +    }
 +}
++
  fn read_implicit_addend(
      bytes: &[u8],
      local_offset: u32,
+     )
+ }
 +fn patch_got_pageoff12_relaxed(
 +    bytes: &mut [u8],
 +    atom: &Atom,
 +    obj: &ObjectFile,
 +    local_offset: u32,
 +    reloc: Reloc,
 +    target: u64,
 +) -> Result<(), RelocError> {
 +    let pageoff = target.wrapping_add_signed(reloc.addend) & 0xfff;
 +    if pageoff > 0xfff {
 +        return Err(reloc_error(
 +            atom,
 +            &obj.path,
 +            local_offset,
 +            reloc.kind,
 +            &describe_referent(obj, reloc.referent),
 +            format!("pageoff immediate 0x{pageoff:x} exceeds 12 bits"),
 +        ));
 +    }
++
 +    let insn = read_u32(
 +        bytes,
 +        local_offset,
 +        atom,
 +        obj,
 +        reloc.kind,
 +        &describe_referent(obj, reloc.referent),
 +    )?;
 +    let rd = insn & 0x1f;
 +    let rn = (insn >> 5) & 0x1f;
 +    let patched = 0x9100_0000 | ((pageoff as u32) << 10) | (rn << 5) | rd;
 +    write_u32(
 +        bytes,
 +        local_offset,
 +        patched,
 +        atom,
 +        obj,
 +        reloc.kind,
 +        &describe_referent(obj, reloc.referent),
 +    )
 +}
++
  fn synthesize_thread_variable_section(
      layout: &mut Layout,
      plan: &SyntheticPlan,
 +    atoms: &AtomTable,
 +    input_map: &HashMap<InputId, &ObjectFile>,
 +    reloc_cache: &HashMap<(InputId, u8), Vec<Reloc>>,
 +    resolve: &ResolveView<'_>,
  ) -> Result<(), RelocError> {
      let Some(_bootstrap_symbol) = plan.tlv_bootstrap_symbol else {
          return Ok(());
      };
      for placed in &mut section.atoms {
 +        let atom = atoms.get(placed.atom);
 +        let obj = input_map.get(&atom.origin).ok_or_else(|| RelocError {
 +            input: PathBuf::from("<missing object>"),
 +            atom: placed.atom,
 +            atom_offset: 0,
 +            kind: RelocKind::Unsigned,
 +            referent: "__thread_vars".to_string(),
 +            detail: "missing parsed object for TLV descriptor atom".to_string(),
 +        })?;
 +        let relocs = reloc_cache
 +            .get(&(atom.origin, atom.input_section))
 +            .map(Vec::as_slice)
 +            .unwrap_or(&[]);
          if placed.size % THREAD_VARIABLE_DESCRIPTOR_SIZE as u64 != 0 {
              return Err(RelocError {
                  input: PathBuf::from("<synthetic tlv>"),
          for descriptor_offset in
              (0..placed.size as usize).step_by(THREAD_VARIABLE_DESCRIPTOR_SIZE as usize)
+         {
 +            let descriptor_offset_u32 = descriptor_offset as u32;
              let start = descriptor_offset;
              let end = start + THREAD_VARIABLE_DESCRIPTOR_SIZE as usize;
              let descriptor = placed.data.get_mut(start..end).ok_or_else(|| RelocError {
              })?;
              descriptor[0..8].fill(0);
 -            let init_addr = u64::from_le_bytes(
 -                descriptor[16..24]
 -                    .try_into()
 -                    .expect("8-byte descriptor tail"),
 -            );
 +            let init_addr = resolve_tlv_init_address(
 +                descriptor,
 +                atom,
 +                obj,
 +                relocs,
 +                descriptor_offset_u32,
 +                input_map,
 +                resolve,
 +            )?;
              if init_addr < template_base {
                  return Err(RelocError {
                      input: PathBuf::from("<synthetic tlv>"),
      Ok(())
+ }
 +fn resolve_tlv_init_address(
 +    descriptor: &[u8],
 +    atom: &Atom,
 +    obj: &ObjectFile,
 +    relocs: &[Reloc],
 +    descriptor_offset: u32,
 +    input_map: &HashMap<InputId, &ObjectFile>,
 +    resolve: &ResolveView<'_>,
 +) -> Result<u64, RelocError> {
 +    for owner in descriptor_owner_symbols(obj, atom, descriptor_offset) {
 +        if let Some(init_addr) = resolve_named_tlv_init(owner, atom, input_map, resolve)? {
 +            return Ok(init_addr);
 +        }
 +    }
++
 +    let field_offset = atom.input_offset + descriptor_offset + 16;
 +    if let Some(reloc) = relocs_for_atom(relocs, atom).find(|reloc| reloc.offset == field_offset) {
 +        let target = resolve_tlv_descriptor_referent(obj, atom, reloc, resolve)?;
 +        return Ok(target.wrapping_add_signed(reloc.addend));
 +    }
++
 +    Ok(u64::from_le_bytes(
 +        descriptor[16..24]
 +            .try_into()
 +            .expect("8-byte descriptor tail"),
 +    ))
 +}
++
 +fn descriptor_owner_symbols<'a>(
 +    obj: &'a ObjectFile,
 +    atom: &'a Atom,
 +    descriptor_offset: u32,
 +) -> impl Iterator<Item = &'a InputSymbol> + 'a {
 +    let descriptor_start = atom.input_offset as u64 + descriptor_offset as u64;
 +    obj.symbols.iter().filter(move |input_sym| {
 +        input_sym.kind() == SymKind::Sect
 +            && input_sym.sect_idx() == atom.input_section
 +            && obj.section_for_symbol(input_sym).is_some_and(|section| {
 +                input_sym.value().saturating_sub(section.addr) == descriptor_start
 +            })
 +    })
 +}
++
 +fn matching_tlv_init_symbol<'a>(
 +    obj: &'a ObjectFile,
 +    owner: &InputSymbol,
 +) -> Result<Option<&'a InputSymbol>, RelocError> {
 +    let owner_name = match obj.symbol_name(owner) {
 +        Ok(name) => name,
 +        Err(_) => return Ok(None),
 +    };
 +    let init_name = format!("{owner_name}$tlv$init");
 +    Ok(obj.symbols.iter().find(|input_sym| {
 +        obj.symbol_name(input_sym)
 +            .is_ok_and(|name| name == init_name)
 +    }))
 +}
++
 +fn resolve_named_tlv_init(
 +    owner: &InputSymbol,
 +    atom: &Atom,
 +    input_map: &HashMap<InputId, &ObjectFile>,
 +    resolve: &ResolveView<'_>,
 +) -> Result<Option<u64>, RelocError> {
 +    for (&origin, obj) in input_map {
 +        let Some(init_symbol) = matching_tlv_init_symbol(obj, owner)? else {
 +            continue;
 +        };
 +        return Ok(Some(resolve_input_symbol_at_origin(
 +            origin,
 +            obj,
 +            atom,
 +            RelocKind::Unsigned,
 +            init_symbol,
 +            resolve,
 +        )?));
 +    }
 +    Ok(None)
 +}
++
 +fn resolve_tlv_descriptor_referent(
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    reloc: Reloc,
 +    resolve: &ResolveView<'_>,
 +) -> Result<u64, RelocError> {
 +    match reloc.referent {
 +        Referent::Section(section_idx) => resolve
 +            .section_addrs
 +            .get(&(atom.origin, section_idx))
 +            .copied()
 +            .ok_or_else(|| {
 +                reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    reloc.offset.saturating_sub(atom.input_offset),
 +                    reloc.kind,
 +                    &format!("section #{section_idx}"),
 +                    "TLV descriptor referent section was not laid out".to_string(),
 +                )
 +            }),
 +        Referent::Symbol(sym_idx) => {
 +            let input_sym = obj.symbols.get(sym_idx as usize).ok_or_else(|| {
 +                reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    reloc.offset.saturating_sub(atom.input_offset),
 +                    reloc.kind,
 +                    &format!("symbol #{sym_idx}"),
 +                    "TLV descriptor symbol index is out of range".to_string(),
 +                )
 +            })?;
 +            resolve_input_symbol_at_origin(atom.origin, obj, atom, reloc.kind, input_sym, resolve)
 +        }
 +    }
 +}
++
 +fn synthesize_got_section(
 +    layout: &mut Layout,
 +    plan: &SyntheticPlan,
 +    resolve: &ResolveView<'_>,
 +) -> Result<(), RelocError> {
 +    let Some(section) = layout
 +        .sections
 +        .iter_mut()
 +        .find(|section| section.segment == "__DATA_CONST" && section.name == "__got")
 +    else {
 +        return Ok(());
 +    };
++
 +    for (idx, entry) in plan.got.entries.iter().enumerate() {
 +        let start = idx * 8;
 +        let end = start + 8;
 +        let value = match resolve.sym_table.get(entry.symbol) {
 +            Symbol::DylibImport { .. } => 0,
 +            Symbol::Defined {
 +                atom: target_atom,
 +                value,
 +                ..
 +            } => {
 +                resolve
 +                    .atom_addrs
 +                    .get(target_atom)
 +                    .copied()
 +                    .ok_or_else(|| RelocError {
 +                        input: PathBuf::from("<synthetic got>"),
 +                        atom: crate::resolve::AtomId(0),
 +                        atom_offset: start as u32,
 +                        kind: RelocKind::PointerToGot,
 +                        referent: format!("symbol {:?}", entry.symbol),
 +                        detail: "defined GOT target is missing final address".to_string(),
 +                    })?
 +                    + *value
 +            }
 +            other => {
 +                return Err(RelocError {
 +                    input: PathBuf::from("<synthetic got>"),
 +                    atom: crate::resolve::AtomId(0),
 +                    atom_offset: start as u32,
 +                    kind: RelocKind::PointerToGot,
 +                    referent: format!("symbol {:?}", entry.symbol),
 +                    detail: format!(
 +                        "synthetic GOT currently does not support symbol kind {:?}",
 +                        other.kind()
 +                    ),
 +                });
 +            }
 +        };
 +        section.synthetic_data[start..end].copy_from_slice(&value.to_le_bytes());
 +    }
++
 +    Ok(())
 +}
++
  fn synthesize_stub_section(
      layout: &mut Layout,
      plan: &SyntheticPlan,
      fn load_store_pageoff_uses_size_scaling() {
          let insn = 0xf940_0000u32;
          assert!(!is_add_immediate(insn));
 -        let shift = (insn >> 30) & 0b11;
 +        let shift = pageoff_load_store_shift(insn);
          assert_eq!(shift, 0b11);
          let pageoff = 0x3f8u64;
          let imm = pageoff >> shift;
          assert_eq!((patched >> 10) & 0xfff, 0x7f);
+     }
 +    #[test]
 +    fn simd_q_pageoff_uses_16_byte_scaling() {
 +        let insn = 0x3dc0_0100u32;
 +        assert!(!is_add_immediate(insn));
 +        assert!(is_simd_fp_pageoff(insn));
 +        let shift = pageoff_load_store_shift(insn);
 +        assert_eq!(shift, 4);
 +        let pageoff = 0x690u64;
 +        let imm = pageoff >> shift;
 +        let patched = (insn & !(0xfff << 10)) | ((imm as u32) << 10);
 +        assert_eq!((patched >> 10) & 0xfff, 0x69);
 +        assert_eq!(patched, 0x3dc1_a500);
 +    }
++
      #[test]
      fn signed_fit_helper_matches_branch_range() {
          assert!(fits_signed((1 << 25) - 1, 26));

src/resolve.rsmodified

  #[derive(Debug)]
  pub struct ObjectInput {
      pub path: PathBuf,
 +    pub load_order: usize,
 +    pub archive_member_offset: Option<u32>,
      /// Raw bytes; `ObjectFile::parse` re-runs cheaply against this on
      /// demand. We don't cache a parsed view because `ObjectFile` copies
      /// the fields it needs on construction, so re-parse is idempotent.
  #[derive(Debug)]
  pub struct ArchiveInput {
      pub path: PathBuf,
 +    pub load_order: usize,
      pub bytes: Vec<u8>,
      /// Members we've already fetched (keyed by `ar_hdr` offset). Prevents
      /// the fixed-point loop from re-ingesting the same object twice —
      /// Register an `.o` file. Validates the Mach-O header by parsing once,
      /// then keeps only the raw bytes (re-parsing on demand is cheap and
      /// sidesteps borrow-lifetime headaches).
 -    pub fn add_object(&mut self, path: PathBuf, bytes: Vec<u8>) -> Result<InputId, InputAddError> {
 +    pub fn add_object(
 +        &mut self,
 +        path: PathBuf,
 +        bytes: Vec<u8>,
 +        load_order: usize,
 +    ) -> Result<InputId, InputAddError> {
          // Validate now — we'd rather catch a bad object at the add site.
          ObjectFile::parse(&path, &bytes)?;
          let id = InputId(self.objects.len() as u32);
 -        self.objects.push(ObjectInput { path, bytes });
 +        self.objects.push(ObjectInput {
 +            path,
 +            load_order,
 +            archive_member_offset: None,
 +            bytes,
 +        });
          Ok(id)
+     }
          &mut self,
          path: PathBuf,
          bytes: Vec<u8>,
 +        load_order: usize,
      ) -> Result<ArchiveId, InputAddError> {
          Archive::open(&path, &bytes)?; // validate
          let id = ArchiveId(self.archives.len() as u32);
          self.archives.push(ArchiveInput {
              path,
 +            load_order,
              bytes,
              fetched: std::collections::HashSet::new(),
          });
      member_id: MemberId,
      report: &mut DrainReport,
  ) -> Result<Vec<PendingFetch>, FetchError> {
 +    let archive_load_order = inputs.archives[archive_id.0 as usize].load_order;
      let ai = &inputs.archives[archive_id.0 as usize];
      if ai.fetched.contains(&member_id.0) {
          return Ok(Vec::new());
      let input_id = InputId(inputs.objects.len() as u32);
      inputs.objects.push(ObjectInput {
          path: PathBuf::from(logical_path),
 +        load_order: archive_load_order,
 +        archive_member_offset: Some(member_id.0),
          bytes: member_bytes,
      });
      report.fetched_members += 1;

src/section.rsmodified

      Text,
      /// Regular data (`S_REGULAR` with none of the attribute markers).
      Data,
 -    /// `__TEXT,__const` — immutable data.
 +    /// Immutable data such as `__TEXT,__const` or `__DATA_CONST,__const`.
      ConstData,
      /// `__TEXT,__cstring` (`S_CSTRING_LITERALS`).
      CStringLiterals,
      if flags & S_ATTR_PURE_INSTRUCTIONS != 0 {
          return SectionKind::Text;
+     }
 -    if segname == "__TEXT" && sectname == "__const" {
 +    if sectname == "__const" && matches!(segname, "__TEXT" | "__DATA" | "__DATA_CONST") {
          return SectionKind::ConstData;
+     }
      SectionKind::Data

src/synth/dyld_info.rsmodified

  use crate::leb::{write_sleb, write_uleb};
  use crate::macho::constants::{
      BIND_IMMEDIATE_MASK, BIND_OPCODE_ADD_ADDR_ULEB, BIND_OPCODE_DO_BIND,
 -    BIND_OPCODE_SET_ADDEND_SLEB, BIND_OPCODE_SET_DYLIB_ORDINAL_IMM,
 -    BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB, BIND_OPCODE_SET_DYLIB_SPECIAL_IMM,
 -    BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
 -    BIND_OPCODE_SET_TYPE_IMM, BIND_SYMBOL_FLAGS_WEAK_IMPORT, BIND_TYPE_POINTER,
 -    REBASE_IMMEDIATE_MASK, REBASE_OPCODE_DO_REBASE_IMM_TIMES, REBASE_OPCODE_DO_REBASE_ULEB_TIMES,
 +    BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB, BIND_OPCODE_SET_ADDEND_SLEB,
 +    BIND_OPCODE_SET_DYLIB_ORDINAL_IMM, BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB,
 +    BIND_OPCODE_SET_DYLIB_SPECIAL_IMM, BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
 +    BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, BIND_OPCODE_SET_TYPE_IMM,
 +    BIND_SYMBOL_FLAGS_WEAK_IMPORT, BIND_TYPE_POINTER, REBASE_IMMEDIATE_MASK,
 +    REBASE_OPCODE_DO_REBASE_IMM_TIMES, REBASE_OPCODE_DO_REBASE_ULEB_TIMES,
  };
  use crate::macho::exports::{ExportEntry, ExportKind};
      let mut state = BindState::default();
      let mut current_symbol: Option<String> = None;
 -    for spec in specs {
 +    let mut idx = 0usize;
 +    while idx < specs.len() {
 +        let spec = specs[idx];
          if state.ordinal != Some(spec.ordinal) {
              emit_bind_ordinal(&mut out, spec.ordinal);
              state.ordinal = Some(spec.ordinal);
+             }
+         }
 -        out.byte(BIND_OPCODE_DO_BIND);
 +        let run_len = bind_run_len(specs, idx);
 +        if run_len > 1 {
 +            let stride = specs[idx + 1].segment_offset - spec.segment_offset;
 +            let skip = stride - 8;
 +            out.byte(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
 +            out.uleb(run_len as u64);
 +            out.uleb(skip);
 +            state.next_segment_offset = Some(spec.segment_offset + (run_len as u64) * stride);
 +            idx += run_len;
 +        } else {
 +            out.byte(BIND_OPCODE_DO_BIND);
 +            state.next_segment_offset = Some(spec.segment_offset + 8);
 +            idx += 1;
 +        }
          state.segment_index = Some(spec.segment_index);
 -        state.next_segment_offset = Some(spec.segment_offset + 8);
+     }
      if specs.last().is_some_and(|spec| spec.terminate) {
+     }
+ }
 +fn bind_run_len(specs: &[BindRecordSpec<'_>], start: usize) -> usize {
 +    let Some(next) = specs.get(start + 1) else {
 +        return 1;
 +    };
 +    let first = specs[start];
 +    if first.segment_index != next.segment_index
 +        || first.ordinal != next.ordinal
 +        || first.name != next.name
 +        || first.weak_import != next.weak_import
 +        || first.addend != next.addend
 +    {
 +        return 1;
 +    }
 +    let stride = next.segment_offset.saturating_sub(first.segment_offset);
 +    if stride < 8 {
 +        return 1;
 +    }
++
 +    let mut len = 2usize;
 +    while let Some(spec) = specs.get(start + len) {
 +        let expected_offset = first.segment_offset + (len as u64) * stride;
 +        if spec.segment_index != first.segment_index
 +            || spec.ordinal != first.ordinal
 +            || spec.name != first.name
 +            || spec.weak_import != first.weak_import
 +            || spec.addend != first.addend
 +            || spec.segment_offset != expected_offset
 +        {
 +            break;
 +        }
 +        len += 1;
 +    }
 +    len
 +}
++
  #[cfg(test)]
  mod tests {
      use crate::leb::{read_sleb, read_uleb};
              .any(|window| window == [BIND_OPCODE_SET_ADDEND_SLEB, 0]);
          assert!(zero_reset, "expected explicit addend reset back to zero");
+     }
++
 +    #[test]
 +    fn bind_encoder_batches_constant_stride_runs() {
 +        let stream = emit_bind_records(&[
 +            BindRecordSpec {
 +                segment_index: 3,
 +                segment_offset: 0x98,
 +                ordinal: 1,
 +                name: "__tlv_bootstrap",
 +                weak_import: false,
 +                addend: 0,
 +                terminate: false,
 +            },
 +            BindRecordSpec {
 +                segment_index: 3,
 +                segment_offset: 0xb0,
 +                ordinal: 1,
 +                name: "__tlv_bootstrap",
 +                weak_import: false,
 +                addend: 0,
 +                terminate: false,
 +            },
 +            BindRecordSpec {
 +                segment_index: 3,
 +                segment_offset: 0xc8,
 +                ordinal: 1,
 +                name: "__tlv_bootstrap",
 +                weak_import: false,
 +                addend: 0,
 +                terminate: true,
 +            },
 +        ]);
++
 +        assert!(stream.contains(&BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB));
 +        let idx = stream
 +            .iter()
 +            .position(|byte| *byte == BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB)
 +            .unwrap();
 +        assert_eq!(stream[idx + 1], 3);
 +        assert_eq!(stream[idx + 2], 0x10);
 +        assert_eq!(stream.last().copied(), Some(0));
 +    }
+ }

src/synth/mod.rsmodified

                      RelocKind::GotLoadPage21
                      | RelocKind::GotLoadPageOff12
                      | RelocKind::PointerToGot => {
 -                        let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table)
 +                        if matches!(
 +                            reloc.kind,
 +                            RelocKind::GotLoadPage21 | RelocKind::GotLoadPageOff12
 +                        ) {
 +                            let Some(symbol_id) =
 +                                dylib_import_referent(obj, reloc.referent, sym_table)
 +                            else {
 +                                continue;
 +                            };
 +                            got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
 +                            continue;
 +                        }
 +                        let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, sym_table)
                          else {
                              continue;
                          };
 +                        if matches!(reloc.kind, RelocKind::PointerToGot)
 +                            && matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. })
 +                        {
 +                            got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
 +                            continue;
 +                        }
                          got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
+                     }
                      RelocKind::Branch26 => {
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,
              &[LayoutInput {
                  id: input_id,
                  object: &object,
 +                load_order: 0,
 +                archive_member_offset: None,
              }],
              &atoms,
              &mut sym_table,

src/synth/unwind.rsmodified

              .chunks_exact(4)
              .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
              .collect();
 -        assert_eq!(words[2], 0, "all encodings are unique so nothing should be common");
 -        assert_eq!(words[6], 3, "expected the encoding pressure to force a second page");
 +        assert_eq!(
 +            words[2], 0,
 +            "all encodings are unique so nothing should be common"
 +        );
 +        assert_eq!(
 +            words[6], 3,
 +            "expected the encoding pressure to force a second page"
 +        );
          let decoded = decode_unwind_info(&bytes).unwrap();
          assert_eq!(decoded.records.len(), records.len());
          assert_eq!(decoded.records[0].function_offset, 0x400);
 -        assert_eq!(decoded.records.last().unwrap().function_offset, 0x400 + 299 * 4);
 +        assert_eq!(
 +            decoded.records.last().unwrap().function_offset,
 +            0x400 + 299 * 4
 +        );
+     }
      #[test]

tests/atom_integration.rsmodified

      let bytes = fs::read(&obj_path).unwrap();
      let mut inputs = Inputs::new();
 -    let input_id = inputs.add_object(obj_path.clone(), bytes).unwrap();
 +    let input_id = inputs.add_object(obj_path.clone(), bytes, 0).unwrap();
      // Seed the symbol table (produces Defined entries with AtomId(0)
      // placeholders).
      let bytes = fs::read(&obj_path).unwrap();
      let mut inputs = Inputs::new();
 -    let input_id = inputs.add_object(obj_path.clone(), bytes).unwrap();
 +    let input_id = inputs.add_object(obj_path.clone(), bytes, 0).unwrap();
      let mut sym_table = SymbolTable::new();
      let _ = seed_all(&inputs, &mut sym_table).expect("seed_all");
      let obj = inputs.object_file(input_id).unwrap();

tests/linker_run.rsmodified

      BIND_OPCODE_SET_DYLIB_ORDINAL_IMM, BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB,
      BIND_OPCODE_SET_DYLIB_SPECIAL_IMM, BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
      BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, BIND_OPCODE_SET_TYPE_IMM,
 -    BIND_SYMBOL_FLAGS_WEAK_IMPORT, DICE_KIND_JUMP_TABLE32, LC_BUILD_VERSION, LC_DATA_IN_CODE,
 -    LC_DYLD_INFO_ONLY, LC_DYSYMTAB, LC_FUNCTION_STARTS, LC_SEGMENT_64, LC_SYMTAB,
 +    BIND_SYMBOL_FLAGS_WEAK_IMPORT, DICE_KIND_JUMP_TABLE32, INDIRECT_SYMBOL_ABS,
 +    INDIRECT_SYMBOL_LOCAL, LC_BUILD_VERSION, LC_DATA_IN_CODE, LC_DYLD_INFO_ONLY, LC_DYSYMTAB,
 +    LC_FUNCTION_STARTS, LC_SEGMENT_64, LC_SYMTAB,
      REBASE_IMMEDIATE_MASK, REBASE_OPCODE_ADD_ADDR_IMM_SCALED, REBASE_OPCODE_ADD_ADDR_ULEB,
      REBASE_OPCODE_DONE, REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB, REBASE_OPCODE_DO_REBASE_IMM_TIMES,
      REBASE_OPCODE_DO_REBASE_ULEB_TIMES, REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB,
      Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
+ }
 +fn find_runtime_archive() -> Option<PathBuf> {
 +    let workspace = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..");
 +    for profile in ["debug", "release"] {
 +        let candidate = workspace
 +            .join("target")
 +            .join(profile)
 +            .join("libarmfortas_rt.a");
 +        if candidate.is_file() {
 +            return Some(candidate);
 +        }
 +    }
 +    None
 +}
++
  fn have_xcrun_tool(tool: &str) -> bool {
      Command::new("xcrun")
          .arg("-f")
      None
+ }
 +fn symbol_values(bytes: &[u8]) -> HashMap<String, u64> {
 +    let header = parse_header(bytes).unwrap();
 +    let commands = parse_commands(&header, bytes).unwrap();
 +    let symtab = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Symtab(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .unwrap();
 +    let symbols = parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).unwrap();
 +    let strings = StringTable::from_file(bytes, symtab.stroff, symtab.strsize).unwrap();
 +    let mut out = HashMap::new();
 +    for symbol in symbols {
 +        let Ok(name) = strings.get(symbol.strx()) else {
 +            continue;
 +        };
 +        out.insert(name.to_string(), symbol.value());
 +    }
 +    out
 +}
++
  fn symtab_and_dysymtab(
      bytes: &[u8],
  ) -> (
          .collect()
+ }
 +fn indirect_symbol_identities(bytes: &[u8]) -> Vec<String> {
 +    let (symtab, _) = symtab_and_dysymtab(bytes);
 +    let symbols = parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).unwrap();
 +    let strings = StringTable::from_file(bytes, symtab.stroff, symtab.strsize).unwrap();
 +    indirect_symbol_table(bytes)
 +        .into_iter()
 +        .map(|index| {
 +            if index & INDIRECT_SYMBOL_LOCAL != 0 {
 +                if index & INDIRECT_SYMBOL_ABS != 0 {
 +                    "<LOCAL|ABS>".to_string()
 +                } else {
 +                    "<LOCAL>".to_string()
 +                }
 +            } else if index & INDIRECT_SYMBOL_ABS != 0 {
 +                "<ABS>".to_string()
 +            } else {
 +                let symbol = &symbols[index as usize];
 +                strings.get(symbol.strx()).unwrap().to_string()
 +            }
 +        })
 +        .collect()
 +}
++
  fn raw_linkedit_data_cmd(bytes: &[u8], expected_cmd: u32) -> (u32, u32) {
      let header = parse_header(bytes).unwrap();
      let commands = parse_commands(&header, bytes).unwrap();
      let _ = fs::remove_file(apple_out);
+ }
 +#[test]
 +fn linker_run_routes_local_got_loads_through_rebased_slots() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("local-got.o");
 +    let our_out = scratch("local-got-ours.out");
 +    let apple_out = scratch("local-got-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x8, _value@GOTPAGE
 +            ldr x8, [x8, _value@GOTPAGEOFF]
 +            ldr w0, [x8]
 +            ret
++
 +        .section __DATA,__data
 +        .globl _value
 +        .p2align 2
 +        _value:
 +            .long 7
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let our_binds = decode_bind_records(&our_bytes, false).unwrap();
 +    let apple_binds = decode_bind_records(&apple_bytes, false).unwrap();
 +    assert_eq!(our_binds, apple_binds);
 +    assert!(
 +        our_binds.iter().all(|record| record.symbol != "_value"),
 +        "local GOT target should not be emitted as a dylib bind: {our_binds:#?}"
 +    );
 +    assert_eq!(
 +        output_section(&our_bytes, "__DATA_CONST", "__got")
 +            .expect("missing __got section")
 +            .1
 +            .len(),
 +        8
 +    );
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(7),
 +        "expected local GOT executable to exit 7"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_relaxes_hidden_got_loads_like_apple_ld() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("hidden-got.o");
 +    let our_out = scratch("hidden-got-ours.out");
 +    let apple_out = scratch("hidden-got-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x8, _value@GOTPAGE
 +            ldr x8, [x8, _value@GOTPAGEOFF]
 +            ldr w0, [x8]
 +            ret
++
 +        .private_extern _value
 +        .section __DATA,__data
 +        .p2align 2
 +        _value:
 +            .long 7
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 +    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 +    assert_eq!(
 +        decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 +        decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add).unwrap()
 +    );
 +    assert_eq!(our_text, apple_text);
 +    assert!(output_section(&our_bytes, "__DATA_CONST", "__got").is_none());
 +    assert!(output_section(&apple_bytes, "__DATA_CONST", "__got").is_none());
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(7),
 +        "expected hidden GOT executable to exit 7"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
  #[test]
  fn linker_run_partitions_symtab_like_ld() {
      if !have_xcrun() {
      assert_eq!(our_output.status.code(), Some(0));
      assert_eq!(apple_output.status.code(), Some(0));
 -    assert!(our_stdout.contains("helper"), "expected helper in output: {our_stdout}");
 -    assert!(our_stdout.contains("main"), "expected main in output: {our_stdout}");
 +    assert!(
 +        our_stdout.contains("helper"),
 +        "expected helper in output: {our_stdout}"
 +    );
 +    assert!(
 +        our_stdout.contains("main"),
 +        "expected main in output: {our_stdout}"
 +    );
      assert!(
          apple_stdout.contains("helper"),
          "expected helper in apple output: {apple_stdout}"
      let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(apple_out);
+ }
++
 +#[test]
 +fn linker_run_preserves_runtime_tlv_descriptor_offsets() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(runtime) = find_runtime_archive() else {
 +        eprintln!("skipping: libarmfortas_rt.a not built");
 +        return;
 +    };
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: no macOS SDK path");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: no macOS SDK version");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("runtime-hello.o");
 +    let out = scratch("runtime-hello.out");
 +    let apple_out = scratch("runtime-hello-apple.out");
 +    let src = r#"
 +        extern void afs_program_init(void);
 +        extern void afs_program_finalize(void);
 +        extern void afs_write_string(int, const char *, long);
 +        extern void afs_write_newline(int);
++
 +        int main(void) {
 +            afs_program_init();
 +            afs_write_string(6, "Hello, World!", 13);
 +            afs_write_newline(6);
 +            afs_program_finalize();
 +            return 0;
 +        }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), runtime.clone(), tbd],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args([
 +            "ld",
 +            "-arch",
 +            "arm64",
 +            "-platform_version",
 +            "macos",
 +            &sdk_ver,
 +            &sdk_ver,
 +            "-syslibroot",
 +            &sdk,
 +            "-lSystem",
 +            "-e",
 +            "_main",
 +            "-no_fixup_chains",
 +            "-o",
 +        ])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&runtime)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
++
 +    let bytes = fs::read(&out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert!(
 +        output_section(&bytes, "__DATA_CONST", "__const").is_some(),
 +        "runtime hello should promote file-backed __const data into __DATA_CONST"
 +    );
 +    assert!(
 +        output_section(&bytes, "__DATA", "__const").is_none(),
 +        "runtime hello should not leave file-backed __const data in __DATA"
 +    );
 +    let (thread_vars_addr, thread_vars) =
 +        output_section(&bytes, "__DATA", "__thread_vars").unwrap();
 +    let (thread_data_addr, _) = output_section(&bytes, "__DATA", "__thread_data").unwrap();
 +    let symbols = symbol_values(&bytes);
 +    let tlv_binds: Vec<_> = decode_bind_records(&bytes, false)
 +        .unwrap()
 +        .into_iter()
 +        .filter(|record| record.section == "__thread_vars")
 +        .collect();
 +    assert_eq!(
 +        tlv_binds.len(),
 +        thread_vars.len() / 24,
 +        "every TLV descriptor should carry exactly one bootstrap bind"
 +    );
 +    assert!(tlv_binds
 +        .iter()
 +        .all(|record| record.symbol == "__tlv_bootstrap"));
++
 +    assert_eq!(
 +        decode_bind_records(&bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap(),
 +        "runtime hello bind records diverged from Apple ld"
 +    );
 +    assert_eq!(
 +        decode_bind_records(&bytes, true).unwrap(),
 +        decode_bind_records(&apple_bytes, true).unwrap(),
 +        "runtime hello lazy-bind records diverged from Apple ld"
 +    );
 +    assert_eq!(
 +        decode_rebase_records(&bytes).unwrap(),
 +        decode_rebase_records(&apple_bytes).unwrap(),
 +        "runtime hello rebase records diverged from Apple ld"
 +    );
 +    assert_eq!(
 +        indirect_symbol_identities(&bytes),
 +        indirect_symbol_identities(&apple_bytes),
 +        "runtime hello indirect symbol identities diverged from Apple ld"
 +    );
++
 +    for (name, descriptor_addr) in symbols.iter().filter(|(name, value)| {
 +        !name.ends_with("$tlv$init")
 +            && **value >= thread_vars_addr
 +            && **value < thread_vars_addr + thread_vars.len() as u64
 +    }) {
 +        let init_name = format!("{name}$tlv$init");
 +        let Some(init_addr) = symbols.get(&init_name) else {
 +            continue;
 +        };
 +        let offset = (*descriptor_addr - thread_vars_addr) as usize;
 +        let actual = u64::from_le_bytes(thread_vars[offset + 16..offset + 24].try_into().unwrap());
 +        let expected = init_addr - thread_data_addr;
 +        assert_eq!(
 +            actual, expected,
 +            "TLV descriptor {} should point at {} via template offset",
 +            name, init_name
 +        );
 +    }
++
 +    let output = Command::new(&out).output().unwrap();
 +    let apple_output = Command::new(&apple_out).output().unwrap();
 +    assert_eq!(
 +        output.status.code(),
 +        Some(0),
 +        "expected runtime hello executable to exit 0, stderr={}",
 +        String::from_utf8_lossy(&output.stderr)
 +    );
 +    assert_eq!(
 +        apple_output.status.code(),
 +        Some(0),
 +        "expected Apple-linked runtime hello executable to exit 0, stderr={}",
 +        String::from_utf8_lossy(&apple_output.stderr)
 +    );
 +    assert_eq!(
 +        String::from_utf8_lossy(&output.stdout),
 +        String::from_utf8_lossy(&apple_output.stdout)
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_rebases_runtime_init_metadata_like_apple_ld() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(runtime) = find_runtime_archive() else {
 +        eprintln!("skipping: libarmfortas_rt.a not built");
 +        return;
 +    };
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: no macOS SDK path");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: no macOS SDK version");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("runtime-init-only.o");
 +    let our_out = scratch("runtime-init-only-ours.out");
 +    let apple_out = scratch("runtime-init-only-apple.out");
 +    let src = r#"
 +        extern void afs_program_init(void);
++
 +        int main(void) {
 +            afs_program_init();
 +            return 0;
 +        }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), runtime.clone(), tbd],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args([
 +            "ld",
 +            "-arch",
 +            "arm64",
 +            "-platform_version",
 +            "macos",
 +            &sdk_ver,
 +            &sdk_ver,
 +            "-syslibroot",
 +            &sdk,
 +            "-lSystem",
 +            "-e",
 +            "_main",
 +            "-no_fixup_chains",
 +            "-o",
 +        ])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&runtime)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let our_rebases = decode_rebase_records(&our_bytes).unwrap();
 +    let apple_rebases = decode_rebase_records(&apple_bytes).unwrap();
 +    assert_eq!(
 +        our_rebases
 +            .iter()
 +            .filter(|record| record.section == "__const")
 +            .count(),
 +        apple_rebases
 +            .iter()
 +            .filter(|record| record.section == "__const")
 +            .count(),
 +        "runtime init const rebases diverged from Apple ld"
 +    );
 +    assert_eq!(
 +        our_rebases
 +            .iter()
 +            .filter(|record| record.section == "__la_symbol_ptr")
 +            .count(),
 +        apple_rebases
 +            .iter()
 +            .filter(|record| record.section == "__la_symbol_ptr")
 +            .count(),
 +        "runtime init lazy-pointer rebases diverged from Apple ld"
 +    );
++
 +    let our_status = Command::new(&our_out).status().unwrap();
 +    let apple_status = Command::new(&apple_out).status().unwrap();
 +    assert_eq!(our_status.code(), Some(0));
 +    assert_eq!(apple_status.code(), Some(0));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}

tests/resolve_integration.rsmodified

      // Register the inputs with the resolver.
      let mut inputs = Inputs::new();
      let a_id = inputs
 -        .add_object(a_o.clone(), fs::read(&a_o).unwrap())
 +        .add_object(a_o.clone(), fs::read(&a_o).unwrap(), 0)
          .unwrap();
      inputs
 -        .add_object(b_o.clone(), fs::read(&b_o).unwrap())
 +        .add_object(b_o.clone(), fs::read(&b_o).unwrap(), 1)
          .unwrap();
      let archive_id = inputs
 -        .add_archive(libtest.clone(), fs::read(&libtest).unwrap())
 +        .add_archive(libtest.clone(), fs::read(&libtest).unwrap(), 2)
          .unwrap();
      let _ = archive_id;