forked from M-Labs/nac3
core/model: introduce codegen/model
This commit is contained in:
parent
c1369ea5bd
commit
c772fdb83a
|
@ -41,6 +41,7 @@ pub mod extern_fns;
|
|||
mod generator;
|
||||
pub mod irrt;
|
||||
pub mod llvm_intrinsics;
|
||||
pub mod model;
|
||||
pub mod numpy;
|
||||
pub mod stmt;
|
||||
|
||||
|
|
|
@ -0,0 +1,161 @@
|
|||
use std::fmt;
|
||||
|
||||
use inkwell::{context::Context, types::*, values::*};
|
||||
|
||||
use super::*;
|
||||
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct TypeContext<'ctx> {
|
||||
pub size_type: IntType<'ctx>,
|
||||
}
|
||||
|
||||
pub trait HasTypeContext {
|
||||
fn type_context<'ctx>(&self, ctx: &'ctx Context) -> TypeContext<'ctx>;
|
||||
}
|
||||
|
||||
impl<T: CodeGenerator + ?Sized> HasTypeContext for T {
|
||||
fn type_context<'ctx>(&self, ctx: &'ctx Context) -> TypeContext<'ctx> {
|
||||
TypeContext { size_type: self.get_size_type(ctx) }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ModelError(pub String);
|
||||
|
||||
impl ModelError {
|
||||
pub(super) fn under_context(mut self, context: &str) -> Self {
|
||||
self.0.push_str(" ... in ");
|
||||
self.0.push_str(context);
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
/// A [`Model`] is a singleton object that uniquely identifies a [`BasicType`]
|
||||
/// solely from a [`CodeGenerator`] and a [`Context`].
|
||||
pub trait Model: CheckType + fmt::Debug + Clone + Copy + Default {
|
||||
type Value<'ctx>: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>>;
|
||||
type Type<'ctx>: BasicType<'ctx>;
|
||||
|
||||
/// Return the [`BasicType`] of this model.
|
||||
fn get_type<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Self::Type<'ctx>;
|
||||
|
||||
/// Check if a [`BasicType`] is the same type of this model.
|
||||
fn check_type<'ctx, T: BasicType<'ctx>>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
ty: T,
|
||||
) -> Result<(), ModelError> {
|
||||
let ty = ty.as_basic_type_enum();
|
||||
self.check_type_impl(tyctx, ctx, ty.as_basic_type_enum())
|
||||
}
|
||||
|
||||
/// Create an instance from a value with [`Instance::model`] being this model.
|
||||
///
|
||||
/// Caller must make sure the type of `value` and the type of this `model` are equivalent.
|
||||
fn believe_value<'ctx>(&self, value: Self::Value<'ctx>) -> Instance<'ctx, Self> {
|
||||
Instance { model: *self, value }
|
||||
}
|
||||
|
||||
/// Check if a [`BasicValue`]'s type is equivalent to the type of this model.
|
||||
/// Wrap it into an [`Instance`] if it is.
|
||||
fn check_value<'ctx, V: BasicValue<'ctx>>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
value: V,
|
||||
) -> Result<Instance<'ctx, Self>, ModelError> {
|
||||
let value = value.as_basic_value_enum();
|
||||
self.check_type(tyctx, ctx, value.get_type())
|
||||
.map_err(|err| err.under_context("the value {value:?}"))?;
|
||||
|
||||
let Ok(value) = Self::Value::try_from(value) else {
|
||||
unreachable!("check_type() has bad implementation")
|
||||
};
|
||||
Ok(self.believe_value(value))
|
||||
}
|
||||
|
||||
// Allocate a value on the stack and return its pointer.
|
||||
fn alloca<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Self> {
|
||||
let pmodel = PtrModel(*self);
|
||||
let p = ctx.builder.build_alloca(self.get_type(tyctx, ctx.ctx), name).unwrap();
|
||||
pmodel.believe_value(p)
|
||||
}
|
||||
|
||||
// Allocate an array on the stack and return its pointer.
|
||||
fn array_alloca<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
len: IntValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Self> {
|
||||
let pmodel = PtrModel(*self);
|
||||
let p = ctx.builder.build_array_alloca(self.get_type(tyctx, ctx.ctx), len, name).unwrap();
|
||||
pmodel.believe_value(p)
|
||||
}
|
||||
|
||||
fn var_alloca<'ctx, G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
generator: &mut G,
|
||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||
name: Option<&str>,
|
||||
) -> Result<Ptr<'ctx, Self>, String> {
|
||||
let tyctx = generator.type_context(ctx.ctx);
|
||||
|
||||
let pmodel = PtrModel(*self);
|
||||
let p = generator.gen_var_alloc(
|
||||
ctx,
|
||||
self.get_type(tyctx, ctx.ctx).as_basic_type_enum(),
|
||||
name,
|
||||
)?;
|
||||
Ok(pmodel.believe_value(p))
|
||||
}
|
||||
|
||||
fn array_var_alloca<'ctx, G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
generator: &mut G,
|
||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||
len: IntValue<'ctx>,
|
||||
name: Option<&'ctx str>,
|
||||
) -> Result<Ptr<'ctx, Self>, String> {
|
||||
let tyctx = generator.type_context(ctx.ctx);
|
||||
|
||||
// TODO: Remove ArraySliceValue
|
||||
let pmodel = PtrModel(*self);
|
||||
let p = generator.gen_array_var_alloc(
|
||||
ctx,
|
||||
self.get_type(tyctx, ctx.ctx).as_basic_type_enum(),
|
||||
len,
|
||||
name,
|
||||
)?;
|
||||
Ok(pmodel.believe_value(PointerValue::from(p)))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct Instance<'ctx, M: Model> {
|
||||
/// The model of this instance.
|
||||
pub model: M,
|
||||
/// The value of this instance.
|
||||
///
|
||||
/// Caller must make sure the type of `value` and the type of this `model` are equivalent,
|
||||
/// down to having the same [`IntType::get_bit_width`] in case of [`IntType`] for example.
|
||||
pub value: M::Value<'ctx>,
|
||||
}
|
||||
|
||||
// NOTE: Must be Rust object-safe - This must be typeable for a Rust trait object.
|
||||
pub trait CheckType {
|
||||
fn check_type_impl<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
ty: BasicTypeEnum<'ctx>,
|
||||
) -> Result<(), ModelError>;
|
||||
}
|
|
@ -0,0 +1,228 @@
|
|||
use std::fmt;
|
||||
|
||||
use inkwell::{
|
||||
context::Context,
|
||||
types::{BasicTypeEnum, IntType},
|
||||
values::IntValue,
|
||||
IntPredicate,
|
||||
};
|
||||
|
||||
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||
|
||||
use super::*;
|
||||
|
||||
pub trait IntKind: fmt::Debug + Clone + Copy + Default {
|
||||
fn get_int_type<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> IntType<'ctx>;
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct Bool;
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct Byte;
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct Int32;
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct Int64;
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct SizeT;
|
||||
|
||||
impl IntKind for Bool {
|
||||
fn get_int_type<'ctx>(&self, _tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> IntType<'ctx> {
|
||||
ctx.bool_type()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntKind for Byte {
|
||||
fn get_int_type<'ctx>(&self, _tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> IntType<'ctx> {
|
||||
ctx.i8_type()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntKind for Int32 {
|
||||
fn get_int_type<'ctx>(&self, _tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> IntType<'ctx> {
|
||||
ctx.i32_type()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntKind for Int64 {
|
||||
fn get_int_type<'ctx>(&self, _tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> IntType<'ctx> {
|
||||
ctx.i64_type()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntKind for SizeT {
|
||||
fn get_int_type<'ctx>(&self, tyctx: TypeContext<'ctx>, _ctx: &'ctx Context) -> IntType<'ctx> {
|
||||
tyctx.size_type
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct IntModel<N: IntKind>(pub N);
|
||||
pub type Int<'ctx, N> = Instance<'ctx, IntModel<N>>;
|
||||
|
||||
impl<N: IntKind> CheckType for IntModel<N> {
|
||||
fn check_type_impl<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
ty: BasicTypeEnum<'ctx>,
|
||||
) -> Result<(), ModelError> {
|
||||
let Ok(ty) = IntType::try_from(ty) else {
|
||||
return Err(ModelError(format!("Expecting IntType, but got {ty:?}")));
|
||||
};
|
||||
|
||||
let exp_ty = self.0.get_int_type(tyctx, ctx);
|
||||
if ty.get_bit_width() != exp_ty.get_bit_width() {
|
||||
return Err(ModelError(format!(
|
||||
"Expecting IntType to have {} bit(s), but got {} bit(s)",
|
||||
exp_ty.get_bit_width(),
|
||||
ty.get_bit_width()
|
||||
)));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<N: IntKind> Model for IntModel<N> {
|
||||
type Value<'ctx> = IntValue<'ctx>;
|
||||
type Type<'ctx> = IntType<'ctx>;
|
||||
|
||||
#[must_use]
|
||||
fn get_type<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Self::Type<'ctx> {
|
||||
self.0.get_int_type(tyctx, ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl<N: IntKind> IntModel<N> {
|
||||
pub fn constant<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
value: u64,
|
||||
) -> Int<'ctx, N> {
|
||||
let value = self.get_type(tyctx, ctx).const_int(value, false);
|
||||
self.believe_value(value)
|
||||
}
|
||||
|
||||
pub fn const_0<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Int<'ctx, N> {
|
||||
self.constant(tyctx, ctx, 0)
|
||||
}
|
||||
|
||||
pub fn const_1<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Int<'ctx, N> {
|
||||
self.constant(tyctx, ctx, 1)
|
||||
}
|
||||
|
||||
pub fn s_extend_or_bit_cast<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
value: IntValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, N> {
|
||||
let value = ctx
|
||||
.builder
|
||||
.build_int_s_extend_or_bit_cast(value, self.get_type(tyctx, ctx.ctx), name)
|
||||
.unwrap();
|
||||
self.believe_value(value)
|
||||
}
|
||||
|
||||
pub fn truncate<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
value: IntValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, N> {
|
||||
let value =
|
||||
ctx.builder.build_int_truncate(value, self.get_type(tyctx, ctx.ctx), name).unwrap();
|
||||
self.believe_value(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl IntModel<Bool> {
|
||||
#[must_use]
|
||||
pub fn const_false<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
) -> Int<'ctx, Bool> {
|
||||
self.constant(tyctx, ctx, 0)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn const_true<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
) -> Int<'ctx, Bool> {
|
||||
self.constant(tyctx, ctx, 1)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx, N: IntKind> Int<'ctx, N> {
|
||||
pub fn s_extend_or_bit_cast<NewN: IntKind, G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
to_int_kind: NewN,
|
||||
name: &str,
|
||||
) -> Int<'ctx, NewN> {
|
||||
IntModel(to_int_kind).s_extend_or_bit_cast(tyctx, ctx, self.value, name)
|
||||
}
|
||||
|
||||
pub fn truncate<NewN: IntKind, G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
to_int_kind: NewN,
|
||||
name: &str,
|
||||
) -> Int<'ctx, NewN> {
|
||||
IntModel(to_int_kind).truncate(tyctx, ctx, self.value, name)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn add<G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
other: Int<'ctx, N>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, N> {
|
||||
let value = ctx.builder.build_int_add(self.value, other.value, name).unwrap();
|
||||
self.model.believe_value(value)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn sub<G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
other: Int<'ctx, N>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, N> {
|
||||
let value = ctx.builder.build_int_sub(self.value, other.value, name).unwrap();
|
||||
self.model.believe_value(value)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn mul<G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
other: Int<'ctx, N>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, N> {
|
||||
let value = ctx.builder.build_int_mul(self.value, other.value, name).unwrap();
|
||||
self.model.believe_value(value)
|
||||
}
|
||||
|
||||
pub fn compare<G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
op: IntPredicate,
|
||||
other: Int<'ctx, N>,
|
||||
name: &str,
|
||||
) -> Int<'ctx, Bool> {
|
||||
let bool_model = IntModel(Bool);
|
||||
let value = ctx.builder.build_int_compare(op, self.value, other.value, name).unwrap();
|
||||
bool_model.believe_value(value)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,11 @@
|
|||
mod core;
|
||||
mod int;
|
||||
mod ptr;
|
||||
mod slice;
|
||||
mod structure;
|
||||
|
||||
pub use core::*;
|
||||
pub use int::*;
|
||||
pub use ptr::*;
|
||||
pub use slice::*;
|
||||
pub use structure::*;
|
|
@ -0,0 +1,141 @@
|
|||
use inkwell::{
|
||||
context::Context,
|
||||
types::{BasicType, BasicTypeEnum, PointerType},
|
||||
values::{IntValue, PointerValue},
|
||||
AddressSpace,
|
||||
};
|
||||
|
||||
use crate::codegen::CodeGenContext;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct PtrModel<Element>(pub Element);
|
||||
pub type Ptr<'ctx, Element> = Instance<'ctx, PtrModel<Element>>;
|
||||
|
||||
impl<Element: CheckType> CheckType for PtrModel<Element> {
|
||||
fn check_type_impl<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
ty: BasicTypeEnum<'ctx>,
|
||||
) -> Result<(), super::ModelError> {
|
||||
let Ok(ty) = PointerType::try_from(ty) else {
|
||||
return Err(ModelError(format!("Expecting PointerType, but got {ty:?}")));
|
||||
};
|
||||
|
||||
let elem_ty = ty.get_element_type();
|
||||
let Ok(elem_ty) = BasicTypeEnum::try_from(elem_ty) else {
|
||||
return Err(ModelError(format!(
|
||||
"Expecting pointer element type to be a BasicTypeEnum, but got {elem_ty:?}"
|
||||
)));
|
||||
};
|
||||
|
||||
// TODO: inkwell `get_element_type()` will be deprecated.
|
||||
// Remove the check for `get_element_type()` when the time comes.
|
||||
self.0
|
||||
.check_type_impl(tyctx, ctx, elem_ty)
|
||||
.map_err(|err| err.under_context("a PointerType"))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<Element: Model> Model for PtrModel<Element> {
|
||||
type Value<'ctx> = PointerValue<'ctx>;
|
||||
type Type<'ctx> = PointerType<'ctx>;
|
||||
|
||||
fn get_type<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Self::Type<'ctx> {
|
||||
self.0.get_type(tyctx, ctx).ptr_type(AddressSpace::default())
|
||||
}
|
||||
}
|
||||
|
||||
impl<Element: Model> PtrModel<Element> {
|
||||
/// Return a ***constant*** nullptr.
|
||||
pub fn nullptr<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
) -> Ptr<'ctx, Element> {
|
||||
let ptr = self.get_type(tyctx, ctx).const_null();
|
||||
self.believe_value(ptr)
|
||||
}
|
||||
|
||||
pub fn transmute<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
ptr: PointerValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Element> {
|
||||
let ptr = ctx.builder.build_pointer_cast(ptr, self.get_type(tyctx, ctx.ctx), name).unwrap();
|
||||
self.believe_value(ptr)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx, Element: Model> Ptr<'ctx, Element> {
|
||||
/// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`].
|
||||
pub fn offset(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
offset: IntValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Element> {
|
||||
let new_ptr =
|
||||
unsafe { ctx.builder.build_in_bounds_gep(self.value, &[offset], name).unwrap() };
|
||||
self.model.check_value(tyctx, ctx.ctx, new_ptr).unwrap()
|
||||
}
|
||||
|
||||
// Load the `i`-th element (0-based) on the array with [`inkwell::builder::Builder::build_in_bounds_gep`].
|
||||
pub fn ix(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
i: IntValue<'ctx>,
|
||||
name: &str,
|
||||
) -> Instance<'ctx, Element> {
|
||||
self.offset(tyctx, ctx, i, name).load(tyctx, ctx, name)
|
||||
}
|
||||
|
||||
/// Load the value with [`inkwell::builder::Builder::build_load`].
|
||||
pub fn load(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
name: &str,
|
||||
) -> Instance<'ctx, Element> {
|
||||
let value = ctx.builder.build_load(self.value, name).unwrap();
|
||||
self.model.0.check_value(tyctx, ctx.ctx, value).unwrap() // If unwrap() panics, there is a logic error.
|
||||
}
|
||||
|
||||
/// Store a value with [`inkwell::builder::Builder::build_store`].
|
||||
pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: Instance<'ctx, Element>) {
|
||||
ctx.builder.build_store(self.value, value.value).unwrap();
|
||||
}
|
||||
|
||||
/// Return a casted pointer of element type `NewElement` with [`inkwell::builder::Builder::build_pointer_cast`].
|
||||
pub fn transmute<NewElement: Model>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
new_model: NewElement,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, NewElement> {
|
||||
PtrModel(new_model).transmute(tyctx, ctx, self.value, name)
|
||||
}
|
||||
|
||||
/// Check if the pointer is null with [`inkwell::builder::Builder::build_is_null`].
|
||||
pub fn is_null(&self, ctx: &CodeGenContext<'ctx, '_>, name: &str) -> Int<'ctx, Bool> {
|
||||
let bool_model = IntModel(Bool);
|
||||
let value = ctx.builder.build_is_null(self.value, name).unwrap();
|
||||
bool_model.believe_value(value)
|
||||
}
|
||||
|
||||
/// Check if the pointer is not null with [`inkwell::builder::Builder::build_is_not_null`].
|
||||
pub fn is_not_null(&self, ctx: &CodeGenContext<'ctx, '_>, name: &str) -> Int<'ctx, Bool> {
|
||||
let bool_model = IntModel(Bool);
|
||||
let value = ctx.builder.build_is_not_null(self.value, name).unwrap();
|
||||
bool_model.believe_value(value)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,72 @@
|
|||
use crate::codegen::{CodeGenContext, CodeGenerator};
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A slice - literally just a pointer and a length value.
|
||||
///
|
||||
/// NOTE: This is NOT a [`Model`].
|
||||
pub struct ArraySlice<'ctx, Len: IntKind, Item: Model> {
|
||||
pub base: Ptr<'ctx, Item>,
|
||||
pub len: Int<'ctx, Len>,
|
||||
}
|
||||
|
||||
impl<'ctx, Len: IntKind, Item: Model> ArraySlice<'ctx, Len, Item> {
|
||||
/// Get the `idx`-nth element of this [`ArraySlice`], but doesn't do an assertion to see if `idx` is out of bounds or not.
|
||||
///
|
||||
/// Also see [`ArraySlice::ix`].
|
||||
pub fn ix_unchecked(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
idx: Int<'ctx, Len>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Item> {
|
||||
let element_ptr = unsafe {
|
||||
ctx.builder.build_in_bounds_gep(self.base.value, &[idx.value], name).unwrap()
|
||||
};
|
||||
self.base.model.check_value(tyctx, ctx.ctx, element_ptr).unwrap()
|
||||
}
|
||||
|
||||
/// Call [`ArraySlice::ix_unchecked`], but checks if `idx` is in bounds, otherwise a runtime `IndexError` will be thrown.
|
||||
pub fn ix<G: CodeGenerator + ?Sized>(
|
||||
&self,
|
||||
generator: &mut G,
|
||||
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||
idx: Int<'ctx, Len>,
|
||||
name: &str,
|
||||
) -> Ptr<'ctx, Item> {
|
||||
let tyctx = generator.type_context(ctx.ctx);
|
||||
let len_model = IntModel(Len::default());
|
||||
|
||||
// Assert `0 <= idx < length` and throw an Exception if `idx` is out of bounds
|
||||
let lower_bounded = ctx
|
||||
.builder
|
||||
.build_int_compare(
|
||||
inkwell::IntPredicate::SLE,
|
||||
len_model.constant(tyctx, ctx.ctx, 0).value,
|
||||
idx.value,
|
||||
"lower_bounded",
|
||||
)
|
||||
.unwrap();
|
||||
let upper_bounded = ctx
|
||||
.builder
|
||||
.build_int_compare(
|
||||
inkwell::IntPredicate::SLT,
|
||||
idx.value,
|
||||
self.len.value,
|
||||
"upper_bounded",
|
||||
)
|
||||
.unwrap();
|
||||
let bounded = ctx.builder.build_and(lower_bounded, upper_bounded, "bounded").unwrap();
|
||||
ctx.make_assert(
|
||||
generator,
|
||||
bounded,
|
||||
"0:IndexError",
|
||||
"nac3core LLVM codegen attempting to access out of bounds array index {0}. Must satisfy 0 <= index < {2}",
|
||||
[ Some(idx.value), Some(self.len.value), None],
|
||||
ctx.current_loc
|
||||
);
|
||||
|
||||
self.ix_unchecked(tyctx, ctx, idx, name)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,174 @@
|
|||
use std::fmt;
|
||||
|
||||
use inkwell::{
|
||||
context::Context,
|
||||
types::{BasicType, BasicTypeEnum, StructType},
|
||||
values::StructValue,
|
||||
};
|
||||
use itertools::izip;
|
||||
|
||||
use crate::codegen::CodeGenContext;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct GepField<M: Model> {
|
||||
pub gep_index: u64,
|
||||
pub name: &'static str,
|
||||
pub model: M,
|
||||
}
|
||||
|
||||
pub trait FieldVisitor {
|
||||
type Field<M: Model + 'static>;
|
||||
|
||||
fn add<M: Model + 'static>(&mut self, name: &'static str) -> Self::Field<M>;
|
||||
}
|
||||
|
||||
pub struct GepFieldVisitor {
|
||||
gep_index_counter: u64,
|
||||
}
|
||||
|
||||
impl FieldVisitor for GepFieldVisitor {
|
||||
type Field<M: Model + 'static> = GepField<M>;
|
||||
|
||||
fn add<M: Model + 'static>(&mut self, name: &'static str) -> Self::Field<M> {
|
||||
let gep_index = self.gep_index_counter;
|
||||
self.gep_index_counter += 1;
|
||||
Self::Field { gep_index, name, model: M::default() }
|
||||
}
|
||||
}
|
||||
|
||||
struct TypeFieldVisitor<'ctx> {
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
field_types: Vec<BasicTypeEnum<'ctx>>,
|
||||
}
|
||||
|
||||
impl<'ctx> FieldVisitor for TypeFieldVisitor<'ctx> {
|
||||
type Field<M: Model + 'static> = ();
|
||||
|
||||
fn add<M: Model + 'static>(&mut self, _name: &'static str) -> Self::Field<M> {
|
||||
self.field_types.push(M::default().get_type(self.tyctx, self.ctx).as_basic_type_enum());
|
||||
}
|
||||
}
|
||||
|
||||
struct CheckTypeEntry {
|
||||
check_type: Box<dyn CheckType + 'static>,
|
||||
name: &'static str,
|
||||
}
|
||||
|
||||
struct CheckTypeFieldVisitor<'ctx> {
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
check_types: Vec<CheckTypeEntry>,
|
||||
}
|
||||
|
||||
impl<'ctx> FieldVisitor for CheckTypeFieldVisitor<'ctx> {
|
||||
type Field<M: Model + 'static> = ();
|
||||
|
||||
fn add<M: Model + 'static>(&mut self, name: &'static str) -> Self::Field<M> {
|
||||
self.check_types.push(CheckTypeEntry { check_type: Box::<M>::default(), name });
|
||||
}
|
||||
}
|
||||
|
||||
pub trait StructKind: fmt::Debug + Clone + Copy + Default {
|
||||
type Fields<F: FieldVisitor>;
|
||||
|
||||
fn visit_fields<F: FieldVisitor>(&self, visitor: &mut F) -> Self::Fields<F>;
|
||||
|
||||
fn fields(&self) -> Self::Fields<GepFieldVisitor> {
|
||||
self.visit_fields(&mut GepFieldVisitor { gep_index_counter: 0 })
|
||||
}
|
||||
|
||||
fn get_struct_type<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
) -> StructType<'ctx> {
|
||||
let mut visitor = TypeFieldVisitor { tyctx, ctx, field_types: Vec::new() };
|
||||
self.visit_fields(&mut visitor);
|
||||
|
||||
ctx.struct_type(&visitor.field_types, false)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct StructModel<S: StructKind>(pub S);
|
||||
pub type Struct<'ctx, S> = Instance<'ctx, StructModel<S>>;
|
||||
|
||||
impl<S: StructKind> CheckType for StructModel<S> {
|
||||
fn check_type_impl<'ctx>(
|
||||
&self,
|
||||
tyctx: TypeContext<'ctx>,
|
||||
ctx: &'ctx Context,
|
||||
ty: BasicTypeEnum<'ctx>,
|
||||
) -> Result<(), ModelError> {
|
||||
let ty = ty.as_basic_type_enum();
|
||||
let Ok(ty) = StructType::try_from(ty) else {
|
||||
return Err(ModelError(format!("Expecting StructType, but got {ty:?}")));
|
||||
};
|
||||
|
||||
let field_types = ty.get_field_types();
|
||||
|
||||
let check_types = {
|
||||
let mut builder = CheckTypeFieldVisitor { tyctx, ctx, check_types: Vec::new() };
|
||||
self.0.visit_fields(&mut builder);
|
||||
builder.check_types
|
||||
};
|
||||
|
||||
if check_types.len() != field_types.len() {
|
||||
return Err(ModelError(format!(
|
||||
"Expecting StructType to have {} field(s), but got {} field(s)",
|
||||
check_types.len(),
|
||||
field_types.len()
|
||||
)));
|
||||
}
|
||||
|
||||
for (field_i, (entry, field_type)) in izip!(check_types, field_types).enumerate() {
|
||||
let field_at = field_i + 1;
|
||||
|
||||
entry.check_type.check_type_impl(tyctx, ctx, field_type).map_err(|err| {
|
||||
err.under_context(format!("struct field #{field_at} '{}'", entry.name).as_str())
|
||||
})?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: StructKind> Model for StructModel<S> {
|
||||
type Value<'ctx> = StructValue<'ctx>;
|
||||
type Type<'ctx> = StructType<'ctx>;
|
||||
|
||||
fn get_type<'ctx>(&self, tyctx: TypeContext<'ctx>, ctx: &'ctx Context) -> Self::Type<'ctx> {
|
||||
self.0.get_struct_type(tyctx, ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'ctx, S: StructKind> Ptr<'ctx, StructModel<S>> {
|
||||
pub fn gep<M, GetField>(
|
||||
&self,
|
||||
ctx: &CodeGenContext<'ctx, '_>,
|
||||
get_field: GetField,
|
||||
) -> Ptr<'ctx, M>
|
||||
where
|
||||
M: Model,
|
||||
GetField: FnOnce(S::Fields<GepFieldVisitor>) -> GepField<M>,
|
||||
{
|
||||
let field = get_field(self.model.0 .0.fields());
|
||||
let llvm_i32 = ctx.ctx.i32_type(); // must be i32, if its i64 then rust segfaults
|
||||
|
||||
let ptr = unsafe {
|
||||
ctx.builder
|
||||
.build_in_bounds_gep(
|
||||
self.value,
|
||||
&[llvm_i32.const_zero(), llvm_i32.const_int(field.gep_index, false)],
|
||||
field.name,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
let ptr_model = PtrModel(field.model);
|
||||
ptr_model.believe_value(ptr)
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue