Can anyone help me find a bug in 8086 CPU emulation?

[superfury]

I'm trying to find some bugs that seem to be in my 8086 CPU emulation (flag operations and group opcodes copied from fake86). Can anyone help me find the error(s) that seems to be in there (if there are any?)

extern byte oper1b, oper2b; //Byte variants!
extern word oper1, oper2; //Word variants!
extern byte res8; //Result 8-bit!
extern word res16; //Result 16-bit!
extern byte reg; //For function number!
extern uint_32 ea; //From RM offset (GRP5 Opcodes only!)

uint_32 temp1, temp2, temp3, temp4, temp5, temp32, tempaddr32;

void CPU8086_internal_INC16(word *reg)
{
	if (MMU_invaddr() || (reg==NULL))
	{
		return;
	}
	byte oldcf;
	oldcf = CF;
	oper1 = *reg;
	oper2 = 1;
	res16 = oper1+oper2;
	flag_add16(oper1,oper2);
	CF = oldcf;
	*reg = res16;
}
void CPU8086_internal_DEC16(word *reg)
{
	if (MMU_invaddr())
	{
		return;
	}
	byte oldcf;
	oldcf = CF;
	oper1 = *reg;
	oper2 = 1;
	res16 = oper1-oper2;
	flag_sub16(oper1,oper2);
	CF = oldcf;
	*reg = res16;
}

void CPU8086_internal_INC8(byte *reg)
{
	if (MMU_invaddr() || (reg==NULL))
	{
		return;
	}
	oper1b = *reg;
	oper2b = 1;
	flag_add8(oper1b,oper2b);
	*reg = oper1b+oper2b;
}
void CPU8086_internal_DEC8(byte *reg)
{
	if (MMU_invaddr())
	{
		return;
	}
	oper1b = *reg;
	oper2b = 1;
	flag_sub8(oper1b,oper2b);
	*reg = oper1b+oper2b;
}

//For ADD
void CPU8086_internal_ADD8(byte *dest, byte addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_add8(*dest,addition);
	*dest += addition;
}
void CPU8086_internal_ADD16(word *dest, word addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_add16(*dest,addition);
	*dest += addition;
}

//For ADC
void CPU8086_internal_ADC8(byte *dest, byte addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_adc8(*dest,addition,CF);
	*dest += addition+CF;
}
void CPU8086_internal_ADC16(word *dest, word addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_adc16(*dest,addition,CF);
	*dest += addition+CF;
}


//For OR
void CPU8086_internal_OR8(byte *dest, byte src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest |= src;
	flag_log8(*dest);
}
void CPU8086_internal_OR16(word *dest, word src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest |= src;
	flag_log16(*dest);
}

//For AND
void CPU8086_internal_AND8(byte *dest, byte src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest &= src;
	flag_log8(*dest);
}
void CPU8086_internal_AND16(word *dest, word src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest &= src;
	flag_log16(*dest);
}


//For SUB
void CPU8086_internal_SUB8(byte *dest, byte addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_sub8(*dest,addition);
	*dest -= addition;
}
void CPU8086_internal_SUB16(word *dest, word addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_sub16(*dest,addition);
	*dest -= addition;
}

//For SBB
void CPU8086_internal_SBB8(byte *dest, byte addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_sbb8(*dest,addition,CF);
	*dest -= addition+CF;
}
void CPU8086_internal_SBB16(word *dest, word addition)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}
	flag_sbb16(*dest,addition,CF);
	*dest -= addition+CF;
}

//For XOR
//See AND, but XOR
void CPU8086_internal_XOR8(byte *dest, byte src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest ^= src;
	flag_log8(*dest);
}
void CPU8086_internal_XOR16(word *dest, word src)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest ^= src;
	flag_log16(*dest);
}

//TEST : same as AND, but discarding the result!
void CPU8086_internal_TEST8(byte dest, byte src)
{
	byte tmpdest = dest;
	CPU8086_internal_AND8(&tmpdest,src);
}
void CPU8086_internal_TEST16(word dest, word src)
{
	word tmpdest = dest;
	CPU8086_internal_AND16(&tmpdest,src);
}

//MOV
void CPU8086_internal_MOV8(byte *dest, byte val)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	}  *dest = val;
}
void CPU8086_internal_MOV16(word *dest, word val)
{
	if (MMU_invaddr() || (dest==NULL))
	{
		return;
	} *dest = val;
}

//LEA
word getLEA(MODRM_PARAMS *params)
{
	return modrm_lea16(params,2);
}


/*

Stuff for GRP opcodes!

*/


void CPU8086_internal_DAA()
{
	if (((AL&0xF)>9) || AF)
	{
		word oper1 = AL+6;
		AL = oper1&255;
		if (oper1&0xFF00)
		{
			CF = 1;
		}
		else
		{
			CF = 0;
		}
		AF = 1;
	}
	else AF = 0;
	if (((AL&0xF0)>0x90) || CF)
	{
		AL += 0x60;
		CF = 1;
	}
	else
	{
		CF = 0;
	}
	flag_szp8(AL);
}
void CPU8086_internal_DAS()
{
	if (((AL&0xF)>9) || AF)
	{
		word oper1 = AL-6;
		AL = oper1&255;
		if (oper1&0xFF00)
		{
			CF = 1;
		}
		else
		{
			CF = 0;
		}
		AF = 1;
	}
	else AF = 0;
	if (((AL&0xF0)>0x90) || CF)
	{
		AL -= 0x60;
		CF = 1;
	}
	else
	{
		CF = 0;
	}
	flag_szp8(AL);
}
void CPU8086_internal_AAA()
{
	if (((AL&0xF)>9) || AF)
	{
		AL += 6;
		++AH;
		AF = 1;
		CF = 1;
	}
	else
	{
		AF = 0;
		CF = 0;
	}
	AL &= 0xF;
}
void CPU8086_internal_AAS()
{
	if (((AL&0xF)>9) || AF)
	{
		AL -= 6;
		--AH;
		AF = 1;
		CF = 1;
	}
	else
	{
		AF = 0;
		CF = 0;
	}
	AL &= 0xF;
}

void CPU8086_internal_CBW()
{
	if ((AL&0x80)==0x80)
	{
		AH = 0xFF;
	}
	else
	{
		AH = 0;
	}
}
void CPU8086_internal_CWD()
{
	if ((AH&0x80)==0x80)
	{
		DX = 0xFFFF;
	}
	else
	{
		DX = 0;
	}
}

//OK so far!
void CPU8086_internal_MOVSB()
{
	MMU_wb(ES,DI,MMU_rb(CPU_segment(CPU_SEGMENT_DS),SI));
	if (DF)
	{
		--SI;
		--DI;
	}
	else
	{
		++SI;
		++DI;
	}
}
void CPU8086_internal_MOVSW()
{
	MMU_ww(ES,DI,MMU_rw(CPU_segment(CPU_SEGMENT_DS),SI));
	if (DF)
	{
		SI -= 2;
		DI -= 2;
	}
	else
	{
		SI += 2;
		DI += 2;
	}
}
void CPU8086_internal_CMPSB()
{
	CMP_b(MMU_rb(CPU_segment(CPU_SEGMENT_DS),SI),MMU_rb(ES,DI));
	if (DF)
	{
		--SI;
		--DI;
	}
	else
	{
		++SI;
		++DI;
	}
}
void CPU8086_internal_CMPSW()
{
	CMP_w(MMU_rw(CPU_segment(CPU_SEGMENT_DS),SI),MMU_rw(ES,DI));
	if (DF)
	{
		SI -= 2;
		DI -= 2;
	}
	else
	{
		SI += 2;
		DI += 2;
	}
}
void CPU8086_internal_STOSB()
{
	MMU_wb(ES,DI,AL);
	if (DF)
	{
		--DI;
	}
	else
	{
		++DI;
	}
}
void CPU8086_internal_STOSW()
{
	MMU_ww(ES,DI,AX);
	if (DF)
	{
		DI -= 2;
	}
	else
	{
		DI += 2;
	}
}
//OK so far!
void CPU8086_internal_LODSB()
{
	AL = MMU_rb(CPU_segment(CPU_SEGMENT_DS),SI);
	if (DF)
	{
		--SI;
	}
	else
	{
		++SI;
	}
}
void CPU8086_internal_LODSW()
{
	AX = MMU_rw(CPU_segment(CPU_SEGMENT_DS),SI);
	if (DF)
	{
		SI -= 2;
	}
	else
	{
		SI += 2;
	}
}
void CPU8086_internal_SCASB()
{
	CMP_b(MMU_rb(ES,DI),AL);
	if (DF)
	{
		DI--;
	}
	else
	{
		DI++;
	}
}
void CPU8086_internal_SCASW()
{
	CMP_w(MMU_rw(ES,DI),AX);
	if (DF)
	{
		DI -= 2;
	}
	else
	{
		DI += 2;
	}
}

void CPU8086_internal_RET(int popbytes)
{
	IP = CPU_POP16();    //Near return
	SP += popbytes;
}
void CPU8086_internal_RETF(int popbytes)
{
	IP = CPU_POP16();    //Far return
	CS = CPU_POP16();
	SP += popbytes;
}

void CPU8086_internal_INTO()
{
	if (OF)
	{
		CPU8086_int(4);
	}
}

void CPU8086_internal_AAM(byte data)
{
	if (!data)
	{
		CPU8086_int(0);    //AAM
		return;
	}
	AH = (SAFEDIV(AL,data)&0xFF);
	AL = (SAFEMOD(AL,data)&0xFF);
	flag_szp16(AX);
}
void CPU8086_internal_AAD(byte data)
{
	AL = (((AH*data)+AL)&0xFF);    //AAD
	AH = 0;
	flag_szp16((AH*data)+AL);
	SF = 0;
}

void CPU8086_internal_XLAT()
{
	AL = MMU_rb(CPU_segment(CPU_SEGMENT_DS),BX+AL);    //XLAT
}

void CPU8086_internal_XCHG8(byte *data1, byte *data2)
{
	byte temp = *data1; //Copy!
	*data1 = *data2; //We're ...
	*data2 = temp; //Swapping this!
}

void CPU8086_internal_XCHG16(word *data1, word *data2)
{
	word temp = *data1; //Copy!
	*data1 = *data2; //We're ...
	*data2 = temp; //Swapping this!
}