Function perform_data_flow_analysis

objdiff-core/src/obj/read.rs:640–700

(obj: &mut Object, config: &DiffObjConfig)

}

fn perform_data_flow_analysis(obj: &mut Object, config: &DiffObjConfig) -> Result<()> {
    // If neither of these settings are on, no flow analysis to perform
    if !config.analyze_data_flow && !config.ppc_calculate_pool_relocations {
        return Ok(());
    }

    let mut generated_relocations = Vec::<(usize, Vec<Relocation>)>::new();
    let mut generated_flow_results = Vec::<(Symbol, Box<dyn FlowAnalysisResult>)>::new();
    for (section_index, section) in obj.sections.iter().enumerate() {
        if section.kind != SectionKind::Code {
            continue;
        }
        for symbol in obj.symbols.iter() {
            if symbol.section != Some(section_index) {
                continue;
            }
            if symbol.kind != SymbolKind::Function {
                continue;
            }
            let code =
                section.data_range(symbol.address, symbol.size as usize).ok_or_else(|| {
                    anyhow!(
                        "Symbol data out of bounds: {:#x}..{:#x}",
                        symbol.address,
                        symbol.address + symbol.size
                    )
                })?;

            // Optional pooled relocation computation
            // Long view: This could be replaced by the full data flow analysis
            // once that feature has stabilized.
            if config.ppc_calculate_pool_relocations {
                let relocations = obj.arch.generate_pooled_relocations(
                    symbol.address,
                    code,
                    &section.relocations,
                    &obj.symbols,
                );
                generated_relocations.push((section_index, relocations));
            }

            // Optional full data flow analysis
            if config.analyze_data_flow
                && let Some(flow_result) =
                    obj.arch.data_flow_analysis(obj, symbol, code, &section.relocations)
            {
                generated_flow_results.push((symbol.clone(), flow_result));
            }
        }
    }
    for (symbol, flow_result) in generated_flow_results {
        obj.add_flow_analysis_result(&symbol, flow_result);
    }
    for (section_index, mut relocations) in generated_relocations {
        obj.sections[section_index].relocations.append(&mut relocations);
    }
    for section in obj.sections.iter_mut() {
        section.relocations.sort_by_key(|r| r.address);