forked from M-Labs/nac3
1
0
Fork 0
nac3/nac3core/src/codegen/generator.rs

259 lines
7.4 KiB
Rust
Raw Normal View History

use crate::{
codegen::{expr::*, stmt::*, bool_to_i1, bool_to_i8, CodeGenContext},
2021-11-20 19:50:25 +08:00
symbol_resolver::ValueEnum,
toplevel::{DefinitionId, TopLevelDef},
typecheck::typedef::{FunSignature, Type},
};
use inkwell::{
context::Context,
types::{BasicTypeEnum, IntType},
values::{BasicValueEnum, IntValue, PointerValue},
};
2021-11-03 17:11:00 +08:00
use nac3parser::ast::{Expr, Stmt, StrRef};
pub trait CodeGenerator {
/// Return the module name for the code generator.
fn get_name(&self) -> &str;
fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx>;
/// Generate function call and returns the function return value.
/// - obj: Optional object for method call.
/// - fun: Function signature and definition ID.
/// - params: Function parameters. Note that this does not include the object even if the
/// function is a class method.
2023-12-06 11:49:02 +08:00
fn gen_call<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
2021-11-20 19:50:25 +08:00
obj: Option<(Type, ValueEnum<'ctx>)>,
fun: (&FunSignature, DefinitionId),
2021-11-20 19:50:25 +08:00
params: Vec<(Option<StrRef>, ValueEnum<'ctx>)>,
) -> Result<Option<BasicValueEnum<'ctx>>, String>
where
Self: Sized,
{
gen_call(self, ctx, obj, fun, params)
}
/// Generate object constructor and returns the constructed object.
/// - signature: Function signature of the constructor.
/// - def: Class definition for the constructor class.
/// - params: Function parameters.
2023-12-06 11:49:02 +08:00
fn gen_constructor<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
signature: &FunSignature,
def: &TopLevelDef,
2021-11-20 19:50:25 +08:00
params: Vec<(Option<StrRef>, ValueEnum<'ctx>)>,
) -> Result<BasicValueEnum<'ctx>, String>
where
Self: Sized,
{
gen_constructor(self, ctx, signature, def, params)
}
/// Generate a function instance.
/// - obj: Optional object for method call.
/// - fun: Function signature, definition ID and the substitution key.
/// - params: Function parameters. Note that this does not include the object even if the
/// function is a class method.
/// Note that this function should check if the function is generated in another thread (due to
/// possible race condition), see the default implementation for an example.
2023-12-06 11:49:02 +08:00
fn gen_func_instance<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
2021-11-20 19:50:25 +08:00
obj: Option<(Type, ValueEnum<'ctx>)>,
fun: (&FunSignature, &mut TopLevelDef, String),
2021-11-20 19:50:25 +08:00
id: usize,
) -> Result<String, String> {
2023-12-08 17:43:32 +08:00
gen_func_instance(ctx, &obj, fun, id)
}
/// Generate the code for an expression.
2023-12-06 11:49:02 +08:00
fn gen_expr<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
expr: &Expr<Option<Type>>,
) -> Result<Option<ValueEnum<'ctx>>, String>
where
Self: Sized,
{
gen_expr(self, ctx, expr)
}
/// Allocate memory for a variable and return a pointer pointing to it.
/// The default implementation places the allocations at the start of the function.
2023-12-06 11:49:02 +08:00
fn gen_var_alloc<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
ty: BasicTypeEnum<'ctx>,
name: Option<&str>,
) -> Result<PointerValue<'ctx>, String> {
gen_var(ctx, ty, name)
}
/// Allocate memory for a variable and return a pointer pointing to it.
/// The default implementation places the allocations at the start of the function.
fn gen_array_var_alloc<'ctx, 'a>(
&mut self,
ctx: &mut CodeGenContext<'ctx, 'a>,
ty: BasicTypeEnum<'ctx>,
size: IntValue<'ctx>,
name: Option<&str>,
) -> Result<PointerValue<'ctx>, String> {
gen_array_var(ctx, ty, size, name)
}
/// Return a pointer pointing to the target of the expression.
2023-12-06 11:49:02 +08:00
fn gen_store_target<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
pattern: &Expr<Option<Type>>,
name: Option<&str>,
) -> Result<Option<PointerValue<'ctx>>, String>
where
Self: Sized,
{
gen_store_target(self, ctx, pattern, name)
}
/// Generate code for an assignment expression.
2023-12-06 11:49:02 +08:00
fn gen_assign<'ctx>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'ctx, '_>,
target: &Expr<Option<Type>>,
2021-11-20 19:50:25 +08:00
value: ValueEnum<'ctx>,
) -> Result<(), String>
where
Self: Sized,
{
gen_assign(self, ctx, target, value)
}
/// Generate code for a while expression.
/// Return true if the while loop must early return
2023-12-06 11:49:02 +08:00
fn gen_while(
2022-02-21 18:27:46 +08:00
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
2022-02-21 18:27:46 +08:00
stmt: &Stmt<Option<Type>>,
) -> Result<(), String>
where
Self: Sized,
{
gen_while(self, ctx, stmt)
}
2021-10-23 23:53:36 +08:00
/// Generate code for a while expression.
/// Return true if the while loop must early return
2023-12-06 11:49:02 +08:00
fn gen_for(
2022-02-21 18:27:46 +08:00
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
2022-02-21 18:27:46 +08:00
stmt: &Stmt<Option<Type>>,
) -> Result<(), String>
where
Self: Sized,
{
gen_for(self, ctx, stmt)
2021-10-23 23:53:36 +08:00
}
/// Generate code for an if expression.
/// Return true if the statement must early return
2023-12-06 11:49:02 +08:00
fn gen_if(
2022-02-21 18:27:46 +08:00
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
2022-02-21 18:27:46 +08:00
stmt: &Stmt<Option<Type>>,
) -> Result<(), String>
where
Self: Sized,
{
gen_if(self, ctx, stmt)
}
2023-12-06 11:49:02 +08:00
fn gen_with(
2022-02-21 18:27:46 +08:00
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
2022-02-21 18:27:46 +08:00
stmt: &Stmt<Option<Type>>,
) -> Result<(), String>
where
Self: Sized,
{
gen_with(self, ctx, stmt)
}
/// Generate code for a statement
///
/// Return true if the statement must early return
2023-12-06 11:49:02 +08:00
fn gen_stmt(
2022-02-21 18:27:46 +08:00
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
2022-02-21 18:27:46 +08:00
stmt: &Stmt<Option<Type>>,
) -> Result<(), String>
where
Self: Sized,
{
gen_stmt(self, ctx, stmt)
}
/// Generates code for a block statement.
2023-12-06 11:49:02 +08:00
fn gen_block<'a, I: Iterator<Item = &'a Stmt<Option<Type>>>>(
&mut self,
2023-12-06 11:49:02 +08:00
ctx: &mut CodeGenContext<'_, '_>,
stmts: I,
) -> Result<(), String>
where
Self: Sized,
{
gen_block(self, ctx, stmts)
}
2023-12-08 17:43:32 +08:00
/// See [`bool_to_i1`].
2023-12-06 11:49:02 +08:00
fn bool_to_i1<'ctx>(
&self,
2023-12-06 11:49:02 +08:00
ctx: &CodeGenContext<'ctx, '_>,
bool_value: IntValue<'ctx>
) -> IntValue<'ctx> {
bool_to_i1(&ctx.builder, bool_value)
}
2023-12-08 17:43:32 +08:00
/// See [`bool_to_i8`].
2023-12-06 11:49:02 +08:00
fn bool_to_i8<'ctx>(
&self,
2023-12-06 11:49:02 +08:00
ctx: &CodeGenContext<'ctx, '_>,
bool_value: IntValue<'ctx>
) -> IntValue<'ctx> {
2023-12-06 11:49:02 +08:00
bool_to_i8(&ctx.builder, ctx.ctx, bool_value)
}
}
pub struct DefaultCodeGenerator {
name: String,
size_t: u32,
}
impl DefaultCodeGenerator {
2023-12-08 17:43:32 +08:00
#[must_use]
pub fn new(name: String, size_t: u32) -> DefaultCodeGenerator {
2023-12-06 11:49:02 +08:00
assert!(matches!(size_t, 32 | 64));
DefaultCodeGenerator { name, size_t }
}
}
impl CodeGenerator for DefaultCodeGenerator {
2023-10-18 13:40:37 +08:00
2023-12-08 17:43:32 +08:00
/// Returns the name for this [`CodeGenerator`].
fn get_name(&self) -> &str {
&self.name
}
2023-10-18 13:40:37 +08:00
/// Returns an LLVM integer type representing `size_t`.
fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx> {
// it should be unsigned, but we don't really need unsigned and this could save us from
// having to do a bit cast...
if self.size_t == 32 {
ctx.i32_type()
} else {
ctx.i64_type()
}
}
}