r55-eth
diff --git a/‎src/cpu.rs‎
Lines changed: 10 additions & 12 deletions b/‎src/cpu.rs‎
Lines changed: 10 additions & 12 deletions
@@ -634,19 +634,20 @@ impl Cpu {
                     // Unimplemented instruction, since all bits are 0.
                     return Err(Exception::IllegalInstruction);
                 }
-                inst = self.execute_compressed()?
+                inst = inst16;
+                self.execute_compressed(inst16)?
+            }
+            _ => {
+                inst = self.fetch(WORD)?;
+                self.execute_general(inst)?
             }
-            _ => inst = self.execute_general()?,
         }
         Ok(inst)
     }
 
     /// Execute a compressed instruction. Raised an exception if something is wrong, otherwise,
     /// returns a fetched instruction. It also increments the program counter by 2 bytes.
-    pub fn execute_compressed(&mut self) -> Result<u64, Exception> {
-        // 1. Fetch.
-        let inst = self.fetch(HALFWORD)?;
-
+    pub fn execute_compressed(&mut self, inst: u64) -> Result<(), Exception> {
         // Add 2 bytes to the program counter.
         self.pc += 2;
 
@@ -1226,15 +1227,12 @@ impl Cpu {
                 return Err(Exception::IllegalInstruction);
             }
         }
-        Ok(inst)
+        Ok(())
     }
 
     /// Execute a general-purpose instruction. Raises an exception if something is wrong,
     /// otherwise, returns a fetched instruction. It also increments the program counter by 4 bytes.
-    fn execute_general(&mut self) -> Result<u64, Exception> {
-        // 1. Fetch.
-        let inst = self.fetch(WORD)?;
-
+    fn execute_general(&mut self, inst: u64) -> Result<(), Exception> {
         // Add 4 bytes to the program counter.
         self.pc += 4;
 
@@ -3323,6 +3321,6 @@ impl Cpu {
                 return Err(Exception::IllegalInstruction);
             }
         }
-        Ok(inst)
+        Ok(())
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -634,19 +634,20 @@ impl Cpu {`
`634`	`634`	`// Unimplemented instruction, since all bits are 0.`
`635`	`635`	`return Err(Exception::IllegalInstruction);`
`636`	`636`	`}`
`637`		`- inst = self.execute_compressed()?`
	`637`	`+ inst = inst16;`
	`638`	`+ self.execute_compressed(inst16)?`
	`639`	`+ }`
	`640`	`+ _ => {`
	`641`	`+ inst = self.fetch(WORD)?;`
	`642`	`+ self.execute_general(inst)?`
`638`	`643`	`}`
`639`		`- _ => inst = self.execute_general()?,`
`640`	`644`	`}`
`641`	`645`	`Ok(inst)`
`642`	`646`	`}`
`643`	`647`
`644`	`648`	`/// Execute a compressed instruction. Raised an exception if something is wrong, otherwise,`
`645`	`649`	`/// returns a fetched instruction. It also increments the program counter by 2 bytes.`
`646`		`- pub fn execute_compressed(&mut self) -> Result<u64, Exception> {`
`647`		`- // 1. Fetch.`
`648`		`- let inst = self.fetch(HALFWORD)?;`
`649`		`-`
	`650`	`+ pub fn execute_compressed(&mut self, inst: u64) -> Result<(), Exception> {`
`650`	`651`	`// Add 2 bytes to the program counter.`
`651`	`652`	`self.pc += 2;`
`652`	`653`
`@@ -1226,15 +1227,12 @@ impl Cpu {`
`1226`	`1227`	`return Err(Exception::IllegalInstruction);`
`1227`	`1228`	`}`
`1228`	`1229`	`}`
`1229`		`- Ok(inst)`
	`1230`	`+ Ok(())`
`1230`	`1231`	`}`
`1231`	`1232`
`1232`	`1233`	`/// Execute a general-purpose instruction. Raises an exception if something is wrong,`
`1233`	`1234`	`/// otherwise, returns a fetched instruction. It also increments the program counter by 4 bytes.`
`1234`		`- fn execute_general(&mut self) -> Result<u64, Exception> {`
`1235`		`- // 1. Fetch.`
`1236`		`- let inst = self.fetch(WORD)?;`
`1237`		`-`
	`1235`	`+ fn execute_general(&mut self, inst: u64) -> Result<(), Exception> {`
`1238`	`1236`	`// Add 4 bytes to the program counter.`
`1239`	`1237`	`self.pc += 4;`
`1240`	`1238`
`@@ -3323,6 +3321,6 @@ impl Cpu {`
`3323`	`3321`	`return Err(Exception::IllegalInstruction);`
`3324`	`3322`	`}`
`3325`	`3323`	`}`
`3326`		`- Ok(inst)`
	`3324`	`+ Ok(())`
`3327`	`3325`	`}`
`3328`	`3326`	`}`