642d5a256791
dataflow_mode_registers.rs
//! Regressions for architecture-scoped register filtering (`r13`/`r15` on ARM32/Thumb vs
//! general-purpose `r13`–`r15` on x86-64) and canonical scratch clobber names on 32-/16-bit x86
//! in `craft_anything_disasm::dataflow::def_use`.
use craft_anything_disasm::dataflow::def_use;
use craft_anything_disasm::{Image, Limits, NoControl, Program};
use craft_anything_formats::{Arch, Binary};
use std::sync::Arc;
/// Build and analyze a raw single-function image at `0x1000` (with optional Thumb entry bit).
fn raw_def_use(bytes: Vec<u8>, arch: Arch, thumb: bool) -> craft_anything_disasm::dataflow::DefUse {
let mut bin = Binary::raw(arch, 0x1000, bytes.len() as u64, 0);
if thumb {
bin.entry = Some(0x1001);
}
let img = Image::from_binary(Arc::from(bytes), bin);
let prog = Program::analyze(&img, &Limits::default(), &NoControl).expect("analyze raw function");
let func = prog.functions.get(&0x1000).expect("function at 0x1000");
let flow = def_use(&img, &prog, func, 500, 1000);
assert!(!flow.truncated, "{flow:?}");
flow
}
/// ARM32 and Thumb `def_use` must ignore stack-pointer (`r13`) and program-counter (`r15`)
/// bookkeeping on `defines`, `edges`, and store `Effect.inputs` (matching `rsp`/`sp`/`rip` on
/// x86-64 and AArch64) while keeping real data registers like `r0` and `r4`.
#[test]
fn arm_and_thumb_def_use_ignores_sp_and_pc_bookkeeping() {
// A32: push {r4, lr}; str r0, [sp]; add r0, r0, #1; pop {r4, pc}
let a32: Vec<u8> = [0xe92d_4010u32, 0xe58d_0000, 0xe280_0001, 0xe8bd_8010].into_iter().flat_map(u32::to_le_bytes).collect();
// Thumb: push {r4, lr}; str r0, [sp, #0]; adds r0, #1; pop {r4, pc}
let thumb: Vec<u8> = vec![0x10, 0xb5, 0x00, 0x90, 0x01, 0x30, 0x10, 0xbd];
for (label, bytes, is_thumb, pop_addr) in [("A32", a32, false, 0x100cu64), ("T32", thumb, true, 0x1006u64)] {
let flow = raw_def_use(bytes, Arch::Arm, is_thumb);
for node in &flow.nodes {
assert!(
!node.defines.iter().any(|r| matches!(r.as_str(), "r13" | "r15")),
"{label}: node {:?} leaked SP/PC into defines: {:?}",
node.addr,
node.defines
);
}
for edge in &flow.edges {
assert!(!matches!(edge.register.as_str(), "r13" | "r15"), "{label}: unexpected SP/PC edge: {edge:?}");
}
let push_node = flow.nodes.iter().find(|n| n.addr == Some(0x1000)).expect("push node");
assert!(push_node.defines.is_empty(), "{label}: push should define no tracked GPRs: {push_node:?}");
let pop_node = flow.nodes.iter().find(|n| n.addr == Some(pop_addr)).expect("pop node");
assert_eq!(pop_node.defines, vec!["r4".to_string()], "{label}: pop {pop_node:?}");
let store = flow.effects.iter().find(|e| e.kind == "store").expect("stack store effect");
assert_eq!(store.inputs, vec!["r0".to_string()], "{label}: store inputs should exclude r13: {store:?}");
}
// Non-terminal `pc` write + subsequent `pc` reads (`popeq {r4, pc}; add r0, pc, #8;
// str pc, [r1]; pop {r4, pc}`) verify `r15` is filtered from `DfEdge` and store `Effect.inputs`
// as well as `DfNode.defines`.
let pc_reads: Vec<u8> = [0x08bd_8010u32, 0xe28f_0008, 0xe581_f000, 0xe8bd_8010].into_iter().flat_map(u32::to_le_bytes).collect();
let pc_flow = raw_def_use(pc_reads, Arch::Arm, false);
assert!(!pc_flow.nodes.iter().any(|n| n.defines.iter().any(|r| matches!(r.as_str(), "r13" | "r15"))), "{pc_flow:?}");
assert!(!pc_flow.edges.iter().any(|e| matches!(e.register.as_str(), "r13" | "r15")), "{pc_flow:?}");
let pc_store = pc_flow.effects.iter().find(|e| e.kind == "store").expect("str pc, [r1] effect");
assert_eq!(pc_store.inputs, vec!["r1".to_string()], "store inputs should exclude r15: {pc_store:?}");
// Once saved on the stack, `lr` (`r14`) is frequently reused as a general-purpose scratch
// register on A32 (`push {r4, lr}; mov lr, #9; add r0, r0, lr; pop {r4, pc}`): keep its edge.
let lr_scratch: Vec<u8> = [0xe92d_4010u32, 0xe3a0_e009, 0xe080_000e, 0xe8bd_8010].into_iter().flat_map(u32::to_le_bytes).collect();
let lr_flow = raw_def_use(lr_scratch, Arch::Arm, false);
let set_lr = lr_flow.nodes.iter().find(|n| n.addr == Some(0x1004)).expect("mov lr, #9");
let use_lr = lr_flow.nodes.iter().find(|n| n.addr == Some(0x1008)).expect("add r0, r0, lr");
assert_eq!(set_lr.defines, vec!["r14".to_string()]);
assert!(lr_flow.edges.iter().any(|e| e.from == set_lr.id && e.to == use_lr.id && e.register == "r14"), "{lr_flow:?}");
}
/// On `Mode::X64`, `r13` and `r15` are general-purpose registers (not SP/PC) and must retain
/// their `defines` and def-use edges while `rsp` remains ignored.
#[test]
fn x86_64_general_purpose_r13_and_r15_keep_their_def_use_edges() {
// push r13 (41 55); mov r13d, 7 (41 bd 07 00 00 00); mov r15d, 3 (41 bf 03 00 00 00);
// mov eax, r13d (44 89 e8); add eax, r15d (44 01 f8); pop r13 (41 5d); ret (c3)
let code = vec![0x41, 0x55, 0x41, 0xbd, 7, 0, 0, 0, 0x41, 0xbf, 3, 0, 0, 0, 0x44, 0x89, 0xe8, 0x44, 0x01, 0xf8, 0x41, 0x5d, 0xc3];
let flow = raw_def_use(code, Arch::X86_64, false);
let set_r13 = flow.nodes.iter().find(|n| n.addr == Some(0x1002)).expect("mov r13d, 7");
let set_r15 = flow.nodes.iter().find(|n| n.addr == Some(0x1008)).expect("mov r15d, 3");
let mov_eax = flow.nodes.iter().find(|n| n.addr == Some(0x100e)).expect("mov eax, r13d");
let add_eax = flow.nodes.iter().find(|n| n.addr == Some(0x1011)).expect("add eax, r15d");
assert_eq!(set_r13.defines, vec!["r13".to_string()]);
assert_eq!(set_r15.defines, vec!["r15".to_string()]);
assert!(flow.edges.iter().any(|e| e.from == set_r13.id && e.to == mov_eax.id && e.register == "r13"), "{flow:?}");
assert!(flow.edges.iter().any(|e| e.from == set_r15.id && e.to == add_eax.id && e.register == "r15"), "{flow:?}");
assert!(!flow.edges.iter().any(|e| e.register == "rsp"), "{flow:?}");
}
/// 32-bit and 16-bit x86 decoders normalize register names to `"rax"`, `"rcx"`, `"rdx"`, so
/// `call` nodes must clobber only those canonical names instead of emitting duplicate dead
/// `"eax"`, `"ecx"`, `"edx"` entries.
#[test]
fn x86_32_and_x86_16_calls_clobber_only_canonical_registers() {
// 32-bit x86 at 0x1000:
// 0x1000: mov ecx, 5 (b9 05 00 00 00)
// 0x1005: call 0x1010 (e8 06 00 00 00)
// 0x100a: add eax, ecx (01 c8)
// 0x100c: ret (c3)
// 0x1010 <callee>: ret (c3)
let mut x32 = vec![0x90u8; 0x14];
x32[0x00..0x0d].copy_from_slice(&[0xb9, 5, 0, 0, 0, 0xe8, 6, 0, 0, 0, 0x01, 0xc8, 0xc3]);
x32[0x10] = 0xc3;
let flow32 = raw_def_use(x32, Arch::X86, false);
let mov_ecx = flow32.nodes.iter().find(|n| n.addr == Some(0x1000)).expect("mov ecx, 5");
let call32 = flow32.nodes.iter().find(|n| n.addr == Some(0x1005)).expect("call 0x1010");
let add32 = flow32.nodes.iter().find(|n| n.addr == Some(0x100a)).expect("add eax, ecx");
let ret32 = flow32.nodes.iter().find(|n| n.addr == Some(0x100c)).expect("ret");
assert_eq!(call32.defines, vec!["rax".to_string(), "rcx".to_string(), "rdx".to_string()], "{call32:?}");
assert!(!flow32.edges.iter().any(|e| e.from == mov_ecx.id && e.to == add32.id && e.register == "rcx"), "call must kill earlier ecx/rcx: {flow32:?}");
assert!(flow32.edges.iter().any(|e| e.from == call32.id && e.to == add32.id && e.register == "rcx"), "{flow32:?}");
assert!(flow32.edges.iter().any(|e| e.from == add32.id && e.to == ret32.id && e.register == "rax"), "{flow32:?}");
// 16-bit x86 at 0x1000: call 0x1006 (e8 03 00); ret (c3); pad; ret (c3)
let x16 = vec![0xe8, 3, 0, 0xc3, 0x90, 0x90, 0xc3];
let flow16 = raw_def_use(x16, Arch::X86_16, false);
let call16 = flow16.nodes.iter().find(|n| n.addr == Some(0x1000)).expect("16-bit call");
assert_eq!(call16.defines, vec!["rax".to_string(), "rcx".to_string(), "rdx".to_string()], "{call16:?}");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.