How are you capturing the resulting flags? Something as critical as the proper Z flag behaviour seems highly unikely to have been overlooked by Bochs.

I'm making a simple dump of register state before every instruction is executed in Bochs (before opcodes are executed and when an IRQ or Trap is fired):

1typedef struct
2{
3	word CS, SS, DS, ES; //16-bit segment registers!
4	word AX, BX, CX, DX; //16-bit GP registers!
5	word SI, DI, SP, BP;
6	word IP;
7	word FLAGS;
8	word type; //Special type indication!
9} VERIFICATIONDATA;

My emulator (x86EMU) compares register states before any instruction is executed. At the point of going to execute a XOR AX,AX instruction the flags register is cleared. When executed my emulator sets the Zero flag (AX=0) and Parity flag (AX=0=Parity becomes 1). The dump from bochs points to the correct instruction after the XOR AX,AX instruction and the Zero flag and Parity flags are cleared in the dump.

I'm looking at the Bochs source code... I can't seem to find the Zero and Parity flags being updated after an XOR instruction?

Maybe bochs' lazy flag calculation doesn't update the correct state yet. But I seriously doubt that bochs would have issues in his.

superfury wrote:

I'm looking at the Bochs source code... I can't seem to find the Zero and Parity flags being updated after an XOR instruction?

Ah, as Harekiet wrote, they are evaluated in a lazy fashion, meaning that the results are not calculated until they are needed.
For that reason, you won't get a 1:1 match in the flags at the moment where you are comparing right now.
You need to either trace until after an instruction that makes use of the flags in any way, in order to see the result, or ignore the flags completely. To really see the flags, for example:
xor eax, eax
je somewhere
The branch will trigger the evaluation, and you will see a match in the flags values.

Is there an easy way to disable the lazy flag behaviour using Bochs defines? I need to have correct values to verify my instruction emulation in my emulator.

Use the source Luke!

I've added the flags by ANDING the dumped resisters and OR it with the getB_*F() result:

1		  data.REGFLAGS = ((BX_CPU_THIS_PTR eflags)&0xFFFF)&(~0x8D5); //Create the flags without lazy flags!
2		  data.REGFLAGS |= getB_CF();
3		  data.REGFLAGS |= (getB_PF() << 2);
4		  data.REGFLAGS |= (getB_AF() << 4);
5		  data.REGFLAGS |= (getB_ZF() << 6);
6		  data.REGFLAGS |= (getB_SF() << 7);
7		  data.REGFLAGS |= (getB_OF() << 11); //Apply all lazy flags to our output!

Now the flags work correctly, but once it starts on the first REP STOSW instruction, it seems to go 3 times as slow as my own emulation (one REP STOSW per dump entry). Bochs dumps three times the same dump entry during this instruction? Anyone knows why?

It might be the result of updating di and cx and the flags. Separately.

Is there a simple way to fix this? I need a normal dump for comparing it to my emulator (one dump per STOSW instruction executed).

You'd have to check the source to find out exactly why it's happening, and then to stop if from happening.