Function infer_symbol_sizes

objdiff-core/src/obj/read.rs:288–363

(arch: &dyn Arch, symbols: &mut [Symbol], sections: &[Section])

}

fn infer_symbol_sizes(arch: &dyn Arch, symbols: &mut [Symbol], sections: &[Section]) -> Result<()> {
    // Above, we've sorted the symbols by section and then by address.

    // Set symbol sizes based on the next symbol's address
    let mut iter_idx = 0;
    let mut last_end = (0, 0);
    while iter_idx < symbols.len() {
        let symbol_idx = iter_idx;
        let symbol = &symbols[symbol_idx];
        let Some(section_idx) = symbol.section else {
            // Start of absolute symbols
            break;
        };
        iter_idx += 1;
        if symbol.size != 0 {
            if symbol.kind != SymbolKind::Section {
                last_end = (section_idx, symbol.address + symbol.size);
            }
            continue;
        }
        // Skip over symbols that are contained within the previous symbol
        if last_end.0 == section_idx && last_end.1 > symbol.address {
            continue;
        }
        let next_symbol = loop {
            let Some(next_symbol) = symbols.get(iter_idx) else {
                break None;
            };
            if next_symbol.section != Some(section_idx) {
                break None;
            }
            if match symbol.kind {
                SymbolKind::Function | SymbolKind::Object => {
                    // For function/object symbols, find the next function/object
                    matches!(next_symbol.kind, SymbolKind::Function | SymbolKind::Object)
                }
                SymbolKind::Unknown | SymbolKind::Section => {
                    // For labels (or anything else), stop at any symbol
                    true
                }
            } && !is_local_label(next_symbol)
            {
                break Some(next_symbol);
            }
            iter_idx += 1;
        };
        let section = &sections[section_idx];
        let next_address =
            next_symbol.map(|s| s.address).unwrap_or_else(|| section.address + section.size);
        let new_size = if symbol.kind == SymbolKind::Section && section.kind == SectionKind::Data {
            // Data sections already have always-visible section symbols created by objdiff to allow
            // diffing them, so no need to unhide these.
            0
        } else if section.kind == SectionKind::Code {
            arch.infer_function_size(symbol, section, next_address)?
        } else {
            next_address.saturating_sub(symbol.address)
        };