`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() {
++            let Some(addr) = atom_addrs.get(atom).copied() else {
--                continue;
++                if dead_strip {
--            }
++                    continue;
--            let addr = layout
++                }
--                .atom_addr(*atom)
++                return Err(WriteError::DefinedSymbolAtomMissing(symbol_id, *atom));
--                .ok_or(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 =
++                let addr = ctx.atom_addrs.get(&atom_id).copied().ok_or(
--                    layout
++                    WriteError::DefinedSymbolAtomMissing(SymbolId(u32::MAX), atom_id),
--                        .atom_addr(atom_id)
++                )? + delta as u64;
--                        .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 {