From 735c3231b1ba4862a24916a39e82e3877e95862e Mon Sep 17 00:00:00 2001 From: sofia Date: Mon, 28 Jul 2025 23:49:22 +0300 Subject: [PATCH] Make macros generate globals --- reid/src/ast/process.rs | 1 + reid/src/codegen/mod.rs | 15 ++++++- reid/src/codegen/util.rs | 10 +++-- reid/src/mir/macros.rs | 93 ++++++++++++++++++++++------------------ reid/src/mir/mod.rs | 12 ++++++ 5 files changed, 84 insertions(+), 47 deletions(-) diff --git a/reid/src/ast/process.rs b/reid/src/ast/process.rs index 1088cba..a4c7cbe 100644 --- a/reid/src/ast/process.rs +++ b/reid/src/ast/process.rs @@ -128,6 +128,7 @@ impl ast::Module { imports, associated_functions, functions, + globals: Vec::new(), path: self.path.clone(), is_main: self.is_main, tokens: self.tokens, diff --git a/reid/src/codegen/mod.rs b/reid/src/codegen/mod.rs index a923050..83ff00c 100644 --- a/reid/src/codegen/mod.rs +++ b/reid/src/codegen/mod.rs @@ -3,6 +3,7 @@ use std::{cell::RefCell, collections::HashMap, rc::Rc}; use allocator::{Allocator, AllocatorScope}; use intrinsics::*; use reid_lib::{ + builder::ConstantValue, compile::CompiledModule, debug_information::{ DebugFileData, DebugLexicalScope, DebugLocalVariable, DebugLocation, DebugMetadata, DebugRecordKind, @@ -96,6 +97,14 @@ impl Default for State { } } +impl mir::GlobalKind { + fn codegen<'ctx>(&'ctx self, context: &'ctx Context, module: &Module) -> Result { + Ok(match self { + mir::GlobalKind::Literal(literal) => module.add_constant(literal.as_const_kind()), + }) + } +} + impl mir::Module { fn codegen<'ctx>( &'ctx self, @@ -105,8 +114,10 @@ impl mir::Module { let mut module = context.module(&self.name, self.is_main); let tokens = &self.tokens; - let const_value = module.add_constant(ConstValueKind::I128(132)); - module.add_global("some_global", const_value); + for global in &self.globals { + let const_value = global.kind.codegen(context, &module)?; + module.add_global(&global.name, const_value); + } let (debug, compile_unit) = if let Some(path) = &self.path { module.create_debug_info(DebugFileData { diff --git a/reid/src/codegen/util.rs b/reid/src/codegen/util.rs index f320bda..ed4a951 100644 --- a/reid/src/codegen/util.rs +++ b/reid/src/codegen/util.rs @@ -34,11 +34,13 @@ impl mir::CmpOperator { impl mir::Literal { pub(super) fn as_const(&self, block: &mut Block) -> InstructionValue { - block.build_named(format!("{}", self), self.as_const_kind()).unwrap() + block + .build_named(format!("{}", self), Instr::Constant(self.as_const_kind())) + .unwrap() } - pub(super) fn as_const_kind(&self) -> Instr { - Instr::Constant(match self.clone() { + pub(super) fn as_const_kind(&self) -> ConstValueKind { + match self.clone() { mir::Literal::I8(val) => ConstValueKind::I8(val), mir::Literal::I16(val) => ConstValueKind::I16(val), mir::Literal::I32(val) => ConstValueKind::I32(val), @@ -61,7 +63,7 @@ impl mir::Literal { mir::Literal::F128(val) => ConstValueKind::F128(val), mir::Literal::F128PPC(val) => ConstValueKind::F128PPC(val), mir::Literal::Char(c) => ConstValueKind::U8(c as u8), - }) + } } } diff --git a/reid/src/mir/macros.rs b/reid/src/mir/macros.rs index 598f883..4683063 100644 --- a/reid/src/mir/macros.rs +++ b/reid/src/mir/macros.rs @@ -1,11 +1,11 @@ use std::collections::HashMap; -use crate::mir::{self, FunctionCall, IfExpression, WhileStatement}; +use crate::mir::{self, FunctionCall, GlobalKind, GlobalValue, IfExpression, Literal, WhileStatement}; use super::pass::{Pass, PassResult, PassState}; pub trait MacroFunction: std::fmt::Debug { - fn generate<'ctx, 'a>(&self, params: &[mir::Literal]) -> Result; + fn generate<'ctx, 'a>(&self, params: &[mir::Literal]) -> Result<(Vec, mir::ExprKind), ErrorKind>; } #[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -36,52 +36,57 @@ impl Pass for MacroPass { fn module(&mut self, module: &mut mir::Module, mut state: PassState) -> PassResult { for function in &mut module.functions { - match &mut function.kind { - mir::FunctionDefinitionKind::Local(block, _) => block.gen_macros(self, &mut state)?, - _ => {} + let globals = match &mut function.kind { + mir::FunctionDefinitionKind::Local(block, _) => block.gen_macros(self, &mut state), + _ => Vec::new(), }; + + module.globals.extend(globals); } Ok(()) } } impl mir::Block { - fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> PassResult { + fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec { + let mut globals = Vec::new(); for statement in &mut self.statements { - statement.gen_macros(data, state)?; + globals.extend(statement.gen_macros(data, state)); } if let Some((_, Some(return_expr))) = &mut self.return_expression { - return_expr.gen_macros(data, state)?; + globals.extend(return_expr.gen_macros(data, state)); } - Ok(()) + globals } } impl mir::Statement { - fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> PassResult { + fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec { + let mut globals = Vec::new(); match &mut self.0 { mir::StmtKind::Let(.., expr) => { - expr.gen_macros(data, state)?; + globals.extend(expr.gen_macros(data, state)); } mir::StmtKind::Set(lhs, rhs) => { - lhs.gen_macros(data, state)?; - rhs.gen_macros(data, state)?; + globals.extend(lhs.gen_macros(data, state)); + globals.extend(rhs.gen_macros(data, state)); } mir::StmtKind::Import(_) => {} mir::StmtKind::Expression(expr) => { - expr.gen_macros(data, state)?; + globals.extend(expr.gen_macros(data, state)); } mir::StmtKind::While(WhileStatement { condition, block, .. }) => { - condition.gen_macros(data, state)?; - block.gen_macros(data, state)?; + globals.extend(condition.gen_macros(data, state)); + globals.extend(block.gen_macros(data, state)); } }; - Ok(()) + globals } } impl mir::Expression { - fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> PassResult { + fn gen_macros(&mut self, data: &MacroPass, state: &mut MacroPassState) -> Vec { + let mut globals = Vec::new(); match &mut self.0 { mir::ExprKind::FunctionCall(function_call) => { if function_call.is_macro { @@ -93,13 +98,15 @@ impl mir::Expression { _ => state.note_errors(&vec![ErrorKind::InvalidMacroArgs], param.1), } } - *self = state.or_else( + let (generated_globals, expr) = state.or_else( existing_macro .generate(&literals) - .map(|kind| mir::Expression(kind, self.1)), - self.clone(), + .map(|(globals, kind)| (globals, mir::Expression(kind, self.1))), + (Vec::new(), self.clone()), self.1, ); + globals.extend(generated_globals); + *self = expr; } else { state.note_errors( &vec![ErrorKind::NoSuchMacro(function_call.name.clone())], @@ -110,26 +117,26 @@ impl mir::Expression { } mir::ExprKind::Variable(_) => {} mir::ExprKind::Indexed(expression, _, expression1) => { - expression.gen_macros(data, state)?; - expression1.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); + globals.extend(expression1.gen_macros(data, state)); } mir::ExprKind::Accessed(expression, ..) => { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } mir::ExprKind::Array(expressions) => { for expression in expressions { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } } mir::ExprKind::Struct(_, items) => { for item in items { - item.1.gen_macros(data, state)?; + globals.extend(item.1.gen_macros(data, state)); } } mir::ExprKind::Literal(_) => {} mir::ExprKind::BinOp(_, expression, expression1, _) => { - expression.gen_macros(data, state)?; - expression1.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); + globals.extend(expression1.gen_macros(data, state)); } mir::ExprKind::AssociatedFunctionCall( _, @@ -138,30 +145,30 @@ impl mir::Expression { }, ) => { for expression in parameters { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } } mir::ExprKind::If(IfExpression(cond, lhs, rhs)) => { - cond.gen_macros(data, state)?; - lhs.gen_macros(data, state)?; + globals.extend(cond.gen_macros(data, state)); + globals.extend(lhs.gen_macros(data, state)); if let Some(rhs) = rhs.as_mut() { - rhs.gen_macros(data, state)?; + globals.extend(rhs.gen_macros(data, state)); } } mir::ExprKind::Block(block) => { - block.gen_macros(data, state)?; + globals.extend(block.gen_macros(data, state)); } mir::ExprKind::Borrow(expression, _) => { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } mir::ExprKind::Deref(expression) => { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } mir::ExprKind::CastTo(expression, _) => { - expression.gen_macros(data, state)?; + globals.extend(expression.gen_macros(data, state)); } } - Ok(()) + globals } } @@ -176,9 +183,13 @@ pub fn form_macros() -> HashMap> { #[derive(Debug)] pub struct TestMacro; impl MacroFunction for TestMacro { - fn generate<'ctx, 'a>(&self, _: &[mir::Literal]) -> Result { - Ok(mir::ExprKind::Literal(mir::Literal::Vague(mir::VagueLiteral::Number( - 5, - )))) + fn generate<'ctx, 'a>(&self, _: &[mir::Literal]) -> Result<(Vec, mir::ExprKind), ErrorKind> { + Ok(( + vec![GlobalValue { + name: "sometestglobalvalue".to_owned(), + kind: GlobalKind::Literal(Literal::I16(12)), + }], + mir::ExprKind::Literal(mir::Literal::Vague(mir::VagueLiteral::Number(5))), + )) } } diff --git a/reid/src/mir/mod.rs b/reid/src/mir/mod.rs index 5a4f542..b61e403 100644 --- a/reid/src/mir/mod.rs +++ b/reid/src/mir/mod.rs @@ -421,11 +421,23 @@ pub struct Module { pub functions: Vec, pub typedefs: Vec, pub binop_defs: Vec, + pub globals: Vec, pub path: Option, pub tokens: Vec, pub is_main: bool, } +#[derive(Debug)] +pub struct GlobalValue { + pub name: String, + pub kind: GlobalKind, +} + +#[derive(Debug)] +pub enum GlobalKind { + Literal(Literal), +} + pub type ModuleMap = HashMap; #[derive(Debug)]