Function map_section_relocations

objdiff-core/src/obj/read.rs:461–595

(
    arch: &dyn Arch,
    obj_file: &object::File,
    obj_section: &object::Section,
    symbol_indices: &[usize],
    ordered_symbols: &[Vec<object::Symbol>],
)

}

fn map_section_relocations(
    arch: &dyn Arch,
    obj_file: &object::File,
    obj_section: &object::Section,
    symbol_indices: &[usize],
    ordered_symbols: &[Vec<object::Symbol>],
) -> Result<Vec<Relocation>> {
    let mut relocations = Vec::<Relocation>::with_capacity(obj_section.relocations().count());
    for (address, reloc) in obj_section.relocations() {
        let mut target_reloc = RelocationOverride {
            target: match reloc.target() {
                object::RelocationTarget::Symbol(symbol) => {
                    RelocationOverrideTarget::Symbol(symbol)
                }
                object::RelocationTarget::Section(section) => {
                    RelocationOverrideTarget::Section(section)
                }
                _ => RelocationOverrideTarget::Skip,
            },
            addend: reloc.addend(),
        };

        // Allow the architecture to override the relocation target and addend
        match arch.relocation_override(obj_file, obj_section, address, &reloc)? {
            Some(reloc_override) => {
                match reloc_override.target {
                    RelocationOverrideTarget::Keep => {}
                    target => {
                        target_reloc.target = target;
                    }
                }
                target_reloc.addend = reloc_override.addend;
            }
            None => {
                ensure!(
                    !reloc.has_implicit_addend(),
                    "Unsupported {:?} implicit relocation {:?}",
                    obj_file.architecture(),
                    reloc.flags()
                );
            }
        }

        // Resolve the relocation target symbol
        let (symbol_index, addend) = match target_reloc.target {
            RelocationOverrideTarget::Keep => unreachable!(),
            RelocationOverrideTarget::Skip => continue,
            RelocationOverrideTarget::Symbol(symbol_index) => {
                // Sometimes used to indicate "absolute"
                if symbol_index.0 == u32::MAX as usize {
                    continue;
                }

                // If the target is a section symbol, try to resolve a better symbol as the target
                if let Some(section_symbol) = obj_file
                    .symbol_by_index(symbol_index)
                    .ok()
                    .filter(|s| s.kind() == object::SymbolKind::Section)