vicis 0.1.0

Manipulate LLVM-IR in Pure 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

use crate::codegen::function::{
    basic_block::{BasicBlock, BasicBlockId},
    instruction::{Instruction, InstructionData, InstructionId},
};
use id_arena::Arena;

pub struct Data<InstData: InstructionData> {
    // pub values: Arena<Value>,
    pub instructions: Arena<Instruction<InstData>>,
    pub basic_blocks: Arena<BasicBlock>,
}

impl<InstData: InstructionData> Data<InstData> {
    pub fn new() -> Self {
        Self {
            // values: Arena::new(),
            instructions: Arena::new(),
            basic_blocks: Arena::new(),
        }
    }

    pub fn create_block(&mut self) -> BasicBlockId {
        self.basic_blocks.alloc(BasicBlock::new())
    }

    pub fn create_inst(&mut self, mut inst: Instruction<InstData>) -> InstructionId<InstData> {
        let id = self.instructions.alloc_with_id(|id| {
            inst.id = Some(id);
            inst
        });
        id
    }

    pub fn block_ref(&self, id: BasicBlockId) -> &BasicBlock {
        &self.basic_blocks[id]
    }

    // TODO: Is this the right way?
    pub fn block_ref_mut(&mut self, id: BasicBlockId) -> &mut BasicBlock {
        &mut self.basic_blocks[id]
    }

    pub fn inst_ref(&self, id: InstructionId<InstData>) -> &Instruction<InstData> {
        &self.instructions[id]
    }

    pub fn inst_ref_mut(&mut self, id: InstructionId<InstData>) -> &mut Instruction<InstData> {
        &mut self.instructions[id]
    }
}