`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,
++                reloc::arm64::ThunkPlanningContext {
--                &layout_inputs,
++                    layout: &layout,
--                &atom_table,
++                    inputs: &layout_inputs,
--                &sym_table,
++                    atoms: &atom_table,
--                Some(&synthetic_plan),
++                    sym_table: &sym_table,
--                icf_redirects,
++                    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,
++    ctx: ThunkPlanningContext<'_>,
--    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 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)
++        let parsed_relocs = crate::macho::writer::build_parsed_reloc_cache(&inputs).unwrap();
--            .unwrap()
++        let plan = plan_thunks(
--            .unwrap();
++            &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)
++        let replan = plan_thunks(
--            .unwrap()
++            &opts,
--            .unwrap();
++            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();
++        let input_symbol_index = build_input_symbol_index(inputs, sym_table, parsed_relocs);
--        for input in inputs {
++        let reloc_index = build_sorted_reloc_index(parsed_relocs);
--            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 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,