Use {read,write}_reg16

src/rust/cpu2/arith.rs

@@ -135,7 +135,7 @@ pub unsafe fn neg32(x: i32) -> i32 { return neg(x, OPSIZE_32); }
 #[no_mangle]
 pub unsafe fn mul8(source_operand: i32) {
     let result = source_operand * *reg8.offset(AL as isize) as i32;
-    *reg16.offset(AX as isize) = result as u16;
+    write_reg16(AX, result);
     *last_result = result & 255;
     *last_op_size = OPSIZE_8;
     if result < 256 {
@@ -149,7 +149,7 @@ pub unsafe fn mul8(source_operand: i32) {
 #[no_mangle]
 pub unsafe fn imul8(source_operand: i32) {
     let result = source_operand * *reg8s.offset(AL as isize) as i32;
-    *reg16.offset(AX as isize) = result as u16;
+    write_reg16(AX, result);
     *last_result = result & 255;
     *last_op_size = OPSIZE_8;
     if result > 127 || result < -128 {
@@ -162,10 +162,10 @@ pub unsafe fn imul8(source_operand: i32) {
 }
 #[no_mangle]
 pub unsafe fn mul16(source_operand: u32) {
-    let result = source_operand.wrapping_mul(*reg16.offset(AX as isize) as u32);
+    let result = source_operand.wrapping_mul(read_reg16(AX) as u32);
     let high_result = result >> 16;
-    *reg16.offset(AX as isize) = result as u16;
-    *reg16.offset(DX as isize) = high_result as u16;
+    write_reg16(AX, result as i32);
+    write_reg16(DX, high_result as i32);
     *last_result = (result & 0xFFFF) as i32;
     *last_op_size = OPSIZE_16;
     if high_result == 0 {
@@ -178,9 +178,9 @@ pub unsafe fn mul16(source_operand: u32) {
 }
 #[no_mangle]
 pub unsafe fn imul16(source_operand: i32) {
-    let result = source_operand * *reg16s.offset(AX as isize) as i32;
-    *reg16.offset(AX as isize) = result as u16;
-    *reg16.offset(DX as isize) = (result >> 16) as u16;
+    let result = source_operand * (read_reg16(AX) << 16 >> 16);
+    write_reg16(AX, result);
+    write_reg16(DX, result >> 16);
     *last_result = result & 0xFFFF;
     *last_op_size = OPSIZE_16;
     if result > 32767 || result < -32768 {
@@ -292,12 +292,12 @@ pub unsafe fn cmpxchg8(data: i32, r: i32) -> i32 {
 }
 #[no_mangle]
 pub unsafe fn cmpxchg16(data: i32, r: i32) -> i32 {
-    cmp16(*reg16.offset(AX as isize) as i32, data);
+    cmp16(read_reg16(AX), data);
     if getzf() {
         read_reg16(r)
     }
     else {
-        *reg16.offset(AX as isize) = data as u16;
+        write_reg16(AX, data);
         data
     }
 }
@@ -356,7 +356,7 @@ pub unsafe fn bcd_das() {
 pub unsafe fn bcd_aad(imm8: i32) {
     let result = *reg8.offset(AL as isize) as i32 + *reg8.offset(AH as isize) as i32 * imm8;
     *last_result = result & 255;
-    *reg16.offset(AX as isize) = *last_result as u16;
+    write_reg16(AX, *last_result);
     *last_op_size = OPSIZE_8;
     *flags_changed = FLAGS_ALL & !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
     *flags &= !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
@@ -382,7 +382,7 @@ pub unsafe fn bcd_aam(imm8: i32) {
 #[no_mangle]
 pub unsafe fn bcd_aaa() {
     if *reg8.offset(AL as isize) as i32 & 15 > 9 || getaf() {
-        *reg16.offset(AX as isize) += 6;
+        write_reg16(AX, read_reg16(AX) + 6);
         *reg8.offset(AH as isize) += 1;
         *flags |= FLAG_ADJUST | 1
     }
@@ -395,7 +395,7 @@ pub unsafe fn bcd_aaa() {
 #[no_mangle]
 pub unsafe fn bcd_aas() {
     if *reg8.offset(AL as isize) as i32 & 15 > 9 || getaf() {
-        *reg16.offset(AX as isize) -= 6;
+        write_reg16(AX, read_reg16(AX) - 6);
         *reg8.offset(AH as isize) -= 1;
         *flags |= FLAG_ADJUST | 1
     }
@@ -662,7 +662,7 @@ pub unsafe fn div8(source_operand: u32) {
         return;
     }
     else {
-        let target_operand = *reg16.offset(AX as isize);
+        let target_operand = read_reg16(AX);
         let result = (target_operand as u32).wrapping_div(source_operand) as u16;
         if result as i32 >= 256 {
             trigger_de();
@@ -682,7 +682,7 @@ pub unsafe fn idiv8(source_operand: i32) {
         return;
     }
     else {
-        let target_operand = *reg16s.offset(AX as isize) as i32;
+        let target_operand = read_reg16(AX) << 16 >> 16;
         let result = target_operand / source_operand;
         if result >= 128 || result <= -129 {
             trigger_de();
@@ -700,14 +700,13 @@ pub unsafe fn div16_without_fault(source_operand: u32) -> bool {
     if source_operand == 0 {
         return false;
     }
-    let target_operand =
-        (*reg16.offset(AX as isize) as i32 | (*reg16.offset(DX as isize) as i32) << 16) as u32;
+    let target_operand = (read_reg16(AX) | read_reg16(DX) << 16) as u32;
     let result = target_operand.wrapping_div(source_operand);
     if result >= 0x10000 {
         return false;
     }
-    *reg16.offset(AX as isize) = result as u16;
-    *reg16.offset(DX as isize) = target_operand.wrapping_rem(source_operand) as u16;
+    write_reg16(AX, result as i32);
+    write_reg16(DX, target_operand.wrapping_rem(source_operand) as i32);
     return true;
 }
 pub unsafe fn div16(source_operand: u32) {
@@ -720,14 +719,13 @@ pub unsafe fn idiv16_without_fault(source_operand: i32) -> bool {
     if source_operand == 0 {
         return false;
     }
-    let target_operand =
-        *reg16.offset(AX as isize) as i32 | (*reg16.offset(DX as isize) as i32) << 16;
+    let target_operand = read_reg16(AX) | read_reg16(DX) << 16;
     let result = target_operand / source_operand;
     if result >= 32768 || result <= -32769 {
         return false;
     }
-    *reg16.offset(AX as isize) = result as u16;
-    *reg16.offset(DX as isize) = (target_operand % source_operand) as u16;
+    write_reg16(AX, result);
+    write_reg16(DX, (target_operand % source_operand) as i32);
     return true;
 }
 pub unsafe fn idiv16(source_operand: i32) {

src/rust/cpu2/cpu.rs

@@ -114,6 +114,7 @@ pub const FLAGS_ALL: i32 =
 pub const OPSIZE_8: i32 = 7;
 pub const OPSIZE_16: i32 = 15;
 pub const OPSIZE_32: i32 = 31;
+
 pub const EAX: i32 = 0;
 pub const ECX: i32 = 1;
 pub const EDX: i32 = 2;
@@ -122,14 +123,16 @@ pub const ESP: i32 = 4;
 pub const EBP: i32 = 5;
 pub const ESI: i32 = 6;
 pub const EDI: i32 = 7;
+
 pub const AX: i32 = 0;
-pub const CX: i32 = 2;
-pub const DX: i32 = 4;
-pub const BX: i32 = 6;
-pub const SP: i32 = 8;
-pub const BP: i32 = 10;
-pub const SI: i32 = 12;
-pub const DI: i32 = 14;
+pub const CX: i32 = 1;
+pub const DX: i32 = 2;
+pub const BX: i32 = 3;
+pub const SP: i32 = 4;
+pub const BP: i32 = 5;
+pub const SI: i32 = 6;
+pub const DI: i32 = 7;
+
 pub const AL: i32 = 0;
 pub const CL: i32 = 4;
 pub const DL: i32 = 8;
@@ -138,6 +141,7 @@ pub const AH: i32 = 1;
 pub const CH: i32 = 5;
 pub const DH: i32 = 9;
 pub const BH: i32 = 13;
+
 pub const ES: i32 = 0;
 pub const CS: i32 = 1;
 pub const SS: i32 = 2;
@@ -145,6 +149,7 @@ pub const DS: i32 = 3;
 pub const FS: i32 = 4;
 pub const GS: i32 = 5;
 pub const TR: i32 = 6;
+
 pub const LDTR: i32 = 7;
 pub const PAGE_TABLE_PRESENT_MASK: i32 = 1 << 0;
 pub const PAGE_TABLE_RW_MASK: i32 = 1 << 1;
@@ -2267,14 +2272,14 @@ pub unsafe fn popa16() {
     return_on_pagefault!(translate_address_read(get_stack_pointer(0)));
     return_on_pagefault!(translate_address_read(get_stack_pointer(15)));
 
-    *reg16.offset(DI as isize) = pop16().unwrap() as u16;
-    *reg16.offset(SI as isize) = pop16().unwrap() as u16;
-    *reg16.offset(BP as isize) = pop16().unwrap() as u16;
+    write_reg16(DI, pop16().unwrap());
+    write_reg16(SI, pop16().unwrap());
+    write_reg16(BP, pop16().unwrap());
     adjust_stack_reg(2);
-    *reg16.offset(BX as isize) = pop16().unwrap() as u16;
-    *reg16.offset(DX as isize) = pop16().unwrap() as u16;
-    *reg16.offset(CX as isize) = pop16().unwrap() as u16;
-    *reg16.offset(AX as isize) = pop16().unwrap() as u16;
+    write_reg16(BX, pop16().unwrap());
+    write_reg16(DX, pop16().unwrap());
+    write_reg16(CX, pop16().unwrap());
+    write_reg16(AX, pop16().unwrap());
 }
 
 pub unsafe fn popa32() {
@@ -3088,26 +3093,36 @@ pub unsafe fn safe_write128(addr: i32, value: reg128) -> OrPageFault<()> {
 pub fn get_reg8_index(index: i32) -> i32 { return index << 2 & 12 | index >> 2 & 1; }
 
 pub unsafe fn read_reg8(index: i32) -> i32 {
+    dbg_assert!(index >= 0 && index < 8);
     return *reg8.offset(get_reg8_index(index) as isize) as i32;
 }
 
 pub unsafe fn write_reg8(index: i32, value: i32) {
+    dbg_assert!(index >= 0 && index < 8);
     *reg8.offset(get_reg8_index(index) as isize) = value as u8;
 }
 
 pub fn get_reg16_index(index: i32) -> i32 { return index << 1; }
 
 pub unsafe fn read_reg16(index: i32) -> i32 {
+    dbg_assert!(index >= 0 && index < 8);
     return *reg16.offset(get_reg16_index(index) as isize) as i32;
 }
 
 pub unsafe fn write_reg16(index: i32, value: i32) {
+    dbg_assert!(index >= 0 && index < 8);
     *reg16.offset(get_reg16_index(index) as isize) = value as u16;
 }
 
-pub unsafe fn read_reg32(index: i32) -> i32 { *reg32.offset(index as isize) }
+pub unsafe fn read_reg32(index: i32) -> i32 {
+    dbg_assert!(index >= 0 && index < 8);
+    *reg32.offset(index as isize)
+}
 
-pub unsafe fn write_reg32(index: i32, value: i32) { *reg32.offset(index as isize) = value; }
+pub unsafe fn write_reg32(index: i32, value: i32) {
+    dbg_assert!(index >= 0 && index < 8);
+    *reg32.offset(index as isize) = value;
+}
 
 pub unsafe fn read_mmx32s(r: i32) -> i32 { *reg_mmx.offset(r as isize) as i32 }
 
@@ -3238,7 +3253,7 @@ pub unsafe fn get_stack_reg() -> i32 {
         return *reg32.offset(ESP as isize);
     }
     else {
-        return *reg16.offset(SP as isize) as i32;
+        return read_reg16(SP);
     };
 }
 
@@ -3248,7 +3263,7 @@ pub unsafe fn set_stack_reg(value: i32) {
         *reg32.offset(ESP as isize) = value
     }
     else {
-        *reg16.offset(SP as isize) = value as u16
+        write_reg16(SP, value)
     };
 }
 
@@ -3269,7 +3284,7 @@ pub unsafe fn set_reg_asize(is_asize_32: bool, reg: i32, value: i32) {
         *reg32.offset(reg as isize) = value
     }
     else {
-        *reg16.offset((reg << 1) as isize) = value as u16
+        write_reg16(reg, value)
     };
 }
 
@@ -3279,8 +3294,8 @@ pub unsafe fn decr_ecx_asize(is_asize_32: bool) -> i32 {
         *reg32.offset(ECX as isize)
     }
     else {
-        *reg16.offset(CX as isize) -= 1;
-        *reg16.offset(CX as isize) as i32
+        write_reg16(CX, read_reg16(CX) - 1);
+        read_reg16(CX)
     };
 }
 

src/rust/cpu2/fpu.rs

@@ -533,7 +533,7 @@ pub unsafe fn fpu_fnstsw_mem(addr: i32) {
     return_on_pagefault!(safe_write16(addr, fpu_load_status_word()));
 }
 #[no_mangle]
-pub unsafe fn fpu_fnstsw_reg() { *reg16.offset(AX as isize) = fpu_load_status_word() as u16; }
+pub unsafe fn fpu_fnstsw_reg() { write_reg16(AX, fpu_load_status_word()); }
 #[no_mangle]
 pub unsafe fn fpu_fprem(ieee: bool) {
     // false: Faster, passes qemutests

src/rust/cpu2/global_pointers.rs

@@ -5,7 +5,6 @@ use cpu2::cpu::reg128;
 pub const reg8: *mut u8 = 64 as *mut u8;
 pub const reg16: *mut u16 = 64 as *mut u16;
 pub const reg8s: *mut i8 = 64 as *mut i8;
-pub const reg16s: *mut i16 = 64 as *mut i16;
 pub const reg32: *mut i32 = 64 as *mut i32;
 
 pub const last_op1: *mut i32 = 96 as *mut i32;

src/rust/cpu2/instructions.rs

@@ -60,9 +60,7 @@ pub unsafe fn instr32_03_reg(r1: i32, r: i32) {
 pub unsafe fn instr_04(imm8: i32) {
     *reg8.offset(AL as isize) = add8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_05(imm16: i32) {
-    *reg16.offset(AX as isize) = add16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_05(imm16: i32) { write_reg16(AX, add16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_05(imm32: i32) {
     *reg32.offset(EAX as isize) = add32(*reg32.offset(EAX as isize), imm32);
 }
@@ -132,9 +130,7 @@ pub unsafe fn instr32_0B_reg(r1: i32, r: i32) {
 pub unsafe fn instr_0C(imm8: i32) {
     *reg8.offset(AL as isize) = or8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_0D(imm16: i32) {
-    *reg16.offset(AX as isize) = or16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_0D(imm16: i32) { write_reg16(AX, or16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_0D(imm32: i32) {
     *reg32.offset(EAX as isize) = or32(*reg32.offset(EAX as isize), imm32);
 }
@@ -193,9 +189,7 @@ pub unsafe fn instr32_13_reg(r1: i32, r: i32) {
 pub unsafe fn instr_14(imm8: i32) {
     *reg8.offset(AL as isize) = adc8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_15(imm16: i32) {
-    *reg16.offset(AX as isize) = adc16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_15(imm16: i32) { write_reg16(AX, adc16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_15(imm32: i32) {
     *reg32.offset(EAX as isize) = adc32(*reg32.offset(EAX as isize), imm32);
 }
@@ -269,9 +263,7 @@ pub unsafe fn instr32_1B_reg(r1: i32, r: i32) {
 pub unsafe fn instr_1C(imm8: i32) {
     *reg8.offset(AL as isize) = sbb8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_1D(imm16: i32) {
-    *reg16.offset(AX as isize) = sbb16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_1D(imm16: i32) { write_reg16(AX, sbb16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_1D(imm32: i32) {
     *reg32.offset(EAX as isize) = sbb32(*reg32.offset(EAX as isize), imm32);
 }
@@ -345,9 +337,7 @@ pub unsafe fn instr32_23_reg(r1: i32, r: i32) {
 pub unsafe fn instr_24(imm8: i32) {
     *reg8.offset(AL as isize) = and8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_25(imm16: i32) {
-    *reg16.offset(AX as isize) = and16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_25(imm16: i32) { write_reg16(AX, and16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_25(imm32: i32) {
     *reg32.offset(EAX as isize) = and32(*reg32.offset(EAX as isize), imm32);
 }
@@ -401,9 +391,7 @@ pub unsafe fn instr32_2B_reg(r1: i32, r: i32) {
 pub unsafe fn instr_2C(imm8: i32) {
     *reg8.offset(AL as isize) = sub8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_2D(imm16: i32) {
-    *reg16.offset(AX as isize) = sub16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_2D(imm16: i32) { write_reg16(AX, sub16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_2D(imm32: i32) {
     *reg32.offset(EAX as isize) = sub32(*reg32.offset(EAX as isize), imm32);
 }
@@ -457,9 +445,7 @@ pub unsafe fn instr32_33_reg(r1: i32, r: i32) {
 pub unsafe fn instr_34(imm8: i32) {
     *reg8.offset(AL as isize) = xor8(*reg8.offset(AL as isize) as i32, imm8) as u8;
 }
-pub unsafe fn instr16_35(imm16: i32) {
-    *reg16.offset(AX as isize) = xor16(*reg16.offset(AX as isize) as i32, imm16) as u16;
-}
+pub unsafe fn instr16_35(imm16: i32) { write_reg16(AX, xor16(read_reg16(AX), imm16)); }
 pub unsafe fn instr32_35(imm32: i32) {
     *reg32.offset(EAX as isize) = xor32(*reg32.offset(EAX as isize), imm32);
 }
@@ -494,7 +480,7 @@ pub unsafe fn instr32_3B_mem(addr: i32, r: i32) {
 }
 pub unsafe fn instr32_3B_reg(r1: i32, r: i32) { cmp32(read_reg32(r), read_reg32(r1)); }
 pub unsafe fn instr_3C(imm8: i32) { cmp8(*reg8.offset(AL as isize) as i32, imm8); }
-pub unsafe fn instr16_3D(imm16: i32) { cmp16(*reg16.offset(AX as isize) as i32, imm16); }
+pub unsafe fn instr16_3D(imm16: i32) { cmp16(read_reg16(AX), imm16); }
 pub unsafe fn instr32_3D(imm32: i32) { cmp32(*reg32.offset(EAX as isize), imm32); }
 
 pub unsafe fn instr_3E() { segment_prefix_op(DS); }
@@ -502,73 +488,41 @@ pub unsafe fn instr_3E() { segment_prefix_op(DS); }
 #[no_mangle]
 pub unsafe fn instr_3F() { bcd_aas(); }
 
-pub unsafe fn instr16_40() {
-    *reg16.offset(AX as isize) = inc16(*reg16.offset(AX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_40() { write_reg16(AX, inc16(read_reg16(AX))); }
 pub unsafe fn instr32_40() { *reg32.offset(EAX as isize) = inc32(*reg32.offset(EAX as isize)); }
-pub unsafe fn instr16_41() {
-    *reg16.offset(CX as isize) = inc16(*reg16.offset(CX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_41() { write_reg16(CX, inc16(read_reg16(CX))); }
 pub unsafe fn instr32_41() { *reg32.offset(ECX as isize) = inc32(*reg32.offset(ECX as isize)); }
-pub unsafe fn instr16_42() {
-    *reg16.offset(DX as isize) = inc16(*reg16.offset(DX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_42() { write_reg16(DX, inc16(read_reg16(DX))); }
 pub unsafe fn instr32_42() { *reg32.offset(EDX as isize) = inc32(*reg32.offset(EDX as isize)); }
-pub unsafe fn instr16_43() {
-    *reg16.offset(BX as isize) = inc16(*reg16.offset(BX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_43() { write_reg16(BX, inc16(read_reg16(BX))); }
 pub unsafe fn instr32_43() { *reg32.offset(EBX as isize) = inc32(*reg32.offset(EBX as isize)); }
-pub unsafe fn instr16_44() {
-    *reg16.offset(SP as isize) = inc16(*reg16.offset(SP as isize) as i32) as u16;
-}
+pub unsafe fn instr16_44() { write_reg16(SP, inc16(read_reg16(SP))); }
 pub unsafe fn instr32_44() { *reg32.offset(ESP as isize) = inc32(*reg32.offset(ESP as isize)); }
-pub unsafe fn instr16_45() {
-    *reg16.offset(BP as isize) = inc16(*reg16.offset(BP as isize) as i32) as u16;
-}
+pub unsafe fn instr16_45() { write_reg16(BP, inc16(read_reg16(BP))); }
 pub unsafe fn instr32_45() { *reg32.offset(EBP as isize) = inc32(*reg32.offset(EBP as isize)); }
-pub unsafe fn instr16_46() {
-    *reg16.offset(SI as isize) = inc16(*reg16.offset(SI as isize) as i32) as u16;
-}
+pub unsafe fn instr16_46() { write_reg16(SI, inc16(read_reg16(SI))); }
 pub unsafe fn instr32_46() { *reg32.offset(ESI as isize) = inc32(*reg32.offset(ESI as isize)); }
-pub unsafe fn instr16_47() {
-    *reg16.offset(DI as isize) = inc16(*reg16.offset(DI as isize) as i32) as u16;
-}
+pub unsafe fn instr16_47() { write_reg16(DI, inc16(read_reg16(DI))); }
 pub unsafe fn instr32_47() { *reg32.offset(EDI as isize) = inc32(*reg32.offset(EDI as isize)); }
-pub unsafe fn instr16_48() {
-    *reg16.offset(AX as isize) = dec16(*reg16.offset(AX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_48() { write_reg16(AX, dec16(read_reg16(AX))); }
 pub unsafe fn instr32_48() { *reg32.offset(EAX as isize) = dec32(*reg32.offset(EAX as isize)); }
-pub unsafe fn instr16_49() {
-    *reg16.offset(CX as isize) = dec16(*reg16.offset(CX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_49() { write_reg16(CX, dec16(read_reg16(CX))); }
 pub unsafe fn instr32_49() { *reg32.offset(ECX as isize) = dec32(*reg32.offset(ECX as isize)); }
-pub unsafe fn instr16_4A() {
-    *reg16.offset(DX as isize) = dec16(*reg16.offset(DX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4A() { write_reg16(DX, dec16(read_reg16(DX))); }
 pub unsafe fn instr32_4A() { *reg32.offset(EDX as isize) = dec32(*reg32.offset(EDX as isize)); }
-pub unsafe fn instr16_4B() {
-    *reg16.offset(BX as isize) = dec16(*reg16.offset(BX as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4B() { write_reg16(BX, dec16(read_reg16(BX))); }
 pub unsafe fn instr32_4B() { *reg32.offset(EBX as isize) = dec32(*reg32.offset(EBX as isize)); }
-pub unsafe fn instr16_4C() {
-    *reg16.offset(SP as isize) = dec16(*reg16.offset(SP as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4C() { write_reg16(SP, dec16(read_reg16(SP))); }
 pub unsafe fn instr32_4C() { *reg32.offset(ESP as isize) = dec32(*reg32.offset(ESP as isize)); }
-pub unsafe fn instr16_4D() {
-    *reg16.offset(BP as isize) = dec16(*reg16.offset(BP as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4D() { write_reg16(BP, dec16(read_reg16(BP))); }
 pub unsafe fn instr32_4D() { *reg32.offset(EBP as isize) = dec32(*reg32.offset(EBP as isize)); }
-pub unsafe fn instr16_4E() {
-    *reg16.offset(SI as isize) = dec16(*reg16.offset(SI as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4E() { write_reg16(SI, dec16(read_reg16(SI))); }
 pub unsafe fn instr32_4E() { *reg32.offset(ESI as isize) = dec32(*reg32.offset(ESI as isize)); }
-pub unsafe fn instr16_4F() {
-    *reg16.offset(DI as isize) = dec16(*reg16.offset(DI as isize) as i32) as u16;
-}
+pub unsafe fn instr16_4F() { write_reg16(DI, dec16(read_reg16(DI))); }
 pub unsafe fn instr32_4F() { *reg32.offset(EDI as isize) = dec32(*reg32.offset(EDI as isize)); }
 
 pub unsafe fn push16_reg(r: i32) {
-    return_on_pagefault!(push16(*reg16.offset(r as isize) as i32));
+    return_on_pagefault!(push16(read_reg16(r)));
 }
 pub unsafe fn push32_reg(r: i32) {
     return_on_pagefault!(push32(*reg32.offset(r as isize) as i32));
@@ -590,25 +544,25 @@ pub unsafe fn instr16_56() { push16_reg(SI) }
 pub unsafe fn instr32_56() { push32_reg(ESI) }
 pub unsafe fn instr16_57() { push16_reg(DI) }
 pub unsafe fn instr32_57() { push32_reg(EDI) }
-pub unsafe fn instr16_58() { *reg16.offset(AX as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_58() { write_reg16(AX, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_58() { *reg32.offset(EAX as isize) = return_on_pagefault!(pop32s()); }
-pub unsafe fn instr16_59() { *reg16.offset(CX as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_59() { write_reg16(CX, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_59() { *reg32.offset(ECX as isize) = return_on_pagefault!(pop32s()); }
-pub unsafe fn instr16_5A() { *reg16.offset(DX as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_5A() { write_reg16(DX, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_5A() { *reg32.offset(EDX as isize) = return_on_pagefault!(pop32s()); }
-pub unsafe fn instr16_5B() { *reg16.offset(BX as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_5B() { write_reg16(BX, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_5B() { *reg32.offset(EBX as isize) = return_on_pagefault!(pop32s()); }
 pub unsafe fn instr16_5C() {
-    *reg16.offset(SP as isize) = return_on_pagefault!(safe_read16(get_stack_pointer(0))) as u16;
+    write_reg16(SP, return_on_pagefault!(safe_read16(get_stack_pointer(0))));
 }
 pub unsafe fn instr32_5C() {
     *reg32.offset(ESP as isize) = return_on_pagefault!(safe_read32s(get_stack_pointer(0)));
 }
-pub unsafe fn instr16_5D() { *reg16.offset(BP as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_5D() { write_reg16(BP, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_5D() { *reg32.offset(EBP as isize) = return_on_pagefault!(pop32s()); }
-pub unsafe fn instr16_5E() { *reg16.offset(SI as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_5E() { write_reg16(SI, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_5E() { *reg32.offset(ESI as isize) = return_on_pagefault!(pop32s()); }
-pub unsafe fn instr16_5F() { *reg16.offset(DI as isize) = return_on_pagefault!(pop16()) as u16; }
+pub unsafe fn instr16_5F() { write_reg16(DI, return_on_pagefault!(pop16())); }
 pub unsafe fn instr32_5F() { *reg32.offset(EDI as isize) = return_on_pagefault!(pop32s()); }
 
 #[no_mangle]
@@ -1090,11 +1044,9 @@ pub unsafe fn instr32_96() { xchg32r(ESI); }
 pub unsafe fn instr16_97() { xchg16r(DI); }
 pub unsafe fn instr32_97() { xchg32r(EDI); }
 
-pub unsafe fn instr16_98() { *reg16.offset(AX as isize) = *reg8s.offset(AL as isize) as u16; }
-pub unsafe fn instr32_98() { *reg32.offset(EAX as isize) = *reg16s.offset(AX as isize) as i32; }
-pub unsafe fn instr16_99() {
-    *reg16.offset(DX as isize) = (*reg16s.offset(AX as isize) as i32 >> 15) as u16;
-}
+pub unsafe fn instr16_98() { write_reg16(AX, *reg8s.offset(AL as isize) as i32); }
+pub unsafe fn instr32_98() { *reg32.offset(EAX as isize) = read_reg16(AX) as i16 as i32; }
+pub unsafe fn instr16_99() { write_reg16(DX, read_reg16(AX) as i16 as i32 >> 15); }
 pub unsafe fn instr32_99() { *reg32.offset(EDX as isize) = *reg32.offset(EAX as isize) >> 31; }
 
 #[no_mangle]
@@ -1200,7 +1152,7 @@ pub unsafe fn instr_A0(moffs: i32) {
 pub unsafe fn instr16_A1(moffs: i32) {
     // mov
     let data = return_on_pagefault!(safe_read16(return_on_pagefault!(get_seg_prefix_ds(moffs))));
-    *reg16.offset(AX as isize) = data as u16;
+    write_reg16(AX, data);
 }
 pub unsafe fn instr32_A1(moffs: i32) {
     let data = return_on_pagefault!(safe_read32s(return_on_pagefault!(get_seg_prefix_ds(moffs))));
@@ -1217,7 +1169,7 @@ pub unsafe fn instr16_A3(moffs: i32) {
     // mov
     return_on_pagefault!(safe_write16(
         return_on_pagefault!(get_seg_prefix_ds(moffs)),
-        *reg16.offset(AX as isize) as i32
+        read_reg16(AX)
     ));
 }
 pub unsafe fn instr32_A3(moffs: i32) {
@@ -1243,7 +1195,7 @@ pub unsafe fn instr32_A7() {
 }
 
 pub unsafe fn instr_A8(imm8: i32) { test8(*reg8.offset(AL as isize) as i32, imm8); }
-pub unsafe fn instr16_A9(imm16: i32) { test16(*reg16.offset(AX as isize) as i32, imm16); }
+pub unsafe fn instr16_A9(imm16: i32) { test16(read_reg16(AX), imm16); }
 pub unsafe fn instr32_A9(imm32: i32) { test32(*reg32.offset(EAX as isize), imm32); }
 
 pub unsafe fn instr_AA() { stosb_no_rep(is_asize_32()); }
@@ -1270,21 +1222,21 @@ pub unsafe fn instr_B4(imm8: i32) { *reg8.offset(AH as isize) = imm8 as u8; }
 pub unsafe fn instr_B5(imm8: i32) { *reg8.offset(CH as isize) = imm8 as u8; }
 pub unsafe fn instr_B6(imm8: i32) { *reg8.offset(DH as isize) = imm8 as u8; }
 pub unsafe fn instr_B7(imm8: i32) { *reg8.offset(BH as isize) = imm8 as u8; }
-pub unsafe fn instr16_B8(imm: i32) { *reg16.offset(AX as isize) = imm as u16; }
+pub unsafe fn instr16_B8(imm: i32) { write_reg16(AX, imm); }
 pub unsafe fn instr32_B8(imm: i32) { *reg32.offset(EAX as isize) = imm; }
-pub unsafe fn instr16_B9(imm: i32) { *reg16.offset(CX as isize) = imm as u16; }
+pub unsafe fn instr16_B9(imm: i32) { write_reg16(CX, imm); }
 pub unsafe fn instr32_B9(imm: i32) { *reg32.offset(ECX as isize) = imm; }
-pub unsafe fn instr16_BA(imm: i32) { *reg16.offset(DX as isize) = imm as u16; }
+pub unsafe fn instr16_BA(imm: i32) { write_reg16(DX, imm); }
 pub unsafe fn instr32_BA(imm: i32) { *reg32.offset(EDX as isize) = imm; }
-pub unsafe fn instr16_BB(imm: i32) { *reg16.offset(BX as isize) = imm as u16; }
+pub unsafe fn instr16_BB(imm: i32) { write_reg16(BX, imm); }
 pub unsafe fn instr32_BB(imm: i32) { *reg32.offset(EBX as isize) = imm; }
-pub unsafe fn instr16_BC(imm: i32) { *reg16.offset(SP as isize) = imm as u16; }
+pub unsafe fn instr16_BC(imm: i32) { write_reg16(SP, imm); }
 pub unsafe fn instr32_BC(imm: i32) { *reg32.offset(ESP as isize) = imm; }
-pub unsafe fn instr16_BD(imm: i32) { *reg16.offset(BP as isize) = imm as u16; }
+pub unsafe fn instr16_BD(imm: i32) { write_reg16(BP, imm); }
 pub unsafe fn instr32_BD(imm: i32) { *reg32.offset(EBP as isize) = imm; }
-pub unsafe fn instr16_BE(imm: i32) { *reg16.offset(SI as isize) = imm as u16; }
+pub unsafe fn instr16_BE(imm: i32) { write_reg16(SI, imm); }
 pub unsafe fn instr32_BE(imm: i32) { *reg32.offset(ESI as isize) = imm; }
-pub unsafe fn instr16_BF(imm: i32) { *reg16.offset(DI as isize) = imm as u16; }
+pub unsafe fn instr16_BF(imm: i32) { write_reg16(DI, imm); }
 pub unsafe fn instr32_BF(imm: i32) { *reg32.offset(EDI as isize) = imm; }
 
 pub unsafe fn instr_C0_0_mem(addr: i32, imm: i32) {
@@ -1486,24 +1438,14 @@ pub unsafe fn instr32_C8(size: i32, nesting: i32) { enter32(size, nesting); }
 #[no_mangle]
 pub unsafe fn instr16_C9() {
     // leave
-    let old_vbp = if *stack_size_32 {
-        *reg32.offset(EBP as isize)
-    }
-    else {
-        *reg16.offset(BP as isize) as i32
-    };
+    let old_vbp = if *stack_size_32 { *reg32.offset(EBP as isize) } else { read_reg16(BP) };
     let new_bp = return_on_pagefault!(safe_read16(get_seg_ss() + old_vbp));
     set_stack_reg(old_vbp + 2);
-    *reg16.offset(BP as isize) = new_bp as u16;
+    write_reg16(BP, new_bp);
 }
 #[no_mangle]
 pub unsafe fn instr32_C9() {
-    let old_vbp = if *stack_size_32 {
-        *reg32.offset(EBP as isize)
-    }
-    else {
-        *reg16.offset(BP as isize) as i32
-    };
+    let old_vbp = if *stack_size_32 { *reg32.offset(EBP as isize) } else { read_reg16(BP) };
     let new_ebp = return_on_pagefault!(safe_read32s(get_seg_ss() + old_vbp));
     set_stack_reg(old_vbp + 4);
     *reg32.offset(EBP as isize) = new_ebp;
@@ -1904,7 +1846,7 @@ pub unsafe fn instr_D7() {
     else {
         *reg8.offset(AL as isize) = return_on_pagefault!(safe_read8(
             return_on_pagefault!(get_seg_prefix(DS))
-                + (*reg16.offset(BX as isize) as i32 + *reg8.offset(AL as isize) as i32 & 0xFFFF),
+                + (read_reg16(BX) + *reg8.offset(AL as isize) as i32 & 0xFFFF),
         )) as u8
     };
 }
@@ -1924,7 +1866,7 @@ pub unsafe fn instr16_E5(port: i32) {
         return;
     }
     else {
-        *reg16.offset(AX as isize) = io_port_read16(port) as u16;
+        write_reg16(AX, io_port_read16(port));
         return;
     };
 }
@@ -1954,7 +1896,7 @@ pub unsafe fn instr16_E7(port: i32) {
         return;
     }
     else {
-        io_port_write16(port, *reg16.offset(AX as isize) as i32);
+        io_port_write16(port, read_reg16(AX));
         return;
     };
 }
@@ -2004,7 +1946,7 @@ pub unsafe fn instr32_EA(new_ip: i32, cs: i32) {
 }
 #[no_mangle]
 pub unsafe fn instr_EC() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 1) {
         return;
     }
@@ -2015,18 +1957,18 @@ pub unsafe fn instr_EC() {
 }
 #[no_mangle]
 pub unsafe fn instr16_ED() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 2) {
         return;
     }
     else {
-        *reg16.offset(AX as isize) = io_port_read16(port) as u16;
+        write_reg16(AX, io_port_read16(port));
         return;
     };
 }
 #[no_mangle]
 pub unsafe fn instr32_ED() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 4) {
         return;
     }
@@ -2037,7 +1979,7 @@ pub unsafe fn instr32_ED() {
 }
 #[no_mangle]
 pub unsafe fn instr_EE() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 1) {
         return;
     }
@@ -2048,18 +1990,18 @@ pub unsafe fn instr_EE() {
 }
 #[no_mangle]
 pub unsafe fn instr16_EF() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 2) {
         return;
     }
     else {
-        io_port_write16(port, *reg16.offset(AX as isize) as i32);
+        io_port_write16(port, read_reg16(AX));
         return;
     };
 }
 #[no_mangle]
 pub unsafe fn instr32_EF() {
-    let port = *reg16.offset(DX as isize) as i32;
+    let port = read_reg16(DX);
     if !test_privileges_for_io(port, 4) {
         return;
     }

src/rust/cpu2/misc_instr.rs

@@ -145,7 +145,7 @@ pub unsafe fn get_stack_pointer(offset: i32) -> i32 {
         return get_seg_ss() + *reg32.offset(ESP as isize) + offset;
     }
     else {
-        return get_seg_ss() + (*reg16.offset(SP as isize) as i32 + offset & 0xFFFF);
+        return get_seg_ss() + (read_reg16(SP) + offset & 0xFFFF);
     };
 }
 #[no_mangle]
@@ -154,15 +154,15 @@ pub unsafe fn adjust_stack_reg(adjustment: i32) {
         *reg32.offset(ESP as isize) += adjustment;
     }
     else {
-        *reg16.offset(SP as isize) += adjustment as u16;
+        write_reg16(SP, read_reg16(SP) + adjustment);
     };
 }
 
 #[no_mangle]
 pub unsafe fn push16_ss16(imm16: i32) -> OrPageFault<()> {
-    let sp = get_seg_ss() + (*reg16.offset(SP as isize) as i32 - 2 & 0xFFFF);
+    let sp = get_seg_ss() + (read_reg16(SP) - 2 & 0xFFFF);
     safe_write16(sp, imm16)?;
-    *reg16.offset(SP as isize) -= 2;
+    write_reg16(SP, read_reg16(SP) - 2);
     Ok(())
 }
 #[no_mangle]
@@ -185,9 +185,9 @@ pub unsafe fn push16(imm16: i32) -> OrPageFault<()> {
 
 #[no_mangle]
 pub unsafe fn push32_ss16(imm32: i32) -> OrPageFault<()> {
-    let new_sp = *reg16.offset(SP as isize) as i32 - 4 & 0xFFFF;
+    let new_sp = read_reg16(SP) - 4 & 0xFFFF;
     safe_write32(get_seg_ss() + new_sp, imm32)?;
-    *reg16.offset(SP as isize) = new_sp as u16;
+    write_reg16(SP, new_sp);
     Ok(())
 }
 #[no_mangle]
@@ -213,9 +213,9 @@ pub unsafe fn pop16() -> OrPageFault<i32> {
 }
 #[no_mangle]
 pub unsafe fn pop16_ss16() -> OrPageFault<i32> {
-    let sp = get_seg_ss() + *reg16.offset(SP as isize) as i32;
+    let sp = get_seg_ss() + read_reg16(SP);
     let result = safe_read16(sp)?;
-    *reg16.offset(SP as isize) += 2;
+    write_reg16(SP, read_reg16(SP) + 2);
     Ok(result)
 }
 #[no_mangle]
@@ -231,9 +231,9 @@ pub unsafe fn pop32s() -> OrPageFault<i32> {
 }
 #[no_mangle]
 pub unsafe fn pop32s_ss16() -> OrPageFault<i32> {
-    let sp = *reg16.offset(SP as isize) as i32;
+    let sp = read_reg16(SP);
     let result = safe_read32s(get_seg_ss() + sp)?;
-    *reg16.offset(SP as isize) = (sp + 4) as u16;
+    write_reg16(SP, sp + 4);
     Ok(result)
 }
 #[no_mangle]
@@ -245,18 +245,18 @@ pub unsafe fn pop32s_ss32() -> OrPageFault<i32> {
 }
 #[no_mangle]
 pub unsafe fn pusha16() {
-    let temp = *reg16.offset(SP as isize);
+    let temp = read_reg16(SP);
     // make sure we don't get a pagefault after having
     // pushed several registers already
     return_on_pagefault!(writable_or_pagefault(get_stack_pointer(-16), 16));
-    push16(*reg16.offset(AX as isize) as i32).unwrap();
-    push16(*reg16.offset(CX as isize) as i32).unwrap();
-    push16(*reg16.offset(DX as isize) as i32).unwrap();
-    push16(*reg16.offset(BX as isize) as i32).unwrap();
+    push16(read_reg16(AX)).unwrap();
+    push16(read_reg16(CX)).unwrap();
+    push16(read_reg16(DX)).unwrap();
+    push16(read_reg16(BX)).unwrap();
     push16(temp as i32).unwrap();
-    push16(*reg16.offset(BP as isize) as i32).unwrap();
-    push16(*reg16.offset(SI as isize) as i32).unwrap();
-    push16(*reg16.offset(DI as isize) as i32).unwrap();
+    push16(read_reg16(BP)).unwrap();
+    push16(read_reg16(SI)).unwrap();
+    push16(read_reg16(DI)).unwrap();
 }
 #[no_mangle]
 pub unsafe fn pusha32() {
@@ -319,11 +319,8 @@ pub unsafe fn enter16(size: i32, mut nesting_level: i32) {
         push16(frame_temp).unwrap();
     }
 
-    return_on_pagefault!(safe_write16(
-        ss + (frame_temp & ss_mask),
-        *reg16.offset(BP as isize) as i32,
-    ));
-    *reg16.offset(BP as isize) = frame_temp as u16;
+    return_on_pagefault!(safe_write16(ss + (frame_temp & ss_mask), read_reg16(BP)));
+    write_reg16(BP, frame_temp);
     adjust_stack_reg(-size - 2);
 }
 
@@ -452,6 +449,7 @@ pub unsafe fn fxrstor(addr: i32) {
         return;
     };
 }
+
 #[no_mangle]
 pub unsafe fn xchg8(data: i32, r8: i32) -> i32 {
     let tmp = *reg8.offset(r8 as isize) as i32;
@@ -466,9 +464,9 @@ pub unsafe fn xchg16(data: i32, r16: i32) -> i32 {
 }
 #[no_mangle]
 pub unsafe fn xchg16r(r16: i32) {
-    let tmp = *reg16.offset(AX as isize) as i32;
-    *reg16.offset(AX as isize) = *reg16.offset(r16 as isize);
-    *reg16.offset(r16 as isize) = tmp as u16;
+    let tmp = read_reg16(AX);
+    write_reg16(AX, read_reg16(r16));
+    write_reg16(r16, tmp);
 }
 #[no_mangle]
 pub unsafe fn xchg32(data: i32, r32: i32) -> i32 {

src/rust/cpu2/modrm.rs

@@ -4,83 +4,69 @@ use paging::OrPageFault;
 
 pub unsafe fn resolve_modrm16(modrm_byte: i32) -> OrPageFault<i32> {
     Ok(match modrm_byte {
-        0 | 8 | 16 | 24 | 32 | 40 | 48 | 56 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(SI as isize) as i32 & 0xFFFF,
-        )?,
-        64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(SI as isize) as i32 + read_imm8s()?
-                & 0xFFFF,
-        )?,
-        128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(SI as isize) as i32 + read_imm16()?
-                & 0xFFFF,
-        )?,
-        1 | 9 | 17 | 25 | 33 | 41 | 49 | 57 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(DI as isize) as i32 & 0xFFFF,
-        )?,
-        65 | 73 | 81 | 89 | 97 | 105 | 113 | 121 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(DI as isize) as i32 + read_imm8s()?
-                & 0xFFFF,
-        )?,
-        129 | 137 | 145 | 153 | 161 | 169 | 177 | 185 => get_seg_prefix_ds(
-            *reg16.offset(BX as isize) as i32 + *reg16.offset(DI as isize) as i32 + read_imm16()?
-                & 0xFFFF,
-        )?,
-        2 | 10 | 18 | 26 | 34 | 42 | 50 | 58 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(SI as isize) as i32 & 0xFFFF,
-        )?,
-        66 | 74 | 82 | 90 | 98 | 106 | 114 | 122 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(SI as isize) as i32 + read_imm8s()?
-                & 0xFFFF,
-        )?,
-        130 | 138 | 146 | 154 | 162 | 170 | 178 | 186 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(SI as isize) as i32 + read_imm16()?
-                & 0xFFFF,
-        )?,
-        3 | 11 | 19 | 27 | 35 | 43 | 51 | 59 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(DI as isize) as i32 & 0xFFFF,
-        )?,
-        67 | 75 | 83 | 91 | 99 | 107 | 115 | 123 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(DI as isize) as i32 + read_imm8s()?
-                & 0xFFFF,
-        )?,
-        131 | 139 | 147 | 155 | 163 | 171 | 179 | 187 => get_seg_prefix_ss(
-            *reg16.offset(BP as isize) as i32 + *reg16.offset(DI as isize) as i32 + read_imm16()?
-                & 0xFFFF,
-        )?,
-        4 | 12 | 20 | 28 | 36 | 44 | 52 | 60 => {
-            get_seg_prefix_ds(*reg16.offset(SI as isize) as i32 & 0xFFFF)?
+        0 | 8 | 16 | 24 | 32 | 40 | 48 | 56 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(SI) & 0xFFFF)?
         },
+        64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(SI) + read_imm8s()? & 0xFFFF)?
+        },
+        128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(SI) + read_imm16()? & 0xFFFF)?
+        },
+        1 | 9 | 17 | 25 | 33 | 41 | 49 | 57 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(DI) & 0xFFFF)?
+        },
+        65 | 73 | 81 | 89 | 97 | 105 | 113 | 121 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(DI) + read_imm8s()? & 0xFFFF)?
+        },
+        129 | 137 | 145 | 153 | 161 | 169 | 177 | 185 => {
+            get_seg_prefix_ds(read_reg16(BX) + read_reg16(DI) + read_imm16()? & 0xFFFF)?
+        },
+        2 | 10 | 18 | 26 | 34 | 42 | 50 | 58 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(SI) & 0xFFFF)?
+        },
+        66 | 74 | 82 | 90 | 98 | 106 | 114 | 122 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(SI) + read_imm8s()? & 0xFFFF)?
+        },
+        130 | 138 | 146 | 154 | 162 | 170 | 178 | 186 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(SI) + read_imm16()? & 0xFFFF)?
+        },
+        3 | 11 | 19 | 27 | 35 | 43 | 51 | 59 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(DI) & 0xFFFF)?
+        },
+        67 | 75 | 83 | 91 | 99 | 107 | 115 | 123 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(DI) + read_imm8s()? & 0xFFFF)?
+        },
+        131 | 139 | 147 | 155 | 163 | 171 | 179 | 187 => {
+            get_seg_prefix_ss(read_reg16(BP) + read_reg16(DI) + read_imm16()? & 0xFFFF)?
+        },
+        4 | 12 | 20 | 28 | 36 | 44 | 52 | 60 => get_seg_prefix_ds(read_reg16(SI) & 0xFFFF)?,
         68 | 76 | 84 | 92 | 100 | 108 | 116 | 124 => {
-            get_seg_prefix_ds(*reg16.offset(SI as isize) as i32 + read_imm8s()? & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(SI) + read_imm8s()? & 0xFFFF)?
         },
         132 | 140 | 148 | 156 | 164 | 172 | 180 | 188 => {
-            get_seg_prefix_ds(*reg16.offset(SI as isize) as i32 + read_imm16()? & 0xFFFF)?
-        },
-        5 | 13 | 21 | 29 | 37 | 45 | 53 | 61 => {
-            get_seg_prefix_ds(*reg16.offset(DI as isize) as i32 & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(SI) + read_imm16()? & 0xFFFF)?
         },
+        5 | 13 | 21 | 29 | 37 | 45 | 53 | 61 => get_seg_prefix_ds(read_reg16(DI) & 0xFFFF)?,
         69 | 77 | 85 | 93 | 101 | 109 | 117 | 125 => {
-            get_seg_prefix_ds(*reg16.offset(DI as isize) as i32 + read_imm8s()? & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(DI) + read_imm8s()? & 0xFFFF)?
         },
         133 | 141 | 149 | 157 | 165 | 173 | 181 | 189 => {
-            get_seg_prefix_ds(*reg16.offset(DI as isize) as i32 + read_imm16()? & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(DI) + read_imm16()? & 0xFFFF)?
         },
         6 | 14 | 22 | 30 | 38 | 46 | 54 | 62 => get_seg_prefix_ds(read_imm16()?)?,
         70 | 78 | 86 | 94 | 102 | 110 | 118 | 126 => {
-            get_seg_prefix_ss(*reg16.offset(BP as isize) as i32 + read_imm8s()? & 0xFFFF)?
+            get_seg_prefix_ss(read_reg16(BP) + read_imm8s()? & 0xFFFF)?
         },
         134 | 142 | 150 | 158 | 166 | 174 | 182 | 190 => {
-            get_seg_prefix_ss(*reg16.offset(BP as isize) as i32 + read_imm16()? & 0xFFFF)?
-        },
-        7 | 15 | 23 | 31 | 39 | 47 | 55 | 63 => {
-            get_seg_prefix_ds(*reg16.offset(BX as isize) as i32 & 0xFFFF)?
+            get_seg_prefix_ss(read_reg16(BP) + read_imm16()? & 0xFFFF)?
         },
+        7 | 15 | 23 | 31 | 39 | 47 | 55 | 63 => get_seg_prefix_ds(read_reg16(BX) & 0xFFFF)?,
         71 | 79 | 87 | 95 | 103 | 111 | 119 | 127 => {
-            get_seg_prefix_ds(*reg16.offset(BX as isize) as i32 + read_imm8s()? & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(BX) + read_imm8s()? & 0xFFFF)?
         },
         135 | 143 | 151 | 159 | 167 | 175 | 183 | 191 => {
-            get_seg_prefix_ds(*reg16.offset(BX as isize) as i32 + read_imm16()? & 0xFFFF)?
+            get_seg_prefix_ds(read_reg16(BX) + read_imm16()? & 0xFFFF)?
         },
         _ => {
             dbg_assert!(false);

src/rust/cpu2/string.rs

@@ -12,12 +12,12 @@
 use cpu2::arith::{cmp8, cmp16, cmp32};
 use cpu2::cpu::{
     get_seg, io_port_read8, io_port_read16, io_port_read32, io_port_write8, io_port_write16,
-    io_port_write32, read_reg32, safe_read8, safe_read16, safe_read32s, safe_write8, safe_write16,
-    safe_write32, set_reg_asize, test_privileges_for_io, translate_address_read,
-    translate_address_write_and_can_skip_dirty, writable_or_pagefault, AL, AX, DX, EAX, ECX, EDI,
-    ES, ESI, FLAG_DIRECTION,
+    io_port_write32, read_reg16, read_reg32, safe_read8, safe_read16, safe_read32s, safe_write8,
+    safe_write16, safe_write32, set_reg_asize, test_privileges_for_io, translate_address_read,
+    translate_address_write_and_can_skip_dirty, writable_or_pagefault, write_reg16, AL, AX, DX,
+    EAX, ECX, EDI, ES, ESI, FLAG_DIRECTION,
 };
-use cpu2::global_pointers::{flags, instruction_pointer, previous_ip, reg8, reg16, reg32};
+use cpu2::global_pointers::{flags, instruction_pointer, previous_ip, reg8, reg32};
 use cpu2::memory::{
     in_mapped_range, memcpy_no_mmap_or_dirty_check, memset_no_mmap_or_dirty_check,
     read8_no_mmap_check, read16_no_mmap_check, read32_no_mmap_check, write8_no_mmap_or_dirty_check,
@@ -125,7 +125,7 @@ unsafe fn string_instruction(
 
     let port = match instruction {
         Instruction::Ins | Instruction::Outs => {
-            let port = *reg16.offset(DX as isize) as i32;
+            let port = read_reg16(DX);
             if !test_privileges_for_io(port, size_bytes) {
                 return;
             }
@@ -243,7 +243,7 @@ unsafe fn string_instruction(
                 },
                 Instruction::Lods => match size {
                     Size::B => *reg8.offset(AL as isize) = src_val as u8,
-                    Size::W => *reg16.offset(AX as isize) = src_val as u16,
+                    Size::W => write_reg16(AX, src_val),
                     Size::D => *reg32.offset(EAX as isize) = src_val,
                 },
                 Instruction::Ins => match size {
@@ -375,7 +375,7 @@ unsafe fn string_instruction(
                 },
                 Instruction::Lods => match size {
                     Size::B => *reg8.offset(AL as isize) = src_val as u8,
-                    Size::W => *reg16.offset(AX as isize) = src_val as u16,
+                    Size::W => write_reg16(AX, src_val),
                     Size::D => *reg32.offset(EAX as isize) = src_val,
                 },
                 Instruction::Movs | Instruction::Stos | Instruction::Ins => match size {