afs-ld Public

Notifications Fork 0 Star 0

Comparing changes

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

Create pull request

Able to merge. These branches can be automatically merged.

61 commits 393 files changed 2 contributors

Commits on repo-cleanup

Align leftover linker helpers a3512fb mfwolffe committed 3 weeks ago
Cache reloc symbol lookups 4919d68 mfwolffe committed 3 weeks ago
Cache rebase symbol lookups 9dbf0eb mfwolffe committed 3 weeks ago
Speed string table planning 86f5fa3 espadonne committed 3 weeks ago
Index local symbol ranges 23e8dad espadonne committed 3 weeks ago
Split linkedit profiling 5a28bad espadonne committed 3 weeks ago
Trim linkedit finalize passes 5c01cb5 espadonne committed 3 weeks ago
Tighten unwind profiling 19a3fcb espadonne committed 3 weeks ago
Skip unwind self-check by default 4a04575 espadonne committed 3 weeks ago
Add linker baseline profiling 9b357f8 espadonne committed 3 weeks ago
Harden parity closeout gates 1a54bfb espadonne committed 3 weeks ago
Scale parity corpus coverage 5aba45e espadonne committed 3 weeks ago
Expand parity corpus coverage 225ec83 espadonne committed 3 weeks ago
Wire parity matrix gating 2f80f68 espadonne committed 3 weeks ago
Add final relocation parity cases f2612ca espadonne committed 3 weeks ago
Add relocation parity cases 60a310e espadonne committed 3 weeks ago
Add shared-data export parity case 5697e2d espadonne committed 3 weeks ago
Add more export parity cases 52a57bd espadonne committed 3 weeks ago
Add branch relocation parity case 004465f espadonne committed 3 weeks ago
Add bss export parity case 5778985 espadonne committed 3 weeks ago
Add prefix export parity case b5032ee espadonne committed 3 weeks ago
Add mixed export parity case df9901c espadonne committed 3 weeks ago
Add branch-only lazy parity case 856cd74 espadonne committed 3 weeks ago
Add batched lazy parity case e514e64 espadonne committed 3 weeks ago
Add lazy import parity case 26bc7f4 espadonne committed 3 weeks ago
Migrate direct bind case 4ec9733 espadonne committed 3 weeks ago
Migrate export parity case 9ad1904 espadonne committed 3 weeks ago
Grow parity matrix corpus e1737a5 espadonne committed 3 weeks ago
Seed parity matrix harness 5b2220f espadonne committed 3 weeks ago
Cover forced thunk sharing 2e63cb5 espadonne committed 3 weeks ago
Split thunk islands within sections 320ee1c espadonne committed 3 weeks ago
Place thunk islands after caller sections c4dc9c1 espadonne committed 3 weeks ago
Iterate thunk planning 1033763 espadonne committed 3 weeks ago
Scope thunks to caller segments 2acae00 espadonne committed 3 weeks ago
Add initial branch thunks b98049e espadonne committed 3 weeks ago
Match Apple LOH output 11020d0 espadonne committed 3 weeks ago
Relax more loh kinds 6ae056c espadonne committed 3 weeks ago
Relax adrp-add hints faaa755 espadonne committed 3 weeks ago
Preserve LOH payloads 1e80916 espadonne committed 3 weeks ago
Respect direct address materialization 1eae32b espadonne committed 3 weeks ago
Tighten safe ICF coverage 9454823 espadonne committed 3 weeks ago
Broaden safe ICF coverage 719c974 espadonne committed 3 weeks ago
Fold matching reloc functions 89c7a40 espadonne committed 3 weeks ago
Add initial safe ICF f72eff5 espadonne committed 3 weeks ago
Preserve dead-stripped eh_frame a062a85 espadonne committed 3 weeks ago
Cover dead strip roots 9f39376 espadonne committed 3 weeks ago
Prune dead synthetic imports 540e530 espadonne committed 3 weeks ago
Add initial dead strip pass 50c4b3e espadonne committed 3 weeks ago
Warn for objc force load bf6c486 espadonne committed 3 weeks ago
Snapshot linker help output f111892 espadonne committed 3 weeks ago
Complete undefined mode wiring cab9755 espadonne committed 3 weeks ago
Filter exported symbols 28ec20f espadonne committed 3 weeks ago
Wire deferred linker flags 091a3ae espadonne committed 3 weeks ago
Add why-live diagnostics 7278d00 espadonne committed 3 weeks ago
Add linker trace and help flags a5438b1 espadonne committed 3 weeks ago
Add linker map output 2a0e179 espadonne committed 3 weeks ago
Wire framework load flags 693b1de espadonne committed 3 weeks ago
Wire undefined and dylib flags 54b0965 espadonne committed 3 weeks ago
Wire library search flags cc64f9c espadonne committed 3 weeks ago
Wire archive load flags bdf7c8c espadonne committed 3 weeks ago
Tighten runtime import parity 4e19654 espadonne committed 3 weeks ago

.docs/sprints/sprint19.mdmodified

21 lines changed — click to load

  - `-why_live` produces a coherent chain on fixtures with dead-strip enabled.
  - Unknown-flag errors include a did-you-mean suggestion.
  - CLI surface passes a snapshot test against the `--help` output.
++
 +## Remaining Flag Slices
 +- [x] `-exported_symbols_list <file>`
 +- [x] `-unexported_symbols_list <file>`
 +- [x] `-exported_symbol <sym>`
 +- [x] `-unexported_symbol <sym>`
 +- [x] `-r` / `-bundle` explicit deferred errors
 +- [x] `-S`
 +- [x] `-no_uuid`
 +- [x] `-dead_strip`
 +- [x] `-icf=safe` / `-icf=none`
 +- [x] `-fixup_chains` / `-no_fixup_chains`
 +- [x] `-Wl,<comma-separated>` normalization
 +- [x] `-map <path>`
 +- [x] `-t` / `-trace`
 +- [x] `-v` / `--version`
 +- [x] `-h` / `--help`
 +- [x] `-why_live <symbol>`

.docs/sprints/sprint27.mdmodified

21 lines changed — click to load

  ### 3. Tolerated-diff rules
 -```rust
 -pub enum ToleratedDiff {
 -    UuidBytes,
 -    Timestamp,
 -    PathHashInString(&'static str),      // e.g. temp path in stabs
 -    StringTableSuffixDedupVariance,
 -    CodeSignatureHashes,
 -}
 -```
 +Current Sprint 27 allowlist is intentionally small and explicit:
 +- UUID load-command bytes.
 +- Dylib timestamp fields.
 +- Code-signature load-command/blob bytes.
 +- Case-specific section-byte ranges declared in `notes.md`.
 +- String-table length drift within 5% for suffix-dedup variance.
  Each tolerance has a precise predicate — no loose "any byte in __LINKEDIT". Unknown diffs fail.

.github/workflows/parity-matrix.ymladded

38 lines changed — click to load

 +name: parity-matrix
++
 +on:
 +  pull_request:
 +  push:
 +    branches:
 +      - trunk
++
 +permissions:
 +  contents: read
++
 +jobs:
 +  parity-matrix:
 +    runs-on: macos-14
 +    timeout-minutes: 30
 +    steps:
 +      - name: Checkout
 +        uses: actions/checkout@v4
++
 +      - name: Install Rust
 +        uses: dtolnay/rust-toolchain@stable
++
 +      - name: Run parity harness proof tests
 +        run: cargo test --test diff_harness_tolerates_known_linkedit --test parity_harness --test parity_canary -- --nocapture
++
 +      - name: Run parity matrix
 +        env:
 +          PARITY_MATRIX_ARTIFACT_DIR: ${{ github.workspace }}/parity-matrix-artifacts
 +          PARITY_MATRIX_MAX_SECONDS: "120"
 +        run: cargo test --test parity_matrix -- --nocapture
++
 +      - name: Upload parity artifacts
 +        if: always()
 +        uses: actions/upload-artifact@v4
 +        with:
 +          name: parity-matrix-html
 +          path: parity-matrix-artifacts
 +          if-no-files-found: warn

src/args.rsmodified

773 lines changed — click to load

  use std::path::PathBuf;
 -use crate::{LinkOptions, OutputKind};
 +use crate::resolve::{levenshtein, UndefinedTreatment};
 +use crate::{FrameworkSpec, IcfMode, LinkOptions, OutputKind, PlatformVersion, ThunkMode};
++
 +const KNOWN_FLAGS: &[&str] = &[
 +    "-o",
 +    "-e",
 +    "-arch",
 +    "-l",
 +    "-L",
 +    "-framework",
 +    "-weak_framework",
 +    "-ObjC",
 +    "-syslibroot",
 +    "-platform_version",
 +    "-r",
 +    "-bundle",
 +    "-undefined",
 +    "-rpath",
 +    "-install_name",
 +    "-current_version",
 +    "-compatibility_version",
 +    "-exported_symbols_list",
 +    "-unexported_symbols_list",
 +    "-exported_symbol",
 +    "-unexported_symbol",
 +    "-S",
 +    "-no_uuid",
 +    "-no_loh",
 +    "-thunks=none",
 +    "-thunks=safe",
 +    "-thunks=all",
 +    "-dead_strip",
 +    "-icf=safe",
 +    "-icf=none",
 +    "-icf=all",
 +    "-fixup_chains",
 +    "-no_fixup_chains",
 +    "-map",
 +    "-why_live",
 +    "-t",
 +    "-trace",
 +    "-v",
 +    "--version",
 +    "-h",
 +    "--help",
 +    "-x",
 +    "-dylib",
 +    "-all_load",
 +    "-force_load",
 +    "--dump",
 +    "--dump-archive",
 +    "--dump-dylib",
 +    "--dump-tbd",
 +];
  #[derive(Debug)]
  pub enum ArgsError {
      /// A flag that takes an argument was supplied without one.
      MissingValue(String),
 +    /// A recognized flag got a value we do not accept.
 +    InvalidValue {
 +        flag: String,
 +        value: String,
 +        expected: String,
 +    },
      /// An unrecognized flag.
 -    UnknownFlag(String),
 +    UnknownFlag {
 +        flag: String,
 +        suggestion: Option<String>,
 +    },
+ }
  impl std::fmt::Display for ArgsError {
              ArgsError::MissingValue(flag) => {
                  write!(f, "flag `{flag}` requires a value")
+             }
 -            ArgsError::UnknownFlag(flag) => {
 +            ArgsError::InvalidValue {
 +                flag,
 +                value,
 +                expected,
 +            } => {
                  write!(
                      f,
 -                    "unknown flag `{flag}` (Sprint 19 adds the full `ld` surface)"
 +                    "flag `{flag}` got invalid value `{value}` (expected {expected})"
+                 )
+             }
 +            ArgsError::UnknownFlag { flag, suggestion } => {
 +                write!(f, "unknown flag `{flag}`")?;
 +                if let Some(suggestion) = suggestion {
 +                    write!(f, " (did you mean `{suggestion}`?)")?;
 +                }
 +                write!(f, " (Sprint 19 adds the full `ld` surface)")
 +            }
+         }
+     }
+ }
 +fn unknown_flag(flag: &str) -> ArgsError {
 +    let suggestion = KNOWN_FLAGS
 +        .iter()
 +        .map(|candidate| (levenshtein(flag, candidate), *candidate))
 +        .filter(|(distance, _)| *distance <= 3)
 +        .min_by_key(|(distance, candidate)| (*distance, candidate.len()))
 +        .map(|(_, candidate)| candidate.to_string());
 +    ArgsError::UnknownFlag {
 +        flag: flag.to_string(),
 +        suggestion,
 +    }
 +}
++
 +fn parse_version_component(flag: &str, value: &str) -> Result<u32, ArgsError> {
 +    let mut parts = value.split('.');
 +    let parse_part = |piece: Option<&str>| -> Result<u32, ArgsError> {
 +        let raw = piece.unwrap_or("0");
 +        raw.parse::<u32>().map_err(|_| ArgsError::InvalidValue {
 +            flag: flag.to_string(),
 +            value: value.to_string(),
 +            expected: "version like <major>[.<minor>[.<patch>]]".into(),
 +        })
 +    };
 +    let major = parse_part(parts.next())?;
 +    let minor = parse_part(parts.next())?;
 +    let patch = parse_part(parts.next())?;
 +    if parts.next().is_some() {
 +        return Err(ArgsError::InvalidValue {
 +            flag: flag.to_string(),
 +            value: value.to_string(),
 +            expected: "version like <major>[.<minor>[.<patch>]]".into(),
 +        });
 +    }
 +    Ok((major << 16) | ((minor & 0xff) << 8) | (patch & 0xff))
 +}
++
  pub fn parse(argv: &[String]) -> Result<LinkOptions, ArgsError> {
 +    let normalized = normalize_wl(argv);
      let mut opts = LinkOptions::default();
 -    let mut it = argv.iter();
 +    let mut it = normalized.iter();
      while let Some(arg) = it.next() {
          match arg.as_str() {
              "-o" => {
                          .clone(),
                  );
+             }
 +            "-l" => {
 +                opts.library_names.push(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-l".into()))?
 +                        .clone(),
 +                );
 +            }
 +            s if s.starts_with("-l") && s.len() > 2 => {
 +                opts.library_names.push(s[2..].to_string());
 +            }
 +            "-L" => {
 +                opts.search_paths.push(PathBuf::from(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-L".into()))?,
 +                ));
 +            }
 +            "-framework" => {
 +                opts.frameworks.push(FrameworkSpec {
 +                    name: it
 +                        .next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-framework".into()))?
 +                        .clone(),
 +                    weak: false,
 +                });
 +            }
 +            "-weak_framework" => {
 +                opts.frameworks.push(FrameworkSpec {
 +                    name: it
 +                        .next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-weak_framework".into()))?
 +                        .clone(),
 +                    weak: true,
 +                });
 +            }
 +            "-ObjC" => {
 +                opts.objc_force_load = true;
 +            }
 +            "-syslibroot" => {
 +                opts.syslibroot =
 +                    Some(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("-syslibroot".into())
 +                    })?));
 +            }
 +            "-platform_version" => {
 +                let platform = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-platform_version".into()))?;
 +                if platform != "macos" {
 +                    return Err(ArgsError::InvalidValue {
 +                        flag: "-platform_version".into(),
 +                        value: platform.clone(),
 +                        expected: "platform `macos`".into(),
 +                    });
 +                }
 +                let minos_raw = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-platform_version".into()))?;
 +                let sdk_raw = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-platform_version".into()))?;
 +                opts.platform_version = Some(PlatformVersion {
 +                    minos: parse_version_component("-platform_version", minos_raw)?,
 +                    sdk: parse_version_component("-platform_version", sdk_raw)?,
 +                });
 +            }
 +            "-r" => {
 +                opts.relocatable = true;
 +            }
 +            "-bundle" => {
 +                opts.bundle = true;
 +            }
 +            "-undefined" => {
 +                let value = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-undefined".into()))?;
 +                opts.undefined_treatment = match value.as_str() {
 +                    "error" => UndefinedTreatment::Error,
 +                    "warning" => UndefinedTreatment::Warning,
 +                    "suppress" => UndefinedTreatment::Suppress,
 +                    "dynamic_lookup" => UndefinedTreatment::DynamicLookup,
 +                    _ => {
 +                        return Err(ArgsError::InvalidValue {
 +                            flag: "-undefined".into(),
 +                            value: value.clone(),
 +                            expected: "`error`, `warning`, `suppress`, or `dynamic_lookup`".into(),
 +                        });
 +                    }
 +                };
 +            }
 +            "-rpath" => {
 +                opts.rpaths.push(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-rpath".into()))?
 +                        .clone(),
 +                );
 +            }
 +            "-install_name" => {
 +                opts.install_name = Some(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-install_name".into()))?
 +                        .clone(),
 +                );
 +            }
 +            "-current_version" => {
 +                let value = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-current_version".into()))?;
 +                opts.current_version = Some(parse_version_component("-current_version", value)?);
 +            }
 +            "-compatibility_version" => {
 +                let value = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-compatibility_version".into()))?;
 +                opts.compatibility_version =
 +                    Some(parse_version_component("-compatibility_version", value)?);
 +            }
 +            "-exported_symbols_list" => {
 +                opts.exported_symbols_lists
 +                    .push(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("-exported_symbols_list".into())
 +                    })?));
 +            }
 +            "-unexported_symbols_list" => {
 +                opts.unexported_symbols_lists.push(PathBuf::from(
 +                    it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("-unexported_symbols_list".into())
 +                    })?,
 +                ));
 +            }
 +            "-exported_symbol" => {
 +                opts.exported_symbols.push(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-exported_symbol".into()))?
 +                        .clone(),
 +                );
 +            }
 +            "-unexported_symbol" => {
 +                opts.unexported_symbols.push(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-unexported_symbol".into()))?
 +                        .clone(),
 +                );
 +            }
 +            "-S" => {
 +                opts.strip_debug = true;
 +            }
 +            "-no_uuid" => {
 +                opts.emit_uuid = false;
 +            }
 +            "-no_loh" => {
 +                opts.no_loh = true;
 +            }
 +            s if s.starts_with("-thunks=") => {
 +                opts.thunks = match s {
 +                    "-thunks=none" => ThunkMode::None,
 +                    "-thunks=safe" => ThunkMode::Safe,
 +                    "-thunks=all" => ThunkMode::All,
 +                    _ => {
 +                        let value = s.trim_start_matches("-thunks=").to_string();
 +                        return Err(ArgsError::InvalidValue {
 +                            flag: "-thunks".into(),
 +                            value,
 +                            expected: "`none`, `safe`, or `all`".into(),
 +                        });
 +                    }
 +                };
 +            }
 +            "-dead_strip" => {
 +                opts.dead_strip = true;
 +            }
 +            s if s.starts_with("-icf=") => {
 +                opts.icf_mode = match s {
 +                    "-icf=none" => IcfMode::None,
 +                    "-icf=safe" => IcfMode::Safe,
 +                    "-icf=all" => IcfMode::All,
 +                    _ => {
 +                        let value = s.trim_start_matches("-icf=").to_string();
 +                        return Err(ArgsError::InvalidValue {
 +                            flag: "-icf".into(),
 +                            value,
 +                            expected: "`safe`, `none`, or `all`".into(),
 +                        });
 +                    }
 +                };
 +            }
 +            "-fixup_chains" => {
 +                opts.fixup_chains = true;
 +            }
 +            "-no_fixup_chains" => {
 +                opts.fixup_chains = false;
 +            }
 +            "-map" => {
 +                opts.map = Some(PathBuf::from(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-map".into()))?,
 +                ));
 +            }
 +            "-why_live" => {
 +                opts.why_live.push(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("-why_live".into()))?
 +                        .clone(),
 +                );
 +            }
 +            "-t" | "-trace" => {
 +                opts.trace_inputs = true;
 +            }
 +            "-v" | "--version" => {
 +                opts.show_version = true;
 +            }
 +            "-h" | "--help" => {
 +                opts.show_help = true;
 +            }
              "-x" => {
                  opts.strip_locals = true;
+             }
              "-dylib" => {
                  opts.kind = OutputKind::Dylib;
+             }
 +            "-all_load" => {
 +                opts.all_load = true;
 +            }
 +            "-force_load" => {
 +                opts.force_load_archives
 +                    .push(PathBuf::from(it.next().ok_or_else(|| {
 +                        ArgsError::MissingValue("-force_load".into())
 +                    })?));
 +            }
              "--dump" => {
                  opts.dump = Some(PathBuf::from(
                      it.next()
                      })?));
+             }
              s if s.starts_with('-') => {
 -                return Err(ArgsError::UnknownFlag(s.to_string()));
 +                return Err(unknown_flag(s));
+             }
              _ => {
                  opts.inputs.push(PathBuf::from(arg));
      Ok(opts)
+ }
 +fn normalize_wl(argv: &[String]) -> Vec<String> {
 +    let mut out = Vec::with_capacity(argv.len());
 +    for arg in argv {
 +        if let Some(rest) = arg.strip_prefix("-Wl,") {
 +            out.extend(
 +                rest.split(',')
 +                    .filter(|piece| !piece.is_empty())
 +                    .map(ToString::to_string),
 +            );
 +        } else {
 +            out.push(arg.clone());
 +        }
 +    }
 +    out
 +}
++
  #[cfg(test)]
  mod tests {
      use super::*;
          assert_eq!(opts.kind, OutputKind::Dylib);
+     }
 +    #[test]
 +    fn deferred_output_flags_are_recorded() {
 +        let opts = parse(&argv(&["-r", "-bundle", "foo.o"])).unwrap();
 +        assert!(opts.relocatable);
 +        assert!(opts.bundle);
 +    }
++
      #[test]
      fn strip_locals_flag_is_recorded() {
          let opts = parse(&argv(&["-x", "foo.o"])).unwrap();
          assert!(opts.strip_locals);
+     }
 +    #[test]
 +    fn strip_debug_and_uuid_flags_are_recorded() {
 +        let opts = parse(&argv(&["-S", "-no_uuid", "foo.o"])).unwrap();
 +        assert!(opts.strip_debug);
 +        assert!(!opts.emit_uuid);
 +    }
++
 +    #[test]
 +    fn no_loh_flag_is_recorded() {
 +        let opts = parse(&argv(&["-no_loh", "foo.o"])).unwrap();
 +        assert!(opts.no_loh);
 +    }
++
 +    #[test]
 +    fn dead_strip_icf_and_fixup_chain_flags_are_recorded() {
 +        let opts = parse(&argv(&[
 +            "-dead_strip",
 +            "-thunks=all",
 +            "-icf=safe",
 +            "-fixup_chains",
 +            "-no_fixup_chains",
 +            "-icf=none",
 +            "foo.o",
 +        ]))
 +        .unwrap();
 +        assert!(opts.dead_strip);
 +        assert_eq!(opts.thunks, ThunkMode::All);
 +        assert_eq!(opts.icf_mode, IcfMode::None);
 +        assert!(!opts.fixup_chains);
 +    }
++
 +    #[test]
 +    fn thunks_flag_rejects_unknown_modes() {
 +        let err = parse(&argv(&["-thunks=clustered", "main.o"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-thunks" && value == "clustered"
 +        ));
 +    }
++
 +    #[test]
 +    fn icf_all_flag_is_recorded() {
 +        let opts = parse(&argv(&["-icf=all", "foo.o"])).unwrap();
 +        assert_eq!(opts.icf_mode, IcfMode::All);
 +    }
++
 +    #[test]
 +    fn icf_flag_rejects_unknown_modes() {
 +        let err = parse(&argv(&["-icf=aggressive", "main.o"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-icf" && value == "aggressive"
 +        ));
 +    }
++
 +    #[test]
 +    fn l_flag_accepts_separate_value() {
 +        let opts = parse(&argv(&["-l", "System", "main.o"])).unwrap();
 +        assert_eq!(opts.library_names, vec!["System".to_string()]);
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn l_flag_accepts_joined_value() {
 +        let opts = parse(&argv(&["-lSystem", "main.o"])).unwrap();
 +        assert_eq!(opts.library_names, vec!["System".to_string()]);
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn search_path_and_syslibroot_flags_are_recorded() {
 +        let opts = parse(&argv(&["-L", "/tmp/lib", "-syslibroot", "/sdk", "main.o"])).unwrap();
 +        assert_eq!(opts.search_paths, vec![PathBuf::from("/tmp/lib")]);
 +        assert_eq!(opts.syslibroot, Some(PathBuf::from("/sdk")));
 +    }
++
 +    #[test]
 +    fn framework_flags_are_recorded_in_order() {
 +        let opts = parse(&argv(&[
 +            "-framework",
 +            "Foundation",
 +            "-weak_framework",
 +            "Metal",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        assert_eq!(
 +            opts.frameworks,
 +            vec![
 +                FrameworkSpec {
 +                    name: "Foundation".into(),
 +                    weak: false,
 +                },
 +                FrameworkSpec {
 +                    name: "Metal".into(),
 +                    weak: true,
 +                }
 +            ]
 +        );
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn objc_flag_is_recorded() {
 +        let opts = parse(&argv(&["-ObjC", "main.o"])).unwrap();
 +        assert!(opts.objc_force_load);
 +    }
++
 +    #[test]
 +    fn platform_version_flag_is_recorded() {
 +        let opts = parse(&argv(&[
 +            "-platform_version",
 +            "macos",
 +            "13.2.1",
 +            "14.5",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        let platform = opts.platform_version.expect("platform version");
 +        assert_eq!(platform.minos, (13 << 16) | (2 << 8) | 1);
 +        assert_eq!(platform.sdk, (14 << 16) | (5 << 8));
 +    }
++
 +    #[test]
 +    fn platform_version_rejects_non_macos_platform() {
 +        let err = parse(&argv(&["-platform_version", "ios", "13.0", "13.0"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-platform_version" && value == "ios"
 +        ));
 +    }
++
 +    #[test]
 +    fn platform_version_rejects_bad_version() {
 +        let err = parse(&argv(&["-platform_version", "macos", "13.bad", "14.0"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-platform_version" && value == "13.bad"
 +        ));
 +    }
++
 +    #[test]
 +    fn undefined_flag_records_dynamic_lookup() {
 +        let opts = parse(&argv(&["-undefined", "dynamic_lookup", "main.o"])).unwrap();
 +        assert_eq!(opts.undefined_treatment, UndefinedTreatment::DynamicLookup);
 +    }
++
 +    #[test]
 +    fn undefined_flag_records_warning_and_suppress() {
 +        let warning = parse(&argv(&["-undefined", "warning", "main.o"])).unwrap();
 +        assert_eq!(warning.undefined_treatment, UndefinedTreatment::Warning);
++
 +        let suppress = parse(&argv(&["-undefined", "suppress", "main.o"])).unwrap();
 +        assert_eq!(suppress.undefined_treatment, UndefinedTreatment::Suppress);
 +    }
++
 +    #[test]
 +    fn undefined_flag_rejects_unknown_modes() {
 +        let err = parse(&argv(&["-undefined", "bogus", "main.o"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-undefined" && value == "bogus"
 +        ));
 +    }
++
 +    #[test]
 +    fn dylib_metadata_flags_are_recorded() {
 +        let opts = parse(&argv(&[
 +            "-rpath",
 +            "@loader_path/../lib",
 +            "-install_name",
 +            "@rpath/libdemo.dylib",
 +            "-current_version",
 +            "2.3.4",
 +            "-compatibility_version",
 +            "1.2",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        assert_eq!(opts.rpaths, vec!["@loader_path/../lib".to_string()]);
 +        assert_eq!(opts.install_name.as_deref(), Some("@rpath/libdemo.dylib"));
 +        assert_eq!(opts.current_version, Some((2 << 16) | (3 << 8) | 4));
 +        assert_eq!(opts.compatibility_version, Some((1 << 16) | (2 << 8)));
 +    }
++
 +    #[test]
 +    fn export_visibility_flags_are_recorded() {
 +        let opts = parse(&argv(&[
 +            "-exported_symbols_list",
 +            "exports.txt",
 +            "-unexported_symbols_list",
 +            "hidden.txt",
 +            "-exported_symbol",
 +            "_keep",
 +            "-unexported_symbol",
 +            "_drop",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        assert_eq!(
 +            opts.exported_symbols_lists,
 +            vec![PathBuf::from("exports.txt")]
 +        );
 +        assert_eq!(
 +            opts.unexported_symbols_lists,
 +            vec![PathBuf::from("hidden.txt")]
 +        );
 +        assert_eq!(opts.exported_symbols, vec!["_keep".to_string()]);
 +        assert_eq!(opts.unexported_symbols, vec!["_drop".to_string()]);
 +    }
++
 +    #[test]
 +    fn map_flag_is_recorded() {
 +        let opts = parse(&argv(&["-map", "link.map", "main.o"])).unwrap();
 +        assert_eq!(opts.map.as_deref(), Some(std::path::Path::new("link.map")));
 +    }
++
 +    #[test]
 +    fn wl_normalizes_map_like_direct_flag() {
 +        let opts = parse(&argv(&["-Wl,-map,link.map", "main.o"])).unwrap();
 +        assert_eq!(opts.map.as_deref(), Some(std::path::Path::new("link.map")));
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn trace_flags_are_recorded() {
 +        let opts = parse(&argv(&["-trace", "main.o"])).unwrap();
 +        assert!(opts.trace_inputs);
 +        let opts = parse(&argv(&["-t", "main.o"])).unwrap();
 +        assert!(opts.trace_inputs);
 +    }
++
 +    #[test]
 +    fn why_live_flag_accumulates_symbols() {
 +        let opts = parse(&argv(&[
 +            "-why_live",
 +            "_helper",
 +            "-why_live",
 +            "_leaf",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        assert_eq!(
 +            opts.why_live,
 +            vec!["_helper".to_string(), "_leaf".to_string()]
 +        );
 +    }
++
 +    #[test]
 +    fn help_and_version_flags_are_recorded() {
 +        let opts = parse(&argv(&["--help"])).unwrap();
 +        assert!(opts.show_help);
 +        let opts = parse(&argv(&["-h"])).unwrap();
 +        assert!(opts.show_help);
 +        let opts = parse(&argv(&["--version"])).unwrap();
 +        assert!(opts.show_version);
 +        let opts = parse(&argv(&["-v"])).unwrap();
 +        assert!(opts.show_version);
 +    }
++
 +    #[test]
 +    fn all_load_flag_is_recorded() {
 +        let opts = parse(&argv(&["-all_load", "libfoo.a"])).unwrap();
 +        assert!(opts.all_load);
 +        assert_eq!(opts.inputs, vec![PathBuf::from("libfoo.a")]);
 +    }
++
 +    #[test]
 +    fn force_load_flag_accumulates_archive_paths() {
 +        let opts = parse(&argv(&[
 +            "-force_load",
 +            "liba.a",
 +            "-force_load",
 +            "libb.a",
 +            "main.o",
 +        ]))
 +        .unwrap();
 +        assert_eq!(
 +            opts.force_load_archives,
 +            vec![PathBuf::from("liba.a"), PathBuf::from("libb.a")]
 +        );
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn missing_force_load_value_errors() {
 +        let err = parse(&argv(&["-force_load"])).unwrap_err();
 +        assert!(matches!(err, ArgsError::MissingValue(ref f) if f == "-force_load"));
 +    }
++
 +    #[test]
 +    fn missing_l_value_errors() {
 +        let err = parse(&argv(&["-l"])).unwrap_err();
 +        assert!(matches!(err, ArgsError::MissingValue(ref f) if f == "-l"));
 +    }
++
      #[test]
      fn missing_output_value_errors() {
          let err = parse(&argv(&["-o"])).unwrap_err();
      #[test]
      fn unknown_flag_errors() {
          let err = parse(&argv(&["-nonsense"])).unwrap_err();
 -        assert!(matches!(err, ArgsError::UnknownFlag(ref f) if f == "-nonsense"));
 +        assert!(matches!(
 +            err,
 +            ArgsError::UnknownFlag {
 +                ref flag,
 +                suggestion: None
 +            } if flag == "-nonsense"
 +        ));
 +    }
++
 +    #[test]
 +    fn unknown_flag_suggests_nearby_match() {
 +        let err = parse(&argv(&["-all_lod"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::UnknownFlag {
 +                ref flag,
 +                suggestion: Some(ref suggestion)
 +            } if flag == "-all_lod" && suggestion == "-all_load"
 +        ));
+     }
      #[test]

src/atom.rsmodified

177 lines changed — click to load

          );
+     }
 -    // Post-pass: wire `parent_of` for every `__compact_unwind` atom to the
 -    // function atom that its `function_start` reloc references.
 +    // Post-pass: wire metadata atoms to the function atoms whose lifetime
 +    // they track, so dead-strip can prune unwind surfaces precisely.
      link_unwind_parents(input_id, obj, table, &out);
 +    link_eh_frame_parents(input_id, obj, table, &out);
      out
+ }
          return;
+     }
 +    if atom_section == AtomSection::EhFrame {
 +        atomize_eh_frame(input_id, section_idx, sect, atom_section, table, out);
 +        return;
 +    }
++
      // With subsections_via_symbols and at least one split point, walk the
      // sorted symbols and emit one atom per non-alt_entry boundary.
      if syms.is_empty() {
+     }
+ }
 +/// Split `__eh_frame` into DWARF CFI records so dead-strip can retain only
 +/// the live FDEs and their shared CIEs.
 +fn atomize_eh_frame(
 +    input_id: InputId,
 +    section_idx: u8,
 +    sect: &InputSection,
 +    atom_section: AtomSection,
 +    table: &mut AtomTable,
 +    out: &mut ObjectAtomization,
 +) {
 +    let mut offset = 0usize;
 +    while offset < sect.data.len() {
 +        let Some(size) = eh_frame_record_size(&sect.data, offset) else {
 +            let atom = build_section_atom(input_id, section_idx, sect, atom_section);
 +            let id = table.push(atom);
 +            out.atoms.push(id);
 +            return;
 +        };
++
 +        let end = (offset + size).min(sect.data.len());
 +        let atom = Atom {
 +            id: AtomId(0),
 +            origin: input_id,
 +            input_section: section_idx,
 +            section: atom_section,
 +            input_offset: offset as u32,
 +            size: (end - offset) as u32,
 +            align_pow2: (sect.align_pow2 as u8).min(2),
 +            owner: None,
 +            alt_entries: Vec::new(),
 +            data: sect.data[offset..end].to_vec(),
 +            flags: AtomFlags::default(),
 +            parent_of: None,
 +        };
 +        let id = table.push(atom);
 +        out.atoms.push(id);
 +        offset = end;
 +    }
 +}
++
 +fn eh_frame_record_size(data: &[u8], offset: usize) -> Option<usize> {
 +    let length_end = offset.checked_add(4)?;
 +    let length_bytes: [u8; 4] = data.get(offset..length_end)?.try_into().ok()?;
 +    let length = u32::from_le_bytes(length_bytes);
 +    if length == 0 {
 +        return Some(4);
 +    }
 +    if length == u32::MAX {
 +        return None;
 +    }
 +    let size = 4usize.checked_add(length as usize)?;
 +    (offset + size <= data.len()).then_some(size)
 +}
++
 +fn eh_frame_cie_pointer(atom: &Atom) -> Option<u32> {
 +    (atom.section == AtomSection::EhFrame && atom.data.len() >= 8).then(|| {
 +        let mut buf = [0u8; 4];
 +        buf.copy_from_slice(&atom.data[4..8]);
 +        u32::from_le_bytes(buf)
 +    })
 +}
++
 +fn resolve_function_parent(
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    reloc: crate::reloc::Reloc,
 +    atom_index: &HashMap<(u8, u32), AtomId>,
 +    field_offset: usize,
 +) -> Option<AtomId> {
 +    match reloc.referent {
 +        Referent::Section(sect_idx) => {
 +            let end = field_offset.checked_add(8)?;
 +            let mut buf = [0u8; 8];
 +            buf.copy_from_slice(atom.data.get(field_offset..end)?);
 +            let target_offset = u64::from_le_bytes(buf) as u32;
 +            atom_index.get(&(sect_idx, target_offset)).copied()
 +        }
 +        Referent::Symbol(sym_idx) => {
 +            let input_sym = obj.symbols.get(sym_idx as usize)?;
 +            (input_sym.kind() == SymKind::Sect)
 +                .then(|| {
 +                    let target_offset = input_sym.value().saturating_sub(
 +                        obj.sections
 +                            .get(input_sym.sect_idx().saturating_sub(1) as usize)
 +                            .map(|section| section.addr)
 +                            .unwrap_or(0),
 +                    ) as u32;
 +                    atom_index
 +                        .get(&(input_sym.sect_idx(), target_offset))
 +                        .copied()
 +                })
 +                .flatten()
 +        }
 +    }
 +}
++
 +fn link_eh_frame_parents(
 +    input_id: InputId,
 +    obj: &ObjectFile,
 +    table: &mut AtomTable,
 +    out: &ObjectAtomization,
 +) {
 +    let Some((eh_idx_zero, eh_sect)) = obj
 +        .sections
 +        .iter()
 +        .enumerate()
 +        .find(|(_, s)| s.kind == SectionKind::EhFrame)
 +    else {
 +        return;
 +    };
 +    let eh_idx_one = (eh_idx_zero + 1) as u8;
++
 +    let raws = match parse_raw_relocs(&eh_sect.raw_relocs, 0, eh_sect.nreloc) {
 +        Ok(r) => r,
 +        Err(_) => return,
 +    };
 +    let fused = match parse_relocs(&raws) {
 +        Ok(f) => f,
 +        Err(_) => return,
 +    };
++
 +    let mut atom_index: HashMap<(u8, u32), AtomId> = HashMap::new();
 +    for id in &out.atoms {
 +        let a = table.get(*id);
 +        atom_index.insert((a.input_section, a.input_offset), *id);
 +    }
++
 +    for id in &out.atoms {
 +        let atom = table.get(*id);
 +        if atom.input_section != eh_idx_one {
 +            continue;
 +        }
 +        let Some(cie_pointer) = eh_frame_cie_pointer(atom) else {
 +            continue;
 +        };
 +        if cie_pointer == 0 {
 +            continue;
 +        }
 +        let Some(reloc) = fused.iter().find(|r| r.offset == atom.input_offset + 8) else {
 +            continue;
 +        };
 +        if let Some(parent_id) = resolve_function_parent(obj, atom, *reloc, &atom_index, 8) {
 +            table.get_mut(*id).parent_of = Some(parent_id);
 +        }
 +    }
 +    let _ = input_id;
 +}
++
  fn atomize_zerofill(
      input_id: InputId,
      section_idx: u8,

src/diag.rsmodified

15 lines changed — click to load

      let mut h = stderr.lock();
      let _ = writeln!(h, "{msg}");
+ }
++
 +pub fn warning(msg: &str) {
 +    let stderr = std::io::stderr();
 +    let mut h = stderr.lock();
 +    let _ = writeln!(h, "afs-ld: warning: {msg}");
 +}
++
 +pub fn warning_verbatim(msg: &str) {
 +    let stderr = std::io::stderr();
 +    let mut h = stderr.lock();
 +    let _ = writeln!(h, "{msg}");
 +}

src/icf.rsadded

506 lines changed — click to load

 +use std::collections::{HashMap, HashSet};
 +use std::fmt;
++
 +use crate::atom::{Atom, AtomFlags, AtomSection, AtomTable};
 +use crate::layout::LayoutInput;
 +use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind, RelocLength};
 +use crate::resolve::{AtomId, InputId, Symbol, SymbolId, SymbolTable};
++
 +#[derive(Debug, Clone, Default)]
 +pub struct IcfPlan {
 +    kept_atoms: HashSet<AtomId>,
 +    redirects: HashMap<AtomId, AtomId>,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct FoldedSymbol {
 +    pub name: String,
 +    pub winner: String,
 +    pub file_index: usize,
 +}
++
 +impl IcfPlan {
 +    pub fn kept_atoms(&self) -> &HashSet<AtomId> {
 +        &self.kept_atoms
 +    }
++
 +    pub fn redirects(&self) -> &HashMap<AtomId, AtomId> {
 +        &self.redirects
 +    }
++
 +    pub fn folded_symbols(
 +        &self,
 +        atom_table: &AtomTable,
 +        sym_table: &SymbolTable,
 +        layout_inputs: &[LayoutInput<'_>],
 +    ) -> Vec<FoldedSymbol> {
 +        let file_index_by_input: HashMap<InputId, usize> = layout_inputs
 +            .iter()
 +            .enumerate()
 +            .map(|(idx, input)| (input.id, idx + 1))
 +            .collect();
 +        let mut out = Vec::new();
 +        for (&loser, &winner) in &self.redirects {
 +            let winner = canonical_atom(winner, &self.redirects);
 +            let Some(winner_symbol) = representative_symbol(atom_table.get(winner)) else {
 +                continue;
 +            };
 +            let winner_name = symbol_name(sym_table, winner_symbol);
 +            for symbol_id in atom_symbols(atom_table.get(loser)) {
 +                let Symbol::Defined { origin, .. } = sym_table.get(symbol_id) else {
 +                    continue;
 +                };
 +                let name = symbol_name(sym_table, symbol_id);
 +                if name == winner_name {
 +                    continue;
 +                }
 +                out.push(FoldedSymbol {
 +                    name,
 +                    winner: winner_name.clone(),
 +                    file_index: file_index_by_input.get(origin).copied().unwrap_or(0),
 +                });
 +            }
 +        }
 +        out.sort_by(|lhs, rhs| {
 +            lhs.name
 +                .cmp(&rhs.name)
 +                .then_with(|| lhs.winner.cmp(&rhs.winner))
 +                .then_with(|| lhs.file_index.cmp(&rhs.file_index))
 +        });
 +        out.dedup_by(|lhs, rhs| {
 +            lhs.name == rhs.name && lhs.winner == rhs.winner && lhs.file_index == rhs.file_index
 +        });
 +        out
 +    }
 +}
++
 +#[derive(Debug, Clone)]
 +pub struct IcfError(String);
++
 +impl fmt::Display for IcfError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        write!(f, "ICF error: {}", self.0)
 +    }
 +}
++
 +impl std::error::Error for IcfError {}
++
 +pub fn fold_safe(
 +    layout_inputs: &[LayoutInput<'_>],
 +    atom_table: &mut AtomTable,
 +    sym_table: &mut SymbolTable,
 +    live_atoms: Option<&HashSet<AtomId>>,
 +) -> Result<IcfPlan, IcfError> {
 +    let resolved_by_name = resolved_symbol_map(sym_table);
 +    let reloc_cache = reloc_cache(layout_inputs)?;
++
 +    mark_address_taken(
 +        layout_inputs,
 +        atom_table,
 +        sym_table,
 +        &resolved_by_name,
 +        &reloc_cache,
 +    );
++
 +    let mut kept_atoms = live_atoms.cloned().unwrap_or_else(|| {
 +        atom_table
 +            .iter()
 +            .map(|(atom_id, _)| atom_id)
 +            .collect::<HashSet<_>>()
 +    });
 +    let mut redirects = HashMap::new();
++
 +    let order_by_input: HashMap<InputId, (usize, Option<u32>)> = layout_inputs
 +        .iter()
 +        .map(|input| (input.id, (input.load_order, input.archive_member_offset)))
 +        .collect();
++
 +    loop {
 +        let mut buckets: HashMap<FoldKey, Vec<AtomId>> = HashMap::new();
 +        for (atom_id, atom) in atom_table.iter() {
 +            if !kept_atoms.contains(&atom_id) {
 +                continue;
 +            }
 +            if !is_foldable_atom(atom, sym_table) {
 +                continue;
 +            }
 +            let relocs = reloc_cache
 +                .get(&(atom.origin, atom.input_section))
 +                .map(Vec::as_slice)
 +                .unwrap_or(&[]);
 +            let Some(reloc_sig) = reloc_signature_for_atom(
 +                atom,
 +                relocs,
 +                layout_inputs,
 +                sym_table,
 +                &resolved_by_name,
 +                &redirects,
 +            ) else {
 +                continue;
 +            };
 +            buckets
 +                .entry(FoldKey::from_atom(atom, reloc_sig))
 +                .or_default()
 +                .push(atom_id);
 +        }
++
 +        let mut changed = false;
 +        for atom_ids in buckets.into_values() {
 +            if atom_ids.len() < 2 {
 +                continue;
 +            }
 +            let winner = *atom_ids
 +                .iter()
 +                .min_by_key(|atom_id| {
 +                    fold_order_key(atom_table.get(**atom_id), &order_by_input, **atom_id)
 +                })
 +                .expect("bucket is non-empty");
 +            for loser in atom_ids {
 +                if loser == winner {
 +                    continue;
 +                }
 +                redirects.insert(loser, winner);
 +                kept_atoms.remove(&loser);
 +                rebind_folded_symbols(sym_table, atom_table.get(loser), winner);
 +                changed = true;
 +            }
 +        }
++
 +        if !changed {
 +            break;
 +        }
 +    }
++
 +    rebind_symbols_to_canonical_winners(sym_table, &redirects);
++
 +    Ok(IcfPlan {
 +        kept_atoms,
 +        redirects,
 +    })
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +struct FoldKey {
 +    section: AtomSection,
 +    size: u32,
 +    align_pow2: u8,
 +    flags: u32,
 +    data: Vec<u8>,
 +    relocs: Vec<FoldReloc>,
 +}
++
 +impl FoldKey {
 +    fn from_atom(atom: &Atom, relocs: Vec<FoldReloc>) -> Self {
 +        Self {
 +            section: atom.section,
 +            size: atom.size,
 +            align_pow2: atom.align_pow2,
 +            flags: atom.flags.bits() & !AtomFlags::ADDRESS_TAKEN,
 +            data: atom.data.clone(),
 +            relocs,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +struct FoldReloc {
 +    offset: u32,
 +    kind: RelocKind,
 +    length: RelocLength,
 +    pcrel: bool,
 +    referent: FoldReferent,
 +    addend: i64,
 +    subtrahend: Option<FoldReferent>,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +enum FoldReferent {
 +    Atom(AtomId),
 +    Symbol(SymbolId),
 +    Section(u8),
 +}
++
 +fn fold_order_key(
 +    atom: &Atom,
 +    order_by_input: &HashMap<InputId, (usize, Option<u32>)>,
 +    atom_id: AtomId,
 +) -> (usize, u32, u32, u32) {
 +    let (load_order, archive_member_offset) = order_by_input
 +        .get(&atom.origin)
 +        .copied()
 +        .unwrap_or((usize::MAX, None));
 +    (
 +        load_order,
 +        archive_member_offset.unwrap_or(0),
 +        atom.input_offset,
 +        atom_id.0,
 +    )
 +}
++
 +fn is_foldable_atom(atom: &Atom, sym_table: &SymbolTable) -> bool {
 +    if !matches!(
 +        atom.section,
 +        AtomSection::Text
 +            | AtomSection::ConstData
 +            | AtomSection::CStringLiterals
 +            | AtomSection::Literal16
 +    ) {
 +        return false;
 +    }
 +    if atom.flags.has(AtomFlags::NO_DEAD_STRIP) || atom.flags.has(AtomFlags::ADDRESS_TAKEN) {
 +        return false;
 +    }
 +    !matches!(
 +        atom.owner.map(|owner| sym_table.get(owner)),
 +        Some(Symbol::Defined {
 +            private_extern: false,
 +            ..
 +        })
 +    )
 +}
++
 +fn rebind_folded_symbols(sym_table: &mut SymbolTable, atom: &Atom, winner: AtomId) {
 +    if let Some(owner) = atom.owner {
 +        let value = match sym_table.get(owner) {
 +            Symbol::Defined { value, .. } => *value,
 +            _ => 0,
 +        };
 +        sym_table.bind_atom(owner, winner, value);
 +    }
 +    for alt in &atom.alt_entries {
 +        let value = match sym_table.get(alt.symbol) {
 +            Symbol::Defined { value, .. } => *value,
 +            _ => alt.offset_within_atom as u64,
 +        };
 +        sym_table.bind_atom(alt.symbol, winner, value);
 +    }
 +}
++
 +fn rebind_symbols_to_canonical_winners(
 +    sym_table: &mut SymbolTable,
 +    redirects: &HashMap<AtomId, AtomId>,
 +) {
 +    let updates: Vec<(SymbolId, AtomId, u64)> = sym_table
 +        .iter()
 +        .filter_map(|(symbol_id, symbol)| match symbol {
 +            Symbol::Defined { atom, value, .. } if atom.0 != 0 => {
 +                let canonical = canonical_atom(*atom, redirects);
 +                (canonical != *atom).then_some((symbol_id, canonical, *value))
 +            }
 +            _ => None,
 +        })
 +        .collect();
 +    for (symbol_id, atom, value) in updates {
 +        sym_table.bind_atom(symbol_id, atom, value);
 +    }
 +}
++
 +fn resolved_symbol_map(sym_table: &SymbolTable) -> HashMap<String, SymbolId> {
 +    let mut out = HashMap::new();
 +    for (symbol_id, symbol) in sym_table.iter() {
 +        out.insert(
 +            sym_table.interner.resolve(symbol.name()).to_string(),
 +            symbol_id,
 +        );
 +    }
 +    out
 +}
++
 +fn reloc_cache(
 +    layout_inputs: &[LayoutInput<'_>],
 +) -> Result<HashMap<(InputId, u8), Vec<Reloc>>, IcfError> {
 +    let mut out = HashMap::new();
 +    for input in layout_inputs {
 +        for (section_idx_zero, section) in input.object.sections.iter().enumerate() {
 +            if section.raw_relocs.is_empty() {
 +                continue;
 +            }
 +            let raws = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc)
 +                .map_err(|err| IcfError(format!("{}: {err}", input.object.path.display())))?;
 +            let relocs = parse_relocs(&raws)
 +                .map_err(|err| IcfError(format!("{}: {err}", input.object.path.display())))?;
 +            out.insert((input.id, (section_idx_zero + 1) as u8), relocs);
 +        }
 +    }
 +    Ok(out)
 +}
++
 +#[allow(clippy::too_many_arguments)]
 +fn mark_address_taken(
 +    layout_inputs: &[LayoutInput<'_>],
 +    atom_table: &mut AtomTable,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +    reloc_cache: &HashMap<(InputId, u8), Vec<Reloc>>,
 +) {
 +    for input in layout_inputs {
 +        for (section_idx_zero, _section) in input.object.sections.iter().enumerate() {
 +            let input_section = (section_idx_zero + 1) as u8;
 +            let Some(relocs) = reloc_cache.get(&(input.id, input_section)) else {
 +                continue;
 +            };
 +            for reloc in relocs {
 +                if !marks_address_taken(reloc.kind) {
 +                    continue;
 +                }
 +                for target_atom in target_atoms_for_reloc(
 +                    input.object,
 +                    reloc.referent,
 +                    sym_table,
 +                    resolved_by_name,
 +                ) {
 +                    atom_table
 +                        .get_mut(target_atom)
 +                        .flags
 +                        .set(AtomFlags::ADDRESS_TAKEN);
 +                }
 +            }
 +        }
 +    }
 +}
++
 +fn marks_address_taken(kind: RelocKind) -> bool {
 +    matches!(
 +        kind,
 +        RelocKind::Unsigned
 +            | RelocKind::Page21
 +            | RelocKind::PageOff12
 +            | RelocKind::PointerToGot
 +            | RelocKind::GotLoadPage21
 +            | RelocKind::GotLoadPageOff12
 +            | RelocKind::TlvpLoadPage21
 +            | RelocKind::TlvpLoadPageOff12
 +    )
 +}
++
 +fn relocs_for_atom<'a>(relocs: &'a [Reloc], atom: &Atom) -> impl Iterator<Item = Reloc> + 'a {
 +    let start = atom.input_offset;
 +    let end = atom.input_offset.saturating_add(atom.size);
 +    relocs.iter().copied().filter(move |reloc| {
 +        let reloc_end = reloc
 +            .offset
 +            .saturating_add(reloc.length.byte_width() as u32);
 +        reloc.offset >= start && reloc_end <= end
 +    })
 +}
++
 +fn reloc_signature_for_atom(
 +    atom: &Atom,
 +    relocs: &[Reloc],
 +    layout_inputs: &[LayoutInput<'_>],
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +    redirects: &HashMap<AtomId, AtomId>,
 +) -> Option<Vec<FoldReloc>> {
 +    let objects_by_input: HashMap<InputId, &crate::input::ObjectFile> = layout_inputs
 +        .iter()
 +        .map(|input| (input.id, input.object))
 +        .collect();
 +    let object = objects_by_input.get(&atom.origin)?;
 +    relocs_for_atom(relocs, atom)
 +        .map(|reloc| {
 +            Some(FoldReloc {
 +                offset: reloc.offset.saturating_sub(atom.input_offset),
 +                kind: reloc.kind,
 +                length: reloc.length,
 +                pcrel: reloc.pcrel,
 +                referent: normalize_referent(
 +                    object,
 +                    reloc.referent,
 +                    sym_table,
 +                    resolved_by_name,
 +                    redirects,
 +                )?,
 +                addend: reloc.addend,
 +                subtrahend: match reloc.subtrahend {
 +                    Some(referent) => Some(normalize_referent(
 +                        object,
 +                        referent,
 +                        sym_table,
 +                        resolved_by_name,
 +                        redirects,
 +                    )?),
 +                    None => None,
 +                },
 +            })
 +        })
 +        .collect()
 +}
++
 +fn normalize_referent(
 +    object: &crate::input::ObjectFile,
 +    referent: Referent,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +    redirects: &HashMap<AtomId, AtomId>,
 +) -> Option<FoldReferent> {
 +    match referent {
 +        Referent::Symbol(sym_idx) => {
 +            let input_sym = object.symbols.get(sym_idx as usize)?;
 +            let name = object.symbol_name(input_sym).ok()?;
 +            let &symbol_id = resolved_by_name.get(name)?;
 +            match sym_table.get(symbol_id) {
 +                Symbol::Defined { atom, .. } if atom.0 != 0 => {
 +                    Some(FoldReferent::Atom(canonical_atom(*atom, redirects)))
 +                }
 +                _ => Some(FoldReferent::Symbol(symbol_id)),
 +            }
 +        }
 +        Referent::Section(section) => Some(FoldReferent::Section(section)),
 +    }
 +}
++
 +fn canonical_atom(atom_id: AtomId, redirects: &HashMap<AtomId, AtomId>) -> AtomId {
 +    let mut current = atom_id;
 +    while let Some(&next) = redirects.get(&current) {
 +        if next == current {
 +            break;
 +        }
 +        current = next;
 +    }
 +    current
 +}
++
 +fn representative_symbol(atom: &Atom) -> Option<SymbolId> {
 +    atom.owner
 +        .or_else(|| atom.alt_entries.first().map(|alt| alt.symbol))
 +}
++
 +fn atom_symbols(atom: &Atom) -> impl Iterator<Item = SymbolId> + '_ {
 +    atom.owner
 +        .into_iter()
 +        .chain(atom.alt_entries.iter().map(|alt| alt.symbol))
 +}
++
 +fn symbol_name(sym_table: &SymbolTable, symbol_id: SymbolId) -> String {
 +    sym_table
 +        .interner
 +        .resolve(sym_table.get(symbol_id).name())
 +        .to_string()
 +}
++
 +fn target_atoms_for_reloc(
 +    object: &crate::input::ObjectFile,
 +    referent: Referent,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +) -> Vec<AtomId> {
 +    match referent {
 +        Referent::Symbol(sym_idx) => {
 +            let Some(input_sym) = object.symbols.get(sym_idx as usize) else {
 +                return Vec::new();
 +            };
 +            let Some(name) = object.symbol_name(input_sym).ok() else {
 +                return Vec::new();
 +            };
 +            let Some(&symbol_id) = resolved_by_name.get(name) else {
 +                return Vec::new();
 +            };
 +            match sym_table.get(symbol_id) {
 +                Symbol::Defined { atom, .. } if atom.0 != 0 => vec![*atom],
 +                _ => Vec::new(),
 +            }
 +        }
 +        Referent::Section(_) => Vec::new(),
 +    }
 +}

src/input.rsmodified

192 lines changed — click to load

  use std::path::PathBuf;
 +use crate::loh::{parse_loh_blob, LohEntry};
  use crate::macho::constants::LC_DATA_IN_CODE;
  use crate::macho::reader::{
      parse_commands, parse_header, DysymtabCmd, LinkEditDataCmd, LoadCommand, MachHeader64,
      pub strings: StringTable,
      pub symtab: Option<SymtabCmd>,
      pub dysymtab: Option<DysymtabCmd>,
 +    pub loh: Vec<LohEntry>,
      pub data_in_code: Vec<DataInCodeEntry>,
+ }
              ),
              None => (Vec::new(), StringTable::from_bytes(Vec::new())),
          };
 +        let loh = parse_loh(&commands, file_bytes)?;
          let data_in_code = parse_data_in_code(&commands, file_bytes)?;
          Ok(ObjectFile {
              strings,
              symtab,
              dysymtab,
 +            loh,
              data_in_code,
          })
+     }
+     }
+ }
 +fn parse_loh(commands: &[LoadCommand], file_bytes: &[u8]) -> Result<Vec<LohEntry>, ReadError> {
 +    let mut out = Vec::new();
 +    for command in commands {
 +        let LoadCommand::LinkerOptimizationHint(linkedit) = command else {
 +            continue;
 +        };
 +        let start = linkedit.dataoff as usize;
 +        let end = start
 +            .checked_add(linkedit.datasize as usize)
 +            .ok_or(ReadError::Truncated {
 +                need: usize::MAX,
 +                have: file_bytes.len(),
 +                context: "LC_LINKER_OPTIMIZATION_HINT payload (offset + size overflows)",
 +            })?;
 +        if end > file_bytes.len() {
 +            return Err(ReadError::Truncated {
 +                need: end,
 +                have: file_bytes.len(),
 +                context: "LC_LINKER_OPTIMIZATION_HINT payload",
 +            });
 +        }
 +        out.extend(parse_loh_blob(&file_bytes[start..end])?);
 +    }
 +    Ok(out)
 +}
++
  fn parse_data_in_code(
      commands: &[LoadCommand],
      file_bytes: &[u8],
  #[cfg(test)]
  mod tests {
      use super::*;
 +    use crate::loh::{write_loh_blob, LOH_ARM64_ADRP_ADD};
      use crate::macho::constants::*;
      use crate::macho::reader::{
          write_commands, write_header, LinkEditDataCmd, LoadCommand, Section64Header, Segment64,
          image
+     }
 +    fn synth_image_with_loh() -> Vec<u8> {
 +        let text_sect = Section64Header {
 +            sectname: name16("__text"),
 +            segname: name16("__TEXT"),
 +            addr: 0,
 +            size: 8,
 +            offset: 0,
 +            align: 2,
 +            reloff: 0,
 +            nreloc: 0,
 +            flags: S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS,
 +            reserved1: 0,
 +            reserved2: 0,
 +            reserved3: 0,
 +        };
 +        let seg = Segment64 {
 +            segname: name16(""),
 +            vmaddr: 0,
 +            vmsize: 8,
 +            fileoff: 0,
 +            filesize: 8,
 +            maxprot: 7,
 +            initprot: 7,
 +            flags: 0,
 +            sections: vec![text_sect],
 +        };
 +        let strtab = b"\0_main\0";
 +        let nsyms = 1u32;
 +        let sym = RawNlist {
 +            strx: 1,
 +            n_type: N_SECT | N_EXT,
 +            n_sect: 1,
 +            n_desc: 0,
 +            n_value: 0,
 +        };
 +        let loh_blob = write_loh_blob(&[LohEntry {
 +            kind: LOH_ARM64_ADRP_ADD,
 +            args: vec![0, 4],
 +        }]);
 +        let hdr_size = HEADER_SIZE;
 +        let seg_size = seg.wire_size() as usize;
 +        let loh_size = LinkEditDataCmd::WIRE_SIZE as usize;
 +        let symtab_size = SymtabCmd::WIRE_SIZE as usize;
 +        let sizeofcmds = (seg_size + loh_size + symtab_size) as u32;
++
 +        let section_offset = (hdr_size + sizeofcmds as usize) as u32;
 +        let loh_off = section_offset + 8;
 +        let symoff = loh_off + loh_blob.len() as u32;
 +        let stroff = symoff + NLIST_SIZE as u32 * nsyms;
 +        let seg = Segment64 {
 +            sections: vec![Section64Header {
 +                offset: section_offset,
 +                ..seg.sections[0]
 +            }],
 +            fileoff: section_offset as u64,
 +            ..seg
 +        };
 +        let header = MachHeader64 {
 +            magic: MH_MAGIC_64,
 +            cputype: CPU_TYPE_ARM64,
 +            cpusubtype: 0,
 +            filetype: MH_OBJECT,
 +            ncmds: 3,
 +            sizeofcmds,
 +            flags: MH_SUBSECTIONS_VIA_SYMBOLS,
 +            reserved: 0,
 +        };
 +        let symtab_cmd = SymtabCmd {
 +            symoff,
 +            nsyms,
 +            stroff,
 +            strsize: strtab.len() as u32,
 +        };
 +        let loh_cmd = LoadCommand::LinkerOptimizationHint(LinkEditDataCmd {
 +            dataoff: loh_off,
 +            datasize: loh_blob.len() as u32,
 +        });
++
 +        let mut image = Vec::new();
 +        write_header(&header, &mut image);
 +        let cmds = vec![
 +            LoadCommand::Segment64(seg),
 +            loh_cmd,
 +            LoadCommand::Symtab(symtab_cmd),
 +        ];
 +        write_commands(&cmds, &mut image);
 +        image.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x11, 0x22]);
 +        image.extend_from_slice(&loh_blob);
 +        sym.write(&mut image);
 +        image.extend_from_slice(strtab);
 +        image
 +    }
++
      #[test]
      fn parse_synth_object_end_to_end() {
          let image = synth_image();
          );
+     }
 +    #[test]
 +    fn parse_preserves_loh_entries() {
 +        let image = synth_image_with_loh();
 +        let obj = ObjectFile::parse("/tmp/synth-loh.o", &image).unwrap();
 +        assert_eq!(
 +            obj.loh,
 +            vec![LohEntry {
 +                kind: LOH_ARM64_ADRP_ADD,
 +                args: vec![0, 4],
 +            }]
 +        );
 +    }
++
      #[test]
      fn indirect_target_name_resolves() {
          // Build a minimal strtab with "\0_alias\0_target\0" and a RawNlist
              strings: strtab,
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
          let alias = InputSymbol::from_raw(RawNlist {

src/layout.rsmodified

278 lines changed — click to load

  //! Groups atoms into output sections, orders them deterministically, and
  //! assigns segment VM/file ranges once the final Mach-O header size is known.
 -use std::collections::HashMap;
 +use std::collections::{HashMap, HashSet};
  use crate::atom::AtomTable;
  use crate::input::ObjectFile;
  use crate::macho::constants::SG_READ_ONLY;
 -use crate::resolve::InputId;
 +use crate::resolve::{AtomId, InputId};
  use crate::section::{
      is_zerofill, InputSection, OutputAtom, OutputSection, OutputSectionId, OutputSegment, Prot,
  };
      name: String,
+ }
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +pub enum ExtraSectionAnchor {
 +    AfterSection { segment: String, name: String },
 +    AfterAtom(AtomId),
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ExtraOutputSection {
 +    pub after_section: Option<ExtraSectionAnchor>,
 +    pub section: OutputSection,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct ExtraLayoutSections<'a> {
 +    pub extra_sections: &'a [ExtraOutputSection],
 +    pub split_after_atoms: &'a [AtomId],
 +}
++
  fn output_section_key(input_section: &InputSection) -> SectionKey {
      match (
          input_section.segname.as_str(),
          atoms: &AtomTable,
          header_size: u64,
      ) -> Self {
 -        Self::build_with_synthetics(kind, inputs, atoms, header_size, None)
 +        Self::build_with_synthetics_filtered(kind, inputs, atoms, header_size, None, None)
+     }
      pub fn build_with_synthetics(
          atoms: &AtomTable,
          header_size: u64,
          synthetic_plan: Option<&SyntheticPlan>,
 +    ) -> Self {
 +        Self::build_with_synthetics_and_extra_filtered(
 +            kind,
 +            inputs,
 +            atoms,
 +            header_size,
 +            synthetic_plan,
 +            None,
 +            ExtraLayoutSections {
 +                extra_sections: &[],
 +                split_after_atoms: &[],
 +            },
 +        )
 +    }
++
 +    pub fn build_with_synthetics_filtered(
 +        kind: OutputKind,
 +        inputs: &[LayoutInput<'_>],
 +        atoms: &AtomTable,
 +        header_size: u64,
 +        synthetic_plan: Option<&SyntheticPlan>,
 +        live_atoms: Option<&HashSet<AtomId>>,
 +    ) -> Self {
 +        Self::build_with_synthetics_and_extra_filtered(
 +            kind,
 +            inputs,
 +            atoms,
 +            header_size,
 +            synthetic_plan,
 +            live_atoms,
 +            ExtraLayoutSections {
 +                extra_sections: &[],
 +                split_after_atoms: &[],
 +            },
 +        )
 +    }
++
 +    pub fn build_with_synthetics_and_extra_filtered(
 +        kind: OutputKind,
 +        inputs: &[LayoutInput<'_>],
 +        atoms: &AtomTable,
 +        header_size: u64,
 +        synthetic_plan: Option<&SyntheticPlan>,
 +        live_atoms: Option<&HashSet<AtomId>>,
 +        extra_layout: ExtraLayoutSections<'_>,
      ) -> Self {
          let input_map: HashMap<InputId, LayoutInput<'_>> =
              inputs.iter().map(|input| (input.id, *input)).collect();
          let mut section_index: HashMap<SectionKey, usize> = HashMap::new();
          for (atom_id, atom) in atoms.iter() {
 +            if live_atoms.is_some_and(|live_atoms| !live_atoms.contains(&atom_id)) {
 +                continue;
 +            }
              let input = input_map
                  .get(&atom.origin)
                  .unwrap_or_else(|| panic!("missing object for input {:?}", atom.origin));
+                 }
+             }
+         }
+-
          sections.sort_by(|a, b| {
              segment_rank(kind, &a.segment)
                  .cmp(&segment_rank(kind, &b.segment))
                      .then_with(|| lhs.input_offset.cmp(&rhs.input_offset))
                      .then_with(|| a.atom.cmp(&b.atom))
              });
 +        }
 +        split_sections_after_atoms(&mut sections, extra_layout.split_after_atoms);
 +        insert_extra_sections(&mut sections, extra_layout.extra_sections);
++
 +        for section in &mut sections {
              let mut size = 0u64;
              for placed in &mut section.atoms {
                  let atom = atoms.get(placed.atom);
+     }
+ }
 +fn split_sections_after_atoms(sections: &mut Vec<OutputSection>, split_after_atoms: &[AtomId]) {
 +    if split_after_atoms.is_empty() {
 +        return;
 +    }
 +    let split_points: HashSet<AtomId> = split_after_atoms.iter().copied().collect();
 +    let mut out = Vec::with_capacity(sections.len());
 +    for mut section in std::mem::take(sections) {
 +        if section.atoms.len() < 2 || !section.synthetic_data.is_empty() {
 +            out.push(section);
 +            continue;
 +        }
 +        if !section
 +            .atoms
 +            .iter()
 +            .any(|placed| split_points.contains(&placed.atom))
 +        {
 +            out.push(section);
 +            continue;
 +        }
 +        let atoms = std::mem::take(&mut section.atoms);
 +        let last_idx = atoms.len().saturating_sub(1);
 +        let mut current = split_section_template(&section);
 +        for (idx, placed) in atoms.into_iter().enumerate() {
 +            let split_here = split_points.contains(&placed.atom) && idx != last_idx;
 +            current.atoms.push(placed);
 +            if split_here {
 +                out.push(current);
 +                current = split_section_template(&section);
 +            }
 +        }
 +        out.push(current);
 +    }
 +    *sections = out;
 +}
++
 +fn split_section_template(section: &OutputSection) -> OutputSection {
 +    OutputSection {
 +        segment: section.segment.clone(),
 +        name: section.name.clone(),
 +        kind: section.kind,
 +        align_pow2: section.align_pow2,
 +        flags: section.flags,
 +        reserved1: section.reserved1,
 +        reserved2: section.reserved2,
 +        reserved3: section.reserved3,
 +        atoms: Vec::new(),
 +        synthetic_offset: 0,
 +        synthetic_data: Vec::new(),
 +        addr: 0,
 +        size: 0,
 +        file_off: 0,
 +    }
 +}
++
 +fn insert_extra_sections(sections: &mut Vec<OutputSection>, extra_sections: &[ExtraOutputSection]) {
 +    for extra in extra_sections {
 +        let section = extra.section.clone();
 +        if let Some(anchor) = &extra.after_section {
 +            let insert_at = sections
 +                .iter()
 +                .rposition(|candidate| match anchor {
 +                    ExtraSectionAnchor::AfterSection { segment, name } => {
 +                        candidate.segment == *segment && candidate.name == *name
 +                    }
 +                    ExtraSectionAnchor::AfterAtom(atom_id) => candidate
 +                        .atoms
 +                        .last()
 +                        .map(|placed| placed.atom == *atom_id)
 +                        .unwrap_or(false),
 +                })
 +                .map(|idx| idx + 1)
 +                .unwrap_or_else(|| {
 +                    panic!(
 +                        "missing anchor {:?} for synthetic section {},{}",
 +                        anchor, section.segment, section.name
 +                    )
 +                });
 +            sections.insert(insert_at, section);
 +        } else {
 +            sections.push(section);
 +        }
 +    }
 +}
++
  fn merge_synthetic_section(existing: &mut OutputSection, synthetic: OutputSection) {
      debug_assert_eq!(existing.segment, synthetic.segment);
      debug_assert_eq!(existing.name, synthetic.name);
      let order: &[&str] = match segment {
          "__TEXT" => &[
              "__text",
 +            "__thunks",
              "__stubs",
              "__stub_helper",
              "__cstring",
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };
              strings: crate::string_table::StringTable::from_bytes(vec![0]),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
          };

src/lib.rsmodified

766 lines changed — click to load

  pub mod atom;
  pub mod diag;
  pub mod dump;
 +pub mod icf;
  pub mod input;
  pub mod layout;
  pub mod leb;
 +pub mod link_map;
 +pub mod loh;
  pub mod macho;
  pub mod reloc;
  pub mod resolve;
  pub mod string_table;
  pub mod symbol;
  pub mod synth;
 +pub mod why_live;
  use std::os::unix::fs::PermissionsExt;
  use std::path::PathBuf;
 +use std::time::{Duration, Instant};
  use std::{fs, io};
  use atom::{atomize_object, backpatch_symbol_atoms, AtomTable};
 -use layout::{Layout, LayoutInput};
 +use icf::IcfError;
 +use layout::{ExtraLayoutSections, Layout, LayoutInput};
  use macho::dylib::{DylibDependency, DylibFile, DylibLoadKind};
  use macho::reader::ReadError;
  use macho::tbd::{parse_tbd, parse_version, Arch, Platform, Target};
  use reloc::arm64::RelocError;
  use resolve::{
 -    classify_unresolved, drain_fetches, format_duplicate_diagnostic, format_undefined_diagnostic,
 -    seed_all, DylibLoadMeta, InputAddError, Inputs, Symbol, SymbolTable, UndefinedTreatment,
 +    classify_unresolved, drain_fetches, find_archive_by_path, force_load_all, force_load_archive,
 +    format_duplicate_diagnostic, format_undefined_diagnostic, format_undefined_warning_diagnostic,
 +    seed_all, DrainReport, DylibLoadMeta, InputAddError, Inputs, Symbol, SymbolTable,
 +    UndefinedTreatment,
  };
  const DEFAULT_TBD_VERSION: u32 = 1 << 16;
 +const THUNK_PLAN_MAX_ITERATIONS: usize = 16;
  /// What kind of Mach-O file the linker is producing.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
      Dylib,
+ }
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum IcfMode {
 +    None,
 +    Safe,
 +    All,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ThunkMode {
 +    None,
 +    Safe,
 +    All,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct PlatformVersion {
 +    pub minos: u32,
 +    pub sdk: u32,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct FrameworkSpec {
 +    pub name: String,
 +    pub weak: bool,
 +}
++
  /// User-facing linker configuration, populated by the CLI parser.
  #[derive(Debug, Clone)]
  pub struct LinkOptions {
      pub inputs: Vec<PathBuf>,
 +    pub library_names: Vec<String>,
 +    pub frameworks: Vec<FrameworkSpec>,
 +    pub search_paths: Vec<PathBuf>,
 +    pub syslibroot: Option<PathBuf>,
 +    pub platform_version: Option<PlatformVersion>,
 +    pub undefined_treatment: UndefinedTreatment,
 +    pub rpaths: Vec<String>,
 +    pub install_name: Option<String>,
 +    pub current_version: Option<u32>,
 +    pub compatibility_version: Option<u32>,
 +    pub exported_symbols_lists: Vec<PathBuf>,
 +    pub unexported_symbols_lists: Vec<PathBuf>,
 +    pub exported_symbols: Vec<String>,
 +    pub unexported_symbols: Vec<String>,
 +    pub map: Option<PathBuf>,
 +    pub why_live: Vec<String>,
 +    pub trace_inputs: bool,
 +    pub show_version: bool,
 +    pub show_help: bool,
      pub output: Option<PathBuf>,
      pub entry: Option<String>,
      pub arch: Option<String>,
 +    pub relocatable: bool,
 +    pub bundle: bool,
 +    pub objc_force_load: bool,
      pub strip_locals: bool,
 +    pub strip_debug: bool,
 +    pub emit_uuid: bool,
 +    pub dead_strip: bool,
 +    pub no_loh: bool,
 +    pub icf_mode: IcfMode,
 +    pub thunks: ThunkMode,
 +    pub fixup_chains: bool,
 +    pub all_load: bool,
 +    pub force_load_archives: Vec<PathBuf>,
      pub kind: OutputKind,
      /// When set, afs-ld operates in dump mode and prints the given file's
      /// header + load commands instead of linking.
      fn default() -> Self {
          Self {
              inputs: Vec::new(),
 +            library_names: Vec::new(),
 +            frameworks: Vec::new(),
 +            search_paths: Vec::new(),
 +            syslibroot: None,
 +            platform_version: None,
 +            undefined_treatment: UndefinedTreatment::Error,
 +            rpaths: Vec::new(),
 +            install_name: None,
 +            current_version: None,
 +            compatibility_version: None,
 +            exported_symbols_lists: Vec::new(),
 +            unexported_symbols_lists: Vec::new(),
 +            exported_symbols: Vec::new(),
 +            unexported_symbols: Vec::new(),
 +            map: None,
 +            why_live: Vec::new(),
 +            trace_inputs: false,
 +            show_version: false,
 +            show_help: false,
              output: None,
              entry: None,
              arch: None,
 +            relocatable: false,
 +            bundle: false,
 +            objc_force_load: false,
              strip_locals: false,
 +            strip_debug: false,
 +            emit_uuid: true,
 +            dead_strip: false,
 +            no_loh: false,
 +            icf_mode: IcfMode::None,
 +            thunks: ThunkMode::Safe,
 +            fixup_chains: false,
 +            all_load: false,
 +            force_load_archives: Vec::new(),
              kind: OutputKind::Executable,
              dump: None,
              dump_archive: None,
      Reloc(RelocError),
      Synth(synth::SynthError),
      Unwind(synth::unwind::UnwindError),
 +    Icf(IcfError),
 +    Loh(loh::LohError),
      DuplicateSymbols(String),
      UndefinedSymbols(String),
      UnsupportedArch(String),
      NoTbdDocument(PathBuf),
      EntrySymbolNotFound(String),
 +    ForceLoadNotArchive(PathBuf),
 +    LibraryNotFound(String),
 +    FrameworkNotFound(String),
 +    ThunkPlanningDidNotConverge,
 +    WhyLive(String),
 +    UnsupportedOption(String),
 +}
++
 +#[derive(Debug, Clone, Default, PartialEq, Eq)]
 +pub struct LinkPhaseTimings {
 +    pub input_parsing: Duration,
 +    pub symbol_resolution: Duration,
 +    pub atomization: Duration,
 +    pub layout: Duration,
 +    pub synth_sections: Duration,
 +    pub synth_linkedit_finalize: Duration,
 +    pub synth_linkedit_symbol_plan: Duration,
 +    pub synth_linkedit_symbol_plan_locals: Duration,
 +    pub synth_linkedit_symbol_plan_globals: Duration,
 +    pub synth_linkedit_symbol_plan_strtab: Duration,
 +    pub synth_linkedit_dyld_info: Duration,
 +    pub synth_linkedit_metadata_tables: Duration,
 +    pub synth_linkedit_code_signature: Duration,
 +    pub synth_unwind: Duration,
 +    pub reloc_apply: Duration,
 +    pub write_output: Duration,
 +}
++
 +impl LinkPhaseTimings {
 +    pub fn accounted_total(&self) -> Duration {
 +        self.input_parsing
 +            + self.symbol_resolution
 +            + self.atomization
 +            + self.layout
 +            + self.synth_sections
 +            + self.reloc_apply
 +            + self.write_output
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct LinkProfile {
 +    pub output: PathBuf,
 +    pub phases: LinkPhaseTimings,
 +    pub total_wall: Duration,
+ }
  impl std::fmt::Display for LinkError {
              LinkError::Reloc(e) => write!(f, "{e}"),
              LinkError::Synth(e) => write!(f, "{e}"),
              LinkError::Unwind(e) => write!(f, "{e}"),
 +            LinkError::Icf(e) => write!(f, "{e}"),
 +            LinkError::Loh(e) => write!(f, "{e}"),
              LinkError::DuplicateSymbols(msg) | LinkError::UndefinedSymbols(msg) => {
                  write!(f, "{msg}")
+             }
              LinkError::EntrySymbolNotFound(name) => {
                  write!(f, "entry symbol `{name}` was not found in linked objects")
+             }
 +            LinkError::ForceLoadNotArchive(path) => {
 +                write!(
 +                    f,
 +                    "{}: -force_load requires a path that is also present as an archive input",
 +                    path.display()
 +                )
 +            }
 +            LinkError::LibraryNotFound(name) => {
 +                write!(f, "unable to find library `{name}`")
 +            }
 +            LinkError::FrameworkNotFound(name) => {
 +                write!(f, "unable to find framework `{name}`")
 +            }
 +            LinkError::ThunkPlanningDidNotConverge => {
 +                write!(f, "thunk planning did not converge")
 +            }
 +            LinkError::WhyLive(msg) => write!(f, "{msg}"),
 +            LinkError::UnsupportedOption(msg) => write!(f, "{msg}"),
+         }
+     }
+ }
+     }
+ }
 +impl From<IcfError> for LinkError {
 +    fn from(value: IcfError) -> Self {
 +        LinkError::Icf(value)
 +    }
 +}
++
 +impl From<loh::LohError> for LinkError {
 +    fn from(value: loh::LohError) -> Self {
 +        LinkError::Loh(value)
 +    }
 +}
++
  /// The linker itself. Sprint 0 only validates that inputs exist; later sprints
  /// grow this into the full pipeline described in `.docs/overview.md`.
  pub struct Linker;
  impl Linker {
      pub fn run(opts: &LinkOptions) -> Result<(), LinkError> {
 -        if opts.inputs.is_empty() {
 +        Self::run_profiled(opts).map(|_| ())
 +    }
++
 +    pub fn run_profiled(opts: &LinkOptions) -> Result<LinkProfile, LinkError> {
 +        let overall_started = Instant::now();
 +        let mut phases = LinkPhaseTimings::default();
 +        if opts.relocatable {
 +            return Err(LinkError::UnsupportedOption(
 +                "`-r` relocatable output is not yet supported".into(),
 +            ));
 +        }
 +        if opts.bundle {
 +            return Err(LinkError::UnsupportedOption(
 +                "`-bundle` output is not yet supported".into(),
 +            ));
 +        }
 +        if opts.fixup_chains {
 +            return Err(LinkError::UnsupportedOption(
 +                "`-fixup_chains` is not yet supported".into(),
 +            ));
 +        }
 +        if opts.icf_mode == IcfMode::All {
 +            return Err(LinkError::UnsupportedOption(
 +                "`-icf=all` is not yet supported; use `-icf=safe` or `-icf=none`".into(),
 +            ));
 +        }
 +        if opts.inputs.is_empty() && opts.library_names.is_empty() && opts.frameworks.is_empty() {
              return Err(LinkError::NoInputs);
+         }
+             }
+         }
 +        if opts.strip_debug {
 +            crate::diag::warning(
 +                "`-S` requested, but afs-ld does not currently emit debug symbols",
 +            );
 +        }
 +        if opts.objc_force_load {
 +            crate::diag::warning(
 +                "`-ObjC` requested, but afs-ld does not yet scan Objective-C archive metadata; the flag currently has no effect",
 +            );
 +        }
 +        if opts.no_loh {
 +            crate::diag::warning(
 +                "`-no_loh` requested, but afs-ld currently matches Apple ld by omitting final-output LOH; the flag has no effect",
 +            );
 +        }
++
 +        let mut load_paths = opts.inputs.clone();
 +        let mut dylib_load_kinds = std::collections::HashMap::new();
 +        for name in &opts.library_names {
 +            let path = resolve_library_input(opts, name)?;
 +            dylib_load_kinds.insert(path.clone(), DylibLoadKind::Normal);
 +            load_paths.push(path);
 +        }
 +        for framework in &opts.frameworks {
 +            let path = resolve_framework_input(opts, &framework.name)?;
 +            dylib_load_kinds.insert(
 +                path.clone(),
 +                if framework.weak {
 +                    DylibLoadKind::Weak
 +                } else {
 +                    DylibLoadKind::Normal
 +                },
 +            );
 +            load_paths.push(path);
 +        }
++
          let mut inputs = Inputs::new();
 -        for (load_order, path) in opts.inputs.iter().enumerate() {
 +        let phase_started = Instant::now();
 +        for (load_order, path) in load_paths.iter().enumerate() {
 +            if opts.trace_inputs {
 +                eprintln!("afs-ld: loading {}", path.display());
 +            }
              register_input(&mut inputs, path, load_order)?;
+         }
 +        phases.input_parsing = phase_started.elapsed();
          let mut sym_table = SymbolTable::new();
 +        let phase_started = Instant::now();
          let seed_report = seed_all(&inputs, &mut sym_table)?;
          if seed_report.has_errors() {
              let mut msg = String::new();
              return Err(LinkError::DuplicateSymbols(msg));
+         }
 +        let mut force_report = DrainReport::default();
 +        if opts.all_load {
 +            force_load_all(&mut inputs, &mut sym_table, &mut force_report)?;
 +        }
 +        for archive_path in &opts.force_load_archives {
 +            let Some(archive_id) = find_archive_by_path(&inputs, archive_path) else {
 +                return Err(LinkError::ForceLoadNotArchive(archive_path.clone()));
 +            };
 +            force_load_archive(&mut inputs, &mut sym_table, archive_id, &mut force_report)?;
 +        }
 +        if opts.trace_inputs {
 +            for path in &force_report.loaded_paths {
 +                eprintln!("afs-ld: loading {}", path.display());
 +            }
 +        }
 +        if !force_report.duplicates.is_empty() {
 +            let mut msg = String::new();
 +            for err in &force_report.duplicates {
 +                msg.push_str(&format_duplicate_diagnostic(&sym_table, &inputs, err));
 +            }
 +            return Err(LinkError::DuplicateSymbols(msg));
 +        }
++
          let drain_report = drain_fetches(&mut inputs, &mut sym_table, seed_report.pending_fetches)?;
 +        if opts.trace_inputs {
 +            for path in &drain_report.loaded_paths {
 +                eprintln!("afs-ld: loading {}", path.display());
 +            }
 +        }
          if !drain_report.duplicates.is_empty() {
              let mut msg = String::new();
              for err in &drain_report.duplicates {
              return Err(LinkError::DuplicateSymbols(msg));
+         }
          let mut referrers = seed_report.referrers.clone();
 +        referrers.extend_from(&force_report.referrers);
          referrers.extend_from(&drain_report.referrers);
 -        let unresolved = classify_unresolved(&mut sym_table, UndefinedTreatment::Error);
 +        let unresolved = classify_unresolved(&mut sym_table, opts.undefined_treatment);
          if !unresolved.errors.is_empty() {
              return Err(LinkError::UndefinedSymbols(format_undefined_diagnostic(
                  &sym_table,
                  &unresolved.errors,
              )));
+         }
 +        if !unresolved.warnings.is_empty() {
 +            crate::diag::warning_verbatim(&format_undefined_warning_diagnostic(
 +                &sym_table,
 +                &inputs,
 +                &referrers,
 +                &unresolved.warnings,
 +            ));
 +        }
 +        phases.symbol_resolution = phase_started.elapsed();
          let mut atom_table = AtomTable::new();
          let mut objects = Vec::new();
 +        let phase_started = Instant::now();
          for idx in 0..inputs.objects.len() {
              let input_id = resolve::InputId(idx as u32);
              let obj = inputs.object_file(input_id)?;
              );
              objects.push((input_id, obj));
+         }
 +        phases.atomization = phase_started.elapsed();
          let layout_inputs: Vec<LayoutInput<'_>> = objects
              .iter()
                  continue;
+             }
              dylib_loads.push(DylibDependency {
 -                kind: DylibLoadKind::Normal,
 +                kind: dylib_load_kinds
 +                    .get(&dylib.path)
 +                    .copied()
 +                    .unwrap_or(DylibLoadKind::Normal),
                  install_name: dylib.load_install_name.clone(),
                  current_version: dylib.load_current_version,
                  compatibility_version: dylib.load_compatibility_version,
                  ordinal: dylib.ordinal,
              });
+         }
 -        let synthetic_plan = synth::SyntheticPlan::build(
 +        let phase_started = Instant::now();
 +        let parsed_relocs = macho::writer::build_parsed_reloc_cache(&layout_inputs)?;
 +        phases.input_parsing += phase_started.elapsed();
 +        let phase_started = Instant::now();
 +        let entry_symbol = find_entry_symbol_id(opts, &sym_table)?;
 +        let dead_strip = opts.dead_strip.then(|| {
 +            why_live::DeadStripAnalysis::build(
 +                opts,
 +                &layout_inputs,
 +                &atom_table,
 +                &sym_table,
 +                entry_symbol,
 +            )
 +        });
 +        let icf = (opts.icf_mode == IcfMode::Safe)
 +            .then(|| {
 +                icf::fold_safe(
 +                    &layout_inputs,
 +                    &mut atom_table,
 +                    &mut sym_table,
 +                    dead_strip.as_ref().map(|analysis| analysis.live_atoms()),
 +                )
 +            })
 +            .transpose()?;
 +        let kept_atoms = if let Some(icf) = &icf {
 +            Some(icf.kept_atoms())
 +        } else {
 +            dead_strip.as_ref().map(|analysis| analysis.live_atoms())
 +        };
 +        let synthetic_plan = synth::SyntheticPlan::build_filtered(
              &layout_inputs,
              &atom_table,
              &mut sym_table,
              &inputs.dylibs,
 +            kept_atoms,
          )?;
 -        let mut layout = Layout::build_with_synthetics(
 +        let icf_redirects = icf.as_ref().map(|plan| plan.redirects());
 +        let mut layout = Layout::build_with_synthetics_filtered(
              opts.kind,
              &layout_inputs,
              &atom_table,
 ,
              Some(&synthetic_plan),
 +            kept_atoms,
          );
 +        let mut thunk_plan = None;
 +        let mut thunk_converged = false;
 +        for _ in 0..THUNK_PLAN_MAX_ITERATIONS {
 +            let next_plan = reloc::arm64::plan_thunks(
 +                opts,
 +                &layout,
 +                &layout_inputs,
 +                &atom_table,
 +                &sym_table,
 +                Some(&synthetic_plan),
 +                icf_redirects,
 +            )?;
 +            if next_plan == thunk_plan {
 +                thunk_converged = true;
 +                break;
 +            }
 +            let extra_sections = next_plan
 +                .as_ref()
 +                .map_or_else(Vec::new, |plan| plan.output_sections());
 +            let split_after_atoms = next_plan
 +                .as_ref()
 +                .map_or_else(Vec::new, |plan| plan.split_after_atoms());
 +            layout = Layout::build_with_synthetics_and_extra_filtered(
 +                opts.kind,
 +                &layout_inputs,
 +                &atom_table,
 +                0,
 +                Some(&synthetic_plan),
 +                kept_atoms,
 +                ExtraLayoutSections {
 +                    extra_sections: &extra_sections,
 +                    split_after_atoms: &split_after_atoms,
 +                },
 +            );
 +            thunk_plan = next_plan;
 +        }
 +        if !thunk_converged {
 +            return Err(LinkError::ThunkPlanningDidNotConverge);
 +        }
 +        phases.layout = phase_started.elapsed();
          let linkedit_context = macho::writer::LinkEditContext {
              layout_inputs: &layout_inputs,
              atom_table: &atom_table,
              sym_table: &sym_table,
              synthetic_plan: &synthetic_plan,
 +            icf_redirects,
 +            parsed_relocs: &parsed_relocs,
          };
 +        let phase_started = Instant::now();
          let mut linkedit = None;
 +        let mut synth_linkedit_finalize = Duration::ZERO;
 +        let mut synth_linkedit_symbol_plan = Duration::ZERO;
 +        let mut synth_linkedit_symbol_plan_locals = Duration::ZERO;
 +        let mut synth_linkedit_symbol_plan_globals = Duration::ZERO;
 +        let mut synth_linkedit_symbol_plan_strtab = Duration::ZERO;
 +        let mut synth_linkedit_dyld_info = Duration::ZERO;
 +        let mut synth_linkedit_metadata_tables = Duration::ZERO;
 +        let mut synth_linkedit_code_signature = Duration::ZERO;
 +        let mut synth_unwind = Duration::ZERO;
          for _ in 0..4 {
 -            let (next_layout, next_linkedit) = macho::writer::finalize_layout_with_linkedit(
 -                &layout,
 -                opts.kind,
 -                opts,
 -                &dylib_loads,
 -                linkedit_context,
 -            )?;
 +            let phase_started = Instant::now();
 +            let (next_layout, next_linkedit, linkedit_timings) =
 +                macho::writer::finalize_layout_with_linkedit(
 +                    &layout,
 +                    opts.kind,
 +                    opts,
 +                    &dylib_loads,
 +                    linkedit_context,
 +                )?;
 +            synth_linkedit_finalize += phase_started.elapsed();
 +            synth_linkedit_symbol_plan += linkedit_timings.symbol_plan;
 +            synth_linkedit_symbol_plan_locals += linkedit_timings.symbol_plan_locals;
 +            synth_linkedit_symbol_plan_globals += linkedit_timings.symbol_plan_globals;
 +            synth_linkedit_symbol_plan_strtab += linkedit_timings.symbol_plan_strtab;
 +            synth_linkedit_dyld_info += linkedit_timings.dyld_info;
 +            synth_linkedit_metadata_tables += linkedit_timings.metadata_tables;
 +            synth_linkedit_code_signature += linkedit_timings.code_signature;
              layout = next_layout;
              linkedit = Some(next_linkedit);
 +            let phase_started = Instant::now();
              let changed = synth::unwind::synthesize(
                  &mut layout,
                  &layout_inputs,
                  &sym_table,
                  &synthetic_plan,
              )?;
 +            synth_unwind += phase_started.elapsed();
              if !changed {
                  break;
+             }
+         }
          let linkedit = linkedit.expect("finalize loop always runs at least once");
 +        phases.synth_linkedit_finalize = synth_linkedit_finalize;
 +        phases.synth_linkedit_symbol_plan = synth_linkedit_symbol_plan;
 +        phases.synth_linkedit_symbol_plan_locals = synth_linkedit_symbol_plan_locals;
 +        phases.synth_linkedit_symbol_plan_globals = synth_linkedit_symbol_plan_globals;
 +        phases.synth_linkedit_symbol_plan_strtab = synth_linkedit_symbol_plan_strtab;
 +        phases.synth_linkedit_dyld_info = synth_linkedit_dyld_info;
 +        phases.synth_linkedit_metadata_tables = synth_linkedit_metadata_tables;
 +        phases.synth_linkedit_code_signature = synth_linkedit_code_signature;
 +        phases.synth_unwind = synth_unwind;
 +        phases.synth_sections = phase_started.elapsed();
 +        let phase_started = Instant::now();
          reloc::arm64::apply_layout(
              &mut layout,
              &layout_inputs,
              &atom_table,
              &sym_table,
 -            Some(&synthetic_plan),
 -            &linkedit,
 +            reloc::arm64::ApplyLayoutPlan {
 +                synthetic_plan: Some(&synthetic_plan),
 +                thunk_plan: thunk_plan.as_ref(),
 +                linkedit: &linkedit,
 +                icf_redirects,
 +            },
          )?;
 +        phases.reloc_apply = phase_started.elapsed();
 +        let folded_symbols = icf
 +            .as_ref()
 +            .map(|plan| plan.folded_symbols(&atom_table, &sym_table, &layout_inputs))
 +            .unwrap_or_default();
 +        if let Some(report) = why_live::format_explanations(
 +            opts,
 +            &layout_inputs,
 +            &atom_table,
 +            &sym_table,
 +            entry_symbol,
 +            dead_strip.as_ref(),
 +            &folded_symbols,
 +        )
 +        .map_err(LinkError::WhyLive)?
 +        {
 +            print!("{report}");
 +        }
++
 +        let phase_started = Instant::now();
          let mut image = Vec::new();
          let entry_point = resolve_entry_point(opts, &sym_table)?;
          macho::writer::write_finalized_with_linkedit(
          )?;
          let output = default_output_path(opts);
          fs::write(&output, image)?;
 +        if let Some(map_path) = &opts.map {
 +            let dead_stripped = dead_strip
 +                .as_ref()
 +                .map(|analysis| {
 +                    analysis.dead_stripped_symbols(&atom_table, &sym_table, &layout_inputs)
 +                })
 +                .unwrap_or_default();
 +            link_map::write_link_map(
 +                map_path,
 +                opts,
 +                &layout,
 +                &layout_inputs,
 +                &linkedit,
 +                &folded_symbols,
 +                &dead_stripped,
 +            )?;
 +        }
          if opts.kind == OutputKind::Executable {
              let mut perms = fs::metadata(&output)?.permissions();
              let mode = perms.mode();
              perms.set_mode(mode | ((mode & 0o444) >> 2));
              fs::set_permissions(&output, perms)?;
+         }
 -        Ok(())
 +        phases.write_output = phase_started.elapsed();
 +        Ok(LinkProfile {
 +            output,
 +            phases,
 +            total_wall: overall_started.elapsed(),
 +        })
+     }
+ }
 +fn resolve_library_input(opts: &LinkOptions, name: &str) -> Result<PathBuf, LinkError> {
 +    let mut search_dirs = Vec::new();
 +    for dir in &opts.search_paths {
 +        search_dirs.push(dir.clone());
 +        if let Some(root) = &opts.syslibroot {
 +            if let Ok(stripped) = dir.strip_prefix("/") {
 +                search_dirs.push(root.join(stripped));
 +            }
 +        }
 +    }
 +    if let Some(root) = &opts.syslibroot {
 +        search_dirs.push(root.join("usr/lib"));
 +    } else {
 +        search_dirs.push(PathBuf::from("/usr/lib"));
 +    }
++
 +    let candidates = [
 +        format!("lib{name}.tbd"),
 +        format!("lib{name}.dylib"),
 +        format!("lib{name}.a"),
 +    ];
 +    for dir in search_dirs {
 +        for candidate in &candidates {
 +            let path = dir.join(candidate);
 +            if path.is_file() {
 +                return Ok(path);
 +            }
 +        }
 +    }
 +    Err(LinkError::LibraryNotFound(name.to_string()))
 +}
++
 +fn resolve_framework_input(opts: &LinkOptions, name: &str) -> Result<PathBuf, LinkError> {
 +    let mut roots = Vec::new();
 +    if let Some(root) = &opts.syslibroot {
 +        roots.push(root.join("System/Library/Frameworks"));
 +        roots.push(root.join("Library/Frameworks"));
 +    } else {
 +        roots.push(PathBuf::from("/System/Library/Frameworks"));
 +        roots.push(PathBuf::from("/Library/Frameworks"));
 +    }
++
 +    for root in roots {
 +        let framework_dir = root.join(format!("{name}.framework"));
 +        for candidate in [
 +            framework_dir.join(format!("{name}.tbd")),
 +            framework_dir.join(name),
 +        ] {
 +            if candidate.is_file() {
 +                return Ok(candidate);
 +            }
 +        }
 +    }
++
 +    Err(LinkError::FrameworkNotFound(name.to_string()))
 +}
++
  fn default_output_path(opts: &LinkOptions) -> PathBuf {
      opts.output
          .clone()
      opts: &LinkOptions,
      sym_table: &SymbolTable,
  ) -> Result<Option<macho::writer::EntryPoint>, LinkError> {
 +    let Some(symbol_id) = find_entry_symbol_id(opts, sym_table)? else {
 +        return Ok(None);
 +    };
 +    let Symbol::Defined { atom, value, .. } = sym_table.get(symbol_id) else {
 +        let name = sym_table.interner.resolve(sym_table.get(symbol_id).name());
 +        return Err(LinkError::EntrySymbolNotFound(name.to_string()));
 +    };
 +    Ok(Some(macho::writer::EntryPoint {
 +        atom: *atom,
 +        atom_value: *value,
 +    }))
 +}
++
 +fn find_entry_symbol_id(
 +    opts: &LinkOptions,
 +    sym_table: &SymbolTable,
 +) -> Result<Option<resolve::SymbolId>, LinkError> {
      let name = if let Some(name) = &opts.entry {
          name.as_str()
      } else if opts.kind == OutputKind::Executable {
      else {
          return Err(LinkError::EntrySymbolNotFound(name.to_string()));
      };
 -    let Symbol::Defined { atom, value, .. } = sym_table.get(symbol_id) else {
 -        return Err(LinkError::EntrySymbolNotFound(name.to_string()));
 -    };
 -    Ok(Some(macho::writer::EntryPoint {
 -        atom: *atom,
 -        atom_value: *value,
 -    }))
 +    Ok(Some(symbol_id))
+ }
  fn symbol_defined(sym_table: &SymbolTable, name: &str) -> bool {

src/link_map.rsadded

94 lines changed — click to load

 +use std::fmt::Write as _;
 +use std::io;
 +use std::path::Path;
++
 +use crate::icf::FoldedSymbol;
 +use crate::layout::{Layout, LayoutInput};
 +use crate::macho::writer::LinkEditPlan;
 +use crate::why_live::DeadStrippedSymbol;
 +use crate::LinkOptions;
++
 +pub fn write_link_map(
 +    path: &Path,
 +    opts: &LinkOptions,
 +    layout: &Layout,
 +    layout_inputs: &[LayoutInput<'_>],
 +    linkedit: &LinkEditPlan,
 +    folded_symbols: &[FoldedSymbol],
 +    dead_stripped: &[DeadStrippedSymbol],
 +) -> io::Result<()> {
 +    let output_path = opts.output.as_deref().unwrap_or_else(|| Path::new("a.out"));
 +    let mut out = String::new();
++
 +    writeln!(&mut out, "# Path: {}", output_path.display()).unwrap();
 +    writeln!(&mut out, "# Arch: arm64").unwrap();
 +    writeln!(&mut out, "# Object files:").unwrap();
 +    writeln!(&mut out, "[  0] linker synthesized").unwrap();
 +    for (idx, input) in layout_inputs.iter().enumerate() {
 +        writeln!(&mut out, "[{:>3}] {}", idx + 1, input.object.path.display()).unwrap();
 +    }
++
 +    writeln!(&mut out, "\n# Sections:").unwrap();
 +    writeln!(
 +        &mut out,
 +        "# Address          Size         Segment   Section"
 +    )
 +    .unwrap();
 +    for section in &layout.sections {
 +        writeln!(
 +            &mut out,
 +            "{:#018x} {:#010x}   {:<8}  {}",
 +            section.addr, section.size, section.segment, section.name
 +        )
 +        .unwrap();
 +    }
++
 +    writeln!(&mut out, "\n# Symbols:").unwrap();
 +    writeln!(&mut out, "# Address          Size         File    Name").unwrap();
 +    let mut symbols = linkedit.map_symbols.clone();
 +    symbols.sort_by(|lhs, rhs| {
 +        lhs.addr
 +            .cmp(&rhs.addr)
 +            .then_with(|| lhs.name.cmp(&rhs.name))
 +    });
 +    for symbol in &symbols {
 +        let file = if symbol.file_index == 0 {
 +            "linker".to_string()
 +        } else {
 +            format!("[{:>3}]", symbol.file_index)
 +        };
 +        writeln!(
 +            &mut out,
 +            "{:#018x} {:#010x}   {:<7} {}",
 +            symbol.addr, symbol.size, file, symbol.name
 +        )
 +        .unwrap();
 +    }
++
 +    writeln!(&mut out, "\n# Folded symbols:").unwrap();
 +    for symbol in folded_symbols {
 +        let file = if symbol.file_index == 0 {
 +            "linker".to_string()
 +        } else {
 +            format!("[{:>3}]", symbol.file_index)
 +        };
 +        writeln!(
 +            &mut out,
 +            "{:<7} {} folded to {}",
 +            file, symbol.name, symbol.winner
 +        )
 +        .unwrap();
 +    }
++
 +    writeln!(&mut out, "\n# Dead stripped:").unwrap();
 +    for symbol in dead_stripped {
 +        let file = if symbol.file_index == 0 {
 +            "linker".to_string()
 +        } else {
 +            format!("[{:>3}]", symbol.file_index)
 +        };
 +        writeln!(&mut out, "{:<7} {}", file, symbol.name).unwrap();
 +    }
++
 +    std::fs::write(path, out)
 +}

src/loh.rsadded

552 lines changed — click to load

 +//! ARM64 Linker Optimization Hints (LOH).
 +//!
 +//! `LC_LINKER_OPTIMIZATION_HINT` stores a ULEB128 stream of `(kind, argc,
 +//! args...)` records. The args are file offsets of the participating
 +//! instructions.
++
 +use std::collections::HashSet;
 +use std::fmt;
++
 +use crate::layout::Layout;
 +use crate::leb::{read_uleb, write_uleb};
 +use crate::macho::reader::ReadError;
 +use crate::macho::writer::LinkEditPlan;
++
 +pub const LOH_ARM64_ADRP_LDR: u32 = 2;
 +pub const LOH_ARM64_ADRP_LDR_GOT_LDR: u32 = 4;
 +pub const LOH_ARM64_ADRP_ADD: u32 = 7;
 +pub const LOH_ARM64_ADRP_LDR_GOT: u32 = 8;
 +const NOP: u32 = 0xd503_201f;
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct LohEntry {
 +    pub kind: u32,
 +    pub args: Vec<u32>,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct LohError(String);
++
 +impl fmt::Display for LohError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        write!(f, "LOH relaxation error: {}", self.0)
 +    }
 +}
++
 +impl std::error::Error for LohError {}
++
 +impl From<ReadError> for LohError {
 +    fn from(value: ReadError) -> Self {
 +        Self(value.to_string())
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +struct LocatedWord {
 +    section_idx: usize,
 +    atom_idx: usize,
 +    word_off: usize,
 +    addr: u64,
 +    insn: u32,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum LiteralLoadKind {
 +    W,
 +    X,
 +    S,
 +    D,
 +    Q,
 +}
++
 +pub fn parse_loh_blob(bytes: &[u8]) -> Result<Vec<LohEntry>, ReadError> {
 +    let mut out = Vec::new();
 +    let mut cursor = 0usize;
 +    while cursor < bytes.len() {
 +        if bytes[cursor..].iter().all(|&byte| byte == 0) {
 +            break;
 +        }
 +        let at_offset = cursor as u32;
 +        let (kind, used) = read_uleb(&bytes[cursor..])?;
 +        cursor += used;
 +        let (argc, used) = read_uleb(&bytes[cursor..])?;
 +        cursor += used;
 +        let kind = u32::try_from(kind).map_err(|_| ReadError::BadRelocation {
 +            at_offset,
 +            reason: "LOH kind overflows u32",
 +        })?;
 +        let argc = usize::try_from(argc).map_err(|_| ReadError::BadRelocation {
 +            at_offset,
 +            reason: "LOH argcount overflows usize",
 +        })?;
 +        let mut args = Vec::with_capacity(argc);
 +        for _ in 0..argc {
 +            let (arg, used) = read_uleb(&bytes[cursor..])?;
 +            cursor += used;
 +            args.push(u32::try_from(arg).map_err(|_| ReadError::BadRelocation {
 +                at_offset,
 +                reason: "LOH arg overflows u32",
 +            })?);
 +        }
 +        out.push(LohEntry { kind, args });
 +    }
 +    Ok(out)
 +}
++
 +pub fn write_loh_blob(entries: &[LohEntry]) -> Vec<u8> {
 +    let mut out = Vec::new();
 +    for entry in entries {
 +        write_uleb(entry.kind as u64, &mut out);
 +        write_uleb(entry.args.len() as u64, &mut out);
 +        for &arg in &entry.args {
 +            write_uleb(arg as u64, &mut out);
 +        }
 +    }
 +    out
 +}
++
 +pub fn relax_layout(
 +    layout: &mut Layout,
 +    linkedit: &LinkEditPlan,
 +    enabled: bool,
 +) -> Result<(), LohError> {
 +    if !enabled || linkedit.loh.is_none() || linkedit.loh_bytes().is_empty() {
 +        return Ok(());
 +    }
++
 +    let mut entries = parse_loh_blob(linkedit.loh_bytes())?;
 +    entries.sort_by(|lhs, rhs| {
 +        rhs.args
 +            .len()
 +            .cmp(&lhs.args.len())
 +            .then_with(|| lhs.args.first().cmp(&rhs.args.first()))
 +            .then_with(|| lhs.kind.cmp(&rhs.kind))
 +    });
 +    let mut rewritten = HashSet::new();
 +    for entry in entries {
 +        match entry.kind {
 +            LOH_ARM64_ADRP_LDR => relax_adrp_ldr(layout, &entry, &mut rewritten)?,
 +            LOH_ARM64_ADRP_LDR_GOT_LDR => relax_adrp_ldr_got_ldr(layout, &entry, &mut rewritten)?,
 +            LOH_ARM64_ADRP_ADD => relax_adrp_add(layout, &entry, &mut rewritten)?,
 +            LOH_ARM64_ADRP_LDR_GOT => relax_adrp_ldr_got(layout, &entry, &mut rewritten)?,
 +            _ => {}
 +        }
 +    }
 +    Ok(())
 +}
++
 +fn relax_adrp_add(
 +    layout: &mut Layout,
 +    entry: &LohEntry,
 +    rewritten: &mut HashSet<u64>,
 +) -> Result<(), LohError> {
 +    if entry.args.len() != 2 {
 +        return Ok(());
 +    }
 +    let adrp_off = entry.args[0] as u64;
 +    let add_off = entry.args[1] as u64;
 +    if !claim_offsets(rewritten, &[adrp_off, add_off]) {
 +        return Ok(());
 +    }
 +    let adrp = locate_word(layout, adrp_off)?;
 +    let add = locate_word(layout, add_off)?;
 +    let Some(target) = decode_adrp_add_target(adrp.insn, add.insn, adrp.addr) else {
 +        return Ok(());
 +    };
 +    let dest = (add.insn & 0x1f) as u8;
 +    let Some(adr) = encode_adr(target, adrp.addr, dest) else {
 +        return Ok(());
 +    };
 +    write_word(layout, adrp, adr)?;
 +    write_word(layout, add, NOP)?;
 +    Ok(())
 +}
++
 +fn relax_adrp_ldr(
 +    layout: &mut Layout,
 +    entry: &LohEntry,
 +    rewritten: &mut HashSet<u64>,
 +) -> Result<(), LohError> {
 +    if entry.args.len() != 2 {
 +        return Ok(());
 +    }
 +    let adrp_off = entry.args[0] as u64;
 +    let ldr_off = entry.args[1] as u64;
 +    if !claim_offsets(rewritten, &[adrp_off, ldr_off]) {
 +        return Ok(());
 +    }
 +    let adrp = locate_word(layout, adrp_off)?;
 +    let ldr = locate_word(layout, ldr_off)?;
 +    let Some(target) = decode_adrp_ldr_target(adrp.insn, ldr.insn, adrp.addr) else {
 +        return Ok(());
 +    };
 +    let Some(literal) = encode_ldr_literal(ldr.insn, target, ldr.addr) else {
 +        return Ok(());
 +    };
 +    write_word(layout, adrp, NOP)?;
 +    write_word(layout, ldr, literal)?;
 +    Ok(())
 +}
++
 +fn relax_adrp_ldr_got(
 +    layout: &mut Layout,
 +    entry: &LohEntry,
 +    rewritten: &mut HashSet<u64>,
 +) -> Result<(), LohError> {
 +    if entry.args.len() != 2 {
 +        return Ok(());
 +    }
 +    let adrp_off = entry.args[0] as u64;
 +    let ldr_off = entry.args[1] as u64;
 +    if !claim_offsets(rewritten, &[adrp_off, ldr_off]) {
 +        return Ok(());
 +    }
 +    let adrp = locate_word(layout, adrp_off)?;
 +    let ldr = locate_word(layout, ldr_off)?;
 +    let Some(got_slot_addr) = decode_adrp_ldr_target(adrp.insn, ldr.insn, adrp.addr) else {
 +        return Ok(());
 +    };
 +    if pageoff_load_kind(ldr.insn) != Some(LiteralLoadKind::X) {
 +        return Ok(());
 +    }
 +    let Some(local_target) = read_u64_at_addr(layout, got_slot_addr) else {
 +        return Ok(());
 +    };
 +    if !points_into_output(layout, local_target) {
 +        return Ok(());
 +    }
 +    let dest = (ldr.insn & 0x1f) as u8;
 +    let Some(adr) = encode_adr(local_target, adrp.addr, dest) else {
 +        return Ok(());
 +    };
 +    write_word(layout, adrp, adr)?;
 +    write_word(layout, ldr, NOP)?;
 +    Ok(())
 +}
++
 +fn relax_adrp_ldr_got_ldr(
 +    layout: &mut Layout,
 +    entry: &LohEntry,
 +    rewritten: &mut HashSet<u64>,
 +) -> Result<(), LohError> {
 +    if entry.args.len() != 3 {
 +        return Ok(());
 +    }
 +    let adrp_off = entry.args[0] as u64;
 +    let got_ldr_off = entry.args[1] as u64;
 +    let final_ldr_off = entry.args[2] as u64;
 +    if !claim_offsets(rewritten, &[adrp_off, got_ldr_off, final_ldr_off]) {
 +        return Ok(());
 +    }
 +    let adrp = locate_word(layout, adrp_off)?;
 +    let got_ldr = locate_word(layout, got_ldr_off)?;
 +    let final_ldr = locate_word(layout, final_ldr_off)?;
 +    let Some(got_slot_addr) = decode_adrp_ldr_target(adrp.insn, got_ldr.insn, adrp.addr) else {
 +        return Ok(());
 +    };
 +    if pageoff_load_kind(got_ldr.insn) != Some(LiteralLoadKind::X) {
 +        return Ok(());
 +    }
 +    let got_dest = (got_ldr.insn & 0x1f) as u8;
 +    if load_base_reg(final_ldr.insn) != Some(got_dest) {
 +        return Ok(());
 +    }
 +    let Some(local_target) = read_u64_at_addr(layout, got_slot_addr) else {
 +        return Ok(());
 +    };
 +    if !points_into_output(layout, local_target) {
 +        return Ok(());
 +    }
 +    let Some(adr) = encode_adr(local_target, adrp.addr, got_dest) else {
 +        return Ok(());
 +    };
 +    write_word(layout, adrp, adr)?;
 +    write_word(layout, got_ldr, NOP)?;
 +    Ok(())
 +}
++
 +fn claim_offsets(rewritten: &mut HashSet<u64>, offsets: &[u64]) -> bool {
 +    if offsets.iter().any(|offset| rewritten.contains(offset)) {
 +        return false;
 +    }
 +    rewritten.extend(offsets.iter().copied());
 +    true
 +}
++
 +fn locate_word(layout: &Layout, file_offset: u64) -> Result<LocatedWord, LohError> {
 +    for (section_idx, section) in layout.sections.iter().enumerate() {
 +        for (atom_idx, atom) in section.atoms.iter().enumerate() {
 +            let start = section.file_off + atom.offset;
 +            let end = start + atom.data.len() as u64;
 +            if !(start <= file_offset && file_offset + 4 <= end) {
 +                continue;
 +            }
 +            let word_off = (file_offset - start) as usize;
 +            let bytes = atom.data.get(word_off..word_off + 4).ok_or_else(|| {
 +                LohError(format!(
 +                    "instruction read OOB at file offset 0x{file_offset:x}"
 +                ))
 +            })?;
 +            return Ok(LocatedWord {
 +                section_idx,
 +                atom_idx,
 +                word_off,
 +                addr: section.addr + atom.offset + word_off as u64,
 +                insn: u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
 +            });
 +        }
 +    }
 +    Err(LohError(format!(
 +        "LOH instruction offset 0x{file_offset:x} did not resolve to an output atom"
 +    )))
 +}
++
 +fn write_word(layout: &mut Layout, word: LocatedWord, insn: u32) -> Result<(), LohError> {
 +    let atom = &mut layout.sections[word.section_idx].atoms[word.atom_idx];
 +    let bytes = atom
 +        .data
 +        .get_mut(word.word_off..word.word_off + 4)
 +        .ok_or_else(|| {
 +            LohError(format!(
 +                "instruction write OOB at section {} atom {} word {}",
 +                word.section_idx, word.atom_idx, word.word_off
 +            ))
 +        })?;
 +    bytes.copy_from_slice(&insn.to_le_bytes());
 +    Ok(())
 +}
++
 +fn decode_adrp_add_target(adrp: u32, add: u32, place: u64) -> Option<u64> {
 +    if !is_adrp(adrp) || !is_add_imm_64(add) {
 +        return None;
 +    }
 +    let rd = (adrp & 0x1f) as u8;
 +    let add_rd = (add & 0x1f) as u8;
 +    let add_rn = ((add >> 5) & 0x1f) as u8;
 +    if rd == 31 || add_rd != rd || add_rn != rd {
 +        return None;
 +    }
 +    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 +    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 +    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 +    let adrp_base = ((place as i64) & !0xfff) + (adrp_pages << 12);
 +    let low = ((add >> 10) & 0xfff) as u64;
 +    Some((adrp_base as u64) + low)
 +}
++
 +fn decode_adrp_ldr_target(adrp: u32, ldr: u32, place: u64) -> Option<u64> {
 +    let _kind = pageoff_load_kind(ldr)?;
 +    let base = ((ldr >> 5) & 0x1f) as u8;
 +    let adrp_reg = (adrp & 0x1f) as u8;
 +    if adrp_reg == 31 || base != adrp_reg {
 +        return None;
 +    }
 +    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 +    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 +    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 +    let adrp_base = ((place as i64) & !0xfff) + (adrp_pages << 12);
 +    let shift = pageoff_shift(ldr);
 +    let low = (((ldr >> 10) & 0xfff) as u64) << shift;
 +    Some((adrp_base as u64) + low)
 +}
++
 +fn encode_adr(target: u64, place: u64, reg: u8) -> Option<u32> {
 +    if reg == 31 {
 +        return None;
 +    }
 +    let delta = (target as i64).wrapping_sub(place as i64);
 +    if !fits_signed(delta, 21) {
 +        return None;
 +    }
 +    let encoded = (delta as u32) & 0x1f_ffff;
 +    let immlo = encoded & 0x3;
 +    let immhi = (encoded >> 2) & 0x7ffff;
 +    Some(0x1000_0000 | (immlo << 29) | (immhi << 5) | reg as u32)
 +}
++
 +fn encode_ldr_literal(insn: u32, target: u64, place: u64) -> Option<u32> {
 +    let kind = pageoff_load_kind(insn)?;
 +    let delta = (target as i64).wrapping_sub(place as i64);
 +    if delta & 0b11 != 0 {
 +        return None;
 +    }
 +    let imm = delta >> 2;
 +    if !fits_signed(imm, 19) {
 +        return None;
 +    }
 +    let encoded = (imm as u32) & 0x7ffff;
 +    let rt = insn & 0x1f;
 +    let base = match kind {
 +        LiteralLoadKind::W => 0x1800_0000,
 +        LiteralLoadKind::X => 0x5800_0000,
 +        LiteralLoadKind::S => 0x1c00_0000,
 +        LiteralLoadKind::D => 0x5c00_0000,
 +        LiteralLoadKind::Q => 0x9c00_0000,
 +    };
 +    Some(base | (encoded << 5) | rt)
 +}
++
 +fn is_adrp(insn: u32) -> bool {
 +    (insn & 0x9f00_0000) == 0x9000_0000
 +}
++
 +fn is_add_imm_64(insn: u32) -> bool {
 +    (insn & 0xffc0_0000) == 0x9100_0000
 +}
++
 +fn pageoff_load_kind(insn: u32) -> Option<LiteralLoadKind> {
 +    match insn & 0xffc0_0000 {
 +        0xb940_0000 => Some(LiteralLoadKind::W),
 +        0xf940_0000 => Some(LiteralLoadKind::X),
 +        0xbd40_0000 => Some(LiteralLoadKind::S),
 +        0xfd40_0000 => Some(LiteralLoadKind::D),
 +        0x3dc0_0000 => Some(LiteralLoadKind::Q),
 +        _ => None,
 +    }
 +}
++
 +fn load_base_reg(insn: u32) -> Option<u8> {
 +    match insn & 0xffc0_0000 {
 +        0xb940_0000 | 0xf940_0000 | 0xbd40_0000 | 0xfd40_0000 | 0x3dc0_0000 | 0x7940_0000
 +        | 0x3940_0000 => Some(((insn >> 5) & 0x1f) as u8),
 +        _ => None,
 +    }
 +}
++
 +fn pageoff_shift(insn: u32) -> u64 {
 +    if is_simd_fp_pageoff(insn) {
 +        let size = ((insn >> 30) & 0b11) as u64;
 +        let opc = ((insn >> 22) & 0b11) as u64;
 +        if size == 0 && (opc & 0b10) != 0 {
 +            4
 +        } else {
 +            size
 +        }
 +    } else {
 +        ((insn >> 30) & 0b11) as u64
 +    }
 +}
++
 +fn is_simd_fp_pageoff(insn: u32) -> bool {
 +    ((insn >> 24) & 0b111) == 0b101
 +}
++
 +fn points_into_output(layout: &Layout, addr: u64) -> bool {
 +    layout
 +        .sections
 +        .iter()
 +        .any(|section| section.addr <= addr && addr < section.addr + section.size)
 +}
++
 +fn read_u64_at_addr(layout: &Layout, addr: u64) -> Option<u64> {
 +    let bytes = read_bytes_at_addr(layout, addr, 8)?;
 +    Some(u64::from_le_bytes(bytes.try_into().ok()?))
 +}
++
 +fn read_bytes_at_addr(layout: &Layout, addr: u64, len: usize) -> Option<Vec<u8>> {
 +    for section in &layout.sections {
 +        for atom in &section.atoms {
 +            let start = section.addr + atom.offset;
 +            let end = start + atom.data.len() as u64;
 +            if start <= addr && addr + len as u64 <= end {
 +                let word_off = (addr - start) as usize;
 +                return Some(atom.data.get(word_off..word_off + len)?.to_vec());
 +            }
 +        }
 +        if !section.synthetic_data.is_empty() {
 +            let start = section.addr + section.synthetic_offset;
 +            let end = start + section.synthetic_data.len() as u64;
 +            if start <= addr && addr + len as u64 <= end {
 +                let word_off = (addr - start) as usize;
 +                return Some(
 +                    section
 +                        .synthetic_data
 +                        .get(word_off..word_off + len)?
 +                        .to_vec(),
 +                );
 +            }
 +        }
 +    }
 +    None
 +}
++
 +fn fits_signed(value: i64, bits: u32) -> bool {
 +    let min = -(1i64 << (bits - 1));
 +    let max = (1i64 << (bits - 1)) - 1;
 +    (min..=max).contains(&value)
 +}
++
 +fn sign_extend_21(value: i64) -> i64 {
 +    if value & (1 << 20) != 0 {
 +        value | !0x1f_ffff
 +    } else {
 +        value
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn loh_blob_round_trips() {
 +        let entries = vec![
 +            LohEntry {
 +                kind: LOH_ARM64_ADRP_ADD,
 +                args: vec![0, 4],
 +            },
 +            LohEntry {
 +                kind: LOH_ARM64_ADRP_LDR_GOT_LDR,
 +                args: vec![8, 12, 16],
 +            },
 +        ];
 +        let blob = write_loh_blob(&entries);
 +        assert_eq!(parse_loh_blob(&blob).unwrap(), entries);
 +    }
++
 +    #[test]
 +    fn loh_blob_ignores_trailing_zero_padding() {
 +        let mut blob = write_loh_blob(&[LohEntry {
 +            kind: LOH_ARM64_ADRP_ADD,
 +            args: vec![0, 4],
 +        }]);
 +        while !blob.len().is_multiple_of(8) {
 +            blob.push(0);
 +        }
 +        assert_eq!(
 +            parse_loh_blob(&blob).unwrap(),
 +            vec![LohEntry {
 +                kind: LOH_ARM64_ADRP_ADD,
 +                args: vec![0, 4],
 +            }]
 +        );
 +    }
++
 +    #[test]
 +    fn encode_adr_round_trips_small_delta() {
 +        let place = 0x1_0000_1000;
 +        let target = place + 0x48;
 +        let adr = encode_adr(target, place, 9).unwrap();
 +        assert_eq!(adr & 0x1f, 9);
 +        let immlo = ((adr >> 29) & 0x3) as i64;
 +        let immhi = ((adr >> 5) & 0x7ffff) as i64;
 +        let delta = sign_extend_21((immhi << 2) | immlo);
 +        assert_eq!(place.wrapping_add_signed(delta), target);
 +    }
++
 +    #[test]
 +    fn encode_ldr_literal_round_trips_x_load() {
 +        let place = 0x1_0000_2004;
 +        let target = place + 0x1fc;
 +        let insn = 0xf940_0005u32;
 +        let literal = encode_ldr_literal(insn, target, place).unwrap();
 +        assert_eq!(literal & 0x1f, 5);
 +        let imm = ((literal >> 5) & 0x7ffff) as i64;
 +        let delta = if imm & (1 << 18) != 0 {
 +            (imm | !0x7ffff) << 2
 +        } else {
 +            imm << 2
 +        };
 +        assert_eq!(place.wrapping_add_signed(delta), target);
 +    }
 +}

src/macho/dylib.rsmodified

15 lines changed — click to load


             _ => None,
         }
     }
+
+    pub fn load_cmd(self) -> u32 {
+        match self {
+            DylibLoadKind::Normal => LC_LOAD_DYLIB,
+            DylibLoadKind::Weak => LC_LOAD_WEAK_DYLIB,
+            DylibLoadKind::Reexport => LC_REEXPORT_DYLIB,
+            DylibLoadKind::Upward => LC_LOAD_UPWARD_DYLIB,
+        }
+    }
 }
 
 /// One dylib this file depends on. Ordinals match the two-level namespace

src/macho/writer.rsmodified

1434 lines changed — click to load

  use std::collections::HashMap;
  use std::fmt;
 +use std::fs;
  use std::path::PathBuf;
 +use std::time::Duration;
  use crate::atom::AtomTable;
  use crate::input::{DataInCodeEntry, ObjectFile};
  use crate::macho::exports::{ExportEntry, ExportKind};
  use crate::macho::reader::{
      write_commands, write_header, BuildTool, BuildVersionCmd, DyldInfoCmd, DylibCmd, DysymtabCmd,
 -    LinkEditDataCmd, LoadCommand, MachHeader64, Section64Header, Segment64, SymtabCmd, HEADER_SIZE,
 +    LinkEditDataCmd, LoadCommand, MachHeader64, RpathCmd, Section64Header, Segment64, SymtabCmd,
 +    HEADER_SIZE,
  };
  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind, RelocLength};
  use crate::resolve::InputId;
      pub atom_table: &'a AtomTable,
      pub sym_table: &'a SymbolTable,
      pub synthetic_plan: &'a SyntheticPlan,
 +    pub icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +    pub parsed_relocs: &'a ParsedRelocCache,
 +}
++
 +pub type ParsedRelocCache = HashMap<(InputId, u8), Vec<Reloc>>;
++
 +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 +pub struct LinkEditBuildTimings {
 +    pub symbol_plan: Duration,
 +    pub symbol_plan_locals: Duration,
 +    pub symbol_plan_globals: Duration,
 +    pub symbol_plan_strtab: Duration,
 +    pub dyld_info: Duration,
 +    pub metadata_tables: Duration,
 +    pub code_signature: Duration,
 +}
++
 +impl std::ops::AddAssign for LinkEditBuildTimings {
 +    fn add_assign(&mut self, rhs: Self) {
 +        self.symbol_plan += rhs.symbol_plan;
 +        self.symbol_plan_locals += rhs.symbol_plan_locals;
 +        self.symbol_plan_globals += rhs.symbol_plan_globals;
 +        self.symbol_plan_strtab += rhs.symbol_plan_strtab;
 +        self.dyld_info += rhs.dyld_info;
 +        self.metadata_tables += rhs.metadata_tables;
 +        self.code_signature += rhs.code_signature;
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct LinkMapSymbol {
 +    pub name: String,
 +    pub addr: u64,
 +    pub size: u64,
 +    pub file_index: usize,
+ }
  #[derive(Debug)]
      ImportSymbolMissing(SymbolId),
      ImportSymbolWrongKind(SymbolId),
      MalformedRelocations(PathBuf, u8, String),
 +    MalformedLoh(PathBuf, String),
      MalformedDataInCode(PathBuf, String),
 +    SymbolListRead(PathBuf, String),
+ }
  impl fmt::Display for WriteError {
                  path.display(),
                  section
              ),
 +            WriteError::MalformedLoh(path, detail) => {
 +                write!(
 +                    f,
 +                    "failed to remap LC_LINKER_OPTIMIZATION_HINT in {}: {detail}",
 +                    path.display()
 +                )
 +            }
              WriteError::MalformedDataInCode(path, detail) => {
                  write!(
                      f,
                      path.display()
+                 )
+             }
 +            WriteError::SymbolListRead(path, detail) => {
 +                write!(
 +                    f,
 +                    "{}: unable to read symbol list: {detail}",
 +                    path.display()
 +                )
 +            }
+         }
+     }
+ }
      opts: &LinkOptions,
      dylibs: &[DylibDependency],
      context: LinkEditContext<'_>,
 -) -> Result<(Layout, LinkEditPlan), WriteError> {
 +) -> Result<(Layout, LinkEditPlan, LinkEditBuildTimings), WriteError> {
      finalize_with_linkedit(layout, kind, opts, dylibs, Some(LinkEditInputs(context)))
+ }
 +pub fn build_parsed_reloc_cache(
 +    inputs: &[LayoutInput<'_>],
 +) -> Result<ParsedRelocCache, WriteError> {
 +    let mut cache = HashMap::new();
 +    for input in inputs {
 +        for (sect_idx, section) in input.object.sections.iter().enumerate() {
 +            if section.raw_relocs.is_empty() {
 +                continue;
 +            }
 +            let section_idx = (sect_idx + 1) as u8;
 +            let raws = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc).map_err(|err| {
 +                WriteError::MalformedRelocations(
 +                    input.object.path.clone(),
 +                    section_idx,
 +                    err.to_string(),
 +                )
 +            })?;
 +            let relocs = parse_relocs(&raws).map_err(|err| {
 +                WriteError::MalformedRelocations(
 +                    input.object.path.clone(),
 +                    section_idx,
 +                    err.to_string(),
 +                )
 +            })?;
 +            cache.insert((input.id, section_idx), relocs);
 +        }
 +    }
 +    Ok(cache)
 +}
++
  fn finalize_with_linkedit(
      layout: &Layout,
      kind: OutputKind,
      opts: &LinkOptions,
      dylibs: &[DylibDependency],
      inputs: Option<LinkEditInputs<'_>>,
 -) -> Result<(Layout, LinkEditPlan), WriteError> {
 +) -> Result<(Layout, LinkEditPlan, LinkEditBuildTimings), WriteError> {
      let mut layout = layout.clone();
 -    let mut linkedit = build_linkedit_plan(&layout, kind, opts, inputs)?;
 +    let (mut linkedit, mut timings) = build_linkedit_plan_profiled(&layout, kind, opts, inputs)?;
      apply_indirect_starts(&mut layout, &linkedit);
      let header_size = estimate_header_size(&layout, kind, opts, dylibs, &linkedit);
      layout.relayout(header_size);
 -    linkedit = build_linkedit_plan(&layout, kind, opts, inputs)?;
 -    apply_indirect_starts(&mut layout, &linkedit);
 -    let sizeofcmds: u32 = build_commands(&layout, kind, opts, None, dylibs, &linkedit)?
 -        .iter()
 -        .map(LoadCommand::cmdsize)
 -        .sum();
 -    let header_size = HEADER_SIZE as u64 + sizeofcmds as u64;
 -    layout.relayout(header_size);
 -    linkedit = build_linkedit_plan(&layout, kind, opts, inputs)?;
 +    let (next_linkedit, next_timings) = build_linkedit_plan_profiled(&layout, kind, opts, inputs)?;
 +    linkedit = next_linkedit;
 +    timings += next_timings;
      apply_indirect_starts(&mut layout, &linkedit);
 +    let exact_header_size =
 +        HEADER_SIZE as u64 + exact_sizeofcmds(&layout, kind, opts, dylibs, &linkedit)? as u64;
 +    if exact_header_size != header_size {
 +        layout.relayout(exact_header_size);
 +        let (next_linkedit, next_timings) =
 +            build_linkedit_plan_profiled(&layout, kind, opts, inputs)?;
 +        linkedit = next_linkedit;
 +        timings += next_timings;
 +        apply_indirect_starts(&mut layout, &linkedit);
 +    }
      let linkedit_seg = layout
          .segment_mut("__LINKEDIT")
          .ok_or(WriteError::MissingSegment("__LINKEDIT"))?;
      linkedit_seg.file_size = linkedit.total_size().max(1);
      linkedit_seg.vm_size = align_up(linkedit.total_size().max(1), PAGE_SIZE);
 -    Ok((layout, linkedit))
 +    Ok((layout, linkedit, timings))
 +}
++
 +fn exact_sizeofcmds(
 +    layout: &Layout,
 +    kind: OutputKind,
 +    opts: &LinkOptions,
 +    dylibs: &[DylibDependency],
 +    linkedit: &LinkEditPlan,
 +) -> Result<u32, WriteError> {
 +    Ok(build_commands(layout, kind, opts, None, dylibs, linkedit)?
 +        .iter()
 +        .map(LoadCommand::cmdsize)
 +        .sum())
+ }
  pub fn write_finalized_with_dylibs(
      let weak_bind_off = linkedit_plan.dyld_info.weak_bind_off as usize;
      let lazy_bind_off = linkedit_plan.dyld_info.lazy_bind_off as usize;
      let export_off = linkedit_plan.dyld_info.export_off as usize;
 +    let loh_off = linkedit_plan.loh.map(|loh| loh.dataoff as usize);
      let function_starts_off = linkedit_plan.function_starts.dataoff as usize;
      let data_in_code_off = linkedit_plan.data_in_code.dataoff as usize;
      let stroff = linkedit_plan.symtab.stroff as usize;
          let end = export_off + linkedit_plan.export_bytes.len();
          out[export_off..end].copy_from_slice(&linkedit_plan.export_bytes);
+     }
 +    if let Some(loh_off) = loh_off {
 +        if !linkedit_plan.loh_bytes.is_empty() {
 +            let end = loh_off + linkedit_plan.loh_bytes.len();
 +            out[loh_off..end].copy_from_slice(&linkedit_plan.loh_bytes);
 +        }
 +    }
      if !linkedit_plan.function_starts_bytes.is_empty() {
          let end = function_starts_off + linkedit_plan.function_starts_bytes.len();
          out[function_starts_off..end].copy_from_slice(&linkedit_plan.function_starts_bytes);
              commands.push(LoadCommand::Symtab(linkedit.symtab));
              commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
              commands.push(raw_dylinker_command("/usr/lib/dyld"));
 -            commands.push(raw_uuid_command(stable_uuid(layout, kind)));
 -            commands.push(LoadCommand::BuildVersion(BuildVersionCmd {
 -                platform: PLATFORM_MACOS,
 -                minos: pack_version(11, 0, 0),
 -                sdk: pack_version(11, 0, 0),
 -                tools: vec![BuildTool {
 -                    tool: 3,
 -                    version: pack_version(0, 1, 0),
 -                }],
 -            }));
 +            if opts.emit_uuid {
 +                commands.push(raw_uuid_command(stable_uuid(layout, kind)));
 +            }
 +            commands.push(LoadCommand::BuildVersion(build_version_command(opts)));
              commands.push(raw_source_version_command(0));
              commands.push(raw_entry_point(resolve_entryoff(layout, entry_point)?, 0));
+         }
          OutputKind::Dylib => {
 -            commands.push(LoadCommand::BuildVersion(BuildVersionCmd {
 -                platform: PLATFORM_MACOS,
 -                minos: pack_version(11, 0, 0),
 -                sdk: pack_version(11, 0, 0),
 -                tools: vec![BuildTool {
 -                    tool: 3,
 -                    version: pack_version(0, 1, 0),
 -                }],
 -            }));
 -            commands.push(raw_uuid_command(stable_uuid(layout, kind)));
              commands.push(LoadCommand::Dylib(DylibCmd {
                  cmd: LC_ID_DYLIB,
                  name: dylib_install_name(opts),
                  timestamp: 2,
 -                current_version: pack_version(1, 0, 0),
 -                compatibility_version: pack_version(1, 0, 0),
 +                current_version: dylib_current_version(opts),
 +                compatibility_version: dylib_compatibility_version(opts),
              }));
 +            commands.push(LoadCommand::DyldInfoOnly(linkedit.dyld_info));
 +            commands.push(LoadCommand::Symtab(linkedit.symtab));
 +            commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
 +            if opts.emit_uuid {
 +                commands.push(raw_uuid_command(stable_uuid(layout, kind)));
 +            }
 +            commands.push(LoadCommand::BuildVersion(build_version_command(opts)));
 +            commands.push(raw_source_version_command(0));
+         }
+     }
 +    for rpath in &opts.rpaths {
 +        commands.push(LoadCommand::Rpath(RpathCmd {
 +            path: rpath.clone(),
 +        }));
 +    }
++
      for dylib in dylibs {
          commands.push(LoadCommand::Dylib(DylibCmd {
 -            cmd: LC_LOAD_DYLIB,
 +            cmd: dylib.kind.load_cmd(),
              name: dylib.install_name.clone(),
              timestamp: 2,
              current_version: dylib.current_version,
          }));
+     }
 +    if let Some(loh) = linkedit.loh {
 +        commands.push(raw_linkedit_command(
 +            LC_LINKER_OPTIMIZATION_HINT,
 +            loh.dataoff,
 +            loh.datasize,
 +        ));
 +    }
      commands.push(raw_linkedit_command(
          LC_FUNCTION_STARTS,
          linkedit.function_starts.dataoff,
      } else {
          commands.push(raw_linkedit_command(LC_CODE_SIGNATURE, 0, 0));
+     }
 -    if kind == OutputKind::Dylib {
 -        commands.push(LoadCommand::DyldInfoOnly(linkedit.dyld_info));
 -        commands.push(LoadCommand::Symtab(linkedit.symtab));
 -        commands.push(LoadCommand::Dysymtab(linkedit.dysymtab));
 -    }
+-
      Ok(commands)
+ }
      kind: OutputKind,
      opts: &LinkOptions,
      dylibs: &[DylibDependency],
 -    _linkedit: &LinkEditPlan,
 +    linkedit: &LinkEditPlan,
  ) -> u64 {
      let mut size = HEADER_SIZE as u64;
      for segment in &layout.segments {
          size += (8 + 64 + 80 * segment.sections.len()) as u64;
+     }
 -    size += BuildVersionCmd {
 -        platform: PLATFORM_MACOS,
 -        minos: pack_version(11, 0, 0),
 -        sdk: pack_version(11, 0, 0),
 -        tools: vec![BuildTool {
 -            tool: 3,
 -            version: pack_version(0, 1, 0),
 -        }],
 +    size += build_version_command(opts).wire_size() as u64;
 +    if opts.emit_uuid {
 +        size += 24;
+     }
 -    .wire_size() as u64;
 -    size += 24;
      size += match kind {
          OutputKind::Executable => {
              raw_dylinker_command("/usr/lib/dyld").cmdsize() as u64
                  + 24
                  + raw_source_version_command(0).cmdsize() as u64
+         }
 -        OutputKind::Dylib => DylibCmd {
 -            cmd: LC_ID_DYLIB,
 -            name: dylib_install_name(opts),
 -            timestamp: 2,
 -            current_version: pack_version(1, 0, 0),
 -            compatibility_version: pack_version(1, 0, 0),
 +        OutputKind::Dylib => {
 +            DylibCmd {
 +                cmd: LC_ID_DYLIB,
 +                name: dylib_install_name(opts),
 +                timestamp: 2,
 +                current_version: dylib_current_version(opts),
 +                compatibility_version: dylib_compatibility_version(opts),
 +            }
 +            .wire_size() as u64
 +                + raw_source_version_command(0).cmdsize() as u64
+         }
 -        .wire_size() as u64,
      };
 +    for rpath in &opts.rpaths {
 +        size += RpathCmd {
 +            path: rpath.clone(),
 +        }
 +        .wire_size() as u64;
 +    }
      for dylib in dylibs {
          size += DylibCmd {
 -            cmd: LC_LOAD_DYLIB,
 +            cmd: dylib.kind.load_cmd(),
              name: dylib.install_name.clone(),
              timestamp: 2,
              current_version: dylib.current_version,
      size += SymtabCmd::WIRE_SIZE as u64;
      size += DysymtabCmd::WIRE_SIZE as u64;
      size += 16 * 3;
 +    if linkedit.loh.is_some() {
 +        size += 16;
 +    }
      size += DyldInfoCmd::WIRE_SIZE as u64;
      size
+ }
+     }
+ }
 +fn build_version_command(opts: &LinkOptions) -> BuildVersionCmd {
 +    let platform = opts.platform_version.unwrap_or(crate::PlatformVersion {
 +        minos: pack_version(11, 0, 0),
 +        sdk: pack_version(11, 0, 0),
 +    });
 +    BuildVersionCmd {
 +        platform: PLATFORM_MACOS,
 +        minos: platform.minos,
 +        sdk: platform.sdk,
 +        tools: vec![BuildTool {
 +            tool: 3,
 +            version: pack_version(0, 1, 0),
 +        }],
 +    }
 +}
++
  fn stable_uuid(layout: &Layout, kind: OutputKind) -> [u8; 16] {
      fn mix(state: &mut u64, bytes: &[u8]) {
          for byte in bytes {
+ }
  fn dylib_install_name(opts: &LinkOptions) -> String {
 +    if let Some(name) = &opts.install_name {
 +        return name.clone();
 +    }
      if let Some(path) = &opts.output {
          if let Some(name) = path.file_name().and_then(|name| name.to_str()) {
              return format!("@rpath/{name}");
      "@rpath/a.out.dylib".to_string()
+ }
 +fn dylib_current_version(opts: &LinkOptions) -> u32 {
 +    opts.current_version
 +        .unwrap_or_else(|| pack_version(1, 0, 0))
 +}
++
 +fn dylib_compatibility_version(opts: &LinkOptions) -> u32 {
 +    opts.compatibility_version
 +        .unwrap_or_else(|| pack_version(1, 0, 0))
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct LinkEditPlan {
      base_off: u32,
      pub symtab: SymtabCmd,
      pub dysymtab: DysymtabCmd,
      pub dyld_info: DyldInfoCmd,
 +    pub loh: Option<LinkEditDataCmd>,
      pub function_starts: LinkEditDataCmd,
      pub data_in_code: LinkEditDataCmd,
      pub symtab_bytes: Vec<u8>,
      weak_bind_bytes: Vec<u8>,
      lazy_bind_bytes: Vec<u8>,
      export_bytes: Vec<u8>,
 +    loh_bytes: Vec<u8>,
      function_starts_bytes: Vec<u8>,
      data_in_code_bytes: Vec<u8>,
      pub strtab_bytes: Vec<u8>,
      code_signature: Option<CodeSignaturePlan>,
      indirect_starts: HashMap<(String, String), u32>,
      lazy_bind_offsets: HashMap<SymbolId, u32>,
 +    pub map_symbols: Vec<LinkMapSymbol>,
+ }
  impl LinkEditPlan {
      pub fn lazy_bind_offset(&self, symbol: SymbolId) -> Option<u32> {
          self.lazy_bind_offsets.get(&symbol).copied()
+     }
++
 +    pub fn loh_bytes(&self) -> &[u8] {
 +        &self.loh_bytes
 +    }
+ }
  fn build_linkedit_plan(
      opts: &LinkOptions,
      inputs: Option<LinkEditInputs<'_>>,
  ) -> Result<LinkEditPlan, WriteError> {
 +    build_linkedit_plan_profiled(layout, kind, opts, inputs).map(|(plan, _)| plan)
 +}
++
 +fn build_linkedit_plan_profiled(
 +    layout: &Layout,
 +    kind: OutputKind,
 +    opts: &LinkOptions,
 +    inputs: Option<LinkEditInputs<'_>>,
 +) -> Result<(LinkEditPlan, LinkEditBuildTimings), WriteError> {
 +    let mut timings = LinkEditBuildTimings::default();
      let linkedit = layout
          .segment("__LINKEDIT")
          .cloned()
      let base_off = u32_fit(linkedit.file_off, "linkedit file offset")?;
      let Some(inputs) = inputs else {
 -        return Ok(LinkEditPlan {
 -            base_off,
 -            symtab: SymtabCmd {
 -                symoff: base_off,
 -                nsyms: 0,
 -                stroff: base_off,
 -                strsize: 8,
 -            },
 -            dysymtab: DysymtabCmd::default(),
 -            dyld_info: DyldInfoCmd::default(),
 -            function_starts: LinkEditDataCmd {
 -                dataoff: base_off,
 -                datasize: 0,
 -            },
 -            data_in_code: LinkEditDataCmd {
 -                dataoff: base_off,
 -                datasize: 0,
 +        let phase_started = std::time::Instant::now();
 +        let code_signature = Some(build_code_signature(
 +            layout,
 +            kind,
 +            opts,
 +            base_off as u64 + 8,
 +        )?);
 +        timings.code_signature += phase_started.elapsed();
 +        return Ok((
 +            LinkEditPlan {
 +                base_off,
 +                symtab: SymtabCmd {
 +                    symoff: base_off,
 +                    nsyms: 0,
 +                    stroff: base_off,
 +                    strsize: 8,
 +                },
 +                dysymtab: DysymtabCmd::default(),
 +                dyld_info: DyldInfoCmd::default(),
 +                loh: None,
 +                function_starts: LinkEditDataCmd {
 +                    dataoff: base_off,
 +                    datasize: 0,
 +                },
 +                data_in_code: LinkEditDataCmd {
 +                    dataoff: base_off,
 +                    datasize: 0,
 +                },
 +                symtab_bytes: Vec::new(),
 +                indirect_bytes: Vec::new(),
 +                rebase_bytes: Vec::new(),
 +                bind_bytes: Vec::new(),
 +                weak_bind_bytes: Vec::new(),
 +                lazy_bind_bytes: Vec::new(),
 +                export_bytes: Vec::new(),
 +                loh_bytes: Vec::new(),
 +                function_starts_bytes: Vec::new(),
 +                data_in_code_bytes: Vec::new(),
 +                strtab_bytes: vec![0; 8],
 +                code_signature,
 +                indirect_starts: HashMap::new(),
 +                lazy_bind_offsets: HashMap::new(),
 +                map_symbols: Vec::new(),
              },
 -            symtab_bytes: Vec::new(),
 -            indirect_bytes: Vec::new(),
 -            rebase_bytes: Vec::new(),
 -            bind_bytes: Vec::new(),
 -            weak_bind_bytes: Vec::new(),
 -            lazy_bind_bytes: Vec::new(),
 -            export_bytes: Vec::new(),
 -            function_starts_bytes: Vec::new(),
 -            data_in_code_bytes: Vec::new(),
 -            strtab_bytes: vec![0; 8],
 -            code_signature: Some(build_code_signature(
 -                layout,
 -                kind,
 -                opts,
 -                base_off as u64 + 8,
 -            )?),
 -            indirect_starts: HashMap::new(),
 -            lazy_bind_offsets: HashMap::new(),
 -        });
 +            timings,
 +        ));
      };
      let sym_table = inputs.0.sym_table;
      let synthetic_plan = inputs.0.synthetic_plan;
 +    let phase_started = std::time::Instant::now();
      let imports = collect_imports(sym_table, synthetic_plan)?;
      let import_lookup: HashMap<SymbolId, &ImportSymbolRecord> = imports
          .iter()
          .map(|record| (record.symbol, record))
          .collect();
 -    let symbol_plan = build_output_symbols(layout, kind, opts.strip_locals, inputs, &imports)?;
 +    let visibility = SymbolVisibilityPolicy::from_opts(opts)?;
 +    let (symbol_plan, symbol_plan_timings) = build_output_symbols_profiled(
 +        layout,
 +        kind,
 +        opts.dead_strip,
 +        opts.strip_locals,
 +        &visibility,
 +        inputs,
 +        &imports,
 +    )?;
 +    timings.symbol_plan += phase_started.elapsed();
 +    timings.symbol_plan_locals += symbol_plan_timings.locals;
 +    timings.symbol_plan_globals += symbol_plan_timings.globals;
 +    timings.symbol_plan_strtab += symbol_plan_timings.strtab;
      let mut symtab_bytes = Vec::new();
      write_nlist_table(&symbol_plan.symbols, &mut symtab_bytes);
          indirect_bytes.extend_from_slice(&index.to_le_bytes());
+     }
 +    let phase_started = std::time::Instant::now();
      let bind_streams = build_bind_streams(layout, synthetic_plan, &import_lookup)?;
      let rebase_bytes = pad_dyld_info_stream(build_rebase_stream(layout, synthetic_plan, inputs)?);
      let bind_bytes = pad_dyld_info_stream(bind_streams.bind);
      let weak_bind_bytes = pad_dyld_info_stream(bind_streams.weak_bind);
      let lazy_bind_bytes = pad_dyld_info_stream(bind_streams.lazy_bind);
      let export_bytes = pad_dyld_info_stream(build_export_trie(&symbol_plan.exports));
 +    timings.dyld_info += phase_started.elapsed();
++
 +    let phase_started = std::time::Instant::now();
 +    let loh_bytes = build_loh(
 +        layout,
 +        inputs.0.layout_inputs,
 +        inputs.0.atom_table,
 +        inputs.0.icf_redirects,
 +    )?;
      let function_starts_bytes =
          build_function_starts(layout, inputs.0.layout_inputs, inputs.0.atom_table)?;
 -    let data_in_code_bytes =
 -        build_data_in_code(layout, inputs.0.layout_inputs, inputs.0.atom_table)?;
 +    let data_in_code_bytes = build_data_in_code(
 +        layout,
 +        inputs.0.layout_inputs,
 +        inputs.0.atom_table,
 +        inputs.0.icf_redirects,
 +    )?;
 +    timings.metadata_tables += phase_started.elapsed();
      let mut cursor = base_off as u64;
      let rebase_off = place_optional_block(&mut cursor, rebase_bytes.len(), "rebase stream offset")?;
          "lazy bind stream offset",
      )?;
      let export_off = place_optional_block(&mut cursor, export_bytes.len(), "export trie offset")?;
 +    let loh = place_optional_linkedit_data_block(&mut cursor, loh_bytes.len(), "LOH offset")?;
      let function_starts = place_linkedit_data_block(
          &mut cursor,
          function_starts_bytes.len(),
          "string table offset",
      )?;
      let regular_end = stroff as u64 + symbol_plan.strtab_bytes.len() as u64;
 -    Ok(LinkEditPlan {
 -        base_off,
 -        symtab: SymtabCmd {
 -            symoff,
 -            nsyms: symbol_plan.symbols.len() as u32,
 -            stroff,
 -            strsize: symbol_plan.strtab_bytes.len() as u32,
 -        },
 -        dysymtab: DysymtabCmd {
 -            indirectsymoff,
 -            nindirectsyms: indirect_symbols.len() as u32,
 -            ..symbol_plan.dysymtab
 -        },
 -        dyld_info: DyldInfoCmd {
 -            rebase_off,
 -            rebase_size: rebase_bytes.len() as u32,
 -            bind_off: bindoff,
 -            bind_size: bind_bytes.len() as u32,
 -            weak_bind_off,
 -            weak_bind_size: weak_bind_bytes.len() as u32,
 -            lazy_bind_off,
 -            lazy_bind_size: lazy_bind_bytes.len() as u32,
 -            export_off,
 -            export_size: export_bytes.len() as u32,
 +    let phase_started = std::time::Instant::now();
 +    let code_signature = Some(build_code_signature(layout, kind, opts, regular_end)?);
 +    timings.code_signature += phase_started.elapsed();
 +    Ok((
 +        LinkEditPlan {
 +            base_off,
 +            symtab: SymtabCmd {
 +                symoff,
 +                nsyms: symbol_plan.symbols.len() as u32,
 +                stroff,
 +                strsize: symbol_plan.strtab_bytes.len() as u32,
 +            },
 +            dysymtab: DysymtabCmd {
 +                indirectsymoff,
 +                nindirectsyms: indirect_symbols.len() as u32,
 +                ..symbol_plan.dysymtab
 +            },
 +            dyld_info: DyldInfoCmd {
 +                rebase_off,
 +                rebase_size: rebase_bytes.len() as u32,
 +                bind_off: bindoff,
 +                bind_size: bind_bytes.len() as u32,
 +                weak_bind_off,
 +                weak_bind_size: weak_bind_bytes.len() as u32,
 +                lazy_bind_off,
 +                lazy_bind_size: lazy_bind_bytes.len() as u32,
 +                export_off,
 +                export_size: export_bytes.len() as u32,
 +            },
 +            loh,
 +            function_starts,
 +            data_in_code,
 +            symtab_bytes,
 +            indirect_bytes,
 +            rebase_bytes,
 +            bind_bytes,
 +            weak_bind_bytes,
 +            lazy_bind_bytes,
 +            export_bytes,
 +            loh_bytes,
 +            function_starts_bytes,
 +            data_in_code_bytes,
 +            strtab_bytes: symbol_plan.strtab_bytes,
 +            code_signature,
 +            indirect_starts,
 +            lazy_bind_offsets: bind_streams.lazy_offsets,
 +            map_symbols: symbol_plan.map_symbols,
          },
 -        function_starts,
 -        data_in_code,
 -        symtab_bytes,
 -        indirect_bytes,
 -        rebase_bytes,
 -        bind_bytes,
 -        weak_bind_bytes,
 -        lazy_bind_bytes,
 -        export_bytes,
 -        function_starts_bytes,
 -        data_in_code_bytes,
 -        strtab_bytes: symbol_plan.strtab_bytes,
 -        code_signature: Some(build_code_signature(layout, kind, opts, regular_end)?),
 -        indirect_starts,
 -        lazy_bind_offsets: bind_streams.lazy_offsets,
 -    })
 +        timings,
 +    ))
+ }
  fn build_code_signature(
      n_sect: u8,
      n_desc: u16,
      n_value: u64,
 +    size: u64,
 +    file_index: usize,
 +}
++
 +#[derive(Debug, Clone)]
 +struct SymbolVisibilityPolicy {
 +    exported: Vec<String>,
 +    unexported: Vec<String>,
 +}
++
 +impl SymbolVisibilityPolicy {
 +    fn from_opts(opts: &LinkOptions) -> Result<Self, WriteError> {
 +        let mut exported = opts.exported_symbols.clone();
 +        let mut unexported = opts.unexported_symbols.clone();
 +        for path in &opts.exported_symbols_lists {
 +            exported.extend(read_symbol_patterns(path)?);
 +        }
 +        for path in &opts.unexported_symbols_lists {
 +            unexported.extend(read_symbol_patterns(path)?);
 +        }
 +        Ok(Self {
 +            exported,
 +            unexported,
 +        })
 +    }
++
 +    fn hides(&self, name: &str) -> bool {
 +        if !self.exported.is_empty()
 +            && !self
 +                .exported
 +                .iter()
 +                .any(|pattern| wildcard_matches(pattern, name))
 +        {
 +            return true;
 +        }
 +        self.unexported
 +            .iter()
 +            .any(|pattern| wildcard_matches(pattern, name))
 +    }
+ }
  #[derive(Debug, Clone)]
  struct SymbolTablePlan {
      symbols: Vec<InputSymbol>,
 +    map_symbols: Vec<LinkMapSymbol>,
      strtab_bytes: Vec<u8>,
      symbol_indices: HashMap<SymbolId, u32>,
      exports: Vec<ExportEntry>,
          synthetic_plan,
          inputs.0.sym_table,
      )?);
 -    let mut reloc_cache: HashMap<(InputId, u8), Vec<Reloc>> = HashMap::new();
      let input_map: HashMap<InputId, &ObjectFile> = inputs
          .0
          .layout_inputs
          .iter()
          .map(|input| (input.id, input.object))
          .collect();
+-
 -    for input in inputs.0.layout_inputs {
 -        for (sect_idx, section) in input.object.sections.iter().enumerate() {
 -            if section.raw_relocs.is_empty() {
 -                continue;
 -            }
 -            let raws = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc).map_err(|err| {
 -                WriteError::MalformedRelocations(
 -                    input.object.path.clone(),
 -                    (sect_idx + 1) as u8,
 -                    err.to_string(),
 -                )
 -            })?;
 -            let relocs = parse_relocs(&raws).map_err(|err| {
 -                WriteError::MalformedRelocations(
 -                    input.object.path.clone(),
 -                    (sect_idx + 1) as u8,
 -                    err.to_string(),
 -                )
 -            })?;
 -            reloc_cache.insert((input.id, (sect_idx + 1) as u8), relocs);
 -        }
 -    }
 +    let symbol_name_index = build_symbol_name_index(inputs.0.sym_table);
      for section in &layout.sections {
          if !matches!(section.segment.as_str(), "__DATA" | "__DATA_CONST") {
              let Some(obj) = input_map.get(&atom.origin).copied() else {
                  continue;
              };
 -            let relocs = reloc_cache
 +            let relocs = inputs
 +                .0
 +                .parsed_relocs
                  .get(&(atom.origin, atom.input_section))
                  .map(Vec::as_slice)
                  .unwrap_or(&[]);
              for reloc in relocs_for_rebase(relocs, atom) {
 -                if !reloc_needs_rebase(obj, reloc, inputs.0.sym_table) {
 +                if !reloc_needs_rebase(obj, reloc, inputs.0.sym_table, &symbol_name_index) {
                      continue;
+                 }
                  let local_offset = reloc.offset.saturating_sub(atom.input_offset) as u64;
      })
+ }
 -fn reloc_needs_rebase(obj: &ObjectFile, reloc: Reloc, sym_table: &SymbolTable) -> bool {
 +fn reloc_needs_rebase(
 +    obj: &ObjectFile,
 +    reloc: Reloc,
 +    sym_table: &SymbolTable,
 +    symbol_name_index: &HashMap<String, SymbolId>,
 +) -> bool {
      if reloc.kind != RelocKind::Unsigned
          || reloc.length != RelocLength::Quad
          || reloc.pcrel
              let Some(input_sym) = obj.symbols.get(sym_idx as usize) else {
                  return false;
              };
 -            match symbol_referent_id(obj, reloc.referent, sym_table) {
 +            match symbol_referent_id(obj, reloc.referent, symbol_name_index) {
                  Some(symbol_id) => match sym_table.get(symbol_id) {
                      Symbol::DylibImport { .. } => false,
                      Symbol::Defined { atom, .. } => atom.0 != 0,
+     }
+ }
 +fn build_symbol_name_index(sym_table: &SymbolTable) -> HashMap<String, SymbolId> {
 +    sym_table
 +        .iter()
 +        .map(|(symbol_id, symbol)| {
 +            (
 +                sym_table.interner.resolve(symbol.name()).to_string(),
 +                symbol_id,
 +            )
 +        })
 +        .collect()
 +}
++
  fn symbol_referent_id(
      obj: &ObjectFile,
      referent: Referent,
 -    sym_table: &SymbolTable,
 +    symbol_name_index: &HashMap<String, SymbolId>,
  ) -> Option<SymbolId> {
      let Referent::Symbol(sym_idx) = referent else {
          return None;
      };
      let input_sym = obj.symbols.get(sym_idx as usize)?;
      let name = obj.symbol_name(input_sym).ok()?;
 -    let (symbol_id, _) = sym_table
 -        .iter()
 -        .find(|(_, symbol)| sym_table.interner.resolve(symbol.name()) == name)?;
 -    Some(symbol_id)
 +    symbol_name_index.get(name).copied()
+ }
  fn build_function_starts(
      layout: &Layout,
      inputs: &[LayoutInput<'_>],
      atom_table: &AtomTable,
 +    icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
  ) -> Result<Vec<u8>, WriteError> {
      #[derive(Clone, Copy)]
      struct RemappedEntry {
+     }
      let atoms_by_input_section = atom_table.by_input_section();
 +    let atom_ranges = build_atom_range_index(atom_table, &atoms_by_input_section, icf_redirects);
      let mut remapped = Vec::new();
      for (input_order, input) in inputs.iter().enumerate() {
          for (input_entry_index, entry) in input.object.data_in_code.iter().copied().enumerate() {
              let (section_index, section_relative) =
                  remap_data_in_code_to_section(input.object, entry)?;
              let (atom_id, atom_delta) = find_containing_atom_range(
 -                atom_table,
 -                &atoms_by_input_section,
 +                &atom_ranges,
                  input.id,
                  section_index,
                  section_relative,
      Ok(out)
+ }
 +fn build_loh(
 +    _layout: &Layout,
 +    _inputs: &[LayoutInput<'_>],
 +    _atom_table: &AtomTable,
 +    _icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +) -> Result<Vec<u8>, WriteError> {
 +    // Current Apple ld omits LC_LINKER_OPTIMIZATION_HINT from final linked
 +    // executables and dylibs on our parity corpus, so we do the same.
 +    Ok(Vec::new())
 +}
++
  fn remap_data_in_code_to_section(
      object: &ObjectFile,
      entry: DataInCodeEntry,
      Ok(out)
+ }
 -fn build_output_symbols(
 +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 +struct SymbolPlanBuildTimings {
 +    locals: Duration,
 +    globals: Duration,
 +    strtab: Duration,
 +}
++
 +fn build_output_symbols_profiled(
      layout: &Layout,
      kind: OutputKind,
 +    dead_strip: bool,
      strip_locals: bool,
 +    visibility: &SymbolVisibilityPolicy,
      inputs: LinkEditInputs<'_>,
      imports: &[ImportSymbolRecord],
 -) -> Result<SymbolTablePlan, WriteError> {
 +) -> Result<(SymbolTablePlan, SymbolPlanBuildTimings), WriteError> {
      let sym_table = inputs.0.sym_table;
      let atom_sections = atom_section_ordinals(layout);
      let atoms_by_input_section = inputs.0.atom_table.by_input_section();
 +    let atom_ranges = build_atom_range_index(
 +        inputs.0.atom_table,
 +        &atoms_by_input_section,
 +        inputs.0.icf_redirects,
 +    );
 +    let file_index_by_input: HashMap<InputId, usize> = inputs
 +        .0
 +        .layout_inputs
 +        .iter()
 +        .enumerate()
 +        .map(|(idx, input)| (input.id, idx + 1))
 +        .collect();
      let image_base = layout.segment("__TEXT").map(|seg| seg.vm_addr).unwrap_or(0);
 +    let mut timings = SymbolPlanBuildTimings::default();
      let mut locals = Vec::new();
      let mut external_defineds = Vec::new();
      let mut undefineds = Vec::with_capacity(imports.len());
              .segment("__TEXT")
              .ok_or(WriteError::MissingSegment("__TEXT"))?
              .vm_addr;
 -        external_defineds.push(OutputSymbolSpec {
 +        let hide_header = visibility.hides("__mh_execute_header");
 +        let header_partition = if hide_header {
 +            OutputSymbolPartition::Local
 +        } else {
 +            OutputSymbolPartition::ExternalDefined
 +        };
 +        let header_type = defined_symbol_type(hide_header);
 +        let target = if hide_header {
 +            &mut locals
 +        } else {
 +            &mut external_defineds
 +        };
 +        target.push(OutputSymbolSpec {
              symbol: None,
              name: "__mh_execute_header".to_string(),
 -            partition: OutputSymbolPartition::ExternalDefined,
 -            n_type: N_SECT | N_EXT,
 +            partition: header_partition,
 +            n_type: header_type,
              n_sect: 1,
              n_desc: REFERENCED_DYNAMICALLY,
              n_value: text_vmaddr,
 +            size: 0,
 +            file_index: 0,
          });
+     }
 +    let phase_started = std::time::Instant::now();
      for input in inputs.0.layout_inputs {
 -        collect_local_symbols(
 -            layout,
 -            inputs.0.atom_table,
 -            &atoms_by_input_section,
 -            &atom_sections,
 -            input.id,
 -            input.object,
 -            &mut locals,
 -        )?;
 +        let ctx = LocalSymbolContext {
 +            atom_table: inputs.0.atom_table,
 +            atom_ranges: &atom_ranges,
 +            atom_sections: &atom_sections,
 +            input_id: input.id,
 +            file_index: file_index_by_input[&input.id],
 +        };
 +        collect_local_symbols(layout, &ctx, input.object, &mut locals)?;
+     }
      collect_synthetic_local_symbols(layout, inputs.0.synthetic_plan, &mut locals)?;
 -    sort_local_symbols(&mut locals);
 +    timings.locals += phase_started.elapsed();
 +    let phase_started = std::time::Instant::now();
      for (symbol_id, symbol) in sym_table.iter() {
          let Symbol::Defined {
              name,
 +            origin,
              atom,
              value,
              weak,
              continue;
+         }
          let name = sym_table.interner.resolve(*name).to_string();
 +        let hidden = visibility.hides(&name);
          let (n_type, n_sect, n_value) = if atom.0 == 0 {
 -            (absolute_symbol_type(*private_extern), NO_SECT, *value)
 +            (absolute_symbol_type(hidden), NO_SECT, *value)
          } else {
 +            if dead_strip && layout.atom_addr(*atom).is_none() {
 +                continue;
 +            }
              let addr = layout
                  .atom_addr(*atom)
                  .ok_or(WriteError::DefinedSymbolAtomMissing(symbol_id, *atom))?;
              let sect = *atom_sections
                  .get(atom)
                  .ok_or(WriteError::DefinedSymbolSectionMissing(symbol_id, *atom))?;
 -            (defined_symbol_type(*private_extern), sect, addr + *value)
 +            (defined_symbol_type(hidden), sect, addr + *value)
 +        };
 +        let size = if atom.0 == 0 {
 +            0
 +        } else {
 +            inputs
 +                .0
 +                .atom_table
 +                .get(*atom)
 +                .size
 +                .saturating_sub(*value as u32) as u64
          };
          let mut n_desc = 0;
          if *weak {
          if *no_dead_strip {
              n_desc |= N_NO_DEAD_STRIP;
+         }
 -        external_defineds.push(OutputSymbolSpec {
 +        let partition = if hidden {
 +            OutputSymbolPartition::Local
 +        } else {
 +            OutputSymbolPartition::ExternalDefined
 +        };
 +        let target = if hidden {
 +            &mut locals
 +        } else {
 +            &mut external_defineds
 +        };
 +        target.push(OutputSymbolSpec {
              symbol: Some(symbol_id),
              name,
 -            partition: OutputSymbolPartition::ExternalDefined,
 +            partition,
              n_type,
              n_sect,
              n_desc,
              n_value,
 +            size,
 +            file_index: file_index_by_input.get(origin).copied().unwrap_or(0),
          });
+     }
 +    sort_local_symbols(&mut locals);
      external_defineds.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
      for import in imports {
          let mut n_desc = import.ordinal << 8;
              n_sect: NO_SECT,
              n_desc,
              n_value: 0,
 +            size: 0,
 +            file_index: 0,
          });
+     }
      undefineds.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
 +    timings.globals += phase_started.elapsed();
      let exports = if matches!(kind, OutputKind::Dylib | OutputKind::Executable) {
          external_defineds
          Vec::new()
      };
 +    let phase_started = std::time::Instant::now();
      let local_count = if strip_locals { 0 } else { locals.len() };
      let mut specs = Vec::with_capacity(local_count + external_defineds.len() + undefineds.len());
      if !strip_locals {
      let mut symbols = Vec::with_capacity(specs.len());
      let mut symbol_indices = HashMap::new();
 +    let map_symbols = specs
 +        .iter()
 +        .filter(|spec| spec.partition != OutputSymbolPartition::Undefined)
 +        .map(|spec| LinkMapSymbol {
 +            name: spec.name.clone(),
 +            addr: spec.n_value,
 +            size: spec.size,
 +            file_index: spec.file_index,
 +        })
 +        .collect();
      for (idx, spec) in specs.into_iter().enumerate() {
          let strx = *strx_by_name
              .get(&spec.name)
              symbol_indices.insert(symbol, idx as u32);
+         }
+     }
+-
 -    Ok(SymbolTablePlan {
 -        symbols,
 -        strtab_bytes,
 -        symbol_indices,
 -        exports,
 -        dysymtab: DysymtabCmd {
 -            ilocalsym: 0,
 -            nlocalsym,
 -            iextdefsym: nlocalsym,
 -            nextdefsym,
 -            iundefsym: nlocalsym + nextdefsym,
 -            nundefsym,
 -            ..DysymtabCmd::default()
 +    timings.strtab += phase_started.elapsed();
++
 +    Ok((
 +        SymbolTablePlan {
 +            symbols,
 +            map_symbols,
 +            strtab_bytes,
 +            symbol_indices,
 +            exports,
 +            dysymtab: DysymtabCmd {
 +                ilocalsym: 0,
 +                nlocalsym,
 +                iextdefsym: nlocalsym,
 +                nextdefsym,
 +                iundefsym: nlocalsym + nextdefsym,
 +                nundefsym,
 +                ..DysymtabCmd::default()
 +            },
          },
 -    })
 +        timings,
 +    ))
+ }
  fn sort_local_symbols(locals: &mut [OutputSymbolSpec]) {
          n_sect: u8::try_from(section_index + 1).expect("section index should fit in n_sect"),
          n_desc: 0,
          n_value: section.addr + section.synthetic_offset,
 +        size: 8,
 +        file_index: 0,
      });
      Ok(())
+ }
  fn collect_local_symbols(
      layout: &Layout,
 -    atom_table: &AtomTable,
 -    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
 -    atom_sections: &HashMap<crate::resolve::AtomId, u8>,
 -    input_id: InputId,
 +    ctx: &LocalSymbolContext<'_>,
      object: &ObjectFile,
      out: &mut Vec<OutputSymbolSpec>,
  ) -> Result<(), WriteError> {
                      .expect("section symbol without section");
                  let offset = input_sym.value().saturating_sub(section.addr) as u32;
                  let (atom_id, delta) = find_containing_atom(
 -                    atom_table,
 -                    atoms_by_input_section,
 -                    input_id,
 +                    ctx.atom_ranges,
 +                    ctx.input_id,
                      input_sym.sect_idx(),
                      offset,
+                 )
                              atom_id,
                          ))?
                          + delta as u64;
 -                let n_sect =
 -                    *atom_sections
 -                        .get(&atom_id)
 -                        .ok_or(WriteError::DefinedSymbolSectionMissing(
 -                            SymbolId(u32::MAX),
 -                            atom_id,
 -                        ))?;
 +                let n_sect = *ctx.atom_sections.get(&atom_id).ok_or(
 +                    WriteError::DefinedSymbolSectionMissing(SymbolId(u32::MAX), atom_id),
 +                )?;
                  out.push(OutputSymbolSpec {
                      symbol: None,
                      name,
                      n_sect,
                      n_desc: input_sym.raw.n_desc,
                      n_value: addr,
 +                    size: ctx.atom_table.get(atom_id).size.saturating_sub(delta) as u64,
 +                    file_index: ctx.file_index,
                  });
+             }
              SymKind::Abs => {
                      n_sect: NO_SECT,
                      n_desc: input_sym.raw.n_desc,
                      n_value: input_sym.value(),
 +                    size: 0,
 +                    file_index: ctx.file_index,
                  });
+             }
              SymKind::Undef | SymKind::Indirect => {}
      Ok(())
+ }
 +struct LocalSymbolContext<'a> {
 +    atom_table: &'a AtomTable,
 +    atom_ranges: &'a AtomRangeIndex,
 +    atom_sections: &'a HashMap<crate::resolve::AtomId, u8>,
 +    input_id: InputId,
 +    file_index: usize,
 +}
++
 +#[derive(Debug, Clone, Copy)]
 +struct AtomRange {
 +    atom: crate::resolve::AtomId,
 +    start: u32,
 +    end: u32,
 +}
++
 +type AtomRangeIndex = HashMap<(InputId, u8), Vec<AtomRange>>;
++
  fn is_assembler_temporary_symbol(name: &str) -> bool {
      name.starts_with('L') || name.starts_with("ltmp")
+ }
 -fn find_containing_atom(
 +fn build_atom_range_index(
      atom_table: &AtomTable,
      atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
 +    icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +) -> AtomRangeIndex {
 +    let mut out = HashMap::with_capacity(atoms_by_input_section.len());
 +    for (&key, ids) in atoms_by_input_section {
 +        let mut ranges = Vec::with_capacity(ids.len());
 +        for atom_id in ids {
 +            let atom = atom_table.get(*atom_id);
 +            ranges.push(AtomRange {
 +                atom: canonical_atom(*atom_id, icf_redirects),
 +                start: atom.input_offset,
 +                end: atom.input_offset.saturating_add(atom.size),
 +            });
 +        }
 +        ranges.sort_by(|lhs, rhs| {
 +            lhs.start
 +                .cmp(&rhs.start)
 +                .then_with(|| lhs.end.cmp(&rhs.end))
 +        });
 +        out.insert(key, ranges);
 +    }
 +    out
 +}
++
 +fn find_containing_atom(
 +    atom_ranges: &AtomRangeIndex,
      input_id: InputId,
      input_section: u8,
      offset: u32,
  ) -> Option<(crate::resolve::AtomId, u32)> {
 -    find_containing_atom_range(
 -        atom_table,
 -        atoms_by_input_section,
 -        input_id,
 -        input_section,
 -        offset,
 -        1,
 -    )
 +    find_containing_atom_range(atom_ranges, input_id, input_section, offset, 1)
+ }
  fn find_containing_atom_range(
 -    atom_table: &AtomTable,
 -    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
 +    atom_ranges: &AtomRangeIndex,
      input_id: InputId,
      input_section: u8,
      offset: u32,
      len: u32,
  ) -> Option<(crate::resolve::AtomId, u32)> {
 -    atoms_by_input_section
 -        .get(&(input_id, input_section))
 -        .and_then(|ids| {
 -            ids.iter().find_map(|atom_id| {
 -                let atom = atom_table.get(*atom_id);
 -                let start = atom.input_offset;
 -                let end = atom.input_offset.saturating_add(atom.size);
 -                let range_end = offset.checked_add(len)?;
 -                (start <= offset && range_end <= end).then_some((*atom_id, offset - start))
 -            })
 -        })
 +    let ranges = atom_ranges.get(&(input_id, input_section))?;
 +    let range_end = offset.checked_add(len)?;
 +    let idx = ranges.partition_point(|range| range.start <= offset);
 +    let range = idx.checked_sub(1).and_then(|idx| ranges.get(idx))?;
 +    (range.start <= offset && range_end <= range.end).then_some((range.atom, offset - range.start))
 +}
++
 +fn canonical_atom(
 +    atom_id: crate::resolve::AtomId,
 +    redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +) -> crate::resolve::AtomId {
 +    let Some(redirects) = redirects else {
 +        return atom_id;
 +    };
 +    let mut current = atom_id;
 +    while let Some(&next) = redirects.get(&current) {
 +        if next == current {
 +            break;
 +        }
 +        current = next;
 +    }
 +    current
+ }
  fn input_symbol_type(input_sym: &InputSymbol) -> u8 {
+ }
  fn defined_symbol_type(private_extern: bool) -> u8 {
 -    let mut n_type = N_SECT | N_EXT;
      if private_extern {
 -        n_type |= N_PEXT;
 +        N_SECT | N_PEXT
 +    } else {
 +        N_SECT | N_EXT
+     }
 -    n_type
+ }
  fn absolute_symbol_type(private_extern: bool) -> u8 {
 -    let mut n_type = N_ABS | N_EXT;
      if private_extern {
 -        n_type |= N_PEXT;
 +        N_ABS | N_PEXT
 +    } else {
 +        N_ABS | N_EXT
+     }
 -    n_type
 +}
++
 +fn read_symbol_patterns(path: &PathBuf) -> Result<Vec<String>, WriteError> {
 +    let contents = fs::read_to_string(path)
 +        .map_err(|err| WriteError::SymbolListRead(path.clone(), err.to_string()))?;
 +    Ok(contents
 +        .lines()
 +        .map(str::trim)
 +        .filter(|line| !line.is_empty())
 +        .map(ToString::to_string)
 +        .collect())
 +}
++
 +fn wildcard_matches(pattern: &str, value: &str) -> bool {
 +    let pattern = pattern.as_bytes();
 +    let value = value.as_bytes();
 +    let mut p = 0usize;
 +    let mut v = 0usize;
 +    let mut star = None;
 +    let mut backtrack = 0usize;
++
 +    while v < value.len() {
 +        if p < pattern.len() && (pattern[p] == b'?' || pattern[p] == value[v]) {
 +            p += 1;
 +            v += 1;
 +        } else if p < pattern.len() && pattern[p] == b'*' {
 +            star = Some(p);
 +            p += 1;
 +            backtrack = v;
 +        } else if let Some(star_idx) = star {
 +            p = star_idx + 1;
 +            backtrack += 1;
 +            v = backtrack;
 +        } else {
 +            return false;
 +        }
 +    }
++
 +    while p < pattern.len() && pattern[p] == b'*' {
 +        p += 1;
 +    }
 +    p == pattern.len()
+ }
  fn place_optional_block(
      })
+ }
 +fn place_optional_linkedit_data_block(
 +    cursor: &mut u64,
 +    size: usize,
 +    context: &'static str,
 +) -> Result<Option<LinkEditDataCmd>, WriteError> {
 +    if size == 0 {
 +        return Ok(None);
 +    }
 +    Ok(Some(place_linkedit_data_block(cursor, size, context)?))
 +}
++
  fn push_indirect_section(
      indirect_symbols: &mut Vec<u32>,
      indirect_starts: &mut HashMap<(String, String), u32>,
          });
          let by_input_section = atoms.by_input_section();
 +        let atom_ranges = build_atom_range_index(&atoms, &by_input_section, None);
          assert_eq!(
 -            find_containing_atom(&atoms, &by_input_section, InputId(7), 3, 4),
 +            find_containing_atom(&atom_ranges, InputId(7), 3, 4),
              Some((first, 4))
          );
          assert_eq!(
 -            find_containing_atom_range(&atoms, &by_input_section, InputId(7), 3, 10, 2),
 +            find_containing_atom_range(&atom_ranges, InputId(7), 3, 10, 2),
              Some((second, 2))
          );
+     }

src/main.rsmodified

76 lines changed — click to load

  use afs_ld::{args, diag, dump, LinkError, Linker};
 +fn usage() -> &'static str {
 +    "\
 +Usage: afs-ld [options] <inputs...>
++
 +Options:
 +  -o <path>                       Write output to <path>
 +  -dylib                          Emit a dylib instead of an executable
 +  -e <symbol>                     Set the entry symbol
 +  -arch arm64                     Select the arm64 target
 +  -map <path>                     Emit text link map
 +  -why_live <symbol>              Print a reachability chain for <symbol>
 +  -l<name> / -l <name>            Search for library
 +  -L <dir>                        Add library search path
 +  -framework <name>               Link framework
 +  -weak_framework <name>          Link weak framework
 +  -ObjC                           Objective-C archive loading mode (currently a no-op warning)
 +  -syslibroot <path>              Prefix SDK search roots
 +  -platform_version macos <min> <sdk>
 +                                  Set LC_BUILD_VERSION payload
 +  -r                              Relocatable output (deferred; errors)
 +  -bundle                         Bundle output (deferred; errors)
 +  -undefined <error|warning|suppress|dynamic_lookup>
 +                                  Control unresolved-symbol treatment
 +  -rpath <path>                   Add LC_RPATH
 +  -install_name <path>            Override dylib install name
 +  -current_version <v>            Override dylib current version
 +  -compatibility_version <v>      Override dylib compatibility version
 +  -exported_symbols_list <file>   Export only symbols matching file patterns
 +  -unexported_symbols_list <file> Hide symbols matching file patterns
 +  -exported_symbol <sym>          Export one symbol/pattern
 +  -unexported_symbol <sym>        Hide one symbol/pattern
 +  -x                              Strip local symbols
 +  -S                              Strip debug symbols (currently a no-op warning)
 +  -no_uuid                        Omit LC_UUID
 +  -no_loh                         Accepted for compatibility (currently warns; no effect)
 +  -thunks=<none|safe|all>         Configure branch thunks
 +  -dead_strip                     Dead-strip unreferenced code/data
 +  -icf=safe | -icf=none | -icf=all
 +                                  Configure identical code folding (`all` currently errors)
 +  -fixup_chains | -no_fixup_chains
 +                                  Select chained fixups vs classic dyld info
 +  -all_load                       Force-load every archive member
 +  -force_load <archive>           Force-load one archive
 +  -Wl,<arg,arg,...>               Normalize comma-separated driver flags
 +  --dump <path>                   Dump a Mach-O file summary
 +  --dump-archive <path>           Dump an archive summary
 +  --dump-dylib <path>             Dump a dylib summary
 +  --dump-tbd <path>               Dump a TBD summary
 +  -t, -trace                      Print input paths as they are loaded
 +  -h, --help                      Show this help
 +  -v, --version                   Show afs-ld version
 +"
 +}
++
  fn main() -> ExitCode {
      let argv: Vec<String> = std::env::args().collect();
+         }
      };
 +    if opts.show_help {
 +        print!("{}", usage());
 +        return ExitCode::SUCCESS;
 +    }
++
 +    if opts.show_version {
 +        println!("afs-ld {}", env!("CARGO_PKG_VERSION"));
 +        return ExitCode::SUCCESS;
 +    }
++
      if let Some(path) = &opts.dump {
          return match dump::dump_file(path) {
              Ok(()) => ExitCode::SUCCESS,

src/reloc/arm64.rsmodified

1267 lines changed — click to load

  use std::fmt;
  use std::path::PathBuf;
 -use crate::atom::{Atom, AtomTable};
 +use crate::atom::{Atom, AtomSection, AtomTable};
  use crate::input::ObjectFile;
 -use crate::layout::{Layout, LayoutInput};
 +use crate::layout::{ExtraOutputSection, ExtraSectionAnchor, Layout, LayoutInput};
  use crate::macho::writer::LinkEditPlan;
  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind, RelocLength};
  use crate::resolve::{InputId, Symbol, SymbolId, SymbolTable};
 +use crate::section::{OutputSection, SectionKind};
  use crate::symbol::{InputSymbol, SymKind};
  use crate::synth::stubs::{STUB_HELPER_ENTRY_SIZE, STUB_HELPER_HEADER_SIZE, STUB_SIZE};
  use crate::synth::tlv::THREAD_VARIABLE_DESCRIPTOR_SIZE;
  use crate::synth::SyntheticPlan;
 +use crate::{LinkOptions, ThunkMode};
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct RelocError {
  struct ResolveView<'a> {
      sym_table: &'a SymbolTable,
 +    symbol_name_index: &'a HashMap<String, SymbolId>,
      atom_table: &'a AtomTable,
      atom_addrs: &'a HashMap<crate::resolve::AtomId, u64>,
      atoms_by_input_section: &'a HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      stub_helper_entry_addrs: &'a HashMap<SymbolId, u64>,
      stub_helper_header_addr: Option<u64>,
      dyld_private_addr: Option<u64>,
 +    icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
+ }
  struct SyntheticAddressMaps {
      dyld_private_addr: Option<u64>,
+ }
 +pub struct ApplyLayoutPlan<'a> {
 +    pub synthetic_plan: Option<&'a SyntheticPlan>,
 +    pub thunk_plan: Option<&'a ThunkPlan>,
 +    pub linkedit: &'a LinkEditPlan,
 +    pub icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +}
++
 +struct InputSectionResolveCtx<'a> {
 +    obj: &'a ObjectFile,
 +    atom: &'a Atom,
 +    kind: RelocKind,
 +    referent: &'a str,
 +}
++
 +const THUNK_SIZE: u64 = 12;
 +const BR_X16: u32 = 0xd61f_0200;
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 +enum BranchTargetKey {
 +    Symbol(SymbolId),
 +    Stub(SymbolId),
 +    InputSectionOffset {
 +        origin: InputId,
 +        input_section: u8,
 +        input_offset: u32,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +struct ThunkBucketKey {
 +    island: usize,
 +    target: BranchTargetKey,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct ThunkIsland {
 +    segment: String,
 +    after_atom: crate::resolve::AtomId,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct ThunkEntry {
 +    island: usize,
 +    slot_in_island: usize,
 +    target: BranchTargetKey,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Default)]
 +pub struct ThunkPlan {
 +    redirects: HashMap<(crate::resolve::AtomId, u32), usize>,
 +    islands: Vec<ThunkIsland>,
 +    entries: Vec<ThunkEntry>,
 +}
++
 +impl ThunkPlan {
 +    pub fn split_after_atoms(&self) -> Vec<crate::resolve::AtomId> {
 +        self.islands
 +            .iter()
 +            .map(|island| island.after_atom)
 +            .collect()
 +    }
++
 +    pub fn output_sections(&self) -> Vec<ExtraOutputSection> {
 +        if self.entries.is_empty() {
 +            return Vec::new();
 +        }
 +        let mut counts = vec![0usize; self.islands.len()];
 +        for entry in &self.entries {
 +            counts[entry.island] += 1;
 +        }
 +        let mut sections = Vec::new();
 +        for (island, island_desc) in self.islands.iter().enumerate() {
 +            let count = counts[island];
 +            if count == 0 {
 +                continue;
 +            }
 +            sections.push(ExtraOutputSection {
 +                after_section: Some(ExtraSectionAnchor::AfterAtom(island_desc.after_atom)),
 +                section: OutputSection {
 +                    segment: island_desc.segment.clone(),
 +                    name: "__thunks".into(),
 +                    kind: SectionKind::Text,
 +                    align_pow2: 2,
 +                    flags: crate::macho::constants::S_REGULAR
 +                        | crate::macho::constants::S_ATTR_PURE_INSTRUCTIONS
 +                        | crate::macho::constants::S_ATTR_SOME_INSTRUCTIONS,
 +                    reserved1: 0,
 +                    reserved2: 0,
 +                    reserved3: 0,
 +                    atoms: Vec::new(),
 +                    synthetic_offset: 0,
 +                    synthetic_data: vec![0; count * THUNK_SIZE as usize],
 +                    addr: 0,
 +                    size: (count as u64) * THUNK_SIZE,
 +                    file_off: 0,
 +                },
 +            });
 +        }
 +        sections
 +    }
++
 +    fn redirect_for(&self, atom: crate::resolve::AtomId, atom_offset: u32) -> Option<usize> {
 +        self.redirects.get(&(atom, atom_offset)).copied()
 +    }
++
 +    fn thunk_addrs(&self, layout: &Layout) -> HashMap<usize, u64> {
 +        let bases: HashMap<_, _> = self
 +            .islands
 +            .iter()
 +            .enumerate()
 +            .filter_map(|(island_idx, island)| {
 +                find_thunk_section_index(layout, island)
 +                    .map(|section_idx| (island_idx, layout.sections[section_idx].addr))
 +            })
 +            .collect();
 +        self.entries
 +            .iter()
 +            .enumerate()
 +            .filter_map(|(index, entry)| {
 +                bases
 +                    .get(&entry.island)
 +                    .copied()
 +                    .map(|base| (index, base + (entry.slot_in_island as u64) * THUNK_SIZE))
 +            })
 +            .collect()
 +    }
 +}
++
  pub fn apply_layout(
      layout: &mut Layout,
      inputs: &[LayoutInput<'_>],
      atoms: &AtomTable,
      sym_table: &SymbolTable,
 -    synthetic_plan: Option<&SyntheticPlan>,
 -    linkedit: &LinkEditPlan,
 +    plan: ApplyLayoutPlan<'_>,
  ) -> Result<(), RelocError> {
      let input_map: HashMap<InputId, &ObjectFile> = inputs
          .iter()
      let atom_addrs = atom_address_map(layout);
      let atoms_by_input_section = atoms.by_input_section();
      let section_addrs = input_section_address_map(layout, atoms);
 -    let synth_addrs = synthetic_address_maps(layout, synthetic_plan);
 +    let synth_addrs = synthetic_address_maps(layout, plan.synthetic_plan);
 +    let symbol_name_index = build_symbol_name_index(sym_table);
      let resolve = ResolveView {
          sym_table,
 +        symbol_name_index: &symbol_name_index,
          atom_table: atoms,
          atom_addrs: &atom_addrs,
          atoms_by_input_section: &atoms_by_input_section,
          stub_helper_entry_addrs: &synth_addrs.stub_helper_entry_addrs,
          stub_helper_header_addr: synth_addrs.stub_helper_header_addr,
          dyld_private_addr: synth_addrs.dyld_private_addr,
 +        icf_redirects: plan.icf_redirects,
      };
 +    let thunk_addrs = plan
 +        .thunk_plan
 +        .map(|thunk_plan| thunk_plan.thunk_addrs(layout));
      for out_section in &mut layout.sections {
          for placed in &mut out_section.atoms {
                      "missing parsed object".to_string(),
+                 )
              })?;
 +            patch_eh_frame_cie_pointer(&mut placed.data, atom, &resolve)?;
              let relocs = reloc_cache
                  .get(&(atom.origin, atom.input_section))
                  .map(Vec::as_slice)
                  .unwrap_or(&[]);
              for reloc in relocs_for_atom(relocs, atom) {
 -                apply_one(&mut placed.data, atom, obj, reloc, &resolve)?;
 +                apply_one(
 +                    &mut placed.data,
 +                    atom,
 +                    obj,
 +                    reloc,
 +                    &resolve,
 +                    plan.thunk_plan,
 +                    thunk_addrs.as_ref(),
 +                )?;
+             }
+         }
+     }
 -    if let Some(plan) = synthetic_plan {
 +    if let Some(thunk_plan) = plan.thunk_plan {
 +        synthesize_thunk_section(layout, thunk_plan, &resolve)?;
 +    }
++
 +    if let Some(synthetic_plan) = plan.synthetic_plan {
          synthesize_thread_variable_section(
              layout,
 -            plan,
 +            synthetic_plan,
              atoms,
              &input_map,
              &reloc_cache,
              &resolve,
          )?;
 -        synthesize_got_section(layout, plan, &resolve)?;
 -        synthesize_stub_section(layout, plan, &resolve)?;
 -        synthesize_lazy_pointer_section(layout, plan, &resolve)?;
 -        synthesize_stub_helper_section(layout, plan, &resolve, linkedit)?;
 +        synthesize_got_section(layout, synthetic_plan, &resolve)?;
 +        synthesize_stub_section(layout, synthetic_plan, &resolve)?;
 +        synthesize_lazy_pointer_section(layout, synthetic_plan, &resolve)?;
 +        synthesize_stub_helper_section(layout, synthetic_plan, &resolve, plan.linkedit)?;
+     }
      Ok(())
+ }
 +fn patch_eh_frame_cie_pointer(
 +    bytes: &mut [u8],
 +    atom: &Atom,
 +    resolve: &ResolveView<'_>,
 +) -> Result<(), RelocError> {
 +    if atom.section != AtomSection::EhFrame || bytes.len() < 8 {
 +        return Ok(());
 +    }
 +    let mut buf = [0u8; 4];
 +    buf.copy_from_slice(&bytes[4..8]);
 +    let cie_delta = u32::from_le_bytes(buf);
 +    if cie_delta == 0 {
 +        return Ok(());
 +    }
++
 +    let cie_offset = atom
 +        .input_offset
 +        .checked_add(4)
 +        .and_then(|value| value.checked_sub(cie_delta))
 +        .ok_or_else(|| {
 +            reloc_error(
 +                atom,
 +                &PathBuf::from("<eh_frame>"),
 +                4,
 +                RelocKind::Unsigned,
 +                "__eh_frame CIE pointer",
 +                "invalid CIE back-pointer".to_string(),
 +            )
 +        })?;
 +    let cie_atom = resolve
 +        .atoms_by_input_section
 +        .get(&(atom.origin, atom.input_section))
 +        .and_then(|atom_ids| {
 +            atom_ids.iter().find_map(|atom_id| {
 +                let candidate = resolve.atom_table.get(*atom_id);
 +                let start = candidate.input_offset;
 +                let end = candidate.input_offset.saturating_add(candidate.size);
 +                (start <= cie_offset && cie_offset < end).then_some(*atom_id)
 +            })
 +        })
 +        .and_then(|atom_id| resolve.atom_addrs.get(&atom_id).copied())
 +        .ok_or_else(|| {
 +            reloc_error(
 +                atom,
 +                &PathBuf::from("<eh_frame>"),
 +                4,
 +                RelocKind::Unsigned,
 +                "__eh_frame CIE pointer",
 +                "eh_frame CIE atom is missing from the final layout".to_string(),
 +            )
 +        })?;
 +    let fde_field = resolve.atom_addrs.get(&atom.id).copied().ok_or_else(|| {
 +        reloc_error(
 +            atom,
 +            &PathBuf::from("<eh_frame>"),
 +            4,
 +            RelocKind::Unsigned,
 +            "__eh_frame CIE pointer",
 +            "eh_frame atom is missing a final address".to_string(),
 +        )
 +    })? + 4;
 +    let rewritten = fde_field.wrapping_sub(cie_atom) as u32;
 +    bytes[4..8].copy_from_slice(&rewritten.to_le_bytes());
 +    Ok(())
 +}
++
  fn relocs_for_atom<'a>(relocs: &'a [Reloc], atom: &Atom) -> impl Iterator<Item = Reloc> + 'a {
      let start = atom.input_offset;
      let end = atom.input_offset + atom.size;
      out
+ }
 +fn atom_output_segment_map(layout: &Layout) -> HashMap<crate::resolve::AtomId, String> {
 +    let mut out = HashMap::new();
 +    for section in &layout.sections {
 +        for placed in &section.atoms {
 +            out.insert(placed.atom, section.segment.clone());
 +        }
 +    }
 +    out
 +}
++
  fn synthetic_address_maps(
      layout: &Layout,
      synthetic_plan: Option<&SyntheticPlan>,
+     }
+ }
 +pub fn plan_thunks(
 +    opts: &LinkOptions,
 +    layout: &Layout,
 +    inputs: &[LayoutInput<'_>],
 +    atoms: &AtomTable,
 +    sym_table: &SymbolTable,
 +    synthetic_plan: Option<&SyntheticPlan>,
 +    icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +) -> Result<Option<ThunkPlan>, RelocError> {
 +    if opts.thunks == ThunkMode::None {
 +        return Ok(None);
 +    }
++
 +    let input_map: HashMap<InputId, &ObjectFile> = inputs
 +        .iter()
 +        .map(|input| (input.id, input.object))
 +        .collect();
 +    let mut reloc_cache: HashMap<(InputId, u8), Vec<Reloc>> = HashMap::new();
 +    for input in inputs {
 +        for (sect_idx, section) in input.object.sections.iter().enumerate() {
 +            let relocs = if section.nreloc == 0 {
 +                Vec::new()
 +            } else {
 +                let raws =
 +                    parse_raw_relocs(&section.raw_relocs, 0, section.nreloc).map_err(|err| {
 +                        RelocError {
 +                            input: input.object.path.clone(),
 +                            atom: crate::resolve::AtomId(0),
 +                            atom_offset: 0,
 +                            kind: RelocKind::Unsigned,
 +                            referent: format!("section {},{}", section.segname, section.sectname),
 +                            detail: err.to_string(),
 +                        }
 +                    })?;
 +                parse_relocs(&raws).map_err(|err| RelocError {
 +                    input: input.object.path.clone(),
 +                    atom: crate::resolve::AtomId(0),
 +                    atom_offset: 0,
 +                    kind: RelocKind::Unsigned,
 +                    referent: format!("section {},{}", section.segname, section.sectname),
 +                    detail: err.to_string(),
 +                })?
 +            };
 +            reloc_cache.insert((input.id, (sect_idx + 1) as u8), relocs);
 +        }
 +    }
++
 +    let atom_addrs = atom_address_map(layout);
 +    let atom_segments = atom_output_segment_map(layout);
 +    let atoms_by_input_section = atoms.by_input_section();
 +    let section_addrs = input_section_address_map(layout, atoms);
 +    let synth_addrs = synthetic_address_maps(layout, synthetic_plan);
 +    let symbol_name_index = build_symbol_name_index(sym_table);
 +    let resolve = ResolveView {
 +        sym_table,
 +        symbol_name_index: &symbol_name_index,
 +        atom_table: atoms,
 +        atom_addrs: &atom_addrs,
 +        atoms_by_input_section: &atoms_by_input_section,
 +        section_addrs: &section_addrs,
 +        stub_addrs: &synth_addrs.stub_addrs,
 +        got_addrs: &synth_addrs.got_addrs,
 +        lazy_pointer_addrs: &synth_addrs.lazy_pointer_addrs,
 +        stub_helper_entry_addrs: &synth_addrs.stub_helper_entry_addrs,
 +        stub_helper_header_addr: synth_addrs.stub_helper_header_addr,
 +        dyld_private_addr: synth_addrs.dyld_private_addr,
 +        icf_redirects,
 +    };
++
 +    let mut redirects = HashMap::new();
 +    let mut island_index: HashMap<crate::resolve::AtomId, usize> = HashMap::new();
 +    let mut index: HashMap<ThunkBucketKey, usize> = HashMap::new();
 +    let mut islands: Vec<ThunkIsland> = Vec::new();
 +    let mut entries: Vec<ThunkEntry> = Vec::new();
 +    for (atom_id, atom) in atoms.iter() {
 +        let Some(obj) = input_map.get(&atom.origin) else {
 +            continue;
 +        };
 +        let relocs = reloc_cache
 +            .get(&(atom.origin, atom.input_section))
 +            .map(Vec::as_slice)
 +            .unwrap_or(&[]);
 +        for reloc in relocs_for_atom(relocs, atom) {
 +            if reloc.kind != RelocKind::Branch26 {
 +                continue;
 +            }
 +            let local_offset = reloc.offset.saturating_sub(atom.input_offset);
 +            let Some(place) = resolve.atom_addrs.get(&atom.id).copied() else {
 +                continue;
 +            };
 +            let Some(caller_segment) = atom_segments.get(&atom.id).cloned() else {
 +                continue;
 +            };
 +            let place = place + local_offset as u64;
 +            let target_key = resolve_branch_target_key(obj, atom, reloc, &resolve)?;
 +            let target = resolve_branch_target_from_key(obj, atom, reloc, target_key, &resolve)?;
 +            let needs_thunk = match opts.thunks {
 +                ThunkMode::None => false,
 +                ThunkMode::Safe => !branch26_in_range(place, target),
 +                ThunkMode::All => true,
 +            };
 +            if !needs_thunk {
 +                continue;
 +            }
 +            let island = if let Some(&existing) = island_index.get(&atom_id) {
 +                existing
 +            } else {
 +                let next = islands.len();
 +                islands.push(ThunkIsland {
 +                    segment: caller_segment.clone(),
 +                    after_atom: atom_id,
 +                });
 +                island_index.insert(atom_id, next);
 +                next
 +            };
 +            let bucket_key = ThunkBucketKey {
 +                island,
 +                target: target_key,
 +            };
 +            let thunk_index = if let Some(&existing) = index.get(&bucket_key) {
 +                existing
 +            } else {
 +                let next = entries.len();
 +                let slot_in_island = entries
 +                    .iter()
 +                    .filter(|entry| entry.island == island)
 +                    .count();
 +                entries.push(ThunkEntry {
 +                    island,
 +                    slot_in_island,
 +                    target: target_key,
 +                });
 +                index.insert(bucket_key, next);
 +                next
 +            };
 +            redirects.insert((atom_id, local_offset), thunk_index);
 +        }
 +    }
++
 +    if entries.is_empty() {
 +        Ok(None)
 +    } else {
 +        Ok(Some(ThunkPlan {
 +            redirects,
 +            islands,
 +            entries,
 +        }))
 +    }
 +}
++
  fn apply_one(
      bytes: &mut [u8],
      atom: &Atom,
      obj: &ObjectFile,
      reloc: Reloc,
      resolve: &ResolveView<'_>,
 +    thunk_plan: Option<&ThunkPlan>,
 +    thunk_addrs: Option<&HashMap<usize, u64>>,
  ) -> Result<(), RelocError> {
      let local_offset = reloc.offset.checked_sub(atom.input_offset).ok_or_else(|| {
          reloc_error(
      })? + local_offset as u64;
      match reloc.kind {
          RelocKind::Unsigned => {
 -            if dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table).is_some() {
 +            if dylib_import_symbol_id(obj, reloc.referent, resolve).is_some() {
                  if direct_import_bind_supported(reloc) {
                      clear_direct_import_slot(bytes, atom, obj, local_offset, reloc)
                  } else {
              resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)?,
              resolve,
          ),
 -        RelocKind::Branch26 => patch_branch26(
 -            bytes,
 -            atom,
 -            obj,
 -            local_offset,
 -            reloc,
 -            place,
 -            resolve_branch_target(obj, atom, reloc, resolve)?,
 -        ),
 +        RelocKind::Branch26 => {
 +            let target = if let Some(plan) = thunk_plan {
 +                if let Some(index) = plan.redirect_for(atom.id, local_offset) {
 +                    thunk_addrs
 +                        .and_then(|addrs| addrs.get(&index).copied())
 +                        .ok_or_else(|| {
 +                            reloc_error(
 +                                atom,
 +                                &obj.path,
 +                                local_offset,
 +                                reloc.kind,
 +                                &describe_referent(obj, reloc.referent),
 +                                "thunk section missing final address".to_string(),
 +                            )
 +                        })?
 +                } else {
 +                    resolve_branch_target(obj, atom, reloc, resolve)?
 +                }
 +            } else {
 +                resolve_branch_target(obj, atom, reloc, resolve)?
 +            };
 +            patch_branch26(bytes, atom, obj, local_offset, reloc, place, target)
 +        }
          RelocKind::Page21 => patch_page21(
              bytes,
              atom,
          ),
          RelocKind::TlvpLoadPageOff12 => {
              let target = resolve_tlvp_pageoff_target(obj, atom, reloc, resolve)?;
 -            if dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table).is_some() {
 +            if dylib_import_symbol_id(obj, reloc.referent, resolve).is_some() {
                  patch_pageoff12(bytes, atom, obj, local_offset, reloc, target)
              } else {
                  patch_tlvp_pageoff12(bytes, atom, obj, local_offset, reloc, target)
      reloc: Reloc,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
 -    if let Some(symbol_id) = dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table) {
 -        return resolve.stub_addrs.get(&symbol_id).copied().ok_or_else(|| {
 -            reloc_error(
 +    let key = resolve_branch_target_key(obj, atom, reloc, resolve)?;
 +    resolve_branch_target_from_key(obj, atom, reloc, key, resolve)
 +}
++
 +fn resolve_branch_target_key(
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    reloc: Reloc,
 +    resolve: &ResolveView<'_>,
 +) -> Result<BranchTargetKey, RelocError> {
 +    if let Some(symbol_id) = dylib_import_symbol_id(obj, reloc.referent, resolve) {
 +        return Ok(BranchTargetKey::Stub(symbol_id));
 +    }
 +    match reloc.referent {
 +        Referent::Section(section_idx) => Ok(BranchTargetKey::InputSectionOffset {
 +            origin: atom.origin,
 +            input_section: section_idx,
 +            input_offset: 0,
 +        }),
 +        Referent::Symbol(sym_idx) => {
 +            let input_sym = obj.symbols.get(sym_idx as usize).ok_or_else(|| {
 +                reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    0,
 +                    reloc.kind,
 +                    &format!("symbol #{sym_idx}"),
 +                    "symbol index is out of range".to_string(),
 +                )
 +            })?;
 +            if let Ok(name) = obj.symbol_name(input_sym) {
 +                if let Some(symbol_id) = resolve.symbol_name_index.get(name).copied() {
 +                    return Ok(BranchTargetKey::Symbol(symbol_id));
 +                }
 +            }
 +            match input_sym.kind() {
 +                SymKind::Sect => {
 +                    let section = obj.section_for_symbol(input_sym).ok_or_else(|| {
 +                        reloc_error(
 +                            atom,
 +                            &obj.path,
 +                            0,
 +                            reloc.kind,
 +                            &describe_input_symbol(obj, input_sym),
 +                            "section-backed symbol did not resolve to an input section".to_string(),
 +                        )
 +                    })?;
 +                    Ok(BranchTargetKey::InputSectionOffset {
 +                        origin: atom.origin,
 +                        input_section: input_sym.sect_idx(),
 +                        input_offset: input_sym.value().saturating_sub(section.addr) as u32,
 +                    })
 +                }
 +                SymKind::Abs => Err(reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    0,
 +                    reloc.kind,
 +                    &describe_input_symbol(obj, input_sym),
 +                    "absolute BRANCH26 targets are not supported".to_string(),
 +                )),
 +                SymKind::Undef => Err(reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    0,
 +                    reloc.kind,
 +                    &describe_input_symbol(obj, input_sym),
 +                    "symbol remained undefined at relocation time".to_string(),
 +                )),
 +                SymKind::Indirect => Err(reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    0,
 +                    reloc.kind,
 +                    &describe_input_symbol(obj, input_sym),
 +                    "indirect BRANCH26 targets are not yet supported".to_string(),
 +                )),
 +            }
 +        }
 +    }
 +}
++
 +fn resolve_branch_target_from_key(
 +    obj: &ObjectFile,
 +    atom: &Atom,
 +    reloc: Reloc,
 +    key: BranchTargetKey,
 +    resolve: &ResolveView<'_>,
 +) -> Result<u64, RelocError> {
 +    match key {
 +        BranchTargetKey::Symbol(symbol_id) => match resolve.sym_table.get(symbol_id) {
 +            Symbol::Defined {
 +                atom: target_atom,
 +                value,
 +                ..
 +            } => resolve
 +                .atom_addrs
 +                .get(&canonical_atom(*target_atom, resolve.icf_redirects))
 +                .copied()
 +                .map(|addr| addr + *value)
 +                .ok_or_else(|| {
 +                    reloc_error(
 +                        atom,
 +                        &obj.path,
 +                        reloc.offset.saturating_sub(atom.input_offset),
 +                        reloc.kind,
 +                        &describe_referent(obj, reloc.referent),
 +                        "target atom missing final address".to_string(),
 +                    )
 +                }),
 +            Symbol::DylibImport { .. } => Err(reloc_error(
                  atom,
                  &obj.path,
                  reloc.offset.saturating_sub(atom.input_offset),
                  reloc.kind,
                  &describe_referent(obj, reloc.referent),
                  "dylib import is missing synthetic stub".to_string(),
 -            )
 -        });
 +            )),
 +            other => Err(reloc_error(
 +                atom,
 +                &obj.path,
 +                reloc.offset.saturating_sub(atom.input_offset),
 +                reloc.kind,
 +                &describe_referent(obj, reloc.referent),
 +                format!("symbol resolved to unsupported state {:?}", other.kind()),
 +            )),
 +        },
 +        BranchTargetKey::Stub(symbol_id) => {
 +            resolve.stub_addrs.get(&symbol_id).copied().ok_or_else(|| {
 +                reloc_error(
 +                    atom,
 +                    &obj.path,
 +                    reloc.offset.saturating_sub(atom.input_offset),
 +                    reloc.kind,
 +                    &describe_referent(obj, reloc.referent),
 +                    "dylib import is missing synthetic stub".to_string(),
 +                )
 +            })
 +        }
 +        BranchTargetKey::InputSectionOffset {
 +            origin,
 +            input_section,
 +            input_offset,
 +        } => resolve_input_section_offset(
 +            origin,
 +            input_section,
 +            input_offset,
 +            InputSectionResolveCtx {
 +                obj,
 +                atom,
 +                kind: reloc.kind,
 +                referent: &describe_referent(obj, reloc.referent),
 +            },
 +            resolve,
 +        ),
+     }
 -    resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)
 +}
++
 +fn branch26_in_range(place: u64, target: u64) -> bool {
 +    let delta = target.wrapping_sub(place) as i64;
 +    delta & 0b11 == 0 && fits_signed(delta >> 2, 26)
 +}
++
 +fn synthesize_thunk_section(
 +    layout: &mut Layout,
 +    plan: &ThunkPlan,
 +    resolve: &ResolveView<'_>,
 +) -> Result<(), RelocError> {
 +    let mut counts: HashMap<usize, usize> = HashMap::new();
 +    for entry in &plan.entries {
 +        *counts.entry(entry.island).or_insert(0usize) += 1;
 +    }
 +    for (island_idx, island) in plan.islands.iter().enumerate() {
 +        let expected_len = counts.get(&island_idx).copied().unwrap_or(0) * THUNK_SIZE as usize;
 +        let section_idx = find_thunk_section_index(layout, island).ok_or_else(|| RelocError {
 +            input: PathBuf::from("<synthetic thunks>"),
 +            atom: crate::resolve::AtomId(0),
 +            atom_offset: (island_idx as u32) * THUNK_SIZE as u32,
 +            kind: RelocKind::Branch26,
 +            referent: "thunk section".to_string(),
 +            detail: format!(
 +                "missing thunk section for island after {},{}",
 +                island.segment, island.after_atom.0
 +            ),
 +        })?;
 +        let section = &mut layout.sections[section_idx];
 +        if section.synthetic_data.len() != expected_len {
 +            section.synthetic_data.resize(expected_len, 0);
 +        }
 +    }
 +    for (idx, entry) in plan.entries.iter().enumerate() {
 +        let island = &plan.islands[entry.island];
 +        let section_idx = find_thunk_section_index(layout, island).ok_or_else(|| RelocError {
 +            input: PathBuf::from("<synthetic thunks>"),
 +            atom: crate::resolve::AtomId(0),
 +            atom_offset: (idx as u32) * THUNK_SIZE as u32,
 +            kind: RelocKind::Branch26,
 +            referent: "thunk section".to_string(),
 +            detail: format!(
 +                "missing thunk section for island after {},{}",
 +                island.segment, island.after_atom.0
 +            ),
 +        })?;
 +        let section = &mut layout.sections[section_idx];
 +        let thunk_addr = section.addr + (entry.slot_in_island as u64) * THUNK_SIZE;
 +        let target = match entry.target {
 +            BranchTargetKey::Symbol(symbol_id) => match resolve.sym_table.get(symbol_id) {
 +                Symbol::Defined { atom, value, .. } => resolve
 +                    .atom_addrs
 +                    .get(&canonical_atom(*atom, resolve.icf_redirects))
 +                    .copied()
 +                    .map(|addr| addr + *value),
 +                _ => None,
 +            },
 +            BranchTargetKey::Stub(symbol_id) => resolve.stub_addrs.get(&symbol_id).copied(),
 +            BranchTargetKey::InputSectionOffset {
 +                origin,
 +                input_section,
 +                input_offset,
 +            } => resolve_input_section_offset_simple(origin, input_section, input_offset, resolve),
 +        }
 +        .ok_or_else(|| RelocError {
 +            input: PathBuf::from("<synthetic thunks>"),
 +            atom: crate::resolve::AtomId(0),
 +            atom_offset: (idx as u32) * THUNK_SIZE as u32,
 +            kind: RelocKind::Branch26,
 +            referent: "thunk target".to_string(),
 +            detail: "missing final target address".to_string(),
 +        })?;
 +        let adrp = encode_adrp_reg(16, thunk_addr, target, "thunk target")?;
 +        let add = encode_add_x_reg_pageoff(16, target, "thunk target")?;
 +        let start = entry.slot_in_island * THUNK_SIZE as usize;
 +        section.synthetic_data[start..start + 4].copy_from_slice(&adrp.to_le_bytes());
 +        section.synthetic_data[start + 4..start + 8].copy_from_slice(&add.to_le_bytes());
 +        section.synthetic_data[start + 8..start + 12].copy_from_slice(&BR_X16.to_le_bytes());
 +    }
 +    Ok(())
 +}
++
 +fn find_thunk_section_index(layout: &Layout, island: &ThunkIsland) -> Option<usize> {
 +    layout
 +        .sections
 +        .iter()
 +        .enumerate()
 +        .skip(1)
 +        .find_map(|(idx, section)| {
 +            let prev = &layout.sections[idx - 1];
 +            (prev.segment == island.segment
 +                && prev
 +                    .atoms
 +                    .last()
 +                    .map(|placed| placed.atom == island.after_atom)
 +                    .unwrap_or(false)
 +                && section.segment == island.segment
 +                && section.name == "__thunks")
 +                .then_some(idx)
 +        })
+ }
  fn resolve_got_target(
      reloc: Reloc,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
 -    let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, resolve.sym_table) else {
 +    let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, resolve) else {
          return Err(reloc_error(
              atom,
              &obj.path,
+ }
  fn got_reloc_relaxes_locally(obj: &ObjectFile, reloc: Reloc, resolve: &ResolveView<'_>) -> bool {
 -    symbol_referent_id(obj, reloc.referent, resolve.sym_table)
 -        .map(|symbol_id| !matches!(resolve.sym_table.get(symbol_id), Symbol::DylibImport { .. }))
 -        .unwrap_or(false)
 +    match symbol_referent_id(obj, reloc.referent, resolve) {
 +        Some(symbol_id) => match resolve.sym_table.get(symbol_id) {
 +            Symbol::DylibImport { .. } => false,
 +            Symbol::Defined { .. } => true,
 +            _ => true,
 +        },
 +        None => true,
 +    }
+ }
  fn resolve_tlvp_target(
      reloc: Reloc,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
 -    if dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table).is_some() {
 +    if dylib_import_symbol_id(obj, reloc.referent, resolve).is_some() {
          return resolve_got_target(obj, atom, reloc, resolve);
+     }
      resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)
      reloc: Reloc,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
 -    if dylib_import_symbol_id(obj, reloc.referent, resolve.sym_table).is_some() {
 +    if dylib_import_symbol_id(obj, reloc.referent, resolve).is_some() {
          return resolve_got_target(obj, atom, reloc, resolve);
+     }
      resolve_referent(obj, atom, reloc.kind, reloc.referent, resolve)
      })?;
      if let Ok(name) = obj.symbol_name(input_sym) {
 -        if let Some((_, symbol)) = resolve
 -            .sym_table
 -            .iter()
 -            .find(|(_, symbol)| resolve.sym_table.interner.resolve(symbol.name()) == name)
 -        {
 -            return resolve_global_symbol(obj, atom, kind, name, symbol, resolve);
 +        if let Some(symbol_id) = resolve.symbol_name_index.get(name).copied() {
 +            return resolve_global_symbol(
 +                obj,
 +                atom,
 +                kind,
 +                name,
 +                resolve.sym_table.get(symbol_id),
 +                resolve,
 +            );
+         }
+     }
  fn dylib_import_symbol_id(
      obj: &ObjectFile,
      referent: Referent,
 -    sym_table: &SymbolTable,
 +    resolve: &ResolveView<'_>,
  ) -> Option<SymbolId> {
 -    let symbol_id = symbol_referent_id(obj, referent, sym_table)?;
 -    matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. }).then_some(symbol_id)
 +    let symbol_id = symbol_referent_id(obj, referent, resolve)?;
 +    matches!(resolve.sym_table.get(symbol_id), Symbol::DylibImport { .. }).then_some(symbol_id)
+ }
  fn symbol_referent_id(
      obj: &ObjectFile,
      referent: Referent,
 -    sym_table: &SymbolTable,
 +    resolve: &ResolveView<'_>,
  ) -> Option<SymbolId> {
      let Referent::Symbol(sym_idx) = referent else {
          return None;
      };
      let input_sym = obj.symbols.get(sym_idx as usize)?;
      let name = obj.symbol_name(input_sym).ok()?;
 -    let (symbol_id, symbol) = sym_table
 +    resolve.symbol_name_index.get(name).copied()
 +}
++
 +fn build_symbol_name_index(sym_table: &SymbolTable) -> HashMap<String, SymbolId> {
 +    sym_table
          .iter()
 -        .find(|(_, symbol)| sym_table.interner.resolve(symbol.name()) == name)?;
 -    let _ = symbol;
 -    Some(symbol_id)
 +        .map(|(symbol_id, symbol)| {
 +            (
 +                sym_table.interner.resolve(symbol.name()).to_string(),
 +                symbol_id,
 +            )
 +        })
 +        .collect()
+ }
  fn resolve_global_symbol(
              let section_offset = input_sym.value().saturating_sub(section.addr) as u32;
              resolve_input_section_offset(
                  origin,
 -                obj,
 -                atom,
 -                kind,
                  input_sym.sect_idx(),
                  section_offset,
 -                &describe_input_symbol(obj, input_sym),
 +                InputSectionResolveCtx {
 +                    obj,
 +                    atom,
 +                    kind,
 +                    referent: &describe_input_symbol(obj, input_sym),
 +                },
                  resolve,
+             )
+         }
  fn resolve_input_section_offset(
      origin: InputId,
 -    obj: &ObjectFile,
 -    atom: &Atom,
 -    kind: RelocKind,
      input_section: u8,
      input_offset: u32,
 -    referent: &str,
 +    ctx: InputSectionResolveCtx<'_>,
      resolve: &ResolveView<'_>,
  ) -> Result<u64, RelocError> {
      if let Some(atom_ids) = resolve.atoms_by_input_section.get(&(origin, input_section)) {
                  None
+             }
          }) {
 +            let target_atom = canonical_atom(target_atom, resolve.icf_redirects);
              let atom_addr = resolve
                  .atom_addrs
                  .get(&target_atom)
                  .copied()
                  .ok_or_else(|| {
                      reloc_error(
 -                        atom,
 -                        &obj.path,
 +                        ctx.atom,
 +                        &ctx.obj.path,
 ,
 -                        kind,
 -                        referent,
 +                        ctx.kind,
 +                        ctx.referent,
                          "section-backed symbol's containing atom is missing a final address"
                              .to_string(),
+                     )
          .copied()
          .ok_or_else(|| {
              reloc_error(
 -                atom,
 -                &obj.path,
 +                ctx.atom,
 +                &ctx.obj.path,
 ,
 -                kind,
 -                referent,
 +                ctx.kind,
 +                ctx.referent,
                  "section-backed symbol's output section is missing".to_string(),
+             )
          })?;
      Ok(section_addr + input_offset as u64)
+ }
 +fn resolve_input_section_offset_simple(
 +    origin: InputId,
 +    input_section: u8,
 +    input_offset: u32,
 +    resolve: &ResolveView<'_>,
 +) -> Option<u64> {
 +    if let Some(atom_ids) = resolve.atoms_by_input_section.get(&(origin, input_section)) {
 +        if let Some((target_atom, delta)) = atom_ids.iter().find_map(|atom_id| {
 +            let candidate = resolve.atom_table.get(*atom_id);
 +            let start = candidate.input_offset;
 +            let end = candidate.input_offset.saturating_add(candidate.size);
 +            if start <= input_offset && input_offset < end {
 +                Some((*atom_id, input_offset - start))
 +            } else if input_offset == end {
 +                Some((*atom_id, candidate.size))
 +            } else {
 +                None
 +            }
 +        }) {
 +            let target_atom = canonical_atom(target_atom, resolve.icf_redirects);
 +            return resolve
 +                .atom_addrs
 +                .get(&target_atom)
 +                .copied()
 +                .map(|addr| addr + delta as u64);
 +        }
 +    }
 +    resolve
 +        .section_addrs
 +        .get(&(origin, input_section))
 +        .copied()
 +        .map(|section_addr| section_addr + input_offset as u64)
 +}
++
 +fn canonical_atom(
 +    atom_id: crate::resolve::AtomId,
 +    redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +) -> crate::resolve::AtomId {
 +    let Some(redirects) = redirects else {
 +        return atom_id;
 +    };
 +    let mut current = atom_id;
 +    while let Some(&next) = redirects.get(&current) {
 +        if next == current {
 +            break;
 +        }
 +        current = next;
 +    }
 +    current
 +}
++
  fn patch_unsigned(
      bytes: &mut [u8],
      atom: &Atom,
  #[cfg(test)]
  mod tests {
      use super::*;
 +    use std::path::PathBuf;
++
 +    use crate::atom::{AtomFlags, AtomSection};
 +    use crate::input::ObjectFile;
 +    use crate::macho::constants::{
 +        CPU_SUBTYPE_ARM64_ALL, CPU_TYPE_ARM64, MH_MAGIC_64, MH_OBJECT, N_EXT, N_SECT,
 +        S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS, S_REGULAR,
 +    };
 +    use crate::macho::reader::MachHeader64;
 +    use crate::reloc::{write_raw_relocs, write_relocs};
 +    use crate::resolve::{InsertOutcome, Symbol, SymbolTable};
 +    use crate::section::InputSection;
 +    use crate::string_table::StringTable;
 +    use crate::symbol::{InputSymbol, RawNlist};
 +    use crate::OutputKind;
      #[test]
      fn branch26_patches_low_bits() {
          assert!(!fits_signed(1 << 25, 26));
          assert!(!fits_signed(-(1 << 25) - 1, 26));
+     }
++
 +    #[test]
 +    fn thunk_plan_splits_monolithic_text_section_into_multiple_islands() {
 +        let gap = 0x0900_0000u32;
 +        let caller2_offset = 4 + gap;
 +        let target_offset = 8 + gap * 2;
 +        let raw_relocs = branch26_raw_relocs(&[0, caller2_offset]);
 +        let object = thunk_test_object(raw_relocs, target_offset as u64, target_offset as u64 + 4);
++
 +        let mut atoms = AtomTable::new();
 +        let caller1 = atoms.push(test_atom(0, 4));
 +        atoms.push(test_atom(4, gap));
 +        let caller2 = atoms.push(test_atom(caller2_offset, 4));
 +        atoms.push(test_atom(caller2_offset + 4, gap));
 +        let target = atoms.push(test_atom(target_offset, 4));
++
 +        let mut sym_table = SymbolTable::new();
 +        let target_name = sym_table.intern("_target");
 +        let insert = sym_table
 +            .insert(Symbol::Defined {
 +                name: target_name,
 +                origin: crate::resolve::InputId(0),
 +                atom: target,
 +                value: 0,
 +                weak: false,
 +                private_extern: false,
 +                no_dead_strip: false,
 +            })
 +            .unwrap();
 +        assert!(matches!(insert, InsertOutcome::Inserted(_)));
++
 +        let inputs = [LayoutInput {
 +            id: crate::resolve::InputId(0),
 +            object: &object,
 +            load_order: 0,
 +            archive_member_offset: None,
 +        }];
 +        let opts = LinkOptions {
 +            kind: OutputKind::Executable,
 +            ..LinkOptions::default()
 +        };
 +        let base_layout = Layout::build(OutputKind::Executable, &inputs, &atoms, 0);
 +        let plan = plan_thunks(&opts, &base_layout, &inputs, &atoms, &sym_table, None, None)
 +            .unwrap()
 +            .unwrap();
++
 +        assert_eq!(
 +            plan.redirect_for(caller1, 0),
 +            Some(0),
 +            "expected first caller to use its own thunk"
 +        );
 +        assert_eq!(
 +            plan.redirect_for(caller2, 0),
 +            Some(1),
 +            "expected second caller to use its own thunk"
 +        );
++
 +        let rebuilt = Layout::build_with_synthetics_and_extra_filtered(
 +            OutputKind::Executable,
 +            &inputs,
 +            &atoms,
 +            0,
 +            None,
 +            None,
 +            crate::layout::ExtraLayoutSections {
 +                extra_sections: &plan.output_sections(),
 +                split_after_atoms: &plan.split_after_atoms(),
 +            },
 +        );
 +        let text_section_count = rebuilt
 +            .sections
 +            .iter()
 +            .filter(|section| section.segment == "__TEXT" && section.name == "__text")
 +            .count();
 +        let thunk_section_count = rebuilt
 +            .sections
 +            .iter()
 +            .filter(|section| section.segment == "__TEXT" && section.name == "__thunks")
 +            .count();
 +        assert_eq!(
 +            text_section_count, 3,
 +            "expected the monolithic text section to split around the two caller atoms"
 +        );
 +        assert_eq!(
 +            thunk_section_count, 2,
 +            "expected one thunk island per far caller atom"
 +        );
 +        let text_sequence: Vec<_> = rebuilt
 +            .sections
 +            .iter()
 +            .filter(|section| section.segment == "__TEXT")
 +            .map(|section| section.name.as_str())
 +            .collect();
 +        assert_eq!(
 +            text_sequence,
 +            vec!["__text", "__thunks", "__text", "__thunks", "__text"]
 +        );
++
 +        let replan = plan_thunks(&opts, &rebuilt, &inputs, &atoms, &sym_table, None, None)
 +            .unwrap()
 +            .unwrap();
 +        assert_eq!(
 +            replan, plan,
 +            "expected thunk planning to converge once the intra-section islands exist"
 +        );
 +    }
++
 +    fn branch26_raw_relocs(offsets: &[u32]) -> Vec<u8> {
 +        let relocs: Vec<_> = offsets
 +            .iter()
 +            .copied()
 +            .map(|offset| crate::reloc::Reloc {
 +                offset,
 +                kind: RelocKind::Branch26,
 +                length: RelocLength::Word,
 +                pcrel: true,
 +                referent: Referent::Symbol(0),
 +                addend: 0,
 +                subtrahend: None,
 +            })
 +            .collect();
 +        let raws = write_relocs(&relocs).unwrap();
 +        let mut out = Vec::new();
 +        write_raw_relocs(&raws, &mut out);
 +        out
 +    }
++
 +    fn thunk_test_object(raw_relocs: Vec<u8>, target_offset: u64, section_size: u64) -> ObjectFile {
 +        let strings = b"\0_target\0".to_vec();
 +        ObjectFile {
 +            path: PathBuf::from("/tmp/thunk-plan.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: "__TEXT".into(),
 +                sectname: "__text".into(),
 +                kind: crate::section::SectionKind::Text,
 +                addr: 0,
 +                size: section_size,
 +                align_pow2: 2,
 +                flags: S_REGULAR | S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS,
 +                offset: 0,
 +                reloff: 0,
 +                nreloc: (raw_relocs.len() / 8) as u32,
 +                reserved1: 0,
 +                reserved2: 0,
 +                reserved3: 0,
 +                data: Vec::new(),
 +                raw_relocs,
 +            }],
 +            symbols: vec![InputSymbol::from_raw(RawNlist {
 +                strx: 1,
 +                n_type: N_SECT | N_EXT,
 +                n_sect: 1,
 +                n_desc: 0,
 +                n_value: target_offset,
 +            })],
 +            strings: StringTable::from_bytes(strings),
 +            symtab: None,
 +            dysymtab: None,
 +            loh: Vec::new(),
 +            data_in_code: Vec::new(),
 +        }
 +    }
++
 +    fn test_atom(input_offset: u32, size: u32) -> Atom {
 +        Atom {
 +            id: crate::resolve::AtomId(0),
 +            origin: crate::resolve::InputId(0),
 +            input_section: 1,
 +            section: AtomSection::Text,
 +            input_offset,
 +            size,
 +            align_pow2: 2,
 +            owner: None,
 +            alt_entries: Vec::new(),
 +            data: Vec::new(),
 +            flags: AtomFlags::NONE,
 +            parent_of: None,
 +        }
 +    }
+ }

src/reloc/mod.rsmodified

16 lines changed — click to load

  // Fused Reloc form. Sprint 11's reloc-application pass consumes this.
  // ---------------------------------------------------------------------------
 -#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  pub enum RelocKind {
      Unsigned,
      Branch26,
      Subtractor,
+ }
 -#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  #[repr(u8)]
  pub enum RelocLength {
      Byte = 0,

src/resolve.rsmodified

121 lines changed — click to load

  #[derive(Debug, Default)]
  pub struct DrainReport {
      pub fetched_members: usize,
 +    pub loaded_paths: Vec<PathBuf>,
      pub duplicates: Vec<InsertError>,
      pub referrers: ReferrerLog,
+ }
          bytes: member_bytes,
      });
      report.fetched_members += 1;
 +    report
 +        .loaded_paths
 +        .push(inputs.objects[input_id.0 as usize].path.clone());
      let mut sub_report = SeedReport::default();
      seed_object(inputs, input_id, table, &mut sub_report)?;
  pub struct ClassificationReport {
      /// Strong undefineds that triggered errors under `Error` treatment.
      pub errors: Vec<Unresolved>,
 -    /// Strong undefineds that produced warnings under `Warning` treatment.
 +    /// Strong undefineds that produced warnings under `Warning` treatment and
 +    /// were promoted to flat-lookup imports for final emission.
      pub warnings: Vec<Unresolved>,
 -    /// Strong undefineds that were silently accepted under `Suppress`.
 +    /// Strong undefineds that were silently accepted under `Suppress` and
 +    /// were promoted to flat-lookup imports for final emission.
      pub suppressed: Vec<Unresolved>,
      /// Undefineds promoted to flat-lookup DylibImport entries.
      pub promoted_to_dynamic: Vec<SymbolId>,
  /// Format the full undefined-symbol diagnostic block, one entry per
  /// unresolved name: the error line, every referrer, and an optional
  /// did-you-mean hint.
 -pub fn format_undefined_diagnostic(
 +fn format_undefined_diagnostic_with_level(
      table: &SymbolTable,
      inputs: &Inputs,
      referrers: &ReferrerLog,
      unresolved: &[Unresolved],
 +    level: &str,
  ) -> String {
      let mut out = String::new();
      for u in unresolved {
          let name = table.interner.resolve(u.name);
 -        out.push_str(&format!("afs-ld: error: undefined symbol: {name}\n"));
 +        out.push_str(&format!("afs-ld: {level}: undefined symbol: {name}\n"));
          for origin in referrers.get(u.name) {
              if let Some(oi) = inputs.objects.get(origin.0 as usize) {
                  out.push_str(&format!("      referenced by {}\n", oi.path.display()));
      out
+ }
 +pub fn format_undefined_diagnostic(
 +    table: &SymbolTable,
 +    inputs: &Inputs,
 +    referrers: &ReferrerLog,
 +    unresolved: &[Unresolved],
 +) -> String {
 +    format_undefined_diagnostic_with_level(table, inputs, referrers, unresolved, "error")
 +}
++
 +pub fn format_undefined_warning_diagnostic(
 +    table: &SymbolTable,
 +    inputs: &Inputs,
 +    referrers: &ReferrerLog,
 +    unresolved: &[Unresolved],
 +) -> String {
 +    format_undefined_diagnostic_with_level(table, inputs, referrers, unresolved, "warning")
 +}
++
  /// Format a `DuplicateStrong` insertion error for user consumption. Needs
  /// the incumbent symbol (from the table) plus the losing second symbol
  /// carried in the error itself.
  ) -> ClassificationReport {
      let mut report = ClassificationReport::default();
 +    fn promote_to_flat_lookup(table: &mut SymbolTable, id: SymbolId, name: Istr) {
 +        table.symbols[id.0 as usize] = Symbol::DylibImport {
 +            name,
 +            dylib: DylibId::INVALID,
 +            ordinal: FLAT_LOOKUP_ORDINAL,
 +            weak_import: true,
 +        };
 +        table.transitions.push(Transition {
 +            id,
 +            from: SymbolKindTag::Undefined,
 +            to: SymbolKindTag::DylibImport,
 +            cause: TransitionCause::Replaced,
 +        });
 +    }
++
      // Collect undefineds before mutating — avoids double-borrow grief.
      let undefs: Vec<(SymbolId, Istr, bool)> = table
          .iter()
+             }
              UndefinedTreatment::Warning => {
                  report.warnings.push(Unresolved { name, id });
 +                promote_to_flat_lookup(table, id, name);
 +                report.promoted_to_dynamic.push(id);
+             }
              UndefinedTreatment::Suppress => {
                  report.suppressed.push(Unresolved { name, id });
 +                promote_to_flat_lookup(table, id, name);
 +                report.promoted_to_dynamic.push(id);
+             }
              UndefinedTreatment::DynamicLookup => {
 -                table.symbols[id.0 as usize] = Symbol::DylibImport {
 -                    name,
 -                    dylib: DylibId::INVALID,
 -                    ordinal: FLAT_LOOKUP_ORDINAL,
 -                    weak_import: true,
 -                };
 -                table.transitions.push(Transition {
 -                    id,
 -                    from: SymbolKindTag::Undefined,
 -                    to: SymbolKindTag::DylibImport,
 -                    cause: TransitionCause::Replaced,
 -                });
 +                promote_to_flat_lookup(table, id, name);
                  report.promoted_to_dynamic.push(id);
+             }
+         }

src/string_table.rsmodified

75 lines changed — click to load

  #[derive(Debug, Clone, Default, PartialEq, Eq)]
  pub struct StringTableBuilder {
 -    roots: Vec<(String, u32)>,
 +    roots: Vec<RootString>,
 +    roots_by_last_byte: HashMap<u8, Vec<usize>>,
      offsets: HashMap<String, u32>,
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct RootString {
 +    name: String,
 +    offset: u32,
 +}
++
  impl StringTableBuilder {
      pub fn new() -> Self {
          Self::default()
              let offset = raw.len() as u32;
              raw.extend_from_slice(name.as_bytes());
              raw.push(0);
 -            self.roots.push((name.clone(), offset));
 +            let root_index = self.roots.len();
 +            self.roots.push(RootString {
 +                name: name.clone(),
 +                offset,
 +            });
 +            if let Some(&last_byte) = name.as_bytes().last() {
 +                self.roots_by_last_byte
 +                    .entry(last_byte)
 +                    .or_default()
 +                    .push(root_index);
 +            }
              self.offsets.insert(name, offset);
+         }
+     }
      fn find_suffix_offset(&self, name: &str) -> Option<u32> {
 -        self.roots.iter().find_map(|(existing, offset)| {
 -            if existing.ends_with(name) {
 -                Some(*offset + (existing.len() - name.len()) as u32)
 -            } else {
 -                None
 -            }
 -        })
 +        let last_byte = *name.as_bytes().last()?;
 +        self.roots_by_last_byte
 +            .get(&last_byte)?
 +            .iter()
 +            .find_map(|&idx| {
 +                let existing = &self.roots[idx];
 +                (existing.name.len() >= name.len() && existing.name.ends_with(name))
 +                    .then(|| existing.offset + (existing.name.len() - name.len()) as u32)
 +            })
+     }
+ }
          assert_eq!(array, afs + 4);
          assert_eq!(table.as_bytes().len() % 8, 0);
+     }
++
 +    #[test]
 +    fn builder_ignores_same_last_byte_non_suffix_names() {
 +        let mut builder = StringTableBuilder::new();
 +        builder.insert("_alpha");
 +        builder.insert("_beta");
++
 +        let (bytes, offsets) = builder.finish();
 +        let table = StringTable::from_bytes(bytes);
++
 +        assert_eq!(table.get(offsets["_alpha"]).unwrap(), "_alpha");
 +        assert_eq!(table.get(offsets["_beta"]).unwrap(), "_beta");
 +    }
+ }

src/synth/dyld_info.rsmodified

77 lines changed — click to load

          let run_len = bind_run_len(specs, idx);
          if run_len > 1 {
              let stride = specs[idx + 1].segment_offset - spec.segment_offset;
 -            let skip = stride - 8;
 -            out.byte(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
 -            out.uleb(run_len as u64);
 -            out.uleb(skip);
 -            state.next_segment_offset = Some(spec.segment_offset + (run_len as u64) * stride);
 -            idx += run_len;
 +            if run_len == 2 && stride == 8 {
 +                out.byte(BIND_OPCODE_DO_BIND);
 +                state.next_segment_offset = Some(spec.segment_offset + 8);
 +                idx += 1;
 +            } else {
 +                let skip = stride - 8;
 +                out.byte(BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB);
 +                out.uleb(run_len as u64);
 +                out.uleb(skip);
 +                state.next_segment_offset = Some(spec.segment_offset + (run_len as u64) * stride);
 +                idx += run_len;
 +            }
          } else {
              out.byte(BIND_OPCODE_DO_BIND);
              state.next_segment_offset = Some(spec.segment_offset + 8);
          assert_eq!(stream[idx + 2], 0x10);
          assert_eq!(stream.last().copied(), Some(0));
+     }
++
 +    #[test]
 +    fn bind_encoder_keeps_adjacent_pair_uncompressed_for_apple_parity() {
 +        let stream = emit_bind_records(&[
 +            BindRecordSpec {
 +                segment_index: 2,
 +                segment_offset: 0,
 +                ordinal: 2,
 +                name: "_ext_data",
 +                weak_import: false,
 +                addend: 0,
 +                terminate: false,
 +            },
 +            BindRecordSpec {
 +                segment_index: 2,
 +                segment_offset: 8,
 +                ordinal: 2,
 +                name: "_ext_data",
 +                weak_import: false,
 +                addend: 0,
 +                terminate: true,
 +            },
 +        ]);
++
 +        assert!(!stream.contains(&BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB));
 +        assert_eq!(
 +            stream,
 +            vec![
 +                BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | 2,
 +                BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM,
 +                b'_',
 +                b'e',
 +                b'x',
 +                b't',
 +                b'_',
 +                b'd',
 +                b'a',
 +                b't',
 +                b'a',
 +                0,
 +                BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER,
 +                BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | 2,
 +                0,
 +                BIND_OPCODE_DO_BIND,
 +                BIND_OPCODE_DO_BIND,
 +                0,
 +            ]
 +        );
 +    }
+ }

src/synth/mod.rsmodified

117 lines changed — click to load

  pub mod tlv;
  pub mod unwind;
 -use std::collections::HashMap;
 +use std::collections::{HashMap, HashSet};
  use std::fmt;
  use std::path::PathBuf;
          atoms: &AtomTable,
          sym_table: &mut SymbolTable,
          dylibs: &[DylibInput],
 +    ) -> Result<Self, SynthError> {
 +        Self::build_filtered(inputs, atoms, sym_table, dylibs, None)
 +    }
++
 +    pub fn build_filtered(
 +        inputs: &[LayoutInput<'_>],
 +        atoms: &AtomTable,
 +        sym_table: &mut SymbolTable,
 +        dylibs: &[DylibInput],
 +        live_atoms: Option<&HashSet<AtomId>>,
      ) -> Result<Self, SynthError> {
          let input_map: HashMap<InputId, &ObjectFile> = inputs
              .iter()
          let mut direct_binds = Vec::new();
          for (atom_id, atom) in atoms.iter() {
 +            if live_atoms.is_some_and(|live_atoms| !live_atoms.contains(&atom_id)) {
 +                continue;
 +            }
              let obj = input_map.get(&atom.origin).ok_or_else(|| SynthError {
                  input: PathBuf::from("<missing object>"),
                  atom: atom_id,
                      RelocKind::GotLoadPage21
                      | RelocKind::GotLoadPageOff12
                      | RelocKind::PointerToGot => {
 -                        if matches!(
 -                            reloc.kind,
 -                            RelocKind::GotLoadPage21 | RelocKind::GotLoadPageOff12
 -                        ) {
 -                            let Some(symbol_id) =
 -                                dylib_import_referent(obj, reloc.referent, sym_table)
 -                            else {
 -                                continue;
 -                            };
 -                            got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
 -                            continue;
 -                        }
                          let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, sym_table)
                          else {
                              continue;
                          };
 -                        if matches!(reloc.kind, RelocKind::PointerToGot)
 -                            && matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. })
 -                        {
 +                        let needs_slot = match reloc.kind {
 +                            RelocKind::PointerToGot => {
 +                                !matches!(sym_table.get(symbol_id), Symbol::LazyArchive { .. })
 +                            }
 +                            RelocKind::GotLoadPage21 | RelocKind::GotLoadPageOff12 => {
 +                                got_page_symbol_needs_slot(sym_table, atoms, symbol_id)
 +                            }
 +                            _ => false,
 +                        };
 +                        if needs_slot {
                              got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
                              continue;
+                         }
 -                        got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
+                     }
                      RelocKind::Branch26 => {
                          let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table)
      matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. })
+ }
 +fn got_page_symbol_needs_slot(
 +    sym_table: &SymbolTable,
 +    atoms: &AtomTable,
 +    symbol_id: SymbolId,
 +) -> bool {
 +    match sym_table.get(symbol_id) {
 +        Symbol::DylibImport { .. } => true,
 +        Symbol::Defined {
 +            atom,
 +            private_extern,
 +            ..
 +        } => {
 +            atom.0 != 0 && !*private_extern && matches!(atoms.get(*atom).section, AtomSection::Data)
 +        }
 +        _ => false,
 +    }
 +}
++
  fn direct_import_bind_supported(reloc: Reloc) -> bool {
      matches!(reloc.length, RelocLength::Quad) && !reloc.pcrel && reloc.subtrahend.is_none()
+ }
              strings: StringTable::from_bytes(strings),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
+         }
+     }
              strings: StringTable::from_bytes(strings),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
+         }
+     }
              strings: StringTable::from_bytes(strings),
              symtab: None,
              dysymtab: None,
 +            loh: Vec::new(),
              data_in_code: Vec::new(),
+         }
+     }

src/synth/unwind.rsmodified

103 lines changed — click to load

 -use std::collections::HashMap;
 +use std::collections::{HashMap, HashSet};
  use std::fmt;
  use std::path::PathBuf;
          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),
 -        detail: err.to_string(),
 -    })?;
 +    if should_validate_serialized_unwind_info() {
 +        validate_serialized_unwind_info(&bytes, &records).map_err(|err| UnwindError {
 +            input: PathBuf::from("<synthetic unwind>"),
 +            atom: AtomId(0),
 +            detail: err.to_string(),
 +        })?;
 +    }
      let section_changed = upsert_unwind_info_section(layout, bytes);
      if changed || section_changed {
          prune_empty_segments(layout);
      Ok(changed || section_changed)
+ }
 +fn should_validate_serialized_unwind_info() -> bool {
 +    std::env::var_os("AFS_LD_VALIDATE_UNWIND_INFO").is_some()
 +}
++
  fn collect_records(
      layout: &Layout,
      inputs: &[LayoutInput<'_>],
          .iter()
          .map(|input| (input.id, input.object))
          .collect();
 +    let compact_unwind_sections: HashSet<(InputId, u8)> = atoms
 +        .iter()
 +        .filter(|(_, atom)| atom.section == AtomSection::CompactUnwind)
 +        .map(|(_, atom)| (atom.origin, atom.input_section))
 +        .collect();
      let mut reloc_cache: HashMap<(InputId, u8), Vec<Reloc>> = HashMap::new();
 -    for input in inputs {
 -        for (section_idx, section) in input.object.sections.iter().enumerate() {
 -            if section.nreloc == 0 {
 -                continue;
 -            }
 -            let raws = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc).map_err(|err| {
 -                UnwindError {
 -                    input: input.object.path.clone(),
 -                    atom: AtomId(0),
 -                    detail: err.to_string(),
 -                }
 -            })?;
 -            let relocs = parse_relocs(&raws).map_err(|err| UnwindError {
 -                input: input.object.path.clone(),
 +    for (input_id, section_idx) in compact_unwind_sections {
 +        let obj = input_map.get(&input_id).ok_or_else(|| UnwindError {
 +            input: PathBuf::from("<missing object>"),
 +            atom: AtomId(0),
 +            detail: "missing parsed object".to_string(),
 +        })?;
 +        let section = obj
 +            .sections
 +            .get((section_idx as usize).saturating_sub(1))
 +            .ok_or_else(|| UnwindError {
 +                input: obj.path.clone(),
                  atom: AtomId(0),
 -                detail: err.to_string(),
 +                detail: format!("compact-unwind section {} is out of range", section_idx),
              })?;
 -            reloc_cache.insert((input.id, (section_idx + 1) as u8), relocs);
 +        if section.nreloc == 0 {
 +            continue;
+         }
 +        let raws = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc).map_err(|err| {
 +            UnwindError {
 +                input: obj.path.clone(),
 +                atom: AtomId(0),
 +                detail: err.to_string(),
 +            }
 +        })?;
 +        let relocs = parse_relocs(&raws).map_err(|err| UnwindError {
 +            input: obj.path.clone(),
 +            atom: AtomId(0),
 +            detail: err.to_string(),
 +        })?;
 +        reloc_cache.insert((input_id, section_idx), relocs);
+     }
      let mut records = Vec::new();
          if atom.section != AtomSection::CompactUnwind {
              continue;
+         }
 +        if atom
 +            .parent_of
 +            .is_some_and(|parent| layout.atom_addr(parent).is_none())
 +        {
 +            continue;
 +        }
          let Some(obj) = input_map.get(&atom.origin) else {
              return Err(UnwindError {
                  input: PathBuf::from("<missing object>"),

src/why_live.rsadded

838 lines changed — click to load

 +use std::collections::{HashMap, HashSet, VecDeque};
 +use std::fmt::Write as _;
++
 +use crate::atom::{Atom, AtomSection, AtomTable};
 +use crate::icf::FoldedSymbol;
 +use crate::input::ObjectFile;
 +use crate::layout::LayoutInput;
 +use crate::reloc::{parse_raw_relocs, parse_relocs, Referent};
 +use crate::resolve::{AtomId, InputId, Symbol, SymbolId, SymbolTable};
 +use crate::{LinkOptions, OutputKind};
++
 +#[derive(Debug, Clone)]
 +enum RootReason {
 +    Entry(String),
 +    NoDeadStrip,
 +    ExportedDylib,
 +}
++
 +impl RootReason {
 +    fn describe(&self, symbol: &str) -> String {
 +        match self {
 +            RootReason::Entry(entry) => format!("{symbol} is in -e {entry} (GC root)"),
 +            RootReason::NoDeadStrip => format!("{symbol} is marked N_NO_DEAD_STRIP (GC root)"),
 +            RootReason::ExportedDylib => format!("{symbol} is exported from the dylib (GC root)"),
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone)]
 +enum LiveCause {
 +    Root(RootReason),
 +    ReferencedBy(AtomId),
 +    ParentOf(AtomId),
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct DeadStrippedSymbol {
 +    pub name: String,
 +    pub file_index: usize,
 +}
++
 +#[derive(Debug, Clone)]
 +pub struct DeadStripAnalysis {
 +    live_atoms: HashSet<AtomId>,
 +    causes: HashMap<AtomId, LiveCause>,
 +    resolved_by_name: HashMap<String, SymbolId>,
 +    atom_symbols: HashMap<AtomId, Vec<SymbolId>>,
 +}
++
 +impl DeadStripAnalysis {
 +    pub fn build(
 +        opts: &LinkOptions,
 +        layout_inputs: &[LayoutInput<'_>],
 +        atom_table: &AtomTable,
 +        sym_table: &SymbolTable,
 +        entry_symbol: Option<SymbolId>,
 +    ) -> Self {
 +        let resolved_by_name = resolved_symbol_map(sym_table);
 +        let atom_symbols = atom_symbol_sets(atom_table);
 +        let roots = root_atoms(opts, atom_table, sym_table, entry_symbol);
 +        let forward_edges =
 +            build_forward_edges(layout_inputs, atom_table, sym_table, &resolved_by_name);
 +        let parent_edges = parent_edges(atom_table);
++
 +        let mut live_atoms = HashSet::new();
 +        let mut causes = HashMap::new();
 +        let mut worklist = VecDeque::new();
 +        for (atom_id, reason) in roots {
 +            if live_atoms.insert(atom_id) {
 +                causes.insert(atom_id, LiveCause::Root(reason));
 +                worklist.push_back(atom_id);
 +            }
 +        }
++
 +        while let Some(atom_id) = worklist.pop_front() {
 +            if let Some(children) = parent_edges.get(&atom_id) {
 +                for &child in children {
 +                    if live_atoms.insert(child) {
 +                        causes.insert(child, LiveCause::ParentOf(atom_id));
 +                        worklist.push_back(child);
 +                    }
 +                }
 +            }
 +            if let Some(targets) = forward_edges.get(&atom_id) {
 +                for &target in targets {
 +                    if live_atoms.insert(target) {
 +                        causes.insert(target, LiveCause::ReferencedBy(atom_id));
 +                        worklist.push_back(target);
 +                    }
 +                }
 +            }
 +        }
++
 +        Self {
 +            live_atoms,
 +            causes,
 +            resolved_by_name,
 +            atom_symbols,
 +        }
 +    }
++
 +    pub fn live_atoms(&self) -> &HashSet<AtomId> {
 +        &self.live_atoms
 +    }
++
 +    pub fn dead_stripped_symbols(
 +        &self,
 +        atom_table: &AtomTable,
 +        sym_table: &SymbolTable,
 +        layout_inputs: &[LayoutInput<'_>],
 +    ) -> Vec<DeadStrippedSymbol> {
 +        let file_index_by_input: HashMap<InputId, usize> = layout_inputs
 +            .iter()
 +            .enumerate()
 +            .map(|(idx, input)| (input.id, idx + 1))
 +            .collect();
 +        let mut out = Vec::new();
 +        for (atom_id, _atom) in atom_table.iter() {
 +            if self.live_atoms.contains(&atom_id) {
 +                continue;
 +            }
 +            let Some(symbols) = self.atom_symbols.get(&atom_id) else {
 +                continue;
 +            };
 +            for &symbol_id in symbols {
 +                let Symbol::Defined { origin, .. } = sym_table.get(symbol_id) else {
 +                    continue;
 +                };
 +                out.push(DeadStrippedSymbol {
 +                    name: self.symbol_name(sym_table, symbol_id),
 +                    file_index: file_index_by_input.get(origin).copied().unwrap_or(0),
 +                });
 +            }
 +        }
 +        out.sort_by(|lhs, rhs| {
 +            lhs.name
 +                .cmp(&rhs.name)
 +                .then(lhs.file_index.cmp(&rhs.file_index))
 +        });
 +        out.dedup_by(|lhs, rhs| lhs.name == rhs.name && lhs.file_index == rhs.file_index);
 +        out
 +    }
++
 +    fn symbol_name(&self, sym_table: &SymbolTable, symbol_id: SymbolId) -> String {
 +        sym_table
 +            .interner
 +            .resolve(sym_table.get(symbol_id).name())
 +            .to_string()
 +    }
++
 +    fn atom_name(&self, sym_table: &SymbolTable, atom_id: AtomId) -> String {
 +        self.atom_symbols
 +            .get(&atom_id)
 +            .and_then(|symbols| symbols.first().copied())
 +            .map(|symbol_id| self.symbol_name(sym_table, symbol_id))
 +            .unwrap_or_else(|| format!("<atom {:?}>", atom_id))
 +    }
++
 +    fn is_live_symbol(&self, sym_table: &SymbolTable, symbol_id: SymbolId) -> bool {
 +        match sym_table.get(symbol_id) {
 +            Symbol::Defined { atom, .. } if atom.0 != 0 => self.live_atoms.contains(atom),
 +            _ => false,
 +        }
 +    }
++
 +    fn format_symbol_explanation(
 +        &self,
 +        sym_table: &SymbolTable,
 +        requested_symbol: SymbolId,
 +    ) -> String {
 +        let requested_name = self.symbol_name(sym_table, requested_symbol);
 +        if !self.is_live_symbol(sym_table, requested_symbol) {
 +            return format!("{requested_name} is not live (dead-stripped)\n");
 +        }
++
 +        let Symbol::Defined { atom, .. } = sym_table.get(requested_symbol) else {
 +            return format!("{requested_name} is not backed by a dead-strip eligible input atom\n");
 +        };
 +        let mut out = String::new();
 +        writeln!(&mut out, "{requested_name} is live because:").unwrap();
++
 +        let mut cursor = *atom;
 +        let mut first = true;
 +        loop {
 +            let Some(cause) = self.causes.get(&cursor).cloned() else {
 +                writeln!(
 +                    &mut out,
 +                    "  no reachability chain from a known GC root was found"
 +                )
 +                .unwrap();
 +                break;
 +            };
 +            match cause {
 +                LiveCause::Root(reason) => {
 +                    let name = if first {
 +                        requested_name.as_str()
 +                    } else {
 +                        &self.atom_name(sym_table, cursor)
 +                    };
 +                    writeln!(&mut out, "  {}", reason.describe(name)).unwrap();
 +                    break;
 +                }
 +                LiveCause::ReferencedBy(parent) => {
 +                    let child_name = if first {
 +                        requested_name.as_str()
 +                    } else {
 +                        &self.atom_name(sym_table, cursor)
 +                    };
 +                    writeln!(
 +                        &mut out,
 +                        "  {child_name} is reachable from {}",
 +                        self.atom_name(sym_table, parent)
 +                    )
 +                    .unwrap();
 +                    cursor = parent;
 +                }
 +                LiveCause::ParentOf(parent) => {
 +                    let child_name = if first {
 +                        requested_name.as_str()
 +                    } else {
 +                        &self.atom_name(sym_table, cursor)
 +                    };
 +                    writeln!(
 +                        &mut out,
 +                        "  {child_name} is reachable via unwind parent from {}",
 +                        self.atom_name(sym_table, parent)
 +                    )
 +                    .unwrap();
 +                    cursor = parent;
 +                }
 +            }
 +            first = false;
 +        }
++
 +        out
 +    }
 +}
++
 +pub fn format_explanations(
 +    opts: &LinkOptions,
 +    layout_inputs: &[LayoutInput<'_>],
 +    atom_table: &AtomTable,
 +    sym_table: &SymbolTable,
 +    entry_symbol: Option<SymbolId>,
 +    dead_strip: Option<&DeadStripAnalysis>,
 +    folded_symbols: &[FoldedSymbol],
 +) -> Result<Option<String>, String> {
 +    if opts.why_live.is_empty() {
 +        return Ok(None);
 +    }
++
 +    let folded_by_name: HashMap<&str, &str> = folded_symbols
 +        .iter()
 +        .map(|symbol| (symbol.name.as_str(), symbol.winner.as_str()))
 +        .collect();
++
 +    if let Some(dead_strip) = dead_strip {
 +        let mut out = String::new();
 +        for (idx, requested) in opts.why_live.iter().enumerate() {
 +            let winner = folded_by_name
 +                .get(requested.as_str())
 +                .copied()
 +                .unwrap_or(requested.as_str());
 +            let Some(&target) = dead_strip.resolved_by_name.get(winner) else {
 +                return Err(format!("`-why_live` symbol `{requested}` was not found"));
 +            };
 +            if idx > 0 {
 +                out.push('\n');
 +            }
 +            if winner != requested {
 +                writeln!(&mut out, "{requested} was folded to {winner} by -icf=safe").unwrap();
 +            }
 +            out.push_str(&dead_strip.format_symbol_explanation(sym_table, target));
 +        }
 +        return Ok(Some(out));
 +    }
++
 +    let graph = WhyLiveGraph::build(opts, layout_inputs, atom_table, sym_table, entry_symbol);
 +    let mut out = String::new();
 +    for (idx, requested) in opts.why_live.iter().enumerate() {
 +        let winner = folded_by_name
 +            .get(requested.as_str())
 +            .copied()
 +            .unwrap_or(requested.as_str());
 +        let Some(&target) = graph.resolved_by_name.get(winner) else {
 +            return Err(format!("`-why_live` symbol `{requested}` was not found"));
 +        };
 +        if idx > 0 {
 +            out.push('\n');
 +        }
 +        if winner != requested {
 +            writeln!(&mut out, "{requested} was folded to {winner} by -icf=safe").unwrap();
 +        }
 +        let target_name = graph.symbol_name(target);
 +        writeln!(&mut out, "{target_name} is live because:").unwrap();
 +        writeln!(
 +            &mut out,
 +            "  note: -dead_strip was not requested; showing the current reachability roots"
 +        )
 +        .unwrap();
 +        if let Some(reason) = graph.roots.get(&target) {
 +            writeln!(&mut out, "  {}", reason.describe(&target_name)).unwrap();
 +            continue;
 +        }
 +        if let Some(path) = graph.find_chain(target) {
 +            for pair in path.windows(2).rev() {
 +                let parent = graph.symbol_name(pair[0]);
 +                let child = graph.symbol_name(pair[1]);
 +                writeln!(&mut out, "  {child} is reachable from {parent}").unwrap();
 +            }
 +            let root = path[0];
 +            let root_name = graph.symbol_name(root);
 +            writeln!(
 +                &mut out,
 +                "  {}",
 +                graph
 +                    .roots
 +                    .get(&root)
 +                    .expect("root path starts from a root")
 +                    .describe(&root_name)
 +            )
 +            .unwrap();
 +        } else {
 +            writeln!(
 +                &mut out,
 +                "  no reachability chain from a known GC root was found; linked inputs are currently retained as loaded"
 +            )
 +            .unwrap();
 +        }
 +    }
 +    Ok(Some(out))
 +}
++
 +struct WhyLiveGraph<'a> {
 +    sym_table: &'a SymbolTable,
 +    resolved_by_name: HashMap<String, SymbolId>,
 +    roots: HashMap<SymbolId, RootReason>,
 +    reverse_edges: HashMap<SymbolId, Vec<SymbolId>>,
 +}
++
 +impl<'a> WhyLiveGraph<'a> {
 +    fn build(
 +        opts: &LinkOptions,
 +        layout_inputs: &[LayoutInput<'_>],
 +        atom_table: &AtomTable,
 +        sym_table: &'a SymbolTable,
 +        entry_symbol: Option<SymbolId>,
 +    ) -> Self {
 +        let resolved_by_name = resolved_symbol_map(sym_table);
 +        let roots = root_symbols(opts, sym_table, entry_symbol);
 +        let reverse_edges = build_reverse_edges(layout_inputs, atom_table, &resolved_by_name);
 +        Self {
 +            sym_table,
 +            resolved_by_name,
 +            roots,
 +            reverse_edges,
 +        }
 +    }
++
 +    fn symbol_name(&self, symbol_id: SymbolId) -> String {
 +        self.sym_table
 +            .interner
 +            .resolve(self.sym_table.get(symbol_id).name())
 +            .to_string()
 +    }
++
 +    fn find_chain(&self, target: SymbolId) -> Option<Vec<SymbolId>> {
 +        let mut queue = VecDeque::from([target]);
 +        let mut seen = HashSet::from([target]);
 +        let mut next_toward_target = HashMap::<SymbolId, SymbolId>::new();
++
 +        while let Some(current) = queue.pop_front() {
 +            let Some(predecessors) = self.reverse_edges.get(&current) else {
 +                continue;
 +            };
 +            for &pred in predecessors {
 +                if !seen.insert(pred) {
 +                    continue;
 +                }
 +                next_toward_target.insert(pred, current);
 +                if self.roots.contains_key(&pred) {
 +                    let mut path = vec![pred];
 +                    let mut cursor = pred;
 +                    while let Some(&next) = next_toward_target.get(&cursor) {
 +                        path.push(next);
 +                        if next == target {
 +                            break;
 +                        }
 +                        cursor = next;
 +                    }
 +                    return Some(path);
 +                }
 +                queue.push_back(pred);
 +            }
 +        }
++
 +        None
 +    }
 +}
++
 +fn resolved_symbol_map(sym_table: &SymbolTable) -> HashMap<String, SymbolId> {
 +    let mut out = HashMap::new();
 +    for (symbol_id, symbol) in sym_table.iter() {
 +        let name = sym_table.interner.resolve(symbol.name()).to_string();
 +        let resolved = match symbol {
 +            Symbol::Alias { name, .. } => sym_table
 +                .resolve_chain(*name)
 +                .map(|(resolved_id, _)| resolved_id)
 +                .unwrap_or(symbol_id),
 +            _ => symbol_id,
 +        };
 +        out.insert(name, resolved);
 +    }
 +    out
 +}
++
 +fn root_symbols(
 +    opts: &LinkOptions,
 +    sym_table: &SymbolTable,
 +    entry_symbol: Option<SymbolId>,
 +) -> HashMap<SymbolId, RootReason> {
 +    let mut roots = HashMap::new();
 +    if let Some(entry_symbol) = entry_symbol {
 +        roots.insert(
 +            entry_symbol,
 +            RootReason::Entry(symbol_name(sym_table, entry_symbol)),
 +        );
 +    }
 +    for (symbol_id, symbol) in sym_table.iter() {
 +        match symbol {
 +            Symbol::Defined {
 +                no_dead_strip: true,
 +                ..
 +            } => {
 +                roots.entry(symbol_id).or_insert(RootReason::NoDeadStrip);
 +            }
 +            Symbol::Defined {
 +                private_extern: false,
 +                ..
 +            } if opts.kind == OutputKind::Dylib => {
 +                roots.entry(symbol_id).or_insert(RootReason::ExportedDylib);
 +            }
 +            _ => {}
 +        }
 +    }
 +    roots
 +}
++
 +fn root_atoms(
 +    opts: &LinkOptions,
 +    atom_table: &AtomTable,
 +    sym_table: &SymbolTable,
 +    entry_symbol: Option<SymbolId>,
 +) -> HashMap<AtomId, RootReason> {
 +    let mut roots = HashMap::new();
 +    if let Some(entry_symbol) = entry_symbol {
 +        if let Symbol::Defined { atom, .. } = sym_table.get(entry_symbol) {
 +            if atom.0 != 0 {
 +                roots.insert(
 +                    *atom,
 +                    RootReason::Entry(symbol_name(sym_table, entry_symbol)),
 +                );
 +            }
 +        }
 +    }
++
 +    for (atom_id, atom) in atom_table.iter() {
 +        if atom.flags.has(crate::atom::AtomFlags::NO_DEAD_STRIP) {
 +            roots.entry(atom_id).or_insert(RootReason::NoDeadStrip);
 +        }
 +    }
++
 +    for (_, symbol) in sym_table.iter() {
 +        match symbol {
 +            Symbol::Defined {
 +                atom,
 +                no_dead_strip: true,
 +                ..
 +            } if atom.0 != 0 => {
 +                roots.entry(*atom).or_insert(RootReason::NoDeadStrip);
 +            }
 +            Symbol::Defined {
 +                atom,
 +                private_extern: false,
 +                ..
 +            } if opts.kind == OutputKind::Dylib && atom.0 != 0 => {
 +                roots.entry(*atom).or_insert(RootReason::ExportedDylib);
 +            }
 +            _ => {}
 +        }
 +    }
++
 +    roots
 +}
++
 +fn build_reverse_edges(
 +    layout_inputs: &[LayoutInput<'_>],
 +    atom_table: &AtomTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +) -> HashMap<SymbolId, Vec<SymbolId>> {
 +    let atoms_by_input_section = atom_table.by_input_section();
 +    let atom_symbols = atom_symbol_sets(atom_table);
 +    let mut edge_set = HashSet::<(SymbolId, SymbolId)>::new();
++
 +    for input in layout_inputs {
 +        for (section_idx_zero, section) in input.object.sections.iter().enumerate() {
 +            if section.raw_relocs.is_empty() {
 +                continue;
 +            }
 +            let Ok(raws) = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc) else {
 +                continue;
 +            };
 +            let Ok(relocs) = parse_relocs(&raws) else {
 +                continue;
 +            };
 +            let input_section = (section_idx_zero + 1) as u8;
 +            for reloc in relocs {
 +                let Some(source_atom) = find_atom_for_offset(
 +                    atom_table,
 +                    &atoms_by_input_section,
 +                    input.id,
 +                    input_section,
 +                    reloc.offset,
 +                ) else {
 +                    continue;
 +                };
 +                let Some(source_symbols) = atom_symbols.get(&source_atom) else {
 +                    continue;
 +                };
 +                let Some(target_symbols) =
 +                    target_symbols_for_reloc(input.object, reloc.referent, resolved_by_name)
 +                else {
 +                    continue;
 +                };
 +                for &source in source_symbols {
 +                    for &target in &target_symbols {
 +                        if source != target {
 +                            edge_set.insert((target, source));
 +                        }
 +                    }
 +                }
 +            }
 +        }
 +    }
++
 +    let mut reverse_edges = HashMap::<SymbolId, Vec<SymbolId>>::new();
 +    for (target, source) in edge_set {
 +        reverse_edges.entry(target).or_default().push(source);
 +    }
 +    for predecessors in reverse_edges.values_mut() {
 +        predecessors.sort_by_key(|sid| sid.0);
 +    }
 +    reverse_edges
 +}
++
 +fn build_forward_edges(
 +    layout_inputs: &[LayoutInput<'_>],
 +    atom_table: &AtomTable,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +) -> HashMap<AtomId, Vec<AtomId>> {
 +    let atoms_by_input_section = atom_table.by_input_section();
 +    let mut edge_set = HashSet::<(AtomId, AtomId)>::new();
++
 +    for input in layout_inputs {
 +        for (section_idx_zero, section) in input.object.sections.iter().enumerate() {
 +            if section.raw_relocs.is_empty() {
 +                continue;
 +            }
 +            let Ok(raws) = parse_raw_relocs(&section.raw_relocs, 0, section.nreloc) else {
 +                continue;
 +            };
 +            let Ok(relocs) = parse_relocs(&raws) else {
 +                continue;
 +            };
 +            let input_section = (section_idx_zero + 1) as u8;
 +            for reloc in relocs {
 +                let Some(source_atom) = find_atom_for_offset(
 +                    atom_table,
 +                    &atoms_by_input_section,
 +                    input.id,
 +                    input_section,
 +                    reloc.offset,
 +                ) else {
 +                    continue;
 +                };
 +                for target_atom in target_atoms_for_reloc(
 +                    input.id,
 +                    input.object,
 +                    atom_table.get(source_atom),
 +                    reloc,
 +                    reloc.referent,
 +                    reloc.subtrahend,
 +                    atom_table,
 +                    sym_table,
 +                    resolved_by_name,
 +                    &atoms_by_input_section,
 +                ) {
 +                    if source_atom != target_atom {
 +                        edge_set.insert((source_atom, target_atom));
 +                    }
 +                }
 +            }
 +        }
 +    }
++
 +    for (atom_id, atom) in atom_table.iter() {
 +        if atom.section != AtomSection::EhFrame {
 +            continue;
 +        }
 +        let Some(cie_atom) = eh_frame_cie_atom(atom_table, &atoms_by_input_section, atom) else {
 +            continue;
 +        };
 +        if atom_id != cie_atom {
 +            edge_set.insert((atom_id, cie_atom));
 +        }
 +    }
++
 +    let mut forward_edges = HashMap::<AtomId, Vec<AtomId>>::new();
 +    for (source, target) in edge_set {
 +        forward_edges.entry(source).or_default().push(target);
 +    }
 +    for targets in forward_edges.values_mut() {
 +        targets.sort_by_key(|aid| aid.0);
 +    }
 +    forward_edges
 +}
++
 +fn parent_edges(atom_table: &AtomTable) -> HashMap<AtomId, Vec<AtomId>> {
 +    let mut out = HashMap::<AtomId, Vec<AtomId>>::new();
 +    for (atom_id, atom) in atom_table.iter() {
 +        if let Some(parent) = atom.parent_of {
 +            out.entry(parent).or_default().push(atom_id);
 +        }
 +    }
 +    for children in out.values_mut() {
 +        children.sort_by_key(|aid| aid.0);
 +    }
 +    out
 +}
++
 +fn atom_symbol_sets(atom_table: &AtomTable) -> HashMap<crate::resolve::AtomId, Vec<SymbolId>> {
 +    let mut out = HashMap::new();
 +    for (atom_id, atom) in atom_table.iter() {
 +        let mut symbols = Vec::new();
 +        if let Some(owner) = atom.owner {
 +            symbols.push(owner);
 +        }
 +        for alt in &atom.alt_entries {
 +            symbols.push(alt.symbol);
 +        }
 +        symbols.sort_by_key(|sid| sid.0);
 +        symbols.dedup();
 +        if !symbols.is_empty() {
 +            out.insert(atom_id, symbols);
 +        }
 +    }
 +    out
 +}
++
 +fn find_atom_for_offset(
 +    atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<AtomId>>,
 +    input_id: InputId,
 +    input_section: u8,
 +    offset: u32,
 +) -> Option<AtomId> {
 +    atoms_by_input_section
 +        .get(&(input_id, input_section))
 +        .and_then(|ids| {
 +            ids.iter().find_map(|atom_id| {
 +                let atom = atom_table.get(*atom_id);
 +                let start = atom.input_offset;
 +                let end = atom.input_offset.saturating_add(atom.size);
 +                (start <= offset && offset < end).then_some(*atom_id)
 +            })
 +        })
 +}
++
 +#[allow(clippy::too_many_arguments)]
 +fn target_atoms_for_reloc(
 +    input_id: InputId,
 +    object: &ObjectFile,
 +    source_atom: &Atom,
 +    reloc: crate::reloc::Reloc,
 +    referent: Referent,
 +    subtrahend: Option<Referent>,
 +    atom_table: &AtomTable,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<AtomId>>,
 +) -> Vec<AtomId> {
 +    let mut out = referent_atoms(
 +        input_id,
 +        object,
 +        source_atom,
 +        reloc,
 +        referent,
 +        atom_table,
 +        sym_table,
 +        resolved_by_name,
 +        atoms_by_input_section,
 +    );
 +    if let Some(subtrahend) = subtrahend {
 +        out.extend(referent_atoms(
 +            input_id,
 +            object,
 +            source_atom,
 +            reloc,
 +            subtrahend,
 +            atom_table,
 +            sym_table,
 +            resolved_by_name,
 +            atoms_by_input_section,
 +        ));
 +    }
 +    out.sort_by_key(|aid| aid.0);
 +    out.dedup();
 +    out
 +}
++
 +#[allow(clippy::too_many_arguments)]
 +fn referent_atoms(
 +    input_id: InputId,
 +    object: &ObjectFile,
 +    source_atom: &Atom,
 +    reloc: crate::reloc::Reloc,
 +    referent: Referent,
 +    atom_table: &AtomTable,
 +    sym_table: &SymbolTable,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<AtomId>>,
 +) -> Vec<AtomId> {
 +    match referent {
 +        Referent::Symbol(symbol_index) => {
 +            let Some(input_sym) = object.symbols.get(symbol_index as usize) else {
 +                return Vec::new();
 +            };
 +            let Some(name) = object.symbol_name(input_sym).ok() else {
 +                return Vec::new();
 +            };
 +            let Some(&symbol_id) = resolved_by_name.get(name) else {
 +                return Vec::new();
 +            };
 +            match sym_table.get(symbol_id) {
 +                Symbol::Defined { atom, .. } if atom.0 != 0 => vec![*atom],
 +                _ => Vec::new(),
 +            }
 +        }
 +        Referent::Section(section_index) => {
 +            if let Some(atom_id) = section_referent_atom(
 +                input_id,
 +                source_atom,
 +                reloc,
 +                section_index,
 +                atom_table,
 +                atoms_by_input_section,
 +            ) {
 +                vec![atom_id]
 +            } else {
 +                atoms_by_input_section
 +                    .get(&(input_id, section_index))
 +                    .cloned()
 +                    .unwrap_or_default()
 +            }
 +        }
 +    }
 +}
++
 +fn section_referent_atom(
 +    input_id: InputId,
 +    source_atom: &Atom,
 +    reloc: crate::reloc::Reloc,
 +    section_index: u8,
 +    atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<AtomId>>,
 +) -> Option<AtomId> {
 +    if source_atom.section == AtomSection::CompactUnwind
 +        && reloc.offset == source_atom.input_offset
 +        && source_atom.data.len() >= 8
 +    {
 +        let mut buf = [0u8; 8];
 +        buf.copy_from_slice(&source_atom.data[..8]);
 +        let target_offset = u64::from_le_bytes(buf) as u32;
 +        return find_atom_for_offset(
 +            atom_table,
 +            atoms_by_input_section,
 +            input_id,
 +            section_index,
 +            target_offset,
 +        );
 +    }
 +    None
 +}
++
 +fn eh_frame_cie_atom(
 +    atom_table: &AtomTable,
 +    atoms_by_input_section: &HashMap<(InputId, u8), Vec<AtomId>>,
 +    atom: &Atom,
 +) -> Option<AtomId> {
 +    if atom.section != AtomSection::EhFrame || atom.data.len() < 8 {
 +        return None;
 +    }
 +    let mut buf = [0u8; 4];
 +    buf.copy_from_slice(&atom.data[4..8]);
 +    let cie_delta = u32::from_le_bytes(buf);
 +    if cie_delta == 0 {
 +        return None;
 +    }
 +    let cie_offset = atom.input_offset.checked_add(4)?.checked_sub(cie_delta)?;
 +    find_atom_for_offset(
 +        atom_table,
 +        atoms_by_input_section,
 +        atom.origin,
 +        atom.input_section,
 +        cie_offset,
 +    )
 +}
++
 +fn target_symbols_for_reloc(
 +    object: &ObjectFile,
 +    referent: Referent,
 +    resolved_by_name: &HashMap<String, SymbolId>,
 +) -> Option<Vec<SymbolId>> {
 +    let Referent::Symbol(symbol_index) = referent else {
 +        return None;
 +    };
 +    let input_sym = object.symbols.get(symbol_index as usize)?;
 +    let name = object.symbol_name(input_sym).ok()?;
 +    resolved_by_name.get(name).copied().map(|sid| vec![sid])
 +}
++
 +fn symbol_name(sym_table: &SymbolTable, symbol_id: SymbolId) -> String {
 +    sym_table
 +        .interner
 +        .resolve(sym_table.get(symbol_id).name())
 +        .to_string()
 +}

tests/cli_diagnostics.rsmodified

927 lines changed — click to load

  use std::path::PathBuf;
  use std::process::Command;
 +use afs_ld::macho::constants::LC_UUID;
 +use afs_ld::macho::reader::{parse_commands, parse_header, LoadCommand};
++
 +const EXPECTED_HELP: &str = include_str!("snapshots/help.txt");
++
  fn have_xcrun() -> bool {
      Command::new("xcrun")
          .arg("-f")
          .unwrap_or(false)
+ }
 +fn sdk_path() -> Option<String> {
 +    let out = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "--show-sdk-path"])
 +        .output()
 +        .ok()?;
 +    if !out.status.success() {
 +        return None;
 +    }
 +    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
 +}
++
 +fn minimal_main_src() -> &'static str {
 +    r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#
 +}
++
  fn assemble(src: &str, out: &PathBuf) -> Result<(), String> {
      let tmp = std::env::temp_dir().join(format!(
          "afs-ld-cli-diag-{}-{}.s",
      std::env::temp_dir().join(format!("afs-ld-cli-diag-{}-{name}", std::process::id()))
+ }
 +fn assemble_minimal_main(name: &str) -> Result<PathBuf, String> {
 +    let obj = scratch(name);
 +    assemble(minimal_main_src(), &obj)?;
 +    Ok(obj)
 +}
++
 +fn assert_flag_errors(flag: &str, expected: &str, name: &str) {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main(&format!("{name}.o")) {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch(&format!("{name}.out"));
 +    let out = Command::new(exe)
 +        .arg(flag)
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(!out.status.success(), "{flag} should fail");
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains(expected),
 +        "missing expected `{expected}` in stderr:\n{stderr}"
 +    );
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +fn archive(objects: &[&PathBuf], out: &PathBuf) -> Result<(), String> {
 +    let output = Command::new("libtool")
 +        .arg("-static")
 +        .arg("-o")
 +        .arg(out)
 +        .args(objects)
 +        .output()
 +        .map_err(|e| format!("spawn libtool: {e}"))?;
 +    if !output.status.success() {
 +        return Err(format!(
 +            "libtool failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +fn nm_defined_names(path: &PathBuf) -> Result<Vec<String>, String> {
 +    let output = Command::new("xcrun")
 +        .args(["nm", "-gj"])
 +        .arg(path)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun nm: {e}"))?;
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun nm failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(String::from_utf8_lossy(&output.stdout)
 +        .lines()
 +        .map(str::trim)
 +        .filter(|line| !line.is_empty())
 +        .map(ToOwned::to_owned)
 +        .collect())
 +}
++
 +#[test]
 +fn help_flag_prints_usage_and_exits_successfully() {
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let out = Command::new(exe)
 +        .arg("--help")
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(out.status.success(), "help should succeed");
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert_eq!(stdout.as_ref(), EXPECTED_HELP);
 +    assert!(
 +        out.stderr.is_empty(),
 +        "help should not write to stderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +}
++
 +#[test]
 +fn version_flag_prints_version_and_exits_successfully() {
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let out = Command::new(exe)
 +        .arg("--version")
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(out.status.success(), "version should succeed");
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert_eq!(
 +        stdout.trim(),
 +        format!("afs-ld {}", env!("CARGO_PKG_VERSION"))
 +    );
 +}
++
 +#[test]
 +fn no_uuid_flag_omits_uuid_load_command() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main("no-uuid-main.o") {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch("no-uuid.out");
 +    let out = Command::new(exe)
 +        .arg("-no_uuid")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-no_uuid link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
++
 +    let bytes = fs::read(&out_path).expect("read linked output");
 +    let header = parse_header(&bytes).expect("parse header");
 +    let commands = parse_commands(&header, &bytes).expect("parse commands");
 +    assert!(
 +        commands.iter().all(|cmd| match cmd {
 +            LoadCommand::Raw { cmd, .. } => *cmd != LC_UUID,
 +            _ => true,
 +        }),
 +        "expected -no_uuid output to omit LC_UUID"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn no_loh_flag_warns_but_links_successfully() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main("no-loh-main.o") {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch("no-loh.out");
 +    let out = Command::new(exe)
 +        .arg("-no_loh")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-no_loh link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains("afs-ld: warning: `-no_loh` requested"),
 +        "expected -no_loh warning:\n{stderr}"
 +    );
 +    assert!(
 +        out_path.is_file(),
 +        "expected -no_loh link to produce {}",
 +        out_path.display()
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn strip_debug_flag_warns_but_links_successfully() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main("strip-debug-main.o") {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch("strip-debug.out");
 +    let out = Command::new(exe)
 +        .arg("-S")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-S link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains("afs-ld: warning: `-S` requested"),
 +        "expected -S warning:\n{stderr}"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn objc_flag_warns_but_links_successfully() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main("objc-main.o") {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch("objc.out");
 +    let out = Command::new(exe)
 +        .arg("-ObjC")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-ObjC link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains("afs-ld: warning: `-ObjC` requested"),
 +        "expected -ObjC warning:\n{stderr}"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn relocatable_flag_errors_loudly() {
 +    assert_flag_errors(
 +        "-r",
 +        "`-r` relocatable output is not yet supported",
 +        "relocatable",
 +    );
 +}
++
 +#[test]
 +fn bundle_flag_errors_loudly() {
 +    assert_flag_errors("-bundle", "`-bundle` output is not yet supported", "bundle");
 +}
++
 +#[test]
 +fn dead_strip_removes_unreferenced_symbols_and_reports_why_live() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let main_obj = scratch("dead-strip-main.o");
 +    let helper_obj = scratch("dead-strip-helper.o");
 +    let unused_obj = scratch("dead-strip-unused.o");
 +    let out_path = scratch("dead-strip.out");
 +    let main_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let unused_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _unused
 +        _unused:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(main_src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
 +    if let Err(e) = assemble(helper_src, &helper_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        return;
 +    }
 +    if let Err(e) = assemble(unused_src, &unused_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        let _ = fs::remove_file(helper_obj);
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-dead_strip")
 +        .arg("-why_live")
 +        .arg("_helper")
 +        .arg("-why_live")
 +        .arg("_unused")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&main_obj)
 +        .arg(&helper_obj)
 +        .arg(&unused_obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-dead_strip link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert!(stdout.contains("_helper is live because:"));
 +    assert!(stdout.contains("_helper is reachable from _main"));
 +    assert!(stdout.contains("_main is in -e _main (GC root)"));
 +    assert!(stdout.contains("_unused is not live (dead-stripped)"));
++
 +    let symbols = match nm_defined_names(&out_path) {
 +        Ok(symbols) => symbols,
 +        Err(e) => {
 +            panic!("nm failed: {e}");
 +        }
 +    };
 +    assert!(symbols.contains(&"_main".to_string()));
 +    assert!(symbols.contains(&"_helper".to_string()));
 +    assert!(
 +        !symbols.contains(&"_unused".to_string()),
 +        "dead-stripped symbol still present:\n{}",
 +        symbols.join("\n")
 +    );
++
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(helper_obj);
 +    let _ = fs::remove_file(unused_obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn dead_strip_keeps_no_dead_strip_roots() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = scratch("dead-strip-no-dead-strip.o");
 +    let out_path = scratch("dead-strip-no-dead-strip.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
++
 +        .globl _keep
 +        _keep:
 +            ret
 +        .desc _keep, 0x20
++
 +        .globl _drop
 +        _drop:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-dead_strip")
 +        .arg("-why_live")
 +        .arg("_keep")
 +        .arg("-why_live")
 +        .arg("_drop")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-dead_strip link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert!(stdout.contains("_keep is live because:"));
 +    assert!(stdout.contains("_keep is marked N_NO_DEAD_STRIP (GC root)"));
 +    assert!(stdout.contains("_drop is not live (dead-stripped)"));
++
 +    let symbols = match nm_defined_names(&out_path) {
 +        Ok(symbols) => symbols,
 +        Err(e) => {
 +            panic!("nm failed: {e}");
 +        }
 +    };
 +    assert!(symbols.contains(&"_main".to_string()));
 +    assert!(symbols.contains(&"_keep".to_string()));
 +    assert!(
 +        !symbols.contains(&"_drop".to_string()),
 +        "dead-stripped symbol still present:\n{}",
 +        symbols.join("\n")
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn icf_safe_flag_links_successfully() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = match assemble_minimal_main("icf-safe-main.o") {
 +        Ok(obj) => obj,
 +        Err(e) => {
 +            eprintln!("skipping: assemble failed: {e}");
 +            return;
 +        }
 +    };
 +    let out_path = scratch("icf-safe.out");
 +    let out = Command::new(exe)
 +        .arg("-icf=safe")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-icf=safe link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    assert!(
 +        out_path.is_file(),
 +        "expected -icf=safe link to produce {}",
 +        out_path.display()
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn icf_all_flag_errors_loudly() {
 +    assert_flag_errors(
 +        "-icf=all",
 +        "`-icf=all` is not yet supported; use `-icf=safe` or `-icf=none`",
 +        "icf-all",
 +    );
 +}
++
 +#[test]
 +fn fixup_chains_flag_errors_loudly() {
 +    assert_flag_errors(
 +        "-fixup_chains",
 +        "`-fixup_chains` is not yet supported",
 +        "fixup-chains",
 +    );
 +}
++
  #[test]
  fn undefined_symbol_diagnostic_is_not_double_prefixed() {
      if !have_xcrun() {
      let _ = fs::remove_file(obj);
+ }
++
 +#[test]
 +fn undefined_warning_mode_links_and_warns_once() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = scratch("missing-warning.o");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _missing
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let out_path = scratch("missing-warning.out");
 +    let out = Command::new(exe)
 +        .arg("-undefined")
 +        .arg("warning")
 +        .arg("-syslibroot")
 +        .arg(&sdk)
 +        .arg("-lSystem")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-undefined warning should link successfully:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains("afs-ld: warning: undefined symbol: _missing"),
 +        "missing expected undefined-symbol warning:\n{stderr}"
 +    );
 +    assert!(
 +        !stderr.contains("afs-ld: warning: afs-ld: warning:"),
 +        "warning diagnostic was double-prefixed:\n{stderr}"
 +    );
 +    assert!(out_path.exists(), "expected linked output to be written");
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn undefined_suppress_mode_links_silently() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = scratch("missing-suppress.o");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _missing
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let out_path = scratch("missing-suppress.out");
 +    let out = Command::new(exe)
 +        .arg("-undefined")
 +        .arg("suppress")
 +        .arg("-syslibroot")
 +        .arg(&sdk)
 +        .arg("-lSystem")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "-undefined suppress should link successfully:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        !stderr.contains("undefined symbol: _missing"),
 +        "expected -undefined suppress to omit undefined diagnostic:\n{stderr}"
 +    );
 +    assert!(out_path.exists(), "expected linked output to be written");
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn trace_flag_prints_loaded_inputs_and_archive_members() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let main_obj = scratch("trace-main.o");
 +    let helper_obj = scratch("trace-helper.o");
 +    let archive_path = scratch("libtracehelpers.a");
 +    let out_path = scratch("trace.out");
 +    let main_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(main_src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
 +    if let Err(e) = assemble(helper_src, &helper_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
 +    if let Err(e) = archive(&[&helper_obj], &archive_path) {
 +        eprintln!("skipping: archive failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        let _ = fs::remove_file(helper_obj);
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-t")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&main_obj)
 +        .arg(&archive_path)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "trace link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stderr = String::from_utf8_lossy(&out.stderr);
 +    assert!(
 +        stderr.contains(&format!("afs-ld: loading {}", main_obj.display())),
 +        "missing main object trace:\n{stderr}"
 +    );
 +    assert!(
 +        stderr.contains(&format!("afs-ld: loading {}", archive_path.display())),
 +        "missing archive trace:\n{stderr}"
 +    );
 +    assert!(
 +        stderr.contains("libtracehelpers.a("),
 +        "missing fetched archive member trace:\n{stderr}"
 +    );
++
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(helper_obj);
 +    let _ = fs::remove_file(archive_path);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn why_live_reports_root_entry_symbol() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let main_obj = scratch("why-live-root-main.o");
 +    let out_path = scratch("why-live-root.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-why_live")
 +        .arg("_main")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&main_obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "why_live link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert!(stdout.contains("_main is live because:"));
 +    assert!(stdout.contains("-dead_strip was not requested"));
 +    assert!(stdout.contains("_main is in -e _main (GC root)"));
++
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn why_live_reports_transitive_symbol_chain() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let main_obj = scratch("why-live-main.o");
 +    let helper_obj = scratch("why-live-helper.o");
 +    let leaf_obj = scratch("why-live-leaf.o");
 +    let out_path = scratch("why-live.out");
 +    let main_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            bl _leaf
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let leaf_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _leaf
 +        _leaf:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(main_src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
 +    if let Err(e) = assemble(helper_src, &helper_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        return;
 +    }
 +    if let Err(e) = assemble(leaf_src, &leaf_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        let _ = fs::remove_file(helper_obj);
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-why_live")
 +        .arg("_leaf")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&main_obj)
 +        .arg(&helper_obj)
 +        .arg(&leaf_obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "why_live link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert!(stdout.contains("_leaf is live because:"));
 +    assert!(stdout.contains("-dead_strip was not requested"));
 +    assert!(stdout.contains("_leaf is reachable from _helper"));
 +    assert!(stdout.contains("_helper is reachable from _main"));
 +    assert!(stdout.contains("_main is in -e _main (GC root)"));
++
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(helper_obj);
 +    let _ = fs::remove_file(leaf_obj);
 +    let _ = fs::remove_file(out_path);
 +}
++
 +#[test]
 +fn why_live_reports_folded_symbol_winner_chain() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let exe = env!("CARGO_BIN_EXE_afs-ld");
 +    let obj = scratch("why-live-folded.o");
 +    let out_path = scratch("why-live-folded.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper1
 +            bl _helper2
 +            mov w0, #0
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .private_extern _helper1
 +        _helper1:
 +            mov w0, #0
 +            ret
++
 +        .private_extern _helper2
 +        _helper2:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let out = Command::new(exe)
 +        .arg("-icf=safe")
 +        .arg("-why_live")
 +        .arg("_helper2")
 +        .arg("-o")
 +        .arg(&out_path)
 +        .arg(&obj)
 +        .output()
 +        .expect("afs-ld should run");
 +    assert!(
 +        out.status.success(),
 +        "why_live folded-symbol link should succeed:\nstderr:\n{}",
 +        String::from_utf8_lossy(&out.stderr)
 +    );
 +    let stdout = String::from_utf8_lossy(&out.stdout);
 +    assert!(stdout.contains("_helper2 was folded to _helper1 by -icf=safe"));
 +    assert!(stdout.contains("_helper1 is live because:"));
 +    assert!(stdout.contains("_helper1 is reachable from _main"));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out_path);
 +}

tests/common/harness.rsmodified

2041 lines changed — click to load

 -//! Differential harness: compare afs-ld output against Apple `ld` output.
 +//! Differential harness shared by parity-oriented integration tests.
  //!
 -//! Sprint 0 lands the diffing surface. The `link_both` function that actually
 -//! shells out to both linkers arrives once afs-ld can produce a real binary
 -//! (Sprint 18). Until then, tests exercise `diff_macho` directly against
 -//! synthesized byte slices.
 +//! The early scaffold only diffed arbitrary byte slices. Sprint 27 starts
 +//! turning it into a real Apple-`ld` matrix harness with a tiny corpus, basic
 +//! tolerated-diff rules, and reusable link/runtime helpers.
  #![allow(dead_code)]
 -use std::path::PathBuf;
 +use std::collections::{BTreeMap, HashSet};
 +use std::fs;
 +use std::path::{Path, PathBuf};
 +use std::process::Command;
 +use std::time::{SystemTime, UNIX_EPOCH};
 +use afs_ld::leb::read_uleb;
 +use afs_ld::macho::constants::{
 +    INDIRECT_SYMBOL_ABS, INDIRECT_SYMBOL_LOCAL, LC_BUILD_VERSION, LC_CODE_SIGNATURE,
 +    LC_DATA_IN_CODE, LC_DYLD_CHAINED_FIXUPS, LC_DYLD_EXPORTS_TRIE, LC_DYLD_INFO_ONLY, LC_DYSYMTAB,
 +    LC_FUNCTION_STARTS, LC_ID_DYLIB, LC_LOAD_DYLIB, LC_LOAD_UPWARD_DYLIB, LC_LOAD_WEAK_DYLIB,
 +    LC_REEXPORT_DYLIB, LC_SEGMENT_64, LC_SYMTAB, LC_UUID,
 +};
 +use afs_ld::macho::dylib::DylibFile;
 +use afs_ld::macho::exports::ExportKind;
 +use afs_ld::macho::reader::{
 +    parse_commands, parse_header, u32_le, BuildVersionCmd, DyldInfoCmd, LoadCommand,
 +    Section64Header,
 +};
 +use afs_ld::string_table::StringTable;
 +use afs_ld::symbol::{parse_nlist_table, SymKind};
 +use afs_ld::synth::unwind::decode_unwind_info;
++
 +#[derive(Debug, Clone)]
  pub struct LinkCase {
 -    pub name: &'static str,
 +    pub name: String,
 +    pub dir: PathBuf,
      pub inputs: Vec<PathBuf>,
      pub args: Vec<String>,
 +    pub section_checks: Vec<(String, String)>,
 +    pub absent_sections: Vec<(String, String)>,
 +    pub page_ref_checks: Vec<PageRefCheck>,
 +    pub command_checks: Vec<CommandCheck>,
 +    artifacts: Vec<ArtifactSpec>,
 +    pub ignored_load_commands: Vec<u32>,
 +    pub absent_load_commands: Vec<u32>,
 +    pub runtime_args: Vec<String>,
 +    pub notes: Option<String>,
 +    pub case_tolerances: Vec<CaseTolerance>,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum CommandCheck {
 +    BuildVersion,
 +    LoadDylibNames,
 +    ExportRecords,
 +    SymbolRecordMap,
 +    IndirectSymbolIdentities,
 +    SymbolPartitionNames,
 +    StringTableNearParity,
 +    FunctionStarts,
 +    NormalizedFunctionStarts,
 +    DataInCode,
 +    RebasedUnwindBytes,
 +    DyldInfoRebase,
 +    DyldInfoBind,
 +    DyldInfoWeakBind,
 +    DyldInfoLazyBind,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct PageRefCheck {
 +    pub segname: String,
 +    pub sectname: String,
 +    pub site_offset: u64,
 +    pub kind: PageRefKind,
 +    pub symbol: String,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum PageRefKind {
 +    Add,
 +    Load,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct CaseTolerance {
 +    pub region: ToleranceRegion,
 +    pub reason: String,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum ToleranceRegion {
 +    SectionBytes {
 +        segname: String,
 +        sectname: Option<String>,
 +        start: usize,
 +        end_inclusive: usize,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct ArtifactSpec {
 +    src_name: String,
 +    out_name: String,
 +    kind: ArtifactKind,
 +    dep_name: Option<String>,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum ArtifactKind {
 +    ClangDylib,
 +    ClangArchive,
 +    ClangReexportDylib,
+ }
  pub struct LinkOutputs {
      pub ours: Vec<u8>,
      pub theirs: Vec<u8>,
 +    pub our_path: PathBuf,
 +    pub their_path: PathBuf,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum DiffCategory {
 -    /// A diff we expect: UUID bytes, timestamps, hash-backed temp paths, etc.
 +    /// A diff we expect: UUID bytes, code-signature hashes, etc.
      Tolerated(&'static str),
      /// Anything else. Fails the parity test.
      Critical,
+     }
+ }
 -/// Byte-level diff between two Mach-O images. Sprint 0 treats every byte diff
 -/// as Critical; later sprints layer in the tolerated-diff predicates (UUID,
 -/// timestamp, code-signature hashes, string-table suffix-dedup variance).
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ProgramOutput {
 +    pub exit_code: Option<i32>,
 +    pub stdout: Vec<u8>,
 +    pub stderr: Vec<u8>,
 +}
++
 +type NormalizedBuildVersion = (u32, u32, u32, Vec<u32>);
++
 +pub fn have_xcrun() -> bool {
 +    Command::new("xcrun")
 +        .arg("-f")
 +        .arg("as")
 +        .output()
 +        .map(|o| o.status.success())
 +        .unwrap_or(false)
 +}
++
 +pub fn have_xcrun_tool(tool: &str) -> bool {
 +    Command::new("xcrun")
 +        .arg("-f")
 +        .arg(tool)
 +        .output()
 +        .map(|o| o.status.success())
 +        .unwrap_or(false)
 +}
++
 +pub fn have_tool(tool: &str) -> bool {
 +    Command::new(tool)
 +        .arg("--version")
 +        .output()
 +        .map(|o| o.status.success() || !o.stderr.is_empty())
 +        .unwrap_or(false)
 +}
++
 +pub fn sdk_path() -> Option<String> {
 +    let out = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "--show-sdk-path"])
 +        .output()
 +        .ok()?;
 +    if !out.status.success() {
 +        return None;
 +    }
 +    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
 +}
++
 +pub fn sdk_version() -> Option<String> {
 +    let out = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "--show-sdk-version"])
 +        .output()
 +        .ok()?;
 +    if !out.status.success() {
 +        return None;
 +    }
 +    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
 +}
++
 +pub fn scratch(name: &str) -> PathBuf {
 +    std::env::temp_dir().join(format!("afs-ld-parity-{}-{name}", std::process::id()))
 +}
++
 +pub fn assemble(src: &str, out: &PathBuf) -> Result<(), String> {
 +    let tmp = std::env::temp_dir().join(format!(
 +        "afs-ld-parity-{}-{}.s",
 +        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}", tmp.display()))?;
 +    let output = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "as", "-arch", "arm64"])
 +        .arg(&tmp)
 +        .arg("-o")
 +        .arg(out)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun as: {e}"))?;
 +    let _ = fs::remove_file(&tmp);
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun as failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +pub fn compile_c(src: &str, out: &PathBuf) -> Result<(), String> {
 +    let tmp = std::env::temp_dir().join(format!(
 +        "afs-ld-parity-{}-{}.c",
 +        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}", tmp.display()))?;
 +    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-parity-{}-{}.c",
 +        std::process::id(),
 +        out.file_stem().and_then(|s| s.to_str()).unwrap_or("lib")
 +    ));
 +    fs::write(&tmp, src).map_err(|e| format!("write {}: {e}", tmp.display()))?;
 +    let install_name = out.to_string_lossy().to_string();
 +    let output = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "clang", "-arch", "arm64", "-dynamiclib"])
 +        .arg(&tmp)
 +        .arg(format!("-Wl,-install_name,{install_name}"))
 +        .arg("-o")
 +        .arg(out)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun clang dylib: {e}"))?;
 +    let _ = fs::remove_file(&tmp);
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun clang dylib failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +fn compile_archive_c(src: &str, out: &PathBuf) -> Result<(), String> {
 +    let obj = out.with_extension("o");
 +    compile_c(src, &obj)?;
 +    let output = Command::new("libtool")
 +        .args(["-static", "-o"])
 +        .arg(out)
 +        .arg(&obj)
 +        .output()
 +        .map_err(|e| format!("spawn libtool archive: {e}"))?;
 +    let _ = fs::remove_file(&obj);
 +    if !output.status.success() {
 +        return Err(format!(
 +            "libtool archive failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +fn compile_reexport_dylib_c(src: &str, out: &PathBuf, dep: &Path) -> Result<(), String> {
 +    let tmp = std::env::temp_dir().join(format!(
 +        "afs-ld-parity-{}-{}.c",
 +        std::process::id(),
 +        out.file_stem()
 +            .and_then(|s| s.to_str())
 +            .unwrap_or("reexport")
 +    ));
 +    fs::write(&tmp, src).map_err(|e| format!("write {}: {e}", tmp.display()))?;
 +    let install_name = out.to_string_lossy().to_string();
 +    let output = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "clang", "-arch", "arm64", "-dynamiclib"])
 +        .arg(&tmp)
 +        .arg(format!("-Wl,-install_name,{install_name}"))
 +        .arg(format!("-Wl,-reexport_library,{}", dep.display()))
 +        .arg("-o")
 +        .arg(out)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun clang reexport dylib: {e}"))?;
 +    let _ = fs::remove_file(&tmp);
 +    if !output.status.success() {
 +        return Err(format!(
 +            "xcrun clang reexport dylib failed: {}",
 +            String::from_utf8_lossy(&output.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +pub fn load_corpus(root: &Path) -> Result<Vec<LinkCase>, String> {
 +    let mut cases = Vec::new();
 +    let entries =
 +        fs::read_dir(root).map_err(|e| format!("read parity corpus {}: {e}", root.display()))?;
 +    for entry in entries {
 +        let entry = entry.map_err(|e| format!("read parity corpus entry: {e}"))?;
 +        let path = entry.path();
 +        if !path.is_dir() {
 +            continue;
 +        }
++
 +        let name = path
 +            .file_name()
 +            .and_then(|s| s.to_str())
 +            .ok_or_else(|| format!("invalid UTF-8 case directory {}", path.display()))?
 +            .to_string();
 +        let inputs_dir = path.join("inputs");
 +        let mut inputs = Vec::new();
 +        let input_entries = fs::read_dir(&inputs_dir)
 +            .map_err(|e| format!("read inputs for {}: {e}", path.display()))?;
 +        for input in input_entries {
 +            let input = input.map_err(|e| format!("read input entry for {}: {e}", name))?;
 +            let input_path = input.path();
 +            match input_path.extension().and_then(|s| s.to_str()) {
 +                Some("s") | Some("c") | Some("o") | Some("a") | Some("tbd") => {
 +                    inputs.push(input_path)
 +                }
 +                _ => {}
 +            }
 +        }
 +        inputs.sort();
 +        if inputs.is_empty() {
 +            return Err(format!(
 +                "parity corpus case {} has no supported source inputs",
 +                path.display()
 +            ));
 +        }
++
 +        let args = read_tokens(&path.join("args.txt"))?;
 +        let section_checks = read_sections(&path.join("sections.txt"))?;
 +        let absent_sections = read_sections_if_present(&path.join("absent_sections.txt"))?;
 +        let page_ref_checks = read_page_refs(&path.join("page_refs.txt"))?;
 +        let command_checks = read_command_checks(&path.join("command_checks.txt"))?;
 +        let artifacts = read_artifacts(&path.join("artifacts.txt"))?;
 +        let artifact_srcs: HashSet<&str> = artifacts
 +            .iter()
 +            .map(|artifact| artifact.src_name.as_str())
 +            .collect();
 +        inputs.retain(|input| {
 +            input
 +                .file_name()
 +                .and_then(|s| s.to_str())
 +                .map(|name| !artifact_srcs.contains(name))
 +                .unwrap_or(true)
 +        });
 +        let ignored_load_commands =
 +            read_load_command_names(&path.join("ignored_load_commands.txt"))?;
 +        let absent_load_commands = read_load_command_names(&path.join("absent_load_commands.txt"))?;
 +        let runtime_args = read_tokens_if_present(&path.join("runtime.txt"))?;
 +        let notes = fs::read_to_string(path.join("notes.md")).ok();
 +        let case_tolerances = parse_case_tolerances(notes.as_deref())?;
++
 +        cases.push(LinkCase {
 +            name,
 +            dir: path,
 +            inputs,
 +            args,
 +            section_checks,
 +            absent_sections,
 +            page_ref_checks,
 +            command_checks,
 +            artifacts,
 +            ignored_load_commands,
 +            absent_load_commands,
 +            runtime_args,
 +            notes,
 +            case_tolerances,
 +        });
 +    }
++
 +    cases.sort_by(|a, b| a.name.cmp(&b.name));
 +    Ok(cases)
 +}
++
 +pub fn link_both(case: &LinkCase) -> Result<LinkOutputs, String> {
 +    let sdk = sdk_path().ok_or_else(|| "xcrun --show-sdk-path unavailable".to_string())?;
 +    let sdk_ver =
 +        sdk_version().ok_or_else(|| "xcrun --show-sdk-version unavailable".to_string())?;
 +    let work_dir = unique_temp_dir(&case.name)?;
 +    let mut compiled: BTreeMap<String, PathBuf> = BTreeMap::new();
 +    let mut sidecars: BTreeMap<String, PathBuf> = BTreeMap::new();
 +    let mut artifacts: BTreeMap<String, PathBuf> = BTreeMap::new();
 +    for input in &case.inputs {
 +        let stem = input
 +            .file_stem()
 +            .and_then(|s| s.to_str())
 +            .ok_or_else(|| format!("invalid input stem {}", input.display()))?;
 +        match input.extension().and_then(|s| s.to_str()) {
 +            Some("s") => {
 +                let src = fs::read_to_string(input)
 +                    .map_err(|e| format!("read parity input {}: {e}", input.display()))?;
 +                let obj = work_dir.join(format!("{stem}.o"));
 +                assemble(&src, &obj)?;
 +                compiled.insert(format!("{stem}.o"), obj);
 +            }
 +            Some("c") => {
 +                let src = fs::read_to_string(input)
 +                    .map_err(|e| format!("read parity input {}: {e}", input.display()))?;
 +                let obj = work_dir.join(format!("{stem}.o"));
 +                compile_c(&src, &obj)?;
 +                compiled.insert(format!("{stem}.o"), obj);
 +            }
 +            Some("o") | Some("a") | Some("tbd") => {
 +                let copied = work_dir.join(
 +                    input
 +                        .file_name()
 +                        .ok_or_else(|| format!("invalid input file name {}", input.display()))?,
 +                );
 +                fs::copy(input, &copied).map_err(|e| {
 +                    format!(
 +                        "copy parity input {} -> {}: {e}",
 +                        input.display(),
 +                        copied.display()
 +                    )
 +                })?;
 +                compiled.insert(
 +                    input
 +                        .file_name()
 +                        .and_then(|s| s.to_str())
 +                        .ok_or_else(|| format!("invalid UTF-8 input file {}", input.display()))?
 +                        .to_string(),
 +                    copied,
 +                );
 +            }
 +            other => {
 +                return Err(format!(
 +                    "unsupported parity input extension {:?} for {}",
 +                    other,
 +                    input.display()
 +                ));
 +            }
 +        }
 +    }
 +    let files_dir = case.dir.join("files");
 +    if files_dir.is_dir() {
 +        for entry in fs::read_dir(&files_dir)
 +            .map_err(|e| format!("read sidecar files for {}: {e}", case.name))?
 +        {
 +            let entry = entry.map_err(|e| format!("read sidecar entry for {}: {e}", case.name))?;
 +            let src = entry.path();
 +            if !src.is_file() {
 +                continue;
 +            }
 +            let name = src
 +                .file_name()
 +                .and_then(|s| s.to_str())
 +                .ok_or_else(|| format!("invalid sidecar file name {}", src.display()))?
 +                .to_string();
 +            let dst = work_dir.join(&name);
 +            fs::copy(&src, &dst)
 +                .map_err(|e| format!("copy sidecar {} -> {}: {e}", src.display(), dst.display()))?;
 +            sidecars.insert(name, dst);
 +        }
 +    }
 +    for artifact in &case.artifacts {
 +        let src = case.dir.join("inputs").join(&artifact.src_name);
 +        let src_contents = fs::read_to_string(&src)
 +            .map_err(|e| format!("read artifact src {}: {e}", src.display()))?;
 +        let out = work_dir.join(&artifact.out_name);
 +        match artifact.kind {
 +            ArtifactKind::ClangDylib => compile_dylib_c(&src_contents, &out)?,
 +            ArtifactKind::ClangArchive => compile_archive_c(&src_contents, &out)?,
 +            ArtifactKind::ClangReexportDylib => {
 +                let dep_name = artifact.dep_name.as_ref().ok_or_else(|| {
 +                    format!(
 +                        "missing reexport dependency for artifact {}",
 +                        artifact.out_name
 +                    )
 +                })?;
 +                let dep = artifacts
 +                    .get(dep_name)
 +                    .ok_or_else(|| format!("unknown reexport dependency `{dep_name}`"))?;
 +                compile_reexport_dylib_c(&src_contents, &out, dep)?;
 +            }
 +        }
 +        artifacts.insert(artifact.out_name.clone(), out);
 +    }
++
 +    let suffix = if case.args.iter().any(|arg| arg == "-dylib") {
 +        "dylib"
 +    } else {
 +        "out"
 +    };
 +    let our_path = work_dir.join(format!("ours.{suffix}"));
 +    let their_path = work_dir.join(format!("apple.{suffix}"));
++
 +    let our_args = expand_args(
 +        &case.args, &compiled, &sidecars, &artifacts, &our_path, &sdk, &sdk_ver,
 +    )?;
 +    let their_args = expand_args(
 +        &case.args,
 +        &compiled,
 +        &sidecars,
 +        &artifacts,
 +        &their_path,
 +        &sdk,
 +        &sdk_ver,
 +    )?;
++
 +    let our_output = Command::new(env!("CARGO_BIN_EXE_afs-ld"))
 +        .args(&our_args)
 +        .output()
 +        .map_err(|e| format!("spawn afs-ld: {e}"))?;
 +    if !our_output.status.success() {
 +        return Err(format!(
 +            "afs-ld failed for {}:\n{}",
 +            case.name,
 +            String::from_utf8_lossy(&our_output.stderr)
 +        ));
 +    }
++
 +    let their_output = Command::new("xcrun")
 +        .arg("ld")
 +        .args(&their_args)
 +        .output()
 +        .map_err(|e| format!("spawn xcrun ld: {e}"))?;
 +    if !their_output.status.success() {
 +        return Err(format!(
 +            "Apple ld failed for {}:\n{}",
 +            case.name,
 +            String::from_utf8_lossy(&their_output.stderr)
 +        ));
 +    }
++
 +    let ours = fs::read(&our_path)
 +        .map_err(|e| format!("read afs-ld output {}: {e}", our_path.display()))?;
 +    let theirs = fs::read(&their_path)
 +        .map_err(|e| format!("read Apple ld output {}: {e}", their_path.display()))?;
++
 +    Ok(LinkOutputs {
 +        ours,
 +        theirs,
 +        our_path,
 +        their_path,
 +    })
 +}
++
 +pub fn command_ids(bytes: &[u8]) -> Result<Vec<u32>, String> {
 +    let header = parse_header(bytes).map_err(|e| format!("parse header: {e}"))?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| format!("parse commands: {e}"))?;
 +    Ok(commands
 +        .into_iter()
 +        .map(|cmd| match cmd {
 +            LoadCommand::Segment64(_) => LC_SEGMENT_64,
 +            LoadCommand::Symtab(_) => LC_SYMTAB,
 +            LoadCommand::Dysymtab(_) => LC_DYSYMTAB,
 +            LoadCommand::BuildVersion(_) => LC_BUILD_VERSION,
 +            LoadCommand::DyldInfoOnly(_) => LC_DYLD_INFO_ONLY,
 +            LoadCommand::DyldChainedFixups(_) => LC_DYLD_CHAINED_FIXUPS,
 +            LoadCommand::DyldExportsTrie(_) => LC_DYLD_EXPORTS_TRIE,
 +            LoadCommand::Dylib(d) => d.cmd,
 +            LoadCommand::Raw { cmd, .. } => cmd,
 +            other => panic!("unexpected load command in command_ids helper: {other:?}"),
 +        })
 +        .collect())
 +}
++
 +pub fn compare_command_ids(ours: &[u8], theirs: &[u8], ignored: &[u32]) -> Result<(), String> {
 +    let our_ids: Vec<u32> = command_ids(ours)?
 +        .into_iter()
 +        .filter(|cmd| !ignored.contains(cmd))
 +        .collect();
 +    let their_ids: Vec<u32> = command_ids(theirs)?
 +        .into_iter()
 +        .filter(|cmd| !ignored.contains(cmd))
 +        .collect();
 +    if our_ids != their_ids {
 +        return Err(format!(
 +            "load-command ids differ:\nours:   {our_ids:#x?}\ntheirs: {their_ids:#x?}"
 +        ));
 +    }
 +    Ok(())
 +}
++
 +pub fn compare_command_details(
 +    ours: &[u8],
 +    theirs: &[u8],
 +    checks: &[CommandCheck],
 +) -> Result<(), String> {
 +    for check in checks {
 +        match check {
 +            CommandCheck::BuildVersion => {
 +                let ours = normalized_build_version(ours)?;
 +                let theirs = normalized_build_version(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "LC_BUILD_VERSION diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::LoadDylibNames => {
 +                let ours = load_dylib_names(ours)?;
 +                let theirs = load_dylib_names(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "LC_LOAD_DYLIB names diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::ExportRecords => {
 +                let ours = canonical_export_records(ours)?;
 +                let theirs = canonical_export_records(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "canonical export records diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::SymbolRecordMap => {
 +                let ours = canonical_symbol_record_map(ours)?;
 +                let theirs = canonical_symbol_record_map(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "canonical symbol record map diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::IndirectSymbolIdentities => {
 +                let ours = indirect_symbol_identities(ours)?;
 +                let theirs = indirect_symbol_identities(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "indirect symbol identities diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::SymbolPartitionNames => {
 +                let ours = symbol_partition_names(ours)?;
 +                let theirs = symbol_partition_names(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "symbol partition names diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::StringTableNearParity => {
 +                let our_len = raw_string_table(ours)?.len();
 +                let their_len = raw_string_table(theirs)?.len();
 +                if !string_table_within_five_percent(our_len, their_len) {
 +                    return Err(format!(
 +                        "string table length drifted too far from Apple ld: ours={} theirs={}",
 +                        our_len, their_len
 +                    ));
 +                }
 +            }
 +            CommandCheck::FunctionStarts => {
 +                let ours = decode_function_starts(ours)?;
 +                let theirs = decode_function_starts(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "function starts diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::NormalizedFunctionStarts => {
 +                let ours = normalize_function_start_offsets(&decode_function_starts(ours)?);
 +                let theirs = normalize_function_start_offsets(&decode_function_starts(theirs)?);
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "normalized function starts diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::DataInCode => {
 +                let ours = canonical_data_in_code(ours)?;
 +                let theirs = canonical_data_in_code(theirs)?;
 +                if ours != theirs {
 +                    return Err(format!(
 +                        "canonical data-in-code records diverged:\nours:   {ours:#?}\ntheirs: {theirs:#?}"
 +                    ));
 +                }
 +            }
 +            CommandCheck::RebasedUnwindBytes => {
 +                let ours = rebased_unwind_bytes(ours)?;
 +                let theirs = rebased_unwind_bytes(theirs)?;
 +                if ours != theirs {
 +                    return Err("rebased unwind bytes diverged".to_string());
 +                }
 +            }
 +            CommandCheck::DyldInfoRebase => {
 +                let ours = dyld_info_stream(ours, DyldInfoStreamKind::Rebase)?;
 +                let theirs = dyld_info_stream(theirs, DyldInfoStreamKind::Rebase)?;
 +                if ours != theirs {
 +                    return Err("rebase stream diverged".to_string());
 +                }
 +            }
 +            CommandCheck::DyldInfoBind => {
 +                let ours = dyld_info_stream(ours, DyldInfoStreamKind::Bind)?;
 +                let theirs = dyld_info_stream(theirs, DyldInfoStreamKind::Bind)?;
 +                if ours != theirs {
 +                    return Err("bind stream diverged".to_string());
 +                }
 +            }
 +            CommandCheck::DyldInfoWeakBind => {
 +                let ours = dyld_info_stream(ours, DyldInfoStreamKind::WeakBind)?;
 +                let theirs = dyld_info_stream(theirs, DyldInfoStreamKind::WeakBind)?;
 +                if ours != theirs {
 +                    return Err("weak-bind stream diverged".to_string());
 +                }
 +            }
 +            CommandCheck::DyldInfoLazyBind => {
 +                let ours = dyld_info_stream(ours, DyldInfoStreamKind::LazyBind)?;
 +                let theirs = dyld_info_stream(theirs, DyldInfoStreamKind::LazyBind)?;
 +                if ours != theirs {
 +                    return Err("lazy-bind stream diverged".to_string());
 +                }
 +            }
 +        }
 +    }
 +    Ok(())
 +}
++
 +pub fn ensure_absent_load_commands(
 +    bytes: &[u8],
 +    commands: &[u32],
 +    side: &str,
 +) -> Result<(), String> {
 +    let ids = command_ids(bytes)?;
 +    for command in commands {
 +        if ids.contains(command) {
 +            return Err(format!(
 +                "{side} unexpectedly emitted {}",
 +                load_command_name(*command)
 +            ));
 +        }
 +    }
 +    Ok(())
 +}
++
 +pub fn ensure_absent_sections(
 +    bytes: &[u8],
 +    sections: &[(String, String)],
 +    side: &str,
 +) -> Result<(), String> {
 +    for (segname, sectname) in sections {
 +        if output_section(bytes, segname, sectname).is_some() {
 +            return Err(format!(
 +                "{side} unexpectedly emitted section {segname},{sectname}"
 +            ));
 +        }
 +    }
 +    Ok(())
 +}
++
 +pub fn output_section(bytes: &[u8], segname: &str, sectname: &str) -> Option<(u64, Vec<u8>)> {
 +    let header = parse_header(bytes).ok()?;
 +    let commands = parse_commands(&header, bytes).ok()?;
 +    for cmd in commands {
 +        if let LoadCommand::Segment64(seg) = cmd {
 +            for section in seg.sections {
 +                if section.segname_str() == segname && section.sectname_str() == sectname {
 +                    let data = if section.offset == 0 {
 +                        Vec::new()
 +                    } else {
 +                        let start = section.offset as usize;
 +                        let end = start + section.size as usize;
 +                        bytes.get(start..end)?.to_vec()
 +                    };
 +                    return Some((section.addr, data));
 +                }
 +            }
 +        }
 +    }
 +    None
 +}
++
 +fn output_section_header(bytes: &[u8], segname: &str, sectname: &str) -> Option<Section64Header> {
 +    let header = parse_header(bytes).ok()?;
 +    let commands = parse_commands(&header, bytes).ok()?;
 +    for cmd in commands {
 +        if let LoadCommand::Segment64(seg) = cmd {
 +            for section in seg.sections {
 +                if section.segname_str() == segname && section.sectname_str() == sectname {
 +                    return Some(section);
 +                }
 +            }
 +        }
 +    }
 +    None
 +}
++
 +fn segment_vmaddr(bytes: &[u8], segname: &str) -> Option<u64> {
 +    let header = parse_header(bytes).ok()?;
 +    let commands = parse_commands(&header, bytes).ok()?;
 +    for cmd in commands {
 +        if let LoadCommand::Segment64(seg) = cmd {
 +            if seg.segname_str() == segname {
 +                return Some(seg.vmaddr);
 +            }
 +        }
 +    }
 +    None
 +}
++
 +pub fn compare_sections(
 +    ours: &[u8],
 +    theirs: &[u8],
 +    sections: &[(String, String)],
 +    case_tolerances: &[CaseTolerance],
 +) -> Result<(), String> {
 +    for (segname, sectname) in sections {
 +        let (_, our_bytes) = output_section(ours, segname, sectname)
 +            .ok_or_else(|| format!("missing section {segname},{sectname} in afs-ld output"))?;
 +        let (_, their_bytes) = output_section(theirs, segname, sectname)
 +            .ok_or_else(|| format!("missing section {segname},{sectname} in Apple output"))?;
 +        let diff = apply_section_tolerances(
 +            diff_macho(&our_bytes, &their_bytes),
 +            segname,
 +            sectname,
 +            case_tolerances,
 +        );
 +        if !diff.is_clean() {
 +            return Err(format!(
 +                "section bytes differ for {segname},{sectname}: {:#?}",
 +                diff.critical
 +            ));
 +        }
 +    }
 +    Ok(())
 +}
++
 +pub fn compare_page_refs(
 +    ours: &[u8],
 +    theirs: &[u8],
 +    checks: &[PageRefCheck],
 +) -> Result<(), String> {
 +    if checks.is_empty() {
 +        return Ok(());
 +    }
 +    let our_symbols = symbol_values(ours)?;
 +    let their_symbols = symbol_values(theirs)?;
 +    for check in checks {
 +        let (our_addr, our_bytes) = output_section(ours, &check.segname, &check.sectname)
 +            .ok_or_else(|| {
 +                format!(
 +                    "missing section {},{} in afs-ld output",
 +                    check.segname, check.sectname
 +                )
 +            })?;
 +        let (their_addr, their_bytes) = output_section(theirs, &check.segname, &check.sectname)
 +            .ok_or_else(|| {
 +                format!(
 +                    "missing section {},{} in Apple output",
 +                    check.segname, check.sectname
 +                )
 +            })?;
 +        let our_target =
 +            decode_page_reference(&our_bytes, our_addr, check.site_offset, check.kind)?;
 +        let their_target =
 +            decode_page_reference(&their_bytes, their_addr, check.site_offset, check.kind)?;
 +        let expected_ours = *our_symbols
 +            .get(&check.symbol)
 +            .ok_or_else(|| format!("missing symbol {} in afs-ld output", check.symbol))?;
 +        let expected_theirs = *their_symbols
 +            .get(&check.symbol)
 +            .ok_or_else(|| format!("missing symbol {} in Apple output", check.symbol))?;
 +        if our_target != expected_ours || their_target != expected_theirs {
 +            return Err(format!(
 +                "page ref {},{}+0x{:x} -> {} diverged: ours=0x{:x} expected=0x{:x}; theirs=0x{:x} expected=0x{:x}",
 +                check.segname,
 +                check.sectname,
 +                check.site_offset,
 +                check.symbol,
 +                our_target,
 +                expected_ours,
 +                their_target,
 +                expected_theirs,
 +            ));
 +        }
 +    }
 +    Ok(())
 +}
++
 +pub fn run_program(path: &Path, args: &[String]) -> Result<ProgramOutput, String> {
 +    let output = Command::new(path)
 +        .args(args)
 +        .output()
 +        .map_err(|e| format!("run {}: {e}", path.display()))?;
 +    Ok(ProgramOutput {
 +        exit_code: output.status.code(),
 +        stdout: output.stdout,
 +        stderr: output.stderr,
 +    })
 +}
++
 +pub fn compare_runtime(our_path: &Path, their_path: &Path, args: &[String]) -> Result<(), String> {
 +    let ours = run_program(our_path, args)?;
 +    let theirs = run_program(their_path, args)?;
 +    if ours != theirs {
 +        return Err(format!(
 +            "runtime differs:\nours: exit={:?} stdout={:?} stderr={:?}\ntheirs: exit={:?} stdout={:?} stderr={:?}",
 +            ours.exit_code,
 +            String::from_utf8_lossy(&ours.stdout),
 +            String::from_utf8_lossy(&ours.stderr),
 +            theirs.exit_code,
 +            String::from_utf8_lossy(&theirs.stdout),
 +            String::from_utf8_lossy(&theirs.stderr),
 +        ));
 +    }
 +    Ok(())
 +}
++
 +/// Byte-level diff between two Mach-O images or section byte slices.
 +///
 +/// Sprint 27 starts tolerating a very small allowlist: UUID bytes, dylib
 +/// timestamp fields, and code-signature command/blob bytes at matching
 +/// offsets. Unknown diffs remain critical.
  pub fn diff_macho(ours: &[u8], theirs: &[u8]) -> DiffReport {
      let mut report = DiffReport::default();
          return report;
+     }
 +    let our_mask = tolerated_mask(ours);
 +    let their_mask = tolerated_mask(theirs);
++
      let mut i = 0;
      while i < ours.len() {
 -        if ours[i] != theirs[i] {
 -            let start = i;
 -            while i < ours.len() && ours[i] != theirs[i] {
 -                i += 1;
 +        if ours[i] == theirs[i] {
 +            i += 1;
 +            continue;
 +        }
++
 +        let tolerated_reason = match (our_mask[i], their_mask[i]) {
 +            (Some(left), Some(right)) if left == right => Some(left),
 +            _ => None,
 +        };
 +        let start = i;
 +        i += 1;
 +        while i < ours.len() && ours[i] != theirs[i] {
 +            let same_category = match tolerated_reason {
 +                Some(reason) => matches!(
 +                    (our_mask[i], their_mask[i]),
 +                    (Some(left), Some(right)) if left == reason && right == reason
 +                ),
 +                None => !matches!(
 +                    (our_mask[i], their_mask[i]),
 +                    (Some(left), Some(right)) if left == right
 +                ),
 +            };
 +            if !same_category {
 +                break;
+             }
 +            i += 1;
 +        }
++
 +        let len = i - start;
 +        if let Some(reason) = tolerated_reason {
 +            report.tolerated.push(DiffChunk {
 +                offset: start,
 +                len,
 +                reason: reason.to_string(),
 +                category: DiffCategory::Tolerated(reason),
 +            });
 +        } else {
              report.critical.push(DiffChunk {
                  offset: start,
 -                len: i - start,
 -                reason: format!("{} byte(s) differ starting at 0x{start:x}", i - start),
 +                len,
 +                reason: format!("{} byte(s) differ starting at 0x{start:x}", len),
                  category: DiffCategory::Critical,
              });
 -        } else {
 -            i += 1;
+         }
+     }
      report
+ }
 -/// Placeholder for the full linker-spawning contract. Sprint 18 wires this to
 -/// real invocations of afs-ld and the system `ld` via `xcrun -f ld`.
 -pub fn link_both(_case: &LinkCase) -> LinkOutputs {
 -    panic!("link_both is not implemented until Sprint 18 (hello-world milestone)");
 +pub fn parse_case_tolerances(notes: Option<&str>) -> Result<Vec<CaseTolerance>, String> {
 +    let Some(notes) = notes else {
 +        return Ok(Vec::new());
 +    };
++
 +    let mut tolerances = Vec::new();
 +    let mut in_block = false;
 +    for raw_line in notes.lines() {
 +        let line = raw_line.trim();
 +        if line.is_empty() {
 +            continue;
 +        }
 +        if line == "tolerated:" {
 +            in_block = true;
 +            continue;
 +        }
 +        if !in_block {
 +            continue;
 +        }
 +        if !line.starts_with("- region:") {
 +            // Stop once the simple tolerated block ends.
 +            if !line.starts_with('#') && !raw_line.starts_with(' ') && !raw_line.starts_with('\t') {
 +                break;
 +            }
 +            continue;
 +        }
 +        tolerances.push(parse_case_tolerance_line(line)?);
 +    }
 +    Ok(tolerances)
 +}
++
 +pub fn apply_section_tolerances(
 +    mut diff: DiffReport,
 +    segname: &str,
 +    sectname: &str,
 +    case_tolerances: &[CaseTolerance],
 +) -> DiffReport {
 +    if diff.critical.is_empty() || case_tolerances.is_empty() {
 +        return diff;
 +    }
++
 +    let mut remaining = Vec::new();
 +    for chunk in diff.critical.drain(..) {
 +        let tolerated = case_tolerances
 +            .iter()
 +            .find(|tol| tolerance_covers_chunk(tol, segname, sectname, chunk.offset, chunk.len));
 +        if let Some(tol) = tolerated {
 +            diff.tolerated.push(DiffChunk {
 +                offset: chunk.offset,
 +                len: chunk.len,
 +                reason: tol.reason.clone(),
 +                category: DiffCategory::Tolerated("case-note"),
 +            });
 +        } else {
 +            remaining.push(chunk);
 +        }
 +    }
 +    diff.critical = remaining;
 +    diff
 +}
++
 +fn unique_temp_dir(case_name: &str) -> Result<PathBuf, String> {
 +    let stamp = SystemTime::now()
 +        .duration_since(UNIX_EPOCH)
 +        .map_err(|e| format!("clock error: {e}"))?
 +        .as_nanos();
 +    let safe_name = case_name.replace(['/', ' '], "-");
 +    let dir = std::env::temp_dir().join(format!(
 +        "afs-ld-parity-{}-{safe_name}-{stamp}",
 +        std::process::id()
 +    ));
 +    fs::create_dir_all(&dir).map_err(|e| format!("create {}: {e}", dir.display()))?;
 +    Ok(dir)
 +}
++
 +fn parse_case_tolerance_line(line: &str) -> Result<CaseTolerance, String> {
 +    let rest = line
 +        .strip_prefix("- region:")
 +        .ok_or_else(|| format!("invalid tolerance line `{line}`"))?
 +        .trim();
 +    let (before_reason, reason_part) = rest
 +        .split_once(" reason:")
 +        .ok_or_else(|| format!("missing `reason:` in tolerance line `{line}`"))?;
 +    let (region_part, bytes_part) = before_reason
 +        .split_once(" bytes ")
 +        .ok_or_else(|| format!("missing `bytes` range in tolerance line `{line}`"))?;
 +    let reason = reason_part.trim().trim_matches('"').to_string();
 +    if reason.is_empty() {
 +        return Err(format!("empty tolerance reason in `{line}`"));
 +    }
 +    let (start, end_inclusive) = parse_tolerance_range(bytes_part.trim())?;
 +    let region_token = region_part.trim();
 +    let (segname, sectname) = match region_token.split_once(',') {
 +        Some((segname, sectname)) => (
 +            segname.trim().to_string(),
 +            Some(sectname.trim().to_string()),
 +        ),
 +        None => (region_token.to_string(), None),
 +    };
 +    if segname.is_empty() {
 +        return Err(format!("empty tolerance region in `{line}`"));
 +    }
 +    Ok(CaseTolerance {
 +        region: ToleranceRegion::SectionBytes {
 +            segname,
 +            sectname,
 +            start,
 +            end_inclusive,
 +        },
 +        reason,
 +    })
 +}
++
 +fn parse_tolerance_range(range: &str) -> Result<(usize, usize), String> {
 +    let (start, end) = range
 +        .split_once('-')
 +        .ok_or_else(|| format!("invalid tolerance range `{range}`"))?;
 +    let start = parse_usize(start.trim())?;
 +    let end = parse_usize(end.trim())?;
 +    if end < start {
 +        return Err(format!("tolerance range end before start in `{range}`"));
 +    }
 +    Ok((start, end))
 +}
++
 +fn parse_usize(token: &str) -> Result<usize, String> {
 +    if let Some(rest) = token.strip_prefix("0x") {
 +        usize::from_str_radix(rest, 16).map_err(|e| format!("parse usize `{token}`: {e}"))
 +    } else {
 +        token
 +            .parse::<usize>()
 +            .map_err(|e| format!("parse usize `{token}`: {e}"))
 +    }
 +}
++
 +fn tolerance_covers_chunk(
 +    tolerance: &CaseTolerance,
 +    segname: &str,
 +    sectname: &str,
 +    offset: usize,
 +    len: usize,
 +) -> bool {
 +    match &tolerance.region {
 +        ToleranceRegion::SectionBytes {
 +            segname: expected_seg,
 +            sectname: expected_sect,
 +            start,
 +            end_inclusive,
 +        } => {
 +            if expected_seg != segname {
 +                return false;
 +            }
 +            if let Some(expected_sect) = expected_sect {
 +                if expected_sect != sectname {
 +                    return false;
 +                }
 +            }
 +            let end = offset.saturating_add(len.saturating_sub(1));
 +            offset >= *start && end <= *end_inclusive
 +        }
 +    }
 +}
++
 +fn read_tokens(path: &Path) -> Result<Vec<String>, String> {
 +    let contents = fs::read_to_string(path).map_err(|e| format!("read {}: {e}", path.display()))?;
 +    Ok(contents
 +        .lines()
 +        .map(str::trim)
 +        .filter(|line| !line.is_empty() && !line.starts_with('#'))
 +        .map(ToOwned::to_owned)
 +        .collect())
 +}
++
 +fn read_tokens_if_present(path: &Path) -> Result<Vec<String>, String> {
 +    if path.exists() {
 +        read_tokens(path)
 +    } else {
 +        Ok(Vec::new())
 +    }
 +}
++
 +fn read_sections(path: &Path) -> Result<Vec<(String, String)>, String> {
 +    let mut sections = Vec::new();
 +    for line in read_tokens(path)? {
 +        let mut parts = line.split_whitespace();
 +        let segname = parts
 +            .next()
 +            .ok_or_else(|| format!("missing segment name in {}", path.display()))?;
 +        let sectname = parts
 +            .next()
 +            .ok_or_else(|| format!("missing section name in {}", path.display()))?;
 +        if parts.next().is_some() {
 +            return Err(format!(
 +                "too many fields in section spec `{line}` from {}",
 +                path.display()
 +            ));
 +        }
 +        sections.push((segname.to_string(), sectname.to_string()));
 +    }
 +    Ok(sections)
 +}
++
 +fn read_sections_if_present(path: &Path) -> Result<Vec<(String, String)>, String> {
 +    if path.exists() {
 +        read_sections(path)
 +    } else {
 +        Ok(Vec::new())
 +    }
 +}
++
 +fn read_load_command_names(path: &Path) -> Result<Vec<u32>, String> {
 +    if !path.exists() {
 +        return Ok(Vec::new());
 +    }
 +    let mut commands = Vec::new();
 +    for line in read_tokens(path)? {
 +        commands.push(parse_load_command_name(&line)?);
 +    }
 +    Ok(commands)
 +}
++
 +fn read_command_checks(path: &Path) -> Result<Vec<CommandCheck>, String> {
 +    if !path.exists() {
 +        return Ok(Vec::new());
 +    }
 +    let mut checks = Vec::new();
 +    for line in read_tokens(path)? {
 +        checks.push(parse_command_check(&line)?);
 +    }
 +    Ok(checks)
 +}
++
 +fn read_page_refs(path: &Path) -> Result<Vec<PageRefCheck>, String> {
 +    if !path.exists() {
 +        return Ok(Vec::new());
 +    }
 +    let mut checks = Vec::new();
 +    for line in read_tokens(path)? {
 +        let mut parts = line.split_whitespace();
 +        let segname = parts
 +            .next()
 +            .ok_or_else(|| format!("missing segment name in {}", path.display()))?;
 +        let sectname = parts
 +            .next()
 +            .ok_or_else(|| format!("missing section name in {}", path.display()))?;
 +        let site_offset = parts
 +            .next()
 +            .ok_or_else(|| format!("missing site offset in {}", path.display()))?;
 +        let kind = parts
 +            .next()
 +            .ok_or_else(|| format!("missing page-ref kind in {}", path.display()))?;
 +        let symbol = parts
 +            .next()
 +            .ok_or_else(|| format!("missing symbol name in {}", path.display()))?;
 +        if parts.next().is_some() {
 +            return Err(format!(
 +                "too many fields in page-ref spec `{line}` from {}",
 +                path.display()
 +            ));
 +        }
 +        checks.push(PageRefCheck {
 +            segname: segname.to_string(),
 +            sectname: sectname.to_string(),
 +            site_offset: parse_u64(site_offset)?,
 +            kind: parse_page_ref_kind(kind)?,
 +            symbol: symbol.to_string(),
 +        });
 +    }
 +    Ok(checks)
 +}
++
 +fn read_artifacts(path: &Path) -> Result<Vec<ArtifactSpec>, String> {
 +    if !path.exists() {
 +        return Ok(Vec::new());
 +    }
 +    let mut specs = Vec::new();
 +    for line in read_tokens(path)? {
 +        let mut parts = line.split_whitespace();
 +        let kind = parts
 +            .next()
 +            .ok_or_else(|| format!("missing artifact kind in {}", path.display()))?;
 +        let src_name = parts
 +            .next()
 +            .ok_or_else(|| format!("missing artifact src in {}", path.display()))?;
 +        let out_name = parts
 +            .next()
 +            .ok_or_else(|| format!("missing artifact output in {}", path.display()))?;
 +        let dep_name = parts.next().map(str::to_string);
 +        if parts.next().is_some() {
 +            return Err(format!(
 +                "too many fields in artifact spec `{line}` from {}",
 +                path.display()
 +            ));
 +        }
 +        let (kind, dep_name) = match kind {
 +            "clang_dylib" => {
 +                if dep_name.is_some() {
 +                    return Err(format!(
 +                        "clang_dylib takes exactly 3 fields in {}",
 +                        path.display()
 +                    ));
 +                }
 +                (ArtifactKind::ClangDylib, None)
 +            }
 +            "clang_archive" => {
 +                if dep_name.is_some() {
 +                    return Err(format!(
 +                        "clang_archive takes exactly 3 fields in {}",
 +                        path.display()
 +                    ));
 +                }
 +                (ArtifactKind::ClangArchive, None)
 +            }
 +            "clang_reexport_dylib" => {
 +                let dep_name = dep_name.ok_or_else(|| {
 +                    format!(
 +                        "clang_reexport_dylib needs a dependency artifact in {}",
 +                        path.display()
 +                    )
 +                })?;
 +                (ArtifactKind::ClangReexportDylib, Some(dep_name))
 +            }
 +            other => return Err(format!("unknown artifact kind `{other}`")),
 +        };
 +        specs.push(ArtifactSpec {
 +            src_name: src_name.to_string(),
 +            out_name: out_name.to_string(),
 +            kind,
 +            dep_name,
 +        });
 +    }
 +    Ok(specs)
 +}
++
 +fn parse_command_check(name: &str) -> Result<CommandCheck, String> {
 +    match name {
 +        "build_version" => Ok(CommandCheck::BuildVersion),
 +        "load_dylib_names" => Ok(CommandCheck::LoadDylibNames),
 +        "export_records" => Ok(CommandCheck::ExportRecords),
 +        "symbol_record_map" => Ok(CommandCheck::SymbolRecordMap),
 +        "indirect_symbol_identities" => Ok(CommandCheck::IndirectSymbolIdentities),
 +        "symbol_partition_names" => Ok(CommandCheck::SymbolPartitionNames),
 +        "string_table_near_parity" => Ok(CommandCheck::StringTableNearParity),
 +        "function_starts" => Ok(CommandCheck::FunctionStarts),
 +        "normalized_function_starts" => Ok(CommandCheck::NormalizedFunctionStarts),
 +        "data_in_code" => Ok(CommandCheck::DataInCode),
 +        "rebased_unwind_bytes" => Ok(CommandCheck::RebasedUnwindBytes),
 +        "dyld_info_rebase" => Ok(CommandCheck::DyldInfoRebase),
 +        "dyld_info_bind" => Ok(CommandCheck::DyldInfoBind),
 +        "dyld_info_weak_bind" => Ok(CommandCheck::DyldInfoWeakBind),
 +        "dyld_info_lazy_bind" => Ok(CommandCheck::DyldInfoLazyBind),
 +        other => Err(format!("unknown command check `{other}`")),
 +    }
 +}
++
 +fn parse_page_ref_kind(kind: &str) -> Result<PageRefKind, String> {
 +    match kind {
 +        "add" => Ok(PageRefKind::Add),
 +        "load" => Ok(PageRefKind::Load),
 +        other => Err(format!("unknown page-ref kind `{other}`")),
 +    }
 +}
++
 +fn parse_load_command_name(name: &str) -> Result<u32, String> {
 +    match name {
 +        "LC_SEGMENT_64" => Ok(LC_SEGMENT_64),
 +        "LC_LOAD_DYLIB" => Ok(LC_LOAD_DYLIB),
 +        "LC_UUID" => Ok(LC_UUID),
 +        "LC_CODE_SIGNATURE" => Ok(LC_CODE_SIGNATURE),
 +        "LC_LINKER_OPTIMIZATION_HINT" => Ok(afs_ld::macho::constants::LC_LINKER_OPTIMIZATION_HINT),
 +        other => Err(format!("unknown load command name `{other}`")),
 +    }
 +}
++
 +fn load_command_name(cmd: u32) -> &'static str {
 +    match cmd {
 +        LC_SEGMENT_64 => "LC_SEGMENT_64",
 +        LC_LOAD_DYLIB => "LC_LOAD_DYLIB",
 +        LC_UUID => "LC_UUID",
 +        LC_CODE_SIGNATURE => "LC_CODE_SIGNATURE",
 +        afs_ld::macho::constants::LC_LINKER_OPTIMIZATION_HINT => "LC_LINKER_OPTIMIZATION_HINT",
 +        _ => "unknown load command",
 +    }
 +}
++
 +fn parse_u64(value: &str) -> Result<u64, String> {
 +    if let Some(hex) = value.strip_prefix("0x") {
 +        u64::from_str_radix(hex, 16).map_err(|e| format!("parse hex `{value}`: {e}"))
 +    } else {
 +        value
 +            .parse::<u64>()
 +            .map_err(|e| format!("parse integer `{value}`: {e}"))
 +    }
 +}
++
 +fn expand_args(
 +    args: &[String],
 +    compiled: &BTreeMap<String, PathBuf>,
 +    sidecars: &BTreeMap<String, PathBuf>,
 +    artifacts: &BTreeMap<String, PathBuf>,
 +    out: &Path,
 +    sdk: &str,
 +    sdk_ver: &str,
 +) -> Result<Vec<String>, String> {
 +    let mut expanded = Vec::with_capacity(args.len());
 +    for arg in args {
 +        if arg == "@OUT@" {
 +            expanded.push(out.to_string_lossy().to_string());
 +            continue;
 +        }
 +        if arg == "@SDK_PATH@" {
 +            expanded.push(sdk.to_string());
 +            continue;
 +        }
 +        if arg == "@SDK_VERSION@" {
 +            expanded.push(sdk_ver.to_string());
 +            continue;
 +        }
 +        if let Some(rel) = arg
 +            .strip_prefix("@SDK_TBD:")
 +            .and_then(|rest| rest.strip_suffix('@'))
 +        {
 +            expanded.push(Path::new(sdk).join(rel).to_string_lossy().to_string());
 +            continue;
 +        }
 +        if let Some(name) = arg
 +            .strip_prefix("@INPUT:")
 +            .and_then(|rest| rest.strip_suffix('@'))
 +        {
 +            let input = compiled
 +                .get(name)
 +                .ok_or_else(|| format!("unknown parity input placeholder `{name}`"))?;
 +            expanded.push(input.to_string_lossy().to_string());
 +            continue;
 +        }
 +        if let Some(name) = arg
 +            .strip_prefix("@FILE:")
 +            .and_then(|rest| rest.strip_suffix('@'))
 +        {
 +            let file = sidecars
 +                .get(name)
 +                .ok_or_else(|| format!("unknown parity sidecar placeholder `{name}`"))?;
 +            expanded.push(file.to_string_lossy().to_string());
 +            continue;
 +        }
 +        if let Some(name) = arg
 +            .strip_prefix("@ARTIFACT:")
 +            .and_then(|rest| rest.strip_suffix('@'))
 +        {
 +            let artifact = artifacts
 +                .get(name)
 +                .ok_or_else(|| format!("unknown parity artifact placeholder `{name}`"))?;
 +            expanded.push(artifact.to_string_lossy().to_string());
 +            continue;
 +        }
 +        expanded.push(arg.clone());
 +    }
 +    Ok(expanded)
 +}
++
 +fn tolerated_mask(bytes: &[u8]) -> Vec<Option<&'static str>> {
 +    let mut mask = vec![None; bytes.len()];
 +    let Ok(header) = parse_header(bytes) else {
 +        return mask;
 +    };
 +    let cmd_base = 32usize;
 +    let Ok(cmd_limit) = cmd_base.checked_add(header.sizeofcmds as usize).ok_or(()) else {
 +        return mask;
 +    };
 +    if cmd_limit > bytes.len() {
 +        return mask;
 +    }
++
 +    let mut cursor = cmd_base;
 +    for _ in 0..header.ncmds {
 +        if cursor + 8 > cmd_limit {
 +            break;
 +        }
 +        let cmd = u32_le(&bytes[cursor..cursor + 4]);
 +        let cmdsize = u32_le(&bytes[cursor + 4..cursor + 8]) as usize;
 +        if cmdsize < 8 || cursor + cmdsize > cmd_limit {
 +            break;
 +        }
 +        match cmd {
 +            LC_UUID => mark_range(&mut mask, cursor, cursor + cmdsize, "UUID bytes"),
 +            LC_CODE_SIGNATURE => {
 +                mark_range(
 +                    &mut mask,
 +                    cursor,
 +                    cursor + cmdsize,
 +                    "code-signature load command",
 +                );
 +                if cmdsize >= 16 {
 +                    let dataoff = u32_le(&bytes[cursor + 8..cursor + 12]) as usize;
 +                    let datasize = u32_le(&bytes[cursor + 12..cursor + 16]) as usize;
 +                    if let Some(end) = dataoff.checked_add(datasize) {
 +                        if end <= bytes.len() {
 +                            mark_range(&mut mask, dataoff, end, "code-signature hashes");
 +                        }
 +                    }
 +                }
 +            }
 +            LC_ID_DYLIB | LC_LOAD_DYLIB | LC_LOAD_WEAK_DYLIB | LC_REEXPORT_DYLIB
 +            | LC_LOAD_UPWARD_DYLIB => {
 +                if cmdsize >= 16 {
 +                    mark_range(&mut mask, cursor + 12, cursor + 16, "dylib timestamp");
 +                }
 +            }
 +            _ => {}
 +        }
 +        cursor += cmdsize;
 +    }
++
 +    mask
 +}
++
 +fn mark_range(mask: &mut [Option<&'static str>], start: usize, end: usize, reason: &'static str) {
 +    let start = start.min(mask.len());
 +    let end = end.min(mask.len());
 +    for slot in &mut mask[start..end] {
 +        *slot = Some(reason);
 +    }
 +}
++
 +fn build_version_command(bytes: &[u8]) -> Result<Option<BuildVersionCmd>, String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    Ok(commands.into_iter().find_map(|cmd| match cmd {
 +        LoadCommand::BuildVersion(cmd) => Some(cmd),
 +        _ => None,
 +    }))
 +}
++
 +fn normalized_build_version(bytes: &[u8]) -> Result<Option<NormalizedBuildVersion>, String> {
 +    Ok(build_version_command(bytes)?.map(|cmd| {
 +        (
 +            cmd.platform,
 +            cmd.minos,
 +            cmd.sdk,
 +            cmd.tools.into_iter().map(|tool| tool.tool).collect(),
 +        )
 +    }))
 +}
++
 +fn load_dylib_names(bytes: &[u8]) -> Result<Vec<String>, String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    Ok(commands
 +        .into_iter()
 +        .filter_map(|cmd| match cmd {
 +            LoadCommand::Dylib(cmd) if cmd.cmd == LC_LOAD_DYLIB => Some(cmd.name),
 +            _ => None,
 +        })
 +        .collect())
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct CanonicalSymbolRecord {
 +    name: String,
 +    n_type: u8,
 +    n_sect: u8,
 +    n_desc: u16,
 +    value: u64,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +enum CanonicalExportKind {
 +    Regular(u64),
 +    ThreadLocal(u64),
 +    Absolute(u64),
 +    Reexport { ordinal: u32, imported_name: String },
 +    StubAndResolver { stub: u64, resolver: u64 },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct CanonicalExportRecord {
 +    name: String,
 +    flags: u64,
 +    kind: CanonicalExportKind,
 +}
++
 +fn canonical_symbol_record_map(
 +    bytes: &[u8],
 +) -> Result<BTreeMap<String, CanonicalSymbolRecord>, String> {
 +    Ok(canonical_symbol_records(bytes)?
 +        .into_iter()
 +        .map(|record| (record.name.clone(), record))
 +        .collect())
 +}
++
 +fn canonical_symbol_records(bytes: &[u8]) -> Result<Vec<CanonicalSymbolRecord>, String> {
 +    let (symtab, _) = symtab_and_dysymtab(bytes)?;
 +    let symbols =
 +        parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).map_err(|e| e.to_string())?;
 +    let strings =
 +        StringTable::from_file(bytes, symtab.stroff, symtab.strsize).map_err(|e| e.to_string())?;
 +    let section_addrs = section_addrs(bytes)?;
 +    Ok(symbols
 +        .iter()
 +        .map(|symbol| {
 +            let value = if symbol.kind() == SymKind::Sect && symbol.sect_idx() != 0 {
 +                let section_addr = section_addrs[symbol.sect_idx() as usize - 1];
 +                if symbol.value() >= section_addr {
 +                    symbol.value() - section_addr
 +                } else {
 +                    symbol.value()
 +                }
 +            } else {
 +                symbol.value()
 +            };
 +            CanonicalSymbolRecord {
 +                name: strings.get(symbol.strx()).unwrap().to_string(),
 +                n_type: symbol.raw.n_type,
 +                n_sect: symbol.raw.n_sect,
 +                n_desc: symbol.raw.n_desc,
 +                value,
 +            }
 +        })
 +        .collect())
 +}
++
 +fn canonical_export_records(bytes: &[u8]) -> Result<Vec<CanonicalExportRecord>, String> {
 +    let dylib = DylibFile::parse("/tmp/canonical.dylib", bytes).map_err(|e| e.to_string())?;
 +    let symbol_values: BTreeMap<String, u64> = canonical_symbol_records(bytes)?
 +        .into_iter()
 +        .map(|record| (record.name, record.value))
 +        .collect();
 +    let mut out = dylib
 +        .exports
 +        .entries()
 +        .map_err(|e| e.to_string())?
 +        .into_iter()
 +        .map(|entry| {
 +            let kind = match entry.kind {
 +                ExportKind::Regular { .. } => {
 +                    CanonicalExportKind::Regular(*symbol_values.get(&entry.name).unwrap())
 +                }
 +                ExportKind::ThreadLocal { .. } => {
 +                    CanonicalExportKind::ThreadLocal(*symbol_values.get(&entry.name).unwrap())
 +                }
 +                ExportKind::Absolute { .. } => {
 +                    CanonicalExportKind::Absolute(*symbol_values.get(&entry.name).unwrap())
 +                }
 +                ExportKind::Reexport {
 +                    ordinal,
 +                    imported_name,
 +                } => CanonicalExportKind::Reexport {
 +                    ordinal,
 +                    imported_name,
 +                },
 +                ExportKind::StubAndResolver { stub, resolver } => {
 +                    CanonicalExportKind::StubAndResolver { stub, resolver }
 +                }
 +            };
 +            CanonicalExportRecord {
 +                name: entry.name,
 +                flags: entry.flags,
 +                kind,
 +            }
 +        })
 +        .collect::<Vec<_>>();
 +    out.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
 +    Ok(out)
 +}
++
 +fn symbol_partition_names(bytes: &[u8]) -> Result<(Vec<String>, Vec<String>, Vec<String>), String> {
 +    let (symtab, dysymtab) = symtab_and_dysymtab(bytes)?;
 +    let symbols =
 +        parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).map_err(|e| e.to_string())?;
 +    let strings =
 +        StringTable::from_file(bytes, symtab.stroff, symtab.strsize).map_err(|e| e.to_string())?;
 +    let names_for = |start: u32, count: u32| -> Vec<String> {
 +        symbols[start as usize..(start + count) as usize]
 +            .iter()
 +            .map(|symbol| strings.get(symbol.strx()).unwrap().to_string())
 +            .collect()
 +    };
 +    Ok((
 +        names_for(dysymtab.ilocalsym, dysymtab.nlocalsym),
 +        names_for(dysymtab.iextdefsym, dysymtab.nextdefsym),
 +        names_for(dysymtab.iundefsym, dysymtab.nundefsym),
 +    ))
 +}
++
 +fn raw_string_table(bytes: &[u8]) -> Result<Vec<u8>, String> {
 +    let (symtab, _) = symtab_and_dysymtab(bytes)?;
 +    let start = symtab.stroff as usize;
 +    let end = start + symtab.strsize as usize;
 +    Ok(bytes[start..end].to_vec())
 +}
++
 +pub fn string_table_within_five_percent(ours: usize, theirs: usize) -> bool {
 +    let delta = ours.abs_diff(theirs);
 +    delta * 20 <= theirs
 +}
++
 +fn indirect_symbol_table(bytes: &[u8]) -> Result<Vec<u32>, String> {
 +    let (_, dysymtab) = symtab_and_dysymtab(bytes)?;
 +    if dysymtab.nindirectsyms == 0 {
 +        return Ok(Vec::new());
 +    }
 +    let start = dysymtab.indirectsymoff as usize;
 +    let end = start + dysymtab.nindirectsyms as usize * 4;
 +    Ok(bytes[start..end]
 +        .chunks_exact(4)
 +        .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
 +        .collect())
 +}
++
 +fn indirect_symbol_identities(bytes: &[u8]) -> Result<Vec<String>, String> {
 +    let (symtab, _) = symtab_and_dysymtab(bytes)?;
 +    let symbols =
 +        parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).map_err(|e| e.to_string())?;
 +    let strings =
 +        StringTable::from_file(bytes, symtab.stroff, symtab.strsize).map_err(|e| e.to_string())?;
 +    Ok(indirect_symbol_table(bytes)?
 +        .into_iter()
 +        .map(|index| {
 +            if index & INDIRECT_SYMBOL_LOCAL != 0 {
 +                if index & INDIRECT_SYMBOL_ABS != 0 {
 +                    "<LOCAL|ABS>".to_string()
 +                } else {
 +                    "<LOCAL>".to_string()
 +                }
 +            } else if index & INDIRECT_SYMBOL_ABS != 0 {
 +                "<ABS>".to_string()
 +            } else {
 +                let symbol = &symbols[index as usize];
 +                strings.get(symbol.strx()).unwrap().to_string()
 +            }
 +        })
 +        .collect())
 +}
++
 +fn raw_linkedit_data_cmd(bytes: &[u8], expected_cmd: u32) -> Result<(u32, u32), String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    for cmd in commands {
 +        match cmd {
 +            LoadCommand::Raw { cmd, data, .. } if cmd == expected_cmd => {
 +                return Ok((u32_le(&data[0..4]), u32_le(&data[4..8])));
 +            }
 +            LoadCommand::LinkerOptimizationHint(linkedit)
 +                if expected_cmd == afs_ld::macho::constants::LC_LINKER_OPTIMIZATION_HINT =>
 +            {
 +                return Ok((linkedit.dataoff, linkedit.datasize));
 +            }
 +            _ => {}
 +        }
 +    }
 +    Err(format!("missing raw linkedit command 0x{expected_cmd:x}"))
 +}
++
 +fn linkedit_payload(bytes: &[u8], cmd: u32) -> Result<Vec<u8>, String> {
 +    let (dataoff, datasize) = raw_linkedit_data_cmd(bytes, cmd)?;
 +    if datasize == 0 {
 +        return Ok(Vec::new());
 +    }
 +    Ok(bytes[dataoff as usize..(dataoff + datasize) as usize].to_vec())
 +}
++
 +fn decode_function_starts(bytes: &[u8]) -> Result<Vec<u64>, String> {
 +    let payload = linkedit_payload(bytes, LC_FUNCTION_STARTS)?;
 +    let mut offsets = Vec::new();
 +    let mut cursor = 0usize;
 +    let mut current = 0u64;
 +    while cursor < payload.len() {
 +        let (delta, used) = read_uleb(&payload[cursor..]).map_err(|e| e.to_string())?;
 +        cursor += used;
 +        if delta == 0 {
 +            break;
 +        }
 +        current += delta;
 +        offsets.push(current);
 +    }
 +    Ok(offsets)
 +}
++
 +fn normalize_function_start_offsets(starts: &[u64]) -> Vec<u64> {
 +    let Some(&base) = starts.first() else {
 +        return Vec::new();
 +    };
 +    starts.iter().map(|offset| offset - base).collect()
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct DataInCodeRecord {
 +    offset: u32,
 +    length: u16,
 +    kind: u16,
 +}
++
 +fn decode_data_in_code(bytes: &[u8]) -> Result<Vec<DataInCodeRecord>, String> {
 +    let payload = linkedit_payload(bytes, LC_DATA_IN_CODE)?;
 +    Ok(payload
 +        .chunks_exact(8)
 +        .map(|chunk| DataInCodeRecord {
 +            offset: u32::from_le_bytes(chunk[0..4].try_into().unwrap()),
 +            length: u16::from_le_bytes(chunk[4..6].try_into().unwrap()),
 +            kind: u16::from_le_bytes(chunk[6..8].try_into().unwrap()),
 +        })
 +        .collect())
 +}
++
 +fn canonical_data_in_code(bytes: &[u8]) -> Result<Vec<DataInCodeRecord>, String> {
 +    let text = output_section_header(bytes, "__TEXT", "__text")
 +        .ok_or_else(|| "missing __TEXT,__text section".to_string())?;
 +    Ok(decode_data_in_code(bytes)?
 +        .into_iter()
 +        .map(|record| DataInCodeRecord {
 +            offset: record.offset - text.offset,
 +            length: record.length,
 +            kind: record.kind,
 +        })
 +        .collect())
 +}
++
 +fn rebased_unwind_bytes(bytes: &[u8]) -> Result<Vec<u8>, String> {
 +    let header_base = segment_vmaddr(bytes, "__TEXT").unwrap_or(0);
 +    let text_base = output_section(bytes, "__TEXT", "__text")
 +        .ok_or_else(|| "missing __TEXT,__text section".to_string())?
 +        .0
 +        - header_base;
 +    let got_range = output_section(bytes, "__DATA_CONST", "__got")
 +        .map(|(addr, data)| (addr - header_base, addr - header_base + data.len() as u64));
 +    let lsda_base =
 +        output_section(bytes, "__TEXT", "__gcc_except_tab").map(|(addr, _)| addr - header_base);
 +    let (_, unwind) = output_section(bytes, "__TEXT", "__unwind_info")
 +        .ok_or_else(|| "missing __TEXT,__unwind_info section".to_string())?;
 +    let mut out = unwind;
 +    if out.len() < 28 {
 +        return Ok(out);
 +    }
++
 +    let personalities_offset = u32_le(&out[12..16]) as usize;
 +    let personalities_count = u32_le(&out[16..20]) as usize;
 +    let indices_offset = u32_le(&out[20..24]) as usize;
 +    let indices_count = u32_le(&out[24..28]) as usize;
++
 +    for idx in 0..personalities_count {
 +        let off = personalities_offset + idx * 4;
 +        let value = u32_le(&out[off..off + 4]) as u64;
 +        let rebased = if let Some((got_start, got_end)) = got_range {
 +            if got_start <= value && value < got_end {
 +                value - got_start
 +            } else if value >= text_base {
 +                value - text_base
 +            } else {
 +                value
 +            }
 +        } else if value >= text_base {
 +            value - text_base
 +        } else {
 +            value
 +        };
 +        out[off..off + 4].copy_from_slice(&(rebased as u32).to_le_bytes());
 +    }
++
 +    let mut lsda_offsets = Vec::with_capacity(indices_count);
 +    for idx in 0..indices_count {
 +        let entry_off = indices_offset + idx * 12;
 +        let function_offset = u32_le(&out[entry_off..entry_off + 4]) as u64;
 +        let rebased = function_offset.saturating_sub(text_base);
 +        out[entry_off..entry_off + 4].copy_from_slice(&(rebased as u32).to_le_bytes());
 +        lsda_offsets.push(u32_le(&out[entry_off + 8..entry_off + 12]) as usize);
 +    }
++
 +    if let (Some(lsda_base), Some(&start), Some(&end)) =
 +        (lsda_base, lsda_offsets.first(), lsda_offsets.last())
 +    {
 +        let mut entry_off = start;
 +        while entry_off < end {
 +            let function_offset = u32_le(&out[entry_off..entry_off + 4]) as u64;
 +            let lsda_offset = u32_le(&out[entry_off + 4..entry_off + 8]) as u64;
 +            out[entry_off..entry_off + 4]
 +                .copy_from_slice(&(function_offset.saturating_sub(text_base) as u32).to_le_bytes());
 +            out[entry_off + 4..entry_off + 8]
 +                .copy_from_slice(&(lsda_offset.saturating_sub(lsda_base) as u32).to_le_bytes());
 +            entry_off += 8;
 +        }
 +    }
++
 +    let _ = decode_unwind_info(&out).map_err(|e| format!("decode unwind info: {e}"))?;
 +    Ok(out)
 +}
++
 +fn symtab_and_dysymtab(
 +    bytes: &[u8],
 +) -> Result<
 +    (
 +        afs_ld::macho::reader::SymtabCmd,
 +        afs_ld::macho::reader::DysymtabCmd,
 +    ),
 +    String,
 +> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    let mut symtab = None;
 +    let mut dysymtab = None;
 +    for cmd in commands {
 +        match cmd {
 +            LoadCommand::Symtab(cmd) => symtab = Some(cmd),
 +            LoadCommand::Dysymtab(cmd) => dysymtab = Some(cmd),
 +            _ => {}
 +        }
 +    }
 +    Ok((
 +        symtab.ok_or_else(|| "missing LC_SYMTAB".to_string())?,
 +        dysymtab.ok_or_else(|| "missing LC_DYSYMTAB".to_string())?,
 +    ))
 +}
++
 +fn section_addrs(bytes: &[u8]) -> Result<Vec<u64>, String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    let mut out = Vec::new();
 +    for cmd in commands {
 +        if let LoadCommand::Segment64(seg) = cmd {
 +            for section in seg.sections {
 +                out.push(section.addr);
 +            }
 +        }
 +    }
 +    Ok(out)
 +}
++
 +#[derive(Clone, Copy)]
 +enum DyldInfoStreamKind {
 +    Rebase,
 +    Bind,
 +    WeakBind,
 +    LazyBind,
 +}
++
 +fn dyld_info_command(bytes: &[u8]) -> Result<DyldInfoCmd, String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    commands
 +        .into_iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::DyldInfoOnly(cmd) => Some(cmd),
 +            _ => None,
 +        })
 +        .ok_or_else(|| "missing LC_DYLD_INFO_ONLY".to_string())
 +}
++
 +fn dyld_info_stream(bytes: &[u8], kind: DyldInfoStreamKind) -> Result<Vec<u8>, String> {
 +    let dyld_info = dyld_info_command(bytes)?;
 +    let (off, size) = match kind {
 +        DyldInfoStreamKind::Rebase => (dyld_info.rebase_off, dyld_info.rebase_size),
 +        DyldInfoStreamKind::Bind => (dyld_info.bind_off, dyld_info.bind_size),
 +        DyldInfoStreamKind::WeakBind => (dyld_info.weak_bind_off, dyld_info.weak_bind_size),
 +        DyldInfoStreamKind::LazyBind => (dyld_info.lazy_bind_off, dyld_info.lazy_bind_size),
 +    };
 +    if size == 0 {
 +        return Ok(Vec::new());
 +    }
 +    let start = off as usize;
 +    let end = start + size as usize;
 +    bytes
 +        .get(start..end)
 +        .map(|slice| slice.to_vec())
 +        .ok_or_else(|| "dyld-info stream out of bounds".to_string())
 +}
++
 +fn symbol_values(bytes: &[u8]) -> Result<BTreeMap<String, u64>, String> {
 +    let header = parse_header(bytes).map_err(|e| e.to_string())?;
 +    let commands = parse_commands(&header, bytes).map_err(|e| e.to_string())?;
 +    let symtab = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Symtab(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .ok_or_else(|| "missing LC_SYMTAB".to_string())?;
 +    let symbols =
 +        parse_nlist_table(bytes, symtab.symoff, symtab.nsyms).map_err(|e| e.to_string())?;
 +    let strings =
 +        StringTable::from_file(bytes, symtab.stroff, symtab.strsize).map_err(|e| e.to_string())?;
 +    let mut out = BTreeMap::new();
 +    for symbol in symbols {
 +        let Ok(name) = strings.get(symbol.strx()) else {
 +            continue;
 +        };
 +        out.insert(name.to_string(), symbol.value());
 +    }
 +    Ok(out)
 +}
++
 +fn decode_page_reference(
 +    bytes: &[u8],
 +    section_addr: u64,
 +    site_offset: u64,
 +    kind: PageRefKind,
 +) -> Result<u64, String> {
 +    let start = site_offset as usize;
 +    let adrp = read_insn(bytes, start)?;
 +    let second = read_insn(bytes, start + 4)?;
 +    let place = section_addr + site_offset;
 +    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 +    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 +    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 +    let adrp_base = ((place as i64) & !0xfff) + (adrp_pages << 12);
 +    let low = match kind {
 +        PageRefKind::Add => ((second >> 10) & 0xfff) as u64,
 +        PageRefKind::Load => {
 +            let shift = ((second >> 30) & 0b11) as u64;
 +            (((second >> 10) & 0xfff) as u64) << shift
 +        }
 +    };
 +    Ok((adrp_base as u64) + low)
 +}
++
 +fn read_insn(bytes: &[u8], start: usize) -> Result<u32, String> {
 +    let end = start + 4;
 +    let slice = bytes
 +        .get(start..end)
 +        .ok_or_else(|| format!("instruction read OOB at 0x{start:x}"))?;
 +    Ok(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
 +}
++
 +fn sign_extend_21(value: i64) -> i64 {
 +    if value & (1 << 20) != 0 {
 +        value | !0x1f_ffff
 +    } else {
 +        value
 +    }
+ }

tests/diff_harness_tolerates_known_linkedit.rsadded

96 lines changed — click to load

 +//! Tolerated-diff proof points for the parity harness.
++
 +mod common;
++
 +use common::harness::diff_macho;
++
 +const MH_MAGIC_64: u32 = 0xFEEDFACF;
 +const CPU_TYPE_ARM64: u32 = 0x0100_000C;
 +const MH_EXECUTE: u32 = 2;
 +const LC_ID_DYLIB: u32 = 0x0D;
 +const LC_UUID: u32 = 0x1B;
 +const LC_CODE_SIGNATURE: u32 = 0x1D;
++
 +#[test]
 +fn differing_uuid_bytes_are_tolerated() {
 +    let ours = synth_uuid_image([0x11; 16]);
 +    let theirs = synth_uuid_image([0x22; 16]);
 +    let report = diff_macho(&ours, &theirs);
 +    assert!(
 +        report.is_clean(),
 +        "UUID-only diff should be tolerated: {report:#?}"
 +    );
 +    assert_eq!(report.tolerated.len(), 1);
 +}
++
 +#[test]
 +fn differing_code_signature_blob_bytes_are_tolerated() {
 +    let ours = synth_code_signature_image([0xAA; 8]);
 +    let theirs = synth_code_signature_image([0xBB; 8]);
 +    let report = diff_macho(&ours, &theirs);
 +    assert!(
 +        report.is_clean(),
 +        "code-signature-only diff should be tolerated: {report:#?}"
 +    );
 +    assert_eq!(report.tolerated.len(), 1);
 +}
++
 +#[test]
 +fn differing_dylib_timestamps_are_tolerated() {
 +    let ours = synth_dylib_image(2);
 +    let theirs = synth_dylib_image(7);
 +    let report = diff_macho(&ours, &theirs);
 +    assert!(
 +        report.is_clean(),
 +        "dylib timestamp-only diff should be tolerated: {report:#?}"
 +    );
 +    assert_eq!(report.tolerated.len(), 1);
 +}
++
 +fn synth_uuid_image(uuid: [u8; 16]) -> Vec<u8> {
 +    let mut out = Vec::new();
 +    push_header(&mut out, 1, 24);
 +    out.extend_from_slice(&LC_UUID.to_le_bytes());
 +    out.extend_from_slice(&24u32.to_le_bytes());
 +    out.extend_from_slice(&uuid);
 +    out
 +}
++
 +fn synth_code_signature_image(blob: [u8; 8]) -> Vec<u8> {
 +    let mut out = Vec::new();
 +    let dataoff = 0x40u32;
 +    let datasize = blob.len() as u32;
 +    push_header(&mut out, 1, 16);
 +    out.extend_from_slice(&LC_CODE_SIGNATURE.to_le_bytes());
 +    out.extend_from_slice(&16u32.to_le_bytes());
 +    out.extend_from_slice(&dataoff.to_le_bytes());
 +    out.extend_from_slice(&datasize.to_le_bytes());
 +    out.resize(dataoff as usize, 0);
 +    out.extend_from_slice(&blob);
 +    out
 +}
++
 +fn synth_dylib_image(timestamp: u32) -> Vec<u8> {
 +    let mut out = Vec::new();
 +    let cmdsize = 32u32;
 +    push_header(&mut out, 1, cmdsize);
 +    out.extend_from_slice(&LC_ID_DYLIB.to_le_bytes());
 +    out.extend_from_slice(&cmdsize.to_le_bytes());
 +    out.extend_from_slice(&24u32.to_le_bytes());
 +    out.extend_from_slice(&timestamp.to_le_bytes());
 +    out.extend_from_slice(&0u32.to_le_bytes());
 +    out.extend_from_slice(&0u32.to_le_bytes());
 +    out.extend_from_slice(b"x\0\0\0\0\0\0\0");
 +    out
 +}
++
 +fn push_header(out: &mut Vec<u8>, ncmds: u32, sizeofcmds: u32) {
 +    out.extend_from_slice(&MH_MAGIC_64.to_le_bytes());
 +    out.extend_from_slice(&CPU_TYPE_ARM64.to_le_bytes());
 +    out.extend_from_slice(&0u32.to_le_bytes());
 +    out.extend_from_slice(&MH_EXECUTE.to_le_bytes());
 +    out.extend_from_slice(&ncmds.to_le_bytes());
 +    out.extend_from_slice(&sizeofcmds.to_le_bytes());
 +    out.extend_from_slice(&0u32.to_le_bytes());
 +    out.extend_from_slice(&0u32.to_le_bytes());
 +}

tests/linker_run.rsmodified

8520 lines changed — click to load

      BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, BIND_OPCODE_SET_TYPE_IMM,
      BIND_SYMBOL_FLAGS_WEAK_IMPORT, DICE_KIND_JUMP_TABLE32, INDIRECT_SYMBOL_ABS,
      INDIRECT_SYMBOL_LOCAL, LC_BUILD_VERSION, LC_DATA_IN_CODE, LC_DYLD_INFO_ONLY, LC_DYSYMTAB,
 -    LC_FUNCTION_STARTS, LC_SEGMENT_64, LC_SYMTAB,
 +    LC_FUNCTION_STARTS, LC_LINKER_OPTIMIZATION_HINT, LC_SEGMENT_64, LC_SYMTAB, N_PEXT,
      REBASE_IMMEDIATE_MASK, REBASE_OPCODE_ADD_ADDR_IMM_SCALED, REBASE_OPCODE_ADD_ADDR_ULEB,
      REBASE_OPCODE_DONE, REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB, REBASE_OPCODE_DO_REBASE_IMM_TIMES,
      REBASE_OPCODE_DO_REBASE_ULEB_TIMES, REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB,
  use afs_ld::string_table::StringTable;
  use afs_ld::symbol::{parse_nlist_table, SymKind};
  use afs_ld::synth::unwind::decode_unwind_info;
 -use afs_ld::{LinkError, LinkOptions, Linker, OutputKind};
 +use afs_ld::{FrameworkSpec, LinkError, LinkOptions, Linker, OutputKind};
  use common::harness::diff_macho;
  fn have_xcrun() -> bool {
      None
+ }
 +fn output_sections(bytes: &[u8], segname: &str, sectname: &str) -> Vec<(u64, Vec<u8>)> {
 +    let Ok(header) = parse_header(bytes) else {
 +        return Vec::new();
 +    };
 +    let Ok(commands) = parse_commands(&header, bytes) else {
 +        return Vec::new();
 +    };
 +    let mut matches = Vec::new();
 +    for cmd in commands {
 +        if let LoadCommand::Segment64(seg) = cmd {
 +            for section in seg.sections {
 +                if section.segname_str() == segname && section.sectname_str() == sectname {
 +                    let data = if section.offset == 0 {
 +                        Vec::new()
 +                    } else {
 +                        let start = section.offset as usize;
 +                        let end = start + section.size as usize;
 +                        let Some(bytes) = bytes.get(start..end) else {
 +                            continue;
 +                        };
 +                        bytes.to_vec()
 +                    };
 +                    matches.push((section.addr, data));
 +                }
 +            }
 +        }
 +    }
 +    matches
 +}
++
  fn output_section_header(bytes: &[u8], segname: &str, sectname: &str) -> Option<Section64Header> {
      let header = parse_header(bytes).ok()?;
      let commands = parse_commands(&header, bytes).ok()?;
          .collect()
+ }
 +fn canonical_symbol_record_map(bytes: &[u8]) -> HashMap<String, CanonicalSymbolRecord> {
 +    canonical_symbol_records(bytes)
 +        .into_iter()
 +        .map(|record| (record.name.clone(), record))
 +        .collect()
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  enum CanonicalExportKind {
      Regular(u64),
      let header = parse_header(bytes).unwrap();
      let commands = parse_commands(&header, bytes).unwrap();
      for cmd in commands {
 -        if let LoadCommand::Raw { cmd, data, .. } = cmd {
 -            if cmd == expected_cmd {
 +        match cmd {
 +            LoadCommand::Raw { cmd, data, .. } if cmd == expected_cmd => {
                  return (u32_le(&data[0..4]), u32_le(&data[4..8]));
+             }
 +            LoadCommand::LinkerOptimizationHint(linkedit)
 +                if expected_cmd == LC_LINKER_OPTIMIZATION_HINT =>
 +            {
 +                return (linkedit.dataoff, linkedit.datasize);
 +            }
 +            _ => {}
+         }
+     }
      panic!("missing raw linkedit command 0x{expected_cmd:x}");
          .collect()
+ }
 +fn has_loh_command(bytes: &[u8]) -> bool {
 +    let header = parse_header(bytes).unwrap();
 +    parse_commands(&header, bytes)
 +        .unwrap()
 +        .into_iter()
 +        .any(|cmd| match cmd {
 +            LoadCommand::LinkerOptimizationHint(_) => true,
 +            LoadCommand::Raw { cmd, .. } => cmd == LC_LINKER_OPTIMIZATION_HINT,
 +            _ => false,
 +        })
 +}
++
  fn assert_strtab_within_five_percent(ours: &[u8], apple: &[u8]) {
      let delta = ours.len().abs_diff(apple.len());
      assert!(
      Ok(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
+ }
 +fn is_adrp(insn: u32) -> bool {
 +    (insn & 0x9f00_0000) == 0x9000_0000
 +}
++
 +fn is_add_imm_64(insn: u32) -> bool {
 +    (insn & 0xffc0_0000) == 0x9100_0000
 +}
++
 +fn is_ldr_literal(insn: u32) -> bool {
 +    matches!(
 +        insn & 0xff00_0000,
 +        0x1800_0000 | 0x5800_0000 | 0x1c00_0000 | 0x5c00_0000 | 0x9c00_0000
 +    )
 +}
++
  fn sign_extend_26(value: i64) -> i64 {
      if value & (1 << 25) != 0 {
          value | !0x03ff_ffff
      let _ = fs::remove_file(apple_out);
+ }
 +#[test]
 +fn linker_run_loh_executable_surfaces_match_apple_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let cases = [
 +        (
 +            "loh-apple-adrp-add-exec",
 +            r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                .globl _target
 +                _main:
 +                Lloh0:
 +                    adrp x0, _target@PAGE
 +                Lloh1:
 +                    add x0, x0, _target@PAGEOFF
 +                    mov w0, #0
 +                    ret
 +                _target:
 +                    ret
 +                .loh AdrpAdd Lloh0, Lloh1
 +                .subsections_via_symbols
 +            "#,
 +        ),
 +        (
 +            "loh-apple-adrp-ldr-exec",
 +            r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                .globl _target
 +                _main:
 +                Lloh0:
 +                    adrp x0, _target@PAGE
 +                Lloh1:
 +                    ldr x1, [x0, _target@PAGEOFF]
 +                    mov w0, #0
 +                    ret
 +                    .p2align 3
 +                _target:
 +                    .quad 0x1122334455667788
 +                .loh AdrpLdr Lloh0, Lloh1
 +                .subsections_via_symbols
 +            "#,
 +        ),
 +        (
 +            "loh-apple-adrp-ldr-got-ldr-exec",
 +            r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                .globl _value
 +                _main:
 +                Lloh0:
 +                    adrp x8, _value@GOTPAGE
 +                Lloh1:
 +                    ldr x8, [x8, _value@GOTPAGEOFF]
 +                Lloh2:
 +                    ldr w0, [x8]
 +                    ret
++
 +                .section __DATA,__data
 +                .p2align 2
 +                _value:
 +                    .long 7
 +                .loh AdrpLdrGotLdr Lloh0, Lloh1, Lloh2
 +                .subsections_via_symbols
 +            "#,
 +        ),
 +    ];
++
 +    for (name, src) in cases {
 +        let obj = scratch(&format!("{name}.o"));
 +        let our_out = scratch(&format!("{name}-ours.out"));
 +        let apple_out = scratch(&format!("{name}-apple.out"));
 +        if let Err(e) = assemble(src, &obj) {
 +            eprintln!("skipping: assemble failed: {e}");
 +            let _ = fs::remove_file(obj);
 +            let _ = fs::remove_file(our_out);
 +            let _ = fs::remove_file(apple_out);
 +            return;
 +        }
++
 +        let opts = LinkOptions {
 +            inputs: vec![obj.clone()],
 +            output: Some(our_out.clone()),
 +            kind: OutputKind::Executable,
 +            ..LinkOptions::default()
 +        };
 +        Linker::run(&opts).unwrap();
 +        apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +        let our_bytes = fs::read(&our_out).unwrap();
 +        let apple_bytes = fs::read(&apple_out).unwrap();
 +        let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 +        let (apple_text_addr, apple_text) =
 +            output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 +        assert_eq!(
 +            our_text.len(),
 +            apple_text.len(),
 +            "{name} text length drifted from Apple ld"
 +        );
 +        assert!(
 +            !has_loh_command(&our_bytes),
 +            "{name} should omit LC_LINKER_OPTIMIZATION_HINT"
 +        );
 +        assert!(
 +            !has_loh_command(&apple_bytes),
 +            "{name} Apple peer unexpectedly emitted LC_LINKER_OPTIMIZATION_HINT"
 +        );
 +        match name {
 +            "loh-apple-adrp-add-exec" => {
 +                let our_target = symbol_values(&our_bytes)["_target"];
 +                let apple_target = symbol_values(&apple_bytes)["_target"];
 +                let our_first = read_insn(&our_text, 0).unwrap();
 +                let our_second = read_insn(&our_text, 4).unwrap();
 +                let apple_first = read_insn(&apple_text, 0).unwrap();
 +                let apple_second = read_insn(&apple_text, 4).unwrap();
 +                assert!(is_adrp(our_first), "{name} should keep ADRP");
 +                assert!(is_add_imm_64(our_second), "{name} should keep ADD");
 +                assert!(is_adrp(apple_first), "{name} Apple peer should keep ADRP");
 +                assert!(
 +                    is_add_imm_64(apple_second),
 +                    "{name} Apple peer should keep ADD"
 +                );
 +                assert_eq!(
 +                    decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 +                    our_target
 +                );
 +                assert_eq!(
 +                    decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add)
 +                        .unwrap(),
 +                    apple_target
 +                );
 +            }
 +            "loh-apple-adrp-ldr-exec" => {
 +                let our_target = symbol_values(&our_bytes)["_target"];
 +                let apple_target = symbol_values(&apple_bytes)["_target"];
 +                let our_first = read_insn(&our_text, 0).unwrap();
 +                let our_second = read_insn(&our_text, 4).unwrap();
 +                let apple_first = read_insn(&apple_text, 0).unwrap();
 +                let apple_second = read_insn(&apple_text, 4).unwrap();
 +                assert!(is_adrp(our_first), "{name} should keep ADRP");
 +                assert!(
 +                    !is_ldr_literal(our_second),
 +                    "{name} should keep pageoff LDR"
 +                );
 +                assert!(is_adrp(apple_first), "{name} Apple peer should keep ADRP");
 +                assert!(
 +                    !is_ldr_literal(apple_second),
 +                    "{name} Apple peer should keep pageoff LDR"
 +                );
 +                assert_eq!(
 +                    decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Load).unwrap(),
 +                    our_target
 +                );
 +                assert_eq!(
 +                    decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Load)
 +                        .unwrap(),
 +                    apple_target
 +                );
 +            }
 +            "loh-apple-adrp-ldr-got-ldr-exec" => {
 +                let our_target = symbol_values(&our_bytes)["_value"];
 +                let apple_target = symbol_values(&apple_bytes)["_value"];
 +                let our_first = read_insn(&our_text, 0).unwrap();
 +                let our_second = read_insn(&our_text, 4).unwrap();
 +                let our_third = read_insn(&our_text, 8).unwrap();
 +                let apple_first = read_insn(&apple_text, 0).unwrap();
 +                let apple_second = read_insn(&apple_text, 4).unwrap();
 +                let apple_third = read_insn(&apple_text, 8).unwrap();
 +                assert!(is_adrp(our_first), "{name} should keep ADRP");
 +                assert!(
 +                    is_add_imm_64(our_second),
 +                    "{name} should keep GOT-resolved ADD"
 +                );
 +                assert!(is_adrp(apple_first), "{name} Apple peer should keep ADRP");
 +                assert!(
 +                    is_add_imm_64(apple_second),
 +                    "{name} Apple peer should keep GOT-resolved ADD"
 +                );
 +                assert_eq!(our_third, apple_third, "{name} final load drifted");
 +                assert_eq!(
 +                    decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 +                    our_target
 +                );
 +                assert_eq!(
 +                    decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add)
 +                        .unwrap(),
 +                    apple_target
 +                );
 +            }
 +            _ => unreachable!("unexpected LOH parity case"),
 +        }
++
 +        let _ = fs::remove_file(obj);
 +        let _ = fs::remove_file(our_out);
 +        let _ = fs::remove_file(apple_out);
 +    }
 +}
++
 +#[test]
 +fn linker_run_loh_dylib_surfaces_match_apple_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let obj = scratch("loh-apple-dylib.o");
 +    let our_out = scratch("loh-apple-ours.dylib");
 +    let apple_out = scratch("loh-apple-apple.dylib");
 +    let install_name = "@rpath/liblohprobe.dylib";
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _loh_probe
 +        .globl _target
 +        _loh_probe:
 +        Lloh0:
 +            adrp x0, _target@PAGE
 +        Lloh1:
 +            add x0, x0, _target@PAGEOFF
 +            ret
 +        _target:
 +            ret
 +        .loh AdrpAdd Lloh0, Lloh1
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Dylib,
 +        install_name: Some(install_name.into()),
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_dylib_classic(&obj, &apple_out, install_name, &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 +    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 +    let our_target = symbol_values(&our_bytes)["_target"];
 +    let apple_target = symbol_values(&apple_bytes)["_target"];
 +    let our_first = read_insn(&our_text, 0).unwrap();
 +    let our_second = read_insn(&our_text, 4).unwrap();
 +    let apple_first = read_insn(&apple_text, 0).unwrap();
 +    let apple_second = read_insn(&apple_text, 4).unwrap();
 +    assert!(is_adrp(our_first), "dylib LOH should keep ADRP");
 +    assert!(is_add_imm_64(our_second), "dylib LOH should keep ADD");
 +    assert!(is_adrp(apple_first), "Apple dylib LOH should keep ADRP");
 +    assert!(
 +        is_add_imm_64(apple_second),
 +        "Apple dylib LOH should keep ADD"
 +    );
 +    assert_eq!(
 +        decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 +        our_target
 +    );
 +    assert_eq!(
 +        decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add).unwrap(),
 +        apple_target
 +    );
 +    assert!(
 +        !has_loh_command(&our_bytes),
 +        "dylib output should omit LC_LINKER_OPTIMIZATION_HINT"
 +    );
 +    assert!(
 +        !has_loh_command(&apple_bytes),
 +        "Apple dylib peer unexpectedly emitted LC_LINKER_OPTIMIZATION_HINT"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
  #[test]
  fn linker_run_emits_minimal_dylib_from_real_object() {
      if !have_xcrun() {
+ }
  #[test]
 -fn dylib_export_surfaces_match_apple_ld() {
 -    if !have_xcrun() || !have_xcrun_tool("ld") {
 -        eprintln!("skipping: xcrun as/ld unavailable");
 +fn linker_run_uses_dylib_identity_flags() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
++
 +    let obj = scratch("libmeta.o");
 +    let out = scratch("libmeta.dylib");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _exported
 +        _exported:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
 -    };
 +    }
 -    let case = ExportParityCase {
 -        name: "export-parity",
 -        src: r#"
 -            .section __TEXT,__text,regular,pure_instructions
 -            .globl _exported
 -            _exported:
 -                ret
 -            .subsections_via_symbols
 -        "#,
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Dylib,
 +        install_name: Some("@rpath/libmeta_custom.dylib".into()),
 +        current_version: Some((2 << 16) | (3 << 8) | 4),
 +        compatibility_version: Some((1 << 16) | (5 << 8)),
 +        rpaths: vec!["@loader_path/../lib".into()],
 +        ..LinkOptions::default()
      };
 -    assert_dylib_export_case_matches_apple_ld(&case, &sdk, &sdk_ver).unwrap();
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let id_dylib = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Dylib(cmd) if cmd.cmd == afs_ld::macho::constants::LC_ID_DYLIB => {
 +                Some(cmd.clone())
 +            }
 +            _ => None,
 +        })
 +        .expect("missing LC_ID_DYLIB");
 +    assert_eq!(id_dylib.name, "@rpath/libmeta_custom.dylib");
 +    assert_eq!(id_dylib.current_version, (2 << 16) | (3 << 8) | 4);
 +    assert_eq!(id_dylib.compatibility_version, (1 << 16) | (5 << 8));
 +    assert!(commands
 +        .iter()
 +        .any(|cmd| matches!(cmd, LoadCommand::Rpath(r) if r.path == "@loader_path/../lib")));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
+ }
  #[test]
 -fn dylib_export_surfaces_match_apple_ld_with_shared_prefixes() {
 -    if !have_xcrun() || !have_xcrun_tool("ld") {
 -        eprintln!("skipping: xcrun as/ld unavailable");
 +fn linker_run_honors_exported_symbol_filters_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
++
 +    let obj = scratch("export-filter.o");
 +    let our_out = scratch("export-filter-ours.dylib");
 +    let apple_out = scratch("export-filter-apple.dylib");
 +    let list_path = scratch("export-filter-exports.txt");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _alpha
 +        .globl _beta
 +        .globl _gamma
 +        _alpha:
 +            ret
 +        _beta:
 +            ret
 +        _gamma:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
 +    }
 +    fs::write(&list_path, "_bet?\n").unwrap();
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Dylib,
 +        exported_symbols: vec!["_alpha".into()],
 +        exported_symbols_lists: vec![list_path.clone()],
 +        ..LinkOptions::default()
      };
 +    Linker::run(&opts).unwrap();
 -    let case = ExportParityCase {
 -        name: "export-prefix-parity",
 -        src: r#"
 -            .section __TEXT,__text,regular,pure_instructions
 -            .globl _alpha
 -            _alpha:
 -                ret
 -            .globl _alphabet
 -            _alphabet:
 -                ret
 +    let apple = Command::new("xcrun")
 +        .args(["clang", "-arch", "arm64", "-dynamiclib"])
 +        .arg(&obj)
 +        .arg("-o")
 +        .arg(&apple_out)
 +        .arg("-Wl,-exported_symbol,_alpha")
 +        .arg(format!(
 +            "-Wl,-exported_symbols_list,{}",
 +            list_path.display()
 +        ))
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        canonical_export_records(&our_bytes),
 +        canonical_export_records(&apple_bytes)
 +    );
 +    assert_eq!(
 +        dyld_info_export_names(&our_bytes).unwrap(),
 +        vec!["_alpha".to_string(), "_beta".to_string()]
 +    );
 +    assert_eq!(
 +        canonical_symbol_record_map(&our_bytes),
 +        canonical_symbol_record_map(&apple_bytes)
 +    );
++
 +    let our_symbols = canonical_symbol_record_map(&our_bytes);
 +    let gamma = our_symbols.get("_gamma").expect("missing _gamma");
 +    assert_ne!(
 +        gamma.n_type & N_PEXT,
 +        0,
 +        "expected _gamma to be private extern"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(list_path);
 +}
++
 +#[test]
 +fn linker_run_honors_unexported_symbol_filters_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("unexport-filter.o");
 +    let our_out = scratch("unexport-filter-ours.dylib");
 +    let apple_out = scratch("unexport-filter-apple.dylib");
 +    let list_path = scratch("unexport-filter-hidden.txt");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _alpha
 +        .globl _beta
 +        .globl _gamma
 +        _alpha:
 +            ret
 +        _beta:
 +            ret
 +        _gamma:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
 +    fs::write(&list_path, "_bet?\n").unwrap();
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Dylib,
 +        unexported_symbols: vec!["_gamma".into()],
 +        unexported_symbols_lists: vec![list_path.clone()],
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args(["clang", "-arch", "arm64", "-dynamiclib"])
 +        .arg(&obj)
 +        .arg("-o")
 +        .arg(&apple_out)
 +        .arg("-Wl,-unexported_symbol,_gamma")
 +        .arg(format!(
 +            "-Wl,-unexported_symbols_list,{}",
 +            list_path.display()
 +        ))
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        canonical_export_records(&our_bytes),
 +        canonical_export_records(&apple_bytes)
 +    );
 +    assert_eq!(
 +        dyld_info_export_names(&our_bytes).unwrap(),
 +        vec!["_alpha".to_string()]
 +    );
 +    assert_eq!(
 +        canonical_symbol_record_map(&our_bytes),
 +        canonical_symbol_record_map(&apple_bytes)
 +    );
++
 +    let our_symbols = canonical_symbol_record_map(&our_bytes);
 +    for name in ["_beta", "_gamma"] {
 +        let record = our_symbols
 +            .get(name)
 +            .unwrap_or_else(|| panic!("missing {name}"));
 +        assert_ne!(
 +            record.n_type & N_PEXT,
 +            0,
 +            "expected {name} to be private extern"
 +        );
 +    }
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(list_path);
 +}
++
 +#[test]
 +fn linker_run_loads_minimal_dylib_via_dlopen() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun clang/as or codesign unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("libfoo_add.o");
 +    let out = scratch("libfoo_add.dylib");
 +    let caller_src = scratch("libfoo_add-caller.c");
 +    let caller = scratch("libfoo_add-caller.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _foo_add
 +        _foo_add:
 +            add w0, w0, w1
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Dylib,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
++
 +    fs::write(
 +        &caller_src,
 +        r#"
 +            #include <dlfcn.h>
 +            typedef int (*foo_add_fn)(int, int);
 +            int main(int argc, char **argv) {
 +                if (argc != 2) return 10;
 +                void *handle = dlopen(argv[1], RTLD_NOW);
 +                if (!handle) return 11;
 +                foo_add_fn fn = (foo_add_fn)dlsym(handle, "foo_add");
 +                if (!fn) return 12;
 +                int value = fn(2, 3);
 +                dlclose(handle);
 +                return value == 5 ? 0 : 1;
 +            }
 +        "#,
 +    )
 +    .unwrap();
++
 +    let output = Command::new("xcrun")
 +        .args(["--sdk", "macosx", "clang", "-arch", "arm64"])
 +        .arg(&caller_src)
 +        .arg("-o")
 +        .arg(&caller)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        output.status.success(),
 +        "xcrun clang caller failed: {}",
 +        String::from_utf8_lossy(&output.stderr)
 +    );
++
 +    let status = Command::new(&caller).arg(&out).status().unwrap();
 +    assert_eq!(status.code(), Some(0), "expected dlopen caller to exit 0");
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(caller_src);
 +    let _ = fs::remove_file(caller);
 +}
++
 +#[test]
 +fn dylib_export_surfaces_match_apple_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let case = ExportParityCase {
 +        name: "export-parity",
 +        src: r#"
 +            .section __TEXT,__text,regular,pure_instructions
 +            .globl _exported
 +            _exported:
 +                ret
 +            .subsections_via_symbols
 +        "#,
 +    };
 +    assert_dylib_export_case_matches_apple_ld(&case, &sdk, &sdk_ver).unwrap();
 +}
++
 +#[test]
 +fn dylib_export_surfaces_match_apple_ld_with_shared_prefixes() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let case = ExportParityCase {
 +        name: "export-prefix-parity",
 +        src: r#"
 +            .section __TEXT,__text,regular,pure_instructions
 +            .globl _alpha
 +            _alpha:
 +                ret
 +            .globl _alphabet
 +            _alphabet:
 +                ret
              .globl _alphanumeric
              _alphanumeric:
                  ret
      let _ = fs::remove_file(obj);
+ }
 +#[test]
 +fn linker_run_promotes_unresolved_symbol_to_dynamic_lookup() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("missing-dynamic.o");
 +    let out = scratch("missing-dynamic.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .section __DATA,__data
 +        .p2align 3
 +        .globl _missing_slot
 +        _missing_slot:
 +            .quad _missing
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        undefined_treatment: afs_ld::resolve::UndefinedTreatment::DynamicLookup,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let bind_records = decode_bind_records(&bytes, false).unwrap();
 +    assert!(
 +        bind_records
 +            .iter()
 +            .any(|record| record.symbol == "_missing" && record.ordinal == 0xFFFE),
 +        "expected flat-lookup bind for _missing, got {bind_records:?}"
 +    );
 +    let (_, _, undefs) = symbol_partition_names(&bytes);
 +    assert_eq!(undefs, vec!["_missing".to_string()]);
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
  #[test]
  fn linker_run_reports_duplicate_from_fetched_archive_member() {
      if !have_xcrun() {
+ }
  #[test]
 -fn linker_run_carries_tbd_inputs_into_load_commands() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_all_load_pulls_entry_from_archive() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun as or codesign unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        eprintln!("skipping: no macOS SDK path");
          return;
      };
      let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
          return;
+     }
 -    let obj = scratch("tbd-main.o");
 -    let out = scratch("tbd-a.out");
 +    let member_obj = scratch("all-load-main.o");
 +    let archive = scratch("all-load-main.a");
 +    let out = scratch("all-load-main.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
          _main:
 -            mov x0, #0
 +            mov w0, #7
              ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(src, &member_obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let ar = Command::new("ar")
 +        .arg("rcs")
 +        .arg(&archive)
 +        .arg(&member_obj)
 +        .output()
 +        .unwrap();
 +    if !ar.status.success() {
 +        eprintln!(
 +            "skipping: ar failed: {}",
 +            String::from_utf8_lossy(&ar.stderr)
 +        );
 +        return;
 +    }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone()],
 +        inputs: vec![archive.clone(), tbd],
          output: Some(out.clone()),
          kind: OutputKind::Executable,
 +        all_load: true,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let bytes = fs::read(&out).unwrap();
 -    let header = parse_header(&bytes).unwrap();
 -    let commands = parse_commands(&header, &bytes).unwrap();
 -    assert!(
 -        commands.iter().any(|cmd| matches!(
 -            cmd,
 -            LoadCommand::Dylib(d) if d.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 -        )),
 -        "expected at least one LC_LOAD_DYLIB in output"
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(7),
 +        "expected all-load executable to exit 7"
      );
 -    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(member_obj);
 +    let _ = fs::remove_file(archive);
      let _ = fs::remove_file(out);
+ }
  #[test]
 -fn linker_run_handles_non_standard_segment_without_panicking() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun as unavailable");
 +fn linker_run_force_load_pulls_entry_from_archive() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun as or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: no macOS SDK path");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
          return;
+     }
 -    let obj = scratch("custom-segment.o");
 -    let out = scratch("custom-segment.out");
 +    let member_obj = scratch("force-load-main.o");
 +    let archive = scratch("force-load-main.a");
 +    let out = scratch("force-load-main.out");
      let src = r#"
 -        .section __FOO,__bar
 -        .globl _custom
 -        _custom:
 -            .quad 1
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #9
 +            ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(src, &member_obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let ar = Command::new("ar")
 +        .arg("rcs")
 +        .arg(&archive)
 +        .arg(&member_obj)
 +        .output()
 +        .unwrap();
 +    if !ar.status.success() {
 +        eprintln!(
 +            "skipping: ar failed: {}",
 +            String::from_utf8_lossy(&ar.stderr)
 +        );
 +        return;
 +    }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone()],
 +        inputs: vec![archive.clone(), tbd],
          output: Some(out.clone()),
          kind: OutputKind::Executable,
 +        force_load_archives: vec![archive.clone()],
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let bytes = fs::read(&out).unwrap();
 -    let header = parse_header(&bytes).unwrap();
 -    let commands = parse_commands(&header, &bytes).unwrap();
 -    assert!(commands.iter().any(|cmd| match cmd {
 -        LoadCommand::Segment64(seg) => seg.segname_str() == "__FOO",
 -        _ => false,
 -    }));
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(9),
 +        "expected force-load executable to exit 9"
 +    );
 -    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(member_obj);
 +    let _ = fs::remove_file(archive);
      let _ = fs::remove_file(out);
+ }
  #[test]
 -fn linker_run_uses_requested_entry_symbol() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun as unavailable");
 +fn linker_run_resolves_lsystem_via_syslibroot() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun as or codesign unavailable");
          return;
+     }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: no macOS SDK path");
 +        return;
 +    };
 -    let obj = scratch("entry.o");
 -    let out = scratch("entry.out");
 +    let obj = scratch("lsystem-main.o");
 +    let out = scratch("lsystem-main.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
          _main:
 -            ret
 -        .globl _alt
 -        _alt:
 -            mov x0, #1
 +            mov w0, #0
              ret
          .subsections_via_symbols
      "#;
      let opts = LinkOptions {
          inputs: vec![obj.clone()],
 +        library_names: vec!["System".into()],
 +        syslibroot: Some(PathBuf::from(&sdk)),
          output: Some(out.clone()),
 -        entry: Some("_alt".into()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
      let bytes = fs::read(&out).unwrap();
 -    let header = parse_header(&bytes).unwrap();
 -    let commands = parse_commands(&header, &bytes).unwrap();
 -    let mut text_offset = None;
 -    let mut main_entryoff = None;
 -    for cmd in commands {
 -        match cmd {
 -            LoadCommand::Segment64(seg) => {
 -                for section in seg.sections {
 -                    if section.sectname_str() == "__text" {
 -                        text_offset = Some(section.offset as u64);
 -                    }
 -                }
 -            }
 -            LoadCommand::Raw { cmd, data, .. } if cmd == afs_ld::macho::constants::LC_MAIN => {
 -                let mut buf = [0u8; 8];
 -                buf.copy_from_slice(&data[0..8]);
 -                main_entryoff = Some(u64::from_le_bytes(buf));
 -            }
 -            _ => {}
 -        }
 -    }
+-
 -    let text_offset = text_offset.expect("text section offset");
 -    let main_entryoff = main_entryoff.expect("LC_MAIN entryoff");
 +    let dylibs = load_dylib_names(&bytes).unwrap();
      assert!(
 -        main_entryoff > text_offset,
 -        "expected custom entry to land after start of __text: text={text_offset}, entry={main_entryoff}"
 +        dylibs
 +            .iter()
 +            .any(|name| name == "/usr/lib/libSystem.B.dylib"),
 +        "expected libSystem load command, got {dylibs:?}"
 +    );
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "expected executable linked via -lSystem to exit 0"
      );
      let _ = fs::remove_file(obj);
+ }
  #[test]
 -fn linker_run_defaults_entry_to_main_symbol() {
 +fn linker_run_resolves_framework_via_syslibroot() {
      if !have_xcrun() {
 -        eprintln!("skipping: xcrun as unavailable");
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let metal = PathBuf::from(format!(
 +        "{sdk}/System/Library/Frameworks/Metal.framework/Metal.tbd"
 +    ));
 +    if !metal.exists() {
 +        eprintln!("skipping: no Metal.tbd at {}", metal.display());
          return;
+     }
 -    let obj = scratch("default-entry.o");
 -    let out = scratch("default-entry.out");
 +    let obj = scratch("framework-main.o");
 +    let out = scratch("framework-main.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
 -        .globl _helper
 -        _helper:
 -            mov w0, #7
 -            ret
          .globl _main
          _main:
              mov w0, #0
      let opts = LinkOptions {
          inputs: vec![obj.clone()],
 +        frameworks: vec![FrameworkSpec {
 +            name: "Metal".into(),
 +            weak: false,
 +        }],
 +        syslibroot: Some(PathBuf::from(&sdk)),
          output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let status = Command::new(&out).status().unwrap();
 -    assert_eq!(
 -        status.code(),
 -        Some(0),
 -        "default executable entry should prefer _main over the first text atom"
 -    );
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    assert!(commands.iter().any(|cmd| matches!(
 +        cmd,
 +        LoadCommand::Dylib(d)
 +            if d.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 +                && d.name.contains("Metal.framework")
 +    )));
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(out);
+ }
  #[test]
 -fn linker_run_applies_core_arm64_relocations() {
 +fn linker_run_resolves_weak_framework_via_syslibroot() {
      if !have_xcrun() {
 -        eprintln!("skipping: xcrun as unavailable");
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let metal = PathBuf::from(format!(
 +        "{sdk}/System/Library/Frameworks/Metal.framework/Metal.tbd"
 +    ));
 +    if !metal.exists() {
 +        eprintln!("skipping: no Metal.tbd at {}", metal.display());
          return;
+     }
 -    let obj = scratch("relocs.o");
 -    let out = scratch("relocs.out");
 +    let obj = scratch("weak-framework-main.o");
 +    let out = scratch("weak-framework-main.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        .globl _helper
          _main:
 -            adrp x0, _target@PAGE
 -            add x0, x0, _target@PAGEOFF
 -            bl _helper
 -            ret
 -        _helper:
 +            mov w0, #0
              ret
+-
 -        .section __DATA,__data
 -        .p2align 3
 -        _target:
 -            .quad _helper
+-
 -        .section __TEXT,__const
 -        .p2align 3
 -        _delta:
 -            .quad _helper - _main
          .subsections_via_symbols
      "#;
      if let Err(e) = assemble(src, &obj) {
      let opts = LinkOptions {
          inputs: vec![obj.clone()],
 +        frameworks: vec![FrameworkSpec {
 +            name: "Metal".into(),
 +            weak: true,
 +        }],
 +        syslibroot: Some(PathBuf::from(&sdk)),
          output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      Linker::run(&opts).unwrap();
      let bytes = fs::read(&out).unwrap();
 -    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").expect("text section");
 -    let (data_addr, data) = output_section(&bytes, "__DATA", "__data").expect("data section");
 -    let (_, cdata) = output_section(&bytes, "__TEXT", "__const").expect("const section");
+-
 -    let adrp = u32::from_le_bytes(text[0..4].try_into().unwrap());
 -    let add = u32::from_le_bytes(text[4..8].try_into().unwrap());
 -    let branch = u32::from_le_bytes(text[8..12].try_into().unwrap());
 -    let data_ptr = u64::from_le_bytes(data[0..8].try_into().unwrap());
 -    let delta = u64::from_le_bytes(cdata[0..8].try_into().unwrap());
+-
 -    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 -    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 -    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 -    let adrp_base = ((text_addr as i64) & !0xfff) + (adrp_pages << 12);
 -    let add_imm = ((add >> 10) & 0xfff) as u64;
 -    let reconstructed_target = (adrp_base as u64) + add_imm;
+-
 -    assert_eq!(
 -        reconstructed_target, data_addr,
 -        "ADRP+ADD should resolve _target"
 -    );
 -    assert_eq!(
 -        branch & 0x03ff_ffff,
 -        0x2,
 -        "BL should branch forward 8 bytes"
 -    );
 -    assert_eq!(
 -        data_ptr,
 -        text_addr + 16,
 -        ".quad _helper should point at helper"
 -    );
 -    assert_eq!(delta, 16, "_helper - _main should fold through SUBTRACTOR");
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    assert!(commands.iter().any(|cmd| matches!(
 +        cmd,
 +        LoadCommand::Dylib(d)
 +            if d.cmd == afs_ld::macho::constants::LC_LOAD_WEAK_DYLIB
 +                && d.name.contains("Metal.framework")
 +    )));
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(out);
+ }
 -fn sign_extend_21(value: i64) -> i64 {
 -    if value & (1 << 20) != 0 {
 -        value | !0x1f_ffff
 -    } else {
 -        value
 -    }
 -}
+-
  #[test]
 -fn linker_run_applies_scaled_pageoff12_for_ldr_x() {
 +fn linker_run_uses_platform_version_for_build_command() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun as unavailable");
          return;
+     }
 -    let obj = scratch("scaled-ldr.o");
 -    let out = scratch("scaled-ldr.out");
 +    let obj = scratch("platform-version.o");
 +    let out = scratch("platform-version.out");
      let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
          _main:
 -            adrp x0, _target@PAGE
 -            ldr x1, [x0, _target@PAGEOFF]
 +            mov w0, #0
              ret
+-
 -        .section __DATA,__data
 -        .space 0x3f8
 -        .p2align 3
 -        .globl _target
 -        _target:
 -            .quad 0x1122334455667788
          .subsections_via_symbols
      "#;
      if let Err(e) = assemble(src, &obj) {
          inputs: vec![obj.clone()],
          output: Some(out.clone()),
          kind: OutputKind::Executable,
 +        platform_version: Some(afs_ld::PlatformVersion {
 +            minos: (13 << 16) | (2 << 8) | 1,
 +            sdk: (14 << 16) | (5 << 8),
 +        }),
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
      let bytes = fs::read(&out).unwrap();
 -    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").expect("text section");
 -    let (data_addr, data) = output_section(&bytes, "__DATA", "__data").expect("data section");
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let build = commands
 +        .into_iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::BuildVersion(cmd) => Some(cmd),
 +            _ => None,
 +        })
 +        .expect("missing LC_BUILD_VERSION");
 +    assert_eq!(build.minos, (13 << 16) | (2 << 8) | 1);
 +    assert_eq!(build.sdk, (14 << 16) | (5 << 8));
 -    let adrp = u32::from_le_bytes(text[0..4].try_into().unwrap());
 -    let ldr = u32::from_le_bytes(text[4..8].try_into().unwrap());
 -    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 -    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 -    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 -    let adrp_base = ((text_addr as i64) & !0xfff) + (adrp_pages << 12);
 -    let ldr_shift = ((ldr >> 30) & 0b11) as u64;
 -    let ldr_imm = ((ldr >> 10) & 0xfff) as u64;
 -    let reconstructed_target = (adrp_base as u64) + (ldr_imm << ldr_shift);
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
 -    assert_eq!(ldr_shift, 3, "expected 64-bit LDR scale");
 -    assert_eq!(ldr_imm, 0x7f, "scaled imm12 should store 0x3f8 >> 3");
 -    assert_eq!(reconstructed_target, data_addr + 0x3f8);
 -    assert_eq!(
 -        u64::from_le_bytes(data[0x3f8..0x400].try_into().unwrap()),
 -        0x1122334455667788
 -    );
 +#[test]
 +fn linker_run_emits_rpath_command() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("rpath-main.o");
 +    let out = scratch("rpath-main.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        rpaths: vec!["@loader_path/../Frameworks".into()],
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let rpaths: Vec<String> = commands
 +        .into_iter()
 +        .filter_map(|cmd| match cmd {
 +            LoadCommand::Rpath(cmd) => Some(cmd.path),
 +            _ => None,
 +        })
 +        .collect();
 +    assert_eq!(rpaths, vec!["@loader_path/../Frameworks".to_string()]);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(out);
+ }
  #[test]
 -fn relocated_sections_match_apple_ld_across_fixture_matrix() {
 -    if !have_xcrun() || !have_xcrun_tool("ld") {
 -        eprintln!("skipping: xcrun as/ld unavailable");
 +fn linker_run_emits_map_file() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
++
 +    let obj = scratch("map-main.o");
 +    let out = scratch("map-main.out");
 +    let map = scratch("map-main.map");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        map: Some(map.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
      };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +    Linker::run(&opts).unwrap();
++
 +    let map_text = fs::read_to_string(&map).unwrap();
 +    assert!(map_text.contains("# Path:"));
 +    assert!(map_text.contains("# Object files:"));
 +    assert!(map_text.contains("linker synthesized"));
 +    assert!(map_text.contains(&obj.display().to_string()));
 +    assert!(map_text.contains("# Sections:"));
 +    assert!(map_text.contains("__TEXT"));
 +    assert!(map_text.contains("__text"));
 +    assert!(map_text.contains("# Symbols:"));
 +    assert!(map_text.contains("_main"));
 +    assert!(map_text.contains("# Dead stripped:"));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(map);
 +}
++
 +#[test]
 +fn linker_run_map_lists_dead_stripped_symbols() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let main_obj = scratch("map-dead-main.o");
 +    let helper_obj = scratch("map-dead-helper.o");
 +    let unused_obj = scratch("map-dead-unused.o");
 +    let out = scratch("map-dead.out");
 +    let map = scratch("map-dead.map");
 +    let main_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let unused_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _unused
 +        _unused:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(main_src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
 +    }
 +    if let Err(e) = assemble(helper_src, &helper_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        return;
 +    }
 +    if let Err(e) = assemble(unused_src, &unused_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        let _ = fs::remove_file(helper_obj);
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![main_obj.clone(), helper_obj.clone(), unused_obj.clone()],
 +        output: Some(out.clone()),
 +        map: Some(map.clone()),
 +        dead_strip: true,
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
      };
 -    const TEXT: SectionCase = SectionCase {
 -        segname: "__TEXT",
 -        sectname: "__text",
 +    Linker::run(&opts).unwrap();
++
 +    let map_text = fs::read_to_string(&map).unwrap();
 +    let dead_stripped_idx = map_text.find("# Dead stripped:").unwrap();
 +    let dead_stripped = &map_text[dead_stripped_idx..];
 +    assert!(dead_stripped.contains("_unused"));
 +    assert!(!dead_stripped.contains("_helper"));
++
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(helper_obj);
 +    let _ = fs::remove_file(unused_obj);
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(map);
 +}
++
 +#[test]
 +fn linker_run_map_lists_folded_symbols_under_icf_safe() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("map-icf-folded.o");
 +    let out = scratch("map-icf-folded.out");
 +    let map = scratch("map-icf-folded.map");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper1
 +            bl _helper2
 +            mov w0, #0
 +            ret
++
 +        .private_extern _helper1
 +        _helper1:
 +            mov w0, #7
 +            ret
++
 +        .private_extern _helper2
 +        _helper2:
 +            mov w0, #7
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        map: Some(map.clone()),
 +        icf_mode: afs_ld::IcfMode::Safe,
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
      };
 -    const CONST: SectionCase = SectionCase {
 -        segname: "__TEXT",
 -        sectname: "__const",
 +    Linker::run(&opts).unwrap();
++
 +    let map_text = fs::read_to_string(&map).unwrap();
 +    let folded_idx = map_text.find("# Folded symbols:").unwrap();
 +    let folded = &map_text[folded_idx..];
 +    assert!(folded.contains("_helper2 folded to _helper1"));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(map);
 +}
++
 +#[test]
 +fn linker_run_carries_tbd_inputs_into_load_commands() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
      };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
 -    let cases = [
 -        ParityCase {
 -            name: "branch-forward",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    bl _helper
 -                    ret
 -                _helper:
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -            check: ParityCheck::ExactSections(&[TEXT]),
 -        },
 -        ParityCase {
 -            name: "branch-backward",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _helper
 -                _helper:
 -                    ret
 -                .globl _main
 -                _main:
 -                    bl _helper
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -            check: ParityCheck::ExactSections(&[TEXT]),
 -        },
 -        ParityCase {
 -            name: "adrp-add-intra-text-forward",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    adrp x0, _target@PAGE
 -                    add x0, x0, _target@PAGEOFF
 -                    ret
 -                .space 0x4ff4
 -                _target:
 -                    .quad 0
 -                .subsections_via_symbols
 -            "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x5000,
 -                kind: PageRefKind::Add,
 -            },
 -        },
 -        ParityCase {
 -            name: "adrp-add-intra-text-backward",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                _target:
 -                    .quad 0x55
 -                .space 0x4ff8
 -                .globl _main
 -                _main:
 +    let obj = scratch("tbd-main.o");
 +    let out = scratch("tbd-a.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov x0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    assert!(
 +        commands.iter().any(|cmd| matches!(
 +            cmd,
 +            LoadCommand::Dylib(d) if d.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 +        )),
 +        "expected at least one LC_LOAD_DYLIB in output"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_handles_non_standard_segment_without_panicking() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("custom-segment.o");
 +    let out = scratch("custom-segment.out");
 +    let src = r#"
 +        .section __FOO,__bar
 +        .globl _custom
 +        _custom:
 +            .quad 1
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    assert!(commands.iter().any(|cmd| match cmd {
 +        LoadCommand::Segment64(seg) => seg.segname_str() == "__FOO",
 +        _ => false,
 +    }));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_uses_requested_entry_symbol() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("entry.o");
 +    let out = scratch("entry.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            ret
 +        .globl _alt
 +        _alt:
 +            mov x0, #1
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        entry: Some("_alt".into()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let mut text_offset = None;
 +    let mut main_entryoff = None;
 +    for cmd in commands {
 +        match cmd {
 +            LoadCommand::Segment64(seg) => {
 +                for section in seg.sections {
 +                    if section.sectname_str() == "__text" {
 +                        text_offset = Some(section.offset as u64);
 +                    }
 +                }
 +            }
 +            LoadCommand::Raw { cmd, data, .. } if cmd == afs_ld::macho::constants::LC_MAIN => {
 +                let mut buf = [0u8; 8];
 +                buf.copy_from_slice(&data[0..8]);
 +                main_entryoff = Some(u64::from_le_bytes(buf));
 +            }
 +            _ => {}
 +        }
 +    }
++
 +    let text_offset = text_offset.expect("text section offset");
 +    let main_entryoff = main_entryoff.expect("LC_MAIN entryoff");
 +    assert!(
 +        main_entryoff > text_offset,
 +        "expected custom entry to land after start of __text: text={text_offset}, entry={main_entryoff}"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_defaults_entry_to_main_symbol() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("default-entry.o");
 +    let out = scratch("default-entry.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            mov w0, #7
 +            ret
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "default executable entry should prefer _main over the first text atom"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_applies_core_arm64_relocations() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("relocs.o");
 +    let out = scratch("relocs.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        .globl _helper
 +        _main:
 +            adrp x0, _target@PAGE
 +            add x0, x0, _target@PAGEOFF
 +            bl _helper
 +            ret
 +        _helper:
 +            ret
++
 +        .section __DATA,__data
 +        .p2align 3
 +        _target:
 +            .quad _helper
++
 +        .section __TEXT,__const
 +        .p2align 3
 +        _delta:
 +            .quad _helper - _main
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").expect("text section");
 +    let (data_addr, data) = output_section(&bytes, "__DATA", "__data").expect("data section");
 +    let (_, cdata) = output_section(&bytes, "__TEXT", "__const").expect("const section");
++
 +    let adrp = u32::from_le_bytes(text[0..4].try_into().unwrap());
 +    let add = u32::from_le_bytes(text[4..8].try_into().unwrap());
 +    let branch = u32::from_le_bytes(text[8..12].try_into().unwrap());
 +    let data_ptr = u64::from_le_bytes(data[0..8].try_into().unwrap());
 +    let delta = u64::from_le_bytes(cdata[0..8].try_into().unwrap());
++
 +    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 +    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 +    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 +    let adrp_base = ((text_addr as i64) & !0xfff) + (adrp_pages << 12);
 +    let add_imm = ((add >> 10) & 0xfff) as u64;
 +    let reconstructed_target = (adrp_base as u64) + add_imm;
++
 +    assert_eq!(
 +        reconstructed_target, data_addr,
 +        "ADRP+ADD should resolve _target"
 +    );
 +    assert_eq!(
 +        branch & 0x03ff_ffff,
 +        0x2,
 +        "BL should branch forward 8 bytes"
 +    );
 +    assert_eq!(
 +        data_ptr,
 +        text_addr + 16,
 +        ".quad _helper should point at helper"
 +    );
 +    assert_eq!(delta, 16, "_helper - _main should fold through SUBTRACTOR");
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +fn sign_extend_21(value: i64) -> i64 {
 +    if value & (1 << 20) != 0 {
 +        value | !0x1f_ffff
 +    } else {
 +        value
 +    }
 +}
++
 +#[test]
 +fn linker_run_applies_scaled_pageoff12_for_ldr_x() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("scaled-ldr.o");
 +    let out = scratch("scaled-ldr.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            ldr x1, [x0, _target@PAGEOFF]
 +            ret
++
 +        .section __DATA,__data
 +        .space 0x3f8
 +        .p2align 3
 +        .globl _target
 +        _target:
 +            .quad 0x1122334455667788
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").expect("text section");
 +    let (data_addr, data) = output_section(&bytes, "__DATA", "__data").expect("data section");
++
 +    let adrp = u32::from_le_bytes(text[0..4].try_into().unwrap());
 +    let ldr = u32::from_le_bytes(text[4..8].try_into().unwrap());
 +    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;
 +    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;
 +    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);
 +    let adrp_base = ((text_addr as i64) & !0xfff) + (adrp_pages << 12);
 +    let ldr_shift = ((ldr >> 30) & 0b11) as u64;
 +    let ldr_imm = ((ldr >> 10) & 0xfff) as u64;
 +    let reconstructed_target = (adrp_base as u64) + (ldr_imm << ldr_shift);
++
 +    assert_eq!(ldr_shift, 3, "expected 64-bit LDR scale");
 +    assert_eq!(ldr_imm, 0x7f, "scaled imm12 should store 0x3f8 >> 3");
 +    assert_eq!(reconstructed_target, data_addr + 0x3f8);
 +    assert_eq!(
 +        u64::from_le_bytes(data[0x3f8..0x400].try_into().unwrap()),
 +        0x1122334455667788
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn relocated_sections_match_apple_ld_across_fixture_matrix() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    const TEXT: SectionCase = SectionCase {
 +        segname: "__TEXT",
 +        sectname: "__text",
 +    };
 +    const CONST: SectionCase = SectionCase {
 +        segname: "__TEXT",
 +        sectname: "__const",
 +    };
++
 +    let cases = [
 +        ParityCase {
 +            name: "branch-forward",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    bl _helper
 +                    ret
 +                _helper:
 +                    ret
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::ExactSections(&[TEXT]),
 +        },
 +        ParityCase {
 +            name: "branch-backward",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _helper
 +                _helper:
 +                    ret
 +                .globl _main
 +                _main:
 +                    bl _helper
 +                    ret
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::ExactSections(&[TEXT]),
 +        },
 +        ParityCase {
 +            name: "adrp-add-intra-text-forward",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    add x0, x0, _target@PAGEOFF
 +                    ret
 +                .space 0x4ff4
 +                _target:
 +                    .quad 0
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x5000,
 +                kind: PageRefKind::Add,
 +            },
 +        },
 +        ParityCase {
 +            name: "adrp-add-intra-text-backward",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                _target:
 +                    .quad 0x55
 +                .space 0x4ff8
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    add x0, x0, _target@PAGEOFF
 +                    ret
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0x5000,
 +                target_offset: 0,
 +                kind: PageRefKind::Add,
 +            },
 +        },
 +        ParityCase {
 +            name: "adrp-ldr-x-intra-text",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    ldr x1, [x0, _target@PAGEOFF]
 +                    ret
 +                .space 0x3f4
 +                _target:
 +                    .quad 0x1122334455667788
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x400,
 +                kind: PageRefKind::Load,
 +            },
 +        },
 +        ParityCase {
 +            name: "adrp-ldr-w-intra-text",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    ldr w1, [x0, _target@PAGEOFF]
 +                    ret
 +                .space 0x2f4
 +                _target:
 +                    .long 0x11223344
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x300,
 +                kind: PageRefKind::Load,
 +            },
 +        },
 +        ParityCase {
 +            name: "adrp-ldrh-intra-text",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    ldrh w1, [x0, _target@PAGEOFF]
 +                    ret
 +                .space 0x1f4
 +                _target:
 +                    .hword 0x3344
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x200,
 +                kind: PageRefKind::Load,
 +            },
 +        },
 +        ParityCase {
 +            name: "adrp-ldrb-intra-text",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _target@PAGE
 +                    ldrb w1, [x0, _target@PAGEOFF]
 +                    ret
 +                .space 0xf4
 +                _target:
 +                    .byte 0x44
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x100,
 +                kind: PageRefKind::Load,
 +            },
 +        },
 +        ParityCase {
 +            name: "mixed-branch-adrp-text",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                .globl _helper
 +                _main:
                      adrp x0, _target@PAGE
                      add x0, x0, _target@PAGEOFF
 +                    bl _helper
 +                    ret
 +                _helper:
 +                    ret
 +                .space 0xff0
 +                _target:
 +                    .quad 0x99
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::PageRef {
 +                section: TEXT,
 +                site_offset: 0,
 +                target_offset: 0x1004,
 +                kind: PageRefKind::Add,
 +            },
 +        },
 +        ParityCase {
 +            name: "subtractor-positive",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _helper
 +                _helper:
 +                    ret
 +                .globl _main
 +                _main:
 +                    bl _helper
 +                    ret
 +                .section __TEXT,__const
 +                .p2align 3
 +                _delta:
 +                    .quad _helper - _main
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::ExactSections(&[CONST]),
 +        },
 +        ParityCase {
 +            name: "subtractor-negative",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _helper
 +                _helper:
 +                    ret
 +                .globl _main
 +                _main:
 +                    ret
 +                .section __TEXT,__const
 +                .p2align 3
 +                _delta:
 +                    .quad _main - _helper
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::ExactSections(&[CONST]),
 +        },
 +        ParityCase {
 +            name: "branch-and-subtractor",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _helper
 +                _helper:
 +                    ret
 +                .globl _main
 +                _main:
 +                    bl _helper
 +                    ret
 +                .section __TEXT,__const
 +                .p2align 3
 +                _delta:
 +                    .quad _main - _helper
 +                .subsections_via_symbols
 +            "#,
 +            check: ParityCheck::ExactSections(&[TEXT, CONST]),
 +        },
 +    ];
++
 +    let mut failures = Vec::new();
 +    for case in &cases {
 +        if let Err(err) = assert_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 +            failures.push(err);
 +        }
 +    }
++
 +    assert!(
 +        failures.is_empty(),
 +        "Apple ld parity failures ({} cases):\n{}",
 +        failures.len(),
 +        failures.join("\n\n")
 +    );
 +}
++
 +#[test]
 +fn linker_run_thunks_none_rejects_out_of_range_branch26() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-range.o");
 +    let out = scratch("branch26-range.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .zerofill __DATA,__bss,_gap,0x9000000,0
++
 +        .section __FAR,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out),
 +        kind: OutputKind::Executable,
 +        thunks: afs_ld::ThunkMode::None,
 +        ..LinkOptions::default()
 +    };
 +    let err = Linker::run(&opts).unwrap_err();
 +    match err {
 +        LinkError::Reloc(err) => {
 +            let msg = err.to_string();
 +            assert!(msg.contains("Branch26"), "{msg}");
 +            assert!(msg.contains("out of BRANCH26 range"), "{msg}");
 +            assert!(msg.contains("_helper"), "{msg}");
 +        }
 +        other => panic!("expected Reloc error, got {other:?}"),
 +    }
++
 +    let _ = fs::remove_file(obj);
 +}
++
 +#[test]
 +fn linker_run_inserts_thunk_for_out_of_range_branch26() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-thunk.o");
 +    let out = scratch("branch26-thunk.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .zerofill __DATA,__bss,_gap,0x9000000,0
++
 +        .section __FAR,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 +    let (thunks_addr, thunks) = output_section(&bytes, "__TEXT", "__thunks").unwrap();
 +    assert_eq!(thunks.len(), 12, "expected one synthetic thunk");
 +    assert_eq!(
 +        decode_branch_target(&text, text_addr, 8).unwrap(),
 +        thunks_addr,
 +        "expected _main BL to target __thunks"
 +    );
 +    assert!(is_adrp(read_insn(&thunks, 0).unwrap()));
 +    assert!(is_add_imm_64(read_insn(&thunks, 4).unwrap()));
 +    assert_eq!(read_insn(&thunks, 8).unwrap(), 0xd61f_0200);
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "expected thunked executable to exit 0"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_safe_thunks_do_not_grow_small_programs() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-small.o");
 +    let out = scratch("branch26-small.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            ret
++
 +        _helper:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    assert!(
 +        output_section(&fs::read(&out).unwrap(), "__TEXT", "__thunks").is_none(),
 +        "small in-range program should not gain __thunks"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_thunks_all_forces_shared_thunk_for_in_range_calls() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-thunks-all.o");
 +    let out = scratch("branch26-thunks-all.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper
 +            bl _helper
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        _helper:
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        thunks: afs_ld::ThunkMode::All,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 +    let (thunks_addr, thunks) = output_section(&bytes, "__TEXT", "__thunks").unwrap();
 +    assert_eq!(
 +        thunks.len(),
 +        12,
 +        "expected both in-range calls to share one forced thunk"
 +    );
 +    assert_eq!(
 +        decode_branch_target(&text, text_addr, 8).unwrap(),
 +        thunks_addr,
 +        "expected first BL to route through __thunks under -thunks=all"
 +    );
 +    assert_eq!(
 +        decode_branch_target(&text, text_addr, 12).unwrap(),
 +        thunks_addr,
 +        "expected second BL to share the same thunk target"
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "expected -thunks=all executable to exit 0"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_places_thunks_in_caller_segment() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-custom-segment-thunk.o");
 +    let out = scratch("branch26-custom-segment-thunk.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            mov w0, #0
 +            ret
++
 +        .zerofill __DATA,__bss,_gap,0x9000000,0
++
 +        .section __FARCALL,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper
 +            ldp x29, x30, [sp], #16
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    assert!(
 +        output_section(&bytes, "__TEXT", "__thunks").is_none(),
 +        "expected no __TEXT thunk section for custom-segment caller"
 +    );
 +    let (text_addr, text) = output_section(&bytes, "__FARCALL", "__text").unwrap();
 +    let (thunks_addr, thunks) = output_section(&bytes, "__FARCALL", "__thunks").unwrap();
 +    assert_eq!(thunks.len(), 12, "expected one custom-segment thunk");
 +    assert_eq!(
 +        decode_branch_target(&text, text_addr, 8).unwrap(),
 +        thunks_addr,
 +        "expected custom-segment BL to target custom-segment thunk"
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_replans_thunks_until_layout_converges() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-thunk-fixed-point.o");
 +    let out = scratch("branch26-thunk-fixed-point.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _overflow
 +            bl _borderline
 +            mov w0, #0
 +            ret
++
 +        .zerofill __TEXT,__apad,_gap,0x7ffffec,2
++
 +        .section __TEXT,__late,regular,pure_instructions
 +        .globl _borderline
 +        _borderline:
 +            ret
++
 +        .globl _overflow
 +        _overflow:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 +    let (thunks_addr, thunks) = output_section(&bytes, "__TEXT", "__thunks").unwrap();
 +    assert_eq!(
 +        thunks.len(),
 +        24,
 +        "expected two thunks after fixed-point replanning"
 +    );
 +    let mut actual_targets = [
 +        decode_branch_target(&text, text_addr, 0).unwrap(),
 +        decode_branch_target(&text, text_addr, 4).unwrap(),
 +    ];
 +    actual_targets.sort_unstable();
 +    assert_eq!(
 +        actual_targets,
 +        [thunks_addr, thunks_addr + 12],
 +        "expected both branches to redirect through the two thunk slots"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_uses_multiple_thunk_islands_within_text_segment() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("branch26-multi-island.o");
 +    let out = scratch("branch26-multi-island.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _midcaller
 +            mov w0, #0
 +            ret
++
 +        .zerofill __TEXT,__apad1,_gap1,0x9000000,2
++
 +        .section __TEXT,__bmid,regular,pure_instructions
 +        .globl _midcaller
 +        _midcaller:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .zerofill __TEXT,__cpad2,_gap2,0x9000000,2
++
 +        .section __TEXT,__dlate,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let thunk_sections = output_sections(&bytes, "__TEXT", "__thunks");
 +    assert_eq!(
 +        thunk_sections.len(),
 +        2,
 +        "expected one thunk island after __text and one after __mid"
 +    );
 +    assert!(
 +        thunk_sections.iter().all(|(_, bytes)| bytes.len() == 12),
 +        "expected one thunk per island"
 +    );
++
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 +    let (mid_addr, mid) = output_section(&bytes, "__TEXT", "__bmid").unwrap();
 +    let mut actual_targets = [
 +        decode_branch_target(&text, text_addr, 0).unwrap(),
 +        decode_branch_target(&mid, mid_addr, 8).unwrap(),
 +    ];
 +    actual_targets.sort_unstable();
 +    let mut expected_targets = [thunk_sections[0].0, thunk_sections[1].0];
 +    expected_targets.sort_unstable();
 +    assert_eq!(
 +        actual_targets, expected_targets,
 +        "expected the two call sites to route through the two thunk islands"
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
 +}
++
 +#[test]
 +fn linker_run_routes_dylib_imports_through_synthetic_sections() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("import-reloc.o");
 +    let out = scratch("import-reloc.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _write@GOTPAGE
 +            ldr x0, [x0, _write@GOTPAGEOFF]
 +            bl _write
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let bytes = fs::read(&out).unwrap();
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 +    let (stubs_addr, stubs) = output_section(&bytes, "__TEXT", "__stubs").unwrap();
 +    let (helper_addr, helper) = output_section(&bytes, "__TEXT", "__stub_helper").unwrap();
 +    let (got_addr, got) = output_section(&bytes, "__DATA_CONST", "__got").unwrap();
 +    let (lazy_addr, lazy) = output_section(&bytes, "__DATA", "__la_symbol_ptr").unwrap();
 +    let (dyld_private_addr, _) = output_section(&bytes, "__DATA", "__data").unwrap();
 +    let stubs_hdr = output_section_header(&bytes, "__TEXT", "__stubs").unwrap();
 +    let got_hdr = output_section_header(&bytes, "__DATA_CONST", "__got").unwrap();
 +    let lazy_hdr = output_section_header(&bytes, "__DATA", "__la_symbol_ptr").unwrap();
++
 +    let symtab = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Symtab(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .unwrap();
 +    let dysymtab = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Dysymtab(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .unwrap();
 +    let dyld_info = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::DyldInfoOnly(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .unwrap();
 +    let libsystem_load = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Dylib(cmd)
 +                if cmd.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 +                    && cmd.name == "/usr/lib/libSystem.B.dylib" =>
 +            {
 +                Some(cmd.clone())
 +            }
 +            _ => None,
 +        })
 +        .unwrap();
 +    let symbols = parse_nlist_table(&bytes, symtab.symoff, symtab.nsyms).unwrap();
 +    let strings = StringTable::from_file(&bytes, symtab.stroff, symtab.strsize).unwrap();
 +    let symbol_names: Vec<&str> = symbols
 +        .iter()
 +        .map(|symbol| strings.get(symbol.strx()).unwrap())
 +        .collect();
++
 +    assert_eq!(got.len(), 16);
 +    assert_eq!(stubs.len(), 12);
 +    assert_eq!(helper.len(), 36);
 +    assert_eq!(lazy.len(), 8);
 +    assert_eq!(symtab.nsyms, 5);
 +    assert_eq!(dysymtab.nlocalsym, 1);
 +    assert_eq!(dysymtab.nextdefsym, 2);
 +    assert_eq!(dysymtab.nundefsym, 2);
 +    assert_eq!(dysymtab.nindirectsyms, 4);
 +    assert_eq!(stubs_hdr.reserved1, 0);
 +    assert_eq!(got_hdr.reserved1, 1);
 +    assert_eq!(lazy_hdr.reserved1, 3);
 +    assert_eq!(stubs_hdr.reserved2, 12);
 +    assert!(libsystem_load.current_version >= (1 << 16));
 +    assert_eq!(libsystem_load.compatibility_version, 1 << 16);
 +    assert!(dyld_info.rebase_size > 0);
 +    assert!(dyld_info.bind_size > 0);
 +    assert!(dyld_info.lazy_bind_size > 0);
 +    assert_eq!(
 +        decode_page_reference(&text, text_addr, 0, &PageRefKind::Load).unwrap(),
 +        got_addr
 +    );
 +    assert_eq!(
 +        decode_branch_target(&text, text_addr, 8).unwrap(),
 +        stubs_addr
 +    );
 +    assert_eq!(
 +        decode_page_reference(&stubs, stubs_addr, 0, &PageRefKind::Load).unwrap(),
 +        lazy_addr
 +    );
 +    assert_eq!(read_insn(&stubs, 8).unwrap(), 0xd61f0200);
 +    assert_eq!(
 +        u64::from_le_bytes(lazy[0..8].try_into().unwrap()),
 +        helper_addr + 24
 +    );
 +    assert_eq!(
 +        decode_page_reference(&helper, helper_addr, 0, &PageRefKind::Add).unwrap(),
 +        dyld_private_addr
 +    );
 +    assert_eq!(
 +        decode_page_reference(&helper, helper_addr, 12, &PageRefKind::Load).unwrap(),
 +        got_addr + 8
 +    );
 +    assert_eq!(read_insn(&helper, 20).unwrap(), 0xd61f0200);
 +    assert_eq!(read_insn(&helper, 24).unwrap(), 0x1800_0050);
 +    assert_eq!(
 +        decode_branch_target(&helper, helper_addr, 28).unwrap(),
 +        helper_addr
 +    );
 +    assert_eq!(u32::from_le_bytes(helper[32..36].try_into().unwrap()), 0);
 +    let (locals, extdefs, undefs) = symbol_partition_names(&bytes);
 +    assert_eq!(locals, vec!["__dyld_private".to_string()]);
 +    assert_eq!(
 +        extdefs,
 +        vec!["__mh_execute_header".to_string(), "_main".to_string()]
 +    );
 +    assert_eq!(
 +        undefs,
 +        vec!["_write".to_string(), "dyld_stub_binder".to_string()]
 +    );
 +    assert!(symbol_names.contains(&"__dyld_private"));
 +    assert!(symbols[dysymtab.iundefsym as usize..]
 +        .iter()
 +        .all(|symbol| symbol.kind() == SymKind::Undef));
 +    assert!(symbols[dysymtab.iundefsym as usize..]
 +        .iter()
 +        .all(|symbol| symbol.library_ordinal().unwrap() > 0));
 +    assert!(symbol_names.contains(&"_write"));
 +    assert!(symbol_names.contains(&"dyld_stub_binder"));
++
 +    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(obj);
 +}
++
 +#[test]
 +fn synthetic_import_surfaces_match_apple_ld_classic_lazy_model() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("import-parity.o");
 +    let our_out = scratch("import-parity-ours.out");
 +    let apple_out = scratch("import-parity-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _write@GOTPAGE
 +            ldr x0, [x0, _write@GOTPAGEOFF]
 +            bl _write
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
++
 +    for (segname, sectname) in [("__TEXT", "__stubs"), ("__TEXT", "__stub_helper")] {
 +        let (_, ours) = output_section(&our_bytes, segname, sectname).unwrap();
 +        let (_, apple) = output_section(&apple_bytes, segname, sectname).unwrap();
 +        let diff = diff_macho(&ours, &apple);
 +        assert!(
 +            diff.is_clean(),
 +            "{segname},{sectname} diverged from Apple ld: {:#?}",
 +            diff.critical
 +        );
 +    }
++
 +    let (our_helper_addr, _) = output_section(&our_bytes, "__TEXT", "__stub_helper").unwrap();
 +    let (apple_helper_addr, _) = output_section(&apple_bytes, "__TEXT", "__stub_helper").unwrap();
 +    let (_, our_lazy) = output_section(&our_bytes, "__DATA", "__la_symbol_ptr").unwrap();
 +    let (_, apple_lazy) = output_section(&apple_bytes, "__DATA", "__la_symbol_ptr").unwrap();
 +    assert_eq!(
 +        u64::from_le_bytes(our_lazy[0..8].try_into().unwrap()) - our_helper_addr,
 +        24
 +    );
 +    assert_eq!(
 +        u64::from_le_bytes(apple_lazy[0..8].try_into().unwrap()) - apple_helper_addr,
 +        24
 +    );
++
 +    assert_eq!(
 +        load_dylib_names(&our_bytes).unwrap(),
 +        load_dylib_names(&apple_bytes).unwrap()
 +    );
 +    assert_eq!(
 +        segment_flags(&our_bytes, "__DATA_CONST"),
 +        Some(SG_READ_ONLY)
 +    );
 +    assert_eq!(
 +        segment_flags(&our_bytes, "__DATA_CONST"),
 +        segment_flags(&apple_bytes, "__DATA_CONST")
 +    );
++
 +    let our_rebases = decode_rebase_records(&our_bytes).unwrap();
 +    let apple_rebases = decode_rebase_records(&apple_bytes).unwrap();
 +    assert!(our_rebases
 +        .iter()
 +        .all(|record| record.rebase_type == REBASE_TYPE_POINTER));
 +    assert_eq!(our_rebases, apple_rebases);
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap()
 +    );
 +    assert_eq!(
 +        dyld_info_stream(&our_bytes, DyldInfoStreamKind::WeakBind).unwrap(),
 +        dyld_info_stream(&apple_bytes, DyldInfoStreamKind::WeakBind).unwrap()
 +    );
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, true).unwrap(),
 +        decode_bind_records(&apple_bytes, true).unwrap()
 +    );
 +    assert_eq!(
 +        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 +        canonical_lazy_bind_stream(&apple_bytes).unwrap()
 +    );
 +    assert_eq!(
 +        indirect_symbol_table(&our_bytes),
 +        indirect_symbol_table(&apple_bytes)
 +    );
++
 +    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(obj);
 +}
++
 +#[test]
 +fn classic_lazy_surfaces_match_apple_ld_across_fixture_matrix() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let cases = [
 +        ClassicLazyParityCase {
 +            name: "single-got-and-call",
 +            src: r#"
 +                .section __TEXT,__text,regular,pure_instructions
 +                .globl _main
 +                _main:
 +                    adrp x0, _write@GOTPAGE
 +                    ldr x0, [x0, _write@GOTPAGEOFF]
 +                    bl _write
                      ret
                  .subsections_via_symbols
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0x5000,
 -                target_offset: 0,
 -                kind: PageRefKind::Add,
 -            },
          },
 -        ParityCase {
 -            name: "adrp-ldr-x-intra-text",
 +        ClassicLazyParityCase {
 +            name: "batched-got-and-calls",
              src: r#"
                  .section __TEXT,__text,regular,pure_instructions
                  .globl _main
                  _main:
 -                    adrp x0, _target@PAGE
 -                    ldr x1, [x0, _target@PAGEOFF]
 +                    adrp x0, _write@GOTPAGE
 +                    ldr x0, [x0, _write@GOTPAGEOFF]
 +                    bl _write
 +                    adrp x1, _close@GOTPAGE
 +                    ldr x1, [x1, _close@GOTPAGEOFF]
 +                    bl _close
 +                    adrp x2, _read@GOTPAGE
 +                    ldr x2, [x2, _read@GOTPAGEOFF]
 +                    bl _read
                      ret
 -                .space 0x3f4
 -                _target:
 -                    .quad 0x1122334455667788
                  .subsections_via_symbols
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x400,
 -                kind: PageRefKind::Load,
 -            },
          },
 -        ParityCase {
 -            name: "adrp-ldr-w-intra-text",
 +        ClassicLazyParityCase {
 +            name: "branch-only-calls",
              src: r#"
                  .section __TEXT,__text,regular,pure_instructions
                  .globl _main
                  _main:
 -                    adrp x0, _target@PAGE
 -                    ldr w1, [x0, _target@PAGEOFF]
 +                    bl _write
 +                    bl _close
 +                    bl _read
                      ret
 -                .space 0x2f4
 -                _target:
 -                    .long 0x11223344
                  .subsections_via_symbols
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x300,
 -                kind: PageRefKind::Load,
 -            },
          },
 -        ParityCase {
 -            name: "adrp-ldrh-intra-text",
 +        ClassicLazyParityCase {
 +            name: "deduped-import",
              src: r#"
                  .section __TEXT,__text,regular,pure_instructions
                  .globl _main
                  _main:
 -                    adrp x0, _target@PAGE
 -                    ldrh w1, [x0, _target@PAGEOFF]
 +                    adrp x0, _write@GOTPAGE
 +                    ldr x0, [x0, _write@GOTPAGEOFF]
 +                    bl _write
 +                    bl _write
 +                    adrp x1, _write@GOTPAGE
 +                    ldr x1, [x1, _write@GOTPAGEOFF]
                      ret
 -                .space 0x1f4
 -                _target:
 -                    .hword 0x3344
                  .subsections_via_symbols
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x200,
 -                kind: PageRefKind::Load,
 -            },
 -        },
 -        ParityCase {
 -            name: "adrp-ldrb-intra-text",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    adrp x0, _target@PAGE
 -                    ldrb w1, [x0, _target@PAGEOFF]
 -                    ret
 -                .space 0xf4
 -                _target:
 -                    .byte 0x44
 -                .subsections_via_symbols
 +        },
 +    ];
++
 +    let mut failures = Vec::new();
 +    for case in &cases {
 +        if let Err(err) = assert_classic_lazy_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 +            failures.push(err);
 +        }
 +    }
++
 +    assert!(
 +        failures.is_empty(),
 +        "Apple ld classic-lazy parity failures ({} cases):\n{}",
 +        failures.len(),
 +        failures.join("\n\n")
 +    );
 +}
++
 +#[test]
 +fn linker_run_binds_direct_dylib_import_pointers() {
 +    if !have_xcrun() || !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 Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let dylib_src = r#"
 +        int ext_data = 5;
 +    "#;
 +    let direct_case = DirectBindParityCase {
 +        name: "direct-data",
 +        dylib_src,
 +        main_src: r#"
 +            extern int ext_data;
 +            int *p = &ext_data;
 +            int main(void) { return *p == 5 ? 0 : 1; }
 +        "#,
 +    };
 +    if let Err(e) = assert_direct_bind_case_matches_apple_ld(&direct_case, &sdk, &sdk_ver) {
 +        panic!("{e}");
 +    }
++
 +    let dylib = scratch("direct-data.dylib");
 +    let obj = scratch("direct-data.o");
 +    let our_out = scratch("direct-data-ours.out");
++
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let main_src = r#"
 +        extern int ext_data;
 +        int *p = &ext_data;
 +        int main(void) { return *p == 5 ? 0 : 1; }
 +    "#;
 +    if let Err(e) = compile_c(main_src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone(), dylib.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let binds = decode_bind_records(&our_bytes, false).unwrap();
 +    assert!(
 +        binds.iter().any(|record| {
 +            record.segment == "__DATA"
 +                && record.section == "__data"
 +                && record.section_offset == 0
 +                && record.symbol == "_ext_data"
 +        }),
 +        "missing direct bind for imported data: {binds:#?}"
 +    );
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "expected direct-import pointer executable to exit 0"
 +    );
++
 +    let _ = fs::remove_file(dylib);
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +}
++
 +#[test]
 +fn direct_bind_surfaces_match_apple_ld_across_fixture_matrix() {
 +    if !have_xcrun() || !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 Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let cases = [
 +        DirectBindParityCase {
 +            name: "direct-multi-data",
 +            dylib_src: r#"
 +                int ext_data = 5;
 +                int more_data = 9;
 +            "#,
 +            main_src: r#"
 +                extern int ext_data;
 +                extern int more_data;
 +                int *p = &ext_data;
 +                int *q = &more_data;
 +                int main(void) { return (*p == 5 && *q == 9) ? 0 : 1; }
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x100,
 -                kind: PageRefKind::Load,
 -            },
          },
 -        ParityCase {
 -            name: "mixed-branch-adrp-text",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                .globl _helper
 -                _main:
 -                    adrp x0, _target@PAGE
 -                    add x0, x0, _target@PAGEOFF
 -                    bl _helper
 -                    ret
 -                _helper:
 -                    ret
 -                .space 0xff0
 -                _target:
 -                    .quad 0x99
 -                .subsections_via_symbols
 +        DirectBindParityCase {
 +            name: "direct-and-call-mixed",
 +            dylib_src: r#"
 +                int ext_data = 5;
 +                int ext_fn(void) { return ext_data + 1; }
              "#,
 -            check: ParityCheck::PageRef {
 -                section: TEXT,
 -                site_offset: 0,
 -                target_offset: 0x1004,
 -                kind: PageRefKind::Add,
 -            },
 -        },
 -        ParityCase {
 -            name: "subtractor-positive",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _helper
 -                _helper:
 -                    ret
 -                .globl _main
 -                _main:
 -                    bl _helper
 -                    ret
 -                .section __TEXT,__const
 -                .p2align 3
 -                _delta:
 -                    .quad _helper - _main
 -                .subsections_via_symbols
 +            main_src: r#"
 +                extern int ext_data;
 +                extern int ext_fn(void);
 +                int *p = &ext_data;
 +                int main(void) { return *p + ext_fn() == 11 ? 0 : 1; }
              "#,
 -            check: ParityCheck::ExactSections(&[CONST]),
          },
 -        ParityCase {
 -            name: "subtractor-negative",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _helper
 -                _helper:
 -                    ret
 -                .globl _main
 -                _main:
 -                    ret
 -                .section __TEXT,__const
 -                .p2align 3
 -                _delta:
 -                    .quad _main - _helper
 -                .subsections_via_symbols
 +        DirectBindParityCase {
 +            name: "direct-deduped",
 +            dylib_src: r#"
 +                int ext_data = 5;
              "#,
 -            check: ParityCheck::ExactSections(&[CONST]),
 -        },
 -        ParityCase {
 -            name: "branch-and-subtractor",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _helper
 -                _helper:
 -                    ret
 -                .globl _main
 -                _main:
 -                    bl _helper
 -                    ret
 -                .section __TEXT,__const
 -                .p2align 3
 -                _delta:
 -                    .quad _main - _helper
 -                .subsections_via_symbols
 +            main_src: r#"
 +                extern int ext_data;
 +                int *p = &ext_data;
 +                int *q = &ext_data;
 +                int main(void) { return (*p == 5 && *q == 5) ? 0 : 1; }
              "#,
 -            check: ParityCheck::ExactSections(&[TEXT, CONST]),
          },
      ];
 -    let mut failures = Vec::new();
 -    for case in &cases {
 -        if let Err(err) = assert_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 -            failures.push(err);
 -        }
 +    let mut failures = Vec::new();
 +    for case in &cases {
 +        if let Err(err) = assert_direct_bind_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 +            failures.push(err);
 +        }
 +    }
++
 +    assert!(
 +        failures.is_empty(),
 +        "Apple ld direct-bind parity failures ({} cases):\n{}",
 +        failures.len(),
 +        failures.join("\n\n")
 +    );
 +}
++
 +#[test]
 +fn linker_run_rebases_local_absolute_pointers_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("local-rebase.o");
 +    let our_out = scratch("local-rebase-ours.out");
 +    let apple_out = scratch("local-rebase-apple.out");
 +    let src = r#"
 +        int ext = 7;
 +        int *p = &ext;
 +        int main(void) { return *p == 7 ? 0 : 1; }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert!(!dyld_info_stream(&our_bytes, DyldInfoStreamKind::Rebase)
 +        .unwrap()
 +        .is_empty());
 +    assert_eq!(
 +        dyld_info_stream(&our_bytes, DyldInfoStreamKind::Rebase).unwrap(),
 +        dyld_info_stream(&apple_bytes, DyldInfoStreamKind::Rebase).unwrap()
 +    );
 +    assert_eq!(
 +        decode_rebase_records(&our_bytes).unwrap(),
 +        decode_rebase_records(&apple_bytes).unwrap()
 +    );
++
 +    let our_status = Command::new(&our_out).status().unwrap();
 +    let apple_status = Command::new(&apple_out).status().unwrap();
 +    assert_eq!(our_status.code(), Some(0));
 +    assert_eq!(apple_status.code(), Some(0));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_routes_local_got_loads_through_rebased_slots() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("local-got.o");
 +    let our_out = scratch("local-got-ours.out");
 +    let apple_out = scratch("local-got-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x8, _value@GOTPAGE
 +            ldr x8, [x8, _value@GOTPAGEOFF]
 +            ldr w0, [x8]
 +            ret
++
 +        .section __DATA,__data
 +        .globl _value
 +        .p2align 2
 +        _value:
 +            .long 7
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let our_binds = decode_bind_records(&our_bytes, false).unwrap();
 +    let apple_binds = decode_bind_records(&apple_bytes, false).unwrap();
 +    assert_eq!(our_binds, apple_binds);
 +    assert!(
 +        our_binds.iter().all(|record| record.symbol != "_value"),
 +        "local GOT target should not be emitted as a dylib bind: {our_binds:#?}"
 +    );
 +    assert_eq!(
 +        output_section(&our_bytes, "__DATA_CONST", "__got")
 +            .expect("missing __got section")
 +            .1
 +            .len(),
 +        8
 +    );
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(7),
 +        "expected local GOT executable to exit 7"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_dead_strip_prunes_synthetic_import_sections() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("dead-strip-import.o");
 +    let our_out = scratch("dead-strip-import-ours.out");
 +    let apple_out = scratch("dead-strip-import-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
++
 +        .globl _unused
 +        _unused:
 +            bl _puts
 +            mov w0, #0
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(our_out.clone()),
 +        dead_strip: true,
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_with_args(
 +        &obj,
 +        &apple_out,
 +        "_main",
 +        &sdk,
 +        &sdk_ver,
 +        &["-dead_strip", "-no_fixup_chains"],
 +    )
 +    .unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    for (segname, sectname) in [
 +        ("__TEXT", "__stubs"),
 +        ("__TEXT", "__stub_helper"),
 +        ("__DATA", "__la_symbol_ptr"),
 +        ("__DATA_CONST", "__got"),
 +    ] {
 +        assert!(
 +            output_section(&our_bytes, segname, sectname).is_none(),
 +            "unexpected synthetic section {segname},{sectname} in our output"
 +        );
 +        assert!(
 +            output_section(&apple_bytes, segname, sectname).is_none(),
 +            "unexpected synthetic section {segname},{sectname} in apple output"
 +        );
 +    }
 +    assert!(decode_bind_records(&our_bytes, false).unwrap().is_empty());
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap()
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(status.code(), Some(0));
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_relaxes_hidden_got_loads_like_apple_ld() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("hidden-got.o");
 +    let our_out = scratch("hidden-got-ours.out");
 +    let apple_out = scratch("hidden-got-apple.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x8, _value@GOTPAGE
 +            ldr x8, [x8, _value@GOTPAGEOFF]
 +            ldr w0, [x8]
 +            ret
++
 +        .private_extern _value
 +        .section __DATA,__data
 +        .p2align 2
 +        _value:
 +            .long 7
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 +    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 +    assert_eq!(
 +        decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 +        decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add).unwrap()
 +    );
 +    assert_eq!(our_text, apple_text);
 +    assert!(output_section(&our_bytes, "__DATA_CONST", "__got").is_none());
 +    assert!(output_section(&apple_bytes, "__DATA_CONST", "__got").is_none());
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(7),
 +        "expected hidden GOT executable to exit 7"
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_partitions_symtab_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
++
 +    let dylib = scratch("symtab-partition.dylib");
 +    let obj = scratch("symtab-partition.o");
 +    let our_out = scratch("symtab-partition-ours.out");
 +    let apple_out = scratch("symtab-partition-apple.out");
++
 +    let dylib_src = r#"
 +        int ext_data = 5;
 +    "#;
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let asm = r#"
 +        .text
 +        .private_extern _hidden
 +        .globl _visible
 +        .globl _main
 +        .p2align 2
 +    _local:
 +        ret
 +    _hidden:
 +        ret
 +    _visible:
 +        ret
 +    _main:
 +        ret
++
 +        .data
 +        .quad _ext_data
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), dylib.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args(["ld", "-arch", "arm64", "-e", "_main", "-o"])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&dylib)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let (our_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 +    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
++
 +    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 +    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 +    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 +    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 +    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 +    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 +    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
 +    assert_eq!(
 +        canonical_symbol_records(&our_bytes),
 +        canonical_symbol_records(&apple_bytes)
 +    );
 +    assert_strtab_within_five_percent(
 +        &raw_string_table(&our_bytes),
 +        &raw_string_table(&apple_bytes),
 +    );
++
 +    assert_eq!(
 +        symbol_partition_names(&our_bytes),
 +        symbol_partition_names(&apple_bytes)
 +    );
++
 +    let _ = fs::remove_file(dylib);
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_strips_locals_with_x_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
++
 +    let dylib = scratch("symtab-strip.dylib");
 +    let obj = scratch("symtab-strip.o");
 +    let our_out = scratch("symtab-strip-ours.out");
 +    let apple_out = scratch("symtab-strip-apple.out");
++
 +    let dylib_src = r#"
 +        int ext_data = 5;
 +    "#;
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let asm = r#"
 +        .text
 +        .private_extern _hidden
 +        .globl _visible
 +        .globl _main
 +        .p2align 2
 +    _local:
 +        ret
 +    _hidden:
 +        ret
 +    _visible:
 +        ret
 +    _main:
 +        ret
++
 +        .data
 +        .quad _ext_data
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
+     }
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), dylib.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        strip_locals: true,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args(["ld", "-arch", "arm64", "-x", "-e", "_main", "-o"])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&dylib)
 +        .output()
 +        .unwrap();
      assert!(
 -        failures.is_empty(),
 -        "Apple ld parity failures ({} cases):\n{}",
 -        failures.len(),
 -        failures.join("\n\n")
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let (our_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 +    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
++
 +    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 +    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 +    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 +    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 +    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 +    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 +    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
 +    assert_eq!(
 +        canonical_symbol_records(&our_bytes),
 +        canonical_symbol_records(&apple_bytes)
 +    );
++
 +    let (locals, extdefs, undefs) = symbol_partition_names(&our_bytes);
 +    assert!(locals.is_empty());
 +    assert_eq!(
 +        extdefs,
 +        vec![
 +            "__mh_execute_header".to_string(),
 +            "_main".to_string(),
 +            "_visible".to_string()
 +        ]
 +    );
 +    assert_eq!(undefs, vec!["_ext_data".to_string()]);
++
 +    let _ = fs::remove_file(dylib);
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_emits_leaf_unwind_info_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let obj = scratch("unwind-leaf.o");
 +    let our_out = scratch("unwind-leaf-ours.out");
 +    let apple_out = scratch("unwind-leaf-apple.out");
 +    let src = r#"
 +        int main(void) {
 +            return 0;
 +        }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
 +    );
 +    assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_emits_multi_function_unwind_info_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
 +        return;
 +    }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
++
 +    let obj = scratch("unwind-mixed.o");
 +    let our_out = scratch("unwind-mixed-ours.out");
 +    let apple_out = scratch("unwind-mixed-apple.out");
 +    let src = r#"
 +        int helper(void) {
 +            return 1;
 +        }
++
 +        int main(void) {
 +            return helper();
 +        }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
 +    }
++
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
      );
 +    assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_rejects_out_of_range_branch26() {
 +fn linker_run_dead_strip_prunes_unused_unwind_records_like_ld() {
      if !have_xcrun() {
 -        eprintln!("skipping: xcrun as unavailable");
 +        eprintln!("skipping: xcrun unavailable");
          return;
+     }
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 -    let obj = scratch("branch26-range.o");
 -    let out = scratch("branch26-range.out");
 +    let obj = scratch("unwind-dead-strip.o");
 +    let our_out = scratch("unwind-dead-strip-ours.out");
 +    let apple_out = scratch("unwind-dead-strip-apple.out");
      let src = r#"
 -        .section __TEXT,__text,regular,pure_instructions
 -        .globl _main
 -        _main:
 -            bl _helper
 -            ret
 +        int helper(void) {
 +            return 1;
 +        }
 -        .zerofill __DATA,__bss,_gap,0x9000000,0
 +        int unused(void) {
 +            return 2;
 +        }
 -        .section __FAR,__text,regular,pure_instructions
 -        .globl _helper
 -        _helper:
 -            ret
 -        .subsections_via_symbols
 +        int main(void) {
 +            return helper();
 +        }
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 -        eprintln!("skipping: assemble failed: {e}");
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
          inputs: vec![obj.clone()],
 -        output: Some(out),
 +        output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        dead_strip: true,
          ..LinkOptions::default()
      };
 -    let err = Linker::run(&opts).unwrap_err();
 -    match err {
 -        LinkError::Reloc(err) => {
 -            let msg = err.to_string();
 -            assert!(msg.contains("Branch26"), "{msg}");
 -            assert!(msg.contains("out of BRANCH26 range"), "{msg}");
 -            assert!(msg.contains("_helper"), "{msg}");
 -        }
 -        other => panic!("expected Reloc error, got {other:?}"),
 -    }
 +    Linker::run(&opts).unwrap();
 +    apple_link_with_args(&obj, &apple_out, "_main", &sdk, &sdk_ver, &["-dead_strip"]).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();
 +    let normalize = |records: &[afs_ld::synth::unwind::DecodedUnwindRecord]| {
 +        let base = records
 +            .first()
 +            .map(|record| record.function_offset)
 +            .unwrap_or(0);
 +        records
 +            .iter()
 +            .map(|record| (record.function_offset - base, record.encoding))
 +            .collect::<Vec<_>>()
 +    };
 +    assert_eq!(
 +        normalize(&our_decoded.records),
 +        normalize(&apple_decoded.records)
 +    );
 +    assert_eq!(our_decoded.records.len(), 2);
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_routes_dylib_imports_through_synthetic_sections() {
 +fn linker_run_handles_large_unwind_function_gaps() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("import-reloc.o");
 -    let out = scratch("import-reloc.out");
 -    let src = r#"
 -        .section __TEXT,__text,regular,pure_instructions
 +    let obj = scratch("unwind-gap.o");
 +    let out = scratch("unwind-gap-ours.out");
 +    let asm = r#"
 +        .text
          .globl _main
 -        _main:
 -            adrp x0, _write@GOTPAGE
 -            ldr x0, [x0, _write@GOTPAGEOFF]
 -            bl _write
 -            ret
 +        .p2align 2
 +    _main:
 +        .cfi_startproc
 +        bl _helper
 +        ret
 +        .cfi_endproc
 +        .space 0x1000010
 +        .globl _helper
 +        .p2align 2
 +    _helper:
 +        .cfi_startproc
 +        ret
 +        .cfi_endproc
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(asm, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone()],
 +        inputs: vec![obj.clone()],
          output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      Linker::run(&opts).unwrap();
      let bytes = fs::read(&out).unwrap();
 -    let header = parse_header(&bytes).unwrap();
 -    let commands = parse_commands(&header, &bytes).unwrap();
 -    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();
 -    let (stubs_addr, stubs) = output_section(&bytes, "__TEXT", "__stubs").unwrap();
 -    let (helper_addr, helper) = output_section(&bytes, "__TEXT", "__stub_helper").unwrap();
 -    let (got_addr, got) = output_section(&bytes, "__DATA_CONST", "__got").unwrap();
 -    let (lazy_addr, lazy) = output_section(&bytes, "__DATA", "__la_symbol_ptr").unwrap();
 -    let (dyld_private_addr, _) = output_section(&bytes, "__DATA", "__data").unwrap();
 -    let stubs_hdr = output_section_header(&bytes, "__TEXT", "__stubs").unwrap();
 -    let got_hdr = output_section_header(&bytes, "__DATA_CONST", "__got").unwrap();
 -    let lazy_hdr = output_section_header(&bytes, "__DATA", "__la_symbol_ptr").unwrap();
+-
 -    let symtab = commands
 -        .iter()
 -        .find_map(|cmd| match cmd {
 -            LoadCommand::Symtab(cmd) => Some(*cmd),
 -            _ => None,
 -        })
 -        .unwrap();
 -    let dysymtab = commands
 -        .iter()
 -        .find_map(|cmd| match cmd {
 -            LoadCommand::Dysymtab(cmd) => Some(*cmd),
 -            _ => None,
 -        })
 -        .unwrap();
 -    let dyld_info = commands
 -        .iter()
 -        .find_map(|cmd| match cmd {
 -            LoadCommand::DyldInfoOnly(cmd) => Some(*cmd),
 -            _ => None,
 -        })
 -        .unwrap();
 -    let libsystem_load = commands
 -        .iter()
 -        .find_map(|cmd| match cmd {
 -            LoadCommand::Dylib(cmd)
 -                if cmd.cmd == afs_ld::macho::constants::LC_LOAD_DYLIB
 -                    && cmd.name == "/usr/lib/libSystem.B.dylib" =>
 -            {
 -                Some(cmd.clone())
 -            }
 -            _ => None,
 -        })
 -        .unwrap();
 -    let symbols = parse_nlist_table(&bytes, symtab.symoff, symtab.nsyms).unwrap();
 -    let strings = StringTable::from_file(&bytes, symtab.stroff, symtab.strsize).unwrap();
 -    let symbol_names: Vec<&str> = symbols
 -        .iter()
 -        .map(|symbol| strings.get(symbol.strx()).unwrap())
 -        .collect();
+-
 -    assert_eq!(got.len(), 16);
 -    assert_eq!(stubs.len(), 12);
 -    assert_eq!(helper.len(), 36);
 -    assert_eq!(lazy.len(), 8);
 -    assert_eq!(symtab.nsyms, 5);
 -    assert_eq!(dysymtab.nlocalsym, 1);
 -    assert_eq!(dysymtab.nextdefsym, 2);
 -    assert_eq!(dysymtab.nundefsym, 2);
 -    assert_eq!(dysymtab.nindirectsyms, 4);
 -    assert_eq!(stubs_hdr.reserved1, 0);
 -    assert_eq!(got_hdr.reserved1, 1);
 -    assert_eq!(lazy_hdr.reserved1, 3);
 -    assert_eq!(stubs_hdr.reserved2, 12);
 -    assert!(libsystem_load.current_version >= (1 << 16));
 -    assert_eq!(libsystem_load.compatibility_version, 1 << 16);
 -    assert!(dyld_info.rebase_size > 0);
 -    assert!(dyld_info.bind_size > 0);
 -    assert!(dyld_info.lazy_bind_size > 0);
 -    assert_eq!(
 -        decode_page_reference(&text, text_addr, 0, &PageRefKind::Load).unwrap(),
 -        got_addr
 -    );
 -    assert_eq!(
 -        decode_branch_target(&text, text_addr, 8).unwrap(),
 -        stubs_addr
 -    );
 -    assert_eq!(
 -        decode_page_reference(&stubs, stubs_addr, 0, &PageRefKind::Load).unwrap(),
 -        lazy_addr
 -    );
 -    assert_eq!(read_insn(&stubs, 8).unwrap(), 0xd61f0200);
 -    assert_eq!(
 -        u64::from_le_bytes(lazy[0..8].try_into().unwrap()),
 -        helper_addr + 24
 -    );
 -    assert_eq!(
 -        decode_page_reference(&helper, helper_addr, 0, &PageRefKind::Add).unwrap(),
 -        dyld_private_addr
 -    );
 -    assert_eq!(
 -        decode_page_reference(&helper, helper_addr, 12, &PageRefKind::Load).unwrap(),
 -        got_addr + 8
 -    );
 -    assert_eq!(read_insn(&helper, 20).unwrap(), 0xd61f0200);
 -    assert_eq!(read_insn(&helper, 24).unwrap(), 0x1800_0050);
 -    assert_eq!(
 -        decode_branch_target(&helper, helper_addr, 28).unwrap(),
 -        helper_addr
 -    );
 -    assert_eq!(u32::from_le_bytes(helper[32..36].try_into().unwrap()), 0);
 -    let (locals, extdefs, undefs) = symbol_partition_names(&bytes);
 -    assert_eq!(locals, vec!["__dyld_private".to_string()]);
 -    assert_eq!(
 -        extdefs,
 -        vec!["__mh_execute_header".to_string(), "_main".to_string()]
 -    );
 -    assert_eq!(
 -        undefs,
 -        vec!["_write".to_string(), "dyld_stub_binder".to_string()]
 +    let (_, unwind) = output_section(&bytes, "__TEXT", "__unwind_info").unwrap();
 +    let decoded = decode_unwind_info(&unwind).unwrap();
 +    assert!(
 +        decoded
 +            .records
 +            .windows(2)
 +            .all(|pair| pair[0].function_offset < pair[1].function_offset),
 +        "expected strictly ascending unwind records after large-gap pagination"
      );
 -    assert!(symbol_names.contains(&"__dyld_private"));
 -    assert!(symbols[dysymtab.iundefsym as usize..]
 -        .iter()
 -        .all(|symbol| symbol.kind() == SymKind::Undef));
 -    assert!(symbols[dysymtab.iundefsym as usize..]
 -        .iter()
 -        .all(|symbol| symbol.library_ordinal().unwrap() > 0));
 -    assert!(symbol_names.contains(&"_write"));
 -    assert!(symbol_names.contains(&"dyld_stub_binder"));
 -    let _ = fs::remove_file(out);
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(out);
+ }
  #[test]
 -fn synthetic_import_surfaces_match_apple_ld_classic_lazy_model() {
 -    if !have_xcrun() || !have_xcrun_tool("ld") {
 -        eprintln!("skipping: xcrun as/ld unavailable");
 +fn linker_run_preserves_eh_frame_like_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("dwarfdump") {
 +        eprintln!("skipping: xcrun dwarfdump unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          eprintln!("skipping: xcrun --show-sdk-version unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("import-parity.o");
 -    let our_out = scratch("import-parity-ours.out");
 -    let apple_out = scratch("import-parity-apple.out");
 -    let src = r#"
 -        .section __TEXT,__text,regular,pure_instructions
 -        .globl _main
 -        _main:
 -            adrp x0, _write@GOTPAGE
 -            ldr x0, [x0, _write@GOTPAGEOFF]
 -            bl _write
 -            ret
 +    let obj = scratch("eh-frame.o");
 +    let our_out = scratch("eh-frame-ours.out");
 +    let apple_out = scratch("eh-frame-apple.out");
 +    let asm = r#"
 +        .text
 +        .globl _main
 +        .p2align 2
 +    _main:
 +        .cfi_startproc
 +        sub sp, sp, #16
 +        .cfi_def_cfa_offset 16
 +        str x30, [sp, #8]
 +        .cfi_offset w30, -8
 +        bl _helper
 +        ldr x30, [sp, #8]
 +        add sp, sp, #16
 +        ret
 +        .cfi_endproc
++
 +        .globl _helper
 +        .p2align 2
 +    _helper:
 +        .cfi_startproc
 +        ret
 +        .cfi_endproc
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(asm, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
+-
 -    for (segname, sectname) in [("__TEXT", "__stubs"), ("__TEXT", "__stub_helper")] {
 -        let (_, ours) = output_section(&our_bytes, segname, sectname).unwrap();
 -        let (_, apple) = output_section(&apple_bytes, segname, sectname).unwrap();
 -        let diff = diff_macho(&ours, &apple);
 -        assert!(
 -            diff.is_clean(),
 -            "{segname},{sectname} diverged from Apple ld: {:#?}",
 -            diff.critical
 -        );
 -    }
+-
 -    let (our_helper_addr, _) = output_section(&our_bytes, "__TEXT", "__stub_helper").unwrap();
 -    let (apple_helper_addr, _) = output_section(&apple_bytes, "__TEXT", "__stub_helper").unwrap();
 -    let (_, our_lazy) = output_section(&our_bytes, "__DATA", "__la_symbol_ptr").unwrap();
 -    let (_, apple_lazy) = output_section(&apple_bytes, "__DATA", "__la_symbol_ptr").unwrap();
 -    assert_eq!(
 -        u64::from_le_bytes(our_lazy[0..8].try_into().unwrap()) - our_helper_addr,
 -        24
 -    );
 -    assert_eq!(
 -        u64::from_le_bytes(apple_lazy[0..8].try_into().unwrap()) - apple_helper_addr,
 -        24
 -    );
+-
 -    assert_eq!(
 -        load_dylib_names(&our_bytes).unwrap(),
 -        load_dylib_names(&apple_bytes).unwrap()
 -    );
 -    assert_eq!(
 -        segment_flags(&our_bytes, "__DATA_CONST"),
 -        Some(SG_READ_ONLY)
 -    );
 -    assert_eq!(
 -        segment_flags(&our_bytes, "__DATA_CONST"),
 -        segment_flags(&apple_bytes, "__DATA_CONST")
 -    );
+-
 -    let our_rebases = decode_rebase_records(&our_bytes).unwrap();
 -    let apple_rebases = decode_rebase_records(&apple_bytes).unwrap();
 -    assert!(our_rebases
 -        .iter()
 -        .all(|record| record.rebase_type == REBASE_TYPE_POINTER));
 -    assert_eq!(our_rebases, apple_rebases);
 -    assert_eq!(
 -        decode_bind_records(&our_bytes, false).unwrap(),
 -        decode_bind_records(&apple_bytes, false).unwrap()
 -    );
 -    assert_eq!(
 -        dyld_info_stream(&our_bytes, DyldInfoStreamKind::WeakBind).unwrap(),
 -        dyld_info_stream(&apple_bytes, DyldInfoStreamKind::WeakBind).unwrap()
 -    );
 -    assert_eq!(
 -        decode_bind_records(&our_bytes, true).unwrap(),
 -        decode_bind_records(&apple_bytes, true).unwrap()
 -    );
 -    assert_eq!(
 -        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 -        canonical_lazy_bind_stream(&apple_bytes).unwrap()
 -    );
 +    assert!(output_section(&our_bytes, "__TEXT", "__eh_frame").is_some());
      assert_eq!(
 -        indirect_symbol_table(&our_bytes),
 -        indirect_symbol_table(&apple_bytes)
 +        output_section(&our_bytes, "__TEXT", "__eh_frame")
 +            .unwrap()
 +            .1
 +            .len(),
 +        output_section(&apple_bytes, "__TEXT", "__eh_frame")
 +            .unwrap()
 +            .1
 +            .len()
      );
 +    let our_dump = normalized_eh_frame_dump(
 +        &our_out,
 +        output_section(&our_bytes, "__TEXT", "__text").unwrap().0,
 +    )
 +    .unwrap();
 +    let apple_dump = normalized_eh_frame_dump(
 +        &apple_out,
 +        output_section(&apple_bytes, "__TEXT", "__text").unwrap().0,
 +    )
 +    .unwrap();
 +    assert_eq!(our_dump, apple_dump);
 -    let _ = fs::remove_file(apple_out);
 -    let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn classic_lazy_surfaces_match_apple_ld_across_fixture_matrix() {
 -    if !have_xcrun() || !have_xcrun_tool("ld") {
 -        eprintln!("skipping: xcrun as/ld unavailable");
 +fn linker_run_dead_strip_preserves_pruned_eh_frame_like_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("dwarfdump") {
 +        eprintln!("skipping: xcrun dwarfdump unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          return;
      };
 -    let cases = [
 -        ClassicLazyParityCase {
 -            name: "single-got-and-call",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    adrp x0, _write@GOTPAGE
 -                    ldr x0, [x0, _write@GOTPAGEOFF]
 -                    bl _write
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -        },
 -        ClassicLazyParityCase {
 -            name: "batched-got-and-calls",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    adrp x0, _write@GOTPAGE
 -                    ldr x0, [x0, _write@GOTPAGEOFF]
 -                    bl _write
 -                    adrp x1, _close@GOTPAGE
 -                    ldr x1, [x1, _close@GOTPAGEOFF]
 -                    bl _close
 -                    adrp x2, _read@GOTPAGE
 -                    ldr x2, [x2, _read@GOTPAGEOFF]
 -                    bl _read
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -        },
 -        ClassicLazyParityCase {
 -            name: "branch-only-calls",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    bl _write
 -                    bl _close
 -                    bl _read
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -        },
 -        ClassicLazyParityCase {
 -            name: "deduped-import",
 -            src: r#"
 -                .section __TEXT,__text,regular,pure_instructions
 -                .globl _main
 -                _main:
 -                    adrp x0, _write@GOTPAGE
 -                    ldr x0, [x0, _write@GOTPAGEOFF]
 -                    bl _write
 -                    bl _write
 -                    adrp x1, _write@GOTPAGE
 -                    ldr x1, [x1, _write@GOTPAGEOFF]
 -                    ret
 -                .subsections_via_symbols
 -            "#,
 -        },
 -    ];
 +    let obj = scratch("eh-frame-dead-strip.o");
 +    let our_out = scratch("eh-frame-dead-strip-ours.out");
 +    let apple_out = scratch("eh-frame-dead-strip-apple.out");
 +    let asm = r#"
 +        .text
 +        .globl _main
 +        .p2align 2
 +    _main:
 +        .cfi_startproc
 +        sub sp, sp, #16
 +        .cfi_def_cfa_offset 16
 +        str x30, [sp, #8]
 +        .cfi_offset w30, -8
 +        bl _helper
 +        ldr x30, [sp, #8]
 +        add sp, sp, #16
 +        ret
 +        .cfi_endproc
 -    let mut failures = Vec::new();
 -    for case in &cases {
 -        if let Err(err) = assert_classic_lazy_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 -            failures.push(err);
 -        }
 +        .globl _helper
 +        .p2align 2
 +    _helper:
 +        .cfi_startproc
 +        sub sp, sp, #16
 +        .cfi_def_cfa_offset 16
 +        str x30, [sp, #8]
 +        .cfi_offset w30, -8
 +        ldr x30, [sp, #8]
 +        add sp, sp, #16
 +        ret
 +        .cfi_endproc
++
 +        .globl _unused
 +        .p2align 2
 +    _unused:
 +        .cfi_startproc
 +        sub sp, sp, #16
 +        .cfi_def_cfa_offset 16
 +        str x30, [sp, #8]
 +        .cfi_offset w30, -8
 +        ldr x30, [sp, #8]
 +        add sp, sp, #16
 +        ret
 +        .cfi_endproc
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        return;
+     }
 -    assert!(
 -        failures.is_empty(),
 -        "Apple ld classic-lazy parity failures ({} cases):\n{}",
 -        failures.len(),
 -        failures.join("\n\n")
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        dead_strip: true,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_with_args(&obj, &apple_out, "_main", &sdk, &sdk_ver, &["-dead_strip"]).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert!(output_section(&our_bytes, "__TEXT", "__eh_frame").is_some());
 +    assert_eq!(
 +        output_section(&our_bytes, "__TEXT", "__eh_frame")
 +            .unwrap()
 +            .1
 +            .len(),
 +        output_section(&apple_bytes, "__TEXT", "__eh_frame")
 +            .unwrap()
 +            .1
 +            .len()
      );
 +    let our_dump = normalized_eh_frame_dump(
 +        &our_out,
 +        output_section(&our_bytes, "__TEXT", "__text").unwrap().0,
 +    )
 +    .unwrap();
 +    let apple_dump = normalized_eh_frame_dump(
 +        &apple_out,
 +        output_section(&apple_bytes, "__TEXT", "__text").unwrap().0,
 +    )
 +    .unwrap();
 +    assert_eq!(our_dump, apple_dump);
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_binds_direct_dylib_import_pointers() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun clang or codesign unavailable");
 +fn linker_run_emits_backtrace_metadata_like_apple_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          return;
+     }
 -    let dylib_src = r#"
 -        int ext_data = 5;
 +    let obj = scratch("unwind-backtrace.o");
 +    let our_out = scratch("unwind-backtrace-ours.out");
 +    let apple_out = scratch("unwind-backtrace-apple.out");
 +    let src = r#"
 +        #include <unwind.h>
++
 +        static _Unwind_Reason_Code cb(struct _Unwind_Context* ctx, void* arg) {
 +            (void)ctx;
 +            int* count = (int*)arg;
 +            (*count)++;
 +            return *count >= 8 ? _URC_END_OF_STACK : _URC_NO_REASON;
 +        }
++
 +        __attribute__((noinline)) int helper(void) {
 +            int count = 0;
 +            _Unwind_Backtrace(cb, &count);
 +            return count;
 +        }
++
 +        int main(void) {
 +            return helper() > 1 ? 0 : 1;
 +        }
      "#;
 -    let direct_case = DirectBindParityCase {
 -        name: "direct-data",
 -        dylib_src,
 -        main_src: r#"
 -            extern int ext_data;
 -            int *p = &ext_data;
 -            int main(void) { return *p == 5 ? 0 : 1; }
 -        "#,
 -    };
 -    if let Err(e) = assert_direct_bind_case_matches_apple_ld(&direct_case, &sdk, &sdk_ver) {
 -        panic!("{e}");
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
+     }
 -    let dylib = scratch("direct-data.dylib");
 -    let obj = scratch("direct-data.o");
 -    let our_out = scratch("direct-data-ours.out");
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        rebased_unwind_bytes(&our_bytes),
 +        rebased_unwind_bytes(&apple_bytes)
 +    );
 +    assert_eq!(
 +        normalize_function_start_offsets(&decode_function_starts(&our_bytes)),
 +        normalize_function_start_offsets(&decode_function_starts(&apple_bytes))
 +    );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_preserves_exception_unwind_metadata_like_apple_ld() {
 +    if !have_xcrun() || !have_xcrun_tool("clang++") || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun clang++ or codesign unavailable");
          return;
+     }
 -    let main_src = r#"
 -        extern int ext_data;
 -        int *p = &ext_data;
 -        int main(void) { return *p == 5 ? 0 : 1; }
 +    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_c(main_src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 +    if let Err(e) = compile_cxx(src, &obj) {
 +        eprintln!("skipping: clang++ compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone(), dylib.clone()],
 +        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 binds = decode_bind_records(&our_bytes, false).unwrap();
 -    assert!(
 -        binds.iter().any(|record| {
 -            record.segment == "__DATA"
 -                && record.section == "__data"
 -                && record.section_offset == 0
 -                && record.symbol == "_ext_data"
 -        }),
 -        "missing direct bind for imported data: {binds:#?}"
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap()
      );
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&our_out)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, true).unwrap(),
 +        decode_bind_records(&apple_bytes, true).unwrap()
      );
 -    let status = Command::new(&our_out).status().unwrap();
      assert_eq!(
 -        status.code(),
 -        Some(0),
 -        "expected direct-import pointer executable to exit 0"
 +        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 +        canonical_lazy_bind_stream(&apple_bytes).unwrap()
      );
 +    let our_decoded = canonical_unwind_info(&our_bytes);
 +    let apple_decoded = canonical_unwind_info(&apple_bytes);
 +    assert_eq!(our_decoded, apple_decoded);
 +    assert_eq!(our_decoded.personalities.len(), 1);
 +    assert_eq!(our_decoded.lsdas.len(), 1);
 +    assert!(output_section(&our_bytes, "__TEXT", "__gcc_except_tab").is_some());
 +    let our_status = Command::new(&our_out).status().unwrap();
 +    let apple_status = Command::new(&apple_out).status().unwrap();
 +    assert_eq!(our_status.code(), Some(42));
 +    assert_eq!(apple_status.code(), Some(42));
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn direct_bind_surfaces_match_apple_ld_across_fixture_matrix() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun clang or codesign unavailable");
 +fn linker_run_resolves_backtrace_symbols_at_runtime() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          eprintln!("skipping: xcrun --show-sdk-version unavailable");
          return;
      };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
 -    let cases = [
 -        DirectBindParityCase {
 -            name: "direct-multi-data",
 -            dylib_src: r#"
 -                int ext_data = 5;
 -                int more_data = 9;
 -            "#,
 -            main_src: r#"
 -                extern int ext_data;
 -                extern int more_data;
 -                int *p = &ext_data;
 -                int *q = &more_data;
 -                int main(void) { return (*p == 5 && *q == 9) ? 0 : 1; }
 -            "#,
 -        },
 -        DirectBindParityCase {
 -            name: "direct-and-call-mixed",
 -            dylib_src: r#"
 -                int ext_data = 5;
 -                int ext_fn(void) { return ext_data + 1; }
 -            "#,
 -            main_src: r#"
 -                extern int ext_data;
 -                extern int ext_fn(void);
 -                int *p = &ext_data;
 -                int main(void) { return *p + ext_fn() == 11 ? 0 : 1; }
 -            "#,
 -        },
 -        DirectBindParityCase {
 -            name: "direct-deduped",
 -            dylib_src: r#"
 -                int ext_data = 5;
 -            "#,
 -            main_src: r#"
 -                extern int ext_data;
 -                int *p = &ext_data;
 -                int *q = &ext_data;
 -                int main(void) { return (*p == 5 && *q == 5) ? 0 : 1; }
 -            "#,
 -        },
 -    ];
 +    let obj = scratch("execinfo-backtrace.o");
 +    let our_out = scratch("execinfo-backtrace-ours.out");
 +    let apple_out = scratch("execinfo-backtrace-apple.out");
 +    let src = r#"
 +        #include <execinfo.h>
 +        #include <stdio.h>
 +        #include <stdlib.h>
 +        #include <string.h>
 -    let mut failures = Vec::new();
 -    for case in &cases {
 -        if let Err(err) = assert_direct_bind_case_matches_apple_ld(case, &sdk, &sdk_ver) {
 -            failures.push(err);
 +        __attribute__((noinline)) int helper(void) {
 +            void *frames[8];
 +            int n = backtrace(frames, 8);
 +            char **syms = backtrace_symbols(frames, n);
 +            int saw_helper = 0;
 +            int saw_main = 0;
 +            if (!syms) return 2;
 +            for (int i = 0; i < n; i++) {
 +                puts(syms[i]);
 +                saw_helper |= strstr(syms[i], "helper") != NULL;
 +                saw_main |= strstr(syms[i], "main") != NULL;
 +            }
 +            free(syms);
 +            return (saw_helper && saw_main) ? 0 : 1;
 +        }
++
 +        int main(void) {
 +            return helper();
+         }
 +    "#;
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: clang compile failed: {e}");
 +        return;
+     }
 +    let opts = LinkOptions {
 +        inputs: vec![obj.clone(), tbd],
 +        output: Some(our_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_output = Command::new(&our_out).output().unwrap();
 +    let apple_output = Command::new(&apple_out).output().unwrap();
 +    let our_stdout = String::from_utf8_lossy(&our_output.stdout);
 +    let apple_stdout = String::from_utf8_lossy(&apple_output.stdout);
++
 +    assert_eq!(our_output.status.code(), Some(0));
 +    assert_eq!(apple_output.status.code(), Some(0));
      assert!(
 -        failures.is_empty(),
 -        "Apple ld direct-bind parity failures ({} cases):\n{}",
 -        failures.len(),
 -        failures.join("\n\n")
 +        our_stdout.contains("helper"),
 +        "expected helper in output: {our_stdout}"
 +    );
 +    assert!(
 +        our_stdout.contains("main"),
 +        "expected main in output: {our_stdout}"
 +    );
 +    assert!(
 +        apple_stdout.contains("helper"),
 +        "expected helper in apple output: {apple_stdout}"
 +    );
 +    assert!(
 +        apple_stdout.contains("main"),
 +        "expected main in apple output: {apple_stdout}"
      );
++
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_rebases_local_absolute_pointers_like_ld() {
 +fn linker_run_emits_function_starts_like_ld() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
          return;
+     }
 -    let obj = scratch("local-rebase.o");
 -    let our_out = scratch("local-rebase-ours.out");
 -    let apple_out = scratch("local-rebase-apple.out");
 -    let src = r#"
 -        int ext = 7;
 -        int *p = &ext;
 -        int main(void) { return *p == 7 ? 0 : 1; }
 +    let obj = scratch("function-starts.o");
 +    let our_out = scratch("function-starts-ours.out");
 +    let apple_out = scratch("function-starts-apple.out");
 +    let asm = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        .p2align 2
 +    _main:
 +        adrp x0, _write@GOTPAGE
 +        ldr x0, [x0, _write@GOTPAGEOFF]
 +        bl _write
 +        ret
 +        .subsections_via_symbols
      "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: clang compile failed: {e}");
 +    if let Err(e) = assemble(asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 -    assert!(!dyld_info_stream(&our_bytes, DyldInfoStreamKind::Rebase)
 -        .unwrap()
 -        .is_empty());
 +    let our_fstarts = raw_linkedit_data_cmd(&our_bytes, LC_FUNCTION_STARTS);
 +    let apple_fstarts = raw_linkedit_data_cmd(&apple_bytes, LC_FUNCTION_STARTS);
 +    assert_ne!(our_fstarts.0, 0);
 +    assert_eq!(our_fstarts.1, apple_fstarts.1);
 +    assert_eq!(our_fstarts.1, 8);
 +    assert!(output_section(&our_bytes, "__TEXT", "__stubs").is_some());
 +    assert!(output_section(&our_bytes, "__TEXT", "__stub_helper").is_some());
 +    assert_eq!(decode_function_starts(&our_bytes).len(), 1);
 +    assert_eq!(decode_function_starts(&apple_bytes).len(), 1);
 +    let our_text_addr = output_section(&our_bytes, "__TEXT", "__text").unwrap().0;
 +    let apple_text_addr = output_section(&apple_bytes, "__TEXT", "__text").unwrap().0;
 +    let our_text_base = segment_vmaddr(&our_bytes, "__TEXT").unwrap();
 +    let apple_text_base = segment_vmaddr(&apple_bytes, "__TEXT").unwrap();
      assert_eq!(
 -        dyld_info_stream(&our_bytes, DyldInfoStreamKind::Rebase).unwrap(),
 -        dyld_info_stream(&apple_bytes, DyldInfoStreamKind::Rebase).unwrap()
 +        decode_function_starts(&our_bytes),
 +        vec![our_text_addr - our_text_base]
      );
      assert_eq!(
 -        decode_rebase_records(&our_bytes).unwrap(),
 -        decode_rebase_records(&apple_bytes).unwrap()
 +        decode_function_starts(&apple_bytes),
 +        vec![apple_text_addr - apple_text_base]
      );
 -    let our_status = Command::new(&our_out).status().unwrap();
 -    let apple_status = Command::new(&apple_out).status().unwrap();
 -    assert_eq!(our_status.code(), Some(0));
 -    assert_eq!(apple_status.code(), Some(0));
 +    let our_dic = raw_linkedit_data_cmd(&our_bytes, LC_DATA_IN_CODE);
 +    let apple_dic = raw_linkedit_data_cmd(&apple_bytes, LC_DATA_IN_CODE);
 +    assert_ne!(our_dic.0, 0);
 +    assert_eq!(our_dic.1, apple_dic.1);
 +    assert_eq!(our_dic.0, our_fstarts.0 + our_fstarts.1);
 +    assert_eq!(apple_dic.0, apple_fstarts.0 + apple_fstarts.1);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
+ }
  #[test]
 -fn linker_run_routes_local_got_loads_through_rebased_slots() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun or codesign unavailable");
 +fn linker_run_emits_function_starts_for_other_text_sections_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          eprintln!("skipping: xcrun --show-sdk-version unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("local-got.o");
 -    let our_out = scratch("local-got-ours.out");
 -    let apple_out = scratch("local-got-apple.out");
 -    let src = r#"
 +    let obj = scratch("function-starts-textcoal.o");
 +    let our_out = scratch("function-starts-textcoal-ours.out");
 +    let apple_out = scratch("function-starts-textcoal-apple.out");
 +    let asm = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        _main:
 -            adrp x8, _value@GOTPAGE
 -            ldr x8, [x8, _value@GOTPAGEOFF]
 -            ldr w0, [x8]
 -            ret
 +        .p2align 2
 +    _main:
 +        ret
 -        .section __DATA,__data
 -        .globl _value
 +        .section __TEXT,__textcoal_nt,regular,pure_instructions
 +        .globl _helper
          .p2align 2
 -        _value:
 -            .long 7
 +    _helper:
 +        ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(asm, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone()],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 -    let our_binds = decode_bind_records(&our_bytes, false).unwrap();
 -    let apple_binds = decode_bind_records(&apple_bytes, false).unwrap();
 -    assert_eq!(our_binds, apple_binds);
 -    assert!(
 -        our_binds.iter().all(|record| record.symbol != "_value"),
 -        "local GOT target should not be emitted as a dylib bind: {our_binds:#?}"
 -    );
 -    assert_eq!(
 -        output_section(&our_bytes, "__DATA_CONST", "__got")
 -            .expect("missing __got section")
 -            .1
 -            .len(),
 -        8
 -    );
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&our_out)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 -    );
 -    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(decode_function_starts(&our_bytes).len(), 2);
 +    assert_eq!(decode_function_starts(&apple_bytes).len(), 2);
++
 +    let our_text_addr = output_section(&our_bytes, "__TEXT", "__text").unwrap().0;
 +    let our_textcoal_addr = output_section(&our_bytes, "__TEXT", "__textcoal_nt")
 +        .unwrap()
 +        .0;
 +    let our_text_base = segment_vmaddr(&our_bytes, "__TEXT").unwrap();
      assert_eq!(
 -        status.code(),
 -        Some(7),
 -        "expected local GOT executable to exit 7"
 +        decode_function_starts(&our_bytes),
 +        vec![
 +            our_text_addr - our_text_base,
 +            our_textcoal_addr - our_text_base
 +        ]
      );
      let _ = fs::remove_file(obj);
+ }
  #[test]
 -fn linker_run_relaxes_hidden_got_loads_like_apple_ld() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun or codesign unavailable");
 +fn linker_run_remaps_data_in_code_like_ld() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
+     }
      let Some(sdk) = sdk_path() else {
          return;
+     }
 -    let obj = scratch("hidden-got.o");
 -    let our_out = scratch("hidden-got-ours.out");
 -    let apple_out = scratch("hidden-got-apple.out");
 -    let src = r#"
 -        .section __TEXT,__text,regular,pure_instructions
 +    let obj = scratch("data-in-code.o");
 +    let our_out = scratch("data-in-code-ours.out");
 +    let apple_out = scratch("data-in-code-apple.out");
 +    let asm = r#"
 +        .text
          .globl _main
 -        _main:
 -            adrp x8, _value@GOTPAGE
 -            ldr x8, [x8, _value@GOTPAGEOFF]
 -            ldr w0, [x8]
 -            ret
+-
 -        .private_extern _value
 -        .section __DATA,__data
          .p2align 2
 -        _value:
 -            .long 7
 +    _main:
 +        mov w0, #0
 +        b Ldispatch
 +        .p2align 2
 +    Ltable:
 +        .data_region jt32
 +        .long Lcase0-Ltable
 +        .long Lcase1-Ltable
 +        .end_data_region
 +    Ldispatch:
 +        cmp w0, #0
 +        b.eq Lcase0
 +        b Lcase1
 +    Lcase0:
 +        mov w0, #1
 +        ret
 +    Lcase1:
 +        mov w0, #2
 +        ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(src, &obj) {
 +    if let Err(e) = assemble(asm, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 -        ..LinkOptions::default()
 -    };
 -    Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
+-
 -    let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 -    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 -    assert_eq!(
 -        decode_page_reference(&our_text, our_text_addr, 0, &PageRefKind::Add).unwrap(),
 -        decode_page_reference(&apple_text, apple_text_addr, 0, &PageRefKind::Add).unwrap()
 -    );
 -    assert_eq!(our_text, apple_text);
 -    assert!(output_section(&our_bytes, "__DATA_CONST", "__got").is_none());
 -    assert!(output_section(&apple_bytes, "__DATA_CONST", "__got").is_none());
+-
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&our_out)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&opts).unwrap();
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let our_dic = raw_linkedit_data_cmd(&our_bytes, LC_DATA_IN_CODE);
 +    let apple_dic = raw_linkedit_data_cmd(&apple_bytes, LC_DATA_IN_CODE);
 +    assert_ne!(our_dic.1, 0);
 +    assert_eq!(our_dic.1, apple_dic.1);
 +    assert_eq!(decode_data_in_code(&our_bytes).len(), 1);
 +    assert_eq!(
 +        canonical_data_in_code(&our_bytes),
 +        canonical_data_in_code(&apple_bytes)
      );
 -    let status = Command::new(&our_out).status().unwrap();
      assert_eq!(
 -        status.code(),
 -        Some(7),
 -        "expected hidden GOT executable to exit 7"
 +        canonical_data_in_code(&our_bytes),
 +        vec![DataInCodeRecord {
 +            offset: 8,
 +            length: 8,
 +            kind: DICE_KIND_JUMP_TABLE32,
 +        }]
      );
      let _ = fs::remove_file(obj);
+ }
  #[test]
 -fn linker_run_partitions_symtab_like_ld() {
 +fn linker_run_remaps_data_in_code_in_later_text_section_like_ld() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
+     }
+-
 -    let dylib = scratch("symtab-partition.dylib");
 -    let obj = scratch("symtab-partition.o");
 -    let our_out = scratch("symtab-partition-ours.out");
 -    let apple_out = scratch("symtab-partition-apple.out");
+-
 -    let dylib_src = r#"
 -        int ext_data = 5;
 -    "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
          return;
+     }
 +    let obj = scratch("data-in-code-late.o");
 +    let our_out = scratch("data-in-code-late-ours.out");
 +    let apple_out = scratch("data-in-code-late-apple.out");
      let asm = r#"
          .text
 -        .private_extern _hidden
 -        .globl _visible
          .globl _main
          .p2align 2
 -    _local:
 +    _main:
          ret
 -    _hidden:
++
 +        .section __TEXT,__text2,regular,pure_instructions
 +        .globl _helper
 +        .p2align 2
 +    _helper:
 +        b Ldispatch
 +        .p2align 2
 +    Ltable:
 +        .data_region jt32
 +        .long Lcase0-Ltable
 +        .long Lcase1-Ltable
 +        .end_data_region
 +    Ldispatch:
          ret
 -    _visible:
 +    Lcase0:
          ret
 -    _main:
 +    Lcase1:
          ret
+-
 -        .data
 -        .quad _ext_data
          .subsections_via_symbols
      "#;
      if let Err(e) = assemble(asm, &obj) {
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), dylib.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
+-
 -    let apple = Command::new("xcrun")
 -        .args(["ld", "-arch", "arm64", "-e", "_main", "-o"])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&dylib)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 -    let (our_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 -    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
+-
 -    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 -    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 -    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 -    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 -    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 -    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 -    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
      assert_eq!(
 -        canonical_symbol_records(&our_bytes),
 -        canonical_symbol_records(&apple_bytes)
 -    );
 -    assert_strtab_within_five_percent(
 -        &raw_string_table(&our_bytes),
 -        &raw_string_table(&apple_bytes),
 +        canonical_data_in_code(&our_bytes),
 +        canonical_data_in_code(&apple_bytes)
      );
+-
      assert_eq!(
 -        symbol_partition_names(&our_bytes),
 -        symbol_partition_names(&apple_bytes)
 +        canonical_data_in_code(&our_bytes),
 +        vec![DataInCodeRecord {
 +            offset: 8,
 +            length: 8,
 +            kind: DICE_KIND_JUMP_TABLE32,
 +        }]
      );
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_strips_locals_with_x_like_ld() {
 +fn linker_run_remaps_data_in_code_after_large_first_text_section_like_ld() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
+     }
+-
 -    let dylib = scratch("symtab-strip.dylib");
 -    let obj = scratch("symtab-strip.o");
 -    let our_out = scratch("symtab-strip-ours.out");
 -    let apple_out = scratch("symtab-strip-apple.out");
+-
 -    let dylib_src = r#"
 -        int ext_data = 5;
 -    "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
          return;
+     }
 +    let obj = scratch("data-in-code-large-first.o");
 +    let our_out = scratch("data-in-code-large-first-ours.out");
 +    let apple_out = scratch("data-in-code-large-first-apple.out");
      let asm = r#"
          .text
 -        .private_extern _hidden
 -        .globl _visible
          .globl _main
          .p2align 2
 -    _local:
 +    _main:
 +        nop
 +        nop
 +        nop
 +        nop
 +        nop
          ret
 -    _hidden:
++
 +        .section __TEXT,__text2,regular,pure_instructions
 +        .globl _helper
 +    _helper:
 +        b Ldispatch
 +        .p2align 2
 +    Ltable:
 +        .data_region jt32
 +        .long Lcase0-Ltable
 +        .long Lcase1-Ltable
 +        .end_data_region
 +    Ldispatch:
          ret
 -    _visible:
 +    Lcase0:
          ret
 -    _main:
 +    Lcase1:
          ret
+-
 -        .data
 -        .quad _ext_data
          .subsections_via_symbols
      "#;
      if let Err(e) = assemble(asm, &obj) {
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), dylib.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 -        strip_locals: true,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
+-
 -    let apple = Command::new("xcrun")
 -        .args(["ld", "-arch", "arm64", "-x", "-e", "_main", "-o"])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&dylib)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
 +    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 -    let (our_symtab, our_dysymtab) = symtab_and_dysymtab(&our_bytes);
 -    let (apple_symtab, apple_dysymtab) = symtab_and_dysymtab(&apple_bytes);
+-
 -    assert_eq!(our_symtab.nsyms, apple_symtab.nsyms);
 -    assert_eq!(our_dysymtab.ilocalsym, apple_dysymtab.ilocalsym);
 -    assert_eq!(our_dysymtab.nlocalsym, apple_dysymtab.nlocalsym);
 -    assert_eq!(our_dysymtab.iextdefsym, apple_dysymtab.iextdefsym);
 -    assert_eq!(our_dysymtab.nextdefsym, apple_dysymtab.nextdefsym);
 -    assert_eq!(our_dysymtab.iundefsym, apple_dysymtab.iundefsym);
 -    assert_eq!(our_dysymtab.nundefsym, apple_dysymtab.nundefsym);
      assert_eq!(
 -        canonical_symbol_records(&our_bytes),
 -        canonical_symbol_records(&apple_bytes)
 +        canonical_data_in_code(&our_bytes),
 +        canonical_data_in_code(&apple_bytes)
      );
+-
 -    let (locals, extdefs, undefs) = symbol_partition_names(&our_bytes);
 -    assert!(locals.is_empty());
      assert_eq!(
 -        extdefs,
 -        vec![
 -            "__mh_execute_header".to_string(),
 -            "_main".to_string(),
 -            "_visible".to_string()
 -        ]
 +        canonical_data_in_code(&our_bytes),
 +        vec![DataInCodeRecord {
 +            offset: 28,
 +            length: 8,
 +            kind: DICE_KIND_JUMP_TABLE32,
 +        }]
      );
 -    assert_eq!(undefs, vec!["_ext_data".to_string()]);
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_emits_leaf_unwind_info_like_ld() {
 +fn linker_run_dedups_output_strtab_like_ld() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
 -    };
+-
 -    let obj = scratch("unwind-leaf.o");
 -    let our_out = scratch("unwind-leaf-ours.out");
 -    let apple_out = scratch("unwind-leaf-apple.out");
 -    let src = r#"
 -        int main(void) {
 -            return 0;
 -        }
 -    "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: clang compile failed: {e}");
 +    let Some(sdk) = sdk_path() else {
 +        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        return;
 +    };
 +    let Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let obj = scratch("strtab-dedup.o");
 +    let our_out = scratch("strtab-dedup-ours.out");
 +    let apple_out = scratch("strtab-dedup-apple.out");
 +    let mut asm =
 +        String::from("        .text\n        .globl _afs_array_sum\n        .globl _main\n");
 +    for idx in 0..20 {
 +        let symbol = format!("_pad_symbol_{idx:02}");
 +        asm.push_str(&format!("        .globl {symbol}\n"));
 +    }
 +    asm.push_str("        .p2align 2\n");
 +    asm.push_str("    _array_sum:\n        ret\n");
 +    asm.push_str("    _afs_array_sum:\n        ret\n");
 +    for idx in 0..20 {
 +        let symbol = format!("_pad_symbol_{idx:02}");
 +        asm.push_str(&format!("    {symbol}:\n        ret\n"));
 +    }
 +    asm.push_str("    _main:\n        bl _afs_array_sum\n        ret\n");
 +    asm.push_str("        .subsections_via_symbols\n");
 +    if let Err(e) = assemble(&asm, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
      assert_eq!(
 -        rebased_unwind_bytes(&our_bytes),
 -        rebased_unwind_bytes(&apple_bytes)
 +        canonical_symbol_records(&our_bytes),
 +        canonical_symbol_records(&apple_bytes)
 +    );
 +    let our_strtab = raw_string_table(&our_bytes);
 +    let apple_strtab = raw_string_table(&apple_bytes);
 +    assert_strtab_within_five_percent(&our_strtab, &apple_strtab);
 +    assert!(
 +        our_strtab.len() <= apple_strtab.len(),
 +        "suffix dedup should not grow the output string table: ours={} apple={}",
 +        our_strtab.len(),
 +        apple_strtab.len()
      );
 -    assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
++
 +    let offsets = symbol_name_offsets(&our_bytes);
 +    assert_eq!(offsets["_array_sum"], offsets["_afs_array_sum"] + 4);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
+ }
  #[test]
 -fn linker_run_emits_multi_function_unwind_info_like_ld() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_launches_with_classic_lazy_dylib_import() {
 +    if !have_xcrun() || !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 Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
          return;
 -    };
 +    }
 -    let obj = scratch("unwind-mixed.o");
 -    let our_out = scratch("unwind-mixed-ours.out");
 -    let apple_out = scratch("unwind-mixed-apple.out");
 -    let src = r#"
 -        int helper(void) {
 -            return 1;
 -        }
 +    let dylib = scratch("lazy-runtime.dylib");
 +    let obj = scratch("lazy-runtime.o");
 +    let out = scratch("lazy-runtime.out");
 -        int main(void) {
 -            return helper();
 -        }
 +    let dylib_src = r#"
 +        int ext_fn(void) { return 7; }
      "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: clang compile failed: {e}");
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
 +        return;
 +    }
++
 +    let main_src = r#"
 +        int ext_fn(void);
 +        int main(void) { return ext_fn() == 7 ? 0 : 1; }
 +    "#;
 +    if let Err(e) = compile_c(main_src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone()],
 -        output: Some(our_out.clone()),
 +        inputs: vec![obj.clone(), tbd, dylib.clone()],
 +        output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 -    let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&out).status().unwrap();
      assert_eq!(
 -        rebased_unwind_bytes(&our_bytes),
 -        rebased_unwind_bytes(&apple_bytes)
 +        status.code(),
 +        Some(0),
 +        "expected dylib-import executable to exit 0"
      );
 -    assert!(output_section(&our_bytes, "__LD", "__compact_unwind").is_none());
 +    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(out);
+ }
  #[test]
 -fn linker_run_handles_large_unwind_function_gaps() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_handles_local_tlv_descriptors() {
 +    if !have_xcrun() || !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 tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
          return;
+     }
 -    let obj = scratch("unwind-gap.o");
 -    let out = scratch("unwind-gap-ours.out");
 -    let asm = r#"
 -        .text
 -        .globl _main
 -        .p2align 2
 -    _main:
 -        .cfi_startproc
 -        bl _helper
 -        ret
 -        .cfi_endproc
 -        .space 0x1000010
 -        .globl _helper
 -        .p2align 2
 -    _helper:
 -        .cfi_startproc
 -        ret
 -        .cfi_endproc
 -        .subsections_via_symbols
 +    let obj = scratch("tlvp-local.o");
 +    let out = scratch("tlvp-local.out");
 +    let src = r#"
 +        __thread long tls_a = 7;
 +        __thread long tls_b;
++
 +        static long tls_sum(void) {
 +            return tls_a + tls_b;
 +        }
++
 +        int main(void) {
 +            return tls_sum() == 7 ? 0 : 1;
 +        }
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 -        eprintln!("skipping: assemble failed: {e}");
 +    if let Err(e) = compile_c(src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone()],
 +        inputs: vec![obj.clone(), tbd],
          output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      Linker::run(&opts).unwrap();
      let bytes = fs::read(&out).unwrap();
 -    let (_, unwind) = output_section(&bytes, "__TEXT", "__unwind_info").unwrap();
 -    let decoded = decode_unwind_info(&unwind).unwrap();
 +    let (_, thread_vars) = output_section(&bytes, "__DATA", "__thread_vars").unwrap();
 +    let (_, thread_data) = output_section(&bytes, "__DATA", "__thread_data").unwrap();
 +    assert!(output_section(&bytes, "__DATA", "__thread_ptrs").is_none());
 +    assert_eq!(thread_vars.len(), 48);
 +    assert_eq!(thread_data.len(), 8);
 +    assert_eq!(
 +        u64::from_le_bytes(thread_vars[16..24].try_into().unwrap()),
 +        0
 +    );
 +    assert_eq!(
 +        u64::from_le_bytes(thread_vars[40..48].try_into().unwrap()),
 +        8
 +    );
++
 +    let binds = decode_bind_records(&bytes, false).unwrap();
 +    let mut tlv_binds: Vec<_> = binds
 +        .into_iter()
 +        .filter(|record| record.section == "__thread_vars" && record.symbol == "__tlv_bootstrap")
 +        .collect();
 +    tlv_binds.sort_by_key(|record| record.section_offset);
 +    assert_eq!(tlv_binds.len(), 2);
 +    assert_eq!(tlv_binds[0].section_offset, 0);
 +    assert_eq!(tlv_binds[1].section_offset, 24);
++
 +    let header = parse_header(&bytes).unwrap();
 +    let commands = parse_commands(&header, &bytes).unwrap();
 +    let symtab = commands
 +        .iter()
 +        .find_map(|cmd| match cmd {
 +            LoadCommand::Symtab(cmd) => Some(*cmd),
 +            _ => None,
 +        })
 +        .unwrap();
 +    let symbols = parse_nlist_table(&bytes, symtab.symoff, symtab.nsyms).unwrap();
 +    let strings = StringTable::from_file(&bytes, symtab.stroff, symtab.strsize).unwrap();
 +    let symbol_names: Vec<&str> = symbols
 +        .iter()
 +        .map(|symbol| strings.get(symbol.strx()).unwrap())
 +        .collect();
 +    assert!(symbol_names.contains(&"__tlv_bootstrap"));
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
      assert!(
 -        decoded
 -            .records
 -            .windows(2)
 -            .all(|pair| pair[0].function_offset < pair[1].function_offset),
 -        "expected strictly ascending unwind records after large-gap pagination"
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
      );
 +    let status = Command::new(&out).status().unwrap();
 +    assert_eq!(status.code(), Some(0), "expected TLV executable to exit 0");
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(out);
+ }
  #[test]
 -fn linker_run_preserves_eh_frame_like_ld() {
 -    if !have_xcrun() || !have_xcrun_tool("dwarfdump") {
 -        eprintln!("skipping: xcrun dwarfdump unavailable");
 +fn linker_run_routes_imported_tlv_through_got() {
 +    if !have_xcrun() || !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 Some(sdk_ver) = sdk_version() else {
 +        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        return;
 +    };
 +    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 +    if !tbd.exists() {
 +        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +        return;
 +    }
++
 +    let dylib = scratch("libtlvprobe.dylib");
 +    let obj = scratch("imported-tlv.o");
 +    let our_out = scratch("imported-tlv-ours.out");
 +    let apple_out = scratch("imported-tlv-apple.out");
++
 +    let dylib_src = r#"
 +        __thread long ext_tls = 5;
 +        long read_lib_tls(void) { return ext_tls; }
 +    "#;
 +    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 +        eprintln!("skipping: dylib compile failed: {e}");
          return;
+     }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
 -    };
+-
 -    let obj = scratch("eh-frame.o");
 -    let our_out = scratch("eh-frame-ours.out");
 -    let apple_out = scratch("eh-frame-apple.out");
 -    let asm = r#"
 -        .text
 -        .globl _main
 -        .p2align 2
 -    _main:
 -        .cfi_startproc
 -        sub sp, sp, #16
 -        .cfi_def_cfa_offset 16
 -        str x30, [sp, #8]
 -        .cfi_offset w30, -8
 -        bl _helper
 -        ldr x30, [sp, #8]
 -        add sp, sp, #16
 -        ret
 -        .cfi_endproc
 -        .globl _helper
 -        .p2align 2
 -    _helper:
 -        .cfi_startproc
 -        ret
 -        .cfi_endproc
 -        .subsections_via_symbols
 +    let main_src = r#"
 +        extern __thread long ext_tls;
 +        int main(void) { return ext_tls == 5 ? 0 : 1; }
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 -        eprintln!("skipping: assemble failed: {e}");
 +    if let Err(e) = compile_c(main_src, &obj) {
 +        eprintln!("skipping: compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone()],
 +        inputs: vec![obj.clone(), tbd.clone(), dylib.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
++
 +    let apple = Command::new("xcrun")
 +        .args([
 +            "ld",
 +            "-arch",
 +            "arm64",
 +            "-platform_version",
 +            "macos",
 +            &sdk_ver,
 +            &sdk_ver,
 +            "-syslibroot",
 +            &sdk,
 +            "-no_fixup_chains",
 +            "-lSystem",
 +            "-e",
 +            "_main",
 +            "-o",
 +        ])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&dylib)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
      let our_bytes = fs::read(&our_out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 -    assert!(output_section(&our_bytes, "__TEXT", "__eh_frame").is_some());
 +    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 +    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 +    let (our_got_addr, our_got) = output_section(&our_bytes, "__DATA_CONST", "__got").unwrap();
 +    let (apple_got_addr, apple_got) =
 +        output_section(&apple_bytes, "__DATA_CONST", "__got").unwrap();
++
 +    assert!(output_section(&our_bytes, "__DATA", "__thread_ptrs").is_none());
 +    assert!(output_section(&apple_bytes, "__DATA", "__thread_ptrs").is_none());
 +    assert_eq!(our_got.len(), 8);
 +    assert_eq!(our_got, apple_got);
      assert_eq!(
 -        output_section(&our_bytes, "__TEXT", "__eh_frame")
 -            .unwrap()
 -            .1
 -            .len(),
 -        output_section(&apple_bytes, "__TEXT", "__eh_frame")
 -            .unwrap()
 -            .1
 -            .len()
 +        decode_page_reference(&our_text, our_text_addr, 20, &PageRefKind::Load).unwrap(),
 +        our_got_addr
 +    );
 +    assert_eq!(
 +        decode_page_reference(&apple_text, apple_text_addr, 20, &PageRefKind::Load).unwrap(),
 +        apple_got_addr
 +    );
 +    assert_eq!(our_text, apple_text);
 +    assert_eq!(read_insn(&our_text, 24).unwrap(), 0xf9400000);
 +    assert_eq!(read_insn(&our_text, 28).unwrap(), 0xf9400008);
 +    assert_eq!(read_insn(&our_text, 32).unwrap(), 0xd63f0100);
 +    assert_eq!(
 +        decode_bind_records(&our_bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap()
 +    );
 +    assert_eq!(
 +        load_dylib_names(&our_bytes).unwrap(),
 +        load_dylib_names(&apple_bytes).unwrap()
 +    );
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&our_out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
 +    let status = Command::new(&our_out).status().unwrap();
 +    assert_eq!(
 +        status.code(),
 +        Some(0),
 +        "expected imported TLV executable to exit 0"
      );
 -    let our_dump = normalized_eh_frame_dump(
 -        &our_out,
 -        output_section(&our_bytes, "__TEXT", "__text").unwrap().0,
 -    )
 -    .unwrap();
 -    let apple_dump = normalized_eh_frame_dump(
 -        &apple_out,
 -        output_section(&apple_bytes, "__TEXT", "__text").unwrap().0,
 -    )
 -    .unwrap();
 -    assert_eq!(our_dump, apple_dump);
 +    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
      let _ = fs::remove_file(our_out);
      let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_emits_backtrace_metadata_like_apple_ld() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_preserves_runtime_tlv_descriptor_offsets() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
          return;
+     }
 +    let Some(runtime) = find_runtime_archive() else {
 +        eprintln!("skipping: libarmfortas_rt.a not built");
 +        return;
 +    };
      let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        eprintln!("skipping: no macOS SDK path");
          return;
      };
      let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        eprintln!("skipping: no macOS SDK version");
          return;
      };
      let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
          return;
+     }
 -    let obj = scratch("unwind-backtrace.o");
 -    let our_out = scratch("unwind-backtrace-ours.out");
 -    let apple_out = scratch("unwind-backtrace-apple.out");
 +    let obj = scratch("runtime-hello.o");
 +    let out = scratch("runtime-hello.out");
 +    let apple_out = scratch("runtime-hello-apple.out");
      let src = r#"
 -        #include <unwind.h>
+-
 -        static _Unwind_Reason_Code cb(struct _Unwind_Context* ctx, void* arg) {
 -            (void)ctx;
 -            int* count = (int*)arg;
 -            (*count)++;
 -            return *count >= 8 ? _URC_END_OF_STACK : _URC_NO_REASON;
 -        }
+-
 -        __attribute__((noinline)) int helper(void) {
 -            int count = 0;
 -            _Unwind_Backtrace(cb, &count);
 -            return count;
 -        }
 +        extern void afs_program_init(void);
 +        extern void afs_program_finalize(void);
 +        extern void afs_write_string(int, const char *, long);
 +        extern void afs_write_newline(int);
          int main(void) {
 -            return helper() > 1 ? 0 : 1;
 +            afs_program_init();
 +            afs_write_string(6, "Hello, World!", 13);
 +            afs_write_newline(6);
 +            afs_program_finalize();
 +            return 0;
+         }
      "#;
      if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: clang compile failed: {e}");
 +        eprintln!("skipping: compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 -        output: Some(our_out.clone()),
 +        inputs: vec![obj.clone(), runtime.clone(), tbd],
 +        output: Some(out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 -    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple = Command::new("xcrun")
 +        .args([
 +            "ld",
 +            "-arch",
 +            "arm64",
 +            "-platform_version",
 +            "macos",
 +            &sdk_ver,
 +            &sdk_ver,
 +            "-syslibroot",
 +            &sdk,
 +            "-lSystem",
 +            "-e",
 +            "_main",
 +            "-no_fixup_chains",
 +            "-o",
 +        ])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&runtime)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
 +    );
++
 +    let verify = Command::new("codesign")
 +        .arg("-v")
 +        .arg(&out)
 +        .output()
 +        .unwrap();
 +    assert!(
 +        verify.status.success(),
 +        "codesign verify failed: {}",
 +        String::from_utf8_lossy(&verify.stderr)
 +    );
++
 +    let bytes = fs::read(&out).unwrap();
      let apple_bytes = fs::read(&apple_out).unwrap();
 +    assert!(
 +        output_section(&bytes, "__DATA_CONST", "__const").is_some(),
 +        "runtime hello should promote file-backed __const data into __DATA_CONST"
 +    );
 +    assert!(
 +        output_section(&bytes, "__DATA", "__const").is_none(),
 +        "runtime hello should not leave file-backed __const data in __DATA"
 +    );
 +    let (thread_vars_addr, thread_vars) =
 +        output_section(&bytes, "__DATA", "__thread_vars").unwrap();
 +    let (thread_data_addr, _) = output_section(&bytes, "__DATA", "__thread_data").unwrap();
 +    let symbols = symbol_values(&bytes);
 +    let tlv_binds: Vec<_> = decode_bind_records(&bytes, false)
 +        .unwrap()
 +        .into_iter()
 +        .filter(|record| record.section == "__thread_vars")
 +        .collect();
 +    assert_eq!(
 +        tlv_binds.len(),
 +        thread_vars.len() / 24,
 +        "every TLV descriptor should carry exactly one bootstrap bind"
 +    );
 +    assert!(tlv_binds
 +        .iter()
 +        .all(|record| record.symbol == "__tlv_bootstrap"));
++
 +    assert_eq!(
 +        decode_bind_records(&bytes, false).unwrap(),
 +        decode_bind_records(&apple_bytes, false).unwrap(),
 +        "runtime hello bind records diverged from Apple ld"
 +    );
      assert_eq!(
 -        rebased_unwind_bytes(&our_bytes),
 -        rebased_unwind_bytes(&apple_bytes)
 +        decode_bind_records(&bytes, true).unwrap(),
 +        decode_bind_records(&apple_bytes, true).unwrap(),
 +        "runtime hello lazy-bind records diverged from Apple ld"
      );
      assert_eq!(
 -        normalize_function_start_offsets(&decode_function_starts(&our_bytes)),
 -        normalize_function_start_offsets(&decode_function_starts(&apple_bytes))
 +        decode_rebase_records(&bytes).unwrap(),
 +        decode_rebase_records(&apple_bytes).unwrap(),
 +        "runtime hello rebase records diverged from Apple ld"
 +    );
 +    assert_eq!(
 +        indirect_symbol_identities(&bytes),
 +        indirect_symbol_identities(&apple_bytes),
 +        "runtime hello indirect symbol identities diverged from Apple ld"
      );
 -    let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
 -}
+-
 -#[test]
 -fn linker_run_preserves_exception_unwind_metadata_like_apple_ld() {
 -    if !have_xcrun() || !have_xcrun_tool("clang++") || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun 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;
 +    for (name, descriptor_addr) in symbols.iter().filter(|(name, value)| {
 +        !name.ends_with("$tlv$init")
 +            && **value >= thread_vars_addr
 +            && **value < thread_vars_addr + thread_vars.len() as u64
 +    }) {
 +        let init_name = format!("{name}$tlv$init");
 +        let Some(init_addr) = symbols.get(&init_name) else {
 +            continue;
 +        };
 +        let offset = (*descriptor_addr - thread_vars_addr) as usize;
 +        let actual = u64::from_le_bytes(thread_vars[offset + 16..offset + 24].try_into().unwrap());
 +        let expected = init_addr - thread_data_addr;
 +        assert_eq!(
 +            actual, expected,
 +            "TLV descriptor {} should point at {} via template offset",
 +            name, init_name
 +        );
+     }
 -    let 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 output = Command::new(&out).output().unwrap();
 +    let apple_output = Command::new(&apple_out).output().unwrap();
      assert_eq!(
 -        decode_bind_records(&our_bytes, false).unwrap(),
 -        decode_bind_records(&apple_bytes, false).unwrap()
 +        output.status.code(),
 +        Some(0),
 +        "expected runtime hello executable to exit 0, stderr={}",
 +        String::from_utf8_lossy(&output.stderr)
      );
      assert_eq!(
 -        decode_bind_records(&our_bytes, true).unwrap(),
 -        decode_bind_records(&apple_bytes, true).unwrap()
 +        apple_output.status.code(),
 +        Some(0),
 +        "expected Apple-linked runtime hello executable to exit 0, stderr={}",
 +        String::from_utf8_lossy(&apple_output.stderr)
      );
      assert_eq!(
 -        canonical_lazy_bind_stream(&our_bytes).unwrap(),
 -        canonical_lazy_bind_stream(&apple_bytes).unwrap()
 +        String::from_utf8_lossy(&output.stdout),
 +        String::from_utf8_lossy(&apple_output.stdout)
      );
 -    let our_decoded = canonical_unwind_info(&our_bytes);
 -    let apple_decoded = canonical_unwind_info(&apple_bytes);
 -    assert_eq!(our_decoded, apple_decoded);
 -    assert_eq!(our_decoded.personalities.len(), 1);
 -    assert_eq!(our_decoded.lsdas.len(), 1);
 -    assert!(output_section(&our_bytes, "__TEXT", "__gcc_except_tab").is_some());
 -    let 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(out);
      let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_resolves_backtrace_symbols_at_runtime() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 +fn linker_run_rebases_runtime_init_metadata_like_apple_ld() {
 +    if !have_xcrun() || !have_tool("codesign") {
 +        eprintln!("skipping: xcrun or codesign unavailable");
          return;
+     }
 +    let Some(runtime) = find_runtime_archive() else {
 +        eprintln!("skipping: libarmfortas_rt.a not built");
 +        return;
 +    };
      let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +        eprintln!("skipping: no macOS SDK path");
          return;
      };
      let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +        eprintln!("skipping: no macOS SDK version");
          return;
      };
      let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
          return;
+     }
 -    let obj = scratch("execinfo-backtrace.o");
 -    let our_out = scratch("execinfo-backtrace-ours.out");
 -    let apple_out = scratch("execinfo-backtrace-apple.out");
 +    let obj = scratch("runtime-init-only.o");
 +    let our_out = scratch("runtime-init-only-ours.out");
 +    let apple_out = scratch("runtime-init-only-apple.out");
      let src = r#"
 -        #include <execinfo.h>
 -        #include <stdio.h>
 -        #include <stdlib.h>
 -        #include <string.h>
+-
 -        __attribute__((noinline)) int helper(void) {
 -            void *frames[8];
 -            int n = backtrace(frames, 8);
 -            char **syms = backtrace_symbols(frames, n);
 -            int saw_helper = 0;
 -            int saw_main = 0;
 -            if (!syms) return 2;
 -            for (int i = 0; i < n; i++) {
 -                puts(syms[i]);
 -                saw_helper |= strstr(syms[i], "helper") != NULL;
 -                saw_main |= strstr(syms[i], "main") != NULL;
 -            }
 -            free(syms);
 -            return (saw_helper && saw_main) ? 0 : 1;
 -        }
 +        extern void afs_program_init(void);
          int main(void) {
 -            return helper();
 +            afs_program_init();
 +            return 0;
+         }
      "#;
      if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: clang compile failed: {e}");
 +        eprintln!("skipping: compile failed: {e}");
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone(), runtime.clone(), tbd],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
+-
 -    let our_output = Command::new(&our_out).output().unwrap();
 -    let apple_output = Command::new(&apple_out).output().unwrap();
 -    let our_stdout = String::from_utf8_lossy(&our_output.stdout);
 -    let apple_stdout = String::from_utf8_lossy(&apple_output.stdout);
 -    assert_eq!(our_output.status.code(), Some(0));
 -    assert_eq!(apple_output.status.code(), Some(0));
 -    assert!(
 -        our_stdout.contains("helper"),
 -        "expected helper in output: {our_stdout}"
 -    );
 +    let apple = Command::new("xcrun")
 +        .args([
 +            "ld",
 +            "-arch",
 +            "arm64",
 +            "-platform_version",
 +            "macos",
 +            &sdk_ver,
 +            &sdk_ver,
 +            "-syslibroot",
 +            &sdk,
 +            "-lSystem",
 +            "-e",
 +            "_main",
 +            "-no_fixup_chains",
 +            "-o",
 +        ])
 +        .arg(&apple_out)
 +        .arg(&obj)
 +        .arg(&runtime)
 +        .output()
 +        .unwrap();
      assert!(
 -        our_stdout.contains("main"),
 -        "expected main in output: {our_stdout}"
 +        apple.status.success(),
 +        "xcrun ld failed: {}",
 +        String::from_utf8_lossy(&apple.stderr)
      );
 -    assert!(
 -        apple_stdout.contains("helper"),
 -        "expected helper in apple output: {apple_stdout}"
++
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let our_rebases = decode_rebase_records(&our_bytes).unwrap();
 +    let apple_rebases = decode_rebase_records(&apple_bytes).unwrap();
 +    assert_eq!(
 +        our_rebases
 +            .iter()
 +            .filter(|record| record.section == "__const")
 +            .count(),
 +        apple_rebases
 +            .iter()
 +            .filter(|record| record.section == "__const")
 +            .count(),
 +        "runtime init const rebases diverged from Apple ld"
      );
 -    assert!(
 -        apple_stdout.contains("main"),
 -        "expected main in apple output: {apple_stdout}"
 +    assert_eq!(
 +        our_rebases
 +            .iter()
 +            .filter(|record| record.section == "__la_symbol_ptr")
 +            .count(),
 +        apple_rebases
 +            .iter()
 +            .filter(|record| record.section == "__la_symbol_ptr")
 +            .count(),
 +        "runtime init lazy-pointer rebases diverged from Apple ld"
      );
 -    let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
 -}
 +    let our_status = Command::new(&our_out).status().unwrap();
 +    let apple_status = Command::new(&apple_out).status().unwrap();
 +    assert_eq!(our_status.code(), Some(0));
 +    assert_eq!(apple_status.code(), Some(0));
 -#[test]
 -fn linker_run_emits_function_starts_like_ld() {
 -    if !have_xcrun() {
 -        eprintln!("skipping: xcrun unavailable");
 -        return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(our_out);
 +    let _ = fs::remove_file(apple_out);
 +}
++
 +#[test]
 +fn linker_run_icf_safe_folds_identical_private_text() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("function-starts.o");
 -    let our_out = scratch("function-starts-ours.out");
 -    let apple_out = scratch("function-starts-apple.out");
 -    let asm = r#"
 +    let obj = scratch("icf-fold.o");
 +    let baseline_out = scratch("icf-fold-baseline.out");
 +    let our_out = scratch("icf-fold-ours.out");
 +    let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        .p2align 2
 -    _main:
 -        adrp x0, _write@GOTPAGE
 -        ldr x0, [x0, _write@GOTPAGEOFF]
 -        bl _write
 -        ret
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper1
 +            bl _helper2
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .private_extern _helper1
 +        _helper1:
 +            mov w0, #7
 +            ret
++
 +        .private_extern _helper2
 +        _helper2:
 +            mov w0, #7
 +            ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link_classic_lazy(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    let our_fstarts = raw_linkedit_data_cmd(&our_bytes, LC_FUNCTION_STARTS);
 -    let apple_fstarts = raw_linkedit_data_cmd(&apple_bytes, LC_FUNCTION_STARTS);
 -    assert_ne!(our_fstarts.0, 0);
 -    assert_eq!(our_fstarts.1, apple_fstarts.1);
 -    assert_eq!(our_fstarts.1, 8);
 -    assert!(output_section(&our_bytes, "__TEXT", "__stubs").is_some());
 -    assert!(output_section(&our_bytes, "__TEXT", "__stub_helper").is_some());
 -    assert_eq!(decode_function_starts(&our_bytes).len(), 1);
 -    assert_eq!(decode_function_starts(&apple_bytes).len(), 1);
 -    let our_text_addr = output_section(&our_bytes, "__TEXT", "__text").unwrap().0;
 -    let apple_text_addr = output_section(&apple_bytes, "__TEXT", "__text").unwrap().0;
 -    let our_text_base = segment_vmaddr(&our_bytes, "__TEXT").unwrap();
 -    let apple_text_base = segment_vmaddr(&apple_bytes, "__TEXT").unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
 +        .unwrap()
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
++
      assert_eq!(
 -        decode_function_starts(&our_bytes),
 -        vec![our_text_addr - our_text_base]
 +        our_symbols.get("_helper1"),
 +        our_symbols.get("_helper2"),
 +        "expected afs-ld -icf=safe to coalesce identical private text atoms"
 +    );
 +    assert_ne!(
 +        baseline_symbols.get("_helper1"),
 +        baseline_symbols.get("_helper2"),
 +        "expected baseline link to keep identical helpers separate"
      );
      assert_eq!(
 -        decode_function_starts(&apple_bytes),
 -        vec![apple_text_addr - apple_text_base]
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(7),
 +        "folded executable should preserve runtime behavior"
 +    );
 +    assert!(
 +        our_text.len() < baseline_text.len(),
 +        "expected -icf=safe to reduce text size on identical helpers"
      );
+-
 -    let our_dic = raw_linkedit_data_cmd(&our_bytes, LC_DATA_IN_CODE);
 -    let apple_dic = raw_linkedit_data_cmd(&apple_bytes, LC_DATA_IN_CODE);
 -    assert_ne!(our_dic.0, 0);
 -    assert_eq!(our_dic.1, apple_dic.1);
 -    assert_eq!(our_dic.0, our_fstarts.0 + our_fstarts.1);
 -    assert_eq!(apple_dic.0, apple_fstarts.0 + apple_fstarts.1);
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_emits_function_starts_for_other_text_sections_like_ld() {
 +fn linker_run_icf_safe_keeps_address_taken_functions_distinct() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
      };
 -    let obj = scratch("function-starts-textcoal.o");
 -    let our_out = scratch("function-starts-textcoal-ours.out");
 -    let apple_out = scratch("function-starts-textcoal-apple.out");
 -    let asm = r#"
 +    let obj = scratch("icf-address-taken.o");
 +    let baseline_out = scratch("icf-address-taken-baseline.out");
 +    let our_out = scratch("icf-address-taken-ours.out");
 +    let src = r#"
          .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        .p2align 2
 -    _main:
 -        ret
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            bl _helper1
 +            bl _helper2
 +            ldp x29, x30, [sp], #16
 +            ret
 -        .section __TEXT,__textcoal_nt,regular,pure_instructions
 -        .globl _helper
 -        .p2align 2
 -    _helper:
 -        ret
 +        .private_extern _helper1
 +        _helper1:
 +            mov w0, #7
 +            ret
++
 +        .private_extern _helper2
 +        _helper2:
 +            mov w0, #7
 +            ret
++
 +        .section __DATA,__const
 +        .p2align 3
 +        _ptrs:
 +            .quad _helper1
 +            .quad _helper2
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
          inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    assert_eq!(decode_function_starts(&our_bytes).len(), 2);
 -    assert_eq!(decode_function_starts(&apple_bytes).len(), 2);
+-
 -    let our_text_addr = output_section(&our_bytes, "__TEXT", "__text").unwrap().0;
 -    let our_textcoal_addr = output_section(&our_bytes, "__TEXT", "__textcoal_nt")
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
          .unwrap()
 -        .0;
 -    let our_text_base = segment_vmaddr(&our_bytes, "__TEXT").unwrap();
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
++
 +    assert_ne!(
 +        our_symbols.get("_helper1"),
 +        our_symbols.get("_helper2"),
 +        "address-taken helpers should not be folded by afs-ld -icf=safe"
 +    );
 +    assert_ne!(
 +        baseline_symbols.get("_helper1"),
 +        baseline_symbols.get("_helper2"),
 +        "baseline link should keep address-taken helpers separate"
 +    );
      assert_eq!(
 -        decode_function_starts(&our_bytes),
 -        vec![
 -            our_text_addr - our_text_base,
 -            our_textcoal_addr - our_text_base
 -        ]
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(7),
 +        "address-taken executable should preserve runtime behavior"
 +    );
 +    assert_eq!(
 +        our_text.len(),
 +        baseline_text.len(),
 +        "address-taken helpers should not shrink under -icf=safe"
      );
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_remaps_data_in_code_like_ld() {
 +fn linker_run_icf_safe_keeps_adrp_add_address_taken_functions_distinct() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("data-in-code.o");
 -    let our_out = scratch("data-in-code-ours.out");
 -    let apple_out = scratch("data-in-code-apple.out");
 -    let asm = r#"
 -        .text
 +    let obj = scratch("icf-adrp-address-taken.o");
 +    let baseline_out = scratch("icf-adrp-address-taken-baseline.out");
 +    let our_out = scratch("icf-adrp-address-taken-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        .p2align 2
 -    _main:
 -        mov w0, #0
 -        b Ldispatch
 -        .p2align 2
 -    Ltable:
 -        .data_region jt32
 -        .long Lcase0-Ltable
 -        .long Lcase1-Ltable
 -        .end_data_region
 -    Ldispatch:
 -        cmp w0, #0
 -        b.eq Lcase0
 -        b Lcase1
 -    Lcase0:
 -        mov w0, #1
 -        ret
 -    Lcase1:
 -        mov w0, #2
 -        ret
 +        _main:
 +            stp x29, x30, [sp, #-16]!
 +            mov x29, sp
 +            adrp x10, _helper1@PAGE
 +            add x10, x10, _helper1@PAGEOFF
 +            adrp x11, _helper2@PAGE
 +            add x11, x11, _helper2@PAGEOFF
 +            cmp x10, x11
 +            b.ne 1f
 +            mov w0, #1
 +            ldp x29, x30, [sp], #16
 +            ret
 +        1:
 +            mov w0, #0
 +            ldp x29, x30, [sp], #16
 +            ret
++
 +        .private_extern _helper1
 +        _helper1:
 +            mov w0, #7
 +            ret
++
 +        .private_extern _helper2
 +        _helper2:
 +            mov w0, #7
 +            ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    let our_dic = raw_linkedit_data_cmd(&our_bytes, LC_DATA_IN_CODE);
 -    let apple_dic = raw_linkedit_data_cmd(&apple_bytes, LC_DATA_IN_CODE);
 -    assert_ne!(our_dic.1, 0);
 -    assert_eq!(our_dic.1, apple_dic.1);
 -    assert_eq!(decode_data_in_code(&our_bytes).len(), 1);
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
 +        .unwrap()
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
++
 +    assert_ne!(
 +        our_symbols.get("_helper1"),
 +        our_symbols.get("_helper2"),
 +        "adrp/add address-taken helpers should not be folded by afs-ld -icf=safe"
 +    );
 +    assert_ne!(
 +        baseline_symbols.get("_helper1"),
 +        baseline_symbols.get("_helper2"),
 +        "baseline link should keep adrp/add address-taken helpers separate"
 +    );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        canonical_data_in_code(&apple_bytes)
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(0),
 +        "adrp/add address-taken executable should preserve pointer inequality"
      );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        vec![DataInCodeRecord {
 -            offset: 8,
 -            length: 8,
 -            kind: DICE_KIND_JUMP_TABLE32,
 -        }]
 +        our_text.len(),
 +        baseline_text.len(),
 +        "adrp/add address-taken helpers should not shrink under -icf=safe"
      );
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_remaps_data_in_code_in_later_text_section_like_ld() {
 +fn linker_run_icf_safe_folds_matching_branch_relocs() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
+-
 -    let obj = scratch("data-in-code-late.o");
 -    let our_out = scratch("data-in-code-late-ours.out");
 -    let apple_out = scratch("data-in-code-late-apple.out");
 -    let asm = r#"
 -        .text
 -        .globl _main
 -        .p2align 2
 -    _main:
 -        ret
 -        .section __TEXT,__text2,regular,pure_instructions
 -        .globl _helper
 -        .p2align 2
 -    _helper:
 -        b Ldispatch
 -        .p2align 2
 -    Ltable:
 -        .data_region jt32
 -        .long Lcase0-Ltable
 -        .long Lcase1-Ltable
 -        .end_data_region
 -    Ldispatch:
 -        ret
 -    Lcase0:
 -        ret
 -    Lcase1:
 -        ret
 +    let obj = scratch("icf-branch-match.o");
 +    let baseline_out = scratch("icf-branch-match-baseline.out");
 +    let our_out = scratch("icf-branch-match-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-32]!
 +            mov x29, sp
 +            bl _wrapper1
 +            str w0, [sp, #16]
 +            bl _wrapper2
 +            ldr w8, [sp, #16]
 +            add w0, w8, w0
 +            ldp x29, x30, [sp], #32
 +            ret
++
 +        .private_extern _wrapper1
 +        _wrapper1:
 +            b _leaf
++
 +        .private_extern _wrapper2
 +        _wrapper2:
 +            b _leaf
++
 +        .private_extern _leaf
 +        _leaf:
 +            mov w0, #5
 +            ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
 +        .unwrap()
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
++
 +    assert_ne!(
 +        baseline_symbols.get("_wrapper1"),
 +        baseline_symbols.get("_wrapper2"),
 +        "baseline link should keep identical wrappers separate"
 +    );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        canonical_data_in_code(&apple_bytes)
 +        our_symbols.get("_wrapper1"),
 +        our_symbols.get("_wrapper2"),
 +        "matching branch relocations should fold under -icf=safe"
      );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        vec![DataInCodeRecord {
 -            offset: 8,
 -            length: 8,
 -            kind: DICE_KIND_JUMP_TABLE32,
 -        }]
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(10),
 +        "folded branch-reloc executable should preserve runtime behavior"
 +    );
 +    assert!(
 +        our_text.len() < baseline_text.len(),
 +        "expected matching branch-reloc wrappers to shrink under -icf=safe"
      );
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_remaps_data_in_code_after_large_first_text_section_like_ld() {
 +fn linker_run_icf_safe_keeps_distinct_branch_targets_unfolded() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("data-in-code-large-first.o");
 -    let our_out = scratch("data-in-code-large-first-ours.out");
 -    let apple_out = scratch("data-in-code-large-first-apple.out");
 -    let asm = r#"
 -        .text
 +    let obj = scratch("icf-branch-distinct.o");
 +    let baseline_out = scratch("icf-branch-distinct-baseline.out");
 +    let our_out = scratch("icf-branch-distinct-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
          .globl _main
 -        .p2align 2
 -    _main:
 -        nop
 -        nop
 -        nop
 -        nop
 -        nop
 -        ret
 +        _main:
 +            stp x29, x30, [sp, #-32]!
 +            mov x29, sp
 +            bl _wrapper1
 +            str w0, [sp, #16]
 +            bl _wrapper2
 +            ldr w8, [sp, #16]
 +            add w0, w8, w0
 +            ldp x29, x30, [sp], #32
 +            ret
 -        .section __TEXT,__text2,regular,pure_instructions
 -        .globl _helper
 -    _helper:
 -        b Ldispatch
 -        .p2align 2
 -    Ltable:
 -        .data_region jt32
 -        .long Lcase0-Ltable
 -        .long Lcase1-Ltable
 -        .end_data_region
 -    Ldispatch:
 -        ret
 -    Lcase0:
 -        ret
 -    Lcase1:
 -        ret
 +        .private_extern _wrapper1
 +        _wrapper1:
 +            b _leaf1
++
 +        .private_extern _wrapper2
 +        _wrapper2:
 +            b _leaf2
++
 +        .private_extern _leaf1
 +        _leaf1:
 +            mov w0, #3
 +            ret
++
 +        .private_extern _leaf2
 +        _leaf2:
 +            mov w0, #5
 +            ret
          .subsections_via_symbols
      "#;
 -    if let Err(e) = assemble(asm, &obj) {
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
 +        .unwrap()
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
++
 +    assert_ne!(
 +        baseline_symbols.get("_wrapper1"),
 +        baseline_symbols.get("_wrapper2"),
 +        "baseline link should keep distinct wrappers separate"
 +    );
 +    assert_ne!(
 +        our_symbols.get("_wrapper1"),
 +        our_symbols.get("_wrapper2"),
 +        "wrappers targeting different leaves must not fold under -icf=safe"
 +    );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        canonical_data_in_code(&apple_bytes)
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(8),
 +        "distinct branch-target executable should preserve runtime behavior"
      );
      assert_eq!(
 -        canonical_data_in_code(&our_bytes),
 -        vec![DataInCodeRecord {
 -            offset: 28,
 -            length: 8,
 -            kind: DICE_KIND_JUMP_TABLE32,
 -        }]
 +        our_text.len(),
 +        baseline_text.len(),
 +        "distinct branch-target wrappers should not shrink under -icf=safe"
      );
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_dedups_output_strtab_like_ld() {
 +fn linker_run_icf_safe_folds_identical_private_const_data() {
      if !have_xcrun() {
          eprintln!("skipping: xcrun unavailable");
          return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 -        return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("strtab-dedup.o");
 -    let our_out = scratch("strtab-dedup-ours.out");
 -    let apple_out = scratch("strtab-dedup-apple.out");
 -    let mut asm =
 -        String::from("        .text\n        .globl _afs_array_sum\n        .globl _main\n");
 -    for idx in 0..20 {
 -        let symbol = format!("_pad_symbol_{idx:02}");
 -        asm.push_str(&format!("        .globl {symbol}\n"));
 -    }
 -    asm.push_str("        .p2align 2\n");
 -    asm.push_str("    _array_sum:\n        ret\n");
 -    asm.push_str("    _afs_array_sum:\n        ret\n");
 -    for idx in 0..20 {
 -        let symbol = format!("_pad_symbol_{idx:02}");
 -        asm.push_str(&format!("    {symbol}:\n        ret\n"));
 -    }
 -    asm.push_str("    _main:\n        bl _afs_array_sum\n        ret\n");
 -    asm.push_str("        .subsections_via_symbols\n");
 -    if let Err(e) = assemble(&asm, &obj) {
 +    let obj = scratch("icf-const-fold.o");
 +    let baseline_out = scratch("icf-const-fold-baseline.out");
 +    let our_out = scratch("icf-const-fold-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
++
 +        .section __TEXT,__const
 +        .p2align 3
 +        .private_extern _const1
 +        _const1:
 +            .quad 0x1122334455667788
 +        .p2align 3
 +        .private_extern _const2
 +        _const2:
 +            .quad 0x1122334455667788
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(src, &obj) {
          eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    apple_link(&obj, &apple_out, "_main", &sdk, &sdk_ver).unwrap();
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_const = output_section(&baseline_bytes, "__TEXT", "__const")
 +        .unwrap()
 +        .1;
 +    let our_const = output_section(&our_bytes, "__TEXT", "__const").unwrap().1;
++
 +    assert_ne!(
 +        baseline_symbols.get("_const1"),
 +        baseline_symbols.get("_const2"),
 +        "baseline link should keep identical private const atoms separate"
 +    );
      assert_eq!(
 -        canonical_symbol_records(&our_bytes),
 -        canonical_symbol_records(&apple_bytes)
 +        our_symbols.get("_const1"),
 +        our_symbols.get("_const2"),
 +        "expected afs-ld -icf=safe to coalesce identical private const atoms"
      );
 -    let our_strtab = raw_string_table(&our_bytes);
 -    let apple_strtab = raw_string_table(&apple_bytes);
 -    assert_strtab_within_five_percent(&our_strtab, &apple_strtab);
      assert!(
 -        our_strtab.len() <= apple_strtab.len(),
 -        "suffix dedup should not grow the output string table: ours={} apple={}",
 -        our_strtab.len(),
 -        apple_strtab.len()
 +        our_const.len() < baseline_const.len(),
 +        "expected -icf=safe to reduce const section size on identical atoms"
      );
 -    let offsets = symbol_name_offsets(&our_bytes);
 -    assert_eq!(offsets["_array_sum"], offsets["_afs_array_sum"] + 4);
+-
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_launches_with_classic_lazy_dylib_import() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun clang or codesign unavailable");
 -        return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +fn linker_run_icf_safe_folds_identical_private_cstrings() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let dylib = scratch("lazy-runtime.dylib");
 -    let obj = scratch("lazy-runtime.o");
 -    let out = scratch("lazy-runtime.out");
 +    let obj = scratch("icf-cstring-fold.o");
 +    let baseline_out = scratch("icf-cstring-fold-baseline.out");
 +    let our_out = scratch("icf-cstring-fold-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 -    let dylib_src = r#"
 -        int ext_fn(void) { return 7; }
 +        .section __TEXT,__cstring,cstring_literals
 +        .private_extern _str1
 +        _str1:
 +            .asciz "fold me"
 +        .private_extern _str2
 +        _str2:
 +            .asciz "fold me"
 +        .subsections_via_symbols
      "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 -    let main_src = r#"
 -        int ext_fn(void);
 -        int main(void) { return ext_fn() == 7 ? 0 : 1; }
 -    "#;
 -    if let Err(e) = compile_c(main_src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 -        return;
 -    }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd, dylib.clone()],
 -        output: Some(out.clone()),
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&out)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_cstrings = output_section(&baseline_bytes, "__TEXT", "__cstring")
 +        .unwrap()
 +        .1;
 +    let our_cstrings = output_section(&our_bytes, "__TEXT", "__cstring").unwrap().1;
++
 +    assert_ne!(
 +        baseline_symbols.get("_str1"),
 +        baseline_symbols.get("_str2"),
 +        "baseline link should keep identical private cstrings separate"
      );
 -    let status = Command::new(&out).status().unwrap();
      assert_eq!(
 -        status.code(),
 -        Some(0),
 -        "expected dylib-import executable to exit 0"
 +        our_symbols.get("_str1"),
 +        our_symbols.get("_str2"),
 +        "expected afs-ld -icf=safe to coalesce identical private cstrings"
 +    );
 +    assert!(
 +        our_cstrings.len() < baseline_cstrings.len(),
 +        "expected -icf=safe to reduce cstring section size on identical literals"
      );
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(baseline_out);
 +    let _ = fs::remove_file(our_out);
+ }
 -#[test]
 -fn linker_run_handles_local_tlv_descriptors() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun clang or codesign unavailable");
 -        return;
 -    }
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: xcrun --show-sdk-path unavailable");
 +#[test]
 +fn linker_run_icf_safe_folds_identical_private_literal16() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("tlvp-local.o");
 -    let out = scratch("tlvp-local.out");
 +    let obj = scratch("icf-literal16-fold.o");
 +    let baseline_out = scratch("icf-literal16-fold-baseline.out");
 +    let our_out = scratch("icf-literal16-fold-ours.out");
      let src = r#"
 -        __thread long tls_a = 7;
 -        __thread long tls_b;
+-
 -        static long tls_sum(void) {
 -            return tls_a + tls_b;
 -        }
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 -        int main(void) {
 -            return tls_sum() == 7 ? 0 : 1;
 -        }
 +        .section __TEXT,__literal16,16byte_literals
 +        .private_extern _lit1
 +        _lit1:
 +            .quad 0x1122334455667788
 +            .quad 0x99aabbccddeeff00
 +        .private_extern _lit2
 +        _lit2:
 +            .quad 0x1122334455667788
 +            .quad 0x99aabbccddeeff00
 +        .subsections_via_symbols
      "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd],
 -        output: Some(out.clone()),
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let bytes = fs::read(&out).unwrap();
 -    let (_, thread_vars) = output_section(&bytes, "__DATA", "__thread_vars").unwrap();
 -    let (_, thread_data) = output_section(&bytes, "__DATA", "__thread_data").unwrap();
 -    assert!(output_section(&bytes, "__DATA", "__thread_ptrs").is_none());
 -    assert_eq!(thread_vars.len(), 48);
 -    assert_eq!(thread_data.len(), 8);
 -    assert_eq!(
 -        u64::from_le_bytes(thread_vars[16..24].try_into().unwrap()),
 -        0
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_literals = output_section(&baseline_bytes, "__TEXT", "__literal16")
 +        .unwrap()
 +        .1;
 +    let our_literals = output_section(&our_bytes, "__TEXT", "__literal16")
 +        .unwrap()
 +        .1;
++
 +    assert_ne!(
 +        baseline_symbols.get("_lit1"),
 +        baseline_symbols.get("_lit2"),
 +        "baseline link should keep identical private literal16 atoms separate"
      );
      assert_eq!(
 -        u64::from_le_bytes(thread_vars[40..48].try_into().unwrap()),
 -        8
 +        our_symbols.get("_lit1"),
 +        our_symbols.get("_lit2"),
 +        "expected afs-ld -icf=safe to coalesce identical private literal16 atoms"
      );
+-
 -    let binds = decode_bind_records(&bytes, false).unwrap();
 -    let mut tlv_binds: Vec<_> = binds
 -        .into_iter()
 -        .filter(|record| record.section == "__thread_vars" && record.symbol == "__tlv_bootstrap")
 -        .collect();
 -    tlv_binds.sort_by_key(|record| record.section_offset);
 -    assert_eq!(tlv_binds.len(), 2);
 -    assert_eq!(tlv_binds[0].section_offset, 0);
 -    assert_eq!(tlv_binds[1].section_offset, 24);
+-
 -    let header = parse_header(&bytes).unwrap();
 -    let commands = parse_commands(&header, &bytes).unwrap();
 -    let symtab = commands
 -        .iter()
 -        .find_map(|cmd| match cmd {
 -            LoadCommand::Symtab(cmd) => Some(*cmd),
 -            _ => None,
 -        })
 -        .unwrap();
 -    let symbols = parse_nlist_table(&bytes, symtab.symoff, symtab.nsyms).unwrap();
 -    let strings = StringTable::from_file(&bytes, symtab.stroff, symtab.strsize).unwrap();
 -    let symbol_names: Vec<&str> = symbols
 -        .iter()
 -        .map(|symbol| strings.get(symbol.strx()).unwrap())
 -        .collect();
 -    assert!(symbol_names.contains(&"__tlv_bootstrap"));
+-
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&out)
 -        .output()
 -        .unwrap();
      assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 +        our_literals.len() < baseline_literals.len(),
 +        "expected -icf=safe to reduce literal16 section size on identical atoms"
      );
 -    let status = Command::new(&out).status().unwrap();
 -    assert_eq!(status.code(), Some(0), "expected TLV executable to exit 0");
      let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(out);
 +    let _ = fs::remove_file(baseline_out);
 +    let _ = fs::remove_file(our_out);
+ }
  #[test]
 -fn linker_run_routes_imported_tlv_through_got() {
 -    if !have_xcrun() || !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 Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: xcrun --show-sdk-version unavailable");
 +fn linker_run_icf_safe_folds_identical_private_data_const_atoms() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let dylib = scratch("libtlvprobe.dylib");
 -    let obj = scratch("imported-tlv.o");
 -    let our_out = scratch("imported-tlv-ours.out");
 -    let apple_out = scratch("imported-tlv-apple.out");
 +    let obj = scratch("icf-data-const-fold.o");
 +    let baseline_out = scratch("icf-data-const-fold-baseline.out");
 +    let our_out = scratch("icf-data-const-fold-ours.out");
 +    let src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            mov w0, #0
 +            ret
 -    let dylib_src = r#"
 -        __thread long ext_tls = 5;
 -        long read_lib_tls(void) { return ext_tls; }
 +        .section __DATA_CONST,__const
 +        .p2align 3
 +        .private_extern _const1
 +        _const1:
 +            .quad 0x0123456789abcdef
 +        .p2align 3
 +        .private_extern _const2
 +        _const2:
 +            .quad 0x0123456789abcdef
 +        .subsections_via_symbols
      "#;
 -    if let Err(e) = compile_dylib_c(dylib_src, &dylib) {
 -        eprintln!("skipping: dylib compile failed: {e}");
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 -    let main_src = r#"
 -        extern __thread long ext_tls;
 -        int main(void) { return ext_tls == 5 ? 0 : 1; }
 -    "#;
 -    if let Err(e) = compile_c(main_src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 -        return;
 -    }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), tbd.clone(), dylib.clone()],
 +        inputs: vec![obj.clone()],
          output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let apple = Command::new("xcrun")
 -        .args([
 -            "ld",
 -            "-arch",
 -            "arm64",
 -            "-platform_version",
 -            "macos",
 -            &sdk_ver,
 -            &sdk_ver,
 -            "-syslibroot",
 -            &sdk,
 -            "-no_fixup_chains",
 -            "-lSystem",
 -            "-e",
 -            "_main",
 -            "-o",
 -        ])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&dylib)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
+-
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    let (our_text_addr, our_text) = output_section(&our_bytes, "__TEXT", "__text").unwrap();
 -    let (apple_text_addr, apple_text) = output_section(&apple_bytes, "__TEXT", "__text").unwrap();
 -    let (our_got_addr, our_got) = output_section(&our_bytes, "__DATA_CONST", "__got").unwrap();
 -    let (apple_got_addr, apple_got) =
 -        output_section(&apple_bytes, "__DATA_CONST", "__got").unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_const = output_section(&baseline_bytes, "__DATA_CONST", "__const")
 +        .unwrap()
 +        .1;
 +    let our_const = output_section(&our_bytes, "__DATA_CONST", "__const")
 +        .unwrap()
 +        .1;
 -    assert!(output_section(&our_bytes, "__DATA", "__thread_ptrs").is_none());
 -    assert!(output_section(&apple_bytes, "__DATA", "__thread_ptrs").is_none());
 -    assert_eq!(our_got.len(), 8);
 -    assert_eq!(our_got, apple_got);
 -    assert_eq!(
 -        decode_page_reference(&our_text, our_text_addr, 20, &PageRefKind::Load).unwrap(),
 -        our_got_addr
 -    );
 -    assert_eq!(
 -        decode_page_reference(&apple_text, apple_text_addr, 20, &PageRefKind::Load).unwrap(),
 -        apple_got_addr
 -    );
 -    assert_eq!(our_text, apple_text);
 -    assert_eq!(read_insn(&our_text, 24).unwrap(), 0xf9400000);
 -    assert_eq!(read_insn(&our_text, 28).unwrap(), 0xf9400008);
 -    assert_eq!(read_insn(&our_text, 32).unwrap(), 0xd63f0100);
 -    assert_eq!(
 -        decode_bind_records(&our_bytes, false).unwrap(),
 -        decode_bind_records(&apple_bytes, false).unwrap()
 +    assert_ne!(
 +        baseline_symbols.get("_const1"),
 +        baseline_symbols.get("_const2"),
 +        "baseline link should keep identical private __DATA_CONST atoms separate"
      );
      assert_eq!(
 -        load_dylib_names(&our_bytes).unwrap(),
 -        load_dylib_names(&apple_bytes).unwrap()
 +        our_symbols.get("_const1"),
 +        our_symbols.get("_const2"),
 +        "expected afs-ld -icf=safe to coalesce identical private __DATA_CONST atoms"
      );
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&our_out)
 -        .output()
 -        .unwrap();
      assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 -    );
 -    let status = Command::new(&our_out).status().unwrap();
 -    assert_eq!(
 -        status.code(),
 -        Some(0),
 -        "expected imported TLV executable to exit 0"
 +        our_const.len() < baseline_const.len(),
 +        "expected -icf=safe to reduce __DATA_CONST,__const size on identical atoms"
      );
 -    let _ = fs::remove_file(dylib);
      let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(baseline_out);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
+ }
  #[test]
 -fn linker_run_preserves_runtime_tlv_descriptor_offsets() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun or codesign unavailable");
 -        return;
 -    }
 -    let Some(runtime) = find_runtime_archive() else {
 -        eprintln!("skipping: libarmfortas_rt.a not built");
 -        return;
 -    };
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: no macOS SDK path");
 -        return;
 -    };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: no macOS SDK version");
 +fn linker_run_icf_safe_reaches_fixed_point_through_folded_targets() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 -        return;
 -    }
 -    let obj = scratch("runtime-hello.o");
 -    let out = scratch("runtime-hello.out");
 -    let apple_out = scratch("runtime-hello-apple.out");
 +    let obj = scratch("icf-fixed-point.o");
 +    let baseline_out = scratch("icf-fixed-point-baseline.out");
 +    let our_out = scratch("icf-fixed-point-ours.out");
      let src = r#"
 -        extern void afs_program_init(void);
 -        extern void afs_program_finalize(void);
 -        extern void afs_write_string(int, const char *, long);
 -        extern void afs_write_newline(int);
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-32]!
 +            mov x29, sp
 +            bl _wrapper1
 +            str w0, [sp, #16]
 +            bl _wrapper2
 +            ldr w8, [sp, #16]
 +            add w0, w8, w0
 +            ldp x29, x30, [sp], #32
 +            ret
++
 +        .private_extern _wrapper1
 +        _wrapper1:
 +            b _leaf1
++
 +        .private_extern _wrapper2
 +        _wrapper2:
 +            b _leaf2
++
 +        .private_extern _leaf1
 +        _leaf1:
 +            mov w0, #6
 +            ret
 -        int main(void) {
 -            afs_program_init();
 -            afs_write_string(6, "Hello, World!", 13);
 -            afs_write_newline(6);
 -            afs_program_finalize();
 -            return 0;
 -        }
 +        .private_extern _leaf2
 +        _leaf2:
 +            mov w0, #6
 +            ret
 +        .subsections_via_symbols
      "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 +    if let Err(e) = assemble(src, &obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
+     }
 +    let baseline_opts = LinkOptions {
 +        inputs: vec![obj.clone()],
 +        output: Some(baseline_out.clone()),
 +        kind: OutputKind::Executable,
 +        ..LinkOptions::default()
 +    };
 +    Linker::run(&baseline_opts).unwrap();
++
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), runtime.clone(), tbd],
 -        output: Some(out.clone()),
 +        inputs: vec![obj.clone()],
 +        output: Some(our_out.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let apple = Command::new("xcrun")
 -        .args([
 -            "ld",
 -            "-arch",
 -            "arm64",
 -            "-platform_version",
 -            "macos",
 -            &sdk_ver,
 -            &sdk_ver,
 -            "-syslibroot",
 -            &sdk,
 -            "-lSystem",
 -            "-e",
 -            "_main",
 -            "-no_fixup_chains",
 -            "-o",
 -        ])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&runtime)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
+-
 -    let verify = Command::new("codesign")
 -        .arg("-v")
 -        .arg(&out)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        verify.status.success(),
 -        "codesign verify failed: {}",
 -        String::from_utf8_lossy(&verify.stderr)
 -    );
+-
 -    let bytes = fs::read(&out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    assert!(
 -        output_section(&bytes, "__DATA_CONST", "__const").is_some(),
 -        "runtime hello should promote file-backed __const data into __DATA_CONST"
 -    );
 -    assert!(
 -        output_section(&bytes, "__DATA", "__const").is_none(),
 -        "runtime hello should not leave file-backed __const data in __DATA"
 -    );
 -    let (thread_vars_addr, thread_vars) =
 -        output_section(&bytes, "__DATA", "__thread_vars").unwrap();
 -    let (thread_data_addr, _) = output_section(&bytes, "__DATA", "__thread_data").unwrap();
 -    let symbols = symbol_values(&bytes);
 -    let tlv_binds: Vec<_> = decode_bind_records(&bytes, false)
 +    let baseline_bytes = fs::read(&baseline_out).unwrap();
 +    let our_bytes = fs::read(&our_out).unwrap();
 +    let baseline_symbols = symbol_values(&baseline_bytes);
 +    let our_symbols = symbol_values(&our_bytes);
 +    let baseline_text = output_section(&baseline_bytes, "__TEXT", "__text")
          .unwrap()
 -        .into_iter()
 -        .filter(|record| record.section == "__thread_vars")
 -        .collect();
 -    assert_eq!(
 -        tlv_binds.len(),
 -        thread_vars.len() / 24,
 -        "every TLV descriptor should carry exactly one bootstrap bind"
 -    );
 -    assert!(tlv_binds
 -        .iter()
 -        .all(|record| record.symbol == "__tlv_bootstrap"));
 +        .1;
 +    let our_text = output_section(&our_bytes, "__TEXT", "__text").unwrap().1;
 -    assert_eq!(
 -        decode_bind_records(&bytes, false).unwrap(),
 -        decode_bind_records(&apple_bytes, false).unwrap(),
 -        "runtime hello bind records diverged from Apple ld"
 -    );
 -    assert_eq!(
 -        decode_bind_records(&bytes, true).unwrap(),
 -        decode_bind_records(&apple_bytes, true).unwrap(),
 -        "runtime hello lazy-bind records diverged from Apple ld"
 +    assert_ne!(
 +        baseline_symbols.get("_leaf1"),
 +        baseline_symbols.get("_leaf2"),
 +        "baseline link should keep equivalent leaves separate"
      );
 -    assert_eq!(
 -        decode_rebase_records(&bytes).unwrap(),
 -        decode_rebase_records(&apple_bytes).unwrap(),
 -        "runtime hello rebase records diverged from Apple ld"
 +    assert_ne!(
 +        baseline_symbols.get("_wrapper1"),
 +        baseline_symbols.get("_wrapper2"),
 +        "baseline link should keep wrappers separate"
      );
      assert_eq!(
 -        indirect_symbol_identities(&bytes),
 -        indirect_symbol_identities(&apple_bytes),
 -        "runtime hello indirect symbol identities diverged from Apple ld"
 +        our_symbols.get("_leaf1"),
 +        our_symbols.get("_leaf2"),
 +        "equivalent leaves should fold under -icf=safe"
      );
+-
 -    for (name, descriptor_addr) in symbols.iter().filter(|(name, value)| {
 -        !name.ends_with("$tlv$init")
 -            && **value >= thread_vars_addr
 -            && **value < thread_vars_addr + thread_vars.len() as u64
 -    }) {
 -        let init_name = format!("{name}$tlv$init");
 -        let Some(init_addr) = symbols.get(&init_name) else {
 -            continue;
 -        };
 -        let offset = (*descriptor_addr - thread_vars_addr) as usize;
 -        let actual = u64::from_le_bytes(thread_vars[offset + 16..offset + 24].try_into().unwrap());
 -        let expected = init_addr - thread_data_addr;
 -        assert_eq!(
 -            actual, expected,
 -            "TLV descriptor {} should point at {} via template offset",
 -            name, init_name
 -        );
 -    }
+-
 -    let output = Command::new(&out).output().unwrap();
 -    let apple_output = Command::new(&apple_out).output().unwrap();
      assert_eq!(
 -        output.status.code(),
 -        Some(0),
 -        "expected runtime hello executable to exit 0, stderr={}",
 -        String::from_utf8_lossy(&output.stderr)
 +        our_symbols.get("_wrapper1"),
 +        our_symbols.get("_wrapper2"),
 +        "wrappers should fold once their targets converge to the same winner"
      );
      assert_eq!(
 -        apple_output.status.code(),
 -        Some(0),
 -        "expected Apple-linked runtime hello executable to exit 0, stderr={}",
 -        String::from_utf8_lossy(&apple_output.stderr)
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(12),
 +        "fixed-point folded executable should preserve runtime behavior"
      );
 -    assert_eq!(
 -        String::from_utf8_lossy(&output.stdout),
 -        String::from_utf8_lossy(&apple_output.stdout)
 +    assert!(
 +        our_text.len() < baseline_text.len(),
 +        "expected fixed-point folding to reduce text size"
      );
      let _ = fs::remove_file(obj);
 -    let _ = fs::remove_file(out);
 -    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(baseline_out);
 +    let _ = fs::remove_file(our_out);
+ }
  #[test]
 -fn linker_run_rebases_runtime_init_metadata_like_apple_ld() {
 -    if !have_xcrun() || !have_tool("codesign") {
 -        eprintln!("skipping: xcrun or codesign unavailable");
 -        return;
 -    }
 -    let Some(runtime) = find_runtime_archive() else {
 -        eprintln!("skipping: libarmfortas_rt.a not built");
 -        return;
 -    };
 -    let Some(sdk) = sdk_path() else {
 -        eprintln!("skipping: no macOS SDK path");
 +fn linker_run_icf_safe_prefers_earlier_input_order_winner() {
 +    if !have_xcrun() {
 +        eprintln!("skipping: xcrun unavailable");
          return;
      };
 -    let Some(sdk_ver) = sdk_version() else {
 -        eprintln!("skipping: no macOS SDK version");
++
 +    let main_obj = scratch("icf-order-main.o");
 +    let first_obj = scratch("icf-order-first.o");
 +    let second_obj = scratch("icf-order-second.o");
 +    let our_out = scratch("icf-order-ours.out");
 +    let map = scratch("icf-order.map");
 +    let main_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            stp x29, x30, [sp, #-32]!
 +            mov x29, sp
 +            bl _helper_a
 +            str w0, [sp, #16]
 +            bl _helper_b
 +            ldr w8, [sp, #16]
 +            add w0, w8, w0
 +            ldp x29, x30, [sp], #32
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_a_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .private_extern _helper_a
 +        .globl _helper_a
 +        _helper_a:
 +            mov w0, #4
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    let helper_b_src = r#"
 +        .section __TEXT,__text,regular,pure_instructions
 +        .private_extern _helper_b
 +        .globl _helper_b
 +        _helper_b:
 +            mov w0, #4
 +            ret
 +        .subsections_via_symbols
 +    "#;
 +    if let Err(e) = assemble(main_src, &main_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
          return;
 -    };
 -    let tbd = PathBuf::from(format!("{sdk}/usr/lib/libSystem.tbd"));
 -    if !tbd.exists() {
 -        eprintln!("skipping: no libSystem.tbd at {}", tbd.display());
 +    }
 +    if let Err(e) = assemble(helper_a_src, &first_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
          return;
+     }
+-
 -    let obj = scratch("runtime-init-only.o");
 -    let our_out = scratch("runtime-init-only-ours.out");
 -    let apple_out = scratch("runtime-init-only-apple.out");
 -    let src = r#"
 -        extern void afs_program_init(void);
+-
 -        int main(void) {
 -            afs_program_init();
 -            return 0;
 -        }
 -    "#;
 -    if let Err(e) = compile_c(src, &obj) {
 -        eprintln!("skipping: compile failed: {e}");
 +    if let Err(e) = assemble(helper_b_src, &second_obj) {
 +        eprintln!("skipping: assemble failed: {e}");
 +        let _ = fs::remove_file(main_obj);
 +        let _ = fs::remove_file(first_obj);
          return;
+     }
      let opts = LinkOptions {
 -        inputs: vec![obj.clone(), runtime.clone(), tbd],
 +        inputs: vec![main_obj.clone(), first_obj.clone(), second_obj.clone()],
          output: Some(our_out.clone()),
 +        map: Some(map.clone()),
          kind: OutputKind::Executable,
 +        icf_mode: afs_ld::IcfMode::Safe,
          ..LinkOptions::default()
      };
      Linker::run(&opts).unwrap();
 -    let apple = Command::new("xcrun")
 -        .args([
 -            "ld",
 -            "-arch",
 -            "arm64",
 -            "-platform_version",
 -            "macos",
 -            &sdk_ver,
 -            &sdk_ver,
 -            "-syslibroot",
 -            &sdk,
 -            "-lSystem",
 -            "-e",
 -            "_main",
 -            "-no_fixup_chains",
 -            "-o",
 -        ])
 -        .arg(&apple_out)
 -        .arg(&obj)
 -        .arg(&runtime)
 -        .output()
 -        .unwrap();
 -    assert!(
 -        apple.status.success(),
 -        "xcrun ld failed: {}",
 -        String::from_utf8_lossy(&apple.stderr)
 -    );
+-
      let our_bytes = fs::read(&our_out).unwrap();
 -    let apple_bytes = fs::read(&apple_out).unwrap();
 -    let our_rebases = decode_rebase_records(&our_bytes).unwrap();
 -    let apple_rebases = decode_rebase_records(&apple_bytes).unwrap();
 +    let our_symbols = symbol_values(&our_bytes);
 +    let map_text = fs::read_to_string(&map).unwrap();
++
      assert_eq!(
 -        our_rebases
 -            .iter()
 -            .filter(|record| record.section == "__const")
 -            .count(),
 -        apple_rebases
 -            .iter()
 -            .filter(|record| record.section == "__const")
 -            .count(),
 -        "runtime init const rebases diverged from Apple ld"
 +        our_symbols.get("_helper_a"),
 +        our_symbols.get("_helper_b"),
 +        "equivalent helpers should fold to the same winner"
 +    );
 +    assert!(
 +        map_text.contains("_helper_b folded to _helper_a"),
 +        "earlier input should win safe-ICF ties:\n{map_text}"
      );
      assert_eq!(
 -        our_rebases
 -            .iter()
 -            .filter(|record| record.section == "__la_symbol_ptr")
 -            .count(),
 -        apple_rebases
 -            .iter()
 -            .filter(|record| record.section == "__la_symbol_ptr")
 -            .count(),
 -        "runtime init lazy-pointer rebases diverged from Apple ld"
 +        Command::new(&our_out).status().unwrap().code(),
 +        Some(8),
 +        "input-order folded executable should preserve runtime behavior"
      );
 -    let our_status = Command::new(&our_out).status().unwrap();
 -    let apple_status = Command::new(&apple_out).status().unwrap();
 -    assert_eq!(our_status.code(), Some(0));
 -    assert_eq!(apple_status.code(), Some(0));
+-
 -    let _ = fs::remove_file(obj);
 +    let _ = fs::remove_file(main_obj);
 +    let _ = fs::remove_file(first_obj);
 +    let _ = fs::remove_file(second_obj);
      let _ = fs::remove_file(our_out);
 -    let _ = fs::remove_file(apple_out);
 +    let _ = fs::remove_file(map);
+ }

tests/parity_canary.rsadded

43 lines changed — click to load

 +//! Intentional-regression guardrails for Sprint 27.
++
 +mod common;
++
 +use std::path::PathBuf;
++
 +use common::harness::{
 +    diff_macho, have_xcrun, have_xcrun_tool, link_both, load_corpus, output_section,
 +};
++
 +#[test]
 +fn mutated_text_byte_is_not_tolerated() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
++
 +    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
 +        .join("tests")
 +        .join("parity_corpus");
 +    let case = load_corpus(&root)
 +        .expect("load parity corpus")
 +        .into_iter()
 +        .find(|case| case.name == "hello_classic")
 +        .expect("hello_classic parity case");
++
 +    let outputs = link_both(&case).expect("link hello_classic with both linkers");
 +    let (_, mut our_text) =
 +        output_section(&outputs.ours, "__TEXT", "__text").expect("afs-ld __TEXT,__text");
 +    let (_, their_text) =
 +        output_section(&outputs.theirs, "__TEXT", "__text").expect("Apple __TEXT,__text");
++
 +    our_text[0] ^= 0x1;
 +    let report = diff_macho(&our_text, &their_text);
 +    assert!(
 +        !report.is_clean(),
 +        "mutated text byte should be reported as critical: {report:#?}"
 +    );
 +    assert!(
 +        !report.critical.is_empty(),
 +        "expected at least one critical diff after mutation: {report:#?}"
 +    );
 +}

tests/parity_corpus/archive_order_exec/args.txtadded

17 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:liba.a@
 +@ARTIFACT:libb.a@

tests/parity_corpus/archive_order_exec/artifacts.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+clang_archive a.c liba.a
	2	+clang_archive b.c libb.a

tests/parity_corpus/archive_order_exec/command_checks.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+build_version
	2	+load_dylib_names

tests/parity_corpus/archive_order_exec/inputs/a.cadded

5 lines changed — click to load

 +int mid(void);
++
 +int top(void) {
 +    return mid();
 +}

tests/parity_corpus/archive_order_exec/inputs/b.cadded

3 lines changed — click to load

 +int mid(void) {
 +    return 17;
 +}

tests/parity_corpus/archive_order_exec/inputs/main.cadded

5 lines changed — click to load

 +int top(void);
++
 +int main(void) {
 +    return top() == 17 ? 0 : 1;
 +}

tests/parity_corpus/archive_order_exec/notes.mdadded

3 lines changed — click to load

 +Multi-archive resolution parity case. `main` pulls `top` from the first archive,
 +and that object in turn requires `mid` from the second archive, so archive
 +fetch order must match Apple `ld`.

tests/parity_corpus/archive_order_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/archive_order_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/backtrace_metadata_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/backtrace_metadata_exec/command_checks.txtadded

4 lines changed — click to load

 +build_version
 +load_dylib_names
 +rebased_unwind_bytes
 +normalized_function_starts

tests/parity_corpus/backtrace_metadata_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/backtrace_metadata_exec/inputs/main.cadded

18 lines changed — click to load

 +#include <unwind.h>
++
 +static _Unwind_Reason_Code cb(struct _Unwind_Context* ctx, void* arg) {
 +    (void)ctx;
 +    int* count = (int*)arg;
 +    (*count)++;
 +    return *count >= 8 ? _URC_END_OF_STACK : _URC_NO_REASON;
 +}
++
 +__attribute__((noinline)) int helper(void) {
 +    int count = 0;
 +    _Unwind_Backtrace(cb, &count);
 +    return count;
 +}
++
 +int main(void) {
 +    return helper() > 1 ? 0 : 1;
 +}

tests/parity_corpus/backtrace_metadata_exec/notes.mdadded

3 lines changed — click to load

 +Backtrace-metadata parity case lifted from the existing Apple `ld` probe. This
 +keeps the Sprint 27 corpus honest about unwind bytes and normalized function
 +starts for a real `_Unwind_Backtrace` executable.

tests/parity_corpus/backtrace_metadata_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/classic_lazy_batched_got_calls/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/classic_lazy_batched_got_calls/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/classic_lazy_batched_got_calls/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/classic_lazy_batched_got_calls/inputs/main.sadded

14 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _write@GOTPAGE
 +            ldr x0, [x0, _write@GOTPAGEOFF]
 +            bl _write
 +            adrp x1, _close@GOTPAGE
 +            ldr x1, [x1, _close@GOTPAGEOFF]
 +            bl _close
 +            adrp x2, _read@GOTPAGE
 +            ldr x2, [x2, _read@GOTPAGEOFF]
 +            bl _read
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/classic_lazy_batched_got_calls/notes.mdadded

4 lines changed — click to load

 +Classic lazy-binding multi-import parity case lifted from the existing
 +`linker_run` matrix. This extends the Sprint 27 corpus around multiple distinct
 +lazy imports in one executable while keeping the Apple-parity dyld-info and
 +stub-surface checks in the dedicated harness.

tests/parity_corpus/classic_lazy_batched_got_calls/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/classic_lazy_branch_calls/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/classic_lazy_branch_calls/command_checks.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+build_version
	2	+load_dylib_names

tests/parity_corpus/classic_lazy_branch_calls/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/classic_lazy_branch_calls/inputs/main.sadded

8 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    bl _write
 +    bl _close
 +    bl _read
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/classic_lazy_branch_calls/notes.mdadded

4 lines changed — click to load

 +Classic lazy-binding executable parity case pulled from the existing
 +`linker_run` matrix. This verifies the dedicated Sprint 27 harness can compare
 +import-stub surfaces and dylib load-command contents, not just minimal hello
 +worlds.

tests/parity_corpus/classic_lazy_branch_calls/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/classic_lazy_branch_only_calls/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/classic_lazy_branch_only_calls/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/classic_lazy_branch_only_calls/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/classic_lazy_branch_only_calls/inputs/main.sadded

8 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _write
 +            bl _close
 +            bl _read
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/classic_lazy_branch_only_calls/notes.mdadded

4 lines changed — click to load

 +Classic lazy-binding branch-only parity case lifted from the existing
 +`linker_run` matrix. This rounds out the Sprint 27 classic-lazy corpus by
 +covering pure branch-driven imports without explicit GOT loads, while keeping
 +the Apple-parity dyld-info and stub-surface checks in the dedicated harness.

tests/parity_corpus/classic_lazy_branch_only_calls/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/classic_lazy_deduped_import/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/classic_lazy_deduped_import/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/classic_lazy_deduped_import/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/classic_lazy_deduped_import/inputs/main.sadded

11 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _write@GOTPAGE
 +            ldr x0, [x0, _write@GOTPAGEOFF]
 +            bl _write
 +            bl _write
 +            adrp x1, _write@GOTPAGE
 +            ldr x1, [x1, _write@GOTPAGEOFF]
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/classic_lazy_deduped_import/notes.mdadded

4 lines changed — click to load

 +Classic lazy-binding dedupe parity case lifted from the existing `linker_run`
 +matrix. This strengthens the Sprint 27 corpus around repeated imports of the
 +same symbol, while still comparing the Apple-parity dyld-info streams and stub
 +surfaces instead of only command IDs.

tests/parity_corpus/classic_lazy_deduped_import/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/common_symbol_promotion_exec/args.txtadded

17 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@INPUT:a.o@
 +@INPUT:b.o@

tests/parity_corpus/common_symbol_promotion_exec/command_checks.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+build_version
	2	+load_dylib_names

tests/parity_corpus/common_symbol_promotion_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_SEGMENT_64

tests/parity_corpus/common_symbol_promotion_exec/inputs/a.sadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+.comm _shared,8,3

tests/parity_corpus/common_symbol_promotion_exec/inputs/b.sadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+.comm _shared,8,3

tests/parity_corpus/common_symbol_promotion_exec/inputs/main.sadded

6 lines changed — click to load

 +.text
 +.globl _main
 +.p2align 2
 +_main:
 +    mov w0, #0
 +    ret

tests/parity_corpus/common_symbol_promotion_exec/notes.mdadded

3 lines changed — click to load

 +Common-symbol promotion parity case. Two objects contribute the same `.comm`
 +symbol, and the linked executable should promote that storage into the final
 +image and record it the same way Apple `ld` does.

tests/parity_corpus/common_symbol_promotion_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/common_symbol_promotion_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/data_in_code_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/data_in_code_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +data_in_code

tests/parity_corpus/data_in_code_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/data_in_code_exec/inputs/main.sadded

23 lines changed — click to load

 +.text
 +.globl _main
 +.p2align 2
 +_main:
 +    mov w0, #0
 +    b Ldispatch
 +    .p2align 2
 +Ltable:
 +    .data_region jt32
 +    .long Lcase0-Ltable
 +    .long Lcase1-Ltable
 +    .end_data_region
 +Ldispatch:
 +    cmp w0, #0
 +    b.eq Lcase0
 +    b Lcase1
 +Lcase0:
 +    mov w0, #1
 +    ret
 +Lcase1:
 +    mov w0, #2
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/data_in_code_exec/notes.mdadded

3 lines changed — click to load

 +Data-in-code parity case lifted from the existing Apple `ld` probe. This keeps
 +the Sprint 27 corpus honest about remapping a jump-table record in the primary
 +text section.

tests/parity_corpus/data_in_code_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/data_in_code_large_first_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/data_in_code_large_first_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +data_in_code

tests/parity_corpus/data_in_code_large_first_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/data_in_code_large_first_exec/inputs/main.sadded

28 lines changed — click to load

 +.text
 +.globl _main
 +.p2align 2
 +_main:
 +    nop
 +    nop
 +    nop
 +    nop
 +    nop
 +    ret
++
 +.section __TEXT,__text2,regular,pure_instructions
 +.globl _helper
 +_helper:
 +    b Ldispatch
 +    .p2align 2
 +Ltable:
 +    .data_region jt32
 +    .long Lcase0-Ltable
 +    .long Lcase1-Ltable
 +    .end_data_region
 +Ldispatch:
 +    ret
 +Lcase0:
 +    ret
 +Lcase1:
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/data_in_code_large_first_exec/notes.mdadded

3 lines changed — click to load

 +Data-in-code parity case lifted from the existing Apple `ld` probe with a large
 +first text section. This keeps the Sprint 27 corpus honest about remapping
 +later jump-table records after earlier text growth.

tests/parity_corpus/data_in_code_large_first_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/data_in_code_late_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/data_in_code_late_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +data_in_code

tests/parity_corpus/data_in_code_late_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/data_in_code_late_exec/inputs/main.sadded

24 lines changed — click to load

 +.text
 +.globl _main
 +.p2align 2
 +_main:
 +    ret
++
 +.section __TEXT,__text2,regular,pure_instructions
 +.globl _helper
 +.p2align 2
 +_helper:
 +    b Ldispatch
 +    .p2align 2
 +Ltable:
 +    .data_region jt32
 +    .long Lcase0-Ltable
 +    .long Lcase1-Ltable
 +    .end_data_region
 +Ldispatch:
 +    ret
 +Lcase0:
 +    ret
 +Lcase1:
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/data_in_code_late_exec/notes.mdadded

3 lines changed — click to load

 +Data-in-code parity case lifted from the existing Apple `ld` probe for a later
 +text section. This keeps the Sprint 27 corpus honest about remapping jump-table
 +records outside the primary text section.

tests/parity_corpus/data_in_code_late_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/dead_strip_import_exec/absent_sections.txtadded

4 lines changed — click to load

 +__TEXT __stubs
 +__TEXT __stub_helper
 +__DATA __la_symbol_ptr
 +__DATA_CONST __got

tests/parity_corpus/dead_strip_import_exec/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-dead_strip
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/dead_strip_import_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_bind

tests/parity_corpus/dead_strip_import_exec/inputs/main.sadded

12 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    mov w0, #0
 +    ret
++
 +.globl _unused
 +_unused:
 +    bl _puts
 +    mov w0, #0
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/dead_strip_import_exec/notes.mdadded

3 lines changed — click to load

 +Dead-strip synthetic-import parity case lifted from the Sprint 23 closeout
 +work. This keeps the Sprint 27 corpus honest about pruning unused synthetic
 +import sections when the importing atom is dead-stripped.

tests/parity_corpus/dead_strip_import_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/dead_strip_import_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_data/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@SDK_TBD:usr/lib/libSystem.tbd@
 +@ARTIFACT:libdirect.dylib@

tests/parity_corpus/direct_bind_data/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libdirect.c libdirect.dylib

tests/parity_corpus/direct_bind_data/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/direct_bind_data/inputs/libdirect.cadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+int ext_data = 5;

tests/parity_corpus/direct_bind_data/inputs/main.cadded

3 lines changed — click to load

 +extern int ext_data;
 +int *p = &ext_data;
 +int main(void) { return *p == 5 ? 0 : 1; }

tests/parity_corpus/direct_bind_data/notes.mdadded

3 lines changed — click to load

 +Direct-bind executable parity case lifted from the standalone data-import probe.
 +This keeps the Sprint 27 corpus honest about direct imported-data pointers even
 +when there is no paired imported function call.

tests/parity_corpus/direct_bind_data/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_data/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_deduped/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@SDK_TBD:usr/lib/libSystem.tbd@
 +@ARTIFACT:libdirect.dylib@

tests/parity_corpus/direct_bind_deduped/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libdirect.c libdirect.dylib

tests/parity_corpus/direct_bind_deduped/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/direct_bind_deduped/inputs/libdirect.cadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+int ext_data = 5;

tests/parity_corpus/direct_bind_deduped/inputs/main.cadded

4 lines changed — click to load

 +extern int ext_data;
 +int *p = &ext_data;
 +int *q = &ext_data;
 +int main(void) { return (*p == 5 && *q == 5) ? 0 : 1; }

tests/parity_corpus/direct_bind_deduped/notes.mdadded

3 lines changed — click to load

 +Direct-bind executable parity case lifted from the direct-bind fixture matrix.
 +This keeps the Sprint 27 corpus honest about repeated direct references to the
 +same imported data symbol.

tests/parity_corpus/direct_bind_deduped/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_deduped/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_mixed/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@SDK_TBD:usr/lib/libSystem.tbd@
 +@ARTIFACT:libdirect.dylib@

tests/parity_corpus/direct_bind_mixed/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libdirect.c libdirect.dylib

tests/parity_corpus/direct_bind_mixed/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/direct_bind_mixed/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_mixed/inputs/libdirect.cadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+int ext_data = 5;
	2	+int ext_fn(void) { return ext_data + 1; }

tests/parity_corpus/direct_bind_mixed/inputs/main.cadded

4 lines changed — click to load

 +extern int ext_data;
 +extern int ext_fn(void);
 +int *p = &ext_data;
 +int main(void) { return *p + ext_fn() == 11 ? 0 : 1; }

tests/parity_corpus/direct_bind_mixed/notes.mdadded

3 lines changed — click to load

 +Direct-bind executable parity case lifted from the existing fixture matrix.
 +This extends the Sprint 27 corpus to handle compiled dylib side artifacts and
 +checks the classic dyld-info streams Apple `ld` emits for direct imports.

tests/parity_corpus/direct_bind_mixed/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_mixed/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_multi_data/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@SDK_TBD:usr/lib/libSystem.tbd@
 +@ARTIFACT:libdirect.dylib@

tests/parity_corpus/direct_bind_multi_data/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libdirect.c libdirect.dylib

tests/parity_corpus/direct_bind_multi_data/command_checks.txtadded

6 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/direct_bind_multi_data/inputs/libdirect.cadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+int ext_data = 5;
	2	+int more_data = 9;

tests/parity_corpus/direct_bind_multi_data/inputs/main.cadded

5 lines changed — click to load

 +extern int ext_data;
 +extern int more_data;
 +int *p = &ext_data;
 +int *q = &more_data;
 +int main(void) { return (*p == 5 && *q == 9) ? 0 : 1; }

tests/parity_corpus/direct_bind_multi_data/notes.mdadded

3 lines changed — click to load

 +Direct-bind executable parity case lifted from the direct-bind fixture matrix.
 +This keeps the Sprint 27 corpus honest about multiple imported data pointers in
 +one executable.

tests/parity_corpus/direct_bind_multi_data/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/direct_bind_multi_data/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_bss_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-bss.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_bss_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_bss_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_bss_dylib/inputs/main.sadded

6 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _touch
 +        _touch:
 +            ret
 +        .zerofill __DATA,__bss,_global_bss,16,3
 +        .subsections_via_symbols

tests/parity_corpus/export_bss_dylib/notes.mdadded

4 lines changed — click to load

 +Exported-BSS dylib parity case lifted from the existing `linker_run` export
 +matrix. This broadens the Sprint 27 corpus into zerofill/export-trie behavior,
 +so the dedicated parity harness checks Apple agreement when an exported symbol
 +lives in `__DATA,__bss` instead of only text or initialized data.

tests/parity_corpus/export_bss_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_filter_dylib/args.txtadded

20 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-filter.dylib
 +-no_fixup_chains
 +-exported_symbol
 +_alpha
 +-exported_symbols_list
 +@FILE:exports.txt@
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_filter_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_filter_dylib/files/exports.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+_bet?

tests/parity_corpus/export_filter_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_filter_dylib/inputs/main.sadded

11 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _alpha
 +.globl _beta
 +.globl _gamma
 +_alpha:
 +    ret
 +_beta:
 +    ret
 +_gamma:
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/export_filter_dylib/notes.mdadded

4 lines changed — click to load

 +Export-filter dylib parity case lifted from the existing `linker_run` coverage.
 +This extends the Sprint 27 corpus to handle sidecar list files and verifies
 +that exported-symbol filtering matches Apple `ld` in both the export trie and
 +the final symtab surface.

tests/parity_corpus/export_filter_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_ordering_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-ordering.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_ordering_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_ordering_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_ordering_dylib/inputs/main.sadded

11 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _zeta
 +        _zeta:
 +            ret
 +        .globl _alpha
 +        _alpha:
 +            ret
 +        .globl _middle
 +        _middle:
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/export_ordering_dylib/notes.mdadded

4 lines changed — click to load

 +Export-ordering dylib parity case lifted from the existing `linker_run`
 +export matrix. This gives the Sprint 27 corpus a direct check that export trie
 +and final symtab ordering semantics stay in Apple-parity agreement even when
 +symbols are declared out of lexical order.

tests/parity_corpus/export_ordering_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_prefix_fanout_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-prefix-fanout.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_prefix_fanout_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_prefix_fanout_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_prefix_fanout_dylib/inputs/main.sadded

14 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _pre
 +        _pre:
 +            ret
 +        .globl _prefix
 +        _prefix:
 +            ret
 +        .globl _prefix_long
 +        _prefix_long:
 +            ret
 +        .globl _prefix_lone
 +        _prefix_lone:
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/export_prefix_fanout_dylib/notes.mdadded

4 lines changed — click to load

 +Shared-prefix dylib export parity case lifted from the existing `linker_run`
 +export matrix. This gives the Sprint 27 corpus a real export-trie fanout shape
 +where multiple exported symbols share a common prefix but diverge later,
 +without relying on export filtering to create the prefix structure.

tests/parity_corpus/export_prefix_fanout_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_shared_data_prefix_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-shared-data-prefix.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_shared_data_prefix_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_shared_data_prefix_dylib/inputs/main.sadded

12 lines changed — click to load

 +        .section __DATA,__data
 +        .p2align 3
 +        .globl _alpha_data
 +        _alpha_data:
 +            .quad 1
 +        .globl _alphabet_data
 +        _alphabet_data:
 +            .quad 2
 +        .globl _alphanumeric_data
 +        _alphanumeric_data:
 +            .quad 3
 +        .subsections_via_symbols

tests/parity_corpus/export_shared_data_prefix_dylib/notes.mdadded

4 lines changed — click to load

 +Shared-prefix data-only dylib export parity case lifted from the existing
 +`linker_run` export matrix. This closes the remaining obvious export-matrix gap
 +by checking Apple parity when all exported symbols live in `__DATA,__data` and
 +share a long common prefix.

tests/parity_corpus/export_shared_data_prefix_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_text_const_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-text-const.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_text_const_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_text_const_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_text_const_dylib/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _entry
 +        _entry:
 +            ret
 +        .section __TEXT,__const
 +        .p2align 3
 +        .globl _ro_value
 +        _ro_value:
 +            .quad 0xfeedface
 +        .subsections_via_symbols

tests/parity_corpus/export_text_const_dylib/notes.mdadded

4 lines changed — click to load

 +Mixed text-plus-const dylib export parity case lifted from the existing
 +`linker_run` export matrix. This expands the Sprint 27 corpus to cover export
 +surfaces where one exported symbol lives in `__TEXT,__const` rather than only
 +code, initialized data, or BSS.

tests/parity_corpus/export_text_const_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_text_data_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/export-text-data.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/export_text_data_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/export_text_data_dylib/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/export_text_data_dylib/inputs/main.sadded

13 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _code_symbol
 +        _code_symbol:
 +            ret
 +        .section __DATA,__data
 +        .p2align 3
 +        .globl _data_symbol
 +        _data_symbol:
 +            .quad 0x1234
 +        .globl _more_data
 +        _more_data:
 +            .long 7
 +        .subsections_via_symbols

tests/parity_corpus/export_text_data_dylib/notes.mdadded

4 lines changed — click to load

 +Mixed text-plus-data dylib export parity case lifted from the existing
 +`linker_run` export matrix. This broadens the Sprint 27 corpus beyond
 +text-only dylibs and checks that both the export trie and final symtab stay in
 +Apple-parity agreement when exported symbols live in different sections.

tests/parity_corpus/export_text_data_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/function_starts_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/function_starts_exec/command_checks.txtadded

4 lines changed — click to load

 +build_version
 +load_dylib_names
 +normalized_function_starts
 +data_in_code

tests/parity_corpus/function_starts_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/function_starts_exec/inputs/main.sadded

9 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +.p2align 2
 +_main:
 +    adrp x0, _write@GOTPAGE
 +    ldr x0, [x0, _write@GOTPAGEOFF]
 +    bl _write
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/function_starts_exec/notes.mdadded

3 lines changed — click to load

 +Function-starts parity case lifted from the existing Apple `ld` probe. This
 +keeps the Sprint 27 corpus honest about `LC_FUNCTION_STARTS` and the adjacent
 +data-in-code payload for a classic lazy-link executable.

tests/parity_corpus/function_starts_exec/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/function_starts_textcoal_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/function_starts_textcoal_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +normalized_function_starts

tests/parity_corpus/function_starts_textcoal_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/function_starts_textcoal_exec/inputs/main.sadded

12 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +.p2align 2
 +_main:
 +    ret
++
 +.section __TEXT,__textcoal_nt,regular,pure_instructions
 +.globl _helper
 +.p2align 2
 +_helper:
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/function_starts_textcoal_exec/notes.mdadded

3 lines changed — click to load

 +Function-starts parity case lifted from the existing Apple `ld` probe for a
 +second text section. This keeps the Sprint 27 corpus honest about recording
 +starts outside the primary `__TEXT,__text` section too.

tests/parity_corpus/function_starts_textcoal_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/hello_classic/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/hello_classic/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/hello_classic/inputs/main.sadded

6 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    mov x0, #0
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/hello_classic/notes.mdadded

3 lines changed — click to load

 +Classic executable hello-world seed case for the Sprint 27 differential
 +matrix. This starts the reusable on-disk corpus with the simplest runnable
 +shape we already expect to match Apple `ld`.

tests/parity_corpus/hello_classic/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/hello_classic/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/hello_dead_strip/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-dead_strip
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/hello_dead_strip/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/hello_dead_strip/inputs/main.sadded

6 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    mov x0, #0
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/hello_dead_strip/notes.mdadded

3 lines changed — click to load

 +Dead-strip executable seed case for the Sprint 27 differential matrix. This
 +exercises the new corpus path on a real post-Sprint-23 behavior knob without
 +dragging in a large multi-object fixture yet.

tests/parity_corpus/hello_dead_strip/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/hello_dead_strip/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/hidden_got_exec/absent_sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__DATA_CONST __got

tests/parity_corpus/hidden_got_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/hidden_got_exec/command_checks.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+build_version
	2	+load_dylib_names

tests/parity_corpus/hidden_got_exec/inputs/main.sadded

14 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    adrp x8, _value@GOTPAGE
 +    ldr x8, [x8, _value@GOTPAGEOFF]
 +    ldr w0, [x8]
 +    ret
++
 +.private_extern _value
 +.section __DATA,__data
 +.p2align 2
 +_value:
 +    .long 7
 +.subsections_via_symbols

tests/parity_corpus/hidden_got_exec/notes.mdadded

3 lines changed — click to load

 +Hidden-GOT relaxation parity case lifted from the existing Apple `ld` probe.
 +This keeps the Sprint 27 corpus honest about relaxing hidden GOT references to
 +direct page references and omitting the final `__got` section.

tests/parity_corpus/hidden_got_exec/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _value

tests/parity_corpus/hidden_got_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/hidden_got_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/imported_tlv_exec/absent_sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__DATA __thread_ptrs

tests/parity_corpus/imported_tlv_exec/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-no_fixup_chains
 +-lSystem
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:libtlvprobe.dylib@

tests/parity_corpus/imported_tlv_exec/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libtlvprobe.c libtlvprobe.dylib

tests/parity_corpus/imported_tlv_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/imported_tlv_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/imported_tlv_exec/inputs/libtlvprobe.cadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__thread long ext_tls = 5;
	2	+long read_lib_tls(void) { return ext_tls; }

tests/parity_corpus/imported_tlv_exec/inputs/main.cadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+extern __thread long ext_tls;
	2	+int main(void) { return ext_tls == 5 ? 0 : 1; }

tests/parity_corpus/imported_tlv_exec/notes.mdadded

3 lines changed — click to load

 +Imported TLV executable parity case lifted from the existing Apple `ld` probe.
 +This keeps the Sprint 27 corpus honest about routing imported TLV access
 +through the GOT while matching Apple in text bytes, GOT contents, and runtime.

tests/parity_corpus/imported_tlv_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/imported_tlv_exec/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __text
	2	+__DATA_CONST __got

tests/parity_corpus/local_got_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/local_got_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_bind

tests/parity_corpus/local_got_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_SEGMENT_64

tests/parity_corpus/local_got_exec/inputs/main.sadded

14 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    adrp x8, _value@GOTPAGE
 +    ldr x8, [x8, _value@GOTPAGEOFF]
 +    ldr w0, [x8]
 +    ret
++
 +.section __DATA,__data
 +.globl _value
 +.p2align 2
 +_value:
 +    .long 7
 +.subsections_via_symbols

tests/parity_corpus/local_got_exec/notes.mdadded

3 lines changed — click to load

 +Local GOT executable parity case lifted from the existing Apple `ld` probe.
 +This keeps the Sprint 27 corpus honest about classic local-GOT routing through
 +rebased slots while preserving runtime behavior.

tests/parity_corpus/local_got_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/local_got_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/local_rebase_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/local_rebase_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +dyld_info_rebase

tests/parity_corpus/local_rebase_exec/inputs/main.cadded

3 lines changed — click to load

 +int ext = 7;
 +int *p = &ext;
 +int main(void) { return *p == 7 ? 0 : 1; }

tests/parity_corpus/local_rebase_exec/notes.mdadded

3 lines changed — click to load

 +Local absolute-pointer executable parity case lifted from the existing Apple
 +`ld` probe. This keeps the Sprint 27 corpus honest about local pointer rebases
 +and the resulting runtime behavior.

tests/parity_corpus/local_rebase_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/local_rebase_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_add_dylib/absent_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LINKER_OPTIMIZATION_HINT

tests/parity_corpus/loh_adrp_add_dylib/args.txtadded

16 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-install_name
 +@rpath/liblohprobe.dylib
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/loh_adrp_add_dylib/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/loh_adrp_add_dylib/inputs/main.sadded

13 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _loh_probe
 +.globl _target
 +_loh_probe:
 +Lloh0:
 +    adrp x0, _target@PAGE
 +Lloh1:
 +    add x0, x0, _target@PAGEOFF
 +    ret
 +_target:
 +    ret
 +.loh AdrpAdd Lloh0, Lloh1
 +.subsections_via_symbols

tests/parity_corpus/loh_adrp_add_dylib/notes.mdadded

4 lines changed — click to load

 +LOH Apple-parity dylib case lifted from the Sprint 25 parity probes. This
 +keeps the dedicated matrix honest about the current Apple `ld` behavior for
 +dylib outputs too: preserve `ADRP+ADD` text and omit
 +`LC_LINKER_OPTIMIZATION_HINT`.

tests/parity_corpus/loh_adrp_add_dylib/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _target

tests/parity_corpus/loh_adrp_add_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_add_exec/absent_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LINKER_OPTIMIZATION_HINT

tests/parity_corpus/loh_adrp_add_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/loh_adrp_add_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/loh_adrp_add_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/loh_adrp_add_exec/inputs/main.sadded

14 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +.globl _target
 +_main:
 +Lloh0:
 +    adrp x0, _target@PAGE
 +Lloh1:
 +    add x0, x0, _target@PAGEOFF
 +    mov w0, #0
 +    ret
 +_target:
 +    ret
 +.loh AdrpAdd Lloh0, Lloh1
 +.subsections_via_symbols

tests/parity_corpus/loh_adrp_add_exec/notes.mdadded

4 lines changed — click to load

 +LOH Apple-parity executable case pulled from the Sprint 25 parity probes. This
 +keeps the dedicated matrix honest about the agreed Apple `ld` direction:
 +preserve `ADRP+ADD` text and omit `LC_LINKER_OPTIMIZATION_HINT` from the final
 +binary.

tests/parity_corpus/loh_adrp_add_exec/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _target

tests/parity_corpus/loh_adrp_add_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_add_exec/sections.txtadded

0 lines changed — click to load

tests/parity_corpus/loh_adrp_ldr_exec/absent_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LINKER_OPTIMIZATION_HINT

tests/parity_corpus/loh_adrp_ldr_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/loh_adrp_ldr_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/loh_adrp_ldr_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/loh_adrp_ldr_exec/inputs/main.sadded

15 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +.globl _target
 +_main:
 +Lloh0:
 +    adrp x0, _target@PAGE
 +Lloh1:
 +    ldr x1, [x0, _target@PAGEOFF]
 +    mov w0, #0
 +    ret
 +    .p2align 3
 +_target:
 +    .quad 0x1122334455667788
 +.loh AdrpLdr Lloh0, Lloh1
 +.subsections_via_symbols

tests/parity_corpus/loh_adrp_ldr_exec/notes.mdadded

4 lines changed — click to load

 +LOH Apple-parity executable case lifted from the Sprint 25 parity probes.
 +This keeps the dedicated matrix honest about the current Apple `ld` behavior:
 +preserve `ADRP+LDR` text and omit `LC_LINKER_OPTIMIZATION_HINT` from the final
 +binary.

tests/parity_corpus/loh_adrp_ldr_exec/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 load _target

tests/parity_corpus/loh_adrp_ldr_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_ldr_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/absent_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LINKER_OPTIMIZATION_HINT

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/ignored_load_commands.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+LC_SEGMENT_64
	2	+LC_LOAD_DYLIB

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/inputs/main.sadded

18 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +.globl _value
 +_main:
 +Lloh0:
 +    adrp x8, _value@GOTPAGE
 +Lloh1:
 +    ldr x8, [x8, _value@GOTPAGEOFF]
 +Lloh2:
 +    ldr w0, [x8]
 +    ret
++
 +.section __DATA,__data
 +.p2align 2
 +_value:
 +    .long 7
 +.loh AdrpLdrGotLdr Lloh0, Lloh1, Lloh2
 +.subsections_via_symbols

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/notes.mdadded

4 lines changed — click to load

 +LOH Apple-parity executable case lifted from the Sprint 25 parity probes.
 +This keeps the dedicated matrix honest about the agreed Apple direction for
 +local GOT-resolved `AdrpLdrGotLdr`: preserve the resolved `ADRP+ADD+LDR` shape
 +and omit `LC_LINKER_OPTIMIZATION_HINT`.

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _value

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/loh_adrp_ldr_got_ldr_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reexport_chain_exec/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:libmid.dylib@

tests/parity_corpus/reexport_chain_exec/artifacts.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+clang_dylib leaf.c libleaf.dylib
	2	+clang_reexport_dylib mid.c libmid.dylib libleaf.dylib

tests/parity_corpus/reexport_chain_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/reexport_chain_exec/inputs/leaf.cadded

3 lines changed — click to load

 +int leaf_value(void) {
 +    return 29;
 +}

tests/parity_corpus/reexport_chain_exec/inputs/main.cadded

5 lines changed — click to load

 +int mid_anchor(void);
++
 +int main(void) {
 +    return mid_anchor() == 0 ? 0 : 1;
 +}

tests/parity_corpus/reexport_chain_exec/inputs/mid.cadded

3 lines changed — click to load

 +int mid_anchor(void) {
 +    return 0;
 +}

tests/parity_corpus/reexport_chain_exec/notes.mdadded

4 lines changed — click to load

 +Dylib reexport-chain parity case. The executable links only the middle dylib,
 +which itself reexports a leaf dylib. The executable resolves a direct symbol
 +from the middle dylib while carrying the same dependency-chain surface Apple
 +`ld` produces.

tests/parity_corpus/reexport_chain_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reexport_chain_exec/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __text
	2	+__TEXT __stubs

tests/parity_corpus/reloc_adrp_add_backward/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_add_backward/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        _target:
 +            .quad 0x55
 +        .space 0x4ff8
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            add x0, x0, _target@PAGEOFF
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_add_backward/notes.mdadded

3 lines changed — click to load

 +Backward `adrp/add` page-reference parity case lifted from the legacy
 +relocation matrix. This keeps the shared corpus honest about negative-offset
 +page references as well as forward ones.

tests/parity_corpus/reloc_adrp_add_backward/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0x5000 add _target

tests/parity_corpus/reloc_adrp_add_backward/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_adrp_add_forward/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_add_forward/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            add x0, x0, _target@PAGEOFF
 +            ret
 +        .space 0x4ff4
 +        _target:
 +            .quad 0
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_add_forward/notes.mdadded

3 lines changed — click to load

 +Forward `adrp/add` page-reference parity case lifted from the legacy relocation
 +matrix. This checks that the shared Sprint 27 corpus can validate semantic page
 +references, not just exact section bytes.

tests/parity_corpus/reloc_adrp_add_forward/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _target

tests/parity_corpus/reloc_adrp_add_forward/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_adrp_ldr_w/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_ldr_w/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            ldr w1, [x0, _target@PAGEOFF]
 +            ret
 +        .space 0x2f4
 +        _target:
 +            .long 0x11223344
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_ldr_w/notes.mdadded

3 lines changed — click to load

 +`adrp/ldr w` page-reference parity case lifted from the legacy relocation
 +matrix. This keeps the shared Sprint 27 corpus growing across narrower load
 +widths, not just 64-bit loads.

tests/parity_corpus/reloc_adrp_ldr_w/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 load _target

tests/parity_corpus/reloc_adrp_ldr_w/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_adrp_ldr_x/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_ldr_x/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            ldr x1, [x0, _target@PAGEOFF]
 +            ret
 +        .space 0x3f4
 +        _target:
 +            .quad 0x1122334455667788
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_ldr_x/notes.mdadded

3 lines changed — click to load

 +`adrp/ldr x` page-reference parity case lifted from the legacy relocation
 +matrix. This expands the shared Sprint 27 corpus from branch and add-based
 +relocations into load-addressing semantics too.

tests/parity_corpus/reloc_adrp_ldr_x/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 load _target

tests/parity_corpus/reloc_adrp_ldr_x/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_adrp_ldrb/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_ldrb/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            ldrb w1, [x0, _target@PAGEOFF]
 +            ret
 +        .space 0xf4
 +        _target:
 +            .byte 0x44
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_ldrb/notes.mdadded

3 lines changed — click to load

 +`adrp/ldrb` page-reference parity case lifted from the legacy relocation
 +matrix. This completes the byte-width side of the current page-reference corpus
 +coverage.

tests/parity_corpus/reloc_adrp_ldrb/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 load _target

tests/parity_corpus/reloc_adrp_ldrb/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_adrp_ldrh/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_adrp_ldrh/inputs/main.sadded

10 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            adrp x0, _target@PAGE
 +            ldrh w1, [x0, _target@PAGEOFF]
 +            ret
 +        .space 0x1f4
 +        _target:
 +            .hword 0x3344
 +        .subsections_via_symbols

tests/parity_corpus/reloc_adrp_ldrh/notes.mdadded

3 lines changed — click to load

 +`adrp/ldrh` page-reference parity case lifted from the legacy relocation
 +matrix. This keeps the corpus honest for halfword loads too, not only word and
 +doubleword forms.

tests/parity_corpus/reloc_adrp_ldrh/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 load _target

tests/parity_corpus/reloc_adrp_ldrh/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_branch_and_subtractor/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_branch_and_subtractor/inputs/main.sadded

13 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .globl _main
 +        _main:
 +            bl _helper
 +            ret
 +        .section __TEXT,__const
 +        .p2align 3
 +        _delta:
 +            .quad _main - _helper
 +        .subsections_via_symbols

tests/parity_corpus/reloc_branch_and_subtractor/notes.mdadded

3 lines changed — click to load

 +Combined branch plus subtractor relocation parity case lifted from the legacy
 +matrix. This finishes the current subtractor trio in the shared Sprint 27
 +corpus and checks both `__TEXT,__text` and `__TEXT,__const` parity together.

tests/parity_corpus/reloc_branch_and_subtractor/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __text
	2	+__TEXT __const

tests/parity_corpus/reloc_branch_backward/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_branch_backward/inputs/main.sadded

9 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .globl _main
 +        _main:
 +            bl _helper
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/reloc_branch_backward/notes.mdadded

4 lines changed — click to load

 +Backward branch relocation parity case lifted from the existing
 +`relocated_sections_match_apple_ld_across_fixture_matrix` coverage. This keeps
 +the shared Sprint 27 corpus growing on the relocation side with a simple exact
 +`__TEXT,__text` byte-parity check after reloc application.

tests/parity_corpus/reloc_branch_backward/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/reloc_branch_forward/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_branch_forward/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_branch_forward/inputs/main.sadded

8 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        _main:
 +            bl _helper
 +            ret
 +        _helper:
 +            ret
 +        .subsections_via_symbols

tests/parity_corpus/reloc_branch_forward/notes.mdadded

5 lines changed — click to load

 +Forward branch relocation parity case lifted from the existing
 +`relocated_sections_match_apple_ld_across_fixture_matrix` coverage. This is the
 +first explicit relocation-matrix migration into the Sprint 27 corpus and keeps
 +the check intentionally simple: exact `__TEXT,__text` byte parity after reloc
 +application.

tests/parity_corpus/reloc_branch_forward/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_corpus/reloc_mixed_branch_adrp_text/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_mixed_branch_adrp_text/inputs/main.sadded

14 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _main
 +        .globl _helper
 +        _main:
 +            adrp x0, _target@PAGE
 +            add x0, x0, _target@PAGEOFF
 +            bl _helper
 +            ret
 +        _helper:
 +            ret
 +        .space 0xff0
 +        _target:
 +            .quad 0x99
 +        .subsections_via_symbols

tests/parity_corpus/reloc_mixed_branch_adrp_text/notes.mdadded

3 lines changed — click to load

 +Mixed branch-plus-`adrp/add` parity case lifted from the legacy relocation
 +matrix. This gives the shared Sprint 27 corpus one executable that exercises
 +both branch and page-reference relocation semantics together.

tests/parity_corpus/reloc_mixed_branch_adrp_text/page_refs.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text 0 add _target

tests/parity_corpus/reloc_mixed_branch_adrp_text/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/reloc_subtractor_negative/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_subtractor_negative/inputs/main.sadded

12 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .globl _main
 +        _main:
 +            ret
 +        .section __TEXT,__const
 +        .p2align 3
 +        _delta:
 +            .quad _main - _helper
 +        .subsections_via_symbols

tests/parity_corpus/reloc_subtractor_negative/notes.mdadded

3 lines changed — click to load

 +Negative subtractor relocation parity case lifted from the legacy relocation
 +matrix. This keeps the corpus honest on signed subtractor results as well as
 +positive ones.

tests/parity_corpus/reloc_subtractor_negative/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __const

tests/parity_corpus/reloc_subtractor_positive/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/reloc_subtractor_positive/inputs/main.sadded

13 lines changed — click to load

 +        .section __TEXT,__text,regular,pure_instructions
 +        .globl _helper
 +        _helper:
 +            ret
 +        .globl _main
 +        _main:
 +            bl _helper
 +            ret
 +        .section __TEXT,__const
 +        .p2align 3
 +        _delta:
 +            .quad _helper - _main
 +        .subsections_via_symbols

tests/parity_corpus/reloc_subtractor_positive/notes.mdadded

3 lines changed — click to load

 +Positive subtractor relocation parity case lifted from the legacy relocation
 +matrix. This extends the shared corpus beyond code relocs into absolute
 +subtractor expressions materialized in `__TEXT,__const`.

tests/parity_corpus/reloc_subtractor_positive/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __const

tests/parity_corpus/runtime_fortran_three_func_exec/args.txtadded

16 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@FILE:libarmfortas_rt.a@

tests/parity_corpus/runtime_fortran_three_func_exec/command_checks.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+build_version
	2	+load_dylib_names

tests/parity_corpus/runtime_fortran_three_func_exec/files/libarmfortas_rt.aadded

Binary file changed.

tests/parity_corpus/runtime_fortran_three_func_exec/files/source.f90added

18 lines changed — click to load

 +program main
 +  integer :: v
 +  v = add3(7)
 +contains
 +  integer function add3(x)
 +    integer, intent(in) :: x
 +    add3 = twice(x) + one()
 +  end function add3
++
 +  integer function twice(x)
 +    integer, intent(in) :: x
 +    twice = x + x
 +  end function twice
++
 +  integer function one()
 +    one = 8
 +  end function one
 +end program main

tests/parity_corpus/runtime_fortran_three_func_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_SEGMENT_64

tests/parity_corpus/runtime_fortran_three_func_exec/inputs/main.oadded

Binary file changed.

tests/parity_corpus/runtime_fortran_three_func_exec/notes.mdadded

4 lines changed — click to load

 +Minimal runtime parity case for a three-function Fortran program. The input
 +object is compiled with `armfortas`, and the sidecar `libarmfortas_rt.a` is a
 +real archive copied from the runtime build so this scenario stays standalone
 +inside the `afs-ld` repo.

tests/parity_corpus/runtime_fortran_three_func_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/runtime_fortran_three_func_exec/sections.txtadded

0 lines changed — click to load

tests/parity_corpus/strip_locals_exec/args.txtadded

10 lines changed — click to load

 +-arch
 +arm64
 +-x
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:libsymtab.dylib@

tests/parity_corpus/strip_locals_exec/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libsymtab.c libsymtab.dylib

tests/parity_corpus/strip_locals_exec/command_checks.txtadded

4 lines changed — click to load

 +load_dylib_names
 +symbol_record_map
 +symbol_partition_names
 +string_table_near_parity

tests/parity_corpus/strip_locals_exec/inputs/libsymtab.cadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+int ext_data = 5;

tests/parity_corpus/strip_locals_exec/inputs/main.sadded

17 lines changed — click to load

 +.text
 +.private_extern _hidden
 +.globl _visible
 +.globl _main
 +.p2align 2
 +_local:
 +    ret
 +_hidden:
 +    ret
 +_visible:
 +    ret
 +_main:
 +    ret
++
 +.data
 +.quad _ext_data
 +.subsections_via_symbols

tests/parity_corpus/strip_locals_exec/notes.mdadded

3 lines changed — click to load

 +`-x` symtab parity case lifted from the existing Apple `ld` probe. This keeps
 +the Sprint 27 corpus honest about stripping locals while preserving the
 +remaining external and undefined symbol partitions.

tests/parity_corpus/strip_locals_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/symtab_partition_exec/args.txtadded

9 lines changed — click to load

 +-arch
 +arm64
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:libsymtab.dylib@

tests/parity_corpus/symtab_partition_exec/artifacts.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+clang_dylib libsymtab.c libsymtab.dylib

tests/parity_corpus/symtab_partition_exec/command_checks.txtadded

4 lines changed — click to load

 +load_dylib_names
 +symbol_record_map
 +symbol_partition_names
 +string_table_near_parity

tests/parity_corpus/symtab_partition_exec/inputs/libsymtab.cadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+int ext_data = 5;

tests/parity_corpus/symtab_partition_exec/inputs/main.sadded

17 lines changed — click to load

 +.text
 +.private_extern _hidden
 +.globl _visible
 +.globl _main
 +.p2align 2
 +_local:
 +    ret
 +_hidden:
 +    ret
 +_visible:
 +    ret
 +_main:
 +    ret
++
 +.data
 +.quad _ext_data
 +.subsections_via_symbols

tests/parity_corpus/symtab_partition_exec/notes.mdadded

3 lines changed — click to load

 +Symtab partition parity case lifted from the existing Apple `ld` probe. This
 +keeps the Sprint 27 corpus honest about local/extdef/undef partitioning and
 +string-table size staying near Apple `ld` on a dylib-import executable.

tests/parity_corpus/symtab_partition_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/synthetic_import_classic_lazy/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/synthetic_import_classic_lazy/command_checks.txtadded

7 lines changed — click to load

 +build_version
 +load_dylib_names
 +indirect_symbol_identities
 +dyld_info_rebase
 +dyld_info_bind
 +dyld_info_weak_bind
 +dyld_info_lazy_bind

tests/parity_corpus/synthetic_import_classic_lazy/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/synthetic_import_classic_lazy/inputs/main.sadded

8 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _main
 +_main:
 +    adrp x0, _write@GOTPAGE
 +    ldr x0, [x0, _write@GOTPAGEOFF]
 +    bl _write
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/synthetic_import_classic_lazy/notes.mdadded

3 lines changed — click to load

 +Synthetic-import classic-lazy parity case lifted from the dedicated Apple `ld`
 +probe. This keeps the Sprint 27 corpus honest about stub surfaces, dyld-info
 +streams, and indirect-symbol identities for the synthetic import path.

tests/parity_corpus/synthetic_import_classic_lazy/sections.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+__TEXT __stubs
	2	+__TEXT __stub_helper

tests/parity_corpus/unexport_filter_dylib/args.txtadded

18 lines changed — click to load

 +-dylib
 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-unexported_symbol
 +_gamma
 +-unexported_symbols_list
 +@FILE:hidden.txt@
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/unexport_filter_dylib/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +export_records
 +symbol_record_map

tests/parity_corpus/unexport_filter_dylib/files/hidden.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+_bet?

tests/parity_corpus/unexport_filter_dylib/inputs/main.sadded

11 lines changed — click to load

 +.section __TEXT,__text,regular,pure_instructions
 +.globl _alpha
 +.globl _beta
 +.globl _gamma
 +_alpha:
 +    ret
 +_beta:
 +    ret
 +_gamma:
 +    ret
 +.subsections_via_symbols

tests/parity_corpus/unexport_filter_dylib/notes.mdadded

4 lines changed — click to load

 +Unexport-filter dylib parity case lifted from the existing `linker_run`
 +coverage. This keeps the Sprint 27 corpus honest about `-unexported_symbol`
 +and `-unexported_symbols_list` matching Apple `ld` in both the export trie and
 +the final symtab surface.

tests/parity_corpus/unexport_filter_dylib/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/unwind_leaf_exec/absent_sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__LD __compact_unwind

tests/parity_corpus/unwind_leaf_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/unwind_leaf_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +rebased_unwind_bytes

tests/parity_corpus/unwind_leaf_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/unwind_leaf_exec/inputs/main.cadded

3 lines changed — click to load

 +int main(void) {
 +    return 0;
 +}

tests/parity_corpus/unwind_leaf_exec/notes.mdadded

3 lines changed — click to load

 +Leaf unwind-info parity case lifted from the existing Apple `ld` probe. This
 +keeps the Sprint 27 corpus honest about rebased `__unwind_info` bytes for the
 +smallest executable shape.

tests/parity_corpus/unwind_leaf_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/unwind_multi_exec/absent_sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__LD __compact_unwind

tests/parity_corpus/unwind_multi_exec/args.txtadded

15 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-no_fixup_chains
 +-e
 +_main
 +-o
 +@OUT@
 +@INPUT:main.o@

tests/parity_corpus/unwind_multi_exec/command_checks.txtadded

3 lines changed — click to load

 +build_version
 +load_dylib_names
 +rebased_unwind_bytes

tests/parity_corpus/unwind_multi_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_LOAD_DYLIB

tests/parity_corpus/unwind_multi_exec/inputs/main.cadded

7 lines changed — click to load

 +int helper(void) {
 +    return 1;
 +}
++
 +int main(void) {
 +    return helper();
 +}

tests/parity_corpus/unwind_multi_exec/notes.mdadded

3 lines changed — click to load

 +Multi-function unwind-info parity case lifted from the existing Apple `ld`
 +probe. This keeps the Sprint 27 corpus honest about rebased `__unwind_info`
 +bytes when more than one function contributes unwind metadata.

tests/parity_corpus/unwind_multi_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/weak_def_coalescing_exec/args.txtadded

17 lines changed — click to load

 +-arch
 +arm64
 +-platform_version
 +macos
 +@SDK_VERSION@
 +@SDK_VERSION@
 +-syslibroot
 +@SDK_PATH@
 +-lSystem
 +-e
 +_main
 +-no_fixup_chains
 +-o
 +@OUT@
 +@INPUT:main.o@
 +@ARTIFACT:libweak_a.dylib@
 +@ARTIFACT:libweak_b.dylib@

tests/parity_corpus/weak_def_coalescing_exec/artifacts.txtadded

2 lines changed — click to load

`@@ -0,0 +1,2 @@`
	1	+clang_dylib weak_a.c libweak_a.dylib
	2	+clang_dylib weak_b.c libweak_b.dylib

tests/parity_corpus/weak_def_coalescing_exec/command_checks.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+build_version

tests/parity_corpus/weak_def_coalescing_exec/ignored_load_commands.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+LC_SEGMENT_64

tests/parity_corpus/weak_def_coalescing_exec/inputs/main.cadded

5 lines changed — click to load

 +int shared(void);
++
 +int main(void) {
 +    return shared() == 17 ? 0 : 1;
 +}

tests/parity_corpus/weak_def_coalescing_exec/inputs/weak_a.cadded

3 lines changed — click to load

 +__attribute__((weak)) int shared(void) {
 +    return 17;
 +}

tests/parity_corpus/weak_def_coalescing_exec/inputs/weak_b.cadded

3 lines changed — click to load

 +__attribute__((weak)) int shared(void) {
 +    return 23;
 +}

tests/parity_corpus/weak_def_coalescing_exec/notes.mdadded

3 lines changed — click to load

 +Weak-definition coalescing parity case. The executable links two dylibs that
 +both export the same weak definition, and the final image plus runtime
 +resolution should follow the same winner Apple `ld` chooses.

tests/parity_corpus/weak_def_coalescing_exec/runtime.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+

tests/parity_corpus/weak_def_coalescing_exec/sections.txtadded

1 lines changed — click to load

`@@ -0,0 +1,1 @@`
	1	+__TEXT __text

tests/parity_harness.rsadded

66 lines changed — click to load

 +//! Focused tests for Sprint 27 harness glue.
++
 +mod common;
++
 +use common::harness::{
 +    apply_section_tolerances, diff_macho, parse_case_tolerances, string_table_within_five_percent,
 +};
++
 +#[test]
 +fn notes_tolerance_block_parses_section_range() {
 +    let notes = r#"
 +tolerated:
 +  - region: __TEXT,__text bytes 0x1-0x3 reason: "known padding drift"
 +"#;
 +    let tolerances = parse_case_tolerances(Some(notes)).expect("parse case tolerances");
 +    assert_eq!(tolerances.len(), 1);
 +    assert_eq!(tolerances[0].reason, "known padding drift");
 +}
++
 +#[test]
 +fn notes_tolerance_can_hide_section_byte_diff() {
 +    let notes = r#"
 +tolerated:
 +  - region: __TEXT,__text bytes 0x1-0x1 reason: "known one-byte drift"
 +"#;
 +    let tolerances = parse_case_tolerances(Some(notes)).expect("parse case tolerances");
 +    let diff = diff_macho(b"abc", b"adc");
 +    let filtered = apply_section_tolerances(diff, "__TEXT", "__text", &tolerances);
 +    assert!(
 +        filtered.is_clean(),
 +        "expected tolerance to absorb diff: {filtered:#?}"
 +    );
 +    assert_eq!(filtered.tolerated.len(), 1);
 +}
++
 +#[test]
 +fn notes_tolerance_does_not_hide_other_sections() {
 +    let notes = r#"
 +tolerated:
 +  - region: __TEXT,__text bytes 0x1-0x1 reason: "known one-byte drift"
 +"#;
 +    let tolerances = parse_case_tolerances(Some(notes)).expect("parse case tolerances");
 +    let diff = diff_macho(b"abc", b"adc");
 +    let filtered = apply_section_tolerances(diff, "__DATA", "__data", &tolerances);
 +    assert!(
 +        !filtered.is_clean(),
 +        "unexpectedly tolerated unrelated diff: {filtered:#?}"
 +    );
 +    assert_eq!(filtered.critical.len(), 1);
 +}
++
 +#[test]
 +fn string_table_near_parity_accepts_small_suffix_dedup_drift() {
 +    assert!(
 +        string_table_within_five_percent(101, 100),
 +        "1% string-table drift should stay within the Sprint 27 allowance"
 +    );
 +}
++
 +#[test]
 +fn string_table_near_parity_rejects_large_suffix_dedup_drift() {
 +    assert!(
 +        !string_table_within_five_percent(120, 100),
 +        "20% string-table drift should fail the Sprint 27 allowance"
 +    );
 +}

tests/parity_matrix.rsadded

286 lines changed — click to load

 +//! Differential parity matrix against Apple `ld`.
 +//!
 +//! Sprint 27 starts with a tiny executable-only corpus so the reusable harness,
 +//! on-disk case format, and runtime parity path all exist before we scale up to
 +//! the full corpus promised by the sprint doc.
++
 +mod common;
++
 +use std::fs;
 +use std::path::{Path, PathBuf};
 +use std::time::{Duration, Instant};
++
 +use common::harness::{
 +    compare_command_details, compare_command_ids, compare_page_refs, compare_runtime,
 +    compare_sections, ensure_absent_load_commands, ensure_absent_sections, have_xcrun,
 +    have_xcrun_tool, link_both, load_corpus, LinkCase,
 +};
++
 +#[test]
 +fn parity_corpus() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let started = Instant::now();
++
 +    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
 +        .join("tests")
 +        .join("parity_corpus");
 +    let cases = load_corpus(&root).expect("load parity corpus");
 +    assert!(
 +        cases.len() >= 50,
 +        "expected at least 50 parity corpus cases under {}, found {}",
 +        root.display(),
 +        cases.len()
 +    );
++
 +    let artifact_dir = std::env::var_os("PARITY_MATRIX_ARTIFACT_DIR").map(PathBuf::from);
 +    if let Some(dir) = artifact_dir.as_ref() {
 +        fs::create_dir_all(dir).expect("create parity artifact dir");
 +    }
++
 +    let mut case_reports = Vec::new();
 +    let mut failures = Vec::new();
++
 +    for case in cases {
 +        let report = run_case(&case);
 +        if let Some(dir) = artifact_dir.as_ref() {
 +            write_case_artifact(dir, &case, &report).expect("write case artifact");
 +        }
 +        if let Some(error) = report.error_message() {
 +            failures.push(error);
 +        }
 +        case_reports.push((case, report));
 +    }
++
 +    if let Some(dir) = artifact_dir.as_ref() {
 +        write_index_artifact(dir, &case_reports).expect("write parity index");
 +    }
++
 +    assert!(
 +        failures.is_empty(),
 +        "Parity matrix failures ({} cases):\n{}",
 +        failures.len(),
 +        failures.join("\n\n")
 +    );
++
 +    if let Some(limit) = parity_matrix_time_limit() {
 +        let elapsed = started.elapsed();
 +        assert!(
 +            elapsed <= limit,
 +            "parity matrix exceeded scale budget: {:?} > {:?}",
 +            elapsed,
 +            limit
 +        );
 +    }
 +}
++
 +#[derive(Debug)]
 +struct CaseStep {
 +    name: &'static str,
 +    error: Option<String>,
 +}
++
 +#[derive(Debug, Default)]
 +struct CaseReport {
 +    steps: Vec<CaseStep>,
 +}
++
 +impl CaseReport {
 +    fn push(&mut self, name: &'static str, result: Result<(), String>) -> bool {
 +        match result {
 +            Ok(()) => {
 +                self.steps.push(CaseStep { name, error: None });
 +                true
 +            }
 +            Err(error) => {
 +                self.steps.push(CaseStep {
 +                    name,
 +                    error: Some(error),
 +                });
 +                false
 +            }
 +        }
 +    }
++
 +    fn passed(&self) -> bool {
 +        self.steps.iter().all(|step| step.error.is_none())
 +    }
++
 +    fn error_message(&self) -> Option<String> {
 +        self.steps.iter().find_map(|step| {
 +            step.error
 +                .as_ref()
 +                .map(|error| format!("{} failed:\n{}", step.name, error))
 +        })
 +    }
 +}
++
 +fn run_case(case: &LinkCase) -> CaseReport {
 +    let mut report = CaseReport::default();
 +    let outputs = match link_both(case) {
 +        Ok(outputs) => {
 +            report.push("link", Ok(()));
 +            outputs
 +        }
 +        Err(error) => {
 +            report.push(
 +                "link",
 +                Err(format!(
 +                    "failed to link parity case from {}:\n{}",
 +                    case.dir.display(),
 +                    error
 +                )),
 +            );
 +            return report;
 +        }
 +    };
++
 +    if !report.push(
 +        "load-command ids",
 +        compare_command_ids(&outputs.ours, &outputs.theirs, &case.ignored_load_commands),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "command details",
 +        compare_command_details(&outputs.ours, &outputs.theirs, &case.command_checks),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "afs-ld absent commands",
 +        ensure_absent_load_commands(&outputs.ours, &case.absent_load_commands, "afs-ld"),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "Apple absent commands",
 +        ensure_absent_load_commands(&outputs.theirs, &case.absent_load_commands, "Apple ld"),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "afs-ld absent sections",
 +        ensure_absent_sections(&outputs.ours, &case.absent_sections, "afs-ld"),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "Apple absent sections",
 +        ensure_absent_sections(&outputs.theirs, &case.absent_sections, "Apple ld"),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "section parity",
 +        compare_sections(
 +            &outputs.ours,
 +            &outputs.theirs,
 +            &case.section_checks,
 +            &case.case_tolerances,
 +        ),
 +    ) {
 +        return report;
 +    }
 +    if !report.push(
 +        "page-ref parity",
 +        compare_page_refs(&outputs.ours, &outputs.theirs, &case.page_ref_checks),
 +    ) {
 +        return report;
 +    }
 +    if !case.runtime_args.is_empty() || case.dir.join("runtime.txt").exists() {
 +        report.push(
 +            "runtime parity",
 +            compare_runtime(&outputs.our_path, &outputs.their_path, &case.runtime_args),
 +        );
 +    }
++
 +    report
 +}
++
 +fn write_case_artifact(dir: &Path, case: &LinkCase, report: &CaseReport) -> Result<(), String> {
 +    let path = dir.join(format!("{}.html", slug(&case.name)));
 +    let mut html = String::new();
 +    html.push_str("<!doctype html><html><head><meta charset=\"utf-8\">");
 +    html.push_str(&format!(
 +        "<title>{}</title><style>body{{font-family:ui-monospace,Menlo,monospace;padding:2rem;}} .ok{{color:#0a0;}} .fail{{color:#a00;}} pre{{background:#f6f8fa;padding:1rem;white-space:pre-wrap;}}</style></head><body>",
 +        escape_html(&case.name)
 +    ));
 +    html.push_str(&format!("<h1>{}</h1>", escape_html(&case.name)));
 +    html.push_str(&format!(
 +        "<p>Status: <strong class=\"{}\">{}</strong></p>",
 +        if report.passed() { "ok" } else { "fail" },
 +        if report.passed() { "PASS" } else { "FAIL" }
 +    ));
 +    html.push_str("<h2>Steps</h2><ul>");
 +    for step in &report.steps {
 +        match &step.error {
 +            None => html.push_str(&format!(
 +                "<li><span class=\"ok\">PASS</span> {}</li>",
 +                escape_html(step.name)
 +            )),
 +            Some(error) => html.push_str(&format!(
 +                "<li><span class=\"fail\">FAIL</span> {}<pre>{}</pre></li>",
 +                escape_html(step.name),
 +                escape_html(error)
 +            )),
 +        }
 +    }
 +    html.push_str("</ul>");
 +    html.push_str("<h2>Args</h2><pre>");
 +    html.push_str(&escape_html(&case.args.join("\n")));
 +    html.push_str("</pre>");
 +    if let Some(notes) = &case.notes {
 +        html.push_str("<h2>Notes</h2><pre>");
 +        html.push_str(&escape_html(notes));
 +        html.push_str("</pre>");
 +    }
 +    html.push_str("</body></html>");
 +    fs::write(&path, html).map_err(|e| format!("write {}: {e}", path.display()))
 +}
++
 +fn write_index_artifact(dir: &Path, cases: &[(LinkCase, CaseReport)]) -> Result<(), String> {
 +    let mut html = String::new();
 +    html.push_str("<!doctype html><html><head><meta charset=\"utf-8\">");
 +    html.push_str("<title>Parity Matrix</title><style>body{font-family:ui-monospace,Menlo,monospace;padding:2rem;} .ok{color:#0a0;} .fail{color:#a00;}</style></head><body>");
 +    html.push_str("<h1>Parity Matrix</h1><ul>");
 +    for (case, report) in cases {
 +        let slug = slug(&case.name);
 +        html.push_str(&format!(
 +            "<li><a href=\"{}.html\">{}</a> <strong class=\"{}\">{}</strong></li>",
 +            slug,
 +            escape_html(&case.name),
 +            if report.passed() { "ok" } else { "fail" },
 +            if report.passed() { "PASS" } else { "FAIL" }
 +        ));
 +    }
 +    html.push_str("</ul></body></html>");
 +    let path = dir.join("index.html");
 +    fs::write(&path, html).map_err(|e| format!("write {}: {e}", path.display()))
 +}
++
 +fn slug(name: &str) -> String {
 +    name.chars()
 +        .map(|ch| {
 +            if ch.is_ascii_alphanumeric() {
 +                ch.to_ascii_lowercase()
 +            } else {
 +                '-'
 +            }
 +        })
 +        .collect()
 +}
++
 +fn parity_matrix_time_limit() -> Option<Duration> {
 +    let raw = std::env::var("PARITY_MATRIX_MAX_SECONDS").ok()?;
 +    let seconds = raw.parse::<u64>().ok()?;
 +    Some(Duration::from_secs(seconds))
 +}
++
 +fn escape_html(text: &str) -> String {
 +    text.replace('&', "&amp;")
 +        .replace('<', "&lt;")
 +        .replace('>', "&gt;")
 +}

tests/perf_baseline.rsadded

170 lines changed — click to load

 +use std::path::{Path, PathBuf};
 +use std::time::Duration;
++
 +mod common;
++
 +use afs_ld::{LinkOptions, LinkProfile, Linker};
 +use common::harness::{assemble, have_xcrun, have_xcrun_tool, scratch, sdk_path, sdk_version};
++
 +fn find_runtime_archive() -> Option<PathBuf> {
 +    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");
 +        if candidate.is_file() {
 +            return Some(candidate);
 +        }
 +    }
 +    None
 +}
++
 +fn executable_opts(inputs: Vec<PathBuf>, output: PathBuf) -> LinkOptions {
 +    LinkOptions {
 +        inputs,
 +        output: Some(output),
 +        syslibroot: sdk_path().map(PathBuf::from),
 +        platform_version: sdk_version().map(|v| {
 +            let parsed = afs_ld::macho::tbd::parse_version(&v);
 +            afs_ld::PlatformVersion {
 +                minos: parsed,
 +                sdk: parsed,
 +            }
 +        }),
 +        library_names: vec!["System".into()],
 +        ..LinkOptions::default()
 +    }
 +}
++
 +fn assert_profile_basics(name: &str, profile: &LinkProfile) {
 +    eprintln!(
 +        "{name}: total={:?} parse={:?} resolve={:?} atomize={:?} layout={:?} synth={:?} (linkedit={:?}: symbols={:?} [locals={:?} globals={:?} strtab={:?}] dyld={:?} metadata={:?} codesig={:?}; unwind={:?}) reloc={:?} write={:?}",
 +        profile.total_wall,
 +        profile.phases.input_parsing,
 +        profile.phases.symbol_resolution,
 +        profile.phases.atomization,
 +        profile.phases.layout,
 +        profile.phases.synth_sections,
 +        profile.phases.synth_linkedit_finalize,
 +        profile.phases.synth_linkedit_symbol_plan,
 +        profile.phases.synth_linkedit_symbol_plan_locals,
 +        profile.phases.synth_linkedit_symbol_plan_globals,
 +        profile.phases.synth_linkedit_symbol_plan_strtab,
 +        profile.phases.synth_linkedit_dyld_info,
 +        profile.phases.synth_linkedit_metadata_tables,
 +        profile.phases.synth_linkedit_code_signature,
 +        profile.phases.synth_unwind,
 +        profile.phases.reloc_apply,
 +        profile.phases.write_output,
 +    );
 +    assert!(profile.output.is_file(), "{name}: output file missing");
 +    assert!(
 +        profile.total_wall >= profile.phases.accounted_total(),
 +        "{name}: accounted phases exceeded total wall time"
 +    );
 +    assert!(
 +        profile.phases.accounted_total() > Duration::ZERO,
 +        "{name}: all phase timings were zero"
 +    );
 +    assert!(
 +        profile.phases.synth_sections
 +            >= profile.phases.synth_linkedit_finalize + profile.phases.synth_unwind,
 +        "{name}: synth subphases exceeded synth total"
 +    );
 +    assert!(
 +        profile.phases.synth_linkedit_finalize
 +            >= profile.phases.synth_linkedit_symbol_plan
 +                + profile.phases.synth_linkedit_dyld_info
 +                + profile.phases.synth_linkedit_metadata_tables
 +                + profile.phases.synth_linkedit_code_signature,
 +        "{name}: linkedit subphases exceeded linkedit total"
 +    );
 +    assert!(
 +        profile.phases.synth_linkedit_symbol_plan
 +            >= profile.phases.synth_linkedit_symbol_plan_locals
 +                + profile.phases.synth_linkedit_symbol_plan_globals
 +                + profile.phases.synth_linkedit_symbol_plan_strtab,
 +        "{name}: symbol-plan subphases exceeded symbol-plan total"
 +    );
 +}
++
 +#[test]
 +fn hello_world_profile_reports_baseline_timings() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
++
 +    let obj = scratch("perf-hello.o");
 +    let out = scratch("perf-hello.out");
 +    assemble(
 +        "\
 +        .text\n\
 +        .globl _main\n\
 +        .p2align 2\n\
 +        _main:\n\
 +            mov w0, #0\n\
 +            ret\n",
 +        &obj,
 +    )
 +    .expect("assemble hello");
++
 +    let profile = Linker::run_profiled(&executable_opts(vec![obj], out)).expect("profile hello");
 +    assert_profile_basics("hello", &profile);
++
 +    if let Ok(limit_ms) = std::env::var("AFS_LD_HELLO_BUDGET_MS") {
 +        let limit = Duration::from_millis(limit_ms.parse().expect("parse hello budget"));
 +        assert!(
 +            profile.total_wall <= limit,
 +            "hello baseline exceeded budget: {:?} > {:?}",
 +            profile.total_wall,
 +            limit
 +        );
 +    }
 +}
++
 +#[test]
 +fn runtime_link_profile_reports_baseline_timings() {
 +    if !have_xcrun() || !have_xcrun_tool("ld") {
 +        eprintln!("skipping: xcrun as/ld unavailable");
 +        return;
 +    }
 +    let Some(runtime) = find_runtime_archive() else {
 +        eprintln!("skipping: libarmfortas_rt.a not built");
 +        return;
 +    };
++
 +    let obj = scratch("perf-runtime.o");
 +    let out = scratch("perf-runtime.out");
 +    assemble(
 +        "\
 +        .text\n\
 +        .globl _main\n\
 +        .p2align 2\n\
 +        _main:\n\
 +            stp x29, x30, [sp, #-16]!\n\
 +            mov x29, sp\n\
 +            bl _afs_program_init\n\
 +            bl _afs_program_finalize\n\
 +            mov w0, #0\n\
 +            ldp x29, x30, [sp], #16\n\
 +            ret\n",
 +        &obj,
 +    )
 +    .expect("assemble runtime");
++
 +    let profile = Linker::run_profiled(&executable_opts(vec![obj, runtime], out))
 +        .expect("profile runtime link");
 +    assert_profile_basics("runtime", &profile);
++
 +    if let Ok(limit_ms) = std::env::var("AFS_LD_RUNTIME_BUDGET_MS") {
 +        let limit = Duration::from_millis(limit_ms.parse().expect("parse runtime budget"));
 +        assert!(
 +            profile.total_wall <= limit,
 +            "runtime baseline exceeded budget: {:?} > {:?}",
 +            profile.total_wall,
 +            limit
 +        );
 +    }
 +}

tests/snapshots/help.txtadded

49 lines changed — click to load

 +Usage: afs-ld [options] <inputs...>
++
 +Options:
 +  -o <path>                       Write output to <path>
 +  -dylib                          Emit a dylib instead of an executable
 +  -e <symbol>                     Set the entry symbol
 +  -arch arm64                     Select the arm64 target
 +  -map <path>                     Emit text link map
 +  -why_live <symbol>              Print a reachability chain for <symbol>
 +  -l<name> / -l <name>            Search for library
 +  -L <dir>                        Add library search path
 +  -framework <name>               Link framework
 +  -weak_framework <name>          Link weak framework
 +  -ObjC                           Objective-C archive loading mode (currently a no-op warning)
 +  -syslibroot <path>              Prefix SDK search roots
 +  -platform_version macos <min> <sdk>
 +                                  Set LC_BUILD_VERSION payload
 +  -r                              Relocatable output (deferred; errors)
 +  -bundle                         Bundle output (deferred; errors)
 +  -undefined <error|warning|suppress|dynamic_lookup>
 +                                  Control unresolved-symbol treatment
 +  -rpath <path>                   Add LC_RPATH
 +  -install_name <path>            Override dylib install name
 +  -current_version <v>            Override dylib current version
 +  -compatibility_version <v>      Override dylib compatibility version
 +  -exported_symbols_list <file>   Export only symbols matching file patterns
 +  -unexported_symbols_list <file> Hide symbols matching file patterns
 +  -exported_symbol <sym>          Export one symbol/pattern
 +  -unexported_symbol <sym>        Hide one symbol/pattern
 +  -x                              Strip local symbols
 +  -S                              Strip debug symbols (currently a no-op warning)
 +  -no_uuid                        Omit LC_UUID
 +  -no_loh                         Accepted for compatibility (currently warns; no effect)
 +  -thunks=<none|safe|all>         Configure branch thunks
 +  -dead_strip                     Dead-strip unreferenced code/data
 +  -icf=safe | -icf=none | -icf=all
 +                                  Configure identical code folding (`all` currently errors)
 +  -fixup_chains | -no_fixup_chains
 +                                  Select chained fixups vs classic dyld info
 +  -all_load                       Force-load every archive member
 +  -force_load <archive>           Force-load one archive
 +  -Wl,<arg,arg,...>               Normalize comma-separated driver flags
 +  --dump <path>                   Dump a Mach-O file summary
 +  --dump-archive <path>           Dump an archive summary
 +  --dump-dylib <path>             Dump a dylib summary
 +  --dump-tbd <path>               Dump a TBD summary
 +  -t, -trace                      Print input paths as they are loaded
 +  -h, --help                      Show this help
 +  -v, --version                   Show afs-ld version

Diff truncated: 393 files; expand each to load its hunks.

`@@ -38,6 +38,15 @@` impl DylibLoadKind {
38	38	_ => None,
39	39	}
40	40	}
	41	+
	42	+ pub fn load_cmd(self) -> u32 {
	43	+ match self {
	44	+ DylibLoadKind::Normal => LC_LOAD_DYLIB,
	45	+ DylibLoadKind::Weak => LC_LOAD_WEAK_DYLIB,
	46	+ DylibLoadKind::Reexport => LC_REEXPORT_DYLIB,
	47	+ DylibLoadKind::Upward => LC_LOAD_UPWARD_DYLIB,
	48	+ }
	49	+ }
41	50	}
42	51
43	52	/// One dylib this file depends on. Ordinals match the two-level namespace