Stack overflow issue in rust when making a simple VM - rust

Question

I have come to you guys today with an error I cannot seem to fix sadly.
First let me explain what I'm trying to do. I am writing a little VM in Rust. I have just finished writing the bare minimum for the VM as you can tell by how unfinished the code is. I have made a system where you can load the program into a certain spot in memory so you can jump to that spot for subroutines later on. The run function in the Arcate struct runs whatever operation is on 0x0000.
As you can also see I have gone with using a databuss just so I can use external memory devices like creating another ArcateMemory struct as a different "drive".
It seems I am getting a stack overflow but since Rust has the best stack overflow messages all I am getting is that it is in main.
Thanks again for your help. Sorry if it is a stupid mistake I'm a little new to Rust.
main.rs
#![allow(dead_code)]
type Instr = u8;
type Program = Vec<Instr>;
#[derive(PartialEq, Eq)]
enum Signals {
BusWrite,
BusRead,
ErrNoInstruction,
Success,
Halt,
}
struct Arcate {
mem : ArcateMem,
ci: Instr,
pc: i32,
acr: i32,
gp1: i32,
gp2: i32,
gp3: i32,
gp4: i32,
gp5: i32,
gp6: i32,
gp7: i32,
gp8: i32,
}
impl Arcate {
fn new(memory: ArcateMem) -> Self {
Arcate {
mem: memory,
ci: 0,
pc: 0,
acr: 0,
gp1: 0,
gp2: 0,
gp3: 0,
gp4: 0,
gp5: 0,
gp6: 0,
gp7: 0,
gp8: 0,
}
}
fn fetchi(&mut self) {
let i: Instr = ArcateBus {data: 0, addr: self.pc, todo: Signals::BusRead, mem: self.mem}.exec();
self.ci = i;
self.pc += 1;
}
fn fetcha(&mut self) -> Instr{
let i: Instr = ArcateBus {data: 0, addr: self.pc, todo: Signals::BusRead, mem: self.mem}.exec();
self.pc += 1;
i
}
fn getr(&mut self, reg: Instr) -> i32 {
match reg {
0x01 => { self.ci as i32},
0x02 => { self.pc },
0x03 => { self.acr },
0x04 => { self.gp1 },
0x05 => { self.gp2 },
0x06 => { self.gp3 },
0x07 => { self.gp4 },
0x08 => { self.gp5 },
0x09 => { self.gp6 },
0x0a => { self.gp7 },
0x0b => { self.gp8 },
_ => { panic!("Register not found {}", reg) }
}
}
fn setr(&mut self, reg: Instr, val: i32) {
match reg {
0x01 => { self.ci = val as u8 },
0x02 => { self.pc = val },
0x03 => { self.acr = val },
0x04 => { self.gp1 = val },
0x05 => { self.gp2 = val },
0x06 => { self.gp3 = val },
0x07 => { self.gp4 = val },
0x08 => { self.gp5 = val },
0x09 => { self.gp6 = val },
0x0a => { self.gp7 = val },
0x0b => { self.gp8 = val },
_ => { panic!("Register not found {}", reg) }
}
}
fn dbg(&mut self, regs: bool, mem: bool) {
if regs {
println!("ci : {}", self.ci );
println!("pc : {}", self.pc );
println!("acr: {}", self.acr);
println!("gp1: {}", self.gp1);
println!("gp2: {}", self.gp2);
println!("gp3: {}", self.gp3);
println!("gp4: {}", self.gp4);
println!("gp5: {}", self.gp5);
println!("gp6: {}", self.gp6);
println!("gp7: {}", self.gp7);
println!("gp8: {}\n", self.gp8);
}
}
fn exec(&mut self) -> Signals {
match self.ci {
// 01: 2 args. movir imm, reg
0x01 => {
let imm1 = self.fetcha();
let imm2 = self.fetcha();
let imm = ((imm1 as i32) << 8) + imm2 as i32;
let reg = self.fetcha();
self.setr(reg, imm);
Signals::Success
}
// 02: 2 args. movrr reg, reg
0x02 => {
let regf = self.fetcha();
let regt = self.fetcha();
let regv = self.getr(regf);
self.setr(regt, regv);
Signals::Success
}
// 03: 2 args. movrm reg, mem
// 04: 2 args. movim imm, mem
// 05: 2 args. addrr reg, reg
0x05 => {
let rego = self.fetcha();
let regt = self.fetcha();
let regov = self.getr(rego);
let regtv = self.getr(regt);
self.acr = regov + regtv;
Signals::Success
}
// 06: 2 args. addir imm, reg
// ff: 0 args. halt
0xff => {
Signals::Halt
}
_ => {
Signals::ErrNoInstruction
}
}
}
fn load(&mut self, prog: Program, loc: usize) {
let mut ld = 0;
for i in loc..prog.len() {
self.mem.mem[i] = prog[ld];
println!("{:2x} -> {:12x}", prog[ld], i);
ld += 1;
}
}
fn run(&mut self, dbgR: bool) {
let mut sig: Signals = Signals::Success;
self.dbg(dbgR, false);
while sig == Signals::Success {
self.fetchi();
sig = self.exec();
self.dbg(dbgR, false);
}
}
}
struct ArcateBus {
data: Instr,
addr: i32,
todo: Signals,
mem : ArcateMem,
}
impl ArcateBus {
fn exec(&mut self) -> Instr {
if self.todo == Signals::BusWrite {
self.mem.mem[self.addr as usize] = self.data;
0x00
} else if self.todo == Signals::BusRead {
self.mem.mem[self.addr as usize]
}else {
0xFF
}
}
}
#[derive(Copy, Clone)]
struct ArcateMem {
mem: [Instr; 0xFFFF*0xFFFF],
}
impl ArcateMem {
fn new() -> Self {
ArcateMem {
mem: [0; 0xFFFF*0xFFFF],
}
}
}
fn main() {
let mem: ArcateMem = ArcateMem::new();
let mut arc: Arcate = Arcate::new(mem);
let prog = vec![
0x01, 0xfe, 0xfe, 0x04,
0x01, 0x01, 0x01, 0x05,
0x05, 0x04, 0x05,
0xff,
];
arc.load(prog, 0x0000);
arc.run(true);
}

Answer 1

I think the issue is around ArcateMem, you are allocating 0xFFFF*0xFFFF Instr, which is about 4GB. With the way the code is written right now, you are allocating this on the stack, which generally can't support allocations this large. You'll probably want to use Box<> to allocate your memory in the heap, as it is more likely able to deal with allocations this large.
It's possible you could configure your operating system to increase your stack size, but I'd recommend using the heap.