teascade/reid-llvm
1
0
Fork 0
Code Issues Pull Requests Packages Releases 3 Wiki Activity

Import binops while importing types as well

Browse Source
This commit is contained in:
Sofia 2025-07-26 13:18:55 +03:00
parent 58cc633f98
commit 0196fb53ed
15 changed files with 123 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/imported_type.reid
View File

@ -14,6 +14,6 @@ fn otus(param: &mut String) {
fn main() -> u8 {
let mut otus = from_str("hello");
otus(&mut otus);
print(otus);
print(otus + " beep");
return 0;
}

72
reid-llvm-lib/src/lib.rs
View File

@ -5,9 +5,7 @@
use std::{fmt::Debug, marker::PhantomData};
use builder::{BlockValue, Builder, FunctionValue, InstructionValue, ModuleValue, TypeValue};
use debug_information::{
DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue,
};
use debug_information::{DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue};
use fmt::PrintableModule;
pub mod builder;
@ -66,13 +64,7 @@ pub struct Module<'ctx> {
}
impl<'ctx> Module<'ctx> {
pub fn function(
&self,
name: &str,
ret: Type,
params: Vec<Type>,
flags: FunctionFlags,
) -> Function<'ctx> {
pub fn function(&self, name: &str, ret: Type, params: Vec<Type>, flags: FunctionFlags) -> Function<'ctx> {
unsafe {
Function {
phantom: PhantomData,
@ -111,10 +103,7 @@ impl<'ctx> Module<'ctx> {
}
}
pub fn create_debug_info(
&mut self,
file: DebugFileData,
) -> (DebugInformation, DebugProgramValue) {
pub fn create_debug_info(&mut self, file: DebugFileData) -> (DebugInformation, DebugProgramValue) {
let (debug_info, program_value) = DebugInformation::from_file(file);
self.debug_info = Some(debug_info.clone());
(debug_info, program_value)
@ -144,10 +133,17 @@ pub struct FunctionData {
#[derive(Debug, Clone, Copy, Hash)]
pub struct FunctionFlags {
/// True in the destination module of the import, false in the source module.
pub is_extern: bool,
/// Whether this function is the main function of the module, that should be
/// executed (and linked externally also).
pub is_main: bool,
/// Whether this function should be available externally always.
pub is_pub: bool,
/// If this function is an imported function (either in the source or
/// destination module)
pub is_imported: bool,
/// Whether this function should add "alwaysinline"-attribute.
pub inline: bool,
}
@ -260,11 +256,7 @@ impl Instr {
}
impl<'builder> Block<'builder> {
pub fn build_named<T: Into<String>>(
&mut self,
name: T,
instruction: Instr,
) -> CompileResult<InstructionValue> {
pub fn build_named<T: Into<String>>(&mut self, name: T, instruction: Instr) -> CompileResult<InstructionValue> {
unsafe {
self.builder.add_instruction(
&self.value,
@ -295,15 +287,13 @@ impl<'builder> Block<'builder> {
pub fn set_instr_location(&self, instruction: InstructionValue, location: DebugLocationValue) {
unsafe {
self.builder
.add_instruction_location(&instruction, location);
self.builder.add_instruction_location(&instruction, location);
}
}
pub fn set_instr_metadata(&self, instruction: InstructionValue, location: DebugMetadataValue) {
unsafe {
self.builder
.add_instruction_metadata(&instruction, location);
self.builder.add_instruction_metadata(&instruction, location);
}
}
@ -610,16 +600,10 @@ impl Type {
| Type::U32
| Type::U64
| Type::U128 => TypeCategory::Integer,
Type::F16
| Type::F32B
| Type::F32
| Type::F64
| Type::F80
| Type::F128
| Type::F128PPC => TypeCategory::Real,
Type::Bool | Type::Void | Type::CustomType(_) | Type::Array(_, _) | Type::Ptr(_) => {
TypeCategory::Other
Type::F16 | Type::F32B | Type::F32 | Type::F64 | Type::F80 | Type::F128 | Type::F128PPC => {
TypeCategory::Real
}
Type::Bool | Type::Void | Type::CustomType(_) | Type::Array(_, _) | Type::Ptr(_) => TypeCategory::Other,
}
}
@ -630,23 +614,15 @@ impl Type {
(I16, I32 | I64 | I128) => Some(Instr::SExt(value, other.clone())),
(I32, I64 | I128) => Some(Instr::SExt(value, other.clone())),
(I64, I128) => Some(Instr::SExt(value, other.clone())),
(I128 | U128, I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => {
Some(Instr::Trunc(value, other.clone()))
}
(I64 | U64, I32 | U32 | I16 | U16 | I8 | U8) => {
Some(Instr::Trunc(value, other.clone()))
}
(I128 | U128, I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
(I64 | U64, I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
(I32 | U32, I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
(I16 | U16, I8 | U8) => Some(Instr::Trunc(value, other.clone())),
(U8 | I8, U8 | I8 | U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => {
Some(Instr::ZExt(value, other.clone()))
}
(U16 | I16, U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => {
Some(Instr::ZExt(value, other.clone()))
}
(U32 | I32, U32 | I32 | U64 | I64 | U128 | I128) => {
Some(Instr::ZExt(value, other.clone()))
}
(U16 | I16, U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
(U32 | I32, U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
(U64 | I64, U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
(U128 | I128, U128 | I128) => Some(Instr::ZExt(value, other.clone())),
(U8 | U16 | U32 | U64 | U128, F16 | F32 | F32B | F64 | F80 | F128 | F128PPC) => {
@ -667,15 +643,11 @@ impl Type {
(Ptr(_), I128 | U128 | I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => {
Some(Instr::PtrToInt(value, other.clone()))
}
(F16, F32 | F32B | F64 | F80 | F128 | F128PPC) => {
Some(Instr::FPExt(value, other.clone()))
}
(F16, F32 | F32B | F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
(F32 | F32B, F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
(F64, F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
(F80, F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
(F128PPC | F128, F80 | F64 | F32B | F32 | F16) => {
Some(Instr::FPTrunc(value, other.clone()))
}
(F128PPC | F128, F80 | F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
(F80, F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
(F64, F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
(F32B | F32, F16) => Some(Instr::FPTrunc(value, other.clone())),

22
reid/lib/std.reid
View File

@ -4,6 +4,21 @@ extern fn malloc(size: u64) -> *u8;
extern fn free(ptr: *u8);
extern fn div(numerator: i32, denominator: i32) -> div_t;
struct String {
inner: *char,
length: u64,
max_length: u64,
must_be_freed: bool,
}
impl binop (lhs: String) + (rhs: *char) -> String {
let mut new = lhs;
let added = from_str(rhs);
concat_strings(&mut new, added);
free_string(&added);
return lhs;
}
struct div_t {
quotient: i32,
remainder: i32,
@ -21,13 +36,6 @@ pub fn allocate(size: u64) -> *u8 {
malloc(size)
}
struct String {
inner: *char,
length: u64,
max_length: u64,
must_be_freed: bool,
}
pub fn new_string() -> String {
String {
inner: allocate(0),

1
reid/src/ast/process.rs
View File

@ -117,6 +117,7 @@ impl ast::Module {
block.2.as_meta(module_id),
),
meta: signature_range.as_meta(module_id),
exported: false,
});
}
}

2
reid/src/codegen/intrinsics.rs
View File

@ -49,6 +49,7 @@ where
return_type: ty.clone(),
fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicSimpleInstr(fun))),
meta: Default::default(),
exported: false,
}
}
@ -63,6 +64,7 @@ where
return_type: TypeKind::Bool,
fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicBooleanInstr(fun))),
meta: Default::default(),
exported: false,
}
}

29
reid/src/codegen/mod.rs
View File

@ -15,7 +15,7 @@ use scope::*;
use crate::{
mir::{
self, implement::TypeCategory, pass::ScopeBinopKey, CustomTypeKey, FunctionDefinitionKind, NamedVariableRef,
self, implement::TypeCategory, pass::BinopKey, CustomTypeKey, FunctionDefinitionKind, NamedVariableRef,
SourceModuleId, StructField, StructType, TypeDefinition, TypeDefinitionKind, TypeKind, WhileStatement,
},
util::try_all,
@ -214,8 +214,12 @@ impl mir::Module {
let mut binops = HashMap::new();
for binop in &self.binop_defs {
let binop_fn_name = format!(
"binop.{}.{:?}.{}.{}",
binop.lhs.1, binop.op, binop.rhs.1, binop.return_type
);
binops.insert(
ScopeBinopKey {
BinopKey {
params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
operator: binop.op,
},
@ -224,16 +228,14 @@ impl mir::Module {
return_ty: binop.return_type.clone(),
kind: match &binop.fn_kind {
FunctionDefinitionKind::Local(block, metadata) => {
let binop_fn_name = format!(
"binop.{}.{:?}.{}.{}",
binop.lhs.1, binop.op, binop.rhs.1, binop.return_type
);
let ir_function = module.function(
&binop_fn_name,
binop.return_type.get_type(&type_values),
vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
FunctionFlags {
inline: true,
is_pub: binop.exported,
is_imported: binop.exported,
..Default::default()
},
);
@ -289,7 +291,18 @@ impl mir::Module {
StackBinopFunctionKind::UserGenerated(ir_function)
}
FunctionDefinitionKind::Extern(_) => todo!(),
FunctionDefinitionKind::Extern(imported) => {
StackBinopFunctionKind::UserGenerated(module.function(
&binop_fn_name,
binop.return_type.get_type(&type_values),
vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
FunctionFlags {
is_extern: true,
is_imported: *imported,
..FunctionFlags::default()
},
))
}
FunctionDefinitionKind::Intrinsic(intrinsic_function) => {
StackBinopFunctionKind::Intrinsic(intrinsic_function)
}
@ -704,7 +717,7 @@ impl mir::Expression {
let lhs = lhs_val.instr();
let rhs = rhs_val.instr();
let operation = scope.binops.get(&ScopeBinopKey {
let operation = scope.binops.get(&BinopKey {
params: (lhs_val.1.clone(), rhs_val.1.clone()),
operator: *binop,
});

14
reid/src/codegen/scope.rs
View File

@ -8,7 +8,7 @@ use reid_lib::{
use crate::{
lexer::FullToken,
mir::{pass::ScopeBinopKey, CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind},
mir::{pass::BinopKey, CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind},
};
use super::{allocator::Allocator, ErrorKind, IntrinsicFunction, ModuleCodegen};
@ -24,7 +24,7 @@ pub struct Scope<'ctx, 'scope> {
pub(super) types: &'scope HashMap<TypeValue, TypeDefinition>,
pub(super) type_values: &'scope HashMap<CustomTypeKey, TypeValue>,
pub(super) functions: &'scope HashMap<String, Function<'ctx>>,
pub(super) binops: &'scope HashMap<ScopeBinopKey, StackBinopDefinition<'ctx>>,
pub(super) binops: &'scope HashMap<BinopKey, StackBinopDefinition<'ctx>>,
pub(super) stack_values: HashMap<String, StackValue>,
pub(super) debug: Option<Debug<'ctx>>,
pub(super) allocator: Rc<RefCell<Allocator>>,
@ -150,15 +150,9 @@ impl<'ctx> StackBinopDefinition<'ctx> {
StackBinopFunctionKind::UserGenerated(ir) => {
let instr = scope
.block
.build(Instr::FunctionCall(
ir.value(),
vec![lhs.instr(), rhs.instr()],
))
.build(Instr::FunctionCall(ir.value(), vec![lhs.instr(), rhs.instr()]))
.unwrap();
Ok(StackValue(
StackValueKind::Immutable(instr),
self.return_ty.clone(),
))
Ok(StackValue(StackValueKind::Immutable(instr), self.return_ty.clone()))
}
StackBinopFunctionKind::Intrinsic(fun) => fun.codegen(scope, &[&lhs, &rhs]),
}

2
reid/src/lib.rs
View File

@ -130,7 +130,7 @@ pub fn perform_all_passes<'map>(
for intrinsic in form_intrinsic_binops() {
binops
.set(
mir::pass::ScopeBinopKey {
mir::pass::BinopKey {
params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
operator: intrinsic.op,
},

10
reid/src/mir/fmt.rs
View File

@ -66,8 +66,14 @@ impl Display for BinopDefinition {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"impl binop ({}: {:#}) {} ({}: {:#}) -> {:#} ",
self.lhs.0, self.lhs.1, self.op, self.rhs.0, self.rhs.1, self.return_type
"{}impl binop ({}: {:#}) {} ({}: {:#}) -> {:#} ",
if self.exported { "exported " } else { "" },
self.lhs.0,
self.lhs.1,
self.op,
self.rhs.0,
self.rhs.1,
self.return_type
)?;
Display::fmt(&self.fn_kind, f)
}

39
reid/src/mir/linker.rs
View File

@ -11,7 +11,10 @@ use crate::{
codegen::scope,
compile_module,
error_raporting::{ErrorModules, ReidError},
mir::{CustomTypeKey, FunctionDefinitionKind, SourceModuleId, TypeDefinition, TypeKind},
mir::{
pass::BinopKey, BinopDefinition, CustomTypeKey, FunctionDefinitionKind, SourceModuleId, TypeDefinition,
TypeKind,
},
parse_module,
};
@ -110,6 +113,7 @@ impl<'map> Pass for LinkerPass<'map> {
let mut modules_to_process: Vec<Rc<RefCell<_>>> = modules.values().cloned().collect();
let mut already_imported_types = HashSet::<CustomTypeKey>::new();
let mut already_imported_binops = HashSet::<BinopKey>::new();
while let Some(module) = modules_to_process.pop() {
let mut extern_types = HashMap::new();
@ -232,10 +236,39 @@ impl<'map> Pass for LinkerPass<'map> {
kind: super::FunctionDefinitionKind::Extern(true),
});
} else if let Some(ty) = imported.typedefs.iter_mut().find(|f| f.name == *import_name) {
dbg!("hello??");
let external_key = CustomTypeKey(ty.name.clone(), ty.source_module);
let imported_ty = TypeKind::CustomType(external_key.clone());
imported_types.push((external_key, true));
dbg!(&imported_types);
for binop in &mut imported.binop_defs {
if binop.lhs.1 != imported_ty && binop.rhs.1 != imported_ty {
continue;
}
let binop_key = BinopKey {
params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
operator: binop.op,
};
if already_imported_binops.contains(&binop_key) {
continue;
}
binop.exported = true;
already_imported_binops.insert(binop_key);
match &binop.fn_kind {
FunctionDefinitionKind::Local(block, metadata) => {
importer_module.binop_defs.push(BinopDefinition {
lhs: binop.lhs.clone(),
op: binop.op,
rhs: binop.rhs.clone(),
return_type: binop.return_type.clone(),
fn_kind: FunctionDefinitionKind::Extern(true),
meta: binop.meta.clone(),
exported: false,
});
}
FunctionDefinitionKind::Extern(_) => {}
FunctionDefinitionKind::Intrinsic(_) => {}
}
}
} else {
state.ok::<_, Infallible>(
Err(ErrorKind::ImportDoesNotExist(module_name.clone(), import_name.clone())),

2
reid/src/mir/mod.rs
View File

@ -370,6 +370,8 @@ pub struct BinopDefinition {
pub return_type: TypeKind,
pub fn_kind: FunctionDefinitionKind,
pub meta: Metadata,
// Wether this binop definition has been imported into another module.
pub exported: bool,
}
impl BinopDefinition {

12
reid/src/mir/pass.rs
View File

@ -117,7 +117,7 @@ impl<Key: std::hash::Hash + Eq, T: Clone + std::fmt::Debug> Storage<Key, T> {
}
}
pub type BinopMap = Storage<ScopeBinopKey, ScopeBinopDef>;
pub type BinopMap = Storage<BinopKey, ScopeBinopDef>;
#[derive(Clone, Default, Debug)]
pub struct Scope<Data: Clone + Default> {
@ -182,7 +182,7 @@ pub struct ScopeVariable {
}
#[derive(Clone, Debug, Eq)]
pub struct ScopeBinopKey {
pub struct BinopKey {
pub params: (TypeKind, TypeKind),
pub operator: BinaryOperator,
}
@ -194,7 +194,7 @@ pub enum CommutativeKind {
Any,
}
impl PartialEq for ScopeBinopKey {
impl PartialEq for BinopKey {
fn eq(&self, other: &Self) -> bool {
if self.operator != other.operator {
return false;
@ -216,7 +216,7 @@ impl PartialEq for ScopeBinopKey {
}
}
impl std::hash::Hash for ScopeBinopKey {
impl std::hash::Hash for BinopKey {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
if self.operator.is_commutative() {
let mut sorted = vec![&self.params.0, &self.params.1];
@ -336,7 +336,7 @@ impl Context {
scope
.binops
.set(
ScopeBinopKey {
BinopKey {
params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
operator: intrinsic.op,
},
@ -374,7 +374,7 @@ impl Module {
scope
.binops
.set(
ScopeBinopKey {
BinopKey {
params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
operator: binop.op,
},

2
reid/src/mir/typecheck/typecheck.rs
View File

@ -422,7 +422,7 @@ impl Expression {
);
};
let binops = state.scope.binops.filter(&pass::ScopeBinopKey {
let binops = state.scope.binops.filter(&pass::BinopKey {
params: (lhs_type.clone(), rhs_type.clone()),
operator: *op,
});

4
reid/src/mir/typecheck/typeinference.rs
View File

@ -20,7 +20,7 @@ use crate::{
use super::{
super::{
pass::{Pass, PassResult, PassState, ScopeBinopKey},
pass::{BinopKey, Pass, PassResult, PassState},
TypeKind::*,
VagueType::*,
},
@ -62,7 +62,7 @@ impl<'t> Pass for TypeInference<'t> {
let mut seen_binops = HashSet::new();
for binop in &module.binop_defs {
let binop_key = ScopeBinopKey {
let binop_key = BinopKey {
params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
operator: binop.op,
};

2
reid/src/mir/typecheck/typerefs.rs
View File

@ -10,7 +10,7 @@ use crate::{
};
use super::{
super::pass::{ScopeBinopDef, ScopeBinopKey, Storage},
super::pass::{BinopKey, ScopeBinopDef, Storage},
ErrorKind,
};