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.

16 commits 15 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
Tighten unwind byte parity e0ad541 espadonne committed 3 weeks ago
Cap unwind page compression 718cb1c espadonne committed 3 weeks ago
Check unwind runtime behavior 37faef0 espadonne committed 3 weeks ago
Default executable entry to _main 6d5122b espadonne committed 3 weeks ago
Match executable command layout fa8751a espadonne committed 3 weeks ago
Default TBD load versions d5f8b82 espadonne committed 3 weeks ago
Tighten backtrace metadata parity 73aafdf 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

      seed_all, DylibLoadMeta, InputAddError, Inputs, Symbol, SymbolTable, UndefinedTreatment,
  };
 +const DEFAULT_TBD_VERSION: u32 = 1 << 16;
++
  /// What kind of Mach-O file the linker is producing.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  pub enum OutputKind {
+         }
          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)?;
                      .current_version
                      .as_deref()
                      .map(parse_version)
 -                    .unwrap_or(0),
 +                    .unwrap_or(DEFAULT_TBD_VERSION),
                  compatibility_version: canonical
                      .compatibility_version
                      .as_deref()
                      .map(parse_version)
 -                    .unwrap_or(0),
 +                    .unwrap_or(DEFAULT_TBD_VERSION),
                  ordinal: inputs.next_dylib_ordinal(),
              };
              let mut loaded = false;
+             }
+         }
          _ => {
 -            let _ = inputs.add_object(path.to_path_buf(), bytes)?;
 +            let _ = inputs.add_object(path.to_path_buf(), bytes, load_order)?;
+         }
+     }
      Ok(())
      opts: &LinkOptions,
      sym_table: &SymbolTable,
  ) -> Result<Option<macho::writer::EntryPoint>, LinkError> {
 -    let Some(name) = &opts.entry else {
 +    let name = if let Some(name) = &opts.entry {
 +        name.as_str()
 +    } else if opts.kind == OutputKind::Executable {
 +        if symbol_defined(sym_table, "_main") {
 +            "_main"
 +        } else if symbol_defined(sym_table, "_start") {
 +            "_start"
 +        } else {
 +            return Ok(None);
 +        }
 +    } else {
          return Ok(None);
      };
      let Some((symbol_id, _)) = sym_table
          .iter()
          .find(|(_, symbol)| sym_table.interner.resolve(symbol.name()) == name)
      else {
 -        return Err(LinkError::EntrySymbolNotFound(name.clone()));
 +        return Err(LinkError::EntrySymbolNotFound(name.to_string()));
      };
      let Symbol::Defined { atom, value, .. } = sym_table.get(symbol_id) else {
 -        return Err(LinkError::EntrySymbolNotFound(name.clone()));
 +        return Err(LinkError::EntrySymbolNotFound(name.to_string()));
      };
      Ok(Some(macho::writer::EntryPoint {
          atom: *atom,
          atom_value: *value,
      }))
+ }
++
 +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 { .. })
 +    })
 +}

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/dylib.rsmodified

  };
  use super::tbd::{parse_version, SymbolLists, Target, Tbd};
 +const DEFAULT_TBD_VERSION: u32 = 1 << 16;
++
  /// How a consumer loaded this dylib. The filetype of the dylib itself is
  /// always `MH_DYLIB`; this kind captures the *relationship*.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
                  .current_version
                  .as_deref()
                  .map(parse_version)
 -                .unwrap_or(0),
 +                .unwrap_or(DEFAULT_TBD_VERSION),
              compatibility_version: tbd
                  .compatibility_version
                  .as_deref()
                  .map(parse_version)
 -                .unwrap_or(0),
 +                .unwrap_or(DEFAULT_TBD_VERSION),
              dependencies,
              rpaths: Vec::new(),
              symtab: None,

src/macho/writer.rsmodified

          )?));
+     }
 -    commands.push(LoadCommand::BuildVersion(BuildVersionCmd {
 -        platform: PLATFORM_MACOS,
 -        minos: pack_version(11, 0, 0),
 -        sdk: pack_version(11, 0, 0),
 -        tools: vec![BuildTool {
 -            tool: 3,
 -            version: pack_version(0, 1, 0),
 -        }],
 -    }));
 -    commands.push(raw_uuid_command(stable_uuid(layout, kind)));
+-
      match kind {
          OutputKind::Executable => {
 +            commands.push(LoadCommand::DyldInfoOnly(linkedit.dyld_info));
 +            commands.push(LoadCommand::Symtab(linkedit.symtab));
 +            commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
              commands.push(raw_dylinker_command("/usr/lib/dyld"));
 +            commands.push(raw_uuid_command(stable_uuid(layout, kind)));
 +            commands.push(LoadCommand::BuildVersion(BuildVersionCmd {
 +                platform: PLATFORM_MACOS,
 +                minos: pack_version(11, 0, 0),
 +                sdk: pack_version(11, 0, 0),
 +                tools: vec![BuildTool {
 +                    tool: 3,
 +                    version: pack_version(0, 1, 0),
 +                }],
 +            }));
 +            commands.push(raw_source_version_command(0));
              commands.push(raw_entry_point(resolve_entryoff(layout, entry_point)?, 0));
+         }
 -        OutputKind::Dylib => commands.push(LoadCommand::Dylib(DylibCmd {
 -            cmd: LC_ID_DYLIB,
 -            name: dylib_install_name(opts),
 -            timestamp: 2,
 -            current_version: pack_version(1, 0, 0),
 -            compatibility_version: pack_version(1, 0, 0),
 -        })),
 +        OutputKind::Dylib => {
 +            commands.push(LoadCommand::BuildVersion(BuildVersionCmd {
 +                platform: PLATFORM_MACOS,
 +                minos: pack_version(11, 0, 0),
 +                sdk: pack_version(11, 0, 0),
 +                tools: vec![BuildTool {
 +                    tool: 3,
 +                    version: pack_version(0, 1, 0),
 +                }],
 +            }));
 +            commands.push(raw_uuid_command(stable_uuid(layout, kind)));
 +            commands.push(LoadCommand::Dylib(DylibCmd {
 +                cmd: LC_ID_DYLIB,
 +                name: dylib_install_name(opts),
 +                timestamp: 2,
 +                current_version: pack_version(1, 0, 0),
 +                compatibility_version: pack_version(1, 0, 0),
 +            }));
 +        }
+     }
      for dylib in dylibs {
          }));
+     }
 -    commands.push(LoadCommand::Symtab(linkedit.symtab));
 -    commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
      commands.push(raw_linkedit_command(
          LC_FUNCTION_STARTS,
          linkedit.function_starts.dataoff,
      } else {
          commands.push(raw_linkedit_command(LC_CODE_SIGNATURE, 0, 0));
+     }
 -    commands.push(LoadCommand::DyldInfoOnly(linkedit.dyld_info));
 +    if kind == OutputKind::Dylib {
 +        commands.push(LoadCommand::DyldInfoOnly(linkedit.dyld_info));
 +        commands.push(LoadCommand::Symtab(linkedit.symtab));
 +        commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
 +    }
      Ok(commands)
+ }
      .wire_size() as u64;
      size += 24;
      size += match kind {
 -        OutputKind::Executable => raw_dylinker_command("/usr/lib/dyld").cmdsize() as u64 + 24,
 +        OutputKind::Executable => {
 +            raw_dylinker_command("/usr/lib/dyld").cmdsize() as u64
 +                + 24
 +                + raw_source_version_command(0).cmdsize() as u64
 +        }
          OutputKind::Dylib => DylibCmd {
              cmd: LC_ID_DYLIB,
              name: dylib_install_name(opts),
+     }
+ }
 +fn raw_source_version_command(version: u64) -> LoadCommand {
 +    LoadCommand::Raw {
 +        cmd: LC_SOURCE_VERSION,
 +        cmdsize: 16,
 +        data: version.to_le_bytes().to_vec(),
 +    }
 +}
++
  fn raw_linkedit_command(cmd: u32, dataoff: u32, datasize: u32) -> LoadCommand {
      let mut data = Vec::with_capacity(8);
      data.extend_from_slice(&dataoff.to_le_bytes());
          .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);
      let weak_bind_bytes = pad_dyld_info_stream(bind_streams.weak_bind);
      let lazy_bind_bytes = pad_dyld_info_stream(bind_streams.lazy_bind);
      let export_bytes = pad_dyld_info_stream(build_export_trie(&symbol_plan.exports));
 -    let function_starts_bytes = build_function_starts(layout, inputs.0.atom_table)?;
 +    let function_starts_bytes =
 +        build_function_starts(layout, inputs.0.layout_inputs, inputs.0.atom_table)?;
      let data_in_code_bytes =
          build_data_in_code(layout, inputs.0.layout_inputs, inputs.0.atom_table)?;
      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),
 +            }
 +        }
+     }
+ }
      Some(symbol_id)
+ }
 -fn build_function_starts(layout: &Layout, atom_table: &AtomTable) -> Result<Vec<u8>, WriteError> {
 +fn build_function_starts(
 +    layout: &Layout,
 +    inputs: &[LayoutInput<'_>],
 +    atom_table: &AtomTable,
 +) -> Result<Vec<u8>, WriteError> {
      let image_base = layout
          .segment("__TEXT")
          .ok_or(WriteError::MissingSegment("__TEXT"))?
          .vm_addr;
 +    let input_map: HashMap<InputId, &ObjectFile> = inputs
 +        .iter()
 +        .map(|input| (input.id, input.object))
 +        .collect();
      let mut starts = Vec::new();
      for section in &layout.sections {
                      section.addr + placed.offset + alt.offset_within_atom as u64 - image_base,
                  );
+             }
 +            let Some(object) = input_map.get(&atom.origin) else {
 +                continue;
 +            };
 +            let Some(input_section) = object
 +                .sections
 +                .get((atom.input_section as usize).saturating_sub(1))
 +            else {
 +                continue;
 +            };
 +            let atom_start = input_section.addr + atom.input_offset as u64;
 +            let atom_end = atom_start + atom.size as u64;
 +            for input_sym in &object.symbols {
 +                if input_sym.stab_kind().is_some()
 +                    || input_sym.kind() != SymKind::Sect
 +                    || input_sym.alt_entry()
 +                    || input_sym.sect_idx() != atom.input_section
 +                {
 +                    continue;
 +                }
 +                let Ok(name) = object.symbol_name(input_sym) else {
 +                    continue;
 +                };
 +                if is_assembler_temporary_symbol(name) {
 +                    continue;
 +                }
 +                let value = input_sym.value();
 +                if !(atom_start < value && value < atom_end) {
 +                    continue;
 +                }
 +                starts.push(section.addr + placed.offset + (value - atom_start) - image_base);
 +            }
+         }
+     }
          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)
              ],
          };
 -        let blob = build_function_starts(&layout, &atoms).unwrap();
 +        let blob = build_function_starts(&layout, &[], &atoms).unwrap();
          assert_eq!(
              decode_function_starts_blob(&blob),
              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

  const UNWIND_INFO_VERSION: u32 = 1;
  const UNWIND_SECOND_LEVEL_REGULAR: u32 = 2;
  const UNWIND_SECOND_LEVEL_COMPRESSED: u32 = 3;
 +const MAX_COMPRESSED_FUNCTION_DELTA: u32 = 0x00ff_ffff;
 +const MAX_COMPRESSED_ENCODING_INDEX: usize = 0xff;
  const FIRST_LEVEL_ENTRY_SIZE: usize = 12;
  const FIRST_LEVEL_INDEX_GAP_SIZE: usize = FIRST_LEVEL_ENTRY_SIZE;
  const COMPRESSED_PAGE_HEADER_SIZE: usize = 12;
  fn serialize_unwind_info(records: &[UnwindRecord]) -> Result<Vec<u8>, UnwindReadError> {
      let (records, personalities, lsdas) = finalize_unwind_records(records)?;
 -    let pages = build_pages(&records);
 +    let common_encodings = select_common_encodings(&records);
 +    let pages = build_pages(&records, &common_encodings);
      let common_encodings_offset = 7 * 4;
 -    let common_encodings_count = 0u32;
 +    let common_encodings_count = common_encodings.len() as u32;
      let personalities_offset = common_encodings_offset + common_encodings_count as usize * 4;
      let indices_offset = personalities_offset + personalities.len() * 4;
      let indices_count = (pages.len() + 1) as u32;
      out.extend_from_slice(&(indices_offset as u32).to_le_bytes());
      out.extend_from_slice(&indices_count.to_le_bytes());
 +    for encoding in &common_encodings {
 +        out.extend_from_slice(&encoding.to_le_bytes());
 +    }
      for personality in &personalities {
          out.extend_from_slice(&personality.to_le_bytes());
+     }
      Ok((finalized, personalities, lsdas))
+ }
 -fn build_pages(records: &[UnwindRecord]) -> Vec<CompressedPage> {
 +fn select_common_encodings(records: &[UnwindRecord]) -> Vec<u32> {
 +    let mut stats: HashMap<u32, (u32, usize)> = HashMap::new();
 +    for (idx, record) in records.iter().enumerate() {
 +        stats
 +            .entry(record.encoding)
 +            .and_modify(|(count, _)| *count += 1)
 +            .or_insert((1, idx));
 +    }
++
 +    let mut encodings: Vec<(u32, u32, usize)> = stats
 +        .into_iter()
 +        .filter_map(|(encoding, (count, first_seen))| {
 +            (count > 1).then_some((encoding, count, first_seen))
 +        })
 +        .collect();
 +    encodings.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.2.cmp(&b.2)));
 +    encodings.truncate(127);
 +    encodings
 +        .into_iter()
 +        .map(|(encoding, _, _)| encoding)
 +        .collect()
 +}
++
 +fn build_pages(records: &[UnwindRecord], common_encodings: &[u32]) -> Vec<CompressedPage> {
      let mut pages = Vec::new();
      let mut current: Option<CompressedPage> = None;
 +    let common_indices: HashMap<u32, usize> = common_encodings
 +        .iter()
 +        .copied()
 +        .enumerate()
 +        .map(|(idx, encoding)| (encoding, idx))
 +        .collect();
      for record in records {
 -        let page = current.get_or_insert_with(|| CompressedPage {
 -            start_function_offset: record.function_offset,
 -            entries: Vec::new(),
 -            local_encodings: Vec::new(),
 -        });
+-
 -        let mut encodings = page.local_encodings.clone();
 -        if encodings
 -            .iter()
 -            .all(|encoding| *encoding != record.encoding)
 -        {
 -            encodings.push(record.encoding);
 -        }
 -        let delta = record
 -            .function_offset
 -            .saturating_sub(page.start_function_offset);
 -        let projected_size =
 -            COMPRESSED_PAGE_HEADER_SIZE + (page.entries.len() + 1) * 4 + encodings.len() * 4;
 -        if projected_size > PAGE_SIZE && !page.entries.is_empty() {
 -            pages.push(current.take().unwrap());
 -            current = Some(CompressedPage {
 +        loop {
 +            let page = current.get_or_insert_with(|| CompressedPage {
                  start_function_offset: record.function_offset,
                  entries: Vec::new(),
                  local_encodings: Vec::new(),
              });
 -        }
 -        let page = current.as_mut().unwrap();
 -        let encoding_index = if let Some(index) = page
 -            .local_encodings
 -            .iter()
 -            .position(|encoding| *encoding == record.encoding)
 -        {
 -            index
 -        } else {
 -            page.local_encodings.push(record.encoding);
 -            page.local_encodings.len() - 1
 -        };
 -        page.entries
 -            .push(((encoding_index as u32) << 24) | (delta & 0x00ff_ffff));
 +            let needs_local_encoding = !common_indices.contains_key(&record.encoding)
 +                && page
 +                    .local_encodings
 +                    .iter()
 +                    .all(|encoding| *encoding != record.encoding);
 +            let prospective_local_count =
 +                page.local_encodings.len() + usize::from(needs_local_encoding);
 +            let delta = record
 +                .function_offset
 +                .saturating_sub(page.start_function_offset);
 +            let projected_size = COMPRESSED_PAGE_HEADER_SIZE
 +                + (page.entries.len() + 1) * 4
 +                + prospective_local_count * 4;
 +            let projected_encoding_count = common_encodings.len() + prospective_local_count;
++
 +            if !page.entries.is_empty()
 +                && (projected_size > PAGE_SIZE
 +                    || delta > MAX_COMPRESSED_FUNCTION_DELTA
 +                    || projected_encoding_count > MAX_COMPRESSED_ENCODING_INDEX + 1)
 +            {
 +                pages.push(current.take().unwrap());
 +                continue;
 +            }
++
 +            let page = current.as_mut().unwrap();
 +            let encoding_index = if let Some(index) = common_indices.get(&record.encoding) {
 +                *index
 +            } else if let Some(index) = page
 +                .local_encodings
 +                .iter()
 +                .position(|encoding| *encoding == record.encoding)
 +            {
 +                common_encodings.len() + index
 +            } else {
 +                page.local_encodings.push(record.encoding);
 +                common_encodings.len() + page.local_encodings.len() - 1
 +            };
 +            page.entries.push(((encoding_index as u32) << 24) | delta);
 +            break;
 +        }
+     }
      if let Some(page) = current {
          );
+     }
 +    #[test]
 +    fn repeated_encodings_promote_to_common_table() {
 +        let bytes = serialize_unwind_info(&[
 +            UnwindRecord {
 +                function_offset: 0x348,
 +                code_len: 0x18,
 +                encoding: 0x0400_0000,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            },
 +            UnwindRecord {
 +                function_offset: 0x360,
 +                code_len: 0x20,
 +                encoding: 0x0200_2000,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            },
 +            UnwindRecord {
 +                function_offset: 0x390,
 +                code_len: 0x10,
 +                encoding: 0x0400_0000,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            },
 +        ])
 +        .unwrap();
 +        let words: Vec<u32> = bytes
 +            .chunks_exact(4)
 +            .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
 +            .collect();
 +        assert_eq!(words[2], 1, "expected one promoted common encoding");
 +        assert_eq!(words[7], 0x0400_0000);
++
 +        let decoded = decode_unwind_info(&bytes).unwrap();
 +        assert_eq!(
 +            decoded.records,
 +            vec![
 +                DecodedUnwindRecord {
 +                    function_offset: 0x348,
 +                    encoding: 0x0400_0000,
 +                },
 +                DecodedUnwindRecord {
 +                    function_offset: 0x360,
 +                    encoding: 0x0200_2000,
 +                },
 +                DecodedUnwindRecord {
 +                    function_offset: 0x390,
 +                    encoding: 0x0400_0000,
 +                },
 +            ]
 +        );
 +    }
++
 +    #[test]
 +    fn large_function_gaps_start_new_pages_before_delta_overflow() {
 +        let bytes = serialize_unwind_info(&[
 +            UnwindRecord {
 +                function_offset: 0x348,
 +                code_len: 0x14,
 +                encoding: 0x0200_0000,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            },
 +            UnwindRecord {
 +                function_offset: 0x0100_0360,
 +                code_len: 0x14,
 +                encoding: 0x0200_0000,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            },
 +        ])
 +        .unwrap();
 +        let words: Vec<u32> = bytes
 +            .chunks_exact(4)
 +            .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
 +            .collect();
 +        assert_eq!(words[6], 3, "expected two pages plus the sentinel index");
 +        let decoded = decode_unwind_info(&bytes).unwrap();
 +        assert_eq!(
 +            decoded.records,
 +            vec![
 +                DecodedUnwindRecord {
 +                    function_offset: 0x348,
 +                    encoding: 0x0200_0000,
 +                },
 +                DecodedUnwindRecord {
 +                    function_offset: 0x0100_0360,
 +                    encoding: 0x0200_0000,
 +                },
 +            ]
 +        );
 +    }
++
 +    #[test]
 +    fn pages_split_before_encoding_index_overflow() {
 +        let records = (0..300u32)
 +            .map(|idx| UnwindRecord {
 +                function_offset: 0x400 + idx * 4,
 +                code_len: 4,
 +                encoding: 0x0200_0000 | idx,
 +                personality_offset: None,
 +                lsda_offset: None,
 +            })
 +            .collect::<Vec<_>>();
 +        let bytes = serialize_unwind_info(&records).unwrap();
 +        let words: Vec<u32> = bytes
 +            .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"
 +        );
 +        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
 +        );
 +    }
++
      #[test]
      fn decode_rejects_bad_encoding_index() {
          let mut bytes = serialize_unwind_info(&[UnwindRecord {

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

1389 lines changed — click to load

      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_DATA_IN_CODE, LC_FUNCTION_STARTS,
 +    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();
      offsets
+ }
 +fn command_ids(bytes: &[u8]) -> Vec<u32> {
 +    let header = parse_header(bytes).unwrap();
 +    let commands = parse_commands(&header, bytes).unwrap();
 +    commands
 +        .into_iter()
 +        .map(|cmd| match cmd {
 +            LoadCommand::Segment64(_) => LC_SEGMENT_64,
 +            LoadCommand::Symtab(_) => LC_SYMTAB,
 +            LoadCommand::Dysymtab(_) => LC_DYSYMTAB,
 +            LoadCommand::BuildVersion(_) => LC_BUILD_VERSION,
 +            LoadCommand::Dylib(d) => d.cmd,
 +            LoadCommand::DyldInfoOnly(_) => LC_DYLD_INFO_ONLY,
 +            LoadCommand::Raw { cmd, .. } => cmd,
 +            other => panic!("unexpected load command in command_ids helper: {other:?}"),
 +        })
 +        .collect()
 +}
++
 +fn normalize_function_start_offsets(starts: &[u64]) -> Vec<u64> {
 +    let Some(&base) = starts.first() else {
 +        return Vec::new();
 +    };
 +    starts.iter().map(|offset| offset - base).collect()
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  struct DataInCodeRecord {
      offset: u32,
      kind: u16,
+ }
 -fn normalized_unwind_words(bytes: &[u8]) -> Vec<u32> {
 +fn rebased_unwind_bytes(bytes: &[u8]) -> Vec<u8> {
 +    let header_base = segment_vmaddr(bytes, "__TEXT").unwrap_or(0);
 +    let text_base = output_section(bytes, "__TEXT", "__text").unwrap().0 - header_base;
 +    let got_range = output_section(bytes, "__DATA_CONST", "__got")
 +        .map(|(addr, data)| (addr - header_base, addr - header_base + data.len() as u64));
 +    let lsda_base =
 +        output_section(bytes, "__TEXT", "__gcc_except_tab").map(|(addr, _)| addr - header_base);
      let (_, unwind) = output_section(bytes, "__TEXT", "__unwind_info").unwrap();
 -    let decoded = decode_unwind_info(&unwind).unwrap();
 -    let mut words: Vec<u32> = unwind
 -        .chunks_exact(4)
 -        .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
 -        .collect();
 -    if words.len() < 7 {
 -        return words;
 -    }
 -    let indices_offset_words = words[5] as usize / 4;
 -    let indices_count = words[6] as usize;
 -    if indices_count == 0 || words.len() < indices_offset_words + indices_count * 3 {
 -        return words;
 +    let mut out = unwind;
 +    if out.len() < 28 {
 +        return out;
 +    }
++
 +    let personalities_offset = u32_le(&out[12..16]) as usize;
 +    let personalities_count = u32_le(&out[16..20]) as usize;
 +    let indices_offset = u32_le(&out[20..24]) as usize;
 +    let indices_count = u32_le(&out[24..28]) as usize;
++
 +    for idx in 0..personalities_count {
 +        let off = personalities_offset + idx * 4;
 +        let value = u32_le(&out[off..off + 4]) as u64;
 +        let rebased = if let Some((got_start, got_end)) = got_range {
 +            if got_start <= value && value < got_end {
 +                value - got_start
 +            } else if value >= text_base {
 +                value - text_base
 +            } else {
 +                value
 +            }
 +        } else if value >= text_base {
 +            value - text_base
 +        } else {
 +            value
 +        };
 +        out[off..off + 4].copy_from_slice(&(rebased as u32).to_le_bytes());
+     }
 -    let base = words[indices_offset_words];
++
 +    let mut lsda_offsets = Vec::with_capacity(indices_count);
      for idx in 0..indices_count {
 -        let word = indices_offset_words + idx * 3;
 -        words[word] = words[word].saturating_sub(base);
 +        let entry_off = indices_offset + idx * 12;
 +        let function_offset = u32_le(&out[entry_off..entry_off + 4]) as u64;
 +        let rebased = function_offset.saturating_sub(text_base);
 +        out[entry_off..entry_off + 4].copy_from_slice(&(rebased as u32).to_le_bytes());
 +        lsda_offsets.push(u32_le(&out[entry_off + 8..entry_off + 12]) as usize);
+     }
 -    if !decoded.records.is_empty() {
 -        assert_eq!(decoded.records[0].function_offset, base);
++
 +    if let (Some(lsda_base), Some(&start), Some(&end)) =
 +        (lsda_base, lsda_offsets.first(), lsda_offsets.last())
 +    {
 +        let mut entry_off = start;
 +        while entry_off < end {
 +            let function_offset = u32_le(&out[entry_off..entry_off + 4]) as u64;
 +            let lsda_offset = u32_le(&out[entry_off + 4..entry_off + 8]) as u64;
 +            out[entry_off..entry_off + 4]
 +                .copy_from_slice(&(function_offset.saturating_sub(text_base) as u32).to_le_bytes());
 +            out[entry_off + 4..entry_off + 8]
 +                .copy_from_slice(&(lsda_offset.saturating_sub(lsda_base) as u32).to_le_bytes());
 +            entry_off += 8;
 +        }
+     }
 -    words
++
 +    out
+ }
  fn normalized_eh_frame_dump(path: &PathBuf, text_base: u64) -> Result<String, String> {
          eprintln!("skipping: xcrun as 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 obj = scratch("main.o");
      let out = scratch("a.out");
 +    let apple_out = scratch("a-apple.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
      let bytes = fs::read(&out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
      let header = parse_header(&bytes).unwrap();
      let commands = parse_commands(&header, &bytes).unwrap();
      let mut text_size = 0u64;
      let mut has_dylinker = false;
      let mut has_uuid = false;
 +    let mut has_source_version = false;
      for cmd in commands {
          match cmd {
              LoadCommand::Segment64(seg) => {
              LoadCommand::Raw { cmd, data, .. } if cmd == afs_ld::macho::constants::LC_UUID => {
                  has_uuid = data.len() == 16 && data.iter().any(|byte| *byte != 0);
+             }
 +            LoadCommand::Raw { cmd, .. } if cmd == afs_ld::macho::constants::LC_SOURCE_VERSION => {
 +                has_source_version = true;
 +            }
              _ => {}
+         }
+     }
          "expected LC_LOAD_DYLINKER in executable output"
      );
      assert!(has_uuid, "expected LC_UUID in executable output");
 +    assert!(
 +        has_source_version,
 +        "expected LC_SOURCE_VERSION in executable output"
 +    );
 +    let our_cmds: Vec<u32> = command_ids(&bytes)
 +        .into_iter()
 +        .filter(|cmd| *cmd != afs_ld::macho::constants::LC_LOAD_DYLIB)
 +        .collect();
 +    let apple_cmds: Vec<u32> = command_ids(&apple_bytes)
 +        .into_iter()
 +        .filter(|cmd| *cmd != afs_ld::macho::constants::LC_LOAD_DYLIB)
 +        .collect();
 +    assert_eq!(our_cmds, apple_cmds);
      assert!(
          fs::metadata(&out).unwrap().permissions().mode() & 0o111 != 0,
          "expected executable output mode"
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
      let _ = fs::remove_file(out);
+ }
 +#[test]
 +fn linker_run_defaults_entry_to_main_symbol() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("default-entry.o");
 +    let out = scratch("default-entry.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            mov w0, #7
 +            ret
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "default executable entry should prefer _main over the first text atom"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
  #[test]
  fn linker_run_applies_core_arm64_relocations() {
      if !have_xcrun() {
              _ => None,
          })
          .unwrap();
 +    let libsystem_load = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Dylib(cmd)
 +                if cmd.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 +                    && cmd.name == "/usr/lib/libSystem.B.dylib" =>
 +            {
 +                Some(cmd.clone())
 +            }
 +            _ => 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 symbol_names: Vec<&str> = symbols
      assert_eq!(got_hdr.reserved1, 1);
      assert_eq!(lazy_hdr.reserved1, 3);
      assert_eq!(stubs_hdr.reserved2, 12);
 +    assert!(libsystem_load.current_version >= (1 << 16));
 +    assert_eq!(libsystem_load.compatibility_version, 1 << 16);
      assert!(dyld_info.rebase_size > 0);
      assert!(dyld_info.bind_size > 0);
      assert!(dyld_info.lazy_bind_size > 0);
+ }
  #[test]
 -fn linker_run_partitions_symtab_like_ld() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_routes_local_got_loads_through_rebased_slots() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
          return;
+     }
+-
 -    let dylib = scratch("symtab-partition.dylib");
 -    let obj = scratch("symtab-partition.o");
 -    let our_out = scratch("symtab-partition-ours.out");
 -    let apple_out = scratch("symtab-partition-apple.out");
+-
 -    let dylib_src = r#"
 -        int ext_data = 5;
 -    "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    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 asm = r#"
 -        .text
 -        .private_extern _hidden
 -        .globl _visible
 +    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
 -        .p2align 2
 -    _local:
 -        ret
 -    _hidden:
 -        ret
 -    _visible:
 -        ret
 -    _main:
 -        ret
 +        _main:
 +            adrp x8, _value@GOTPAGE
 +            ldr x8, [x8, _value@GOTPAGEOFF]
 +            ldr w0, [x8]
 +            ret
 -        .data
 -        .quad _ext_data
 +        .section __DATA,__data
 +        .globl _value
 +        .p2align 2
 +        _value:
 +            .long 7
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), dylib.clone()],
 +        inputs: vec![obj.clone(), tbd.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
+-
 -    let apple = Command::new("xcrun")
 -        .args(["ld", "-arch", "arm64", "-e", "_main", "-o"])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&dylib)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
 +    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_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 -    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
+-
 -    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 -    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 -    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 -    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 -    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 -    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 -    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
 +    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!(
 -        canonical_symbol_records(&our_bytes),
 -        canonical_symbol_records(&apple_bytes)
 +        output_section(&our_bytes, "__DATA_CONST", "__got")
 +            .expect("missing __got section")
 +            .1
 +            .len(),
 +        8
      );
 -    assert_strtab_within_five_percent(
 -        &raw_string_table(&our_bytes),
 -        &raw_string_table(&apple_bytes),
 +    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!(
 -        symbol_partition_names(&our_bytes),
 -        symbol_partition_names(&apple_bytes)
 +        status.code(),
 +        Some(7),
 +        "expected local GOT executable to exit 7"
      );
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_strips_locals_with_x_like_ld() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_relaxes_hidden_got_loads_like_apple_ld() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
          return;
+     }
+-
 -    let dylib = scratch("symtab-strip.dylib");
 -    let obj = scratch("symtab-strip.o");
 -    let our_out = scratch("symtab-strip-ours.out");
 -    let apple_out = scratch("symtab-strip-apple.out");
+-
 -    let dylib_src = r#"
 -        int ext_data = 5;
 -    "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    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 asm = r#"
 -        .text
 -        .private_extern _hidden
 -        .globl _visible
 +    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() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
++
 +    let dylib = scratch("symtab-partition.dylib");
 +    let obj = scratch("symtab-partition.o");
 +    let our_out = scratch("symtab-partition-ours.out");
 +    let apple_out = scratch("symtab-partition-apple.out");
++
 +    let dylib_src = r#"
 +        int ext_data = 5;
 +    "#;
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let asm = r#"
 +        .text
 +        .private_extern _hidden
 +        .globl _visible
 +        .globl _main
 +        .p2align 2
 +    _local:
 +        ret
 +    _hidden:
 +        ret
 +    _visible:
 +        ret
 +    _main:
 +        ret
++
 +        .data
 +        .quad _ext_data
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), dylib.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args(["ld", "-arch", "arm64", "-e", "_main", "-o"])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&dylib)
 +        .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_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 +    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
++
 +    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 +    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 +    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 +    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 +    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 +    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 +    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
 +    assert_eq!(
 +        canonical_symbol_records(&our_bytes),
 +        canonical_symbol_records(&apple_bytes)
 +    );
 +    assert_strtab_within_five_percent(
 +        &raw_string_table(&our_bytes),
 +        &raw_string_table(&apple_bytes),
 +    );
++
 +    assert_eq!(
 +        symbol_partition_names(&our_bytes),
 +        symbol_partition_names(&apple_bytes)
 +    );
++
 +    let _ = fs::remove_file(dylib);
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_strips_locals_with_x_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
++
 +    let dylib = scratch("symtab-strip.dylib");
 +    let obj = scratch("symtab-strip.o");
 +    let our_out = scratch("symtab-strip-ours.out");
 +    let apple_out = scratch("symtab-strip-apple.out");
++
 +    let dylib_src = r#"
 +        int ext_data = 5;
 +    "#;
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let asm = r#"
 +        .text
 +        .private_extern _hidden
 +        .globl _visible
          .globl _main
          .p2align 2
      _local:
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
      assert_eq!(
 -        normalized_unwind_words(&our_bytes),
 -        normalized_unwind_words(&apple_bytes)
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
      );
      assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
      assert_eq!(
 -        normalized_unwind_words(&our_bytes),
 -        normalized_unwind_words(&apple_bytes)
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
      );
      assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
      let _ = fs::remove_file(apple_out);
+ }
 +#[test]
 +fn linker_run_handles_large_unwind_function_gaps() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("unwind-gap.o");
 +    let out = scratch("unwind-gap-ours.out");
 +    let asm = r#"
 +        .text
 +        .globl _main
 +        .p2align 2
 +    _main:
 +        .cfi_startproc
 +        bl _helper
 +        ret
 +        .cfi_endproc
 +        .space 0x1000010
 +        .globl _helper
 +        .p2align 2
 +    _helper:
 +        .cfi_startproc
 +        ret
 +        .cfi_endproc
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (_, unwind) = output_section(&bytes, "__TEXT", "__unwind_info").unwrap();
 +    let decoded = decode_unwind_info(&unwind).unwrap();
 +    assert!(
 +        decoded
 +            .records
 +            .windows(2)
 +            .all(|pair| pair[0].function_offset < pair[1].function_offset),
 +        "expected strictly ascending unwind records after large-gap pagination"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
  #[test]
  fn linker_run_preserves_eh_frame_like_ld() {
      if !have_xcrun() || !have_xcrun_tool("dwarfdump") {
      let _ = fs::remove_file(apple_out);
+ }
 +#[test]
 +fn linker_run_emits_backtrace_metadata_like_apple_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun 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("unwind-backtrace.o");
 +    let our_out = scratch("unwind-backtrace-ours.out");
 +    let apple_out = scratch("unwind-backtrace-apple.out");
 +    let src = r#"
 +        #include <unwind.h>
++
 +        static _Unwind_Reason_Code cb(struct _Unwind_Context* ctx, void* arg) {
 +            (void)ctx;
 +            int* count = (int*)arg;
 +            (*count)++;
 +            return *count >= 8 ? _URC_END_OF_STACK : _URC_NO_REASON;
 +        }
++
 +        __attribute__((noinline)) int helper(void) {
 +            int count = 0;
 +            _Unwind_Backtrace(cb, &count);
 +            return count;
 +        }
++
 +        int main(void) {
 +            return helper() > 1 ? 0 : 1;
 +        }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd],
 +        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();
 +    assert_eq!(
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
 +    );
 +    assert_eq!(
 +        normalize_function_start_offsets(&decode_function_starts(&our_bytes)),
 +        normalize_function_start_offsets(&decode_function_starts(&apple_bytes))
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
  #[test]
  fn linker_run_preserves_exception_unwind_metadata_like_apple_ld() {
      if !have_xcrun() || !have_xcrun_tool("clang++") || !have_tool("codesign") {
          eprintln!("skipping: xcrun --show-sdk-path unavailable");
          return;
      };
 -    let libsystem = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    let libcxx = PathBuf::from(format!("{sdk}/usr/lib/libc++.tbd"));
 -    if !libsystem.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", libsystem.display());
 +    let libsystem = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    let libcxx = PathBuf::from(format!("{sdk}/usr/lib/libc++.tbd"));
 +    if !libsystem.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", libsystem.display());
 +        return;
 +    }
 +    if !libcxx.exists() {
 +        eprintln!("skipping: no libc++.tbd at {}", libcxx.display());
 +        return;
 +    }
++
 +    let obj = scratch("cxx-exc.o");
 +    let our_out = scratch("cxx-exc-ours.out");
 +    let apple_out = scratch("cxx-exc-apple.out");
 +    let src = r#"
 +        int helper() { throw 7; }
 +        int main() {
 +            try { return helper(); }
 +            catch (...) { return 42; }
 +        }
 +    "#;
 +    if let Err(e) = compile_cxx(src, &obj) {
 +        eprintln!("skipping: clang++ compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), libcxx.clone(), libsystem.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_cxx_classic(&obj, &apple_out).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap()
 +    );
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, true).unwrap(),
 +        decode_bind_records(&apple_bytes, true).unwrap()
 +    );
 +    assert_eq!(
 +        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 +        canonical_lazy_bind_stream(&apple_bytes).unwrap()
 +    );
 +    let our_decoded = canonical_unwind_info(&our_bytes);
 +    let apple_decoded = canonical_unwind_info(&apple_bytes);
 +    assert_eq!(our_decoded, apple_decoded);
 +    assert_eq!(our_decoded.personalities.len(), 1);
 +    assert_eq!(our_decoded.lsdas.len(), 1);
 +    assert!(output_section(&our_bytes, "__TEXT", "__gcc_except_tab").is_some());
 +    let our_status = Command::new(&our_out).status().unwrap();
 +    let apple_status = Command::new(&apple_out).status().unwrap();
 +    assert_eq!(our_status.code(), Some(42));
 +    assert_eq!(apple_status.code(), Some(42));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_resolves_backtrace_symbols_at_runtime() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun 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;
 -    }
 -    if !libcxx.exists() {
 -        eprintln!("skipping: no libc++.tbd at {}", libcxx.display());
 +    };
 +    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("cxx-exc.o");
 -    let our_out = scratch("cxx-exc-ours.out");
 -    let apple_out = scratch("cxx-exc-apple.out");
 +    let obj = scratch("execinfo-backtrace.o");
 +    let our_out = scratch("execinfo-backtrace-ours.out");
 +    let apple_out = scratch("execinfo-backtrace-apple.out");
      let src = r#"
 -        int helper() { throw 7; }
 -        int main() {
 -            try { return helper(); }
 -            catch (...) { return 42; }
 +        #include <execinfo.h>
 +        #include <stdio.h>
 +        #include <stdlib.h>
 +        #include <string.h>
++
 +        __attribute__((noinline)) int helper(void) {
 +            void *frames[8];
 +            int n = backtrace(frames, 8);
 +            char **syms = backtrace_symbols(frames, n);
 +            int saw_helper = 0;
 +            int saw_main = 0;
 +            if (!syms) return 2;
 +            for (int i = 0; i < n; i++) {
 +                puts(syms[i]);
 +                saw_helper |= strstr(syms[i], "helper") != NULL;
 +                saw_main |= strstr(syms[i], "main") != NULL;
 +            }
 +            free(syms);
 +            return (saw_helper && saw_main) ? 0 : 1;
 +        }
++
 +        int main(void) {
 +            return helper();
+         }
      "#;
 -    if let Err(e) = compile_cxx(src, &obj) {
 -        eprintln!("skipping: clang++ compile failed: {e}");
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), libcxx.clone(), libsystem.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_cxx_classic(&obj, &apple_out).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();
 -    assert_eq!(
 -        decode_bind_records(&our_bytes, false).unwrap(),
 -        decode_bind_records(&apple_bytes, false).unwrap()
 +    let our_output = Command::new(&our_out).output().unwrap();
 +    let apple_output = Command::new(&apple_out).output().unwrap();
 +    let our_stdout = String::from_utf8_lossy(&our_output.stdout);
 +    let apple_stdout = String::from_utf8_lossy(&apple_output.stdout);
++
 +    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_eq!(
 -        decode_bind_records(&our_bytes, true).unwrap(),
 -        decode_bind_records(&apple_bytes, true).unwrap()
 +    assert!(
 +        our_stdout.contains("main"),
 +        "expected main in output: {our_stdout}"
      );
 -    assert_eq!(
 -        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 -        canonical_lazy_bind_stream(&apple_bytes).unwrap()
 +    assert!(
 +        apple_stdout.contains("helper"),
 +        "expected helper in apple output: {apple_stdout}"
 +    );
 +    assert!(
 +        apple_stdout.contains("main"),
 +        "expected main in apple output: {apple_stdout}"
      );
 -    let our_decoded = canonical_unwind_info(&our_bytes);
 -    let apple_decoded = canonical_unwind_info(&apple_bytes);
 -    assert_eq!(our_decoded, apple_decoded);
 -    assert_eq!(our_decoded.personalities.len(), 1);
 -    assert_eq!(our_decoded.lsdas.len(), 1);
 -    assert!(output_section(&our_bytes, "__TEXT", "__gcc_except_tab").is_some());
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
      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;

tests/tbd_integration.rsmodified

      let dy = DylibFile::from_tbd(&path, main, &target);
      assert_eq!(dy.install_name, "/usr/lib/libSystem.B.dylib");
 +    assert!(dy.current_version >= (1 << 16));
 +    assert_eq!(dy.compatibility_version, 1 << 16);
      // libSystem's main TBD doc only exposes a short list of internal
      // symbols directly; everything useful (malloc, printf, dyld binder)