Function EbIb

source/test/testCPU.cpp:705–769

}

void EbIb(int instruction, int which, struct Data* data, bool address32, bool includeLock = false) {
    while (data->valid) {
        int eb;
        int rm;
        U32 result;

        for (int setsFlags = 0; setsFlags < 3; setsFlags++) {
            for (eb = 0; eb < 8; eb++) {
                U8* e;

                rm = eb | (which << 3) | 0xC0;
                newInstructionWithRM(instruction, rm, data->flags);
                pushCode8(data->var2);
                e = cpu->reg8[E(rm)];
                cpu->reg[E8(rm)].u32 = DEFAULT;
                *e = data->var1;

                if (setsFlags == 0) {
                    pushCode8(0x39);
                    pushCode8(0xc0); // cmp eax, eax: this will overwrite flags so the above code might take a different path in the dynamic cores that optimize away flag calculation
                } else if (setsFlags == 2) {
                    // flags will be calculate in JIT
                    U8 reg = 5;
                    if (eb == 5) {
                        reg = 6;
                    }
                    pushCode8(0x9c); // push flags
                    pushCode8(0x58 + reg); // pop reg
                }

                runTestCPU();
                assertResult(data, cpu, instruction, *e, 0, E8(rm), -1, 0, 8, setsFlags == 0);
            }
        }

        for (int lock = 0; lock < 3; lock++) {
            rm = (which << 3);
            if (address32) {
                rm += 5;
            } else {
                rm += 6;
            }
            bool isBig = cpu->big ? true : false;
            bool needPrefix = address32 != isBig;
            newInstructionWithRM(instruction, rm, data->flags, (needPrefix ? 0x67 : 0), lock ? LOCK_PREFIX : 0);
            U16 offset = lock == 2 ? 201 : 200;

            if (address32) {
                pushCode32(offset);
            } else {
                pushCode16(offset);
            }
            pushCode8(data->var2);
            memory->writed(cpu->seg[DS].address + offset, DEFAULT);
            memory->writeb(cpu->seg[DS].address + offset, data->var1);
            runTestCPU();
            result = memory->readb(cpu->seg[DS].address + offset);
            assertResult(data, cpu, instruction, result, 0, -1, -1, cpu->seg[DS].address + offset, 8);