Capture linker layout and formatting updates

Status	File	+	-
M	`src/archive.rs`	57	41
M	`src/args.rs`	18	14
M	`src/atom.rs`	37	21
M	`src/dump.rs`	20	37
M	`src/layout.rs`	136	37
M	`src/lib.rs`	7	2
M	`src/macho/dylib.rs`	6	12
M	`src/macho/exports.rs`	6	1
M	`src/macho/reader.rs`	82	35
M	`src/macho/tbd.rs`	15	13
M	`src/macho/tbd_yaml.rs`	10	16
M	`src/macho/writer.rs`	4	1
M	`src/reloc/arm64.rs`	16	2
M	`src/reloc/mod.rs`	24	12
M	`src/resolve.rs`	29	45
M	`src/section.rs`	14	10
M	`src/string_table.rs`	23	16
M	`src/symbol.rs`	7	1
M	`src/synth/code_sig.rs`	30	21
M	`src/synth/dyld_info.rs`	33	16
M	`src/synth/mod.rs`	124	0
M	`src/synth/unwind.rs`	384	62
M	`tests/archive_runtime.rs`	14	6
M	`tests/atom_integration.rs`	10	9
M	`tests/dylib_integration.rs`	1	9
M	`tests/linker_run.rs`	115	0
M	`tests/minimal_output.rs`	4	1
M	`tests/reader_corpus_round_trip.rs`	28	19
M	`tests/resolve_integration.rs`	4	10
M	`tests/tbd_integration.rs`	5	2
M	`tests/tbd_smoke.rs`	5	1

src/archive.rsmodified

  #[derive(Debug)]
  pub enum ArchiveError {
      /// The input buffer is shorter than the next structure we need to read.
 -    Truncated { need: usize, have: usize, context: &'static str },
 +    Truncated {
 +        need: usize,
 +        have: usize,
 +        context: &'static str,
 +    },
      /// The 8-byte magic is neither `!<arch>\n` nor `!<thin>\n`.
      BadMagic { got: [u8; 8] },
      /// A header footer (`fmag`) wasn't `` `\n ``.
      BadEntryFooter { at_offset: usize },
      /// An ASCII decimal field (size/date/uid/gid/mode) didn't parse.
 -    BadAsciiField { at_offset: usize, field: &'static str },
 +    BadAsciiField {
 +        at_offset: usize,
 +        field: &'static str,
 +    },
      /// A member's claimed size would overrun the archive.
      MemberOverrun { at_offset: usize, size: u64 },
      /// A `/NNN` long-name offset didn't land inside the `//` table.
      /// Return every non-special member (skips symbol indexes and long-name
      /// tables).
      pub fn object_members(&self) -> impl Iterator<Item = &Member<'a>> {
 -        self.members.iter().filter(|m| m.special == SpecialMember::None)
 +        self.members
 +            .iter()
 +            .filter(|m| m.special == SpecialMember::None)
+     }
      /// Find the first member whose `ar_hdr` begins at `header_offset`. The
      /// Resolve `name` to its defining member, then parse that member as an
      /// `ObjectFile`. Returns `None` when the symbol is absent; `Some(Err(_))`
      /// when the member exists but fails to parse.
 -    pub fn fetch_object_defining(
 -        &self,
 -        name: &str,
 -    ) -> Option<Result<ObjectFile, FetchError>> {
 +    pub fn fetch_object_defining(&self, name: &str) -> Option<Result<ObjectFile, FetchError>> {
          let member = self.first_member_defining(name)?;
          Some(self.parse_member_object(member))
+     }
              });
+         }
          let raw_name = hdr.raw_name_str();
 -        let (real_name, body_offset, body, special) = decode_member(
 -            raw_name,
 -            data,
 -            body_start,
 -            size,
 -            flavor,
 -            long_names,
 -            cursor,
 -        )?;
 +        let (real_name, body_offset, body, special) =
 +            decode_member(raw_name, data, body_start, size, flavor, long_names, cursor)?;
          // Opportunistic flavor refinement. The sole unambiguous signal for
          // Sysv is the presence of `/` or `//` members — BSD never emits
          // Advance past body + 1-byte alignment pad for odd sizes (GNU-thin
          // members have zero-byte bodies so this collapses to a no-op).
          let advance = AR_HDR_SIZE + size + (size & 1);
 -        cursor = cursor.checked_add(advance).ok_or(ArchiveError::MemberOverrun {
 -            at_offset: cursor,
 -            size: hdr.size,
 -        })?;
 +        cursor = cursor
 +            .checked_add(advance)
 +            .ok_or(ArchiveError::MemberOverrun {
 +                at_offset: cursor,
 +                size: hdr.size,
 +            })?;
+     }
      Ok((out, flavor))
      // GNU-thin: body is zero bytes; name field is the external path.
      if flavor == Flavor::GnuThin {
          let name = raw_name.trim_end_matches('/').to_string();
 -        return Ok((name, body_start, &data[body_start..body_start], SpecialMember::None));
 +        return Ok((
 +            name,
 +            body_start,
 +            &data[body_start..body_start],
 +            SpecialMember::None,
 +        ));
+     }
      // BSD extended: "#1/<N>" — first N bytes of the body are the real name.
              reason: "__.SYMDEF ranlib byte count not a multiple of 8",
          });
+     }
 -    let ranlib_end = 4usize.checked_add(ranlib_bytes).ok_or(ArchiveError::BadSymbolIndex {
 -        reason: "__.SYMDEF ranlib region overflows",
 -    })?;
 +    let ranlib_end = 4usize
 +        .checked_add(ranlib_bytes)
 +        .ok_or(ArchiveError::BadSymbolIndex {
 +            reason: "__.SYMDEF ranlib region overflows",
 +        })?;
      if ranlib_end + 4 > body.len() {
          return Err(ArchiveError::BadSymbolIndex {
              reason: "__.SYMDEF ranlib + stringsize region overruns member",
      let stringsize =
          u32::from_le_bytes(body[ranlib_end..ranlib_end + 4].try_into().unwrap()) as usize;
      let strings_start = ranlib_end + 4;
 -    let strings_end = strings_start
 -        .checked_add(stringsize)
 -        .ok_or(ArchiveError::BadSymbolIndex {
 -            reason: "__.SYMDEF strings region overflows",
 -        })?;
 +    let strings_end =
 +        strings_start
 +            .checked_add(stringsize)
 +            .ok_or(ArchiveError::BadSymbolIndex {
 +                reason: "__.SYMDEF strings region overflows",
 +            })?;
      if strings_end > body.len() {
          return Err(ArchiveError::BadSymbolIndex {
              reason: "__.SYMDEF strings region overruns member",
      Ok(SymbolIndex { entries })
+ }
 -fn decode_long_name(
 -    table: &[u8],
 -    strx: u32,
 -    at_offset: usize,
 -) -> Result<String, ArchiveError> {
 +fn decode_long_name(table: &[u8], strx: u32, at_offset: usize) -> Result<String, ArchiveError> {
      let start = strx as usize;
      if start >= table.len() {
          return Err(ArchiveError::LongNameOob { at_offset, strx });
          .map(|i| start + i)
          .unwrap_or(table.len());
      // Strip a trailing slash that GNU appends before the newline.
 -    let trimmed_end = if end > 0 && table[end - 1] == b'/' { end - 1 } else { end };
 +    let trimmed_end = if end > 0 && table[end - 1] == b'/' {
 +        end - 1
 +    } else {
 +        end
 +    };
      str::from_utf8(&table[start..trimmed_end])
          .map(|s| s.to_string())
          .map_err(|_| ArchiveError::BadName { at_offset })
          let mut buf = Vec::with_capacity(AR_HDR_SIZE);
          let name_bytes = name.as_bytes();
          let mut name_field = [b' '; 16];
 -        name_field[..name_bytes.len().min(16)].copy_from_slice(&name_bytes[..name_bytes.len().min(16)]);
 +        name_field[..name_bytes.len().min(16)]
 +            .copy_from_slice(&name_bytes[..name_bytes.len().min(16)]);
          buf.extend_from_slice(&name_field);
          buf.extend_from_slice(&[b' '; 12]); // date
 -        buf.extend_from_slice(&[b' '; 6]);  // uid
 -        buf.extend_from_slice(&[b' '; 6]);  // gid
 -        buf.extend_from_slice(&[b' '; 8]);  // mode
 +        buf.extend_from_slice(&[b' '; 6]); // uid
 +        buf.extend_from_slice(&[b' '; 6]); // gid
 +        buf.extend_from_slice(&[b' '; 8]); // mode
          let mut size_field = [b' '; 10];
          let size_str = size.to_string();
          let bytes = size_str.as_bytes();
          let short = vec![0u8; 30];
          assert!(matches!(
              ArHeader::parse(&short, 0).unwrap_err(),
 -            ArchiveError::Truncated { need: AR_HDR_SIZE, .. }
 +            ArchiveError::Truncated {
 +                need: AR_HDR_SIZE,
 +                ..
 +            }
          ));
+     }
      fn bsd_extended_name_splits_body() {
          let mut buf = Vec::new();
          buf.extend_from_slice(AR_MAGIC);
 -        buf.extend_from_slice(&encode_bsd_extended("long_filename_with_many_chars.o", b"CONT"));
 +        buf.extend_from_slice(&encode_bsd_extended(
 +            "long_filename_with_many_chars.o",
 +            b"CONT",
 +        ));
          let ar = Archive::open("/tmp/bsd_ext.a", &buf).unwrap();
          assert_eq!(ar.members()[0].name, "long_filename_with_many_chars.o");
          assert_eq!(ar.members()[0].body, b"CONT");

src/args.rsmodified

                  write!(f, "flag `{flag}` requires a value")
+             }
              ArgsError::UnknownFlag(flag) => {
 -                write!(f, "unknown flag `{flag}` (Sprint 19 adds the full `ld` surface)")
 +                write!(
 +                    f,
 +                    "unknown flag `{flag}` (Sprint 19 adds the full `ld` surface)"
 +                )
+             }
+         }
+     }
          match arg.as_str() {
              "-o" => {
                  opts.output = Some(PathBuf::from(
 -                    it.next().ok_or_else(|| ArgsError::MissingValue("-o".into()))?,
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-o".into()))?,
                  ));
+             }
              "-e" => {
                  ));
+             }
              "--dump-archive" => {
 -                opts.dump_archive = Some(PathBuf::from(
 -                    it.next()
 -                        .ok_or_else(|| ArgsError::MissingValue("--dump-archive".into()))?,
 -                ));
 +                opts.dump_archive =
 +                    Some(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("--dump-archive".into())
 +                    })?));
+             }
              "--dump-dylib" => {
 -                opts.dump_dylib = Some(PathBuf::from(
 -                    it.next()
 -                        .ok_or_else(|| ArgsError::MissingValue("--dump-dylib".into()))?,
 -                ));
 +                opts.dump_dylib =
 +                    Some(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("--dump-dylib".into())
 +                    })?));
+             }
              "--dump-tbd" => {
 -                opts.dump_tbd = Some(PathBuf::from(
 -                    it.next()
 -                        .ok_or_else(|| ArgsError::MissingValue("--dump-tbd".into()))?,
 -                ));
 +                opts.dump_tbd =
 +                    Some(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("--dump-tbd".into())
 +                    })?));
+             }
              s if s.starts_with('-') => {
                  return Err(ArgsError::UnknownFlag(s.to_string()));

src/atom.rsmodified

  use crate::input::ObjectFile;
  use crate::macho::constants::MH_SUBSECTIONS_VIA_SYMBOLS;
  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent};
 -use crate::resolve::{AtomId, InputId, SymbolTable, SymbolId};
 +use crate::resolve::{AtomId, InputId, SymbolId, SymbolTable};
  use crate::section::{InputSection, SectionKind};
  use crate::symbol::{InputSymbol, SymKind};
+     }
      pub fn is_zerofill(self) -> bool {
 -        matches!(
 -            self,
 -            AtomSection::ZeroFill | AtomSection::ThreadLocalBss
 -        )
 +        matches!(self, AtomSection::ZeroFill | AtomSection::ThreadLocalBss)
+     }
      pub fn is_literal(self) -> bool {
      pub fn by_input_section(&self) -> HashMap<(InputId, u8), Vec<AtomId>> {
          let mut out: HashMap<(InputId, u8), Vec<AtomId>> = HashMap::new();
          for (id, atom) in self.iter() {
 -            out.entry((atom.origin, atom.input_section)).or_default().push(id);
 +            out.entry((atom.origin, atom.input_section))
 +                .or_default()
 +                .push(id);
+         }
          out
+     }
          AtomSection::CStringLiterals => {
              atomize_cstring(input_id, section_idx, sect, syms, atom_section, table, out)
+         }
 -        AtomSection::Literal4 => {
 -            atomize_fixed_literal(input_id, section_idx, sect, syms, 4, atom_section, table, out)
 -        }
 -        AtomSection::Literal8 => {
 -            atomize_fixed_literal(input_id, section_idx, sect, syms, 8, atom_section, table, out)
 -        }
 -        AtomSection::Literal16 => {
 -            atomize_fixed_literal(input_id, section_idx, sect, syms, 16, atom_section, table, out)
 -        }
 +        AtomSection::Literal4 => atomize_fixed_literal(
 +            input_id,
 +            section_idx,
 +            sect,
 +            syms,
 +            4,
 +            atom_section,
 +            table,
 +            out,
 +        ),
 +        AtomSection::Literal8 => atomize_fixed_literal(
 +            input_id,
 +            section_idx,
 +            sect,
 +            syms,
 +            8,
 +            atom_section,
 +            table,
 +            out,
 +        ),
 +        AtomSection::Literal16 => atomize_fixed_literal(
 +            input_id,
 +            section_idx,
 +            sect,
 +            syms,
 +            16,
 +            atom_section,
 +            table,
 +            out,
 +        ),
          _ => unreachable!("atomize_literal_section called with non-literal kind"),
+     }
+ }
          let data = sect.data[offset..end].to_vec();
          let size = (end - offset) as u32;
 -        let owner_entry = syms
 -            .iter()
 -            .find(|(_, _, off)| *off as usize == offset);
 +        let owner_entry = syms.iter().find(|(_, _, off)| *off as usize == offset);
          let owner_idx = owner_entry.map(|(i, _, _)| *i);
          let mut flags = AtomFlags::default().with(AtomFlags::LITERAL);
          };
          let size = (end - offset) as u32;
 -        let owner_entry = syms
 -            .iter()
 -            .find(|(_, _, off)| *off as usize == offset);
 +        let owner_entry = syms.iter().find(|(_, _, off)| *off as usize == offset);
          let owner_idx = owner_entry.map(|(i, _, _)| *i);
          let mut flags = AtomFlags::default().with(AtomFlags::LITERAL);

src/dump.rsmodified

  use crate::archive::{Archive, Flavor, SpecialMember};
  use crate::input::ObjectFile;
 +use crate::macho::constants::*;
  use crate::macho::dylib::{DylibFile, DylibLoadKind};
  use crate::macho::exports::ExportKind;
 -use crate::macho::tbd::parse_tbd;
 -use crate::macho::constants::*;
  use crate::macho::reader::{
      BuildVersionCmd, DyldInfoCmd, DylibCmd, DysymtabCmd, LinkEditDataCmd, LoadCommand,
      MachHeader64, RpathCmd, Section64Header, Segment64, SymtabCmd,
  };
 +use crate::macho::tbd::parse_tbd;
  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind};
  use crate::section::InputSection;
  use crate::symbol::{InputSymbol, SymKind};
      if let Some(idx) = ar.symbol_index() {
          writeln!(h, "Symbols ({}):", idx.len())?;
          for (i, e) in idx.entries.iter().enumerate().take(16) {
 -            writeln!(h, "  [{i}] {} -> member@0x{:x}", e.name, e.member_header_offset)?;
 +            writeln!(
 +                h,
 +                "  [{i}] {} -> member@0x{:x}",
 +                e.name, e.member_header_offset
 +            )?;
+         }
          if idx.len() > 16 {
              writeln!(h, "  ... ({} more)", idx.len() - 16)?;
  pub fn dump_tbd_file(path: &Path) -> io::Result<()> {
      let src = std::fs::read_to_string(path)?;
 -    let docs = parse_tbd(&src)
 -        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
 +    let docs =
 +        parse_tbd(&src).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
      let out = io::stdout();
      let mut h = out.lock();
      writeln!(h, "{}:", path.display())?;
              tbd.compatibility_version.as_deref().unwrap_or("-")
          )?;
          if !tbd.reexported_libraries.is_empty() {
 -            let total: usize = tbd
 -                .reexported_libraries
 -                .iter()
 -                .map(|s| s.value.len())
 -                .sum();
 +            let total: usize = tbd.reexported_libraries.iter().map(|s| s.value.len()).sum();
              writeln!(h, "      reexported-libraries: {total}")?;
+         }
 -        let export_syms: usize = tbd
 -            .exports
 -            .iter()
 -            .map(|s| s.value.total())
 -            .sum();
 +        let export_syms: usize = tbd.exports.iter().map(|s| s.value.total()).sum();
          if export_syms > 0 {
              writeln!(h, "      exports: {export_syms} symbols total")?;
+         }
          LoadCommand::DyldExportsTrie(l) => write_linkedit_data(w, l, "EXPORTS_TRIE"),
          LoadCommand::DyldChainedFixups(l) => write_linkedit_data(w, l, "CHAINED_FIXUPS"),
          LoadCommand::Raw { cmd, data, .. } => {
 -            writeln!(
 -                w,
 -                "  (raw — cmd=0x{:x}, payload {} bytes)",
 -                cmd,
 -                data.len()
 -            )
 +            writeln!(w, "  (raw — cmd=0x{:x}, payload {} bytes)", cmd, data.len())
+         }
+     }
+ }
+ }
  fn write_linkedit_data(w: &mut impl Write, l: &LinkEditDataCmd, kind: &str) -> io::Result<()> {
 -    writeln!(
 -        w,
 -        "  {kind} dataoff={} datasize={}",
 -        l.dataoff, l.datasize
 -    )
 +    writeln!(w, "  {kind} dataoff={} datasize={}", l.dataoff, l.datasize)
+ }
  fn write_sections(w: &mut impl Write, secs: &[InputSection]) -> io::Result<()> {
          writeln!(
              w,
              "  [{i}] {},{:<16} {:?} addr=0x{:x} size=0x{:x} align=2^{} offset={} flags=0x{:08x}",
 -            s.segname,
 -            s.sectname,
 -            s.kind,
 -            s.addr,
 -            s.size,
 -            s.align_pow2,
 -            s.offset,
 -            s.flags
 +            s.segname, s.sectname, s.kind, s.addr, s.size, s.align_pow2, s.offset, s.flags
          )?;
          if !s.data.is_empty() {
              writeln!(w, "      data: {}", hex_preview(&s.data, 16))?;
+         }
          if s.nreloc > 0 {
              writeln!(w, "      relocs ({}):", s.nreloc)?;
 -            match parse_raw_relocs(&s.raw_relocs, 0, s.nreloc)
 -                .and_then(|raws| parse_relocs(&raws))
 +            match parse_raw_relocs(&s.raw_relocs, 0, s.nreloc).and_then(|raws| parse_relocs(&raws))
+             {
                  Ok(fused) => {
                      for (ri, r) in fused.iter().enumerate() {
  fn describe_symbol(sym: &InputSymbol) -> String {
      if let Some(stab) = sym.stab_kind() {
 -        return format!("STAB kind=0x{stab:02x} sect={} value=0x{:x}", sym.sect_idx(), sym.value());
 +        return format!(
 +            "STAB kind=0x{stab:02x} sect={} value=0x{:x}",
 +            sym.sect_idx(),
 +            sym.value()
 +        );
+     }
      let mut parts: Vec<String> = Vec::new();
      parts.push(

src/layout.rsmodified

  use crate::input::ObjectFile;
  use crate::macho::constants::SG_READ_ONLY;
  use crate::resolve::InputId;
 -use crate::section::{is_zerofill, OutputAtom, OutputSection, OutputSectionId, OutputSegment, Prot};
 +use crate::section::{
 +    is_zerofill, OutputAtom, OutputSection, OutputSectionId, OutputSegment, Prot,
 +};
  use crate::synth::SyntheticPlan;
  use crate::OutputKind;
  pub const PAGE_SIZE: u64 = 0x4000;
  pub const EXECUTABLE_TEXT_BASE: u64 = 0x1_0000_0000;
 -const EXEC_SEGMENTS: [&str; 5] = ["__PAGEZERO", "__TEXT", "__DATA_CONST", "__DATA", "__LINKEDIT"];
 +const EXEC_SEGMENTS: [&str; 5] = [
 +    "__PAGEZERO",
 +    "__TEXT",
 +    "__DATA_CONST",
 +    "__DATA",
 +    "__LINKEDIT",
 +];
  const DYLIB_SEGMENTS: [&str; 4] = ["__TEXT", "__DATA_CONST", "__DATA", "__LINKEDIT"];
  #[derive(Debug, Clone, Copy)]
          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, &ObjectFile> = inputs
 +            .iter()
 +            .map(|input| (input.id, input.object))
 +            .collect();
          let mut sections: Vec<OutputSection> = Vec::new();
          let mut section_index: HashMap<SectionKey, usize> = HashMap::new();
          if let Some(plan) = synthetic_plan {
              for synthetic in plan.output_sections() {
 -                if let Some(existing) = sections
 -                    .iter_mut()
 -                    .find(|section| section.segment == synthetic.segment && section.name == synthetic.name)
 -                {
 +                if let Some(existing) = sections.iter_mut().find(|section| {
 +                    section.segment == synthetic.segment && section.name == synthetic.name
 +                }) {
                      merge_synthetic_section(existing, synthetic);
                  } else {
                      sections.push(synthetic);
          sections.sort_by(|a, b| {
              segment_rank(kind, &a.segment)
                  .cmp(&segment_rank(kind, &b.segment))
 -                .then_with(|| section_rank(&a.segment, &a.name).cmp(&section_rank(&b.segment, &b.name)))
 +                .then_with(|| {
 +                    section_rank(&a.segment, &a.name).cmp(&section_rank(&b.segment, &b.name))
 +                })
                  .then_with(|| a.segment.cmp(&b.segment))
                  .then_with(|| a.name.cmp(&b.name))
          });
                  placed.offset = size;
                  size += placed.size;
+             }
 -            section.synthetic_offset = if section.synthetic_data.is_empty() || section.atoms.is_empty() {
 -                0
 -            } else {
 -                let align = 1u64 << section.align_pow2.min(63);
 -                align_up(size, align)
 -            };
 +            section.synthetic_offset =
 +                if section.synthetic_data.is_empty() || section.atoms.is_empty() {
 +                    0
 +                } else {
 +                    let align = 1u64 << section.align_pow2.min(63);
 +                    align_up(size, align)
 +                };
              section.size = if section.synthetic_data.is_empty() {
                  size
              } else {
              } else {
                  seg_start_vm
              };
 -            let mut file_cursor = if is_text {
 -                header_size
 -            } else {
 -                seg_start_file
 -            };
 +            let mut file_cursor = if is_text { header_size } else { seg_start_file };
              let mut seg_vm_end = if is_text {
                  seg_start_vm + header_size
              } else {
                  align_up(raw_vm_size, PAGE_SIZE)
              };
              segment.file_size = if is_linkedit || raw_file_size == 0 {
 -                if is_linkedit { 0 } else { raw_file_size }
 +                if is_linkedit {
 +                    0
 +                } else {
 +                    raw_file_size
 +                }
              } else {
                  align_up(raw_file_size, PAGE_SIZE)
              };
 -            next_vm = if is_linkedit { seg_start_vm } else { seg_vm_end };
 -            next_file = if is_linkedit { seg_start_file } else { seg_file_end };
 +            next_vm = if is_linkedit {
 +                seg_start_vm
 +            } else {
 +                seg_vm_end
 +            };
 +            next_file = if is_linkedit {
 +                seg_start_file
 +            } else {
 +                seg_file_end
 +            };
+         }
+     }
+ }
      existing.reserved2 = synthetic.reserved2;
      existing.reserved3 = synthetic.reserved3;
      if !synthetic.synthetic_data.is_empty() {
 -        existing.synthetic_data.extend_from_slice(&synthetic.synthetic_data);
 +        existing
 +            .synthetic_data
 +            .extend_from_slice(&synthetic.synthetic_data);
+     }
+ }
          OutputKind::Executable => &EXEC_SEGMENTS,
          OutputKind::Dylib => &DYLIB_SEGMENTS,
      };
 -    order.iter().position(|name| *name == segment).unwrap_or(order.len())
 +    order
 +        .iter()
 +        .position(|name| *name == segment)
 +        .unwrap_or(order.len())
+ }
  fn section_rank(segment: &str, section: &str) -> usize {
          "__LINKEDIT" => &[],
          _ => &[],
      };
 -    order.iter().position(|name| *name == section).unwrap_or(order.len())
 +    order
 +        .iter()
 +        .position(|name| *name == section)
 +        .unwrap_or(order.len())
+ }
  fn segment_init_prot(name: &str) -> Prot {
      use crate::atom::{Atom, AtomFlags, AtomSection, AtomTable};
      use crate::input::ObjectFile;
 -    use crate::macho::constants::{CPU_SUBTYPE_ARM64_ALL, CPU_TYPE_ARM64, MH_MAGIC_64, MH_OBJECT, S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS, S_CSTRING_LITERALS, S_REGULAR, S_ZEROFILL};
 +    use crate::macho::constants::{
 +        CPU_SUBTYPE_ARM64_ALL, CPU_TYPE_ARM64, MH_MAGIC_64, MH_OBJECT, S_ATTR_PURE_INSTRUCTIONS,
 +        S_ATTR_SOME_INSTRUCTIONS, S_CSTRING_LITERALS, S_REGULAR, S_ZEROFILL,
 +    };
      use crate::macho::reader::MachHeader64;
      use crate::resolve::{DylibId, InputId, SymbolId};
      use crate::section::{InputSection, SectionKind};
 -    use crate::synth::{got::GotSection, stubs::{LazyPointerSection, StubsSection, StubEntry, LazyPointerEntry}, SyntheticPlan};
 +    use crate::synth::{
 +        got::GotSection,
 +        stubs::{LazyPointerEntry, LazyPointerSection, StubEntry, StubsSection},
 +        SyntheticPlan,
 +    };
      use super::*;
              },
              commands: Vec::new(),
              sections: vec![
 -                input_section("__TEXT", "__cstring", SectionKind::CStringLiterals, 0, S_CSTRING_LITERALS),
 +                input_section(
 +                    "__TEXT",
 +                    "__cstring",
 +                    SectionKind::CStringLiterals,
 +                    0,
 +                    S_CSTRING_LITERALS,
 +                ),
                  input_section(
                      "__TEXT",
                      "__text",
 ,
              b"hello\0".to_vec(),
          ));
 -        atoms.push(atom(InputId(0), 3, AtomSection::ConstData, 0, 16, 3, vec![1; 16]));
 -        atoms.push(atom(InputId(0), 4, AtomSection::ZeroFill, 0, 32, 3, Vec::new()));
 +        atoms.push(atom(
 +            InputId(0),
 +            3,
 +            AtomSection::ConstData,
 +            0,
 +            16,
 +            3,
 +            vec![1; 16],
 +        ));
 +        atoms.push(atom(
 +            InputId(0),
 +            4,
 +            AtomSection::ZeroFill,
 +            0,
 +            32,
 +            3,
 +            Vec::new(),
 +        ));
          let layout = Layout::build(
              OutputKind::Executable,
                  reserved: 0,
              },
              commands: Vec::new(),
 -            sections: vec![input_section("__DATA", "__bss", SectionKind::ZeroFill, 4, S_ZEROFILL)],
 +            sections: vec![input_section(
 +                "__DATA",
 +                "__bss",
 +                SectionKind::ZeroFill,
 +                4,
 +                S_ZEROFILL,
 +            )],
              symbols: Vec::new(),
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
          };
          let mut atoms = AtomTable::new();
 -        atoms.push(atom(InputId(0), 1, AtomSection::ZeroFill, 0, 64, 4, Vec::new()));
 +        atoms.push(atom(
 +            InputId(0),
 +            1,
 +            AtomSection::ZeroFill,
 +            0,
 +            64,
 +            4,
 +            Vec::new(),
 +        ));
          let layout = Layout::build(
              OutputKind::Executable,
          };
          let mut atoms = AtomTable::new();
 -        atoms.push(atom(InputId(0), 1, AtomSection::Text, 0, 16, 2, vec![0; 16]));
 +        atoms.push(atom(
 +            InputId(0),
 +            1,
 +            AtomSection::Text,
 +            0,
 +            16,
 +            2,
 +            vec![0; 16],
 +        ));
          atoms.push(atom(InputId(0), 2, AtomSection::Data, 0, 8, 3, vec![0; 8]));
          let layout = Layout::build(
                  reserved: 0,
              },
              commands: Vec::new(),
 -            sections: vec![input_section("__DATA", "__data", SectionKind::Data, 3, S_REGULAR)],
 +            sections: vec![input_section(
 +                "__DATA",
 +                "__data",
 +                SectionKind::Data,
 +                3,
 +                S_REGULAR,
 +            )],
              symbols: Vec::new(),
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
          };
          let mut atoms = AtomTable::new();
 -        atoms.push(atom(InputId(0), 1, AtomSection::Data, 0, 16, 3, vec![0xaa; 16]));
 +        atoms.push(atom(
 +            InputId(0),
 +            1,
 +            AtomSection::Data,
 +            0,
 +            16,
 +            3,
 +            vec![0xaa; 16],
 +        ));
          let plan = SyntheticPlan {
              got: GotSection {
                  reserved: 0,
              },
              commands: Vec::new(),
 -            sections: vec![input_section("__FOO", "__bar", SectionKind::Data, 3, S_REGULAR)],
 +            sections: vec![input_section(
 +                "__FOO",
 +                "__bar",
 +                SectionKind::Data,
 +                3,
 +                S_REGULAR,
 +            )],
              symbols: Vec::new(),
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,

src/lib.rsmodified

              )?;
              layout = next_layout;
              linkedit = Some(next_linkedit);
 -            let changed =
 -                synth::unwind::synthesize(&mut layout, &layout_inputs, &atom_table, &sym_table)?;
 +            let changed = synth::unwind::synthesize(
 +                &mut layout,
 +                &layout_inputs,
 +                &atom_table,
 +                &sym_table,
 +                &synthetic_plan,
 +            )?;
              if !changed {
                  break;
+             }

src/macho/dylib.rsmodified

  use super::constants::*;
  use super::exports::{ExportEntry, ExportKind, Exports};
 -use super::reader::{parse_commands, parse_header, LoadCommand, MachHeader64, ReadError, SymtabCmd};
 +use super::reader::{
 +    parse_commands, parse_header, LoadCommand, MachHeader64, ReadError, SymtabCmd,
 +};
  use super::tbd::{parse_version, SymbolLists, Target, Tbd};
  /// How a consumer loaded this dylib. The filetype of the dylib itself is
  /// `LC_DYLD_EXPORTS_TRIE` (chained-fixups era). Dylibs built by older
  /// toolchains may have no export trie; in that case return an empty
  /// `Exports::Flat(vec![])` so downstream `entries()` works uniformly.
 -fn locate_exports(
 -    commands: &[LoadCommand],
 -    file_bytes: &[u8],
 -) -> Result<Exports, ReadError> {
 +fn locate_exports(commands: &[LoadCommand], file_bytes: &[u8]) -> Result<Exports, ReadError> {
      for cmd in commands {
          match cmd {
              LoadCommand::DyldInfoOnly(d) if d.export_size != 0 => {
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::macho::reader::{
 -        write_commands, write_header, DylibCmd, RpathCmd,
 -    };
 +    use crate::macho::reader::{write_commands, write_header, DylibCmd, RpathCmd};
      fn make_dylib_image(commands: Vec<LoadCommand>) -> Vec<u8> {
          let sizeofcmds: u32 = commands.iter().map(|c| c.cmdsize()).sum();
              }),
          ]);
          let dy = DylibFile::parse("/tmp/x.dylib", &image).unwrap();
 -        assert_eq!(
 -            dy.rpaths,
 -            vec!["@executable_path/../lib", "/opt/local/lib"]
 -        );
 +        assert_eq!(dy.rpaths, vec!["@executable_path/../lib", "/opt/local/lib"]);
+     }
      // ----- DylibFile::from_tbd tests -----

src/macho/exports.rsmodified

          child_cursor += off_len;
          let edge_bytes = edge.as_bytes();
          if remaining.len() >= edge_bytes.len() && &remaining[..edge_bytes.len()] == edge_bytes {
 -            return lookup(trie, child_off as usize, &remaining[edge_bytes.len()..], depth + 1);
 +            return lookup(
 +                trie,
 +                child_off as usize,
 +                &remaining[edge_bytes.len()..],
 +                depth + 1,
 +            );
+         }
+     }
      Ok(None)

src/macho/reader.rsmodified

  #[derive(Debug)]
  pub enum ReadError {
      /// Not enough bytes to decode the next field.
 -    Truncated { need: usize, have: usize, context: &'static str },
 +    Truncated {
 +        need: usize,
 +        have: usize,
 +        context: &'static str,
 +    },
      /// Magic number is not `MH_MAGIC_64`.
      BadMagic { got: u32 },
      /// CPU type is not `CPU_TYPE_ARM64`.
      UnsupportedCpu { got: u32 },
      /// A load command's `cmdsize` field is malformed.
 -    BadCmdsize { cmd: u32, cmdsize: u32, at_offset: usize, reason: &'static str },
 +    BadCmdsize {
 +        cmd: u32,
 +        cmdsize: u32,
 +        at_offset: usize,
 +        reason: &'static str,
 +    },
      /// A relocation entry or pairing is structurally invalid.
 -    BadRelocation { at_offset: u32, reason: &'static str },
 +    BadRelocation {
 +        at_offset: u32,
 +        reason: &'static str,
 +    },
+ }
  impl fmt::Display for ReadError {
      DyldChainedFixups(LinkEditDataCmd),
      /// A load command whose payload we haven't decoded yet. Preserves bytes
      /// verbatim for byte-level round-trip.
 -    Raw { cmd: u32, cmdsize: u32, data: Vec<u8> },
 +    Raw {
 +        cmd: u32,
 +        cmdsize: u32,
 +        data: Vec<u8>,
 +    },
+ }
  impl LoadCommand {
  /// Parse the `header.ncmds` load commands that follow a `mach_header_64`.
  /// The slice must cover the full file (or at least through `sizeofcmds`);
  /// offsets are always relative to the start of the mach-o image.
 -pub fn parse_commands(
 -    header: &MachHeader64,
 -    bytes: &[u8],
 -) -> Result<Vec<LoadCommand>, ReadError> {
 -    let cmds_end = HEADER_SIZE
 -        .checked_add(header.sizeofcmds as usize)
 -        .ok_or(ReadError::Truncated {
 -            need: usize::MAX,
 -            have: bytes.len(),
 -            context: "load-command region (sizeofcmds overflows)",
 -        })?;
 +pub fn parse_commands(header: &MachHeader64, bytes: &[u8]) -> Result<Vec<LoadCommand>, ReadError> {
 +    let cmds_end =
 +        HEADER_SIZE
 +            .checked_add(header.sizeofcmds as usize)
 +            .ok_or(ReadError::Truncated {
 +                need: usize::MAX,
 +                have: bytes.len(),
 +                context: "load-command region (sizeofcmds overflows)",
 +            })?;
      if bytes.len() < cmds_end {
          return Err(ReadError::Truncated {
              need: cmds_end,
          LC_LINKER_OPTIMIZATION_HINT => Ok(LoadCommand::LinkerOptimizationHint(
              LinkEditDataCmd::parse(LC_LINKER_OPTIMIZATION_HINT, cmdsize, payload)?,
          )),
 -        LC_ID_DYLIB
 -        | LC_LOAD_DYLIB
 -        | LC_LOAD_WEAK_DYLIB
 -        | LC_REEXPORT_DYLIB
 +        LC_ID_DYLIB | LC_LOAD_DYLIB | LC_LOAD_WEAK_DYLIB | LC_REEXPORT_DYLIB
          | LC_LOAD_UPWARD_DYLIB => Ok(LoadCommand::Dylib(DylibCmd::parse(cmd, cmdsize, payload)?)),
          LC_RPATH => Ok(LoadCommand::Rpath(RpathCmd::parse(cmdsize, payload)?)),
 -        LC_DYLD_INFO_ONLY => Ok(LoadCommand::DyldInfoOnly(DyldInfoCmd::parse(cmdsize, payload)?)),
 +        LC_DYLD_INFO_ONLY => Ok(LoadCommand::DyldInfoOnly(DyldInfoCmd::parse(
 +            cmdsize, payload,
 +        )?)),
          LC_DYLD_EXPORTS_TRIE => Ok(LoadCommand::DyldExportsTrie(LinkEditDataCmd::parse(
              LC_DYLD_EXPORTS_TRIE,
              cmdsize,
+         }
          let start = off_in_cmd - 8;
          let bytes = &payload[start..];
 -        let nul = bytes.iter().position(|&b| b == 0).ok_or(ReadError::BadCmdsize {
 -            cmd: LC_RPATH,
 -            cmdsize,
 -            at_offset: 0,
 -            reason: "rpath_command path is not null-terminated",
 -        })?;
 +        let nul = bytes
 +            .iter()
 +            .position(|&b| b == 0)
 +            .ok_or(ReadError::BadCmdsize {
 +                cmd: LC_RPATH,
 +                cmdsize,
 +                at_offset: 0,
 +                reason: "rpath_command path is not null-terminated",
 +            })?;
          let path = std::str::from_utf8(&bytes[..nul])
              .map_err(|_| ReadError::BadCmdsize {
                  cmd: LC_RPATH,
      fn truncated_header_errors_cleanly() {
          let err = parse_header(&[0u8; 10]).unwrap_err();
          assert!(
 -            matches!(err, ReadError::Truncated { need: HEADER_SIZE, have: 10, .. }),
 +            matches!(
 +                err,
 +                ReadError::Truncated {
 +                    need: HEADER_SIZE,
 +                    have: 10,
 +                    ..
 +                }
 +            ),
              "unexpected: {err:?}"
          );
+     }
          // Overwrite cputype with x86_64 (0x01000007).
          bytes[4..8].copy_from_slice(&0x0100_0007u32.to_le_bytes());
          let err = parse_header(&bytes).unwrap_err();
 -        assert!(matches!(err, ReadError::UnsupportedCpu { got: 0x0100_0007 }));
 +        assert!(matches!(
 +            err,
 +            ReadError::UnsupportedCpu { got: 0x0100_0007 }
 +        ));
+     }
      /// Synthesize a mach-o image with `n` load commands, each of size
              minos: (11 << 16) | (3 << 8),
              sdk: (14 << 16) | (2 << 8),
              tools: vec![
 -                BuildTool { tool: 3, version: 0x0001_0002 },
 -                BuildTool { tool: 4, version: 0x0002_0003 },
 +                BuildTool {
 +                    tool: 3,
 +                    version: 0x0001_0002,
 +                },
 +                BuildTool {
 +                    tool: 4,
 +                    version: 0x0002_0003,
 +                },
              ],
          };
          let mut wire2 = Vec::new();
              platform: PLATFORM_MACOS,
              minos: (11 << 16),
              sdk: (14 << 16),
 -            tools: vec![BuildTool { tool: 3, version: 1 }],
 +            tools: vec![BuildTool {
 +                tool: 3,
 +                version: 1,
 +            }],
          };
          let mut wire = Vec::new();
          cmd.write(&mut wire);
          payload.extend_from_slice(&0u32.to_le_bytes());
          payload.extend_from_slice(&0u32.to_le_bytes());
          let err = DylibCmd::parse(LC_LOAD_DYLIB, 32, &payload).unwrap_err();
 -        assert!(matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("name offset")));
 +        assert!(
 +            matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("name offset"))
 +        );
+     }
      #[test]
          cmd.write(LC_LINKER_OPTIMIZATION_HINT, &mut wire);
          assert_eq!(wire.len(), LinkEditDataCmd::WIRE_SIZE as usize);
 -        let decoded =
 -            LinkEditDataCmd::parse(LC_LINKER_OPTIMIZATION_HINT, LinkEditDataCmd::WIRE_SIZE, &wire[8..]).unwrap();
 +        let decoded = LinkEditDataCmd::parse(
 +            LC_LINKER_OPTIMIZATION_HINT,
 +            LinkEditDataCmd::WIRE_SIZE,
 +            &wire[8..],
 +        )
 +        .unwrap();
          assert_eq!(decoded, cmd);
          let hdr = MachHeader64 {
          let parsed_hdr = parse_header(&image).unwrap();
          let cmds = parse_commands(&parsed_hdr, &image).unwrap();
          assert!(matches!(cmds[0], LoadCommand::Segment64(_)));
 -        assert!(matches!(cmds[1], LoadCommand::Raw { cmd: 0xCAFE_F00D, .. }));
 +        assert!(matches!(
 +            cmds[1],
 +            LoadCommand::Raw {
 +                cmd: 0xCAFE_F00D,
 +                ..
 +            }
 +        ));
          let mut out = Vec::new();
          write_header(&parsed_hdr, &mut out);

src/macho/tbd.rsmodified

              "exports" => tbd.exports = decode_scoped_symbols(v)?,
              "reexports" => tbd.reexports = decode_scoped_symbols(v)?,
              // Known-but-ignored keys (grow this list as TAPI adds them).
 -            "uuids"
 -            | "flags"
 -            | "swift-abi-version"
 -            | "rpaths"
 -            | "objc-constraint"
 +            "uuids" | "flags" | "swift-abi-version" | "rpaths" | "objc-constraint"
              | "parent-libraries" => {}
              _ => {
                  // Silently accept unknown keys — TAPI can add new ones in
          .ok_or_else(|| schema("'targets' must be a sequence"))?;
      let mut out = Vec::with_capacity(seq.len());
      for item in seq {
 -        let s = item.as_str().ok_or_else(|| schema("target must be a scalar"))?;
 +        let s = item
 +            .as_str()
 +            .ok_or_else(|| schema("target must be a scalar"))?;
          out.push(parse_target(s)?);
+     }
      Ok(out)
  fn parse_target(s: &str) -> Result<Target, TbdError> {
      // `arch-platform`. Arch may contain a hyphen (none today, but armv7k
      // in the wild) — split on the *last* `-`.
 -    let hyphen = s.rfind('-').ok_or_else(|| schema(&format!(
 -        "target {s:?} is not `arch-platform`"
 -    )))?;
 +    let hyphen = s
 +        .rfind('-')
 +        .ok_or_else(|| schema(&format!("target {s:?} is not `arch-platform`")))?;
      let arch = match &s[..hyphen] {
          "arm64" => Arch::Arm64,
          "arm64e" => Arch::Arm64e,
              .as_mapping()
              .ok_or_else(|| schema("parent-umbrella entry must be a mapping"))?;
          let targets = lookup_required(m, "targets").and_then(decode_target_list)?;
 -        let umbrella = lookup_required(m, "umbrella")
 -            .and_then(|v| scalar_string(v, "umbrella"))?;
 +        let umbrella = lookup_required(m, "umbrella").and_then(|v| scalar_string(v, "umbrella"))?;
          out.push(Scoped {
              targets,
              value: umbrella,
+ }
  fn schema(msg: &str) -> TbdError {
 -    TbdError::Schema { msg: msg.to_string() }
 +    TbdError::Schema {
 +        msg: msg.to_string(),
 +    }
+ }
  /// Pack a `"X.Y.Z"` / `"X.Y"` / `"X"` / `"1351"` version string to
          assert_eq!(tbd.reexported_libraries.len(), 1);
          assert_eq!(
              tbd.reexported_libraries[0].value,
 -            vec!["/usr/lib/system/libcache.dylib", "/usr/lib/system/libxpc.dylib"]
 +            vec![
 +                "/usr/lib/system/libcache.dylib",
 +                "/usr/lib/system/libxpc.dylib"
 +            ]
          );
+     }

src/macho/tbd_yaml.rsmodified

  impl fmt::Display for YamlError {
      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 -        write!(f, "YAML error at line {}, col {}: {}", self.line, self.col, self.msg)
 +        write!(
 +            f,
 +            "YAML error at line {}, col {}: {}",
 +            self.line, self.col, self.msg
 +        )
+     }
+ }
  fn parse_tag(rest: &str) -> Option<String> {
      let rest = rest.trim_start();
      if let Some(tag) = rest.strip_prefix('!') {
 -        let end = tag
 -            .chars()
 -            .take_while(|c| !c.is_whitespace())
 -            .count();
 +        let end = tag.chars().take_while(|c| !c.is_whitespace()).count();
          Some(format!("!{}", &tag[..end]))
      } else {
          None
      None
+ }
 -fn split_key(
 -    content: &str,
 -    line_no: usize,
 -    col: usize,
 -) -> Result<(String, String), YamlError> {
 +fn split_key(content: &str, line_no: usize, col: usize) -> Result<(String, String), YamlError> {
      let colon = find_top_level_mapping_colon(content).ok_or(YamlError {
          line: line_no,
          col: col + 1,
      #[test]
      fn nested_mapping_via_indentation() {
 -        let doc = parse_one(
 -            "a:\n  b: 1\n  c: 2\n",
 -        );
 +        let doc = parse_one("a:\n  b: 1\n  c: 2\n");
          let a = doc.root.get("a").unwrap();
          let m = a.as_mapping().unwrap();
          assert_eq!(m[0], ("b".into(), Value::Scalar("1".into())));
      #[test]
      fn block_sequence_entries_with_flow_values() {
 -        let doc = parse_one(
 -            "exports:\n  - targets: [ arm64-macos ]\n    symbols: [ _foo, _bar ]\n",
 -        );
 +        let doc =
 +            parse_one("exports:\n  - targets: [ arm64-macos ]\n    symbols: [ _foo, _bar ]\n");
          let e = doc.root.get("exports").unwrap().as_sequence().unwrap();
          let entry = e[0].as_mapping().unwrap();
          assert_eq!(

src/macho/writer.rsmodified


         };
 
         let blob = build_function_starts(&layout, &atoms).unwrap();
-        assert_eq!(decode_function_starts_blob(&blob), vec![0x1000, 0x1008, 0x1040]);
+        assert_eq!(
+            decode_function_starts_blob(&blob),
+            vec![0x1000, 0x1008, 0x1040]
+        );
     }
 }

src/reloc/arm64.rsmodified

      referent: Referent,
  ) -> Result<i64, RelocError> {
      match length {
 -        RelocLength::Word => Ok(read_u32(bytes, local_offset, atom, obj, kind, &describe_referent(obj, referent))? as i32 as i64),
 -        RelocLength::Quad => Ok(read_u64(bytes, local_offset, atom, obj, kind, &describe_referent(obj, referent))? as i64),
 +        RelocLength::Word => Ok(read_u32(
 +            bytes,
 +            local_offset,
 +            atom,
 +            obj,
 +            kind,
 +            &describe_referent(obj, referent),
 +        )? as i32 as i64),
 +        RelocLength::Quad => Ok(read_u64(
 +            bytes,
 +            local_offset,
 +            atom,
 +            obj,
 +            kind,
 +            &describe_referent(obj, referent),
 +        )? as i64),
          other => Err(reloc_error(
              atom,
              &obj.path,

src/reloc/mod.rsmodified

      nreloc: u32,
  ) -> Result<Vec<RawRelocation>, ReadError> {
      let start = reloff as usize;
 -    let total = (nreloc as usize).checked_mul(RAW_RELOC_SIZE).ok_or(ReadError::Truncated {
 -        need: usize::MAX,
 -        have: file_bytes.len(),
 -        context: "reloc table (nreloc × 8 overflows)",
 -    })?;
 +    let total = (nreloc as usize)
 +        .checked_mul(RAW_RELOC_SIZE)
 +        .ok_or(ReadError::Truncated {
 +            need: usize::MAX,
 +            have: file_bytes.len(),
 +            context: "reloc table (nreloc × 8 overflows)",
 +        })?;
      let end = start.checked_add(total).ok_or(ReadError::Truncated {
          need: usize::MAX,
          have: file_bytes.len(),
      let mut out = Vec::with_capacity(nreloc as usize);
      for i in 0..nreloc as usize {
          let off = start + i * RAW_RELOC_SIZE;
 -        out.push(RawRelocation::parse(&file_bytes[off..off + RAW_RELOC_SIZE])?);
 +        out.push(RawRelocation::parse(
 +            &file_bytes[off..off + RAW_RELOC_SIZE],
 +        )?);
+     }
      Ok(out)
+ }
                      at_offset: raw.r_address as u32,
                      reason: "unknown ARM64_RELOC_* type",
                  })?;
 -                let length = RelocLength::from_bits(raw.r_length).ok_or(ReadError::BadRelocation {
 -                    at_offset: raw.r_address as u32,
 -                    reason: "invalid r_length (must be 0..=3)",
 -                })?;
 +                let length =
 +                    RelocLength::from_bits(raw.r_length).ok_or(ReadError::BadRelocation {
 +                        at_offset: raw.r_address as u32,
 +                        reason: "invalid r_length (must be 0..=3)",
 +                    })?;
                  let addend = pending_addend.take().map(|v| v as i64).unwrap_or(0);
                  let referent = referent_from(raw)?;
      fn raw_reloc_preserves_all_bit_fields() {
          // Cover every extreme value to catch shift/mask bugs.
          let raw = RawRelocation {
 -            r_address: -1, // signed negative round-trips
 +            r_address: -1,            // signed negative round-trips
              r_symbolnum: 0x00FF_FFFF, // max 24-bit value
              r_pcrel: true,
              r_length: 0b11,
      #[test]
      fn raw_reloc_truncated_errors() {
          let err = RawRelocation::parse(&[0u8; 4]).unwrap_err();
 -        assert!(matches!(err, ReadError::Truncated { need: RAW_RELOC_SIZE, have: 4, .. }));
 +        assert!(matches!(
 +            err,
 +            ReadError::Truncated {
 +                need: RAW_RELOC_SIZE,
 +                have: 4,
 +                ..
 +            }
 +        ));
+     }
      #[test]

src/resolve.rsmodified

              compatibility_version: file.compatibility_version,
              ordinal,
          };
 -        self.add_dylib_from_file_with_meta(
 -            path,
 -            file,
 -            load,
 -        )
 +        self.add_dylib_from_file_with_meta(path, file, load)
+     }
      pub fn add_dylib_from_file_with_meta(
+     }
      pub fn next_dylib_ordinal(&self) -> u16 {
 -        self.dylibs.iter().map(|dylib| dylib.ordinal).max().unwrap_or(0) + 1
 +        self.dylibs
 +            .iter()
 +            .map(|dylib| dylib.ordinal)
 +            .max()
 +            .unwrap_or(0)
 +            + 1
+     }
      // ---- accessors ----
                  first: existing_id,
                  second: Box::new(new.clone()),
              }),
 -            (false, true) => Ok(Action::Replace),     // strong over weak
 -            (true, false) => Ok(Action::Keep),        // strong keeps its seat
 -            (false, false) => Ok(Action::Keep),       // first weak wins
 +            (false, true) => Ok(Action::Replace), // strong over weak
 +            (true, false) => Ok(Action::Keep),    // strong keeps its seat
 +            (false, false) => Ok(Action::Keep),   // first weak wins
+         }
+     }
                  InsertOutcome::CommonCoalesced { id }
+             }
              Action::PendingArchiveFetch => {
 -                let Symbol::LazyArchive { archive, member, .. } = self.symbols[id.0 as usize]
 +                let Symbol::LazyArchive {
 +                    archive, member, ..
 +                } = self.symbols[id.0 as usize]
                  else {
                      unreachable!("PendingArchiveFetch requires LazyArchive in slot")
                  };
+                 }
+             }
              Action::PendingObjectLoad => {
 -                let Symbol::LazyObject { origin, .. } = self.symbols[id.0 as usize]
 -                else {
 +                let Symbol::LazyObject { origin, .. } = self.symbols[id.0 as usize] else {
                      unreachable!("PendingObjectLoad requires LazyObject in slot")
                  };
                  InsertOutcome::PendingObjectLoad { id, origin }
              unreachable!("coalesce_common requires two Common entries");
          };
          if let Symbol::Common {
 -            size,
 -            align_pow2,
 -            ..
 +            size, align_pow2, ..
          } = slot
+         {
              *size = a_size.max(b_size);
+     }
      pub fn get(&self, name: Istr) -> &[InputId] {
 -        self.entries
 -            .get(&name)
 -            .map(|v| v.as_slice())
 -            .unwrap_or(&[])
 +        self.entries.get(&name).map(|v| v.as_slice()).unwrap_or(&[])
+     }
      pub fn extend_from(&mut self, other: &ReferrerLog) {
      report: &mut SeedReport,
  ) -> Result<(), SeedError> {
      let di = inputs.dylib(dylib_id);
 -    let entries = di
 -        .file
 -        .exports
 -        .entries()
 -        .map_err(SeedError::Read)?;
 +    let entries = di.file.exports.entries().map_err(SeedError::Read)?;
      for entry in entries {
          let name = table.intern(&entry.name);
          let sym = Symbol::DylibImport {
      // Extract owned data before mutating the registry.
      let (logical_path, member_bytes) = {
          let archive = Archive::open(&ai.path, &ai.bytes)?;
 -        let member =
 -            archive
 -                .member_at_offset(member_id.0)
 -                .ok_or(FetchError::MemberNotFound {
 -                    archive: archive_id,
 -                    member: member_id,
 -                })?;
 +        let member = archive
 +            .member_at_offset(member_id.0)
 +            .ok_or(FetchError::MemberNotFound {
 +                archive: archive_id,
 +                member: member_id,
 +            })?;
          let logical = format!("{}({})", ai.path.display(), member.name);
          (logical, member.body.to_vec())
      };
      };
      let mut queue: Vec<PendingFetch> = Vec::new();
      for offset in member_offsets {
 -        let new = ingest_member_bytes(
 -            inputs,
 -            table,
 -            archive_id,
 -            MemberId(offset),
 -            report,
 -        )?;
 +        let new = ingest_member_bytes(inputs, table, archive_id, MemberId(offset), report)?;
          queue.extend(new);
+     }
      while let Some(p) = queue.pop() {
          row[0] = i + 1;
          for (j, cb) in b.iter().enumerate() {
              let cost = if ca == cb { 0 } else { 1 };
 -            let new_val = (row[j + 1] + 1)
 -                .min(row[j] + 1)
 -                .min(prev + cost);
 +            let new_val = (row[j + 1] + 1).min(row[j] + 1).min(prev + cost);
              prev = row[j + 1];
              row[j + 1] = new_val;
+         }
      let undefs: Vec<(SymbolId, Istr, bool)> = table
          .iter()
          .filter_map(|(id, s)| match s {
 -            Symbol::Undefined {
 -                name, weak_ref, ..
 -            } => Some((id, *name, *weak_ref)),
 +            Symbol::Undefined { name, weak_ref, .. } => Some((id, *name, *weak_ref)),
              _ => None,
          })
          .collect();
          t.insert(lazy).unwrap();
          let want = undef(&mut t, "_hidden");
          match t.insert(want).unwrap() {
 -            InsertOutcome::PendingArchiveFetch { archive, member, .. } => {
 +            InsertOutcome::PendingArchiveFetch {
 +                archive, member, ..
 +            } => {
                  assert_eq!(archive, ArchiveId(7));
                  assert_eq!(member, MemberId(42));
+             }

src/section.rsmodified

              Vec::new()
          } else {
              let start = hdr.offset as usize;
 -            let end = start.checked_add(hdr.size as usize).ok_or(ReadError::Truncated {
 -                need: usize::MAX,
 -                have: file_bytes.len(),
 -                context: "section content (offset + size overflows)",
 -            })?;
 +            let end = start
 +                .checked_add(hdr.size as usize)
 +                .ok_or(ReadError::Truncated {
 +                    need: usize::MAX,
 +                    have: file_bytes.len(),
 +                    context: "section content (offset + size overflows)",
 +                })?;
              if end > file_bytes.len() {
                  return Err(ReadError::Truncated {
                      need: end,
              Vec::new()
          } else {
              let start = hdr.reloff as usize;
 -            let total = (hdr.nreloc as usize).checked_mul(8).ok_or(ReadError::Truncated {
 -                need: usize::MAX,
 -                have: file_bytes.len(),
 -                context: "section relocs (nreloc × 8 overflows)",
 -            })?;
 +            let total = (hdr.nreloc as usize)
 +                .checked_mul(8)
 +                .ok_or(ReadError::Truncated {
 +                    need: usize::MAX,
 +                    have: file_bytes.len(),
 +                    context: "section relocs (nreloc × 8 overflows)",
 +                })?;
              let end = start.checked_add(total).ok_or(ReadError::Truncated {
                  need: usize::MAX,
                  have: file_bytes.len(),

src/string_table.rsmodified

      /// from `LC_SYMTAB`.
      pub fn from_file(file_bytes: &[u8], stroff: u32, strsize: u32) -> Result<Self, ReadError> {
          let start = stroff as usize;
 -        let end = start.checked_add(strsize as usize).ok_or(ReadError::Truncated {
 -            need: usize::MAX,
 -            have: file_bytes.len(),
 -            context: "string table (stroff + strsize overflows)",
 -        })?;
 +        let end = start
 +            .checked_add(strsize as usize)
 +            .ok_or(ReadError::Truncated {
 +                need: usize::MAX,
 +                have: file_bytes.len(),
 +                context: "string table (stroff + strsize overflows)",
 +            })?;
          if end > file_bytes.len() {
              return Err(ReadError::Truncated {
                  need: end,
                  reason: "strx out of bounds",
              });
+         }
 -        let end = start + self.raw[start..]
 -            .iter()
 -            .position(|&b| b == 0)
 -            .ok_or(ReadError::BadCmdsize {
 -                cmd: 0,
 -                cmdsize: 0,
 -                at_offset: start,
 -                reason: "unterminated string (no null byte before end)",
 -            })?;
 +        let end = start
 +            + self.raw[start..]
 +                .iter()
 +                .position(|&b| b == 0)
 +                .ok_or(ReadError::BadCmdsize {
 +                    cmd: 0,
 +                    cmdsize: 0,
 +                    at_offset: start,
 +                    reason: "unterminated string (no null byte before end)",
 +                })?;
          std::str::from_utf8(&self.raw[start..end]).map_err(|_| ReadError::BadCmdsize {
              cmd: 0,
              cmdsize: 0,
      fn out_of_bounds_strx_errors() {
          let t = tbl(b"\0a\0");
          let err = t.get(100).unwrap_err();
 -        assert!(matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("out of bounds")));
 +        assert!(
 +            matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("out of bounds"))
 +        );
+     }
      #[test]
      fn unterminated_string_errors() {
          let t = tbl(b"\0abcdef"); // no trailing null
          let err = t.get(1).unwrap_err();
 -        assert!(matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("unterminated")));
 +        assert!(
 +            matches!(err, ReadError::BadCmdsize { reason, .. } if reason.contains("unterminated"))
 +        );
+     }
      #[test]

src/symbol.rsmodified

      use super::*;
      fn nlist(strx: u32, n_type: u8, n_sect: u8, n_desc: u16, n_value: u64) -> RawNlist {
 -        RawNlist { strx, n_type, n_sect, n_desc, n_value }
 +        RawNlist {
 +            strx,
 +            n_type,
 +            n_sect,
 +            n_desc,
 +            n_value,
 +        }
+     }
      #[test]

src/synth/code_sig.rsmodified

          code_limit: u64,
          executable: bool,
      ) -> Result<Self, &'static str> {
 -        let code_limit = u32::try_from(code_limit).map_err(|_| "code-signature offset exceeds 32-bit Mach-O field width")?;
 +        let code_limit = u32::try_from(code_limit)
 +            .map_err(|_| "code-signature offset exceeds 32-bit Mach-O field width")?;
          let identifier = output_identifier(opts);
          let (exec_seg_base, exec_seg_limit, exec_seg_flags) = exec_segment_info(layout, executable);
          let blob_len = blob_len(code_limit as usize, &identifier);
          Ok(Self {
              dataoff: code_limit,
 -            datasize: u32::try_from(blob_len).map_err(|_| "code-signature blob exceeds 32-bit Mach-O field width")?,
 +            datasize: u32::try_from(blob_len)
 +                .map_err(|_| "code-signature blob exceeds 32-bit Mach-O field width")?,
              code_limit,
              identifier,
              exec_seg_base,
          if !is_executable(section.kind) || section.is_zerofill() {
              continue;
+         }
 -        min_off = Some(
 -            min_off.map_or(section.file_off, |min_off: u64| min_off.min(section.file_off)),
 -        );
 +        min_off = Some(min_off.map_or(section.file_off, |min_off: u64| {
 +            min_off.min(section.file_off)
 +        }));
          max_end = max_end.max(section.file_off + section.size);
+     }
      let exec_seg_limit = min_off.map_or(0, |min_off| max_end.saturating_sub(min_off));
+ }
  fn blob_len(code_limit: usize, identifier: &str) -> usize {
 -    let cd_len = CODEDIRECTORY_HEADER_SIZE + identifier.len() + 1 + code_slots(code_limit) * CS_SHA256_LEN as usize;
 +    let cd_len = CODEDIRECTORY_HEADER_SIZE
 +        + identifier.len()
 +        + 1
 +        + code_slots(code_limit) * CS_SHA256_LEN as usize;
      align_up((SUPERBLOB_HEADER_SIZE + cd_len) as u64, 8) as usize
+ }
  fn sha256(data: &[u8]) -> [u8; 32] {
      const INIT: [u32; 8] = [
 -        0x6a09e667,
 -        0xbb67ae85,
 -        0x3c6ef372,
 -        0xa54ff53a,
 -        0x510e527f,
 -        0x9b05688c,
 -        0x1f83d9ab,
 +        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
 x5be0cd19,
      ];
      const K: [u32; 64] = [
      let mut block = [0u8; 128];
      let full_blocks = data.len() / 64;
      for idx in 0..full_blocks {
 -        compress(&mut state, (&data[idx * 64..idx * 64 + 64]).try_into().unwrap(), &K);
 +        compress(
 +            &mut state,
 +            (&data[idx * 64..idx * 64 + 64]).try_into().unwrap(),
 +            &K,
 +        );
+     }
      let rem = &data[full_blocks * 64..];
          assert_eq!(
              sha256(b""),
+             [
 -                0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99,
 -                0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95,
 -                0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55,
 +                0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f,
 +                0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b,
 +                0x78, 0x52, 0xb8, 0x55,
+             ]
          );
          assert_eq!(
              sha256(b"abc"),
+             [
 -                0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d,
 -                0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10,
 -                0xff, 0x61, 0xf2, 0x00, 0x15, 0xad,
 +                0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae,
 +                0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61,
 +                0xf2, 0x00, 0x15, 0xad,
+             ]
          );
+     }
              output: Some("apple".into()),
              ..LinkOptions::default()
          };
 -        let plan = CodeSignaturePlan::new(&Layout::empty(crate::OutputKind::Executable, 0), &opts, 16_512, true).unwrap();
 +        let plan = CodeSignaturePlan::new(
 +            &Layout::empty(crate::OutputKind::Executable, 0),
 +            &opts,
 +            16_512,
 +            true,
 +        )
 +        .unwrap();
          let blob = plan.build(&vec![0; 16_512]);
          assert_eq!(plan.dataoff, 16_512);

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_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,
  };
  use crate::macho::exports::{ExportEntry, ExportKind};
      let mut stream = OpcodeStream::new();
      stream.uleb(terminal.len() as u64);
      stream.bytes(&terminal);
 -    stream.byte(u8::try_from(node.children.len()).expect("export trie node fanout should fit in u8"));
 +    stream
 +        .byte(u8::try_from(node.children.len()).expect("export trie node fanout should fit in u8"));
      for (edge, child) in &node.children {
          stream.string(edge);
          stream.uleb(offsets[*child] as u64);
              state.ordinal = Some(spec.ordinal);
+         }
 -        if current_symbol.as_deref() != Some(spec.name) || state.weak_import != Some(spec.weak_import) {
 -            out.byte(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | bind_symbol_flags(spec.weak_import));
 +        if current_symbol.as_deref() != Some(spec.name)
 +            || state.weak_import != Some(spec.weak_import)
 +        {
 +            out.byte(
 +                BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | bind_symbol_flags(spec.weak_import),
 +            );
              out.string(spec.name);
              current_symbol = Some(spec.name.to_string());
              state.weak_import = Some(spec.weak_import);
          match (state.segment_index, state.next_segment_offset) {
              (Some(segment_index), Some(next_segment_offset))
 -                if segment_index == spec.segment_index && next_segment_offset == spec.segment_offset => {}
 +                if segment_index == spec.segment_index
 +                    && next_segment_offset == spec.segment_offset => {}
              (Some(segment_index), Some(next_segment_offset))
 -                if segment_index == spec.segment_index && next_segment_offset < spec.segment_offset =>
 +                if segment_index == spec.segment_index
 +                    && next_segment_offset < spec.segment_offset =>
+             {
                  out.byte(BIND_OPCODE_ADD_ADDR_ULEB);
                  out.uleb(spec.segment_offset - next_segment_offset);
      use crate::macho::constants::{
          BIND_OPCODE_DO_BIND, BIND_OPCODE_SET_ADDEND_SLEB, BIND_OPCODE_SET_DYLIB_ORDINAL_IMM,
          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
 -        BIND_OPCODE_SET_TYPE_IMM, BIND_TYPE_POINTER,
 -        EXPORT_SYMBOL_FLAGS_KIND_REGULAR, EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL,
 -        EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION,
 +        BIND_OPCODE_SET_TYPE_IMM, BIND_TYPE_POINTER, EXPORT_SYMBOL_FLAGS_KIND_REGULAR,
 +        EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL, EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION,
      };
      use crate::macho::exports::Exports;
              vec![
                  BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | 1,
                  BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
 -                b'_', b'a', b'l', b'p', b'h', b'a', 0,
 +                b'_',
 +                b'a',
 +                b'l',
 +                b'p',
 +                b'h',
 +                b'a',
 +                0,
                  BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER,
                  BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | 2,
 ,
                  BIND_OPCODE_DO_BIND,
                  BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
 -                b'_', b'b', b'e', b't', b'a', 0,
 +                b'_',
 +                b'b',
 +                b'e',
 +                b't',
 +                b'a',
 +                0,
                  BIND_OPCODE_DO_BIND,
 ,
+             ]

src/synth/mod.rsmodified

  };
  use self::tlv::{ThreadPointerSection, THREAD_POINTER_SIZE};
 +const COMPACT_UNWIND_PERSONALITY_FIELD_OFFSET: u32 = 16;
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct SyntheticPlan {
      pub got: GotSection,
                  .map(Vec::as_slice)
                  .unwrap_or(&[]);
              for reloc in relocs_for_atom(relocs, atom) {
 +                if atom.section == AtomSection::CompactUnwind
 +                    && reloc.kind == RelocKind::Unsigned
 +                    && reloc.offset
 +                        == atom.input_offset + COMPACT_UNWIND_PERSONALITY_FIELD_OFFSET
 +                {
 +                    if let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table)
 +                    {
 +                        got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
 +                    }
 +                    continue;
 +                }
                  match reloc.kind {
                      RelocKind::Unsigned => {
                          // `__thread_vars` descriptors carry their own dedicated
          assert_eq!(plan.direct_binds[0].symbol, import);
+     }
 +    #[test]
 +    fn synthetic_plan_collects_got_for_compact_unwind_personality_import() {
 +        let mut sym_table = SymbolTable::new();
 +        let name = sym_table.intern("___gxx_personality_v0");
 +        let input_id = InputId(0);
 +        let import = match sym_table
 +            .insert(Symbol::DylibImport {
 +                name,
 +                dylib: DylibId(0),
 +                ordinal: 2,
 +                weak_import: false,
 +            })
 +            .unwrap()
 +        {
 +            crate::resolve::InsertOutcome::Inserted(id) => id,
 +            other => panic!("unexpected insert outcome: {other:?}"),
 +        };
++
 +        let relocs = vec![Reloc {
 +            offset: 16,
 +            kind: RelocKind::Unsigned,
 +            length: RelocLength::Quad,
 +            pcrel: false,
 +            referent: Referent::Symbol(0),
 +            addend: 0,
 +            subtrahend: None,
 +        }];
 +        let object = compact_unwind_object("___gxx_personality_v0", encode_raw_relocs(&relocs));
++
 +        let mut atoms = AtomTable::new();
 +        atoms.push(Atom {
 +            id: crate::resolve::AtomId(0),
 +            origin: input_id,
 +            input_section: 1,
 +            section: AtomSection::CompactUnwind,
 +            input_offset: 0,
 +            size: 32,
 +            align_pow2: 3,
 +            owner: None,
 +            alt_entries: Vec::new(),
 +            data: vec![0; 32],
 +            flags: AtomFlags::default(),
 +            parent_of: None,
 +        });
++
 +        let plan = SyntheticPlan::build(
 +            &[LayoutInput {
 +                id: input_id,
 +                object: &object,
 +            }],
 +            &atoms,
 +            &mut sym_table,
 +            &[libsystem_input()],
 +        )
 +        .unwrap();
++
 +        assert_eq!(plan.got.entries.len(), 1);
 +        assert_eq!(plan.got.entries[0].symbol, import);
 +        assert!(plan.stubs.entries.is_empty());
 +        assert!(plan.lazy_pointers.entries.is_empty());
 +    }
++
      fn libsystem_input() -> DylibInput {
          DylibInput {
              path: PathBuf::from("/tmp/libSystem.tbd"),
              data_in_code: Vec::new(),
+         }
+     }
++
 +    fn compact_unwind_object(symbol_name: &str, raw_relocs: Vec<u8>) -> ObjectFile {
 +        let mut strings = vec![0];
 +        let strx = strings.len() as u32;
 +        strings.extend_from_slice(symbol_name.as_bytes());
 +        strings.push(0);
 +        ObjectFile {
 +            path: PathBuf::from("/tmp/synth-compact-unwind.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![InputSection {
 +                segname: "__LD".into(),
 +                sectname: "__compact_unwind".into(),
 +                kind: SectionKind::CompactUnwind,
 +                addr: 0,
 +                size: 32,
 +                align_pow2: 3,
 +                flags: crate::macho::constants::S_REGULAR,
 +                offset: 0,
 +                reloff: 0,
 +                nreloc: (raw_relocs.len() / 8) as u32,
 +                reserved1: 0,
 +                reserved2: 0,
 +                reserved3: 0,
 +                data: vec![0; 32],
 +                raw_relocs,
 +            }],
 +            symbols: vec![InputSymbol::from_raw(RawNlist {
 +                strx,
 +                n_type: N_UNDF | N_EXT,
 +                n_sect: 0,
 +                n_desc: 0,
 +                n_value: 0,
 +            })],
 +            strings: StringTable::from_bytes(strings),
 +            symtab: None,
 +            dysymtab: None,
 +            data_in_code: Vec::new(),
 +        }
 +    }
+ }

src/synth/unwind.rsmodified

  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc};
  use crate::resolve::{AtomId, InputId, Symbol, SymbolTable};
  use crate::section::{OutputSection, SectionKind};
 +use crate::synth::SyntheticPlan;
  const PAGE_SIZE: usize = 4096;
  const UNWIND_INFO_VERSION: u32 = 1;
  const UNWIND_SECOND_LEVEL_COMPRESSED: u32 = 3;
  const FIRST_LEVEL_ENTRY_SIZE: usize = 12;
  const COMPRESSED_PAGE_HEADER_SIZE: usize = 12;
 +const UNWIND_HAS_LSDA: u32 = 0x4000_0000;
 +const UNWIND_PERSONALITY_MASK: u32 = 0x3000_0000;
 +const UNWIND_PERSONALITY_SHIFT: u32 = 28;
 +const UNWIND_ARM64_MODE_MASK: u32 = 0x0f00_0000;
 +const UNWIND_ARM64_MODE_DWARF: u32 = 0x0300_0000;
 +const UNWIND_ARM64_DWARF_SECTION_OFFSET_MASK: u32 = 0x00ff_ffff;
 +const COMPACT_UNWIND_FUNCTION_OFFSET: usize = 0;
 +const COMPACT_UNWIND_PERSONALITY_OFFSET: usize = 16;
 +const COMPACT_UNWIND_LSDA_OFFSET: usize = 24;
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct UnwindError {
      UnsupportedSecondLevelPageKind(u32),
      BadFirstLevelIndexOrder { previous: u32, next: u32 },
      BadEncodingIndex { index: u32, max: u32 },
 +    TooManyPersonalities(usize),
+ }
  impl fmt::Display for UnwindReadError {
                      "encoding index {index} exceeds decoded encoding table size {max}"
+                 )
+             }
 +            UnwindReadError::TooManyPersonalities(count) => {
 +                write!(f, "unwind info needs {count} personalities but only 3 are encodable")
 +            }
+         }
+     }
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct DecodedUnwindInfo {
      pub version: u32,
 +    pub personalities: Vec<u32>,
 +    pub lsdas: Vec<DecodedLsdaRecord>,
      pub records: Vec<DecodedUnwindRecord>,
+ }
      function_offset: u32,
      code_len: u32,
      encoding: u32,
 +    personality_offset: Option<u32>,
 +    lsda_offset: Option<u32>,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct DecodedLsdaRecord {
 +    pub function_offset: u32,
 +    pub lsda_offset: u32,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +struct LsdaRecord {
 +    function_offset: u32,
 +    lsda_offset: u32,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      inputs: &[LayoutInput<'_>],
      atoms: &AtomTable,
      sym_table: &SymbolTable,
 +    synthetic_plan: &SyntheticPlan,
  ) -> Result<bool, UnwindError> {
      let mut changed = remove_compact_unwind_sections(layout);
 -    let records = collect_records(layout, inputs, atoms, sym_table)?;
 +    let records = collect_records(layout, inputs, atoms, sym_table, synthetic_plan)?;
      if records.is_empty() {
          changed |= remove_unwind_info_section(layout);
          if changed {
          return Ok(changed);
+     }
 -    let bytes = serialize_unwind_info(&records);
 +    let bytes = serialize_unwind_info(&records).map_err(|err| UnwindError {
 +        input: PathBuf::from("<synthetic unwind>"),
 +        atom: AtomId(0),
 +        detail: err.to_string(),
 +    })?;
      validate_serialized_unwind_info(&bytes, &records).map_err(|err| UnwindError {
          input: PathBuf::from("<synthetic unwind>"),
          atom: AtomId(0),
      inputs: &[LayoutInput<'_>],
      atoms: &AtomTable,
      sym_table: &SymbolTable,
 +    synthetic_plan: &SyntheticPlan,
  ) -> Result<Vec<UnwindRecord>, UnwindError> {
      let text_base = layout
          .segment("__TEXT")
              .unwrap_or(&[]);
          let function_addr =
              resolve_function_address(atom_id, atom, obj, relocs, atoms, sym_table, layout)?;
 -        if has_nonzero_u64(atom, 16) || has_reloc_at(relocs, atom.input_offset + 16) {
 -            return Err(UnwindError {
 +        let personality_offset = resolve_metadata_offset(
 +            atom_id,
 +            atom,
 +            obj,
 +            relocs,
 +            atoms,
 +            sym_table,
 +            layout,
 +            synthetic_plan,
 +            COMPACT_UNWIND_PERSONALITY_OFFSET,
 +            true,
 +            "personality",
 +        )?
 +        .map(|addr| {
 +            u32::try_from(addr.saturating_sub(text_base)).map_err(|_| UnwindError {
                  input: obj.path.clone(),
                  atom: atom_id,
 -                detail: "personality records are not implemented yet".to_string(),
 -            });
 -        }
 -        if has_nonzero_u64(atom, 24) || has_reloc_at(relocs, atom.input_offset + 24) {
 -            return Err(UnwindError {
 +                detail: "personality target exceeds 32-bit unwind offset range".to_string(),
 +            })
 +        })
 +        .transpose()?;
 +        let lsda_offset = resolve_metadata_offset(
 +            atom_id,
 +            atom,
 +            obj,
 +            relocs,
 +            atoms,
 +            sym_table,
 +            layout,
 +            synthetic_plan,
 +            COMPACT_UNWIND_LSDA_OFFSET,
 +            false,
 +            "LSDA",
 +        )?
 +        .map(|addr| {
 +            u32::try_from(addr.saturating_sub(text_base)).map_err(|_| UnwindError {
                  input: obj.path.clone(),
                  atom: atom_id,
 -                detail: "LSDA records are not implemented yet".to_string(),
 -            });
 -        }
 +                detail: "LSDA target exceeds 32-bit unwind offset range".to_string(),
 +            })
 +        })
 +        .transpose()?;
          let function_offset =
              u32::try_from(function_addr.saturating_sub(text_base)).map_err(|_| UnwindError {
              function_offset,
              code_len: u32::from_le_bytes(atom.data[8..12].try_into().unwrap()),
              encoding: u32::from_le_bytes(atom.data[12..16].try_into().unwrap()),
 +            personality_offset,
 +            lsda_offset,
          });
+     }
              detail: "function_start reloc is missing".to_string(),
          });
      };
 -    match reloc.referent {
 +    resolve_reference_address(
 +        atom_id,
 +        atom,
 +        obj,
 +        atoms,
 +        sym_table,
 +        layout,
 +        None,
 +        reloc.referent,
 +        read_u64(atom, COMPACT_UNWIND_FUNCTION_OFFSET)? as u32,
 +        "function_start",
 +        false,
 +    )
 +}
++
 +#[allow(clippy::too_many_arguments)]
 +fn resolve_metadata_offset(
 +    atom_id: AtomId,
 +    atom: &Atom,
 +    obj: &crate::input::ObjectFile,
 +    relocs: &[Reloc],
 +    atoms: &AtomTable,
 +    sym_table: &SymbolTable,
 +    layout: &Layout,
 +    synthetic_plan: &SyntheticPlan,
 +    field_offset: usize,
 +    allow_import_got: bool,
 +    label: &str,
 +) -> Result<Option<u64>, UnwindError> {
 +    let raw_value = read_u64(atom, field_offset)?;
 +    let reloc = relocs
 +        .iter()
 +        .find(|reloc| reloc.offset == atom.input_offset + field_offset as u32);
 +    if raw_value == 0 && reloc.is_none() {
 +        return Ok(None);
 +    }
 +    let Some(reloc) = reloc else {
 +        return Err(UnwindError {
 +            input: obj.path.clone(),
 +            atom: atom_id,
 +            detail: format!("{label} field has inline value but no relocation"),
 +        });
 +    };
 +    Ok(Some(resolve_reference_address(
 +        atom_id,
 +        atom,
 +        obj,
 +        atoms,
 +        sym_table,
 +        layout,
 +        Some(synthetic_plan),
 +        reloc.referent,
 +        raw_value as u32,
 +        label,
 +        allow_import_got,
 +    )?))
 +}
++
 +#[allow(clippy::too_many_arguments)]
 +fn resolve_reference_address(
 +    atom_id: AtomId,
 +    atom: &Atom,
 +    obj: &crate::input::ObjectFile,
 +    atoms: &AtomTable,
 +    sym_table: &SymbolTable,
 +    layout: &Layout,
 +    synthetic_plan: Option<&SyntheticPlan>,
 +    referent: Referent,
 +    target_offset: u32,
 +    label: &str,
 +    allow_import_got: bool,
 +) -> Result<u64, UnwindError> {
 +    match referent {
          Referent::Section(section_idx) => {
 -            let target_offset = read_u64(atom, 0)? as u32;
 +            let input_section = obj
 +                .sections
 +                .get((section_idx as usize).saturating_sub(1))
 +                .ok_or_else(|| UnwindError {
 +                    input: obj.path.clone(),
 +                    atom: atom_id,
 +                    detail: format!("{label} section {} is out of range", section_idx),
 +                })?;
              let Some((candidate_id, candidate)) = atoms.iter().find(|(_, candidate)| {
                  candidate.origin == atom.origin
                      && candidate.input_section == section_idx
 -                    && candidate.input_offset <= target_offset
 -                    && target_offset < candidate.input_offset + candidate.size
 +                    && input_section.addr + candidate.input_offset as u64 <= target_offset as u64
 +                    && (target_offset as u64)
 +                        < input_section.addr + candidate.input_offset as u64 + candidate.size as u64
              }) else {
                  return Err(UnwindError {
                      input: obj.path.clone(),
                      atom: atom_id,
                      detail: format!(
 -                        "function_start points at missing input atom section {} offset 0x{:x}",
 +                        "{label} points at missing input atom section {} offset 0x{:x}",
                          section_idx, target_offset
                      ),
                  });
                  return Err(UnwindError {
                      input: obj.path.clone(),
                      atom: atom_id,
 -                    detail: format!("function atom {:?} missing from final layout", candidate_id),
 +                    detail: format!("{label} atom {:?} missing from final layout", candidate_id),
                  });
              };
 -            Ok(base_addr + (target_offset - candidate.input_offset) as u64)
 +            let atom_input_addr = input_section.addr + candidate.input_offset as u64;
 +            Ok(base_addr + (target_offset as u64 - atom_input_addr))
+         }
          Referent::Symbol(sym_idx) => {
              let input_symbol = obj
                  .ok_or_else(|| UnwindError {
                      input: obj.path.clone(),
                      atom: atom_id,
 -                    detail: format!("function_start symbol {} is out of range", sym_idx),
 +                    detail: format!("{label} symbol {} is out of range", sym_idx),
                  })?;
              let name = obj.symbol_name(input_symbol).map_err(|err| UnwindError {
                  input: obj.path.clone(),
                  atom: atom_id,
                  detail: err.to_string(),
              })?;
 -            let Some((_, symbol)) = sym_table
 +            let Some((symbol_id, symbol)) = sym_table
                  .iter()
                  .find(|(_, symbol)| sym_table.interner.resolve(symbol.name()) == name)
              else {
                  return Err(UnwindError {
                      input: obj.path.clone(),
                      atom: atom_id,
 -                    detail: format!("function_start symbol `{name}` was not resolved"),
 +                    detail: format!("{label} symbol `{name}` was not resolved"),
                  });
              };
              match symbol {
 -                Symbol::Defined { atom, value, .. } => {
 -                    let Some(base_addr) = layout.atom_addr(*atom) else {
 +                Symbol::Defined {
 +                    atom: target_atom,
 +                    value,
 +                    ..
 +                } => {
 +                    let Some(base_addr) = layout.atom_addr(*target_atom) else {
                          return Err(UnwindError {
                              input: obj.path.clone(),
                              atom: atom_id,
 -                            detail: format!("function atom {:?} missing from final layout", atom),
 +                            detail: format!(
 +                                "{label} atom {:?} missing from final layout",
 +                                target_atom
 +                            ),
                          });
                      };
                      Ok(base_addr + *value)
+                 }
 +                Symbol::DylibImport { .. } if allow_import_got => {
 +                    personality_got_addr(layout, synthetic_plan, symbol_id, atom_id, obj, label)
 +                }
                  other => Err(UnwindError {
                      input: obj.path.clone(),
                      atom: atom_id,
                      detail: format!(
 -                        "function_start symbol `{name}` resolved to unsupported kind {:?}",
 +                        "{label} symbol `{name}` resolved to unsupported kind {:?}",
                          other.kind()
                      ),
                  }),
+     }
+ }
 +fn personality_got_addr(
 +    layout: &Layout,
 +    synthetic_plan: Option<&SyntheticPlan>,
 +    symbol_id: crate::resolve::SymbolId,
 +    atom_id: AtomId,
 +    obj: &crate::input::ObjectFile,
 +    label: &str,
 +) -> Result<u64, UnwindError> {
 +    let Some(plan) = synthetic_plan else {
 +        return Err(UnwindError {
 +            input: obj.path.clone(),
 +            atom: atom_id,
 +            detail: format!("{label} import needs a synthetic GOT slot"),
 +        });
 +    };
 +    let Some((idx, _)) = plan.got.get(symbol_id) else {
 +        return Err(UnwindError {
 +            input: obj.path.clone(),
 +            atom: atom_id,
 +            detail: format!("{label} import is missing synthetic GOT planning"),
 +        });
 +    };
 +    let Some(section) = layout
 +        .sections
 +        .iter()
 +        .find(|section| section.segment == "__DATA_CONST" && section.name == "__got")
 +    else {
 +        return Err(UnwindError {
 +            input: obj.path.clone(),
 +            atom: atom_id,
 +            detail: format!("{label} import is missing the output __got section"),
 +        });
 +    };
 +    Ok(section.addr + (idx as u64) * 8)
 +}
++
  fn read_u64(atom: &Atom, offset: usize) -> Result<u64, UnwindError> {
      let end = offset + 8;
      if end > atom.data.len() {
      ))
+ }
 -fn has_nonzero_u64(atom: &Atom, offset: usize) -> bool {
 -    read_u64(atom, offset)
 -        .map(|value| value != 0)
 -        .unwrap_or(false)
 -}
+-
 -fn has_reloc_at(relocs: &[Reloc], offset: u32) -> bool {
 -    relocs.iter().any(|reloc| reloc.offset == offset)
 -}
+-
 -fn serialize_unwind_info(records: &[UnwindRecord]) -> Vec<u8> {
 -    let pages = build_pages(records);
 -    let indices_offset = 7 * 4;
 +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_offset = 7 * 4;
 +    let common_encodings_count = 0u32;
 +    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;
 -    let second_level_start = align_up(
 -        (indices_offset + indices_count as usize * FIRST_LEVEL_ENTRY_SIZE) as u32,
 -        16,
 -    ) as usize;
 +    let lsdas_offset = indices_offset + indices_count as usize * FIRST_LEVEL_ENTRY_SIZE;
 +    let second_level_start = align_up((lsdas_offset + lsdas.len() * 8) as u32, 16) as usize;
      let page_blobs: Vec<Vec<u8>> = pages.iter().map(serialize_compressed_page).collect();
 -    let lsda_offset = second_level_start as u32;
      let sentinel = records
          .last()
          .map(|record| record.function_offset + record.code_len)
      let mut out = Vec::new();
      out.extend_from_slice(&UNWIND_INFO_VERSION.to_le_bytes());
 -    out.extend_from_slice(&(indices_offset as u32).to_le_bytes());
 -    out.extend_from_slice(&0u32.to_le_bytes());
 -    out.extend_from_slice(&(indices_offset as u32).to_le_bytes());
 -    out.extend_from_slice(&0u32.to_le_bytes());
 +    out.extend_from_slice(&(common_encodings_offset as u32).to_le_bytes());
 +    out.extend_from_slice(&common_encodings_count.to_le_bytes());
 +    out.extend_from_slice(&(personalities_offset as u32).to_le_bytes());
 +    out.extend_from_slice(&(personalities.len() as u32).to_le_bytes());
      out.extend_from_slice(&(indices_offset as u32).to_le_bytes());
      out.extend_from_slice(&indices_count.to_le_bytes());
 +    for personality in &personalities {
 +        out.extend_from_slice(&personality.to_le_bytes());
 +    }
++
 +    let mut page_lsda_index = 0usize;
      let mut page_offset = second_level_start as u32;
 -    for page in &pages {
 +    for (page_idx, page) in pages.iter().enumerate() {
 +        let next_page_start = pages
 +            .get(page_idx + 1)
 +            .map(|page| page.start_function_offset)
 +            .unwrap_or(sentinel);
 +        while page_lsda_index < lsdas.len()
 +            && lsdas[page_lsda_index].function_offset < page.start_function_offset
 +        {
 +            page_lsda_index += 1;
 +        }
 +        let lsda_index_offset = lsdas_offset as u32 + (page_lsda_index as u32) * 8;
          out.extend_from_slice(&page.start_function_offset.to_le_bytes());
          out.extend_from_slice(&page_offset.to_le_bytes());
 -        out.extend_from_slice(&lsda_offset.to_le_bytes());
 +        out.extend_from_slice(&lsda_index_offset.to_le_bytes());
 +        while page_lsda_index < lsdas.len()
 +            && lsdas[page_lsda_index].function_offset < next_page_start
 +        {
 +            page_lsda_index += 1;
 +        }
          page_offset += serialize_compressed_page(page).len() as u32;
+     }
      out.extend_from_slice(&sentinel.to_le_bytes());
      out.extend_from_slice(&0u32.to_le_bytes());
 -    out.extend_from_slice(&lsda_offset.to_le_bytes());
 +    out.extend_from_slice(&(lsdas_offset as u32 + (lsdas.len() as u32) * 8).to_le_bytes());
++
 +    for lsda in &lsdas {
 +        out.extend_from_slice(&lsda.function_offset.to_le_bytes());
 +        out.extend_from_slice(&lsda.lsda_offset.to_le_bytes());
 +    }
++
      while out.len() < second_level_start {
          out.push(0);
+     }
      while !out.len().is_multiple_of(8) {
          out.push(0);
+     }
 -    out
 +    Ok(out)
+ }
  pub fn decode_unwind_info(bytes: &[u8]) -> Result<DecodedUnwindInfo, UnwindReadError> {
+     }
      let common_encodings_offset = read_u32(bytes, 4, "common encodings offset")? as usize;
      let common_encodings_count = read_u32(bytes, 8, "common encodings count")? as usize;
 -    let _personalities_offset = read_u32(bytes, 12, "personalities offset")? as usize;
 -    let _personalities_count = read_u32(bytes, 16, "personalities count")? as usize;
 +    let personalities_offset = read_u32(bytes, 12, "personalities offset")? as usize;
 +    let personalities_count = read_u32(bytes, 16, "personalities count")? as usize;
      let indices_offset = read_u32(bytes, 20, "indices offset")? as usize;
      let indices_count = read_u32(bytes, 24, "indices count")? as usize;
          common_encodings_count,
          "common encodings",
      )?;
 +    let personalities = read_u32_array(
 +        bytes,
 +        personalities_offset,
 +        personalities_count,
 +        "personality array",
 +    )?;
      let mut index_starts = Vec::new();
 +    let mut index_lsda_offsets = Vec::new();
      for idx in 0..indices_count {
          let entry_off = indices_offset + idx * FIRST_LEVEL_ENTRY_SIZE;
          if entry_off + FIRST_LEVEL_ENTRY_SIZE > bytes.len() {
              return Err(UnwindReadError::Truncated("first-level index"));
+         }
          index_starts.push(read_u32(bytes, entry_off, "first-level function offset")?);
 +        index_lsda_offsets.push(read_u32(bytes, entry_off + 8, "first-level lsda offset")?);
+     }
      for pair in index_starts.windows(2) {
          if pair[0] > pair[1] {
+         }
+     }
 +    let mut lsdas = Vec::new();
 +    if let (Some(&lsda_start), Some(&lsda_end)) = (index_lsda_offsets.first(), index_lsda_offsets.last())
 +    {
 +        let start = lsda_start as usize;
 +        let end = lsda_end as usize;
 +        if end < start {
 +            return Err(UnwindReadError::Truncated("lsda index array"));
 +        }
 +        let mut entry_off = start;
 +        while entry_off < end {
 +            if entry_off + 8 > bytes.len() {
 +                return Err(UnwindReadError::Truncated("lsda index entry"));
 +            }
 +            lsdas.push(DecodedLsdaRecord {
 +                function_offset: read_u32(bytes, entry_off, "lsda function offset")?,
 +                lsda_offset: read_u32(bytes, entry_off + 4, "lsda target offset")?,
 +            });
 +            entry_off += 8;
 +        }
 +    }
++
      let mut records = Vec::new();
      for idx in 0..indices_count.saturating_sub(1) {
          let entry_off = indices_offset + idx * FIRST_LEVEL_ENTRY_SIZE;
+         }
+     }
 -    Ok(DecodedUnwindInfo { version, records })
 +    Ok(DecodedUnwindInfo {
 +        version,
 +        personalities,
 +        lsdas,
 +        records,
 +    })
+ }
  fn validate_serialized_unwind_info(
      records: &[UnwindRecord],
  ) -> Result<(), UnwindReadError> {
      let decoded = decode_unwind_info(bytes)?;
 +    let (records, personalities, lsdas) = finalize_unwind_records(records)?;
      let expected: Vec<DecodedUnwindRecord> = records
          .iter()
          .map(|record| DecodedUnwindRecord {
              "decoded unwind records do not round-trip",
          ));
+     }
 +    if decoded.personalities != personalities {
 +        return Err(UnwindReadError::Truncated(
 +            "decoded personality table does not round-trip",
 +        ));
 +    }
 +    let expected_lsdas: Vec<DecodedLsdaRecord> = lsdas
 +        .iter()
 +        .map(|lsda| DecodedLsdaRecord {
 +            function_offset: lsda.function_offset,
 +            lsda_offset: lsda.lsda_offset,
 +        })
 +        .collect();
 +    if decoded.lsdas != expected_lsdas {
 +        return Err(UnwindReadError::Truncated(
 +            "decoded lsda table does not round-trip",
 +        ));
 +    }
      Ok(())
+ }
 +fn finalize_unwind_records(
 +    records: &[UnwindRecord],
 +) -> Result<(Vec<UnwindRecord>, Vec<u32>, Vec<LsdaRecord>), UnwindReadError> {
 +    let mut personalities = Vec::new();
 +    let mut finalized = Vec::with_capacity(records.len());
 +    let mut lsdas = Vec::new();
 +    let mut personality_index = HashMap::new();
++
 +    for record in records {
 +        let mut encoding = record.encoding & !UNWIND_PERSONALITY_MASK;
 +        if let Some(personality_offset) = record.personality_offset {
 +            let idx = if let Some(&idx) = personality_index.get(&personality_offset) {
 +                idx
 +            } else {
 +                if personalities.len() == 3 {
 +                    return Err(UnwindReadError::TooManyPersonalities(personalities.len() + 1));
 +                }
 +                personalities.push(personality_offset);
 +                let idx = personalities.len() as u32;
 +                personality_index.insert(personality_offset, idx);
 +                idx
 +            };
 +            encoding |= idx << UNWIND_PERSONALITY_SHIFT;
 +        }
 +        if let Some(lsda_offset) = record.lsda_offset {
 +            encoding |= UNWIND_HAS_LSDA;
 +            lsdas.push(LsdaRecord {
 +                function_offset: record.function_offset,
 +                lsda_offset,
 +            });
 +        } else {
 +            encoding &= !UNWIND_HAS_LSDA;
 +        }
 +        if encoding & UNWIND_ARM64_MODE_MASK == UNWIND_ARM64_MODE_DWARF {
 +            encoding &= !UNWIND_ARM64_DWARF_SECTION_OFFSET_MASK;
 +        }
 +        finalized.push(UnwindRecord {
 +            encoding,
 +            ..*record
 +        });
 +    }
++
 +    Ok((finalized, personalities, lsdas))
 +}
++
  fn build_pages(records: &[UnwindRecord]) -> Vec<CompressedPage> {
      let mut pages = Vec::new();
      let mut current: Option<CompressedPage> = None;
              function_offset: 0x348,
              code_len: 0x14,
              encoding: 0x0200_1000,
 -        }]);
 +            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()))
 ,
 x348,
 x40,
 -                0x40,
 +                0x34,
 x35c,
 ,
 -                0x40,
 +                0x34,
 ,
 ,
 ,
+             ]
          );
          let decoded = decode_unwind_info(&bytes).unwrap();
 +        assert!(decoded.personalities.is_empty());
 +        assert!(decoded.lsdas.is_empty());
          assert_eq!(
              decoded.records,
              vec![DecodedUnwindRecord {
                  function_offset: 0x348,
                  code_len: 0x8,
                  encoding: 0x0200_0000,
 +                personality_offset: None,
 +                lsda_offset: None,
              },
              UnwindRecord {
                  function_offset: 0x350,
                  code_len: 0x20,
                  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()))
 ,
 x348,
 x40,
 -                0x40,
 +                0x34,
 x370,
 ,
 -                0x40,
 +                0x34,
 ,
 ,
 ,
+             ]
          );
          let decoded = decode_unwind_info(&bytes).unwrap();
 +        assert!(decoded.personalities.is_empty());
 +        assert!(decoded.lsdas.is_empty());
          assert_eq!(
              decoded.records,
              vec![
              function_offset: 0x348,
              code_len: 0x14,
              encoding: 0x0200_1000,
 -        }]);
 +            personality_offset: None,
 +            lsda_offset: None,
 +        }])
 +        .unwrap();
          let second_level_offset =
              u32::from_le_bytes(bytes[28 + 4..28 + 8].try_into().unwrap()) as usize;
          let entries_offset = second_level_offset

tests/archive_runtime.rsmodified

      // .../armfortas/target/.
      let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
      for profile in ["debug", "release"] {
 -        let candidate = workspace.join("target").join(profile).join("libarmfortas_rt.a");
 +        let candidate = workspace
 +            .join("target")
 +            .join(profile)
 +            .join("libarmfortas_rt.a");
          if candidate.is_file() {
              return Some(candidate);
+         }
      let members: Vec<_> = ar.object_members().collect();
      assert!(!members.is_empty(), "runtime archive has no object members");
 -    let idx = ar.symbol_index().expect("runtime archive has a BSD symbol index");
 +    let idx = ar
 +        .symbol_index()
 +        .expect("runtime archive has a BSD symbol index");
      assert!(!idx.is_empty(), "runtime archive symbol index is empty");
      // Pick a symbol we're confident the runtime exports. `_afs_program_init`
          .symbols
          .iter()
          .find(|s| {
 -            obj.symbol_name(s)
 -                .map(|n| n == target)
 -                .unwrap_or(false)
 +            obj.symbol_name(s).map(|n| n == target).unwrap_or(false)
                  && s.kind() == SymKind::Sect
                  && s.is_ext()
          })
+ }
  fn panic_with_index(msg: &str, idx: &SymbolIndex) -> ! {
 -    let preview: Vec<&str> = idx.entries.iter().take(10).map(|e| e.name.as_str()).collect();
 +    let preview: Vec<&str> = idx
 +        .entries
 +        .iter()
 +        .take(10)
 +        .map(|e| e.name.as_str())
 +        .collect();
      panic!("{msg}\nfirst 10 symbols: {preview:?}");
+ }

tests/atom_integration.rsmodified

          .subsections_via_symbols
      "#;
 -    let obj_path = std::env::temp_dir().join(format!(
 -        "afs-ld-atom-{}-test.o",
 -        std::process::id()
 -    ));
 +    let obj_path = std::env::temp_dir().join(format!("afs-ld-atom-{}-test.o", std::process::id()));
      if let Err(e) = assemble(src, &obj_path) {
          eprintln!("skipping: assemble failed: {e}");
          return;
      let obj = inputs.object_file(input_id).unwrap();
      let mut atom_table = AtomTable::new();
      let atomization = atomize_object(input_id, &obj, &mut atom_table);
 -    backpatch_symbol_atoms(&atomization, input_id, &obj, &mut sym_table, &mut atom_table);
 +    backpatch_symbol_atoms(
 +        &atomization,
 +        input_id,
 +        &obj,
 +        &mut sym_table,
 +        &mut atom_table,
 +    );
      // At least one atom per defined function plus one for data_global.
      assert!(
          .subsections_via_symbols
      "#;
 -    let obj_path = std::env::temp_dir().join(format!(
 -        "afs-ld-atom-{}-cstrings.o",
 -        std::process::id()
 -    ));
 +    let obj_path =
 +        std::env::temp_dir().join(format!("afs-ld-atom-{}-cstrings.o", std::process::id()));
      if let Err(e) = assemble(src, &obj_path) {
          eprintln!("skipping: assemble failed: {e}");
          return;

tests/dylib_integration.rsmodified

  fn build_test_dylib(src: &str, out: &PathBuf) -> Result<(), String> {
      let mut child = Command::new("xcrun")
          .args([
 -            "--sdk",
 -            "macosx",
 -            "clang",
 -            "-x",
 -            "c",
 -            "-arch",
 -            "arm64",
 -            "-shared",
 -            "-o",
 +            "--sdk", "macosx", "clang", "-x", "c", "-arch", "arm64", "-shared", "-o",
          ])
          .arg(out)
          .arg("-install_name")

tests/linker_run.rsmodified

      Ok(())
+ }
 +fn compile_cxx(src: &str, out: &PathBuf) -> Result<(), String> {
 +    let tmp = std::env::temp_dir().join(format!(
 +        "afs-ld-linker-run-{}-{}.cc",
 +        std::process::id(),
 +        out.file_stem().and_then(|s| s.to_str()).unwrap_or("t")
 +    ));
 +    fs::write(&tmp, src).map_err(|e| format!("write: {e}"))?;
 +    let output = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "clang++", "-arch", "arm64", "-c"])
 +        .arg(&tmp)
 +        .arg("-o")
 +        .arg(out)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun clang++: {e}"))?;
 +    let _ = fs::remove_file(&tmp);
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun clang++ failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
  fn compile_dylib_c(src: &str, out: &PathBuf) -> Result<(), String> {
      let tmp = std::env::temp_dir().join(format!(
          "afs-ld-linker-run-{}-{}.c",
      Ok(())
+ }
 +fn apple_link_cxx_classic(obj: &PathBuf, out: &PathBuf) -> Result<(), String> {
 +    let output = Command::new("xcrun")
 +        .args([
 +            "--sdk",
 +            "macosx",
 +            "clang++",
 +            "-arch",
 +            "arm64",
 +            "-Wl,-no_fixup_chains",
 +            "-o",
 +        ])
 +        .arg(out)
 +        .arg(obj)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun clang++ link: {e}"))?;
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun clang++ link failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  struct RebaseRecord {
      segment: String,
      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 clang++ or codesign unavailable");
 +        return;
 +    }
++
 +    let Some(sdk) = sdk_path() else {
 +        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());
 +        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();
 +    let (_, our_unwind) = output_section(&our_bytes, "__TEXT", "__unwind_info").unwrap();
 +    let (_, apple_unwind) = output_section(&apple_bytes, "__TEXT", "__unwind_info").unwrap();
 +    let our_decoded = decode_unwind_info(&our_unwind).unwrap();
 +    let apple_decoded = decode_unwind_info(&apple_unwind).unwrap();
 +    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_emits_function_starts_like_ld() {
      if !have_xcrun() {

tests/minimal_output.rsmodified

      for (path, expected) in [
          (&exe, "Mach-O 64-bit executable arm64"),
 -        (&dylib, "Mach-O 64-bit dynamically linked shared library arm64"),
 +        (
 +            &dylib,
 +            "Mach-O 64-bit dynamically linked shared library arm64",
 +        ),
      ] {
          let otool = Command::new("xcrun")
              .args(["otool", "-lV"])

tests/reader_corpus_round_trip.rsmodified

  use std::process::Command;
  use afs_ld::input::ObjectFile;
 -use afs_ld::macho::reader::{parse_commands, parse_header, write_commands, write_header, HEADER_SIZE};
 +use afs_ld::macho::reader::{
 +    parse_commands, parse_header, write_commands, write_header, HEADER_SIZE,
 +};
  use afs_ld::reloc::{
 -    parse_raw_relocs, parse_relocs, validate_relocs, write_raw_relocs, write_relocs,
 -    RAW_RELOC_SIZE,
 +    parse_raw_relocs, parse_relocs, validate_relocs, write_raw_relocs, write_relocs, RAW_RELOC_SIZE,
  };
  use afs_ld::symbol::{write_nlist_table, NLIST_SIZE};
          fixture_count += 1;
          let obj_name = format!(
              "{}.o",
 -            src.file_stem().and_then(|s| s.to_str()).unwrap_or("fixture")
 +            src.file_stem()
 +                .and_then(|s| s.to_str())
 +                .unwrap_or("fixture")
          );
          let obj = scratch.join(&obj_name);
+         }
+     }
 -    assert!(fixture_count > 0, "no .s fixtures found in {}", corpus.display());
 +    assert!(
 +        fixture_count > 0,
 +        "no .s fixtures found in {}",
 +        corpus.display()
 +    );
      assert!(
          failures.is_empty(),
          "{} of {} corpus fixtures failed:\n{}",
          fixture_count += 1;
          let obj_path = scratch.join(format!(
              "{}.o",
 -            src.file_stem().and_then(|s| s.to_str()).unwrap_or("fixture")
 +            src.file_stem()
 +                .and_then(|s| s.to_str())
 +                .unwrap_or("fixture")
          ));
          if let Err(e) = assemble(&src, &obj_path) {
              if sym.stab_kind().is_some() {
                  continue; // stab n_sect has a different meaning
+             }
 -            if sym.kind() == afs_ld::symbol::SymKind::Sect
 -                && obj.section_for_symbol(sym).is_none()
 +            if sym.kind() == afs_ld::symbol::SymKind::Sect && obj.section_for_symbol(sym).is_none()
+             {
                  failures.push(format!(
                      "{}: symbol[{i}] has SECT kind but n_sect={} is out of range ({} sections)",
          if let Some(symtab) = obj.symtab {
              let mut reemitted = Vec::with_capacity(obj.symbols.len() * NLIST_SIZE);
              write_nlist_table(&obj.symbols, &mut reemitted);
 -            let want = &bytes
 -                [symtab.symoff as usize..symtab.symoff as usize + symtab.nsyms as usize * NLIST_SIZE];
 +            let want = &bytes[symtab.symoff as usize
 +                ..symtab.symoff as usize + symtab.nsyms as usize * NLIST_SIZE];
              if reemitted != want {
                  failures.push(format!(
                      "{}: nlist region re-emit mismatch (symoff=0x{:x} nsyms={})",
+             }
              // Byte-level equality of the string-table blob.
 -            let strtab_want = &bytes
 -                [symtab.stroff as usize..symtab.stroff as usize + symtab.strsize as usize];
 +            let strtab_want =
 +                &bytes[symtab.stroff as usize..symtab.stroff as usize + symtab.strsize as usize];
              if obj.strings.as_bytes() != strtab_want {
                  failures.push(format!(
                      "{}: strtab byte mismatch (stroff=0x{:x} strsize={})",
          fixture_count += 1;
          let obj_path = scratch.join(format!(
              "{}.o",
 -            src.file_stem().and_then(|s| s.to_str()).unwrap_or("fixture")
 +            src.file_stem()
 +                .and_then(|s| s.to_str())
 +                .unwrap_or("fixture")
          ));
          if let Err(e) = assemble(&src, &obj_path) {
              failures.push(format!("{}: assemble: {e}", src.display()));
+ }
  fn first_diff(a: &[u8], b: &[u8]) -> usize {
 -    a.iter().zip(b.iter()).position(|(x, y)| x != y).unwrap_or(a.len().min(b.len()))
 +    a.iter()
 +        .zip(b.iter())
 +        .position(|(x, y)| x != y)
 +        .unwrap_or(a.len().min(b.len()))
+ }
  fn tempdir() -> PathBuf {
      // Each caller gets a unique dir so cargo's parallel tests don't step on
      // one another's .o files.
      let seq = COUNTER.fetch_add(1, Ordering::Relaxed);
 -    let base = std::env::temp_dir().join(format!(
 -        "afs-ld-corpus-{}-{}",
 -        std::process::id(),
 -        seq
 -    ));
 +    let base = std::env::temp_dir().join(format!("afs-ld-corpus-{}-{}", std::process::id(), seq));
      let _ = fs::remove_dir_all(&base);
      fs::create_dir_all(&base).expect("create scratch dir");
      base

tests/resolve_integration.rsmodified

      let tmp = std::env::temp_dir().join(format!(
          "afs-ld-resolve-{}-{}.s",
          std::process::id(),
 -        out.file_stem()
 -            .and_then(|s| s.to_str())
 -            .unwrap_or("t")
 +        out.file_stem().and_then(|s| s.to_str()).unwrap_or("t")
      ));
      fs::write(&tmp, src_text).map_err(|e| format!("write .s: {e}"))?;
      let status = Command::new("xcrun")
+ }
  fn scratch(name: &str) -> PathBuf {
 -    std::env::temp_dir().join(format!(
 -        "afs-ld-resolve-{}-{}",
 -        std::process::id(),
 -        name
 -    ))
 +    std::env::temp_dir().join(format!("afs-ld-resolve-{}-{}", std::process::id(), name))
+ }
  #[test]
          "unexpected duplicates in seeding: {:?}",
          seed_report.duplicates
      );
 -    let drain_report = drain_fetches(&mut inputs, &mut table, seed_report.pending_fetches)
 -        .expect("drain_fetches");
 +    let drain_report =
 +        drain_fetches(&mut inputs, &mut table, seed_report.pending_fetches).expect("drain_fetches");
      assert!(
          drain_report.fetched_members >= 1,
          "expected at least one archive member fetched; got {}",

tests/tbd_integration.rsmodified

      // Common expected sub-dylibs we re-export — matches what `otool -L
      // libSystem.B.dylib` shows on a real macOS.
 -    let install_names: Vec<&str> =
 -        dy.dependencies.iter().map(|d| d.install_name.as_str()).collect();
 +    let install_names: Vec<&str> = dy
 +        .dependencies
 +        .iter()
 +        .map(|d| d.install_name.as_str())
 +        .collect();
      for sub in [
          "/usr/lib/system/libsystem_c.dylib",
          "/usr/lib/system/libsystem_kernel.dylib",

tests/tbd_smoke.rsmodified

      let docs = parse_documents(&bytes).unwrap_or_else(|e| {
          panic!("libSystem.tbd failed to parse: {e}");
      });
 -    assert!(docs.len() >= 2, "expected >=2 documents, got {}", docs.len());
 +    assert!(
 +        docs.len() >= 2,
 +        "expected >=2 documents, got {}",
 +        docs.len()
 +    );
      // Every doc should carry the !tapi-tbd tag.
      for (i, d) in docs.iter().enumerate() {
          assert_eq!(d.tag.as_deref(), Some("!tapi-tbd"), "doc[{i}] tag");

`@@ -2217,6 +2217,9 @@` mod tests {
2217	2217	};
2218	2218
2219	2219	let blob = build_function_starts(&layout, &atoms).unwrap();
2220		- assert_eq!(decode_function_starts_blob(&blob), vec![0x1000, 0x1008, 0x1040]);
	2220	+ assert_eq!(
	2221	+ decode_function_starts_blob(&blob),
	2222	+ vec![0x1000, 0x1008, 0x1040]
	2223	+ );
2221	2224	}
2222	2225	}

fortrangoingonforty/afs-ld / `20d5047`

31 changed files