`23e8dad`

Index local symbol ranges

Authored by

espadonne 3 weeks ago

SHA: 23e8daddfe2445fa6c5bbd80d6df5c7655d822da
Parents: 5a28bad
Tree: acaa458

1 changed file

Status	File	+	-
M	`src/macho/writer.rs`	96	54

src/macho/writer.rsmodified

  #[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;
          .map(|record| (record.symbol, record))
          .collect();
      let visibility = SymbolVisibilityPolicy::from_opts(opts)?;
--    let symbol_plan = build_output_symbols(
++    let (symbol_plan, symbol_plan_timings) = build_output_symbols_profiled(
          layout,
          kind,
          opts.dead_strip,
          &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);
+     }
      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,
++                &atom_ranges,
--                &atoms_by_input_section,
                  input.id,
                  section_index,
                  section_relative,
                  entry.length as u32,
--                icf_redirects,
+             )
              .ok_or_else(|| {
                  WriteError::MalformedDataInCode(
      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,
      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
          .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());
          });
+     }
++    let phase_started = std::time::Instant::now();
      for input in inputs.0.layout_inputs {
          let ctx = LocalSymbolContext {
              atom_table: inputs.0.atom_table,
--            atoms_by_input_section: &atoms_by_input_section,
++            atom_ranges: &atom_ranges,
              atom_sections: &atom_sections,
--            icf_redirects: inputs.0.icf_redirects,
              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)?;
++    timings.locals += phase_started.elapsed();
++    let phase_started = std::time::Instant::now();
      for (symbol_id, symbol) in sym_table.iter() {
          let Symbol::Defined {
              name,
          });
+     }
      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 {
              symbol_indices.insert(symbol, idx as u32);
+         }
+     }
++    timings.strtab += phase_started.elapsed();
--    Ok(SymbolTablePlan {
++    Ok((
--        symbols,
++        SymbolTablePlan {
--        map_symbols,
++            symbols,
--        strtab_bytes,
++            map_symbols,
--        symbol_indices,
++            strtab_bytes,
--        exports,
++            symbol_indices,
--        dysymtab: DysymtabCmd {
++            exports,
--            ilocalsym: 0,
++            dysymtab: DysymtabCmd {
--            nlocalsym,
++                ilocalsym: 0,
--            iextdefsym: nlocalsym,
++                nlocalsym,
--            nextdefsym,
++                iextdefsym: nlocalsym,
--            iundefsym: nlocalsym + nextdefsym,
++                nextdefsym,
--            nundefsym,
++                iundefsym: nlocalsym + nextdefsym,
--            ..DysymtabCmd::default()
++                nundefsym,
++                ..DysymtabCmd::default()
++            },
          },
--    })
++        timings,
++    ))
+ }
  fn sort_local_symbols(locals: &mut [OutputSymbolSpec]) {
                      .expect("section symbol without section");
                  let offset = input_sym.value().saturating_sub(section.addr) as u32;
                  let (atom_id, delta) = find_containing_atom(
--                    ctx.atom_table,
++                    ctx.atom_ranges,
--                    ctx.atoms_by_input_section,
                      ctx.input_id,
                      input_sym.sect_idx(),
                      offset,
--                    ctx.icf_redirects,
+                 )
                  .ok_or(WriteError::MissingSegment("__UNKNOWN"))?;
                  let addr =
  struct LocalSymbolContext<'a> {
      atom_table: &'a AtomTable,
--    atoms_by_input_section: &'a HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
++    atom_ranges: &'a AtomRangeIndex,
      atom_sections: &'a HashMap<crate::resolve::AtomId, u8>,
--    icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
      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,
--    icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
  ) -> Option<(crate::resolve::AtomId, u32)> {
--    find_containing_atom_range(
++    find_containing_atom_range(atom_ranges, input_id, input_section, offset, 1)
--        atom_table,
--        atoms_by_input_section,
--        input_id,
--        input_section,
--        offset,
--        1,
--        icf_redirects,
--    )
+ }
  fn find_containing_atom_range(
--    atom_table: &AtomTable,
++    atom_ranges: &AtomRangeIndex,
--    atoms_by_input_section: &HashMap<(InputId, u8), Vec<crate::resolve::AtomId>>,
      input_id: InputId,
      input_section: u8,
      offset: u32,
      len: u32,
--    icf_redirects: Option<&HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
  ) -> Option<(crate::resolve::AtomId, u32)> {
--    atoms_by_input_section
++    let ranges = atom_ranges.get(&(input_id, input_section))?;
--        .get(&(input_id, input_section))
++    let range_end = offset.checked_add(len)?;
--        .and_then(|ids| {
++    let idx = ranges.partition_point(|range| range.start <= offset);
--            ids.iter().find_map(|atom_id| {
++    let range = idx.checked_sub(1).and_then(|idx| ranges.get(idx))?;
--                let atom = atom_table.get(*atom_id);
++    (range.start <= offset && range_end <= range.end).then_some((range.atom, offset - range.start))
--                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((canonical_atom(*atom_id, icf_redirects), offset - start))
--            })
--        })
+ }
  fn canonical_atom(