z80.c

DC的SEGA_GG模拟器源代码

/***************************************************************
 * LD	R,A
 ***************************************************************/
#define LD_R_A {												\
	_R = _A;													\
	_R2 = _A & 0x80;				/* keep bit 7 of R */		\
}

/***************************************************************
 * LD	A,R
 ***************************************************************/
#define LD_A_R {												\
	_A = (_R & 0x7f) | _R2; 									\
	_F = (_F & CF) | SZ[_A] | ( _IFF2 << 2 );					\
}

/***************************************************************
 * LD	I,A
 ***************************************************************/
#define LD_I_A {												\
	_I = _A;													\
}

/***************************************************************
 * LD	A,I
 ***************************************************************/
#define LD_A_I {												\
	_A = _I;													\
	_F = (_F & CF) | SZ[_A] | ( _IFF2 << 2 );					\
}

/***************************************************************
 * RST
 ***************************************************************/
#define RST(addr)												\
	PUSH( PC ); 												\
    _PCD = addr;                                                

/***************************************************************
 * INC	r8
 ***************************************************************/
static __inline UINT8 INC(UINT8 value)
{
	UINT8 res = value + 1;
	_F = (_F & CF) | SZHV_inc[res];
	return (UINT8)res;
}

/***************************************************************
 * DEC	r8
 ***************************************************************/
static __inline UINT8 DEC(UINT8 value)
{
	UINT8 res = value - 1;
	_F = (_F & CF) | SZHV_dec[res];
    return res;
}

/***************************************************************
 * RLCA
 ***************************************************************/
#if Z80_EXACT
#define RLCA													\
	_A = (_A << 1) | (_A >> 7); 								\
	_F = (_F & (SF | ZF | PF)) | (_A & (YF | XF | CF))
#else
#define RLCA                                                    \
	_A = (_A << 1) | (_A >> 7); 								\
	_F = (_F & (SF | ZF | YF | XF | PF)) | (_A & CF)
#endif

/***************************************************************
 * RRCA
 ***************************************************************/
#if Z80_EXACT
#define RRCA                                                    \
	_F = (_F & (SF | ZF | PF)) | (_A & (YF | XF | CF)); 		\
    _A = (_A >> 1) | (_A << 7)
#else
#define RRCA                                                    \
	_F = (_F & (SF | ZF | YF | XF | PF)) | (_A & CF);			\
	_A = (_A >> 1) | (_A << 7)
#endif

/***************************************************************
 * RLA
 ***************************************************************/
#if Z80_EXACT
#define RLA {													\
	UINT8 res = (_A << 1) | (_F & CF);							\
	UINT8 c = (_A & 0x80) ? CF : 0; 							\
	_F = (_F & (SF | ZF | PF)) | c | (res & (YF | XF)); 		\
	_A = res;													\
}
#else
#define RLA {                                                   \
	UINT8 res = (_A << 1) | (_F & CF);							\
	UINT8 c = (_A & 0x80) ? CF : 0; 							\
	_F = (_F & (SF | ZF | YF | XF | PF)) | c;					\
	_A = res;													\
}
#endif

/***************************************************************
 * RRA
 ***************************************************************/
#if Z80_EXACT
#define RRA {                                                   \
	UINT8 res = (_A >> 1) | (_F << 7);							\
	UINT8 c = (_A & 0x01) ? CF : 0; 							\
	_F = (_F & (SF | ZF | PF)) | c | (res & (YF | XF)); 		\
	_A = res;													\
}
#else
#define RRA {                                                   \
	UINT8 res = (_A >> 1) | (_F << 7);							\
	UINT8 c = (_A & 0x01) ? CF : 0; 							\
    _F = (_F & (SF | ZF | YF | XF | PF)) | c;                   \
	_A = res;													\
}
#endif

/***************************************************************
 * RRD
 ***************************************************************/
#define RRD {													\
	UINT8 n = RM(_HL);											\
	WM( _HL, (n >> 4) | (_A << 4) );							\
	_A = (_A & 0xf0) | (n & 0x0f);								\
	_F = (_F & CF) | SZP[_A];									\
}

/***************************************************************
 * RLD
 ***************************************************************/
#define RLD {                                                   \
    UINT8 n = RM(_HL);                                          \
	WM( _HL, (n << 4) | (_A & 0x0f) );							\
    _A = (_A & 0xf0) | (n >> 4);                                \
	_F = (_F & CF) | SZP[_A];									\
}

/***************************************************************
 * ADD	A,n
 ***************************************************************/
#ifdef X86_ASM
#if Z80_EXACT
#define ADD(value)												\
 asm (															\
 " addb %2,%0           \n"                                     \
 " lahf                 \n"                                     \
 " setob %1             \n" /* al = 1 if overflow */            \
 " addb %1,%1           \n"                                     \
 " addb %1,%1           \n" /* shift to P/V bit position */     \
 " andb $0xd1,%%ah      \n" /* sign, zero, half carry, carry */ \
 " orb %%ah,%1          \n"                                     \
 " movb %0,%%ah         \n" /* get result */                    \
 " andb $0x28,%%ah      \n" /* maks flags 5+3 */                \
 " orb %%ah,%1          \n" /* put them into flags */           \
 :"=r" (_A), "=r" (_F)                                          \
 :"r" (value), "1" (_F), "0" (_A)                               \
 )
#else
#define ADD(value)                                              \
 asm (															\
 " addb %2,%0           \n"                                     \
 " lahf                 \n"                                     \
 " setob %1             \n" /* al = 1 if overflow */            \
 " addb %1,%1           \n"                                     \
 " addb %1,%1           \n" /* shift to P/V bit position */     \
 " andb $0xd1,%%ah      \n" /* sign, zero, half carry, carry */ \
 " orb %%ah,%1          \n"                                     \
 :"=r" (_A), "=r" (_F)                                          \
 :"r" (value), "1" (_F), "0" (_A)                               \
 )
#endif
#else
#if BIG_FLAGS_ARRAY
#define ADD(value)												\
{																\
	UINT32 ah = _AFD & 0xff00;									\
	UINT32 res = (UINT8)((ah >> 8) + value);					\
	_F = SZHVC_add[ah | res];									\
    _A = res;                                                   \
}
#else
#define ADD(value)												\
{																\
	unsigned val = value;										\
    unsigned res = _A + val;                                    \
    _F = SZ[(UINT8)res] | ((res >> 8) & CF) |                   \
        ((_A ^ res ^ val) & HF) |                               \
        (((val ^ _A ^ 0x80) & (val ^ res) & 0x80) >> 5);        \
    _A = (UINT8)res;                                            \
}
#endif
#endif

/***************************************************************
 * ADC	A,n
 ***************************************************************/
#ifdef X86_ASM
#if Z80_EXACT
#define ADC(value)												\
 asm (															\
 " shrb $1,%1           \n"                                     \
 " adcb %2,%0           \n"                                     \
 " lahf                 \n"                                     \
 " setob %1             \n" /* al = 1 if overflow */            \
 " addb %1,%1           \n" /* shift to P/V bit position */     \
 " addb %1,%1           \n"                                     \
 " andb $0xd1,%%ah      \n" /* sign, zero, half carry, carry */ \
 " orb %%ah,%1          \n" /* combine with P/V */              \
 " movb %0,%%ah         \n" /* get result */                    \
 " andb $0x28,%%ah      \n" /* maks flags 5+3 */                \
 " orb %%ah,%1          \n" /* put them into flags */           \
 :"=r" (_A), "=r" (_F)                                          \
 :"r" (value), "1" (_F), "0" (_A)                               \
 )
#else
#define ADC(value)                                              \
 asm (															\
 " shrb $1,%1           \n"                                     \
 " adcb %2,%0           \n"                                     \
 " lahf                 \n"                                     \
 " setob %1             \n" /* al = 1 if overflow */            \
 " addb %1,%1           \n" /* shift to P/V bit position */     \
 " addb %1,%1           \n"                                     \
 " andb $0xd1,%%ah      \n" /* sign, zero, half carry, carry */ \
 " orb %%ah,%1          \n" /* combine with P/V */              \
 :"=r" (_A), "=r" (_F)                                          \
 :"r" (value), "1" (_F), "0" (_A)                               \
 )
#endif
#else
#if BIG_FLAGS_ARRAY
#define ADC(value)												\
{																\
	UINT32 ah = _AFD & 0xff00, c = _AFD & 1;					\
	UINT32 res = (UINT8)((ah >> 8) + value + c);				\
	_F = SZHVC_add[(c << 16) | ah | res];						\
    _A = res;                                                   \
}
#else
#define ADC(value)												\
{																\
	unsigned val = value;										\
	unsigned res = _A + val + (_F & CF);						\
	_F = SZ[res & 0xff] | ((res >> 8) & CF) |					\
		((_A ^ res ^ val) & HF) |								\
		(((val ^ _A ^ 0x80) & (val ^ res) & 0x80) >> 5);		\
	_A = res;													\
}
#endif
#endif

/***************************************************************
 * SUB	n
 ***************************************************************/
#ifdef X86_ASM
#if Z80_EXACT
#define SUB(value)												\