`4bf5d09`

Speed thunk and symbol planning

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

SHA: 4bf5d0983c29cdce9fbb4e6c14778b41bc372a1f
Parents: afcd90f
Tree: ffb4095

2 changed files

Status	File	+	-
M	`src/macho/writer.rs`	23	16
M	`src/reloc/arm64.rs`	66	0

src/macho/writer.rsmodified

  ) -> Result<(SymbolTablePlan, SymbolPlanBuildTimings), WriteError> {
      let sym_table = inputs.0.sym_table;
      let atom_sections = atom_section_ordinals(layout);
 +    let atom_addrs = atom_addresses(layout);
      let atoms_by_input_section = inputs.0.atom_table.by_input_section();
      let atom_ranges = build_atom_range_index(
          inputs.0.atom_table,
              atom_table: inputs.0.atom_table,
              atom_ranges: &atom_ranges,
              atom_sections: &atom_sections,
 +            atom_addrs: &atom_addrs,
              input_id: input.id,
              file_index: file_index_by_input[&input.id],
          };
 -        collect_local_symbols(layout, &ctx, input.object, &mut locals)?;
 +        collect_local_symbols(&ctx, input.object, &mut locals)?;
+     }
      collect_synthetic_local_symbols(layout, inputs.0.synthetic_plan, &mut locals)?;
      timings.locals += phase_started.elapsed();
          let (n_type, n_sect, n_value) = if atom.0 == 0 {
              (absolute_symbol_type(hidden), NO_SECT, *value)
          } else {
 -            if dead_strip && layout.atom_addr(*atom).is_none() {
 -                continue;
 -            }
 -            let addr = layout
 -                .atom_addr(*atom)
 -                .ok_or(WriteError::DefinedSymbolAtomMissing(symbol_id, *atom))?;
 +            let Some(addr) = atom_addrs.get(atom).copied() else {
 +                if dead_strip {
 +                    continue;
 +                }
 +                return Err(WriteError::DefinedSymbolAtomMissing(symbol_id, *atom));
 +            };
              let sect = *atom_sections
                  .get(atom)
                  .ok_or(WriteError::DefinedSymbolSectionMissing(symbol_id, *atom))?;
+ }
  fn collect_local_symbols(
 -    layout: &Layout,
      ctx: &LocalSymbolContext<'_>,
      object: &ObjectFile,
      out: &mut Vec<OutputSymbolSpec>,
                      offset,
+                 )
                  .ok_or(WriteError::MissingSegment("__UNKNOWN"))?;
 -                let addr =
 -                    layout
 -                        .atom_addr(atom_id)
 -                        .ok_or(WriteError::DefinedSymbolAtomMissing(
 -                            SymbolId(u32::MAX),
 -                            atom_id,
 -                        ))?
 -                        + delta as u64;
 +                let addr = ctx.atom_addrs.get(&atom_id).copied().ok_or(
 +                    WriteError::DefinedSymbolAtomMissing(SymbolId(u32::MAX), atom_id),
 +                )? + delta as u64;
                  let n_sect = *ctx.atom_sections.get(&atom_id).ok_or(
                      WriteError::DefinedSymbolSectionMissing(SymbolId(u32::MAX), atom_id),
                  )?;
      atom_table: &'a AtomTable,
      atom_ranges: &'a AtomRangeIndex,
      atom_sections: &'a HashMap<crate::resolve::AtomId, u8>,
 +    atom_addrs: &'a HashMap<crate::resolve::AtomId, u64>,
      input_id: InputId,
      file_index: usize,
+ }
      out
+ }
 +fn atom_addresses(layout: &Layout) -> HashMap<AtomId, u64> {
 +    let mut out = HashMap::new();
 +    for section in &layout.sections {
 +        for placed in &section.atoms {
 +            out.insert(placed.atom, section.addr + placed.offset);
 +        }
 +    }
 +    out
 +}
++
  fn export_symbol_flags(layout: &Layout, n_desc: u16, n_type: u8, n_sect: u8) -> u64 {
      let mut flags = 0u64;
      if n_desc & N_WEAK_DEF != 0 {

src/reloc/arm64.rsmodified

  const THUNK_SIZE: u64 = 12;
  const BR_X16: u32 = 0xd61f_0200;
 +const BRANCH26_MAX_FORWARD_DELTA_BYTES: u64 = ((1u64 << 25) - 1) * 4;
  #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  enum BranchTargetKey {
          parsed_relocs,
      } = ctx;
 +    if opts.thunks == ThunkMode::Safe && layout_fits_branch26_span(layout) {
 +        return Ok(None);
 +    }
++
      let input_map: HashMap<InputId, &ObjectFile> = inputs
          .iter()
          .map(|input| (input.id, input.object))
      delta & 0b11 == 0 && fits_signed(delta >> 2, 26)
+ }
 +fn layout_fits_branch26_span(layout: &Layout) -> bool {
 +    let mut min_addr = u64::MAX;
 +    let mut max_addr = 0u64;
 +    for section in &layout.sections {
 +        if section.segment == "__LINKEDIT" || section.size == 0 {
 +            continue;
 +        }
 +        min_addr = min_addr.min(section.addr);
 +        max_addr = max_addr.max(section.addr.saturating_add(section.size));
 +    }
 +    min_addr == u64::MAX || max_addr.saturating_sub(min_addr) <= BRANCH26_MAX_FORWARD_DELTA_BYTES
 +}
++
  fn synthesize_thunk_section(
      layout: &mut Layout,
      plan: &ThunkPlan,
          assert!(!fits_signed(-(1 << 25) - 1, 26));
+     }
 +    #[test]
 +    fn branch26_span_fast_path_rejects_only_large_non_linkedit_images() {
 +        let small = Layout {
 +            kind: OutputKind::Executable,
 +            segments: Vec::new(),
 +            sections: vec![
 +                output_section("__TEXT", "__text", 0x1_0000_0000, 0x100),
 +                output_section("__DATA", "__data", 0x1_0001_0000, 0x100),
 +                output_section("__LINKEDIT", "__linkedit", 0x1_8000_0000, 0x1000),
 +            ],
 +        };
 +        assert!(layout_fits_branch26_span(&small));
++
 +        let large = Layout {
 +            kind: OutputKind::Executable,
 +            segments: Vec::new(),
 +            sections: vec![
 +                output_section("__TEXT", "__text", 0x1_0000_0000, 0x100),
 +                output_section(
 +                    "__DATA",
 +                    "__data",
 +                    0x1_0000_0000 + BRANCH26_MAX_FORWARD_DELTA_BYTES + 1,
 +                    0x100,
 +                ),
 +            ],
 +        };
 +        assert!(!layout_fits_branch26_span(&large));
 +    }
++
      #[test]
      fn thunk_plan_splits_monolithic_text_section_into_multiple_islands() {
          let gap = 0x0900_0000u32;
          out
+     }
 +    fn output_section(segment: &str, name: &str, addr: u64, size: u64) -> OutputSection {
 +        OutputSection {
 +            segment: segment.into(),
 +            name: name.into(),
 +            kind: SectionKind::Text,
 +            align_pow2: 2,
 +            flags: 0,
 +            reserved1: 0,
 +            reserved2: 0,
 +            reserved3: 0,
 +            atoms: Vec::new(),
 +            synthetic_offset: 0,
 +            synthetic_data: Vec::new(),
 +            addr,
 +            size,
 +            file_off: 0,
 +        }
 +    }
++
      fn thunk_test_object(raw_relocs: Vec<u8>, target_offset: u64, section_size: u64) -> ObjectFile {
          let strings = b"\0_target\0".to_vec();
          ObjectFile {