`43a662a`

Avoid cloned strtab offset map

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

SHA: 43a662acdd8322063c62818599c29abbb71066c0
Parents: d608670
Tree: 0735ea5

2 changed files

Status	File	+	-
M	`src/macho/writer.rs`	14	30
M	`src/string_table.rs`	66	0

src/macho/writer.rsmodified

  use crate::resolve::{Symbol, SymbolId, SymbolTable};
  use crate::section::is_executable;
  use crate::string_table::StringTableBuilder;
--use crate::symbol::{write_nlist_table, InputSymbol, RawNlist, SymKind};
++use crate::symbol::{write_nlist_table, InputSymbol, RawNlist, SymKind, NLIST_SIZE};
  use crate::synth::tlv::THREAD_VARIABLE_DESCRIPTOR_SIZE;
  use crate::synth::{
      code_sig::CodeSignaturePlan,
      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();
++    let mut symtab_bytes = Vec::with_capacity(symbol_plan.symbols.len() * NLIST_SIZE);
      write_nlist_table(&symbol_plan.symbols, &mut symtab_bytes);
      let mut indirect_symbols = Vec::new();
          Vec::new()
      };
--    let phase_started = std::time::Instant::now();
      let local_count = if strip_locals { 0 } else { locals.len() };
++    let external_defined_count = external_defineds.len();
++    let undefined_count = undefineds.len();
++    let phase_started = std::time::Instant::now();
      let mut specs = Vec::with_capacity(local_count + external_defineds.len() + undefineds.len());
      if !strip_locals {
          specs.extend(locals);
      specs.extend(external_defineds);
      specs.extend(undefineds);
--    let mut strtab = StringTableBuilder::new();
++    let (strtab_bytes, strx_by_spec) =
--    for spec in &specs {
++        StringTableBuilder::build_with_name_offsets(specs.iter().map(|spec| spec.name.as_str()));
--        strtab.insert(&spec.name);
--    }
--    let (strtab_bytes, strx_by_name) = strtab.finish();
--
--    let nlocalsym = specs
--        .iter()
--        .filter(|spec| spec.partition == OutputSymbolPartition::Local)
--        .count() as u32;
--    let nextdefsym = specs
--        .iter()
--        .filter(|spec| spec.partition == OutputSymbolPartition::ExternalDefined)
--        .count() as u32;
--    let nundefsym = specs
--        .iter()
--        .filter(|spec| spec.partition == OutputSymbolPartition::Undefined)
--        .count() as u32;
      let mut symbols = Vec::with_capacity(specs.len());
--    let mut symbol_indices = HashMap::new();
++    let mut symbol_indices = HashMap::with_capacity(specs.len());
      let map_symbols = specs
          .iter()
          .filter(|spec| spec.partition != OutputSymbolPartition::Undefined)
          })
          .collect();
      for (idx, spec) in specs.into_iter().enumerate() {
--        let strx = *strx_by_name
++        let strx = strx_by_spec[idx];
--            .get(&spec.name)
--            .expect("string table offset missing for output symbol");
          symbols.push(InputSymbol::from_raw(RawNlist {
              strx,
              n_type: spec.n_type,
              exports,
              dysymtab: DysymtabCmd {
                  ilocalsym: 0,
--                nlocalsym,
++                nlocalsym: local_count as u32,
--                iextdefsym: nlocalsym,
++                iextdefsym: local_count as u32,
--                nextdefsym,
++                nextdefsym: external_defined_count as u32,
--                iundefsym: nlocalsym + nextdefsym,
++                iundefsym: (local_count + external_defined_count) as u32,
--                nundefsym,
++                nundefsym: undefined_count as u32,
                  ..DysymtabCmd::default()
              },
          },

src/string_table.rsmodified

      offset: u32,
+ }
++#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++struct BorrowedRootString<'a> {
++    name: &'a str,
++    offset: u32,
++}
++
  impl StringTableBuilder {
      pub fn new() -> Self {
          Self::default()
          self.offsets.entry(name.to_string()).or_insert(0);
+     }
++    pub fn build_with_name_offsets<'a, I>(names: I) -> (Vec<u8>, Vec<u32>)
++    where
++        I: IntoIterator<Item = &'a str>,
++    {
++        let mut entries: Vec<_> = names
++            .into_iter()
++            .enumerate()
++            .map(|(index, name)| (name, index))
++            .collect();
++        let mut offsets = vec![0; entries.len()];
++        entries.sort_by(|(lhs, lhs_index), (rhs, rhs_index)| {
++            reverse_suffix_order(lhs, rhs).then_with(|| lhs_index.cmp(rhs_index))
++        });
++
++        let mut raw = vec![0u8];
++        let mut roots = Vec::new();
++        for (name, index) in entries {
++            if let Some(offset) = find_borrowed_suffix_offset(&roots, name) {
++                offsets[index] = offset;
++                continue;
++            }
++
++            let offset = raw.len() as u32;
++            raw.extend_from_slice(name.as_bytes());
++            raw.push(0);
++            roots.push(BorrowedRootString { name, offset });
++            offsets[index] = offset;
++        }
++
++        while !raw.len().is_multiple_of(8) {
++            raw.push(0);
++        }
++        (raw, offsets)
++    }
++
      pub fn finish(mut self) -> (Vec<u8>, HashMap<String, u32>) {
          let mut names: Vec<String> = self.offsets.keys().cloned().collect();
          names.sort_by(|lhs, rhs| reverse_suffix_order(lhs, rhs));
+     }
+ }
++fn find_borrowed_suffix_offset(roots: &[BorrowedRootString<'_>], name: &str) -> Option<u32> {
++    if name.is_empty() {
++        return Some(0);
++    }
++    let insert_at = roots.partition_point(|root| reverse_suffix_order(root.name, name).is_lt());
++    let existing = roots.get(insert_at.checked_sub(1)?)?;
++    (existing.name.len() >= name.len() && existing.name.ends_with(name))
++        .then(|| existing.offset + (existing.name.len() - name.len()) as u32)
++}
++
  fn reverse_suffix_order(lhs: &str, rhs: &str) -> std::cmp::Ordering {
      let mut lhs_rev = lhs.bytes().rev();
      let mut rhs_rev = rhs.bytes().rev();
          assert_eq!(table.get(offsets["_alpha"]).unwrap(), "_alpha");
          assert_eq!(table.get(offsets["_beta"]).unwrap(), "_beta");
+     }
++
++    #[test]
++    fn builder_returns_offsets_in_input_order_without_cloning_keys() {
++        let names = ["_helper", "_afs_helper", "_helper", ""];
++        let (bytes, offsets) = StringTableBuilder::build_with_name_offsets(names);
++        let table = StringTable::from_bytes(bytes);
++
++        assert_eq!(table.get(offsets[0]).unwrap(), "_helper");
++        assert_eq!(table.get(offsets[1]).unwrap(), "_afs_helper");
++        assert_eq!(table.get(offsets[2]).unwrap(), "_helper");
++        assert_eq!(table.get(offsets[3]).unwrap(), "");
++        assert_eq!(offsets[0], offsets[2]);
++        assert_eq!(offsets[0], offsets[1] + 4);
++        assert_eq!(table.as_bytes().len() % 8, 0);
++    }
+ }