add8 adc did not work

Author: brandonros

src/emu/flags.rs

@@ -395,26 +395,18 @@ impl Flags {
         result as u64
     }
 
-    pub fn add8(&mut self, value1: u64, value2: u64, input_cf: bool) -> u64 {
-        // Do full addition including carry
-        let result = (value1 as u8).wrapping_add(value2 as u8).wrapping_add(if input_cf { 1 } else { 0 });
-        
-        // Check carry by doing additions step by step
-        let (temp, first_carry) = (value2 as u8).overflowing_add(value1 as u8);
-        let (_, second_carry) = temp.overflowing_add(if input_cf { 1 } else { 0 });
-        self.f_cf = first_carry || second_carry;
-        
-        // Similar for overflow
-        let (temp_s, first_overflow) = (value2 as u8 as i8).overflowing_add(value1 as u8 as i8);
-        let (_, second_overflow) = temp_s.overflowing_add(if input_cf { 1 } else { 0 });
-        self.f_of = first_overflow || second_overflow;
-    
-        // Rest of flags based on final result
-        self.f_sf = (result as i8) < 0;
-        self.f_zf = result == 0;
-        self.calc_pf(result);
+    pub fn add8(&mut self, value1: u64, value2: u64) -> u64 {
+        let unsigned: u16 = value1 as u8 as u16 + value2 as u8 as u16;
+
+        self.f_sf = (unsigned as i8) < 0;
+        self.f_zf = (unsigned & 0xff) == 0;
+        self.calc_pf(unsigned as u8);
+        let (result, carry) = (value2 as u8).overflowing_add(value1 as u8);
+        let (_, overflow) = (value2 as u8 as i8).overflowing_add(value1 as u8 as i8);
+        self.f_of = overflow;
+        self.f_cf = carry;
         self.calc_af(value1, value2, result as u64, 8);
-    
+
         result as u64
     }
 

src/emu/mod.rs

@@ -5128,10 +5128,10 @@ impl Emu {
                 };
 
                 let res: u64 = match self.get_operand_sz(&ins, 1) {
-                    64 => self.flags.add64(value0, value1), // TODO: cf as separate argument
-                    32 => self.flags.add32(value0, value1), // TODO: cf as separate argument
-                    16 => self.flags.add16(value0, value1), // TODO: cf as separate argument
-                    8 => self.flags.add8(value0, value1, self.flags.f_cf),
+                    64 => self.flags.add64(value0, value1),
+                    32 => self.flags.add32(value0, value1),
+                    16 => self.flags.add16(value0, value1),
+                    8 => self.flags.add8(value0, value1),
                     _ => unreachable!("weird size"),
                 };
 
@@ -5142,37 +5142,35 @@ impl Emu {
 
             Mnemonic::Adc => {
                 self.show_instruction(&self.colors.cyan, &ins);
-            
+
                 assert!(ins.op_count() == 2);
-            
-                // Get current carry flag value
-                let cf = if self.flags.f_cf { 1 } else { 0 };
-            
-                // Get the size first to ensure consistent handling
-                let size = self.get_operand_sz(&ins, 1);
-                
-                // Get destination value (first operand)
-                let dest = match self.get_operand_value(&ins, 0, true) {
+
+                let cf: u64;
+                if self.flags.f_cf {
+                    cf = 1
+                } else {
+                    cf = 0;
+                }
+
+                let value0 = match self.get_operand_value(&ins, 0, true) {
                     Some(v) => v,
                     None => return false,
                 };
-            
-                // Get source value (second operand)  
-                let src = match self.get_operand_value(&ins, 1, true) {
+
+                let value1 = match self.get_operand_value(&ins, 1, true) {
                     Some(v) => v,
                     None => return false,
                 };
-            
-                // Do the addition with carry
-                let res = match size {
-                    64 => self.flags.add64(dest, src + cf), // TODO: cf as separate argument
-                    32 => self.flags.add32(dest, src + cf), // TODO: cf as separate argument
-                    16 => self.flags.add16(dest, src + cf), // TODO: cf as separate argument
-                    8 => self.flags.add8(dest, src, self.flags.f_cf),
+
+                let res: u64;
+                match self.get_operand_sz(&ins, 1) {
+                    64 => res = self.flags.add64(value0, value1 + cf),
+                    32 => res = self.flags.add32(value0, value1 + cf),
+                    16 => res = self.flags.add16(value0, value1 + cf),
+                    8 => res = self.flags.add8(value0, value1 + cf),
                     _ => unreachable!("weird size"),
-                };
-            
-                // Set the result
+                }
+
                 if !self.set_operand_value(&ins, 0, res) {
                     return false;
                 }
@@ -6588,10 +6586,10 @@ impl Emu {
                 }
 
                 let res: u64 = match self.get_operand_sz(&ins, 1) {
-                    64 => self.flags.add64(value0, value1), // TODO: cf as separate argument
-                    32 => self.flags.add32(value0, value1), // TODO: cf as separate argument
-                    16 => self.flags.add16(value0, value1), // TODO: cf as separate argument
-                    8 => self.flags.add8(value0, value1, self.flags.f_cf),
+                    64 => self.flags.add64(value0, value1),
+                    32 => self.flags.add32(value0, value1),
+                    16 => self.flags.add16(value0, value1),
+                    8 => self.flags.add8(value0, value1),
                     _ => unreachable!("weird size"),
                 };