schala/src/compilation.rs

212 lines
6.8 KiB
Rust
Raw Normal View History

2016-02-09 23:52:57 -08:00
extern crate llvm_sys;
use std::collections::HashMap;
use self::llvm_sys::prelude::*;
2017-01-03 02:45:36 -08:00
use parser::{AST, Statement, Function, Expression};
2016-02-10 03:25:37 -08:00
2016-12-26 23:29:24 -08:00
use llvm_wrap as LLVMWrap;
2016-12-25 12:05:24 -08:00
pub fn compilation_sequence(ast: AST, sourcefile: &str) {
use std::process::Command;
let ll_filename = "out.ll";
let obj_filename = "out.o";
2016-12-29 02:01:48 -08:00
let q: Vec<&str> = sourcefile.split('.').collect();
let bin_filename = match &q[..] {
&[name, "schala"] => name,
_ => panic!("Bad filename {}", sourcefile),
};
compile_ast(ast, ll_filename);
Command::new("llc")
.arg("-filetype=obj")
.arg(ll_filename)
.output()
.expect("Failed to run llc");
Command::new("gcc")
.arg(format!("-o{}", bin_filename))
.arg(obj_filename)
.output()
.expect("failed to run gcc");
2016-12-26 12:05:29 -08:00
for filename in [obj_filename].iter() {
Command::new("rm")
2016-12-26 12:05:29 -08:00
.arg(filename)
.output()
.expect(&format!("failed to run rm {}", filename));
}
}
type VariableMap = HashMap<String, LLVMValueRef>;
struct CompilationData {
context: LLVMContextRef,
module: LLVMModuleRef,
builder: LLVMBuilderRef,
variables: VariableMap,
2017-01-10 18:07:16 -08:00
func: Option<LLVMValueRef>,
}
fn compile_ast(ast: AST, filename: &str) {
2016-03-04 14:32:22 -08:00
println!("Compiling!");
let names: VariableMap = HashMap::new();
2016-12-22 18:40:01 -08:00
let context = LLVMWrap::create_context();
let module = LLVMWrap::module_create_with_name("example module");
2016-12-21 17:50:13 -08:00
let builder = LLVMWrap::CreateBuilderInContext(context);
2016-03-04 14:32:22 -08:00
let mut data = CompilationData {
context: context,
module: module,
builder: builder,
variables: names,
2017-01-10 18:07:16 -08:00
func: None,
};
2016-12-25 12:05:24 -08:00
let int_type = LLVMWrap::Int64TypeInContext(data.context);
let function_type = LLVMWrap::FunctionType(int_type, &Vec::new(), false);
let function = LLVMWrap::AddFunction(data.module, "main", function_type);
2016-12-25 11:19:17 -08:00
2017-01-10 18:07:16 -08:00
data.func = Some(function);
let bb = LLVMWrap::AppendBasicBlockInContext(data.context, function, "entry");
LLVMWrap::PositionBuilderAtEnd(builder, bb);
let value = ast.codegen(&mut data);
2016-12-25 19:33:47 -08:00
LLVMWrap::BuildRet(builder, value);
2017-01-10 18:07:16 -08:00
println!("Printing {} to file", filename);
LLVMWrap::PrintModuleToFile(module, filename);
// Clean up. Values created in the context mostly get cleaned up there.
LLVMWrap::DisposeBuilder(builder);
LLVMWrap::DisposeModule(module);
LLVMWrap::ContextDispose(context);
2016-03-04 14:32:22 -08:00
}
trait CodeGen {
2016-12-29 02:01:48 -08:00
fn codegen(&self, &mut CompilationData) -> LLVMValueRef;
2016-02-10 03:25:37 -08:00
}
2016-12-25 19:33:47 -08:00
impl CodeGen for AST {
fn codegen(&self, data: &mut CompilationData) -> LLVMValueRef {
let int_type = LLVMWrap::Int64TypeInContext(data.context);
let mut ret = LLVMWrap::ConstInt(int_type, 0, false);
for statement in self {
ret = statement.codegen(data);
}
ret
2016-12-25 19:33:47 -08:00
}
}
2017-01-03 02:45:36 -08:00
impl CodeGen for Statement {
fn codegen(&self, data: &mut CompilationData) -> LLVMValueRef {
2017-01-03 02:45:36 -08:00
use self::Statement::*;
2016-02-11 10:49:45 -08:00
match self {
&ExprNode(ref expr) => expr.codegen(data),
&FuncDefNode(ref func) => func.codegen(data),
2016-02-11 10:49:45 -08:00
}
}
}
2016-12-25 19:33:47 -08:00
impl CodeGen for Function {
fn codegen(&self, data: &mut CompilationData) -> LLVMValueRef {
2016-12-25 19:33:47 -08:00
let ref body = self.body;
2016-12-27 17:33:24 -08:00
let int_type = LLVMWrap::Int64TypeInContext(data.context);
let mut ret = LLVMWrap::ConstInt(int_type, 0, false);
for expr in body {
ret = expr.codegen(data);
}
ret
2016-12-25 19:33:47 -08:00
}
}
impl CodeGen for Expression {
fn codegen(&self, data: &mut CompilationData) -> LLVMValueRef {
use self::Expression::*;
2016-12-25 19:33:47 -08:00
let int_type = LLVMWrap::Int64TypeInContext(data.context);
2017-01-10 18:07:16 -08:00
let zero = LLVMWrap::ConstInt(int_type, 0, false);
2016-12-25 19:33:47 -08:00
2017-01-10 03:33:02 -08:00
match *self {
Variable(ref name) => *data.variables.get(&**name).unwrap(),
BinExp(ref op, ref left, ref right) if **op == "=" => {
2016-12-27 17:33:24 -08:00
if let Variable(ref name) = **left {
let new_value = right.codegen(data);
data.variables.insert((**name).clone(), new_value);
2016-12-27 17:33:24 -08:00
new_value
} else {
panic!("Bad variable assignment")
}
2016-12-29 02:01:48 -08:00
}
2017-01-10 03:33:02 -08:00
BinExp(ref op, ref left, ref right) => {
let lhs = left.codegen(data);
let rhs = right.codegen(data);
let generator = match op.as_ref().as_ref() {
2016-12-26 12:36:28 -08:00
"+" => LLVMWrap::BuildAdd,
"-" => LLVMWrap::BuildSub,
"*" => LLVMWrap::BuildMul,
"/" => LLVMWrap::BuildUDiv,
"%" => LLVMWrap::BuildSRem,
_ => panic!("Bad operator {}", op),
};
generator(data.builder, lhs, rhs, "temp")
2016-12-29 02:01:48 -08:00
}
2017-01-10 03:33:02 -08:00
Number(ref n) => {
2016-12-25 19:33:47 -08:00
let native_val = *n as u64;
let int_value: LLVMValueRef = LLVMWrap::ConstInt(int_type, native_val, false);
int_value
2016-12-29 02:01:48 -08:00
}
Conditional(ref test, ref then_expr, ref else_expr) => {
2017-01-10 03:33:02 -08:00
let condition_value = test.codegen(data);
let is_nonzero =
LLVMWrap::BuildICmp(data.builder,
llvm_sys::LLVMIntPredicate::LLVMIntNE,
condition_value,
zero,
"is_nonzero");
2017-01-10 03:33:02 -08:00
2017-01-10 18:07:16 -08:00
let func: LLVMValueRef = data.func.expect("lol no function here");
let then_block =
LLVMWrap::AppendBasicBlockInContext(data.context, func, "entry");
let else_block =
LLVMWrap::AppendBasicBlockInContext(data.context, func, "entry");
let merge_block =
LLVMWrap::AppendBasicBlockInContext(data.context, func, "entry");
LLVMWrap::BuildCondBr(data.builder, is_nonzero, then_block, else_block);
LLVMWrap::PositionBuilderAtEnd(data.builder, then_block);
let then_return = then_expr.codegen(data);
LLVMWrap::BuildBr(data.builder, merge_block);
LLVMWrap::PositionBuilderAtEnd(data.builder, else_block);
2017-01-10 18:07:16 -08:00
let else_return = match *else_expr {
Some(ref e) => e.codegen(data),
None => zero,
2017-01-10 10:32:56 -08:00
};
LLVMWrap::BuildBr(data.builder, merge_block);
LLVMWrap::PositionBuilderAtEnd(data.builder, merge_block);
zero
2017-01-10 03:33:02 -08:00
}
2017-01-10 18:07:16 -08:00
Block(ref exprs) => {
let mut ret = zero;
for e in exprs.iter() {
ret = e.codegen(data);
}
ret
}
ref e => {
println!("Unimplemented {:?}", e);
unimplemented!()
}
2016-02-12 23:14:09 -08:00
}
}
}