Initial commit
This commit is contained in:
Generated
+176
@@ -0,0 +1,176 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "2.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
|
||||
|
||||
[[package]]
|
||||
name = "boxcar"
|
||||
version = "0.2.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "36f64beae40a84da1b4b26ff2761a5b895c12adc41dc25aaee1c4f2bbfe97a6e"
|
||||
|
||||
[[package]]
|
||||
name = "bumpalo"
|
||||
version = "3.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
|
||||
|
||||
[[package]]
|
||||
name = "byteorder"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "derive_more"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
|
||||
dependencies = [
|
||||
"derive_more-impl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "derive_more-impl"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"unicode-xid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fxhash"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
|
||||
dependencies = [
|
||||
"byteorder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "leaf"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"boxcar",
|
||||
"bumpalo",
|
||||
"derive_more",
|
||||
"fxhash",
|
||||
"half",
|
||||
"scc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.103"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.42"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "saa"
|
||||
version = "5.3.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4dfac11c0cd0606aaf7eb9ef66f82c119438a96dc487715abb8b57fdf08ad4fe"
|
||||
|
||||
[[package]]
|
||||
name = "scc"
|
||||
version = "3.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3904515dbe9c10a126a54faa1d44fd40b893224247a1198d8c5dab6ef028bbdc"
|
||||
dependencies = [
|
||||
"saa",
|
||||
"sdd",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sdd"
|
||||
version = "4.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd556f4cb1d30590889c126f4951eb87f8a70d736ed5a2f62cc89d290721a1c2"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.109"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2f17c7e013e88258aa9543dcbe81aca68a667a9ac37cd69c9fbc07858bfe0e2f"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.22"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-xid"
|
||||
version = "0.2.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
@@ -0,0 +1,13 @@
|
||||
[package]
|
||||
name = "leaf_assembly"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
bitflags = "2.10.0"
|
||||
boxcar = "0.2.14"
|
||||
derive_more = { version = "2.0.1", features = ["deref", "debug", "display"] }
|
||||
half = "2.7.1"
|
||||
scc = "3.3.7"
|
||||
|
||||
leaf_allocators = { path = "../allocators" }
|
||||
@@ -0,0 +1,175 @@
|
||||
use crate::{
|
||||
functions::Function,
|
||||
types::{
|
||||
Type,
|
||||
derivations::{FuncT, TypeDerivations},
|
||||
intrinsics::*,
|
||||
},
|
||||
values::{Const, Int},
|
||||
};
|
||||
use leaf_allocators::SyncAllocator;
|
||||
use scc::HashMap;
|
||||
use std::{hash::Hash, sync::OnceLock};
|
||||
|
||||
pub type Ctx<'l> = &'l Context<'l>;
|
||||
|
||||
pub struct Context<'l> {
|
||||
pub(crate) alloc: &'l dyn SyncAllocator,
|
||||
pub(crate) derivations: TypeDerivations<'l>,
|
||||
|
||||
constants: HashMap<&'l Const<'l>, &'l Const<'l>>,
|
||||
intrinsics: OnceLock<Box<intrinsic_types::IntrinsicTypesArray<'l>>>,
|
||||
}
|
||||
|
||||
impl Eq for Context<'_> {}
|
||||
|
||||
impl PartialEq for Context<'_> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
std::ptr::eq(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for Context<'_> {
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
(self as *const Self).hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Context<'l> {
|
||||
pub fn new(alloc: &'l dyn SyncAllocator) -> &'l Context<'l> {
|
||||
let ctx = alloc.alloc(Self {
|
||||
alloc,
|
||||
constants: HashMap::new(),
|
||||
derivations: TypeDerivations::new(alloc),
|
||||
intrinsics: OnceLock::new(),
|
||||
});
|
||||
ctx.intrinsics
|
||||
.set(Box::new(intrinsic_types::make_intrinsic_types(ctx)))
|
||||
.unwrap();
|
||||
ctx
|
||||
}
|
||||
|
||||
pub fn create_function(&'l self, ty: &'l FuncT<'l>) -> &'l Function<'l> {
|
||||
self.alloc.alloc(Function {
|
||||
ty,
|
||||
body: OnceLock::new(),
|
||||
ctx: self,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub trait CreateConst<'l, T> {
|
||||
fn create_const(&'l self, value: T) -> &'l Const<'l>;
|
||||
}
|
||||
|
||||
macro_rules! create_const {
|
||||
($(impl $ty:ty : $expr:expr,)*) => {
|
||||
$(
|
||||
impl<'l> CreateConst<'l, $ty> for Context<'l> {
|
||||
fn create_const(&'l self, value: $ty) -> &'l Const<'l> {
|
||||
let constant = ($expr)(self, value);
|
||||
if let Some(existing) = self.constants.get_sync(&constant) {
|
||||
return *existing;
|
||||
}
|
||||
let constant = self.alloc.alloc(constant);
|
||||
*self.constants.entry_sync(constant).or_insert(constant)
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
create_const! {
|
||||
impl i8: |ctx, val| Const::Int(Int::I8(val), ctx),
|
||||
impl i16: |ctx, val| Const::Int(Int::I16(val), ctx),
|
||||
impl i32: |ctx, val| Const::Int(Int::I32(val), ctx),
|
||||
impl i64: |ctx, val| Const::Int(Int::I64(val), ctx),
|
||||
impl i128: |ctx, val| Const::Int(Int::I128(val), ctx),
|
||||
|
||||
impl u8: |ctx, val| Const::Int(Int::U8(val), ctx),
|
||||
impl u16: |ctx, val| Const::Int(Int::U16(val), ctx),
|
||||
impl u32: |ctx, val| Const::Int(Int::U32(val), ctx),
|
||||
impl u64: |ctx, val| Const::Int(Int::U64(val), ctx),
|
||||
impl u128: |ctx, val| Const::Int(Int::U128(val), ctx),
|
||||
|
||||
impl (): |ctx, _| Const::Void(ctx),
|
||||
impl char: |ctx, val| Const::Char(val, ctx),
|
||||
impl bool: |ctx, val| Const::Bool(val, ctx),
|
||||
impl &'l str: |ctx, val| Const::Str(val, ctx),
|
||||
}
|
||||
|
||||
mod intrinsic_types {
|
||||
use super::*;
|
||||
use std::mem::MaybeUninit;
|
||||
|
||||
macro_rules! create_intrinsics {
|
||||
($(($id:ident, $fn_id:ident, $init:expr),)*) => {
|
||||
pub enum IntrinsicTypeKind {
|
||||
$($id,)*
|
||||
COUNT,
|
||||
}
|
||||
|
||||
pub type IntrinsicTypesArray<'l> = [Type<'l>; IntrinsicTypeKind::COUNT as usize];
|
||||
|
||||
pub fn make_intrinsic_types<'l>(ctx: Ctx<'l>) -> IntrinsicTypesArray<'l> {
|
||||
unsafe {
|
||||
const C: usize = IntrinsicTypeKind::COUNT as usize;
|
||||
let mut intrinsics = [MaybeUninit::<Type>::uninit(); C];
|
||||
|
||||
$(
|
||||
intrinsics[IntrinsicTypeKind::$id as usize]
|
||||
.write((&*ctx.alloc.alloc($init(ctx))).into());
|
||||
)*
|
||||
|
||||
std::mem::transmute(intrinsics)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Context<'l> {
|
||||
$(
|
||||
#[inline]
|
||||
pub fn $fn_id(&'l self) -> Type<'l> {
|
||||
self.get_intrinsic(IntrinsicTypeKind::$id)
|
||||
}
|
||||
)*
|
||||
|
||||
#[inline]
|
||||
fn get_intrinsic(&'l self, intrinsic: IntrinsicTypeKind) -> Type<'l> {
|
||||
unsafe {
|
||||
self.intrinsics
|
||||
.get()
|
||||
.unwrap_unchecked()
|
||||
.get_unchecked(intrinsic as usize)
|
||||
.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
create_intrinsics! {
|
||||
(Void, void_t, |ctx| VoidT { ctx }),
|
||||
(Char, char_t, |ctx| CharT { ctx }),
|
||||
(Bool, bool_t, |ctx| BoolT { ctx }),
|
||||
(Type, type_t, |ctx| TypeT { ctx, }),
|
||||
(ConstStr, const_str_t, |ctx| ConstStrT { ctx, }),
|
||||
|
||||
(I8, i8_t, |ctx| IntT { ctx, signed: true, precision: 8 }),
|
||||
(I16, i16_t, |ctx| IntT { ctx, signed: true, precision: 16 }),
|
||||
(I32, i32_t, |ctx| IntT { ctx, signed: true, precision: 32 }),
|
||||
(I64, i64_t, |ctx| IntT { ctx, signed: true, precision: 64 }),
|
||||
(I128, i128_t, |ctx| IntT { ctx, signed: true, precision: 128 }),
|
||||
(ISize, isize_t, |ctx| IntT { ctx, signed: true, precision: u32::MAX }),
|
||||
|
||||
(U8, u8_t, |ctx| IntT { ctx, signed: false, precision: 8 }),
|
||||
(U16, u16_t, |ctx| IntT { ctx, signed: false, precision: 16 }),
|
||||
(U32, u32_t, |ctx| IntT { ctx, signed: false, precision: 32 }),
|
||||
(U64, u64_t, |ctx| IntT { ctx, signed: false, precision: 64 }),
|
||||
(U128, u128_t, |ctx| IntT { ctx, signed: false, precision: 128 }),
|
||||
(USize, usize_t, |ctx| IntT { ctx, signed: false, precision: u32::MAX }),
|
||||
|
||||
(F16, f16_t, |ctx| FloatT { ctx, precision: 16 }),
|
||||
(F32, f32_t, |ctx| FloatT { ctx, precision: 32 }),
|
||||
(F64, f64_t, |ctx| FloatT { ctx, precision: 64 }),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,316 @@
|
||||
use crate::{
|
||||
context::Ctx,
|
||||
functions::{Function, FunctionBody},
|
||||
types::{Type, derivations::*},
|
||||
values::{Value, ValueFlags},
|
||||
};
|
||||
use derive_more::Debug;
|
||||
use std::{
|
||||
borrow::Cow,
|
||||
hash::Hash,
|
||||
ops::Deref,
|
||||
sync::{
|
||||
OnceLock,
|
||||
atomic::{AtomicU32, Ordering},
|
||||
},
|
||||
u32,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
#[debug("%{}: {variant:?}", self.id())]
|
||||
pub struct Instruction<'l> {
|
||||
id: AtomicU32,
|
||||
pub parent_block: &'l Block<'l>,
|
||||
pub variant: InstructionVariant<'l>,
|
||||
}
|
||||
|
||||
impl Eq for Instruction<'_> {}
|
||||
|
||||
impl PartialEq for Instruction<'_> {
|
||||
#[inline]
|
||||
fn eq(&self, _: &Self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for Instruction<'_> {
|
||||
#[inline]
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
(self as *const Self).hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Deref for Instruction<'l> {
|
||||
type Target = InstructionVariant<'l>;
|
||||
|
||||
#[inline]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.variant
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Into<Value<'l>> for &'l Instruction<'l> {
|
||||
#[inline]
|
||||
fn into(self) -> Value<'l> {
|
||||
Value::Instruction(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Instruction<'l> {
|
||||
#[inline]
|
||||
pub fn ctx(&self) -> Ctx<'l> {
|
||||
self.parent_block.func.ctx
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn id(&self) -> u32 {
|
||||
self.id.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
pub fn value_flags(&self) -> ValueFlags {
|
||||
match self.variant {
|
||||
_ => todo!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn value_ty(&self) -> Type<'l> {
|
||||
match self.variant {
|
||||
_ => todo!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Hash)]
|
||||
pub enum InstructionVariant<'l> {
|
||||
#[debug("stackalloc {_0}")]
|
||||
StackAlloc(Type<'l>),
|
||||
|
||||
#[debug("gcalloc {_0}")]
|
||||
GCAlloc(Type<'l>),
|
||||
|
||||
#[debug("load {_0}")]
|
||||
Load(Value<'l>),
|
||||
|
||||
#[debug("store {_0}, {_1}")]
|
||||
Store(Value<'l>, Value<'l>),
|
||||
|
||||
#[debug("return{}", _0.map(|v| format!(" {v}")).unwrap_or_default())]
|
||||
Return(Option<Value<'l>>),
|
||||
}
|
||||
|
||||
impl InstructionVariant<'_> {
|
||||
pub fn is_block_termination(&self) -> bool {
|
||||
match self {
|
||||
Self::Return(_) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Block<'l> {
|
||||
pub id: u32,
|
||||
func: &'l Function<'l>,
|
||||
instructions: OnceLock<Vec<&'l Instruction<'l>>>,
|
||||
}
|
||||
|
||||
impl<'l> Block<'l> {
|
||||
#[inline]
|
||||
pub fn instructions(&self) -> &[&'l Instruction<'l>] {
|
||||
match self.instructions.get() {
|
||||
None => &[],
|
||||
Some(v) => v,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct BlockBuilder<'l> {
|
||||
block: &'l Block<'l>,
|
||||
instructions: Vec<&'l Instruction<'l>>,
|
||||
}
|
||||
|
||||
pub type BlockBuilderError<'l> = Cow<'l, str>;
|
||||
pub type BlockBuilderResult<'l, T> = Result<T, BlockBuilderError<'l>>;
|
||||
|
||||
impl<'l> BlockBuilder<'l> {
|
||||
pub fn stack_alloc(&mut self, ty: Type<'l>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
let inst = self.push_instruction(InstructionVariant::StackAlloc(ty))?;
|
||||
Ok(inst.into())
|
||||
}
|
||||
|
||||
pub fn store(
|
||||
&mut self,
|
||||
target: Value<'l>,
|
||||
value: Value<'l>,
|
||||
) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
let value_ty = value.ty();
|
||||
let target_ty = target.ty();
|
||||
match target_ty {
|
||||
Type::Ptr(PtrT {
|
||||
base,
|
||||
mutable: true,
|
||||
}) if *base == value_ty => {}
|
||||
|
||||
Type::Ref(RefT {
|
||||
base,
|
||||
mutable: true,
|
||||
}) if *base == value_ty => {}
|
||||
|
||||
_ => {
|
||||
return Err(format!(
|
||||
"Cannot store value of type `{value_ty}` into target of type `{target_ty}.`"
|
||||
)
|
||||
.into());
|
||||
}
|
||||
};
|
||||
let inst = self.push_instruction(InstructionVariant::Store(target, value))?;
|
||||
Ok(inst.into())
|
||||
}
|
||||
|
||||
pub fn load(&mut self, value: Value<'l>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
let value_ty = value.ty();
|
||||
match value_ty {
|
||||
Type::Ptr(PtrT { .. }) => {}
|
||||
Type::Ref(RefT { .. }) => {}
|
||||
_ => {
|
||||
return Err(format!("Cannot load value of type `{}`.`", value_ty).into());
|
||||
}
|
||||
}
|
||||
let inst = self.push_instruction(InstructionVariant::Load(value))?;
|
||||
Ok(inst.into())
|
||||
}
|
||||
|
||||
pub fn ret(&mut self, value: Option<Value<'l>>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
let ret_t = self.block.func.ty.ret_t;
|
||||
let value_ty = match value {
|
||||
Some(v) => v.ty(),
|
||||
None => self.block.func.ctx.void_t(),
|
||||
};
|
||||
if value_ty != ret_t {
|
||||
return Err(format!(
|
||||
"Cannot return value of type `{value_ty}`. Expected type `{ret_t}`."
|
||||
)
|
||||
.into());
|
||||
}
|
||||
let inst = self.push_instruction(InstructionVariant::Return(value))?;
|
||||
Ok(inst.into())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn has_termination(&self) -> bool {
|
||||
match self.instructions.as_slice() {
|
||||
[.., i] => i.is_block_termination(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build(self) -> BlockBuilderResult<'l, &'l Block<'l>> {
|
||||
if !self.has_termination() {
|
||||
return Err(format!("Block #{} has not termination.", self.block.id).into());
|
||||
}
|
||||
self.block.instructions.set(self.instructions).unwrap();
|
||||
Ok(self.block)
|
||||
}
|
||||
|
||||
fn push_instruction(
|
||||
&mut self,
|
||||
variant: InstructionVariant<'l>,
|
||||
) -> BlockBuilderResult<'l, &'l Instruction<'l>> {
|
||||
if self.has_termination() {
|
||||
return Err(format!("Block #{} has already terminated", self.block.id).into());
|
||||
}
|
||||
let instruction = &*self.block.func.ctx.alloc.alloc(Instruction {
|
||||
id: AtomicU32::new(u32::MAX),
|
||||
parent_block: self.block,
|
||||
variant,
|
||||
});
|
||||
self.instructions.push(instruction);
|
||||
Ok(instruction)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct FunctionBodyBuilder<'l> {
|
||||
current_block: usize,
|
||||
func: &'l Function<'l>,
|
||||
blocks: Vec<BlockBuilder<'l>>,
|
||||
}
|
||||
|
||||
impl<'l> FunctionBodyBuilder<'l> {
|
||||
pub fn new(func: &'l Function<'l>) -> Self {
|
||||
let mut builder = Self {
|
||||
func,
|
||||
blocks: vec![],
|
||||
current_block: 0,
|
||||
};
|
||||
builder.create_block();
|
||||
builder
|
||||
}
|
||||
|
||||
pub fn current_block(&self) -> &'l Block<'l> {
|
||||
self.blocks[self.current_block].block
|
||||
}
|
||||
|
||||
pub fn set_current_block(&mut self, block: &'l Block<'l>) -> Option<&'l Block<'l>> {
|
||||
match std::ptr::eq(block.func, self.func) {
|
||||
false => None,
|
||||
true => {
|
||||
let current = self.current_block();
|
||||
self.current_block = block.id as usize;
|
||||
Some(current)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_block(&mut self) -> &'l Block<'l> {
|
||||
let block = &*self.func.ctx.alloc.alloc(Block {
|
||||
id: 0,
|
||||
func: self.func,
|
||||
instructions: OnceLock::new(),
|
||||
});
|
||||
let builder = BlockBuilder {
|
||||
block,
|
||||
instructions: vec![],
|
||||
};
|
||||
self.blocks.push(builder);
|
||||
block
|
||||
}
|
||||
|
||||
pub fn build(self) -> Result<&'l FunctionBody<'l>, Cow<'l, str>> {
|
||||
let mut next_id = 0..;
|
||||
let mut blocks = Vec::with_capacity(self.blocks.len());
|
||||
for block in self.blocks {
|
||||
let block = block.build()?;
|
||||
for inst in block.instructions() {
|
||||
inst.id.store(next_id.next().unwrap(), Ordering::Relaxed);
|
||||
}
|
||||
blocks.push(block);
|
||||
}
|
||||
if self.func.body.set(FunctionBody { blocks }).is_err() {
|
||||
return Err("Function body already exists.".into());
|
||||
}
|
||||
Ok(self.func.body.get().unwrap())
|
||||
}
|
||||
|
||||
pub fn stack_alloc(&mut self, ty: Type<'l>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
self.current_builder().stack_alloc(ty)
|
||||
}
|
||||
|
||||
pub fn store(
|
||||
&mut self,
|
||||
target: Value<'l>,
|
||||
value: Value<'l>,
|
||||
) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
self.current_builder().store(target, value)
|
||||
}
|
||||
|
||||
pub fn load(&mut self, value: Value<'l>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
self.current_builder().load(value)
|
||||
}
|
||||
|
||||
pub fn ret(&mut self, value: Option<Value<'l>>) -> BlockBuilderResult<'l, Value<'l>> {
|
||||
self.current_builder().ret(value)
|
||||
}
|
||||
|
||||
fn current_builder(&mut self) -> &mut BlockBuilder<'l> {
|
||||
&mut self.blocks[self.current_block]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
use crate::{
|
||||
context::Ctx,
|
||||
functions::ir::{Block, FunctionBodyBuilder},
|
||||
types::derivations::FuncT,
|
||||
};
|
||||
use std::{fmt::Debug as FmtDebug, sync::OnceLock};
|
||||
|
||||
pub mod ir;
|
||||
|
||||
#[non_exhaustive]
|
||||
pub struct Function<'l> {
|
||||
pub ty: &'l FuncT<'l>,
|
||||
pub(crate) body: OnceLock<FunctionBody<'l>>,
|
||||
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Function<'l> {
|
||||
pub fn body(&self) -> Option<&FunctionBody<'l>> {
|
||||
self.body.get()
|
||||
}
|
||||
|
||||
pub fn create_body(&'l self) -> Option<FunctionBodyBuilder<'l>> {
|
||||
match self.body() {
|
||||
Some(_) => None,
|
||||
None => Some(FunctionBodyBuilder::new(self)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FmtDebug for Function<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
let body: &dyn FmtDebug = match self.body() {
|
||||
Some(b) => b,
|
||||
None => &None::<()>,
|
||||
};
|
||||
|
||||
f.debug_struct("Function")
|
||||
.field("ty", &format_args!("{}", self.ty))
|
||||
.field("body", body)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
pub struct FunctionBody<'l> {
|
||||
pub blocks: Vec<&'l Block<'l>>,
|
||||
}
|
||||
|
||||
impl<'l> FmtDebug for FunctionBody<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
struct BlockDbg<'l>(&'l Block<'l>);
|
||||
|
||||
impl FmtDebug for BlockDbg<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
use std::fmt::Write;
|
||||
let mut name = format!("#{}:", self.0.id);
|
||||
let mut dbg = f.debug_struct(&name);
|
||||
for inst in self.0.instructions() {
|
||||
name.clear();
|
||||
write!(name, "%{}", inst.id())?;
|
||||
dbg.field(&name, &format_args!("{:?}", inst.variant));
|
||||
}
|
||||
dbg.finish()
|
||||
}
|
||||
}
|
||||
|
||||
f.debug_set()
|
||||
.entries(self.blocks.iter().map(|b| BlockDbg(b)))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
pub mod context;
|
||||
pub mod functions;
|
||||
pub mod types;
|
||||
pub mod values;
|
||||
@@ -0,0 +1,15 @@
|
||||
use leaf_allocators::SyncArenaAllocator;
|
||||
use leaf_assembly::context::{Context, CreateConst};
|
||||
use leaf_assembly::types::derivations::MakeTypeDerivations;
|
||||
|
||||
fn main() {
|
||||
let allocator = SyncArenaAllocator::default();
|
||||
let context = Context::new(&allocator);
|
||||
let func = context.create_function(context.u32_t().make_fn([]));
|
||||
let mut builder = func.create_body().unwrap();
|
||||
builder
|
||||
.ret(Some(context.create_const(42u32).into()))
|
||||
.unwrap();
|
||||
builder.build().unwrap();
|
||||
println!("{func:#?}");
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
use crate::types::*;
|
||||
use derive_more::{Debug, Display};
|
||||
use leaf_allocators::SyncAllocator;
|
||||
use scc::HashMap;
|
||||
use std::{fmt::Display, hash::Hash, sync::Arc};
|
||||
|
||||
pub struct TypeDerivations<'l> {
|
||||
alloc: &'l dyn SyncAllocator,
|
||||
ptr_t: HashMap<(Type<'l>, bool), Type<'l>>,
|
||||
ref_t: HashMap<(Type<'l>, bool), Type<'l>>,
|
||||
fun_t: HashMap<(Type<'l>, Arc<[Type<'l>]>), Type<'l>>,
|
||||
}
|
||||
|
||||
impl<'l> TypeDerivations<'l> {
|
||||
pub fn new(alloc: &'l dyn SyncAllocator) -> Self {
|
||||
Self {
|
||||
alloc,
|
||||
ptr_t: HashMap::new(),
|
||||
ref_t: HashMap::new(),
|
||||
fun_t: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn make_ptr(&self, base: Type<'l>, mutable: bool) -> &'l PtrT<'l> {
|
||||
let Type::Ptr(ty) = *self
|
||||
.ptr_t
|
||||
.entry_sync((base, mutable))
|
||||
.or_insert_with(|| (&*self.alloc.alloc(PtrT { base, mutable })).into())
|
||||
else {
|
||||
unreachable!()
|
||||
};
|
||||
ty
|
||||
}
|
||||
|
||||
pub fn make_ref(&'l self, base: Type<'l>, mutable: bool) -> &'l RefT<'l> {
|
||||
let Type::Ref(ty) = *self
|
||||
.ref_t
|
||||
.entry_sync((base, mutable))
|
||||
.or_insert_with(|| (&*self.alloc.alloc(RefT { base, mutable })).into())
|
||||
else {
|
||||
unreachable!()
|
||||
};
|
||||
ty
|
||||
}
|
||||
|
||||
pub fn make_fn(&'l self, ret_t: Type<'l>, par_t: Arc<[Type<'l>]>) -> &'l FuncT<'l> {
|
||||
let Type::Func(ty) = *self
|
||||
.fun_t
|
||||
.entry_sync((ret_t, par_t.clone()))
|
||||
.or_insert_with(|| {
|
||||
let ctx = ret_t.ctx();
|
||||
for ty in par_t.iter() {
|
||||
if ty.ctx() != ctx {
|
||||
panic!("All types must share the same context.");
|
||||
}
|
||||
}
|
||||
(&*self.alloc.alloc(FuncT { ret_t, par_t })).into()
|
||||
})
|
||||
else {
|
||||
unreachable!()
|
||||
};
|
||||
ty
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for TypeDerivations<'_> {}
|
||||
|
||||
impl PartialEq for TypeDerivations<'_> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
std::ptr::eq(self, other)
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for TypeDerivations<'_> {
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
(self as *const Self).hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("*{}{}", if *mutable { "mut " } else { "" }, *base)]
|
||||
pub struct PtrT<'l> {
|
||||
#[debug("{base}")]
|
||||
pub base: Type<'l>,
|
||||
pub mutable: bool,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l PtrT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Ptr(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("&{}{}", if *mutable { "mut " } else { "" }, *base)]
|
||||
pub struct RefT<'l> {
|
||||
#[debug("{base}")]
|
||||
pub base: Type<'l>,
|
||||
pub mutable: bool,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l RefT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Ref(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct FuncT<'l> {
|
||||
pub ret_t: Type<'l>,
|
||||
pub par_t: Arc<[Type<'l>]>,
|
||||
}
|
||||
|
||||
impl Display for FuncT<'_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
let mut separator = "";
|
||||
write!(f, "fn(")?;
|
||||
for ty in &*self.par_t {
|
||||
write!(f, "{separator}{ty}")?;
|
||||
separator = ", ";
|
||||
}
|
||||
write!(f, ") -> {}", self.ret_t)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l FuncT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Func(self)
|
||||
}
|
||||
}
|
||||
|
||||
pub trait MakeTypeDerivations<'l> {
|
||||
fn make_ptr(self, mutable: bool) -> &'l PtrT<'l>;
|
||||
fn make_ref(self, mutable: bool) -> &'l RefT<'l>;
|
||||
fn make_fn(self, par_t: impl IntoIterator<Item = Type<'l>>) -> &'l FuncT<'l>;
|
||||
}
|
||||
|
||||
impl<'l, T: 'l + Into<Type<'l>>> MakeTypeDerivations<'l> for T {
|
||||
fn make_ptr(self, mutable: bool) -> &'l PtrT<'l> {
|
||||
let ty = self.into();
|
||||
ty.ctx().derivations.make_ptr(ty, mutable)
|
||||
}
|
||||
|
||||
fn make_ref(self, mutable: bool) -> &'l RefT<'l> {
|
||||
let ty = self.into();
|
||||
ty.ctx().derivations.make_ref(ty, mutable)
|
||||
}
|
||||
|
||||
fn make_fn(self, par_t: impl IntoIterator<Item = Type<'l>>) -> &'l FuncT<'l> {
|
||||
let ty = self.into();
|
||||
ty.ctx()
|
||||
.derivations
|
||||
.make_fn(ty, par_t.into_iter().collect())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
use crate::{context::Ctx, types::Type};
|
||||
use derive_more::{Debug, Display};
|
||||
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("type")]
|
||||
#[debug("type")]
|
||||
pub struct TypeT<'l> {
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l TypeT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Type(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("void")]
|
||||
#[debug("void")]
|
||||
pub struct VoidT<'l> {
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l VoidT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Void(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("char")]
|
||||
#[debug("char")]
|
||||
pub struct CharT<'l> {
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l CharT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Char(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("bool")]
|
||||
#[debug("bool")]
|
||||
pub struct BoolT<'l> {
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l BoolT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Bool(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("const_str")]
|
||||
#[debug("const_str")]
|
||||
pub struct ConstStrT<'l> {
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l ConstStrT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::ConstStr(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("{}{}", if *signed { "i" } else { "u" }, precision)]
|
||||
#[debug("{self}")]
|
||||
pub struct IntT<'l> {
|
||||
pub signed: bool,
|
||||
pub precision: u32,
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l IntT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Int(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Display, PartialEq, Eq, Hash)]
|
||||
#[display("f{}", precision)]
|
||||
#[debug("{self}")]
|
||||
pub struct FloatT<'l> {
|
||||
pub precision: u32,
|
||||
pub(crate) ctx: Ctx<'l>,
|
||||
}
|
||||
|
||||
impl<'l> Into<Type<'l>> for &'l FloatT<'l> {
|
||||
fn into(self) -> Type<'l> {
|
||||
Type::Float(self)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
pub mod derivations;
|
||||
pub mod intrinsics;
|
||||
|
||||
use crate::{
|
||||
context::Ctx,
|
||||
types::{derivations::*, intrinsics::*},
|
||||
};
|
||||
use derive_more::{Debug, Display};
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Type<'l> {
|
||||
Void(&'l VoidT<'l>),
|
||||
Char(&'l CharT<'l>),
|
||||
Bool(&'l BoolT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Int(&'l IntT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Float(&'l FloatT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Ptr(&'l PtrT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Ref(&'l RefT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Func(&'l FuncT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
Type(&'l TypeT<'l>),
|
||||
|
||||
#[debug("{_0:?}")]
|
||||
#[display("{_0}")]
|
||||
ConstStr(&'l ConstStrT<'l>),
|
||||
}
|
||||
|
||||
impl<'l> Type<'l> {
|
||||
pub fn ctx(&self) -> Ctx<'l> {
|
||||
match self {
|
||||
Type::Void(t) => t.ctx,
|
||||
Type::Char(t) => t.ctx,
|
||||
Type::Bool(t) => t.ctx,
|
||||
Type::Int(t) => t.ctx,
|
||||
Type::Float(t) => t.ctx,
|
||||
Type::Ptr(t) => t.base.ctx(),
|
||||
Type::Ref(t) => t.base.ctx(),
|
||||
Type::Func(t) => t.ret_t.ctx(),
|
||||
Type::Type(t) => t.ctx,
|
||||
Type::ConstStr(t) => t.ctx,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
use crate::{context::Ctx, functions::ir::Instruction, types::Type};
|
||||
use bitflags::bitflags;
|
||||
use derive_more::{Debug, Display};
|
||||
use half::f16;
|
||||
use std::hash::Hash;
|
||||
|
||||
bitflags! {
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct ValueFlags: u16 {
|
||||
const Mutable = 0b00000000_00000001;
|
||||
const Volatile = 0b00000000_00000010;
|
||||
const Const = 0b00000001_00000000;
|
||||
const ConstOnly = 0b00000011_00000000;
|
||||
const Type = 0b00000111_00000000;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Int {
|
||||
I8(i8),
|
||||
I16(i16),
|
||||
I32(i32),
|
||||
I64(i64),
|
||||
I128(i128),
|
||||
|
||||
U8(u8),
|
||||
U16(u16),
|
||||
U32(u32),
|
||||
U64(u64),
|
||||
U128(u128),
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, Clone, Copy, PartialEq)]
|
||||
pub enum Float {
|
||||
F16(f16),
|
||||
F32(f32),
|
||||
F64(f64),
|
||||
}
|
||||
|
||||
impl Eq for Float {}
|
||||
|
||||
impl Hash for Float {
|
||||
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
||||
match self {
|
||||
Float::F16(v) => v.to_ne_bytes().hash(state),
|
||||
Float::F32(v) => v.to_ne_bytes().hash(state),
|
||||
Float::F64(v) => v.to_ne_bytes().hash(state),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Const<'l> {
|
||||
#[display("()")]
|
||||
#[debug("()")]
|
||||
Void(Ctx<'l>),
|
||||
|
||||
#[debug("{:?}", _0)]
|
||||
#[display("{}", _0)]
|
||||
Bool(bool, Ctx<'l>),
|
||||
|
||||
#[debug("{:?}", _0)]
|
||||
#[display("{}", _0)]
|
||||
Char(char, Ctx<'l>),
|
||||
|
||||
#[debug("{:?}", _0)]
|
||||
#[display("\"{}\"", _0)]
|
||||
Str(&'l str, Ctx<'l>),
|
||||
|
||||
#[debug("{:?}", _0)]
|
||||
#[display("{}", _0)]
|
||||
Int(Int, Ctx<'l>),
|
||||
|
||||
#[debug("{:?}", _0)]
|
||||
#[display("{}", _0)]
|
||||
Float(Float, Ctx<'l>),
|
||||
}
|
||||
|
||||
impl<'l> Const<'l> {
|
||||
pub fn flags(&self) -> ValueFlags {
|
||||
match self {
|
||||
Const::Void(_) => ValueFlags::Const,
|
||||
Const::Char(_, _) => ValueFlags::Const,
|
||||
Const::Bool(_, _) => ValueFlags::Const,
|
||||
Const::Str(_, _) => ValueFlags::Const,
|
||||
Const::Int(_, _) => ValueFlags::Const,
|
||||
Const::Float(_, _) => ValueFlags::Const,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ty(&self) -> Type<'l> {
|
||||
match self {
|
||||
Const::Void(ctx) => ctx.void_t(),
|
||||
Const::Char(_, ctx) => ctx.char_t(),
|
||||
Const::Bool(_, ctx) => ctx.bool_t(),
|
||||
Const::Str(_, ctx) => ctx.const_str_t(),
|
||||
Const::Int(v, ctx) => match v {
|
||||
Int::I8(_) => ctx.i8_t(),
|
||||
Int::I16(_) => ctx.i16_t(),
|
||||
Int::I32(_) => ctx.i32_t(),
|
||||
Int::I64(_) => ctx.i64_t(),
|
||||
Int::I128(_) => ctx.i128_t(),
|
||||
Int::U8(_) => ctx.u8_t(),
|
||||
Int::U16(_) => ctx.u16_t(),
|
||||
Int::U32(_) => ctx.u32_t(),
|
||||
Int::U64(_) => ctx.u64_t(),
|
||||
Int::U128(_) => ctx.u128_t(),
|
||||
},
|
||||
Const::Float(v, ctx) => match v {
|
||||
Float::F16(_) => ctx.f16_t(),
|
||||
Float::F32(_) => ctx.f32_t(),
|
||||
Float::F64(_) => ctx.f64_t(),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'l> Into<Value<'l>> for &'l Const<'l> {
|
||||
fn into(self) -> Value<'l> {
|
||||
Value::Const(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Value<'l> {
|
||||
#[display("{}", _0)]
|
||||
Const(&'l Const<'l>),
|
||||
#[display("{}", _0)]
|
||||
Type(Type<'l>),
|
||||
#[display("%{}", _0.id())]
|
||||
Instruction(&'l Instruction<'l>),
|
||||
}
|
||||
|
||||
impl<'l> Value<'l> {
|
||||
pub fn flags(&self) -> ValueFlags {
|
||||
match self {
|
||||
Value::Const(c) => c.flags(),
|
||||
Value::Type(_) => ValueFlags::Type,
|
||||
Value::Instruction(i) => i.value_flags(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ty(&self) -> Type<'l> {
|
||||
match self {
|
||||
Value::Const(v) => v.ty(),
|
||||
Value::Type(v) => v.ctx().type_t(),
|
||||
Value::Instruction(v) => v.value_ty(),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user