Function EdGdEffective

source/test/testCPU.cpp:1724–1816

}

void EdGdEffective(int instruction, struct Data* data, bool includeLock = false) {
    while (data->valid) {
        int ed;
        int gd;
        int rm;

        for (ed = 0; ed < 8; ed++) {
            for (gd = 0; gd < 8; gd++) {
                Reg* e;
                Reg* g;

                if (ed == gd)
                    continue;
                rm = ed | (gd << 3) | 0xC0;
                newInstructionWithRM(instruction, rm, data->flags);
                pushConstant(data);
                e = &cpu->reg[E(rm)];
                g = &cpu->reg[G(rm)];
                e->u32 = data->var1;
                g->u32 = data->var2;
                runTestCPU();
                assertResult(data, cpu, instruction, e->u32, g->u32, E(rm), G(rm), 0, 32);

                if (gd == 4 || ed == 4) {
                    continue;
                }
                newInstructionWithRM(instruction, rm, data->flags);
                pushConstant(data);
                e = &cpu->reg[E(rm)];
                g = &cpu->reg[G(rm)];
                e->u32 = data->var1;
                g->u32 = data->var2;
                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
                runTestCPU();
                assertResult(data, cpu, instruction, e->u32, g->u32, E(rm), G(rm), 0, 32, true);
            }
        }

        for (int lock = 0; lock < 3; lock++) {
            for (gd = 0; gd < 8; gd++) {
                Reg* g;
                U32 result;
                int offset = 0;

                rm = (gd << 3);
                if (cpu->big) {
                    offset = (data->var2 >> 5) * 4;
                    rm += 5;
                } else {
                    offset = (data->var2 >> 4) * 2;
                    rm += 6;
                }
                newInstructionWithRM(instruction, rm, data->flags, lock ? LOCK_PREFIX : 0);
                U16 addressOffset = lock == 2 ? 202 : 200;

                if (cpu->big)
                    pushCode32(addressOffset);