`1d9f402`

Speed synthetic planning

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: 1d9f402d4ed10ae203a7d88bf28cdfeb14fe94dc
Parents: b81b24f
Tree: 9ff8a82

7 changed files

Status	File	+	-
M	`src/lib.rs`	33	8
M	`src/macho/writer.rs`	3	3
M	`src/reloc/arm64.rs`	56	76
M	`src/reloc/mod.rs`	5	0
M	`src/resolve.rs`	8	0
M	`src/synth/mod.rs`	125	36
M	`tests/perf_baseline.rs`	17	1

src/lib.rsmodified

      pub symbol_resolution: Duration,
      pub atomization: Duration,
      pub layout: Duration,
 +    pub layout_entry_lookup: Duration,
 +    pub layout_dead_strip: Duration,
 +    pub layout_icf: Duration,
 +    pub layout_synthetic_plan: Duration,
 +    pub layout_build: Duration,
 +    pub layout_thunk_plan: Duration,
      pub synth_sections: Duration,
      pub synth_linkedit_finalize: Duration,
      pub synth_linkedit_symbol_plan: Duration,
          let phase_started = Instant::now();
          let parsed_relocs = macho::writer::build_parsed_reloc_cache(&layout_inputs)?;
          phases.input_parsing += phase_started.elapsed();
 +        let layout_started = Instant::now();
          let phase_started = Instant::now();
          let entry_symbol = find_entry_symbol_id(opts, &sym_table)?;
 +        phases.layout_entry_lookup = phase_started.elapsed();
 +        let phase_started = Instant::now();
          let dead_strip = opts.dead_strip.then(|| {
              why_live::DeadStripAnalysis::build(
                  opts,
                  entry_symbol,
+             )
          });
 +        phases.layout_dead_strip = phase_started.elapsed();
 +        let phase_started = Instant::now();
          let icf = (opts.icf_mode == IcfMode::Safe)
              .then(|| {
                  icf::fold_safe(
+                 )
              })
              .transpose()?;
 +        phases.layout_icf = phase_started.elapsed();
          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(
 +        let phase_started = Instant::now();
 +        let synthetic_plan = synth::SyntheticPlan::build_filtered_with_relocs(
              &layout_inputs,
              &atom_table,
              &mut sym_table,
              &inputs.dylibs,
              kept_atoms,
 +            &parsed_relocs,
          )?;
 +        phases.layout_synthetic_plan = phase_started.elapsed();
          let icf_redirects = icf.as_ref().map(|plan| plan.redirects());
 +        let phase_started = Instant::now();
          let mut layout = Layout::build_with_synthetics_filtered(
              opts.kind,
              &layout_inputs,
              Some(&synthetic_plan),
              kept_atoms,
          );
 +        phases.layout_build += phase_started.elapsed();
          let mut thunk_plan = None;
          let mut thunk_converged = false;
          for _ in 0..THUNK_PLAN_MAX_ITERATIONS {
 +            let phase_started = Instant::now();
              let next_plan = reloc::arm64::plan_thunks(
                  opts,
 -                &layout,
 -                &layout_inputs,
 -                &atom_table,
 -                &sym_table,
 -                Some(&synthetic_plan),
 -                icf_redirects,
 +                reloc::arm64::ThunkPlanningContext {
 +                    layout: &layout,
 +                    inputs: &layout_inputs,
 +                    atoms: &atom_table,
 +                    sym_table: &sym_table,
 +                    synthetic_plan: Some(&synthetic_plan),
 +                    icf_redirects,
 +                    parsed_relocs: &parsed_relocs,
 +                },
              )?;
 +            phases.layout_thunk_plan += phase_started.elapsed();
              if next_plan == thunk_plan {
                  thunk_converged = true;
                  break;
              let split_after_atoms = next_plan
                  .as_ref()
                  .map_or_else(Vec::new, |plan| plan.split_after_atoms());
 +            let phase_started = Instant::now();
              layout = Layout::build_with_synthetics_and_extra_filtered(
                  opts.kind,
                  &layout_inputs,
                      split_after_atoms: &split_after_atoms,
                  },
              );
 +            phases.layout_build += phase_started.elapsed();
              thunk_plan = next_plan;
+         }
          if !thunk_converged {
              return Err(LinkError::ThunkPlanningDidNotConverge);
+         }
 -        phases.layout = phase_started.elapsed();
 +        phases.layout = layout_started.elapsed();
          let linkedit_context = macho::writer::LinkEditContext {
              layout_inputs: &layout_inputs,
              atom_table: &atom_table,
                  thunk_plan: thunk_plan.as_ref(),
                  linkedit: &linkedit,
                  icf_redirects,
 +                parsed_relocs: &parsed_relocs,
              },
          )?;
          phases.reloc_apply = phase_started.elapsed();

src/macho/writer.rsmodified

      LinkEditDataCmd, LoadCommand, MachHeader64, RpathCmd, Section64Header, Segment64, SymtabCmd,
      HEADER_SIZE,
  };
 -use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind, RelocLength};
 +use crate::reloc::{
 +    parse_raw_relocs, parse_relocs, ParsedRelocCache, Referent, Reloc, RelocKind, RelocLength,
 +};
  use crate::resolve::InputId;
  use crate::resolve::{Symbol, SymbolId, SymbolTable};
  use crate::section::is_executable;
      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,

src/reloc/arm64.rsmodified

  use crate::input::ObjectFile;
  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::reloc::{ParsedRelocCache, Referent, Reloc, RelocKind, RelocLength};
  use crate::resolve::{InputId, Symbol, SymbolId, SymbolTable};
  use crate::section::{OutputSection, SectionKind};
  use crate::symbol::{InputSymbol, SymKind};
      pub thunk_plan: Option<&'a ThunkPlan>,
      pub linkedit: &'a LinkEditPlan,
      pub icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +    pub parsed_relocs: &'a ParsedRelocCache,
+ }
  struct InputSectionResolveCtx<'a> {
          .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 atoms_by_input_section = atoms.by_input_section();
      let section_addrs = input_section_address_map(layout, atoms);
+                 )
              })?;
              patch_eh_frame_cie_pointer(&mut placed.data, atom, &resolve)?;
 -            let relocs = reloc_cache
 +            let relocs = plan
 +                .parsed_relocs
                  .get(&(atom.origin, atom.input_section))
                  .map(Vec::as_slice)
                  .unwrap_or(&[]);
              synthetic_plan,
              atoms,
              &input_map,
 -            &reloc_cache,
 +            plan.parsed_relocs,
              &resolve,
          )?;
          synthesize_got_section(layout, synthetic_plan, &resolve)?;
+     }
+ }
 +pub struct ThunkPlanningContext<'a> {
 +    pub layout: &'a Layout,
 +    pub inputs: &'a [LayoutInput<'a>],
 +    pub atoms: &'a AtomTable,
 +    pub sym_table: &'a SymbolTable,
 +    pub synthetic_plan: Option<&'a SyntheticPlan>,
 +    pub icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
 +    pub parsed_relocs: &'a ParsedRelocCache,
 +}
++
  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>>,
 +    ctx: ThunkPlanningContext<'_>,
  ) -> Result<Option<ThunkPlan>, RelocError> {
      if opts.thunks == ThunkMode::None {
          return Ok(None);
+     }
 +    let ThunkPlanningContext {
 +        layout,
 +        inputs,
 +        atoms,
 +        sym_table,
 +        synthetic_plan,
 +        icf_redirects,
 +        parsed_relocs,
 +    } = ctx;
++
      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 Some(obj) = input_map.get(&atom.origin) else {
              continue;
          };
 -        let relocs = reloc_cache
 +        let relocs = parsed_relocs
              .get(&(atom.origin, atom.input_section))
              .map(Vec::as_slice)
              .unwrap_or(&[]);
              ..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();
 +        let parsed_relocs = crate::macho::writer::build_parsed_reloc_cache(&inputs).unwrap();
 +        let plan = plan_thunks(
 +            &opts,
 +            ThunkPlanningContext {
 +                layout: &base_layout,
 +                inputs: &inputs,
 +                atoms: &atoms,
 +                sym_table: &sym_table,
 +                synthetic_plan: None,
 +                icf_redirects: None,
 +                parsed_relocs: &parsed_relocs,
 +            },
 +        )
 +        .unwrap()
 +        .unwrap();
          assert_eq!(
              plan.redirect_for(caller1, 0),
              vec!["__text", "__thunks", "__text", "__thunks", "__text"]
          );
 -        let replan = plan_thunks(&opts, &rebuilt, &inputs, &atoms, &sym_table, None, None)
 -            .unwrap()
 -            .unwrap();
 +        let replan = plan_thunks(
 +            &opts,
 +            ThunkPlanningContext {
 +                layout: &rebuilt,
 +                inputs: &inputs,
 +                atoms: &atoms,
 +                sym_table: &sym_table,
 +                synthetic_plan: None,
 +                icf_redirects: None,
 +                parsed_relocs: &parsed_relocs,
 +            },
 +        )
 +        .unwrap()
 +        .unwrap();
          assert_eq!(
              replan, plan,
              "expected thunk planning to converge once the intra-section islands exist"

src/reloc/mod.rsmodified

  pub mod arm64;
 +use std::collections::HashMap;
++
  use crate::macho::constants::*;
  use crate::macho::reader::{u32_le, ReadError};
 +use crate::resolve::InputId;
  /// Size of one `relocation_info` on the wire.
  pub const RAW_RELOC_SIZE: usize = 8;
      pub subtrahend: Option<Referent>,
+ }
 +pub type ParsedRelocCache = HashMap<(InputId, u8), Vec<Reloc>>;
++
  fn referent_from(raw: &RawRelocation) -> Result<Referent, ReadError> {
      if raw.r_extern {
          Ok(Referent::Symbol(raw.r_symbolnum))

src/resolve.rsmodified


         Istr(id)
     }
 
+    pub fn get(&self, s: &str) -> Option<Istr> {
+        self.index.get(s).copied().map(Istr)
+    }
+
     pub fn resolve(&self, i: Istr) -> &str {
         &self.strings[i.0 as usize]
     }

         self.by_name.get(&name).copied()
     }
 
+    pub fn lookup_str(&self, name: &str) -> Option<SymbolId> {
+        self.interner.get(name).and_then(|name| self.lookup(name))
+    }
+
     pub fn get(&self, id: SymbolId) -> &Symbol {
         &self.symbols[id.0 as usize]
     }

src/synth/mod.rsmodified

      S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS, S_LAZY_SYMBOL_POINTERS,
      S_NON_LAZY_SYMBOL_POINTERS, S_REGULAR, S_SYMBOL_STUBS, S_THREAD_LOCAL_VARIABLE_POINTERS,
  };
 -use crate::reloc::{parse_raw_relocs, parse_relocs, Referent, Reloc, RelocKind, RelocLength};
 +use crate::reloc::{
 +    parse_raw_relocs, parse_relocs, ParsedRelocCache, Referent, Reloc, RelocKind, RelocLength,
 +};
  use crate::resolve::{
      AtomId, DylibId, DylibInput, InputId, InsertOutcome, Symbol, SymbolId, SymbolTable,
  };
          sym_table: &mut SymbolTable,
          dylibs: &[DylibInput],
          live_atoms: Option<&HashSet<AtomId>>,
 +    ) -> Result<Self, SynthError> {
 +        let reloc_cache = build_synthetic_reloc_cache(inputs)?;
 +        Self::build_filtered_with_relocs(inputs, atoms, sym_table, dylibs, live_atoms, &reloc_cache)
 +    }
++
 +    pub fn build_filtered_with_relocs(
 +        inputs: &[LayoutInput<'_>],
 +        atoms: &AtomTable,
 +        sym_table: &mut SymbolTable,
 +        dylibs: &[DylibInput],
 +        live_atoms: Option<&HashSet<AtomId>>,
 +        parsed_relocs: &ParsedRelocCache,
      ) -> Result<Self, SynthError> {
          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| SynthError {
 -                            input: input.object.path.clone(),
 -                            atom: crate::resolve::AtomId(0),
 -                            reloc_offset: 0,
 -                            kind: RelocKind::Unsigned,
 -                            detail: err.to_string(),
 -                        },
 -                    )?;
 -                    parse_relocs(&raws).map_err(|err| SynthError {
 -                        input: input.object.path.clone(),
 -                        atom: crate::resolve::AtomId(0),
 -                        reloc_offset: 0,
 -                        kind: RelocKind::Unsigned,
 -                        detail: err.to_string(),
 -                    })?
 -                };
 -                reloc_cache.insert((input.id, (sect_idx + 1) as u8), relocs);
 -            }
 -        }
 +        let input_symbol_index = build_input_symbol_index(inputs, sym_table, parsed_relocs);
 +        let reloc_index = build_sorted_reloc_index(parsed_relocs);
          let mut got = GotSection::default();
          let mut stubs = StubsSection::default();
                  kind: RelocKind::Unsigned,
                  detail: "missing parsed object".to_string(),
              })?;
 -            let relocs = reloc_cache
 +            let relocs = reloc_index
                  .get(&(atom.origin, atom.input_section))
                  .map(Vec::as_slice)
                  .unwrap_or(&[]);
 +            let input_symbols = input_symbol_index.get(&atom.origin).map(Vec::as_slice);
              for reloc in relocs_for_atom(relocs, atom) {
                  if atom.section == AtomSection::CompactUnwind
                      && reloc.kind == RelocKind::Unsigned
                      && reloc.offset == atom.input_offset + COMPACT_UNWIND_PERSONALITY_FIELD_OFFSET
+                 {
 -                    if let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table) {
 +                    if let Some(symbol_id) =
 +                        dylib_import_referent(obj, reloc.referent, sym_table, input_symbols)
 +                    {
                          got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
+                     }
                      continue;
                          if matches!(atom.section, AtomSection::ThreadLocalVariables) {
                              continue;
+                         }
 -                        let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table)
 +                        let Some(symbol_id) =
 +                            dylib_import_referent(obj, reloc.referent, sym_table, input_symbols)
                          else {
                              continue;
                          };
                      RelocKind::GotLoadPage21
                      | RelocKind::GotLoadPageOff12
                      | RelocKind::PointerToGot => {
 -                        let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, sym_table)
 +                        let Some(symbol_id) =
 +                            symbol_referent_id(obj, reloc.referent, sym_table, input_symbols)
                          else {
                              continue;
                          };
+                         }
+                     }
                      RelocKind::Branch26 => {
 -                        let Some(symbol_id) = dylib_import_referent(obj, reloc.referent, sym_table)
 +                        let Some(symbol_id) =
 +                            dylib_import_referent(obj, reloc.referent, sym_table, input_symbols)
                          else {
                              continue;
                          };
                          );
+                     }
                      RelocKind::TlvpLoadPage21 | RelocKind::TlvpLoadPageOff12 => {
 -                        if let Some(symbol_id) = symbol_referent_id(obj, reloc.referent, sym_table)
 +                        if let Some(symbol_id) =
 +                            symbol_referent_id(obj, reloc.referent, sym_table, input_symbols)
+                         {
                              if tlv_symbol_needs_got(sym_table, symbol_id) {
                                  got.intern(symbol_id, dylib_import_is_weak(sym_table, symbol_id));
+     }
+ }
 +fn build_synthetic_reloc_cache(inputs: &[LayoutInput<'_>]) -> Result<ParsedRelocCache, SynthError> {
 +    let mut reloc_cache = ParsedRelocCache::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| {
 +                        SynthError {
 +                            input: input.object.path.clone(),
 +                            atom: crate::resolve::AtomId(0),
 +                            reloc_offset: 0,
 +                            kind: RelocKind::Unsigned,
 +                            detail: err.to_string(),
 +                        }
 +                    })?;
 +                parse_relocs(&raws).map_err(|err| SynthError {
 +                    input: input.object.path.clone(),
 +                    atom: crate::resolve::AtomId(0),
 +                    reloc_offset: 0,
 +                    kind: RelocKind::Unsigned,
 +                    detail: err.to_string(),
 +                })?
 +            };
 +            reloc_cache.insert((input.id, (sect_idx + 1) as u8), relocs);
 +        }
 +    }
 +    Ok(reloc_cache)
 +}
++
 +fn build_input_symbol_index(
 +    inputs: &[LayoutInput<'_>],
 +    sym_table: &SymbolTable,
 +    parsed_relocs: &ParsedRelocCache,
 +) -> HashMap<InputId, Vec<Option<SymbolId>>> {
 +    let mut referenced = HashMap::<InputId, HashSet<u32>>::new();
 +    for ((input_id, _), relocs) in parsed_relocs {
 +        let referenced = referenced.entry(*input_id).or_default();
 +        for reloc in relocs {
 +            if let Referent::Symbol(sym_idx) = reloc.referent {
 +                referenced.insert(sym_idx);
 +            }
 +            if let Some(Referent::Symbol(sym_idx)) = reloc.subtrahend {
 +                referenced.insert(sym_idx);
 +            }
 +        }
 +    }
++
 +    let mut index = HashMap::new();
 +    for input in inputs {
 +        let mut symbols = vec![None; input.object.symbols.len()];
 +        if let Some(referenced) = referenced.get(&input.id) {
 +            for sym_idx in referenced {
 +                let Some(input_sym) = input.object.symbols.get(*sym_idx as usize) else {
 +                    continue;
 +                };
 +                let Some(slot) = symbols.get_mut(*sym_idx as usize) else {
 +                    continue;
 +                };
 +                *slot = input
 +                    .object
 +                    .symbol_name(input_sym)
 +                    .ok()
 +                    .and_then(|name| sym_table.lookup_str(name));
 +            }
 +        }
 +        index.insert(input.id, symbols);
 +    }
 +    index
 +}
++
 +fn build_sorted_reloc_index(parsed_relocs: &ParsedRelocCache) -> ParsedRelocCache {
 +    let mut index = ParsedRelocCache::new();
 +    for (key, relocs) in parsed_relocs {
 +        if relocs.is_empty() {
 +            continue;
 +        }
 +        let mut sorted = relocs.clone();
 +        sorted.sort_by_key(|reloc| reloc.offset);
 +        index.insert(*key, sorted);
 +    }
 +    index
 +}
++
  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;
 -    relocs.iter().copied().filter(move |reloc| {
 +    let first = relocs.partition_point(|reloc| reloc.offset < start);
 +    let last = relocs.partition_point(|reloc| reloc.offset < end);
 +    relocs[first..last].iter().copied().filter(move |reloc| {
          let reloc_end = reloc.offset + reloc.width_for_planning();
 -        reloc.offset >= start && reloc_end <= end
 +        reloc_end <= end
      })
+ }
      obj: &ObjectFile,
      referent: Referent,
      sym_table: &SymbolTable,
 +    input_symbols: Option<&[Option<SymbolId>]>,
  ) -> Option<SymbolId> {
 -    let symbol_id = symbol_referent_id(obj, referent, sym_table)?;
 +    let symbol_id = symbol_referent_id(obj, referent, sym_table, input_symbols)?;
      matches!(sym_table.get(symbol_id), Symbol::DylibImport { .. }).then_some(symbol_id)
+ }
      obj: &ObjectFile,
      referent: Referent,
      sym_table: &SymbolTable,
 +    input_symbols: Option<&[Option<SymbolId>]>,
  ) -> Option<SymbolId> {
      let Referent::Symbol(sym_idx) = referent else {
          return None;
      };
 +    if let Some(symbols) = input_symbols {
 +        return symbols.get(sym_idx as usize).copied().flatten();
 +    }
      let input_sym = obj.symbols.get(sym_idx as usize)?;
      let name = obj.symbol_name(input_sym).ok()?;
      let (symbol_id, _) = sym_table

tests/perf_baseline.rsmodified

  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={:?}",
 +        "{name}: total={:?} parse={:?} resolve={:?} atomize={:?} layout={:?} (entry={:?} dead={:?} icf={:?} synth_plan={:?} build={:?} thunks={:?}) 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.layout_entry_lookup,
 +        profile.phases.layout_dead_strip,
 +        profile.phases.layout_icf,
 +        profile.phases.layout_synthetic_plan,
 +        profile.phases.layout_build,
 +        profile.phases.layout_thunk_plan,
          profile.phases.synth_sections,
          profile.phases.synth_linkedit_finalize,
          profile.phases.synth_linkedit_symbol_plan,
          profile.phases.accounted_total() > Duration::ZERO,
          "{name}: all phase timings were zero"
      );
 +    assert!(
 +        profile.phases.layout
 +            >= profile.phases.layout_entry_lookup
 +                + profile.phases.layout_dead_strip
 +                + profile.phases.layout_icf
 +                + profile.phases.layout_synthetic_plan
 +                + profile.phases.layout_build
 +                + profile.phases.layout_thunk_plan,
 +        "{name}: layout subphases exceeded layout total"
 +    );
      assert!(
          profile.phases.synth_sections
              >= profile.phases.synth_linkedit_finalize + profile.phases.synth_unwind,

`@@ -63,6 +63,10 @@` impl StringInterner {
63	63	Istr(id)
64	64	}
65	65
	66	+ pub fn get(&self, s: &str) -> Option<Istr> {
	67	+ self.index.get(s).copied().map(Istr)
	68	+ }
	69	+
66	70	pub fn resolve(&self, i: Istr) -> &str {
67	71	&self.strings[i.0 as usize]
68	72	}
`@@ -554,6 +558,10 @@` impl SymbolTable {
554	558	self.by_name.get(&name).copied()
555	559	}
556	560
	561	+ pub fn lookup_str(&self, name: &str) -> Option<SymbolId> {
	562	+ self.interner.get(name).and_then(\|name\| self.lookup(name))
	563	+ }
	564	+
557	565	pub fn get(&self, id: SymbolId) -> &Symbol {
558	566	&self.symbols[id.0 as usize]
559	567	}