/target-sparc/translate.c - Annotate - qemu - Greek Research and Technology Network's projects

root / target-sparc / translate.c @ e00c1e71

History | View | Annotate | Download (183.6 kB)

1	7a3f1944	bellard	/*
2	7a3f1944	bellard	SPARC translation
3	7a3f1944	bellard
4	7a3f1944	bellard	Copyright (C) 2003 Thomas M. Ogrisegg <tom@fnord.at>
5	3475187d	bellard	Copyright (C) 2003-2005 Fabrice Bellard
6	7a3f1944	bellard
7	7a3f1944	bellard	This library is free software; you can redistribute it and/or
8	7a3f1944	bellard	modify it under the terms of the GNU Lesser General Public
9	7a3f1944	bellard	License as published by the Free Software Foundation; either
10	7a3f1944	bellard	version 2 of the License, or (at your option) any later version.
11	7a3f1944	bellard
12	7a3f1944	bellard	This library is distributed in the hope that it will be useful,
13	7a3f1944	bellard	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	7a3f1944	bellard	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	7a3f1944	bellard	Lesser General Public License for more details.
16	7a3f1944	bellard
17	7a3f1944	bellard	You should have received a copy of the GNU Lesser General Public
18	7a3f1944	bellard	License along with this library; if not, write to the Free Software
19	7a3f1944	bellard	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	7a3f1944	bellard	*/
21	7a3f1944	bellard
22	7a3f1944	bellard	#include <stdarg.h>
23	7a3f1944	bellard	#include <stdlib.h>
24	7a3f1944	bellard	#include <stdio.h>
25	7a3f1944	bellard	#include <string.h>
26	7a3f1944	bellard	#include <inttypes.h>
27	7a3f1944	bellard
28	7a3f1944	bellard	#include "cpu.h"
29	7a3f1944	bellard	#include "exec-all.h"
30	7a3f1944	bellard	#include "disas.h"
31	1a2fb1c0	blueswir1	#include "helper.h"
32	57fec1fe	bellard	#include "tcg-op.h"
33	7a3f1944	bellard
34	7a3f1944	bellard	#define DEBUG_DISAS
35	7a3f1944	bellard
36	72cbca10	bellard	#define DYNAMIC_PC 1 /* dynamic pc value */
37	72cbca10	bellard	#define JUMP_PC 2 /* dynamic pc value which takes only two values
38	72cbca10	bellard	according to jump_pc[T2] */
39	72cbca10	bellard
40	1a2fb1c0	blueswir1	/* global register indexes */
41	77f193da	blueswir1	static TCGv cpu_env, cpu_T[2], cpu_regwptr;
42	77f193da	blueswir1	static TCGv cpu_cc_src, cpu_cc_src2, cpu_cc_dst;
43	48d5c82b	blueswir1	static TCGv cpu_psr, cpu_fsr, cpu_pc, cpu_npc, cpu_gregs[8];
44	6ae20372	blueswir1	static TCGv cpu_cond, cpu_src1, cpu_src2, cpu_dst, cpu_addr, cpu_val;
45	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
46	dc99a3f2	blueswir1	static TCGv cpu_xcc;
47	dc99a3f2	blueswir1	#endif
48	1a2fb1c0	blueswir1	/* local register indexes (only used inside old micro ops) */
49	8911f501	blueswir1	static TCGv cpu_tmp0, cpu_tmp32, cpu_tmp64;
50	1a2fb1c0	blueswir1
51	7a3f1944	bellard	typedef struct DisasContext {
52	0f8a249a	blueswir1	target_ulong pc; /* current Program Counter: integer or DYNAMIC_PC */
53	0f8a249a	blueswir1	target_ulong npc; /* next PC: integer or DYNAMIC_PC or JUMP_PC */
54	72cbca10	bellard	target_ulong jump_pc[2]; /* used when JUMP_PC pc value is used */
55	cf495bcf	bellard	int is_br;
56	e8af50a3	bellard	int mem_idx;
57	a80dde08	bellard	int fpu_enabled;
58	cf495bcf	bellard	struct TranslationBlock *tb;
59	64a88d5d	blueswir1	uint32_t features;
60	7a3f1944	bellard	} DisasContext;
61	7a3f1944	bellard
62	3475187d	bellard	// This function uses non-native bit order
63	7a3f1944	bellard	#define GET_FIELD(X, FROM, TO) \
64	7a3f1944	bellard	((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
65	7a3f1944	bellard
66	3475187d	bellard	// This function uses the order in the manuals, i.e. bit 0 is 2^0
67	3475187d	bellard	#define GET_FIELD_SP(X, FROM, TO) \
68	3475187d	bellard	GET_FIELD(X, 31 - (TO), 31 - (FROM))
69	3475187d	bellard
70	3475187d	bellard	#define GET_FIELDs(x,a,b) sign_extend (GET_FIELD(x,a,b), (b) - (a) + 1)
71	46d38ba8	blueswir1	#define GET_FIELD_SPs(x,a,b) sign_extend (GET_FIELD_SP(x,a,b), ((b) - (a) + 1))
72	3475187d	bellard
73	3475187d	bellard	#ifdef TARGET_SPARC64
74	19f329ad	blueswir1	#define FFPREG(r) (r)
75	0387d928	blueswir1	#define DFPREG(r) (((r & 1) << 5) \| (r & 0x1e))
76	1f587329	blueswir1	#define QFPREG(r) (((r & 1) << 5) \| (r & 0x1c))
77	3475187d	bellard	#else
78	19f329ad	blueswir1	#define FFPREG(r) (r)
79	c185970a	blueswir1	#define DFPREG(r) (r & 0x1e)
80	1f587329	blueswir1	#define QFPREG(r) (r & 0x1c)
81	3475187d	bellard	#endif
82	3475187d	bellard
83	3475187d	bellard	static int sign_extend(int x, int len)
84	3475187d	bellard	{
85	3475187d	bellard	len = 32 - len;
86	3475187d	bellard	return (x << len) >> len;
87	3475187d	bellard	}
88	3475187d	bellard
89	7a3f1944	bellard	#define IS_IMM (insn & (1<<13))
90	7a3f1944	bellard
91	ff07ec83	blueswir1	/* floating point registers moves */
92	ff07ec83	blueswir1	static void gen_op_load_fpr_FT0(unsigned int src)
93	ff07ec83	blueswir1	{
94	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
95	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, ft0));
96	3475187d	bellard	}
97	ff07ec83	blueswir1
98	ff07ec83	blueswir1	static void gen_op_load_fpr_FT1(unsigned int src)
99	ff07ec83	blueswir1	{
100	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
101	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, ft1));
102	e8af50a3	bellard	}
103	e8af50a3	bellard
104	ff07ec83	blueswir1	static void gen_op_store_FT0_fpr(unsigned int dst)
105	ff07ec83	blueswir1	{
106	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, ft0));
107	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst]));
108	ff07ec83	blueswir1	}
109	ff07ec83	blueswir1
110	ff07ec83	blueswir1	static void gen_op_load_fpr_DT0(unsigned int src)
111	ff07ec83	blueswir1	{
112	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
113	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt0) +
114	77f193da	blueswir1	offsetof(CPU_DoubleU, l.upper));
115	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));
116	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt0) +
117	77f193da	blueswir1	offsetof(CPU_DoubleU, l.lower));
118	ff07ec83	blueswir1	}
119	ff07ec83	blueswir1
120	ff07ec83	blueswir1	static void gen_op_load_fpr_DT1(unsigned int src)
121	ff07ec83	blueswir1	{
122	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
123	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt1) +
124	77f193da	blueswir1	offsetof(CPU_DoubleU, l.upper));
125	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));
126	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt1) +
127	77f193da	blueswir1	offsetof(CPU_DoubleU, l.lower));
128	ff07ec83	blueswir1	}
129	ff07ec83	blueswir1
130	ff07ec83	blueswir1	static void gen_op_store_DT0_fpr(unsigned int dst)
131	ff07ec83	blueswir1	{
132	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt0) +
133	77f193da	blueswir1	offsetof(CPU_DoubleU, l.upper));
134	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst]));
135	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, dt0) +
136	77f193da	blueswir1	offsetof(CPU_DoubleU, l.lower));
137	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst + 1]));
138	ff07ec83	blueswir1	}
139	ff07ec83	blueswir1
140	ff07ec83	blueswir1	static void gen_op_load_fpr_QT0(unsigned int src)
141	ff07ec83	blueswir1	{
142	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
143	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
144	77f193da	blueswir1	offsetof(CPU_QuadU, l.upmost));
145	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));
146	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
147	77f193da	blueswir1	offsetof(CPU_QuadU, l.upper));
148	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 2]));
149	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
150	77f193da	blueswir1	offsetof(CPU_QuadU, l.lower));
151	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 3]));
152	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
153	77f193da	blueswir1	offsetof(CPU_QuadU, l.lowest));
154	ff07ec83	blueswir1	}
155	ff07ec83	blueswir1
156	ff07ec83	blueswir1	static void gen_op_load_fpr_QT1(unsigned int src)
157	ff07ec83	blueswir1	{
158	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src]));
159	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt1) +
160	77f193da	blueswir1	offsetof(CPU_QuadU, l.upmost));
161	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 1]));
162	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt1) +
163	77f193da	blueswir1	offsetof(CPU_QuadU, l.upper));
164	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 2]));
165	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt1) +
166	77f193da	blueswir1	offsetof(CPU_QuadU, l.lower));
167	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[src + 3]));
168	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt1) +
169	77f193da	blueswir1	offsetof(CPU_QuadU, l.lowest));
170	ff07ec83	blueswir1	}
171	ff07ec83	blueswir1
172	ff07ec83	blueswir1	static void gen_op_store_QT0_fpr(unsigned int dst)
173	ff07ec83	blueswir1	{
174	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
175	77f193da	blueswir1	offsetof(CPU_QuadU, l.upmost));
176	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst]));
177	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
178	77f193da	blueswir1	offsetof(CPU_QuadU, l.upper));
179	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst + 1]));
180	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
181	77f193da	blueswir1	offsetof(CPU_QuadU, l.lower));
182	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst + 2]));
183	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, qt0) +
184	77f193da	blueswir1	offsetof(CPU_QuadU, l.lowest));
185	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, fpr[dst + 3]));
186	ff07ec83	blueswir1	}
187	1f587329	blueswir1
188	81ad8ba2	blueswir1	/* moves */
189	81ad8ba2	blueswir1	#ifdef CONFIG_USER_ONLY
190	3475187d	bellard	#define supervisor(dc) 0
191	81ad8ba2	blueswir1	#ifdef TARGET_SPARC64
192	e9ebed4d	blueswir1	#define hypervisor(dc) 0
193	81ad8ba2	blueswir1	#endif
194	3475187d	bellard	#else
195	6f27aba6	blueswir1	#define supervisor(dc) (dc->mem_idx >= 1)
196	81ad8ba2	blueswir1	#ifdef TARGET_SPARC64
197	81ad8ba2	blueswir1	#define hypervisor(dc) (dc->mem_idx == 2)
198	6f27aba6	blueswir1	#else
199	3475187d	bellard	#endif
200	81ad8ba2	blueswir1	#endif
201	81ad8ba2	blueswir1
202	1a2fb1c0	blueswir1	#ifdef TARGET_ABI32
203	8911f501	blueswir1	#define ABI32_MASK(addr) tcg_gen_andi_tl(addr, addr, 0xffffffffULL);
204	1a2fb1c0	blueswir1	#else
205	1a2fb1c0	blueswir1	#define ABI32_MASK(addr)
206	1a2fb1c0	blueswir1	#endif
207	3391c818	blueswir1
208	1a2fb1c0	blueswir1	static inline void gen_movl_reg_TN(int reg, TCGv tn)
209	81ad8ba2	blueswir1	{
210	1a2fb1c0	blueswir1	if (reg == 0)
211	1a2fb1c0	blueswir1	tcg_gen_movi_tl(tn, 0);
212	1a2fb1c0	blueswir1	else if (reg < 8)
213	f5069b26	blueswir1	tcg_gen_mov_tl(tn, cpu_gregs[reg]);
214	1a2fb1c0	blueswir1	else {
215	1a2fb1c0	blueswir1	tcg_gen_ld_tl(tn, cpu_regwptr, (reg - 8) * sizeof(target_ulong));
216	81ad8ba2	blueswir1	}
217	81ad8ba2	blueswir1	}
218	81ad8ba2	blueswir1
219	1a2fb1c0	blueswir1	static inline void gen_movl_TN_reg(int reg, TCGv tn)
220	81ad8ba2	blueswir1	{
221	1a2fb1c0	blueswir1	if (reg == 0)
222	1a2fb1c0	blueswir1	return;
223	1a2fb1c0	blueswir1	else if (reg < 8)
224	f5069b26	blueswir1	tcg_gen_mov_tl(cpu_gregs[reg], tn);
225	1a2fb1c0	blueswir1	else {
226	1a2fb1c0	blueswir1	tcg_gen_st_tl(tn, cpu_regwptr, (reg - 8) * sizeof(target_ulong));
227	81ad8ba2	blueswir1	}
228	81ad8ba2	blueswir1	}
229	81ad8ba2	blueswir1
230	5fafdf24	ths	static inline void gen_goto_tb(DisasContext *s, int tb_num,
231	6e256c93	bellard	target_ulong pc, target_ulong npc)
232	6e256c93	bellard	{
233	6e256c93	bellard	TranslationBlock *tb;
234	6e256c93	bellard
235	6e256c93	bellard	tb = s->tb;
236	6e256c93	bellard	if ((pc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) &&
237	6e256c93	bellard	(npc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK)) {
238	6e256c93	bellard	/* jump to same page: we can use a direct jump */
239	57fec1fe	bellard	tcg_gen_goto_tb(tb_num);
240	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_pc, pc);
241	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_npc, npc);
242	57fec1fe	bellard	tcg_gen_exit_tb((long)tb + tb_num);
243	6e256c93	bellard	} else {
244	6e256c93	bellard	/* jump to another page: currently not optimized */
245	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_pc, pc);
246	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_npc, npc);
247	57fec1fe	bellard	tcg_gen_exit_tb(0);
248	6e256c93	bellard	}
249	6e256c93	bellard	}
250	6e256c93	bellard
251	19f329ad	blueswir1	// XXX suboptimal
252	19f329ad	blueswir1	static inline void gen_mov_reg_N(TCGv reg, TCGv src)
253	19f329ad	blueswir1	{
254	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
255	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, PSR_NEG_SHIFT);
256	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
257	19f329ad	blueswir1	}
258	19f329ad	blueswir1
259	19f329ad	blueswir1	static inline void gen_mov_reg_Z(TCGv reg, TCGv src)
260	19f329ad	blueswir1	{
261	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
262	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, PSR_ZERO_SHIFT);
263	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
264	19f329ad	blueswir1	}
265	19f329ad	blueswir1
266	19f329ad	blueswir1	static inline void gen_mov_reg_V(TCGv reg, TCGv src)
267	19f329ad	blueswir1	{
268	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
269	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, PSR_OVF_SHIFT);
270	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
271	19f329ad	blueswir1	}
272	19f329ad	blueswir1
273	19f329ad	blueswir1	static inline void gen_mov_reg_C(TCGv reg, TCGv src)
274	19f329ad	blueswir1	{
275	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
276	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, PSR_CARRY_SHIFT);
277	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
278	19f329ad	blueswir1	}
279	19f329ad	blueswir1
280	ce5b3c3d	blueswir1	static inline void gen_cc_clear_icc(void)
281	dc99a3f2	blueswir1	{
282	dc99a3f2	blueswir1	tcg_gen_movi_i32(cpu_psr, 0);
283	ce5b3c3d	blueswir1	}
284	ce5b3c3d	blueswir1
285	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
286	ce5b3c3d	blueswir1	static inline void gen_cc_clear_xcc(void)
287	ce5b3c3d	blueswir1	{
288	dc99a3f2	blueswir1	tcg_gen_movi_i32(cpu_xcc, 0);
289	dc99a3f2	blueswir1	}
290	ce5b3c3d	blueswir1	#endif
291	dc99a3f2	blueswir1
292	dc99a3f2	blueswir1	/* old op:
293	dc99a3f2	blueswir1	if (!T0)
294	dc99a3f2	blueswir1	env->psr \|= PSR_ZERO;
295	dc99a3f2	blueswir1	if ((int32_t) T0 < 0)
296	dc99a3f2	blueswir1	env->psr \|= PSR_NEG;
297	dc99a3f2	blueswir1	*/
298	ce5b3c3d	blueswir1	static inline void gen_cc_NZ_icc(TCGv dst)
299	dc99a3f2	blueswir1	{
300	8911f501	blueswir1	TCGv r_temp;
301	dc99a3f2	blueswir1	int l1, l2;
302	dc99a3f2	blueswir1
303	dc99a3f2	blueswir1	l1 = gen_new_label();
304	dc99a3f2	blueswir1	l2 = gen_new_label();
305	8911f501	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
306	8911f501	blueswir1	tcg_gen_andi_tl(r_temp, dst, 0xffffffffULL);
307	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_NE, r_temp, 0, l1);
308	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_ZERO);
309	dc99a3f2	blueswir1	gen_set_label(l1);
310	bdf46ea2	blueswir1	tcg_gen_ext_i32_tl(r_temp, dst);
311	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_GE, r_temp, 0, l2);
312	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_NEG);
313	dc99a3f2	blueswir1	gen_set_label(l2);
314	2ea815ca	blueswir1	tcg_temp_free(r_temp);
315	ce5b3c3d	blueswir1	}
316	ce5b3c3d	blueswir1
317	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
318	ce5b3c3d	blueswir1	static inline void gen_cc_NZ_xcc(TCGv dst)
319	ce5b3c3d	blueswir1	{
320	ce5b3c3d	blueswir1	int l1, l2;
321	ce5b3c3d	blueswir1
322	ce5b3c3d	blueswir1	l1 = gen_new_label();
323	ce5b3c3d	blueswir1	l2 = gen_new_label();
324	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_NE, dst, 0, l1);
325	ce5b3c3d	blueswir1	tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_ZERO);
326	ce5b3c3d	blueswir1	gen_set_label(l1);
327	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_GE, dst, 0, l2);
328	ce5b3c3d	blueswir1	tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_NEG);
329	ce5b3c3d	blueswir1	gen_set_label(l2);
330	dc99a3f2	blueswir1	}
331	ce5b3c3d	blueswir1	#endif
332	dc99a3f2	blueswir1
333	dc99a3f2	blueswir1	/* old op:
334	dc99a3f2	blueswir1	if (T0 < src1)
335	dc99a3f2	blueswir1	env->psr \|= PSR_CARRY;
336	dc99a3f2	blueswir1	*/
337	ce5b3c3d	blueswir1	static inline void gen_cc_C_add_icc(TCGv dst, TCGv src1)
338	dc99a3f2	blueswir1	{
339	8911f501	blueswir1	TCGv r_temp;
340	dc99a3f2	blueswir1	int l1;
341	dc99a3f2	blueswir1
342	dc99a3f2	blueswir1	l1 = gen_new_label();
343	8911f501	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
344	8911f501	blueswir1	tcg_gen_andi_tl(r_temp, dst, 0xffffffffULL);
345	8911f501	blueswir1	tcg_gen_brcond_tl(TCG_COND_GEU, dst, src1, l1);
346	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_CARRY);
347	dc99a3f2	blueswir1	gen_set_label(l1);
348	2ea815ca	blueswir1	tcg_temp_free(r_temp);
349	ce5b3c3d	blueswir1	}
350	ce5b3c3d	blueswir1
351	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
352	ce5b3c3d	blueswir1	static inline void gen_cc_C_add_xcc(TCGv dst, TCGv src1)
353	ce5b3c3d	blueswir1	{
354	ce5b3c3d	blueswir1	int l1;
355	dc99a3f2	blueswir1
356	ce5b3c3d	blueswir1	l1 = gen_new_label();
357	ce5b3c3d	blueswir1	tcg_gen_brcond_tl(TCG_COND_GEU, dst, src1, l1);
358	ce5b3c3d	blueswir1	tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_CARRY);
359	ce5b3c3d	blueswir1	gen_set_label(l1);
360	dc99a3f2	blueswir1	}
361	ce5b3c3d	blueswir1	#endif
362	dc99a3f2	blueswir1
363	dc99a3f2	blueswir1	/* old op:
364	dc99a3f2	blueswir1	if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
365	dc99a3f2	blueswir1	env->psr \|= PSR_OVF;
366	dc99a3f2	blueswir1	*/
367	ce5b3c3d	blueswir1	static inline void gen_cc_V_add_icc(TCGv dst, TCGv src1, TCGv src2)
368	dc99a3f2	blueswir1	{
369	0425bee5	blueswir1	TCGv r_temp;
370	dc99a3f2	blueswir1
371	dc99a3f2	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
372	dc99a3f2	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
373	dc99a3f2	blueswir1	tcg_gen_xori_tl(r_temp, r_temp, -1);
374	0425bee5	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
375	0425bee5	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
376	0425bee5	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));
377	653ccb80	blueswir1	tcg_gen_shri_tl(r_temp, r_temp, 31 - PSR_OVF_SHIFT);
378	653ccb80	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, r_temp);
379	2ea815ca	blueswir1	tcg_temp_free(r_temp);
380	653ccb80	blueswir1	tcg_gen_or_i32(cpu_psr, cpu_psr, cpu_tmp32);
381	ce5b3c3d	blueswir1	}
382	ce5b3c3d	blueswir1
383	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
384	ce5b3c3d	blueswir1	static inline void gen_cc_V_add_xcc(TCGv dst, TCGv src1, TCGv src2)
385	ce5b3c3d	blueswir1	{
386	ce5b3c3d	blueswir1	TCGv r_temp;
387	ce5b3c3d	blueswir1
388	ce5b3c3d	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
389	ce5b3c3d	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
390	ce5b3c3d	blueswir1	tcg_gen_xori_tl(r_temp, r_temp, -1);
391	ce5b3c3d	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
392	ce5b3c3d	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
393	ce5b3c3d	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));
394	653ccb80	blueswir1	tcg_gen_shri_tl(r_temp, r_temp, 63 - PSR_OVF_SHIFT);
395	653ccb80	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, r_temp);
396	2ea815ca	blueswir1	tcg_temp_free(r_temp);
397	653ccb80	blueswir1	tcg_gen_or_i32(cpu_xcc, cpu_xcc, cpu_tmp32);
398	dc99a3f2	blueswir1	}
399	ce5b3c3d	blueswir1	#endif
400	dc99a3f2	blueswir1
401	dc99a3f2	blueswir1	static inline void gen_add_tv(TCGv dst, TCGv src1, TCGv src2)
402	dc99a3f2	blueswir1	{
403	2ea815ca	blueswir1	TCGv r_temp, r_const;
404	dc99a3f2	blueswir1	int l1;
405	dc99a3f2	blueswir1
406	dc99a3f2	blueswir1	l1 = gen_new_label();
407	dc99a3f2	blueswir1
408	dc99a3f2	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
409	dc99a3f2	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
410	dc99a3f2	blueswir1	tcg_gen_xori_tl(r_temp, r_temp, -1);
411	0425bee5	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
412	0425bee5	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
413	0425bee5	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));
414	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_temp, 0, l1);
415	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_TOVF);
416	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
417	2ea815ca	blueswir1	tcg_temp_free(r_const);
418	dc99a3f2	blueswir1	gen_set_label(l1);
419	2ea815ca	blueswir1	tcg_temp_free(r_temp);
420	dc99a3f2	blueswir1	}
421	dc99a3f2	blueswir1
422	dc99a3f2	blueswir1	static inline void gen_cc_V_tag(TCGv src1, TCGv src2)
423	dc99a3f2	blueswir1	{
424	dc99a3f2	blueswir1	int l1;
425	dc99a3f2	blueswir1
426	dc99a3f2	blueswir1	l1 = gen_new_label();
427	0425bee5	blueswir1	tcg_gen_or_tl(cpu_tmp0, src1, src2);
428	0425bee5	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0x3);
429	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
430	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);
431	dc99a3f2	blueswir1	gen_set_label(l1);
432	dc99a3f2	blueswir1	}
433	dc99a3f2	blueswir1
434	dc99a3f2	blueswir1	static inline void gen_tag_tv(TCGv src1, TCGv src2)
435	dc99a3f2	blueswir1	{
436	dc99a3f2	blueswir1	int l1;
437	2ea815ca	blueswir1	TCGv r_const;
438	dc99a3f2	blueswir1
439	dc99a3f2	blueswir1	l1 = gen_new_label();
440	0425bee5	blueswir1	tcg_gen_or_tl(cpu_tmp0, src1, src2);
441	0425bee5	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0x3);
442	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
443	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_TOVF);
444	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
445	2ea815ca	blueswir1	tcg_temp_free(r_const);
446	dc99a3f2	blueswir1	gen_set_label(l1);
447	dc99a3f2	blueswir1	}
448	dc99a3f2	blueswir1
449	4af984a7	blueswir1	static inline void gen_op_add_cc(TCGv dst, TCGv src1, TCGv src2)
450	dc99a3f2	blueswir1	{
451	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
452	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
453	4af984a7	blueswir1	tcg_gen_add_tl(dst, src1, src2);
454	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
455	ce5b3c3d	blueswir1	gen_cc_clear_icc();
456	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
457	ba28189b	blueswir1	gen_cc_C_add_icc(cpu_cc_dst, cpu_cc_src);
458	ba28189b	blueswir1	gen_cc_V_add_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
459	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
460	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
461	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
462	ba28189b	blueswir1	gen_cc_C_add_xcc(cpu_cc_dst, cpu_cc_src);
463	ba28189b	blueswir1	gen_cc_V_add_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
464	ce5b3c3d	blueswir1	#endif
465	dc99a3f2	blueswir1	}
466	dc99a3f2	blueswir1
467	4af984a7	blueswir1	static inline void gen_op_addx_cc(TCGv dst, TCGv src1, TCGv src2)
468	dc99a3f2	blueswir1	{
469	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
470	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
471	dc99a3f2	blueswir1	gen_mov_reg_C(cpu_tmp0, cpu_psr);
472	4af984a7	blueswir1	tcg_gen_add_tl(dst, src1, cpu_tmp0);
473	ce5b3c3d	blueswir1	gen_cc_clear_icc();
474	4af984a7	blueswir1	gen_cc_C_add_icc(dst, cpu_cc_src);
475	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
476	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
477	4af984a7	blueswir1	gen_cc_C_add_xcc(dst, cpu_cc_src);
478	ce5b3c3d	blueswir1	#endif
479	6f551262	blueswir1	tcg_gen_add_tl(dst, dst, cpu_cc_src2);
480	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
481	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
482	ba28189b	blueswir1	gen_cc_C_add_icc(cpu_cc_dst, cpu_cc_src);
483	ba28189b	blueswir1	gen_cc_V_add_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
484	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
485	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
486	ba28189b	blueswir1	gen_cc_C_add_xcc(cpu_cc_dst, cpu_cc_src);
487	ba28189b	blueswir1	gen_cc_V_add_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
488	ce5b3c3d	blueswir1	#endif
489	dc99a3f2	blueswir1	}
490	dc99a3f2	blueswir1
491	4af984a7	blueswir1	static inline void gen_op_tadd_cc(TCGv dst, TCGv src1, TCGv src2)
492	dc99a3f2	blueswir1	{
493	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
494	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
495	4af984a7	blueswir1	tcg_gen_add_tl(dst, src1, src2);
496	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
497	ce5b3c3d	blueswir1	gen_cc_clear_icc();
498	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
499	ba28189b	blueswir1	gen_cc_C_add_icc(cpu_cc_dst, cpu_cc_src);
500	ba28189b	blueswir1	gen_cc_V_add_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
501	6f551262	blueswir1	gen_cc_V_tag(cpu_cc_src, cpu_cc_src2);
502	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
503	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
504	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
505	ba28189b	blueswir1	gen_cc_C_add_xcc(cpu_cc_dst, cpu_cc_src);
506	ba28189b	blueswir1	gen_cc_V_add_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
507	ce5b3c3d	blueswir1	#endif
508	dc99a3f2	blueswir1	}
509	dc99a3f2	blueswir1
510	4af984a7	blueswir1	static inline void gen_op_tadd_ccTV(TCGv dst, TCGv src1, TCGv src2)
511	dc99a3f2	blueswir1	{
512	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
513	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
514	6f551262	blueswir1	gen_tag_tv(cpu_cc_src, cpu_cc_src2);
515	4af984a7	blueswir1	tcg_gen_add_tl(dst, src1, src2);
516	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
517	6f551262	blueswir1	gen_add_tv(dst, cpu_cc_src, cpu_cc_src2);
518	ce5b3c3d	blueswir1	gen_cc_clear_icc();
519	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
520	ba28189b	blueswir1	gen_cc_C_add_icc(cpu_cc_dst, cpu_cc_src);
521	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
522	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
523	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
524	ba28189b	blueswir1	gen_cc_C_add_xcc(cpu_cc_dst, cpu_cc_src);
525	ba28189b	blueswir1	gen_cc_V_add_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
526	ce5b3c3d	blueswir1	#endif
527	dc99a3f2	blueswir1	}
528	dc99a3f2	blueswir1
529	dc99a3f2	blueswir1	/* old op:
530	dc99a3f2	blueswir1	if (src1 < T1)
531	dc99a3f2	blueswir1	env->psr \|= PSR_CARRY;
532	dc99a3f2	blueswir1	*/
533	ce5b3c3d	blueswir1	static inline void gen_cc_C_sub_icc(TCGv src1, TCGv src2)
534	dc99a3f2	blueswir1	{
535	8911f501	blueswir1	TCGv r_temp1, r_temp2;
536	dc99a3f2	blueswir1	int l1;
537	dc99a3f2	blueswir1
538	dc99a3f2	blueswir1	l1 = gen_new_label();
539	8911f501	blueswir1	r_temp1 = tcg_temp_new(TCG_TYPE_TL);
540	8911f501	blueswir1	r_temp2 = tcg_temp_new(TCG_TYPE_TL);
541	8911f501	blueswir1	tcg_gen_andi_tl(r_temp1, src1, 0xffffffffULL);
542	8911f501	blueswir1	tcg_gen_andi_tl(r_temp2, src2, 0xffffffffULL);
543	8911f501	blueswir1	tcg_gen_brcond_tl(TCG_COND_GEU, r_temp1, r_temp2, l1);
544	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_CARRY);
545	dc99a3f2	blueswir1	gen_set_label(l1);
546	2ea815ca	blueswir1	tcg_temp_free(r_temp1);
547	2ea815ca	blueswir1	tcg_temp_free(r_temp2);
548	ce5b3c3d	blueswir1	}
549	ce5b3c3d	blueswir1
550	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
551	ce5b3c3d	blueswir1	static inline void gen_cc_C_sub_xcc(TCGv src1, TCGv src2)
552	ce5b3c3d	blueswir1	{
553	ce5b3c3d	blueswir1	int l1;
554	dc99a3f2	blueswir1
555	ce5b3c3d	blueswir1	l1 = gen_new_label();
556	ce5b3c3d	blueswir1	tcg_gen_brcond_tl(TCG_COND_GEU, src1, src2, l1);
557	ce5b3c3d	blueswir1	tcg_gen_ori_i32(cpu_xcc, cpu_xcc, PSR_CARRY);
558	ce5b3c3d	blueswir1	gen_set_label(l1);
559	dc99a3f2	blueswir1	}
560	ce5b3c3d	blueswir1	#endif
561	dc99a3f2	blueswir1
562	dc99a3f2	blueswir1	/* old op:
563	dc99a3f2	blueswir1	if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
564	dc99a3f2	blueswir1	env->psr \|= PSR_OVF;
565	dc99a3f2	blueswir1	*/
566	ce5b3c3d	blueswir1	static inline void gen_cc_V_sub_icc(TCGv dst, TCGv src1, TCGv src2)
567	dc99a3f2	blueswir1	{
568	0425bee5	blueswir1	TCGv r_temp;
569	dc99a3f2	blueswir1
570	dc99a3f2	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
571	dc99a3f2	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
572	0425bee5	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
573	0425bee5	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
574	0425bee5	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));
575	653ccb80	blueswir1	tcg_gen_shri_tl(r_temp, r_temp, 31 - PSR_OVF_SHIFT);
576	653ccb80	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, r_temp);
577	653ccb80	blueswir1	tcg_gen_or_i32(cpu_psr, cpu_psr, cpu_tmp32);
578	2ea815ca	blueswir1	tcg_temp_free(r_temp);
579	ce5b3c3d	blueswir1	}
580	ce5b3c3d	blueswir1
581	dc99a3f2	blueswir1	#ifdef TARGET_SPARC64
582	ce5b3c3d	blueswir1	static inline void gen_cc_V_sub_xcc(TCGv dst, TCGv src1, TCGv src2)
583	ce5b3c3d	blueswir1	{
584	ce5b3c3d	blueswir1	TCGv r_temp;
585	ce5b3c3d	blueswir1
586	ce5b3c3d	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
587	ce5b3c3d	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
588	ce5b3c3d	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
589	ce5b3c3d	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
590	ce5b3c3d	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1ULL << 63));
591	653ccb80	blueswir1	tcg_gen_shri_tl(r_temp, r_temp, 63 - PSR_OVF_SHIFT);
592	653ccb80	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, r_temp);
593	653ccb80	blueswir1	tcg_gen_or_i32(cpu_xcc, cpu_xcc, cpu_tmp32);
594	2ea815ca	blueswir1	tcg_temp_free(r_temp);
595	dc99a3f2	blueswir1	}
596	ce5b3c3d	blueswir1	#endif
597	dc99a3f2	blueswir1
598	dc99a3f2	blueswir1	static inline void gen_sub_tv(TCGv dst, TCGv src1, TCGv src2)
599	dc99a3f2	blueswir1	{
600	2ea815ca	blueswir1	TCGv r_temp, r_const;
601	dc99a3f2	blueswir1	int l1;
602	dc99a3f2	blueswir1
603	dc99a3f2	blueswir1	l1 = gen_new_label();
604	dc99a3f2	blueswir1
605	dc99a3f2	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
606	dc99a3f2	blueswir1	tcg_gen_xor_tl(r_temp, src1, src2);
607	0425bee5	blueswir1	tcg_gen_xor_tl(cpu_tmp0, src1, dst);
608	0425bee5	blueswir1	tcg_gen_and_tl(r_temp, r_temp, cpu_tmp0);
609	0425bee5	blueswir1	tcg_gen_andi_tl(r_temp, r_temp, (1 << 31));
610	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_temp, 0, l1);
611	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_TOVF);
612	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
613	2ea815ca	blueswir1	tcg_temp_free(r_const);
614	dc99a3f2	blueswir1	gen_set_label(l1);
615	2ea815ca	blueswir1	tcg_temp_free(r_temp);
616	dc99a3f2	blueswir1	}
617	dc99a3f2	blueswir1
618	4af984a7	blueswir1	static inline void gen_op_sub_cc(TCGv dst, TCGv src1, TCGv src2)
619	dc99a3f2	blueswir1	{
620	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
621	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
622	4af984a7	blueswir1	tcg_gen_sub_tl(dst, src1, src2);
623	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
624	ce5b3c3d	blueswir1	gen_cc_clear_icc();
625	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
626	6f551262	blueswir1	gen_cc_C_sub_icc(cpu_cc_src, cpu_cc_src2);
627	ba28189b	blueswir1	gen_cc_V_sub_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
628	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
629	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
630	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
631	6f551262	blueswir1	gen_cc_C_sub_xcc(cpu_cc_src, cpu_cc_src2);
632	ba28189b	blueswir1	gen_cc_V_sub_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
633	ce5b3c3d	blueswir1	#endif
634	dc99a3f2	blueswir1	}
635	dc99a3f2	blueswir1
636	4af984a7	blueswir1	static inline void gen_op_subx_cc(TCGv dst, TCGv src1, TCGv src2)
637	dc99a3f2	blueswir1	{
638	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
639	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
640	dc99a3f2	blueswir1	gen_mov_reg_C(cpu_tmp0, cpu_psr);
641	4af984a7	blueswir1	tcg_gen_sub_tl(dst, src1, cpu_tmp0);
642	ce5b3c3d	blueswir1	gen_cc_clear_icc();
643	4af984a7	blueswir1	gen_cc_C_sub_icc(dst, cpu_cc_src);
644	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
645	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
646	4af984a7	blueswir1	gen_cc_C_sub_xcc(dst, cpu_cc_src);
647	ce5b3c3d	blueswir1	#endif
648	6f551262	blueswir1	tcg_gen_sub_tl(dst, dst, cpu_cc_src2);
649	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
650	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
651	ba28189b	blueswir1	gen_cc_C_sub_icc(cpu_cc_dst, cpu_cc_src);
652	ba28189b	blueswir1	gen_cc_V_sub_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
653	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
654	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
655	ba28189b	blueswir1	gen_cc_C_sub_xcc(cpu_cc_dst, cpu_cc_src);
656	ba28189b	blueswir1	gen_cc_V_sub_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
657	ce5b3c3d	blueswir1	#endif
658	dc99a3f2	blueswir1	}
659	dc99a3f2	blueswir1
660	4af984a7	blueswir1	static inline void gen_op_tsub_cc(TCGv dst, TCGv src1, TCGv src2)
661	dc99a3f2	blueswir1	{
662	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
663	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
664	4af984a7	blueswir1	tcg_gen_sub_tl(dst, src1, src2);
665	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
666	ce5b3c3d	blueswir1	gen_cc_clear_icc();
667	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
668	6f551262	blueswir1	gen_cc_C_sub_icc(cpu_cc_src, cpu_cc_src2);
669	ba28189b	blueswir1	gen_cc_V_sub_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
670	6f551262	blueswir1	gen_cc_V_tag(cpu_cc_src, cpu_cc_src2);
671	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
672	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
673	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
674	6f551262	blueswir1	gen_cc_C_sub_xcc(cpu_cc_src, cpu_cc_src2);
675	ba28189b	blueswir1	gen_cc_V_sub_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
676	ce5b3c3d	blueswir1	#endif
677	dc99a3f2	blueswir1	}
678	dc99a3f2	blueswir1
679	4af984a7	blueswir1	static inline void gen_op_tsub_ccTV(TCGv dst, TCGv src1, TCGv src2)
680	dc99a3f2	blueswir1	{
681	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
682	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
683	6f551262	blueswir1	gen_tag_tv(cpu_cc_src, cpu_cc_src2);
684	4af984a7	blueswir1	tcg_gen_sub_tl(dst, src1, src2);
685	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
686	6f551262	blueswir1	gen_sub_tv(dst, cpu_cc_src, cpu_cc_src2);
687	ce5b3c3d	blueswir1	gen_cc_clear_icc();
688	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
689	6f551262	blueswir1	gen_cc_C_sub_icc(cpu_cc_src, cpu_cc_src2);
690	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
691	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
692	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
693	6f551262	blueswir1	gen_cc_C_sub_xcc(cpu_cc_src, cpu_cc_src2);
694	ba28189b	blueswir1	gen_cc_V_sub_xcc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
695	ce5b3c3d	blueswir1	#endif
696	dc99a3f2	blueswir1	}
697	dc99a3f2	blueswir1
698	4af984a7	blueswir1	static inline void gen_op_mulscc(TCGv dst, TCGv src1, TCGv src2)
699	d9bdab86	blueswir1	{
700	7127fe84	blueswir1	TCGv r_temp, r_temp2;
701	6f551262	blueswir1	int l1;
702	d9bdab86	blueswir1
703	d9bdab86	blueswir1	l1 = gen_new_label();
704	d9bdab86	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
705	7127fe84	blueswir1	r_temp2 = tcg_temp_new(TCG_TYPE_I32);
706	d9bdab86	blueswir1
707	d9bdab86	blueswir1	/* old op:
708	d9bdab86	blueswir1	if (!(env->y & 1))
709	d9bdab86	blueswir1	T1 = 0;
710	d9bdab86	blueswir1	*/
711	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
712	7127fe84	blueswir1	tcg_gen_ld32u_tl(r_temp, cpu_env, offsetof(CPUSPARCState, y));
713	7127fe84	blueswir1	tcg_gen_trunc_tl_i32(r_temp2, r_temp);
714	7127fe84	blueswir1	tcg_gen_andi_i32(r_temp2, r_temp2, 0x1);
715	4af984a7	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
716	cb63669a	pbrook	tcg_gen_brcondi_i32(TCG_COND_NE, r_temp2, 0, l1);
717	d9bdab86	blueswir1	tcg_gen_movi_tl(cpu_cc_src2, 0);
718	6f551262	blueswir1	gen_set_label(l1);
719	d9bdab86	blueswir1
720	d9bdab86	blueswir1	// b2 = T0 & 1;
721	d9bdab86	blueswir1	// env->y = (b2 << 31) \| (env->y >> 1);
722	6f551262	blueswir1	tcg_gen_trunc_tl_i32(r_temp2, cpu_cc_src);
723	7127fe84	blueswir1	tcg_gen_andi_i32(r_temp2, r_temp2, 0x1);
724	7127fe84	blueswir1	tcg_gen_shli_i32(r_temp2, r_temp2, 31);
725	8911f501	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, y));
726	8911f501	blueswir1	tcg_gen_shri_i32(cpu_tmp32, cpu_tmp32, 1);
727	7127fe84	blueswir1	tcg_gen_or_i32(cpu_tmp32, cpu_tmp32, r_temp2);
728	2ea815ca	blueswir1	tcg_temp_free(r_temp2);
729	8911f501	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env, offsetof(CPUSPARCState, y));
730	d9bdab86	blueswir1
731	d9bdab86	blueswir1	// b1 = N ^ V;
732	d9bdab86	blueswir1	gen_mov_reg_N(cpu_tmp0, cpu_psr);
733	d9bdab86	blueswir1	gen_mov_reg_V(r_temp, cpu_psr);
734	d9bdab86	blueswir1	tcg_gen_xor_tl(cpu_tmp0, cpu_tmp0, r_temp);
735	2ea815ca	blueswir1	tcg_temp_free(r_temp);
736	d9bdab86	blueswir1
737	d9bdab86	blueswir1	// T0 = (b1 << 31) \| (T0 >> 1);
738	d9bdab86	blueswir1	// src1 = T0;
739	d9bdab86	blueswir1	tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, 31);
740	6f551262	blueswir1	tcg_gen_shri_tl(cpu_cc_src, cpu_cc_src, 1);
741	d9bdab86	blueswir1	tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_tmp0);
742	d9bdab86	blueswir1
743	d9bdab86	blueswir1	/* do addition and update flags */
744	4af984a7	blueswir1	tcg_gen_add_tl(dst, cpu_cc_src, cpu_cc_src2);
745	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
746	d9bdab86	blueswir1
747	ce5b3c3d	blueswir1	gen_cc_clear_icc();
748	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
749	ba28189b	blueswir1	gen_cc_V_add_icc(cpu_cc_dst, cpu_cc_src, cpu_cc_src2);
750	ba28189b	blueswir1	gen_cc_C_add_icc(cpu_cc_dst, cpu_cc_src);
751	d9bdab86	blueswir1	}
752	d9bdab86	blueswir1
753	4af984a7	blueswir1	static inline void gen_op_umul(TCGv dst, TCGv src1, TCGv src2)
754	8879d139	blueswir1	{
755	8879d139	blueswir1	TCGv r_temp, r_temp2;
756	8879d139	blueswir1
757	8879d139	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_I64);
758	8879d139	blueswir1	r_temp2 = tcg_temp_new(TCG_TYPE_I64);
759	8879d139	blueswir1
760	4af984a7	blueswir1	tcg_gen_extu_tl_i64(r_temp, src2);
761	4af984a7	blueswir1	tcg_gen_extu_tl_i64(r_temp2, src1);
762	8879d139	blueswir1	tcg_gen_mul_i64(r_temp2, r_temp, r_temp2);
763	8879d139	blueswir1
764	8879d139	blueswir1	tcg_gen_shri_i64(r_temp, r_temp2, 32);
765	8879d139	blueswir1	tcg_gen_trunc_i64_i32(r_temp, r_temp);
766	8879d139	blueswir1	tcg_gen_st_i32(r_temp, cpu_env, offsetof(CPUSPARCState, y));
767	2ea815ca	blueswir1	tcg_temp_free(r_temp);
768	8879d139	blueswir1	#ifdef TARGET_SPARC64
769	4af984a7	blueswir1	tcg_gen_mov_i64(dst, r_temp2);
770	8879d139	blueswir1	#else
771	4af984a7	blueswir1	tcg_gen_trunc_i64_tl(dst, r_temp2);
772	8879d139	blueswir1	#endif
773	2ea815ca	blueswir1	tcg_temp_free(r_temp2);
774	8879d139	blueswir1	}
775	8879d139	blueswir1
776	4af984a7	blueswir1	static inline void gen_op_smul(TCGv dst, TCGv src1, TCGv src2)
777	8879d139	blueswir1	{
778	8879d139	blueswir1	TCGv r_temp, r_temp2;
779	8879d139	blueswir1
780	8879d139	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_I64);
781	8879d139	blueswir1	r_temp2 = tcg_temp_new(TCG_TYPE_I64);
782	8879d139	blueswir1
783	4af984a7	blueswir1	tcg_gen_ext_tl_i64(r_temp, src2);
784	4af984a7	blueswir1	tcg_gen_ext_tl_i64(r_temp2, src1);
785	8879d139	blueswir1	tcg_gen_mul_i64(r_temp2, r_temp, r_temp2);
786	8879d139	blueswir1
787	8879d139	blueswir1	tcg_gen_shri_i64(r_temp, r_temp2, 32);
788	8879d139	blueswir1	tcg_gen_trunc_i64_i32(r_temp, r_temp);
789	8879d139	blueswir1	tcg_gen_st_i32(r_temp, cpu_env, offsetof(CPUSPARCState, y));
790	2ea815ca	blueswir1	tcg_temp_free(r_temp);
791	8879d139	blueswir1	#ifdef TARGET_SPARC64
792	4af984a7	blueswir1	tcg_gen_mov_i64(dst, r_temp2);
793	8879d139	blueswir1	#else
794	4af984a7	blueswir1	tcg_gen_trunc_i64_tl(dst, r_temp2);
795	8879d139	blueswir1	#endif
796	2ea815ca	blueswir1	tcg_temp_free(r_temp2);
797	8879d139	blueswir1	}
798	8879d139	blueswir1
799	1a7b60e7	blueswir1	#ifdef TARGET_SPARC64
800	8911f501	blueswir1	static inline void gen_trap_ifdivzero_tl(TCGv divisor)
801	1a7b60e7	blueswir1	{
802	2ea815ca	blueswir1	TCGv r_const;
803	1a7b60e7	blueswir1	int l1;
804	1a7b60e7	blueswir1
805	1a7b60e7	blueswir1	l1 = gen_new_label();
806	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_NE, divisor, 0, l1);
807	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_DIV_ZERO);
808	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
809	2ea815ca	blueswir1	tcg_temp_free(r_const);
810	1a7b60e7	blueswir1	gen_set_label(l1);
811	1a7b60e7	blueswir1	}
812	1a7b60e7	blueswir1
813	4af984a7	blueswir1	static inline void gen_op_sdivx(TCGv dst, TCGv src1, TCGv src2)
814	1a7b60e7	blueswir1	{
815	1a7b60e7	blueswir1	int l1, l2;
816	1a7b60e7	blueswir1
817	1a7b60e7	blueswir1	l1 = gen_new_label();
818	1a7b60e7	blueswir1	l2 = gen_new_label();
819	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src, src1);
820	6f551262	blueswir1	tcg_gen_mov_tl(cpu_cc_src2, src2);
821	4af984a7	blueswir1	gen_trap_ifdivzero_tl(src2);
822	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, l1);
823	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src2, -1, l1);
824	4af984a7	blueswir1	tcg_gen_movi_i64(dst, INT64_MIN);
825	06b3e1b3	blueswir1	tcg_gen_br(l2);
826	1a7b60e7	blueswir1	gen_set_label(l1);
827	6f551262	blueswir1	tcg_gen_div_i64(dst, cpu_cc_src, cpu_cc_src2);
828	1a7b60e7	blueswir1	gen_set_label(l2);
829	1a7b60e7	blueswir1	}
830	1a7b60e7	blueswir1	#endif
831	1a7b60e7	blueswir1
832	4af984a7	blueswir1	static inline void gen_op_div_cc(TCGv dst)
833	dc99a3f2	blueswir1	{
834	dc99a3f2	blueswir1	int l1;
835	dc99a3f2	blueswir1
836	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
837	ce5b3c3d	blueswir1	gen_cc_clear_icc();
838	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
839	dc99a3f2	blueswir1	l1 = gen_new_label();
840	3b89f26c	blueswir1	tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUSPARCState, cc_src2));
841	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
842	dc99a3f2	blueswir1	tcg_gen_ori_i32(cpu_psr, cpu_psr, PSR_OVF);
843	dc99a3f2	blueswir1	gen_set_label(l1);
844	dc99a3f2	blueswir1	}
845	dc99a3f2	blueswir1
846	4af984a7	blueswir1	static inline void gen_op_logic_cc(TCGv dst)
847	dc99a3f2	blueswir1	{
848	ba28189b	blueswir1	tcg_gen_mov_tl(cpu_cc_dst, dst);
849	ba28189b	blueswir1
850	ce5b3c3d	blueswir1	gen_cc_clear_icc();
851	ba28189b	blueswir1	gen_cc_NZ_icc(cpu_cc_dst);
852	ce5b3c3d	blueswir1	#ifdef TARGET_SPARC64
853	ce5b3c3d	blueswir1	gen_cc_clear_xcc();
854	ba28189b	blueswir1	gen_cc_NZ_xcc(cpu_cc_dst);
855	ce5b3c3d	blueswir1	#endif
856	dc99a3f2	blueswir1	}
857	dc99a3f2	blueswir1
858	19f329ad	blueswir1	// 1
859	19f329ad	blueswir1	static inline void gen_op_eval_ba(TCGv dst)
860	19f329ad	blueswir1	{
861	19f329ad	blueswir1	tcg_gen_movi_tl(dst, 1);
862	19f329ad	blueswir1	}
863	19f329ad	blueswir1
864	19f329ad	blueswir1	// Z
865	19f329ad	blueswir1	static inline void gen_op_eval_be(TCGv dst, TCGv src)
866	19f329ad	blueswir1	{
867	19f329ad	blueswir1	gen_mov_reg_Z(dst, src);
868	19f329ad	blueswir1	}
869	19f329ad	blueswir1
870	19f329ad	blueswir1	// Z \| (N ^ V)
871	19f329ad	blueswir1	static inline void gen_op_eval_ble(TCGv dst, TCGv src)
872	19f329ad	blueswir1	{
873	0425bee5	blueswir1	gen_mov_reg_N(cpu_tmp0, src);
874	19f329ad	blueswir1	gen_mov_reg_V(dst, src);
875	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
876	0425bee5	blueswir1	gen_mov_reg_Z(cpu_tmp0, src);
877	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
878	19f329ad	blueswir1	}
879	19f329ad	blueswir1
880	19f329ad	blueswir1	// N ^ V
881	19f329ad	blueswir1	static inline void gen_op_eval_bl(TCGv dst, TCGv src)
882	19f329ad	blueswir1	{
883	0425bee5	blueswir1	gen_mov_reg_V(cpu_tmp0, src);
884	19f329ad	blueswir1	gen_mov_reg_N(dst, src);
885	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
886	19f329ad	blueswir1	}
887	19f329ad	blueswir1
888	19f329ad	blueswir1	// C \| Z
889	19f329ad	blueswir1	static inline void gen_op_eval_bleu(TCGv dst, TCGv src)
890	19f329ad	blueswir1	{
891	0425bee5	blueswir1	gen_mov_reg_Z(cpu_tmp0, src);
892	19f329ad	blueswir1	gen_mov_reg_C(dst, src);
893	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
894	19f329ad	blueswir1	}
895	19f329ad	blueswir1
896	19f329ad	blueswir1	// C
897	19f329ad	blueswir1	static inline void gen_op_eval_bcs(TCGv dst, TCGv src)
898	19f329ad	blueswir1	{
899	19f329ad	blueswir1	gen_mov_reg_C(dst, src);
900	19f329ad	blueswir1	}
901	19f329ad	blueswir1
902	19f329ad	blueswir1	// V
903	19f329ad	blueswir1	static inline void gen_op_eval_bvs(TCGv dst, TCGv src)
904	19f329ad	blueswir1	{
905	19f329ad	blueswir1	gen_mov_reg_V(dst, src);
906	19f329ad	blueswir1	}
907	19f329ad	blueswir1
908	19f329ad	blueswir1	// 0
909	19f329ad	blueswir1	static inline void gen_op_eval_bn(TCGv dst)
910	19f329ad	blueswir1	{
911	19f329ad	blueswir1	tcg_gen_movi_tl(dst, 0);
912	19f329ad	blueswir1	}
913	19f329ad	blueswir1
914	19f329ad	blueswir1	// N
915	19f329ad	blueswir1	static inline void gen_op_eval_bneg(TCGv dst, TCGv src)
916	19f329ad	blueswir1	{
917	19f329ad	blueswir1	gen_mov_reg_N(dst, src);
918	19f329ad	blueswir1	}
919	19f329ad	blueswir1
920	19f329ad	blueswir1	// !Z
921	19f329ad	blueswir1	static inline void gen_op_eval_bne(TCGv dst, TCGv src)
922	19f329ad	blueswir1	{
923	19f329ad	blueswir1	gen_mov_reg_Z(dst, src);
924	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
925	19f329ad	blueswir1	}
926	19f329ad	blueswir1
927	19f329ad	blueswir1	// !(Z \| (N ^ V))
928	19f329ad	blueswir1	static inline void gen_op_eval_bg(TCGv dst, TCGv src)
929	19f329ad	blueswir1	{
930	0425bee5	blueswir1	gen_mov_reg_N(cpu_tmp0, src);
931	19f329ad	blueswir1	gen_mov_reg_V(dst, src);
932	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
933	0425bee5	blueswir1	gen_mov_reg_Z(cpu_tmp0, src);
934	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
935	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
936	19f329ad	blueswir1	}
937	19f329ad	blueswir1
938	19f329ad	blueswir1	// !(N ^ V)
939	19f329ad	blueswir1	static inline void gen_op_eval_bge(TCGv dst, TCGv src)
940	19f329ad	blueswir1	{
941	0425bee5	blueswir1	gen_mov_reg_V(cpu_tmp0, src);
942	19f329ad	blueswir1	gen_mov_reg_N(dst, src);
943	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
944	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
945	19f329ad	blueswir1	}
946	19f329ad	blueswir1
947	19f329ad	blueswir1	// !(C \| Z)
948	19f329ad	blueswir1	static inline void gen_op_eval_bgu(TCGv dst, TCGv src)
949	19f329ad	blueswir1	{
950	0425bee5	blueswir1	gen_mov_reg_Z(cpu_tmp0, src);
951	19f329ad	blueswir1	gen_mov_reg_C(dst, src);
952	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
953	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
954	19f329ad	blueswir1	}
955	19f329ad	blueswir1
956	19f329ad	blueswir1	// !C
957	19f329ad	blueswir1	static inline void gen_op_eval_bcc(TCGv dst, TCGv src)
958	19f329ad	blueswir1	{
959	19f329ad	blueswir1	gen_mov_reg_C(dst, src);
960	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
961	19f329ad	blueswir1	}
962	19f329ad	blueswir1
963	19f329ad	blueswir1	// !N
964	19f329ad	blueswir1	static inline void gen_op_eval_bpos(TCGv dst, TCGv src)
965	19f329ad	blueswir1	{
966	19f329ad	blueswir1	gen_mov_reg_N(dst, src);
967	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
968	19f329ad	blueswir1	}
969	19f329ad	blueswir1
970	19f329ad	blueswir1	// !V
971	19f329ad	blueswir1	static inline void gen_op_eval_bvc(TCGv dst, TCGv src)
972	19f329ad	blueswir1	{
973	19f329ad	blueswir1	gen_mov_reg_V(dst, src);
974	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
975	19f329ad	blueswir1	}
976	19f329ad	blueswir1
977	19f329ad	blueswir1	/*
978	19f329ad	blueswir1	FPSR bit field FCC1 \| FCC0:
979	19f329ad	blueswir1	0 =
980	19f329ad	blueswir1	1 <
981	19f329ad	blueswir1	2 >
982	19f329ad	blueswir1	3 unordered
983	19f329ad	blueswir1	*/
984	19f329ad	blueswir1	static inline void gen_mov_reg_FCC0(TCGv reg, TCGv src,
985	19f329ad	blueswir1	unsigned int fcc_offset)
986	19f329ad	blueswir1	{
987	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
988	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, FSR_FCC0_SHIFT + fcc_offset);
989	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
990	19f329ad	blueswir1	}
991	19f329ad	blueswir1
992	19f329ad	blueswir1	static inline void gen_mov_reg_FCC1(TCGv reg, TCGv src,
993	19f329ad	blueswir1	unsigned int fcc_offset)
994	19f329ad	blueswir1	{
995	8911f501	blueswir1	tcg_gen_extu_i32_tl(reg, src);
996	4b8b8b76	blueswir1	tcg_gen_shri_tl(reg, reg, FSR_FCC1_SHIFT + fcc_offset);
997	19f329ad	blueswir1	tcg_gen_andi_tl(reg, reg, 0x1);
998	19f329ad	blueswir1	}
999	19f329ad	blueswir1
1000	19f329ad	blueswir1	// !0: FCC0 \| FCC1
1001	19f329ad	blueswir1	static inline void gen_op_eval_fbne(TCGv dst, TCGv src,
1002	19f329ad	blueswir1	unsigned int fcc_offset)
1003	19f329ad	blueswir1	{
1004	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1005	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1006	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
1007	19f329ad	blueswir1	}
1008	19f329ad	blueswir1
1009	19f329ad	blueswir1	// 1 or 2: FCC0 ^ FCC1
1010	19f329ad	blueswir1	static inline void gen_op_eval_fblg(TCGv dst, TCGv src,
1011	19f329ad	blueswir1	unsigned int fcc_offset)
1012	19f329ad	blueswir1	{
1013	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1014	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1015	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
1016	19f329ad	blueswir1	}
1017	19f329ad	blueswir1
1018	19f329ad	blueswir1	// 1 or 3: FCC0
1019	19f329ad	blueswir1	static inline void gen_op_eval_fbul(TCGv dst, TCGv src,
1020	19f329ad	blueswir1	unsigned int fcc_offset)
1021	19f329ad	blueswir1	{
1022	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1023	19f329ad	blueswir1	}
1024	19f329ad	blueswir1
1025	19f329ad	blueswir1	// 1: FCC0 & !FCC1
1026	19f329ad	blueswir1	static inline void gen_op_eval_fbl(TCGv dst, TCGv src,
1027	19f329ad	blueswir1	unsigned int fcc_offset)
1028	19f329ad	blueswir1	{
1029	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1030	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1031	0425bee5	blueswir1	tcg_gen_xori_tl(cpu_tmp0, cpu_tmp0, 0x1);
1032	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1033	19f329ad	blueswir1	}
1034	19f329ad	blueswir1
1035	19f329ad	blueswir1	// 2 or 3: FCC1
1036	19f329ad	blueswir1	static inline void gen_op_eval_fbug(TCGv dst, TCGv src,
1037	19f329ad	blueswir1	unsigned int fcc_offset)
1038	19f329ad	blueswir1	{
1039	19f329ad	blueswir1	gen_mov_reg_FCC1(dst, src, fcc_offset);
1040	19f329ad	blueswir1	}
1041	19f329ad	blueswir1
1042	19f329ad	blueswir1	// 2: !FCC0 & FCC1
1043	19f329ad	blueswir1	static inline void gen_op_eval_fbg(TCGv dst, TCGv src,
1044	19f329ad	blueswir1	unsigned int fcc_offset)
1045	19f329ad	blueswir1	{
1046	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1047	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1048	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1049	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1050	19f329ad	blueswir1	}
1051	19f329ad	blueswir1
1052	19f329ad	blueswir1	// 3: FCC0 & FCC1
1053	19f329ad	blueswir1	static inline void gen_op_eval_fbu(TCGv dst, TCGv src,
1054	19f329ad	blueswir1	unsigned int fcc_offset)
1055	19f329ad	blueswir1	{
1056	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1057	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1058	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1059	19f329ad	blueswir1	}
1060	19f329ad	blueswir1
1061	19f329ad	blueswir1	// 0: !(FCC0 \| FCC1)
1062	19f329ad	blueswir1	static inline void gen_op_eval_fbe(TCGv dst, TCGv src,
1063	19f329ad	blueswir1	unsigned int fcc_offset)
1064	19f329ad	blueswir1	{
1065	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1066	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1067	0425bee5	blueswir1	tcg_gen_or_tl(dst, dst, cpu_tmp0);
1068	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1069	19f329ad	blueswir1	}
1070	19f329ad	blueswir1
1071	19f329ad	blueswir1	// 0 or 3: !(FCC0 ^ FCC1)
1072	19f329ad	blueswir1	static inline void gen_op_eval_fbue(TCGv dst, TCGv src,
1073	19f329ad	blueswir1	unsigned int fcc_offset)
1074	19f329ad	blueswir1	{
1075	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1076	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1077	0425bee5	blueswir1	tcg_gen_xor_tl(dst, dst, cpu_tmp0);
1078	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1079	19f329ad	blueswir1	}
1080	19f329ad	blueswir1
1081	19f329ad	blueswir1	// 0 or 2: !FCC0
1082	19f329ad	blueswir1	static inline void gen_op_eval_fbge(TCGv dst, TCGv src,
1083	19f329ad	blueswir1	unsigned int fcc_offset)
1084	19f329ad	blueswir1	{
1085	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1086	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1087	19f329ad	blueswir1	}
1088	19f329ad	blueswir1
1089	19f329ad	blueswir1	// !1: !(FCC0 & !FCC1)
1090	19f329ad	blueswir1	static inline void gen_op_eval_fbuge(TCGv dst, TCGv src,
1091	19f329ad	blueswir1	unsigned int fcc_offset)
1092	19f329ad	blueswir1	{
1093	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1094	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1095	0425bee5	blueswir1	tcg_gen_xori_tl(cpu_tmp0, cpu_tmp0, 0x1);
1096	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1097	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1098	19f329ad	blueswir1	}
1099	19f329ad	blueswir1
1100	19f329ad	blueswir1	// 0 or 1: !FCC1
1101	19f329ad	blueswir1	static inline void gen_op_eval_fble(TCGv dst, TCGv src,
1102	19f329ad	blueswir1	unsigned int fcc_offset)
1103	19f329ad	blueswir1	{
1104	19f329ad	blueswir1	gen_mov_reg_FCC1(dst, src, fcc_offset);
1105	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1106	19f329ad	blueswir1	}
1107	19f329ad	blueswir1
1108	19f329ad	blueswir1	// !2: !(!FCC0 & FCC1)
1109	19f329ad	blueswir1	static inline void gen_op_eval_fbule(TCGv dst, TCGv src,
1110	19f329ad	blueswir1	unsigned int fcc_offset)
1111	19f329ad	blueswir1	{
1112	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1113	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1114	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1115	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1116	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1117	19f329ad	blueswir1	}
1118	19f329ad	blueswir1
1119	19f329ad	blueswir1	// !3: !(FCC0 & FCC1)
1120	19f329ad	blueswir1	static inline void gen_op_eval_fbo(TCGv dst, TCGv src,
1121	19f329ad	blueswir1	unsigned int fcc_offset)
1122	19f329ad	blueswir1	{
1123	19f329ad	blueswir1	gen_mov_reg_FCC0(dst, src, fcc_offset);
1124	0425bee5	blueswir1	gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
1125	0425bee5	blueswir1	tcg_gen_and_tl(dst, dst, cpu_tmp0);
1126	19f329ad	blueswir1	tcg_gen_xori_tl(dst, dst, 0x1);
1127	19f329ad	blueswir1	}
1128	19f329ad	blueswir1
1129	46525e1f	blueswir1	static inline void gen_branch2(DisasContext *dc, target_ulong pc1,
1130	19f329ad	blueswir1	target_ulong pc2, TCGv r_cond)
1131	83469015	bellard	{
1132	83469015	bellard	int l1;
1133	83469015	bellard
1134	83469015	bellard	l1 = gen_new_label();
1135	83469015	bellard
1136	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, 0, l1);
1137	83469015	bellard
1138	6e256c93	bellard	gen_goto_tb(dc, 0, pc1, pc1 + 4);
1139	83469015	bellard
1140	83469015	bellard	gen_set_label(l1);
1141	6e256c93	bellard	gen_goto_tb(dc, 1, pc2, pc2 + 4);
1142	83469015	bellard	}
1143	83469015	bellard
1144	46525e1f	blueswir1	static inline void gen_branch_a(DisasContext *dc, target_ulong pc1,
1145	19f329ad	blueswir1	target_ulong pc2, TCGv r_cond)
1146	83469015	bellard	{
1147	83469015	bellard	int l1;
1148	83469015	bellard
1149	83469015	bellard	l1 = gen_new_label();
1150	83469015	bellard
1151	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, 0, l1);
1152	83469015	bellard
1153	6e256c93	bellard	gen_goto_tb(dc, 0, pc2, pc1);
1154	83469015	bellard
1155	83469015	bellard	gen_set_label(l1);
1156	6e256c93	bellard	gen_goto_tb(dc, 1, pc2 + 4, pc2 + 8);
1157	83469015	bellard	}
1158	83469015	bellard
1159	19f329ad	blueswir1	static inline void gen_generic_branch(target_ulong npc1, target_ulong npc2,
1160	19f329ad	blueswir1	TCGv r_cond)
1161	83469015	bellard	{
1162	83469015	bellard	int l1, l2;
1163	83469015	bellard
1164	83469015	bellard	l1 = gen_new_label();
1165	83469015	bellard	l2 = gen_new_label();
1166	19f329ad	blueswir1
1167	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, 0, l1);
1168	83469015	bellard
1169	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_npc, npc1);
1170	06b3e1b3	blueswir1	tcg_gen_br(l2);
1171	83469015	bellard
1172	83469015	bellard	gen_set_label(l1);
1173	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_npc, npc2);
1174	83469015	bellard	gen_set_label(l2);
1175	83469015	bellard	}
1176	83469015	bellard
1177	4af984a7	blueswir1	/* call this function before using the condition register as it may
1178	4af984a7	blueswir1	have been set for a jump */
1179	4af984a7	blueswir1	static inline void flush_cond(DisasContext *dc, TCGv cond)
1180	83469015	bellard	{
1181	83469015	bellard	if (dc->npc == JUMP_PC) {
1182	4af984a7	blueswir1	gen_generic_branch(dc->jump_pc[0], dc->jump_pc[1], cond);
1183	83469015	bellard	dc->npc = DYNAMIC_PC;
1184	83469015	bellard	}
1185	83469015	bellard	}
1186	83469015	bellard
1187	4af984a7	blueswir1	static inline void save_npc(DisasContext *dc, TCGv cond)
1188	72cbca10	bellard	{
1189	72cbca10	bellard	if (dc->npc == JUMP_PC) {
1190	4af984a7	blueswir1	gen_generic_branch(dc->jump_pc[0], dc->jump_pc[1], cond);
1191	72cbca10	bellard	dc->npc = DYNAMIC_PC;
1192	72cbca10	bellard	} else if (dc->npc != DYNAMIC_PC) {
1193	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_npc, dc->npc);
1194	72cbca10	bellard	}
1195	72cbca10	bellard	}
1196	72cbca10	bellard
1197	4af984a7	blueswir1	static inline void save_state(DisasContext *dc, TCGv cond)
1198	72cbca10	bellard	{
1199	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_pc, dc->pc);
1200	4af984a7	blueswir1	save_npc(dc, cond);
1201	72cbca10	bellard	}
1202	72cbca10	bellard
1203	4af984a7	blueswir1	static inline void gen_mov_pc_npc(DisasContext *dc, TCGv cond)
1204	0bee699e	bellard	{
1205	0bee699e	bellard	if (dc->npc == JUMP_PC) {
1206	4af984a7	blueswir1	gen_generic_branch(dc->jump_pc[0], dc->jump_pc[1], cond);
1207	48d5c82b	blueswir1	tcg_gen_mov_tl(cpu_pc, cpu_npc);
1208	0bee699e	bellard	dc->pc = DYNAMIC_PC;
1209	0bee699e	bellard	} else if (dc->npc == DYNAMIC_PC) {
1210	48d5c82b	blueswir1	tcg_gen_mov_tl(cpu_pc, cpu_npc);
1211	0bee699e	bellard	dc->pc = DYNAMIC_PC;
1212	0bee699e	bellard	} else {
1213	0bee699e	bellard	dc->pc = dc->npc;
1214	0bee699e	bellard	}
1215	0bee699e	bellard	}
1216	0bee699e	bellard
1217	38bc628b	blueswir1	static inline void gen_op_next_insn(void)
1218	38bc628b	blueswir1	{
1219	48d5c82b	blueswir1	tcg_gen_mov_tl(cpu_pc, cpu_npc);
1220	48d5c82b	blueswir1	tcg_gen_addi_tl(cpu_npc, cpu_npc, 4);
1221	38bc628b	blueswir1	}
1222	38bc628b	blueswir1
1223	19f329ad	blueswir1	static inline void gen_cond(TCGv r_dst, unsigned int cc, unsigned int cond)
1224	19f329ad	blueswir1	{
1225	19f329ad	blueswir1	TCGv r_src;
1226	3475187d	bellard
1227	3475187d	bellard	#ifdef TARGET_SPARC64
1228	19f329ad	blueswir1	if (cc)
1229	dc99a3f2	blueswir1	r_src = cpu_xcc;
1230	19f329ad	blueswir1	else
1231	dc99a3f2	blueswir1	r_src = cpu_psr;
1232	3475187d	bellard	#else
1233	dc99a3f2	blueswir1	r_src = cpu_psr;
1234	3475187d	bellard	#endif
1235	19f329ad	blueswir1	switch (cond) {
1236	19f329ad	blueswir1	case 0x0:
1237	19f329ad	blueswir1	gen_op_eval_bn(r_dst);
1238	19f329ad	blueswir1	break;
1239	19f329ad	blueswir1	case 0x1:
1240	19f329ad	blueswir1	gen_op_eval_be(r_dst, r_src);
1241	19f329ad	blueswir1	break;
1242	19f329ad	blueswir1	case 0x2:
1243	19f329ad	blueswir1	gen_op_eval_ble(r_dst, r_src);
1244	19f329ad	blueswir1	break;
1245	19f329ad	blueswir1	case 0x3:
1246	19f329ad	blueswir1	gen_op_eval_bl(r_dst, r_src);
1247	19f329ad	blueswir1	break;
1248	19f329ad	blueswir1	case 0x4:
1249	19f329ad	blueswir1	gen_op_eval_bleu(r_dst, r_src);
1250	19f329ad	blueswir1	break;
1251	19f329ad	blueswir1	case 0x5:
1252	19f329ad	blueswir1	gen_op_eval_bcs(r_dst, r_src);
1253	19f329ad	blueswir1	break;
1254	19f329ad	blueswir1	case 0x6:
1255	19f329ad	blueswir1	gen_op_eval_bneg(r_dst, r_src);
1256	19f329ad	blueswir1	break;
1257	19f329ad	blueswir1	case 0x7:
1258	19f329ad	blueswir1	gen_op_eval_bvs(r_dst, r_src);
1259	19f329ad	blueswir1	break;
1260	19f329ad	blueswir1	case 0x8:
1261	19f329ad	blueswir1	gen_op_eval_ba(r_dst);
1262	19f329ad	blueswir1	break;
1263	19f329ad	blueswir1	case 0x9:
1264	19f329ad	blueswir1	gen_op_eval_bne(r_dst, r_src);
1265	19f329ad	blueswir1	break;
1266	19f329ad	blueswir1	case 0xa:
1267	19f329ad	blueswir1	gen_op_eval_bg(r_dst, r_src);
1268	19f329ad	blueswir1	break;
1269	19f329ad	blueswir1	case 0xb:
1270	19f329ad	blueswir1	gen_op_eval_bge(r_dst, r_src);
1271	19f329ad	blueswir1	break;
1272	19f329ad	blueswir1	case 0xc:
1273	19f329ad	blueswir1	gen_op_eval_bgu(r_dst, r_src);
1274	19f329ad	blueswir1	break;
1275	19f329ad	blueswir1	case 0xd:
1276	19f329ad	blueswir1	gen_op_eval_bcc(r_dst, r_src);
1277	19f329ad	blueswir1	break;
1278	19f329ad	blueswir1	case 0xe:
1279	19f329ad	blueswir1	gen_op_eval_bpos(r_dst, r_src);
1280	19f329ad	blueswir1	break;
1281	19f329ad	blueswir1	case 0xf:
1282	19f329ad	blueswir1	gen_op_eval_bvc(r_dst, r_src);
1283	19f329ad	blueswir1	break;
1284	19f329ad	blueswir1	}
1285	19f329ad	blueswir1	}
1286	7a3f1944	bellard
1287	19f329ad	blueswir1	static inline void gen_fcond(TCGv r_dst, unsigned int cc, unsigned int cond)
1288	e8af50a3	bellard	{
1289	19f329ad	blueswir1	unsigned int offset;
1290	19f329ad	blueswir1
1291	19f329ad	blueswir1	switch (cc) {
1292	19f329ad	blueswir1	default:
1293	19f329ad	blueswir1	case 0x0:
1294	19f329ad	blueswir1	offset = 0;
1295	19f329ad	blueswir1	break;
1296	19f329ad	blueswir1	case 0x1:
1297	19f329ad	blueswir1	offset = 32 - 10;
1298	19f329ad	blueswir1	break;
1299	19f329ad	blueswir1	case 0x2:
1300	19f329ad	blueswir1	offset = 34 - 10;
1301	19f329ad	blueswir1	break;
1302	19f329ad	blueswir1	case 0x3:
1303	19f329ad	blueswir1	offset = 36 - 10;
1304	19f329ad	blueswir1	break;
1305	19f329ad	blueswir1	}
1306	19f329ad	blueswir1
1307	19f329ad	blueswir1	switch (cond) {
1308	19f329ad	blueswir1	case 0x0:
1309	19f329ad	blueswir1	gen_op_eval_bn(r_dst);
1310	19f329ad	blueswir1	break;
1311	19f329ad	blueswir1	case 0x1:
1312	87e92502	blueswir1	gen_op_eval_fbne(r_dst, cpu_fsr, offset);
1313	19f329ad	blueswir1	break;
1314	19f329ad	blueswir1	case 0x2:
1315	87e92502	blueswir1	gen_op_eval_fblg(r_dst, cpu_fsr, offset);
1316	19f329ad	blueswir1	break;
1317	19f329ad	blueswir1	case 0x3:
1318	87e92502	blueswir1	gen_op_eval_fbul(r_dst, cpu_fsr, offset);
1319	19f329ad	blueswir1	break;
1320	19f329ad	blueswir1	case 0x4:
1321	87e92502	blueswir1	gen_op_eval_fbl(r_dst, cpu_fsr, offset);
1322	19f329ad	blueswir1	break;
1323	19f329ad	blueswir1	case 0x5:
1324	87e92502	blueswir1	gen_op_eval_fbug(r_dst, cpu_fsr, offset);
1325	19f329ad	blueswir1	break;
1326	19f329ad	blueswir1	case 0x6:
1327	87e92502	blueswir1	gen_op_eval_fbg(r_dst, cpu_fsr, offset);
1328	19f329ad	blueswir1	break;
1329	19f329ad	blueswir1	case 0x7:
1330	87e92502	blueswir1	gen_op_eval_fbu(r_dst, cpu_fsr, offset);
1331	19f329ad	blueswir1	break;
1332	19f329ad	blueswir1	case 0x8:
1333	19f329ad	blueswir1	gen_op_eval_ba(r_dst);
1334	19f329ad	blueswir1	break;
1335	19f329ad	blueswir1	case 0x9:
1336	87e92502	blueswir1	gen_op_eval_fbe(r_dst, cpu_fsr, offset);
1337	19f329ad	blueswir1	break;
1338	19f329ad	blueswir1	case 0xa:
1339	87e92502	blueswir1	gen_op_eval_fbue(r_dst, cpu_fsr, offset);
1340	19f329ad	blueswir1	break;
1341	19f329ad	blueswir1	case 0xb:
1342	87e92502	blueswir1	gen_op_eval_fbge(r_dst, cpu_fsr, offset);
1343	19f329ad	blueswir1	break;
1344	19f329ad	blueswir1	case 0xc:
1345	87e92502	blueswir1	gen_op_eval_fbuge(r_dst, cpu_fsr, offset);
1346	19f329ad	blueswir1	break;
1347	19f329ad	blueswir1	case 0xd:
1348	87e92502	blueswir1	gen_op_eval_fble(r_dst, cpu_fsr, offset);
1349	19f329ad	blueswir1	break;
1350	19f329ad	blueswir1	case 0xe:
1351	87e92502	blueswir1	gen_op_eval_fbule(r_dst, cpu_fsr, offset);
1352	19f329ad	blueswir1	break;
1353	19f329ad	blueswir1	case 0xf:
1354	87e92502	blueswir1	gen_op_eval_fbo(r_dst, cpu_fsr, offset);
1355	19f329ad	blueswir1	break;
1356	19f329ad	blueswir1	}
1357	e8af50a3	bellard	}
1358	00f219bf	blueswir1
1359	19f329ad	blueswir1	#ifdef TARGET_SPARC64
1360	00f219bf	blueswir1	// Inverted logic
1361	00f219bf	blueswir1	static const int gen_tcg_cond_reg[8] = {
1362	00f219bf	blueswir1	-1,
1363	00f219bf	blueswir1	TCG_COND_NE,
1364	00f219bf	blueswir1	TCG_COND_GT,
1365	00f219bf	blueswir1	TCG_COND_GE,
1366	00f219bf	blueswir1	-1,
1367	00f219bf	blueswir1	TCG_COND_EQ,
1368	00f219bf	blueswir1	TCG_COND_LE,
1369	00f219bf	blueswir1	TCG_COND_LT,
1370	00f219bf	blueswir1	};
1371	19f329ad	blueswir1
1372	4af984a7	blueswir1	static inline void gen_cond_reg(TCGv r_dst, int cond, TCGv r_src)
1373	19f329ad	blueswir1	{
1374	19f329ad	blueswir1	int l1;
1375	19f329ad	blueswir1
1376	19f329ad	blueswir1	l1 = gen_new_label();
1377	0425bee5	blueswir1	tcg_gen_movi_tl(r_dst, 0);
1378	cb63669a	pbrook	tcg_gen_brcondi_tl(gen_tcg_cond_reg[cond], r_src, 0, l1);
1379	19f329ad	blueswir1	tcg_gen_movi_tl(r_dst, 1);
1380	19f329ad	blueswir1	gen_set_label(l1);
1381	19f329ad	blueswir1	}
1382	3475187d	bellard	#endif
1383	cf495bcf	bellard
1384	0bee699e	bellard	/* XXX: potentially incorrect if dynamic npc */
1385	4af984a7	blueswir1	static void do_branch(DisasContext *dc, int32_t offset, uint32_t insn, int cc,
1386	4af984a7	blueswir1	TCGv r_cond)
1387	7a3f1944	bellard	{
1388	cf495bcf	bellard	unsigned int cond = GET_FIELD(insn, 3, 6), a = (insn & (1 << 29));
1389	af7bf89b	bellard	target_ulong target = dc->pc + offset;
1390	5fafdf24	ths
1391	cf495bcf	bellard	if (cond == 0x0) {
1392	0f8a249a	blueswir1	/* unconditional not taken */
1393	0f8a249a	blueswir1	if (a) {
1394	0f8a249a	blueswir1	dc->pc = dc->npc + 4;
1395	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1396	0f8a249a	blueswir1	} else {
1397	0f8a249a	blueswir1	dc->pc = dc->npc;
1398	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1399	0f8a249a	blueswir1	}
1400	cf495bcf	bellard	} else if (cond == 0x8) {
1401	0f8a249a	blueswir1	/* unconditional taken */
1402	0f8a249a	blueswir1	if (a) {
1403	0f8a249a	blueswir1	dc->pc = target;
1404	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1405	0f8a249a	blueswir1	} else {
1406	0f8a249a	blueswir1	dc->pc = dc->npc;
1407	0f8a249a	blueswir1	dc->npc = target;
1408	0f8a249a	blueswir1	}
1409	cf495bcf	bellard	} else {
1410	4af984a7	blueswir1	flush_cond(dc, r_cond);
1411	4af984a7	blueswir1	gen_cond(r_cond, cc, cond);
1412	0f8a249a	blueswir1	if (a) {
1413	4af984a7	blueswir1	gen_branch_a(dc, target, dc->npc, r_cond);
1414	cf495bcf	bellard	dc->is_br = 1;
1415	0f8a249a	blueswir1	} else {
1416	cf495bcf	bellard	dc->pc = dc->npc;
1417	72cbca10	bellard	dc->jump_pc[0] = target;
1418	72cbca10	bellard	dc->jump_pc[1] = dc->npc + 4;
1419	72cbca10	bellard	dc->npc = JUMP_PC;
1420	0f8a249a	blueswir1	}
1421	cf495bcf	bellard	}
1422	7a3f1944	bellard	}
1423	7a3f1944	bellard
1424	0bee699e	bellard	/* XXX: potentially incorrect if dynamic npc */
1425	4af984a7	blueswir1	static void do_fbranch(DisasContext *dc, int32_t offset, uint32_t insn, int cc,
1426	4af984a7	blueswir1	TCGv r_cond)
1427	e8af50a3	bellard	{
1428	e8af50a3	bellard	unsigned int cond = GET_FIELD(insn, 3, 6), a = (insn & (1 << 29));
1429	af7bf89b	bellard	target_ulong target = dc->pc + offset;
1430	af7bf89b	bellard
1431	e8af50a3	bellard	if (cond == 0x0) {
1432	0f8a249a	blueswir1	/* unconditional not taken */
1433	0f8a249a	blueswir1	if (a) {
1434	0f8a249a	blueswir1	dc->pc = dc->npc + 4;
1435	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1436	0f8a249a	blueswir1	} else {
1437	0f8a249a	blueswir1	dc->pc = dc->npc;
1438	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1439	0f8a249a	blueswir1	}
1440	e8af50a3	bellard	} else if (cond == 0x8) {
1441	0f8a249a	blueswir1	/* unconditional taken */
1442	0f8a249a	blueswir1	if (a) {
1443	0f8a249a	blueswir1	dc->pc = target;
1444	0f8a249a	blueswir1	dc->npc = dc->pc + 4;
1445	0f8a249a	blueswir1	} else {
1446	0f8a249a	blueswir1	dc->pc = dc->npc;
1447	0f8a249a	blueswir1	dc->npc = target;
1448	0f8a249a	blueswir1	}
1449	e8af50a3	bellard	} else {
1450	4af984a7	blueswir1	flush_cond(dc, r_cond);
1451	4af984a7	blueswir1	gen_fcond(r_cond, cc, cond);
1452	0f8a249a	blueswir1	if (a) {
1453	4af984a7	blueswir1	gen_branch_a(dc, target, dc->npc, r_cond);
1454	e8af50a3	bellard	dc->is_br = 1;
1455	0f8a249a	blueswir1	} else {
1456	e8af50a3	bellard	dc->pc = dc->npc;
1457	e8af50a3	bellard	dc->jump_pc[0] = target;
1458	e8af50a3	bellard	dc->jump_pc[1] = dc->npc + 4;
1459	e8af50a3	bellard	dc->npc = JUMP_PC;
1460	0f8a249a	blueswir1	}
1461	e8af50a3	bellard	}
1462	e8af50a3	bellard	}
1463	e8af50a3	bellard
1464	3475187d	bellard	#ifdef TARGET_SPARC64
1465	3475187d	bellard	/* XXX: potentially incorrect if dynamic npc */
1466	4af984a7	blueswir1	static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn,
1467	4af984a7	blueswir1	TCGv r_cond, TCGv r_reg)
1468	7a3f1944	bellard	{
1469	3475187d	bellard	unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29));
1470	3475187d	bellard	target_ulong target = dc->pc + offset;
1471	3475187d	bellard
1472	4af984a7	blueswir1	flush_cond(dc, r_cond);
1473	4af984a7	blueswir1	gen_cond_reg(r_cond, cond, r_reg);
1474	3475187d	bellard	if (a) {
1475	4af984a7	blueswir1	gen_branch_a(dc, target, dc->npc, r_cond);
1476	0f8a249a	blueswir1	dc->is_br = 1;
1477	3475187d	bellard	} else {
1478	0f8a249a	blueswir1	dc->pc = dc->npc;
1479	0f8a249a	blueswir1	dc->jump_pc[0] = target;
1480	0f8a249a	blueswir1	dc->jump_pc[1] = dc->npc + 4;
1481	0f8a249a	blueswir1	dc->npc = JUMP_PC;
1482	3475187d	bellard	}
1483	7a3f1944	bellard	}
1484	7a3f1944	bellard
1485	3475187d	bellard	static GenOpFunc * const gen_fcmps[4] = {
1486	7e8c2b6c	blueswir1	helper_fcmps,
1487	7e8c2b6c	blueswir1	helper_fcmps_fcc1,
1488	7e8c2b6c	blueswir1	helper_fcmps_fcc2,
1489	7e8c2b6c	blueswir1	helper_fcmps_fcc3,
1490	3475187d	bellard	};
1491	3475187d	bellard
1492	3475187d	bellard	static GenOpFunc * const gen_fcmpd[4] = {
1493	7e8c2b6c	blueswir1	helper_fcmpd,
1494	7e8c2b6c	blueswir1	helper_fcmpd_fcc1,
1495	7e8c2b6c	blueswir1	helper_fcmpd_fcc2,
1496	7e8c2b6c	blueswir1	helper_fcmpd_fcc3,
1497	3475187d	bellard	};
1498	417454b0	blueswir1
1499	1f587329	blueswir1	static GenOpFunc * const gen_fcmpq[4] = {
1500	7e8c2b6c	blueswir1	helper_fcmpq,
1501	7e8c2b6c	blueswir1	helper_fcmpq_fcc1,
1502	7e8c2b6c	blueswir1	helper_fcmpq_fcc2,
1503	7e8c2b6c	blueswir1	helper_fcmpq_fcc3,
1504	1f587329	blueswir1	};
1505	1f587329	blueswir1
1506	417454b0	blueswir1	static GenOpFunc * const gen_fcmpes[4] = {
1507	7e8c2b6c	blueswir1	helper_fcmpes,
1508	7e8c2b6c	blueswir1	helper_fcmpes_fcc1,
1509	7e8c2b6c	blueswir1	helper_fcmpes_fcc2,
1510	7e8c2b6c	blueswir1	helper_fcmpes_fcc3,
1511	417454b0	blueswir1	};
1512	417454b0	blueswir1
1513	417454b0	blueswir1	static GenOpFunc * const gen_fcmped[4] = {
1514	7e8c2b6c	blueswir1	helper_fcmped,
1515	7e8c2b6c	blueswir1	helper_fcmped_fcc1,
1516	7e8c2b6c	blueswir1	helper_fcmped_fcc2,
1517	7e8c2b6c	blueswir1	helper_fcmped_fcc3,
1518	417454b0	blueswir1	};
1519	417454b0	blueswir1
1520	1f587329	blueswir1	static GenOpFunc * const gen_fcmpeq[4] = {
1521	7e8c2b6c	blueswir1	helper_fcmpeq,
1522	7e8c2b6c	blueswir1	helper_fcmpeq_fcc1,
1523	7e8c2b6c	blueswir1	helper_fcmpeq_fcc2,
1524	7e8c2b6c	blueswir1	helper_fcmpeq_fcc3,
1525	1f587329	blueswir1	};
1526	7e8c2b6c	blueswir1
1527	7e8c2b6c	blueswir1	static inline void gen_op_fcmps(int fccno)
1528	7e8c2b6c	blueswir1	{
1529	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmps[fccno]);
1530	7e8c2b6c	blueswir1	}
1531	7e8c2b6c	blueswir1
1532	7e8c2b6c	blueswir1	static inline void gen_op_fcmpd(int fccno)
1533	7e8c2b6c	blueswir1	{
1534	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmpd[fccno]);
1535	7e8c2b6c	blueswir1	}
1536	7e8c2b6c	blueswir1
1537	7e8c2b6c	blueswir1	static inline void gen_op_fcmpq(int fccno)
1538	7e8c2b6c	blueswir1	{
1539	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmpq[fccno]);
1540	7e8c2b6c	blueswir1	}
1541	7e8c2b6c	blueswir1
1542	7e8c2b6c	blueswir1	static inline void gen_op_fcmpes(int fccno)
1543	7e8c2b6c	blueswir1	{
1544	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmpes[fccno]);
1545	7e8c2b6c	blueswir1	}
1546	7e8c2b6c	blueswir1
1547	7e8c2b6c	blueswir1	static inline void gen_op_fcmped(int fccno)
1548	7e8c2b6c	blueswir1	{
1549	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmped[fccno]);
1550	7e8c2b6c	blueswir1	}
1551	7e8c2b6c	blueswir1
1552	7e8c2b6c	blueswir1	static inline void gen_op_fcmpeq(int fccno)
1553	7e8c2b6c	blueswir1	{
1554	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(gen_fcmpeq[fccno]);
1555	7e8c2b6c	blueswir1	}
1556	7e8c2b6c	blueswir1
1557	7e8c2b6c	blueswir1	#else
1558	7e8c2b6c	blueswir1
1559	7e8c2b6c	blueswir1	static inline void gen_op_fcmps(int fccno)
1560	7e8c2b6c	blueswir1	{
1561	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmps);
1562	7e8c2b6c	blueswir1	}
1563	7e8c2b6c	blueswir1
1564	7e8c2b6c	blueswir1	static inline void gen_op_fcmpd(int fccno)
1565	7e8c2b6c	blueswir1	{
1566	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmpd);
1567	7e8c2b6c	blueswir1	}
1568	7e8c2b6c	blueswir1
1569	7e8c2b6c	blueswir1	static inline void gen_op_fcmpq(int fccno)
1570	7e8c2b6c	blueswir1	{
1571	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmpq);
1572	7e8c2b6c	blueswir1	}
1573	7e8c2b6c	blueswir1
1574	7e8c2b6c	blueswir1	static inline void gen_op_fcmpes(int fccno)
1575	7e8c2b6c	blueswir1	{
1576	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmpes);
1577	7e8c2b6c	blueswir1	}
1578	7e8c2b6c	blueswir1
1579	7e8c2b6c	blueswir1	static inline void gen_op_fcmped(int fccno)
1580	7e8c2b6c	blueswir1	{
1581	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmped);
1582	7e8c2b6c	blueswir1	}
1583	7e8c2b6c	blueswir1
1584	7e8c2b6c	blueswir1	static inline void gen_op_fcmpeq(int fccno)
1585	7e8c2b6c	blueswir1	{
1586	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fcmpeq);
1587	7e8c2b6c	blueswir1	}
1588	7e8c2b6c	blueswir1	#endif
1589	7e8c2b6c	blueswir1
1590	134d77a1	blueswir1	static inline void gen_op_fpexception_im(int fsr_flags)
1591	134d77a1	blueswir1	{
1592	2ea815ca	blueswir1	TCGv r_const;
1593	2ea815ca	blueswir1
1594	87e92502	blueswir1	tcg_gen_andi_tl(cpu_fsr, cpu_fsr, ~FSR_FTT_MASK);
1595	87e92502	blueswir1	tcg_gen_ori_tl(cpu_fsr, cpu_fsr, fsr_flags);
1596	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_FP_EXCP);
1597	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
1598	2ea815ca	blueswir1	tcg_temp_free(r_const);
1599	134d77a1	blueswir1	}
1600	134d77a1	blueswir1
1601	4af984a7	blueswir1	static int gen_trap_ifnofpu(DisasContext *dc, TCGv r_cond)
1602	a80dde08	bellard	{
1603	a80dde08	bellard	#if !defined(CONFIG_USER_ONLY)
1604	a80dde08	bellard	if (!dc->fpu_enabled) {
1605	2ea815ca	blueswir1	TCGv r_const;
1606	2ea815ca	blueswir1
1607	4af984a7	blueswir1	save_state(dc, r_cond);
1608	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_NFPU_INSN);
1609	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
1610	2ea815ca	blueswir1	tcg_temp_free(r_const);
1611	a80dde08	bellard	dc->is_br = 1;
1612	a80dde08	bellard	return 1;
1613	a80dde08	bellard	}
1614	a80dde08	bellard	#endif
1615	a80dde08	bellard	return 0;
1616	a80dde08	bellard	}
1617	a80dde08	bellard
1618	7e8c2b6c	blueswir1	static inline void gen_op_clear_ieee_excp_and_FTT(void)
1619	7e8c2b6c	blueswir1	{
1620	87e92502	blueswir1	tcg_gen_andi_tl(cpu_fsr, cpu_fsr, ~(FSR_FTT_MASK \| FSR_CEXC_MASK));
1621	7e8c2b6c	blueswir1	}
1622	7e8c2b6c	blueswir1
1623	7e8c2b6c	blueswir1	static inline void gen_clear_float_exceptions(void)
1624	7e8c2b6c	blueswir1	{
1625	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_clear_float_exceptions);
1626	7e8c2b6c	blueswir1	}
1627	7e8c2b6c	blueswir1
1628	1a2fb1c0	blueswir1	/* asi moves */
1629	1a2fb1c0	blueswir1	#ifdef TARGET_SPARC64
1630	0425bee5	blueswir1	static inline TCGv gen_get_asi(int insn, TCGv r_addr)
1631	1a2fb1c0	blueswir1	{
1632	1a2fb1c0	blueswir1	int asi, offset;
1633	0425bee5	blueswir1	TCGv r_asi;
1634	1a2fb1c0	blueswir1
1635	1a2fb1c0	blueswir1	if (IS_IMM) {
1636	0425bee5	blueswir1	r_asi = tcg_temp_new(TCG_TYPE_I32);
1637	1a2fb1c0	blueswir1	offset = GET_FIELD(insn, 25, 31);
1638	0425bee5	blueswir1	tcg_gen_addi_tl(r_addr, r_addr, offset);
1639	0425bee5	blueswir1	tcg_gen_ld_i32(r_asi, cpu_env, offsetof(CPUSPARCState, asi));
1640	1a2fb1c0	blueswir1	} else {
1641	1a2fb1c0	blueswir1	asi = GET_FIELD(insn, 19, 26);
1642	0425bee5	blueswir1	r_asi = tcg_const_i32(asi);
1643	1a2fb1c0	blueswir1	}
1644	0425bee5	blueswir1	return r_asi;
1645	0425bee5	blueswir1	}
1646	0425bee5	blueswir1
1647	77f193da	blueswir1	static inline void gen_ld_asi(TCGv dst, TCGv addr, int insn, int size,
1648	77f193da	blueswir1	int sign)
1649	0425bee5	blueswir1	{
1650	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1651	0425bee5	blueswir1
1652	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1653	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1654	2ea815ca	blueswir1	r_sign = tcg_const_i32(sign);
1655	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, dst, addr, r_asi, r_size, r_sign);
1656	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1657	2ea815ca	blueswir1	tcg_temp_free(r_size);
1658	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1659	1a2fb1c0	blueswir1	}
1660	1a2fb1c0	blueswir1
1661	4af984a7	blueswir1	static inline void gen_st_asi(TCGv src, TCGv addr, int insn, int size)
1662	1a2fb1c0	blueswir1	{
1663	2ea815ca	blueswir1	TCGv r_asi, r_size;
1664	1a2fb1c0	blueswir1
1665	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1666	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1667	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, src, r_asi, r_size);
1668	2ea815ca	blueswir1	tcg_temp_free(r_size);
1669	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1670	1a2fb1c0	blueswir1	}
1671	1a2fb1c0	blueswir1
1672	4af984a7	blueswir1	static inline void gen_ldf_asi(TCGv addr, int insn, int size, int rd)
1673	1a2fb1c0	blueswir1	{
1674	2ea815ca	blueswir1	TCGv r_asi, r_size, r_rd;
1675	1a2fb1c0	blueswir1
1676	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1677	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1678	2ea815ca	blueswir1	r_rd = tcg_const_i32(rd);
1679	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_ldf_asi, addr, r_asi, r_size, r_rd);
1680	2ea815ca	blueswir1	tcg_temp_free(r_rd);
1681	2ea815ca	blueswir1	tcg_temp_free(r_size);
1682	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1683	1a2fb1c0	blueswir1	}
1684	1a2fb1c0	blueswir1
1685	4af984a7	blueswir1	static inline void gen_stf_asi(TCGv addr, int insn, int size, int rd)
1686	1a2fb1c0	blueswir1	{
1687	2ea815ca	blueswir1	TCGv r_asi, r_size, r_rd;
1688	1a2fb1c0	blueswir1
1689	31741a27	blueswir1	r_asi = gen_get_asi(insn, addr);
1690	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1691	2ea815ca	blueswir1	r_rd = tcg_const_i32(rd);
1692	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_stf_asi, addr, r_asi, r_size, r_rd);
1693	2ea815ca	blueswir1	tcg_temp_free(r_rd);
1694	2ea815ca	blueswir1	tcg_temp_free(r_size);
1695	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1696	1a2fb1c0	blueswir1	}
1697	1a2fb1c0	blueswir1
1698	4af984a7	blueswir1	static inline void gen_swap_asi(TCGv dst, TCGv addr, int insn)
1699	1a2fb1c0	blueswir1	{
1700	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1701	1a2fb1c0	blueswir1
1702	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1703	2ea815ca	blueswir1	r_size = tcg_const_i32(4);
1704	2ea815ca	blueswir1	r_sign = tcg_const_i32(0);
1705	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, cpu_tmp64, addr, r_asi, r_size, r_sign);
1706	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1707	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, dst, r_asi, r_size);
1708	2ea815ca	blueswir1	tcg_temp_free(r_size);
1709	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1710	8d96d209	blueswir1	tcg_gen_trunc_i64_tl(dst, cpu_tmp64);
1711	1a2fb1c0	blueswir1	}
1712	1a2fb1c0	blueswir1
1713	4af984a7	blueswir1	static inline void gen_ldda_asi(TCGv lo, TCGv hi, TCGv addr, int insn)
1714	1a2fb1c0	blueswir1	{
1715	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1716	1a2fb1c0	blueswir1
1717	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1718	2ea815ca	blueswir1	r_size = tcg_const_i32(8);
1719	2ea815ca	blueswir1	r_sign = tcg_const_i32(0);
1720	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, cpu_tmp64, addr, r_asi, r_size, r_sign);
1721	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1722	2ea815ca	blueswir1	tcg_temp_free(r_size);
1723	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1724	4af984a7	blueswir1	tcg_gen_andi_i64(lo, cpu_tmp64, 0xffffffffULL);
1725	8911f501	blueswir1	tcg_gen_shri_i64(cpu_tmp64, cpu_tmp64, 32);
1726	4af984a7	blueswir1	tcg_gen_andi_i64(hi, cpu_tmp64, 0xffffffffULL);
1727	0425bee5	blueswir1	}
1728	0425bee5	blueswir1
1729	4af984a7	blueswir1	static inline void gen_stda_asi(TCGv hi, TCGv addr, int insn, int rd)
1730	0425bee5	blueswir1	{
1731	2ea815ca	blueswir1	TCGv r_temp, r_asi, r_size;
1732	0425bee5	blueswir1
1733	8d96d209	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
1734	0425bee5	blueswir1	gen_movl_reg_TN(rd + 1, r_temp);
1735	4af984a7	blueswir1	tcg_gen_helper_1_2(helper_pack64, cpu_tmp64, hi,
1736	0425bee5	blueswir1	r_temp);
1737	2ea815ca	blueswir1	tcg_temp_free(r_temp);
1738	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1739	2ea815ca	blueswir1	r_size = tcg_const_i32(8);
1740	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, cpu_tmp64, r_asi, r_size);
1741	2ea815ca	blueswir1	tcg_temp_free(r_size);
1742	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1743	1a2fb1c0	blueswir1	}
1744	1a2fb1c0	blueswir1
1745	77f193da	blueswir1	static inline void gen_cas_asi(TCGv dst, TCGv addr, TCGv val2, int insn,
1746	77f193da	blueswir1	int rd)
1747	1a2fb1c0	blueswir1	{
1748	1a2fb1c0	blueswir1	TCGv r_val1, r_asi;
1749	1a2fb1c0	blueswir1
1750	ef28fd86	blueswir1	r_val1 = tcg_temp_new(TCG_TYPE_TL);
1751	1a2fb1c0	blueswir1	gen_movl_reg_TN(rd, r_val1);
1752	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1753	4af984a7	blueswir1	tcg_gen_helper_1_4(helper_cas_asi, dst, addr, r_val1, val2, r_asi);
1754	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1755	2ea815ca	blueswir1	tcg_temp_free(r_val1);
1756	1a2fb1c0	blueswir1	}
1757	1a2fb1c0	blueswir1
1758	77f193da	blueswir1	static inline void gen_casx_asi(TCGv dst, TCGv addr, TCGv val2, int insn,
1759	77f193da	blueswir1	int rd)
1760	1a2fb1c0	blueswir1	{
1761	8911f501	blueswir1	TCGv r_asi;
1762	1a2fb1c0	blueswir1
1763	8911f501	blueswir1	gen_movl_reg_TN(rd, cpu_tmp64);
1764	4af984a7	blueswir1	r_asi = gen_get_asi(insn, addr);
1765	4af984a7	blueswir1	tcg_gen_helper_1_4(helper_casx_asi, dst, addr, cpu_tmp64, val2, r_asi);
1766	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1767	1a2fb1c0	blueswir1	}
1768	1a2fb1c0	blueswir1
1769	1a2fb1c0	blueswir1	#elif !defined(CONFIG_USER_ONLY)
1770	1a2fb1c0	blueswir1
1771	77f193da	blueswir1	static inline void gen_ld_asi(TCGv dst, TCGv addr, int insn, int size,
1772	77f193da	blueswir1	int sign)
1773	1a2fb1c0	blueswir1	{
1774	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1775	1a2fb1c0	blueswir1
1776	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1777	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1778	2ea815ca	blueswir1	r_sign = tcg_const_i32(sign);
1779	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, cpu_tmp64, addr, r_asi, r_size, r_sign);
1780	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1781	2ea815ca	blueswir1	tcg_temp_free(r_size);
1782	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1783	4af984a7	blueswir1	tcg_gen_trunc_i64_tl(dst, cpu_tmp64);
1784	1a2fb1c0	blueswir1	}
1785	1a2fb1c0	blueswir1
1786	4af984a7	blueswir1	static inline void gen_st_asi(TCGv src, TCGv addr, int insn, int size)
1787	1a2fb1c0	blueswir1	{
1788	2ea815ca	blueswir1	TCGv r_asi, r_size;
1789	1a2fb1c0	blueswir1
1790	4af984a7	blueswir1	tcg_gen_extu_tl_i64(cpu_tmp64, src);
1791	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1792	2ea815ca	blueswir1	r_size = tcg_const_i32(size);
1793	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, cpu_tmp64, r_asi, r_size);
1794	2ea815ca	blueswir1	tcg_temp_free(r_size);
1795	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1796	1a2fb1c0	blueswir1	}
1797	1a2fb1c0	blueswir1
1798	4af984a7	blueswir1	static inline void gen_swap_asi(TCGv dst, TCGv addr, int insn)
1799	1a2fb1c0	blueswir1	{
1800	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1801	1a2fb1c0	blueswir1
1802	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1803	2ea815ca	blueswir1	r_size = tcg_const_i32(4);
1804	2ea815ca	blueswir1	r_sign = tcg_const_i32(0);
1805	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, cpu_tmp64, addr, r_asi, r_size, r_sign);
1806	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1807	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, dst, r_asi, r_size);
1808	2ea815ca	blueswir1	tcg_temp_free(r_size);
1809	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1810	8d96d209	blueswir1	tcg_gen_trunc_i64_tl(dst, cpu_tmp64);
1811	1a2fb1c0	blueswir1	}
1812	1a2fb1c0	blueswir1
1813	4af984a7	blueswir1	static inline void gen_ldda_asi(TCGv lo, TCGv hi, TCGv addr, int insn)
1814	1a2fb1c0	blueswir1	{
1815	2ea815ca	blueswir1	TCGv r_asi, r_size, r_sign;
1816	1a2fb1c0	blueswir1
1817	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1818	2ea815ca	blueswir1	r_size = tcg_const_i32(8);
1819	2ea815ca	blueswir1	r_sign = tcg_const_i32(0);
1820	2ea815ca	blueswir1	tcg_gen_helper_1_4(helper_ld_asi, cpu_tmp64, addr, r_asi, r_size, r_sign);
1821	2ea815ca	blueswir1	tcg_temp_free(r_sign);
1822	2ea815ca	blueswir1	tcg_temp_free(r_size);
1823	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1824	4af984a7	blueswir1	tcg_gen_trunc_i64_tl(lo, cpu_tmp64);
1825	8911f501	blueswir1	tcg_gen_shri_i64(cpu_tmp64, cpu_tmp64, 32);
1826	4af984a7	blueswir1	tcg_gen_trunc_i64_tl(hi, cpu_tmp64);
1827	0425bee5	blueswir1	}
1828	0425bee5	blueswir1
1829	4af984a7	blueswir1	static inline void gen_stda_asi(TCGv hi, TCGv addr, int insn, int rd)
1830	0425bee5	blueswir1	{
1831	2ea815ca	blueswir1	TCGv r_temp, r_asi, r_size;
1832	0425bee5	blueswir1
1833	8d96d209	blueswir1	r_temp = tcg_temp_new(TCG_TYPE_TL);
1834	0425bee5	blueswir1	gen_movl_reg_TN(rd + 1, r_temp);
1835	4af984a7	blueswir1	tcg_gen_helper_1_2(helper_pack64, cpu_tmp64, hi, r_temp);
1836	2ea815ca	blueswir1	tcg_temp_free(r_temp);
1837	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1838	2ea815ca	blueswir1	r_size = tcg_const_i32(8);
1839	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, cpu_tmp64, r_asi, r_size);
1840	2ea815ca	blueswir1	tcg_temp_free(r_size);
1841	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1842	1a2fb1c0	blueswir1	}
1843	1a2fb1c0	blueswir1	#endif
1844	1a2fb1c0	blueswir1
1845	1a2fb1c0	blueswir1	#if !defined(CONFIG_USER_ONLY) \|\| defined(TARGET_SPARC64)
1846	4af984a7	blueswir1	static inline void gen_ldstub_asi(TCGv dst, TCGv addr, int insn)
1847	1a2fb1c0	blueswir1	{
1848	2ea815ca	blueswir1	TCGv r_val, r_asi, r_size;
1849	1a2fb1c0	blueswir1
1850	4af984a7	blueswir1	gen_ld_asi(dst, addr, insn, 1, 0);
1851	1a2fb1c0	blueswir1
1852	2ea815ca	blueswir1	r_val = tcg_const_i64(0xffULL);
1853	2ea815ca	blueswir1	r_asi = tcg_const_i32(GET_FIELD(insn, 19, 26));
1854	2ea815ca	blueswir1	r_size = tcg_const_i32(1);
1855	2ea815ca	blueswir1	tcg_gen_helper_0_4(helper_st_asi, addr, r_val, r_asi, r_size);
1856	2ea815ca	blueswir1	tcg_temp_free(r_size);
1857	2ea815ca	blueswir1	tcg_temp_free(r_asi);
1858	2ea815ca	blueswir1	tcg_temp_free(r_val);
1859	1a2fb1c0	blueswir1	}
1860	1a2fb1c0	blueswir1	#endif
1861	1a2fb1c0	blueswir1
1862	9322a4bf	blueswir1	static inline TCGv get_src1(unsigned int insn, TCGv def)
1863	9322a4bf	blueswir1	{
1864	9322a4bf	blueswir1	TCGv r_rs1 = def;
1865	9322a4bf	blueswir1	unsigned int rs1;
1866	9322a4bf	blueswir1
1867	9322a4bf	blueswir1	rs1 = GET_FIELD(insn, 13, 17);
1868	9322a4bf	blueswir1	if (rs1 == 0)
1869	9322a4bf	blueswir1	//r_rs1 = tcg_const_tl(0);
1870	9322a4bf	blueswir1	tcg_gen_movi_tl(def, 0);
1871	9322a4bf	blueswir1	else if (rs1 < 8)
1872	9322a4bf	blueswir1	//r_rs1 = cpu_gregs[rs1];
1873	9322a4bf	blueswir1	tcg_gen_mov_tl(def, cpu_gregs[rs1]);
1874	9322a4bf	blueswir1	else
1875	9322a4bf	blueswir1	tcg_gen_ld_tl(def, cpu_regwptr, (rs1 - 8) * sizeof(target_ulong));
1876	9322a4bf	blueswir1	return r_rs1;
1877	9322a4bf	blueswir1	}
1878	9322a4bf	blueswir1
1879	a49d9390	blueswir1	static inline TCGv get_src2(unsigned int insn, TCGv def)
1880	a49d9390	blueswir1	{
1881	a49d9390	blueswir1	TCGv r_rs2 = def;
1882	a49d9390	blueswir1	unsigned int rs2;
1883	a49d9390	blueswir1
1884	a49d9390	blueswir1	if (IS_IMM) { /* immediate */
1885	a49d9390	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
1886	2ea815ca	blueswir1	r_rs2 = tcg_const_tl((int)rs2); // XXX how to free?
1887	a49d9390	blueswir1	} else { /* register */
1888	a49d9390	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
1889	a49d9390	blueswir1	if (rs2 == 0)
1890	2ea815ca	blueswir1	r_rs2 = tcg_const_tl(0); // XXX how to free?
1891	a49d9390	blueswir1	else if (rs2 < 8)
1892	a49d9390	blueswir1	r_rs2 = cpu_gregs[rs2];
1893	a49d9390	blueswir1	else
1894	a49d9390	blueswir1	tcg_gen_ld_tl(def, cpu_regwptr, (rs2 - 8) * sizeof(target_ulong));
1895	a49d9390	blueswir1	}
1896	a49d9390	blueswir1	return r_rs2;
1897	a49d9390	blueswir1	}
1898	a49d9390	blueswir1
1899	64a88d5d	blueswir1	#define CHECK_IU_FEATURE(dc, FEATURE) \
1900	64a88d5d	blueswir1	if (!((dc)->features & CPU_FEATURE_ ## FEATURE)) \
1901	64a88d5d	blueswir1	goto illegal_insn;
1902	64a88d5d	blueswir1	#define CHECK_FPU_FEATURE(dc, FEATURE) \
1903	64a88d5d	blueswir1	if (!((dc)->features & CPU_FEATURE_ ## FEATURE)) \
1904	64a88d5d	blueswir1	goto nfpu_insn;
1905	64a88d5d	blueswir1
1906	0bee699e	bellard	/* before an instruction, dc->pc must be static */
1907	cf495bcf	bellard	static void disas_sparc_insn(DisasContext * dc)
1908	cf495bcf	bellard	{
1909	cf495bcf	bellard	unsigned int insn, opc, rs1, rs2, rd;
1910	7a3f1944	bellard
1911	a8c768c0	blueswir1	if (unlikely(loglevel & CPU_LOG_TB_OP))
1912	a8c768c0	blueswir1	tcg_gen_debug_insn_start(dc->pc);
1913	0fa85d43	bellard	insn = ldl_code(dc->pc);
1914	cf495bcf	bellard	opc = GET_FIELD(insn, 0, 1);
1915	7a3f1944	bellard
1916	cf495bcf	bellard	rd = GET_FIELD(insn, 2, 6);
1917	6ae20372	blueswir1
1918	6ae20372	blueswir1	cpu_dst = cpu_T[0];
1919	6ae20372	blueswir1	cpu_src1 = cpu_T[0]; // const
1920	6ae20372	blueswir1	cpu_src2 = cpu_T[1]; // const
1921	6ae20372	blueswir1
1922	6ae20372	blueswir1	// loads and stores
1923	6ae20372	blueswir1	cpu_addr = cpu_T[0];
1924	6ae20372	blueswir1	cpu_val = cpu_T[1];
1925	6ae20372	blueswir1
1926	cf495bcf	bellard	switch (opc) {
1927	0f8a249a	blueswir1	case 0: /* branches/sethi */
1928	0f8a249a	blueswir1	{
1929	0f8a249a	blueswir1	unsigned int xop = GET_FIELD(insn, 7, 9);
1930	0f8a249a	blueswir1	int32_t target;
1931	0f8a249a	blueswir1	switch (xop) {
1932	3475187d	bellard	#ifdef TARGET_SPARC64
1933	0f8a249a	blueswir1	case 0x1: /* V9 BPcc */
1934	0f8a249a	blueswir1	{
1935	0f8a249a	blueswir1	int cc;
1936	0f8a249a	blueswir1
1937	0f8a249a	blueswir1	target = GET_FIELD_SP(insn, 0, 18);
1938	0f8a249a	blueswir1	target = sign_extend(target, 18);
1939	0f8a249a	blueswir1	target <<= 2;
1940	0f8a249a	blueswir1	cc = GET_FIELD_SP(insn, 20, 21);
1941	0f8a249a	blueswir1	if (cc == 0)
1942	6ae20372	blueswir1	do_branch(dc, target, insn, 0, cpu_cond);
1943	0f8a249a	blueswir1	else if (cc == 2)
1944	6ae20372	blueswir1	do_branch(dc, target, insn, 1, cpu_cond);
1945	0f8a249a	blueswir1	else
1946	0f8a249a	blueswir1	goto illegal_insn;
1947	0f8a249a	blueswir1	goto jmp_insn;
1948	0f8a249a	blueswir1	}
1949	0f8a249a	blueswir1	case 0x3: /* V9 BPr */
1950	0f8a249a	blueswir1	{
1951	0f8a249a	blueswir1	target = GET_FIELD_SP(insn, 0, 13) \|
1952	13846e70	bellard	(GET_FIELD_SP(insn, 20, 21) << 14);
1953	0f8a249a	blueswir1	target = sign_extend(target, 16);
1954	0f8a249a	blueswir1	target <<= 2;
1955	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
1956	6ae20372	blueswir1	do_branch_reg(dc, target, insn, cpu_cond, cpu_src1);
1957	0f8a249a	blueswir1	goto jmp_insn;
1958	0f8a249a	blueswir1	}
1959	0f8a249a	blueswir1	case 0x5: /* V9 FBPcc */
1960	0f8a249a	blueswir1	{
1961	0f8a249a	blueswir1	int cc = GET_FIELD_SP(insn, 20, 21);
1962	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
1963	a80dde08	bellard	goto jmp_insn;
1964	0f8a249a	blueswir1	target = GET_FIELD_SP(insn, 0, 18);
1965	0f8a249a	blueswir1	target = sign_extend(target, 19);
1966	0f8a249a	blueswir1	target <<= 2;
1967	6ae20372	blueswir1	do_fbranch(dc, target, insn, cc, cpu_cond);
1968	0f8a249a	blueswir1	goto jmp_insn;
1969	0f8a249a	blueswir1	}
1970	a4d17f19	blueswir1	#else
1971	0f8a249a	blueswir1	case 0x7: /* CBN+x */
1972	0f8a249a	blueswir1	{
1973	0f8a249a	blueswir1	goto ncp_insn;
1974	0f8a249a	blueswir1	}
1975	0f8a249a	blueswir1	#endif
1976	0f8a249a	blueswir1	case 0x2: /* BN+x */
1977	0f8a249a	blueswir1	{
1978	0f8a249a	blueswir1	target = GET_FIELD(insn, 10, 31);
1979	0f8a249a	blueswir1	target = sign_extend(target, 22);
1980	0f8a249a	blueswir1	target <<= 2;
1981	6ae20372	blueswir1	do_branch(dc, target, insn, 0, cpu_cond);
1982	0f8a249a	blueswir1	goto jmp_insn;
1983	0f8a249a	blueswir1	}
1984	0f8a249a	blueswir1	case 0x6: /* FBN+x */
1985	0f8a249a	blueswir1	{
1986	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
1987	a80dde08	bellard	goto jmp_insn;
1988	0f8a249a	blueswir1	target = GET_FIELD(insn, 10, 31);
1989	0f8a249a	blueswir1	target = sign_extend(target, 22);
1990	0f8a249a	blueswir1	target <<= 2;
1991	6ae20372	blueswir1	do_fbranch(dc, target, insn, 0, cpu_cond);
1992	0f8a249a	blueswir1	goto jmp_insn;
1993	0f8a249a	blueswir1	}
1994	0f8a249a	blueswir1	case 0x4: /* SETHI */
1995	0f8a249a	blueswir1	if (rd) { // nop
1996	0f8a249a	blueswir1	uint32_t value = GET_FIELD(insn, 10, 31);
1997	2ea815ca	blueswir1	TCGv r_const;
1998	2ea815ca	blueswir1
1999	2ea815ca	blueswir1	r_const = tcg_const_tl(value << 10);
2000	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
2001	2ea815ca	blueswir1	tcg_temp_free(r_const);
2002	0f8a249a	blueswir1	}
2003	0f8a249a	blueswir1	break;
2004	0f8a249a	blueswir1	case 0x0: /* UNIMPL */
2005	0f8a249a	blueswir1	default:
2006	3475187d	bellard	goto illegal_insn;
2007	0f8a249a	blueswir1	}
2008	0f8a249a	blueswir1	break;
2009	0f8a249a	blueswir1	}
2010	0f8a249a	blueswir1	break;
2011	cf495bcf	bellard	case 1:
2012	0f8a249a	blueswir1	/CALL/ {
2013	0f8a249a	blueswir1	target_long target = GET_FIELDs(insn, 2, 31) << 2;
2014	2ea815ca	blueswir1	TCGv r_const;
2015	cf495bcf	bellard
2016	2ea815ca	blueswir1	r_const = tcg_const_tl(dc->pc);
2017	2ea815ca	blueswir1	gen_movl_TN_reg(15, r_const);
2018	2ea815ca	blueswir1	tcg_temp_free(r_const);
2019	0f8a249a	blueswir1	target += dc->pc;
2020	6ae20372	blueswir1	gen_mov_pc_npc(dc, cpu_cond);
2021	0f8a249a	blueswir1	dc->npc = target;
2022	0f8a249a	blueswir1	}
2023	0f8a249a	blueswir1	goto jmp_insn;
2024	0f8a249a	blueswir1	case 2: /* FPU & Logical Operations */
2025	0f8a249a	blueswir1	{
2026	0f8a249a	blueswir1	unsigned int xop = GET_FIELD(insn, 7, 12);
2027	0f8a249a	blueswir1	if (xop == 0x3a) { /* generate trap */
2028	cf495bcf	bellard	int cond;
2029	3475187d	bellard
2030	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2031	0f8a249a	blueswir1	if (IS_IMM) {
2032	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 25, 31);
2033	6ae20372	blueswir1	tcg_gen_addi_tl(cpu_dst, cpu_src1, rs2);
2034	cf495bcf	bellard	} else {
2035	cf495bcf	bellard	rs2 = GET_FIELD(insn, 27, 31);
2036	0f8a249a	blueswir1	if (rs2 != 0) {
2037	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
2038	6ae20372	blueswir1	tcg_gen_add_tl(cpu_dst, cpu_src1, cpu_src2);
2039	6f551262	blueswir1	} else
2040	6f551262	blueswir1	tcg_gen_mov_tl(cpu_dst, cpu_src1);
2041	cf495bcf	bellard	}
2042	cf495bcf	bellard	cond = GET_FIELD(insn, 3, 6);
2043	cf495bcf	bellard	if (cond == 0x8) {
2044	6ae20372	blueswir1	save_state(dc, cpu_cond);
2045	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_trap, cpu_dst);
2046	af7bf89b	bellard	} else if (cond != 0) {
2047	748b9d8e	blueswir1	TCGv r_cond = tcg_temp_new(TCG_TYPE_TL);
2048	3475187d	bellard	#ifdef TARGET_SPARC64
2049	0f8a249a	blueswir1	/* V9 icc/xcc */
2050	0f8a249a	blueswir1	int cc = GET_FIELD_SP(insn, 11, 12);
2051	748b9d8e	blueswir1
2052	6ae20372	blueswir1	save_state(dc, cpu_cond);
2053	0f8a249a	blueswir1	if (cc == 0)
2054	748b9d8e	blueswir1	gen_cond(r_cond, 0, cond);
2055	0f8a249a	blueswir1	else if (cc == 2)
2056	748b9d8e	blueswir1	gen_cond(r_cond, 1, cond);
2057	0f8a249a	blueswir1	else
2058	0f8a249a	blueswir1	goto illegal_insn;
2059	3475187d	bellard	#else
2060	6ae20372	blueswir1	save_state(dc, cpu_cond);
2061	748b9d8e	blueswir1	gen_cond(r_cond, 0, cond);
2062	3475187d	bellard	#endif
2063	6ae20372	blueswir1	tcg_gen_helper_0_2(helper_trapcc, cpu_dst, r_cond);
2064	2ea815ca	blueswir1	tcg_temp_free(r_cond);
2065	cf495bcf	bellard	}
2066	a80dde08	bellard	gen_op_next_insn();
2067	57fec1fe	bellard	tcg_gen_exit_tb(0);
2068	a80dde08	bellard	dc->is_br = 1;
2069	a80dde08	bellard	goto jmp_insn;
2070	cf495bcf	bellard	} else if (xop == 0x28) {
2071	cf495bcf	bellard	rs1 = GET_FIELD(insn, 13, 17);
2072	cf495bcf	bellard	switch(rs1) {
2073	cf495bcf	bellard	case 0: /* rdy */
2074	65fe7b09	blueswir1	#ifndef TARGET_SPARC64
2075	65fe7b09	blueswir1	case 0x01 ... 0x0e: /* undefined in the SPARCv8
2076	65fe7b09	blueswir1	manual, rdy on the microSPARC
2077	65fe7b09	blueswir1	II */
2078	65fe7b09	blueswir1	case 0x0f: /* stbar in the SPARCv8 manual,
2079	65fe7b09	blueswir1	rdy on the microSPARC II */
2080	65fe7b09	blueswir1	case 0x10 ... 0x1f: /* implementation-dependent in the
2081	65fe7b09	blueswir1	SPARCv8 manual, rdy on the
2082	65fe7b09	blueswir1	microSPARC II */
2083	65fe7b09	blueswir1	#endif
2084	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2085	77f193da	blueswir1	offsetof(CPUSPARCState, y));
2086	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2087	cf495bcf	bellard	break;
2088	3475187d	bellard	#ifdef TARGET_SPARC64
2089	0f8a249a	blueswir1	case 0x2: /* V9 rdccr */
2090	6ae20372	blueswir1	tcg_gen_helper_1_0(helper_rdccr, cpu_dst);
2091	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2092	3475187d	bellard	break;
2093	0f8a249a	blueswir1	case 0x3: /* V9 rdasi */
2094	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2095	77f193da	blueswir1	offsetof(CPUSPARCState, asi));
2096	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2097	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2098	3475187d	bellard	break;
2099	0f8a249a	blueswir1	case 0x4: /* V9 rdtick */
2100	ccd4a219	blueswir1	{
2101	ccd4a219	blueswir1	TCGv r_tickptr;
2102	ccd4a219	blueswir1
2103	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
2104	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
2105	ccd4a219	blueswir1	offsetof(CPUState, tick));
2106	6ae20372	blueswir1	tcg_gen_helper_1_1(helper_tick_get_count, cpu_dst,
2107	ccd4a219	blueswir1	r_tickptr);
2108	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
2109	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2110	ccd4a219	blueswir1	}
2111	3475187d	bellard	break;
2112	0f8a249a	blueswir1	case 0x5: /* V9 rdpc */
2113	2ea815ca	blueswir1	{
2114	2ea815ca	blueswir1	TCGv r_const;
2115	2ea815ca	blueswir1
2116	2ea815ca	blueswir1	r_const = tcg_const_tl(dc->pc);
2117	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
2118	2ea815ca	blueswir1	tcg_temp_free(r_const);
2119	2ea815ca	blueswir1	}
2120	0f8a249a	blueswir1	break;
2121	0f8a249a	blueswir1	case 0x6: /* V9 rdfprs */
2122	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2123	77f193da	blueswir1	offsetof(CPUSPARCState, fprs));
2124	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2125	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2126	3475187d	bellard	break;
2127	65fe7b09	blueswir1	case 0xf: /* V9 membar */
2128	65fe7b09	blueswir1	break; /* no effect */
2129	0f8a249a	blueswir1	case 0x13: /* Graphics Status */
2130	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
2131	725cb90b	bellard	goto jmp_insn;
2132	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2133	77f193da	blueswir1	offsetof(CPUSPARCState, gsr));
2134	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2135	725cb90b	bellard	break;
2136	0f8a249a	blueswir1	case 0x17: /* Tick compare */
2137	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2138	77f193da	blueswir1	offsetof(CPUSPARCState, tick_cmpr));
2139	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2140	83469015	bellard	break;
2141	0f8a249a	blueswir1	case 0x18: /* System tick */
2142	ccd4a219	blueswir1	{
2143	ccd4a219	blueswir1	TCGv r_tickptr;
2144	ccd4a219	blueswir1
2145	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
2146	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
2147	ccd4a219	blueswir1	offsetof(CPUState, stick));
2148	6ae20372	blueswir1	tcg_gen_helper_1_1(helper_tick_get_count, cpu_dst,
2149	ccd4a219	blueswir1	r_tickptr);
2150	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
2151	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2152	ccd4a219	blueswir1	}
2153	83469015	bellard	break;
2154	0f8a249a	blueswir1	case 0x19: /* System tick compare */
2155	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2156	77f193da	blueswir1	offsetof(CPUSPARCState, stick_cmpr));
2157	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2158	83469015	bellard	break;
2159	0f8a249a	blueswir1	case 0x10: /* Performance Control */
2160	0f8a249a	blueswir1	case 0x11: /* Performance Instrumentation Counter */
2161	0f8a249a	blueswir1	case 0x12: /* Dispatch Control */
2162	0f8a249a	blueswir1	case 0x14: /* Softint set, WO */
2163	0f8a249a	blueswir1	case 0x15: /* Softint clear, WO */
2164	0f8a249a	blueswir1	case 0x16: /* Softint write */
2165	3475187d	bellard	#endif
2166	3475187d	bellard	default:
2167	cf495bcf	bellard	goto illegal_insn;
2168	cf495bcf	bellard	}
2169	e8af50a3	bellard	#if !defined(CONFIG_USER_ONLY)
2170	e9ebed4d	blueswir1	} else if (xop == 0x29) { /* rdpsr / UA2005 rdhpr */
2171	3475187d	bellard	#ifndef TARGET_SPARC64
2172	0f8a249a	blueswir1	if (!supervisor(dc))
2173	0f8a249a	blueswir1	goto priv_insn;
2174	6ae20372	blueswir1	tcg_gen_helper_1_0(helper_rdpsr, cpu_dst);
2175	e9ebed4d	blueswir1	#else
2176	e9ebed4d	blueswir1	if (!hypervisor(dc))
2177	e9ebed4d	blueswir1	goto priv_insn;
2178	e9ebed4d	blueswir1	rs1 = GET_FIELD(insn, 13, 17);
2179	e9ebed4d	blueswir1	switch (rs1) {
2180	e9ebed4d	blueswir1	case 0: // hpstate
2181	e9ebed4d	blueswir1	// gen_op_rdhpstate();
2182	e9ebed4d	blueswir1	break;
2183	e9ebed4d	blueswir1	case 1: // htstate
2184	e9ebed4d	blueswir1	// gen_op_rdhtstate();
2185	e9ebed4d	blueswir1	break;
2186	e9ebed4d	blueswir1	case 3: // hintp
2187	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2188	77f193da	blueswir1	offsetof(CPUSPARCState, hintp));
2189	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2190	e9ebed4d	blueswir1	break;
2191	e9ebed4d	blueswir1	case 5: // htba
2192	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2193	77f193da	blueswir1	offsetof(CPUSPARCState, htba));
2194	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2195	e9ebed4d	blueswir1	break;
2196	e9ebed4d	blueswir1	case 6: // hver
2197	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2198	77f193da	blueswir1	offsetof(CPUSPARCState, hver));
2199	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2200	e9ebed4d	blueswir1	break;
2201	e9ebed4d	blueswir1	case 31: // hstick_cmpr
2202	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
2203	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
2204	77f193da	blueswir1	offsetof(CPUSPARCState, hstick_cmpr));
2205	e9ebed4d	blueswir1	break;
2206	e9ebed4d	blueswir1	default:
2207	e9ebed4d	blueswir1	goto illegal_insn;
2208	e9ebed4d	blueswir1	}
2209	e9ebed4d	blueswir1	#endif
2210	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2211	e8af50a3	bellard	break;
2212	3475187d	bellard	} else if (xop == 0x2a) { /* rdwim / V9 rdpr */
2213	0f8a249a	blueswir1	if (!supervisor(dc))
2214	0f8a249a	blueswir1	goto priv_insn;
2215	3475187d	bellard	#ifdef TARGET_SPARC64
2216	3475187d	bellard	rs1 = GET_FIELD(insn, 13, 17);
2217	0f8a249a	blueswir1	switch (rs1) {
2218	0f8a249a	blueswir1	case 0: // tpc
2219	375ee38b	blueswir1	{
2220	375ee38b	blueswir1	TCGv r_tsptr;
2221	375ee38b	blueswir1
2222	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
2223	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
2224	375ee38b	blueswir1	offsetof(CPUState, tsptr));
2225	6ae20372	blueswir1	tcg_gen_ld_tl(cpu_dst, r_tsptr,
2226	375ee38b	blueswir1	offsetof(trap_state, tpc));
2227	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
2228	375ee38b	blueswir1	}
2229	0f8a249a	blueswir1	break;
2230	0f8a249a	blueswir1	case 1: // tnpc
2231	375ee38b	blueswir1	{
2232	375ee38b	blueswir1	TCGv r_tsptr;
2233	375ee38b	blueswir1
2234	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
2235	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
2236	375ee38b	blueswir1	offsetof(CPUState, tsptr));
2237	6ae20372	blueswir1	tcg_gen_ld_tl(cpu_dst, r_tsptr,
2238	375ee38b	blueswir1	offsetof(trap_state, tnpc));
2239	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
2240	375ee38b	blueswir1	}
2241	0f8a249a	blueswir1	break;
2242	0f8a249a	blueswir1	case 2: // tstate
2243	375ee38b	blueswir1	{
2244	375ee38b	blueswir1	TCGv r_tsptr;
2245	375ee38b	blueswir1
2246	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
2247	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
2248	375ee38b	blueswir1	offsetof(CPUState, tsptr));
2249	6ae20372	blueswir1	tcg_gen_ld_tl(cpu_dst, r_tsptr,
2250	375ee38b	blueswir1	offsetof(trap_state, tstate));
2251	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
2252	375ee38b	blueswir1	}
2253	0f8a249a	blueswir1	break;
2254	0f8a249a	blueswir1	case 3: // tt
2255	375ee38b	blueswir1	{
2256	375ee38b	blueswir1	TCGv r_tsptr;
2257	375ee38b	blueswir1
2258	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
2259	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
2260	375ee38b	blueswir1	offsetof(CPUState, tsptr));
2261	6ae20372	blueswir1	tcg_gen_ld_i32(cpu_dst, r_tsptr,
2262	375ee38b	blueswir1	offsetof(trap_state, tt));
2263	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
2264	375ee38b	blueswir1	}
2265	0f8a249a	blueswir1	break;
2266	0f8a249a	blueswir1	case 4: // tick
2267	ccd4a219	blueswir1	{
2268	ccd4a219	blueswir1	TCGv r_tickptr;
2269	ccd4a219	blueswir1
2270	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
2271	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
2272	ccd4a219	blueswir1	offsetof(CPUState, tick));
2273	6ae20372	blueswir1	tcg_gen_helper_1_1(helper_tick_get_count, cpu_dst,
2274	ccd4a219	blueswir1	r_tickptr);
2275	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2276	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
2277	ccd4a219	blueswir1	}
2278	0f8a249a	blueswir1	break;
2279	0f8a249a	blueswir1	case 5: // tba
2280	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2281	77f193da	blueswir1	offsetof(CPUSPARCState, tbr));
2282	0f8a249a	blueswir1	break;
2283	0f8a249a	blueswir1	case 6: // pstate
2284	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2285	77f193da	blueswir1	offsetof(CPUSPARCState, pstate));
2286	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2287	0f8a249a	blueswir1	break;
2288	0f8a249a	blueswir1	case 7: // tl
2289	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2290	77f193da	blueswir1	offsetof(CPUSPARCState, tl));
2291	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2292	0f8a249a	blueswir1	break;
2293	0f8a249a	blueswir1	case 8: // pil
2294	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2295	77f193da	blueswir1	offsetof(CPUSPARCState, psrpil));
2296	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2297	0f8a249a	blueswir1	break;
2298	0f8a249a	blueswir1	case 9: // cwp
2299	6ae20372	blueswir1	tcg_gen_helper_1_0(helper_rdcwp, cpu_dst);
2300	0f8a249a	blueswir1	break;
2301	0f8a249a	blueswir1	case 10: // cansave
2302	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2303	77f193da	blueswir1	offsetof(CPUSPARCState, cansave));
2304	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2305	0f8a249a	blueswir1	break;
2306	0f8a249a	blueswir1	case 11: // canrestore
2307	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2308	77f193da	blueswir1	offsetof(CPUSPARCState, canrestore));
2309	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2310	0f8a249a	blueswir1	break;
2311	0f8a249a	blueswir1	case 12: // cleanwin
2312	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2313	77f193da	blueswir1	offsetof(CPUSPARCState, cleanwin));
2314	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2315	0f8a249a	blueswir1	break;
2316	0f8a249a	blueswir1	case 13: // otherwin
2317	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2318	77f193da	blueswir1	offsetof(CPUSPARCState, otherwin));
2319	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2320	0f8a249a	blueswir1	break;
2321	0f8a249a	blueswir1	case 14: // wstate
2322	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2323	77f193da	blueswir1	offsetof(CPUSPARCState, wstate));
2324	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2325	0f8a249a	blueswir1	break;
2326	e9ebed4d	blueswir1	case 16: // UA2005 gl
2327	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2328	77f193da	blueswir1	offsetof(CPUSPARCState, gl));
2329	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2330	e9ebed4d	blueswir1	break;
2331	e9ebed4d	blueswir1	case 26: // UA2005 strand status
2332	e9ebed4d	blueswir1	if (!hypervisor(dc))
2333	e9ebed4d	blueswir1	goto priv_insn;
2334	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2335	77f193da	blueswir1	offsetof(CPUSPARCState, ssr));
2336	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2337	e9ebed4d	blueswir1	break;
2338	0f8a249a	blueswir1	case 31: // ver
2339	77f193da	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env,
2340	77f193da	blueswir1	offsetof(CPUSPARCState, version));
2341	0f8a249a	blueswir1	break;
2342	0f8a249a	blueswir1	case 15: // fq
2343	0f8a249a	blueswir1	default:
2344	0f8a249a	blueswir1	goto illegal_insn;
2345	0f8a249a	blueswir1	}
2346	3475187d	bellard	#else
2347	77f193da	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
2348	77f193da	blueswir1	offsetof(CPUSPARCState, wim));
2349	6ae20372	blueswir1	tcg_gen_ext_i32_tl(cpu_dst, cpu_tmp32);
2350	3475187d	bellard	#endif
2351	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2352	e8af50a3	bellard	break;
2353	3475187d	bellard	} else if (xop == 0x2b) { /* rdtbr / V9 flushw */
2354	3475187d	bellard	#ifdef TARGET_SPARC64
2355	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_flushw);
2356	3475187d	bellard	#else
2357	0f8a249a	blueswir1	if (!supervisor(dc))
2358	0f8a249a	blueswir1	goto priv_insn;
2359	6ae20372	blueswir1	tcg_gen_ld_tl(cpu_dst, cpu_env, offsetof(CPUSPARCState, tbr));
2360	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2361	3475187d	bellard	#endif
2362	e8af50a3	bellard	break;
2363	e8af50a3	bellard	#endif
2364	0f8a249a	blueswir1	} else if (xop == 0x34) { /* FPU Operations */
2365	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
2366	a80dde08	bellard	goto jmp_insn;
2367	0f8a249a	blueswir1	gen_op_clear_ieee_excp_and_FTT();
2368	e8af50a3	bellard	rs1 = GET_FIELD(insn, 13, 17);
2369	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
2370	0f8a249a	blueswir1	xop = GET_FIELD(insn, 18, 26);
2371	0f8a249a	blueswir1	switch (xop) {
2372	0f8a249a	blueswir1	case 0x1: /* fmovs */
2373	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs2);
2374	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2375	0f8a249a	blueswir1	break;
2376	0f8a249a	blueswir1	case 0x5: /* fnegs */
2377	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2378	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnegs);
2379	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2380	0f8a249a	blueswir1	break;
2381	0f8a249a	blueswir1	case 0x9: /* fabss */
2382	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2383	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fabss);
2384	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2385	0f8a249a	blueswir1	break;
2386	0f8a249a	blueswir1	case 0x29: /* fsqrts */
2387	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FSQRT);
2388	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2389	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2390	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fsqrts);
2391	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2392	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2393	0f8a249a	blueswir1	break;
2394	0f8a249a	blueswir1	case 0x2a: /* fsqrtd */
2395	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FSQRT);
2396	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2397	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2398	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fsqrtd);
2399	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2400	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2401	0f8a249a	blueswir1	break;
2402	0f8a249a	blueswir1	case 0x2b: /* fsqrtq */
2403	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2404	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2405	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2406	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fsqrtq);
2407	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2408	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2409	1f587329	blueswir1	break;
2410	0f8a249a	blueswir1	case 0x41:
2411	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2412	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2413	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2414	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fadds);
2415	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2416	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2417	0f8a249a	blueswir1	break;
2418	0f8a249a	blueswir1	case 0x42:
2419	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2420	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2421	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2422	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_faddd);
2423	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2424	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2425	0f8a249a	blueswir1	break;
2426	0f8a249a	blueswir1	case 0x43: /* faddq */
2427	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2428	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2429	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2430	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2431	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_faddq);
2432	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2433	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2434	1f587329	blueswir1	break;
2435	0f8a249a	blueswir1	case 0x45:
2436	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2437	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2438	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2439	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fsubs);
2440	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2441	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2442	0f8a249a	blueswir1	break;
2443	0f8a249a	blueswir1	case 0x46:
2444	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2445	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2446	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2447	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fsubd);
2448	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2449	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2450	0f8a249a	blueswir1	break;
2451	0f8a249a	blueswir1	case 0x47: /* fsubq */
2452	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2453	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2454	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2455	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2456	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fsubq);
2457	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2458	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2459	1f587329	blueswir1	break;
2460	64a88d5d	blueswir1	case 0x49: /* fmuls */
2461	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FMUL);
2462	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2463	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2464	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2465	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmuls);
2466	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2467	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2468	0f8a249a	blueswir1	break;
2469	64a88d5d	blueswir1	case 0x4a: /* fmuld */
2470	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FMUL);
2471	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2472	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2473	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2474	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmuld);
2475	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2476	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2477	0f8a249a	blueswir1	break;
2478	0f8a249a	blueswir1	case 0x4b: /* fmulq */
2479	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2480	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FMUL);
2481	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2482	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2483	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2484	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmulq);
2485	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2486	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2487	1f587329	blueswir1	break;
2488	0f8a249a	blueswir1	case 0x4d:
2489	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2490	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2491	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2492	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdivs);
2493	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2494	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2495	0f8a249a	blueswir1	break;
2496	0f8a249a	blueswir1	case 0x4e:
2497	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2498	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2499	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2500	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdivd);
2501	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2502	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2503	0f8a249a	blueswir1	break;
2504	0f8a249a	blueswir1	case 0x4f: /* fdivq */
2505	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2506	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2507	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2508	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2509	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdivq);
2510	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2511	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2512	1f587329	blueswir1	break;
2513	0f8a249a	blueswir1	case 0x69:
2514	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2515	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2516	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2517	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fsmuld);
2518	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2519	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2520	0f8a249a	blueswir1	break;
2521	0f8a249a	blueswir1	case 0x6e: /* fdmulq */
2522	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2523	1f587329	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2524	1f587329	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2525	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2526	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdmulq);
2527	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2528	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2529	1f587329	blueswir1	break;
2530	0f8a249a	blueswir1	case 0xc4:
2531	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2532	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2533	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fitos);
2534	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2535	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2536	0f8a249a	blueswir1	break;
2537	0f8a249a	blueswir1	case 0xc6:
2538	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2539	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2540	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdtos);
2541	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2542	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2543	0f8a249a	blueswir1	break;
2544	0f8a249a	blueswir1	case 0xc7: /* fqtos */
2545	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2546	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2547	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2548	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fqtos);
2549	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2550	1f587329	blueswir1	gen_op_store_FT0_fpr(rd);
2551	1f587329	blueswir1	break;
2552	0f8a249a	blueswir1	case 0xc8:
2553	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2554	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fitod);
2555	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2556	0f8a249a	blueswir1	break;
2557	0f8a249a	blueswir1	case 0xc9:
2558	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2559	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fstod);
2560	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2561	0f8a249a	blueswir1	break;
2562	0f8a249a	blueswir1	case 0xcb: /* fqtod */
2563	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2564	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2565	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2566	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fqtod);
2567	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2568	1f587329	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2569	1f587329	blueswir1	break;
2570	0f8a249a	blueswir1	case 0xcc: /* fitoq */
2571	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2572	1f587329	blueswir1	gen_op_load_fpr_FT1(rs2);
2573	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fitoq);
2574	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2575	1f587329	blueswir1	break;
2576	0f8a249a	blueswir1	case 0xcd: /* fstoq */
2577	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2578	1f587329	blueswir1	gen_op_load_fpr_FT1(rs2);
2579	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fstoq);
2580	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2581	1f587329	blueswir1	break;
2582	0f8a249a	blueswir1	case 0xce: /* fdtoq */
2583	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2584	1f587329	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2585	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdtoq);
2586	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2587	1f587329	blueswir1	break;
2588	0f8a249a	blueswir1	case 0xd1:
2589	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2590	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2591	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fstoi);
2592	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2593	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2594	0f8a249a	blueswir1	break;
2595	0f8a249a	blueswir1	case 0xd2:
2596	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2597	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2598	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdtoi);
2599	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2600	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2601	0f8a249a	blueswir1	break;
2602	0f8a249a	blueswir1	case 0xd3: /* fqtoi */
2603	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2604	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2605	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2606	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fqtoi);
2607	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2608	1f587329	blueswir1	gen_op_store_FT0_fpr(rd);
2609	1f587329	blueswir1	break;
2610	3475187d	bellard	#ifdef TARGET_SPARC64
2611	0f8a249a	blueswir1	case 0x2: /* V9 fmovd */
2612	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs2));
2613	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2614	0f8a249a	blueswir1	break;
2615	1f587329	blueswir1	case 0x3: /* V9 fmovq */
2616	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2617	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs2));
2618	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2619	1f587329	blueswir1	break;
2620	0f8a249a	blueswir1	case 0x6: /* V9 fnegd */
2621	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2622	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnegd);
2623	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2624	0f8a249a	blueswir1	break;
2625	1f587329	blueswir1	case 0x7: /* V9 fnegq */
2626	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2627	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2628	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnegq);
2629	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2630	1f587329	blueswir1	break;
2631	0f8a249a	blueswir1	case 0xa: /* V9 fabsd */
2632	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2633	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fabsd);
2634	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2635	0f8a249a	blueswir1	break;
2636	1f587329	blueswir1	case 0xb: /* V9 fabsq */
2637	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2638	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2639	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_fabsq);
2640	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2641	1f587329	blueswir1	break;
2642	0f8a249a	blueswir1	case 0x81: /* V9 fstox */
2643	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2644	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2645	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fstox);
2646	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2647	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2648	0f8a249a	blueswir1	break;
2649	0f8a249a	blueswir1	case 0x82: /* V9 fdtox */
2650	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2651	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2652	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fdtox);
2653	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2654	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2655	0f8a249a	blueswir1	break;
2656	1f587329	blueswir1	case 0x83: /* V9 fqtox */
2657	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2658	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2659	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2660	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fqtox);
2661	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2662	1f587329	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2663	1f587329	blueswir1	break;
2664	0f8a249a	blueswir1	case 0x84: /* V9 fxtos */
2665	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2666	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2667	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxtos);
2668	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2669	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2670	0f8a249a	blueswir1	break;
2671	0f8a249a	blueswir1	case 0x88: /* V9 fxtod */
2672	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2673	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2674	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxtod);
2675	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2676	0f8a249a	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2677	0f8a249a	blueswir1	break;
2678	0f8a249a	blueswir1	case 0x8c: /* V9 fxtoq */
2679	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2680	1f587329	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2681	7e8c2b6c	blueswir1	gen_clear_float_exceptions();
2682	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxtoq);
2683	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_check_ieee_exceptions);
2684	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2685	1f587329	blueswir1	break;
2686	1f587329	blueswir1	#endif
2687	0f8a249a	blueswir1	default:
2688	0f8a249a	blueswir1	goto illegal_insn;
2689	0f8a249a	blueswir1	}
2690	0f8a249a	blueswir1	} else if (xop == 0x35) { /* FPU Operations */
2691	3475187d	bellard	#ifdef TARGET_SPARC64
2692	0f8a249a	blueswir1	int cond;
2693	3475187d	bellard	#endif
2694	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
2695	a80dde08	bellard	goto jmp_insn;
2696	0f8a249a	blueswir1	gen_op_clear_ieee_excp_and_FTT();
2697	cf495bcf	bellard	rs1 = GET_FIELD(insn, 13, 17);
2698	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
2699	0f8a249a	blueswir1	xop = GET_FIELD(insn, 18, 26);
2700	3475187d	bellard	#ifdef TARGET_SPARC64
2701	0f8a249a	blueswir1	if ((xop & 0x11f) == 0x005) { // V9 fmovsr
2702	dcf24905	blueswir1	int l1;
2703	dcf24905	blueswir1
2704	dcf24905	blueswir1	l1 = gen_new_label();
2705	0f8a249a	blueswir1	cond = GET_FIELD_SP(insn, 14, 17);
2706	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2707	cb63669a	pbrook	tcg_gen_brcondi_tl(gen_tcg_cond_reg[cond], cpu_src1,
2708	cb63669a	pbrook	0, l1);
2709	19f329ad	blueswir1	gen_op_load_fpr_FT0(rs2);
2710	0f8a249a	blueswir1	gen_op_store_FT0_fpr(rd);
2711	dcf24905	blueswir1	gen_set_label(l1);
2712	0f8a249a	blueswir1	break;
2713	0f8a249a	blueswir1	} else if ((xop & 0x11f) == 0x006) { // V9 fmovdr
2714	dcf24905	blueswir1	int l1;
2715	dcf24905	blueswir1
2716	dcf24905	blueswir1	l1 = gen_new_label();
2717	0f8a249a	blueswir1	cond = GET_FIELD_SP(insn, 14, 17);
2718	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2719	cb63669a	pbrook	tcg_gen_brcondi_tl(gen_tcg_cond_reg[cond], cpu_src1,
2720	cb63669a	pbrook	0, l1);
2721	19f329ad	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs2));
2722	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
2723	dcf24905	blueswir1	gen_set_label(l1);
2724	0f8a249a	blueswir1	break;
2725	0f8a249a	blueswir1	} else if ((xop & 0x11f) == 0x007) { // V9 fmovqr
2726	dcf24905	blueswir1	int l1;
2727	dcf24905	blueswir1
2728	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2729	dcf24905	blueswir1	l1 = gen_new_label();
2730	1f587329	blueswir1	cond = GET_FIELD_SP(insn, 14, 17);
2731	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2732	cb63669a	pbrook	tcg_gen_brcondi_tl(gen_tcg_cond_reg[cond], cpu_src1,
2733	cb63669a	pbrook	0, l1);
2734	19f329ad	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs2));
2735	1f587329	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
2736	dcf24905	blueswir1	gen_set_label(l1);
2737	1f587329	blueswir1	break;
2738	0f8a249a	blueswir1	}
2739	0f8a249a	blueswir1	#endif
2740	0f8a249a	blueswir1	switch (xop) {
2741	3475187d	bellard	#ifdef TARGET_SPARC64
2742	19f329ad	blueswir1	#define FMOVCC(size_FDQ, fcc) \
2743	19f329ad	blueswir1	{ \
2744	0425bee5	blueswir1	TCGv r_cond; \
2745	19f329ad	blueswir1	int l1; \
2746	19f329ad	blueswir1	\
2747	19f329ad	blueswir1	l1 = gen_new_label(); \
2748	19f329ad	blueswir1	r_cond = tcg_temp_new(TCG_TYPE_TL); \
2749	19f329ad	blueswir1	cond = GET_FIELD_SP(insn, 14, 17); \
2750	19f329ad	blueswir1	gen_fcond(r_cond, fcc, cond); \
2751	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, \
2752	cb63669a	pbrook	0, l1); \
2753	77f193da	blueswir1	glue(glue(gen_op_load_fpr_, size_FDQ), T0) \
2754	77f193da	blueswir1	(glue(size_FDQ, FPREG(rs2))); \
2755	77f193da	blueswir1	glue(glue(gen_op_store_, size_FDQ), T0_fpr) \
2756	77f193da	blueswir1	(glue(size_FDQ, FPREG(rd))); \
2757	19f329ad	blueswir1	gen_set_label(l1); \
2758	2ea815ca	blueswir1	tcg_temp_free(r_cond); \
2759	19f329ad	blueswir1	}
2760	0f8a249a	blueswir1	case 0x001: /* V9 fmovscc %fcc0 */
2761	19f329ad	blueswir1	FMOVCC(F, 0);
2762	0f8a249a	blueswir1	break;
2763	0f8a249a	blueswir1	case 0x002: /* V9 fmovdcc %fcc0 */
2764	19f329ad	blueswir1	FMOVCC(D, 0);
2765	0f8a249a	blueswir1	break;
2766	0f8a249a	blueswir1	case 0x003: /* V9 fmovqcc %fcc0 */
2767	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2768	19f329ad	blueswir1	FMOVCC(Q, 0);
2769	1f587329	blueswir1	break;
2770	0f8a249a	blueswir1	case 0x041: /* V9 fmovscc %fcc1 */
2771	19f329ad	blueswir1	FMOVCC(F, 1);
2772	0f8a249a	blueswir1	break;
2773	0f8a249a	blueswir1	case 0x042: /* V9 fmovdcc %fcc1 */
2774	19f329ad	blueswir1	FMOVCC(D, 1);
2775	0f8a249a	blueswir1	break;
2776	0f8a249a	blueswir1	case 0x043: /* V9 fmovqcc %fcc1 */
2777	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2778	19f329ad	blueswir1	FMOVCC(Q, 1);
2779	1f587329	blueswir1	break;
2780	0f8a249a	blueswir1	case 0x081: /* V9 fmovscc %fcc2 */
2781	19f329ad	blueswir1	FMOVCC(F, 2);
2782	0f8a249a	blueswir1	break;
2783	0f8a249a	blueswir1	case 0x082: /* V9 fmovdcc %fcc2 */
2784	19f329ad	blueswir1	FMOVCC(D, 2);
2785	0f8a249a	blueswir1	break;
2786	0f8a249a	blueswir1	case 0x083: /* V9 fmovqcc %fcc2 */
2787	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2788	19f329ad	blueswir1	FMOVCC(Q, 2);
2789	1f587329	blueswir1	break;
2790	0f8a249a	blueswir1	case 0x0c1: /* V9 fmovscc %fcc3 */
2791	19f329ad	blueswir1	FMOVCC(F, 3);
2792	0f8a249a	blueswir1	break;
2793	0f8a249a	blueswir1	case 0x0c2: /* V9 fmovdcc %fcc3 */
2794	19f329ad	blueswir1	FMOVCC(D, 3);
2795	0f8a249a	blueswir1	break;
2796	0f8a249a	blueswir1	case 0x0c3: /* V9 fmovqcc %fcc3 */
2797	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2798	19f329ad	blueswir1	FMOVCC(Q, 3);
2799	1f587329	blueswir1	break;
2800	19f329ad	blueswir1	#undef FMOVCC
2801	19f329ad	blueswir1	#define FMOVCC(size_FDQ, icc) \
2802	19f329ad	blueswir1	{ \
2803	0425bee5	blueswir1	TCGv r_cond; \
2804	19f329ad	blueswir1	int l1; \
2805	19f329ad	blueswir1	\
2806	19f329ad	blueswir1	l1 = gen_new_label(); \
2807	19f329ad	blueswir1	r_cond = tcg_temp_new(TCG_TYPE_TL); \
2808	19f329ad	blueswir1	cond = GET_FIELD_SP(insn, 14, 17); \
2809	19f329ad	blueswir1	gen_cond(r_cond, icc, cond); \
2810	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, \
2811	cb63669a	pbrook	0, l1); \
2812	77f193da	blueswir1	glue(glue(gen_op_load_fpr_, size_FDQ), T0) \
2813	77f193da	blueswir1	(glue(size_FDQ, FPREG(rs2))); \
2814	77f193da	blueswir1	glue(glue(gen_op_store_, size_FDQ), T0_fpr) \
2815	77f193da	blueswir1	(glue(size_FDQ, FPREG(rd))); \
2816	19f329ad	blueswir1	gen_set_label(l1); \
2817	2ea815ca	blueswir1	tcg_temp_free(r_cond); \
2818	19f329ad	blueswir1	}
2819	19f329ad	blueswir1
2820	0f8a249a	blueswir1	case 0x101: /* V9 fmovscc %icc */
2821	19f329ad	blueswir1	FMOVCC(F, 0);
2822	0f8a249a	blueswir1	break;
2823	0f8a249a	blueswir1	case 0x102: /* V9 fmovdcc %icc */
2824	19f329ad	blueswir1	FMOVCC(D, 0);
2825	0f8a249a	blueswir1	case 0x103: /* V9 fmovqcc %icc */
2826	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2827	64a88d5d	blueswir1	FMOVCC(Q, 0);
2828	1f587329	blueswir1	break;
2829	0f8a249a	blueswir1	case 0x181: /* V9 fmovscc %xcc */
2830	19f329ad	blueswir1	FMOVCC(F, 1);
2831	0f8a249a	blueswir1	break;
2832	0f8a249a	blueswir1	case 0x182: /* V9 fmovdcc %xcc */
2833	19f329ad	blueswir1	FMOVCC(D, 1);
2834	0f8a249a	blueswir1	break;
2835	0f8a249a	blueswir1	case 0x183: /* V9 fmovqcc %xcc */
2836	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2837	19f329ad	blueswir1	FMOVCC(Q, 1);
2838	1f587329	blueswir1	break;
2839	19f329ad	blueswir1	#undef FMOVCC
2840	1f587329	blueswir1	#endif
2841	1f587329	blueswir1	case 0x51: /* fcmps, V9 %fcc */
2842	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2843	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2844	7e8c2b6c	blueswir1	gen_op_fcmps(rd & 3);
2845	0f8a249a	blueswir1	break;
2846	1f587329	blueswir1	case 0x52: /* fcmpd, V9 %fcc */
2847	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2848	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2849	7e8c2b6c	blueswir1	gen_op_fcmpd(rd & 3);
2850	0f8a249a	blueswir1	break;
2851	1f587329	blueswir1	case 0x53: /* fcmpq, V9 %fcc */
2852	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2853	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2854	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2855	7e8c2b6c	blueswir1	gen_op_fcmpq(rd & 3);
2856	1f587329	blueswir1	break;
2857	0f8a249a	blueswir1	case 0x55: /* fcmpes, V9 %fcc */
2858	0f8a249a	blueswir1	gen_op_load_fpr_FT0(rs1);
2859	0f8a249a	blueswir1	gen_op_load_fpr_FT1(rs2);
2860	7e8c2b6c	blueswir1	gen_op_fcmpes(rd & 3);
2861	0f8a249a	blueswir1	break;
2862	0f8a249a	blueswir1	case 0x56: /* fcmped, V9 %fcc */
2863	0f8a249a	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
2864	0f8a249a	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
2865	7e8c2b6c	blueswir1	gen_op_fcmped(rd & 3);
2866	0f8a249a	blueswir1	break;
2867	1f587329	blueswir1	case 0x57: /* fcmpeq, V9 %fcc */
2868	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
2869	1f587329	blueswir1	gen_op_load_fpr_QT0(QFPREG(rs1));
2870	1f587329	blueswir1	gen_op_load_fpr_QT1(QFPREG(rs2));
2871	7e8c2b6c	blueswir1	gen_op_fcmpeq(rd & 3);
2872	1f587329	blueswir1	break;
2873	0f8a249a	blueswir1	default:
2874	0f8a249a	blueswir1	goto illegal_insn;
2875	0f8a249a	blueswir1	}
2876	0f8a249a	blueswir1	} else if (xop == 0x2) {
2877	0f8a249a	blueswir1	// clr/mov shortcut
2878	e80cfcfc	bellard
2879	e80cfcfc	bellard	rs1 = GET_FIELD(insn, 13, 17);
2880	0f8a249a	blueswir1	if (rs1 == 0) {
2881	1a2fb1c0	blueswir1	// or %g0, x, y -> mov T0, x; mov y, T0
2882	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
2883	2ea815ca	blueswir1	TCGv r_const;
2884	2ea815ca	blueswir1
2885	0f8a249a	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
2886	2ea815ca	blueswir1	r_const = tcg_const_tl((int)rs2);
2887	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
2888	2ea815ca	blueswir1	tcg_temp_free(r_const);
2889	0f8a249a	blueswir1	} else { /* register */
2890	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
2891	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_dst);
2892	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2893	0f8a249a	blueswir1	}
2894	0f8a249a	blueswir1	} else {
2895	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2896	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
2897	0f8a249a	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
2898	6ae20372	blueswir1	tcg_gen_ori_tl(cpu_dst, cpu_src1, (int)rs2);
2899	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2900	0f8a249a	blueswir1	} else { /* register */
2901	0f8a249a	blueswir1	// or x, %g0, y -> mov T1, x; mov y, T1
2902	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
2903	0f8a249a	blueswir1	if (rs2 != 0) {
2904	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
2905	6ae20372	blueswir1	tcg_gen_or_tl(cpu_dst, cpu_src1, cpu_src2);
2906	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2907	6f551262	blueswir1	} else
2908	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_src1);
2909	0f8a249a	blueswir1	}
2910	0f8a249a	blueswir1	}
2911	83469015	bellard	#ifdef TARGET_SPARC64
2912	0f8a249a	blueswir1	} else if (xop == 0x25) { /* sll, V9 sllx */
2913	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2914	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
2915	83469015	bellard	rs2 = GET_FIELDs(insn, 20, 31);
2916	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2917	6ae20372	blueswir1	tcg_gen_shli_i64(cpu_dst, cpu_src1, rs2 & 0x3f);
2918	1a2fb1c0	blueswir1	} else {
2919	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2920	6ae20372	blueswir1	tcg_gen_shli_i64(cpu_dst, cpu_dst, rs2 & 0x1f);
2921	1a2fb1c0	blueswir1	}
2922	0f8a249a	blueswir1	} else { /* register */
2923	83469015	bellard	rs2 = GET_FIELD(insn, 27, 31);
2924	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
2925	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2926	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x3f);
2927	6ae20372	blueswir1	tcg_gen_shl_i64(cpu_dst, cpu_src1, cpu_tmp0);
2928	1a2fb1c0	blueswir1	} else {
2929	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x1f);
2930	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2931	6ae20372	blueswir1	tcg_gen_shl_i64(cpu_dst, cpu_dst, cpu_tmp0);
2932	1a2fb1c0	blueswir1	}
2933	83469015	bellard	}
2934	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2935	0f8a249a	blueswir1	} else if (xop == 0x26) { /* srl, V9 srlx */
2936	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2937	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
2938	83469015	bellard	rs2 = GET_FIELDs(insn, 20, 31);
2939	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2940	6ae20372	blueswir1	tcg_gen_shri_i64(cpu_dst, cpu_src1, rs2 & 0x3f);
2941	1a2fb1c0	blueswir1	} else {
2942	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2943	6ae20372	blueswir1	tcg_gen_shri_i64(cpu_dst, cpu_dst, rs2 & 0x1f);
2944	1a2fb1c0	blueswir1	}
2945	0f8a249a	blueswir1	} else { /* register */
2946	83469015	bellard	rs2 = GET_FIELD(insn, 27, 31);
2947	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
2948	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2949	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x3f);
2950	6ae20372	blueswir1	tcg_gen_shr_i64(cpu_dst, cpu_src1, cpu_tmp0);
2951	1a2fb1c0	blueswir1	} else {
2952	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x1f);
2953	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2954	6ae20372	blueswir1	tcg_gen_shr_i64(cpu_dst, cpu_dst, cpu_tmp0);
2955	1a2fb1c0	blueswir1	}
2956	83469015	bellard	}
2957	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2958	0f8a249a	blueswir1	} else if (xop == 0x27) { /* sra, V9 srax */
2959	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2960	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
2961	83469015	bellard	rs2 = GET_FIELDs(insn, 20, 31);
2962	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2963	6ae20372	blueswir1	tcg_gen_sari_i64(cpu_dst, cpu_src1, rs2 & 0x3f);
2964	1a2fb1c0	blueswir1	} else {
2965	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2966	6ae20372	blueswir1	tcg_gen_ext_i32_i64(cpu_dst, cpu_dst);
2967	6ae20372	blueswir1	tcg_gen_sari_i64(cpu_dst, cpu_dst, rs2 & 0x1f);
2968	1a2fb1c0	blueswir1	}
2969	0f8a249a	blueswir1	} else { /* register */
2970	83469015	bellard	rs2 = GET_FIELD(insn, 27, 31);
2971	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
2972	1a2fb1c0	blueswir1	if (insn & (1 << 12)) {
2973	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x3f);
2974	6ae20372	blueswir1	tcg_gen_sar_i64(cpu_dst, cpu_src1, cpu_tmp0);
2975	1a2fb1c0	blueswir1	} else {
2976	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_tmp0, cpu_src2, 0x1f);
2977	6ae20372	blueswir1	tcg_gen_andi_i64(cpu_dst, cpu_src1, 0xffffffffULL);
2978	6ae20372	blueswir1	tcg_gen_sar_i64(cpu_dst, cpu_dst, cpu_tmp0);
2979	1a2fb1c0	blueswir1	}
2980	83469015	bellard	}
2981	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
2982	83469015	bellard	#endif
2983	fcc72045	blueswir1	} else if (xop < 0x36) {
2984	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
2985	a49d9390	blueswir1	cpu_src2 = get_src2(insn, cpu_src2);
2986	cf495bcf	bellard	if (xop < 0x20) {
2987	cf495bcf	bellard	switch (xop & ~0x10) {
2988	cf495bcf	bellard	case 0x0:
2989	cf495bcf	bellard	if (xop & 0x10)
2990	6ae20372	blueswir1	gen_op_add_cc(cpu_dst, cpu_src1, cpu_src2);
2991	cf495bcf	bellard	else
2992	6ae20372	blueswir1	tcg_gen_add_tl(cpu_dst, cpu_src1, cpu_src2);
2993	cf495bcf	bellard	break;
2994	cf495bcf	bellard	case 0x1:
2995	6ae20372	blueswir1	tcg_gen_and_tl(cpu_dst, cpu_src1, cpu_src2);
2996	cf495bcf	bellard	if (xop & 0x10)
2997	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
2998	cf495bcf	bellard	break;
2999	cf495bcf	bellard	case 0x2:
3000	6ae20372	blueswir1	tcg_gen_or_tl(cpu_dst, cpu_src1, cpu_src2);
3001	0f8a249a	blueswir1	if (xop & 0x10)
3002	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3003	0f8a249a	blueswir1	break;
3004	cf495bcf	bellard	case 0x3:
3005	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3006	cf495bcf	bellard	if (xop & 0x10)
3007	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3008	cf495bcf	bellard	break;
3009	cf495bcf	bellard	case 0x4:
3010	cf495bcf	bellard	if (xop & 0x10)
3011	6ae20372	blueswir1	gen_op_sub_cc(cpu_dst, cpu_src1, cpu_src2);
3012	cf495bcf	bellard	else
3013	6ae20372	blueswir1	tcg_gen_sub_tl(cpu_dst, cpu_src1, cpu_src2);
3014	cf495bcf	bellard	break;
3015	cf495bcf	bellard	case 0x5:
3016	6ae20372	blueswir1	tcg_gen_xori_tl(cpu_tmp0, cpu_src2, -1);
3017	6ae20372	blueswir1	tcg_gen_and_tl(cpu_dst, cpu_src1, cpu_tmp0);
3018	cf495bcf	bellard	if (xop & 0x10)
3019	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3020	cf495bcf	bellard	break;
3021	cf495bcf	bellard	case 0x6:
3022	6ae20372	blueswir1	tcg_gen_xori_tl(cpu_tmp0, cpu_src2, -1);
3023	6ae20372	blueswir1	tcg_gen_or_tl(cpu_dst, cpu_src1, cpu_tmp0);
3024	cf495bcf	bellard	if (xop & 0x10)
3025	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3026	cf495bcf	bellard	break;
3027	cf495bcf	bellard	case 0x7:
3028	6ae20372	blueswir1	tcg_gen_xori_tl(cpu_tmp0, cpu_src2, -1);
3029	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_tmp0);
3030	cf495bcf	bellard	if (xop & 0x10)
3031	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3032	cf495bcf	bellard	break;
3033	cf495bcf	bellard	case 0x8:
3034	cf495bcf	bellard	if (xop & 0x10)
3035	6ae20372	blueswir1	gen_op_addx_cc(cpu_dst, cpu_src1, cpu_src2);
3036	38bc628b	blueswir1	else {
3037	dc99a3f2	blueswir1	gen_mov_reg_C(cpu_tmp0, cpu_psr);
3038	6ae20372	blueswir1	tcg_gen_add_tl(cpu_tmp0, cpu_src2, cpu_tmp0);
3039	6ae20372	blueswir1	tcg_gen_add_tl(cpu_dst, cpu_src1, cpu_tmp0);
3040	38bc628b	blueswir1	}
3041	cf495bcf	bellard	break;
3042	ded3ab80	pbrook	#ifdef TARGET_SPARC64
3043	0f8a249a	blueswir1	case 0x9: /* V9 mulx */
3044	6ae20372	blueswir1	tcg_gen_mul_i64(cpu_dst, cpu_src1, cpu_src2);
3045	ded3ab80	pbrook	break;
3046	ded3ab80	pbrook	#endif
3047	cf495bcf	bellard	case 0xa:
3048	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, MUL);
3049	6ae20372	blueswir1	gen_op_umul(cpu_dst, cpu_src1, cpu_src2);
3050	cf495bcf	bellard	if (xop & 0x10)
3051	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3052	cf495bcf	bellard	break;
3053	cf495bcf	bellard	case 0xb:
3054	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, MUL);
3055	6ae20372	blueswir1	gen_op_smul(cpu_dst, cpu_src1, cpu_src2);
3056	cf495bcf	bellard	if (xop & 0x10)
3057	6ae20372	blueswir1	gen_op_logic_cc(cpu_dst);
3058	cf495bcf	bellard	break;
3059	cf495bcf	bellard	case 0xc:
3060	cf495bcf	bellard	if (xop & 0x10)
3061	6ae20372	blueswir1	gen_op_subx_cc(cpu_dst, cpu_src1, cpu_src2);
3062	38bc628b	blueswir1	else {
3063	dc99a3f2	blueswir1	gen_mov_reg_C(cpu_tmp0, cpu_psr);
3064	6ae20372	blueswir1	tcg_gen_add_tl(cpu_tmp0, cpu_src2, cpu_tmp0);
3065	6ae20372	blueswir1	tcg_gen_sub_tl(cpu_dst, cpu_src1, cpu_tmp0);
3066	38bc628b	blueswir1	}
3067	cf495bcf	bellard	break;
3068	ded3ab80	pbrook	#ifdef TARGET_SPARC64
3069	0f8a249a	blueswir1	case 0xd: /* V9 udivx */
3070	6ae20372	blueswir1	gen_trap_ifdivzero_tl(cpu_src2);
3071	6ae20372	blueswir1	tcg_gen_divu_i64(cpu_dst, cpu_src1, cpu_src2);
3072	ded3ab80	pbrook	break;
3073	ded3ab80	pbrook	#endif
3074	cf495bcf	bellard	case 0xe:
3075	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, DIV);
3076	77f193da	blueswir1	tcg_gen_helper_1_2(helper_udiv, cpu_dst, cpu_src1,
3077	77f193da	blueswir1	cpu_src2);
3078	cf495bcf	bellard	if (xop & 0x10)
3079	6ae20372	blueswir1	gen_op_div_cc(cpu_dst);
3080	cf495bcf	bellard	break;
3081	cf495bcf	bellard	case 0xf:
3082	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, DIV);
3083	77f193da	blueswir1	tcg_gen_helper_1_2(helper_sdiv, cpu_dst, cpu_src1,
3084	77f193da	blueswir1	cpu_src2);
3085	cf495bcf	bellard	if (xop & 0x10)
3086	6ae20372	blueswir1	gen_op_div_cc(cpu_dst);
3087	cf495bcf	bellard	break;
3088	cf495bcf	bellard	default:
3089	cf495bcf	bellard	goto illegal_insn;
3090	cf495bcf	bellard	}
3091	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3092	cf495bcf	bellard	} else {
3093	cf495bcf	bellard	switch (xop) {
3094	0f8a249a	blueswir1	case 0x20: /* taddcc */
3095	6ae20372	blueswir1	gen_op_tadd_cc(cpu_dst, cpu_src1, cpu_src2);
3096	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3097	0f8a249a	blueswir1	break;
3098	0f8a249a	blueswir1	case 0x21: /* tsubcc */
3099	6ae20372	blueswir1	gen_op_tsub_cc(cpu_dst, cpu_src1, cpu_src2);
3100	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3101	0f8a249a	blueswir1	break;
3102	0f8a249a	blueswir1	case 0x22: /* taddcctv */
3103	6ae20372	blueswir1	save_state(dc, cpu_cond);
3104	6ae20372	blueswir1	gen_op_tadd_ccTV(cpu_dst, cpu_src1, cpu_src2);
3105	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3106	0f8a249a	blueswir1	break;
3107	0f8a249a	blueswir1	case 0x23: /* tsubcctv */
3108	6ae20372	blueswir1	save_state(dc, cpu_cond);
3109	6ae20372	blueswir1	gen_op_tsub_ccTV(cpu_dst, cpu_src1, cpu_src2);
3110	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3111	0f8a249a	blueswir1	break;
3112	cf495bcf	bellard	case 0x24: /* mulscc */
3113	6ae20372	blueswir1	gen_op_mulscc(cpu_dst, cpu_src1, cpu_src2);
3114	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3115	cf495bcf	bellard	break;
3116	83469015	bellard	#ifndef TARGET_SPARC64
3117	0f8a249a	blueswir1	case 0x25: /* sll */
3118	e35298cd	blueswir1	if (IS_IMM) { /* immediate */
3119	e35298cd	blueswir1	rs2 = GET_FIELDs(insn, 20, 31);
3120	e35298cd	blueswir1	tcg_gen_shli_tl(cpu_dst, cpu_src1, rs2 & 0x1f);
3121	e35298cd	blueswir1	} else { /* register */
3122	e35298cd	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_src2, 0x1f);
3123	e35298cd	blueswir1	tcg_gen_shl_tl(cpu_dst, cpu_src1, cpu_tmp0);
3124	e35298cd	blueswir1	}
3125	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3126	cf495bcf	bellard	break;
3127	83469015	bellard	case 0x26: /* srl */
3128	e35298cd	blueswir1	if (IS_IMM) { /* immediate */
3129	e35298cd	blueswir1	rs2 = GET_FIELDs(insn, 20, 31);
3130	e35298cd	blueswir1	tcg_gen_shri_tl(cpu_dst, cpu_src1, rs2 & 0x1f);
3131	e35298cd	blueswir1	} else { /* register */
3132	e35298cd	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_src2, 0x1f);
3133	e35298cd	blueswir1	tcg_gen_shr_tl(cpu_dst, cpu_src1, cpu_tmp0);
3134	e35298cd	blueswir1	}
3135	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3136	cf495bcf	bellard	break;
3137	83469015	bellard	case 0x27: /* sra */
3138	e35298cd	blueswir1	if (IS_IMM) { /* immediate */
3139	e35298cd	blueswir1	rs2 = GET_FIELDs(insn, 20, 31);
3140	e35298cd	blueswir1	tcg_gen_sari_tl(cpu_dst, cpu_src1, rs2 & 0x1f);
3141	e35298cd	blueswir1	} else { /* register */
3142	e35298cd	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_src2, 0x1f);
3143	e35298cd	blueswir1	tcg_gen_sar_tl(cpu_dst, cpu_src1, cpu_tmp0);
3144	e35298cd	blueswir1	}
3145	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3146	cf495bcf	bellard	break;
3147	83469015	bellard	#endif
3148	cf495bcf	bellard	case 0x30:
3149	cf495bcf	bellard	{
3150	cf495bcf	bellard	switch(rd) {
3151	3475187d	bellard	case 0: /* wry */
3152	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3153	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3154	77f193da	blueswir1	offsetof(CPUSPARCState, y));
3155	cf495bcf	bellard	break;
3156	65fe7b09	blueswir1	#ifndef TARGET_SPARC64
3157	65fe7b09	blueswir1	case 0x01 ... 0x0f: /* undefined in the
3158	65fe7b09	blueswir1	SPARCv8 manual, nop
3159	65fe7b09	blueswir1	on the microSPARC
3160	65fe7b09	blueswir1	II */
3161	65fe7b09	blueswir1	case 0x10 ... 0x1f: /* implementation-dependent
3162	65fe7b09	blueswir1	in the SPARCv8
3163	65fe7b09	blueswir1	manual, nop on the
3164	65fe7b09	blueswir1	microSPARC II */
3165	65fe7b09	blueswir1	break;
3166	65fe7b09	blueswir1	#else
3167	0f8a249a	blueswir1	case 0x2: /* V9 wrccr */
3168	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3169	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_wrccr, cpu_dst);
3170	0f8a249a	blueswir1	break;
3171	0f8a249a	blueswir1	case 0x3: /* V9 wrasi */
3172	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3173	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3174	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3175	77f193da	blueswir1	offsetof(CPUSPARCState, asi));
3176	0f8a249a	blueswir1	break;
3177	0f8a249a	blueswir1	case 0x6: /* V9 wrfprs */
3178	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3179	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3180	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3181	77f193da	blueswir1	offsetof(CPUSPARCState, fprs));
3182	6ae20372	blueswir1	save_state(dc, cpu_cond);
3183	3299908c	blueswir1	gen_op_next_insn();
3184	57fec1fe	bellard	tcg_gen_exit_tb(0);
3185	3299908c	blueswir1	dc->is_br = 1;
3186	0f8a249a	blueswir1	break;
3187	0f8a249a	blueswir1	case 0xf: /* V9 sir, nop if user */
3188	3475187d	bellard	#if !defined(CONFIG_USER_ONLY)
3189	0f8a249a	blueswir1	if (supervisor(dc))
3190	1a2fb1c0	blueswir1	; // XXX
3191	3475187d	bellard	#endif
3192	0f8a249a	blueswir1	break;
3193	0f8a249a	blueswir1	case 0x13: /* Graphics Status */
3194	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
3195	725cb90b	bellard	goto jmp_insn;
3196	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3197	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3198	77f193da	blueswir1	offsetof(CPUSPARCState, gsr));
3199	0f8a249a	blueswir1	break;
3200	0f8a249a	blueswir1	case 0x17: /* Tick compare */
3201	83469015	bellard	#if !defined(CONFIG_USER_ONLY)
3202	0f8a249a	blueswir1	if (!supervisor(dc))
3203	0f8a249a	blueswir1	goto illegal_insn;
3204	83469015	bellard	#endif
3205	ccd4a219	blueswir1	{
3206	ccd4a219	blueswir1	TCGv r_tickptr;
3207	ccd4a219	blueswir1
3208	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1,
3209	6ae20372	blueswir1	cpu_src2);
3210	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3211	77f193da	blueswir1	offsetof(CPUSPARCState,
3212	77f193da	blueswir1	tick_cmpr));
3213	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
3214	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
3215	ccd4a219	blueswir1	offsetof(CPUState, tick));
3216	ccd4a219	blueswir1	tcg_gen_helper_0_2(helper_tick_set_limit,
3217	6ae20372	blueswir1	r_tickptr, cpu_dst);
3218	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
3219	ccd4a219	blueswir1	}
3220	0f8a249a	blueswir1	break;
3221	0f8a249a	blueswir1	case 0x18: /* System tick */
3222	83469015	bellard	#if !defined(CONFIG_USER_ONLY)
3223	0f8a249a	blueswir1	if (!supervisor(dc))
3224	0f8a249a	blueswir1	goto illegal_insn;
3225	83469015	bellard	#endif
3226	ccd4a219	blueswir1	{
3227	ccd4a219	blueswir1	TCGv r_tickptr;
3228	ccd4a219	blueswir1
3229	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1,
3230	6ae20372	blueswir1	cpu_src2);
3231	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
3232	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
3233	ccd4a219	blueswir1	offsetof(CPUState, stick));
3234	ccd4a219	blueswir1	tcg_gen_helper_0_2(helper_tick_set_count,
3235	6ae20372	blueswir1	r_tickptr, cpu_dst);
3236	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
3237	ccd4a219	blueswir1	}
3238	0f8a249a	blueswir1	break;
3239	0f8a249a	blueswir1	case 0x19: /* System tick compare */
3240	83469015	bellard	#if !defined(CONFIG_USER_ONLY)
3241	0f8a249a	blueswir1	if (!supervisor(dc))
3242	0f8a249a	blueswir1	goto illegal_insn;
3243	3475187d	bellard	#endif
3244	ccd4a219	blueswir1	{
3245	ccd4a219	blueswir1	TCGv r_tickptr;
3246	ccd4a219	blueswir1
3247	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1,
3248	6ae20372	blueswir1	cpu_src2);
3249	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3250	77f193da	blueswir1	offsetof(CPUSPARCState,
3251	77f193da	blueswir1	stick_cmpr));
3252	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
3253	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
3254	ccd4a219	blueswir1	offsetof(CPUState, stick));
3255	ccd4a219	blueswir1	tcg_gen_helper_0_2(helper_tick_set_limit,
3256	6ae20372	blueswir1	r_tickptr, cpu_dst);
3257	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
3258	ccd4a219	blueswir1	}
3259	0f8a249a	blueswir1	break;
3260	83469015	bellard
3261	0f8a249a	blueswir1	case 0x10: /* Performance Control */
3262	77f193da	blueswir1	case 0x11: /* Performance Instrumentation
3263	77f193da	blueswir1	Counter */
3264	0f8a249a	blueswir1	case 0x12: /* Dispatch Control */
3265	0f8a249a	blueswir1	case 0x14: /* Softint set */
3266	0f8a249a	blueswir1	case 0x15: /* Softint clear */
3267	0f8a249a	blueswir1	case 0x16: /* Softint write */
3268	83469015	bellard	#endif
3269	3475187d	bellard	default:
3270	cf495bcf	bellard	goto illegal_insn;
3271	cf495bcf	bellard	}
3272	cf495bcf	bellard	}
3273	cf495bcf	bellard	break;
3274	e8af50a3	bellard	#if !defined(CONFIG_USER_ONLY)
3275	af7bf89b	bellard	case 0x31: /* wrpsr, V9 saved, restored */
3276	e8af50a3	bellard	{
3277	0f8a249a	blueswir1	if (!supervisor(dc))
3278	0f8a249a	blueswir1	goto priv_insn;
3279	3475187d	bellard	#ifdef TARGET_SPARC64
3280	0f8a249a	blueswir1	switch (rd) {
3281	0f8a249a	blueswir1	case 0:
3282	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_saved);
3283	0f8a249a	blueswir1	break;
3284	0f8a249a	blueswir1	case 1:
3285	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_restored);
3286	0f8a249a	blueswir1	break;
3287	e9ebed4d	blueswir1	case 2: /* UA2005 allclean */
3288	e9ebed4d	blueswir1	case 3: /* UA2005 otherw */
3289	e9ebed4d	blueswir1	case 4: /* UA2005 normalw */
3290	e9ebed4d	blueswir1	case 5: /* UA2005 invalw */
3291	e9ebed4d	blueswir1	// XXX
3292	0f8a249a	blueswir1	default:
3293	3475187d	bellard	goto illegal_insn;
3294	3475187d	bellard	}
3295	3475187d	bellard	#else
3296	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3297	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_wrpsr, cpu_dst);
3298	6ae20372	blueswir1	save_state(dc, cpu_cond);
3299	9e61bde5	bellard	gen_op_next_insn();
3300	57fec1fe	bellard	tcg_gen_exit_tb(0);
3301	0f8a249a	blueswir1	dc->is_br = 1;
3302	3475187d	bellard	#endif
3303	e8af50a3	bellard	}
3304	e8af50a3	bellard	break;
3305	af7bf89b	bellard	case 0x32: /* wrwim, V9 wrpr */
3306	e8af50a3	bellard	{
3307	0f8a249a	blueswir1	if (!supervisor(dc))
3308	0f8a249a	blueswir1	goto priv_insn;
3309	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_src1, cpu_src2);
3310	3475187d	bellard	#ifdef TARGET_SPARC64
3311	0f8a249a	blueswir1	switch (rd) {
3312	0f8a249a	blueswir1	case 0: // tpc
3313	375ee38b	blueswir1	{
3314	375ee38b	blueswir1	TCGv r_tsptr;
3315	375ee38b	blueswir1
3316	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
3317	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
3318	375ee38b	blueswir1	offsetof(CPUState, tsptr));
3319	6ae20372	blueswir1	tcg_gen_st_tl(cpu_dst, r_tsptr,
3320	375ee38b	blueswir1	offsetof(trap_state, tpc));
3321	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
3322	375ee38b	blueswir1	}
3323	0f8a249a	blueswir1	break;
3324	0f8a249a	blueswir1	case 1: // tnpc
3325	375ee38b	blueswir1	{
3326	375ee38b	blueswir1	TCGv r_tsptr;
3327	375ee38b	blueswir1
3328	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
3329	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
3330	375ee38b	blueswir1	offsetof(CPUState, tsptr));
3331	6ae20372	blueswir1	tcg_gen_st_tl(cpu_dst, r_tsptr,
3332	375ee38b	blueswir1	offsetof(trap_state, tnpc));
3333	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
3334	375ee38b	blueswir1	}
3335	0f8a249a	blueswir1	break;
3336	0f8a249a	blueswir1	case 2: // tstate
3337	375ee38b	blueswir1	{
3338	375ee38b	blueswir1	TCGv r_tsptr;
3339	375ee38b	blueswir1
3340	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
3341	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
3342	375ee38b	blueswir1	offsetof(CPUState, tsptr));
3343	6ae20372	blueswir1	tcg_gen_st_tl(cpu_dst, r_tsptr,
3344	77f193da	blueswir1	offsetof(trap_state,
3345	77f193da	blueswir1	tstate));
3346	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
3347	375ee38b	blueswir1	}
3348	0f8a249a	blueswir1	break;
3349	0f8a249a	blueswir1	case 3: // tt
3350	375ee38b	blueswir1	{
3351	375ee38b	blueswir1	TCGv r_tsptr;
3352	375ee38b	blueswir1
3353	375ee38b	blueswir1	r_tsptr = tcg_temp_new(TCG_TYPE_PTR);
3354	375ee38b	blueswir1	tcg_gen_ld_ptr(r_tsptr, cpu_env,
3355	375ee38b	blueswir1	offsetof(CPUState, tsptr));
3356	6ae20372	blueswir1	tcg_gen_st_i32(cpu_dst, r_tsptr,
3357	375ee38b	blueswir1	offsetof(trap_state, tt));
3358	2ea815ca	blueswir1	tcg_temp_free(r_tsptr);
3359	375ee38b	blueswir1	}
3360	0f8a249a	blueswir1	break;
3361	0f8a249a	blueswir1	case 4: // tick
3362	ccd4a219	blueswir1	{
3363	ccd4a219	blueswir1	TCGv r_tickptr;
3364	ccd4a219	blueswir1
3365	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
3366	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
3367	ccd4a219	blueswir1	offsetof(CPUState, tick));
3368	ccd4a219	blueswir1	tcg_gen_helper_0_2(helper_tick_set_count,
3369	6ae20372	blueswir1	r_tickptr, cpu_dst);
3370	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
3371	ccd4a219	blueswir1	}
3372	0f8a249a	blueswir1	break;
3373	0f8a249a	blueswir1	case 5: // tba
3374	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3375	77f193da	blueswir1	offsetof(CPUSPARCState, tbr));
3376	0f8a249a	blueswir1	break;
3377	0f8a249a	blueswir1	case 6: // pstate
3378	6ae20372	blueswir1	save_state(dc, cpu_cond);
3379	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_wrpstate, cpu_dst);
3380	ded3ab80	pbrook	gen_op_next_insn();
3381	57fec1fe	bellard	tcg_gen_exit_tb(0);
3382	ded3ab80	pbrook	dc->is_br = 1;
3383	0f8a249a	blueswir1	break;
3384	0f8a249a	blueswir1	case 7: // tl
3385	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3386	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3387	77f193da	blueswir1	offsetof(CPUSPARCState, tl));
3388	0f8a249a	blueswir1	break;
3389	0f8a249a	blueswir1	case 8: // pil
3390	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3391	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3392	77f193da	blueswir1	offsetof(CPUSPARCState,
3393	77f193da	blueswir1	psrpil));
3394	0f8a249a	blueswir1	break;
3395	0f8a249a	blueswir1	case 9: // cwp
3396	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_wrcwp, cpu_dst);
3397	0f8a249a	blueswir1	break;
3398	0f8a249a	blueswir1	case 10: // cansave
3399	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3400	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3401	77f193da	blueswir1	offsetof(CPUSPARCState,
3402	77f193da	blueswir1	cansave));
3403	0f8a249a	blueswir1	break;
3404	0f8a249a	blueswir1	case 11: // canrestore
3405	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3406	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3407	77f193da	blueswir1	offsetof(CPUSPARCState,
3408	77f193da	blueswir1	canrestore));
3409	0f8a249a	blueswir1	break;
3410	0f8a249a	blueswir1	case 12: // cleanwin
3411	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3412	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3413	77f193da	blueswir1	offsetof(CPUSPARCState,
3414	77f193da	blueswir1	cleanwin));
3415	0f8a249a	blueswir1	break;
3416	0f8a249a	blueswir1	case 13: // otherwin
3417	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3418	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3419	77f193da	blueswir1	offsetof(CPUSPARCState,
3420	77f193da	blueswir1	otherwin));
3421	0f8a249a	blueswir1	break;
3422	0f8a249a	blueswir1	case 14: // wstate
3423	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3424	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3425	77f193da	blueswir1	offsetof(CPUSPARCState,
3426	77f193da	blueswir1	wstate));
3427	0f8a249a	blueswir1	break;
3428	e9ebed4d	blueswir1	case 16: // UA2005 gl
3429	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3430	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3431	77f193da	blueswir1	offsetof(CPUSPARCState, gl));
3432	e9ebed4d	blueswir1	break;
3433	e9ebed4d	blueswir1	case 26: // UA2005 strand status
3434	e9ebed4d	blueswir1	if (!hypervisor(dc))
3435	e9ebed4d	blueswir1	goto priv_insn;
3436	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3437	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3438	77f193da	blueswir1	offsetof(CPUSPARCState, ssr));
3439	e9ebed4d	blueswir1	break;
3440	0f8a249a	blueswir1	default:
3441	0f8a249a	blueswir1	goto illegal_insn;
3442	0f8a249a	blueswir1	}
3443	3475187d	bellard	#else
3444	77f193da	blueswir1	tcg_gen_andi_tl(cpu_dst, cpu_dst,
3445	77f193da	blueswir1	((1 << NWINDOWS) - 1));
3446	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3447	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3448	77f193da	blueswir1	offsetof(CPUSPARCState, wim));
3449	3475187d	bellard	#endif
3450	e8af50a3	bellard	}
3451	e8af50a3	bellard	break;
3452	e9ebed4d	blueswir1	case 0x33: /* wrtbr, UA2005 wrhpr */
3453	e8af50a3	bellard	{
3454	e9ebed4d	blueswir1	#ifndef TARGET_SPARC64
3455	0f8a249a	blueswir1	if (!supervisor(dc))
3456	0f8a249a	blueswir1	goto priv_insn;
3457	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_dst, cpu_src2);
3458	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3459	77f193da	blueswir1	offsetof(CPUSPARCState, tbr));
3460	e9ebed4d	blueswir1	#else
3461	e9ebed4d	blueswir1	if (!hypervisor(dc))
3462	e9ebed4d	blueswir1	goto priv_insn;
3463	6ae20372	blueswir1	tcg_gen_xor_tl(cpu_dst, cpu_dst, cpu_src2);
3464	e9ebed4d	blueswir1	switch (rd) {
3465	e9ebed4d	blueswir1	case 0: // hpstate
3466	e9ebed4d	blueswir1	// XXX gen_op_wrhpstate();
3467	6ae20372	blueswir1	save_state(dc, cpu_cond);
3468	e9ebed4d	blueswir1	gen_op_next_insn();
3469	57fec1fe	bellard	tcg_gen_exit_tb(0);
3470	e9ebed4d	blueswir1	dc->is_br = 1;
3471	e9ebed4d	blueswir1	break;
3472	e9ebed4d	blueswir1	case 1: // htstate
3473	e9ebed4d	blueswir1	// XXX gen_op_wrhtstate();
3474	e9ebed4d	blueswir1	break;
3475	e9ebed4d	blueswir1	case 3: // hintp
3476	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3477	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3478	77f193da	blueswir1	offsetof(CPUSPARCState, hintp));
3479	e9ebed4d	blueswir1	break;
3480	e9ebed4d	blueswir1	case 5: // htba
3481	6ae20372	blueswir1	tcg_gen_trunc_tl_i32(cpu_tmp32, cpu_dst);
3482	77f193da	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
3483	77f193da	blueswir1	offsetof(CPUSPARCState, htba));
3484	e9ebed4d	blueswir1	break;
3485	e9ebed4d	blueswir1	case 31: // hstick_cmpr
3486	ccd4a219	blueswir1	{
3487	ccd4a219	blueswir1	TCGv r_tickptr;
3488	ccd4a219	blueswir1
3489	77f193da	blueswir1	tcg_gen_st_tl(cpu_dst, cpu_env,
3490	77f193da	blueswir1	offsetof(CPUSPARCState,
3491	77f193da	blueswir1	hstick_cmpr));
3492	ccd4a219	blueswir1	r_tickptr = tcg_temp_new(TCG_TYPE_PTR);
3493	ccd4a219	blueswir1	tcg_gen_ld_ptr(r_tickptr, cpu_env,
3494	ccd4a219	blueswir1	offsetof(CPUState, hstick));
3495	ccd4a219	blueswir1	tcg_gen_helper_0_2(helper_tick_set_limit,
3496	6ae20372	blueswir1	r_tickptr, cpu_dst);
3497	2ea815ca	blueswir1	tcg_temp_free(r_tickptr);
3498	ccd4a219	blueswir1	}
3499	e9ebed4d	blueswir1	break;
3500	e9ebed4d	blueswir1	case 6: // hver readonly
3501	e9ebed4d	blueswir1	default:
3502	e9ebed4d	blueswir1	goto illegal_insn;
3503	e9ebed4d	blueswir1	}
3504	e9ebed4d	blueswir1	#endif
3505	e8af50a3	bellard	}
3506	e8af50a3	bellard	break;
3507	e8af50a3	bellard	#endif
3508	3475187d	bellard	#ifdef TARGET_SPARC64
3509	0f8a249a	blueswir1	case 0x2c: /* V9 movcc */
3510	0f8a249a	blueswir1	{
3511	0f8a249a	blueswir1	int cc = GET_FIELD_SP(insn, 11, 12);
3512	0f8a249a	blueswir1	int cond = GET_FIELD_SP(insn, 14, 17);
3513	748b9d8e	blueswir1	TCGv r_cond;
3514	00f219bf	blueswir1	int l1;
3515	00f219bf	blueswir1
3516	748b9d8e	blueswir1	r_cond = tcg_temp_new(TCG_TYPE_TL);
3517	0f8a249a	blueswir1	if (insn & (1 << 18)) {
3518	0f8a249a	blueswir1	if (cc == 0)
3519	748b9d8e	blueswir1	gen_cond(r_cond, 0, cond);
3520	0f8a249a	blueswir1	else if (cc == 2)
3521	748b9d8e	blueswir1	gen_cond(r_cond, 1, cond);
3522	0f8a249a	blueswir1	else
3523	0f8a249a	blueswir1	goto illegal_insn;
3524	0f8a249a	blueswir1	} else {
3525	748b9d8e	blueswir1	gen_fcond(r_cond, cc, cond);
3526	0f8a249a	blueswir1	}
3527	00f219bf	blueswir1
3528	00f219bf	blueswir1	l1 = gen_new_label();
3529	00f219bf	blueswir1
3530	cb63669a	pbrook	tcg_gen_brcondi_tl(TCG_COND_EQ, r_cond, 0, l1);
3531	00f219bf	blueswir1	if (IS_IMM) { /* immediate */
3532	2ea815ca	blueswir1	TCGv r_const;
3533	2ea815ca	blueswir1
3534	00f219bf	blueswir1	rs2 = GET_FIELD_SPs(insn, 0, 10);
3535	2ea815ca	blueswir1	r_const = tcg_const_tl((int)rs2);
3536	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
3537	2ea815ca	blueswir1	tcg_temp_free(r_const);
3538	00f219bf	blueswir1	} else {
3539	00f219bf	blueswir1	rs2 = GET_FIELD_SP(insn, 0, 4);
3540	9c6c6662	blueswir1	gen_movl_reg_TN(rs2, cpu_tmp0);
3541	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_tmp0);
3542	00f219bf	blueswir1	}
3543	00f219bf	blueswir1	gen_set_label(l1);
3544	2ea815ca	blueswir1	tcg_temp_free(r_cond);
3545	0f8a249a	blueswir1	break;
3546	0f8a249a	blueswir1	}
3547	0f8a249a	blueswir1	case 0x2d: /* V9 sdivx */
3548	6ae20372	blueswir1	gen_op_sdivx(cpu_dst, cpu_src1, cpu_src2);
3549	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3550	0f8a249a	blueswir1	break;
3551	0f8a249a	blueswir1	case 0x2e: /* V9 popc */
3552	0f8a249a	blueswir1	{
3553	a49d9390	blueswir1	cpu_src2 = get_src2(insn, cpu_src2);
3554	6ae20372	blueswir1	tcg_gen_helper_1_1(helper_popc, cpu_dst,
3555	6ae20372	blueswir1	cpu_src2);
3556	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3557	0f8a249a	blueswir1	}
3558	0f8a249a	blueswir1	case 0x2f: /* V9 movr */
3559	0f8a249a	blueswir1	{
3560	0f8a249a	blueswir1	int cond = GET_FIELD_SP(insn, 10, 12);
3561	00f219bf	blueswir1	int l1;
3562	00f219bf	blueswir1
3563	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
3564	00f219bf	blueswir1
3565	00f219bf	blueswir1	l1 = gen_new_label();
3566	00f219bf	blueswir1
3567	cb63669a	pbrook	tcg_gen_brcondi_tl(gen_tcg_cond_reg[cond],
3568	cb63669a	pbrook	cpu_src1, 0, l1);
3569	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
3570	2ea815ca	blueswir1	TCGv r_const;
3571	2ea815ca	blueswir1
3572	0f8a249a	blueswir1	rs2 = GET_FIELD_SPs(insn, 0, 9);
3573	2ea815ca	blueswir1	r_const = tcg_const_tl((int)rs2);
3574	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
3575	2ea815ca	blueswir1	tcg_temp_free(r_const);
3576	00f219bf	blueswir1	} else {
3577	0f8a249a	blueswir1	rs2 = GET_FIELD_SP(insn, 0, 4);
3578	9c6c6662	blueswir1	gen_movl_reg_TN(rs2, cpu_tmp0);
3579	9c6c6662	blueswir1	gen_movl_TN_reg(rd, cpu_tmp0);
3580	0f8a249a	blueswir1	}
3581	00f219bf	blueswir1	gen_set_label(l1);
3582	0f8a249a	blueswir1	break;
3583	0f8a249a	blueswir1	}
3584	0f8a249a	blueswir1	#endif
3585	0f8a249a	blueswir1	default:
3586	0f8a249a	blueswir1	goto illegal_insn;
3587	0f8a249a	blueswir1	}
3588	0f8a249a	blueswir1	}
3589	3299908c	blueswir1	} else if (xop == 0x36) { /* UltraSparc shutdown, VIS, V8 CPop1 */
3590	3299908c	blueswir1	#ifdef TARGET_SPARC64
3591	3299908c	blueswir1	int opf = GET_FIELD_SP(insn, 5, 13);
3592	3299908c	blueswir1	rs1 = GET_FIELD(insn, 13, 17);
3593	3299908c	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
3594	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
3595	e9ebed4d	blueswir1	goto jmp_insn;
3596	3299908c	blueswir1
3597	3299908c	blueswir1	switch (opf) {
3598	e9ebed4d	blueswir1	case 0x000: /* VIS I edge8cc */
3599	e9ebed4d	blueswir1	case 0x001: /* VIS II edge8n */
3600	e9ebed4d	blueswir1	case 0x002: /* VIS I edge8lcc */
3601	e9ebed4d	blueswir1	case 0x003: /* VIS II edge8ln */
3602	e9ebed4d	blueswir1	case 0x004: /* VIS I edge16cc */
3603	e9ebed4d	blueswir1	case 0x005: /* VIS II edge16n */
3604	e9ebed4d	blueswir1	case 0x006: /* VIS I edge16lcc */
3605	e9ebed4d	blueswir1	case 0x007: /* VIS II edge16ln */
3606	e9ebed4d	blueswir1	case 0x008: /* VIS I edge32cc */
3607	e9ebed4d	blueswir1	case 0x009: /* VIS II edge32n */
3608	e9ebed4d	blueswir1	case 0x00a: /* VIS I edge32lcc */
3609	e9ebed4d	blueswir1	case 0x00b: /* VIS II edge32ln */
3610	e9ebed4d	blueswir1	// XXX
3611	e9ebed4d	blueswir1	goto illegal_insn;
3612	e9ebed4d	blueswir1	case 0x010: /* VIS I array8 */
3613	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3614	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
3615	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
3616	6ae20372	blueswir1	tcg_gen_helper_1_2(helper_array8, cpu_dst, cpu_src1,
3617	6ae20372	blueswir1	cpu_src2);
3618	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3619	e9ebed4d	blueswir1	break;
3620	e9ebed4d	blueswir1	case 0x012: /* VIS I array16 */
3621	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3622	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
3623	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
3624	6ae20372	blueswir1	tcg_gen_helper_1_2(helper_array8, cpu_dst, cpu_src1,
3625	6ae20372	blueswir1	cpu_src2);
3626	6ae20372	blueswir1	tcg_gen_shli_i64(cpu_dst, cpu_dst, 1);
3627	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3628	e9ebed4d	blueswir1	break;
3629	e9ebed4d	blueswir1	case 0x014: /* VIS I array32 */
3630	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3631	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
3632	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
3633	6ae20372	blueswir1	tcg_gen_helper_1_2(helper_array8, cpu_dst, cpu_src1,
3634	6ae20372	blueswir1	cpu_src2);
3635	6ae20372	blueswir1	tcg_gen_shli_i64(cpu_dst, cpu_dst, 2);
3636	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3637	e9ebed4d	blueswir1	break;
3638	3299908c	blueswir1	case 0x018: /* VIS I alignaddr */
3639	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3640	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
3641	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
3642	6ae20372	blueswir1	tcg_gen_helper_1_2(helper_alignaddr, cpu_dst, cpu_src1,
3643	6ae20372	blueswir1	cpu_src2);
3644	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
3645	3299908c	blueswir1	break;
3646	e9ebed4d	blueswir1	case 0x019: /* VIS II bmask */
3647	3299908c	blueswir1	case 0x01a: /* VIS I alignaddrl */
3648	3299908c	blueswir1	// XXX
3649	e9ebed4d	blueswir1	goto illegal_insn;
3650	e9ebed4d	blueswir1	case 0x020: /* VIS I fcmple16 */
3651	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3652	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3653	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3654	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmple16);
3655	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3656	e9ebed4d	blueswir1	break;
3657	e9ebed4d	blueswir1	case 0x022: /* VIS I fcmpne16 */
3658	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3659	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3660	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3661	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpne16);
3662	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3663	3299908c	blueswir1	break;
3664	e9ebed4d	blueswir1	case 0x024: /* VIS I fcmple32 */
3665	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3666	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3667	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3668	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmple32);
3669	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3670	e9ebed4d	blueswir1	break;
3671	e9ebed4d	blueswir1	case 0x026: /* VIS I fcmpne32 */
3672	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3673	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3674	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3675	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpne32);
3676	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3677	e9ebed4d	blueswir1	break;
3678	e9ebed4d	blueswir1	case 0x028: /* VIS I fcmpgt16 */
3679	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3680	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3681	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3682	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpgt16);
3683	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3684	e9ebed4d	blueswir1	break;
3685	e9ebed4d	blueswir1	case 0x02a: /* VIS I fcmpeq16 */
3686	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3687	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3688	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3689	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpeq16);
3690	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3691	e9ebed4d	blueswir1	break;
3692	e9ebed4d	blueswir1	case 0x02c: /* VIS I fcmpgt32 */
3693	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3694	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3695	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3696	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpgt32);
3697	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3698	e9ebed4d	blueswir1	break;
3699	e9ebed4d	blueswir1	case 0x02e: /* VIS I fcmpeq32 */
3700	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3701	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3702	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3703	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fcmpeq32);
3704	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3705	e9ebed4d	blueswir1	break;
3706	e9ebed4d	blueswir1	case 0x031: /* VIS I fmul8x16 */
3707	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3708	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3709	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3710	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmul8x16);
3711	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3712	e9ebed4d	blueswir1	break;
3713	e9ebed4d	blueswir1	case 0x033: /* VIS I fmul8x16au */
3714	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3715	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3716	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3717	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmul8x16au);
3718	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3719	e9ebed4d	blueswir1	break;
3720	e9ebed4d	blueswir1	case 0x035: /* VIS I fmul8x16al */
3721	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3722	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3723	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3724	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmul8x16al);
3725	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3726	e9ebed4d	blueswir1	break;
3727	e9ebed4d	blueswir1	case 0x036: /* VIS I fmul8sux16 */
3728	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3729	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3730	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3731	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmul8sux16);
3732	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3733	e9ebed4d	blueswir1	break;
3734	e9ebed4d	blueswir1	case 0x037: /* VIS I fmul8ulx16 */
3735	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3736	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3737	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3738	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmul8ulx16);
3739	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3740	e9ebed4d	blueswir1	break;
3741	e9ebed4d	blueswir1	case 0x038: /* VIS I fmuld8sux16 */
3742	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3743	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3744	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3745	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmuld8sux16);
3746	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3747	e9ebed4d	blueswir1	break;
3748	e9ebed4d	blueswir1	case 0x039: /* VIS I fmuld8ulx16 */
3749	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3750	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3751	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3752	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fmuld8ulx16);
3753	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3754	e9ebed4d	blueswir1	break;
3755	e9ebed4d	blueswir1	case 0x03a: /* VIS I fpack32 */
3756	e9ebed4d	blueswir1	case 0x03b: /* VIS I fpack16 */
3757	e9ebed4d	blueswir1	case 0x03d: /* VIS I fpackfix */
3758	e9ebed4d	blueswir1	case 0x03e: /* VIS I pdist */
3759	e9ebed4d	blueswir1	// XXX
3760	e9ebed4d	blueswir1	goto illegal_insn;
3761	3299908c	blueswir1	case 0x048: /* VIS I faligndata */
3762	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3763	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3764	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3765	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_faligndata);
3766	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3767	3299908c	blueswir1	break;
3768	e9ebed4d	blueswir1	case 0x04b: /* VIS I fpmerge */
3769	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3770	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3771	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3772	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpmerge);
3773	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3774	e9ebed4d	blueswir1	break;
3775	e9ebed4d	blueswir1	case 0x04c: /* VIS II bshuffle */
3776	e9ebed4d	blueswir1	// XXX
3777	e9ebed4d	blueswir1	goto illegal_insn;
3778	e9ebed4d	blueswir1	case 0x04d: /* VIS I fexpand */
3779	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3780	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3781	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3782	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fexpand);
3783	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3784	e9ebed4d	blueswir1	break;
3785	e9ebed4d	blueswir1	case 0x050: /* VIS I fpadd16 */
3786	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3787	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3788	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3789	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpadd16);
3790	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3791	e9ebed4d	blueswir1	break;
3792	e9ebed4d	blueswir1	case 0x051: /* VIS I fpadd16s */
3793	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3794	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3795	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3796	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpadd16s);
3797	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3798	e9ebed4d	blueswir1	break;
3799	e9ebed4d	blueswir1	case 0x052: /* VIS I fpadd32 */
3800	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3801	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3802	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3803	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpadd32);
3804	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3805	e9ebed4d	blueswir1	break;
3806	e9ebed4d	blueswir1	case 0x053: /* VIS I fpadd32s */
3807	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3808	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3809	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3810	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpadd32s);
3811	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3812	e9ebed4d	blueswir1	break;
3813	e9ebed4d	blueswir1	case 0x054: /* VIS I fpsub16 */
3814	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3815	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3816	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3817	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpsub16);
3818	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3819	e9ebed4d	blueswir1	break;
3820	e9ebed4d	blueswir1	case 0x055: /* VIS I fpsub16s */
3821	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3822	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3823	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3824	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpsub16s);
3825	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3826	e9ebed4d	blueswir1	break;
3827	e9ebed4d	blueswir1	case 0x056: /* VIS I fpsub32 */
3828	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3829	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3830	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3831	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpadd32);
3832	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3833	e9ebed4d	blueswir1	break;
3834	e9ebed4d	blueswir1	case 0x057: /* VIS I fpsub32s */
3835	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3836	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3837	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3838	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fpsub32s);
3839	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3840	e9ebed4d	blueswir1	break;
3841	3299908c	blueswir1	case 0x060: /* VIS I fzero */
3842	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3843	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_movl_DT0_0);
3844	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3845	3299908c	blueswir1	break;
3846	3299908c	blueswir1	case 0x061: /* VIS I fzeros */
3847	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3848	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_movl_FT0_0);
3849	3299908c	blueswir1	gen_op_store_FT0_fpr(rd);
3850	3299908c	blueswir1	break;
3851	e9ebed4d	blueswir1	case 0x062: /* VIS I fnor */
3852	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3853	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3854	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3855	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnor);
3856	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3857	e9ebed4d	blueswir1	break;
3858	e9ebed4d	blueswir1	case 0x063: /* VIS I fnors */
3859	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3860	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3861	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3862	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnors);
3863	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3864	e9ebed4d	blueswir1	break;
3865	e9ebed4d	blueswir1	case 0x064: /* VIS I fandnot2 */
3866	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3867	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs1));
3868	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs2));
3869	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fandnot);
3870	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3871	e9ebed4d	blueswir1	break;
3872	e9ebed4d	blueswir1	case 0x065: /* VIS I fandnot2s */
3873	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3874	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs1);
3875	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs2);
3876	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fandnots);
3877	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3878	e9ebed4d	blueswir1	break;
3879	e9ebed4d	blueswir1	case 0x066: /* VIS I fnot2 */
3880	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3881	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3882	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnot);
3883	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3884	e9ebed4d	blueswir1	break;
3885	e9ebed4d	blueswir1	case 0x067: /* VIS I fnot2s */
3886	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3887	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3888	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnot);
3889	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3890	e9ebed4d	blueswir1	break;
3891	e9ebed4d	blueswir1	case 0x068: /* VIS I fandnot1 */
3892	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3893	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3894	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3895	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fandnot);
3896	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3897	e9ebed4d	blueswir1	break;
3898	e9ebed4d	blueswir1	case 0x069: /* VIS I fandnot1s */
3899	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3900	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3901	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3902	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fandnots);
3903	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3904	e9ebed4d	blueswir1	break;
3905	e9ebed4d	blueswir1	case 0x06a: /* VIS I fnot1 */
3906	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3907	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs1));
3908	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnot);
3909	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3910	e9ebed4d	blueswir1	break;
3911	e9ebed4d	blueswir1	case 0x06b: /* VIS I fnot1s */
3912	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3913	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs1);
3914	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnot);
3915	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3916	e9ebed4d	blueswir1	break;
3917	e9ebed4d	blueswir1	case 0x06c: /* VIS I fxor */
3918	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3919	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3920	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3921	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxor);
3922	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3923	e9ebed4d	blueswir1	break;
3924	e9ebed4d	blueswir1	case 0x06d: /* VIS I fxors */
3925	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3926	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3927	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3928	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxors);
3929	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3930	e9ebed4d	blueswir1	break;
3931	e9ebed4d	blueswir1	case 0x06e: /* VIS I fnand */
3932	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3933	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3934	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3935	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnand);
3936	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3937	e9ebed4d	blueswir1	break;
3938	e9ebed4d	blueswir1	case 0x06f: /* VIS I fnands */
3939	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3940	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3941	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3942	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fnands);
3943	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3944	e9ebed4d	blueswir1	break;
3945	e9ebed4d	blueswir1	case 0x070: /* VIS I fand */
3946	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3947	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3948	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3949	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fand);
3950	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3951	e9ebed4d	blueswir1	break;
3952	e9ebed4d	blueswir1	case 0x071: /* VIS I fands */
3953	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3954	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3955	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3956	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fands);
3957	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3958	e9ebed4d	blueswir1	break;
3959	e9ebed4d	blueswir1	case 0x072: /* VIS I fxnor */
3960	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3961	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3962	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
3963	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxnor);
3964	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3965	e9ebed4d	blueswir1	break;
3966	e9ebed4d	blueswir1	case 0x073: /* VIS I fxnors */
3967	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3968	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
3969	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
3970	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fxnors);
3971	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3972	e9ebed4d	blueswir1	break;
3973	3299908c	blueswir1	case 0x074: /* VIS I fsrc1 */
3974	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3975	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
3976	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3977	3299908c	blueswir1	break;
3978	3299908c	blueswir1	case 0x075: /* VIS I fsrc1s */
3979	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3980	3299908c	blueswir1	gen_op_load_fpr_FT0(rs1);
3981	3299908c	blueswir1	gen_op_store_FT0_fpr(rd);
3982	3299908c	blueswir1	break;
3983	e9ebed4d	blueswir1	case 0x076: /* VIS I fornot2 */
3984	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3985	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs1));
3986	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs2));
3987	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fornot);
3988	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
3989	e9ebed4d	blueswir1	break;
3990	e9ebed4d	blueswir1	case 0x077: /* VIS I fornot2s */
3991	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3992	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs1);
3993	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs2);
3994	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fornots);
3995	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
3996	e9ebed4d	blueswir1	break;
3997	3299908c	blueswir1	case 0x078: /* VIS I fsrc2 */
3998	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
3999	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs2));
4000	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
4001	3299908c	blueswir1	break;
4002	3299908c	blueswir1	case 0x079: /* VIS I fsrc2s */
4003	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4004	3299908c	blueswir1	gen_op_load_fpr_FT0(rs2);
4005	3299908c	blueswir1	gen_op_store_FT0_fpr(rd);
4006	3299908c	blueswir1	break;
4007	e9ebed4d	blueswir1	case 0x07a: /* VIS I fornot1 */
4008	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4009	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
4010	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
4011	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fornot);
4012	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
4013	e9ebed4d	blueswir1	break;
4014	e9ebed4d	blueswir1	case 0x07b: /* VIS I fornot1s */
4015	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4016	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
4017	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
4018	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fornots);
4019	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
4020	e9ebed4d	blueswir1	break;
4021	e9ebed4d	blueswir1	case 0x07c: /* VIS I for */
4022	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4023	2382dc6b	blueswir1	gen_op_load_fpr_DT0(DFPREG(rs1));
4024	2382dc6b	blueswir1	gen_op_load_fpr_DT1(DFPREG(rs2));
4025	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_for);
4026	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
4027	e9ebed4d	blueswir1	break;
4028	e9ebed4d	blueswir1	case 0x07d: /* VIS I fors */
4029	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4030	e9ebed4d	blueswir1	gen_op_load_fpr_FT0(rs1);
4031	e9ebed4d	blueswir1	gen_op_load_fpr_FT1(rs2);
4032	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_fors);
4033	e9ebed4d	blueswir1	gen_op_store_FT0_fpr(rd);
4034	e9ebed4d	blueswir1	break;
4035	3299908c	blueswir1	case 0x07e: /* VIS I fone */
4036	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4037	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_movl_DT0_1);
4038	2382dc6b	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
4039	3299908c	blueswir1	break;
4040	3299908c	blueswir1	case 0x07f: /* VIS I fones */
4041	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, VIS1);
4042	44e7757c	blueswir1	tcg_gen_helper_0_0(helper_movl_FT0_1);
4043	3299908c	blueswir1	gen_op_store_FT0_fpr(rd);
4044	3299908c	blueswir1	break;
4045	e9ebed4d	blueswir1	case 0x080: /* VIS I shutdown */
4046	e9ebed4d	blueswir1	case 0x081: /* VIS II siam */
4047	e9ebed4d	blueswir1	// XXX
4048	e9ebed4d	blueswir1	goto illegal_insn;
4049	3299908c	blueswir1	default:
4050	3299908c	blueswir1	goto illegal_insn;
4051	3299908c	blueswir1	}
4052	3299908c	blueswir1	#else
4053	0f8a249a	blueswir1	goto ncp_insn;
4054	3299908c	blueswir1	#endif
4055	3299908c	blueswir1	} else if (xop == 0x37) { /* V8 CPop2, V9 impdep2 */
4056	fcc72045	blueswir1	#ifdef TARGET_SPARC64
4057	0f8a249a	blueswir1	goto illegal_insn;
4058	fcc72045	blueswir1	#else
4059	0f8a249a	blueswir1	goto ncp_insn;
4060	fcc72045	blueswir1	#endif
4061	3475187d	bellard	#ifdef TARGET_SPARC64
4062	0f8a249a	blueswir1	} else if (xop == 0x39) { /* V9 return */
4063	2ea815ca	blueswir1	TCGv r_const;
4064	2ea815ca	blueswir1
4065	6ae20372	blueswir1	save_state(dc, cpu_cond);
4066	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
4067	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
4068	0f8a249a	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
4069	6ae20372	blueswir1	tcg_gen_addi_tl(cpu_dst, cpu_src1, (int)rs2);
4070	0f8a249a	blueswir1	} else { /* register */
4071	3475187d	bellard	rs2 = GET_FIELD(insn, 27, 31);
4072	0f8a249a	blueswir1	if (rs2) {
4073	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
4074	6ae20372	blueswir1	tcg_gen_add_tl(cpu_dst, cpu_src1, cpu_src2);
4075	6f551262	blueswir1	} else
4076	6f551262	blueswir1	tcg_gen_mov_tl(cpu_dst, cpu_src1);
4077	3475187d	bellard	}
4078	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_restore);
4079	6ae20372	blueswir1	gen_mov_pc_npc(dc, cpu_cond);
4080	2ea815ca	blueswir1	r_const = tcg_const_i32(3);
4081	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_dst, r_const);
4082	2ea815ca	blueswir1	tcg_temp_free(r_const);
4083	6ae20372	blueswir1	tcg_gen_mov_tl(cpu_npc, cpu_dst);
4084	0f8a249a	blueswir1	dc->npc = DYNAMIC_PC;
4085	0f8a249a	blueswir1	goto jmp_insn;
4086	3475187d	bellard	#endif
4087	0f8a249a	blueswir1	} else {
4088	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
4089	0f8a249a	blueswir1	if (IS_IMM) { /* immediate */
4090	0f8a249a	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
4091	6ae20372	blueswir1	tcg_gen_addi_tl(cpu_dst, cpu_src1, (int)rs2);
4092	0f8a249a	blueswir1	} else { /* register */
4093	e80cfcfc	bellard	rs2 = GET_FIELD(insn, 27, 31);
4094	0f8a249a	blueswir1	if (rs2) {
4095	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
4096	6ae20372	blueswir1	tcg_gen_add_tl(cpu_dst, cpu_src1, cpu_src2);
4097	6f551262	blueswir1	} else
4098	6f551262	blueswir1	tcg_gen_mov_tl(cpu_dst, cpu_src1);
4099	cf495bcf	bellard	}
4100	0f8a249a	blueswir1	switch (xop) {
4101	0f8a249a	blueswir1	case 0x38: /* jmpl */
4102	0f8a249a	blueswir1	{
4103	2ea815ca	blueswir1	TCGv r_const;
4104	2ea815ca	blueswir1
4105	2ea815ca	blueswir1	r_const = tcg_const_tl(dc->pc);
4106	2ea815ca	blueswir1	gen_movl_TN_reg(rd, r_const);
4107	2ea815ca	blueswir1	tcg_temp_free(r_const);
4108	6ae20372	blueswir1	gen_mov_pc_npc(dc, cpu_cond);
4109	2ea815ca	blueswir1	r_const = tcg_const_i32(3);
4110	77f193da	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_dst,
4111	2ea815ca	blueswir1	r_const);
4112	2ea815ca	blueswir1	tcg_temp_free(r_const);
4113	6ae20372	blueswir1	tcg_gen_mov_tl(cpu_npc, cpu_dst);
4114	0f8a249a	blueswir1	dc->npc = DYNAMIC_PC;
4115	0f8a249a	blueswir1	}
4116	0f8a249a	blueswir1	goto jmp_insn;
4117	3475187d	bellard	#if !defined(CONFIG_USER_ONLY) && !defined(TARGET_SPARC64)
4118	0f8a249a	blueswir1	case 0x39: /* rett, V9 return */
4119	0f8a249a	blueswir1	{
4120	2ea815ca	blueswir1	TCGv r_const;
4121	2ea815ca	blueswir1
4122	0f8a249a	blueswir1	if (!supervisor(dc))
4123	0f8a249a	blueswir1	goto priv_insn;
4124	6ae20372	blueswir1	gen_mov_pc_npc(dc, cpu_cond);
4125	2ea815ca	blueswir1	r_const = tcg_const_i32(3);
4126	77f193da	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_dst,
4127	2ea815ca	blueswir1	r_const);
4128	2ea815ca	blueswir1	tcg_temp_free(r_const);
4129	6ae20372	blueswir1	tcg_gen_mov_tl(cpu_npc, cpu_dst);
4130	0f8a249a	blueswir1	dc->npc = DYNAMIC_PC;
4131	1a2fb1c0	blueswir1	tcg_gen_helper_0_0(helper_rett);
4132	0f8a249a	blueswir1	}
4133	0f8a249a	blueswir1	goto jmp_insn;
4134	0f8a249a	blueswir1	#endif
4135	0f8a249a	blueswir1	case 0x3b: /* flush */
4136	64a88d5d	blueswir1	if (!((dc)->features & CPU_FEATURE_FLUSH))
4137	64a88d5d	blueswir1	goto unimp_flush;
4138	6ae20372	blueswir1	tcg_gen_helper_0_1(helper_flush, cpu_dst);
4139	0f8a249a	blueswir1	break;
4140	0f8a249a	blueswir1	case 0x3c: /* save */
4141	6ae20372	blueswir1	save_state(dc, cpu_cond);
4142	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_save);
4143	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
4144	0f8a249a	blueswir1	break;
4145	0f8a249a	blueswir1	case 0x3d: /* restore */
4146	6ae20372	blueswir1	save_state(dc, cpu_cond);
4147	72a9747b	blueswir1	tcg_gen_helper_0_0(helper_restore);
4148	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_dst);
4149	0f8a249a	blueswir1	break;
4150	3475187d	bellard	#if !defined(CONFIG_USER_ONLY) && defined(TARGET_SPARC64)
4151	0f8a249a	blueswir1	case 0x3e: /* V9 done/retry */
4152	0f8a249a	blueswir1	{
4153	0f8a249a	blueswir1	switch (rd) {
4154	0f8a249a	blueswir1	case 0:
4155	0f8a249a	blueswir1	if (!supervisor(dc))
4156	0f8a249a	blueswir1	goto priv_insn;
4157	0f8a249a	blueswir1	dc->npc = DYNAMIC_PC;
4158	0f8a249a	blueswir1	dc->pc = DYNAMIC_PC;
4159	1a2fb1c0	blueswir1	tcg_gen_helper_0_0(helper_done);
4160	0f8a249a	blueswir1	goto jmp_insn;
4161	0f8a249a	blueswir1	case 1:
4162	0f8a249a	blueswir1	if (!supervisor(dc))
4163	0f8a249a	blueswir1	goto priv_insn;
4164	0f8a249a	blueswir1	dc->npc = DYNAMIC_PC;
4165	0f8a249a	blueswir1	dc->pc = DYNAMIC_PC;
4166	1a2fb1c0	blueswir1	tcg_gen_helper_0_0(helper_retry);
4167	0f8a249a	blueswir1	goto jmp_insn;
4168	0f8a249a	blueswir1	default:
4169	0f8a249a	blueswir1	goto illegal_insn;
4170	0f8a249a	blueswir1	}
4171	0f8a249a	blueswir1	}
4172	0f8a249a	blueswir1	break;
4173	0f8a249a	blueswir1	#endif
4174	0f8a249a	blueswir1	default:
4175	0f8a249a	blueswir1	goto illegal_insn;
4176	0f8a249a	blueswir1	}
4177	cf495bcf	bellard	}
4178	0f8a249a	blueswir1	break;
4179	0f8a249a	blueswir1	}
4180	0f8a249a	blueswir1	break;
4181	0f8a249a	blueswir1	case 3: /* load/store instructions */
4182	0f8a249a	blueswir1	{
4183	0f8a249a	blueswir1	unsigned int xop = GET_FIELD(insn, 7, 12);
4184	9322a4bf	blueswir1
4185	9322a4bf	blueswir1	cpu_src1 = get_src1(insn, cpu_src1);
4186	81ad8ba2	blueswir1	if (xop == 0x3c \|\| xop == 0x3e)
4187	81ad8ba2	blueswir1	{
4188	81ad8ba2	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
4189	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
4190	81ad8ba2	blueswir1	}
4191	81ad8ba2	blueswir1	else if (IS_IMM) { /* immediate */
4192	0f8a249a	blueswir1	rs2 = GET_FIELDs(insn, 19, 31);
4193	6ae20372	blueswir1	tcg_gen_addi_tl(cpu_addr, cpu_src1, (int)rs2);
4194	0f8a249a	blueswir1	} else { /* register */
4195	0f8a249a	blueswir1	rs2 = GET_FIELD(insn, 27, 31);
4196	0f8a249a	blueswir1	if (rs2 != 0) {
4197	6ae20372	blueswir1	gen_movl_reg_TN(rs2, cpu_src2);
4198	6ae20372	blueswir1	tcg_gen_add_tl(cpu_addr, cpu_src1, cpu_src2);
4199	6f551262	blueswir1	} else
4200	6f551262	blueswir1	tcg_gen_mov_tl(cpu_addr, cpu_src1);
4201	0f8a249a	blueswir1	}
4202	2f2ecb83	blueswir1	if (xop < 4 \|\| (xop > 7 && xop < 0x14 && xop != 0x0e) \|\|
4203	2f2ecb83	blueswir1	(xop > 0x17 && xop <= 0x1d ) \|\|
4204	2f2ecb83	blueswir1	(xop > 0x2c && xop <= 0x33) \|\| xop == 0x1f \|\| xop == 0x3d) {
4205	0f8a249a	blueswir1	switch (xop) {
4206	1a2fb1c0	blueswir1	case 0x0: /* load unsigned word */
4207	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4208	6ae20372	blueswir1	tcg_gen_qemu_ld32u(cpu_val, cpu_addr, dc->mem_idx);
4209	0f8a249a	blueswir1	break;
4210	0f8a249a	blueswir1	case 0x1: /* load unsigned byte */
4211	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4212	6ae20372	blueswir1	tcg_gen_qemu_ld8u(cpu_val, cpu_addr, dc->mem_idx);
4213	0f8a249a	blueswir1	break;
4214	0f8a249a	blueswir1	case 0x2: /* load unsigned halfword */
4215	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4216	6ae20372	blueswir1	tcg_gen_qemu_ld16u(cpu_val, cpu_addr, dc->mem_idx);
4217	0f8a249a	blueswir1	break;
4218	0f8a249a	blueswir1	case 0x3: /* load double word */
4219	0f8a249a	blueswir1	if (rd & 1)
4220	d4218d99	blueswir1	goto illegal_insn;
4221	1a2fb1c0	blueswir1	else {
4222	2ea815ca	blueswir1	TCGv r_const;
4223	2ea815ca	blueswir1
4224	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4225	2ea815ca	blueswir1	r_const = tcg_const_i32(7);
4226	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_dst,
4227	2ea815ca	blueswir1	r_const); // XXX remove
4228	2ea815ca	blueswir1	tcg_temp_free(r_const);
4229	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4230	6ae20372	blueswir1	tcg_gen_qemu_ld64(cpu_tmp64, cpu_addr, dc->mem_idx);
4231	32b6c812	blueswir1	tcg_gen_trunc_i64_tl(cpu_tmp0, cpu_tmp64);
4232	32b6c812	blueswir1	tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0xffffffffULL);
4233	32b6c812	blueswir1	gen_movl_TN_reg(rd + 1, cpu_tmp0);
4234	8911f501	blueswir1	tcg_gen_shri_i64(cpu_tmp64, cpu_tmp64, 32);
4235	6ae20372	blueswir1	tcg_gen_trunc_i64_tl(cpu_val, cpu_tmp64);
4236	6ae20372	blueswir1	tcg_gen_andi_tl(cpu_val, cpu_val, 0xffffffffULL);
4237	1a2fb1c0	blueswir1	}
4238	0f8a249a	blueswir1	break;
4239	0f8a249a	blueswir1	case 0x9: /* load signed byte */
4240	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4241	6ae20372	blueswir1	tcg_gen_qemu_ld8s(cpu_val, cpu_addr, dc->mem_idx);
4242	0f8a249a	blueswir1	break;
4243	0f8a249a	blueswir1	case 0xa: /* load signed halfword */
4244	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4245	6ae20372	blueswir1	tcg_gen_qemu_ld16s(cpu_val, cpu_addr, dc->mem_idx);
4246	0f8a249a	blueswir1	break;
4247	0f8a249a	blueswir1	case 0xd: /* ldstub -- XXX: should be atomically */
4248	2ea815ca	blueswir1	{
4249	2ea815ca	blueswir1	TCGv r_const;
4250	2ea815ca	blueswir1
4251	2ea815ca	blueswir1	ABI32_MASK(cpu_addr);
4252	2ea815ca	blueswir1	tcg_gen_qemu_ld8s(cpu_val, cpu_addr, dc->mem_idx);
4253	2ea815ca	blueswir1	r_const = tcg_const_tl(0xff);
4254	2ea815ca	blueswir1	tcg_gen_qemu_st8(r_const, cpu_addr, dc->mem_idx);
4255	2ea815ca	blueswir1	tcg_temp_free(r_const);
4256	2ea815ca	blueswir1	}
4257	0f8a249a	blueswir1	break;
4258	77f193da	blueswir1	case 0x0f: /* swap register with memory. Also
4259	77f193da	blueswir1	atomically */
4260	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, SWAP);
4261	6ae20372	blueswir1	gen_movl_reg_TN(rd, cpu_val);
4262	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4263	6ae20372	blueswir1	tcg_gen_qemu_ld32u(cpu_tmp32, cpu_addr, dc->mem_idx);
4264	6ae20372	blueswir1	tcg_gen_qemu_st32(cpu_val, cpu_addr, dc->mem_idx);
4265	6ae20372	blueswir1	tcg_gen_extu_i32_tl(cpu_val, cpu_tmp32);
4266	0f8a249a	blueswir1	break;
4267	3475187d	bellard	#if !defined(CONFIG_USER_ONLY) \|\| defined(TARGET_SPARC64)
4268	0f8a249a	blueswir1	case 0x10: /* load word alternate */
4269	3475187d	bellard	#ifndef TARGET_SPARC64
4270	0f8a249a	blueswir1	if (IS_IMM)
4271	0f8a249a	blueswir1	goto illegal_insn;
4272	0f8a249a	blueswir1	if (!supervisor(dc))
4273	0f8a249a	blueswir1	goto priv_insn;
4274	6ea4a6c8	blueswir1	#endif
4275	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4276	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 4, 0);
4277	0f8a249a	blueswir1	break;
4278	0f8a249a	blueswir1	case 0x11: /* load unsigned byte alternate */
4279	3475187d	bellard	#ifndef TARGET_SPARC64
4280	0f8a249a	blueswir1	if (IS_IMM)
4281	0f8a249a	blueswir1	goto illegal_insn;
4282	0f8a249a	blueswir1	if (!supervisor(dc))
4283	0f8a249a	blueswir1	goto priv_insn;
4284	0f8a249a	blueswir1	#endif
4285	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4286	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 1, 0);
4287	0f8a249a	blueswir1	break;
4288	0f8a249a	blueswir1	case 0x12: /* load unsigned halfword alternate */
4289	3475187d	bellard	#ifndef TARGET_SPARC64
4290	0f8a249a	blueswir1	if (IS_IMM)
4291	0f8a249a	blueswir1	goto illegal_insn;
4292	0f8a249a	blueswir1	if (!supervisor(dc))
4293	0f8a249a	blueswir1	goto priv_insn;
4294	6ea4a6c8	blueswir1	#endif
4295	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4296	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 2, 0);
4297	0f8a249a	blueswir1	break;
4298	0f8a249a	blueswir1	case 0x13: /* load double word alternate */
4299	3475187d	bellard	#ifndef TARGET_SPARC64
4300	0f8a249a	blueswir1	if (IS_IMM)
4301	0f8a249a	blueswir1	goto illegal_insn;
4302	0f8a249a	blueswir1	if (!supervisor(dc))
4303	0f8a249a	blueswir1	goto priv_insn;
4304	3475187d	bellard	#endif
4305	0f8a249a	blueswir1	if (rd & 1)
4306	d4218d99	blueswir1	goto illegal_insn;
4307	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4308	6ae20372	blueswir1	gen_ldda_asi(cpu_tmp0, cpu_val, cpu_addr, insn);
4309	32b6c812	blueswir1	gen_movl_TN_reg(rd + 1, cpu_tmp0);
4310	0f8a249a	blueswir1	break;
4311	0f8a249a	blueswir1	case 0x19: /* load signed byte alternate */
4312	3475187d	bellard	#ifndef TARGET_SPARC64
4313	0f8a249a	blueswir1	if (IS_IMM)
4314	0f8a249a	blueswir1	goto illegal_insn;
4315	0f8a249a	blueswir1	if (!supervisor(dc))
4316	0f8a249a	blueswir1	goto priv_insn;
4317	0f8a249a	blueswir1	#endif
4318	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4319	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 1, 1);
4320	0f8a249a	blueswir1	break;
4321	0f8a249a	blueswir1	case 0x1a: /* load signed halfword alternate */
4322	3475187d	bellard	#ifndef TARGET_SPARC64
4323	0f8a249a	blueswir1	if (IS_IMM)
4324	0f8a249a	blueswir1	goto illegal_insn;
4325	0f8a249a	blueswir1	if (!supervisor(dc))
4326	0f8a249a	blueswir1	goto priv_insn;
4327	6ea4a6c8	blueswir1	#endif
4328	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4329	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 2, 1);
4330	0f8a249a	blueswir1	break;
4331	0f8a249a	blueswir1	case 0x1d: /* ldstuba -- XXX: should be atomically */
4332	3475187d	bellard	#ifndef TARGET_SPARC64
4333	0f8a249a	blueswir1	if (IS_IMM)
4334	0f8a249a	blueswir1	goto illegal_insn;
4335	0f8a249a	blueswir1	if (!supervisor(dc))
4336	0f8a249a	blueswir1	goto priv_insn;
4337	0f8a249a	blueswir1	#endif
4338	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4339	6ae20372	blueswir1	gen_ldstub_asi(cpu_val, cpu_addr, insn);
4340	0f8a249a	blueswir1	break;
4341	77f193da	blueswir1	case 0x1f: /* swap reg with alt. memory. Also
4342	77f193da	blueswir1	atomically */
4343	64a88d5d	blueswir1	CHECK_IU_FEATURE(dc, SWAP);
4344	3475187d	bellard	#ifndef TARGET_SPARC64
4345	0f8a249a	blueswir1	if (IS_IMM)
4346	0f8a249a	blueswir1	goto illegal_insn;
4347	0f8a249a	blueswir1	if (!supervisor(dc))
4348	0f8a249a	blueswir1	goto priv_insn;
4349	6ea4a6c8	blueswir1	#endif
4350	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4351	6ae20372	blueswir1	gen_movl_reg_TN(rd, cpu_val);
4352	6ae20372	blueswir1	gen_swap_asi(cpu_val, cpu_addr, insn);
4353	0f8a249a	blueswir1	break;
4354	3475187d	bellard
4355	3475187d	bellard	#ifndef TARGET_SPARC64
4356	0f8a249a	blueswir1	case 0x30: /* ldc */
4357	0f8a249a	blueswir1	case 0x31: /* ldcsr */
4358	0f8a249a	blueswir1	case 0x33: /* lddc */
4359	0f8a249a	blueswir1	goto ncp_insn;
4360	3475187d	bellard	#endif
4361	3475187d	bellard	#endif
4362	3475187d	bellard	#ifdef TARGET_SPARC64
4363	0f8a249a	blueswir1	case 0x08: /* V9 ldsw */
4364	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4365	6ae20372	blueswir1	tcg_gen_qemu_ld32s(cpu_val, cpu_addr, dc->mem_idx);
4366	0f8a249a	blueswir1	break;
4367	0f8a249a	blueswir1	case 0x0b: /* V9 ldx */
4368	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4369	6ae20372	blueswir1	tcg_gen_qemu_ld64(cpu_val, cpu_addr, dc->mem_idx);
4370	0f8a249a	blueswir1	break;
4371	0f8a249a	blueswir1	case 0x18: /* V9 ldswa */
4372	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4373	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 4, 1);
4374	0f8a249a	blueswir1	break;
4375	0f8a249a	blueswir1	case 0x1b: /* V9 ldxa */
4376	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4377	6ae20372	blueswir1	gen_ld_asi(cpu_val, cpu_addr, insn, 8, 0);
4378	0f8a249a	blueswir1	break;
4379	0f8a249a	blueswir1	case 0x2d: /* V9 prefetch, no effect */
4380	0f8a249a	blueswir1	goto skip_move;
4381	0f8a249a	blueswir1	case 0x30: /* V9 ldfa */
4382	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4383	6ae20372	blueswir1	gen_ldf_asi(cpu_addr, insn, 4, rd);
4384	81ad8ba2	blueswir1	goto skip_move;
4385	0f8a249a	blueswir1	case 0x33: /* V9 lddfa */
4386	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4387	6ae20372	blueswir1	gen_ldf_asi(cpu_addr, insn, 8, DFPREG(rd));
4388	81ad8ba2	blueswir1	goto skip_move;
4389	0f8a249a	blueswir1	case 0x3d: /* V9 prefetcha, no effect */
4390	0f8a249a	blueswir1	goto skip_move;
4391	0f8a249a	blueswir1	case 0x32: /* V9 ldqfa */
4392	64a88d5d	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
4393	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4394	6ae20372	blueswir1	gen_ldf_asi(cpu_addr, insn, 16, QFPREG(rd));
4395	1f587329	blueswir1	goto skip_move;
4396	1f587329	blueswir1	#endif
4397	0f8a249a	blueswir1	default:
4398	0f8a249a	blueswir1	goto illegal_insn;
4399	0f8a249a	blueswir1	}
4400	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_val);
4401	3475187d	bellard	#ifdef TARGET_SPARC64
4402	0f8a249a	blueswir1	skip_move: ;
4403	3475187d	bellard	#endif
4404	0f8a249a	blueswir1	} else if (xop >= 0x20 && xop < 0x24) {
4405	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
4406	a80dde08	bellard	goto jmp_insn;
4407	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4408	0f8a249a	blueswir1	switch (xop) {
4409	0f8a249a	blueswir1	case 0x20: /* load fpreg */
4410	c2bc0e38	blueswir1	ABI32_MASK(cpu_addr);
4411	6ae20372	blueswir1	tcg_gen_qemu_ld32u(cpu_tmp32, cpu_addr, dc->mem_idx);
4412	ce8536e2	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
4413	ce8536e2	blueswir1	offsetof(CPUState, fpr[rd]));
4414	0f8a249a	blueswir1	break;
4415	0f8a249a	blueswir1	case 0x21: /* load fsr */
4416	c2bc0e38	blueswir1	ABI32_MASK(cpu_addr);
4417	6ae20372	blueswir1	tcg_gen_qemu_ld32u(cpu_tmp32, cpu_addr, dc->mem_idx);
4418	ce8536e2	blueswir1	tcg_gen_st_i32(cpu_tmp32, cpu_env,
4419	ce8536e2	blueswir1	offsetof(CPUState, ft0));
4420	7e8c2b6c	blueswir1	tcg_gen_helper_0_0(helper_ldfsr);
4421	0f8a249a	blueswir1	break;
4422	0f8a249a	blueswir1	case 0x22: /* load quad fpreg */
4423	2ea815ca	blueswir1	{
4424	2ea815ca	blueswir1	TCGv r_const;
4425	2ea815ca	blueswir1
4426	2ea815ca	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
4427	2ea815ca	blueswir1	r_const = tcg_const_i32(dc->mem_idx);
4428	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_ldqf, cpu_addr, r_const);
4429	2ea815ca	blueswir1	tcg_temp_free(r_const);
4430	2ea815ca	blueswir1	gen_op_store_QT0_fpr(QFPREG(rd));
4431	2ea815ca	blueswir1	}
4432	1f587329	blueswir1	break;
4433	0f8a249a	blueswir1	case 0x23: /* load double fpreg */
4434	2ea815ca	blueswir1	{
4435	2ea815ca	blueswir1	TCGv r_const;
4436	2ea815ca	blueswir1
4437	2ea815ca	blueswir1	r_const = tcg_const_i32(dc->mem_idx);
4438	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_lddf, cpu_addr, r_const);
4439	2ea815ca	blueswir1	tcg_temp_free(r_const);
4440	2ea815ca	blueswir1	gen_op_store_DT0_fpr(DFPREG(rd));
4441	2ea815ca	blueswir1	}
4442	0f8a249a	blueswir1	break;
4443	0f8a249a	blueswir1	default:
4444	0f8a249a	blueswir1	goto illegal_insn;
4445	0f8a249a	blueswir1	}
4446	0f8a249a	blueswir1	} else if (xop < 8 \|\| (xop >= 0x14 && xop < 0x18) \|\| \
4447	0f8a249a	blueswir1	xop == 0xe \|\| xop == 0x1e) {
4448	6ae20372	blueswir1	gen_movl_reg_TN(rd, cpu_val);
4449	0f8a249a	blueswir1	switch (xop) {
4450	1a2fb1c0	blueswir1	case 0x4: /* store word */
4451	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4452	6ae20372	blueswir1	tcg_gen_qemu_st32(cpu_val, cpu_addr, dc->mem_idx);
4453	0f8a249a	blueswir1	break;
4454	1a2fb1c0	blueswir1	case 0x5: /* store byte */
4455	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4456	6ae20372	blueswir1	tcg_gen_qemu_st8(cpu_val, cpu_addr, dc->mem_idx);
4457	0f8a249a	blueswir1	break;
4458	1a2fb1c0	blueswir1	case 0x6: /* store halfword */
4459	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4460	6ae20372	blueswir1	tcg_gen_qemu_st16(cpu_val, cpu_addr, dc->mem_idx);
4461	0f8a249a	blueswir1	break;
4462	1a2fb1c0	blueswir1	case 0x7: /* store double word */
4463	0f8a249a	blueswir1	if (rd & 1)
4464	d4218d99	blueswir1	goto illegal_insn;
4465	1a2fb1c0	blueswir1	else {
4466	2ea815ca	blueswir1	TCGv r_low, r_const;
4467	1a2fb1c0	blueswir1
4468	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4469	c2bc0e38	blueswir1	ABI32_MASK(cpu_addr);
4470	2ea815ca	blueswir1	r_const = tcg_const_i32(7);
4471	c2bc0e38	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_addr,
4472	2ea815ca	blueswir1	r_const); // XXX remove
4473	2ea815ca	blueswir1	tcg_temp_free(r_const);
4474	8d96d209	blueswir1	r_low = tcg_temp_new(TCG_TYPE_TL);
4475	1a2fb1c0	blueswir1	gen_movl_reg_TN(rd + 1, r_low);
4476	6ae20372	blueswir1	tcg_gen_helper_1_2(helper_pack64, cpu_tmp64, cpu_val,
4477	1a2fb1c0	blueswir1	r_low);
4478	2ea815ca	blueswir1	tcg_temp_free(r_low);
4479	6ae20372	blueswir1	tcg_gen_qemu_st64(cpu_tmp64, cpu_addr, dc->mem_idx);
4480	7fa76c0b	blueswir1	}
4481	0f8a249a	blueswir1	break;
4482	3475187d	bellard	#if !defined(CONFIG_USER_ONLY) \|\| defined(TARGET_SPARC64)
4483	1a2fb1c0	blueswir1	case 0x14: /* store word alternate */
4484	3475187d	bellard	#ifndef TARGET_SPARC64
4485	0f8a249a	blueswir1	if (IS_IMM)
4486	0f8a249a	blueswir1	goto illegal_insn;
4487	0f8a249a	blueswir1	if (!supervisor(dc))
4488	0f8a249a	blueswir1	goto priv_insn;
4489	3475187d	bellard	#endif
4490	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4491	6ae20372	blueswir1	gen_st_asi(cpu_val, cpu_addr, insn, 4);
4492	d39c0b99	bellard	break;
4493	1a2fb1c0	blueswir1	case 0x15: /* store byte alternate */
4494	3475187d	bellard	#ifndef TARGET_SPARC64
4495	0f8a249a	blueswir1	if (IS_IMM)
4496	0f8a249a	blueswir1	goto illegal_insn;
4497	0f8a249a	blueswir1	if (!supervisor(dc))
4498	0f8a249a	blueswir1	goto priv_insn;
4499	3475187d	bellard	#endif
4500	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4501	6ae20372	blueswir1	gen_st_asi(cpu_val, cpu_addr, insn, 1);
4502	d39c0b99	bellard	break;
4503	1a2fb1c0	blueswir1	case 0x16: /* store halfword alternate */
4504	3475187d	bellard	#ifndef TARGET_SPARC64
4505	0f8a249a	blueswir1	if (IS_IMM)
4506	0f8a249a	blueswir1	goto illegal_insn;
4507	0f8a249a	blueswir1	if (!supervisor(dc))
4508	0f8a249a	blueswir1	goto priv_insn;
4509	3475187d	bellard	#endif
4510	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4511	6ae20372	blueswir1	gen_st_asi(cpu_val, cpu_addr, insn, 2);
4512	d39c0b99	bellard	break;
4513	1a2fb1c0	blueswir1	case 0x17: /* store double word alternate */
4514	3475187d	bellard	#ifndef TARGET_SPARC64
4515	0f8a249a	blueswir1	if (IS_IMM)
4516	0f8a249a	blueswir1	goto illegal_insn;
4517	0f8a249a	blueswir1	if (!supervisor(dc))
4518	0f8a249a	blueswir1	goto priv_insn;
4519	3475187d	bellard	#endif
4520	0f8a249a	blueswir1	if (rd & 1)
4521	d4218d99	blueswir1	goto illegal_insn;
4522	1a2fb1c0	blueswir1	else {
4523	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4524	6ae20372	blueswir1	gen_stda_asi(cpu_val, cpu_addr, insn, rd);
4525	1a2fb1c0	blueswir1	}
4526	d39c0b99	bellard	break;
4527	e80cfcfc	bellard	#endif
4528	3475187d	bellard	#ifdef TARGET_SPARC64
4529	0f8a249a	blueswir1	case 0x0e: /* V9 stx */
4530	6ae20372	blueswir1	ABI32_MASK(cpu_addr);
4531	6ae20372	blueswir1	tcg_gen_qemu_st64(cpu_val, cpu_addr, dc->mem_idx);
4532	0f8a249a	blueswir1	break;
4533	0f8a249a	blueswir1	case 0x1e: /* V9 stxa */
4534	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4535	6ae20372	blueswir1	gen_st_asi(cpu_val, cpu_addr, insn, 8);
4536	0f8a249a	blueswir1	break;
4537	3475187d	bellard	#endif
4538	0f8a249a	blueswir1	default:
4539	0f8a249a	blueswir1	goto illegal_insn;
4540	0f8a249a	blueswir1	}
4541	0f8a249a	blueswir1	} else if (xop > 0x23 && xop < 0x28) {
4542	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
4543	a80dde08	bellard	goto jmp_insn;
4544	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4545	0f8a249a	blueswir1	switch (xop) {
4546	ce8536e2	blueswir1	case 0x24: /* store fpreg */
4547	c2bc0e38	blueswir1	ABI32_MASK(cpu_addr);
4548	ce8536e2	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
4549	ce8536e2	blueswir1	offsetof(CPUState, fpr[rd]));
4550	6ae20372	blueswir1	tcg_gen_qemu_st32(cpu_tmp32, cpu_addr, dc->mem_idx);
4551	0f8a249a	blueswir1	break;
4552	0f8a249a	blueswir1	case 0x25: /* stfsr, V9 stxfsr */
4553	c2bc0e38	blueswir1	ABI32_MASK(cpu_addr);
4554	bb5529bb	blueswir1	tcg_gen_helper_0_0(helper_stfsr);
4555	ce8536e2	blueswir1	tcg_gen_ld_i32(cpu_tmp32, cpu_env,
4556	ce8536e2	blueswir1	offsetof(CPUState, ft0));
4557	6ae20372	blueswir1	tcg_gen_qemu_st32(cpu_tmp32, cpu_addr, dc->mem_idx);
4558	0f8a249a	blueswir1	break;
4559	1f587329	blueswir1	case 0x26:
4560	1f587329	blueswir1	#ifdef TARGET_SPARC64
4561	1f587329	blueswir1	/* V9 stqf, store quad fpreg */
4562	2ea815ca	blueswir1	{
4563	2ea815ca	blueswir1	TCGv r_const;
4564	2ea815ca	blueswir1
4565	2ea815ca	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
4566	2ea815ca	blueswir1	gen_op_load_fpr_QT0(QFPREG(rd));
4567	2ea815ca	blueswir1	r_const = tcg_const_i32(dc->mem_idx);
4568	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_stqf, cpu_addr, r_const);
4569	2ea815ca	blueswir1	tcg_temp_free(r_const);
4570	2ea815ca	blueswir1	}
4571	1f587329	blueswir1	break;
4572	1f587329	blueswir1	#else /* !TARGET_SPARC64 */
4573	1f587329	blueswir1	/* stdfq, store floating point queue */
4574	1f587329	blueswir1	#if defined(CONFIG_USER_ONLY)
4575	1f587329	blueswir1	goto illegal_insn;
4576	1f587329	blueswir1	#else
4577	0f8a249a	blueswir1	if (!supervisor(dc))
4578	0f8a249a	blueswir1	goto priv_insn;
4579	6ae20372	blueswir1	if (gen_trap_ifnofpu(dc, cpu_cond))
4580	0f8a249a	blueswir1	goto jmp_insn;
4581	0f8a249a	blueswir1	goto nfq_insn;
4582	0f8a249a	blueswir1	#endif
4583	1f587329	blueswir1	#endif
4584	7fa76c0b	blueswir1	case 0x27: /* store double fpreg */
4585	2ea815ca	blueswir1	{
4586	2ea815ca	blueswir1	TCGv r_const;
4587	2ea815ca	blueswir1
4588	2ea815ca	blueswir1	gen_op_load_fpr_DT0(DFPREG(rd));
4589	2ea815ca	blueswir1	r_const = tcg_const_i32(dc->mem_idx);
4590	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_stdf, cpu_addr, r_const);
4591	2ea815ca	blueswir1	tcg_temp_free(r_const);
4592	2ea815ca	blueswir1	}
4593	0f8a249a	blueswir1	break;
4594	0f8a249a	blueswir1	default:
4595	0f8a249a	blueswir1	goto illegal_insn;
4596	0f8a249a	blueswir1	}
4597	0f8a249a	blueswir1	} else if (xop > 0x33 && xop < 0x3f) {
4598	c2bc0e38	blueswir1	save_state(dc, cpu_cond);
4599	0f8a249a	blueswir1	switch (xop) {
4600	a4d17f19	blueswir1	#ifdef TARGET_SPARC64
4601	0f8a249a	blueswir1	case 0x34: /* V9 stfa */
4602	3391c818	blueswir1	gen_op_load_fpr_FT0(rd);
4603	6ae20372	blueswir1	gen_stf_asi(cpu_addr, insn, 4, rd);
4604	0f8a249a	blueswir1	break;
4605	1f587329	blueswir1	case 0x36: /* V9 stqfa */
4606	2ea815ca	blueswir1	{
4607	2ea815ca	blueswir1	TCGv r_const;
4608	2ea815ca	blueswir1
4609	2ea815ca	blueswir1	CHECK_FPU_FEATURE(dc, FLOAT128);
4610	2ea815ca	blueswir1	r_const = tcg_const_i32(7);
4611	2ea815ca	blueswir1	tcg_gen_helper_0_2(helper_check_align, cpu_addr,
4612	2ea815ca	blueswir1	r_const);
4613	2ea815ca	blueswir1	tcg_temp_free(r_const);
4614	2ea815ca	blueswir1	gen_op_load_fpr_QT0(QFPREG(rd));
4615	2ea815ca	blueswir1	gen_stf_asi(cpu_addr, insn, 16, QFPREG(rd));
4616	2ea815ca	blueswir1	}
4617	1f587329	blueswir1	break;
4618	0f8a249a	blueswir1	case 0x37: /* V9 stdfa */
4619	3391c818	blueswir1	gen_op_load_fpr_DT0(DFPREG(rd));
4620	6ae20372	blueswir1	gen_stf_asi(cpu_addr, insn, 8, DFPREG(rd));
4621	0f8a249a	blueswir1	break;
4622	0f8a249a	blueswir1	case 0x3c: /* V9 casa */
4623	6ae20372	blueswir1	gen_cas_asi(cpu_val, cpu_addr, cpu_val, insn, rd);
4624	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_val);
4625	0f8a249a	blueswir1	break;
4626	0f8a249a	blueswir1	case 0x3e: /* V9 casxa */
4627	6ae20372	blueswir1	gen_casx_asi(cpu_val, cpu_addr, cpu_val, insn, rd);
4628	6ae20372	blueswir1	gen_movl_TN_reg(rd, cpu_val);
4629	0f8a249a	blueswir1	break;
4630	a4d17f19	blueswir1	#else
4631	0f8a249a	blueswir1	case 0x34: /* stc */
4632	0f8a249a	blueswir1	case 0x35: /* stcsr */
4633	0f8a249a	blueswir1	case 0x36: /* stdcq */
4634	0f8a249a	blueswir1	case 0x37: /* stdc */
4635	0f8a249a	blueswir1	goto ncp_insn;
4636	0f8a249a	blueswir1	#endif
4637	0f8a249a	blueswir1	default:
4638	0f8a249a	blueswir1	goto illegal_insn;
4639	0f8a249a	blueswir1	}
4640	e8af50a3	bellard	}
4641	0f8a249a	blueswir1	else
4642	0f8a249a	blueswir1	goto illegal_insn;
4643	0f8a249a	blueswir1	}
4644	0f8a249a	blueswir1	break;
4645	cf495bcf	bellard	}
4646	cf495bcf	bellard	/* default case for non jump instructions */
4647	72cbca10	bellard	if (dc->npc == DYNAMIC_PC) {
4648	0f8a249a	blueswir1	dc->pc = DYNAMIC_PC;
4649	0f8a249a	blueswir1	gen_op_next_insn();
4650	72cbca10	bellard	} else if (dc->npc == JUMP_PC) {
4651	72cbca10	bellard	/* we can do a static jump */
4652	6ae20372	blueswir1	gen_branch2(dc, dc->jump_pc[0], dc->jump_pc[1], cpu_cond);
4653	72cbca10	bellard	dc->is_br = 1;
4654	72cbca10	bellard	} else {
4655	0f8a249a	blueswir1	dc->pc = dc->npc;
4656	0f8a249a	blueswir1	dc->npc = dc->npc + 4;
4657	cf495bcf	bellard	}
4658	e80cfcfc	bellard	jmp_insn:
4659	cf495bcf	bellard	return;
4660	cf495bcf	bellard	illegal_insn:
4661	2ea815ca	blueswir1	{
4662	2ea815ca	blueswir1	TCGv r_const;
4663	2ea815ca	blueswir1
4664	2ea815ca	blueswir1	save_state(dc, cpu_cond);
4665	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_ILL_INSN);
4666	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
4667	2ea815ca	blueswir1	tcg_temp_free(r_const);
4668	2ea815ca	blueswir1	dc->is_br = 1;
4669	2ea815ca	blueswir1	}
4670	e8af50a3	bellard	return;
4671	64a88d5d	blueswir1	unimp_flush:
4672	2ea815ca	blueswir1	{
4673	2ea815ca	blueswir1	TCGv r_const;
4674	2ea815ca	blueswir1
4675	2ea815ca	blueswir1	save_state(dc, cpu_cond);
4676	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_UNIMP_FLUSH);
4677	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
4678	2ea815ca	blueswir1	tcg_temp_free(r_const);
4679	2ea815ca	blueswir1	dc->is_br = 1;
4680	2ea815ca	blueswir1	}
4681	64a88d5d	blueswir1	return;
4682	e80cfcfc	bellard	#if !defined(CONFIG_USER_ONLY)
4683	e8af50a3	bellard	priv_insn:
4684	2ea815ca	blueswir1	{
4685	2ea815ca	blueswir1	TCGv r_const;
4686	2ea815ca	blueswir1
4687	2ea815ca	blueswir1	save_state(dc, cpu_cond);
4688	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_PRIV_INSN);
4689	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
4690	2ea815ca	blueswir1	tcg_temp_free(r_const);
4691	2ea815ca	blueswir1	dc->is_br = 1;
4692	2ea815ca	blueswir1	}
4693	e80cfcfc	bellard	return;
4694	64a88d5d	blueswir1	#endif
4695	e80cfcfc	bellard	nfpu_insn:
4696	6ae20372	blueswir1	save_state(dc, cpu_cond);
4697	e80cfcfc	bellard	gen_op_fpexception_im(FSR_FTT_UNIMPFPOP);
4698	e80cfcfc	bellard	dc->is_br = 1;
4699	fcc72045	blueswir1	return;
4700	64a88d5d	blueswir1	#if !defined(CONFIG_USER_ONLY) && !defined(TARGET_SPARC64)
4701	9143e598	blueswir1	nfq_insn:
4702	6ae20372	blueswir1	save_state(dc, cpu_cond);
4703	9143e598	blueswir1	gen_op_fpexception_im(FSR_FTT_SEQ_ERROR);
4704	9143e598	blueswir1	dc->is_br = 1;
4705	9143e598	blueswir1	return;
4706	9143e598	blueswir1	#endif
4707	fcc72045	blueswir1	#ifndef TARGET_SPARC64
4708	fcc72045	blueswir1	ncp_insn:
4709	2ea815ca	blueswir1	{
4710	2ea815ca	blueswir1	TCGv r_const;
4711	2ea815ca	blueswir1
4712	2ea815ca	blueswir1	save_state(dc, cpu_cond);
4713	2ea815ca	blueswir1	r_const = tcg_const_i32(TT_NCP_INSN);
4714	2ea815ca	blueswir1	tcg_gen_helper_0_1(raise_exception, r_const);
4715	2ea815ca	blueswir1	tcg_temp_free(r_const);
4716	2ea815ca	blueswir1	dc->is_br = 1;
4717	2ea815ca	blueswir1	}
4718	fcc72045	blueswir1	return;
4719	fcc72045	blueswir1	#endif
4720	7a3f1944	bellard	}
4721	7a3f1944	bellard
4722	cf495bcf	bellard	static inline int gen_intermediate_code_internal(TranslationBlock * tb,
4723	0f8a249a	blueswir1	int spc, CPUSPARCState *env)
4724	7a3f1944	bellard	{
4725	72cbca10	bellard	target_ulong pc_start, last_pc;
4726	cf495bcf	bellard	uint16_t *gen_opc_end;
4727	cf495bcf	bellard	DisasContext dc1, *dc = &dc1;
4728	e8af50a3	bellard	int j, lj = -1;
4729	cf495bcf	bellard
4730	cf495bcf	bellard	memset(dc, 0, sizeof(DisasContext));
4731	cf495bcf	bellard	dc->tb = tb;
4732	72cbca10	bellard	pc_start = tb->pc;
4733	cf495bcf	bellard	dc->pc = pc_start;
4734	e80cfcfc	bellard	last_pc = dc->pc;
4735	72cbca10	bellard	dc->npc = (target_ulong) tb->cs_base;
4736	6f27aba6	blueswir1	dc->mem_idx = cpu_mmu_index(env);
4737	64a88d5d	blueswir1	dc->features = env->features;
4738	64a88d5d	blueswir1	if ((dc->features & CPU_FEATURE_FLOAT)) {
4739	64a88d5d	blueswir1	dc->fpu_enabled = cpu_fpu_enabled(env);
4740	64a88d5d	blueswir1	#if defined(CONFIG_USER_ONLY)
4741	64a88d5d	blueswir1	dc->features \|= CPU_FEATURE_FLOAT128;
4742	64a88d5d	blueswir1	#endif
4743	64a88d5d	blueswir1	} else
4744	64a88d5d	blueswir1	dc->fpu_enabled = 0;
4745	cf495bcf	bellard	gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
4746	cf495bcf	bellard
4747	1a2fb1c0	blueswir1	cpu_tmp0 = tcg_temp_new(TCG_TYPE_TL);
4748	8911f501	blueswir1	cpu_tmp32 = tcg_temp_new(TCG_TYPE_I32);
4749	8911f501	blueswir1	cpu_tmp64 = tcg_temp_new(TCG_TYPE_I64);
4750	1a2fb1c0	blueswir1
4751	cf495bcf	bellard	do {
4752	e8af50a3	bellard	if (env->nb_breakpoints > 0) {
4753	e8af50a3	bellard	for(j = 0; j < env->nb_breakpoints; j++) {
4754	e8af50a3	bellard	if (env->breakpoints[j] == dc->pc) {
4755	0f8a249a	blueswir1	if (dc->pc != pc_start)
4756	6ae20372	blueswir1	save_state(dc, cpu_cond);
4757	1a2fb1c0	blueswir1	tcg_gen_helper_0_0(helper_debug);
4758	57fec1fe	bellard	tcg_gen_exit_tb(0);
4759	0f8a249a	blueswir1	dc->is_br = 1;
4760	e80cfcfc	bellard	goto exit_gen_loop;
4761	e8af50a3	bellard	}
4762	e8af50a3	bellard	}
4763	e8af50a3	bellard	}
4764	e8af50a3	bellard	if (spc) {
4765	e8af50a3	bellard	if (loglevel > 0)
4766	e8af50a3	bellard	fprintf(logfile, "Search PC...\n");
4767	e8af50a3	bellard	j = gen_opc_ptr - gen_opc_buf;
4768	e8af50a3	bellard	if (lj < j) {
4769	e8af50a3	bellard	lj++;
4770	e8af50a3	bellard	while (lj < j)
4771	e8af50a3	bellard	gen_opc_instr_start[lj++] = 0;
4772	e8af50a3	bellard	gen_opc_pc[lj] = dc->pc;
4773	e8af50a3	bellard	gen_opc_npc[lj] = dc->npc;
4774	e8af50a3	bellard	gen_opc_instr_start[lj] = 1;
4775	e8af50a3	bellard	}
4776	e8af50a3	bellard	}
4777	0f8a249a	blueswir1	last_pc = dc->pc;
4778	0f8a249a	blueswir1	disas_sparc_insn(dc);
4779	0f8a249a	blueswir1
4780	0f8a249a	blueswir1	if (dc->is_br)
4781	0f8a249a	blueswir1	break;
4782	0f8a249a	blueswir1	/* if the next PC is different, we abort now */
4783	0f8a249a	blueswir1	if (dc->pc != (last_pc + 4))
4784	0f8a249a	blueswir1	break;
4785	d39c0b99	bellard	/* if we reach a page boundary, we stop generation so that the
4786	d39c0b99	bellard	PC of a TT_TFAULT exception is always in the right page */
4787	d39c0b99	bellard	if ((dc->pc & (TARGET_PAGE_SIZE - 1)) == 0)
4788	d39c0b99	bellard	break;
4789	e80cfcfc	bellard	/* if single step mode, we generate only one instruction and
4790	e80cfcfc	bellard	generate an exception */
4791	e80cfcfc	bellard	if (env->singlestep_enabled) {
4792	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_pc, dc->pc);
4793	57fec1fe	bellard	tcg_gen_exit_tb(0);
4794	e80cfcfc	bellard	break;
4795	e80cfcfc	bellard	}
4796	cf495bcf	bellard	} while ((gen_opc_ptr < gen_opc_end) &&
4797	0f8a249a	blueswir1	(dc->pc - pc_start) < (TARGET_PAGE_SIZE - 32));
4798	e80cfcfc	bellard
4799	e80cfcfc	bellard	exit_gen_loop:
4800	2ea815ca	blueswir1	tcg_temp_free(cpu_tmp64);
4801	2ea815ca	blueswir1	tcg_temp_free(cpu_tmp32);
4802	2ea815ca	blueswir1	tcg_temp_free(cpu_tmp0);
4803	72cbca10	bellard	if (!dc->is_br) {
4804	5fafdf24	ths	if (dc->pc != DYNAMIC_PC &&
4805	72cbca10	bellard	(dc->npc != DYNAMIC_PC && dc->npc != JUMP_PC)) {
4806	72cbca10	bellard	/* static PC and NPC: we can use direct chaining */
4807	2f5680ee	blueswir1	gen_goto_tb(dc, 0, dc->pc, dc->npc);
4808	72cbca10	bellard	} else {
4809	72cbca10	bellard	if (dc->pc != DYNAMIC_PC)
4810	2f5680ee	blueswir1	tcg_gen_movi_tl(cpu_pc, dc->pc);
4811	6ae20372	blueswir1	save_npc(dc, cpu_cond);
4812	57fec1fe	bellard	tcg_gen_exit_tb(0);
4813	72cbca10	bellard	}
4814	72cbca10	bellard	}
4815	cf495bcf	bellard	*gen_opc_ptr = INDEX_op_end;
4816	e8af50a3	bellard	if (spc) {
4817	e8af50a3	bellard	j = gen_opc_ptr - gen_opc_buf;
4818	e8af50a3	bellard	lj++;
4819	e8af50a3	bellard	while (lj <= j)
4820	e8af50a3	bellard	gen_opc_instr_start[lj++] = 0;
4821	e8af50a3	bellard	#if 0
4822	e8af50a3	bellard	if (loglevel > 0) {
4823	e8af50a3	bellard	page_dump(logfile);
4824	e8af50a3	bellard	}
4825	e8af50a3	bellard	#endif
4826	c3278b7b	bellard	gen_opc_jump_pc[0] = dc->jump_pc[0];
4827	c3278b7b	bellard	gen_opc_jump_pc[1] = dc->jump_pc[1];
4828	e8af50a3	bellard	} else {
4829	e80cfcfc	bellard	tb->size = last_pc + 4 - pc_start;
4830	e8af50a3	bellard	}
4831	7a3f1944	bellard	#ifdef DEBUG_DISAS
4832	e19e89a5	bellard	if (loglevel & CPU_LOG_TB_IN_ASM) {
4833	0f8a249a	blueswir1	fprintf(logfile, "--------------\n");
4834	0f8a249a	blueswir1	fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
4835	0f8a249a	blueswir1	target_disas(logfile, pc_start, last_pc + 4 - pc_start, 0);
4836	0f8a249a	blueswir1	fprintf(logfile, "\n");
4837	cf495bcf	bellard	}
4838	7a3f1944	bellard	#endif
4839	cf495bcf	bellard	return 0;
4840	7a3f1944	bellard	}
4841	7a3f1944	bellard
4842	cf495bcf	bellard	int gen_intermediate_code(CPUSPARCState * env, TranslationBlock * tb)
4843	7a3f1944	bellard	{
4844	e8af50a3	bellard	return gen_intermediate_code_internal(tb, 0, env);
4845	7a3f1944	bellard	}
4846	7a3f1944	bellard
4847	cf495bcf	bellard	int gen_intermediate_code_pc(CPUSPARCState * env, TranslationBlock * tb)
4848	7a3f1944	bellard	{
4849	e8af50a3	bellard	return gen_intermediate_code_internal(tb, 1, env);
4850	7a3f1944	bellard	}
4851	7a3f1944	bellard
4852	c48fcb47	blueswir1	void gen_intermediate_code_init(CPUSPARCState *env)
4853	e80cfcfc	bellard	{
4854	f5069b26	blueswir1	unsigned int i;
4855	c48fcb47	blueswir1	static int inited;
4856	f5069b26	blueswir1	static const char * const gregnames[8] = {
4857	f5069b26	blueswir1	NULL, // g0 not used
4858	f5069b26	blueswir1	"g1",
4859	f5069b26	blueswir1	"g2",
4860	f5069b26	blueswir1	"g3",
4861	f5069b26	blueswir1	"g4",
4862	f5069b26	blueswir1	"g5",
4863	f5069b26	blueswir1	"g6",
4864	f5069b26	blueswir1	"g7",
4865	f5069b26	blueswir1	};
4866	aaed909a	bellard
4867	1a2fb1c0	blueswir1	/* init various static tables */
4868	1a2fb1c0	blueswir1	if (!inited) {
4869	1a2fb1c0	blueswir1	inited = 1;
4870	1a2fb1c0	blueswir1
4871	1a2fb1c0	blueswir1	cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
4872	db4a4ea4	blueswir1	cpu_regwptr = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
4873	db4a4ea4	blueswir1	offsetof(CPUState, regwptr),
4874	db4a4ea4	blueswir1	"regwptr");
4875	1a2fb1c0	blueswir1	#ifdef TARGET_SPARC64
4876	dc99a3f2	blueswir1	cpu_xcc = tcg_global_mem_new(TCG_TYPE_I32,
4877	dc99a3f2	blueswir1	TCG_AREG0, offsetof(CPUState, xcc),
4878	dc99a3f2	blueswir1	"xcc");
4879	1a2fb1c0	blueswir1	#endif
4880	7c60cc4b	bellard	/* XXX: T0 and T1 should be temporaries */
4881	7c60cc4b	bellard	cpu_T[0] = tcg_global_mem_new(TCG_TYPE_TL,
4882	7c60cc4b	bellard	TCG_AREG0, offsetof(CPUState, t0), "T0");
4883	7c60cc4b	bellard	cpu_T[1] = tcg_global_mem_new(TCG_TYPE_TL,
4884	7c60cc4b	bellard	TCG_AREG0, offsetof(CPUState, t1), "T1");
4885	7c60cc4b	bellard	cpu_cond = tcg_global_mem_new(TCG_TYPE_TL,
4886	77f193da	blueswir1	TCG_AREG0, offsetof(CPUState, cond),
4887	77f193da	blueswir1	"cond");
4888	dc99a3f2	blueswir1	cpu_cc_src = tcg_global_mem_new(TCG_TYPE_TL,
4889	dc99a3f2	blueswir1	TCG_AREG0, offsetof(CPUState, cc_src),
4890	dc99a3f2	blueswir1	"cc_src");
4891	d9bdab86	blueswir1	cpu_cc_src2 = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
4892	d9bdab86	blueswir1	offsetof(CPUState, cc_src2),
4893	d9bdab86	blueswir1	"cc_src2");
4894	dc99a3f2	blueswir1	cpu_cc_dst = tcg_global_mem_new(TCG_TYPE_TL,
4895	dc99a3f2	blueswir1	TCG_AREG0, offsetof(CPUState, cc_dst),
4896	dc99a3f2	blueswir1	"cc_dst");
4897	dc99a3f2	blueswir1	cpu_psr = tcg_global_mem_new(TCG_TYPE_I32,
4898	dc99a3f2	blueswir1	TCG_AREG0, offsetof(CPUState, psr),
4899	dc99a3f2	blueswir1	"psr");
4900	87e92502	blueswir1	cpu_fsr = tcg_global_mem_new(TCG_TYPE_TL,
4901	87e92502	blueswir1	TCG_AREG0, offsetof(CPUState, fsr),
4902	87e92502	blueswir1	"fsr");
4903	48d5c82b	blueswir1	cpu_pc = tcg_global_mem_new(TCG_TYPE_TL,
4904	48d5c82b	blueswir1	TCG_AREG0, offsetof(CPUState, pc),
4905	48d5c82b	blueswir1	"pc");
4906	48d5c82b	blueswir1	cpu_npc = tcg_global_mem_new(TCG_TYPE_TL,
4907	48d5c82b	blueswir1	TCG_AREG0, offsetof(CPUState, npc),
4908	48d5c82b	blueswir1	"npc");
4909	f5069b26	blueswir1	for (i = 1; i < 8; i++)
4910	f5069b26	blueswir1	cpu_gregs[i] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
4911	f5069b26	blueswir1	offsetof(CPUState, gregs[i]),
4912	f5069b26	blueswir1	gregnames[i]);
4913	c9e03d8f	blueswir1	/* register helpers */
4914	c9e03d8f	blueswir1
4915	c9e03d8f	blueswir1	#undef DEF_HELPER
4916	c9e03d8f	blueswir1	#define DEF_HELPER(ret, name, params) tcg_register_helper(name, #name);
4917	c9e03d8f	blueswir1	#include "helper.h"
4918	1a2fb1c0	blueswir1	}
4919	658138bc	bellard	}
4920	d2856f1a	aurel32
4921	d2856f1a	aurel32	void gen_pc_load(CPUState env, TranslationBlock tb,
4922	d2856f1a	aurel32	unsigned long searched_pc, int pc_pos, void *puc)
4923	d2856f1a	aurel32	{
4924	d2856f1a	aurel32	target_ulong npc;
4925	d2856f1a	aurel32	env->pc = gen_opc_pc[pc_pos];
4926	d2856f1a	aurel32	npc = gen_opc_npc[pc_pos];
4927	d2856f1a	aurel32	if (npc == 1) {
4928	d2856f1a	aurel32	/* dynamic NPC: already stored */
4929	d2856f1a	aurel32	} else if (npc == 2) {
4930	d2856f1a	aurel32	target_ulong t2 = (target_ulong)(unsigned long)puc;
4931	d2856f1a	aurel32	/* jump PC: use T2 and the jump targets of the translation */
4932	d2856f1a	aurel32	if (t2)
4933	d2856f1a	aurel32	env->npc = gen_opc_jump_pc[0];
4934	d2856f1a	aurel32	else
4935	d2856f1a	aurel32	env->npc = gen_opc_jump_pc[1];
4936	d2856f1a	aurel32	} else {
4937	d2856f1a	aurel32	env->npc = npc;
4938	d2856f1a	aurel32	}
4939	d2856f1a	aurel32	}

Archipelago » qemu

root / target-sparc / translate.c @ e00c1e71