Add launch argument parser, add debug parameter to machine

burritos now launch binary

src/simulator/loader.rs

@@ -612,7 +612,7 @@ mod test {
 
     #[test]
     fn test_parse_elf() {
-        let mut machine = Machine::default();
+        let mut machine = Machine::new(true);
         let loader = Loader::load_and_parse("./target/guac/unsigned_addition.guac").expect("IO Error");
         loader.load_into_machine(&mut machine, 0).expect("Parsing error");
         assert!(!loader.elf_header.is_32bits);
@@ -633,7 +633,7 @@ mod test {
 
     #[test]
     fn test_parse_section() {
-        let mut machine = Machine::default();
+        let mut machine = Machine::new(true);
         let loader = Loader::load_and_parse("./target/guac/unsigned_addition.guac").expect("IO Error");
         loader.load_into_machine(&mut machine, 0).expect("Parsing error");
         assert_eq!(9, loader.sections.len());

src/simulator/machine.rs

@@ -80,6 +80,8 @@ pub const MEM_SIZE : usize = (PAGE_SIZE*NUM_PHY_PAGE*100_000) as usize;
 
 /// RISC-V Simulator
 pub struct Machine {
+	/// Debug mode of the machine
+	debug: bool,
 	/// Program counter
 	pub pc : u64,
 	/// Stack pointer
@@ -107,9 +109,28 @@ pub struct Machine {
 impl Machine {
 
 	/// Machine constructor
-	#[deprecated]
-	pub fn init_machine() -> Machine {	
-		Self::default()
+	pub fn new(debug: bool) -> Self {
+		let mut shiftmask : [u64 ; 64] = [0 ; 64];
+		let mut value : u64 = 0xffffffff;
+
+		value = (value << 32) + value;
+		for item in &mut shiftmask {
+			*item = value;
+			value >>= 1;
+		}
+
+		Machine {
+			debug,
+			pc : 0,
+			sp: 0,
+			int_reg : { let mut r = Register::<i64>::init(); r.set_reg(10, -1); r },
+			fp_reg : Register::<f32>::init(),
+			main_memory : vec![0_u8; MEM_SIZE],
+			shiftmask,
+			interrupt: Interrupt::new(),
+			registers_trace : String::from(""),
+			status: MachineStatus::SystemMode
+		}
 	}
 
 	/// Read from main memory of the machine
@@ -189,10 +210,8 @@ impl Machine {
 			println!();
 		}
 		println!("________________SP________________");
-		let sp_index = self.int_reg.get_reg(2);
-		/* for i in 0..5 {
-			println!("SP+{:<2} : {:16x}", i*8, self.read_memory(8, (sp_index + i*8) as usize));
-		} */		
+		let sp = self.int_reg.get_reg(2);
+		println!("SP: {:16x}", self.read_memory(8, sp as usize));	
 		println!("##################################");
 	}
 
@@ -267,11 +286,13 @@ impl Machine {
 		
 		let val = u32::from_be_bytes(val) as u64;
 		let inst : Instruction = Instruction::new(val);
-		self.print_status();
-		println!("executing instruction : {:016x} at pc {:x}", val, self.pc);
-		println!("{}", instruction::instruction_debug(&inst, self.pc as i32));
-		let trace = Self::string_registers(self);
-		self.registers_trace.push_str(format!("{}\n", trace).as_str());
+		if self.debug {
+			self.print_status();
+			println!("executing instruction : {:016x} at pc {:x}", val, self.pc);
+			println!("{}", instruction::instruction_debug(&inst, self.pc as i32));
+			let trace = Self::string_registers(self);
+			self.registers_trace.push_str(format!("{}\n", trace).as_str());
+		}
 		
 		self.pc += 4;
 		
@@ -680,42 +701,12 @@ impl Machine {
 	}
 }
 
-impl Default for Machine {
-	/// Machine constructor
-    fn default() -> Self {
-        let mut shiftmask : [u64 ; 64] = [0 ; 64];
-		let mut value : u64 = 0xffffffff;
-
-		value = (value << 32) + value;
-		for item in &mut shiftmask {
-			*item = value;
-			value >>= 1;
-		}
-
-		Machine {
-			pc : 0,
-			sp: 0,
-			int_reg : { let mut r = Register::<i64>::init(); r.set_reg(10, -1); r },
-			fp_reg : Register::<f32>::init(),
-			main_memory : vec![0_u8; MEM_SIZE],
-			shiftmask,
-			interrupt: Interrupt::new(),
-			registers_trace : String::from(""),
-			status: MachineStatus::SystemMode
-		}
-    }
-}
-
 #[cfg(test)]
 
 mod test {
     use std::fs;
 
     use crate::simulator::{machine::Machine, mem_cmp};
-	use crate::kernel::thread::Thread;
-	use crate::kernel::process::Process;
-	use std::rc::Rc;
-	use std::cell::RefCell;
 
 	macro_rules! get_full_path {
 		($prefix: expr, $test_name:expr) => {{
@@ -729,7 +720,7 @@ mod test {
 
 	macro_rules! init_test {
 		($a:expr) => {{
-			let mut m = Machine::init_machine();
+			let mut m = Machine::new(true);
 			let end_file_name = { let mut s = String::from($a); s.push_str("End"); s };
 			let memory_before = mem_cmp::MemChecker::from(get_full_path!("memory", $a)).unwrap();
 			let memory_after = mem_cmp::MemChecker::from(get_full_path!("memory", &end_file_name)).unwrap();
@@ -744,12 +735,12 @@ mod test {
 
 	#[test]
 	fn test_init_machine() {
-		let _ = Machine::init_machine();
+		let _ = Machine::new(true);
 	}
 
 	#[test]
 	fn test_read_memory() {
-		let mut m = Machine::init_machine();
+		let mut m = Machine::new(true);
     	m.main_memory[4] = 43;
     	m.main_memory[5] = 150;
 		assert_eq!((43 << 8) + 150, m.read_memory(2, 4));
@@ -757,7 +748,7 @@ mod test {
 
 	#[test]
 	fn test_write_memory() {
-		let mut m = Machine::init_machine();
+		let mut m = Machine::new(true);
 		m.write_memory(2, 6, (43 << 8) + 150);
 		assert_eq!(43, m.main_memory[6]);
 		assert_eq!(150, m.main_memory[7]);

src/simulator/mem_cmp.rs

@@ -211,7 +211,7 @@ mod tests {
     #[test]
     fn test_fill_memory(){
         let m_c = MemChecker::from("test/machine/memoryAdd.txt").unwrap();
-        let mut machine = Machine::init_machine();
+        let mut machine = Machine::new(true);
         MemChecker::fill_memory_from_mem_checker(&m_c, &mut machine);
         MemChecker::compare_print_m_c_machine(&m_c, &mut machine);
     }