fn handle_macho_binary()

in src/extract_execute.rs [204:275]

• 63 lines of code
• 10 McCabe index (conditional complexity)

fn handle_macho_binary(
    macho: &mach::MachO,
    sections: &mut Vec<SectionInfo>,
    architecture: &mut String,
    entry_string: &mut String,
    imports_result: &mut HashMap<String, HashSet<String>>,
    exports_result: &mut HashSet<String>,
) {
    if entry_string.is_empty() {
        *entry_string = format!("0x{:x}", macho.entry);
    } else {
        *entry_string += ",";
        *entry_string += &format!("0x{:x}", macho.entry);
    }

    for segment in &macho.segments {
        let Ok(sects) = segment.sections() else {
            continue;
        };

        for (section, _) in sects {
            let section_info = SectionInfo {
                name: section.name().unwrap_or("").to_string(),
                virtual_address: section.addr,
                virtual_size: section.size,
                raw_address: section.offset as u64,
                raw_size: section.size,
                characteristics_num: 0,
                characteristics_str: String::new(),
            };

            sections.push(section_info);
        }
    }

    let arch = match macho.header.cputype {
        mach::cputype::CPU_TYPE_X86 => "x86",
        mach::cputype::CPU_TYPE_X86_64 => "x86_64",
        mach::cputype::CPU_TYPE_ARM => "ARM",
        mach::cputype::CPU_TYPE_ARM64 => "ARM64",
        mach::cputype::CPU_TYPE_POWERPC => "PowerPC",
        mach::cputype::CPU_TYPE_POWERPC64 => "PowerPC64",
        _ => "unknown",
    };
    if architecture.is_empty() {
        *architecture = arch.to_string();
    } else {
        *architecture += ",";
        *architecture += arch;
    }

    if let Ok(exports) = macho.exports() {
        for export in exports {
            exports_result.insert(export.name);
        }
    }

    if let Ok(dyld_info) = macho.imports() {
        for import in dyld_info {
            if !imports_result.contains_key(import.dylib) {
                imports_result.insert(import.dylib.to_string(), HashSet::new());
            }
    
            let Some(entry) = imports_result.get_mut(import.dylib) else {
                continue;
            };

            entry.insert(import.name.to_string());
        }
    }

}