[mupen64plus-pandora.git] / source / mupen64plus-core / src / r4300 / x86 / gregimm.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - gregimm.c                                               *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2002 Hacktarux                                          *
 *                                                                         *
 *   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.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <stdio.h>

#include "assemble.h"
#include "interpret.h"

#include "r4300/recomph.h"
#include "r4300/recomp.h"
#include "r4300/r4300.h"
#include "r4300/ops.h"
#include "r4300/macros.h"

#include "memory/memory.h"

static void genbltz_test(void)
{
   int rs_64bit = is64((unsigned int *)dst->f.i.rs);
   
   if (!rs_64bit)
     {
    int rs = allocate_register((unsigned int *)dst->f.i.rs);
    
    cmp_reg32_imm32(rs, 0);
    jge_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
   else if (rs_64bit == -1)
     {
    cmp_m32_imm32(((unsigned int *)dst->f.i.rs)+1, 0);
    jge_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
   else
     {
    int rs2 = allocate_64_register2((unsigned int *)dst->f.i.rs);
    
    cmp_reg32_imm32(rs2, 0);
    jge_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
}

void genbltz(void)
{
#ifdef INTERPRET_BLTZ
   gencallinterp((unsigned int)cached_interpreter_table.BLTZ, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZ, 1);
    return;
     }
   
   genbltz_test();
   gendelayslot();
   gentest();
#endif
}

void genbltz_out(void)
{
#ifdef INTERPRET_BLTZ_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BLTZ_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZ_OUT, 1);
    return;
     }
   
   genbltz_test();
   gendelayslot();
   gentest_out();
#endif
}

void genbltz_idle(void)
{
#ifdef INTERPRET_BLTZ_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BLTZ_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZ_IDLE, 1);
    return;
     }
   
   genbltz_test();
   gentest_idle();
   genbltz();
#endif
}

static void genbgez_test(void)
{
   int rs_64bit = is64((unsigned int *)dst->f.i.rs);
   
   if (!rs_64bit)
     {
    int rs = allocate_register((unsigned int *)dst->f.i.rs);
    
    cmp_reg32_imm32(rs, 0);
    jl_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
   else if (rs_64bit == -1)
     {
    cmp_m32_imm32(((unsigned int *)dst->f.i.rs)+1, 0);
    jl_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
   else
     {
    int rs2 = allocate_64_register2((unsigned int *)dst->f.i.rs);
    
    cmp_reg32_imm32(rs2, 0);
    jl_rj(12);
    mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
    jmp_imm_short(10); // 2
    mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
     }
}

void genbgez(void)
{
#ifdef INTERPRET_BGEZ
   gencallinterp((unsigned int)cached_interpreter_table.BGEZ, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZ, 1);
    return;
     }
   
   genbgez_test();
   gendelayslot();
   gentest();
#endif
}

void genbgez_out(void)
{
#ifdef INTERPRET_BGEZ_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BGEZ_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZ_OUT, 1);
    return;
     }
   
   genbgez_test();
   gendelayslot();
   gentest_out();
#endif
}

void genbgez_idle(void)
{
#ifdef INTERPRET_BGEZ_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BGEZ_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZ_IDLE, 1);
    return;
     }
   
   genbgez_test();
   gentest_idle();
   genbgez();
#endif
}

void genbltzl(void)
{
#ifdef INTERPRET_BLTZL
   gencallinterp((unsigned int)cached_interpreter_table.BLTZL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZL, 1);
    return;
     }
   
   genbltz_test();
   free_all_registers();
   gentestl();
#endif
}

void genbltzl_out(void)
{
#ifdef INTERPRET_BLTZL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BLTZL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZL_OUT, 1);
    return;
     }
   
   genbltz_test();
   free_all_registers();
   gentestl_out();
#endif
}

void genbltzl_idle(void)
{
#ifdef INTERPRET_BLTZL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BLTZL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZL_IDLE, 1);
    return;
     }
   
   genbltz_test();
   gentest_idle();
   genbltzl();
#endif
}

void genbgezl(void)
{
#ifdef INTERPRET_BGEZL
   gencallinterp((unsigned int)cached_interpreter_table.BGEZL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZL, 1);
    return;
     }
   
   genbgez_test();
   free_all_registers();
   gentestl();
#endif
}

void genbgezl_out(void)
{
#ifdef INTERPRET_BGEZL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BGEZL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZL_OUT, 1);
    return;
     }
   
   genbgez_test();
   free_all_registers();
   gentestl_out();
#endif
}

void genbgezl_idle(void)
{
#ifdef INTERPRET_BGEZL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BGEZL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZL_IDLE, 1);
    return;
     }
   
   genbgez_test();
   gentest_idle();
   genbgezl();
#endif
}

static void genbranchlink(void)
{
   int r31_64bit = is64((unsigned int*)&reg[31]);
   
   if (!r31_64bit)
     {
    int r31 = allocate_register_w((unsigned int *)&reg[31]);
    
    mov_reg32_imm32(r31, dst->addr+8);
     }
   else if (r31_64bit == -1)
     {
    mov_m32_imm32((unsigned int *)&reg[31], dst->addr + 8);
    if (dst->addr & 0x80000000)
      mov_m32_imm32(((unsigned int *)&reg[31])+1, 0xFFFFFFFF);
    else
      mov_m32_imm32(((unsigned int *)&reg[31])+1, 0);
     }
   else
     {
    int r311 = allocate_64_register1_w((unsigned int *)&reg[31]);
    int r312 = allocate_64_register2_w((unsigned int *)&reg[31]);
    
    mov_reg32_imm32(r311, dst->addr+8);
    if (dst->addr & 0x80000000)
      mov_reg32_imm32(r312, 0xFFFFFFFF);
    else
      mov_reg32_imm32(r312, 0);
     }
}

void genbltzal(void)
{
#ifdef INTERPRET_BLTZAL
   gencallinterp((unsigned int)cached_interpreter_table.BLTZAL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZAL, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   gendelayslot();
   gentest();
#endif
}

void genbltzal_out(void)
{
#ifdef INTERPRET_BLTZAL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_OUT, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   gendelayslot();
   gentest_out();
#endif
}

void genbltzal_idle(void)
{
#ifdef INTERPRET_BLTZAL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_IDLE, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   gentest_idle();
   genbltzal();
#endif
}

void genbgezal(void)
{
#ifdef INTERPRET_BGEZAL
   gencallinterp((unsigned int)cached_interpreter_table.BGEZAL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZAL, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   gendelayslot();
   gentest();
#endif
}

void genbgezal_out(void)
{
#ifdef INTERPRET_BGEZAL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_OUT, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   gendelayslot();
   gentest_out();
#endif
}

void genbgezal_idle(void)
{
#ifdef INTERPRET_BGEZAL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_IDLE, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   gentest_idle();
   genbgezal();
#endif
}

void genbltzall(void)
{
#ifdef INTERPRET_BLTZALL
   gencallinterp((unsigned int)cached_interpreter_table.BLTZALL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZALL, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   free_all_registers();
   gentestl();
#endif
}

void genbltzall_out(void)
{
#ifdef INTERPRET_BLTZALL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_OUT, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   free_all_registers();
   gentestl_out();
#endif
}

void genbltzall_idle(void)
{
#ifdef INTERPRET_BLTZALL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_IDLE, 1);
    return;
     }
   
   genbltz_test();
   genbranchlink();
   gentest_idle();
   genbltzall();
#endif
}

void genbgezall(void)
{
#ifdef INTERPRET_BGEZALL
   gencallinterp((unsigned int)cached_interpreter_table.BGEZALL, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZALL, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   free_all_registers();
   gentestl();
#endif
}

void genbgezall_out(void)
{
#ifdef INTERPRET_BGEZALL_OUT
   gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_OUT, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_OUT, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   free_all_registers();
   gentestl_out();
#endif
}

void genbgezall_idle(void)
{
#ifdef INTERPRET_BGEZALL_IDLE
   gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_IDLE, 1);
#else
   if (((dst->addr & 0xFFF) == 0xFFC && 
       (dst->addr < 0x80000000 || dst->addr >= 0xC0000000))||no_compiled_jump)
     {
    gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_IDLE, 1);
    return;
     }
   
   genbgez_test();
   genbranchlink();
   gentest_idle();
   genbgezall();
#endif
}
Commit	Line	Data
451ab91e	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - gregimm.c *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2002 Hacktarux *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#include <stdio.h>
	23
	24	#include "assemble.h"
	25	#include "interpret.h"
	26
	27	#include "r4300/recomph.h"
	28	#include "r4300/recomp.h"
	29	#include "r4300/r4300.h"
	30	#include "r4300/ops.h"
	31	#include "r4300/macros.h"
	32
	33	#include "memory/memory.h"
	34
	35	static void genbltz_test(void)
	36	{
	37	int rs_64bit = is64((unsigned int *)dst->f.i.rs);
	38
	39	if (!rs_64bit)
	40	{
	41	int rs = allocate_register((unsigned int *)dst->f.i.rs);
	42
	43	cmp_reg32_imm32(rs, 0);
	44	jge_rj(12);
	45	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
	46	jmp_imm_short(10); // 2
	47	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
	48	}
	49	else if (rs_64bit == -1)
	50	{
	51	cmp_m32_imm32(((unsigned int *)dst->f.i.rs)+1, 0);
	52	jge_rj(12);
	53	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
	54	jmp_imm_short(10); // 2
	55	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
	56	}
	57	else
	58	{
	59	int rs2 = allocate_64_register2((unsigned int *)dst->f.i.rs);
	60
	61	cmp_reg32_imm32(rs2, 0);
	62	jge_rj(12);
	63	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
	64	jmp_imm_short(10); // 2
65	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
66	}
67	}
68
69	void genbltz(void)
70	{
71	#ifdef INTERPRET_BLTZ
72	gencallinterp((unsigned int)cached_interpreter_table.BLTZ, 1);
73	#else
74	if (((dst->addr & 0xFFF) == 0xFFC &&
75	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
76	{
77	gencallinterp((unsigned int)cached_interpreter_table.BLTZ, 1);
78	return;
79	}
80
81	genbltz_test();
82	gendelayslot();
83	gentest();
84	#endif
85	}
86
87	void genbltz_out(void)
88	{
89	#ifdef INTERPRET_BLTZ_OUT
90	gencallinterp((unsigned int)cached_interpreter_table.BLTZ_OUT, 1);
91	#else
92	if (((dst->addr & 0xFFF) == 0xFFC &&
93	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
94	{
95	gencallinterp((unsigned int)cached_interpreter_table.BLTZ_OUT, 1);
96	return;
97	}
98
99	genbltz_test();
100	gendelayslot();
101	gentest_out();
102	#endif
103	}
104
105	void genbltz_idle(void)
106	{
107	#ifdef INTERPRET_BLTZ_IDLE
108	gencallinterp((unsigned int)cached_interpreter_table.BLTZ_IDLE, 1);
109	#else
110	if (((dst->addr & 0xFFF) == 0xFFC &&
111	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
112	{
113	gencallinterp((unsigned int)cached_interpreter_table.BLTZ_IDLE, 1);
114	return;
115	}
116
117	genbltz_test();
118	gentest_idle();
119	genbltz();
120	#endif
121	}
122
123	static void genbgez_test(void)
124	{
125	int rs_64bit = is64((unsigned int *)dst->f.i.rs);
126
127	if (!rs_64bit)
128	{
129	int rs = allocate_register((unsigned int *)dst->f.i.rs);
130
131	cmp_reg32_imm32(rs, 0);
132	jl_rj(12);
133	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
134	jmp_imm_short(10); // 2
135	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
136	}
137	else if (rs_64bit == -1)
138	{
139	cmp_m32_imm32(((unsigned int *)dst->f.i.rs)+1, 0);
140	jl_rj(12);
141	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
142	jmp_imm_short(10); // 2
143	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
144	}
145	else
146	{
147	int rs2 = allocate_64_register2((unsigned int *)dst->f.i.rs);
148
149	cmp_reg32_imm32(rs2, 0);
150	jl_rj(12);
151	mov_m32_imm32((unsigned int *)(&branch_taken), 1); // 10
152	jmp_imm_short(10); // 2
153	mov_m32_imm32((unsigned int *)(&branch_taken), 0); // 10
154	}
155	}
156
157	void genbgez(void)
158	{
159	#ifdef INTERPRET_BGEZ
160	gencallinterp((unsigned int)cached_interpreter_table.BGEZ, 1);
161	#else
162	if (((dst->addr & 0xFFF) == 0xFFC &&
163	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
164	{
165	gencallinterp((unsigned int)cached_interpreter_table.BGEZ, 1);
166	return;
167	}
168
169	genbgez_test();
170	gendelayslot();
171	gentest();
172	#endif
173	}
174
175	void genbgez_out(void)
176	{
177	#ifdef INTERPRET_BGEZ_OUT
178	gencallinterp((unsigned int)cached_interpreter_table.BGEZ_OUT, 1);
179	#else
180	if (((dst->addr & 0xFFF) == 0xFFC &&
181	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
182	{
183	gencallinterp((unsigned int)cached_interpreter_table.BGEZ_OUT, 1);
184	return;
185	}
186
187	genbgez_test();
188	gendelayslot();
189	gentest_out();
190	#endif
191	}
192
193	void genbgez_idle(void)
194	{
195	#ifdef INTERPRET_BGEZ_IDLE
196	gencallinterp((unsigned int)cached_interpreter_table.BGEZ_IDLE, 1);
197	#else
198	if (((dst->addr & 0xFFF) == 0xFFC &&
199	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
200	{
201	gencallinterp((unsigned int)cached_interpreter_table.BGEZ_IDLE, 1);
202	return;
203	}
204
205	genbgez_test();
206	gentest_idle();
207	genbgez();
208	#endif
209	}
210
211	void genbltzl(void)
212	{
213	#ifdef INTERPRET_BLTZL
214	gencallinterp((unsigned int)cached_interpreter_table.BLTZL, 1);
215	#else
216	if (((dst->addr & 0xFFF) == 0xFFC &&
217	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
218	{
219	gencallinterp((unsigned int)cached_interpreter_table.BLTZL, 1);
220	return;
221	}
222
223	genbltz_test();
224	free_all_registers();
225	gentestl();
226	#endif
227	}
228
229	void genbltzl_out(void)
230	{
231	#ifdef INTERPRET_BLTZL_OUT
232	gencallinterp((unsigned int)cached_interpreter_table.BLTZL_OUT, 1);
233	#else
234	if (((dst->addr & 0xFFF) == 0xFFC &&
235	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
236	{
237	gencallinterp((unsigned int)cached_interpreter_table.BLTZL_OUT, 1);
238	return;
239	}
240
241	genbltz_test();
242	free_all_registers();
243	gentestl_out();
244	#endif
245	}
246
247	void genbltzl_idle(void)
248	{
249	#ifdef INTERPRET_BLTZL_IDLE
250	gencallinterp((unsigned int)cached_interpreter_table.BLTZL_IDLE, 1);
251	#else
252	if (((dst->addr & 0xFFF) == 0xFFC &&
253	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
254	{
255	gencallinterp((unsigned int)cached_interpreter_table.BLTZL_IDLE, 1);
256	return;
257	}
258
259	genbltz_test();
260	gentest_idle();
261	genbltzl();
262	#endif
263	}
264
265	void genbgezl(void)
266	{
267	#ifdef INTERPRET_BGEZL
268	gencallinterp((unsigned int)cached_interpreter_table.BGEZL, 1);
269	#else
270	if (((dst->addr & 0xFFF) == 0xFFC &&
271	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
272	{
273	gencallinterp((unsigned int)cached_interpreter_table.BGEZL, 1);
274	return;
275	}
276
277	genbgez_test();
278	free_all_registers();
279	gentestl();
280	#endif
281	}
282
283	void genbgezl_out(void)
284	{
285	#ifdef INTERPRET_BGEZL_OUT
286	gencallinterp((unsigned int)cached_interpreter_table.BGEZL_OUT, 1);
287	#else
288	if (((dst->addr & 0xFFF) == 0xFFC &&
289	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
290	{
291	gencallinterp((unsigned int)cached_interpreter_table.BGEZL_OUT, 1);
292	return;
293	}
294
295	genbgez_test();
296	free_all_registers();
297	gentestl_out();
298	#endif
299	}
300
301	void genbgezl_idle(void)
302	{
303	#ifdef INTERPRET_BGEZL_IDLE
304	gencallinterp((unsigned int)cached_interpreter_table.BGEZL_IDLE, 1);
305	#else
306	if (((dst->addr & 0xFFF) == 0xFFC &&
307	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
308	{
309	gencallinterp((unsigned int)cached_interpreter_table.BGEZL_IDLE, 1);
310	return;
311	}
312
313	genbgez_test();
314	gentest_idle();
315	genbgezl();
316	#endif
317	}
318
319	static void genbranchlink(void)
320	{
321	int r31_64bit = is64((unsigned int*)&reg[31]);
322
323	if (!r31_64bit)
324	{
325	int r31 = allocate_register_w((unsigned int *)&reg[31]);
326
327	mov_reg32_imm32(r31, dst->addr+8);
328	}
329	else if (r31_64bit == -1)
330	{
331	mov_m32_imm32((unsigned int *)&reg[31], dst->addr + 8);
332	if (dst->addr & 0x80000000)
333	mov_m32_imm32(((unsigned int *)&reg[31])+1, 0xFFFFFFFF);
334	else
335	mov_m32_imm32(((unsigned int *)&reg[31])+1, 0);
336	}
337	else
338	{
339	int r311 = allocate_64_register1_w((unsigned int *)&reg[31]);
340	int r312 = allocate_64_register2_w((unsigned int *)&reg[31]);
341
342	mov_reg32_imm32(r311, dst->addr+8);
343	if (dst->addr & 0x80000000)
344	mov_reg32_imm32(r312, 0xFFFFFFFF);
345	else
346	mov_reg32_imm32(r312, 0);
347	}
348	}
349
350	void genbltzal(void)
351	{
352	#ifdef INTERPRET_BLTZAL
353	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL, 1);
354	#else
355	if (((dst->addr & 0xFFF) == 0xFFC &&
356	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
357	{
358	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL, 1);
359	return;
360	}
361
362	genbltz_test();
363	genbranchlink();
364	gendelayslot();
365	gentest();
366	#endif
367	}
368
369	void genbltzal_out(void)
370	{
371	#ifdef INTERPRET_BLTZAL_OUT
372	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_OUT, 1);
373	#else
374	if (((dst->addr & 0xFFF) == 0xFFC &&
375	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
376	{
377	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_OUT, 1);
378	return;
379	}
380
381	genbltz_test();
382	genbranchlink();
383	gendelayslot();
384	gentest_out();
385	#endif
386	}
387
388	void genbltzal_idle(void)
389	{
390	#ifdef INTERPRET_BLTZAL_IDLE
391	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_IDLE, 1);
392	#else
393	if (((dst->addr & 0xFFF) == 0xFFC &&
394	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
395	{
396	gencallinterp((unsigned int)cached_interpreter_table.BLTZAL_IDLE, 1);
397	return;
398	}
399
400	genbltz_test();
401	genbranchlink();
402	gentest_idle();
403	genbltzal();
404	#endif
405	}
406
407	void genbgezal(void)
408	{
409	#ifdef INTERPRET_BGEZAL
410	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL, 1);
411	#else
412	if (((dst->addr & 0xFFF) == 0xFFC &&
413	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
414	{
415	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL, 1);
416	return;
417	}
418
419	genbgez_test();
420	genbranchlink();
421	gendelayslot();
422	gentest();
423	#endif
424	}
425
426	void genbgezal_out(void)
427	{
428	#ifdef INTERPRET_BGEZAL_OUT
429	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_OUT, 1);
430	#else
431	if (((dst->addr & 0xFFF) == 0xFFC &&
432	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
433	{
434	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_OUT, 1);
435	return;
436	}
437
438	genbgez_test();
439	genbranchlink();
440	gendelayslot();
441	gentest_out();
442	#endif
443	}
444
445	void genbgezal_idle(void)
446	{
447	#ifdef INTERPRET_BGEZAL_IDLE
448	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_IDLE, 1);
449	#else
450	if (((dst->addr & 0xFFF) == 0xFFC &&
451	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
452	{
453	gencallinterp((unsigned int)cached_interpreter_table.BGEZAL_IDLE, 1);
454	return;
455	}
456
457	genbgez_test();
458	genbranchlink();
459	gentest_idle();
460	genbgezal();
461	#endif
462	}
463
464	void genbltzall(void)
465	{
466	#ifdef INTERPRET_BLTZALL
467	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL, 1);
468	#else
469	if (((dst->addr & 0xFFF) == 0xFFC &&
470	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
471	{
472	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL, 1);
473	return;
474	}
475
476	genbltz_test();
477	genbranchlink();
478	free_all_registers();
479	gentestl();
480	#endif
481	}
482
483	void genbltzall_out(void)
484	{
485	#ifdef INTERPRET_BLTZALL_OUT
486	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_OUT, 1);
487	#else
488	if (((dst->addr & 0xFFF) == 0xFFC &&
489	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
490	{
491	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_OUT, 1);
492	return;
493	}
494
495	genbltz_test();
496	genbranchlink();
497	free_all_registers();
498	gentestl_out();
499	#endif
500	}
501
502	void genbltzall_idle(void)
503	{
504	#ifdef INTERPRET_BLTZALL_IDLE
505	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_IDLE, 1);
506	#else
507	if (((dst->addr & 0xFFF) == 0xFFC &&
508	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
509	{
510	gencallinterp((unsigned int)cached_interpreter_table.BLTZALL_IDLE, 1);
511	return;
512	}
513
514	genbltz_test();
515	genbranchlink();
516	gentest_idle();
517	genbltzall();
518	#endif
519	}
520
521	void genbgezall(void)
522	{
523	#ifdef INTERPRET_BGEZALL
524	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL, 1);
525	#else
526	if (((dst->addr & 0xFFF) == 0xFFC &&
527	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
528	{
529	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL, 1);
530	return;
531	}
532
533	genbgez_test();
534	genbranchlink();
535	free_all_registers();
536	gentestl();
537	#endif
538	}
539
540	void genbgezall_out(void)
541	{
542	#ifdef INTERPRET_BGEZALL_OUT
543	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_OUT, 1);
544	#else
545	if (((dst->addr & 0xFFF) == 0xFFC &&
546	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
547	{
548	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_OUT, 1);
549	return;
550	}
551
552	genbgez_test();
553	genbranchlink();
554	free_all_registers();
555	gentestl_out();
556	#endif
557	}
558
559	void genbgezall_idle(void)
560	{
561	#ifdef INTERPRET_BGEZALL_IDLE
562	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_IDLE, 1);
563	#else
564	if (((dst->addr & 0xFFF) == 0xFFC &&
565	(dst->addr < 0x80000000 \|\| dst->addr >= 0xC0000000))\|\|no_compiled_jump)
566	{
567	gencallinterp((unsigned int)cached_interpreter_table.BGEZALL_IDLE, 1);
568	return;
569	}
570
571	genbgez_test();
572	genbranchlink();
573	gentest_idle();
574	genbgezall();
575	#endif
576	}
577