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

Get pointers working

Browse Source
This commit is contained in:
Sofia 2025-07-21 14:43:24 +03:00
parent 9db508bd9c
commit ed9c8638d5
5 changed files with 63 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
reid-llvm-lib/src/builder.rs
View File

@ -395,6 +395,8 @@ impl Builder {
Instr::Alloca(_) => Ok(()), Instr::Alloca(_) => Ok(()),
Instr::Load(ptr, load_ty) => { Instr::Load(ptr, load_ty) => {
let ptr_ty = ptr.get_type(&self)?; let ptr_ty = ptr.get_type(&self)?;
dbg!(&self);
dbg!(&ptr_ty, &load_ty);
if let Type::Ptr(ptr_ty_inner) = ptr_ty { if let Type::Ptr(ptr_ty_inner) = ptr_ty {
if *ptr_ty_inner == load_ty { if *ptr_ty_inner == load_ty {
Ok(()) Ok(())

4
reid-llvm-lib/src/compile.rs
View File

@ -68,6 +68,10 @@ pub struct CompileOutput {
impl CompiledModule { impl CompiledModule {
pub fn output(&self) -> CompileOutput { pub fn output(&self) -> CompileOutput {
unsafe { unsafe {
let llvm_ir = from_cstring(LLVMPrintModuleToString(self.module_ref))
.expect("Unable to print LLVM IR to string");
println!("{}", llvm_ir);
LLVM_InitializeAllTargets(); LLVM_InitializeAllTargets();
LLVM_InitializeAllTargetInfos(); LLVM_InitializeAllTargetInfos();
LLVM_InitializeAllTargetMCs(); LLVM_InitializeAllTargetMCs();

63
reid/src/codegen.rs
View File

@ -1,4 +1,4 @@
use std::{collections::HashMap, mem}; use std::{array, collections::HashMap, mem};
use reid_lib::{ use reid_lib::{
builder::{InstructionValue, TypeValue}, builder::{InstructionValue, TypeValue},
@ -736,7 +736,7 @@ impl mir::Expression {
} }
} }
mir::ExprKind::Indexed(expression, val_t, idx_expr) => { mir::ExprKind::Indexed(expression, val_t, idx_expr) => {
let StackValue(kind, array_ty) = expression let StackValue(kind, ty) = expression
.codegen(scope, &state.load(false)) .codegen(scope, &state.load(false))
.expect("array returned none!"); .expect("array returned none!");
let idx = idx_expr let idx = idx_expr
@ -749,23 +749,49 @@ impl mir::Expression {
.build("array.zero", Instr::Constant(ConstValue::U32(0))) .build("array.zero", Instr::Constant(ConstValue::U32(0)))
.unwrap(); .unwrap();
let ptr = scope let TypeKind::CodegenPtr(inner) = ty else {
panic!();
};
let (ptr, contained_ty) = if let TypeKind::UserPtr(further_inner) = *inner.clone() {
dbg!(&further_inner, &val_t);
let loaded = scope
.block
.build(
"array.load",
Instr::Load(
kind.instr(),
inner.get_type(scope.type_values, scope.types),
),
)
.unwrap();
(
scope
.block
.build(format!("array.gep"), Instr::GetElemPtr(loaded, vec![idx]))
.unwrap()
.maybe_location(&mut scope.block, location),
*further_inner,
)
} else {
let TypeKind::Array(elem_ty, _) = *inner else {
panic!();
};
(
scope
.block .block
.build( .build(
format!("array.gep"), format!("array.gep"),
Instr::GetElemPtr(kind.instr(), vec![first, idx]), Instr::GetElemPtr(kind.instr(), vec![first, idx]),
) )
.unwrap() .unwrap()
.maybe_location(&mut scope.block, location); .maybe_location(&mut scope.block, location),
val_t.clone(),
let TypeKind::CodegenPtr(inner) = array_ty else { )
panic!();
};
let TypeKind::Array(elem_ty, _) = *inner else {
panic!();
}; };
if state.should_load { if state.should_load {
dbg!(&contained_ty);
Some(StackValue( Some(StackValue(
kind.derive( kind.derive(
scope scope
@ -774,16 +800,19 @@ impl mir::Expression {
"array.load", "array.load",
Instr::Load( Instr::Load(
ptr, ptr,
val_t.get_type(scope.type_values, scope.types), contained_ty.get_type(scope.type_values, scope.types),
), ),
) )
.unwrap() .unwrap()
.maybe_location(&mut scope.block, location), .maybe_location(&mut scope.block, location),
), ),
*elem_ty, contained_ty,
)) ))
} else { } else {
Some(StackValue(kind.derive(ptr), TypeKind::CodegenPtr(elem_ty))) Some(StackValue(
kind.derive(ptr),
TypeKind::CodegenPtr(Box::new(contained_ty)),
))
} }
} }
mir::ExprKind::Array(expressions) => { mir::ExprKind::Array(expressions) => {
@ -1175,9 +1204,9 @@ impl TypeKind {
let type_val = type_vals.get(n).unwrap().clone(); let type_val = type_vals.get(n).unwrap().clone();
Type::CustomType(type_val) Type::CustomType(type_val)
} }
TypeKind::UserPtr(type_kind) => { TypeKind::UserPtr(type_kind) => Type::Ptr(Box::new(Type::Ptr(Box::new(
Type::Ptr(Box::new(type_kind.get_type(type_vals, typedefs))) type_kind.get_type(type_vals, typedefs),
} )))),
TypeKind::CodegenPtr(type_kind) => { TypeKind::CodegenPtr(type_kind) => {
Type::Ptr(Box::new(type_kind.get_type(type_vals, typedefs))) Type::Ptr(Box::new(type_kind.get_type(type_vals, typedefs)))
} }
@ -1228,7 +1257,7 @@ impl TypeKind {
), ),
size_bits: self.size_of(), size_bits: self.size_of(),
}), }),
TypeKind::CodegenPtr(inner) | TypeKind::Borrow(inner, _) => { TypeKind::CodegenPtr(inner) | TypeKind::UserPtr(inner) | TypeKind::Borrow(inner, _) => {
DebugTypeData::Pointer(DebugPointerType { DebugTypeData::Pointer(DebugPointerType {
name, name,
pointee: inner.get_debug_type_hard( pointee: inner.get_debug_type_hard(

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

@ -103,10 +103,10 @@ impl<'map> Pass for LinkerPass<'map> {
modules.insert(module.name.clone(), Rc::new(RefCell::new((module, tokens)))); modules.insert(module.name.clone(), Rc::new(RefCell::new((module, tokens))));
} }
modules.insert( // modules.insert(
"std".to_owned(), // "std".to_owned(),
Rc::new(RefCell::new(compile_std(&mut self.module_map)?)), // Rc::new(RefCell::new(compile_std(&mut self.module_map)?)),
); // );
let mut modules_to_process: Vec<Rc<RefCell<(Module, Vec<FullToken>)>>> = let mut modules_to_process: Vec<Rc<RefCell<(Module, Vec<FullToken>)>>> =
modules.values().cloned().collect(); modules.values().cloned().collect();

4
reid_src/ptr.reid
View File

@ -4,7 +4,9 @@
extern fn malloc(size: u64) -> *u8; extern fn malloc(size: u64) -> *u8;
fn main() -> u8 { fn main() -> u8 {
let ptr = malloc(4); let mut ptr = malloc(4);
ptr[0] = 5;
return ptr[0]; return ptr[0];
} }