inc 0.1.3

Incremental approach to compiler construction
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

//! A symbol is a blob of UTF-8 encoded bytes prefixed with the length and an
//! unique identifier.
//!
//! Specification: https://www.scheme.com/tspl4/objects.html#./objects:h11
//!
//! See strings module for more docs since these modules are very similar.
//!
//! Example memory layout:
//!
//! A literal "hello" gets statically allocated at offset 4000 along with an ID
//! 7 and the length 5.
//!
//! ```txt
//!  -----------------
//! | Address | Value |
//!  -----------------
//! | 4000    | 7     |
//! | 4000    | 5     |
//! | 4000    | hello |
//! |         |       |
//! | 8000    | 4005  |
//!  -----------------
//! ```

use crate::{
    compiler::state::State,
    immediate,
    x86::{self, Ins, Register::RAX, ASM},
};

/// Evaluate a symbols object
pub fn eval(s: &State, data: &str) -> ASM {
    let index = s
        .symbols
        .get(data)
        .unwrap_or_else(|| panic!("Symbol `{}` not found in symbol table", data));

    x86::lea(RAX, &label(*index), immediate::SYM).into()
}

/// Inline static symbols in source directly into the binary
pub fn inline(s: &State) -> ASM {
    let mut asm = ASM(vec![]);

    for (symbol, index) in &s.symbols {
        asm += Ins::from("");
        asm += Ins::from(".p2align 3");
        asm += x86::label(&label(*index));
        asm += Ins(format!(".quad  {}", index));
        asm += Ins(format!(".quad  {}", symbol.len()));
        asm += Ins(format!(".asciz \"{}\"", symbol))
    }

    asm
}

/// Label for inlining symbol
fn label(index: usize) -> String {
    format!("inc_sym_{}", index)
}