`336a3da`

decode LC_DYLD_INFO_ONLY and wire export trie through DylibFile

Authored by

espadonne 4 weeks ago

SHA: 336a3daa7d66e95640c9538126007d878ef7515f
Parents: 015579b
Tree: 20ce1a3

7 changed files

Status	File	+	-
M	`src/args.rs`	6	0
M	`src/dump.rs`	93	2
M	`src/lib.rs`	3	0
M	`src/macho/dylib.rs`	30	13
M	`src/macho/reader.rs`	100	0
M	`src/main.rs`	10	0
A	`tests/dylib_integration.rs`	103	0

src/args.rsmodified

                          .ok_or_else(|| ArgsError::MissingValue("--dump-archive".into()))?,
                  ));
+             }
 +            "--dump-dylib" => {
 +                opts.dump_dylib = Some(PathBuf::from(
 +                    it.next()
 +                        .ok_or_else(|| ArgsError::MissingValue("--dump-dylib".into()))?,
 +                ));
 +            }
              s if s.starts_with('-') => {
                  return Err(ArgsError::UnknownFlag(s.to_string()));
+             }

src/dump.rsmodified

  use crate::archive::{Archive, Flavor, SpecialMember};
  use crate::input::ObjectFile;
 +use crate::macho::dylib::{DylibFile, DylibLoadKind};
 +use crate::macho::exports::ExportKind;
  use crate::macho::constants::*;
  use crate::macho::reader::{
 -    BuildVersionCmd, DylibCmd, DysymtabCmd, LinkEditDataCmd, LoadCommand, MachHeader64,
 -    RpathCmd, Section64Header, Segment64, SymtabCmd,
 +    BuildVersionCmd, DyldInfoCmd, DylibCmd, DysymtabCmd, LinkEditDataCmd, LoadCommand,
 +    MachHeader64, RpathCmd, Section64Header, Segment64, SymtabCmd,
  };
  use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind};
  use crate::section::InputSection;
      Ok(())
+ }
 +pub fn dump_dylib_file(path: &Path) -> io::Result<()> {
 +    let bytes = std::fs::read(path)?;
 +    let dy = DylibFile::parse(path, &bytes)
 +        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
 +    let out = io::stdout();
 +    let mut h = out.lock();
 +    writeln!(h, "{}:", path.display())?;
 +    writeln!(
 +        h,
 +        "dylib: install_name={:?} current={} compat={}",
 +        dy.install_name,
 +        version_str(dy.current_version),
 +        version_str(dy.compatibility_version)
 +    )?;
 +    writeln!(h, "Dependencies ({}):", dy.dependencies.len())?;
 +    for d in &dy.dependencies {
 +        let kind = match d.kind {
 +            DylibLoadKind::Normal => "normal",
 +            DylibLoadKind::Weak => "weak",
 +            DylibLoadKind::Reexport => "reexport",
 +            DylibLoadKind::Upward => "upward",
 +        };
 +        writeln!(
 +            h,
 +            "  [{}] {kind:<8} {} current={} compat={}",
 +            d.ordinal,
 +            d.install_name,
 +            version_str(d.current_version),
 +            version_str(d.compatibility_version)
 +        )?;
 +    }
 +    if !dy.rpaths.is_empty() {
 +        writeln!(h, "Rpaths ({}):", dy.rpaths.len())?;
 +        for (i, p) in dy.rpaths.iter().enumerate() {
 +            writeln!(h, "  [{i}] {p}")?;
 +        }
 +    }
 +    let entries = dy
 +        .exports
 +        .entries()
 +        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
 +    writeln!(h, "Exports ({}):", entries.len())?;
 +    for (i, e) in entries.iter().enumerate().take(32) {
 +        let rhs = match &e.kind {
 +            ExportKind::Regular { address } => format!("addr=0x{address:x}"),
 +            ExportKind::ThreadLocal { address } => format!("tlv addr=0x{address:x}"),
 +            ExportKind::Absolute { address } => format!("abs=0x{address:x}"),
 +            ExportKind::Reexport {
 +                ordinal,
 +                imported_name,
 +            } => {
 +                if imported_name.is_empty() {
 +                    format!("reexport from dylib#{ordinal}")
 +                } else {
 +                    format!("reexport from dylib#{ordinal} as {imported_name}")
 +                }
 +            }
 +            ExportKind::StubAndResolver { stub, resolver } => {
 +                format!("stub=0x{stub:x} resolver=0x{resolver:x}")
 +            }
 +        };
 +        writeln!(h, "  [{i}] {:<40} {rhs}", e.name)?;
 +    }
 +    if entries.len() > 32 {
 +        writeln!(h, "  ... ({} more)", entries.len() - 32)?;
 +    }
 +    Ok(())
 +}
++
  pub fn dump_file(path: &Path) -> io::Result<()> {
      let bytes = std::fs::read(path)?;
      let obj = ObjectFile::parse(path, &bytes)
          LoadCommand::LinkerOptimizationHint(l) => write_linkedit_data(w, l, "LOH"),
          LoadCommand::Dylib(d) => write_dylib(w, d),
          LoadCommand::Rpath(r) => write_rpath(w, r),
 +        LoadCommand::DyldInfoOnly(d) => write_dyld_info(w, d),
 +        LoadCommand::DyldExportsTrie(l) => write_linkedit_data(w, l, "EXPORTS_TRIE"),
 +        LoadCommand::DyldChainedFixups(l) => write_linkedit_data(w, l, "CHAINED_FIXUPS"),
          LoadCommand::Raw { cmd, data, .. } => {
              writeln!(
                  w,
      writeln!(w, "  path={:?}", r.path)
+ }
 +fn write_dyld_info(w: &mut impl Write, d: &DyldInfoCmd) -> io::Result<()> {
 +    writeln!(
 +        w,
 +        "  rebase=@{}..+{} bind=@{}..+{} weak_bind=@{}..+{} lazy_bind=@{}..+{} export=@{}..+{}",
 +        d.rebase_off,
 +        d.rebase_size,
 +        d.bind_off,
 +        d.bind_size,
 +        d.weak_bind_off,
 +        d.weak_bind_size,
 +        d.lazy_bind_off,
 +        d.lazy_bind_size,
 +        d.export_off,
 +        d.export_size
 +    )
 +}
++
  fn write_segment64(w: &mut impl Write, s: &Segment64) -> io::Result<()> {
      writeln!(
          w,

src/lib.rsmodified


     pub dump: Option<PathBuf>,
     /// When set, afs-ld dumps the named static archive's structure.
     pub dump_archive: Option<PathBuf>,
+    /// When set, afs-ld dumps the named MH_DYLIB's load commands + exports.
+    pub dump_dylib: Option<PathBuf>,
 }
 
 impl Default for LinkOptions {

             kind: OutputKind::Executable,
             dump: None,
             dump_archive: None,
+            dump_dylib: None,
         }
     }
 }

src/macho/dylib.rsmodified

+     }
+ }
 -/// The export trie lives in `__LINKEDIT` pointed at either by
 -/// `LC_DYLD_INFO_ONLY.export_off / export_size` (classic) or by
 -/// `LC_DYLD_EXPORTS_TRIE` (chained-fixups era). We accept both; the latter
 -/// shares the `linkedit_data_command` wire shape.
 -///
 -/// Dylibs built with older toolchains may have no export trie at all (the
 -/// symbol table was the only source of exports). Return an empty trie so
 -/// downstream code doesn't crash.
 +/// Locate the export-trie bytes in either `LC_DYLD_INFO_ONLY.export_*` or
 +/// `LC_DYLD_EXPORTS_TRIE` (chained-fixups era). Dylibs built by older
 +/// toolchains may have no export trie; in that case return an empty trie.
  fn locate_exports_trie(
      commands: &[LoadCommand],
      file_bytes: &[u8],
  ) -> Result<ExportTrie, ReadError> {
 -    // Sprint 5 intentionally surfaces only the raw trie bytes; the walker
 -    // arrives in the next commit. Placeholder for now: return the empty trie.
      for cmd in commands {
 -        if let LoadCommand::LinkerOptimizationHint(_) = cmd {
 -            // LC_LOH is not the trie — just here to keep the walk explicit.
 +        match cmd {
 +            LoadCommand::DyldInfoOnly(d) if d.export_size != 0 => {
 +                return trie_slice(file_bytes, d.export_off, d.export_size);
 +            }
 +            LoadCommand::DyldExportsTrie(l) if l.datasize != 0 => {
 +                return trie_slice(file_bytes, l.dataoff, l.datasize);
 +            }
 +            _ => {}
+         }
+     }
 -    let _ = file_bytes;
      Ok(ExportTrie::empty())
+ }
 +fn trie_slice(file_bytes: &[u8], off: u32, size: u32) -> Result<ExportTrie, ReadError> {
 +    let start = off as usize;
 +    let end = start
 +        .checked_add(size as usize)
 +        .ok_or(ReadError::Truncated {
 +            need: usize::MAX,
 +            have: file_bytes.len(),
 +            context: "export trie (offset + size overflows)",
 +        })?;
 +    if end > file_bytes.len() {
 +        return Err(ReadError::Truncated {
 +            need: end,
 +            have: file_bytes.len(),
 +            context: "export trie",
 +        });
 +    }
 +    Ok(ExportTrie::from_bytes(&file_bytes[start..end]))
 +}
++
  /// Look up the 1-based ordinal of a dependency by its install name. Used by
  /// Sprint 14's symbol-table writer when encoding each undefined symbol's
  /// two-level-namespace library ordinal into its `n_desc` high byte.

src/macho/reader.rsmodified

      Dylib(DylibCmd),
      /// `LC_RPATH` — one runtime-search path per entry.
      Rpath(RpathCmd),
 +    /// `LC_DYLD_INFO_ONLY` — classic locator for rebase/bind/lazy/weak/export
 +    /// streams in `__LINKEDIT`.
 +    DyldInfoOnly(DyldInfoCmd),
 +    /// `LC_DYLD_EXPORTS_TRIE` — the modern chained-fixups alternative that
 +    /// holds only the export trie (paired with `LC_DYLD_CHAINED_FIXUPS`).
 +    DyldExportsTrie(LinkEditDataCmd),
 +    /// `LC_DYLD_CHAINED_FIXUPS` — pointer to the chained-fixups blob.
 +    DyldChainedFixups(LinkEditDataCmd),
      /// A load command whose payload we haven't decoded yet. Preserves bytes
      /// verbatim for byte-level round-trip.
      Raw { cmd: u32, cmdsize: u32, data: Vec<u8> },
              LoadCommand::LinkerOptimizationHint(_) => LC_LINKER_OPTIMIZATION_HINT,
              LoadCommand::Dylib(d) => d.cmd,
              LoadCommand::Rpath(_) => LC_RPATH,
 +            LoadCommand::DyldInfoOnly(_) => LC_DYLD_INFO_ONLY,
 +            LoadCommand::DyldExportsTrie(_) => LC_DYLD_EXPORTS_TRIE,
 +            LoadCommand::DyldChainedFixups(_) => LC_DYLD_CHAINED_FIXUPS,
              LoadCommand::Raw { cmd, .. } => *cmd,
+         }
+     }
              LoadCommand::LinkerOptimizationHint(_) => LinkEditDataCmd::WIRE_SIZE,
              LoadCommand::Dylib(d) => d.wire_size(),
              LoadCommand::Rpath(r) => r.wire_size(),
 +            LoadCommand::DyldInfoOnly(_) => DyldInfoCmd::WIRE_SIZE,
 +            LoadCommand::DyldExportsTrie(_) => LinkEditDataCmd::WIRE_SIZE,
 +            LoadCommand::DyldChainedFixups(_) => LinkEditDataCmd::WIRE_SIZE,
              LoadCommand::Raw { cmdsize, .. } => *cmdsize,
+         }
+     }
          | LC_REEXPORT_DYLIB
          | LC_LOAD_UPWARD_DYLIB => Ok(LoadCommand::Dylib(DylibCmd::parse(cmd, cmdsize, payload)?)),
          LC_RPATH => Ok(LoadCommand::Rpath(RpathCmd::parse(cmdsize, payload)?)),
 +        LC_DYLD_INFO_ONLY => Ok(LoadCommand::DyldInfoOnly(DyldInfoCmd::parse(cmdsize, payload)?)),
 +        LC_DYLD_EXPORTS_TRIE => Ok(LoadCommand::DyldExportsTrie(LinkEditDataCmd::parse(
 +            LC_DYLD_EXPORTS_TRIE,
 +            cmdsize,
 +            payload,
 +        )?)),
 +        LC_DYLD_CHAINED_FIXUPS => Ok(LoadCommand::DyldChainedFixups(LinkEditDataCmd::parse(
 +            LC_DYLD_CHAINED_FIXUPS,
 +            cmdsize,
 +            payload,
 +        )?)),
          _ => Ok(LoadCommand::Raw {
              cmd,
              cmdsize,
              LoadCommand::LinkerOptimizationHint(l) => l.write(LC_LINKER_OPTIMIZATION_HINT, out),
              LoadCommand::Dylib(d) => d.write(out),
              LoadCommand::Rpath(r) => r.write(out),
 +            LoadCommand::DyldInfoOnly(d) => d.write(out),
 +            LoadCommand::DyldExportsTrie(l) => l.write(LC_DYLD_EXPORTS_TRIE, out),
 +            LoadCommand::DyldChainedFixups(l) => l.write(LC_DYLD_CHAINED_FIXUPS, out),
              LoadCommand::Raw { cmd, cmdsize, data } => {
                  out.extend_from_slice(&cmd.to_le_bytes());
                  out.extend_from_slice(&cmdsize.to_le_bytes());
      (n + 7) & !7
+ }
 +// ---------------------------------------------------------------------------
 +// LC_DYLD_INFO_ONLY — classic locator for rebase/bind/lazy/weak/export.
 +// ---------------------------------------------------------------------------
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 +pub struct DyldInfoCmd {
 +    pub rebase_off: u32,
 +    pub rebase_size: u32,
 +    pub bind_off: u32,
 +    pub bind_size: u32,
 +    pub weak_bind_off: u32,
 +    pub weak_bind_size: u32,
 +    pub lazy_bind_off: u32,
 +    pub lazy_bind_size: u32,
 +    pub export_off: u32,
 +    pub export_size: u32,
 +}
++
 +impl DyldInfoCmd {
 +    pub const WIRE_SIZE: u32 = 8 + 40;
++
 +    pub fn parse(cmdsize: u32, payload: &[u8]) -> Result<Self, ReadError> {
 +        if cmdsize != Self::WIRE_SIZE {
 +            return Err(ReadError::BadCmdsize {
 +                cmd: LC_DYLD_INFO_ONLY,
 +                cmdsize,
 +                at_offset: 0,
 +                reason: "LC_DYLD_INFO_ONLY cmdsize must be 48",
 +            });
 +        }
 +        if payload.len() < 40 {
 +            return Err(ReadError::Truncated {
 +                need: 40,
 +                have: payload.len(),
 +                context: "dyld_info_command",
 +            });
 +        }
 +        let g = |i: usize| u32_le(&payload[i * 4..(i + 1) * 4]);
 +        Ok(DyldInfoCmd {
 +            rebase_off: g(0),
 +            rebase_size: g(1),
 +            bind_off: g(2),
 +            bind_size: g(3),
 +            weak_bind_off: g(4),
 +            weak_bind_size: g(5),
 +            lazy_bind_off: g(6),
 +            lazy_bind_size: g(7),
 +            export_off: g(8),
 +            export_size: g(9),
 +        })
 +    }
++
 +    pub fn write(&self, out: &mut Vec<u8>) {
 +        out.extend_from_slice(&LC_DYLD_INFO_ONLY.to_le_bytes());
 +        out.extend_from_slice(&Self::WIRE_SIZE.to_le_bytes());
 +        for v in [
 +            self.rebase_off,
 +            self.rebase_size,
 +            self.bind_off,
 +            self.bind_size,
 +            self.weak_bind_off,
 +            self.weak_bind_size,
 +            self.lazy_bind_off,
 +            self.lazy_bind_size,
 +            self.export_off,
 +            self.export_size,
 +        ] {
 +            out.extend_from_slice(&v.to_le_bytes());
 +        }
 +    }
 +}
++
  // ---------------------------------------------------------------------------
  // linkedit_data_command — shared wire format for LC_LINKER_OPTIMIZATION_HINT,
  // LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_CODE_SIGNATURE, LC_DYLD_EXPORTS_TRIE,

src/main.rsmodified

          };
+     }
 +    if let Some(path) = &opts.dump_dylib {
 +        return match dump::dump_dylib_file(path) {
 +            Ok(()) => ExitCode::SUCCESS,
 +            Err(e) => {
 +                diag::error(&format!("{}: {}", path.display(), e));
 +                ExitCode::from(1)
 +            }
 +        };
 +    }
++
      match Linker::run(&opts) {
          Ok(()) => ExitCode::SUCCESS,
          Err(LinkError::NoInputs) => {

tests/dylib_integration.rsadded

 +//! Sprint 5 real-world gate: build a tiny dylib with `clang`, parse it via
 +//! `DylibFile`, and confirm:
 +//!
 +//! - `install_name` is what `-install_name` requested;
 +//! - the exported symbol surfaces in the trie;
 +//! - at least one `LC_LOAD_DYLIB` dependency is present (every clang-linked
 +//!   dylib picks up libSystem).
 +//!
 +//! Skipped if `xcrun clang` isn't available or fails for any reason.
++
 +use std::path::PathBuf;
 +use std::process::Command;
++
 +use afs_ld::macho::dylib::DylibFile;
 +use afs_ld::macho::exports::ExportKind;
++
 +fn build_test_dylib(src: &str, out: &PathBuf) -> Result<(), String> {
 +    let mut child = Command::new("xcrun")
 +        .args([
 +            "--sdk",
 +            "macosx",
 +            "clang",
 +            "-x",
 +            "c",
 +            "-arch",
 +            "arm64",
 +            "-shared",
 +            "-o",
 +        ])
 +        .arg(out)
 +        .arg("-install_name")
 +        .arg("@rpath/libafsldtest.dylib")
 +        .arg("-")
 +        .stdin(std::process::Stdio::piped())
 +        .stdout(std::process::Stdio::piped())
 +        .stderr(std::process::Stdio::piped())
 +        .spawn()
 +        .map_err(|e| format!("spawn: {e}"))?;
 +    use std::io::Write;
 +    child
 +        .stdin
 +        .as_mut()
 +        .unwrap()
 +        .write_all(src.as_bytes())
 +        .map_err(|e| format!("write: {e}"))?;
 +    let out = child.wait_with_output().map_err(|e| format!("wait: {e}"))?;
 +    if !out.status.success() {
 +        return Err(format!(
 +            "clang failed: {}",
 +            String::from_utf8_lossy(&out.stderr)
 +        ));
 +    }
 +    Ok(())
 +}
++
 +#[test]
 +fn small_clang_dylib_parses_and_exports_function() {
 +    let which = Command::new("xcrun").arg("-f").arg("clang").output();
 +    if !matches!(which, Ok(o) if o.status.success()) {
 +        eprintln!("skipping: xcrun clang unavailable");
 +        return;
 +    }
++
 +    use std::sync::atomic::{AtomicUsize, Ordering};
 +    static SEQ: AtomicUsize = AtomicUsize::new(0);
 +    let out_path = std::env::temp_dir().join(format!(
 +        "afs-ld-dylib-{}-{}.dylib",
 +        std::process::id(),
 +        SEQ.fetch_add(1, Ordering::Relaxed)
 +    ));
++
 +    let src = r#"
 +        int afsld_answer(int x) { return x + 42; }
 +    "#;
 +    if let Err(e) = build_test_dylib(src, &out_path) {
 +        eprintln!("skipping: clang could not build test dylib: {e}");
 +        return;
 +    }
++
 +    let bytes = std::fs::read(&out_path).expect("read test dylib");
 +    let dy = DylibFile::parse(&out_path, &bytes).expect("parse test dylib");
++
 +    assert_eq!(dy.install_name, "@rpath/libafsldtest.dylib");
++
 +    // clang-linked dylibs pull libSystem in as a Normal dependency.
 +    assert!(
 +        dy.dependencies
 +            .iter()
 +            .any(|d| d.install_name.contains("libSystem")),
 +        "expected a libSystem dependency; got {:?}",
 +        dy.dependencies
 +    );
++
 +    let entries = dy.exports.entries().expect("decode exports");
 +    let name = "_afsld_answer";
 +    let found = entries.iter().find(|e| e.name == name).unwrap_or_else(|| {
 +        let exported: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
 +        panic!("expected {name} in exports; got {exported:?}")
 +    });
 +    assert!(matches!(found.kind, ExportKind::Regular { .. }));
++
 +    let _ = std::fs::remove_file(&out_path);
 +}

`@@ -38,6 +38,8 @@` pub struct LinkOptions {
38	38	pub dump: Option<PathBuf>,
39	39	/// When set, afs-ld dumps the named static archive's structure.
40	40	pub dump_archive: Option<PathBuf>,
	41	+ /// When set, afs-ld dumps the named MH_DYLIB's load commands + exports.
	42	+ pub dump_dylib: Option<PathBuf>,
41	43	}
42	44
43	45	impl Default for LinkOptions {
`@@ -50,6 +52,7 @@` impl Default for LinkOptions {
50	52	kind: OutputKind::Executable,
51	53	dump: None,
52	54	dump_archive: None,
	55	+ dump_dylib: None,
53	56	}
54	57	}
55	58	}