nilang 0.4.1

A scripting language interpreter for Advent of Code
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
111
112
113
114

use crate::codegen::backpatch::{BackPatchLabel, BackpatchContext};
use crate::codegen::func::Func;
use crate::codegen::ssa_elimination::ssa_elimination;
use crate::codegen::InterferenceGraph;
use crate::ir::{Block, Func as IRFunc, LabelID, Tac, VReg};
use crate::runtime::ByteCode;

pub fn handle_control_flow_instruction(
    instr: &Tac,
    current_block: &Block,
    ir_func: &IRFunc,
    graph: &InterferenceGraph,
    func: &mut Func,
    ctx: &mut BackpatchContext,
) -> bool {
    match instr {
        Tac::Label { label } => {
            ctx.insert_label_position(BackPatchLabel::Label(*label), func.len());
            true
        }
        Tac::Jnt { src, label } | Tac::Jit { src, label } => {
            handle_conditional_jump(
                instr,
                *src,
                *label,
                current_block,
                ir_func,
                graph,
                func,
                ctx,
            );
            true
        }
        Tac::Jump { label } => {
            handle_unconditional_jump(*label, current_block, ir_func, graph, func, ctx);
            true
        }
        _ => false,
    }
}

pub fn handle_block_fall_through(
    current_block: &Block,
    ir_func: &IRFunc,
    graph: &InterferenceGraph,
    func: &mut Func,
) {
    if let Some(id) = current_block.falls_through() {
        let next_block = ir_func.get_block(id);
        ssa_elimination(func, next_block, current_block, graph);
    }
}

fn handle_conditional_jump(
    instr: &Tac,
    src: VReg,
    label: LabelID,
    current_block: &Block,
    ir_func: &IRFunc,
    graph: &InterferenceGraph,
    func: &mut Func,
    ctx: &mut BackpatchContext,
) {
    let original_label = BackPatchLabel::Label(label);
    let bytecode_instr = match instr {
        Tac::Jnt { .. } => ByteCode::Jnt {
            src: graph.get_reg(&src),
            offset: 0,
        },
        Tac::Jit { .. } => ByteCode::Jit {
            src: graph.get_reg(&src),
            offset: 0,
        },
        _ => unreachable!(),
    };

    let jump_block_id = ir_func.get_block_from_label(label);
    let jump_block = ir_func.get_block(jump_block_id);
    let jump_label = if jump_block.get_phi_nodes().is_empty() {
        original_label
    } else {
        ctx.next_temp_label()
    };

    ctx.push_generic_jump_instr(bytecode_instr, func, jump_label);

    let next_block = ir_func.get_block(current_block.get_id() + 1);
    ssa_elimination(func, next_block, current_block, graph);
    let fall_through_label = ctx.next_temp_label();

    if !jump_block.get_phi_nodes().is_empty() {
        ctx.push_jump_instr(func, fall_through_label);
        ctx.insert_label_position(jump_label, func.len());
        ssa_elimination(func, jump_block, current_block, graph);
        ctx.push_jump_instr(func, original_label);
        ctx.insert_label_position(fall_through_label, func.len());
    }
}

fn handle_unconditional_jump(
    label: LabelID,
    current_block: &Block,
    ir_func: &IRFunc,
    graph: &InterferenceGraph,
    func: &mut Func,
    ctx: &mut BackpatchContext,
) {
    let next_block_id = ir_func.get_block_from_label(label);
    let next_block = ir_func.get_block(next_block_id);
    let original_label = BackPatchLabel::Label(label);

    ssa_elimination(func, next_block, current_block, graph);
    ctx.push_jump_instr(func, original_label);
}