/**

 * $Id: sh4x86.in,v 1.20 2007-11-08 11:54:16 nkeynes Exp $

 * 

 * SH4 => x86 translation. This version does no real optimization, it just

 * outputs straight-line x86 code - it mainly exists to provide a baseline

 * to test the optimizing versions against.

 *

 * Copyright (c) 2007 Nathan Keynes.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include <assert.h>

#include <math.h>

#ifndef NDEBUG

#define DEBUG_JUMPS 1

#endif

#include "sh4/xltcache.h"

#include "sh4/sh4core.h"

#include "sh4/sh4trans.h"

#include "sh4/sh4mmio.h"

#include "sh4/x86op.h"

#include "clock.h"

#define DEFAULT_BACKPATCH_SIZE 4096

/** 

 * Struct to manage internal translation state. This state is not saved -

 * it is only valid between calls to sh4_translate_begin_block() and

 * sh4_translate_end_block()

 */

struct sh4_x86_state {

    gboolean in_delay_slot;

    gboolean priv_checked; /* true if we've already checked the cpu mode. */

    gboolean fpuen_checked; /* true if we've already checked fpu enabled. */

    gboolean branch_taken; /* true if we branched unconditionally */

    uint32_t block_start_pc;

    int tstate;

    /* Allocated memory for the (block-wide) back-patch list */

    uint32_t **backpatch_list;

    uint32_t backpatch_posn;

    uint32_t backpatch_size;

};

#define TSTATE_NONE -1

#define TSTATE_O    0

#define TSTATE_C    2

#define TSTATE_E    4

#define TSTATE_NE   5

#define TSTATE_G    0xF

#define TSTATE_GE   0xD

#define TSTATE_A    7

#define TSTATE_AE   3

/** Branch if T is set (either in the current cflags, or in sh4r.t) */

#define JT_rel8(rel8,label) if( sh4_x86.tstate == TSTATE_NONE ) { \

	CMP_imm8s_sh4r( 1, R_T ); sh4_x86.tstate = TSTATE_E; } \

    OP(0x70+sh4_x86.tstate); OP(rel8); \

    MARK_JMP(rel8,label)

/** Branch if T is clear (either in the current cflags or in sh4r.t) */

#define JF_rel8(rel8,label) if( sh4_x86.tstate == TSTATE_NONE ) { \

	CMP_imm8s_sh4r( 1, R_T ); sh4_x86.tstate = TSTATE_E; } \

    OP(0x70+ (sh4_x86.tstate^1)); OP(rel8); \

    MARK_JMP(rel8, label)

#define EXIT_DATA_ADDR_READ 0

#define EXIT_DATA_ADDR_WRITE 7

#define EXIT_ILLEGAL 14

#define EXIT_SLOT_ILLEGAL 21

#define EXIT_FPU_DISABLED 28

#define EXIT_SLOT_FPU_DISABLED 35

static struct sh4_x86_state sh4_x86;

static uint32_t max_int = 0x7FFFFFFF;

static uint32_t min_int = 0x80000000;

static uint32_t save_fcw; /* save value for fpu control word */

static uint32_t trunc_fcw = 0x0F7F; /* fcw value for truncation mode */

void sh4_x86_init()

{

    sh4_x86.backpatch_list = malloc(DEFAULT_BACKPATCH_SIZE);

    sh4_x86.backpatch_size = DEFAULT_BACKPATCH_SIZE / sizeof(uint32_t *);

}

static void sh4_x86_add_backpatch( uint8_t *ptr )

{

    if( sh4_x86.backpatch_posn == sh4_x86.backpatch_size ) {

	sh4_x86.backpatch_size <<= 1;

	sh4_x86.backpatch_list = realloc( sh4_x86.backpatch_list, sh4_x86.backpatch_size * sizeof(uint32_t *) );

	assert( sh4_x86.backpatch_list != NULL );

    }

    sh4_x86.backpatch_list[sh4_x86.backpatch_posn++] = (uint32_t *)ptr;

}

static void sh4_x86_do_backpatch( uint8_t *reloc_base )

{

    unsigned int i;

    for( i=0; i<sh4_x86.backpatch_posn; i++ ) {

	*sh4_x86.backpatch_list[i] += (reloc_base - ((uint8_t *)sh4_x86.backpatch_list[i]) - 4);

    }

}

/**

 * Emit an instruction to load an SH4 reg into a real register

 */

static inline void load_reg( int x86reg, int sh4reg ) 

{

    /* mov [bp+n], reg */

    OP(0x8B);

    OP(0x45 + (x86reg<<3));

    OP(REG_OFFSET(r[sh4reg]));

}

static inline void load_reg16s( int x86reg, int sh4reg )

{

    OP(0x0F);

    OP(0xBF);

    MODRM_r32_sh4r(x86reg, REG_OFFSET(r[sh4reg]));

}

static inline void load_reg16u( int x86reg, int sh4reg )

{

    OP(0x0F);

    OP(0xB7);

    MODRM_r32_sh4r(x86reg, REG_OFFSET(r[sh4reg]));

}

#define load_spreg( x86reg, regoff ) MOV_sh4r_r32( regoff, x86reg )

#define store_spreg( x86reg, regoff ) MOV_r32_sh4r( x86reg, regoff )

/**

 * Emit an instruction to load an immediate value into a register

 */

static inline void load_imm32( int x86reg, uint32_t value ) {

    /* mov #value, reg */

    OP(0xB8 + x86reg);

    OP32(value);

}

/**

 * Load an immediate 64-bit quantity (note: x86-64 only)

 */

static inline void load_imm64( int x86reg, uint32_t value ) {

    /* mov #value, reg */

    REXW();

    OP(0xB8 + x86reg);

    OP64(value);

}

/**

 * Emit an instruction to store an SH4 reg (RN)

 */

void static inline store_reg( int x86reg, int sh4reg ) {

    /* mov reg, [bp+n] */

    OP(0x89);

    OP(0x45 + (x86reg<<3));

    OP(REG_OFFSET(r[sh4reg]));

}

#define load_fr_bank(bankreg) load_spreg( bankreg, REG_OFFSET(fr_bank))

/**

 * Load an FR register (single-precision floating point) into an integer x86

 * register (eg for register-to-register moves)

 */

void static inline load_fr( int bankreg, int x86reg, int frm )

{

    OP(0x8B); OP(0x40+bankreg+(x86reg<<3)); OP((frm^1)<<2);

}

/**

 * Store an FR register (single-precision floating point) into an integer x86

 * register (eg for register-to-register moves)

 */

void static inline store_fr( int bankreg, int x86reg, int frn )

{

    OP(0x89);  OP(0x40+bankreg+(x86reg<<3)); OP((frn^1)<<2);

}

/**

 * Load a pointer to the back fp back into the specified x86 register. The

 * bankreg must have been previously loaded with FPSCR.

 * NB: 12 bytes

 */

static inline void load_xf_bank( int bankreg )

{

    NOT_r32( bankreg );

    SHR_imm8_r32( (21 - 6), bankreg ); // Extract bit 21 then *64 for bank size

    AND_imm8s_r32( 0x40, bankreg );    // Complete extraction

    OP(0x8D); OP(0x44+(bankreg<<3)); OP(0x28+bankreg); OP(REG_OFFSET(fr)); // LEA [ebp+bankreg+disp], bankreg

}

/**

 * Update the fr_bank pointer based on the current fpscr value.

 */

static inline void update_fr_bank( int fpscrreg )

{

    SHR_imm8_r32( (21 - 6), fpscrreg ); // Extract bit 21 then *64 for bank size

    AND_imm8s_r32( 0x40, fpscrreg );    // Complete extraction

    OP(0x8D); OP(0x44+(fpscrreg<<3)); OP(0x28+fpscrreg); OP(REG_OFFSET(fr)); // LEA [ebp+fpscrreg+disp], fpscrreg

    store_spreg( fpscrreg, REG_OFFSET(fr_bank) );

}

/**

 * Push FPUL (as a 32-bit float) onto the FPU stack

 */

static inline void push_fpul( )

{

    OP(0xD9); OP(0x45); OP(R_FPUL);

}

/**

 * Pop FPUL (as a 32-bit float) from the FPU stack

 */

static inline void pop_fpul( )

{

    OP(0xD9); OP(0x5D); OP(R_FPUL);

}

/**

 * Push a 32-bit float onto the FPU stack, with bankreg previously loaded

 * with the location of the current fp bank.

 */

static inline void push_fr( int bankreg, int frm ) 

{

    OP(0xD9); OP(0x40 + bankreg); OP((frm^1)<<2);  // FLD.S [bankreg + frm^1*4]

}

/**

 * Pop a 32-bit float from the FPU stack and store it back into the fp bank, 

 * with bankreg previously loaded with the location of the current fp bank.

 */

static inline void pop_fr( int bankreg, int frm )

{

    OP(0xD9); OP(0x58 + bankreg); OP((frm^1)<<2); // FST.S [bankreg + frm^1*4]

}

/**

 * Push a 64-bit double onto the FPU stack, with bankreg previously loaded

 * with the location of the current fp bank.

 */

static inline void push_dr( int bankreg, int frm )

{

    OP(0xDD); OP(0x40 + bankreg); OP(frm<<2); // FLD.D [bankreg + frm*4]

}

static inline void pop_dr( int bankreg, int frm )

{

    OP(0xDD); OP(0x58 + bankreg); OP(frm<<2); // FST.D [bankreg + frm*4]

}

#if SH4_TRANSLATOR == TARGET_X86_64

/* X86-64 has different calling conventions... */

/**

 * Note: clobbers EAX to make the indirect call - this isn't usually

 * a problem since the callee will usually clobber it anyway.

 * Size: 12 bytes

 */

#define CALL_FUNC0_SIZE 12

static inline void call_func0( void *ptr )

{

    load_imm64(R_EAX, (uint64_t)ptr);

    CALL_r32(R_EAX);

}

#define CALL_FUNC1_SIZE 14

static inline void call_func1( void *ptr, int arg1 )

{

    MOV_r32_r32(arg1, R_EDI);

    call_func0(ptr);

}

#define CALL_FUNC2_SIZE 16

static inline void call_func2( void *ptr, int arg1, int arg2 )

{

    MOV_r32_r32(arg1, R_EDI);

    MOV_r32_r32(arg2, R_ESI);

    call_func0(ptr);

}

#define MEM_WRITE_DOUBLE_SIZE 39

/**

 * Write a double (64-bit) value into memory, with the first word in arg2a, and

 * the second in arg2b

 */

static inline void MEM_WRITE_DOUBLE( int addr, int arg2a, int arg2b )

{

/*

    MOV_r32_r32( addr, R_EDI );

    MOV_r32_r32( arg2b, R_ESI );

    REXW(); SHL_imm8_r32( 32, R_ESI );

    REXW(); MOVZX_r16_r32( arg2a, arg2a );

    REXW(); OR_r32_r32( arg2a, R_ESI );

    call_func0(sh4_write_quad);

*/

    PUSH_r32(arg2b);

    PUSH_r32(addr);

    call_func2(sh4_write_long, addr, arg2a);

    POP_r32(addr);

    POP_r32(arg2b);

    ADD_imm8s_r32(4, addr);

    call_func2(sh4_write_long, addr, arg2b);

}

#define MEM_READ_DOUBLE_SIZE 35

/**

 * Read a double (64-bit) value from memory, writing the first word into arg2a

 * and the second into arg2b. The addr must not be in EAX

 */

static inline void MEM_READ_DOUBLE( int addr, int arg2a, int arg2b )

{

/*

    MOV_r32_r32( addr, R_EDI );

    call_func0(sh4_read_quad);

    REXW(); MOV_r32_r32( R_EAX, arg2a );

    REXW(); MOV_r32_r32( R_EAX, arg2b );

    REXW(); SHR_imm8_r32( 32, arg2b );

*/

    PUSH_r32(addr);

    call_func1(sh4_read_long, addr);

    POP_r32(R_EDI);

    PUSH_r32(R_EAX);

    ADD_imm8s_r32(4, R_EDI);

    call_func0(sh4_read_long);

    MOV_r32_r32(R_EAX, arg2b);

    POP_r32(arg2a);

}

#define EXIT_BLOCK_SIZE 35

/**

 * Exit the block to an absolute PC

 */

void exit_block( sh4addr_t pc, sh4addr_t endpc )

{

    load_imm32( R_ECX, pc );                            // 5

    store_spreg( R_ECX, REG_OFFSET(pc) );               // 3

    REXW(); MOV_moff32_EAX( xlat_get_lut_entry(pc) );

    REXW(); AND_imm8s_r32( 0xFC, R_EAX ); // 3

    load_imm32( R_ECX, ((endpc - sh4_x86.block_start_pc)>>1)*sh4_cpu_period ); // 5

    ADD_r32_sh4r( R_ECX, REG_OFFSET(slice_cycle) );     // 6

    POP_r32(R_EBP);

    RET();

}

/**

 * Write the block trailer (exception handling block)

 */

void sh4_translate_end_block( sh4addr_t pc ) {

    if( sh4_x86.branch_taken == FALSE ) {

	// Didn't exit unconditionally already, so write the termination here

	exit_block( pc, pc );

    }

    if( sh4_x86.backpatch_posn != 0 ) {

	uint8_t *end_ptr = xlat_output;

	// Exception termination. Jump block for various exception codes:

	load_imm32( R_EDI, EXC_DATA_ADDR_READ );

	JMP_rel8( 33, target1 );

	load_imm32( R_EDI, EXC_DATA_ADDR_WRITE );

	JMP_rel8( 26, target2 );

	load_imm32( R_EDI, EXC_ILLEGAL );

	JMP_rel8( 19, target3 );

	load_imm32( R_EDI, EXC_SLOT_ILLEGAL ); 

	JMP_rel8( 12, target4 );

	load_imm32( R_EDI, EXC_FPU_DISABLED ); 

	JMP_rel8( 5, target5 );

	load_imm32( R_EDI, EXC_SLOT_FPU_DISABLED );

	// target

	JMP_TARGET(target1);

	JMP_TARGET(target2);

	JMP_TARGET(target3);

	JMP_TARGET(target4);

	JMP_TARGET(target5);

	// Raise exception

	load_spreg( R_ECX, REG_OFFSET(pc) );

	ADD_r32_r32( R_EDX, R_ECX );

	ADD_r32_r32( R_EDX, R_ECX );

	store_spreg( R_ECX, REG_OFFSET(pc) );

	MOV_moff32_EAX( &sh4_cpu_period );

	MUL_r32( R_EDX );

	ADD_r32_sh4r( R_EAX, REG_OFFSET(slice_cycle) );

	call_func0( sh4_raise_exception );

	load_spreg( R_EAX, REG_OFFSET(pc) );

	call_func1(xlat_get_code,R_EAX);

	POP_r32(R_EBP);

	RET();

	sh4_x86_do_backpatch( end_ptr );

    }

}

#else /* SH4_TRANSLATOR == TARGET_X86 */

/**

 * Note: clobbers EAX to make the indirect call - this isn't usually

 * a problem since the callee will usually clobber it anyway.

 */

#define CALL_FUNC0_SIZE 7

static inline void call_func0( void *ptr )

{

    load_imm32(R_EAX, (uint32_t)ptr);

    CALL_r32(R_EAX);

}

#define CALL_FUNC1_SIZE 11

static inline void call_func1( void *ptr, int arg1 )

{

    PUSH_r32(arg1);

    call_func0(ptr);

    ADD_imm8s_r32( 4, R_ESP );

}

#define CALL_FUNC2_SIZE 12

static inline void call_func2( void *ptr, int arg1, int arg2 )

{

    PUSH_r32(arg2);

    PUSH_r32(arg1);

    call_func0(ptr);

    ADD_imm8s_r32( 8, R_ESP );

}

/**

 * Write a double (64-bit) value into memory, with the first word in arg2a, and

 * the second in arg2b

 * NB: 30 bytes

 */

#define MEM_WRITE_DOUBLE_SIZE 30

static inline void MEM_WRITE_DOUBLE( int addr, int arg2a, int arg2b )

{

    ADD_imm8s_r32( 4, addr );

    PUSH_r32(arg2b);

    PUSH_r32(addr);

    ADD_imm8s_r32( -4, addr );

    PUSH_r32(arg2a);

    PUSH_r32(addr);

    call_func0(sh4_write_long);

    ADD_imm8s_r32( 8, R_ESP );

    call_func0(sh4_write_long);

    ADD_imm8s_r32( 8, R_ESP );

}

/**

 * Read a double (64-bit) value from memory, writing the first word into arg2a

 * and the second into arg2b. The addr must not be in EAX

 * NB: 27 bytes

 */

#define MEM_READ_DOUBLE_SIZE 27

static inline void MEM_READ_DOUBLE( int addr, int arg2a, int arg2b )

{

    PUSH_r32(addr);

    call_func0(sh4_read_long);

    POP_r32(addr);

    PUSH_r32(R_EAX);

    ADD_imm8s_r32( 4, addr );

    PUSH_r32(addr);

    call_func0(sh4_read_long);

    ADD_imm8s_r32( 4, R_ESP );

    MOV_r32_r32( R_EAX, arg2b );

    POP_r32(arg2a);

}

#define EXIT_BLOCK_SIZE 29

/**

 * Exit the block to an absolute PC

 */

void exit_block( sh4addr_t pc, sh4addr_t endpc )

{

    load_imm32( R_ECX, pc );                            // 5

    store_spreg( R_ECX, REG_OFFSET(pc) );               // 3

    MOV_moff32_EAX( xlat_get_lut_entry(pc) ); // 5

    AND_imm8s_r32( 0xFC, R_EAX ); // 3

    load_imm32( R_ECX, ((endpc - sh4_x86.block_start_pc)>>1)*sh4_cpu_period ); // 5

    ADD_r32_sh4r( R_ECX, REG_OFFSET(slice_cycle) );     // 6

    POP_r32(R_EBP);

    RET();

}

/**

 * Write the block trailer (exception handling block)

 */

void sh4_translate_end_block( sh4addr_t pc ) {

    if( sh4_x86.branch_taken == FALSE ) {

	// Didn't exit unconditionally already, so write the termination here

	exit_block( pc, pc );

    }

    if( sh4_x86.backpatch_posn != 0 ) {

	uint8_t *end_ptr = xlat_output;

	// Exception termination. Jump block for various exception codes:

	PUSH_imm32( EXC_DATA_ADDR_READ );

	JMP_rel8( 33, target1 );

	PUSH_imm32( EXC_DATA_ADDR_WRITE );

	JMP_rel8( 26, target2 );

	PUSH_imm32( EXC_ILLEGAL );

	JMP_rel8( 19, target3 );

	PUSH_imm32( EXC_SLOT_ILLEGAL ); 

	JMP_rel8( 12, target4 );

	PUSH_imm32( EXC_FPU_DISABLED ); 

	JMP_rel8( 5, target5 );

	PUSH_imm32( EXC_SLOT_FPU_DISABLED );

	// target

	JMP_TARGET(target1);

	JMP_TARGET(target2);

	JMP_TARGET(target3);

	JMP_TARGET(target4);

	JMP_TARGET(target5);

	// Raise exception

	load_spreg( R_ECX, REG_OFFSET(pc) );

	ADD_r32_r32( R_EDX, R_ECX );

	ADD_r32_r32( R_EDX, R_ECX );

	store_spreg( R_ECX, REG_OFFSET(pc) );

	MOV_moff32_EAX( &sh4_cpu_period );

	MUL_r32( R_EDX );

	ADD_r32_sh4r( R_EAX, REG_OFFSET(slice_cycle) );

	call_func0( sh4_raise_exception );

	ADD_imm8s_r32( 4, R_ESP );

	load_spreg( R_EAX, REG_OFFSET(pc) );

	call_func1(xlat_get_code,R_EAX);

	POP_r32(R_EBP);

	RET();

	sh4_x86_do_backpatch( end_ptr );

    }

}

#endif

/* Exception checks - Note that all exception checks will clobber EAX */

#define precheck() load_imm32(R_EDX, (pc-sh4_x86.block_start_pc-(sh4_x86.in_delay_slot?2:0))>>1)

#define check_priv( ) \

    if( !sh4_x86.priv_checked ) { \

	sh4_x86.priv_checked = TRUE;\

	precheck();\

	load_spreg( R_EAX, R_SR );\

	AND_imm32_r32( SR_MD, R_EAX );\

	if( sh4_x86.in_delay_slot ) {\

	    JE_exit( EXIT_SLOT_ILLEGAL );\

	} else {\

	    JE_exit( EXIT_ILLEGAL );\

	}\

    }\

static void check_priv_no_precheck()

{

    if( !sh4_x86.priv_checked ) {

	sh4_x86.priv_checked = TRUE;

	load_spreg( R_EAX, R_SR );

	AND_imm32_r32( SR_MD, R_EAX );

	if( sh4_x86.in_delay_slot ) {

	    JE_exit( EXIT_SLOT_ILLEGAL );

	} else {

	    JE_exit( EXIT_ILLEGAL );

	}

    }

}

#define check_fpuen( ) \

    if( !sh4_x86.fpuen_checked ) {\

	sh4_x86.fpuen_checked = TRUE;\

	precheck();\

	load_spreg( R_EAX, R_SR );\

	AND_imm32_r32( SR_FD, R_EAX );\

	if( sh4_x86.in_delay_slot ) {\

	    JNE_exit(EXIT_SLOT_FPU_DISABLED);\

	} else {\

	    JNE_exit(EXIT_FPU_DISABLED);\

	}\

    }

static void check_fpuen_no_precheck()

{

    if( !sh4_x86.fpuen_checked ) {

	sh4_x86.fpuen_checked = TRUE;

	load_spreg( R_EAX, R_SR );

	AND_imm32_r32( SR_FD, R_EAX );

	if( sh4_x86.in_delay_slot ) {

	    JNE_exit(EXIT_SLOT_FPU_DISABLED);

	} else {

	    JNE_exit(EXIT_FPU_DISABLED);

	}

    }

}

static void check_ralign16( int x86reg )

{

    TEST_imm32_r32( 0x00000001, x86reg );

    JNE_exit(EXIT_DATA_ADDR_READ);

}

static void check_walign16( int x86reg )

{

    TEST_imm32_r32( 0x00000001, x86reg );

    JNE_exit(EXIT_DATA_ADDR_WRITE);

}

static void check_ralign32( int x86reg )

{

    TEST_imm32_r32( 0x00000003, x86reg );

    JNE_exit(EXIT_DATA_ADDR_READ);

}

static void check_walign32( int x86reg )

{

    TEST_imm32_r32( 0x00000003, x86reg );

    JNE_exit(EXIT_DATA_ADDR_WRITE);

}

#define UNDEF()

#define MEM_RESULT(value_reg) if(value_reg != R_EAX) { MOV_r32_r32(R_EAX,value_reg); }

#define MEM_READ_BYTE( addr_reg, value_reg ) call_func1(sh4_read_byte, addr_reg ); MEM_RESULT(value_reg)

#define MEM_READ_WORD( addr_reg, value_reg ) call_func1(sh4_read_word, addr_reg ); MEM_RESULT(value_reg)

#define MEM_READ_LONG( addr_reg, value_reg ) call_func1(sh4_read_long, addr_reg ); MEM_RESULT(value_reg)

#define MEM_WRITE_BYTE( addr_reg, value_reg ) call_func2(sh4_write_byte, addr_reg, value_reg)

#define MEM_WRITE_WORD( addr_reg, value_reg ) call_func2(sh4_write_word, addr_reg, value_reg)

#define MEM_WRITE_LONG( addr_reg, value_reg ) call_func2(sh4_write_long, addr_reg, value_reg)

#define SLOTILLEGAL() precheck(); JMP_exit(EXIT_SLOT_ILLEGAL); sh4_x86.in_delay_slot = FALSE; return 1;

/**

 * Emit the 'start of block' assembly. Sets up the stack frame and save

 * SI/DI as required

 */

void sh4_translate_begin_block( sh4addr_t pc ) 

{

    PUSH_r32(R_EBP);

    /* mov &sh4r, ebp */

    load_imm32( R_EBP, (uint32_t)&sh4r );

    sh4_x86.in_delay_slot = FALSE;

    sh4_x86.priv_checked = FALSE;

    sh4_x86.fpuen_checked = FALSE;

    sh4_x86.branch_taken = FALSE;

    sh4_x86.backpatch_posn = 0;

    sh4_x86.block_start_pc = pc;

    sh4_x86.tstate = TSTATE_NONE;

}

/**

 * Exit the block with sh4r.pc already written

 * Bytes: 15

 */

void exit_block_pcset( pc )

{

    load_imm32( R_ECX, ((pc - sh4_x86.block_start_pc)>>1)*sh4_cpu_period ); // 5

    ADD_r32_sh4r( R_ECX, REG_OFFSET(slice_cycle) );    // 6

    load_spreg( R_EAX, REG_OFFSET(pc) );

    call_func1(xlat_get_code,R_EAX);

    POP_r32(R_EBP);

    RET();

}

extern uint16_t *sh4_icache;

extern uint32_t sh4_icache_addr;

/**

 * Translate a single instruction. Delayed branches are handled specially

 * by translating both branch and delayed instruction as a single unit (as

 * 

 *

 * @return true if the instruction marks the end of a basic block

 * (eg a branch or 

 */

uint32_t sh4_translate_instruction( sh4addr_t pc )

{

    uint32_t ir;

    /* Read instruction */

    uint32_t pageaddr = pc >> 12;

    if( sh4_icache != NULL && pageaddr == sh4_icache_addr ) {

	ir = sh4_icache[(pc&0xFFF)>>1];

    } else {

	sh4_icache = (uint16_t *)mem_get_page(pc);

	if( ((uintptr_t)sh4_icache) < MAX_IO_REGIONS ) {

	    /* If someone's actually been so daft as to try to execute out of an IO

	     * region, fallback on the full-blown memory read

	     */

	    sh4_icache = NULL;

	    ir = sh4_read_word(pc);

	} else {

	    sh4_icache_addr = pageaddr;

	    ir = sh4_icache[(pc&0xFFF)>>1];

	}

    }

%%

/* ALU operations */

ADD Rm, Rn {:

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    ADD_r32_r32( R_EAX, R_ECX );

    store_reg( R_ECX, Rn );

    sh4_x86.tstate = TSTATE_NONE;

:}

ADD #imm, Rn {:  

    load_reg( R_EAX, Rn );

    ADD_imm8s_r32( imm, R_EAX );

    store_reg( R_EAX, Rn );

    sh4_x86.tstate = TSTATE_NONE;

:}

ADDC Rm, Rn {:

    if( sh4_x86.tstate != TSTATE_C ) {

	LDC_t();

    }

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    ADC_r32_r32( R_EAX, R_ECX );

    store_reg( R_ECX, Rn );

    SETC_t();

    sh4_x86.tstate = TSTATE_C;

:}

ADDV Rm, Rn {:

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    ADD_r32_r32( R_EAX, R_ECX );

    store_reg( R_ECX, Rn );

    SETO_t();

    sh4_x86.tstate = TSTATE_O;

:}

AND Rm, Rn {:

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    AND_r32_r32( R_EAX, R_ECX );

    store_reg( R_ECX, Rn );

    sh4_x86.tstate = TSTATE_NONE;

:}

AND #imm, R0 {:  

    load_reg( R_EAX, 0 );

    AND_imm32_r32(imm, R_EAX); 

    store_reg( R_EAX, 0 );

    sh4_x86.tstate = TSTATE_NONE;

:}

AND.B #imm, @(R0, GBR) {: 

    load_reg( R_EAX, 0 );

    load_spreg( R_ECX, R_GBR );

    ADD_r32_r32( R_EAX, R_ECX );

    PUSH_r32(R_ECX);

    MEM_READ_BYTE( R_ECX, R_EAX );

    POP_r32(R_ECX);

    AND_imm32_r32(imm, R_EAX );

    MEM_WRITE_BYTE( R_ECX, R_EAX );

    sh4_x86.tstate = TSTATE_NONE;

:}

CMP/EQ Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    CMP_r32_r32( R_EAX, R_ECX );

    SETE_t();

    sh4_x86.tstate = TSTATE_E;

:}

CMP/EQ #imm, R0 {:  

    load_reg( R_EAX, 0 );

    CMP_imm8s_r32(imm, R_EAX);

    SETE_t();

    sh4_x86.tstate = TSTATE_E;

:}

CMP/GE Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    CMP_r32_r32( R_EAX, R_ECX );

    SETGE_t();

    sh4_x86.tstate = TSTATE_GE;

:}

CMP/GT Rm, Rn {: 

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    CMP_r32_r32( R_EAX, R_ECX );

    SETG_t();

    sh4_x86.tstate = TSTATE_G;

:}

CMP/HI Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    CMP_r32_r32( R_EAX, R_ECX );

    SETA_t();

    sh4_x86.tstate = TSTATE_A;

:}

CMP/HS Rm, Rn {: 

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    CMP_r32_r32( R_EAX, R_ECX );

    SETAE_t();

    sh4_x86.tstate = TSTATE_AE;

 :}

CMP/PL Rn {: 

    load_reg( R_EAX, Rn );

    CMP_imm8s_r32( 0, R_EAX );

    SETG_t();

    sh4_x86.tstate = TSTATE_G;

:}

CMP/PZ Rn {:  

    load_reg( R_EAX, Rn );

    CMP_imm8s_r32( 0, R_EAX );

    SETGE_t();

    sh4_x86.tstate = TSTATE_GE;

:}

CMP/STR Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    XOR_r32_r32( R_ECX, R_EAX );

    TEST_r8_r8( R_AL, R_AL );

    JE_rel8(13, target1);

    TEST_r8_r8( R_AH, R_AH ); // 2

    JE_rel8(9, target2);

    SHR_imm8_r32( 16, R_EAX ); // 3

    TEST_r8_r8( R_AL, R_AL ); // 2

    JE_rel8(2, target3);

    TEST_r8_r8( R_AH, R_AH ); // 2

    JMP_TARGET(target1);

    JMP_TARGET(target2);

    JMP_TARGET(target3);

    SETE_t();

    sh4_x86.tstate = TSTATE_E;

:}

DIV0S Rm, Rn {:

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    SHR_imm8_r32( 31, R_EAX );

    SHR_imm8_r32( 31, R_ECX );

    store_spreg( R_EAX, R_M );

    store_spreg( R_ECX, R_Q );

    CMP_r32_r32( R_EAX, R_ECX );

    SETNE_t();

    sh4_x86.tstate = TSTATE_NE;

:}

DIV0U {:  

    XOR_r32_r32( R_EAX, R_EAX );

    store_spreg( R_EAX, R_Q );

    store_spreg( R_EAX, R_M );

    store_spreg( R_EAX, R_T );

    sh4_x86.tstate = TSTATE_C; // works for DIV1

:}

DIV1 Rm, Rn {:

    load_spreg( R_ECX, R_M );

    load_reg( R_EAX, Rn );

    if( sh4_x86.tstate != TSTATE_C ) {

	LDC_t();

    }

    RCL1_r32( R_EAX );

    SETC_r8( R_DL ); // Q'

    CMP_sh4r_r32( R_Q, R_ECX );

    JE_rel8(5, mqequal);

    ADD_sh4r_r32( REG_OFFSET(r[Rm]), R_EAX );

    JMP_rel8(3, end);

    JMP_TARGET(mqequal);

    SUB_sh4r_r32( REG_OFFSET(r[Rm]), R_EAX );

    JMP_TARGET(end);

    store_reg( R_EAX, Rn ); // Done with Rn now

    SETC_r8(R_AL); // tmp1

    XOR_r8_r8( R_DL, R_AL ); // Q' = Q ^ tmp1

    XOR_r8_r8( R_AL, R_CL ); // Q'' = Q' ^ M

    store_spreg( R_ECX, R_Q );

    XOR_imm8s_r32( 1, R_AL );   // T = !Q'

    MOVZX_r8_r32( R_AL, R_EAX );

    store_spreg( R_EAX, R_T );

    sh4_x86.tstate = TSTATE_NONE;

:}

DMULS.L Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    IMUL_r32(R_ECX);

    store_spreg( R_EDX, R_MACH );

    store_spreg( R_EAX, R_MACL );

    sh4_x86.tstate = TSTATE_NONE;

:}

DMULU.L Rm, Rn {:  

    load_reg( R_EAX, Rm );

    load_reg( R_ECX, Rn );

    MUL_r32(R_ECX);

    store_spreg( R_EDX, R_MACH );

    store_spreg( R_EAX, R_MACL );    

    sh4_x86.tstate = TSTATE_NONE;

:}

DT Rn {:  

    load_reg( R_EAX, Rn );

    ADD_imm8s_r32( -1, R_EAX );

    store_reg( R_EAX, Rn );

    SETE_t();

    sh4_x86.tstate = TSTATE_E;

:}

EXTS.B Rm, Rn {:  

    load_reg( R_EAX, Rm );

    MOVSX_r8_r32( R_EAX, R_EAX );

    store_reg( R_EAX, Rn );

:}

EXTS.W Rm, Rn {:  

    load_reg( R_EAX, Rm );

    MOVSX_r16_r32( R_EAX, R_EAX );

    store_reg( R_EAX, Rn );

:}

EXTU.B Rm, Rn {:  

    load_reg( R_EAX, Rm );

    MOVZX_r8_r32( R_EAX, R_EAX );

    store_reg( R_EAX, Rn );

:}

EXTU.W Rm, Rn {:  

    load_reg( R_EAX, Rm );

    MOVZX_r16_r32( R_EAX, R_EAX );

    store_reg( R_EAX, Rn );

:}

MAC.L @Rm+, @Rn+ {:  

    load_reg( R_ECX, Rm );

    precheck();

    check_ralign32( R_ECX );

    load_reg( R_ECX, Rn );

    check_ralign32( R_ECX );

    ADD_imm8s_sh4r( 4, REG_OFFSET(r[Rn]) );

    MEM_READ_LONG( R_ECX, R_EAX );

    PUSH_r32( R_EAX );

    load_reg( R_ECX, Rm );

    ADD_imm8s_sh4r( 4, REG_OFFSET(r[Rm]) );

    MEM_READ_LONG( R_ECX, R_EAX );

    POP_r32( R_ECX );

    IMUL_r32( R_ECX );

    ADD_r32_sh4r( R_EAX, R_MACL );

    ADC_r32_sh4r( R_EDX, R_MACH );

    load_spreg( R_ECX, R_S );

    TEST_r32_r32(R_ECX, R_ECX);

    JE_rel8( CALL_FUNC0_SIZE, nosat );

    call_func0( signsat48 );

    JMP_TARGET( nosat );

    sh4_x86.tstate = TSTATE_NONE;

:}

MAC.W @Rm+, @Rn+ {:  

    load_reg( R_ECX, Rm );

    precheck();

    check_ralign16( R_ECX );

    load_reg( R_ECX, Rn );

    check_ralign16( R_ECX );

    ADD_imm8s_sh4r( 2, REG_OFFSET(r[Rn]) );

    MEM_READ_WORD( R_ECX, R_EAX );

    PUSH_r32( R_EAX );

    load_reg( R_ECX, Rm );

    ADD_imm8s_sh4r( 2, REG_OFFSET(r[Rm]) );

    MEM_READ_WORD( R_ECX, R_EAX );

    POP_r32( R_ECX );

    IMUL_r32( R_ECX );

    load_spreg( R_ECX, R_S );

    TEST_r32_r32( R_ECX, R_ECX );

    JE_rel8( 47, nosat );

    ADD_r32_sh4r( R_EAX, R_MACL );  // 6

    JNO_rel8( 51, end );            // 2

    load_imm32( R_EDX, 1 );         // 5

    store_spreg( R_EDX, R_MACH );   // 6

    JS_rel8( 13, positive );        // 2

    load_imm32( R_EAX, 0x80000000 );// 5

    store_spreg( R_EAX, R_MACL );   // 6

    JMP_rel8( 25, end2 );           // 2

    JMP_TARGET(positive);

    load_imm32( R_EAX, 0x7FFFFFFF );// 5

    store_spreg( R_EAX, R_MACL );   // 6

    JMP_rel8( 12, end3);            // 2

    JMP_TARGET(nosat);

    ADD_r32_sh4r( R_EAX, R_MACL );  // 6

    ADC_r32_sh4r( R_EDX, R_MACH );  // 6

    JMP_TARGET(end);

    JMP_TARGET(end2);

    JMP_TARGET(end3);

    sh4_x86.tstate = TSTATE_NONE;

:}

MOVT Rn {:  

    load_spreg( R_EAX, R_T );

    store_reg( R_EAX, Rn );

:}