neo-decompiler 0.6.2

Minimal tooling for inspecting Neo N3 NEF bytecode
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use super::{make_instr, BlockId, CfgBuilder, OpCode, Operand, Terminator};

#[test]
fn unconditional_jump_creates_two_blocks() {
    let instructions = vec![
        make_instr(0, OpCode::Jmp, Some(Operand::Jump(3))), // jumps to offset 3
        make_instr(2, OpCode::Push0, None),                 // skipped
        make_instr(3, OpCode::Ret, None),                   // target
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    assert!(cfg.block_count() >= 2);
}

#[test]
fn conditional_branch_creates_multiple_blocks() {
    let instructions = vec![
        make_instr(0, OpCode::Push1, None),
        make_instr(1, OpCode::Jmpifnot, Some(Operand::Jump(4))), // if false, jump to offset 5
        make_instr(3, OpCode::Push0, None),                      // then branch
        make_instr(4, OpCode::Ret, None),
        make_instr(5, OpCode::Push1, None), // else branch
        make_instr(6, OpCode::Ret, None),
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    assert!(cfg.block_count() >= 2);

    let entry = cfg.entry_block().unwrap();
    assert!(
        matches!(entry.terminator, Terminator::Branch { .. })
            || matches!(entry.terminator, Terminator::Fallthrough { .. })
    );
}

#[test]
fn multiple_exit_blocks() {
    let instructions = vec![
        make_instr(0, OpCode::Push1, None),
        make_instr(1, OpCode::Jmpifnot, Some(Operand::Jump(3))), // jump to offset 4
        make_instr(3, OpCode::Ret, None),                        // then: return
        make_instr(4, OpCode::Throw, None),                      // else: throw
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    assert!(cfg.exit_blocks().len() >= 2);
}

#[test]
fn successors_and_predecessors() {
    let instructions = vec![
        make_instr(0, OpCode::Push1, None),
        make_instr(1, OpCode::Jmpifnot, Some(Operand::Jump(3))), // jump to offset 4
        make_instr(3, OpCode::Ret, None),
        make_instr(4, OpCode::Ret, None),
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    let entry_succs = cfg.successors(BlockId::ENTRY);
    assert!(!entry_succs.is_empty());

    for &succ in entry_succs {
        let preds = cfg.predecessors(succ);
        assert!(preds.contains(&BlockId::ENTRY));
    }
}

#[test]
fn edge_count_matches_terminators() {
    let instructions = vec![
        make_instr(0, OpCode::Push1, None),
        make_instr(1, OpCode::Jmpifnot, Some(Operand::Jump(3))), // conditional branch
        make_instr(3, OpCode::Ret, None),
        make_instr(4, OpCode::Ret, None),
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    let entry_edges: Vec<_> = cfg
        .edges()
        .iter()
        .filter(|e| e.from == BlockId::ENTRY)
        .collect();
    assert_eq!(entry_edges.len(), 2);
}

#[test]
fn long_jump_creates_blocks() {
    let instructions = vec![
        make_instr(0, OpCode::Jmp_L, Some(Operand::Jump32(10))), // jumps to offset 10
        make_instr(5, OpCode::Push0, None),                      // skipped
        make_instr(6, OpCode::Ret, None),
        make_instr(10, OpCode::Push1, None), // target
        make_instr(11, OpCode::Ret, None),
    ];

    let cfg = CfgBuilder::new(&instructions).build();

    assert!(cfg.block_count() >= 2);
}