luau-bytecode 0.732.0

Luau bytecode model, builder, serializer, and dumper
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
108
109
110

use super::{
    BytecodeBlock, BytecodeBlockId, BytecodeEdge, BytecodeEdgeKind, BytecodeImmediate,
    BytecodeImmediateId, BytecodeInstruction, BytecodeInstructionId, BytecodeInstructionStream,
    BytecodeOperand, BytecodePhi, BytecodePhiId, BytecodeProjection, BytecodeProjectionId,
    InstructionPc,
};
use crate::error::BytecodeReadError;
use crate::model::Register;
use crate::model::{Instruction, InstructionAux};
use crate::opcodes::Opcode;
use std::collections::{HashMap, HashSet};

fn constant_index(value: u32) -> i32 {
    i32::try_from(value).expect("constant index must fit int32")
}

pub(super) struct FunctionGraphBuilder {
    pub(super) immediates: Vec<BytecodeImmediate>,
    pub(super) phis: Vec<BytecodePhi>,
    pub(super) projections: Vec<BytecodeProjection>,
    pub(super) registers: HashMap<BytecodeOperand, Register>,
    pub(super) block_phis: Vec<Vec<BytecodePhiId>>,
    producers: Producers,
    current_block: BytecodeBlockId,
}

impl Default for FunctionGraphBuilder {
    fn default() -> Self {
        Self {
            immediates: Vec::new(),
            phis: Vec::new(),
            projections: Vec::new(),
            registers: HashMap::new(),
            block_phis: Vec::new(),
            producers: Producers::default(),
            current_block: BytecodeBlockId::new(0),
        }
    }
}

#[derive(Clone)]
struct BlockProducers {
    own: HashMap<Register, BytecodeOperand>,
    cached: HashMap<Register, BytecodeOperand>,
    multi_return: Option<BytecodeOperand>,
    multi_return_start: Register,
    invalid_after: i32,
    sealed: bool,
    unsealed_predecessors: usize,
    incomplete_phis: HashMap<Register, BytecodeOperand>,
}

impl Default for BlockProducers {
    fn default() -> Self {
        Self {
            own: HashMap::new(),
            cached: HashMap::new(),
            multi_return: None,
            multi_return_start: 0xff,
            invalid_after: 255,
            sealed: false,
            unsealed_predecessors: 0,
            incomplete_phis: HashMap::new(),
        }
    }
}

#[derive(Default)]
struct Producers {
    blocks: Vec<BlockProducers>,
}

impl FunctionGraphBuilder {
    pub(super) fn new(
        blocks: &[BytecodeBlock],
        parameter_count: u8,
        entry: BytecodeBlockId,
    ) -> Self {
        let mut builder = Self {
            producers: Producers {
                blocks: vec![BlockProducers::default(); blocks.len()],
            },
            block_phis: vec![Vec::new(); blocks.len()],
            ..Self::default()
        };

        for (index, block) in blocks.iter().enumerate() {
            builder.producers.blocks[index].unsealed_predecessors = block.predecessors().len();
            builder.producers.blocks[index].sealed = block.predecessors().is_empty();
        }

        for register in 0..parameter_count {
            builder.add_producer_to(entry, register, BytecodeOperand::VmRegister(register));
        }

        builder
    }

    pub(super) fn begin_block(
        &mut self,
        block: BytecodeBlockId,
        _entry: BytecodeBlockId,
        _predecessors: &[BytecodeEdge],
    ) {
        self.current_block = block;
    }
}

mod operands;
mod producers;