642d5a256791
a64_exclusive_value_flow.rs
use craft_anything_disasm::{Image, Insn, Kind, Limits, Mode, NoControl, Program, dataflow, decode, pseudo};
use craft_anything_formats::Arch;
use craft_anything_testkit as tk;
fn instruction(word: u32) -> Insn {
decode(Mode::A64, &word.to_le_bytes(), 0x1000, true).unwrap()
}
fn registers(i: &Insn, reads: &[&str], writes: &[&str]) {
let mut actual_reads = i.reads.iter().map(String::as_str).collect::<Vec<_>>();
let mut actual_writes = i.writes.iter().map(String::as_str).collect::<Vec<_>>();
let mut expected_reads = reads.to_vec();
let mut expected_writes = writes.to_vec();
actual_reads.sort_unstable();
actual_writes.sort_unstable();
expected_reads.sort_unstable();
expected_writes.sort_unstable();
assert_eq!(actual_reads, expected_reads, "{} reads", i.text());
assert_eq!(actual_writes, expected_writes, "{} writes", i.text());
}
fn stores() -> Vec<u32> {
let mut words = Vec::new();
for size in 0..4 {
for release in [0, 0x8000] {
words.push(0x0802_7c83 | (size << 30) | release); // st[x/lx]r[b/h] w2, [w/x]3, [x4]
}
}
for size in [0, 0x4000_0000] {
for release in [0, 0x8000] {
words.push(0x8820_0861 | size | release); // st[l]xp w0, [w/x]1, [w/x]2, [x3]
}
}
words
}
#[test]
fn exclusive_stores_write_the_status_and_read_only_values_and_the_address() {
for word in stores() {
let i = instruction(word);
assert_eq!(i.kind, Kind::Store);
if i.ops.len() == 4 {
registers(&i, &["x1", "x2", "x3"], &["x0"]);
} else {
registers(&i, &["x3", "x4"], &["x2"]);
}
}
}
#[test]
fn a_discarded_status_does_not_turn_the_first_value_into_a_definition() {
registers(&instruction(0xc81f_7c83), &["x3", "x4"], &[]); // stxr wzr, x3, [x4]
registers(&instruction(0xc81f_ffe3), &["sp", "x3"], &[]); // stlxr wzr, x3, [sp]
registers(&instruction(0xc83f_0861), &["x1", "x2", "x3"], &[]); // stxp wzr, x1, x2, [x3]
}
#[test]
fn single_exclusive_loads_are_typed_memory_reads() {
for size in 0..4 {
for acquire in [0, 0x8000] {
let i = instruction(0x085f_7c83 | (size << 30) | acquire);
assert_eq!(i.kind, Kind::Load, "{}", i.text());
registers(&i, &["x4"], &["x3"]);
}
}
}
#[test]
fn exclusive_pair_loads_define_both_results() {
for word in [0x887f_0440, 0x887f_8440, 0xc87f_0440, 0xc87f_8440] {
let i = instruction(word);
assert_eq!(i.kind, Kind::LoadPair);
registers(&i, &["x2"], &["x0", "x1"]);
}
}
#[test]
fn exclusive_pair_loads_can_discard_either_result() {
for word in [0xc87f_045f, 0xc87f_845f] {
// l[d/a]xp xzr, x1, [x2]
registers(&instruction(word), &["x2"], &["x1"]);
}
for word in [0xc87f_7c40, 0xc87f_fc40] {
// l[d/a]xp x0, xzr, [x2]
registers(&instruction(word), &["x2"], &["x0"]);
}
}
fn with_program<T>(words: &[u32], run: impl FnOnce(&Image, &Program) -> T) -> T {
let bytes = words.iter().flat_map(|word| word.to_le_bytes()).collect::<Vec<_>>();
let image = Image::raw(bytes.into(), Arch::Aarch64, 0x1000);
let program = Program::analyze(&image, &Limits { scan_prologues: false, ..Limits::default() }, &NoControl).unwrap();
run(&image, &program)
}
#[test]
fn an_exclusive_store_status_reaches_the_retry_condition() {
// ldxr x3, [x4]; stxr w2, x3, [x4]; cbnz w2, loop; ret
with_program(&[0xc85f_7c83, 0xc802_7c83, 0x35ff_ffc2, 0xd65f_03c0], |image, program| {
let flow = dataflow::def_use(image, program, program.functions.get(&0x1000).unwrap(), 100, 100);
let store = flow.nodes.iter().find(|node| node.addr == Some(0x1004)).unwrap();
let condition = flow.nodes.iter().find(|node| node.addr == Some(0x1008)).unwrap();
assert_eq!(store.defines, ["x2"]);
assert!(flow.edges.iter().any(|edge| edge.from == store.id && edge.to == condition.id && edge.register == "x2"));
assert!(!flow.parameter_uses.iter().any(|(register, _)| register == "x2"));
let effect = flow.effects.iter().find(|effect| effect.addr == 0x1004).unwrap();
assert_eq!(effect.kind, "store");
assert!(!effect.inputs.iter().any(|register| register == "x2"));
});
}
#[test]
fn the_second_exclusive_load_result_reaches_its_use() {
// ldxp x0, x1, [x2]; mov x3, x1; ret
with_program(&[0xc87f_0440, 0xaa01_03e3, 0xd65f_03c0], |image, program| {
let flow = dataflow::def_use(image, program, program.functions.get(&0x1000).unwrap(), 100, 100);
let load = flow.nodes.iter().find(|node| node.addr == Some(0x1000)).unwrap();
let use_result = flow.nodes.iter().find(|node| node.addr == Some(0x1004)).unwrap();
assert!(load.defines.iter().any(|register| register == "x1"));
assert!(flow.edges.iter().any(|edge| edge.from == load.id && edge.to == use_result.id && edge.register == "x1"));
assert!(!flow.parameter_uses.iter().any(|(register, _)| register == "x1"));
});
}
fn lifted(word: u32) -> pseudo::Pseudo {
with_program(&[word, 0xd65f_03c0], |image, program| pseudo::lift(image, program, program.functions.get(&0x1000).unwrap(), &|_| None))
}
#[test]
fn exclusive_stores_keep_their_conditional_memory_operation_in_pseudo_c() {
for word in stores() {
let p = lifted(word);
assert_eq!(p.asm_fallbacks, 1, "{}: {}", instruction(word).text(), p.text);
assert!(p.text.contains(&format!("__asm(\"{}", instruction(word).mnemonic)), "{}", p.text);
}
}
#[test]
fn exclusive_loads_keep_their_monitor_operation_in_pseudo_c() {
let mut words = vec![0x887f_0440, 0x887f_8440, 0xc87f_0440, 0xc87f_8440];
for size in 0..4 {
for acquire in [0, 0x8000] {
words.push(0x085f_7c83 | (size << 30) | acquire);
}
}
for word in words {
let p = lifted(word);
assert_eq!(p.asm_fallbacks, 1, "{}: {}", instruction(word).text(), p.text);
assert!(p.text.contains(&format!("__asm(\"{}", instruction(word).mnemonic)), "{}", p.text);
}
}
#[test]
fn an_exclusive_load_from_a_known_import_slot_is_not_elided() {
let (mut bytes, layout) = tk::elf64(tk::ElfArch::Aarch64, false);
let pages = (layout.got_va >> 12).wrapping_sub(layout.code_va >> 12) & 0x1f_ffff;
let adrp = 0x9000_0001 | (((pages & 3) as u32) << 29) | (((pages >> 2) as u32) << 5);
let add = 0x9100_0021 | (((layout.got_va & 0xfff) as u32) << 10);
let code = [adrp, add, 0xc85f_7c20, 0xd65f_03c0].into_iter().flat_map(u32::to_le_bytes).collect::<Vec<_>>();
let start = tk::ELF_TEXT_OFF as usize;
bytes[start..start + tk::a64::CODE_SIZE].fill(0);
bytes[start..start + code.len()].copy_from_slice(&code);
let image = Image::parse(bytes.into()).unwrap();
let program = Program::analyze(&image, &Limits { scan_prologues: false, ..Limits::default() }, &NoControl).unwrap();
assert!(program.import_slots.contains_key(&layout.got_va));
let p = pseudo::lift(&image, &program, program.functions.get(&layout.code_va).unwrap(), &|_| None);
assert_eq!(p.asm_fallbacks, 1, "{}", p.text);
assert!(p.text.contains("__asm(\"ldxr x0"), "{}", p.text);
}
#[test]
fn ordinary_load_store_and_pair_operations_keep_their_existing_pseudo_c() {
for (word, reads, writes) in [
(0xf940_0083, vec!["x4"], vec!["x3"]), // ldr x3, [x4]
(0xf900_0083, vec!["x3", "x4"], vec![]), // str x3, [x4]
(0xa940_0440, vec!["x2"], vec!["x0", "x1"]), // ldp x0, x1, [x2]
(0xa900_0440, vec!["x0", "x1", "x2"], vec![]), // stp x0, x1, [x2]
] {
registers(&instruction(word), &reads, &writes);
let p = lifted(word);
assert_eq!(p.asm_fallbacks, 0, "{}", p.text);
assert!(!p.text.contains("__asm"), "{}", p.text);
}
}
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.