akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

4688

This commit is contained in:
Kartik Agaram 2018-10-12 23:41:43 -07:00
parent 01dada15c3
commit 222c31db21
7 changed files with 100 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
subx/013direct_addressing.cc
View File

@ -29,9 +29,9 @@ case 0x01: { // add r32 to r/m32
// We return a pointer so that instructions can write to multiple bytes in
// 'Mem' at once.
int32_t* effective_address(uint8_t modrm) {
uint8_t mod = (modrm>>6);
const uint8_t mod = (modrm>>6);
// ignore middle 3 'reg opcode' bits
uint8_t rm = modrm & 0x7;
const uint8_t rm = modrm & 0x7;
if (mod == 3) {
// mod 3 is just register direct addressing
trace(90, "run") << "r/m32 is " << rname(rm) << end();
@ -41,9 +41,9 @@ int32_t* effective_address(uint8_t modrm) {
}
uint32_t effective_address_number(uint8_t modrm) {
uint8_t mod = (modrm>>6);
const uint8_t mod = (modrm>>6);
// ignore middle 3 'reg opcode' bits
uint8_t rm = modrm & 0x7;
const uint8_t rm = modrm & 0x7;
uint32_t addr = 0;
switch (mod) {
case 3:
@ -91,8 +91,8 @@ put(name, "29", "subtract r32 from rm32");
:(before "End Single-Byte Opcodes")
case 0x29: { // subtract r32 from r/m32
uint8_t modrm = next();
uint8_t arg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg2 = (modrm>>3)&0x7;
trace(90, "run") << "subtract " << rname(arg2) << " from r/m32" << end();
int32_t* arg1 = effective_address(modrm);
BINARY_ARITHMETIC_OP(-, *arg1, Reg[arg2].i);
@ -118,14 +118,14 @@ put(name, "f7", "test/negate/mul/div rm32 (with EAX if necessary) depending on s
:(before "End Single-Byte Opcodes")
case 0xf7: { // xor r32 with r/m32
uint8_t modrm = next();
const uint8_t modrm = next();
trace(90, "run") << "operate on r/m32" << end();
int32_t* arg1 = effective_address(modrm);
uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
switch (subop) {
case 4: { // mul unsigned EAX by r/m32
trace(90, "run") << "subop: multiply EAX by r/m32" << end();
uint64_t result = Reg[EAX].u * static_cast<uint32_t>(*arg1);
const uint64_t result = Reg[EAX].u * static_cast<uint32_t>(*arg1);
Reg[EAX].u = result & 0xffffffff;
Reg[EDX].u = result >> 32;
OF = (Reg[EDX].u != 0);
@ -158,10 +158,10 @@ put(name_0f, "af", "multiply rm32 into r32");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0xaf: { // multiply r32 into r/m32
uint8_t modrm = next();
uint8_t arg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg2 = (modrm>>3)&0x7;
trace(90, "run") << "multiply r/m32 into " << rname(arg2) << end();
int32_t* arg1 = effective_address(modrm);
const int32_t* arg1 = effective_address(modrm);
BINARY_ARITHMETIC_OP(*, Reg[arg2].i, *arg1);
break;
}
@ -184,8 +184,8 @@ put(name, "21", "rm32 = bitwise AND of r32 with rm32");
:(before "End Single-Byte Opcodes")
case 0x21: { // and r32 with r/m32
uint8_t modrm = next();
uint8_t arg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg2 = (modrm>>3)&0x7;
trace(90, "run") << "and " << rname(arg2) << " with r/m32" << end();
int32_t* arg1 = effective_address(modrm);
BINARY_BITWISE_OP(&, *arg1, Reg[arg2].u);
@ -210,8 +210,8 @@ put(name, "09", "rm32 = bitwise OR of r32 with rm32");
:(before "End Single-Byte Opcodes")
case 0x09: { // or r32 with r/m32
uint8_t modrm = next();
uint8_t arg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg2 = (modrm>>3)&0x7;
trace(90, "run") << "or " << rname(arg2) << " with r/m32" << end();
int32_t* arg1 = effective_address(modrm);
BINARY_BITWISE_OP(|, *arg1, Reg[arg2].u);
@ -236,8 +236,8 @@ put(name, "31", "rm32 = bitwise XOR of r32 with rm32");
:(before "End Single-Byte Opcodes")
case 0x31: { // xor r32 with r/m32
uint8_t modrm = next();
uint8_t arg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg2 = (modrm>>3)&0x7;
trace(90, "run") << "xor " << rname(arg2) << " with r/m32" << end();
int32_t* arg1 = effective_address(modrm);
BINARY_BITWISE_OP(^, *arg1, Reg[arg2].u);
@ -289,15 +289,15 @@ put(name, "39", "compare: set SF if rm32 < r32");
:(before "End Single-Byte Opcodes")
case 0x39: { // set SF if r/m32 < r32
uint8_t modrm = next();
uint8_t reg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t reg2 = (modrm>>3)&0x7;
trace(90, "run") << "compare " << rname(reg2) << " with r/m32" << end();
int32_t* arg1 = effective_address(modrm);
int32_t arg2 = Reg[reg2].i;
int32_t tmp1 = *arg1 - arg2;
const int32_t* arg1 = effective_address(modrm);
const int32_t arg2 = Reg[reg2].i;
const int32_t tmp1 = *arg1 - arg2;
SF = (tmp1 < 0);
ZF = (tmp1 == 0);
int64_t tmp2 = *arg1 - arg2;
const int64_t tmp2 = *arg1 - arg2;
OF = (tmp1 != tmp2);
trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end();
break;
@ -342,8 +342,8 @@ put(name, "89", "copy r32 to rm32");
:(before "End Single-Byte Opcodes")
case 0x89: { // copy r32 to r/m32
uint8_t modrm = next();
uint8_t rsrc = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t rsrc = (modrm>>3)&0x7;
trace(90, "run") << "copy " << rname(rsrc) << " to r/m32" << end();
int32_t* dest = effective_address(modrm);
*dest = Reg[rsrc].i;
@ -370,11 +370,11 @@ put(name, "87", "swap the contents of r32 and rm32");
:(before "End Single-Byte Opcodes")
case 0x87: { // exchange r32 with r/m32
uint8_t modrm = next();
uint8_t reg2 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t reg2 = (modrm>>3)&0x7;
trace(90, "run") << "exchange " << rname(reg2) << " with r/m32" << end();
int32_t* arg1 = effective_address(modrm);
int32_t tmp = *arg1;
const int32_t tmp = *arg1;
*arg1 = Reg[reg2].i;
Reg[reg2].i = tmp;
trace(90, "run") << "storing 0x" << HEXWORD << *arg1 << " in r/m32" << end();
@ -411,7 +411,7 @@ case 0x44:
case 0x45:
case 0x46:
case 0x47: { // increment r32
uint8_t reg = op & 0x7;
const uint8_t reg = op & 0x7;
trace(90, "run") << "increment " << rname(reg) << end();
++Reg[reg].u;
trace(90, "run") << "storing value 0x" << HEXWORD << Reg[reg].u << end();
@ -433,8 +433,8 @@ put(name, "ff", "inc/dec/jump/push/call rm32 based on subop");
:(before "End Single-Byte Opcodes")
case 0xff: {
uint8_t modrm = next();
uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
const uint8_t modrm = next();
const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
switch (subop) {
case 0: { // increment r/m32
trace(90, "run") << "increment r/m32" << end();
@ -477,7 +477,7 @@ case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f: { // decrement r32
uint8_t reg = op & 0x7;
const uint8_t reg = op & 0x7;
trace(90, "run") << "decrement " << rname(reg) << end();
--Reg[reg].u;
trace(90, "run") << "storing value 0x" << HEXWORD << Reg[reg].u << end();
@ -575,7 +575,7 @@ case 0x5c:
case 0x5d:
case 0x5e:
case 0x5f: { // pop stack into r32
uint8_t reg = op & 0x7;
const uint8_t reg = op & 0x7;
trace(90, "run") << "pop into " << rname(reg) << end();
//? cerr << "pop from " << Reg[ESP].u << '\n';
Reg[reg].u = pop();
@ -584,7 +584,7 @@ case 0x5f: { // pop stack into r32
}
:(code)
uint32_t pop() {
uint32_t result = read_mem_u32(Reg[ESP].u);
const uint32_t result = read_mem_u32(Reg[ESP].u);
trace(90, "run") << "popping value 0x" << HEXWORD << result << end();
Reg[ESP].u += 4;
trace(90, "run") << "incrementing ESP to 0x" << HEXWORD << Reg[ESP].u << end();

56
subx/014indirect_addressing.cc
View File

@ -45,8 +45,8 @@ put(name, "03", "add rm32 to r32");
:(before "End Single-Byte Opcodes")
case 0x03: { // add r/m32 to r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "add r/m32 to " << rname(arg1) << end();
const int32_t* arg2 = effective_address(modrm);
BINARY_ARITHMETIC_OP(+, Reg[arg1].i, *arg2);
@ -88,8 +88,8 @@ put(name, "2b", "subtract rm32 from r32");
:(before "End Single-Byte Opcodes")
case 0x2b: { // subtract r/m32 from r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "subtract r/m32 from " << rname(arg1) << end();
const int32_t* arg2 = effective_address(modrm);
BINARY_ARITHMETIC_OP(-, Reg[arg1].i, *arg2);
@ -131,8 +131,8 @@ ff 00 00 00 # 0xff
:(before "End Single-Byte Opcodes")
case 0x23: { // and r/m32 with r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "and r/m32 with " << rname(arg1) << end();
const int32_t* arg2 = effective_address(modrm);
BINARY_BITWISE_OP(&, Reg[arg1].u, *arg2);
@ -174,8 +174,8 @@ put(name, "0b", "r32 = bitwise OR of r32 with rm32");
:(before "End Single-Byte Opcodes")
case 0x0b: { // or r/m32 with r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "or r/m32 with " << rname(arg1) << end();
const int32_t* arg2 = effective_address(modrm);
BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2);
@ -217,8 +217,8 @@ put(name, "33", "r32 = bitwise XOR of r32 with rm32");
:(before "End Single-Byte Opcodes")
case 0x33: { // xor r/m32 with r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "xor r/m32 with " << rname(arg1) << end();
const int32_t* arg2 = effective_address(modrm);
BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2);
@ -301,12 +301,12 @@ put(name, "3b", "compare: set SF if r32 < rm32");
:(before "End Single-Byte Opcodes")
case 0x3b: { // set SF if r32 < r/m32
uint8_t modrm = next();
uint8_t reg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t reg1 = (modrm>>3)&0x7;
trace(90, "run") << "compare r/m32 with " << rname(reg1) << end();
int32_t arg1 = Reg[reg1].i;
int32_t* arg2 = effective_address(modrm);
int32_t tmp1 = arg1 - *arg2;
const int32_t arg1 = Reg[reg1].i;
const int32_t* arg2 = effective_address(modrm);
const int32_t tmp1 = arg1 - *arg2;
SF = (tmp1 < 0);
ZF = (tmp1 == 0);
int64_t tmp2 = arg1 - *arg2;
@ -373,10 +373,10 @@ af 00 00 00 # 0xaf
:(before "End Single-Byte Opcodes")
case 0x8b: { // copy r32 to r/m32
uint8_t modrm = next();
uint8_t rdest = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t rdest = (modrm>>3)&0x7;
trace(90, "run") << "copy r/m32 to " << rname(rdest) << end();
int32_t* src = effective_address(modrm);
const int32_t* src = effective_address(modrm);
Reg[rdest].i = *src;
trace(90, "run") << "storing 0x" << HEXWORD << *src << end();
break;
@ -403,8 +403,8 @@ f0 cc bb aa # 0xf0 with more data in following bytes
:(before "End Single-Byte Opcodes")
case 0x88: { // copy r8 to r/m8
uint8_t modrm = next();
uint8_t rsrc = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t rsrc = (modrm>>3)&0x7;
trace(90, "run") << "copy lowermost byte of " << rname(rsrc) << " to r8/m8-at-r32" << end();
// use unsigned to zero-extend 8-bit value to 32 bits
uint8_t* dest = reinterpret_cast<uint8_t*>(effective_address(modrm));
@ -435,11 +435,11 @@ ab ff ff ff # 0xab with more data in following bytes
:(before "End Single-Byte Opcodes")
case 0x8a: { // copy r/m8 to r8
uint8_t modrm = next();
uint8_t rdest = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t rdest = (modrm>>3)&0x7;
trace(90, "run") << "copy r8/m8-at-r32 to lowermost byte of " << rname(rdest) << end();
// use unsigned to zero-extend 8-bit value to 32 bits
uint8_t* src = reinterpret_cast<uint8_t*>(effective_address(modrm));
const uint8_t* src = reinterpret_cast<uint8_t*>(effective_address(modrm));
trace(90, "run") << "storing 0x" << HEXBYTE << NUM(*src) << end();
*reinterpret_cast<uint8_t*>(&Reg[rdest].u) = *src; // assumes host is little-endian
trace(90, "run") << rname(rdest) << " now contains 0x" << HEXWORD << Reg[rdest].u << end();
@ -468,7 +468,7 @@ case 0x8a: { // copy r/m8 to r8
:(before "End Op ff Subops")
case 4: { // jump to r/m32
trace(90, "run") << "jump to r/m32" << end();
int32_t* arg2 = effective_address(modrm);
const int32_t* arg2 = effective_address(modrm);
EIP = *arg2;
trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end();
break;
@ -519,8 +519,8 @@ put(name, "8f", "pop top of stack to rm32");
:(before "End Single-Byte Opcodes")
case 0x8f: { // pop stack into r/m32
uint8_t modrm = next();
uint8_t subop = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t subop = (modrm>>3)&0x7;
switch (subop) {
case 0: {
trace(90, "run") << "pop into r/m32" << end();
@ -658,8 +658,8 @@ put(name, "8d", "load effective address of memory in rm32 into r32");
:(before "End Single-Byte Opcodes")
case 0x8d: { // lea m32 to r32
uint8_t modrm = next();
uint8_t arg1 = (modrm>>3)&0x7;
const uint8_t modrm = next();
const uint8_t arg1 = (modrm>>3)&0x7;
trace(90, "run") << "lea into " << rname(arg1) << end();
Reg[arg1].u = effective_address_number(modrm);
break;

36
subx/015immediate_addressing.cc
View File

@ -18,11 +18,11 @@ put(name, "81", "combine rm32 with imm32 based on subop");
:(before "End Single-Byte Opcodes")
case 0x81: { // combine imm32 with r/m32
trace(90, "run") << "combine imm32 with r/m32" << end();
uint8_t modrm = next();
const uint8_t modrm = next();
int32_t* arg1 = effective_address(modrm);
int32_t arg2 = next32();
const int32_t arg2 = next32();
trace(90, "run") << "imm32 is 0x" << HEXWORD << arg2 << end();
uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits
switch (subop) {
case 0:
trace(90, "run") << "subop add" << end();
@ -67,7 +67,7 @@ put(name, "2d", "subtract imm32 from R0 (EAX)");
:(before "End Single-Byte Opcodes")
case 0x2d: { // subtract imm32 from EAX
int32_t arg2 = next32();
const int32_t arg2 = next32();
trace(90, "run") << "subtract imm32 0x" << HEXWORD << arg2 << " from EAX" << end();
BINARY_ARITHMETIC_OP(-, Reg[EAX].i, arg2);
break;
@ -125,7 +125,7 @@ put(name, "25", "R0 = bitwise AND of imm32 with R0 (EAX)");
:(before "End Single-Byte Opcodes")
case 0x25: { // and imm32 with EAX
int32_t arg2 = next32();
const int32_t arg2 = next32();
trace(90, "run") << "and imm32 0x" << HEXWORD << arg2 << " with EAX" << end();
BINARY_BITWISE_OP(&, Reg[EAX].i, arg2);
break;
@ -183,7 +183,7 @@ put(name, "0d", "R0 = bitwise OR of imm32 with R0 (EAX)");
:(before "End Single-Byte Opcodes")
case 0x0d: { // or imm32 with EAX
int32_t arg2 = next32();
const int32_t arg2 = next32();
trace(90, "run") << "or imm32 0x" << HEXWORD << arg2 << " with EAX" << end();
BINARY_BITWISE_OP(|, Reg[EAX].i, arg2);
break;
@ -239,7 +239,7 @@ put(name, "35", "R0 = bitwise XOR of imm32 with R0 (EAX)");
:(before "End Single-Byte Opcodes")
case 0x35: { // xor imm32 with EAX
int32_t arg2 = next32();
const int32_t arg2 = next32();
trace(90, "run") << "xor imm32 0x" << HEXWORD << arg2 << " with EAX" << end();
BINARY_BITWISE_OP(^, Reg[EAX].i, arg2);
break;
@ -295,13 +295,13 @@ put(name, "3d", "compare: set SF if R0 < imm32");
:(before "End Single-Byte Opcodes")
case 0x3d: { // compare EAX with imm32
int32_t arg1 = Reg[EAX].i;
int32_t arg2 = next32();
const int32_t arg1 = Reg[EAX].i;
const int32_t arg2 = next32();
trace(90, "run") << "compare EAX and imm32 0x" << HEXWORD << arg2 << end();
int32_t tmp1 = arg1 - arg2;
const int32_t tmp1 = arg1 - arg2;
SF = (tmp1 < 0);
ZF = (tmp1 == 0);
int64_t tmp2 = arg1 - arg2;
const int64_t tmp2 = arg1 - arg2;
OF = (tmp1 != tmp2);
trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end();
break;
@ -339,10 +339,10 @@ case 0x3d: { // compare EAX with imm32
:(before "End Op 81 Subops")
case 7: {
trace(90, "run") << "subop compare" << end();
int32_t tmp1 = *arg1 - arg2;
const int32_t tmp1 = *arg1 - arg2;
SF = (tmp1 < 0);
ZF = (tmp1 == 0);
int64_t tmp2 = *arg1 - arg2;
const int64_t tmp2 = *arg1 - arg2;
OF = (tmp1 != tmp2);
trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end();
break;
@ -437,8 +437,8 @@ case 0xbc:
case 0xbd:
case 0xbe:
case 0xbf: { // copy imm32 to r32
uint8_t rdest = op & 0x7;
int32_t src = next32();
const uint8_t rdest = op & 0x7;
const int32_t src = next32();
trace(90, "run") << "copy imm32 0x" << HEXWORD << src << " to " << rname(rdest) << end();
Reg[rdest].i = src;
break;
@ -461,10 +461,10 @@ put(name, "c7", "copy imm32 to rm32");
:(before "End Single-Byte Opcodes")
case 0xc7: { // copy imm32 to r32
uint8_t modrm = next();
const uint8_t modrm = next();
trace(90, "run") << "copy imm32 to r/m32" << end();
int32_t* dest = effective_address(modrm);
int32_t src = next32();
const int32_t src = next32();
trace(90, "run") << "imm32 is 0x" << HEXWORD << src << end();
*dest = src;
break;
@ -486,7 +486,7 @@ put(name, "68", "push imm32 to stack");
:(before "End Single-Byte Opcodes")
case 0x68: {
uint32_t val = static_cast<uint32_t>(next32());
const uint32_t val = static_cast<uint32_t>(next32());
trace(90, "run") << "push imm32 0x" << HEXWORD << val << end();
//? cerr << "push: " << val << " => " << Reg[ESP].u << '\n';
push(val);

8
subx/016index_addressing.cc
View File

@ -21,8 +21,8 @@ case 4: // exception: mod 0b00 rm 0b100 => incoming SIB (scale-index-base) byte
break;
:(code)
uint32_t effective_address_from_sib(uint8_t mod) {
uint8_t sib = next();
uint8_t base = sib&0x7;
const uint8_t sib = next();
const uint8_t base = sib&0x7;
uint32_t addr = 0;
if (base != EBP || mod != 0) {
addr = Reg[base].u;
@ -33,13 +33,13 @@ uint32_t effective_address_from_sib(uint8_t mod) {
addr = next32(); // ignore base
trace(90, "run") << "effective address is initially 0x" << std::hex << addr << " (disp32)" << end();
}
uint8_t index = (sib>>3)&0x7;
const uint8_t index = (sib>>3)&0x7;
if (index == ESP) {
// ignore index and scale
trace(90, "run") << "effective address is 0x" << std::hex << addr << end();
}
else {
uint8_t scale = (1 << (sib>>6));
const uint8_t scale = (1 << (sib>>6));
addr += Reg[index].i*scale; // treat index register as signed. Maybe base as well? But we'll always ensure it's non-negative.
trace(90, "run") << "effective address is 0x" << std::hex << addr << " (after adding " << rname(index) << "*" << NUM(scale) << ")" << end();
}

12
subx/017jump_disp8.cc
View File

@ -43,7 +43,7 @@ put(name, "74", "jump disp8 bytes away if ZF is set");
:(before "End Single-Byte Opcodes")
case 0x74: { // jump rel8 if ZF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (ZF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -82,7 +82,7 @@ put(name, "75", "jump disp8 bytes away if ZF is not set");
:(before "End Single-Byte Opcodes")
case 0x75: { // jump rel8 unless ZF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (!ZF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -123,7 +123,7 @@ put(name, "7f", "jump disp8 bytes away if greater (ZF is unset, SF == OF)");
:(before "End Single-Byte Opcodes")
case 0x7f: { // jump rel8 if !SF and !ZF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (!ZF && SF == OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -165,7 +165,7 @@ put(name, "7d", "jump disp8 bytes away if greater or equal (SF == OF)");
:(before "End Single-Byte Opcodes")
case 0x7d: { // jump rel8 if !SF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (SF == OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -207,7 +207,7 @@ put(name, "7c", "jump disp8 bytes away if lesser (SF != OF)");
:(before "End Single-Byte Opcodes")
case 0x7c: { // jump rel8 if SF and !ZF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (SF != OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -264,7 +264,7 @@ put(name, "7e", "jump disp8 bytes away if lesser or equal (ZF is set or SF != OF
:(before "End Single-Byte Opcodes")
case 0x7e: { // jump rel8 if SF or ZF
int8_t offset = static_cast<int>(next());
const int8_t offset = static_cast<int>(next());
if (ZF || SF != OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;

14
subx/018jump_disp16.cc
View File

@ -18,7 +18,7 @@ put(name, "e9", "jump disp16 bytes away");
:(before "End Single-Byte Opcodes")
case 0xe9: { // jump rel8
int16_t offset = imm16();
const int16_t offset = imm16();
trace(90, "run") << "jump " << offset << end();
EIP += offset;
break;
@ -49,7 +49,7 @@ put(name_0f, "84", "jump disp16 bytes away if ZF is set");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x84: { // jump rel16 if ZF
int8_t offset = imm16();
const int8_t offset = imm16();
if (ZF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -88,7 +88,7 @@ put(name_0f, "85", "jump disp16 bytes away if ZF is not set");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x85: { // jump rel16 unless ZF
int8_t offset = imm16();
const int8_t offset = imm16();
if (!ZF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -129,7 +129,7 @@ put(name_0f, "8f", "jump disp16 bytes away if greater (ZF is unset, SF == OF)");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x8f: { // jump rel16 if !SF and !ZF
int8_t offset = imm16();
const int8_t offset = imm16();
if (!ZF && SF == OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -171,7 +171,7 @@ put(name_0f, "8d", "jump disp16 bytes away if greater or equal (SF == OF)");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x8d: { // jump rel16 if !SF
int8_t offset = imm16();
const int8_t offset = imm16();
if (SF == OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -213,7 +213,7 @@ put(name_0f, "8c", "jump disp16 bytes away if lesser (SF != OF)");
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x8c: { // jump rel16 if SF and !ZF
int8_t offset = imm16();
const int8_t offset = imm16();
if (SF != OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;
@ -270,7 +270,7 @@ put(name_0f, "8e", "jump disp16 bytes away if lesser or equal (ZF is set or SF !
:(before "End Two-Byte Opcodes Starting With 0f")
case 0x8e: { // jump rel16 if SF or ZF
int8_t offset = imm16();
const int8_t offset = imm16();
if (ZF || SF != OF) {
trace(90, "run") << "jump " << NUM(offset) << end();
EIP += offset;

4
subx/019functions.cc
View File

@ -16,7 +16,7 @@ put(name, "e8", "call disp32");
:(before "End Single-Byte Opcodes")
case 0xe8: { // call disp32 relative to next EIP
int32_t offset = next32();
const int32_t offset = next32();
trace(90, "run") << "call imm32 0x" << HEXWORD << offset << end();
//? cerr << "push: EIP: " << EIP << " => " << Reg[ESP].u << '\n';
push(EIP);
@ -43,7 +43,7 @@ case 0xe8: { // call disp32 relative to next EIP
:(before "End Op ff Subops")
case 2: { // call function pointer at r/m32
trace(90, "run") << "call to r/m32" << end();
int32_t* offset = effective_address(modrm);
const int32_t* offset = effective_address(modrm);
push(EIP);
EIP += *offset;
trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end();