`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();
 -    for spec in &specs {
 -        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 (strtab_bytes, strx_by_spec) =
 +        StringTableBuilder::build_with_name_offsets(specs.iter().map(|spec| spec.name.as_str()));
      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
 -            .get(&spec.name)
 -            .expect("string table offset missing for output symbol");
 +        let strx = strx_by_spec[idx];
          symbols.push(InputSymbol::from_raw(RawNlist {
              strx,
              n_type: spec.n_type,
              exports,
              dysymtab: DysymtabCmd {
                  ilocalsym: 0,
 -                nlocalsym,
 -                iextdefsym: nlocalsym,
 -                nextdefsym,
 -                iundefsym: nlocalsym + nextdefsym,
 -                nundefsym,
 +                nlocalsym: local_count as u32,
 +                iextdefsym: local_count as u32,
 +                nextdefsym: external_defined_count as u32,
 +                iundefsym: (local_count + external_defined_count) as u32,
 +                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);
 +    }
+ }