c2rust cleanup: Remove unnecessary type annotations on let bindings
This commit is contained in:
Fabian
parent
764879bad1
commit
034ecd5390
|
|
@ -9,7 +9,7 @@ pub fn int_log2(x: i32) -> i32 { 31 - x.leading_zeros() as i32 }
|
|||
pub unsafe fn add(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
||||
*last_op1 = dest_operand;
|
||||
*last_op2 = source_operand;
|
||||
let res: i32 = dest_operand + source_operand;
|
||||
let res = dest_operand + source_operand;
|
||||
*last_result = res;
|
||||
*last_add_result = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -18,10 +18,10 @@ pub unsafe fn add(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn adc(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
||||
let cf: i32 = getcf() as i32;
|
||||
let cf = getcf() as i32;
|
||||
*last_op1 = dest_operand;
|
||||
*last_op2 = source_operand;
|
||||
let res: i32 = dest_operand + source_operand + cf;
|
||||
let res = dest_operand + source_operand + cf;
|
||||
*last_result = res;
|
||||
*last_add_result = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -32,7 +32,7 @@ pub unsafe fn adc(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
|||
pub unsafe fn sub(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
||||
*last_add_result = dest_operand;
|
||||
*last_op2 = source_operand;
|
||||
let res: i32 = dest_operand - source_operand;
|
||||
let res = dest_operand - source_operand;
|
||||
*last_result = res;
|
||||
*last_op1 = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -41,10 +41,10 @@ pub unsafe fn sub(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn sbb(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
|
||||
let cf: i32 = getcf() as i32;
|
||||
let cf = getcf() as i32;
|
||||
*last_add_result = dest_operand;
|
||||
*last_op2 = source_operand;
|
||||
let res: i32 = dest_operand - source_operand - cf;
|
||||
let res = dest_operand - source_operand - cf;
|
||||
*last_result = res;
|
||||
*last_op1 = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -86,7 +86,7 @@ pub unsafe fn inc(dest_operand: i32, op_size: i32) -> i32 {
|
|||
*flags = *flags & !1 | getcf() as i32;
|
||||
*last_op1 = dest_operand;
|
||||
*last_op2 = 1;
|
||||
let res: i32 = dest_operand + 1;
|
||||
let res = dest_operand + 1;
|
||||
*last_result = res;
|
||||
*last_add_result = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -98,7 +98,7 @@ pub unsafe fn dec(dest_operand: i32, op_size: i32) -> i32 {
|
|||
*flags = *flags & !1 | getcf() as i32;
|
||||
*last_add_result = dest_operand;
|
||||
*last_op2 = 1;
|
||||
let res: i32 = dest_operand - 1;
|
||||
let res = dest_operand - 1;
|
||||
*last_result = res;
|
||||
*last_op1 = *last_result;
|
||||
*last_op_size = op_size;
|
||||
|
|
@ -127,7 +127,7 @@ pub unsafe fn not32(x: i32) -> i32 { return !x; }
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn neg(dest_operand: i32, op_size: i32) -> i32 {
|
||||
let res: i32 = -dest_operand;
|
||||
let res = -dest_operand;
|
||||
*last_result = res;
|
||||
*last_op1 = *last_result;
|
||||
*flags_changed = FLAGS_ALL;
|
||||
|
|
@ -145,7 +145,7 @@ pub unsafe fn neg32(x: i32) -> i32 { return neg(x, OPSIZE_32); }
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn mul8(source_operand: i32) {
|
||||
let result: i32 = source_operand * *reg8.offset(AL as isize) as i32;
|
||||
let result = source_operand * *reg8.offset(AL as isize) as i32;
|
||||
*reg16.offset(AX as isize) = result as u16;
|
||||
*last_result = result & 255;
|
||||
*last_op_size = OPSIZE_8;
|
||||
|
|
@ -159,7 +159,7 @@ pub unsafe fn mul8(source_operand: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn imul8(source_operand: i32) {
|
||||
let result: i32 = source_operand * *reg8s.offset(AL as isize) as i32;
|
||||
let result = source_operand * *reg8s.offset(AL as isize) as i32;
|
||||
*reg16.offset(AX as isize) = result as u16;
|
||||
*last_result = result & 255;
|
||||
*last_op_size = OPSIZE_8;
|
||||
|
|
@ -173,8 +173,8 @@ pub unsafe fn imul8(source_operand: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn mul16(source_operand: u32) {
|
||||
let result: u32 = source_operand.wrapping_mul(*reg16.offset(AX as isize) as u32);
|
||||
let high_result: u32 = result >> 16;
|
||||
let result = source_operand.wrapping_mul(*reg16.offset(AX as isize) as u32);
|
||||
let high_result = result >> 16;
|
||||
*reg16.offset(AX as isize) = result as u16;
|
||||
*reg16.offset(DX as isize) = high_result as u16;
|
||||
*last_result = (result & 0xFFFF) as i32;
|
||||
|
|
@ -189,7 +189,7 @@ pub unsafe fn mul16(source_operand: u32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn imul16(source_operand: i32) {
|
||||
let result: i32 = source_operand * *reg16s.offset(AX as isize) as 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;
|
||||
*last_result = result & 0xFFFF;
|
||||
|
|
@ -206,7 +206,7 @@ pub unsafe fn imul16(source_operand: i32) {
|
|||
pub unsafe fn imul_reg16(mut operand1: i32, mut operand2: i32) -> i32 {
|
||||
operand1 = operand1 << 16 >> 16;
|
||||
operand2 = operand2 << 16 >> 16;
|
||||
let result: i32 = operand1 * operand2;
|
||||
let result = operand1 * operand2;
|
||||
*last_result = result & 0xFFFF;
|
||||
*last_op_size = OPSIZE_16;
|
||||
if result > 32767 || result < -32768 {
|
||||
|
|
@ -220,10 +220,10 @@ pub unsafe fn imul_reg16(mut operand1: i32, mut operand2: i32) -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn mul32(source_operand: i32) {
|
||||
let dest_operand: i32 = *reg32.offset(EAX as isize);
|
||||
let result: u64 = (dest_operand as u32 as u64).wrapping_mul(source_operand as u32 as u64);
|
||||
let result_low: i32 = result as i32;
|
||||
let result_high: i32 = (result >> 32) as i32;
|
||||
let dest_operand = *reg32.offset(EAX as isize);
|
||||
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;
|
||||
*last_result = result_low;
|
||||
|
|
@ -238,10 +238,10 @@ pub unsafe fn mul32(source_operand: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn imul32(source_operand: i32) {
|
||||
let dest_operand: i32 = *reg32.offset(EAX as isize);
|
||||
let result: i64 = dest_operand as i64 * source_operand as i64;
|
||||
let result_low: i32 = result as i32;
|
||||
let result_high: i32 = (result >> 32) as i32;
|
||||
let dest_operand = *reg32.offset(EAX as isize);
|
||||
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;
|
||||
*last_result = result_low;
|
||||
|
|
@ -256,9 +256,9 @@ pub unsafe fn imul32(source_operand: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn imul_reg32(operand1: i32, operand2: i32) -> i32 {
|
||||
let result: i64 = operand1 as i64 * operand2 as i64;
|
||||
let result_low: i32 = result as i32;
|
||||
let result_high: i32 = (result >> 32) as i32;
|
||||
let result = operand1 as i64 * operand2 as i64;
|
||||
let result_low = result as i32;
|
||||
let result_high = (result >> 32) as i32;
|
||||
*last_result = result_low;
|
||||
*last_op_size = OPSIZE_32;
|
||||
if result_high == result_low >> 31 {
|
||||
|
|
@ -273,19 +273,19 @@ pub unsafe fn imul_reg32(operand1: i32, operand2: i32) -> i32 {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn xadd8(source_operand: i32, reg: i32) -> i32 {
|
||||
let tmp: i32 = *reg8.offset(reg as isize) as i32;
|
||||
let tmp = *reg8.offset(reg as isize) as i32;
|
||||
*reg8.offset(reg as isize) = source_operand as u8;
|
||||
return add(source_operand, tmp, OPSIZE_8);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xadd16(source_operand: i32, reg: i32) -> i32 {
|
||||
let tmp: i32 = *reg16.offset(reg as isize) as i32;
|
||||
let tmp = *reg16.offset(reg as isize) as i32;
|
||||
*reg16.offset(reg as isize) = source_operand as u16;
|
||||
return add(source_operand, tmp, OPSIZE_16);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xadd32(source_operand: i32, reg: i32) -> i32 {
|
||||
let tmp: i32 = *reg32.offset(reg as isize);
|
||||
let tmp = *reg32.offset(reg as isize);
|
||||
*reg32.offset(reg as isize) = source_operand;
|
||||
return add(source_operand, tmp, OPSIZE_32);
|
||||
}
|
||||
|
|
@ -326,9 +326,9 @@ pub unsafe fn cmpxchg32(data: i32, r: i32) -> i32 {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn bcd_daa() {
|
||||
let old_al: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let old_cf: i32 = getcf() as i32;
|
||||
let old_af: i32 = getaf() as i32;
|
||||
let old_al = *reg8.offset(AL as isize) as i32;
|
||||
let old_cf = getcf() as i32;
|
||||
let old_af = getaf() as i32;
|
||||
*flags &= !1 & !FLAG_ADJUST;
|
||||
if old_al & 15 > 9 || 0 != old_af {
|
||||
*reg8.offset(AL as isize) += 6;
|
||||
|
|
@ -346,8 +346,8 @@ pub unsafe fn bcd_daa() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn bcd_das() {
|
||||
let old_al: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let old_cf: i32 = getcf() as i32;
|
||||
let old_al = *reg8.offset(AL as isize) as i32;
|
||||
let old_cf = getcf() as i32;
|
||||
*flags &= !1;
|
||||
if old_al & 15 > 9 || 0 != getaf() as i32 {
|
||||
*reg8.offset(AL as isize) -= 6;
|
||||
|
|
@ -369,7 +369,7 @@ pub unsafe fn bcd_das() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn bcd_aad(imm8: i32) {
|
||||
let result: i32 = *reg8.offset(AL as isize) as i32 + *reg8.offset(AH as isize) as i32 * imm8;
|
||||
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;
|
||||
*last_op_size = OPSIZE_8;
|
||||
|
|
@ -386,7 +386,7 @@ pub unsafe fn bcd_aam(imm8: i32) {
|
|||
trigger_de();
|
||||
}
|
||||
else {
|
||||
let temp: u8 = *reg8.offset(AL as isize);
|
||||
let temp = *reg8.offset(AL as isize);
|
||||
*reg8.offset(AH as isize) = (temp as i32 / imm8) as u8;
|
||||
*reg8.offset(AL as isize) = (temp as i32 % imm8) as u8;
|
||||
*last_result = *reg8.offset(AL as isize) as i32;
|
||||
|
|
@ -477,7 +477,7 @@ pub unsafe fn rol8(dest_operand: i32, mut count: i32) -> i32 {
|
|||
}
|
||||
else {
|
||||
count &= 7;
|
||||
let result: i32 = dest_operand << count | dest_operand >> 8 - count;
|
||||
let result = dest_operand << count | dest_operand >> 8 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result & 1
|
||||
|
|
@ -493,7 +493,7 @@ pub unsafe fn rol16(dest_operand: i32, mut count: i32) -> i32 {
|
|||
}
|
||||
else {
|
||||
count &= 15;
|
||||
let result: i32 = dest_operand << count | dest_operand >> 16 - count;
|
||||
let result = dest_operand << count | dest_operand >> 16 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result & 1
|
||||
|
|
@ -508,8 +508,7 @@ pub unsafe fn rol32(dest_operand: i32, count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
((dest_operand << count) as u32 | dest_operand as u32 >> 32 - count) as i32;
|
||||
let result = ((dest_operand << count) as u32 | dest_operand as u32 >> 32 - count) as i32;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result & 1
|
||||
|
|
@ -525,7 +524,7 @@ pub unsafe fn rcl8(dest_operand: i32, mut count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
let result =
|
||||
dest_operand << count | (getcf() as i32) << count - 1 | dest_operand >> 9 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
|
|
@ -542,7 +541,7 @@ pub unsafe fn rcl16(dest_operand: i32, mut count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
let result =
|
||||
dest_operand << count | (getcf() as i32) << count - 1 | dest_operand >> 17 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
|
|
@ -577,7 +576,7 @@ pub unsafe fn ror8(dest_operand: i32, mut count: i32) -> i32 {
|
|||
}
|
||||
else {
|
||||
count &= 7;
|
||||
let result: i32 = dest_operand >> count | dest_operand << 8 - count;
|
||||
let result = dest_operand >> count | dest_operand << 8 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result >> 7 & 1
|
||||
|
|
@ -593,7 +592,7 @@ pub unsafe fn ror16(dest_operand: i32, mut count: i32) -> i32 {
|
|||
}
|
||||
else {
|
||||
count &= 15;
|
||||
let result: i32 = dest_operand >> count | dest_operand << 16 - count;
|
||||
let result = dest_operand >> count | dest_operand << 16 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result >> 15 & 1
|
||||
|
|
@ -608,8 +607,7 @@ pub unsafe fn ror32(dest_operand: i32, count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
(dest_operand as u32 >> count | (dest_operand << 32 - count) as u32) as i32;
|
||||
let result = (dest_operand as u32 >> count | (dest_operand << 32 - count) as u32) as i32;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
| result >> 31 & 1
|
||||
|
|
@ -625,7 +623,7 @@ pub unsafe fn rcr8(dest_operand: i32, mut count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
let result =
|
||||
dest_operand >> count | (getcf() as i32) << 8 - count | dest_operand << 9 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
|
|
@ -642,7 +640,7 @@ pub unsafe fn rcr16(dest_operand: i32, mut count: i32) -> i32 {
|
|||
return dest_operand;
|
||||
}
|
||||
else {
|
||||
let result: i32 =
|
||||
let result =
|
||||
dest_operand >> count | (getcf() as i32) << 16 - count | dest_operand << 17 - count;
|
||||
*flags_changed &= !1 & !FLAG_OVERFLOW;
|
||||
*flags = *flags & !1 & !FLAG_OVERFLOW
|
||||
|
|
@ -677,8 +675,8 @@ pub unsafe fn div8(source_operand: u32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_operand: u16 = *reg16.offset(AX as isize);
|
||||
let result: u16 = (target_operand as u32).wrapping_div(source_operand) as u16;
|
||||
let target_operand = *reg16.offset(AX as isize);
|
||||
let result = (target_operand as u32).wrapping_div(source_operand) as u16;
|
||||
if result as i32 >= 256 {
|
||||
trigger_de();
|
||||
}
|
||||
|
|
@ -697,8 +695,8 @@ pub unsafe fn idiv8(source_operand: i32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_operand: i32 = *reg16s.offset(AX as isize) as i32;
|
||||
let result: i32 = target_operand / source_operand;
|
||||
let target_operand = *reg16s.offset(AX as isize) as i32;
|
||||
let result = target_operand / source_operand;
|
||||
if result >= 128 || result <= -129 {
|
||||
trigger_de();
|
||||
}
|
||||
|
|
@ -716,9 +714,9 @@ pub unsafe fn div16(source_operand: u32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_operand: u32 =
|
||||
let target_operand =
|
||||
(*reg16.offset(AX as isize) as i32 | (*reg16.offset(DX as isize) as i32) << 16) as u32;
|
||||
let result: u32 = target_operand.wrapping_div(source_operand);
|
||||
let result = target_operand.wrapping_div(source_operand);
|
||||
if result >= 0x10000 {
|
||||
trigger_de();
|
||||
}
|
||||
|
|
@ -736,9 +734,9 @@ pub unsafe fn idiv16(source_operand: i32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_operand: i32 =
|
||||
let target_operand =
|
||||
*reg16.offset(AX as isize) as i32 | (*reg16.offset(DX as isize) as i32) << 16;
|
||||
let result: i32 = target_operand / source_operand;
|
||||
let result = target_operand / source_operand;
|
||||
if result >= 32768 || result <= -32769 {
|
||||
trigger_de();
|
||||
}
|
||||
|
|
@ -756,16 +754,16 @@ pub unsafe fn div32(source_operand: u32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_low: u32 = *reg32.offset(EAX as isize) as u32;
|
||||
let target_high: u32 = *reg32.offset(EDX as isize) as u32;
|
||||
let target_operand: u64 = (target_high as u64) << 32 | target_low as u64;
|
||||
let result: u64 = target_operand.wrapping_div(source_operand as u64);
|
||||
let target_low = *reg32.offset(EAX as isize) as u32;
|
||||
let target_high = *reg32.offset(EDX as isize) 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 {
|
||||
trigger_de();
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mod_0: i32 = target_operand.wrapping_rem(source_operand as u64) as i32;
|
||||
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;
|
||||
return;
|
||||
|
|
@ -779,21 +777,21 @@ pub unsafe fn idiv32(source_operand: i32) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let target_low: u32 = *reg32.offset(EAX as isize) as u32;
|
||||
let target_high: u32 = *reg32.offset(EDX as isize) as u32;
|
||||
let target_operand: i64 = ((target_high as u64) << 32 | target_low as u64) as i64;
|
||||
let target_low = *reg32.offset(EAX as isize) as u32;
|
||||
let target_high = *reg32.offset(EDX as isize) 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 {
|
||||
trigger_de();
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let result: i64 = target_operand / source_operand as i64;
|
||||
let result = target_operand / source_operand as i64;
|
||||
if result < -0x80000000 || result > 0x7FFFFFFF {
|
||||
trigger_de();
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mod_0: i32 = (target_operand % source_operand as i64) as i32;
|
||||
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;
|
||||
return;
|
||||
|
|
@ -1061,7 +1059,7 @@ pub unsafe fn btr_reg(bit_base: i32, bit_offset: i32) -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn bt_mem(virt_addr: i32, mut bit_offset: i32) {
|
||||
let bit_base: i32 = return_on_pagefault!(safe_read8(virt_addr + (bit_offset >> 3)));
|
||||
let bit_base = return_on_pagefault!(safe_read8(virt_addr + (bit_offset >> 3)));
|
||||
bit_offset &= 7;
|
||||
*flags = *flags & !1 | bit_base >> bit_offset & 1;
|
||||
*flags_changed &= !1;
|
||||
|
|
@ -1069,7 +1067,7 @@ pub unsafe fn bt_mem(virt_addr: i32, mut bit_offset: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn btc_mem(virt_addr: i32, mut bit_offset: i32) {
|
||||
let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
|
||||
let bit_base: i32 = read8(phys_addr);
|
||||
let bit_base = read8(phys_addr);
|
||||
bit_offset &= 7;
|
||||
*flags = *flags & !1 | bit_base >> bit_offset & 1;
|
||||
*flags_changed &= !1;
|
||||
|
|
@ -1078,7 +1076,7 @@ pub unsafe fn btc_mem(virt_addr: i32, mut bit_offset: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn btr_mem(virt_addr: i32, mut bit_offset: i32) {
|
||||
let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
|
||||
let bit_base: i32 = read8(phys_addr);
|
||||
let bit_base = read8(phys_addr);
|
||||
bit_offset &= 7;
|
||||
*flags = *flags & !1 | bit_base >> bit_offset & 1;
|
||||
*flags_changed &= !1;
|
||||
|
|
@ -1087,7 +1085,7 @@ pub unsafe fn btr_mem(virt_addr: i32, mut bit_offset: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn bts_mem(virt_addr: i32, mut bit_offset: i32) {
|
||||
let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
|
||||
let bit_base: i32 = read8(phys_addr);
|
||||
let bit_base = read8(phys_addr);
|
||||
bit_offset &= 7;
|
||||
*flags = *flags & !1 | bit_base >> bit_offset & 1;
|
||||
*flags_changed &= !1;
|
||||
|
|
|
|||
|
|
@ -1014,9 +1014,9 @@ pub unsafe fn get_eflags() -> i32 {
|
|||
pub unsafe fn get_eflags_no_arith() -> i32 { return *flags; }
|
||||
|
||||
pub unsafe fn translate_address_read(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
let user = *cpl as i32 == 3;
|
||||
if entry & (TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 }) == TLB_VALID {
|
||||
Ok((entry & !0xFFF ^ address) as u32)
|
||||
}
|
||||
|
|
@ -1026,9 +1026,9 @@ pub unsafe fn translate_address_read(address: i32) -> OrPageFault<u32> {
|
|||
}
|
||||
|
||||
pub unsafe fn translate_address_read_jit(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
let user = *cpl as i32 == 3;
|
||||
if entry & (TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 }) == TLB_VALID {
|
||||
Ok((entry & !0xFFF ^ address) as u32)
|
||||
}
|
||||
|
|
@ -1064,7 +1064,7 @@ pub unsafe fn do_page_walk(addr: i32, for_writing: bool, user: bool) -> Result<i
|
|||
let mut can_write: bool = true;
|
||||
let global;
|
||||
let mut allow_user: bool = true;
|
||||
let page: i32 = (addr as u32 >> 12) as i32;
|
||||
let page = (addr as u32 >> 12) as i32;
|
||||
let high;
|
||||
if *cr & CR0_PG == 0 {
|
||||
// paging disabled
|
||||
|
|
@ -1072,11 +1072,10 @@ pub unsafe fn do_page_walk(addr: i32, for_writing: bool, user: bool) -> Result<i
|
|||
global = false
|
||||
}
|
||||
else {
|
||||
let page_dir_addr: i32 =
|
||||
(*cr.offset(3) as u32 >> 2).wrapping_add((page >> 10) as u32) as i32;
|
||||
let page_dir_entry: i32 = read_aligned32(page_dir_addr as u32);
|
||||
let page_dir_addr = (*cr.offset(3) as u32 >> 2).wrapping_add((page >> 10) as u32) as i32;
|
||||
let page_dir_entry = read_aligned32(page_dir_addr as u32);
|
||||
// XXX
|
||||
let kernel_write_override: bool = !user && 0 == *cr & CR0_WP;
|
||||
let kernel_write_override = !user && 0 == *cr & CR0_WP;
|
||||
if 0 == page_dir_entry & PAGE_TABLE_PRESENT_MASK {
|
||||
// to do at this place:
|
||||
//
|
||||
|
|
@ -1134,9 +1133,9 @@ pub unsafe fn do_page_walk(addr: i32, for_writing: bool, user: bool) -> Result<i
|
|||
global = page_dir_entry & PAGE_TABLE_GLOBAL_MASK == PAGE_TABLE_GLOBAL_MASK
|
||||
}
|
||||
else {
|
||||
let page_table_addr: i32 = ((page_dir_entry as u32 & 0xFFFFF000) >> 2)
|
||||
let page_table_addr = ((page_dir_entry as u32 & 0xFFFFF000) >> 2)
|
||||
.wrapping_add((page & 1023) as u32) as i32;
|
||||
let page_table_entry: i32 = read_aligned32(page_table_addr as u32);
|
||||
let page_table_entry = read_aligned32(page_table_addr as u32);
|
||||
if page_table_entry & PAGE_TABLE_PRESENT_MASK == 0 {
|
||||
return Err(PageFault {
|
||||
addr,
|
||||
|
|
@ -1217,11 +1216,11 @@ pub unsafe fn do_page_walk(addr: i32, for_writing: bool, user: bool) -> Result<i
|
|||
}
|
||||
dbg_assert!(found);
|
||||
}
|
||||
let is_in_mapped_range: bool = in_mapped_range(high as u32);
|
||||
let physical_page: i32 = (high as u32 >> 12) as i32;
|
||||
let has_code: bool =
|
||||
let is_in_mapped_range = in_mapped_range(high as u32);
|
||||
let physical_page = (high as u32 >> 12) as i32;
|
||||
let has_code =
|
||||
!is_in_mapped_range && 0 != ::c_api::jit_page_has_code(physical_page as u32) as i32;
|
||||
let info_bits: i32 = TLB_VALID
|
||||
let info_bits = TLB_VALID
|
||||
| if 0 != can_write as i32 {
|
||||
0
|
||||
}
|
||||
|
|
@ -1264,7 +1263,7 @@ pub unsafe fn full_clear_tlb() {
|
|||
*last_virt_eip = -1;
|
||||
*last_virt_esp = -1;
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
*tlb_data.offset(page as isize) = 0;
|
||||
}
|
||||
valid_tlb_entries_count = 0;
|
||||
|
|
@ -1283,8 +1282,8 @@ pub unsafe fn clear_tlb() {
|
|||
*last_virt_esp = -1;
|
||||
let mut global_page_offset: i32 = 0;
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let entry: i32 = *tlb_data.offset(page as isize);
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
let entry = *tlb_data.offset(page as isize);
|
||||
if 0 != entry & TLB_GLOBAL {
|
||||
// reinsert at the front
|
||||
valid_tlb_entries[global_page_offset as usize] = page;
|
||||
|
|
@ -1397,9 +1396,9 @@ pub unsafe fn trigger_pagefault(fault: PageFault) {
|
|||
}
|
||||
|
||||
pub unsafe fn translate_address_write(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
let user = *cpl as i32 == 3;
|
||||
if entry & (TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 } | TLB_READONLY)
|
||||
== TLB_VALID
|
||||
{
|
||||
|
|
@ -1411,9 +1410,9 @@ pub unsafe fn translate_address_write(address: i32) -> OrPageFault<u32> {
|
|||
}
|
||||
|
||||
pub unsafe fn translate_address_write_jit(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
let user = *cpl as i32 == 3;
|
||||
if entry & (TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 } | TLB_READONLY)
|
||||
== TLB_VALID
|
||||
{
|
||||
|
|
@ -1434,10 +1433,10 @@ pub unsafe fn translate_address_write_jit(address: i32) -> OrPageFault<u32> {
|
|||
pub unsafe fn tlb_set_has_code(physical_page: Page, has_code: bool) {
|
||||
let physical_page = physical_page.to_u32();
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let entry: i32 = *tlb_data.offset(page as isize);
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
let entry = *tlb_data.offset(page as isize);
|
||||
if 0 != entry {
|
||||
let tlb_physical_page: u32 = entry as u32 >> 12 ^ page as u32;
|
||||
let tlb_physical_page = entry as u32 >> 12 ^ page as u32;
|
||||
if physical_page == tlb_physical_page {
|
||||
*tlb_data.offset(page as isize) = if 0 != has_code as i32 {
|
||||
entry | TLB_HAS_CODE
|
||||
|
|
@ -1458,8 +1457,8 @@ pub unsafe fn check_tlb_invariants() {
|
|||
}
|
||||
else {
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let entry: i32 = *tlb_data.offset(page as isize);
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
let entry = *tlb_data.offset(page as isize);
|
||||
if 0 == entry || 0 != entry & TLB_IN_MAPPED_RANGE {
|
||||
// there's no code in mapped memory
|
||||
}
|
||||
|
|
@ -1475,14 +1474,14 @@ pub unsafe fn writable_or_pagefault(addr: i32, size: i32) -> OrPageFault<()> {
|
|||
return Ok(());
|
||||
}
|
||||
else {
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let mask: i32 = TLB_READONLY | TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 };
|
||||
let expect: i32 = TLB_VALID;
|
||||
let page: i32 = (addr as u32 >> 12) as i32;
|
||||
let user = *cpl as i32 == 3;
|
||||
let mask = TLB_READONLY | TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 };
|
||||
let expect = TLB_VALID;
|
||||
let page = (addr as u32 >> 12) as i32;
|
||||
if *tlb_data.offset(page as isize) & mask != expect {
|
||||
do_page_translation(addr, true, user)?;
|
||||
}
|
||||
let next_page: i32 = ((addr + size - 1) as u32 >> 12) as i32;
|
||||
let next_page = ((addr + size - 1) as u32 >> 12) as i32;
|
||||
if page != next_page {
|
||||
dbg_assert!(next_page == page + 1);
|
||||
// XXX: possibly out of bounds
|
||||
|
|
@ -1501,14 +1500,14 @@ pub unsafe fn writable_or_pagefault_jit(addr: i32, size: i32) -> OrPageFault<()>
|
|||
return Ok(());
|
||||
}
|
||||
else {
|
||||
let user: bool = *cpl as i32 == 3;
|
||||
let mask: i32 = TLB_READONLY | TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 };
|
||||
let expect: i32 = TLB_VALID;
|
||||
let page: i32 = (addr as u32 >> 12) as i32;
|
||||
let user = *cpl as i32 == 3;
|
||||
let mask = TLB_READONLY | TLB_VALID | if 0 != user as i32 { TLB_NO_USER } else { 0 };
|
||||
let expect = TLB_VALID;
|
||||
let page = (addr as u32 >> 12) as i32;
|
||||
if *tlb_data.offset(page as isize) & mask != expect {
|
||||
translate_address_write_jit(addr)?;
|
||||
}
|
||||
let next_page: i32 = ((addr + size - 1) as u32 >> 12) as i32;
|
||||
let next_page = ((addr + size - 1) as u32 >> 12) as i32;
|
||||
if page != next_page {
|
||||
dbg_assert!(next_page == page + 1);
|
||||
// XXX: possibly out of bounds
|
||||
|
|
@ -1521,13 +1520,13 @@ pub unsafe fn writable_or_pagefault_jit(addr: i32, size: i32) -> OrPageFault<()>
|
|||
}
|
||||
|
||||
pub unsafe fn read_imm8() -> OrPageFault<i32> {
|
||||
let eip: i32 = *instruction_pointer;
|
||||
let eip = *instruction_pointer;
|
||||
if 0 != eip & !0xFFF ^ *last_virt_eip {
|
||||
*eip_phys = (translate_address_read(eip)? ^ eip as u32) as i32;
|
||||
*last_virt_eip = eip & !0xFFF
|
||||
}
|
||||
dbg_assert!(!in_mapped_range((*eip_phys ^ eip) as u32));
|
||||
let data8: i32 = *mem8.offset((*eip_phys ^ eip) as isize) as i32;
|
||||
let data8 = *mem8.offset((*eip_phys ^ eip) as isize) as i32;
|
||||
*instruction_pointer = eip + 1;
|
||||
return Ok(data8);
|
||||
}
|
||||
|
|
@ -1542,7 +1541,7 @@ pub unsafe fn read_imm16() -> OrPageFault<i32> {
|
|||
return Ok(read_imm8()? | read_imm8()? << 8);
|
||||
}
|
||||
else {
|
||||
let data16: i32 = read16((*eip_phys ^ *instruction_pointer) as u32);
|
||||
let data16 = read16((*eip_phys ^ *instruction_pointer) as u32);
|
||||
*instruction_pointer = *instruction_pointer + 2;
|
||||
return Ok(data16);
|
||||
};
|
||||
|
|
@ -1554,7 +1553,7 @@ pub unsafe fn read_imm32s() -> OrPageFault<i32> {
|
|||
return Ok(read_imm16()? | read_imm16()? << 16);
|
||||
}
|
||||
else {
|
||||
let data32: i32 = read32s((*eip_phys ^ *instruction_pointer) as u32);
|
||||
let data32 = read32s((*eip_phys ^ *instruction_pointer) as u32);
|
||||
*instruction_pointer = *instruction_pointer + 4;
|
||||
return Ok(data32);
|
||||
};
|
||||
|
|
@ -1842,7 +1841,7 @@ pub unsafe fn get_seg_cs() -> i32 { return *segment_offsets.offset(CS as isize);
|
|||
pub unsafe fn get_seg_ss() -> i32 { return *segment_offsets.offset(SS as isize); }
|
||||
|
||||
pub unsafe fn get_seg_prefix(default_segment: i32) -> i32 {
|
||||
let prefix: i32 = *prefixes as i32 & PREFIX_MASK_SEGMENT;
|
||||
let prefix = *prefixes as i32 & PREFIX_MASK_SEGMENT;
|
||||
if 0 != prefix {
|
||||
if prefix == SEG_PREFIX_ZERO {
|
||||
return 0;
|
||||
|
|
@ -1878,9 +1877,9 @@ pub unsafe fn cycle_internal() {
|
|||
profiler::stat_increment(CYCLE_INTERNAL);
|
||||
if !::config::FORCE_DISABLE_JIT {
|
||||
*previous_ip = *instruction_pointer;
|
||||
let phys_addr: u32 = return_on_pagefault!(get_phys_eip()) as u32;
|
||||
let phys_addr = return_on_pagefault!(get_phys_eip()) as u32;
|
||||
let state_flags = pack_current_state_flags();
|
||||
let entry: u32 = ::c_api::jit_find_cache_entry(phys_addr, state_flags);
|
||||
let entry = ::c_api::jit_find_cache_entry(phys_addr, state_flags);
|
||||
|
||||
if 0 != entry {
|
||||
profiler::stat_increment(RUN_FROM_CACHE);
|
||||
|
|
@ -1969,12 +1968,12 @@ pub unsafe fn cycle_internal() {
|
|||
}
|
||||
|
||||
pub unsafe fn get_phys_eip() -> OrPageFault<u32> {
|
||||
let eip: i32 = *instruction_pointer;
|
||||
let eip = *instruction_pointer;
|
||||
if 0 != eip & !0xFFF ^ *last_virt_eip {
|
||||
*eip_phys = (translate_address_read(eip)? ^ eip as u32) as i32;
|
||||
*last_virt_eip = eip & !0xFFF
|
||||
}
|
||||
let phys_addr: u32 = (*eip_phys ^ eip) as u32;
|
||||
let phys_addr = (*eip_phys ^ eip) as u32;
|
||||
dbg_assert!(!in_mapped_range(phys_addr));
|
||||
return Ok(phys_addr);
|
||||
}
|
||||
|
|
@ -2079,7 +2078,7 @@ pub unsafe fn segment_prefix_op(seg: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn do_many_cycles_native() {
|
||||
profiler::stat_increment(DO_MANY_CYCLES);
|
||||
let initial_timestamp_counter: u32 = *timestamp_counter;
|
||||
let initial_timestamp_counter = *timestamp_counter;
|
||||
while (*timestamp_counter).wrapping_sub(initial_timestamp_counter) < LOOP_COUNTER as u32
|
||||
&& !*in_hlt
|
||||
{
|
||||
|
|
@ -2730,7 +2729,7 @@ pub unsafe fn write_xmm64(r: i32, data: reg64) {
|
|||
}
|
||||
|
||||
pub unsafe fn write_xmm128(r: i32, i0: i32, i1: i32, i2: i32, i3: i32) {
|
||||
let x: reg128 = reg128 {
|
||||
let x = reg128 {
|
||||
u32_0: [i0 as u32, i1 as u32, i2 as u32, i3 as u32],
|
||||
};
|
||||
*reg_xmm.offset(r as isize) = x;
|
||||
|
|
@ -2854,7 +2853,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: i32 = *reg32.offset(reg as isize);
|
||||
let r = *reg32.offset(reg as isize);
|
||||
if is_asize_32() {
|
||||
return r;
|
||||
}
|
||||
|
|
@ -2895,14 +2894,14 @@ pub unsafe fn decr_ecx_asize() -> i32 {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn set_tsc(low: u32, high: u32) {
|
||||
let new_value: u64 = low as u64 | (high as u64) << 32;
|
||||
let current_value: u64 = read_tsc();
|
||||
let new_value = low as u64 | (high as u64) << 32;
|
||||
let current_value = read_tsc();
|
||||
tsc_offset = current_value.wrapping_sub(new_value);
|
||||
}
|
||||
|
||||
pub unsafe fn read_tsc() -> u64 {
|
||||
let n: f64 = microtick() * TSC_RATE;
|
||||
let value: u64 = (n as u64).wrapping_sub(tsc_offset);
|
||||
let n = microtick() * TSC_RATE;
|
||||
let value = (n as u64).wrapping_sub(tsc_offset);
|
||||
if true {
|
||||
return value;
|
||||
}
|
||||
|
|
@ -2914,7 +2913,7 @@ pub unsafe fn read_tsc() -> u64 {
|
|||
}
|
||||
}
|
||||
else {
|
||||
let previous_value: u64 = rdtsc_last_value.wrapping_add(rdtsc_imprecision_offset);
|
||||
let previous_value = rdtsc_last_value.wrapping_add(rdtsc_imprecision_offset);
|
||||
if previous_value <= value {
|
||||
rdtsc_last_value = value;
|
||||
rdtsc_imprecision_offset = 0
|
||||
|
|
@ -2973,7 +2972,7 @@ pub unsafe fn get_opstats_buffer(
|
|||
}
|
||||
|
||||
pub unsafe fn invlpg(addr: i32) {
|
||||
let page: i32 = (addr as u32 >> 12) as i32;
|
||||
let page = (addr as u32 >> 12) as i32;
|
||||
// Note: Doesn't remove this page from valid_tlb_entries: This isn't
|
||||
// necessary, because when valid_tlb_entries grows too large, it will be
|
||||
// empties by calling clear_tlb, which removes this entry as it isn't global.
|
||||
|
|
@ -3020,8 +3019,8 @@ pub unsafe fn get_valid_tlb_entries_count() -> i32 {
|
|||
}
|
||||
let mut result: i32 = 0;
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let entry: i32 = *tlb_data.offset(page as isize);
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
let entry = *tlb_data.offset(page as isize);
|
||||
if 0 != entry {
|
||||
result += 1
|
||||
}
|
||||
|
|
@ -3036,8 +3035,8 @@ pub unsafe fn get_valid_global_tlb_entries_count() -> i32 {
|
|||
}
|
||||
let mut result: i32 = 0;
|
||||
for i in 0..valid_tlb_entries_count {
|
||||
let page: i32 = valid_tlb_entries[i as usize];
|
||||
let entry: i32 = *tlb_data.offset(page as isize);
|
||||
let page = valid_tlb_entries[i as usize];
|
||||
let entry = *tlb_data.offset(page as isize);
|
||||
if 0 != entry & TLB_GLOBAL {
|
||||
result += 1
|
||||
}
|
||||
|
|
@ -3046,8 +3045,8 @@ pub unsafe fn get_valid_global_tlb_entries_count() -> i32 {
|
|||
}
|
||||
|
||||
pub unsafe fn translate_address_system_read(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
if 0 != entry & TLB_VALID {
|
||||
return Ok((entry & !0xFFF ^ address) as u32);
|
||||
}
|
||||
|
|
@ -3057,8 +3056,8 @@ pub unsafe fn translate_address_system_read(address: i32) -> OrPageFault<u32> {
|
|||
}
|
||||
|
||||
pub unsafe fn translate_address_system_write(address: i32) -> OrPageFault<u32> {
|
||||
let base: i32 = (address as u32 >> 12) as i32;
|
||||
let entry: i32 = *tlb_data.offset(base as isize);
|
||||
let base = (address as u32 >> 12) as i32;
|
||||
let entry = *tlb_data.offset(base as isize);
|
||||
if entry & (TLB_VALID | TLB_READONLY) == TLB_VALID {
|
||||
return Ok((entry & !0xFFF ^ address) as u32);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ impl FloatParts {
|
|||
let d = (self.sign as u64) << F64_SIGN_SHIFT
|
||||
| (self.exponent as u64) << F64_EXPONENT_SHIFT
|
||||
| self.mantissa;
|
||||
let f: f64 = unsafe { transmute(d) };
|
||||
let f = unsafe { transmute(d) };
|
||||
f
|
||||
}
|
||||
|
||||
|
|
@ -119,12 +119,12 @@ pub unsafe fn fpu_get_sti(mut i: i32) -> f64 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_integer_round(f: f64) -> f64 {
|
||||
let rc: i32 = *fpu_control_word >> 10 & 3;
|
||||
let rc = *fpu_control_word >> 10 & 3;
|
||||
// XXX: See https://en.wikipedia.org/wiki/C_mathematical_functions
|
||||
if rc == 0 {
|
||||
// Round to nearest, or even if equidistant
|
||||
let mut rounded: f64 = round(f);
|
||||
let diff: f64 = rounded - f;
|
||||
let diff = rounded - f;
|
||||
if diff == 0.5f64 || diff == -0.5f64 {
|
||||
rounded = 2.0f64 * round(f * 0.5f64)
|
||||
}
|
||||
|
|
@ -145,29 +145,29 @@ pub unsafe fn fpu_load_m32(addr: i32) -> OrPageFault<f64> {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_load_m64(addr: i32) -> OrPageFault<f64> {
|
||||
let value: u64 = safe_read64s(addr)?.u64_0[0];
|
||||
let f: f64 = transmute(value);
|
||||
let value = safe_read64s(addr)?.u64_0[0];
|
||||
let f = transmute(value);
|
||||
Ok(f)
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_load_m80(addr: i32) -> OrPageFault<f64> {
|
||||
let value: u64 = safe_read64s(addr as i32)?.u64_0[0];
|
||||
let exponent: i32 = safe_read16(addr.wrapping_add(8) as i32)?;
|
||||
let value = safe_read64s(addr as i32)?.u64_0[0];
|
||||
let exponent = safe_read16(addr.wrapping_add(8) as i32)?;
|
||||
let f = fpu_f80_to_f64((value, exponent as u16));
|
||||
Ok(f)
|
||||
}
|
||||
|
||||
pub unsafe fn fpu_f80_to_f64(i: (u64, u16)) -> f64 {
|
||||
let mantissa: u64 = i.0;
|
||||
let mantissa = i.0;
|
||||
let exponent = i.1 & F80_EXPONENT_MASK;
|
||||
let sign = i.1 >> 15 == 1;
|
||||
|
||||
if exponent == 0 {
|
||||
// Denormal number
|
||||
// A few bits of precision lost and "integer part" bit ignored
|
||||
let d: u64 = (sign as u64) << F64_SIGN_SHIFT | (mantissa >> 11 & F64_MANTISSA_MASK);
|
||||
let f: f64 = transmute(d);
|
||||
let d = (sign as u64) << F64_SIGN_SHIFT | (mantissa >> 11 & F64_MANTISSA_MASK);
|
||||
let f = transmute(d);
|
||||
f
|
||||
}
|
||||
else if exponent < F80_EXPONENT_NAN_INF {
|
||||
|
|
@ -203,7 +203,7 @@ mod tests {
|
|||
fn test_f80_f64_conversion(d: u64) -> bool {
|
||||
let f = unsafe { transmute(d) };
|
||||
let f2 = unsafe { fpu_f80_to_f64(fpu_f64_to_f80(f)) };
|
||||
let d2: u64 = unsafe { transmute(f2) };
|
||||
let d2 = unsafe { transmute(f2) };
|
||||
d == d2
|
||||
}
|
||||
|
||||
|
|
@ -216,7 +216,7 @@ mod tests {
|
|||
let f = unsafe { transmute(d) };
|
||||
let mut parts = FloatParts::of_f64(f);
|
||||
parts.exponent = F64_EXPONENT_NAN_INF;
|
||||
let d: u64 = unsafe { transmute(parts.to_f64()) };
|
||||
let d = unsafe { transmute(parts.to_f64()) };
|
||||
test_f80_f64_conversion(d)
|
||||
}
|
||||
|
||||
|
|
@ -224,7 +224,7 @@ mod tests {
|
|||
let f = unsafe { transmute(d) };
|
||||
let mut parts = FloatParts::of_f64(f);
|
||||
parts.exponent = 0;
|
||||
let d: u64 = unsafe { transmute(parts.to_f64()) };
|
||||
let d = unsafe { transmute(parts.to_f64()) };
|
||||
test_f80_f64_conversion(d)
|
||||
}
|
||||
}
|
||||
|
|
@ -241,7 +241,7 @@ pub unsafe fn fpu_load_status_word() -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fadd(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
fpu_write_st(*fpu_stack_ptr as i32 + target_index & 7, st0 + val);
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -263,7 +263,7 @@ pub unsafe fn fpu_fcmovcc(condition: bool, r: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fcom(y: f64) {
|
||||
let x: f64 = fpu_get_st0();
|
||||
let x = fpu_get_st0();
|
||||
*fpu_status_word &= !FPU_RESULT_FLAGS;
|
||||
if !(x > y) {
|
||||
if y > x {
|
||||
|
|
@ -279,8 +279,8 @@ pub unsafe fn fpu_fcom(y: f64) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fcomi(r: i32) {
|
||||
let y: f64 = fpu_get_sti(r);
|
||||
let x: f64 = *fpu_st.offset(*fpu_stack_ptr as isize);
|
||||
let y = fpu_get_sti(r);
|
||||
let x = *fpu_st.offset(*fpu_stack_ptr as isize);
|
||||
*flags_changed &= !(1 | FLAG_PARITY | FLAG_ZERO | FLAG_ADJUST | FLAG_SIGN | FLAG_OVERFLOW);
|
||||
*flags &= !(1 | FLAG_PARITY | FLAG_ZERO | FLAG_ADJUST | FLAG_SIGN | FLAG_OVERFLOW);
|
||||
if !(x > y) {
|
||||
|
|
@ -312,7 +312,7 @@ pub unsafe fn fpu_fcomp(val: f64) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fdiv(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
if val == 0.0 {
|
||||
fpu_zero_fault();
|
||||
}
|
||||
|
|
@ -320,7 +320,7 @@ pub unsafe fn fpu_fdiv(target_index: i32, val: f64) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fdivr(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
if st0 == 0.0 {
|
||||
fpu_zero_fault();
|
||||
}
|
||||
|
|
@ -332,8 +332,8 @@ pub unsafe fn fpu_ffree(r: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fildm64(addr: i32) {
|
||||
let value: i64 = return_on_pagefault!(safe_read64s(addr)).i64_0[0];
|
||||
let m64: f64 = value as f64;
|
||||
let value = return_on_pagefault!(safe_read64s(addr)).i64_0[0];
|
||||
let m64 = value as f64;
|
||||
fpu_push(m64);
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -366,7 +366,7 @@ pub unsafe fn fpu_invalid_arithmetic() { *fpu_status_word |= FPU_EX_I; }
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_convert_to_i16(f: f64) -> i16 {
|
||||
let st0: f64 = fpu_integer_round(f);
|
||||
let st0 = fpu_integer_round(f);
|
||||
if st0 <= 32767.0 && st0 >= -32768.0 {
|
||||
st0 as i16
|
||||
}
|
||||
|
|
@ -410,7 +410,7 @@ pub unsafe fn fpu_fistm32p(addr: i32) {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_convert_to_i64(f: f64) -> i64 {
|
||||
let st0: f64 = fpu_integer_round(f);
|
||||
let st0 = fpu_integer_round(f);
|
||||
if st0 < TWO_POW_63 && st0 >= -TWO_POW_63 {
|
||||
st0 as i64
|
||||
}
|
||||
|
|
@ -428,7 +428,7 @@ pub unsafe fn fpu_fistm64p(addr: i32) {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fldcw(addr: i32) {
|
||||
let word: i32 = return_on_pagefault!(safe_read16(addr));
|
||||
let word = return_on_pagefault!(safe_read16(addr));
|
||||
*fpu_control_word = word;
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -498,7 +498,7 @@ pub unsafe fn fpu_fldm80(addr: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fmul(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
fpu_write_st(*fpu_stack_ptr as i32 + target_index & 7, st0 * val);
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -513,13 +513,13 @@ pub unsafe fn fpu_fprem(ieee: bool) {
|
|||
// true: Slower, passes nasmtests
|
||||
let intel_compatibility = false;
|
||||
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st1: f64 = fpu_get_sti(1);
|
||||
let st0 = fpu_get_st0();
|
||||
let st1 = fpu_get_sti(1);
|
||||
let exp0 = st0.log2();
|
||||
let exp1 = st1.log2();
|
||||
let d = (exp0 - exp1).abs();
|
||||
if !intel_compatibility || d < 64.0 {
|
||||
let fprem_quotient: i32 = convert_f64_to_i32(if ieee {
|
||||
let fprem_quotient = convert_f64_to_i32(if ieee {
|
||||
round(st0 / st1)
|
||||
}
|
||||
else {
|
||||
|
|
@ -540,7 +540,7 @@ pub unsafe fn fpu_fprem(ieee: bool) {
|
|||
}
|
||||
else {
|
||||
let n = 32.0;
|
||||
let fprem_quotient: i32 = convert_f64_to_i32(
|
||||
let fprem_quotient = convert_f64_to_i32(
|
||||
if ieee {
|
||||
round(st0 / st1)
|
||||
}
|
||||
|
|
@ -656,7 +656,7 @@ pub unsafe fn fpu_fstenv(addr: i32) {
|
|||
pub unsafe fn fpu_load_tag_word() -> i32 {
|
||||
let mut tag_word: i32 = 0;
|
||||
for i in 0..8 {
|
||||
let value: f64 = *fpu_st.offset(i as isize);
|
||||
let value = *fpu_st.offset(i as isize);
|
||||
if 0 != *fpu_stack_empty >> i & 1 {
|
||||
tag_word |= 3 << (i << 1)
|
||||
}
|
||||
|
|
@ -701,7 +701,7 @@ pub unsafe fn fpu_fstm64(addr: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_store_m64(addr: i32, x: f64) -> OrPageFault<()> {
|
||||
let v: i64 = transmute(x);
|
||||
let v = transmute(x);
|
||||
safe_write64(addr, v)
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -716,12 +716,12 @@ pub unsafe fn fpu_fstp(r: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fsub(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
fpu_write_st(*fpu_stack_ptr as i32 + target_index & 7, st0 - val)
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fsubr(target_index: i32, val: f64) {
|
||||
let st0: f64 = fpu_get_st0();
|
||||
let st0 = fpu_get_st0();
|
||||
fpu_write_st(*fpu_stack_ptr as i32 + target_index & 7, val - st0)
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -795,7 +795,7 @@ pub unsafe fn fpu_sign(i: i32) -> i32 {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn fpu_fxch(i: i32) {
|
||||
let sti: f64 = fpu_get_sti(i);
|
||||
let sti = fpu_get_sti(i);
|
||||
fpu_write_st(*fpu_stack_ptr as i32 + i & 7, fpu_get_st0());
|
||||
fpu_write_st(*fpu_stack_ptr as i32, sti);
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -127,7 +127,7 @@ pub unsafe fn write16(addr: u32, value: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn write_aligned16(addr: u32, value: u32) {
|
||||
dbg_assert!(addr < 0x80000000);
|
||||
let phys_addr: u32 = addr << 1;
|
||||
let phys_addr = addr << 1;
|
||||
if in_mapped_range(phys_addr) {
|
||||
mmap_write16(phys_addr, value as i32);
|
||||
}
|
||||
|
|
@ -154,7 +154,7 @@ pub unsafe fn write_aligned32_no_mmap_or_dirty_check(addr: u32, value: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn write_aligned32(addr: u32, value: i32) {
|
||||
dbg_assert!(addr < 0x40000000 as u32);
|
||||
let phys_addr: u32 = addr << 2;
|
||||
let phys_addr = addr << 2;
|
||||
if in_mapped_range(phys_addr) {
|
||||
mmap_write32(phys_addr, value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ pub unsafe fn test_nl() -> bool { return !test_l(); }
|
|||
pub unsafe fn test_nle() -> bool { return !test_le(); }
|
||||
#[no_mangle]
|
||||
pub unsafe fn jmp_rel16(rel16: i32) {
|
||||
let cs_offset: i32 = get_seg_cs();
|
||||
let cs_offset = get_seg_cs();
|
||||
// limit ip to 16 bit
|
||||
*instruction_pointer = cs_offset + (*instruction_pointer - cs_offset + rel16 & 0xFFFF);
|
||||
}
|
||||
|
|
@ -162,14 +162,14 @@ pub unsafe fn adjust_stack_reg(adjustment: i32) {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn push16_ss16(imm16: i32) -> OrPageFault<()> {
|
||||
let sp: i32 = get_seg_ss() + (*reg16.offset(SP as isize) as i32 - 2 & 0xFFFF);
|
||||
let sp = get_seg_ss() + (*reg16.offset(SP as isize) as i32 - 2 & 0xFFFF);
|
||||
safe_write16(sp, imm16)?;
|
||||
*reg16.offset(SP as isize) -= 2;
|
||||
Ok(())
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn push16_ss32(imm16: i32) -> OrPageFault<()> {
|
||||
let sp: i32 = get_seg_ss() + *reg32.offset(ESP as isize) - 2;
|
||||
let sp = get_seg_ss() + *reg32.offset(ESP as isize) - 2;
|
||||
safe_write16(sp, imm16)?;
|
||||
*reg32.offset(ESP as isize) -= 2;
|
||||
Ok(())
|
||||
|
|
@ -192,14 +192,14 @@ pub unsafe fn push16(imm16: i32) -> OrPageFault<()> {
|
|||
|
||||
#[no_mangle]
|
||||
pub unsafe fn push32_ss16(imm32: i32) -> OrPageFault<()> {
|
||||
let new_sp: i32 = *reg16.offset(SP as isize) as i32 - 4 & 0xFFFF;
|
||||
let new_sp = *reg16.offset(SP as isize) as i32 - 4 & 0xFFFF;
|
||||
safe_write32(get_seg_ss() + new_sp, imm32)?;
|
||||
*reg16.offset(SP as isize) = new_sp as u16;
|
||||
Ok(())
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn push32_ss32(imm32: i32) -> OrPageFault<()> {
|
||||
let new_esp: i32 = *reg32.offset(ESP as isize) - 4;
|
||||
let new_esp = *reg32.offset(ESP as isize) - 4;
|
||||
safe_write32(get_seg_ss() + new_esp, imm32)?;
|
||||
*reg32.offset(ESP as isize) = new_esp;
|
||||
Ok(())
|
||||
|
|
@ -230,15 +230,15 @@ pub unsafe fn pop16() -> OrPageFault<i32> {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pop16_ss16() -> OrPageFault<i32> {
|
||||
let sp: i32 = get_seg_ss() + *reg16.offset(SP as isize) as i32;
|
||||
let result: i32 = safe_read16(sp)?;
|
||||
let sp = get_seg_ss() + *reg16.offset(SP as isize) as i32;
|
||||
let result = safe_read16(sp)?;
|
||||
*reg16.offset(SP as isize) += 2;
|
||||
Ok(result)
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pop16_ss32() -> OrPageFault<i32> {
|
||||
let esp: i32 = get_seg_ss() + *reg32.offset(ESP as isize);
|
||||
let result: i32 = safe_read16(esp)?;
|
||||
let esp = get_seg_ss() + *reg32.offset(ESP as isize);
|
||||
let result = safe_read16(esp)?;
|
||||
*reg32.offset(ESP as isize) += 2;
|
||||
Ok(result)
|
||||
}
|
||||
|
|
@ -253,21 +253,21 @@ pub unsafe fn pop32s() -> OrPageFault<i32> {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pop32s_ss16() -> OrPageFault<i32> {
|
||||
let sp: i32 = *reg16.offset(SP as isize) as i32;
|
||||
let result: i32 = safe_read32s(get_seg_ss() + sp)?;
|
||||
let sp = *reg16.offset(SP as isize) as i32;
|
||||
let result = safe_read32s(get_seg_ss() + sp)?;
|
||||
*reg16.offset(SP as isize) = (sp + 4) as u16;
|
||||
Ok(result)
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pop32s_ss32() -> OrPageFault<i32> {
|
||||
let esp: i32 = *reg32.offset(ESP as isize);
|
||||
let result: i32 = safe_read32s(get_seg_ss() + esp)?;
|
||||
let esp = *reg32.offset(ESP as isize);
|
||||
let result = safe_read32s(get_seg_ss() + esp)?;
|
||||
*reg32.offset(ESP as isize) = esp + 4;
|
||||
Ok(result)
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pusha16() {
|
||||
let temp: u16 = *reg16.offset(SP as isize);
|
||||
let temp = *reg16.offset(SP as isize);
|
||||
// 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));
|
||||
|
|
@ -282,7 +282,7 @@ pub unsafe fn pusha16() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pusha32() {
|
||||
let temp: i32 = *reg32.offset(ESP as isize);
|
||||
let temp = *reg32.offset(ESP as isize);
|
||||
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();
|
||||
|
|
@ -346,7 +346,7 @@ pub unsafe fn fxrstor(addr: i32) {
|
|||
// TODO: Add readable_or_pagefault
|
||||
return_on_pagefault!(translate_address_read(addr));
|
||||
return_on_pagefault!(translate_address_read(addr.wrapping_add(511)));
|
||||
let new_mxcsr: i32 = safe_read32s(addr.wrapping_add(24) as i32).unwrap();
|
||||
let new_mxcsr = safe_read32s(addr.wrapping_add(24) as i32).unwrap();
|
||||
if 0 != new_mxcsr & !MXCSR_MASK {
|
||||
dbg_log!("#gp Invalid mxcsr bits");
|
||||
trigger_gp(0);
|
||||
|
|
@ -394,31 +394,31 @@ pub unsafe fn fxrstor(addr: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xchg8(data: i32, r8: i32) -> i32 {
|
||||
let tmp: i32 = *reg8.offset(r8 as isize) as i32;
|
||||
let tmp = *reg8.offset(r8 as isize) as i32;
|
||||
*reg8.offset(r8 as isize) = data as u8;
|
||||
return tmp;
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xchg16(data: i32, r16: i32) -> i32 {
|
||||
let tmp: i32 = *reg16.offset(r16 as isize) as i32;
|
||||
let tmp = *reg16.offset(r16 as isize) as i32;
|
||||
*reg16.offset(r16 as isize) = data as u16;
|
||||
return tmp;
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xchg16r(r16: i32) {
|
||||
let tmp: i32 = *reg16.offset(AX as isize) as 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;
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xchg32(data: i32, r32: i32) -> i32 {
|
||||
let tmp: i32 = *reg32.offset(r32 as isize);
|
||||
let tmp = *reg32.offset(r32 as isize);
|
||||
*reg32.offset(r32 as isize) = data;
|
||||
return tmp;
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn xchg32r(r32: i32) {
|
||||
let tmp: i32 = *reg32.offset(EAX as isize);
|
||||
let tmp = *reg32.offset(EAX as isize);
|
||||
*reg32.offset(EAX as isize) = *reg32.offset(r32 as isize);
|
||||
*reg32.offset(r32 as isize) = tmp;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ pub unsafe fn resolve_modrm16(modrm_byte: i32) -> OrPageFault<i32> {
|
|||
}
|
||||
|
||||
pub unsafe fn resolve_modrm32_(modrm_byte: i32) -> OrPageFault<i32> {
|
||||
let r: u8 = (modrm_byte & 7) as u8;
|
||||
let r = (modrm_byte & 7) as u8;
|
||||
dbg_assert!(modrm_byte < 192);
|
||||
Ok(if r as i32 == 4 {
|
||||
if modrm_byte < 64 {
|
||||
|
|
@ -139,9 +139,9 @@ pub unsafe fn resolve_modrm32_(modrm_byte: i32) -> OrPageFault<i32> {
|
|||
}
|
||||
unsafe fn resolve_sib(mod_0: bool) -> OrPageFault<i32> {
|
||||
let s;
|
||||
let sib_byte: u8 = read_imm8()? as u8;
|
||||
let r: u8 = (sib_byte as i32 & 7) as u8;
|
||||
let m: u8 = (sib_byte as i32 >> 3 & 7) as u8;
|
||||
let sib_byte = read_imm8()? as u8;
|
||||
let r = (sib_byte as i32 & 7) as u8;
|
||||
let m = (sib_byte as i32 >> 3 & 7) as u8;
|
||||
let base;
|
||||
let seg;
|
||||
if r as i32 == 4 {
|
||||
|
|
|
|||
|
|
@ -3,26 +3,26 @@ use cpu2::cpu::*;
|
|||
#[no_mangle]
|
||||
pub unsafe fn mov_r_m64(addr: i32, r: i32) {
|
||||
// mov* m64, mm
|
||||
let data: reg64 = read_mmx64s(r);
|
||||
let data = read_mmx64s(r);
|
||||
return_on_pagefault!(safe_write64(addr, data.u64_0[0] as i64));
|
||||
transition_fpu_to_mmx();
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn movl_r128_m64(addr: i32, r: i32) {
|
||||
// mov* m64, xmm
|
||||
let data: reg64 = read_xmm64s(r);
|
||||
let data = read_xmm64s(r);
|
||||
return_on_pagefault!(safe_write64(addr, data.u64_0[0] as i64));
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn mov_r_r128(r1: i32, r2: i32) {
|
||||
// mov* xmm, xmm
|
||||
let data: reg128 = read_xmm128s(r2);
|
||||
let data = read_xmm128s(r2);
|
||||
write_xmm_reg128(r1, data);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn mov_r_m128(addr: i32, r: i32) {
|
||||
// mov* m128, xmm
|
||||
let data: reg128 = read_xmm128s(r);
|
||||
let data = read_xmm128s(r);
|
||||
return_on_pagefault!(safe_write128(addr, data));
|
||||
}
|
||||
#[no_mangle]
|
||||
|
|
@ -33,8 +33,8 @@ pub unsafe fn mov_rm_r128(source: reg128, r: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn movh_m64_r128(addr: i32, r: i32) {
|
||||
// movhp* xmm, m64
|
||||
let data: reg64 = return_on_pagefault!(safe_read64s(addr));
|
||||
let orig: reg128 = read_xmm128s(r);
|
||||
let data = return_on_pagefault!(safe_read64s(addr));
|
||||
let orig = read_xmm128s(r);
|
||||
write_xmm128(
|
||||
r,
|
||||
orig.u32_0[0] as i32,
|
||||
|
|
@ -46,14 +46,14 @@ pub unsafe fn movh_m64_r128(addr: i32, r: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn movh_r128_m64(addr: i32, r: i32) {
|
||||
// movhp* m64, xmm
|
||||
let data: reg128 = read_xmm128s(r);
|
||||
let data = read_xmm128s(r);
|
||||
return_on_pagefault!(safe_write64(addr, data.u64_0[1] as i64));
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pand_r128(source: reg128, r: i32) {
|
||||
// pand xmm, xmm/m128
|
||||
// XXX: Aligned access or #gp
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut result: reg128 = reg128 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -65,7 +65,7 @@ pub unsafe fn pand_r128(source: reg128, r: i32) {
|
|||
pub unsafe fn pandn_r128(source: reg128, r: i32) {
|
||||
// pandn xmm, xmm/m128
|
||||
// XXX: Aligned access or #gp
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut result: reg128 = reg128 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -77,7 +77,7 @@ pub unsafe fn pandn_r128(source: reg128, r: i32) {
|
|||
pub unsafe fn pxor_r128(source: reg128, r: i32) {
|
||||
// pxor xmm, xmm/m128
|
||||
// XXX: Aligned access or #gp
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut result: reg128 = reg128 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -89,7 +89,7 @@ pub unsafe fn pxor_r128(source: reg128, r: i32) {
|
|||
pub unsafe fn por_r128(source: reg128, r: i32) {
|
||||
// por xmm, xmm/m128
|
||||
// XXX: Aligned access or #gp
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut result: reg128 = reg128 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -100,7 +100,7 @@ pub unsafe fn por_r128(source: reg128, r: i32) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrlw_r64(r: i32, shift: u64) {
|
||||
// psrlw mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
if shift <= 15 {
|
||||
|
|
@ -113,11 +113,11 @@ pub unsafe fn psrlw_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psraw_r64(r: i32, shift: u64) {
|
||||
// psraw mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let shift_clamped: i32 = (if shift > 15 { 16 } else { shift }) as i32;
|
||||
let dword0: i32 = destination.i16_0[0] as i32 >> shift_clamped & 0xFFFF
|
||||
let destination = read_mmx64s(r);
|
||||
let shift_clamped = (if shift > 15 { 16 } else { shift }) as i32;
|
||||
let dword0 = destination.i16_0[0] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[1] as i32 >> shift_clamped << 16;
|
||||
let dword1: i32 = destination.i16_0[2] as i32 >> shift_clamped & 0xFFFF
|
||||
let dword1 = destination.i16_0[2] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[3] as i32 >> shift_clamped << 16;
|
||||
write_mmx64(r, dword0, dword1);
|
||||
transition_fpu_to_mmx();
|
||||
|
|
@ -125,7 +125,7 @@ pub unsafe fn psraw_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psllw_r64(r: i32, shift: u64) {
|
||||
// psllw mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
if shift <= 15 {
|
||||
|
|
@ -140,7 +140,7 @@ pub unsafe fn psllw_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrld_r64(r: i32, shift: u64) {
|
||||
// psrld mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
if shift <= 31 {
|
||||
|
|
@ -153,17 +153,17 @@ pub unsafe fn psrld_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrad_r64(r: i32, shift: u64) {
|
||||
// psrad mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let shift_clamped: i32 = (if shift > 31 { 31 } else { shift }) as i32;
|
||||
let dword0: i32 = destination.i32_0[0] >> shift_clamped;
|
||||
let dword1: i32 = destination.i32_0[1] >> shift_clamped;
|
||||
let destination = read_mmx64s(r);
|
||||
let shift_clamped = (if shift > 31 { 31 } else { shift }) as i32;
|
||||
let dword0 = destination.i32_0[0] >> shift_clamped;
|
||||
let dword1 = destination.i32_0[1] >> shift_clamped;
|
||||
write_mmx64(r, dword0, dword1);
|
||||
transition_fpu_to_mmx();
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pslld_r64(r: i32, shift: u64) {
|
||||
// pslld mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
if shift <= 31 {
|
||||
|
|
@ -180,7 +180,7 @@ pub unsafe fn psrlq_r64(r: i32, shift: u64) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
let mut result: reg64 = reg64 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -195,7 +195,7 @@ pub unsafe fn psrlq_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psllq_r64(r: i32, shift: u64) {
|
||||
// psllq mm, {shift}
|
||||
let destination: reg64 = read_mmx64s(r);
|
||||
let destination = read_mmx64s(r);
|
||||
if shift == 0 {
|
||||
return;
|
||||
}
|
||||
|
|
@ -214,7 +214,7 @@ pub unsafe fn psllq_r64(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrlw_r128(r: i32, shift: u64) {
|
||||
// psrlw xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
let mut dword2: i32 = 0;
|
||||
|
|
@ -230,22 +230,22 @@ pub unsafe fn psrlw_r128(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psraw_r128(r: i32, shift: u64) {
|
||||
// psraw xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let shift_clamped: i32 = (if shift > 15 { 16 } else { shift as u32 }) as i32;
|
||||
let dword0: i32 = destination.i16_0[0] as i32 >> shift_clamped & 0xFFFF
|
||||
let destination = read_xmm128s(r);
|
||||
let shift_clamped = (if shift > 15 { 16 } else { shift as u32 }) as i32;
|
||||
let dword0 = destination.i16_0[0] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[1] as i32 >> shift_clamped << 16;
|
||||
let dword1: i32 = destination.i16_0[2] as i32 >> shift_clamped & 0xFFFF
|
||||
let dword1 = destination.i16_0[2] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[3] as i32 >> shift_clamped << 16;
|
||||
let dword2: i32 = destination.i16_0[4] as i32 >> shift_clamped & 0xFFFF
|
||||
let dword2 = destination.i16_0[4] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[5] as i32 >> shift_clamped << 16;
|
||||
let dword3: i32 = destination.i16_0[6] as i32 >> shift_clamped & 0xFFFF
|
||||
let dword3 = destination.i16_0[6] as i32 >> shift_clamped & 0xFFFF
|
||||
| destination.i16_0[7] as i32 >> shift_clamped << 16;
|
||||
write_xmm128(r, dword0, dword1, dword2, dword3);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn psllw_r128(r: i32, shift: u64) {
|
||||
// psllw xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
let mut dword2: i32 = 0;
|
||||
|
|
@ -265,7 +265,7 @@ pub unsafe fn psllw_r128(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrld_r128(r: i32, shift: u64) {
|
||||
// psrld xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
let mut dword2: i32 = 0;
|
||||
|
|
@ -281,18 +281,18 @@ pub unsafe fn psrld_r128(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psrad_r128(r: i32, shift: u64) {
|
||||
// psrad xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let shift_clamped: i32 = (if shift > 31 { 31 } else { shift }) as i32;
|
||||
let dword0: i32 = destination.i32_0[0] >> shift_clamped;
|
||||
let dword1: i32 = destination.i32_0[1] >> shift_clamped;
|
||||
let dword2: i32 = destination.i32_0[2] >> shift_clamped;
|
||||
let dword3: i32 = destination.i32_0[3] >> shift_clamped;
|
||||
let destination = read_xmm128s(r);
|
||||
let shift_clamped = (if shift > 31 { 31 } else { shift }) as i32;
|
||||
let dword0 = destination.i32_0[0] >> shift_clamped;
|
||||
let dword1 = destination.i32_0[1] >> shift_clamped;
|
||||
let dword2 = destination.i32_0[2] >> shift_clamped;
|
||||
let dword3 = destination.i32_0[3] >> shift_clamped;
|
||||
write_xmm128(r, dword0, dword1, dword2, dword3);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn pslld_r128(r: i32, shift: u64) {
|
||||
// pslld xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut dword0: i32 = 0;
|
||||
let mut dword1: i32 = 0;
|
||||
let mut dword2: i32 = 0;
|
||||
|
|
@ -312,7 +312,7 @@ pub unsafe fn psrlq_r128(r: i32, shift: u64) {
|
|||
return;
|
||||
}
|
||||
else {
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
let mut result: reg128 = reg128 {
|
||||
i8_0: [0 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
};
|
||||
|
|
@ -327,7 +327,7 @@ pub unsafe fn psrlq_r128(r: i32, shift: u64) {
|
|||
#[no_mangle]
|
||||
pub unsafe fn psllq_r128(r: i32, shift: u64) {
|
||||
// psllq xmm, {shift}
|
||||
let destination: reg128 = read_xmm128s(r);
|
||||
let destination = read_xmm128s(r);
|
||||
if shift == 0 {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,27 +34,27 @@ pub unsafe fn string_get_cycle_count(mut size: i32, mut address: i32) -> i32 {
|
|||
}
|
||||
dbg_assert!(address & size - 1 == 0);
|
||||
// 1 -> 0; 2 -> 1; 4 -> 2
|
||||
let shift: i32 = size >> 1;
|
||||
let shift = size >> 1;
|
||||
return 0x1000 - (address & 0xFFF) >> shift;
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn string_get_cycle_count2(size: i32, addr1: i32, addr2: i32) -> i32 {
|
||||
let c1: i32 = string_get_cycle_count(size, addr1);
|
||||
let c2: i32 = string_get_cycle_count(size, addr2);
|
||||
let c1 = string_get_cycle_count(size, addr1);
|
||||
let c2 = string_get_cycle_count(size, addr2);
|
||||
return if c1 < c2 { c1 } else { c2 };
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn movsb_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count2(size, src, dest);
|
||||
let mut phys_src: i32 = return_on_pagefault!(translate_address_read(src)) as i32;
|
||||
let mut phys_dest: i32 = return_on_pagefault!(translate_address_write(dest)) as i32;
|
||||
|
|
@ -89,7 +89,7 @@ pub unsafe fn movsb_rep() {
|
|||
}
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(EDI, diff);
|
||||
add_reg_asize(ESI, diff);
|
||||
set_ecx_asize(count);
|
||||
|
|
@ -103,9 +103,9 @@ pub unsafe fn movsb_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn movsb_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
return_on_pagefault!(safe_write8(dest, return_on_pagefault!(safe_read8(src))));
|
||||
add_reg_asize(EDI, size);
|
||||
add_reg_asize(ESI, size);
|
||||
|
|
@ -115,17 +115,17 @@ pub unsafe fn movsw_rep() {
|
|||
let diff;
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 1 && 0 == src & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 = (return_on_pagefault!(translate_address_read(src)) >> 1) as i32;
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 1) as i32;
|
||||
|
|
@ -174,9 +174,9 @@ pub unsafe fn movsw_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn movsw_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
return_on_pagefault!(safe_write16(dest, return_on_pagefault!(safe_read16(src))));
|
||||
add_reg_asize(EDI, size);
|
||||
add_reg_asize(ESI, size);
|
||||
|
|
@ -186,17 +186,17 @@ pub unsafe fn movsd_rep() {
|
|||
let diff;
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 3 && 0 == src & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 = (return_on_pagefault!(translate_address_read(src)) >> 2) as i32;
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 2) as i32;
|
||||
|
|
@ -266,28 +266,28 @@ pub unsafe fn movsd_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn movsd_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
return_on_pagefault!(safe_write32(dest, return_on_pagefault!(safe_read32s(src))));
|
||||
add_reg_asize(EDI, size);
|
||||
add_reg_asize(ESI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn cmpsb_rep(prefix_flag: i32) {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let mut data_src;
|
||||
let mut data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count2(size, src, dest);
|
||||
let mut phys_src: i32 = return_on_pagefault!(translate_address_read(src)) as i32;
|
||||
let mut phys_dest: i32 = return_on_pagefault!(translate_address_read(dest)) as i32;
|
||||
|
|
@ -305,7 +305,7 @@ pub unsafe fn cmpsb_rep(prefix_flag: i32) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(EDI, diff);
|
||||
add_reg_asize(ESI, diff);
|
||||
set_ecx_asize(count);
|
||||
|
|
@ -320,11 +320,11 @@ pub unsafe fn cmpsb_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn cmpsb_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let data_src;
|
||||
let data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
data_src = return_on_pagefault!(safe_read8(src));
|
||||
data_dest = return_on_pagefault!(safe_read8(dest));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -338,18 +338,18 @@ pub unsafe fn cmpsw_rep(prefix_flag: i32) {
|
|||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let mut data_src;
|
||||
let mut data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 1 && 0 == src & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 = (return_on_pagefault!(translate_address_read(src)) >> 1) as i32;
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_read(dest)) >> 1) as i32;
|
||||
|
|
@ -401,11 +401,11 @@ pub unsafe fn cmpsw_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn cmpsw_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let data_src;
|
||||
let data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
data_dest = return_on_pagefault!(safe_read16(dest));
|
||||
data_src = return_on_pagefault!(safe_read16(src));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -419,18 +419,18 @@ pub unsafe fn cmpsd_rep(prefix_flag: i32) {
|
|||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let mut data_src;
|
||||
let mut data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 3 && 0 == src & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 = (return_on_pagefault!(translate_address_read(src)) >> 2) as i32;
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_read(dest)) >> 2) as i32;
|
||||
|
|
@ -482,11 +482,11 @@ pub unsafe fn cmpsd_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn cmpsd_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let data_src;
|
||||
let data_dest;
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
data_dest = return_on_pagefault!(safe_read32s(dest));
|
||||
data_src = return_on_pagefault!(safe_read32s(src));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -495,16 +495,16 @@ pub unsafe fn cmpsd_no_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosb_rep() {
|
||||
let data: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let data = *reg8.offset(AL as isize) as i32;
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count(size, dest);
|
||||
let mut phys_dest: i32 = return_on_pagefault!(translate_address_write(dest)) as i32;
|
||||
if !in_mapped_range(phys_dest as u32) {
|
||||
|
|
@ -536,7 +536,7 @@ pub unsafe fn stosb_rep() {
|
|||
}
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(EDI, diff);
|
||||
set_ecx_asize(count);
|
||||
*timestamp_counter =
|
||||
|
|
@ -549,28 +549,28 @@ pub unsafe fn stosb_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosb_no_rep() {
|
||||
let data: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let data = *reg8.offset(AL as isize) as i32;
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
return_on_pagefault!(safe_write8(dest, data));
|
||||
add_reg_asize(EDI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosw_rep() {
|
||||
let diff;
|
||||
let data: i32 = *reg16.offset(AX as isize) as i32;
|
||||
let data = *reg16.offset(AX as isize) as i32;
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 1) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -614,28 +614,28 @@ pub unsafe fn stosw_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosw_no_rep() {
|
||||
let data: i32 = *reg16.offset(AX as isize) as i32;
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let data = *reg16.offset(AX as isize) as i32;
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
return_on_pagefault!(safe_write16(dest, data));
|
||||
add_reg_asize(EDI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosd_rep() {
|
||||
let diff;
|
||||
let data: i32 = *reg32.offset(EAX as isize);
|
||||
let data = *reg32.offset(EAX as isize);
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 2) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -696,23 +696,23 @@ pub unsafe fn stosd_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn stosd_no_rep() {
|
||||
let data: i32 = *reg32.offset(EAX as isize);
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let data = *reg32.offset(EAX as isize);
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
return_on_pagefault!(safe_write32(dest, data));
|
||||
add_reg_asize(EDI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsb_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count(size, src);
|
||||
let mut phys_src: i32 = return_on_pagefault!(translate_address_read(src)) as i32;
|
||||
loop {
|
||||
|
|
@ -727,7 +727,7 @@ pub unsafe fn lodsb_rep() {
|
|||
break;
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(ESI, diff);
|
||||
set_ecx_asize(count);
|
||||
*timestamp_counter =
|
||||
|
|
@ -740,16 +740,16 @@ pub unsafe fn lodsb_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsb_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
*reg8.offset(AL as isize) = return_on_pagefault!(safe_read8(src)) as u8;
|
||||
add_reg_asize(ESI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsw_rep() {
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let count: u32 = get_reg_asize(ECX) as u32;
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let count = get_reg_asize(ECX) as u32;
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
|
|
@ -776,16 +776,16 @@ pub unsafe fn lodsw_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsw_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
*reg16.offset(AX as isize) = return_on_pagefault!(safe_read16(src)) as u16;
|
||||
add_reg_asize(ESI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsd_rep() {
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let count: i32 = get_reg_asize(ECX);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let count = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
|
|
@ -812,25 +812,25 @@ pub unsafe fn lodsd_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn lodsd_no_rep() {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
*reg32.offset(EAX as isize) = return_on_pagefault!(safe_read32s(src));
|
||||
add_reg_asize(ESI, size);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn scasb_rep(prefix_flag: i32) {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut data_dest;
|
||||
let data_src: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let data_src = *reg8.offset(AL as isize) as i32;
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count(size, dest);
|
||||
let mut phys_dest: i32 = return_on_pagefault!(translate_address_read(dest)) as i32;
|
||||
loop {
|
||||
|
|
@ -845,7 +845,7 @@ pub unsafe fn scasb_rep(prefix_flag: i32) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(EDI, diff);
|
||||
set_ecx_asize(count);
|
||||
*timestamp_counter =
|
||||
|
|
@ -859,10 +859,10 @@ pub unsafe fn scasb_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn scasb_no_rep() {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let data_dest;
|
||||
let data_src: i32 = *reg8.offset(AL as isize) as i32;
|
||||
let data_src = *reg8.offset(AL as isize) as i32;
|
||||
data_dest = return_on_pagefault!(safe_read8(dest));
|
||||
add_reg_asize(EDI, size);
|
||||
cmp8(data_src, data_dest);
|
||||
|
|
@ -871,20 +871,20 @@ pub unsafe fn scasb_no_rep() {
|
|||
pub unsafe fn scasw_rep(prefix_flag: i32) {
|
||||
let diff;
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut data_dest;
|
||||
let data_src: i32 = *reg16.offset(AL as isize) as i32;
|
||||
let data_src = *reg16.offset(AL as isize) as i32;
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_read(dest)) >> 1) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -929,10 +929,10 @@ pub unsafe fn scasw_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn scasw_no_rep() {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let data_dest;
|
||||
let data_src: i32 = *reg16.offset(AL as isize) as i32;
|
||||
let data_src = *reg16.offset(AL as isize) as i32;
|
||||
data_dest = return_on_pagefault!(safe_read16(dest));
|
||||
add_reg_asize(EDI, size);
|
||||
cmp16(data_src, data_dest);
|
||||
|
|
@ -941,20 +941,20 @@ pub unsafe fn scasw_no_rep() {
|
|||
pub unsafe fn scasd_rep(prefix_flag: i32) {
|
||||
let diff;
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut data_dest;
|
||||
let data_src: i32 = *reg32.offset(EAX as isize);
|
||||
let data_src = *reg32.offset(EAX as isize);
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let is_repz: i32 = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let start_count = count;
|
||||
let is_repz = (prefix_flag == PREFIX_REPZ) as i32;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_read(dest)) >> 2) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -999,30 +999,30 @@ pub unsafe fn scasd_rep(prefix_flag: i32) {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn scasd_no_rep() {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let data_dest;
|
||||
let data_src: i32 = *reg32.offset(EAX as isize);
|
||||
let data_src = *reg32.offset(EAX as isize);
|
||||
data_dest = return_on_pagefault!(safe_read32s(dest));
|
||||
add_reg_asize(EDI, size);
|
||||
cmp32(data_src, data_dest);
|
||||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn insb_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 1) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count(size, dest);
|
||||
let mut phys_dest: i32 = return_on_pagefault!(translate_address_write(dest)) as i32;
|
||||
loop {
|
||||
|
|
@ -1037,7 +1037,7 @@ pub unsafe fn insb_rep() {
|
|||
break;
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(EDI, diff);
|
||||
set_ecx_asize(count);
|
||||
*timestamp_counter = (*timestamp_counter as u32)
|
||||
|
|
@ -1052,13 +1052,13 @@ pub unsafe fn insb_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn insb_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 1) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
return_on_pagefault!(writable_or_pagefault(dest, 1));
|
||||
return_on_pagefault!(safe_write8(dest, io_port_read8(port)));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -1068,23 +1068,23 @@ pub unsafe fn insb_no_rep() {
|
|||
#[no_mangle]
|
||||
pub unsafe fn insw_rep() {
|
||||
let diff;
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 2) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 1) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -1131,13 +1131,13 @@ pub unsafe fn insw_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn insw_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 2) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
return_on_pagefault!(writable_or_pagefault(dest, 2));
|
||||
return_on_pagefault!(safe_write16(dest, io_port_read16(port)));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -1147,23 +1147,23 @@ pub unsafe fn insw_no_rep() {
|
|||
#[no_mangle]
|
||||
pub unsafe fn insd_rep() {
|
||||
let diff;
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 4) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == dest & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_dest: i32 =
|
||||
(return_on_pagefault!(translate_address_write(dest)) >> 2) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, dest);
|
||||
|
|
@ -1210,13 +1210,13 @@ pub unsafe fn insd_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn insd_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 4) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let dest: i32 = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let dest = get_seg(ES) + get_reg_asize(EDI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
return_on_pagefault!(writable_or_pagefault(dest, 4));
|
||||
return_on_pagefault!(safe_write32(dest, io_port_read32(port)));
|
||||
add_reg_asize(EDI, size);
|
||||
|
|
@ -1225,20 +1225,20 @@ pub unsafe fn insd_no_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn outsb_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 1) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = string_get_cycle_count(size, src);
|
||||
let mut phys_src: i32 = return_on_pagefault!(translate_address_read(src)) as i32;
|
||||
loop {
|
||||
|
|
@ -1253,7 +1253,7 @@ pub unsafe fn outsb_rep() {
|
|||
break;
|
||||
}
|
||||
}
|
||||
let diff: i32 = size * (start_count - count);
|
||||
let diff = size * (start_count - count);
|
||||
add_reg_asize(ESI, diff);
|
||||
set_ecx_asize(count);
|
||||
*timestamp_counter = (*timestamp_counter as u32)
|
||||
|
|
@ -1268,13 +1268,13 @@ pub unsafe fn outsb_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn outsb_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 1) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -1 } else { 1 };
|
||||
io_port_write8(port, return_on_pagefault!(safe_read8(src)));
|
||||
add_reg_asize(ESI, size);
|
||||
return;
|
||||
|
|
@ -1283,23 +1283,23 @@ pub unsafe fn outsb_no_rep() {
|
|||
#[no_mangle]
|
||||
pub unsafe fn outsw_rep() {
|
||||
let diff;
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 2) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == src & 1 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 =
|
||||
(return_on_pagefault!(translate_address_read(src)) >> 1) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, src);
|
||||
|
|
@ -1345,13 +1345,13 @@ pub unsafe fn outsw_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn outsw_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 2) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -2 } else { 2 };
|
||||
io_port_write16(port, return_on_pagefault!(safe_read16(src)));
|
||||
add_reg_asize(ESI, size);
|
||||
return;
|
||||
|
|
@ -1360,23 +1360,23 @@ pub unsafe fn outsw_no_rep() {
|
|||
#[no_mangle]
|
||||
pub unsafe fn outsd_rep() {
|
||||
let diff;
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 4) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let mut count: i32 = get_reg_asize(ECX);
|
||||
if count == 0 {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let mut cont;
|
||||
let start_count: i32 = count;
|
||||
let start_count = count;
|
||||
let mut cycle_counter: i32 = MAX_COUNT_PER_CYCLE;
|
||||
if 0 == src & 3 {
|
||||
let single_size: i32 = if size < 0 { -1 } else { 1 };
|
||||
let single_size = if size < 0 { -1 } else { 1 };
|
||||
let mut phys_src: i32 =
|
||||
(return_on_pagefault!(translate_address_read(src)) >> 2) as i32;
|
||||
cycle_counter = string_get_cycle_count(size, src);
|
||||
|
|
@ -1422,13 +1422,13 @@ pub unsafe fn outsd_rep() {
|
|||
}
|
||||
#[no_mangle]
|
||||
pub unsafe fn outsd_no_rep() {
|
||||
let port: i32 = *reg16.offset(DX as isize) as i32;
|
||||
let port = *reg16.offset(DX as isize) as i32;
|
||||
if !test_privileges_for_io(port, 4) {
|
||||
return;
|
||||
}
|
||||
else {
|
||||
let src: i32 = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size: i32 = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
let src = get_seg_prefix(DS) + get_reg_asize(ESI);
|
||||
let size = if 0 != *flags & FLAG_DIRECTION { -4 } else { 4 };
|
||||
io_port_write32(port, return_on_pagefault!(safe_read32s(src)));
|
||||
add_reg_asize(ESI, size);
|
||||
return;
|
||||
|
|
|
|||
Loading…
Reference in a new issue