Use {read,write}_reg32

src/rust/cpu2/arith.rs

@@ -209,12 +209,12 @@ pub unsafe fn imul_reg16(mut operand1: i32, mut operand2: i32) -> i32 {
 }
 #[no_mangle]
 pub unsafe fn mul32(source_operand: i32) {
-    let dest_operand = *reg32.offset(EAX as isize);
+    let dest_operand = read_reg32(EAX);
     let result = (dest_operand as u32 as u64).wrapping_mul(source_operand as u32 as u64);
     let result_low = result as i32;
     let result_high = (result >> 32) as i32;
-    *reg32.offset(EAX as isize) = result_low;
-    *reg32.offset(EDX as isize) = result_high;
+    write_reg32(EAX, result_low);
+    write_reg32(EDX, result_high);
     *last_result = result_low;
     *last_op_size = OPSIZE_32;
     if result_high == 0 {
@@ -227,12 +227,12 @@ pub unsafe fn mul32(source_operand: i32) {
 }
 #[no_mangle]
 pub unsafe fn imul32(source_operand: i32) {
-    let dest_operand = *reg32.offset(EAX as isize);
+    let dest_operand = read_reg32(EAX);
     let result = dest_operand as i64 * source_operand as i64;
     let result_low = result as i32;
     let result_high = (result >> 32) as i32;
-    *reg32.offset(EAX as isize) = result_low;
-    *reg32.offset(EDX as isize) = result_high;
+    write_reg32(EAX, result_low);
+    write_reg32(EDX, result_high);
     *last_result = result_low;
     *last_op_size = OPSIZE_32;
     if result_high == result_low >> 31 {
@@ -274,8 +274,8 @@ pub unsafe fn xadd16(source_operand: i32, reg: i32) -> i32 {
 }
 #[no_mangle]
 pub unsafe fn xadd32(source_operand: i32, reg: i32) -> i32 {
-    let tmp = *reg32.offset(reg as isize);
-    *reg32.offset(reg as isize) = source_operand;
+    let tmp = read_reg32(reg);
+    write_reg32(reg, source_operand);
     return add(source_operand, tmp, OPSIZE_32);
 }
 
@@ -303,12 +303,12 @@ pub unsafe fn cmpxchg16(data: i32, r: i32) -> i32 {
 }
 #[no_mangle]
 pub unsafe fn cmpxchg32(data: i32, r: i32) -> i32 {
-    cmp32(*reg32.offset(EAX as isize), data);
+    cmp32(read_reg32(EAX), data);
     if getzf() {
         read_reg32(r)
     }
     else {
-        *reg32.offset(EAX as isize) = data;
+        write_reg32(EAX, data);
         data
     }
 }
@@ -742,16 +742,16 @@ pub unsafe fn div32_without_fault(source_operand: u32) -> bool {
     if source_operand == 0 {
         return false;
     }
-    let target_low = *reg32.offset(EAX as isize) as u32;
-    let target_high = *reg32.offset(EDX as isize) as u32;
+    let target_low = read_reg32(EAX) as u32;
+    let target_high = read_reg32(EDX) as u32;
     let target_operand = (target_high as u64) << 32 | target_low as u64;
     let result = target_operand.wrapping_div(source_operand as u64);
     if result > 0xFFFFFFFF {
         return false;
     }
     let mod_0 = target_operand.wrapping_rem(source_operand as u64) as i32;
-    *reg32.offset(EAX as isize) = result as i32;
-    *reg32.offset(EDX as isize) = mod_0;
+    write_reg32(EAX, result as i32);
+    write_reg32(EDX, mod_0);
     return true;
 }
 pub unsafe fn div32(source_operand: u32) {
@@ -764,8 +764,8 @@ pub unsafe fn idiv32_without_fault(source_operand: i32) -> bool {
     if source_operand == 0 {
         return false;
     }
-    let target_low = *reg32.offset(EAX as isize) as u32;
-    let target_high = *reg32.offset(EDX as isize) as u32;
+    let target_low = read_reg32(EAX) as u32;
+    let target_high = read_reg32(EDX) as u32;
     let target_operand = ((target_high as u64) << 32 | target_low as u64) as i64;
     if source_operand == -1 && target_operand == -0x80000000_00000000 as i64 {
         return false;
@@ -775,8 +775,8 @@ pub unsafe fn idiv32_without_fault(source_operand: i32) -> bool {
         return false;
     }
     let mod_0 = (target_operand % source_operand as i64) as i32;
-    *reg32.offset(EAX as isize) = result as i32;
-    *reg32.offset(EDX as isize) = mod_0;
+    write_reg32(EAX, result as i32);
+    write_reg32(EDX, mod_0);
     return true;
 }
 pub unsafe fn idiv32(source_operand: i32) {

src/rust/cpu2/cpu.rs

@@ -500,7 +500,7 @@ pub unsafe fn iret(is_16: bool) {
 
             adjust_stack_reg(9 * 4); // 9 dwords: eip, cs, flags, esp, ss, es, ds, fs, gs
 
-            *reg32.offset(ESP as isize) = temp_esp;
+            write_reg32(ESP, temp_esp);
             if !switch_seg(SS, temp_ss) {
                 // XXX
                 dbg_assert!(false);
@@ -827,7 +827,7 @@ pub unsafe fn call_interrupt_vector(
                 panic!("Unimplemented: #TS handler");
             }
 
-            let old_esp = *reg32.offset(ESP as isize);
+            let old_esp = read_reg32(ESP);
             let old_ss = *sreg.offset(SS as isize) as i32;
 
             let error_code_space = if error_code.is_some() { 1 } else { 0 };
@@ -1164,7 +1164,7 @@ pub unsafe fn far_jump(eip: i32, selector: i32, is_call: bool, is_osize_32: bool
                     )); // , cs_info.dpl
                 }
 
-                let old_esp = *reg32.offset(ESP as isize);
+                let old_esp = read_reg32(ESP);
                 let old_ss = *sreg.offset(SS as isize);
                 let old_stack_pointer = get_stack_pointer(0);
 
@@ -2286,14 +2286,14 @@ pub unsafe fn popa32() {
     return_on_pagefault!(translate_address_read(get_stack_pointer(0)));
     return_on_pagefault!(translate_address_read(get_stack_pointer(31)));
 
-    *reg32.offset(EDI as isize) = pop32s().unwrap();
-    *reg32.offset(ESI as isize) = pop32s().unwrap();
-    *reg32.offset(EBP as isize) = pop32s().unwrap();
+    write_reg32(EDI, pop32s().unwrap());
+    write_reg32(ESI, pop32s().unwrap());
+    write_reg32(EBP, pop32s().unwrap());
     adjust_stack_reg(4);
-    *reg32.offset(EBX as isize) = pop32s().unwrap();
-    *reg32.offset(EDX as isize) = pop32s().unwrap();
-    *reg32.offset(ECX as isize) = pop32s().unwrap();
-    *reg32.offset(EAX as isize) = pop32s().unwrap();
+    write_reg32(EBX, pop32s().unwrap());
+    write_reg32(EDX, pop32s().unwrap());
+    write_reg32(ECX, pop32s().unwrap());
+    write_reg32(EAX, pop32s().unwrap());
 }
 
 #[no_mangle]
@@ -3250,7 +3250,7 @@ pub unsafe fn get_real_eip() -> i32 {
 
 pub unsafe fn get_stack_reg() -> i32 {
     if *stack_size_32 {
-        return *reg32.offset(ESP as isize);
+        return read_reg32(ESP);
     }
     else {
         return read_reg16(SP);
@@ -3260,7 +3260,7 @@ pub unsafe fn get_stack_reg() -> i32 {
 #[no_mangle]
 pub unsafe fn set_stack_reg(value: i32) {
     if *stack_size_32 {
-        *reg32.offset(ESP as isize) = value
+        write_reg32(ESP, value)
     }
     else {
         write_reg16(SP, value)
@@ -3269,7 +3269,7 @@ pub unsafe fn set_stack_reg(value: i32) {
 
 pub unsafe fn get_reg_asize(reg: i32) -> i32 {
     dbg_assert!(reg == ECX || reg == ESI || reg == EDI);
-    let r = *reg32.offset(reg as isize);
+    let r = read_reg32(reg);
     if is_asize_32() {
         return r;
     }
@@ -3281,7 +3281,7 @@ pub unsafe fn get_reg_asize(reg: i32) -> i32 {
 pub unsafe fn set_reg_asize(is_asize_32: bool, reg: i32, value: i32) {
     dbg_assert!(reg == ECX || reg == ESI || reg == EDI);
     if is_asize_32 {
-        *reg32.offset(reg as isize) = value
+        write_reg32(reg, value)
     }
     else {
         write_reg16(reg, value)
@@ -3290,8 +3290,8 @@ pub unsafe fn set_reg_asize(is_asize_32: bool, reg: i32, value: i32) {
 
 pub unsafe fn decr_ecx_asize(is_asize_32: bool) -> i32 {
     return if is_asize_32 {
-        *reg32.offset(ECX as isize) -= 1;
-        *reg32.offset(ECX as isize)
+        write_reg32(ECX, read_reg32(ECX) - 1);
+        read_reg32(ECX)
     }
     else {
         write_reg16(CX, read_reg16(CX) - 1);

src/rust/cpu2/instructions.rs

@@ -59,9 +59,7 @@ pub unsafe fn instr32_03_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_04(imm8: i32) { write_reg8(AL, add8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_05(imm32: i32) { write_reg32(EAX, add32(read_reg32(EAX), imm32)); }
 pub unsafe fn instr16_06() {
     return_on_pagefault!(push16(*sreg.offset(ES as isize) as i32));
 }
@@ -127,9 +125,7 @@ pub unsafe fn instr32_0B_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_0C(imm8: i32) { write_reg8(AL, or8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_0D(imm32: i32) { write_reg32(EAX, or32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr16_0E() {
     return_on_pagefault!(push16(*sreg.offset(CS as isize) as i32));
@@ -184,9 +180,7 @@ pub unsafe fn instr32_13_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_14(imm8: i32) { write_reg8(AL, adc8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_15(imm32: i32) { write_reg32(EAX, adc32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr16_16() {
     return_on_pagefault!(push16(*sreg.offset(SS as isize) as i32));
@@ -256,9 +250,7 @@ pub unsafe fn instr32_1B_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_1C(imm8: i32) { write_reg8(AL, sbb8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_1D(imm32: i32) { write_reg32(EAX, sbb32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr16_1E() {
     return_on_pagefault!(push16(*sreg.offset(DS as isize) as i32));
@@ -328,9 +320,7 @@ pub unsafe fn instr32_23_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_24(imm8: i32) { write_reg8(AL, and8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_25(imm32: i32) { write_reg32(EAX, and32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr_26() { segment_prefix_op(ES); }
 
@@ -380,9 +370,7 @@ pub unsafe fn instr32_2B_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_2C(imm8: i32) { write_reg8(AL, sub8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_2D(imm32: i32) { write_reg32(EAX, sub32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr_2E() { segment_prefix_op(CS); }
 
@@ -432,9 +420,7 @@ pub unsafe fn instr32_33_reg(r1: i32, r: i32) {
 }
 pub unsafe fn instr_34(imm8: i32) { write_reg8(AL, xor8(read_reg8(AL), imm8)); }
 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);
-}
+pub unsafe fn instr32_35(imm32: i32) { write_reg32(EAX, xor32(read_reg32(EAX), imm32)); }
 
 pub unsafe fn instr_36() { segment_prefix_op(SS); }
 
@@ -467,7 +453,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(read_reg8(AL), imm8); }
 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 instr32_3D(imm32: i32) { cmp32(read_reg32(EAX), imm32); }
 
 pub unsafe fn instr_3E() { segment_prefix_op(DS); }
 
@@ -475,43 +461,43 @@ pub unsafe fn instr_3E() { segment_prefix_op(DS); }
 pub unsafe fn instr_3F() { bcd_aas(); }
 
 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 instr32_40() { write_reg32(EAX, inc32(read_reg32(EAX))); }
 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 instr32_41() { write_reg32(ECX, inc32(read_reg32(ECX))); }
 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 instr32_42() { write_reg32(EDX, inc32(read_reg32(EDX))); }
 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 instr32_43() { write_reg32(EBX, inc32(read_reg32(EBX))); }
 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 instr32_44() { write_reg32(ESP, inc32(read_reg32(ESP))); }
 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 instr32_45() { write_reg32(EBP, inc32(read_reg32(EBP))); }
 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 instr32_46() { write_reg32(ESI, inc32(read_reg32(ESI))); }
 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 instr32_47() { write_reg32(EDI, inc32(read_reg32(EDI))); }
 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 instr32_48() { write_reg32(EAX, dec32(read_reg32(EAX))); }
 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 instr32_49() { write_reg32(ECX, dec32(read_reg32(ECX))); }
 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 instr32_4A() { write_reg32(EDX, dec32(read_reg32(EDX))); }
 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 instr32_4B() { write_reg32(EBX, dec32(read_reg32(EBX))); }
 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 instr32_4C() { write_reg32(ESP, dec32(read_reg32(ESP))); }
 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 instr32_4D() { write_reg32(EBP, dec32(read_reg32(EBP))); }
 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 instr32_4E() { write_reg32(ESI, dec32(read_reg32(ESI))); }
 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 instr32_4F() { write_reg32(EDI, dec32(read_reg32(EDI))); }
 
 pub unsafe fn push16_reg(r: 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));
+    return_on_pagefault!(push32(read_reg32(r)));
 }
 
 pub unsafe fn instr16_50() { push16_reg(AX) }
@@ -531,25 +517,28 @@ 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() { write_reg16(AX, return_on_pagefault!(pop16())); }
-pub unsafe fn instr32_58() { *reg32.offset(EAX as isize) = return_on_pagefault!(pop32s()); }
+pub unsafe fn instr32_58() { write_reg32(EAX, return_on_pagefault!(pop32s())); }
 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 instr32_59() { write_reg32(ECX, return_on_pagefault!(pop32s())); }
 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 instr32_5A() { write_reg32(EDX, return_on_pagefault!(pop32s())); }
 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 instr32_5B() { write_reg32(EBX, return_on_pagefault!(pop32s())); }
 pub unsafe fn instr16_5C() {
     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)));
+    write_reg32(
+        ESP,
+        return_on_pagefault!(safe_read32s(get_stack_pointer(0))),
+    );
 }
 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 instr32_5D() { write_reg32(EBP, return_on_pagefault!(pop32s())); }
 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 instr32_5E() { write_reg32(ESI, return_on_pagefault!(pop32s())); }
 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()); }
+pub unsafe fn instr32_5F() { write_reg32(EDI, return_on_pagefault!(pop32s())); }
 
 #[no_mangle]
 pub unsafe fn instr16_60() { pusha16(); }
@@ -1031,9 +1020,9 @@ pub unsafe fn instr16_97() { xchg16r(DI); }
 pub unsafe fn instr32_97() { xchg32r(EDI); }
 
 pub unsafe fn instr16_98() { write_reg16(AX, read_reg8(AL) << 24 >> 24); }
-pub unsafe fn instr32_98() { *reg32.offset(EAX as isize) = read_reg16(AX) as i16 as i32; }
+pub unsafe fn instr32_98() { write_reg32(EAX, 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; }
+pub unsafe fn instr32_99() { write_reg32(EDX, read_reg32(EAX) >> 31); }
 
 #[no_mangle]
 pub unsafe fn instr16_9A(new_ip: i32, new_cs: i32) {
@@ -1142,7 +1131,7 @@ pub unsafe fn instr16_A1(moffs: i32) {
 }
 pub unsafe fn instr32_A1(moffs: i32) {
     let data = return_on_pagefault!(safe_read32s(return_on_pagefault!(get_seg_prefix_ds(moffs))));
-    *reg32.offset(EAX as isize) = data;
+    write_reg32(EAX, data);
 }
 pub unsafe fn instr_A2(moffs: i32) {
     // mov
@@ -1161,7 +1150,7 @@ pub unsafe fn instr16_A3(moffs: i32) {
 pub unsafe fn instr32_A3(moffs: i32) {
     return_on_pagefault!(safe_write32(
         return_on_pagefault!(get_seg_prefix_ds(moffs)),
-        *reg32.offset(EAX as isize)
+        read_reg32(EAX)
     ));
 }
 pub unsafe fn instr_A4() { movsb_no_rep(is_asize_32(), return_on_pagefault!(get_seg_prefix(DS))); }
@@ -1182,7 +1171,7 @@ pub unsafe fn instr32_A7() {
 
 pub unsafe fn instr_A8(imm8: i32) { test8(read_reg8(AL), imm8); }
 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 instr32_A9(imm32: i32) { test32(read_reg32(EAX), imm32); }
 
 pub unsafe fn instr_AA() { stosb_no_rep(is_asize_32()); }
 pub unsafe fn instr16_AB() { stosw_no_rep(is_asize_32()); }
@@ -1209,21 +1198,21 @@ pub unsafe fn instr_B5(imm8: i32) { write_reg8(CH, imm8); }
 pub unsafe fn instr_B6(imm8: i32) { write_reg8(DH, imm8); }
 pub unsafe fn instr_B7(imm8: i32) { write_reg8(BH, imm8); }
 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 instr32_B8(imm: i32) { write_reg32(EAX, imm); }
 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 instr32_B9(imm: i32) { write_reg32(ECX, imm); }
 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 instr32_BA(imm: i32) { write_reg32(EDX, imm); }
 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 instr32_BB(imm: i32) { write_reg32(EBX, imm); }
 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 instr32_BC(imm: i32) { write_reg32(ESP, imm); }
 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 instr32_BD(imm: i32) { write_reg32(EBP, imm); }
 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 instr32_BE(imm: i32) { write_reg32(ESI, imm); }
 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 instr32_BF(imm: i32) { write_reg32(EDI, imm); }
 
 pub unsafe fn instr_C0_0_mem(addr: i32, imm: i32) {
     SAFE_READ_WRITE8!(___, addr, rol8(___, imm & 31));
@@ -1424,17 +1413,17 @@ 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 { read_reg16(BP) };
+    let old_vbp = if *stack_size_32 { read_reg32(EBP) } else { read_reg16(BP) };
     let new_bp = return_on_pagefault!(safe_read16(get_seg_ss() + old_vbp));
     set_stack_reg(old_vbp + 2);
     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 { read_reg16(BP) };
+    let old_vbp = if *stack_size_32 { read_reg32(EBP) } 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;
+    write_reg32(EBP, new_ebp);
 }
 #[no_mangle]
 pub unsafe fn instr16_CA(imm16: i32) {
@@ -1738,9 +1727,7 @@ pub unsafe fn instr_D7() {
         write_reg8(
             AL,
             return_on_pagefault!(safe_read8(
-                return_on_pagefault!(get_seg_prefix(DS))
-                    + *reg32.offset(EBX as isize)
-                    + read_reg8(AL),
+                return_on_pagefault!(get_seg_prefix(DS)) + read_reg32(EBX) + read_reg8(AL),
             )),
         )
     }
@@ -1780,7 +1767,7 @@ pub unsafe fn instr32_E5(port: i32) {
         return;
     }
     else {
-        *reg32.offset(EAX as isize) = io_port_read32(port);
+        write_reg32(EAX, io_port_read32(port));
         return;
     };
 }
@@ -1810,7 +1797,7 @@ pub unsafe fn instr32_E7(port: i32) {
         return;
     }
     else {
-        io_port_write32(port, *reg32.offset(EAX as isize));
+        io_port_write32(port, read_reg32(EAX));
         return;
     };
 }
@@ -1877,7 +1864,7 @@ pub unsafe fn instr32_ED() {
         return;
     }
     else {
-        *reg32.offset(EAX as isize) = io_port_read32(port);
+        write_reg32(EAX, io_port_read32(port));
         return;
     };
 }
@@ -1910,7 +1897,7 @@ pub unsafe fn instr32_EF() {
         return;
     }
     else {
-        io_port_write32(port, *reg32.offset(EAX as isize));
+        io_port_write32(port, read_reg32(EAX));
         return;
     };
 }

src/rust/cpu2/instructions_0f.rs

@@ -1162,9 +1162,9 @@ pub unsafe fn instr_0F30() {
         return;
     }
 
-    let index = *reg32.offset(ECX as isize);
-    let low = *reg32.offset(EAX as isize);
-    let high = *reg32.offset(EDX as isize);
+    let index = read_reg32(ECX);
+    let low = read_reg32(EAX);
+    let high = read_reg32(EDX);
 
     if index != IA32_SYSENTER_ESP {
         dbg_log!("wrmsr ecx={:x} data={:x}:{:x}", index, high, low);
@@ -1228,14 +1228,10 @@ pub unsafe fn instr_0F31() {
     // rdtsc - read timestamp counter
     if 0 == *cpl || 0 == *cr.offset(4) & CR4_TSD {
         let tsc = read_tsc();
-        *reg32.offset(EAX as isize) = tsc as i32;
-        *reg32.offset(EDX as isize) = (tsc >> 32) as i32;
+        write_reg32(EAX, tsc as i32);
+        write_reg32(EDX, (tsc >> 32) as i32);
         if false {
-            dbg_log!(
-                "rdtsc  edx:eax={:x}:{:x}",
-                *reg32.offset(EDX as isize),
-                *reg32.offset(EAX as isize)
-            );
+            dbg_log!("rdtsc  edx:eax={:x}:{:x}", read_reg32(EDX), read_reg32(EAX));
         }
     }
     else {
@@ -1251,7 +1247,7 @@ pub unsafe fn instr_0F32() {
         return;
     }
 
-    let index = *reg32.offset(ECX as isize);
+    let index = read_reg32(ECX);
     dbg_log!("rdmsr ecx={:x}", index);
 
     let mut low: i32 = 0;
@@ -1311,8 +1307,8 @@ pub unsafe fn instr_0F32() {
         dbg_assert!(false);
     }
 
-    *reg32.offset(EAX as isize) = low;
-    *reg32.offset(EDX as isize) = high;
+    write_reg32(EAX, low);
+    write_reg32(EDX, high);
 }
 #[no_mangle]
 pub unsafe fn instr_0F33() {
@@ -1330,7 +1326,7 @@ pub unsafe fn instr_0F34() {
     else {
         *flags &= !FLAG_VM & !FLAG_INTERRUPT;
         *instruction_pointer = *sysenter_eip;
-        *reg32.offset(ESP as isize) = *sysenter_esp;
+        write_reg32(ESP, *sysenter_esp);
         *sreg.offset(CS as isize) = seg as u16;
         *segment_is_null.offset(CS as isize) = false;
         *segment_limits.offset(CS as isize) = -1i32 as u32;
@@ -1355,8 +1351,8 @@ pub unsafe fn instr_0F35() {
         return;
     }
     else {
-        *instruction_pointer = *reg32.offset(EDX as isize);
-        *reg32.offset(ESP as isize) = *reg32.offset(ECX as isize);
+        *instruction_pointer = read_reg32(EDX);
+        write_reg32(ESP, read_reg32(ECX));
         *sreg.offset(CS as isize) = (seg + 16 | 3) as u16;
         *segment_is_null.offset(CS as isize) = false;
         *segment_limits.offset(CS as isize) = -1i32 as u32;
@@ -3294,15 +3290,15 @@ pub unsafe fn instr16_0FC7_1_mem(addr: i32) {
     return_on_pagefault!(writable_or_pagefault(addr, 8));
     let m64_low = safe_read32s(addr).unwrap();
     let m64_high = safe_read32s(addr + 4).unwrap();
-    if *reg32.offset(EAX as isize) == m64_low && *reg32.offset(EDX as isize) == m64_high {
+    if read_reg32(EAX) == m64_low && read_reg32(EDX) == m64_high {
         *flags |= FLAG_ZERO;
-        safe_write32(addr, *reg32.offset(EBX as isize)).unwrap();
-        safe_write32(addr + 4, *reg32.offset(ECX as isize)).unwrap();
+        safe_write32(addr, read_reg32(EBX)).unwrap();
+        safe_write32(addr + 4, read_reg32(ECX)).unwrap();
     }
     else {
         *flags &= !FLAG_ZERO;
-        *reg32.offset(EAX as isize) = m64_low;
-        *reg32.offset(EDX as isize) = m64_high;
+        write_reg32(EAX, m64_low);
+        write_reg32(EDX, m64_high);
         safe_write32(addr, m64_low).unwrap();
         safe_write32(addr + 4, m64_high).unwrap();
     }

src/rust/cpu2/misc_instr.rs

@@ -142,7 +142,7 @@ pub unsafe fn cmovcc32(condition: bool, value: i32, r: i32) {
 #[no_mangle]
 pub unsafe fn get_stack_pointer(offset: i32) -> i32 {
     if *stack_size_32 {
-        return get_seg_ss() + *reg32.offset(ESP as isize) + offset;
+        return get_seg_ss() + read_reg32(ESP) + offset;
     }
     else {
         return get_seg_ss() + (read_reg16(SP) + offset & 0xFFFF);
@@ -151,7 +151,7 @@ pub unsafe fn get_stack_pointer(offset: i32) -> i32 {
 #[no_mangle]
 pub unsafe fn adjust_stack_reg(adjustment: i32) {
     if *stack_size_32 {
-        *reg32.offset(ESP as isize) += adjustment;
+        write_reg32(ESP, read_reg32(ESP) + adjustment);
     }
     else {
         write_reg16(SP, read_reg16(SP) + adjustment);
@@ -167,9 +167,9 @@ pub unsafe fn push16_ss16(imm16: i32) -> OrPageFault<()> {
 }
 #[no_mangle]
 pub unsafe fn push16_ss32(imm16: i32) -> OrPageFault<()> {
-    let sp = get_seg_ss() + *reg32.offset(ESP as isize) - 2;
+    let sp = get_seg_ss() + read_reg32(ESP) - 2;
     safe_write16(sp, imm16)?;
-    *reg32.offset(ESP as isize) -= 2;
+    write_reg32(ESP, read_reg32(ESP) - 2);
     Ok(())
 }
 
@@ -192,9 +192,9 @@ pub unsafe fn push32_ss16(imm32: i32) -> OrPageFault<()> {
 }
 #[no_mangle]
 pub unsafe fn push32_ss32(imm32: i32) -> OrPageFault<()> {
-    let new_esp = *reg32.offset(ESP as isize) - 4;
+    let new_esp = read_reg32(ESP) - 4;
     safe_write32(get_seg_ss() + new_esp, imm32)?;
-    *reg32.offset(ESP as isize) = new_esp;
+    write_reg32(ESP, new_esp);
     Ok(())
 }
 
@@ -220,9 +220,9 @@ pub unsafe fn pop16_ss16() -> OrPageFault<i32> {
 }
 #[no_mangle]
 pub unsafe fn pop16_ss32() -> OrPageFault<i32> {
-    let esp = get_seg_ss() + *reg32.offset(ESP as isize);
+    let esp = get_seg_ss() + read_reg32(ESP);
     let result = safe_read16(esp)?;
-    *reg32.offset(ESP as isize) += 2;
+    write_reg32(ESP, read_reg32(ESP) + 2);
     Ok(result)
 }
 #[no_mangle]
@@ -238,9 +238,9 @@ pub unsafe fn pop32s_ss16() -> OrPageFault<i32> {
 }
 #[no_mangle]
 pub unsafe fn pop32s_ss32() -> OrPageFault<i32> {
-    let esp = *reg32.offset(ESP as isize);
+    let esp = read_reg32(ESP);
     let result = safe_read32s(get_seg_ss() + esp)?;
-    *reg32.offset(ESP as isize) = esp + 4;
+    write_reg32(ESP, read_reg32(ESP) + 4);
     Ok(result)
 }
 #[no_mangle]
@@ -260,16 +260,16 @@ pub unsafe fn pusha16() {
 }
 #[no_mangle]
 pub unsafe fn pusha32() {
-    let temp = *reg32.offset(ESP as isize);
+    let temp = read_reg32(ESP);
     return_on_pagefault!(writable_or_pagefault(get_stack_pointer(-32), 32));
-    push32(*reg32.offset(EAX as isize)).unwrap();
-    push32(*reg32.offset(ECX as isize)).unwrap();
-    push32(*reg32.offset(EDX as isize)).unwrap();
-    push32(*reg32.offset(EBX as isize)).unwrap();
+    push32(read_reg32(EAX)).unwrap();
+    push32(read_reg32(ECX)).unwrap();
+    push32(read_reg32(EDX)).unwrap();
+    push32(read_reg32(EBX)).unwrap();
     push32(temp).unwrap();
-    push32(*reg32.offset(EBP as isize)).unwrap();
-    push32(*reg32.offset(ESI as isize)).unwrap();
-    push32(*reg32.offset(EDI as isize)).unwrap();
+    push32(read_reg32(EBP)).unwrap();
+    push32(read_reg32(ESI)).unwrap();
+    push32(read_reg32(EDI)).unwrap();
 }
 
 pub unsafe fn lss16(addr: i32, reg: i32, seg: i32) {
@@ -308,10 +308,10 @@ pub unsafe fn enter16(size: i32, mut nesting_level: i32) {
 
     let ss_mask = if *stack_size_32 { -1 } else { 0xFFFF };
     let ss = get_seg_ss();
-    let frame_temp = *reg32.offset(ESP as isize) - 2;
+    let frame_temp = read_reg32(ESP) - 2;
 
     if nesting_level > 0 {
-        let mut tmp_ebp = *reg32.offset(EBP as isize);
+        let mut tmp_ebp = read_reg32(EBP);
         for _ in 1..nesting_level {
             tmp_ebp -= 2;
             push16(safe_read16(ss + (tmp_ebp & ss_mask)).unwrap()).unwrap();
@@ -338,10 +338,10 @@ pub unsafe fn enter32(size: i32, mut nesting_level: i32) {
 
     let ss_mask = if *stack_size_32 { -1 } else { 0xFFFF };
     let ss = get_seg_ss();
-    let frame_temp = *reg32.offset(ESP as isize) - 4;
+    let frame_temp = read_reg32(ESP) - 4;
 
     if nesting_level > 0 {
-        let mut tmp_ebp = *reg32.offset(EBP as isize);
+        let mut tmp_ebp = read_reg32(EBP);
         for _ in 1..nesting_level {
             tmp_ebp -= 4;
             push32(safe_read32s(ss + (tmp_ebp & ss_mask)).unwrap()).unwrap();
@@ -349,11 +349,8 @@ pub unsafe fn enter32(size: i32, mut nesting_level: i32) {
         push32(frame_temp).unwrap();
     }
 
-    return_on_pagefault!(safe_write32(
-        ss + (frame_temp & ss_mask),
-        *reg32.offset(EBP as isize)
-    ));
-    *reg32.offset(EBP as isize) = frame_temp;
+    return_on_pagefault!(safe_write32(ss + (frame_temp & ss_mask), read_reg32(EBP)));
+    write_reg32(EBP, frame_temp);
     adjust_stack_reg(-size - 4);
 }
 
@@ -470,15 +467,15 @@ pub unsafe fn xchg16r(r16: i32) {
 }
 #[no_mangle]
 pub unsafe fn xchg32(data: i32, r32: i32) -> i32 {
-    let tmp = *reg32.offset(r32 as isize);
-    *reg32.offset(r32 as isize) = data;
+    let tmp = read_reg32(r32);
+    write_reg32(r32, data);
     return tmp;
 }
 #[no_mangle]
 pub unsafe fn xchg32r(r32: i32) {
-    let tmp = *reg32.offset(EAX as isize);
-    *reg32.offset(EAX as isize) = *reg32.offset(r32 as isize);
-    *reg32.offset(r32 as isize) = tmp;
+    let tmp = read_reg32(EAX);
+    write_reg32(EAX, read_reg32(r32));
+    write_reg32(r32, tmp);
 }
 
 #[no_mangle]

src/rust/cpu2/modrm.rs

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

src/rust/cpu2/string.rs

@@ -14,10 +14,10 @@ use cpu2::cpu::{
     get_seg, io_port_read8, io_port_read16, io_port_read32, io_port_write8, io_port_write16,
     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_reg8, write_reg16, AL,
-    AX, DX, EAX, ECX, EDI, ES, ESI, FLAG_DIRECTION,
+    translate_address_write_and_can_skip_dirty, writable_or_pagefault, write_reg8, write_reg16,
+    write_reg32, AL, AX, DX, EAX, ECX, EDI, ES, ESI, FLAG_DIRECTION,
 };
-use cpu2::global_pointers::{flags, instruction_pointer, previous_ip, reg32};
+use cpu2::global_pointers::{flags, instruction_pointer, previous_ip};
 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,
@@ -94,7 +94,7 @@ unsafe fn string_instruction(
     let increment = direction * size_bytes;
 
     let data = match instruction {
-        Instruction::Stos | Instruction::Scas => *reg32.offset(EAX as isize),
+        Instruction::Stos | Instruction::Scas => read_reg32(EAX),
         _ => 0,
     };
 
@@ -244,7 +244,7 @@ unsafe fn string_instruction(
                 Instruction::Lods => match size {
                     Size::B => write_reg8(AL, src_val),
                     Size::W => write_reg16(AX, src_val),
-                    Size::D => *reg32.offset(EAX as isize) = src_val,
+                    Size::D => write_reg32(EAX, src_val),
                 },
                 Instruction::Ins => match size {
                     Size::B => write8_no_mmap_or_dirty_check(phys_dst, src_val),
@@ -376,7 +376,7 @@ unsafe fn string_instruction(
                 Instruction::Lods => match size {
                     Size::B => write_reg8(AL, src_val),
                     Size::W => write_reg16(AX, src_val),
-                    Size::D => *reg32.offset(EAX as isize) = src_val,
+                    Size::D => write_reg32(EAX, src_val),
                 },
                 Instruction::Movs | Instruction::Stos | Instruction::Ins => match size {
                     Size::B => break_on_pagefault!(safe_write8(es + dst, src_val)),