diff --git a/src/cpu/8080.c b/src/cpu/8080.c index 6d9849e24..c427919bc 100644 --- a/src/cpu/8080.c +++ b/src/cpu/8080.c @@ -21,13 +21,16 @@ #include <86box/i8080.h> #include <86box/mem.h> -static int prefetching = 1, completed = 1; +static int completed = 1; static int in_rep = 0, repeating = 0, rep_c_flag = 0; -static int oldc, clear_lock = 0; -static int refresh = 0, cycdiff; +static int oldc, cycdiff; +#ifdef UNUSED_8080_VARS +static int prefetching = 1; +static int refresh = 0, clear_lock = 0; static uint32_t cpu_src = 0, cpu_dest = 0; static uint32_t cpu_data = 0; +#endif static void clock_start(void) @@ -48,7 +51,7 @@ clock_end(void) } static void -8080_wait(int c, int bus) +i8080_wait(int c, int bus) { cycles -= c; if (bus < 2) { @@ -57,12 +60,13 @@ static void } } +#ifdef UNUSED_8080_FUNCS static uint8_t readmemb(uint32_t a) { uint8_t ret; - 8080_wait(4, 1); + i8080_wait(4, 1); ret = read_mem_b(a); return ret; @@ -76,6 +80,7 @@ ins_fetch(i8080* cpu) cpu->pc++; return ret; } +#endif void transfer_from_808x(i8080* cpu) @@ -188,12 +193,14 @@ interpret_exec8080(i8080* cpu, uint8_t opcode) void exec8080(i8080* cpu, int cycs) { +#ifdef UNUSED_8080_VARS uint8_t temp = 0, temp2; uint8_t old_af; - uint8_t handled = 0; + uint8_t handled = 0; uint16_t addr, tempw; uint16_t new_ip; int bits; +#endif cycles += cycs; @@ -204,7 +211,7 @@ exec8080(i8080* cpu, int cycs) cpu->oldpc = cpu->pc; opcode = cpu->fetchinstruction(cpu); oldc = cpu->flags & C_FLAG_I8080; - 8080_wait(1, 0); + i8080_wait(1, 0); } completed = 1; if (completed) { diff --git a/src/cpu/808x.c b/src/cpu/808x.c index 60188faff..eed504196 100644 --- a/src/cpu/808x.c +++ b/src/cpu/808x.c @@ -1645,12 +1645,18 @@ cpu_outw(uint16_t port, uint16_t val) void execx86(int cycs) { - uint8_t temp = 0, temp2; - uint8_t old_af; - uint8_t handled = 0; - uint16_t addr, tempw; - uint16_t new_cs, new_ip; + uint8_t temp = 0, temp2, old_af, nests; + uint8_t temp_val, temp_al, bit, handled = 0; + uint8_t odd, zero, nibbles_count, destcmp; + uint8_t destbyte, srcbyte, nibble_result, bit_length; + uint8_t bit_offset; + int8_t nibble_result_s; + uint16_t addr, tempw, new_cs, new_ip; + uint16_t tempw_int, size, tempbp, lowbound; + uint16_t highbound, regval; int bits; + uint32_t dest_seg, i, carry, nibble; + uint32_t srcseg, byteaddr; cycles += cycs; @@ -1674,110 +1680,106 @@ execx86(int cycs) switch (opcode) { case 0x6c: case 0x6d: /* INM dst, DW/INS dst, DX */ - { - bits = 8 << (opcode & 1); - handled = 1; - if (!repeating) - wait(2, 0); + bits = 8 << (opcode & 1); + handled = 1; + if (!repeating) + wait(2, 0); - if (rep_action(bits)) { - break; - } else if (!repeating) { - wait(7, 0); - } - if (bits == 16) { - writememw(es, DI, cpu_inw(DX)); - DI += (cpu_state.flags & D_FLAG) ? -2 : 2; - } else { - wait(4, 0); - writememb(es, DI, inb(DX)); - DI += (cpu_state.flags & D_FLAG) ? -1 : 1; - } - if (in_rep == 0) { - break; - } - repeating = 1; - clock_end(); + if (rep_action(bits)) break; + else if (!repeating) + wait(7, 0); + + if (bits == 16) { + writememw(es, DI, cpu_inw(DX)); + DI += (cpu_state.flags & D_FLAG) ? -2 : 2; + } else { + wait(4, 0); + writememb(es, DI, inb(DX)); + DI += (cpu_state.flags & D_FLAG) ? -1 : 1; } + + if (in_rep == 0) + break; + + repeating = 1; + clock_end(); + break; + case 0x6e: case 0x6f: /* OUTM DW, src/OUTS DX, src */ - { - uint32_t dest_seg = ovr_seg ? *ovr_seg : ds; - bits = 8 << (opcode & 1); - handled = 1; - if (!repeating) - wait(2, 0); + dest_seg = ovr_seg ? *ovr_seg : ds; + bits = 8 << (opcode & 1); + handled = 1; + if (!repeating) + wait(2, 0); - if (rep_action(bits)) { - break; - } else if (!repeating) { - wait(7, 0); - } - if (bits == 16) { - cpu_outw(DX, readmemw(dest_seg, SI)); - SI += (cpu_state.flags & D_FLAG) ? -2 : 2; - } else { - wait(4, 0); - outb(DX, readmemb(dest_seg + SI)); - SI += (cpu_state.flags & D_FLAG) ? -1 : 1; - } - if (in_rep == 0) { - break; - } - repeating = 1; - clock_end(); - break; - } - case 0xC8: /* ENTER/PREPARE */ - { - uint16_t temp = 0; - uint16_t size = pfq_fetchw(); - uint8_t nests = pfq_fetchb(); - uint32_t i = 0; + if (rep_action(bits)) + break; + else if (!repeating) + wait(7, 0); - push(&BP); - temp = SP; - if (nests > 0) { - while (--nests) { - uint16_t tempbp = 0; - BP -= 2; - tempbp = readmemw(ss, BP); - push(&tempbp); - } - push(&temp); + if (bits == 16) { + cpu_outw(DX, readmemw(dest_seg, SI)); + SI += (cpu_state.flags & D_FLAG) ? -2 : 2; + } else { + wait(4, 0); + outb(DX, readmemb(dest_seg + SI)); + SI += (cpu_state.flags & D_FLAG) ? -1 : 1; + } + if (in_rep == 0) + break; + + repeating = 1; + clock_end(); + break; + + case 0xc8: /* ENTER/PREPARE */ + tempw_int = 0; + size = pfq_fetchw(); + nests = pfq_fetchb(); + i = 0; + + push(&BP); + tempw_int = SP; + if (nests > 0) { + while (--nests) { + tempbp = 0; + BP -= 2; + tempbp = readmemw(ss, BP); + push(&tempbp); } - BP = temp; - SP -= size; - handled = 1; - break; - } - case 0xC9: /* LEAVE/DISPOSE */ - { - SP = BP; - BP = pop(); - handled = 1; - break; + push(&tempw_int); } + BP = tempw_int; + SP -= size; + handled = 1; + break; + + case 0xc9: /* LEAVE/DISPOSE */ + SP = BP; + BP = pop(); + handled = 1; + break; + case 0x62: /* BOUND r/m */ - { - uint16_t oldpc = cpu_state.oldpc; - uint16_t lowbound = 0, highbound = 0; - uint16_t regval = 0; - do_mod_rm(); + lowbound = 0; + highbound = 0; + regval = 0; + do_mod_rm(); - lowbound = readmemw(easeg, cpu_state.eaaddr); - highbound = readmemw(easeg, cpu_state.eaaddr + 2); - regval = get_reg(cpu_reg); - if (lowbound > regval || highbound < regval) { - cpu_state.pc = cpu_state.oldpc; - interrupt(5); - } - handled = 1; - break; + lowbound = readmemw(easeg, cpu_state.eaaddr); + highbound = readmemw(easeg, cpu_state.eaaddr + 2); + regval = get_reg(cpu_reg); + if (lowbound > regval || highbound < regval) { + cpu_state.pc = cpu_state.oldpc; + interrupt(5); } - case 0xC0: - case 0xC1: /*rot imm8 */ + handled = 1; + break; + + case 0xc0: + case 0xc1: /*rot imm8 */ bits = 8 << (opcode & 1); do_mod_rm(); if (cpu_mod == 3) @@ -1885,297 +1887,289 @@ execx86(int cycs) opcode = pfq_fetchb(); switch (opcode) { case 0x28: /* ROL4 r/m */ - { - do_mod_rm(); - wait(21, 0); - { - uint8_t temp_val = geteab(); - uint8_t temp_al = AL; + do_mod_rm(); + wait(21, 0); - temp_al &= 0xF; - temp_al |= (temp_val & 0xF0); - temp_val = (temp_al & 0xF) | ((temp_val & 0xF) << 4); - temp_al >>= 4; - temp_al &= 0xF; - seteab(temp_val); - AL = temp_al; - } - handled = 1; - break; - } - case 0x2a: /* ROR4 r/m */ - { - do_mod_rm(); - wait(21, 0); - { - uint8_t temp_val = geteab(); - uint8_t temp_al = AL; + temp_val = geteab(); + temp_al = AL; - AL = temp_val & 0xF; - temp_val = (temp_val >> 4) | ((temp_al & 0xF) << 4); + temp_al &= 0xF; + temp_al |= (temp_val & 0xF0); + temp_val = (temp_al & 0xF) | ((temp_val & 0xF) << 4); + temp_al >>= 4; + temp_al &= 0xF; + seteab(temp_val); + AL = temp_al; + + handled = 1; + break; + + case 0x2a: /* ROR4 r/m */ + do_mod_rm(); + wait(21, 0); + + temp_val = geteab(); + temp_al = AL; + + AL = temp_val & 0xF; + temp_val = (temp_val >> 4) | ((temp_al & 0xF) << 4); + + seteab(temp_val); + + handled = 1; + break; - seteab(temp_val); - } - handled = 1; - break; - } case 0x10: /* TEST1 r8/m8, CL*/ case 0x11: /* TEST1 r16/m16, CL*/ case 0x18: /* TEST1 r8/m8, imm3 */ case 0x19: /* TEST1 r16/m16, imm4 */ - { - bits = 8 << (opcode & 0x1); - do_mod_rm(); - wait(3, 0); - { - uint8_t bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); - bit &= ((1 << (3 + (opcode & 0x1))) - 1); - read_ea(0, bits); + bits = 8 << (opcode & 0x1); + do_mod_rm(); + wait(3, 0); + + bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); + bit &= ((1 << (3 + (opcode & 0x1))) - 1); + read_ea(0, bits); + + set_zf_ex(!(cpu_data & (1 << bit))); + cpu_state.flags &= ~(V_FLAG | C_FLAG); + + handled = 1; + break; - set_zf_ex(!(cpu_data & (1 << bit))); - cpu_state.flags &= ~(V_FLAG | C_FLAG); - } - handled = 1; - break; - } case 0x16: /* NOT1 r8/m8, CL*/ case 0x17: /* NOT1 r16/m16, CL*/ case 0x1e: /* NOT1 r8/m8, imm3 */ case 0x1f: /* NOT1 r16/m16, imm4 */ - { - bits = 8 << (opcode & 0x1); - do_mod_rm(); - wait(3, 0); - { - uint8_t bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); - bit &= ((1 << (3 + (opcode & 0x1))) - 1); - read_ea(0, bits); + bits = 8 << (opcode & 0x1); + do_mod_rm(); + wait(3, 0); + + bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); + bit &= ((1 << (3 + (opcode & 0x1))) - 1); + read_ea(0, bits); + + if (bits == 8) + seteab((cpu_data & 0xFF) ^ (1 << bit)); + else + seteaw((cpu_data & 0xFFFF) ^ (1 << bit)); + + handled = 1; + break; - if (bits == 8) - seteab((cpu_data & 0xFF) ^ (1 << bit)); - else - seteaw((cpu_data & 0xFFFF) ^ (1 << bit)); - } - handled = 1; - break; - } case 0x14: /* SET1 r8/m8, CL*/ case 0x15: /* SET1 r16/m16, CL*/ case 0x1c: /* SET1 r8/m8, imm3 */ case 0x1d: /* SET1 r16/m16, imm4 */ - { - bits = 8 << (opcode & 0x1); - do_mod_rm(); - wait(3, 0); - { - uint8_t bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); - bit &= ((1 << (3 + (opcode & 0x1))) - 1); - read_ea(0, bits); + bits = 8 << (opcode & 0x1); + do_mod_rm(); + wait(3, 0); + + bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); + bit &= ((1 << (3 + (opcode & 0x1))) - 1); + read_ea(0, bits); + + if (bits == 8) + seteab((cpu_data & 0xFF) | (1 << bit)); + else + seteaw((cpu_data & 0xFFFF) | (1 << bit)); + + handled = 1; + break; - if (bits == 8) - seteab((cpu_data & 0xFF) | (1 << bit)); - else - seteaw((cpu_data & 0xFFFF) | (1 << bit)); - } - handled = 1; - break; - } case 0x12: /* CLR1 r8/m8, CL*/ case 0x13: /* CLR1 r16/m16, CL*/ case 0x1a: /* CLR1 r8/m8, imm3 */ case 0x1b: /* CLR1 r16/m16, imm4 */ - { - bits = 8 << (opcode & 0x1); - do_mod_rm(); - wait(3, 0); - { - uint8_t bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); - bit &= ((1 << (3 + (opcode & 0x1))) - 1); - read_ea(0, bits); + bits = 8 << (opcode & 0x1); + do_mod_rm(); + wait(3, 0); + + bit = (opcode & 0x8) ? (pfq_fetchb()) : (CL); + bit &= ((1 << (3 + (opcode & 0x1))) - 1); + read_ea(0, bits); + + if (bits == 8) + seteab((cpu_data & 0xFF) & ~(1 << bit)); + else + seteaw((cpu_data & 0xFFFF) & ~(1 << bit)); + + handled = 1; + break; - if (bits == 8) - seteab((cpu_data & 0xFF) & ~(1 << bit)); - else - seteaw((cpu_data & 0xFFFF) & ~(1 << bit)); - } - handled = 1; - break; - } case 0x20: /* ADD4S */ - { - uint8_t odd = !!(CL % 2); - uint8_t zero = 1; - uint8_t nibbles_count = CL - odd; - uint32_t i = 0, carry = 0, nibble = 0; - uint32_t srcseg = ovr_seg ? *ovr_seg : ds; + odd = !!(CL % 2); + zero = 1; + nibbles_count = CL - odd; + i = 0; + carry = 0; + nibble = 0; + srcseg = ovr_seg ? *ovr_seg : ds; - wait(5, 0); - for (i = 0; i < ((nibbles_count / 2) + odd); i++) { - wait(19, 0); - uint8_t destcmp = read_mem_b((es) + DI + i); - for (nibble = 0; nibble < 2; nibble++) { - uint8_t destbyte = destcmp >> (nibble ? 4 : 0); - uint8_t srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); - destbyte &= 0xF; - srcbyte &= 0xF; - uint8_t nibble_result = (i == (nibbles_count / 2) && nibble == 1) ? (destbyte + carry) : ((uint8_t) (destbyte)) + ((uint8_t) (srcbyte)) + ((uint32_t) carry); - carry = 0; - while (nibble_result >= 10) { - nibble_result -= 10; - carry++; - } - if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) - zero = (nibble_result == 0); - destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result << (4 * nibble))); + wait(5, 0); + for (i = 0; i < ((nibbles_count / 2) + odd); i++) { + wait(19, 0); + destcmp = read_mem_b((es) + DI + i); + for (nibble = 0; nibble < 2; nibble++) { + destbyte = destcmp >> (nibble ? 4 : 0); + srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); + destbyte &= 0xF; + srcbyte &= 0xF; + nibble_result = (i == (nibbles_count / 2) && nibble == 1) ? (destbyte + carry) : ((uint8_t) (destbyte)) + ((uint8_t) (srcbyte)) + ((uint32_t) carry); + carry = 0; + while (nibble_result >= 10) { + nibble_result -= 10; + carry++; } - write_mem_b(es + DI + i, destcmp); + if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) + zero = (nibble_result == 0); + destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result << (4 * nibble))); } - set_cf(!!carry); - set_zf(!!zero); - handled = 1; - break; + write_mem_b(es + DI + i, destcmp); } + set_cf(!!carry); + set_zf(!!zero); + handled = 1; + break; + case 0x22: /* SUB4S */ - { - uint8_t odd = !!(CL % 2); - uint8_t zero = 1; - uint8_t nibbles_count = CL - odd; - uint32_t i = 0, carry = 0, nibble = 0; - uint32_t srcseg = ovr_seg ? *ovr_seg : ds; + odd = !!(CL % 2); + zero = 1; + nibbles_count = CL - odd; + i = 0; + carry = 0; + nibble = 0; + srcseg = ovr_seg ? *ovr_seg : ds; - wait(5, 0); - for (i = 0; i < ((nibbles_count / 2) + odd); i++) { - wait(19, 0); - uint8_t destcmp = read_mem_b((es) + DI + i); - for (nibble = 0; nibble < 2; nibble++) { - uint8_t destbyte = destcmp >> (nibble ? 4 : 0); - uint8_t srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); - destbyte &= 0xF; - srcbyte &= 0xF; - int8_t nibble_result = (i == (nibbles_count / 2) && nibble == 1) ? ((int8_t) destbyte - (int8_t) carry) : ((int8_t) (destbyte)) - ((int8_t) (srcbyte)) - ((int8_t) carry); - carry = 0; - while (nibble_result < 0) { - nibble_result += 10; - carry++; - } - if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) - zero = (nibble_result == 0); - destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result << (4 * nibble))); + wait(5, 0); + for (i = 0; i < ((nibbles_count / 2) + odd); i++) { + wait(19, 0); + destcmp = read_mem_b((es) + DI + i); + for (nibble = 0; nibble < 2; nibble++) { + destbyte = destcmp >> (nibble ? 4 : 0); + srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); + destbyte &= 0xF; + srcbyte &= 0xF; + nibble_result_s = (i == (nibbles_count / 2) && nibble == 1) ? ((int8_t) destbyte - (int8_t) carry) : ((int8_t) (destbyte)) - ((int8_t) (srcbyte)) - ((int8_t) carry); + carry = 0; + while (nibble_result_s < 0) { + nibble_result_s += 10; + carry++; } - write_mem_b(es + DI + i, destcmp); + if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) + zero = (nibble_result_s == 0); + destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result_s << (4 * nibble))); } - set_cf(!!carry); - set_zf(!!zero); - handled = 1; - break; + write_mem_b(es + DI + i, destcmp); } + set_cf(!!carry); + set_zf(!!zero); + handled = 1; + break; + case 0x26: /* CMP4S */ - { - uint8_t odd = !!(CL % 2); - uint8_t zero = 1; - uint8_t nibbles_count = CL - odd; - uint32_t i = 0, carry = 0, nibble = 0; - uint32_t srcseg = ovr_seg ? *ovr_seg : ds; + odd = !!(CL % 2); + zero = 1; + nibbles_count = CL - odd; + i = 0; + carry = 0; + nibble = 0; + srcseg = ovr_seg ? *ovr_seg : ds; - wait(5, 0); - for (i = 0; i < ((nibbles_count / 2) + odd); i++) { - wait(19, 0); - uint8_t destcmp = read_mem_b((es) + DI + i); - for (nibble = 0; nibble < 2; nibble++) { - uint8_t destbyte = destcmp >> (nibble ? 4 : 0); - uint8_t srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); - destbyte &= 0xF; - srcbyte &= 0xF; - int8_t nibble_result = ((int8_t) (destbyte)) - ((int8_t) (srcbyte)) - ((int8_t) carry); - carry = 0; - while (nibble_result < 0) { - nibble_result += 10; - carry++; - } - if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) - zero = (nibble_result == 0); - destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result << (4 * nibble))); + wait(5, 0); + for (i = 0; i < ((nibbles_count / 2) + odd); i++) { + wait(19, 0); + destcmp = read_mem_b((es) + DI + i); + for (nibble = 0; nibble < 2; nibble++) { + destbyte = destcmp >> (nibble ? 4 : 0); + srcbyte = read_mem_b(srcseg + SI + i) >> (nibble ? 4 : 0); + destbyte &= 0xF; + srcbyte &= 0xF; + nibble_result_s = ((int8_t) (destbyte)) - ((int8_t) (srcbyte)) - ((int8_t) carry); + carry = 0; + while (nibble_result_s < 0) { + nibble_result_s += 10; + carry++; } + if (zero != 0 || (i == (nibbles_count / 2) && nibble == 1)) + zero = (nibble_result_s == 0); + destcmp = ((destcmp & (nibble ? 0x0F : 0xF0)) | (nibble_result_s << (4 * nibble))); } - set_cf(!!carry); - set_zf(!!zero); - handled = 1; - break; } + set_cf(!!carry); + set_zf(!!zero); + handled = 1; + break; + case 0x31: /* INS reg1, reg2 */ case 0x39: /* INS reg8, imm4 */ - { - do_mod_rm(); - wait(1, 0); - { - uint8_t bit_length = ((opcode & 0x8) ? (pfq_fetchb() & 0xF) : (getr8(cpu_reg) & 0xF)) + 1; - uint8_t bit_offset = getr8(cpu_rm) & 0xF; - uint32_t byteaddr = (es) + DI; - uint32_t i = 0; - if (bit_offset >= 8) { - DI++; - byteaddr++; - bit_offset -= 8; - } - for (i = 0; i < bit_length; i++) { - byteaddr = (es) + DI; - writememb(es, DI, (read_mem_b(byteaddr) & ~(1 << (bit_offset))) | ((!!(AX & (1 << i))) << bit_offset)); - bit_offset++; - if (bit_offset == 8) { - DI++; - bit_offset = 0; - } - } - setr8(cpu_rm, bit_offset); - } - handled = 1; - break; + do_mod_rm(); + wait(1, 0); + + bit_length = ((opcode & 0x8) ? (pfq_fetchb() & 0xF) : (getr8(cpu_reg) & 0xF)) + 1; + bit_offset = getr8(cpu_rm) & 0xF; + byteaddr = (es) + DI; + i = 0; + + if (bit_offset >= 8) { + DI++; + byteaddr++; + bit_offset -= 8; } + for (i = 0; i < bit_length; i++) { + byteaddr = (es) + DI; + writememb(es, DI, (read_mem_b(byteaddr) & ~(1 << (bit_offset))) | ((!!(AX & (1 << i))) << bit_offset)); + bit_offset++; + if (bit_offset == 8) { + DI++; + bit_offset = 0; + } + } + setr8(cpu_rm, bit_offset); + + handled = 1; + break; + case 0x33: /* EXT reg1, reg2 */ case 0x3b: /* EXT reg8, imm4 */ - { - do_mod_rm(); - wait(1, 0); - { - uint8_t bit_length = ((opcode & 0x8) ? (pfq_fetchb() & 0xF) : (getr8(cpu_reg) & 0xF)) + 1; - uint8_t bit_offset = getr8(cpu_rm) & 0xF; - uint32_t byteaddr = (ds) + SI; - uint32_t i = 0; + do_mod_rm(); + wait(1, 0); - if (bit_offset >= 8) { - SI++; - byteaddr++; - bit_offset -= 8; - } + bit_length = ((opcode & 0x8) ? (pfq_fetchb() & 0xF) : (getr8(cpu_reg) & 0xF)) + 1; + bit_offset = getr8(cpu_rm) & 0xF; + byteaddr = (ds) + SI; + i = 0; - AX = 0; - for (i = 0; i < bit_length; i++) { - byteaddr = (ds) + SI; - AX |= (!!(readmemb(byteaddr) & (1 << bit_offset))) << i; - bit_offset++; - if (bit_offset == 8) { - SI++; - bit_offset = 0; - } - } - setr8(cpu_rm, bit_offset); + if (bit_offset >= 8) { + SI++; + byteaddr++; + bit_offset -= 8; + } + + AX = 0; + for (i = 0; i < bit_length; i++) { + byteaddr = (ds) + SI; + AX |= (!!(readmemb(byteaddr) & (1 << bit_offset))) << i; + bit_offset++; + if (bit_offset == 8) { + SI++; + bit_offset = 0; } - handled = 1; - break; } + setr8(cpu_rm, bit_offset); + + handled = 1; + break; + + case 0xFF: /* BRKEM */ + /* Unimplemented for now. */ + fatal("808x: Unsupported 8080 emulation mode attempted to enter into!"); + break; - case 0xFF: - { /* BRKEM */ - /* Unimplemented for now. */ - fatal("808x: Unsupported 8080 emulation mode attempted to enter into!"); - break; - } default: - { - opcode = orig_opcode; - cpu_state.pc--; - break; - } + opcode = orig_opcode; + cpu_state.pc--; + break; } } else handled = 0; @@ -2445,12 +2439,11 @@ execx86(int cycs) case 0x70: /*JO*/ case 0x61: /*JNO alias*/ if (is186) { /* POPA/POP R*/ - uint16_t orig_sp = 0; /* deliberately unused. */ wait(9, 0); DI = pop(); SI = pop(); BP = pop(); - orig_sp = pop(); + (void) pop(); /* former orig_sp */ BX = pop(); DX = pop(); CX = pop();