unluac 1.1.1

Multi-dialect Lua decompiler written in Rust.
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
105
106
107

use std::collections::VecDeque;

use super::*;

pub(super) fn compute_phi_candidates(
    cfg: &Cfg,
    graph_facts: &GraphFacts,
    defs: &[Def],
    live_in: &[BTreeSet<Reg>],
    block_out: &[FixedState],
    fixed_def_lookup: &[FixedDefLookup],
) -> Vec<PhiCandidate> {
    let mut def_blocks = BTreeMap::<Reg, BTreeSet<BlockRef>>::new();
    for def in defs {
        if cfg.reachable_blocks.contains(&def.block) {
            def_blocks.entry(def.reg).or_default().insert(def.block);
        }
    }

    let mut phi_candidates = Vec::new();

    for (reg, blocks) in def_blocks {
        let mut placed = BTreeSet::new();
        let mut worklist = blocks.iter().copied().collect::<VecDeque<_>>();

        while let Some(block) = worklist.pop_front() {
            for frontier_block in graph_facts.dominance_frontier_blocks(block) {
                if !live_in[frontier_block.index()].contains(&reg) || !placed.insert(frontier_block)
                {
                    continue;
                }

                if let Some(candidate) = build_phi_candidate(cfg, frontier_block, reg, block_out) {
                    phi_candidates.push(candidate);
                }

                if !block_defines_reg(cfg, frontier_block, reg, fixed_def_lookup) {
                    worklist.push_back(frontier_block);
                }
            }
        }
    }

    phi_candidates.sort_by_key(|candidate| (candidate.block, candidate.reg));
    for (index, candidate) in phi_candidates.iter_mut().enumerate() {
        candidate.id = PhiId(index);
    }
    phi_candidates
}

fn build_phi_candidate(
    cfg: &Cfg,
    block: BlockRef,
    reg: Reg,
    block_out: &[FixedState],
) -> Option<PhiCandidate> {
    let mut incoming = Vec::new();
    let mut distinct_defs = BTreeSet::new();
    let mut has_entry_incoming = false;

    for edge_ref in &cfg.preds[block.index()] {
        let pred = cfg.edges[edge_ref.index()].from;
        if !cfg.reachable_blocks.contains(&pred) {
            continue;
        }

        let defs = block_out
            .get(pred.index())
            .map(|defs_by_reg| defs_by_reg.get(reg))?
            .clone();
        if defs.is_empty() {
            has_entry_incoming = true;
        }

        distinct_defs.extend(defs.iter().copied());
        incoming.push(PhiIncoming {
            pred,
            defs: defs.iter().copied().collect(),
        });
    }

    let distinct_sources = distinct_defs.len() + usize::from(has_entry_incoming);
    if incoming.len() < 2 || distinct_sources < 2 {
        return None;
    }

    incoming.sort_by_key(|incoming| incoming.pred);
    Some(PhiCandidate {
        id: PhiId(0),
        block,
        reg,
        incoming,
    })
}

fn block_defines_reg(
    cfg: &Cfg,
    block: BlockRef,
    reg: Reg,
    fixed_def_lookup: &[FixedDefLookup],
) -> bool {
    let Some(mut instr_indices) = super::instr_indices(cfg, block) else {
        return false;
    };

    instr_indices.any(|instr_index| fixed_def_lookup[instr_index].defines(reg))
}