shadowcat/lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added returning & more asm instructions

Browse Source
This commit is contained in:
shadow cat
2025-03-22 16:54:28 -04:00
parent 7f809d797c
commit 6c2f4e814f
11 changed files with 176 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
data/test.lang
View File

@@ -1,9 +1,11 @@
fn start() {
print("Helld!\n");
print("Hello World!!!!!\n");
println("Helld!");
println("Hello World!!!!!");
thinger();
print("what\n");
exit(39);
println("what");
print(tester());
arger("a", "b", "c");
exit(add(35, 4));
}
fn thinger() {
@@ -14,6 +16,11 @@ fn unused() {
print("el unused\n");
}
fn println(msg: slice<8>) {
print(msg);
print("\n");
}
fn print(msg: slice<8>) {
asm (a1 = msg) {
ld a2, 8, a1
@@ -24,6 +31,23 @@ fn print(msg: slice<8>) {
}
}
fn add(a: 64, b: 64) -> 64 {
let c: 64 = 0;
asm (t0 = a, t1 = b, a0 = c) {
ld t0, 0, t0
ld t1, 0, t1
add t0, t0, t1
sd t0, 0, a0
};
c
}
fn arger(a: slice<8>, b: slice<8>, c: slice<8>) {
print(a);
print(b);
println(c);
}
fn exit(status: 64) {
asm (a0 = status) {
ld a0, 0, a0
@@ -31,3 +55,7 @@ fn exit(status: 64) {
ecall
};
}
fn tester() -> slice<8> {
"hola\n"
}

58
src/compiler/arch/riscv64/compile.rs
View File

@@ -100,9 +100,8 @@ pub fn compile(program: IRLProgram) -> (Vec<u8>, Option<Addr>) {
let mut v = Vec::new();
let mut stack = HashMap::new();
let mut stack_len = 0;
let has_stack = !f.stack.is_empty() || !f.args.is_empty() || f.makes_call;
let mut stack_ra = None;
if has_stack {
let mut stack_rva = None;
if f.makes_call {
// return addr
stack_ra = Some(stack_len);
@@ -116,13 +115,23 @@ pub fn compile(program: IRLProgram) -> (Vec<u8>, Option<Addr>) {
stack.insert(id, stack_len);
stack_len += align(s);
}
if f.ret_size > 0 {
stack_rva = Some(stack_len);
stack_len += align(&f.ret_size);
}
v.push(LI::Addi {
dest: sp,
src: sp,
imm: -stack_len,
});
let has_stack = stack_len > 0;
if has_stack {
if let Some(stack_ra) = stack_ra {
v.push(LI::Sd { src: ra, offset: stack_ra, base: sp });
v.push(LI::Sd {
src: ra,
offset: stack_ra,
base: sp,
});
}
}
for i in &f.instructions {
@@ -156,6 +165,19 @@ pub fn compile(program: IRLProgram) -> (Vec<u8>, Option<Addr>) {
}
IRI::Call { dest, f, args } => {
let mut offset = 0;
if let Some((dest, s)) = dest {
offset -= align(s);
v.push(LI::Addi {
dest: t0,
src: sp,
imm: stack[&dest],
});
v.push(LI::Sd {
src: t0,
offset,
base: sp,
})
}
for (arg, s) in args {
let bs = align(s);
offset -= bs;
@@ -191,15 +213,39 @@ pub fn compile(program: IRLProgram) -> (Vec<u8>, Option<Addr>) {
offset: offset as i32,
base: r(base),
}),
AI::Sd { src, base, offset } => v.push(LI::Sd {
src: r(src),
offset: offset as i32,
base: r(base),
}),
AI::Add { dest, src1, src2 } => v.push(LI::Add {
dest: r(dest),
src1: r(src1),
src2: r(src2),
}),
}
}
}
IRI::Ret { src } => todo!(),
IRI::Ret { src } => {
let Some(rva) = stack_rva else {
panic!("no return value address on stack!")
};
v.push(LI::Ld {
dest: t0,
offset: rva,
base: sp,
});
mov_mem(&mut v, sp, stack[src], t0, 0, t1, align(&f.ret_size) as u32);
}
}
}
if has_stack {
if let Some(stack_ra) = stack_ra {
v.push(LI::Ld { dest: ra, offset: stack_ra, base: sp });
v.push(LI::Ld {
dest: ra,
offset: stack_ra,
base: sp,
});
}
v.push(LI::Addi {
dest: sp,
@@ -210,5 +256,5 @@ pub fn compile(program: IRLProgram) -> (Vec<u8>, Option<Addr>) {
v.push(LI::Ret);
fns.push((v, *sym));
}
create_program(fns, data, Some(program.entry()))
create_program(fns, data, Some(program.entry()), &program)
}

13
src/compiler/program.rs
View File

@@ -1,11 +1,12 @@
use std::collections::HashMap;
use crate::ir::Symbol;
use crate::ir::{IRLProgram, Symbol};
pub fn create_program<I: Instr>(
fns: Vec<(Vec<I>, Symbol)>,
ro_data: Vec<(Vec<u8>, Symbol)>,
start: Option<Symbol>,
program: &IRLProgram,
) -> (Vec<u8>, Option<Addr>) {
let mut data = Vec::new();
let mut sym_table = SymTable::new(fns.len() + ro_data.len());
@@ -36,6 +37,16 @@ pub fn create_program<I: Instr>(
}
}
}
for (s, f) in program.fns() {
println!(
"{}: {:?}",
f.name,
sym_table.get(*s).map(|a| {
let pos = a.0 + 0x1000 + 0x40 + 0x38;
format!("0x{:x}", pos)
})
);
}
assert!(missing.is_empty());
(
data,

17
src/ir/arch/riscv64.rs
View File

@@ -1,7 +1,4 @@
use crate::{
compiler::arch::riscv64::*,
ir::{VarID, VarInst},
};
use crate::{compiler::arch::riscv64::*, ir::VarInst};
#[derive(Copy, Clone)]
pub enum RV64Instruction {
@@ -23,6 +20,16 @@ pub enum RV64Instruction {
offset: i64,
base: RegRef,
},
Sd {
src: RegRef,
offset: i64,
base: RegRef,
},
Add {
dest: RegRef,
src1: RegRef,
src2: RegRef,
},
}
#[derive(Copy, Clone)]
@@ -48,6 +55,8 @@ impl std::fmt::Debug for RV64Instruction {
Self::Mv { dest, src } => write!(f, "mv {dest:?}, {src:?}"),
Self::La { dest, src } => write!(f, "la {dest:?}, {src:?}"),
Self::Ld { dest, offset, base } => write!(f, "ld {dest:?}, {offset}({base:?})"),
Self::Sd { src, offset, base } => write!(f, "sd {src:?}, {offset}({base:?})"),
Self::Add { dest, src1, src2 } => write!(f, "add {dest:?}, {src1:?}, {src2:?}"),
}
}
}

3
src/ir/lower/func.rs
View File

@@ -9,6 +9,7 @@ pub struct IRLFunction {
pub instructions: Vec<IRLInstruction>,
pub stack: HashMap<VarID, Size>,
pub args: Vec<(VarID, Size)>,
pub ret_size: Size,
pub makes_call: bool,
}
@@ -34,7 +35,7 @@ pub enum IRLInstruction {
len: Len,
},
Call {
dest: VarID,
dest: Option<(VarID, Size)>,
f: Symbol,
args: Vec<(VarID, Size)>,
},

9
src/ir/lower/program.rs
View File

@@ -106,8 +106,14 @@ impl IRLProgram {
makes_call = true;
let fid = &p.fn_map[&f.id];
let sym = builder.func(fid);
let ret_size = p.size_of_var(dest.id).expect("unsized type");
let dest = if ret_size > 0 {
Some((dest.id, ret_size))
} else {
None
};
instrs.push(IRLInstruction::Call {
dest: dest.id,
dest,
f: sym,
args: args
.iter()
@@ -135,6 +141,7 @@ impl IRLProgram {
.iter()
.map(|a| (*a, p.size_of_var(*a).expect("unsized type")))
.collect(),
ret_size: p.size_of_type(&f.ret).expect("unsized type"),
stack,
},
);

6
src/ir/upper/func.rs
View File

@@ -1,11 +1,12 @@
use std::fmt::Write;
use super::{arch::riscv64::RV64Instruction, inst::VarInst, DataID, FnID, IRUInstrInst, VarID};
use super::{arch::riscv64::RV64Instruction, inst::VarInst, DataID, FnID, IRUInstrInst, Type, VarID};
use crate::{common::FileSpan, compiler::arch::riscv64::Reg, util::Padder};
pub struct IRUFunction {
pub name: String,
pub args: Vec<VarID>,
pub ret: Type,
pub instructions: Vec<IRUInstrInst>,
}
@@ -49,9 +50,10 @@ pub struct IRInstructions {
}
impl IRUFunction {
pub fn new(name: String, args: Vec<VarID>, instructions: IRInstructions) -> Self {
pub fn new(name: String, args: Vec<VarID>, ret: Type, instructions: IRInstructions) -> Self {
Self {
name,
ret,
args,
instructions: instructions.vec,
}

15
src/ir/upper/validate.rs
View File

@@ -1,11 +1,11 @@
// TODO: move this into ir, not parser
use super::{IRUProgram, Type};
use crate::common::CompilerOutput;
use crate::common::{CompilerMsg, CompilerOutput};
impl IRUProgram {
pub fn validate(&self) -> CompilerOutput {
let mut output = CompilerOutput::new();
for f in self.fns.iter().flatten() {
for (f, fd) in self.fns.iter().flatten().zip(&self.fn_defs) {
for i in &f.instructions {
match &i.i {
super::IRUInstruction::Mv { dest, src } => {
@@ -35,6 +35,12 @@ impl IRUProgram {
todo!()
};
output.check_assign(self, ret, destty, dest.span);
if args.len() != argtys.len() {
output.err(CompilerMsg {
msg: "Wrong number of arguments to function".to_string(),
spans: vec![dest.span],
});
}
for (argv, argt) in args.iter().zip(argtys) {
let dest = self.get_var(argv.id);
output.check_assign(self, argt, &dest.ty, argv.span);
@@ -43,7 +49,10 @@ impl IRUProgram {
super::IRUInstruction::AsmBlock { instructions, args } => {
// TODO
}
super::IRUInstruction::Ret { src } => todo!(),
super::IRUInstruction::Ret { src } => {
let srcty = &self.get_var(src.id).ty;
output.check_assign(self, srcty, &fd.ret, src.span);
},
}
}
}

4
src/main.rs
View File

@@ -49,8 +49,8 @@ fn run_file(file: &str, gdb: bool) {
let output = namespace.validate();
output.write_for(&mut stdout(), file);
if output.errs.is_empty() {
let program = IRLProgram::create(&namespace);
let bin = compiler::compile(program.expect("morir"));
let program = IRLProgram::create(&namespace).expect("morir");
let bin = compiler::compile(program);
println!("compiled");
save_run(&bin, gdb);
}

22
src/parser/v3/lower/arch/riscv64.rs
View File

@@ -1,4 +1,4 @@
use super::{PAsmArg, FnLowerCtx, PIdent, Node, PInstruction};
use super::{FnLowerCtx, Node, PAsmArg, PIdent, PInstruction};
use crate::{
compiler::arch::riscv64::*,
ir::{
@@ -40,6 +40,16 @@ impl RV64Instruction {
let base = RegRef::from_arg(base, ctx)?;
Self::Ld { dest, offset, base }
}
"sd" => {
let [src, offset, base] = args else {
ctx.err("sd requires 3 arguments".to_string());
return None;
};
let src = RegRef::from_arg(src, ctx)?;
let offset = i64_from_arg(offset, ctx)?;
let base = RegRef::from_arg(base, ctx)?;
Self::Sd { src, offset, base }
}
"mv" => {
let [dest, src] = args else {
ctx.err("la requires 2 arguments".to_string());
@@ -49,6 +59,16 @@ impl RV64Instruction {
let src = RegRef::from_arg(src, ctx)?;
Self::Mv { dest, src }
}
"add" => {
let [dest, src1, src2] = args else {
ctx.err("add requires 3 arguments".to_string());
return None;
};
let dest = RegRef::from_arg(dest, ctx)?;
let src1 = RegRef::from_arg(src1, ctx)?;
let src2 = RegRef::from_arg(src2, ctx)?;
Self::Add { dest, src1, src2 }
}
w => {
ctx.err_at(inst.op.span, format!("Unknown instruction '{}'", w));
return None;

2
src/parser/v3/lower/func.rs
View File

@@ -73,7 +73,7 @@ impl PFunction {
if let Some(src) = self.body.lower(&mut ctx) {
instructions.push(IRUInstruction::Ret { src }, src.span);
}
IRUFunction::new(def.name.clone(), args, instructions)
IRUFunction::new(def.name.clone(), args, def.ret, instructions)
}
}