]> git.proxmox.com Git - mirror_qemu.git/blob - target/tricore/translate.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
target/tricore: Rename csfr.def -> csfr.h.inc
[mirror_qemu.git] / target / tricore / translate.c
1 /*
2 * TriCore emulation for qemu: main translation routines.
3 *
4 * Copyright (c) 2013-2014 Bastian Koppelmann C-Lab/University Paderborn
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "disas/disas.h"
24 #include "exec/exec-all.h"
25 #include "tcg/tcg-op.h"
26 #include "exec/cpu_ldst.h"
27 #include "qemu/qemu-print.h"
28
29 #include "exec/helper-proto.h"
30 #include "exec/helper-gen.h"
31
32 #include "tricore-opcodes.h"
33 #include "exec/translator.h"
34 #include "exec/log.h"
35
36 /*
37 * TCG registers
38 */
39 static TCGv cpu_PC;
40 static TCGv cpu_PCXI;
41 static TCGv cpu_PSW;
42 static TCGv cpu_ICR;
43 /* GPR registers */
44 static TCGv cpu_gpr_a[16];
45 static TCGv cpu_gpr_d[16];
46 /* PSW Flag cache */
47 static TCGv cpu_PSW_C;
48 static TCGv cpu_PSW_V;
49 static TCGv cpu_PSW_SV;
50 static TCGv cpu_PSW_AV;
51 static TCGv cpu_PSW_SAV;
52
53 #include "exec/gen-icount.h"
54
55 static const char *regnames_a[] = {
56 "a0" , "a1" , "a2" , "a3" , "a4" , "a5" ,
57 "a6" , "a7" , "a8" , "a9" , "sp" , "a11" ,
58 "a12" , "a13" , "a14" , "a15",
59 };
60
61 static const char *regnames_d[] = {
62 "d0" , "d1" , "d2" , "d3" , "d4" , "d5" ,
63 "d6" , "d7" , "d8" , "d9" , "d10" , "d11" ,
64 "d12" , "d13" , "d14" , "d15",
65 };
66
67 typedef struct DisasContext {
68 DisasContextBase base;
69 target_ulong pc_succ_insn;
70 uint32_t opcode;
71 /* Routine used to access memory */
72 int mem_idx;
73 uint32_t hflags, saved_hflags;
74 uint64_t features;
75 } DisasContext;
76
77 static int has_feature(DisasContext *ctx, int feature)
78 {
79 return (ctx->features & (1ULL << feature)) != 0;
80 }
81
82 enum {
83 MODE_LL = 0,
84 MODE_LU = 1,
85 MODE_UL = 2,
86 MODE_UU = 3,
87 };
88
89 void tricore_cpu_dump_state(CPUState *cs, FILE *f, int flags)
90 {
91 TriCoreCPU *cpu = TRICORE_CPU(cs);
92 CPUTriCoreState *env = &cpu->env;
93 uint32_t psw;
94 int i;
95
96 psw = psw_read(env);
97
98 qemu_fprintf(f, "PC: " TARGET_FMT_lx, env->PC);
99 qemu_fprintf(f, " PSW: " TARGET_FMT_lx, psw);
100 qemu_fprintf(f, " ICR: " TARGET_FMT_lx, env->ICR);
101 qemu_fprintf(f, "\nPCXI: " TARGET_FMT_lx, env->PCXI);
102 qemu_fprintf(f, " FCX: " TARGET_FMT_lx, env->FCX);
103 qemu_fprintf(f, " LCX: " TARGET_FMT_lx, env->LCX);
104
105 for (i = 0; i < 16; ++i) {
106 if ((i & 3) == 0) {
107 qemu_fprintf(f, "\nGPR A%02d:", i);
108 }
109 qemu_fprintf(f, " " TARGET_FMT_lx, env->gpr_a[i]);
110 }
111 for (i = 0; i < 16; ++i) {
112 if ((i & 3) == 0) {
113 qemu_fprintf(f, "\nGPR D%02d:", i);
114 }
115 qemu_fprintf(f, " " TARGET_FMT_lx, env->gpr_d[i]);
116 }
117 qemu_fprintf(f, "\n");
118 }
119
120 /*
121 * Functions to generate micro-ops
122 */
123
124 /* Makros for generating helpers */
125
126 #define gen_helper_1arg(name, arg) do { \
127 TCGv_i32 helper_tmp = tcg_const_i32(arg); \
128 gen_helper_##name(cpu_env, helper_tmp); \
129 tcg_temp_free_i32(helper_tmp); \
130 } while (0)
131
132 #define GEN_HELPER_LL(name, ret, arg0, arg1, n) do { \
133 TCGv arg00 = tcg_temp_new(); \
134 TCGv arg01 = tcg_temp_new(); \
135 TCGv arg11 = tcg_temp_new(); \
136 tcg_gen_sari_tl(arg00, arg0, 16); \
137 tcg_gen_ext16s_tl(arg01, arg0); \
138 tcg_gen_ext16s_tl(arg11, arg1); \
139 gen_helper_##name(ret, arg00, arg01, arg11, arg11, n); \
140 tcg_temp_free(arg00); \
141 tcg_temp_free(arg01); \
142 tcg_temp_free(arg11); \
143 } while (0)
144
145 #define GEN_HELPER_LU(name, ret, arg0, arg1, n) do { \
146 TCGv arg00 = tcg_temp_new(); \
147 TCGv arg01 = tcg_temp_new(); \
148 TCGv arg10 = tcg_temp_new(); \
149 TCGv arg11 = tcg_temp_new(); \
150 tcg_gen_sari_tl(arg00, arg0, 16); \
151 tcg_gen_ext16s_tl(arg01, arg0); \
152 tcg_gen_sari_tl(arg11, arg1, 16); \
153 tcg_gen_ext16s_tl(arg10, arg1); \
154 gen_helper_##name(ret, arg00, arg01, arg10, arg11, n); \
155 tcg_temp_free(arg00); \
156 tcg_temp_free(arg01); \
157 tcg_temp_free(arg10); \
158 tcg_temp_free(arg11); \
159 } while (0)
160
161 #define GEN_HELPER_UL(name, ret, arg0, arg1, n) do { \
162 TCGv arg00 = tcg_temp_new(); \
163 TCGv arg01 = tcg_temp_new(); \
164 TCGv arg10 = tcg_temp_new(); \
165 TCGv arg11 = tcg_temp_new(); \
166 tcg_gen_sari_tl(arg00, arg0, 16); \
167 tcg_gen_ext16s_tl(arg01, arg0); \
168 tcg_gen_sari_tl(arg10, arg1, 16); \
169 tcg_gen_ext16s_tl(arg11, arg1); \
170 gen_helper_##name(ret, arg00, arg01, arg10, arg11, n); \
171 tcg_temp_free(arg00); \
172 tcg_temp_free(arg01); \
173 tcg_temp_free(arg10); \
174 tcg_temp_free(arg11); \
175 } while (0)
176
177 #define GEN_HELPER_UU(name, ret, arg0, arg1, n) do { \
178 TCGv arg00 = tcg_temp_new(); \
179 TCGv arg01 = tcg_temp_new(); \
180 TCGv arg11 = tcg_temp_new(); \
181 tcg_gen_sari_tl(arg01, arg0, 16); \
182 tcg_gen_ext16s_tl(arg00, arg0); \
183 tcg_gen_sari_tl(arg11, arg1, 16); \
184 gen_helper_##name(ret, arg00, arg01, arg11, arg11, n); \
185 tcg_temp_free(arg00); \
186 tcg_temp_free(arg01); \
187 tcg_temp_free(arg11); \
188 } while (0)
189
190 #define GEN_HELPER_RRR(name, rl, rh, al1, ah1, arg2) do { \
191 TCGv_i64 ret = tcg_temp_new_i64(); \
192 TCGv_i64 arg1 = tcg_temp_new_i64(); \
193 \
194 tcg_gen_concat_i32_i64(arg1, al1, ah1); \
195 gen_helper_##name(ret, arg1, arg2); \
196 tcg_gen_extr_i64_i32(rl, rh, ret); \
197 \
198 tcg_temp_free_i64(ret); \
199 tcg_temp_free_i64(arg1); \
200 } while (0)
201
202 #define GEN_HELPER_RR(name, rl, rh, arg1, arg2) do { \
203 TCGv_i64 ret = tcg_temp_new_i64(); \
204 \
205 gen_helper_##name(ret, cpu_env, arg1, arg2); \
206 tcg_gen_extr_i64_i32(rl, rh, ret); \
207 \
208 tcg_temp_free_i64(ret); \
209 } while (0)
210
211 #define EA_ABS_FORMAT(con) (((con & 0x3C000) << 14) + (con & 0x3FFF))
212 #define EA_B_ABSOLUT(con) (((offset & 0xf00000) << 8) | \
213 ((offset & 0x0fffff) << 1))
214
215 /* For two 32-bit registers used a 64-bit register, the first
216 registernumber needs to be even. Otherwise we trap. */
217 static inline void generate_trap(DisasContext *ctx, int class, int tin);
218 #define CHECK_REG_PAIR(reg) do { \
219 if (reg & 0x1) { \
220 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_OPD); \
221 } \
222 } while (0)
223
224 /* Functions for load/save to/from memory */
225
226 static inline void gen_offset_ld(DisasContext *ctx, TCGv r1, TCGv r2,
227 int16_t con, MemOp mop)
228 {
229 TCGv temp = tcg_temp_new();
230 tcg_gen_addi_tl(temp, r2, con);
231 tcg_gen_qemu_ld_tl(r1, temp, ctx->mem_idx, mop);
232 tcg_temp_free(temp);
233 }
234
235 static inline void gen_offset_st(DisasContext *ctx, TCGv r1, TCGv r2,
236 int16_t con, MemOp mop)
237 {
238 TCGv temp = tcg_temp_new();
239 tcg_gen_addi_tl(temp, r2, con);
240 tcg_gen_qemu_st_tl(r1, temp, ctx->mem_idx, mop);
241 tcg_temp_free(temp);
242 }
243
244 static void gen_st_2regs_64(TCGv rh, TCGv rl, TCGv address, DisasContext *ctx)
245 {
246 TCGv_i64 temp = tcg_temp_new_i64();
247
248 tcg_gen_concat_i32_i64(temp, rl, rh);
249 tcg_gen_qemu_st_i64(temp, address, ctx->mem_idx, MO_LEUQ);
250
251 tcg_temp_free_i64(temp);
252 }
253
254 static void gen_offset_st_2regs(TCGv rh, TCGv rl, TCGv base, int16_t con,
255 DisasContext *ctx)
256 {
257 TCGv temp = tcg_temp_new();
258 tcg_gen_addi_tl(temp, base, con);
259 gen_st_2regs_64(rh, rl, temp, ctx);
260 tcg_temp_free(temp);
261 }
262
263 static void gen_ld_2regs_64(TCGv rh, TCGv rl, TCGv address, DisasContext *ctx)
264 {
265 TCGv_i64 temp = tcg_temp_new_i64();
266
267 tcg_gen_qemu_ld_i64(temp, address, ctx->mem_idx, MO_LEUQ);
268 /* write back to two 32 bit regs */
269 tcg_gen_extr_i64_i32(rl, rh, temp);
270
271 tcg_temp_free_i64(temp);
272 }
273
274 static void gen_offset_ld_2regs(TCGv rh, TCGv rl, TCGv base, int16_t con,
275 DisasContext *ctx)
276 {
277 TCGv temp = tcg_temp_new();
278 tcg_gen_addi_tl(temp, base, con);
279 gen_ld_2regs_64(rh, rl, temp, ctx);
280 tcg_temp_free(temp);
281 }
282
283 static void gen_st_preincr(DisasContext *ctx, TCGv r1, TCGv r2, int16_t off,
284 MemOp mop)
285 {
286 TCGv temp = tcg_temp_new();
287 tcg_gen_addi_tl(temp, r2, off);
288 tcg_gen_qemu_st_tl(r1, temp, ctx->mem_idx, mop);
289 tcg_gen_mov_tl(r2, temp);
290 tcg_temp_free(temp);
291 }
292
293 static void gen_ld_preincr(DisasContext *ctx, TCGv r1, TCGv r2, int16_t off,
294 MemOp mop)
295 {
296 TCGv temp = tcg_temp_new();
297 tcg_gen_addi_tl(temp, r2, off);
298 tcg_gen_qemu_ld_tl(r1, temp, ctx->mem_idx, mop);
299 tcg_gen_mov_tl(r2, temp);
300 tcg_temp_free(temp);
301 }
302
303 /* M(EA, word) = (M(EA, word) & ~E[a][63:32]) | (E[a][31:0] & E[a][63:32]); */
304 static void gen_ldmst(DisasContext *ctx, int ereg, TCGv ea)
305 {
306 TCGv temp = tcg_temp_new();
307 TCGv temp2 = tcg_temp_new();
308
309 CHECK_REG_PAIR(ereg);
310 /* temp = (M(EA, word) */
311 tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
312 /* temp = temp & ~E[a][63:32]) */
313 tcg_gen_andc_tl(temp, temp, cpu_gpr_d[ereg+1]);
314 /* temp2 = (E[a][31:0] & E[a][63:32]); */
315 tcg_gen_and_tl(temp2, cpu_gpr_d[ereg], cpu_gpr_d[ereg+1]);
316 /* temp = temp | temp2; */
317 tcg_gen_or_tl(temp, temp, temp2);
318 /* M(EA, word) = temp; */
319 tcg_gen_qemu_st_tl(temp, ea, ctx->mem_idx, MO_LEUL);
320
321 tcg_temp_free(temp);
322 tcg_temp_free(temp2);
323 }
324
325 /* tmp = M(EA, word);
326 M(EA, word) = D[a];
327 D[a] = tmp[31:0];*/
328 static void gen_swap(DisasContext *ctx, int reg, TCGv ea)
329 {
330 TCGv temp = tcg_temp_new();
331
332 tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
333 tcg_gen_qemu_st_tl(cpu_gpr_d[reg], ea, ctx->mem_idx, MO_LEUL);
334 tcg_gen_mov_tl(cpu_gpr_d[reg], temp);
335
336 tcg_temp_free(temp);
337 }
338
339 static void gen_cmpswap(DisasContext *ctx, int reg, TCGv ea)
340 {
341 TCGv temp = tcg_temp_new();
342 TCGv temp2 = tcg_temp_new();
343 tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
344 tcg_gen_movcond_tl(TCG_COND_EQ, temp2, cpu_gpr_d[reg+1], temp,
345 cpu_gpr_d[reg], temp);
346 tcg_gen_qemu_st_tl(temp2, ea, ctx->mem_idx, MO_LEUL);
347 tcg_gen_mov_tl(cpu_gpr_d[reg], temp);
348
349 tcg_temp_free(temp);
350 tcg_temp_free(temp2);
351 }
352
353 static void gen_swapmsk(DisasContext *ctx, int reg, TCGv ea)
354 {
355 TCGv temp = tcg_temp_new();
356 TCGv temp2 = tcg_temp_new();
357 TCGv temp3 = tcg_temp_new();
358
359 tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
360 tcg_gen_and_tl(temp2, cpu_gpr_d[reg], cpu_gpr_d[reg+1]);
361 tcg_gen_andc_tl(temp3, temp, cpu_gpr_d[reg+1]);
362 tcg_gen_or_tl(temp2, temp2, temp3);
363 tcg_gen_qemu_st_tl(temp2, ea, ctx->mem_idx, MO_LEUL);
364 tcg_gen_mov_tl(cpu_gpr_d[reg], temp);
365
366 tcg_temp_free(temp);
367 tcg_temp_free(temp2);
368 tcg_temp_free(temp3);
369 }
370
371
372 /* We generate loads and store to core special function register (csfr) through
373 the function gen_mfcr and gen_mtcr. To handle access permissions, we use 3
374 makros R, A and E, which allow read-only, all and endinit protected access.
375 These makros also specify in which ISA version the csfr was introduced. */
376 #define R(ADDRESS, REG, FEATURE) \
377 case ADDRESS: \
378 if (has_feature(ctx, FEATURE)) { \
379 tcg_gen_ld_tl(ret, cpu_env, offsetof(CPUTriCoreState, REG)); \
380 } \
381 break;
382 #define A(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE)
383 #define E(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE)
384 static inline void gen_mfcr(DisasContext *ctx, TCGv ret, int32_t offset)
385 {
386 /* since we're caching PSW make this a special case */
387 if (offset == 0xfe04) {
388 gen_helper_psw_read(ret, cpu_env);
389 } else {
390 switch (offset) {
391 #include "csfr.h.inc"
392 }
393 }
394 }
395 #undef R
396 #undef A
397 #undef E
398
399 #define R(ADDRESS, REG, FEATURE) /* don't gen writes to read-only reg,
400 since no execption occurs */
401 #define A(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE) \
402 case ADDRESS: \
403 if (has_feature(ctx, FEATURE)) { \
404 tcg_gen_st_tl(r1, cpu_env, offsetof(CPUTriCoreState, REG)); \
405 } \
406 break;
407 /* Endinit protected registers
408 TODO: Since the endinit bit is in a register of a not yet implemented
409 watchdog device, we handle endinit protected registers like
410 all-access registers for now. */
411 #define E(ADDRESS, REG, FEATURE) A(ADDRESS, REG, FEATURE)
412 static inline void gen_mtcr(DisasContext *ctx, TCGv r1,
413 int32_t offset)
414 {
415 if ((ctx->hflags & TRICORE_HFLAG_KUU) == TRICORE_HFLAG_SM) {
416 /* since we're caching PSW make this a special case */
417 if (offset == 0xfe04) {
418 gen_helper_psw_write(cpu_env, r1);
419 } else {
420 switch (offset) {
421 #include "csfr.h.inc"
422 }
423 }
424 } else {
425 /* generate privilege trap */
426 }
427 }
428
429 /* Functions for arithmetic instructions */
430
431 static inline void gen_add_d(TCGv ret, TCGv r1, TCGv r2)
432 {
433 TCGv t0 = tcg_temp_new_i32();
434 TCGv result = tcg_temp_new_i32();
435 /* Addition and set V/SV bits */
436 tcg_gen_add_tl(result, r1, r2);
437 /* calc V bit */
438 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
439 tcg_gen_xor_tl(t0, r1, r2);
440 tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
441 /* Calc SV bit */
442 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
443 /* Calc AV/SAV bits */
444 tcg_gen_add_tl(cpu_PSW_AV, result, result);
445 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
446 /* calc SAV */
447 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
448 /* write back result */
449 tcg_gen_mov_tl(ret, result);
450
451 tcg_temp_free(result);
452 tcg_temp_free(t0);
453 }
454
455 static inline void
456 gen_add64_d(TCGv_i64 ret, TCGv_i64 r1, TCGv_i64 r2)
457 {
458 TCGv temp = tcg_temp_new();
459 TCGv_i64 t0 = tcg_temp_new_i64();
460 TCGv_i64 t1 = tcg_temp_new_i64();
461 TCGv_i64 result = tcg_temp_new_i64();
462
463 tcg_gen_add_i64(result, r1, r2);
464 /* calc v bit */
465 tcg_gen_xor_i64(t1, result, r1);
466 tcg_gen_xor_i64(t0, r1, r2);
467 tcg_gen_andc_i64(t1, t1, t0);
468 tcg_gen_extrh_i64_i32(cpu_PSW_V, t1);
469 /* calc SV bit */
470 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
471 /* calc AV/SAV bits */
472 tcg_gen_extrh_i64_i32(temp, result);
473 tcg_gen_add_tl(cpu_PSW_AV, temp, temp);
474 tcg_gen_xor_tl(cpu_PSW_AV, temp, cpu_PSW_AV);
475 /* calc SAV */
476 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
477 /* write back result */
478 tcg_gen_mov_i64(ret, result);
479
480 tcg_temp_free(temp);
481 tcg_temp_free_i64(result);
482 tcg_temp_free_i64(t0);
483 tcg_temp_free_i64(t1);
484 }
485
486 static inline void
487 gen_addsub64_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
488 TCGv r3, void(*op1)(TCGv, TCGv, TCGv),
489 void(*op2)(TCGv, TCGv, TCGv))
490 {
491 TCGv temp = tcg_temp_new();
492 TCGv temp2 = tcg_temp_new();
493 TCGv temp3 = tcg_temp_new();
494 TCGv temp4 = tcg_temp_new();
495
496 (*op1)(temp, r1_low, r2);
497 /* calc V0 bit */
498 tcg_gen_xor_tl(temp2, temp, r1_low);
499 tcg_gen_xor_tl(temp3, r1_low, r2);
500 if (op1 == tcg_gen_add_tl) {
501 tcg_gen_andc_tl(temp2, temp2, temp3);
502 } else {
503 tcg_gen_and_tl(temp2, temp2, temp3);
504 }
505
506 (*op2)(temp3, r1_high, r3);
507 /* calc V1 bit */
508 tcg_gen_xor_tl(cpu_PSW_V, temp3, r1_high);
509 tcg_gen_xor_tl(temp4, r1_high, r3);
510 if (op2 == tcg_gen_add_tl) {
511 tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, temp4);
512 } else {
513 tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp4);
514 }
515 /* combine V0/V1 bits */
516 tcg_gen_or_tl(cpu_PSW_V, cpu_PSW_V, temp2);
517 /* calc sv bit */
518 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
519 /* write result */
520 tcg_gen_mov_tl(ret_low, temp);
521 tcg_gen_mov_tl(ret_high, temp3);
522 /* calc AV bit */
523 tcg_gen_add_tl(temp, ret_low, ret_low);
524 tcg_gen_xor_tl(temp, temp, ret_low);
525 tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
526 tcg_gen_xor_tl(cpu_PSW_AV, cpu_PSW_AV, ret_high);
527 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp);
528 /* calc SAV bit */
529 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
530
531 tcg_temp_free(temp);
532 tcg_temp_free(temp2);
533 tcg_temp_free(temp3);
534 tcg_temp_free(temp4);
535 }
536
537 /* ret = r2 + (r1 * r3); */
538 static inline void gen_madd32_d(TCGv ret, TCGv r1, TCGv r2, TCGv r3)
539 {
540 TCGv_i64 t1 = tcg_temp_new_i64();
541 TCGv_i64 t2 = tcg_temp_new_i64();
542 TCGv_i64 t3 = tcg_temp_new_i64();
543
544 tcg_gen_ext_i32_i64(t1, r1);
545 tcg_gen_ext_i32_i64(t2, r2);
546 tcg_gen_ext_i32_i64(t3, r3);
547
548 tcg_gen_mul_i64(t1, t1, t3);
549 tcg_gen_add_i64(t1, t2, t1);
550
551 tcg_gen_extrl_i64_i32(ret, t1);
552 /* calc V
553 t1 > 0x7fffffff */
554 tcg_gen_setcondi_i64(TCG_COND_GT, t3, t1, 0x7fffffffLL);
555 /* t1 < -0x80000000 */
556 tcg_gen_setcondi_i64(TCG_COND_LT, t2, t1, -0x80000000LL);
557 tcg_gen_or_i64(t2, t2, t3);
558 tcg_gen_extrl_i64_i32(cpu_PSW_V, t2);
559 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
560 /* Calc SV bit */
561 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
562 /* Calc AV/SAV bits */
563 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
564 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
565 /* calc SAV */
566 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
567
568 tcg_temp_free_i64(t1);
569 tcg_temp_free_i64(t2);
570 tcg_temp_free_i64(t3);
571 }
572
573 static inline void gen_maddi32_d(TCGv ret, TCGv r1, TCGv r2, int32_t con)
574 {
575 TCGv temp = tcg_const_i32(con);
576 gen_madd32_d(ret, r1, r2, temp);
577 tcg_temp_free(temp);
578 }
579
580 static inline void
581 gen_madd64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
582 TCGv r3)
583 {
584 TCGv t1 = tcg_temp_new();
585 TCGv t2 = tcg_temp_new();
586 TCGv t3 = tcg_temp_new();
587 TCGv t4 = tcg_temp_new();
588
589 tcg_gen_muls2_tl(t1, t2, r1, r3);
590 /* only the add can overflow */
591 tcg_gen_add2_tl(t3, t4, r2_low, r2_high, t1, t2);
592 /* calc V bit */
593 tcg_gen_xor_tl(cpu_PSW_V, t4, r2_high);
594 tcg_gen_xor_tl(t1, r2_high, t2);
595 tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t1);
596 /* Calc SV bit */
597 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
598 /* Calc AV/SAV bits */
599 tcg_gen_add_tl(cpu_PSW_AV, t4, t4);
600 tcg_gen_xor_tl(cpu_PSW_AV, t4, cpu_PSW_AV);
601 /* calc SAV */
602 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
603 /* write back the result */
604 tcg_gen_mov_tl(ret_low, t3);
605 tcg_gen_mov_tl(ret_high, t4);
606
607 tcg_temp_free(t1);
608 tcg_temp_free(t2);
609 tcg_temp_free(t3);
610 tcg_temp_free(t4);
611 }
612
613 static inline void
614 gen_maddu64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
615 TCGv r3)
616 {
617 TCGv_i64 t1 = tcg_temp_new_i64();
618 TCGv_i64 t2 = tcg_temp_new_i64();
619 TCGv_i64 t3 = tcg_temp_new_i64();
620
621 tcg_gen_extu_i32_i64(t1, r1);
622 tcg_gen_concat_i32_i64(t2, r2_low, r2_high);
623 tcg_gen_extu_i32_i64(t3, r3);
624
625 tcg_gen_mul_i64(t1, t1, t3);
626 tcg_gen_add_i64(t2, t2, t1);
627 /* write back result */
628 tcg_gen_extr_i64_i32(ret_low, ret_high, t2);
629 /* only the add overflows, if t2 < t1
630 calc V bit */
631 tcg_gen_setcond_i64(TCG_COND_LTU, t2, t2, t1);
632 tcg_gen_extrl_i64_i32(cpu_PSW_V, t2);
633 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
634 /* Calc SV bit */
635 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
636 /* Calc AV/SAV bits */
637 tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
638 tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
639 /* calc SAV */
640 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
641
642 tcg_temp_free_i64(t1);
643 tcg_temp_free_i64(t2);
644 tcg_temp_free_i64(t3);
645 }
646
647 static inline void
648 gen_maddi64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
649 int32_t con)
650 {
651 TCGv temp = tcg_const_i32(con);
652 gen_madd64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
653 tcg_temp_free(temp);
654 }
655
656 static inline void
657 gen_maddui64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
658 int32_t con)
659 {
660 TCGv temp = tcg_const_i32(con);
661 gen_maddu64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
662 tcg_temp_free(temp);
663 }
664
665 static inline void
666 gen_madd_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
667 TCGv r3, uint32_t n, uint32_t mode)
668 {
669 TCGv temp = tcg_const_i32(n);
670 TCGv temp2 = tcg_temp_new();
671 TCGv_i64 temp64 = tcg_temp_new_i64();
672 switch (mode) {
673 case MODE_LL:
674 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
675 break;
676 case MODE_LU:
677 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
678 break;
679 case MODE_UL:
680 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
681 break;
682 case MODE_UU:
683 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
684 break;
685 }
686 tcg_gen_extr_i64_i32(temp, temp2, temp64);
687 gen_addsub64_h(ret_low, ret_high, r1_low, r1_high, temp, temp2,
688 tcg_gen_add_tl, tcg_gen_add_tl);
689 tcg_temp_free(temp);
690 tcg_temp_free(temp2);
691 tcg_temp_free_i64(temp64);
692 }
693
694 static inline void
695 gen_maddsu_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
696 TCGv r3, uint32_t n, uint32_t mode)
697 {
698 TCGv temp = tcg_const_i32(n);
699 TCGv temp2 = tcg_temp_new();
700 TCGv_i64 temp64 = tcg_temp_new_i64();
701 switch (mode) {
702 case MODE_LL:
703 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
704 break;
705 case MODE_LU:
706 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
707 break;
708 case MODE_UL:
709 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
710 break;
711 case MODE_UU:
712 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
713 break;
714 }
715 tcg_gen_extr_i64_i32(temp, temp2, temp64);
716 gen_addsub64_h(ret_low, ret_high, r1_low, r1_high, temp, temp2,
717 tcg_gen_sub_tl, tcg_gen_add_tl);
718 tcg_temp_free(temp);
719 tcg_temp_free(temp2);
720 tcg_temp_free_i64(temp64);
721 }
722
723 static inline void
724 gen_maddsum_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
725 TCGv r3, uint32_t n, uint32_t mode)
726 {
727 TCGv temp = tcg_const_i32(n);
728 TCGv_i64 temp64 = tcg_temp_new_i64();
729 TCGv_i64 temp64_2 = tcg_temp_new_i64();
730 TCGv_i64 temp64_3 = tcg_temp_new_i64();
731 switch (mode) {
732 case MODE_LL:
733 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
734 break;
735 case MODE_LU:
736 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
737 break;
738 case MODE_UL:
739 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
740 break;
741 case MODE_UU:
742 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
743 break;
744 }
745 tcg_gen_concat_i32_i64(temp64_3, r1_low, r1_high);
746 tcg_gen_sari_i64(temp64_2, temp64, 32); /* high */
747 tcg_gen_ext32s_i64(temp64, temp64); /* low */
748 tcg_gen_sub_i64(temp64, temp64_2, temp64);
749 tcg_gen_shli_i64(temp64, temp64, 16);
750
751 gen_add64_d(temp64_2, temp64_3, temp64);
752 /* write back result */
753 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64_2);
754
755 tcg_temp_free(temp);
756 tcg_temp_free_i64(temp64);
757 tcg_temp_free_i64(temp64_2);
758 tcg_temp_free_i64(temp64_3);
759 }
760
761 static inline void gen_adds(TCGv ret, TCGv r1, TCGv r2);
762
763 static inline void
764 gen_madds_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
765 TCGv r3, uint32_t n, uint32_t mode)
766 {
767 TCGv temp = tcg_const_i32(n);
768 TCGv temp2 = tcg_temp_new();
769 TCGv temp3 = tcg_temp_new();
770 TCGv_i64 temp64 = tcg_temp_new_i64();
771
772 switch (mode) {
773 case MODE_LL:
774 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
775 break;
776 case MODE_LU:
777 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
778 break;
779 case MODE_UL:
780 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
781 break;
782 case MODE_UU:
783 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
784 break;
785 }
786 tcg_gen_extr_i64_i32(temp, temp2, temp64);
787 gen_adds(ret_low, r1_low, temp);
788 tcg_gen_mov_tl(temp, cpu_PSW_V);
789 tcg_gen_mov_tl(temp3, cpu_PSW_AV);
790 gen_adds(ret_high, r1_high, temp2);
791 /* combine v bits */
792 tcg_gen_or_tl(cpu_PSW_V, cpu_PSW_V, temp);
793 /* combine av bits */
794 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp3);
795
796 tcg_temp_free(temp);
797 tcg_temp_free(temp2);
798 tcg_temp_free(temp3);
799 tcg_temp_free_i64(temp64);
800
801 }
802
803 static inline void gen_subs(TCGv ret, TCGv r1, TCGv r2);
804
805 static inline void
806 gen_maddsus_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
807 TCGv r3, uint32_t n, uint32_t mode)
808 {
809 TCGv temp = tcg_const_i32(n);
810 TCGv temp2 = tcg_temp_new();
811 TCGv temp3 = tcg_temp_new();
812 TCGv_i64 temp64 = tcg_temp_new_i64();
813
814 switch (mode) {
815 case MODE_LL:
816 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
817 break;
818 case MODE_LU:
819 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
820 break;
821 case MODE_UL:
822 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
823 break;
824 case MODE_UU:
825 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
826 break;
827 }
828 tcg_gen_extr_i64_i32(temp, temp2, temp64);
829 gen_subs(ret_low, r1_low, temp);
830 tcg_gen_mov_tl(temp, cpu_PSW_V);
831 tcg_gen_mov_tl(temp3, cpu_PSW_AV);
832 gen_adds(ret_high, r1_high, temp2);
833 /* combine v bits */
834 tcg_gen_or_tl(cpu_PSW_V, cpu_PSW_V, temp);
835 /* combine av bits */
836 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp3);
837
838 tcg_temp_free(temp);
839 tcg_temp_free(temp2);
840 tcg_temp_free(temp3);
841 tcg_temp_free_i64(temp64);
842
843 }
844
845 static inline void
846 gen_maddsums_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
847 TCGv r3, uint32_t n, uint32_t mode)
848 {
849 TCGv temp = tcg_const_i32(n);
850 TCGv_i64 temp64 = tcg_temp_new_i64();
851 TCGv_i64 temp64_2 = tcg_temp_new_i64();
852
853 switch (mode) {
854 case MODE_LL:
855 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
856 break;
857 case MODE_LU:
858 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
859 break;
860 case MODE_UL:
861 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
862 break;
863 case MODE_UU:
864 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
865 break;
866 }
867 tcg_gen_sari_i64(temp64_2, temp64, 32); /* high */
868 tcg_gen_ext32s_i64(temp64, temp64); /* low */
869 tcg_gen_sub_i64(temp64, temp64_2, temp64);
870 tcg_gen_shli_i64(temp64, temp64, 16);
871 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
872
873 gen_helper_add64_ssov(temp64, cpu_env, temp64_2, temp64);
874 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
875
876 tcg_temp_free(temp);
877 tcg_temp_free_i64(temp64);
878 tcg_temp_free_i64(temp64_2);
879 }
880
881
882 static inline void
883 gen_maddm_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
884 TCGv r3, uint32_t n, uint32_t mode)
885 {
886 TCGv temp = tcg_const_i32(n);
887 TCGv_i64 temp64 = tcg_temp_new_i64();
888 TCGv_i64 temp64_2 = tcg_temp_new_i64();
889 TCGv_i64 temp64_3 = tcg_temp_new_i64();
890 switch (mode) {
891 case MODE_LL:
892 GEN_HELPER_LL(mulm_h, temp64, r2, r3, temp);
893 break;
894 case MODE_LU:
895 GEN_HELPER_LU(mulm_h, temp64, r2, r3, temp);
896 break;
897 case MODE_UL:
898 GEN_HELPER_UL(mulm_h, temp64, r2, r3, temp);
899 break;
900 case MODE_UU:
901 GEN_HELPER_UU(mulm_h, temp64, r2, r3, temp);
902 break;
903 }
904 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
905 gen_add64_d(temp64_3, temp64_2, temp64);
906 /* write back result */
907 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64_3);
908
909 tcg_temp_free(temp);
910 tcg_temp_free_i64(temp64);
911 tcg_temp_free_i64(temp64_2);
912 tcg_temp_free_i64(temp64_3);
913 }
914
915 static inline void
916 gen_maddms_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
917 TCGv r3, uint32_t n, uint32_t mode)
918 {
919 TCGv temp = tcg_const_i32(n);
920 TCGv_i64 temp64 = tcg_temp_new_i64();
921 TCGv_i64 temp64_2 = tcg_temp_new_i64();
922 switch (mode) {
923 case MODE_LL:
924 GEN_HELPER_LL(mulm_h, temp64, r2, r3, temp);
925 break;
926 case MODE_LU:
927 GEN_HELPER_LU(mulm_h, temp64, r2, r3, temp);
928 break;
929 case MODE_UL:
930 GEN_HELPER_UL(mulm_h, temp64, r2, r3, temp);
931 break;
932 case MODE_UU:
933 GEN_HELPER_UU(mulm_h, temp64, r2, r3, temp);
934 break;
935 }
936 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
937 gen_helper_add64_ssov(temp64, cpu_env, temp64_2, temp64);
938 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
939
940 tcg_temp_free(temp);
941 tcg_temp_free_i64(temp64);
942 tcg_temp_free_i64(temp64_2);
943 }
944
945 static inline void
946 gen_maddr64_h(TCGv ret, TCGv r1_low, TCGv r1_high, TCGv r2, TCGv r3, uint32_t n,
947 uint32_t mode)
948 {
949 TCGv temp = tcg_const_i32(n);
950 TCGv_i64 temp64 = tcg_temp_new_i64();
951 switch (mode) {
952 case MODE_LL:
953 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
954 break;
955 case MODE_LU:
956 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
957 break;
958 case MODE_UL:
959 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
960 break;
961 case MODE_UU:
962 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
963 break;
964 }
965 gen_helper_addr_h(ret, cpu_env, temp64, r1_low, r1_high);
966
967 tcg_temp_free(temp);
968 tcg_temp_free_i64(temp64);
969 }
970
971 static inline void
972 gen_maddr32_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
973 {
974 TCGv temp = tcg_temp_new();
975 TCGv temp2 = tcg_temp_new();
976
977 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
978 tcg_gen_shli_tl(temp, r1, 16);
979 gen_maddr64_h(ret, temp, temp2, r2, r3, n, mode);
980
981 tcg_temp_free(temp);
982 tcg_temp_free(temp2);
983 }
984
985 static inline void
986 gen_maddsur32_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
987 {
988 TCGv temp = tcg_const_i32(n);
989 TCGv temp2 = tcg_temp_new();
990 TCGv_i64 temp64 = tcg_temp_new_i64();
991 switch (mode) {
992 case MODE_LL:
993 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
994 break;
995 case MODE_LU:
996 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
997 break;
998 case MODE_UL:
999 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1000 break;
1001 case MODE_UU:
1002 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1003 break;
1004 }
1005 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
1006 tcg_gen_shli_tl(temp, r1, 16);
1007 gen_helper_addsur_h(ret, cpu_env, temp64, temp, temp2);
1008
1009 tcg_temp_free(temp);
1010 tcg_temp_free(temp2);
1011 tcg_temp_free_i64(temp64);
1012 }
1013
1014
1015 static inline void
1016 gen_maddr64s_h(TCGv ret, TCGv r1_low, TCGv r1_high, TCGv r2, TCGv r3,
1017 uint32_t n, uint32_t mode)
1018 {
1019 TCGv temp = tcg_const_i32(n);
1020 TCGv_i64 temp64 = tcg_temp_new_i64();
1021 switch (mode) {
1022 case MODE_LL:
1023 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1024 break;
1025 case MODE_LU:
1026 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1027 break;
1028 case MODE_UL:
1029 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1030 break;
1031 case MODE_UU:
1032 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1033 break;
1034 }
1035 gen_helper_addr_h_ssov(ret, cpu_env, temp64, r1_low, r1_high);
1036
1037 tcg_temp_free(temp);
1038 tcg_temp_free_i64(temp64);
1039 }
1040
1041 static inline void
1042 gen_maddr32s_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
1043 {
1044 TCGv temp = tcg_temp_new();
1045 TCGv temp2 = tcg_temp_new();
1046
1047 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
1048 tcg_gen_shli_tl(temp, r1, 16);
1049 gen_maddr64s_h(ret, temp, temp2, r2, r3, n, mode);
1050
1051 tcg_temp_free(temp);
1052 tcg_temp_free(temp2);
1053 }
1054
1055 static inline void
1056 gen_maddsur32s_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
1057 {
1058 TCGv temp = tcg_const_i32(n);
1059 TCGv temp2 = tcg_temp_new();
1060 TCGv_i64 temp64 = tcg_temp_new_i64();
1061 switch (mode) {
1062 case MODE_LL:
1063 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1064 break;
1065 case MODE_LU:
1066 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1067 break;
1068 case MODE_UL:
1069 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1070 break;
1071 case MODE_UU:
1072 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1073 break;
1074 }
1075 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
1076 tcg_gen_shli_tl(temp, r1, 16);
1077 gen_helper_addsur_h_ssov(ret, cpu_env, temp64, temp, temp2);
1078
1079 tcg_temp_free(temp);
1080 tcg_temp_free(temp2);
1081 tcg_temp_free_i64(temp64);
1082 }
1083
1084 static inline void
1085 gen_maddr_q(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n)
1086 {
1087 TCGv temp = tcg_const_i32(n);
1088 gen_helper_maddr_q(ret, cpu_env, r1, r2, r3, temp);
1089 tcg_temp_free(temp);
1090 }
1091
1092 static inline void
1093 gen_maddrs_q(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n)
1094 {
1095 TCGv temp = tcg_const_i32(n);
1096 gen_helper_maddr_q_ssov(ret, cpu_env, r1, r2, r3, temp);
1097 tcg_temp_free(temp);
1098 }
1099
1100 static inline void
1101 gen_madd32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n,
1102 uint32_t up_shift)
1103 {
1104 TCGv temp = tcg_temp_new();
1105 TCGv temp2 = tcg_temp_new();
1106 TCGv temp3 = tcg_temp_new();
1107 TCGv_i64 t1 = tcg_temp_new_i64();
1108 TCGv_i64 t2 = tcg_temp_new_i64();
1109 TCGv_i64 t3 = tcg_temp_new_i64();
1110
1111 tcg_gen_ext_i32_i64(t2, arg2);
1112 tcg_gen_ext_i32_i64(t3, arg3);
1113
1114 tcg_gen_mul_i64(t2, t2, t3);
1115 tcg_gen_shli_i64(t2, t2, n);
1116
1117 tcg_gen_ext_i32_i64(t1, arg1);
1118 tcg_gen_sari_i64(t2, t2, up_shift);
1119
1120 tcg_gen_add_i64(t3, t1, t2);
1121 tcg_gen_extrl_i64_i32(temp3, t3);
1122 /* calc v bit */
1123 tcg_gen_setcondi_i64(TCG_COND_GT, t1, t3, 0x7fffffffLL);
1124 tcg_gen_setcondi_i64(TCG_COND_LT, t2, t3, -0x80000000LL);
1125 tcg_gen_or_i64(t1, t1, t2);
1126 tcg_gen_extrl_i64_i32(cpu_PSW_V, t1);
1127 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1128 /* We produce an overflow on the host if the mul before was
1129 (0x80000000 * 0x80000000) << 1). If this is the
1130 case, we negate the ovf. */
1131 if (n == 1) {
1132 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, arg2, 0x80000000);
1133 tcg_gen_setcond_tl(TCG_COND_EQ, temp2, arg2, arg3);
1134 tcg_gen_and_tl(temp, temp, temp2);
1135 tcg_gen_shli_tl(temp, temp, 31);
1136 /* negate v bit, if special condition */
1137 tcg_gen_xor_tl(cpu_PSW_V, cpu_PSW_V, temp);
1138 }
1139 /* Calc SV bit */
1140 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1141 /* Calc AV/SAV bits */
1142 tcg_gen_add_tl(cpu_PSW_AV, temp3, temp3);
1143 tcg_gen_xor_tl(cpu_PSW_AV, temp3, cpu_PSW_AV);
1144 /* calc SAV */
1145 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1146 /* write back result */
1147 tcg_gen_mov_tl(ret, temp3);
1148
1149 tcg_temp_free(temp);
1150 tcg_temp_free(temp2);
1151 tcg_temp_free(temp3);
1152 tcg_temp_free_i64(t1);
1153 tcg_temp_free_i64(t2);
1154 tcg_temp_free_i64(t3);
1155 }
1156
1157 static inline void
1158 gen_m16add32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n)
1159 {
1160 TCGv temp = tcg_temp_new();
1161 TCGv temp2 = tcg_temp_new();
1162 if (n == 0) {
1163 tcg_gen_mul_tl(temp, arg2, arg3);
1164 } else { /* n is expected to be 1 */
1165 tcg_gen_mul_tl(temp, arg2, arg3);
1166 tcg_gen_shli_tl(temp, temp, 1);
1167 /* catch special case r1 = r2 = 0x8000 */
1168 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
1169 tcg_gen_sub_tl(temp, temp, temp2);
1170 }
1171 gen_add_d(ret, arg1, temp);
1172
1173 tcg_temp_free(temp);
1174 tcg_temp_free(temp2);
1175 }
1176
1177 static inline void
1178 gen_m16adds32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n)
1179 {
1180 TCGv temp = tcg_temp_new();
1181 TCGv temp2 = tcg_temp_new();
1182 if (n == 0) {
1183 tcg_gen_mul_tl(temp, arg2, arg3);
1184 } else { /* n is expected to be 1 */
1185 tcg_gen_mul_tl(temp, arg2, arg3);
1186 tcg_gen_shli_tl(temp, temp, 1);
1187 /* catch special case r1 = r2 = 0x8000 */
1188 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
1189 tcg_gen_sub_tl(temp, temp, temp2);
1190 }
1191 gen_adds(ret, arg1, temp);
1192
1193 tcg_temp_free(temp);
1194 tcg_temp_free(temp2);
1195 }
1196
1197 static inline void
1198 gen_m16add64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
1199 TCGv arg3, uint32_t n)
1200 {
1201 TCGv temp = tcg_temp_new();
1202 TCGv temp2 = tcg_temp_new();
1203 TCGv_i64 t1 = tcg_temp_new_i64();
1204 TCGv_i64 t2 = tcg_temp_new_i64();
1205 TCGv_i64 t3 = tcg_temp_new_i64();
1206
1207 if (n == 0) {
1208 tcg_gen_mul_tl(temp, arg2, arg3);
1209 } else { /* n is expected to be 1 */
1210 tcg_gen_mul_tl(temp, arg2, arg3);
1211 tcg_gen_shli_tl(temp, temp, 1);
1212 /* catch special case r1 = r2 = 0x8000 */
1213 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
1214 tcg_gen_sub_tl(temp, temp, temp2);
1215 }
1216 tcg_gen_ext_i32_i64(t2, temp);
1217 tcg_gen_shli_i64(t2, t2, 16);
1218 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
1219 gen_add64_d(t3, t1, t2);
1220 /* write back result */
1221 tcg_gen_extr_i64_i32(rl, rh, t3);
1222
1223 tcg_temp_free_i64(t1);
1224 tcg_temp_free_i64(t2);
1225 tcg_temp_free_i64(t3);
1226 tcg_temp_free(temp);
1227 tcg_temp_free(temp2);
1228 }
1229
1230 static inline void
1231 gen_m16adds64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
1232 TCGv arg3, uint32_t n)
1233 {
1234 TCGv temp = tcg_temp_new();
1235 TCGv temp2 = tcg_temp_new();
1236 TCGv_i64 t1 = tcg_temp_new_i64();
1237 TCGv_i64 t2 = tcg_temp_new_i64();
1238
1239 if (n == 0) {
1240 tcg_gen_mul_tl(temp, arg2, arg3);
1241 } else { /* n is expected to be 1 */
1242 tcg_gen_mul_tl(temp, arg2, arg3);
1243 tcg_gen_shli_tl(temp, temp, 1);
1244 /* catch special case r1 = r2 = 0x8000 */
1245 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
1246 tcg_gen_sub_tl(temp, temp, temp2);
1247 }
1248 tcg_gen_ext_i32_i64(t2, temp);
1249 tcg_gen_shli_i64(t2, t2, 16);
1250 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
1251
1252 gen_helper_add64_ssov(t1, cpu_env, t1, t2);
1253 tcg_gen_extr_i64_i32(rl, rh, t1);
1254
1255 tcg_temp_free(temp);
1256 tcg_temp_free(temp2);
1257 tcg_temp_free_i64(t1);
1258 tcg_temp_free_i64(t2);
1259 }
1260
1261 static inline void
1262 gen_madd64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
1263 TCGv arg3, uint32_t n)
1264 {
1265 TCGv_i64 t1 = tcg_temp_new_i64();
1266 TCGv_i64 t2 = tcg_temp_new_i64();
1267 TCGv_i64 t3 = tcg_temp_new_i64();
1268 TCGv_i64 t4 = tcg_temp_new_i64();
1269 TCGv temp, temp2;
1270
1271 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
1272 tcg_gen_ext_i32_i64(t2, arg2);
1273 tcg_gen_ext_i32_i64(t3, arg3);
1274
1275 tcg_gen_mul_i64(t2, t2, t3);
1276 if (n != 0) {
1277 tcg_gen_shli_i64(t2, t2, 1);
1278 }
1279 tcg_gen_add_i64(t4, t1, t2);
1280 /* calc v bit */
1281 tcg_gen_xor_i64(t3, t4, t1);
1282 tcg_gen_xor_i64(t2, t1, t2);
1283 tcg_gen_andc_i64(t3, t3, t2);
1284 tcg_gen_extrh_i64_i32(cpu_PSW_V, t3);
1285 /* We produce an overflow on the host if the mul before was
1286 (0x80000000 * 0x80000000) << 1). If this is the
1287 case, we negate the ovf. */
1288 if (n == 1) {
1289 temp = tcg_temp_new();
1290 temp2 = tcg_temp_new();
1291 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, arg2, 0x80000000);
1292 tcg_gen_setcond_tl(TCG_COND_EQ, temp2, arg2, arg3);
1293 tcg_gen_and_tl(temp, temp, temp2);
1294 tcg_gen_shli_tl(temp, temp, 31);
1295 /* negate v bit, if special condition */
1296 tcg_gen_xor_tl(cpu_PSW_V, cpu_PSW_V, temp);
1297
1298 tcg_temp_free(temp);
1299 tcg_temp_free(temp2);
1300 }
1301 /* write back result */
1302 tcg_gen_extr_i64_i32(rl, rh, t4);
1303 /* Calc SV bit */
1304 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1305 /* Calc AV/SAV bits */
1306 tcg_gen_add_tl(cpu_PSW_AV, rh, rh);
1307 tcg_gen_xor_tl(cpu_PSW_AV, rh, cpu_PSW_AV);
1308 /* calc SAV */
1309 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1310
1311 tcg_temp_free_i64(t1);
1312 tcg_temp_free_i64(t2);
1313 tcg_temp_free_i64(t3);
1314 tcg_temp_free_i64(t4);
1315 }
1316
1317 static inline void
1318 gen_madds32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n,
1319 uint32_t up_shift)
1320 {
1321 TCGv_i64 t1 = tcg_temp_new_i64();
1322 TCGv_i64 t2 = tcg_temp_new_i64();
1323 TCGv_i64 t3 = tcg_temp_new_i64();
1324
1325 tcg_gen_ext_i32_i64(t1, arg1);
1326 tcg_gen_ext_i32_i64(t2, arg2);
1327 tcg_gen_ext_i32_i64(t3, arg3);
1328
1329 tcg_gen_mul_i64(t2, t2, t3);
1330 tcg_gen_sari_i64(t2, t2, up_shift - n);
1331
1332 gen_helper_madd32_q_add_ssov(ret, cpu_env, t1, t2);
1333
1334 tcg_temp_free_i64(t1);
1335 tcg_temp_free_i64(t2);
1336 tcg_temp_free_i64(t3);
1337 }
1338
1339 static inline void
1340 gen_madds64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
1341 TCGv arg3, uint32_t n)
1342 {
1343 TCGv_i64 r1 = tcg_temp_new_i64();
1344 TCGv temp = tcg_const_i32(n);
1345
1346 tcg_gen_concat_i32_i64(r1, arg1_low, arg1_high);
1347 gen_helper_madd64_q_ssov(r1, cpu_env, r1, arg2, arg3, temp);
1348 tcg_gen_extr_i64_i32(rl, rh, r1);
1349
1350 tcg_temp_free_i64(r1);
1351 tcg_temp_free(temp);
1352 }
1353 /* ret = r2 - (r1 * r3); */
1354 static inline void gen_msub32_d(TCGv ret, TCGv r1, TCGv r2, TCGv r3)
1355 {
1356 TCGv_i64 t1 = tcg_temp_new_i64();
1357 TCGv_i64 t2 = tcg_temp_new_i64();
1358 TCGv_i64 t3 = tcg_temp_new_i64();
1359
1360 tcg_gen_ext_i32_i64(t1, r1);
1361 tcg_gen_ext_i32_i64(t2, r2);
1362 tcg_gen_ext_i32_i64(t3, r3);
1363
1364 tcg_gen_mul_i64(t1, t1, t3);
1365 tcg_gen_sub_i64(t1, t2, t1);
1366
1367 tcg_gen_extrl_i64_i32(ret, t1);
1368 /* calc V
1369 t2 > 0x7fffffff */
1370 tcg_gen_setcondi_i64(TCG_COND_GT, t3, t1, 0x7fffffffLL);
1371 /* result < -0x80000000 */
1372 tcg_gen_setcondi_i64(TCG_COND_LT, t2, t1, -0x80000000LL);
1373 tcg_gen_or_i64(t2, t2, t3);
1374 tcg_gen_extrl_i64_i32(cpu_PSW_V, t2);
1375 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1376
1377 /* Calc SV bit */
1378 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1379 /* Calc AV/SAV bits */
1380 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
1381 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
1382 /* calc SAV */
1383 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1384
1385 tcg_temp_free_i64(t1);
1386 tcg_temp_free_i64(t2);
1387 tcg_temp_free_i64(t3);
1388 }
1389
1390 static inline void gen_msubi32_d(TCGv ret, TCGv r1, TCGv r2, int32_t con)
1391 {
1392 TCGv temp = tcg_const_i32(con);
1393 gen_msub32_d(ret, r1, r2, temp);
1394 tcg_temp_free(temp);
1395 }
1396
1397 static inline void
1398 gen_msub64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1399 TCGv r3)
1400 {
1401 TCGv t1 = tcg_temp_new();
1402 TCGv t2 = tcg_temp_new();
1403 TCGv t3 = tcg_temp_new();
1404 TCGv t4 = tcg_temp_new();
1405
1406 tcg_gen_muls2_tl(t1, t2, r1, r3);
1407 /* only the sub can overflow */
1408 tcg_gen_sub2_tl(t3, t4, r2_low, r2_high, t1, t2);
1409 /* calc V bit */
1410 tcg_gen_xor_tl(cpu_PSW_V, t4, r2_high);
1411 tcg_gen_xor_tl(t1, r2_high, t2);
1412 tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, t1);
1413 /* Calc SV bit */
1414 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1415 /* Calc AV/SAV bits */
1416 tcg_gen_add_tl(cpu_PSW_AV, t4, t4);
1417 tcg_gen_xor_tl(cpu_PSW_AV, t4, cpu_PSW_AV);
1418 /* calc SAV */
1419 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1420 /* write back the result */
1421 tcg_gen_mov_tl(ret_low, t3);
1422 tcg_gen_mov_tl(ret_high, t4);
1423
1424 tcg_temp_free(t1);
1425 tcg_temp_free(t2);
1426 tcg_temp_free(t3);
1427 tcg_temp_free(t4);
1428 }
1429
1430 static inline void
1431 gen_msubi64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1432 int32_t con)
1433 {
1434 TCGv temp = tcg_const_i32(con);
1435 gen_msub64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
1436 tcg_temp_free(temp);
1437 }
1438
1439 static inline void
1440 gen_msubu64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1441 TCGv r3)
1442 {
1443 TCGv_i64 t1 = tcg_temp_new_i64();
1444 TCGv_i64 t2 = tcg_temp_new_i64();
1445 TCGv_i64 t3 = tcg_temp_new_i64();
1446
1447 tcg_gen_extu_i32_i64(t1, r1);
1448 tcg_gen_concat_i32_i64(t2, r2_low, r2_high);
1449 tcg_gen_extu_i32_i64(t3, r3);
1450
1451 tcg_gen_mul_i64(t1, t1, t3);
1452 tcg_gen_sub_i64(t3, t2, t1);
1453 tcg_gen_extr_i64_i32(ret_low, ret_high, t3);
1454 /* calc V bit, only the sub can overflow, if t1 > t2 */
1455 tcg_gen_setcond_i64(TCG_COND_GTU, t1, t1, t2);
1456 tcg_gen_extrl_i64_i32(cpu_PSW_V, t1);
1457 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1458 /* Calc SV bit */
1459 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1460 /* Calc AV/SAV bits */
1461 tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
1462 tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
1463 /* calc SAV */
1464 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1465
1466 tcg_temp_free_i64(t1);
1467 tcg_temp_free_i64(t2);
1468 tcg_temp_free_i64(t3);
1469 }
1470
1471 static inline void
1472 gen_msubui64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1473 int32_t con)
1474 {
1475 TCGv temp = tcg_const_i32(con);
1476 gen_msubu64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
1477 tcg_temp_free(temp);
1478 }
1479
1480 static inline void gen_addi_d(TCGv ret, TCGv r1, target_ulong r2)
1481 {
1482 TCGv temp = tcg_const_i32(r2);
1483 gen_add_d(ret, r1, temp);
1484 tcg_temp_free(temp);
1485 }
1486 /* calculate the carry bit too */
1487 static inline void gen_add_CC(TCGv ret, TCGv r1, TCGv r2)
1488 {
1489 TCGv t0 = tcg_temp_new_i32();
1490 TCGv result = tcg_temp_new_i32();
1491
1492 tcg_gen_movi_tl(t0, 0);
1493 /* Addition and set C/V/SV bits */
1494 tcg_gen_add2_i32(result, cpu_PSW_C, r1, t0, r2, t0);
1495 /* calc V bit */
1496 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
1497 tcg_gen_xor_tl(t0, r1, r2);
1498 tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
1499 /* Calc SV bit */
1500 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1501 /* Calc AV/SAV bits */
1502 tcg_gen_add_tl(cpu_PSW_AV, result, result);
1503 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
1504 /* calc SAV */
1505 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1506 /* write back result */
1507 tcg_gen_mov_tl(ret, result);
1508
1509 tcg_temp_free(result);
1510 tcg_temp_free(t0);
1511 }
1512
1513 static inline void gen_addi_CC(TCGv ret, TCGv r1, int32_t con)
1514 {
1515 TCGv temp = tcg_const_i32(con);
1516 gen_add_CC(ret, r1, temp);
1517 tcg_temp_free(temp);
1518 }
1519
1520 static inline void gen_addc_CC(TCGv ret, TCGv r1, TCGv r2)
1521 {
1522 TCGv carry = tcg_temp_new_i32();
1523 TCGv t0 = tcg_temp_new_i32();
1524 TCGv result = tcg_temp_new_i32();
1525
1526 tcg_gen_movi_tl(t0, 0);
1527 tcg_gen_setcondi_tl(TCG_COND_NE, carry, cpu_PSW_C, 0);
1528 /* Addition, carry and set C/V/SV bits */
1529 tcg_gen_add2_i32(result, cpu_PSW_C, r1, t0, carry, t0);
1530 tcg_gen_add2_i32(result, cpu_PSW_C, result, cpu_PSW_C, r2, t0);
1531 /* calc V bit */
1532 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
1533 tcg_gen_xor_tl(t0, r1, r2);
1534 tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
1535 /* Calc SV bit */
1536 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1537 /* Calc AV/SAV bits */
1538 tcg_gen_add_tl(cpu_PSW_AV, result, result);
1539 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
1540 /* calc SAV */
1541 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1542 /* write back result */
1543 tcg_gen_mov_tl(ret, result);
1544
1545 tcg_temp_free(result);
1546 tcg_temp_free(t0);
1547 tcg_temp_free(carry);
1548 }
1549
1550 static inline void gen_addci_CC(TCGv ret, TCGv r1, int32_t con)
1551 {
1552 TCGv temp = tcg_const_i32(con);
1553 gen_addc_CC(ret, r1, temp);
1554 tcg_temp_free(temp);
1555 }
1556
1557 static inline void gen_cond_add(TCGCond cond, TCGv r1, TCGv r2, TCGv r3,
1558 TCGv r4)
1559 {
1560 TCGv temp = tcg_temp_new();
1561 TCGv temp2 = tcg_temp_new();
1562 TCGv result = tcg_temp_new();
1563 TCGv mask = tcg_temp_new();
1564 TCGv t0 = tcg_const_i32(0);
1565
1566 /* create mask for sticky bits */
1567 tcg_gen_setcond_tl(cond, mask, r4, t0);
1568 tcg_gen_shli_tl(mask, mask, 31);
1569
1570 tcg_gen_add_tl(result, r1, r2);
1571 /* Calc PSW_V */
1572 tcg_gen_xor_tl(temp, result, r1);
1573 tcg_gen_xor_tl(temp2, r1, r2);
1574 tcg_gen_andc_tl(temp, temp, temp2);
1575 tcg_gen_movcond_tl(cond, cpu_PSW_V, r4, t0, temp, cpu_PSW_V);
1576 /* Set PSW_SV */
1577 tcg_gen_and_tl(temp, temp, mask);
1578 tcg_gen_or_tl(cpu_PSW_SV, temp, cpu_PSW_SV);
1579 /* calc AV bit */
1580 tcg_gen_add_tl(temp, result, result);
1581 tcg_gen_xor_tl(temp, temp, result);
1582 tcg_gen_movcond_tl(cond, cpu_PSW_AV, r4, t0, temp, cpu_PSW_AV);
1583 /* calc SAV bit */
1584 tcg_gen_and_tl(temp, temp, mask);
1585 tcg_gen_or_tl(cpu_PSW_SAV, temp, cpu_PSW_SAV);
1586 /* write back result */
1587 tcg_gen_movcond_tl(cond, r3, r4, t0, result, r1);
1588
1589 tcg_temp_free(t0);
1590 tcg_temp_free(temp);
1591 tcg_temp_free(temp2);
1592 tcg_temp_free(result);
1593 tcg_temp_free(mask);
1594 }
1595
1596 static inline void gen_condi_add(TCGCond cond, TCGv r1, int32_t r2,
1597 TCGv r3, TCGv r4)
1598 {
1599 TCGv temp = tcg_const_i32(r2);
1600 gen_cond_add(cond, r1, temp, r3, r4);
1601 tcg_temp_free(temp);
1602 }
1603
1604 static inline void gen_sub_d(TCGv ret, TCGv r1, TCGv r2)
1605 {
1606 TCGv temp = tcg_temp_new_i32();
1607 TCGv result = tcg_temp_new_i32();
1608
1609 tcg_gen_sub_tl(result, r1, r2);
1610 /* calc V bit */
1611 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
1612 tcg_gen_xor_tl(temp, r1, r2);
1613 tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
1614 /* calc SV bit */
1615 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1616 /* Calc AV bit */
1617 tcg_gen_add_tl(cpu_PSW_AV, result, result);
1618 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
1619 /* calc SAV bit */
1620 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1621 /* write back result */
1622 tcg_gen_mov_tl(ret, result);
1623
1624 tcg_temp_free(temp);
1625 tcg_temp_free(result);
1626 }
1627
1628 static inline void
1629 gen_sub64_d(TCGv_i64 ret, TCGv_i64 r1, TCGv_i64 r2)
1630 {
1631 TCGv temp = tcg_temp_new();
1632 TCGv_i64 t0 = tcg_temp_new_i64();
1633 TCGv_i64 t1 = tcg_temp_new_i64();
1634 TCGv_i64 result = tcg_temp_new_i64();
1635
1636 tcg_gen_sub_i64(result, r1, r2);
1637 /* calc v bit */
1638 tcg_gen_xor_i64(t1, result, r1);
1639 tcg_gen_xor_i64(t0, r1, r2);
1640 tcg_gen_and_i64(t1, t1, t0);
1641 tcg_gen_extrh_i64_i32(cpu_PSW_V, t1);
1642 /* calc SV bit */
1643 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1644 /* calc AV/SAV bits */
1645 tcg_gen_extrh_i64_i32(temp, result);
1646 tcg_gen_add_tl(cpu_PSW_AV, temp, temp);
1647 tcg_gen_xor_tl(cpu_PSW_AV, temp, cpu_PSW_AV);
1648 /* calc SAV */
1649 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1650 /* write back result */
1651 tcg_gen_mov_i64(ret, result);
1652
1653 tcg_temp_free(temp);
1654 tcg_temp_free_i64(result);
1655 tcg_temp_free_i64(t0);
1656 tcg_temp_free_i64(t1);
1657 }
1658
1659 static inline void gen_sub_CC(TCGv ret, TCGv r1, TCGv r2)
1660 {
1661 TCGv result = tcg_temp_new();
1662 TCGv temp = tcg_temp_new();
1663
1664 tcg_gen_sub_tl(result, r1, r2);
1665 /* calc C bit */
1666 tcg_gen_setcond_tl(TCG_COND_GEU, cpu_PSW_C, r1, r2);
1667 /* calc V bit */
1668 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
1669 tcg_gen_xor_tl(temp, r1, r2);
1670 tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
1671 /* calc SV bit */
1672 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1673 /* Calc AV bit */
1674 tcg_gen_add_tl(cpu_PSW_AV, result, result);
1675 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
1676 /* calc SAV bit */
1677 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1678 /* write back result */
1679 tcg_gen_mov_tl(ret, result);
1680
1681 tcg_temp_free(result);
1682 tcg_temp_free(temp);
1683 }
1684
1685 static inline void gen_subc_CC(TCGv ret, TCGv r1, TCGv r2)
1686 {
1687 TCGv temp = tcg_temp_new();
1688 tcg_gen_not_tl(temp, r2);
1689 gen_addc_CC(ret, r1, temp);
1690 tcg_temp_free(temp);
1691 }
1692
1693 static inline void gen_cond_sub(TCGCond cond, TCGv r1, TCGv r2, TCGv r3,
1694 TCGv r4)
1695 {
1696 TCGv temp = tcg_temp_new();
1697 TCGv temp2 = tcg_temp_new();
1698 TCGv result = tcg_temp_new();
1699 TCGv mask = tcg_temp_new();
1700 TCGv t0 = tcg_const_i32(0);
1701
1702 /* create mask for sticky bits */
1703 tcg_gen_setcond_tl(cond, mask, r4, t0);
1704 tcg_gen_shli_tl(mask, mask, 31);
1705
1706 tcg_gen_sub_tl(result, r1, r2);
1707 /* Calc PSW_V */
1708 tcg_gen_xor_tl(temp, result, r1);
1709 tcg_gen_xor_tl(temp2, r1, r2);
1710 tcg_gen_and_tl(temp, temp, temp2);
1711 tcg_gen_movcond_tl(cond, cpu_PSW_V, r4, t0, temp, cpu_PSW_V);
1712 /* Set PSW_SV */
1713 tcg_gen_and_tl(temp, temp, mask);
1714 tcg_gen_or_tl(cpu_PSW_SV, temp, cpu_PSW_SV);
1715 /* calc AV bit */
1716 tcg_gen_add_tl(temp, result, result);
1717 tcg_gen_xor_tl(temp, temp, result);
1718 tcg_gen_movcond_tl(cond, cpu_PSW_AV, r4, t0, temp, cpu_PSW_AV);
1719 /* calc SAV bit */
1720 tcg_gen_and_tl(temp, temp, mask);
1721 tcg_gen_or_tl(cpu_PSW_SAV, temp, cpu_PSW_SAV);
1722 /* write back result */
1723 tcg_gen_movcond_tl(cond, r3, r4, t0, result, r1);
1724
1725 tcg_temp_free(t0);
1726 tcg_temp_free(temp);
1727 tcg_temp_free(temp2);
1728 tcg_temp_free(result);
1729 tcg_temp_free(mask);
1730 }
1731
1732 static inline void
1733 gen_msub_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
1734 TCGv r3, uint32_t n, uint32_t mode)
1735 {
1736 TCGv temp = tcg_const_i32(n);
1737 TCGv temp2 = tcg_temp_new();
1738 TCGv_i64 temp64 = tcg_temp_new_i64();
1739 switch (mode) {
1740 case MODE_LL:
1741 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1742 break;
1743 case MODE_LU:
1744 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1745 break;
1746 case MODE_UL:
1747 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1748 break;
1749 case MODE_UU:
1750 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1751 break;
1752 }
1753 tcg_gen_extr_i64_i32(temp, temp2, temp64);
1754 gen_addsub64_h(ret_low, ret_high, r1_low, r1_high, temp, temp2,
1755 tcg_gen_sub_tl, tcg_gen_sub_tl);
1756 tcg_temp_free(temp);
1757 tcg_temp_free(temp2);
1758 tcg_temp_free_i64(temp64);
1759 }
1760
1761 static inline void
1762 gen_msubs_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
1763 TCGv r3, uint32_t n, uint32_t mode)
1764 {
1765 TCGv temp = tcg_const_i32(n);
1766 TCGv temp2 = tcg_temp_new();
1767 TCGv temp3 = tcg_temp_new();
1768 TCGv_i64 temp64 = tcg_temp_new_i64();
1769
1770 switch (mode) {
1771 case MODE_LL:
1772 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1773 break;
1774 case MODE_LU:
1775 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1776 break;
1777 case MODE_UL:
1778 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1779 break;
1780 case MODE_UU:
1781 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1782 break;
1783 }
1784 tcg_gen_extr_i64_i32(temp, temp2, temp64);
1785 gen_subs(ret_low, r1_low, temp);
1786 tcg_gen_mov_tl(temp, cpu_PSW_V);
1787 tcg_gen_mov_tl(temp3, cpu_PSW_AV);
1788 gen_subs(ret_high, r1_high, temp2);
1789 /* combine v bits */
1790 tcg_gen_or_tl(cpu_PSW_V, cpu_PSW_V, temp);
1791 /* combine av bits */
1792 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp3);
1793
1794 tcg_temp_free(temp);
1795 tcg_temp_free(temp2);
1796 tcg_temp_free(temp3);
1797 tcg_temp_free_i64(temp64);
1798 }
1799
1800 static inline void
1801 gen_msubm_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
1802 TCGv r3, uint32_t n, uint32_t mode)
1803 {
1804 TCGv temp = tcg_const_i32(n);
1805 TCGv_i64 temp64 = tcg_temp_new_i64();
1806 TCGv_i64 temp64_2 = tcg_temp_new_i64();
1807 TCGv_i64 temp64_3 = tcg_temp_new_i64();
1808 switch (mode) {
1809 case MODE_LL:
1810 GEN_HELPER_LL(mulm_h, temp64, r2, r3, temp);
1811 break;
1812 case MODE_LU:
1813 GEN_HELPER_LU(mulm_h, temp64, r2, r3, temp);
1814 break;
1815 case MODE_UL:
1816 GEN_HELPER_UL(mulm_h, temp64, r2, r3, temp);
1817 break;
1818 case MODE_UU:
1819 GEN_HELPER_UU(mulm_h, temp64, r2, r3, temp);
1820 break;
1821 }
1822 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
1823 gen_sub64_d(temp64_3, temp64_2, temp64);
1824 /* write back result */
1825 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64_3);
1826
1827 tcg_temp_free(temp);
1828 tcg_temp_free_i64(temp64);
1829 tcg_temp_free_i64(temp64_2);
1830 tcg_temp_free_i64(temp64_3);
1831 }
1832
1833 static inline void
1834 gen_msubms_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
1835 TCGv r3, uint32_t n, uint32_t mode)
1836 {
1837 TCGv temp = tcg_const_i32(n);
1838 TCGv_i64 temp64 = tcg_temp_new_i64();
1839 TCGv_i64 temp64_2 = tcg_temp_new_i64();
1840 switch (mode) {
1841 case MODE_LL:
1842 GEN_HELPER_LL(mulm_h, temp64, r2, r3, temp);
1843 break;
1844 case MODE_LU:
1845 GEN_HELPER_LU(mulm_h, temp64, r2, r3, temp);
1846 break;
1847 case MODE_UL:
1848 GEN_HELPER_UL(mulm_h, temp64, r2, r3, temp);
1849 break;
1850 case MODE_UU:
1851 GEN_HELPER_UU(mulm_h, temp64, r2, r3, temp);
1852 break;
1853 }
1854 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
1855 gen_helper_sub64_ssov(temp64, cpu_env, temp64_2, temp64);
1856 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
1857
1858 tcg_temp_free(temp);
1859 tcg_temp_free_i64(temp64);
1860 tcg_temp_free_i64(temp64_2);
1861 }
1862
1863 static inline void
1864 gen_msubr64_h(TCGv ret, TCGv r1_low, TCGv r1_high, TCGv r2, TCGv r3, uint32_t n,
1865 uint32_t mode)
1866 {
1867 TCGv temp = tcg_const_i32(n);
1868 TCGv_i64 temp64 = tcg_temp_new_i64();
1869 switch (mode) {
1870 case MODE_LL:
1871 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1872 break;
1873 case MODE_LU:
1874 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1875 break;
1876 case MODE_UL:
1877 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1878 break;
1879 case MODE_UU:
1880 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1881 break;
1882 }
1883 gen_helper_subr_h(ret, cpu_env, temp64, r1_low, r1_high);
1884
1885 tcg_temp_free(temp);
1886 tcg_temp_free_i64(temp64);
1887 }
1888
1889 static inline void
1890 gen_msubr32_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
1891 {
1892 TCGv temp = tcg_temp_new();
1893 TCGv temp2 = tcg_temp_new();
1894
1895 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
1896 tcg_gen_shli_tl(temp, r1, 16);
1897 gen_msubr64_h(ret, temp, temp2, r2, r3, n, mode);
1898
1899 tcg_temp_free(temp);
1900 tcg_temp_free(temp2);
1901 }
1902
1903 static inline void
1904 gen_msubr64s_h(TCGv ret, TCGv r1_low, TCGv r1_high, TCGv r2, TCGv r3,
1905 uint32_t n, uint32_t mode)
1906 {
1907 TCGv temp = tcg_const_i32(n);
1908 TCGv_i64 temp64 = tcg_temp_new_i64();
1909 switch (mode) {
1910 case MODE_LL:
1911 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
1912 break;
1913 case MODE_LU:
1914 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
1915 break;
1916 case MODE_UL:
1917 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
1918 break;
1919 case MODE_UU:
1920 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
1921 break;
1922 }
1923 gen_helper_subr_h_ssov(ret, cpu_env, temp64, r1_low, r1_high);
1924
1925 tcg_temp_free(temp);
1926 tcg_temp_free_i64(temp64);
1927 }
1928
1929 static inline void
1930 gen_msubr32s_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
1931 {
1932 TCGv temp = tcg_temp_new();
1933 TCGv temp2 = tcg_temp_new();
1934
1935 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
1936 tcg_gen_shli_tl(temp, r1, 16);
1937 gen_msubr64s_h(ret, temp, temp2, r2, r3, n, mode);
1938
1939 tcg_temp_free(temp);
1940 tcg_temp_free(temp2);
1941 }
1942
1943 static inline void
1944 gen_msubr_q(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n)
1945 {
1946 TCGv temp = tcg_const_i32(n);
1947 gen_helper_msubr_q(ret, cpu_env, r1, r2, r3, temp);
1948 tcg_temp_free(temp);
1949 }
1950
1951 static inline void
1952 gen_msubrs_q(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n)
1953 {
1954 TCGv temp = tcg_const_i32(n);
1955 gen_helper_msubr_q_ssov(ret, cpu_env, r1, r2, r3, temp);
1956 tcg_temp_free(temp);
1957 }
1958
1959 static inline void
1960 gen_msub32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n,
1961 uint32_t up_shift)
1962 {
1963 TCGv temp = tcg_temp_new();
1964 TCGv temp2 = tcg_temp_new();
1965 TCGv temp3 = tcg_temp_new();
1966 TCGv_i64 t1 = tcg_temp_new_i64();
1967 TCGv_i64 t2 = tcg_temp_new_i64();
1968 TCGv_i64 t3 = tcg_temp_new_i64();
1969 TCGv_i64 t4 = tcg_temp_new_i64();
1970
1971 tcg_gen_ext_i32_i64(t2, arg2);
1972 tcg_gen_ext_i32_i64(t3, arg3);
1973
1974 tcg_gen_mul_i64(t2, t2, t3);
1975
1976 tcg_gen_ext_i32_i64(t1, arg1);
1977 /* if we shift part of the fraction out, we need to round up */
1978 tcg_gen_andi_i64(t4, t2, (1ll << (up_shift - n)) - 1);
1979 tcg_gen_setcondi_i64(TCG_COND_NE, t4, t4, 0);
1980 tcg_gen_sari_i64(t2, t2, up_shift - n);
1981 tcg_gen_add_i64(t2, t2, t4);
1982
1983 tcg_gen_sub_i64(t3, t1, t2);
1984 tcg_gen_extrl_i64_i32(temp3, t3);
1985 /* calc v bit */
1986 tcg_gen_setcondi_i64(TCG_COND_GT, t1, t3, 0x7fffffffLL);
1987 tcg_gen_setcondi_i64(TCG_COND_LT, t2, t3, -0x80000000LL);
1988 tcg_gen_or_i64(t1, t1, t2);
1989 tcg_gen_extrl_i64_i32(cpu_PSW_V, t1);
1990 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1991 /* Calc SV bit */
1992 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1993 /* Calc AV/SAV bits */
1994 tcg_gen_add_tl(cpu_PSW_AV, temp3, temp3);
1995 tcg_gen_xor_tl(cpu_PSW_AV, temp3, cpu_PSW_AV);
1996 /* calc SAV */
1997 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1998 /* write back result */
1999 tcg_gen_mov_tl(ret, temp3);
2000
2001 tcg_temp_free(temp);
2002 tcg_temp_free(temp2);
2003 tcg_temp_free(temp3);
2004 tcg_temp_free_i64(t1);
2005 tcg_temp_free_i64(t2);
2006 tcg_temp_free_i64(t3);
2007 tcg_temp_free_i64(t4);
2008 }
2009
2010 static inline void
2011 gen_m16sub32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n)
2012 {
2013 TCGv temp = tcg_temp_new();
2014 TCGv temp2 = tcg_temp_new();
2015 if (n == 0) {
2016 tcg_gen_mul_tl(temp, arg2, arg3);
2017 } else { /* n is expected to be 1 */
2018 tcg_gen_mul_tl(temp, arg2, arg3);
2019 tcg_gen_shli_tl(temp, temp, 1);
2020 /* catch special case r1 = r2 = 0x8000 */
2021 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
2022 tcg_gen_sub_tl(temp, temp, temp2);
2023 }
2024 gen_sub_d(ret, arg1, temp);
2025
2026 tcg_temp_free(temp);
2027 tcg_temp_free(temp2);
2028 }
2029
2030 static inline void
2031 gen_m16subs32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n)
2032 {
2033 TCGv temp = tcg_temp_new();
2034 TCGv temp2 = tcg_temp_new();
2035 if (n == 0) {
2036 tcg_gen_mul_tl(temp, arg2, arg3);
2037 } else { /* n is expected to be 1 */
2038 tcg_gen_mul_tl(temp, arg2, arg3);
2039 tcg_gen_shli_tl(temp, temp, 1);
2040 /* catch special case r1 = r2 = 0x8000 */
2041 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
2042 tcg_gen_sub_tl(temp, temp, temp2);
2043 }
2044 gen_subs(ret, arg1, temp);
2045
2046 tcg_temp_free(temp);
2047 tcg_temp_free(temp2);
2048 }
2049
2050 static inline void
2051 gen_m16sub64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
2052 TCGv arg3, uint32_t n)
2053 {
2054 TCGv temp = tcg_temp_new();
2055 TCGv temp2 = tcg_temp_new();
2056 TCGv_i64 t1 = tcg_temp_new_i64();
2057 TCGv_i64 t2 = tcg_temp_new_i64();
2058 TCGv_i64 t3 = tcg_temp_new_i64();
2059
2060 if (n == 0) {
2061 tcg_gen_mul_tl(temp, arg2, arg3);
2062 } else { /* n is expected to be 1 */
2063 tcg_gen_mul_tl(temp, arg2, arg3);
2064 tcg_gen_shli_tl(temp, temp, 1);
2065 /* catch special case r1 = r2 = 0x8000 */
2066 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
2067 tcg_gen_sub_tl(temp, temp, temp2);
2068 }
2069 tcg_gen_ext_i32_i64(t2, temp);
2070 tcg_gen_shli_i64(t2, t2, 16);
2071 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
2072 gen_sub64_d(t3, t1, t2);
2073 /* write back result */
2074 tcg_gen_extr_i64_i32(rl, rh, t3);
2075
2076 tcg_temp_free_i64(t1);
2077 tcg_temp_free_i64(t2);
2078 tcg_temp_free_i64(t3);
2079 tcg_temp_free(temp);
2080 tcg_temp_free(temp2);
2081 }
2082
2083 static inline void
2084 gen_m16subs64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
2085 TCGv arg3, uint32_t n)
2086 {
2087 TCGv temp = tcg_temp_new();
2088 TCGv temp2 = tcg_temp_new();
2089 TCGv_i64 t1 = tcg_temp_new_i64();
2090 TCGv_i64 t2 = tcg_temp_new_i64();
2091
2092 if (n == 0) {
2093 tcg_gen_mul_tl(temp, arg2, arg3);
2094 } else { /* n is expected to be 1 */
2095 tcg_gen_mul_tl(temp, arg2, arg3);
2096 tcg_gen_shli_tl(temp, temp, 1);
2097 /* catch special case r1 = r2 = 0x8000 */
2098 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, temp, 0x80000000);
2099 tcg_gen_sub_tl(temp, temp, temp2);
2100 }
2101 tcg_gen_ext_i32_i64(t2, temp);
2102 tcg_gen_shli_i64(t2, t2, 16);
2103 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
2104
2105 gen_helper_sub64_ssov(t1, cpu_env, t1, t2);
2106 tcg_gen_extr_i64_i32(rl, rh, t1);
2107
2108 tcg_temp_free(temp);
2109 tcg_temp_free(temp2);
2110 tcg_temp_free_i64(t1);
2111 tcg_temp_free_i64(t2);
2112 }
2113
2114 static inline void
2115 gen_msub64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
2116 TCGv arg3, uint32_t n)
2117 {
2118 TCGv_i64 t1 = tcg_temp_new_i64();
2119 TCGv_i64 t2 = tcg_temp_new_i64();
2120 TCGv_i64 t3 = tcg_temp_new_i64();
2121 TCGv_i64 t4 = tcg_temp_new_i64();
2122 TCGv temp, temp2;
2123
2124 tcg_gen_concat_i32_i64(t1, arg1_low, arg1_high);
2125 tcg_gen_ext_i32_i64(t2, arg2);
2126 tcg_gen_ext_i32_i64(t3, arg3);
2127
2128 tcg_gen_mul_i64(t2, t2, t3);
2129 if (n != 0) {
2130 tcg_gen_shli_i64(t2, t2, 1);
2131 }
2132 tcg_gen_sub_i64(t4, t1, t2);
2133 /* calc v bit */
2134 tcg_gen_xor_i64(t3, t4, t1);
2135 tcg_gen_xor_i64(t2, t1, t2);
2136 tcg_gen_and_i64(t3, t3, t2);
2137 tcg_gen_extrh_i64_i32(cpu_PSW_V, t3);
2138 /* We produce an overflow on the host if the mul before was
2139 (0x80000000 * 0x80000000) << 1). If this is the
2140 case, we negate the ovf. */
2141 if (n == 1) {
2142 temp = tcg_temp_new();
2143 temp2 = tcg_temp_new();
2144 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, arg2, 0x80000000);
2145 tcg_gen_setcond_tl(TCG_COND_EQ, temp2, arg2, arg3);
2146 tcg_gen_and_tl(temp, temp, temp2);
2147 tcg_gen_shli_tl(temp, temp, 31);
2148 /* negate v bit, if special condition */
2149 tcg_gen_xor_tl(cpu_PSW_V, cpu_PSW_V, temp);
2150
2151 tcg_temp_free(temp);
2152 tcg_temp_free(temp2);
2153 }
2154 /* write back result */
2155 tcg_gen_extr_i64_i32(rl, rh, t4);
2156 /* Calc SV bit */
2157 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2158 /* Calc AV/SAV bits */
2159 tcg_gen_add_tl(cpu_PSW_AV, rh, rh);
2160 tcg_gen_xor_tl(cpu_PSW_AV, rh, cpu_PSW_AV);
2161 /* calc SAV */
2162 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2163
2164 tcg_temp_free_i64(t1);
2165 tcg_temp_free_i64(t2);
2166 tcg_temp_free_i64(t3);
2167 tcg_temp_free_i64(t4);
2168 }
2169
2170 static inline void
2171 gen_msubs32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n,
2172 uint32_t up_shift)
2173 {
2174 TCGv_i64 t1 = tcg_temp_new_i64();
2175 TCGv_i64 t2 = tcg_temp_new_i64();
2176 TCGv_i64 t3 = tcg_temp_new_i64();
2177 TCGv_i64 t4 = tcg_temp_new_i64();
2178
2179 tcg_gen_ext_i32_i64(t1, arg1);
2180 tcg_gen_ext_i32_i64(t2, arg2);
2181 tcg_gen_ext_i32_i64(t3, arg3);
2182
2183 tcg_gen_mul_i64(t2, t2, t3);
2184 /* if we shift part of the fraction out, we need to round up */
2185 tcg_gen_andi_i64(t4, t2, (1ll << (up_shift - n)) - 1);
2186 tcg_gen_setcondi_i64(TCG_COND_NE, t4, t4, 0);
2187 tcg_gen_sari_i64(t3, t2, up_shift - n);
2188 tcg_gen_add_i64(t3, t3, t4);
2189
2190 gen_helper_msub32_q_sub_ssov(ret, cpu_env, t1, t3);
2191
2192 tcg_temp_free_i64(t1);
2193 tcg_temp_free_i64(t2);
2194 tcg_temp_free_i64(t3);
2195 tcg_temp_free_i64(t4);
2196 }
2197
2198 static inline void
2199 gen_msubs64_q(TCGv rl, TCGv rh, TCGv arg1_low, TCGv arg1_high, TCGv arg2,
2200 TCGv arg3, uint32_t n)
2201 {
2202 TCGv_i64 r1 = tcg_temp_new_i64();
2203 TCGv temp = tcg_const_i32(n);
2204
2205 tcg_gen_concat_i32_i64(r1, arg1_low, arg1_high);
2206 gen_helper_msub64_q_ssov(r1, cpu_env, r1, arg2, arg3, temp);
2207 tcg_gen_extr_i64_i32(rl, rh, r1);
2208
2209 tcg_temp_free_i64(r1);
2210 tcg_temp_free(temp);
2211 }
2212
2213 static inline void
2214 gen_msubad_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
2215 TCGv r3, uint32_t n, uint32_t mode)
2216 {
2217 TCGv temp = tcg_const_i32(n);
2218 TCGv temp2 = tcg_temp_new();
2219 TCGv_i64 temp64 = tcg_temp_new_i64();
2220 switch (mode) {
2221 case MODE_LL:
2222 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2223 break;
2224 case MODE_LU:
2225 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2226 break;
2227 case MODE_UL:
2228 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2229 break;
2230 case MODE_UU:
2231 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2232 break;
2233 }
2234 tcg_gen_extr_i64_i32(temp, temp2, temp64);
2235 gen_addsub64_h(ret_low, ret_high, r1_low, r1_high, temp, temp2,
2236 tcg_gen_add_tl, tcg_gen_sub_tl);
2237 tcg_temp_free(temp);
2238 tcg_temp_free(temp2);
2239 tcg_temp_free_i64(temp64);
2240 }
2241
2242 static inline void
2243 gen_msubadm_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
2244 TCGv r3, uint32_t n, uint32_t mode)
2245 {
2246 TCGv temp = tcg_const_i32(n);
2247 TCGv_i64 temp64 = tcg_temp_new_i64();
2248 TCGv_i64 temp64_2 = tcg_temp_new_i64();
2249 TCGv_i64 temp64_3 = tcg_temp_new_i64();
2250 switch (mode) {
2251 case MODE_LL:
2252 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2253 break;
2254 case MODE_LU:
2255 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2256 break;
2257 case MODE_UL:
2258 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2259 break;
2260 case MODE_UU:
2261 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2262 break;
2263 }
2264 tcg_gen_concat_i32_i64(temp64_3, r1_low, r1_high);
2265 tcg_gen_sari_i64(temp64_2, temp64, 32); /* high */
2266 tcg_gen_ext32s_i64(temp64, temp64); /* low */
2267 tcg_gen_sub_i64(temp64, temp64_2, temp64);
2268 tcg_gen_shli_i64(temp64, temp64, 16);
2269
2270 gen_sub64_d(temp64_2, temp64_3, temp64);
2271 /* write back result */
2272 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64_2);
2273
2274 tcg_temp_free(temp);
2275 tcg_temp_free_i64(temp64);
2276 tcg_temp_free_i64(temp64_2);
2277 tcg_temp_free_i64(temp64_3);
2278 }
2279
2280 static inline void
2281 gen_msubadr32_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
2282 {
2283 TCGv temp = tcg_const_i32(n);
2284 TCGv temp2 = tcg_temp_new();
2285 TCGv_i64 temp64 = tcg_temp_new_i64();
2286 switch (mode) {
2287 case MODE_LL:
2288 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2289 break;
2290 case MODE_LU:
2291 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2292 break;
2293 case MODE_UL:
2294 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2295 break;
2296 case MODE_UU:
2297 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2298 break;
2299 }
2300 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
2301 tcg_gen_shli_tl(temp, r1, 16);
2302 gen_helper_subadr_h(ret, cpu_env, temp64, temp, temp2);
2303
2304 tcg_temp_free(temp);
2305 tcg_temp_free(temp2);
2306 tcg_temp_free_i64(temp64);
2307 }
2308
2309 static inline void
2310 gen_msubads_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
2311 TCGv r3, uint32_t n, uint32_t mode)
2312 {
2313 TCGv temp = tcg_const_i32(n);
2314 TCGv temp2 = tcg_temp_new();
2315 TCGv temp3 = tcg_temp_new();
2316 TCGv_i64 temp64 = tcg_temp_new_i64();
2317
2318 switch (mode) {
2319 case MODE_LL:
2320 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2321 break;
2322 case MODE_LU:
2323 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2324 break;
2325 case MODE_UL:
2326 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2327 break;
2328 case MODE_UU:
2329 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2330 break;
2331 }
2332 tcg_gen_extr_i64_i32(temp, temp2, temp64);
2333 gen_adds(ret_low, r1_low, temp);
2334 tcg_gen_mov_tl(temp, cpu_PSW_V);
2335 tcg_gen_mov_tl(temp3, cpu_PSW_AV);
2336 gen_subs(ret_high, r1_high, temp2);
2337 /* combine v bits */
2338 tcg_gen_or_tl(cpu_PSW_V, cpu_PSW_V, temp);
2339 /* combine av bits */
2340 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp3);
2341
2342 tcg_temp_free(temp);
2343 tcg_temp_free(temp2);
2344 tcg_temp_free(temp3);
2345 tcg_temp_free_i64(temp64);
2346 }
2347
2348 static inline void
2349 gen_msubadms_h(TCGv ret_low, TCGv ret_high, TCGv r1_low, TCGv r1_high, TCGv r2,
2350 TCGv r3, uint32_t n, uint32_t mode)
2351 {
2352 TCGv temp = tcg_const_i32(n);
2353 TCGv_i64 temp64 = tcg_temp_new_i64();
2354 TCGv_i64 temp64_2 = tcg_temp_new_i64();
2355
2356 switch (mode) {
2357 case MODE_LL:
2358 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2359 break;
2360 case MODE_LU:
2361 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2362 break;
2363 case MODE_UL:
2364 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2365 break;
2366 case MODE_UU:
2367 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2368 break;
2369 }
2370 tcg_gen_sari_i64(temp64_2, temp64, 32); /* high */
2371 tcg_gen_ext32s_i64(temp64, temp64); /* low */
2372 tcg_gen_sub_i64(temp64, temp64_2, temp64);
2373 tcg_gen_shli_i64(temp64, temp64, 16);
2374 tcg_gen_concat_i32_i64(temp64_2, r1_low, r1_high);
2375
2376 gen_helper_sub64_ssov(temp64, cpu_env, temp64_2, temp64);
2377 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
2378
2379 tcg_temp_free(temp);
2380 tcg_temp_free_i64(temp64);
2381 tcg_temp_free_i64(temp64_2);
2382 }
2383
2384 static inline void
2385 gen_msubadr32s_h(TCGv ret, TCGv r1, TCGv r2, TCGv r3, uint32_t n, uint32_t mode)
2386 {
2387 TCGv temp = tcg_const_i32(n);
2388 TCGv temp2 = tcg_temp_new();
2389 TCGv_i64 temp64 = tcg_temp_new_i64();
2390 switch (mode) {
2391 case MODE_LL:
2392 GEN_HELPER_LL(mul_h, temp64, r2, r3, temp);
2393 break;
2394 case MODE_LU:
2395 GEN_HELPER_LU(mul_h, temp64, r2, r3, temp);
2396 break;
2397 case MODE_UL:
2398 GEN_HELPER_UL(mul_h, temp64, r2, r3, temp);
2399 break;
2400 case MODE_UU:
2401 GEN_HELPER_UU(mul_h, temp64, r2, r3, temp);
2402 break;
2403 }
2404 tcg_gen_andi_tl(temp2, r1, 0xffff0000);
2405 tcg_gen_shli_tl(temp, r1, 16);
2406 gen_helper_subadr_h_ssov(ret, cpu_env, temp64, temp, temp2);
2407
2408 tcg_temp_free(temp);
2409 tcg_temp_free(temp2);
2410 tcg_temp_free_i64(temp64);
2411 }
2412
2413 static inline void gen_abs(TCGv ret, TCGv r1)
2414 {
2415 tcg_gen_abs_tl(ret, r1);
2416 /* overflow can only happen, if r1 = 0x80000000 */
2417 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, r1, 0x80000000);
2418 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
2419 /* calc SV bit */
2420 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2421 /* Calc AV bit */
2422 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
2423 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
2424 /* calc SAV bit */
2425 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2426 }
2427
2428 static inline void gen_absdif(TCGv ret, TCGv r1, TCGv r2)
2429 {
2430 TCGv temp = tcg_temp_new_i32();
2431 TCGv result = tcg_temp_new_i32();
2432
2433 tcg_gen_sub_tl(result, r1, r2);
2434 tcg_gen_sub_tl(temp, r2, r1);
2435 tcg_gen_movcond_tl(TCG_COND_GT, result, r1, r2, result, temp);
2436
2437 /* calc V bit */
2438 tcg_gen_xor_tl(cpu_PSW_V, result, r1);
2439 tcg_gen_xor_tl(temp, result, r2);
2440 tcg_gen_movcond_tl(TCG_COND_GT, cpu_PSW_V, r1, r2, cpu_PSW_V, temp);
2441 tcg_gen_xor_tl(temp, r1, r2);
2442 tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
2443 /* calc SV bit */
2444 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2445 /* Calc AV bit */
2446 tcg_gen_add_tl(cpu_PSW_AV, result, result);
2447 tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
2448 /* calc SAV bit */
2449 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2450 /* write back result */
2451 tcg_gen_mov_tl(ret, result);
2452
2453 tcg_temp_free(temp);
2454 tcg_temp_free(result);
2455 }
2456
2457 static inline void gen_absdifi(TCGv ret, TCGv r1, int32_t con)
2458 {
2459 TCGv temp = tcg_const_i32(con);
2460 gen_absdif(ret, r1, temp);
2461 tcg_temp_free(temp);
2462 }
2463
2464 static inline void gen_absdifsi(TCGv ret, TCGv r1, int32_t con)
2465 {
2466 TCGv temp = tcg_const_i32(con);
2467 gen_helper_absdif_ssov(ret, cpu_env, r1, temp);
2468 tcg_temp_free(temp);
2469 }
2470
2471 static inline void gen_mul_i32s(TCGv ret, TCGv r1, TCGv r2)
2472 {
2473 TCGv high = tcg_temp_new();
2474 TCGv low = tcg_temp_new();
2475
2476 tcg_gen_muls2_tl(low, high, r1, r2);
2477 tcg_gen_mov_tl(ret, low);
2478 /* calc V bit */
2479 tcg_gen_sari_tl(low, low, 31);
2480 tcg_gen_setcond_tl(TCG_COND_NE, cpu_PSW_V, high, low);
2481 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
2482 /* calc SV bit */
2483 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2484 /* Calc AV bit */
2485 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
2486 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
2487 /* calc SAV bit */
2488 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2489
2490 tcg_temp_free(high);
2491 tcg_temp_free(low);
2492 }
2493
2494 static inline void gen_muli_i32s(TCGv ret, TCGv r1, int32_t con)
2495 {
2496 TCGv temp = tcg_const_i32(con);
2497 gen_mul_i32s(ret, r1, temp);
2498 tcg_temp_free(temp);
2499 }
2500
2501 static inline void gen_mul_i64s(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2)
2502 {
2503 tcg_gen_muls2_tl(ret_low, ret_high, r1, r2);
2504 /* clear V bit */
2505 tcg_gen_movi_tl(cpu_PSW_V, 0);
2506 /* calc SV bit */
2507 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2508 /* Calc AV bit */
2509 tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
2510 tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
2511 /* calc SAV bit */
2512 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2513 }
2514
2515 static inline void gen_muli_i64s(TCGv ret_low, TCGv ret_high, TCGv r1,
2516 int32_t con)
2517 {
2518 TCGv temp = tcg_const_i32(con);
2519 gen_mul_i64s(ret_low, ret_high, r1, temp);
2520 tcg_temp_free(temp);
2521 }
2522
2523 static inline void gen_mul_i64u(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2)
2524 {
2525 tcg_gen_mulu2_tl(ret_low, ret_high, r1, r2);
2526 /* clear V bit */
2527 tcg_gen_movi_tl(cpu_PSW_V, 0);
2528 /* calc SV bit */
2529 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2530 /* Calc AV bit */
2531 tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
2532 tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
2533 /* calc SAV bit */
2534 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2535 }
2536
2537 static inline void gen_muli_i64u(TCGv ret_low, TCGv ret_high, TCGv r1,
2538 int32_t con)
2539 {
2540 TCGv temp = tcg_const_i32(con);
2541 gen_mul_i64u(ret_low, ret_high, r1, temp);
2542 tcg_temp_free(temp);
2543 }
2544
2545 static inline void gen_mulsi_i32(TCGv ret, TCGv r1, int32_t con)
2546 {
2547 TCGv temp = tcg_const_i32(con);
2548 gen_helper_mul_ssov(ret, cpu_env, r1, temp);
2549 tcg_temp_free(temp);
2550 }
2551
2552 static inline void gen_mulsui_i32(TCGv ret, TCGv r1, int32_t con)
2553 {
2554 TCGv temp = tcg_const_i32(con);
2555 gen_helper_mul_suov(ret, cpu_env, r1, temp);
2556 tcg_temp_free(temp);
2557 }
2558 /* gen_maddsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9); */
2559 static inline void gen_maddsi_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
2560 {
2561 TCGv temp = tcg_const_i32(con);
2562 gen_helper_madd32_ssov(ret, cpu_env, r1, r2, temp);
2563 tcg_temp_free(temp);
2564 }
2565
2566 static inline void gen_maddsui_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
2567 {
2568 TCGv temp = tcg_const_i32(con);
2569 gen_helper_madd32_suov(ret, cpu_env, r1, r2, temp);
2570 tcg_temp_free(temp);
2571 }
2572
2573 static void
2574 gen_mul_q(TCGv rl, TCGv rh, TCGv arg1, TCGv arg2, uint32_t n, uint32_t up_shift)
2575 {
2576 TCGv temp = tcg_temp_new();
2577 TCGv_i64 temp_64 = tcg_temp_new_i64();
2578 TCGv_i64 temp2_64 = tcg_temp_new_i64();
2579
2580 if (n == 0) {
2581 if (up_shift == 32) {
2582 tcg_gen_muls2_tl(rh, rl, arg1, arg2);
2583 } else if (up_shift == 16) {
2584 tcg_gen_ext_i32_i64(temp_64, arg1);
2585 tcg_gen_ext_i32_i64(temp2_64, arg2);
2586
2587 tcg_gen_mul_i64(temp_64, temp_64, temp2_64);
2588 tcg_gen_shri_i64(temp_64, temp_64, up_shift);
2589 tcg_gen_extr_i64_i32(rl, rh, temp_64);
2590 } else {
2591 tcg_gen_muls2_tl(rl, rh, arg1, arg2);
2592 }
2593 /* reset v bit */
2594 tcg_gen_movi_tl(cpu_PSW_V, 0);
2595 } else { /* n is expected to be 1 */
2596 tcg_gen_ext_i32_i64(temp_64, arg1);
2597 tcg_gen_ext_i32_i64(temp2_64, arg2);
2598
2599 tcg_gen_mul_i64(temp_64, temp_64, temp2_64);
2600
2601 if (up_shift == 0) {
2602 tcg_gen_shli_i64(temp_64, temp_64, 1);
2603 } else {
2604 tcg_gen_shri_i64(temp_64, temp_64, up_shift - 1);
2605 }
2606 tcg_gen_extr_i64_i32(rl, rh, temp_64);
2607 /* overflow only occurs if r1 = r2 = 0x8000 */
2608 if (up_shift == 0) {/* result is 64 bit */
2609 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, rh,
2610 0x80000000);
2611 } else { /* result is 32 bit */
2612 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, rl,
2613 0x80000000);
2614 }
2615 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
2616 /* calc sv overflow bit */
2617 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2618 }
2619 /* calc av overflow bit */
2620 if (up_shift == 0) {
2621 tcg_gen_add_tl(cpu_PSW_AV, rh, rh);
2622 tcg_gen_xor_tl(cpu_PSW_AV, rh, cpu_PSW_AV);
2623 } else {
2624 tcg_gen_add_tl(cpu_PSW_AV, rl, rl);
2625 tcg_gen_xor_tl(cpu_PSW_AV, rl, cpu_PSW_AV);
2626 }
2627 /* calc sav overflow bit */
2628 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2629 tcg_temp_free(temp);
2630 tcg_temp_free_i64(temp_64);
2631 tcg_temp_free_i64(temp2_64);
2632 }
2633
2634 static void
2635 gen_mul_q_16(TCGv ret, TCGv arg1, TCGv arg2, uint32_t n)
2636 {
2637 TCGv temp = tcg_temp_new();
2638 if (n == 0) {
2639 tcg_gen_mul_tl(ret, arg1, arg2);
2640 } else { /* n is expected to be 1 */
2641 tcg_gen_mul_tl(ret, arg1, arg2);
2642 tcg_gen_shli_tl(ret, ret, 1);
2643 /* catch special case r1 = r2 = 0x8000 */
2644 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, ret, 0x80000000);
2645 tcg_gen_sub_tl(ret, ret, temp);
2646 }
2647 /* reset v bit */
2648 tcg_gen_movi_tl(cpu_PSW_V, 0);
2649 /* calc av overflow bit */
2650 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
2651 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
2652 /* calc sav overflow bit */
2653 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2654
2655 tcg_temp_free(temp);
2656 }
2657
2658 static void gen_mulr_q(TCGv ret, TCGv arg1, TCGv arg2, uint32_t n)
2659 {
2660 TCGv temp = tcg_temp_new();
2661 if (n == 0) {
2662 tcg_gen_mul_tl(ret, arg1, arg2);
2663 tcg_gen_addi_tl(ret, ret, 0x8000);
2664 } else {
2665 tcg_gen_mul_tl(ret, arg1, arg2);
2666 tcg_gen_shli_tl(ret, ret, 1);
2667 tcg_gen_addi_tl(ret, ret, 0x8000);
2668 /* catch special case r1 = r2 = 0x8000 */
2669 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, ret, 0x80008000);
2670 tcg_gen_muli_tl(temp, temp, 0x8001);
2671 tcg_gen_sub_tl(ret, ret, temp);
2672 }
2673 /* reset v bit */
2674 tcg_gen_movi_tl(cpu_PSW_V, 0);
2675 /* calc av overflow bit */
2676 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
2677 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
2678 /* calc sav overflow bit */
2679 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2680 /* cut halfword off */
2681 tcg_gen_andi_tl(ret, ret, 0xffff0000);
2682
2683 tcg_temp_free(temp);
2684 }
2685
2686 static inline void
2687 gen_madds_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2688 TCGv r3)
2689 {
2690 TCGv_i64 temp64 = tcg_temp_new_i64();
2691 tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
2692 gen_helper_madd64_ssov(temp64, cpu_env, r1, temp64, r3);
2693 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
2694 tcg_temp_free_i64(temp64);
2695 }
2696
2697 static inline void
2698 gen_maddsi_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2699 int32_t con)
2700 {
2701 TCGv temp = tcg_const_i32(con);
2702 gen_madds_64(ret_low, ret_high, r1, r2_low, r2_high, temp);
2703 tcg_temp_free(temp);
2704 }
2705
2706 static inline void
2707 gen_maddsu_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2708 TCGv r3)
2709 {
2710 TCGv_i64 temp64 = tcg_temp_new_i64();
2711 tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
2712 gen_helper_madd64_suov(temp64, cpu_env, r1, temp64, r3);
2713 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
2714 tcg_temp_free_i64(temp64);
2715 }
2716
2717 static inline void
2718 gen_maddsui_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2719 int32_t con)
2720 {
2721 TCGv temp = tcg_const_i32(con);
2722 gen_maddsu_64(ret_low, ret_high, r1, r2_low, r2_high, temp);
2723 tcg_temp_free(temp);
2724 }
2725
2726 static inline void gen_msubsi_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
2727 {
2728 TCGv temp = tcg_const_i32(con);
2729 gen_helper_msub32_ssov(ret, cpu_env, r1, r2, temp);
2730 tcg_temp_free(temp);
2731 }
2732
2733 static inline void gen_msubsui_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
2734 {
2735 TCGv temp = tcg_const_i32(con);
2736 gen_helper_msub32_suov(ret, cpu_env, r1, r2, temp);
2737 tcg_temp_free(temp);
2738 }
2739
2740 static inline void
2741 gen_msubs_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2742 TCGv r3)
2743 {
2744 TCGv_i64 temp64 = tcg_temp_new_i64();
2745 tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
2746 gen_helper_msub64_ssov(temp64, cpu_env, r1, temp64, r3);
2747 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
2748 tcg_temp_free_i64(temp64);
2749 }
2750
2751 static inline void
2752 gen_msubsi_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2753 int32_t con)
2754 {
2755 TCGv temp = tcg_const_i32(con);
2756 gen_msubs_64(ret_low, ret_high, r1, r2_low, r2_high, temp);
2757 tcg_temp_free(temp);
2758 }
2759
2760 static inline void
2761 gen_msubsu_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2762 TCGv r3)
2763 {
2764 TCGv_i64 temp64 = tcg_temp_new_i64();
2765 tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
2766 gen_helper_msub64_suov(temp64, cpu_env, r1, temp64, r3);
2767 tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
2768 tcg_temp_free_i64(temp64);
2769 }
2770
2771 static inline void
2772 gen_msubsui_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
2773 int32_t con)
2774 {
2775 TCGv temp = tcg_const_i32(con);
2776 gen_msubsu_64(ret_low, ret_high, r1, r2_low, r2_high, temp);
2777 tcg_temp_free(temp);
2778 }
2779
2780 static void gen_saturate(TCGv ret, TCGv arg, int32_t up, int32_t low)
2781 {
2782 TCGv sat_neg = tcg_const_i32(low);
2783 TCGv temp = tcg_const_i32(up);
2784
2785 /* sat_neg = (arg < low ) ? low : arg; */
2786 tcg_gen_movcond_tl(TCG_COND_LT, sat_neg, arg, sat_neg, sat_neg, arg);
2787
2788 /* ret = (sat_neg > up ) ? up : sat_neg; */
2789 tcg_gen_movcond_tl(TCG_COND_GT, ret, sat_neg, temp, temp, sat_neg);
2790
2791 tcg_temp_free(sat_neg);
2792 tcg_temp_free(temp);
2793 }
2794
2795 static void gen_saturate_u(TCGv ret, TCGv arg, int32_t up)
2796 {
2797 TCGv temp = tcg_const_i32(up);
2798 /* sat_neg = (arg > up ) ? up : arg; */
2799 tcg_gen_movcond_tl(TCG_COND_GTU, ret, arg, temp, temp, arg);
2800 tcg_temp_free(temp);
2801 }
2802
2803 static void gen_shi(TCGv ret, TCGv r1, int32_t shift_count)
2804 {
2805 if (shift_count == -32) {
2806 tcg_gen_movi_tl(ret, 0);
2807 } else if (shift_count >= 0) {
2808 tcg_gen_shli_tl(ret, r1, shift_count);
2809 } else {
2810 tcg_gen_shri_tl(ret, r1, -shift_count);
2811 }
2812 }
2813
2814 static void gen_sh_hi(TCGv ret, TCGv r1, int32_t shiftcount)
2815 {
2816 TCGv temp_low, temp_high;
2817
2818 if (shiftcount == -16) {
2819 tcg_gen_movi_tl(ret, 0);
2820 } else {
2821 temp_high = tcg_temp_new();
2822 temp_low = tcg_temp_new();
2823
2824 tcg_gen_andi_tl(temp_low, r1, 0xffff);
2825 tcg_gen_andi_tl(temp_high, r1, 0xffff0000);
2826 gen_shi(temp_low, temp_low, shiftcount);
2827 gen_shi(ret, temp_high, shiftcount);
2828 tcg_gen_deposit_tl(ret, ret, temp_low, 0, 16);
2829
2830 tcg_temp_free(temp_low);
2831 tcg_temp_free(temp_high);
2832 }
2833 }
2834
2835 static void gen_shaci(TCGv ret, TCGv r1, int32_t shift_count)
2836 {
2837 uint32_t msk, msk_start;
2838 TCGv temp = tcg_temp_new();
2839 TCGv temp2 = tcg_temp_new();
2840 TCGv t_0 = tcg_const_i32(0);
2841
2842 if (shift_count == 0) {
2843 /* Clear PSW.C and PSW.V */
2844 tcg_gen_movi_tl(cpu_PSW_C, 0);
2845 tcg_gen_mov_tl(cpu_PSW_V, cpu_PSW_C);
2846 tcg_gen_mov_tl(ret, r1);
2847 } else if (shift_count == -32) {
2848 /* set PSW.C */
2849 tcg_gen_mov_tl(cpu_PSW_C, r1);
2850 /* fill ret completely with sign bit */
2851 tcg_gen_sari_tl(ret, r1, 31);
2852 /* clear PSW.V */
2853 tcg_gen_movi_tl(cpu_PSW_V, 0);
2854 } else if (shift_count > 0) {
2855 TCGv t_max = tcg_const_i32(0x7FFFFFFF >> shift_count);
2856 TCGv t_min = tcg_const_i32(((int32_t) -0x80000000) >> shift_count);
2857
2858 /* calc carry */
2859 msk_start = 32 - shift_count;
2860 msk = ((1 << shift_count) - 1) << msk_start;
2861 tcg_gen_andi_tl(cpu_PSW_C, r1, msk);
2862 /* calc v/sv bits */
2863 tcg_gen_setcond_tl(TCG_COND_GT, temp, r1, t_max);
2864 tcg_gen_setcond_tl(TCG_COND_LT, temp2, r1, t_min);
2865 tcg_gen_or_tl(cpu_PSW_V, temp, temp2);
2866 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
2867 /* calc sv */
2868 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_V, cpu_PSW_SV);
2869 /* do shift */
2870 tcg_gen_shli_tl(ret, r1, shift_count);
2871
2872 tcg_temp_free(t_max);
2873 tcg_temp_free(t_min);
2874 } else {
2875 /* clear PSW.V */
2876 tcg_gen_movi_tl(cpu_PSW_V, 0);
2877 /* calc carry */
2878 msk = (1 << -shift_count) - 1;
2879 tcg_gen_andi_tl(cpu_PSW_C, r1, msk);
2880 /* do shift */
2881 tcg_gen_sari_tl(ret, r1, -shift_count);
2882 }
2883 /* calc av overflow bit */
2884 tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
2885 tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
2886 /* calc sav overflow bit */
2887 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2888
2889 tcg_temp_free(temp);
2890 tcg_temp_free(temp2);
2891 tcg_temp_free(t_0);
2892 }
2893
2894 static void gen_shas(TCGv ret, TCGv r1, TCGv r2)
2895 {
2896 gen_helper_sha_ssov(ret, cpu_env, r1, r2);
2897 }
2898
2899 static void gen_shasi(TCGv ret, TCGv r1, int32_t con)
2900 {
2901 TCGv temp = tcg_const_i32(con);
2902 gen_shas(ret, r1, temp);
2903 tcg_temp_free(temp);
2904 }
2905
2906 static void gen_sha_hi(TCGv ret, TCGv r1, int32_t shift_count)
2907 {
2908 TCGv low, high;
2909
2910 if (shift_count == 0) {
2911 tcg_gen_mov_tl(ret, r1);
2912 } else if (shift_count > 0) {
2913 low = tcg_temp_new();
2914 high = tcg_temp_new();
2915
2916 tcg_gen_andi_tl(high, r1, 0xffff0000);
2917 tcg_gen_shli_tl(low, r1, shift_count);
2918 tcg_gen_shli_tl(ret, high, shift_count);
2919 tcg_gen_deposit_tl(ret, ret, low, 0, 16);
2920
2921 tcg_temp_free(low);
2922 tcg_temp_free(high);
2923 } else {
2924 low = tcg_temp_new();
2925 high = tcg_temp_new();
2926
2927 tcg_gen_ext16s_tl(low, r1);
2928 tcg_gen_sari_tl(low, low, -shift_count);
2929 tcg_gen_sari_tl(ret, r1, -shift_count);
2930 tcg_gen_deposit_tl(ret, ret, low, 0, 16);
2931
2932 tcg_temp_free(low);
2933 tcg_temp_free(high);
2934 }
2935
2936 }
2937
2938 /* ret = {ret[30:0], (r1 cond r2)}; */
2939 static void gen_sh_cond(int cond, TCGv ret, TCGv r1, TCGv r2)
2940 {
2941 TCGv temp = tcg_temp_new();
2942 TCGv temp2 = tcg_temp_new();
2943
2944 tcg_gen_shli_tl(temp, ret, 1);
2945 tcg_gen_setcond_tl(cond, temp2, r1, r2);
2946 tcg_gen_or_tl(ret, temp, temp2);
2947
2948 tcg_temp_free(temp);
2949 tcg_temp_free(temp2);
2950 }
2951
2952 static void gen_sh_condi(int cond, TCGv ret, TCGv r1, int32_t con)
2953 {
2954 TCGv temp = tcg_const_i32(con);
2955 gen_sh_cond(cond, ret, r1, temp);
2956 tcg_temp_free(temp);
2957 }
2958
2959 static inline void gen_adds(TCGv ret, TCGv r1, TCGv r2)
2960 {
2961 gen_helper_add_ssov(ret, cpu_env, r1, r2);
2962 }
2963
2964 static inline void gen_addsi(TCGv ret, TCGv r1, int32_t con)
2965 {
2966 TCGv temp = tcg_const_i32(con);
2967 gen_helper_add_ssov(ret, cpu_env, r1, temp);
2968 tcg_temp_free(temp);
2969 }
2970
2971 static inline void gen_addsui(TCGv ret, TCGv r1, int32_t con)
2972 {
2973 TCGv temp = tcg_const_i32(con);
2974 gen_helper_add_suov(ret, cpu_env, r1, temp);
2975 tcg_temp_free(temp);
2976 }
2977
2978 static inline void gen_subs(TCGv ret, TCGv r1, TCGv r2)
2979 {
2980 gen_helper_sub_ssov(ret, cpu_env, r1, r2);
2981 }
2982
2983 static inline void gen_subsu(TCGv ret, TCGv r1, TCGv r2)
2984 {
2985 gen_helper_sub_suov(ret, cpu_env, r1, r2);
2986 }
2987
2988 static inline void gen_bit_2op(TCGv ret, TCGv r1, TCGv r2,
2989 int pos1, int pos2,
2990 void(*op1)(TCGv, TCGv, TCGv),
2991 void(*op2)(TCGv, TCGv, TCGv))
2992 {
2993 TCGv temp1, temp2;
2994
2995 temp1 = tcg_temp_new();
2996 temp2 = tcg_temp_new();
2997
2998 tcg_gen_shri_tl(temp2, r2, pos2);
2999 tcg_gen_shri_tl(temp1, r1, pos1);
3000
3001 (*op1)(temp1, temp1, temp2);
3002 (*op2)(temp1 , ret, temp1);
3003
3004 tcg_gen_deposit_tl(ret, ret, temp1, 0, 1);
3005
3006 tcg_temp_free(temp1);
3007 tcg_temp_free(temp2);
3008 }
3009
3010 /* ret = r1[pos1] op1 r2[pos2]; */
3011 static inline void gen_bit_1op(TCGv ret, TCGv r1, TCGv r2,
3012 int pos1, int pos2,
3013 void(*op1)(TCGv, TCGv, TCGv))
3014 {
3015 TCGv temp1, temp2;
3016
3017 temp1 = tcg_temp_new();
3018 temp2 = tcg_temp_new();
3019
3020 tcg_gen_shri_tl(temp2, r2, pos2);
3021 tcg_gen_shri_tl(temp1, r1, pos1);
3022
3023 (*op1)(ret, temp1, temp2);
3024
3025 tcg_gen_andi_tl(ret, ret, 0x1);
3026
3027 tcg_temp_free(temp1);
3028 tcg_temp_free(temp2);
3029 }
3030
3031 static inline void gen_accumulating_cond(int cond, TCGv ret, TCGv r1, TCGv r2,
3032 void(*op)(TCGv, TCGv, TCGv))
3033 {
3034 TCGv temp = tcg_temp_new();
3035 TCGv temp2 = tcg_temp_new();
3036 /* temp = (arg1 cond arg2 )*/
3037 tcg_gen_setcond_tl(cond, temp, r1, r2);
3038 /* temp2 = ret[0]*/
3039 tcg_gen_andi_tl(temp2, ret, 0x1);
3040 /* temp = temp insn temp2 */
3041 (*op)(temp, temp, temp2);
3042 /* ret = {ret[31:1], temp} */
3043 tcg_gen_deposit_tl(ret, ret, temp, 0, 1);
3044
3045 tcg_temp_free(temp);
3046 tcg_temp_free(temp2);
3047 }
3048
3049 static inline void
3050 gen_accumulating_condi(int cond, TCGv ret, TCGv r1, int32_t con,
3051 void(*op)(TCGv, TCGv, TCGv))
3052 {
3053 TCGv temp = tcg_const_i32(con);
3054 gen_accumulating_cond(cond, ret, r1, temp, op);
3055 tcg_temp_free(temp);
3056 }
3057
3058 /* ret = (r1 cond r2) ? 0xFFFFFFFF ? 0x00000000;*/
3059 static inline void gen_cond_w(TCGCond cond, TCGv ret, TCGv r1, TCGv r2)
3060 {
3061 tcg_gen_setcond_tl(cond, ret, r1, r2);
3062 tcg_gen_neg_tl(ret, ret);
3063 }
3064
3065 static inline void gen_eqany_bi(TCGv ret, TCGv r1, int32_t con)
3066 {
3067 TCGv b0 = tcg_temp_new();
3068 TCGv b1 = tcg_temp_new();
3069 TCGv b2 = tcg_temp_new();
3070 TCGv b3 = tcg_temp_new();
3071
3072 /* byte 0 */
3073 tcg_gen_andi_tl(b0, r1, 0xff);
3074 tcg_gen_setcondi_tl(TCG_COND_EQ, b0, b0, con & 0xff);
3075
3076 /* byte 1 */
3077 tcg_gen_andi_tl(b1, r1, 0xff00);
3078 tcg_gen_setcondi_tl(TCG_COND_EQ, b1, b1, con & 0xff00);
3079
3080 /* byte 2 */
3081 tcg_gen_andi_tl(b2, r1, 0xff0000);
3082 tcg_gen_setcondi_tl(TCG_COND_EQ, b2, b2, con & 0xff0000);
3083
3084 /* byte 3 */
3085 tcg_gen_andi_tl(b3, r1, 0xff000000);
3086 tcg_gen_setcondi_tl(TCG_COND_EQ, b3, b3, con & 0xff000000);
3087
3088 /* combine them */
3089 tcg_gen_or_tl(ret, b0, b1);
3090 tcg_gen_or_tl(ret, ret, b2);
3091 tcg_gen_or_tl(ret, ret, b3);
3092
3093 tcg_temp_free(b0);
3094 tcg_temp_free(b1);
3095 tcg_temp_free(b2);
3096 tcg_temp_free(b3);
3097 }
3098
3099 static inline void gen_eqany_hi(TCGv ret, TCGv r1, int32_t con)
3100 {
3101 TCGv h0 = tcg_temp_new();
3102 TCGv h1 = tcg_temp_new();
3103
3104 /* halfword 0 */
3105 tcg_gen_andi_tl(h0, r1, 0xffff);
3106 tcg_gen_setcondi_tl(TCG_COND_EQ, h0, h0, con & 0xffff);
3107
3108 /* halfword 1 */
3109 tcg_gen_andi_tl(h1, r1, 0xffff0000);
3110 tcg_gen_setcondi_tl(TCG_COND_EQ, h1, h1, con & 0xffff0000);
3111
3112 /* combine them */
3113 tcg_gen_or_tl(ret, h0, h1);
3114
3115 tcg_temp_free(h0);
3116 tcg_temp_free(h1);
3117 }
3118 /* mask = ((1 << width) -1) << pos;
3119 ret = (r1 & ~mask) | (r2 << pos) & mask); */
3120 static inline void gen_insert(TCGv ret, TCGv r1, TCGv r2, TCGv width, TCGv pos)
3121 {
3122 TCGv mask = tcg_temp_new();
3123 TCGv temp = tcg_temp_new();
3124 TCGv temp2 = tcg_temp_new();
3125
3126 tcg_gen_movi_tl(mask, 1);
3127 tcg_gen_shl_tl(mask, mask, width);
3128 tcg_gen_subi_tl(mask, mask, 1);
3129 tcg_gen_shl_tl(mask, mask, pos);
3130
3131 tcg_gen_shl_tl(temp, r2, pos);
3132 tcg_gen_and_tl(temp, temp, mask);
3133 tcg_gen_andc_tl(temp2, r1, mask);
3134 tcg_gen_or_tl(ret, temp, temp2);
3135
3136 tcg_temp_free(mask);
3137 tcg_temp_free(temp);
3138 tcg_temp_free(temp2);
3139 }
3140
3141 static inline void gen_bsplit(TCGv rl, TCGv rh, TCGv r1)
3142 {
3143 TCGv_i64 temp = tcg_temp_new_i64();
3144
3145 gen_helper_bsplit(temp, r1);
3146 tcg_gen_extr_i64_i32(rl, rh, temp);
3147
3148 tcg_temp_free_i64(temp);
3149 }
3150
3151 static inline void gen_unpack(TCGv rl, TCGv rh, TCGv r1)
3152 {
3153 TCGv_i64 temp = tcg_temp_new_i64();
3154
3155 gen_helper_unpack(temp, r1);
3156 tcg_gen_extr_i64_i32(rl, rh, temp);
3157
3158 tcg_temp_free_i64(temp);
3159 }
3160
3161 static inline void
3162 gen_dvinit_b(DisasContext *ctx, TCGv rl, TCGv rh, TCGv r1, TCGv r2)
3163 {
3164 TCGv_i64 ret = tcg_temp_new_i64();
3165
3166 if (!has_feature(ctx, TRICORE_FEATURE_131)) {
3167 gen_helper_dvinit_b_13(ret, cpu_env, r1, r2);
3168 } else {
3169 gen_helper_dvinit_b_131(ret, cpu_env, r1, r2);
3170 }
3171 tcg_gen_extr_i64_i32(rl, rh, ret);
3172
3173 tcg_temp_free_i64(ret);
3174 }
3175
3176 static inline void
3177 gen_dvinit_h(DisasContext *ctx, TCGv rl, TCGv rh, TCGv r1, TCGv r2)
3178 {
3179 TCGv_i64 ret = tcg_temp_new_i64();
3180
3181 if (!has_feature(ctx, TRICORE_FEATURE_131)) {
3182 gen_helper_dvinit_h_13(ret, cpu_env, r1, r2);
3183 } else {
3184 gen_helper_dvinit_h_131(ret, cpu_env, r1, r2);
3185 }
3186 tcg_gen_extr_i64_i32(rl, rh, ret);
3187
3188 tcg_temp_free_i64(ret);
3189 }
3190
3191 static void gen_calc_usb_mul_h(TCGv arg_low, TCGv arg_high)
3192 {
3193 TCGv temp = tcg_temp_new();
3194 /* calc AV bit */
3195 tcg_gen_add_tl(temp, arg_low, arg_low);
3196 tcg_gen_xor_tl(temp, temp, arg_low);
3197 tcg_gen_add_tl(cpu_PSW_AV, arg_high, arg_high);
3198 tcg_gen_xor_tl(cpu_PSW_AV, cpu_PSW_AV, arg_high);
3199 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp);
3200 /* calc SAV bit */
3201 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
3202 tcg_gen_movi_tl(cpu_PSW_V, 0);
3203 tcg_temp_free(temp);
3204 }
3205
3206 static void gen_calc_usb_mulr_h(TCGv arg)
3207 {
3208 TCGv temp = tcg_temp_new();
3209 /* calc AV bit */
3210 tcg_gen_add_tl(temp, arg, arg);
3211 tcg_gen_xor_tl(temp, temp, arg);
3212 tcg_gen_shli_tl(cpu_PSW_AV, temp, 16);
3213 tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp);
3214 /* calc SAV bit */
3215 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
3216 /* clear V bit */
3217 tcg_gen_movi_tl(cpu_PSW_V, 0);
3218 tcg_temp_free(temp);
3219 }
3220
3221 /* helpers for generating program flow micro-ops */
3222
3223 static inline void gen_save_pc(target_ulong pc)
3224 {
3225 tcg_gen_movi_tl(cpu_PC, pc);
3226 }
3227
3228 static void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
3229 {
3230 if (translator_use_goto_tb(&ctx->base, dest)) {
3231 tcg_gen_goto_tb(n);
3232 gen_save_pc(dest);
3233 tcg_gen_exit_tb(ctx->base.tb, n);
3234 } else {
3235 gen_save_pc(dest);
3236 tcg_gen_lookup_and_goto_ptr();
3237 }
3238 }
3239
3240 static void generate_trap(DisasContext *ctx, int class, int tin)
3241 {
3242 TCGv_i32 classtemp = tcg_const_i32(class);
3243 TCGv_i32 tintemp = tcg_const_i32(tin);
3244
3245 gen_save_pc(ctx->base.pc_next);
3246 gen_helper_raise_exception_sync(cpu_env, classtemp, tintemp);
3247 ctx->base.is_jmp = DISAS_NORETURN;
3248
3249 tcg_temp_free(classtemp);
3250 tcg_temp_free(tintemp);
3251 }
3252
3253 static inline void gen_branch_cond(DisasContext *ctx, TCGCond cond, TCGv r1,
3254 TCGv r2, int16_t address)
3255 {
3256 TCGLabel *jumpLabel = gen_new_label();
3257 tcg_gen_brcond_tl(cond, r1, r2, jumpLabel);
3258
3259 gen_goto_tb(ctx, 1, ctx->pc_succ_insn);
3260
3261 gen_set_label(jumpLabel);
3262 gen_goto_tb(ctx, 0, ctx->base.pc_next + address * 2);
3263 }
3264
3265 static inline void gen_branch_condi(DisasContext *ctx, TCGCond cond, TCGv r1,
3266 int r2, int16_t address)
3267 {
3268 TCGv temp = tcg_const_i32(r2);
3269 gen_branch_cond(ctx, cond, r1, temp, address);
3270 tcg_temp_free(temp);
3271 }
3272
3273 static void gen_loop(DisasContext *ctx, int r1, int32_t offset)
3274 {
3275 TCGLabel *l1 = gen_new_label();
3276
3277 tcg_gen_subi_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], 1);
3278 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr_a[r1], -1, l1);
3279 gen_goto_tb(ctx, 1, ctx->base.pc_next + offset);
3280 gen_set_label(l1);
3281 gen_goto_tb(ctx, 0, ctx->pc_succ_insn);
3282 }
3283
3284 static void gen_fcall_save_ctx(DisasContext *ctx)
3285 {
3286 TCGv temp = tcg_temp_new();
3287
3288 tcg_gen_addi_tl(temp, cpu_gpr_a[10], -4);
3289 tcg_gen_qemu_st_tl(cpu_gpr_a[11], temp, ctx->mem_idx, MO_LESL);
3290 tcg_gen_movi_tl(cpu_gpr_a[11], ctx->pc_succ_insn);
3291 tcg_gen_mov_tl(cpu_gpr_a[10], temp);
3292
3293 tcg_temp_free(temp);
3294 }
3295
3296 static void gen_fret(DisasContext *ctx)
3297 {
3298 TCGv temp = tcg_temp_new();
3299
3300 tcg_gen_andi_tl(temp, cpu_gpr_a[11], ~0x1);
3301 tcg_gen_qemu_ld_tl(cpu_gpr_a[11], cpu_gpr_a[10], ctx->mem_idx, MO_LESL);
3302 tcg_gen_addi_tl(cpu_gpr_a[10], cpu_gpr_a[10], 4);
3303 tcg_gen_mov_tl(cpu_PC, temp);
3304 tcg_gen_exit_tb(NULL, 0);
3305 ctx->base.is_jmp = DISAS_NORETURN;
3306
3307 tcg_temp_free(temp);
3308 }
3309
3310 static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
3311 int r2 , int32_t constant , int32_t offset)
3312 {
3313 TCGv temp, temp2;
3314 int n;
3315
3316 switch (opc) {
3317 /* SB-format jumps */
3318 case OPC1_16_SB_J:
3319 case OPC1_32_B_J:
3320 gen_goto_tb(ctx, 0, ctx->base.pc_next + offset * 2);
3321 break;
3322 case OPC1_32_B_CALL:
3323 case OPC1_16_SB_CALL:
3324 gen_helper_1arg(call, ctx->pc_succ_insn);
3325 gen_goto_tb(ctx, 0, ctx->base.pc_next + offset * 2);
3326 break;
3327 case OPC1_16_SB_JZ:
3328 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
3329 break;
3330 case OPC1_16_SB_JNZ:
3331 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
3332 break;
3333 /* SBC-format jumps */
3334 case OPC1_16_SBC_JEQ:
3335 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
3336 break;
3337 case OPC1_16_SBC_JEQ2:
3338 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant,
3339 offset + 16);
3340 break;
3341 case OPC1_16_SBC_JNE:
3342 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
3343 break;
3344 case OPC1_16_SBC_JNE2:
3345 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15],
3346 constant, offset + 16);
3347 break;
3348 /* SBRN-format jumps */
3349 case OPC1_16_SBRN_JZ_T:
3350 temp = tcg_temp_new();
3351 tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
3352 gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
3353 tcg_temp_free(temp);
3354 break;
3355 case OPC1_16_SBRN_JNZ_T:
3356 temp = tcg_temp_new();
3357 tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
3358 gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
3359 tcg_temp_free(temp);
3360 break;
3361 /* SBR-format jumps */
3362 case OPC1_16_SBR_JEQ:
3363 gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
3364 offset);
3365 break;
3366 case OPC1_16_SBR_JEQ2:
3367 gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
3368 offset + 16);
3369 break;
3370 case OPC1_16_SBR_JNE:
3371 gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
3372 offset);
3373 break;
3374 case OPC1_16_SBR_JNE2:
3375 gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
3376 offset + 16);
3377 break;
3378 case OPC1_16_SBR_JNZ:
3379 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
3380 break;
3381 case OPC1_16_SBR_JNZ_A:
3382 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
3383 break;
3384 case OPC1_16_SBR_JGEZ:
3385 gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
3386 break;
3387 case OPC1_16_SBR_JGTZ:
3388 gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
3389 break;
3390 case OPC1_16_SBR_JLEZ:
3391 gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
3392 break;
3393 case OPC1_16_SBR_JLTZ:
3394 gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
3395 break;
3396 case OPC1_16_SBR_JZ:
3397 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
3398 break;
3399 case OPC1_16_SBR_JZ_A:
3400 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
3401 break;
3402 case OPC1_16_SBR_LOOP:
3403 gen_loop(ctx, r1, offset * 2 - 32);
3404 break;
3405 /* SR-format jumps */
3406 case OPC1_16_SR_JI:
3407 tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
3408 tcg_gen_exit_tb(NULL, 0);
3409 break;
3410 case OPC2_32_SYS_RET:
3411 case OPC2_16_SR_RET:
3412 gen_helper_ret(cpu_env);
3413 tcg_gen_exit_tb(NULL, 0);
3414 break;
3415 /* B-format */
3416 case OPC1_32_B_CALLA:
3417 gen_helper_1arg(call, ctx->pc_succ_insn);
3418 gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
3419 break;
3420 case OPC1_32_B_FCALL:
3421 gen_fcall_save_ctx(ctx);
3422 gen_goto_tb(ctx, 0, ctx->base.pc_next + offset * 2);
3423 break;
3424 case OPC1_32_B_FCALLA:
3425 gen_fcall_save_ctx(ctx);
3426 gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
3427 break;
3428 case OPC1_32_B_JLA:
3429 tcg_gen_movi_tl(cpu_gpr_a[11], ctx->pc_succ_insn);
3430 /* fall through */
3431 case OPC1_32_B_JA:
3432 gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
3433 break;
3434 case OPC1_32_B_JL:
3435 tcg_gen_movi_tl(cpu_gpr_a[11], ctx->pc_succ_insn);
3436 gen_goto_tb(ctx, 0, ctx->base.pc_next + offset * 2);
3437 break;
3438 /* BOL format */
3439 case OPCM_32_BRC_EQ_NEQ:
3440 if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
3441 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
3442 } else {
3443 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
3444 }
3445 break;
3446 case OPCM_32_BRC_GE:
3447 if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
3448 gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
3449 } else {
3450 constant = MASK_OP_BRC_CONST4(ctx->opcode);
3451 gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
3452 offset);
3453 }
3454 break;
3455 case OPCM_32_BRC_JLT:
3456 if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
3457 gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
3458 } else {
3459 constant = MASK_OP_BRC_CONST4(ctx->opcode);
3460 gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
3461 offset);
3462 }
3463 break;
3464 case OPCM_32_BRC_JNE:
3465 temp = tcg_temp_new();
3466 if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
3467 tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
3468 /* subi is unconditional */
3469 tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
3470 gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
3471 } else {
3472 tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
3473 /* addi is unconditional */
3474 tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
3475 gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
3476 }
3477 tcg_temp_free(temp);
3478 break;
3479 /* BRN format */
3480 case OPCM_32_BRN_JTT:
3481 n = MASK_OP_BRN_N(ctx->opcode);
3482
3483 temp = tcg_temp_new();
3484 tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
3485
3486 if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
3487 gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
3488 } else {
3489 gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
3490 }
3491 tcg_temp_free(temp);
3492 break;
3493 /* BRR Format */
3494 case OPCM_32_BRR_EQ_NEQ:
3495 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
3496 gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
3497 offset);
3498 } else {
3499 gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
3500 offset);
3501 }
3502 break;
3503 case OPCM_32_BRR_ADDR_EQ_NEQ:
3504 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
3505 gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
3506 offset);
3507 } else {
3508 gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
3509 offset);
3510 }
3511 break;
3512 case OPCM_32_BRR_GE:
3513 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
3514 gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
3515 offset);
3516 } else {
3517 gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
3518 offset);
3519 }
3520 break;
3521 case OPCM_32_BRR_JLT:
3522 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
3523 gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
3524 offset);
3525 } else {
3526 gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
3527 offset);
3528 }
3529 break;
3530 case OPCM_32_BRR_LOOP:
3531 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
3532 gen_loop(ctx, r2, offset * 2);
3533 } else {
3534 /* OPC2_32_BRR_LOOPU */
3535 gen_goto_tb(ctx, 0, ctx->base.pc_next + offset * 2);
3536 }
3537 break;
3538 case OPCM_32_BRR_JNE:
3539 temp = tcg_temp_new();
3540 temp2 = tcg_temp_new();
3541 if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
3542 tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
3543 /* also save r2, in case of r1 == r2, so r2 is not decremented */
3544 tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
3545 /* subi is unconditional */
3546 tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
3547 gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
3548 } else {
3549 tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
3550 /* also save r2, in case of r1 == r2, so r2 is not decremented */
3551 tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
3552 /* addi is unconditional */
3553 tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
3554 gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
3555 }
3556 tcg_temp_free(temp);
3557 tcg_temp_free(temp2);
3558 break;
3559 case OPCM_32_BRR_JNZ:
3560 if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
3561 gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
3562 } else {
3563 gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
3564 }
3565 break;
3566 default:
3567 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3568 }
3569 ctx->base.is_jmp = DISAS_NORETURN;
3570 }
3571
3572
3573 /*
3574 * Functions for decoding instructions
3575 */
3576
3577 static void decode_src_opc(DisasContext *ctx, int op1)
3578 {
3579 int r1;
3580 int32_t const4;
3581 TCGv temp, temp2;
3582
3583 r1 = MASK_OP_SRC_S1D(ctx->opcode);
3584 const4 = MASK_OP_SRC_CONST4_SEXT(ctx->opcode);
3585
3586 switch (op1) {
3587 case OPC1_16_SRC_ADD:
3588 gen_addi_d(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
3589 break;
3590 case OPC1_16_SRC_ADD_A15:
3591 gen_addi_d(cpu_gpr_d[r1], cpu_gpr_d[15], const4);
3592 break;
3593 case OPC1_16_SRC_ADD_15A:
3594 gen_addi_d(cpu_gpr_d[15], cpu_gpr_d[r1], const4);
3595 break;
3596 case OPC1_16_SRC_ADD_A:
3597 tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], const4);
3598 break;
3599 case OPC1_16_SRC_CADD:
3600 gen_condi_add(TCG_COND_NE, cpu_gpr_d[r1], const4, cpu_gpr_d[r1],
3601 cpu_gpr_d[15]);
3602 break;
3603 case OPC1_16_SRC_CADDN:
3604 gen_condi_add(TCG_COND_EQ, cpu_gpr_d[r1], const4, cpu_gpr_d[r1],
3605 cpu_gpr_d[15]);
3606 break;
3607 case OPC1_16_SRC_CMOV:
3608 temp = tcg_const_tl(0);
3609 temp2 = tcg_const_tl(const4);
3610 tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
3611 temp2, cpu_gpr_d[r1]);
3612 tcg_temp_free(temp);
3613 tcg_temp_free(temp2);
3614 break;
3615 case OPC1_16_SRC_CMOVN:
3616 temp = tcg_const_tl(0);
3617 temp2 = tcg_const_tl(const4);
3618 tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
3619 temp2, cpu_gpr_d[r1]);
3620 tcg_temp_free(temp);
3621 tcg_temp_free(temp2);
3622 break;
3623 case OPC1_16_SRC_EQ:
3624 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[15], cpu_gpr_d[r1],
3625 const4);
3626 break;
3627 case OPC1_16_SRC_LT:
3628 tcg_gen_setcondi_tl(TCG_COND_LT, cpu_gpr_d[15], cpu_gpr_d[r1],
3629 const4);
3630 break;
3631 case OPC1_16_SRC_MOV:
3632 tcg_gen_movi_tl(cpu_gpr_d[r1], const4);
3633 break;
3634 case OPC1_16_SRC_MOV_A:
3635 const4 = MASK_OP_SRC_CONST4(ctx->opcode);
3636 tcg_gen_movi_tl(cpu_gpr_a[r1], const4);
3637 break;
3638 case OPC1_16_SRC_MOV_E:
3639 if (has_feature(ctx, TRICORE_FEATURE_16)) {
3640 tcg_gen_movi_tl(cpu_gpr_d[r1], const4);
3641 tcg_gen_sari_tl(cpu_gpr_d[r1+1], cpu_gpr_d[r1], 31);
3642 } else {
3643 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3644 }
3645 break;
3646 case OPC1_16_SRC_SH:
3647 gen_shi(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
3648 break;
3649 case OPC1_16_SRC_SHA:
3650 gen_shaci(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
3651 break;
3652 default:
3653 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3654 }
3655 }
3656
3657 static void decode_srr_opc(DisasContext *ctx, int op1)
3658 {
3659 int r1, r2;
3660 TCGv temp;
3661
3662 r1 = MASK_OP_SRR_S1D(ctx->opcode);
3663 r2 = MASK_OP_SRR_S2(ctx->opcode);
3664
3665 switch (op1) {
3666 case OPC1_16_SRR_ADD:
3667 gen_add_d(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3668 break;
3669 case OPC1_16_SRR_ADD_A15:
3670 gen_add_d(cpu_gpr_d[r1], cpu_gpr_d[15], cpu_gpr_d[r2]);
3671 break;
3672 case OPC1_16_SRR_ADD_15A:
3673 gen_add_d(cpu_gpr_d[15], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3674 break;
3675 case OPC1_16_SRR_ADD_A:
3676 tcg_gen_add_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], cpu_gpr_a[r2]);
3677 break;
3678 case OPC1_16_SRR_ADDS:
3679 gen_adds(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3680 break;
3681 case OPC1_16_SRR_AND:
3682 tcg_gen_and_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3683 break;
3684 case OPC1_16_SRR_CMOV:
3685 temp = tcg_const_tl(0);
3686 tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
3687 cpu_gpr_d[r2], cpu_gpr_d[r1]);
3688 tcg_temp_free(temp);
3689 break;
3690 case OPC1_16_SRR_CMOVN:
3691 temp = tcg_const_tl(0);
3692 tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
3693 cpu_gpr_d[r2], cpu_gpr_d[r1]);
3694 tcg_temp_free(temp);
3695 break;
3696 case OPC1_16_SRR_EQ:
3697 tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[15], cpu_gpr_d[r1],
3698 cpu_gpr_d[r2]);
3699 break;
3700 case OPC1_16_SRR_LT:
3701 tcg_gen_setcond_tl(TCG_COND_LT, cpu_gpr_d[15], cpu_gpr_d[r1],
3702 cpu_gpr_d[r2]);
3703 break;
3704 case OPC1_16_SRR_MOV:
3705 tcg_gen_mov_tl(cpu_gpr_d[r1], cpu_gpr_d[r2]);
3706 break;
3707 case OPC1_16_SRR_MOV_A:
3708 tcg_gen_mov_tl(cpu_gpr_a[r1], cpu_gpr_d[r2]);
3709 break;
3710 case OPC1_16_SRR_MOV_AA:
3711 tcg_gen_mov_tl(cpu_gpr_a[r1], cpu_gpr_a[r2]);
3712 break;
3713 case OPC1_16_SRR_MOV_D:
3714 tcg_gen_mov_tl(cpu_gpr_d[r1], cpu_gpr_a[r2]);
3715 break;
3716 case OPC1_16_SRR_MUL:
3717 gen_mul_i32s(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3718 break;
3719 case OPC1_16_SRR_OR:
3720 tcg_gen_or_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3721 break;
3722 case OPC1_16_SRR_SUB:
3723 gen_sub_d(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3724 break;
3725 case OPC1_16_SRR_SUB_A15B:
3726 gen_sub_d(cpu_gpr_d[r1], cpu_gpr_d[15], cpu_gpr_d[r2]);
3727 break;
3728 case OPC1_16_SRR_SUB_15AB:
3729 gen_sub_d(cpu_gpr_d[15], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3730 break;
3731 case OPC1_16_SRR_SUBS:
3732 gen_subs(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3733 break;
3734 case OPC1_16_SRR_XOR:
3735 tcg_gen_xor_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
3736 break;
3737 default:
3738 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3739 }
3740 }
3741
3742 static void decode_ssr_opc(DisasContext *ctx, int op1)
3743 {
3744 int r1, r2;
3745
3746 r1 = MASK_OP_SSR_S1(ctx->opcode);
3747 r2 = MASK_OP_SSR_S2(ctx->opcode);
3748
3749 switch (op1) {
3750 case OPC1_16_SSR_ST_A:
3751 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
3752 break;
3753 case OPC1_16_SSR_ST_A_POSTINC:
3754 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
3755 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
3756 break;
3757 case OPC1_16_SSR_ST_B:
3758 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
3759 break;
3760 case OPC1_16_SSR_ST_B_POSTINC:
3761 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
3762 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 1);
3763 break;
3764 case OPC1_16_SSR_ST_H:
3765 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUW);
3766 break;
3767 case OPC1_16_SSR_ST_H_POSTINC:
3768 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUW);
3769 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 2);
3770 break;
3771 case OPC1_16_SSR_ST_W:
3772 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
3773 break;
3774 case OPC1_16_SSR_ST_W_POSTINC:
3775 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
3776 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
3777 break;
3778 default:
3779 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3780 }
3781 }
3782
3783 static void decode_sc_opc(DisasContext *ctx, int op1)
3784 {
3785 int32_t const16;
3786
3787 const16 = MASK_OP_SC_CONST8(ctx->opcode);
3788
3789 switch (op1) {
3790 case OPC1_16_SC_AND:
3791 tcg_gen_andi_tl(cpu_gpr_d[15], cpu_gpr_d[15], const16);
3792 break;
3793 case OPC1_16_SC_BISR:
3794 gen_helper_1arg(bisr, const16 & 0xff);
3795 break;
3796 case OPC1_16_SC_LD_A:
3797 gen_offset_ld(ctx, cpu_gpr_a[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
3798 break;
3799 case OPC1_16_SC_LD_W:
3800 gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
3801 break;
3802 case OPC1_16_SC_MOV:
3803 tcg_gen_movi_tl(cpu_gpr_d[15], const16);
3804 break;
3805 case OPC1_16_SC_OR:
3806 tcg_gen_ori_tl(cpu_gpr_d[15], cpu_gpr_d[15], const16);
3807 break;
3808 case OPC1_16_SC_ST_A:
3809 gen_offset_st(ctx, cpu_gpr_a[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
3810 break;
3811 case OPC1_16_SC_ST_W:
3812 gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
3813 break;
3814 case OPC1_16_SC_SUB_A:
3815 tcg_gen_subi_tl(cpu_gpr_a[10], cpu_gpr_a[10], const16);
3816 break;
3817 default:
3818 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3819 }
3820 }
3821
3822 static void decode_slr_opc(DisasContext *ctx, int op1)
3823 {
3824 int r1, r2;
3825
3826 r1 = MASK_OP_SLR_D(ctx->opcode);
3827 r2 = MASK_OP_SLR_S2(ctx->opcode);
3828
3829 switch (op1) {
3830 /* SLR-format */
3831 case OPC1_16_SLR_LD_A:
3832 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
3833 break;
3834 case OPC1_16_SLR_LD_A_POSTINC:
3835 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
3836 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
3837 break;
3838 case OPC1_16_SLR_LD_BU:
3839 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
3840 break;
3841 case OPC1_16_SLR_LD_BU_POSTINC:
3842 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
3843 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 1);
3844 break;
3845 case OPC1_16_SLR_LD_H:
3846 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
3847 break;
3848 case OPC1_16_SLR_LD_H_POSTINC:
3849 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
3850 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 2);
3851 break;
3852 case OPC1_16_SLR_LD_W:
3853 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
3854 break;
3855 case OPC1_16_SLR_LD_W_POSTINC:
3856 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
3857 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
3858 break;
3859 default:
3860 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3861 }
3862 }
3863
3864 static void decode_sro_opc(DisasContext *ctx, int op1)
3865 {
3866 int r2;
3867 int32_t address;
3868
3869 r2 = MASK_OP_SRO_S2(ctx->opcode);
3870 address = MASK_OP_SRO_OFF4(ctx->opcode);
3871
3872 /* SRO-format */
3873 switch (op1) {
3874 case OPC1_16_SRO_LD_A:
3875 gen_offset_ld(ctx, cpu_gpr_a[15], cpu_gpr_a[r2], address * 4, MO_LESL);
3876 break;
3877 case OPC1_16_SRO_LD_BU:
3878 gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_UB);
3879 break;
3880 case OPC1_16_SRO_LD_H:
3881 gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_LESW);
3882 break;
3883 case OPC1_16_SRO_LD_W:
3884 gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 4, MO_LESL);
3885 break;
3886 case OPC1_16_SRO_ST_A:
3887 gen_offset_st(ctx, cpu_gpr_a[15], cpu_gpr_a[r2], address * 4, MO_LESL);
3888 break;
3889 case OPC1_16_SRO_ST_B:
3890 gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_UB);
3891 break;
3892 case OPC1_16_SRO_ST_H:
3893 gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 2, MO_LESW);
3894 break;
3895 case OPC1_16_SRO_ST_W:
3896 gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 4, MO_LESL);
3897 break;
3898 default:
3899 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3900 }
3901 }
3902
3903 static void decode_sr_system(DisasContext *ctx)
3904 {
3905 uint32_t op2;
3906 op2 = MASK_OP_SR_OP2(ctx->opcode);
3907
3908 switch (op2) {
3909 case OPC2_16_SR_NOP:
3910 break;
3911 case OPC2_16_SR_RET:
3912 gen_compute_branch(ctx, op2, 0, 0, 0, 0);
3913 break;
3914 case OPC2_16_SR_RFE:
3915 gen_helper_rfe(cpu_env);
3916 tcg_gen_exit_tb(NULL, 0);
3917 ctx->base.is_jmp = DISAS_NORETURN;
3918 break;
3919 case OPC2_16_SR_DEBUG:
3920 /* raise EXCP_DEBUG */
3921 break;
3922 case OPC2_16_SR_FRET:
3923 gen_fret(ctx);
3924 break;
3925 default:
3926 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3927 }
3928 }
3929
3930 static void decode_sr_accu(DisasContext *ctx)
3931 {
3932 uint32_t op2;
3933 uint32_t r1;
3934 TCGv temp;
3935
3936 r1 = MASK_OP_SR_S1D(ctx->opcode);
3937 op2 = MASK_OP_SR_OP2(ctx->opcode);
3938
3939 switch (op2) {
3940 case OPC2_16_SR_RSUB:
3941 /* overflow only if r1 = -0x80000000 */
3942 temp = tcg_const_i32(-0x80000000);
3943 /* calc V bit */
3944 tcg_gen_setcond_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r1], temp);
3945 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
3946 /* calc SV bit */
3947 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
3948 /* sub */
3949 tcg_gen_neg_tl(cpu_gpr_d[r1], cpu_gpr_d[r1]);
3950 /* calc av */
3951 tcg_gen_add_tl(cpu_PSW_AV, cpu_gpr_d[r1], cpu_gpr_d[r1]);
3952 tcg_gen_xor_tl(cpu_PSW_AV, cpu_gpr_d[r1], cpu_PSW_AV);
3953 /* calc sav */
3954 tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
3955 tcg_temp_free(temp);
3956 break;
3957 case OPC2_16_SR_SAT_B:
3958 gen_saturate(cpu_gpr_d[r1], cpu_gpr_d[r1], 0x7f, -0x80);
3959 break;
3960 case OPC2_16_SR_SAT_BU:
3961 gen_saturate_u(cpu_gpr_d[r1], cpu_gpr_d[r1], 0xff);
3962 break;
3963 case OPC2_16_SR_SAT_H:
3964 gen_saturate(cpu_gpr_d[r1], cpu_gpr_d[r1], 0x7fff, -0x8000);
3965 break;
3966 case OPC2_16_SR_SAT_HU:
3967 gen_saturate_u(cpu_gpr_d[r1], cpu_gpr_d[r1], 0xffff);
3968 break;
3969 default:
3970 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
3971 }
3972 }
3973
3974 static void decode_16Bit_opc(DisasContext *ctx)
3975 {
3976 int op1;
3977 int r1, r2;
3978 int32_t const16;
3979 int32_t address;
3980 TCGv temp;
3981
3982 op1 = MASK_OP_MAJOR(ctx->opcode);
3983
3984 /* handle ADDSC.A opcode only being 6 bit long */
3985 if (unlikely((op1 & 0x3f) == OPC1_16_SRRS_ADDSC_A)) {
3986 op1 = OPC1_16_SRRS_ADDSC_A;
3987 }
3988
3989 switch (op1) {
3990 case OPC1_16_SRC_ADD:
3991 case OPC1_16_SRC_ADD_A15:
3992 case OPC1_16_SRC_ADD_15A:
3993 case OPC1_16_SRC_ADD_A:
3994 case OPC1_16_SRC_CADD:
3995 case OPC1_16_SRC_CADDN:
3996 case OPC1_16_SRC_CMOV:
3997 case OPC1_16_SRC_CMOVN:
3998 case OPC1_16_SRC_EQ:
3999 case OPC1_16_SRC_LT:
4000 case OPC1_16_SRC_MOV:
4001 case OPC1_16_SRC_MOV_A:
4002 case OPC1_16_SRC_MOV_E:
4003 case OPC1_16_SRC_SH:
4004 case OPC1_16_SRC_SHA:
4005 decode_src_opc(ctx, op1);
4006 break;
4007 /* SRR-format */
4008 case OPC1_16_SRR_ADD:
4009 case OPC1_16_SRR_ADD_A15:
4010 case OPC1_16_SRR_ADD_15A:
4011 case OPC1_16_SRR_ADD_A:
4012 case OPC1_16_SRR_ADDS:
4013 case OPC1_16_SRR_AND:
4014 case OPC1_16_SRR_CMOV:
4015 case OPC1_16_SRR_CMOVN:
4016 case OPC1_16_SRR_EQ:
4017 case OPC1_16_SRR_LT:
4018 case OPC1_16_SRR_MOV:
4019 case OPC1_16_SRR_MOV_A:
4020 case OPC1_16_SRR_MOV_AA:
4021 case OPC1_16_SRR_MOV_D:
4022 case OPC1_16_SRR_MUL:
4023 case OPC1_16_SRR_OR:
4024 case OPC1_16_SRR_SUB:
4025 case OPC1_16_SRR_SUB_A15B:
4026 case OPC1_16_SRR_SUB_15AB:
4027 case OPC1_16_SRR_SUBS:
4028 case OPC1_16_SRR_XOR:
4029 decode_srr_opc(ctx, op1);
4030 break;
4031 /* SSR-format */
4032 case OPC1_16_SSR_ST_A:
4033 case OPC1_16_SSR_ST_A_POSTINC:
4034 case OPC1_16_SSR_ST_B:
4035 case OPC1_16_SSR_ST_B_POSTINC:
4036 case OPC1_16_SSR_ST_H:
4037 case OPC1_16_SSR_ST_H_POSTINC:
4038 case OPC1_16_SSR_ST_W:
4039 case OPC1_16_SSR_ST_W_POSTINC:
4040 decode_ssr_opc(ctx, op1);
4041 break;
4042 /* SRRS-format */
4043 case OPC1_16_SRRS_ADDSC_A:
4044 r2 = MASK_OP_SRRS_S2(ctx->opcode);
4045 r1 = MASK_OP_SRRS_S1D(ctx->opcode);
4046 const16 = MASK_OP_SRRS_N(ctx->opcode);
4047 temp = tcg_temp_new();
4048 tcg_gen_shli_tl(temp, cpu_gpr_d[15], const16);
4049 tcg_gen_add_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], temp);
4050 tcg_temp_free(temp);
4051 break;
4052 /* SLRO-format */
4053 case OPC1_16_SLRO_LD_A:
4054 r1 = MASK_OP_SLRO_D(ctx->opcode);
4055 const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
4056 gen_offset_ld(ctx, cpu_gpr_a[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
4057 break;
4058 case OPC1_16_SLRO_LD_BU:
4059 r1 = MASK_OP_SLRO_D(ctx->opcode);
4060 const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
4061 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16, MO_UB);
4062 break;
4063 case OPC1_16_SLRO_LD_H:
4064 r1 = MASK_OP_SLRO_D(ctx->opcode);
4065 const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
4066 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 2, MO_LESW);
4067 break;
4068 case OPC1_16_SLRO_LD_W:
4069 r1 = MASK_OP_SLRO_D(ctx->opcode);
4070 const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
4071 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
4072 break;
4073 /* SB-format */
4074 case OPC1_16_SB_CALL:
4075 case OPC1_16_SB_J:
4076 case OPC1_16_SB_JNZ:
4077 case OPC1_16_SB_JZ:
4078 address = MASK_OP_SB_DISP8_SEXT(ctx->opcode);
4079 gen_compute_branch(ctx, op1, 0, 0, 0, address);
4080 break;
4081 /* SBC-format */
4082 case OPC1_16_SBC_JEQ:
4083 case OPC1_16_SBC_JNE:
4084 address = MASK_OP_SBC_DISP4(ctx->opcode);
4085 const16 = MASK_OP_SBC_CONST4_SEXT(ctx->opcode);
4086 gen_compute_branch(ctx, op1, 0, 0, const16, address);
4087 break;
4088 case OPC1_16_SBC_JEQ2:
4089 case OPC1_16_SBC_JNE2:
4090 if (has_feature(ctx, TRICORE_FEATURE_16)) {
4091 address = MASK_OP_SBC_DISP4(ctx->opcode);
4092 const16 = MASK_OP_SBC_CONST4_SEXT(ctx->opcode);
4093 gen_compute_branch(ctx, op1, 0, 0, const16, address);
4094 } else {
4095 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4096 }
4097 break;
4098 /* SBRN-format */
4099 case OPC1_16_SBRN_JNZ_T:
4100 case OPC1_16_SBRN_JZ_T:
4101 address = MASK_OP_SBRN_DISP4(ctx->opcode);
4102 const16 = MASK_OP_SBRN_N(ctx->opcode);
4103 gen_compute_branch(ctx, op1, 0, 0, const16, address);
4104 break;
4105 /* SBR-format */
4106 case OPC1_16_SBR_JEQ2:
4107 case OPC1_16_SBR_JNE2:
4108 if (has_feature(ctx, TRICORE_FEATURE_16)) {
4109 r1 = MASK_OP_SBR_S2(ctx->opcode);
4110 address = MASK_OP_SBR_DISP4(ctx->opcode);
4111 gen_compute_branch(ctx, op1, r1, 0, 0, address);
4112 } else {
4113 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4114 }
4115 break;
4116 case OPC1_16_SBR_JEQ:
4117 case OPC1_16_SBR_JGEZ:
4118 case OPC1_16_SBR_JGTZ:
4119 case OPC1_16_SBR_JLEZ:
4120 case OPC1_16_SBR_JLTZ:
4121 case OPC1_16_SBR_JNE:
4122 case OPC1_16_SBR_JNZ:
4123 case OPC1_16_SBR_JNZ_A:
4124 case OPC1_16_SBR_JZ:
4125 case OPC1_16_SBR_JZ_A:
4126 case OPC1_16_SBR_LOOP:
4127 r1 = MASK_OP_SBR_S2(ctx->opcode);
4128 address = MASK_OP_SBR_DISP4(ctx->opcode);
4129 gen_compute_branch(ctx, op1, r1, 0, 0, address);
4130 break;
4131 /* SC-format */
4132 case OPC1_16_SC_AND:
4133 case OPC1_16_SC_BISR:
4134 case OPC1_16_SC_LD_A:
4135 case OPC1_16_SC_LD_W:
4136 case OPC1_16_SC_MOV:
4137 case OPC1_16_SC_OR:
4138 case OPC1_16_SC_ST_A:
4139 case OPC1_16_SC_ST_W:
4140 case OPC1_16_SC_SUB_A:
4141 decode_sc_opc(ctx, op1);
4142 break;
4143 /* SLR-format */
4144 case OPC1_16_SLR_LD_A:
4145 case OPC1_16_SLR_LD_A_POSTINC:
4146 case OPC1_16_SLR_LD_BU:
4147 case OPC1_16_SLR_LD_BU_POSTINC:
4148 case OPC1_16_SLR_LD_H:
4149 case OPC1_16_SLR_LD_H_POSTINC:
4150 case OPC1_16_SLR_LD_W:
4151 case OPC1_16_SLR_LD_W_POSTINC:
4152 decode_slr_opc(ctx, op1);
4153 break;
4154 /* SRO-format */
4155 case OPC1_16_SRO_LD_A:
4156 case OPC1_16_SRO_LD_BU:
4157 case OPC1_16_SRO_LD_H:
4158 case OPC1_16_SRO_LD_W:
4159 case OPC1_16_SRO_ST_A:
4160 case OPC1_16_SRO_ST_B:
4161 case OPC1_16_SRO_ST_H:
4162 case OPC1_16_SRO_ST_W:
4163 decode_sro_opc(ctx, op1);
4164 break;
4165 /* SSRO-format */
4166 case OPC1_16_SSRO_ST_A:
4167 r1 = MASK_OP_SSRO_S1(ctx->opcode);
4168 const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
4169 gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
4170 break;
4171 case OPC1_16_SSRO_ST_B:
4172 r1 = MASK_OP_SSRO_S1(ctx->opcode);
4173 const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
4174 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16, MO_UB);
4175 break;
4176 case OPC1_16_SSRO_ST_H:
4177 r1 = MASK_OP_SSRO_S1(ctx->opcode);
4178 const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
4179 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 2, MO_LESW);
4180 break;
4181 case OPC1_16_SSRO_ST_W:
4182 r1 = MASK_OP_SSRO_S1(ctx->opcode);
4183 const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
4184 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
4185 break;
4186 /* SR-format */
4187 case OPCM_16_SR_SYSTEM:
4188 decode_sr_system(ctx);
4189 break;
4190 case OPCM_16_SR_ACCU:
4191 decode_sr_accu(ctx);
4192 break;
4193 case OPC1_16_SR_JI:
4194 r1 = MASK_OP_SR_S1D(ctx->opcode);
4195 gen_compute_branch(ctx, op1, r1, 0, 0, 0);
4196 break;
4197 case OPC1_16_SR_NOT:
4198 r1 = MASK_OP_SR_S1D(ctx->opcode);
4199 tcg_gen_not_tl(cpu_gpr_d[r1], cpu_gpr_d[r1]);
4200 break;
4201 default:
4202 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4203 }
4204 }
4205
4206 /*
4207 * 32 bit instructions
4208 */
4209
4210 /* ABS-format */
4211 static void decode_abs_ldw(DisasContext *ctx)
4212 {
4213 int32_t op2;
4214 int32_t r1;
4215 uint32_t address;
4216 TCGv temp;
4217
4218 r1 = MASK_OP_ABS_S1D(ctx->opcode);
4219 address = MASK_OP_ABS_OFF18(ctx->opcode);
4220 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4221
4222 temp = tcg_const_i32(EA_ABS_FORMAT(address));
4223
4224 switch (op2) {
4225 case OPC2_32_ABS_LD_A:
4226 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LESL);
4227 break;
4228 case OPC2_32_ABS_LD_D:
4229 CHECK_REG_PAIR(r1);
4230 gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
4231 break;
4232 case OPC2_32_ABS_LD_DA:
4233 CHECK_REG_PAIR(r1);
4234 gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
4235 break;
4236 case OPC2_32_ABS_LD_W:
4237 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESL);
4238 break;
4239 default:
4240 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4241 }
4242
4243 tcg_temp_free(temp);
4244 }
4245
4246 static void decode_abs_ldb(DisasContext *ctx)
4247 {
4248 int32_t op2;
4249 int32_t r1;
4250 uint32_t address;
4251 TCGv temp;
4252
4253 r1 = MASK_OP_ABS_S1D(ctx->opcode);
4254 address = MASK_OP_ABS_OFF18(ctx->opcode);
4255 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4256
4257 temp = tcg_const_i32(EA_ABS_FORMAT(address));
4258
4259 switch (op2) {
4260 case OPC2_32_ABS_LD_B:
4261 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_SB);
4262 break;
4263 case OPC2_32_ABS_LD_BU:
4264 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_UB);
4265 break;
4266 case OPC2_32_ABS_LD_H:
4267 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESW);
4268 break;
4269 case OPC2_32_ABS_LD_HU:
4270 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
4271 break;
4272 default:
4273 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4274 }
4275
4276 tcg_temp_free(temp);
4277 }
4278
4279 static void decode_abs_ldst_swap(DisasContext *ctx)
4280 {
4281 int32_t op2;
4282 int32_t r1;
4283 uint32_t address;
4284 TCGv temp;
4285
4286 r1 = MASK_OP_ABS_S1D(ctx->opcode);
4287 address = MASK_OP_ABS_OFF18(ctx->opcode);
4288 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4289
4290 temp = tcg_const_i32(EA_ABS_FORMAT(address));
4291
4292 switch (op2) {
4293 case OPC2_32_ABS_LDMST:
4294 gen_ldmst(ctx, r1, temp);
4295 break;
4296 case OPC2_32_ABS_SWAP_W:
4297 gen_swap(ctx, r1, temp);
4298 break;
4299 default:
4300 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4301 }
4302
4303 tcg_temp_free(temp);
4304 }
4305
4306 static void decode_abs_ldst_context(DisasContext *ctx)
4307 {
4308 uint32_t op2;
4309 int32_t off18;
4310
4311 off18 = MASK_OP_ABS_OFF18(ctx->opcode);
4312 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4313
4314 switch (op2) {
4315 case OPC2_32_ABS_LDLCX:
4316 gen_helper_1arg(ldlcx, EA_ABS_FORMAT(off18));
4317 break;
4318 case OPC2_32_ABS_LDUCX:
4319 gen_helper_1arg(lducx, EA_ABS_FORMAT(off18));
4320 break;
4321 case OPC2_32_ABS_STLCX:
4322 gen_helper_1arg(stlcx, EA_ABS_FORMAT(off18));
4323 break;
4324 case OPC2_32_ABS_STUCX:
4325 gen_helper_1arg(stucx, EA_ABS_FORMAT(off18));
4326 break;
4327 default:
4328 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4329 }
4330 }
4331
4332 static void decode_abs_store(DisasContext *ctx)
4333 {
4334 int32_t op2;
4335 int32_t r1;
4336 uint32_t address;
4337 TCGv temp;
4338
4339 r1 = MASK_OP_ABS_S1D(ctx->opcode);
4340 address = MASK_OP_ABS_OFF18(ctx->opcode);
4341 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4342
4343 temp = tcg_const_i32(EA_ABS_FORMAT(address));
4344
4345 switch (op2) {
4346 case OPC2_32_ABS_ST_A:
4347 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LESL);
4348 break;
4349 case OPC2_32_ABS_ST_D:
4350 CHECK_REG_PAIR(r1);
4351 gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
4352 break;
4353 case OPC2_32_ABS_ST_DA:
4354 CHECK_REG_PAIR(r1);
4355 gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
4356 break;
4357 case OPC2_32_ABS_ST_W:
4358 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESL);
4359 break;
4360 default:
4361 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4362 }
4363 tcg_temp_free(temp);
4364 }
4365
4366 static void decode_abs_storeb_h(DisasContext *ctx)
4367 {
4368 int32_t op2;
4369 int32_t r1;
4370 uint32_t address;
4371 TCGv temp;
4372
4373 r1 = MASK_OP_ABS_S1D(ctx->opcode);
4374 address = MASK_OP_ABS_OFF18(ctx->opcode);
4375 op2 = MASK_OP_ABS_OP2(ctx->opcode);
4376
4377 temp = tcg_const_i32(EA_ABS_FORMAT(address));
4378
4379 switch (op2) {
4380 case OPC2_32_ABS_ST_B:
4381 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_UB);
4382 break;
4383 case OPC2_32_ABS_ST_H:
4384 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
4385 break;
4386 default:
4387 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4388 }
4389 tcg_temp_free(temp);
4390 }
4391
4392 /* Bit-format */
4393
4394 static void decode_bit_andacc(DisasContext *ctx)
4395 {
4396 uint32_t op2;
4397 int r1, r2, r3;
4398 int pos1, pos2;
4399
4400 r1 = MASK_OP_BIT_S1(ctx->opcode);
4401 r2 = MASK_OP_BIT_S2(ctx->opcode);
4402 r3 = MASK_OP_BIT_D(ctx->opcode);
4403 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4404 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4405 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4406
4407
4408 switch (op2) {
4409 case OPC2_32_BIT_AND_AND_T:
4410 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4411 pos1, pos2, &tcg_gen_and_tl, &tcg_gen_and_tl);
4412 break;
4413 case OPC2_32_BIT_AND_ANDN_T:
4414 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4415 pos1, pos2, &tcg_gen_andc_tl, &tcg_gen_and_tl);
4416 break;
4417 case OPC2_32_BIT_AND_NOR_T:
4418 if (TCG_TARGET_HAS_andc_i32) {
4419 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4420 pos1, pos2, &tcg_gen_or_tl, &tcg_gen_andc_tl);
4421 } else {
4422 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4423 pos1, pos2, &tcg_gen_nor_tl, &tcg_gen_and_tl);
4424 }
4425 break;
4426 case OPC2_32_BIT_AND_OR_T:
4427 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4428 pos1, pos2, &tcg_gen_or_tl, &tcg_gen_and_tl);
4429 break;
4430 default:
4431 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4432 }
4433 }
4434
4435 static void decode_bit_logical_t(DisasContext *ctx)
4436 {
4437 uint32_t op2;
4438 int r1, r2, r3;
4439 int pos1, pos2;
4440 r1 = MASK_OP_BIT_S1(ctx->opcode);
4441 r2 = MASK_OP_BIT_S2(ctx->opcode);
4442 r3 = MASK_OP_BIT_D(ctx->opcode);
4443 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4444 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4445 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4446
4447 switch (op2) {
4448 case OPC2_32_BIT_AND_T:
4449 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4450 pos1, pos2, &tcg_gen_and_tl);
4451 break;
4452 case OPC2_32_BIT_ANDN_T:
4453 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4454 pos1, pos2, &tcg_gen_andc_tl);
4455 break;
4456 case OPC2_32_BIT_NOR_T:
4457 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4458 pos1, pos2, &tcg_gen_nor_tl);
4459 break;
4460 case OPC2_32_BIT_OR_T:
4461 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4462 pos1, pos2, &tcg_gen_or_tl);
4463 break;
4464 default:
4465 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4466 }
4467 }
4468
4469 static void decode_bit_insert(DisasContext *ctx)
4470 {
4471 uint32_t op2;
4472 int r1, r2, r3;
4473 int pos1, pos2;
4474 TCGv temp;
4475 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4476 r1 = MASK_OP_BIT_S1(ctx->opcode);
4477 r2 = MASK_OP_BIT_S2(ctx->opcode);
4478 r3 = MASK_OP_BIT_D(ctx->opcode);
4479 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4480 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4481
4482 temp = tcg_temp_new();
4483
4484 tcg_gen_shri_tl(temp, cpu_gpr_d[r2], pos2);
4485 if (op2 == OPC2_32_BIT_INSN_T) {
4486 tcg_gen_not_tl(temp, temp);
4487 }
4488 tcg_gen_deposit_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], temp, pos1, 1);
4489 tcg_temp_free(temp);
4490 }
4491
4492 static void decode_bit_logical_t2(DisasContext *ctx)
4493 {
4494 uint32_t op2;
4495
4496 int r1, r2, r3;
4497 int pos1, pos2;
4498
4499 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4500 r1 = MASK_OP_BIT_S1(ctx->opcode);
4501 r2 = MASK_OP_BIT_S2(ctx->opcode);
4502 r3 = MASK_OP_BIT_D(ctx->opcode);
4503 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4504 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4505
4506 switch (op2) {
4507 case OPC2_32_BIT_NAND_T:
4508 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4509 pos1, pos2, &tcg_gen_nand_tl);
4510 break;
4511 case OPC2_32_BIT_ORN_T:
4512 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4513 pos1, pos2, &tcg_gen_orc_tl);
4514 break;
4515 case OPC2_32_BIT_XNOR_T:
4516 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4517 pos1, pos2, &tcg_gen_eqv_tl);
4518 break;
4519 case OPC2_32_BIT_XOR_T:
4520 gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4521 pos1, pos2, &tcg_gen_xor_tl);
4522 break;
4523 default:
4524 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4525 }
4526 }
4527
4528 static void decode_bit_orand(DisasContext *ctx)
4529 {
4530 uint32_t op2;
4531
4532 int r1, r2, r3;
4533 int pos1, pos2;
4534
4535 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4536 r1 = MASK_OP_BIT_S1(ctx->opcode);
4537 r2 = MASK_OP_BIT_S2(ctx->opcode);
4538 r3 = MASK_OP_BIT_D(ctx->opcode);
4539 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4540 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4541
4542 switch (op2) {
4543 case OPC2_32_BIT_OR_AND_T:
4544 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4545 pos1, pos2, &tcg_gen_and_tl, &tcg_gen_or_tl);
4546 break;
4547 case OPC2_32_BIT_OR_ANDN_T:
4548 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4549 pos1, pos2, &tcg_gen_andc_tl, &tcg_gen_or_tl);
4550 break;
4551 case OPC2_32_BIT_OR_NOR_T:
4552 if (TCG_TARGET_HAS_orc_i32) {
4553 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4554 pos1, pos2, &tcg_gen_or_tl, &tcg_gen_orc_tl);
4555 } else {
4556 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4557 pos1, pos2, &tcg_gen_nor_tl, &tcg_gen_or_tl);
4558 }
4559 break;
4560 case OPC2_32_BIT_OR_OR_T:
4561 gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
4562 pos1, pos2, &tcg_gen_or_tl, &tcg_gen_or_tl);
4563 break;
4564 default:
4565 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4566 }
4567 }
4568
4569 static void decode_bit_sh_logic1(DisasContext *ctx)
4570 {
4571 uint32_t op2;
4572 int r1, r2, r3;
4573 int pos1, pos2;
4574 TCGv temp;
4575
4576 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4577 r1 = MASK_OP_BIT_S1(ctx->opcode);
4578 r2 = MASK_OP_BIT_S2(ctx->opcode);
4579 r3 = MASK_OP_BIT_D(ctx->opcode);
4580 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4581 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4582
4583 temp = tcg_temp_new();
4584
4585 switch (op2) {
4586 case OPC2_32_BIT_SH_AND_T:
4587 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4588 pos1, pos2, &tcg_gen_and_tl);
4589 break;
4590 case OPC2_32_BIT_SH_ANDN_T:
4591 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4592 pos1, pos2, &tcg_gen_andc_tl);
4593 break;
4594 case OPC2_32_BIT_SH_NOR_T:
4595 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4596 pos1, pos2, &tcg_gen_nor_tl);
4597 break;
4598 case OPC2_32_BIT_SH_OR_T:
4599 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4600 pos1, pos2, &tcg_gen_or_tl);
4601 break;
4602 default:
4603 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4604 }
4605 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 1);
4606 tcg_gen_add_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
4607 tcg_temp_free(temp);
4608 }
4609
4610 static void decode_bit_sh_logic2(DisasContext *ctx)
4611 {
4612 uint32_t op2;
4613 int r1, r2, r3;
4614 int pos1, pos2;
4615 TCGv temp;
4616
4617 op2 = MASK_OP_BIT_OP2(ctx->opcode);
4618 r1 = MASK_OP_BIT_S1(ctx->opcode);
4619 r2 = MASK_OP_BIT_S2(ctx->opcode);
4620 r3 = MASK_OP_BIT_D(ctx->opcode);
4621 pos1 = MASK_OP_BIT_POS1(ctx->opcode);
4622 pos2 = MASK_OP_BIT_POS2(ctx->opcode);
4623
4624 temp = tcg_temp_new();
4625
4626 switch (op2) {
4627 case OPC2_32_BIT_SH_NAND_T:
4628 gen_bit_1op(temp, cpu_gpr_d[r1] , cpu_gpr_d[r2] ,
4629 pos1, pos2, &tcg_gen_nand_tl);
4630 break;
4631 case OPC2_32_BIT_SH_ORN_T:
4632 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4633 pos1, pos2, &tcg_gen_orc_tl);
4634 break;
4635 case OPC2_32_BIT_SH_XNOR_T:
4636 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4637 pos1, pos2, &tcg_gen_eqv_tl);
4638 break;
4639 case OPC2_32_BIT_SH_XOR_T:
4640 gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
4641 pos1, pos2, &tcg_gen_xor_tl);
4642 break;
4643 default:
4644 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4645 }
4646 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 1);
4647 tcg_gen_add_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
4648 tcg_temp_free(temp);
4649 }
4650
4651 /* BO-format */
4652
4653
4654 static void decode_bo_addrmode_post_pre_base(DisasContext *ctx)
4655 {
4656 uint32_t op2;
4657 uint32_t off10;
4658 int32_t r1, r2;
4659 TCGv temp;
4660
4661 r1 = MASK_OP_BO_S1D(ctx->opcode);
4662 r2 = MASK_OP_BO_S2(ctx->opcode);
4663 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
4664 op2 = MASK_OP_BO_OP2(ctx->opcode);
4665
4666 switch (op2) {
4667 case OPC2_32_BO_CACHEA_WI_SHORTOFF:
4668 case OPC2_32_BO_CACHEA_W_SHORTOFF:
4669 case OPC2_32_BO_CACHEA_I_SHORTOFF:
4670 /* instruction to access the cache */
4671 break;
4672 case OPC2_32_BO_CACHEA_WI_POSTINC:
4673 case OPC2_32_BO_CACHEA_W_POSTINC:
4674 case OPC2_32_BO_CACHEA_I_POSTINC:
4675 /* instruction to access the cache, but we still need to handle
4676 the addressing mode */
4677 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4678 break;
4679 case OPC2_32_BO_CACHEA_WI_PREINC:
4680 case OPC2_32_BO_CACHEA_W_PREINC:
4681 case OPC2_32_BO_CACHEA_I_PREINC:
4682 /* instruction to access the cache, but we still need to handle
4683 the addressing mode */
4684 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4685 break;
4686 case OPC2_32_BO_CACHEI_WI_SHORTOFF:
4687 case OPC2_32_BO_CACHEI_W_SHORTOFF:
4688 if (!has_feature(ctx, TRICORE_FEATURE_131)) {
4689 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4690 }
4691 break;
4692 case OPC2_32_BO_CACHEI_W_POSTINC:
4693 case OPC2_32_BO_CACHEI_WI_POSTINC:
4694 if (has_feature(ctx, TRICORE_FEATURE_131)) {
4695 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4696 } else {
4697 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4698 }
4699 break;
4700 case OPC2_32_BO_CACHEI_W_PREINC:
4701 case OPC2_32_BO_CACHEI_WI_PREINC:
4702 if (has_feature(ctx, TRICORE_FEATURE_131)) {
4703 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4704 } else {
4705 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4706 }
4707 break;
4708 case OPC2_32_BO_ST_A_SHORTOFF:
4709 gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
4710 break;
4711 case OPC2_32_BO_ST_A_POSTINC:
4712 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
4713 MO_LESL);
4714 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4715 break;
4716 case OPC2_32_BO_ST_A_PREINC:
4717 gen_st_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
4718 break;
4719 case OPC2_32_BO_ST_B_SHORTOFF:
4720 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
4721 break;
4722 case OPC2_32_BO_ST_B_POSTINC:
4723 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
4724 MO_UB);
4725 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4726 break;
4727 case OPC2_32_BO_ST_B_PREINC:
4728 gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
4729 break;
4730 case OPC2_32_BO_ST_D_SHORTOFF:
4731 CHECK_REG_PAIR(r1);
4732 gen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
4733 off10, ctx);
4734 break;
4735 case OPC2_32_BO_ST_D_POSTINC:
4736 CHECK_REG_PAIR(r1);
4737 gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
4738 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4739 break;
4740 case OPC2_32_BO_ST_D_PREINC:
4741 CHECK_REG_PAIR(r1);
4742 temp = tcg_temp_new();
4743 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
4744 gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
4745 tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
4746 tcg_temp_free(temp);
4747 break;
4748 case OPC2_32_BO_ST_DA_SHORTOFF:
4749 CHECK_REG_PAIR(r1);
4750 gen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
4751 off10, ctx);
4752 break;
4753 case OPC2_32_BO_ST_DA_POSTINC:
4754 CHECK_REG_PAIR(r1);
4755 gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
4756 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4757 break;
4758 case OPC2_32_BO_ST_DA_PREINC:
4759 CHECK_REG_PAIR(r1);
4760 temp = tcg_temp_new();
4761 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
4762 gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
4763 tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
4764 tcg_temp_free(temp);
4765 break;
4766 case OPC2_32_BO_ST_H_SHORTOFF:
4767 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
4768 break;
4769 case OPC2_32_BO_ST_H_POSTINC:
4770 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
4771 MO_LEUW);
4772 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4773 break;
4774 case OPC2_32_BO_ST_H_PREINC:
4775 gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
4776 break;
4777 case OPC2_32_BO_ST_Q_SHORTOFF:
4778 temp = tcg_temp_new();
4779 tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
4780 gen_offset_st(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
4781 tcg_temp_free(temp);
4782 break;
4783 case OPC2_32_BO_ST_Q_POSTINC:
4784 temp = tcg_temp_new();
4785 tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
4786 tcg_gen_qemu_st_tl(temp, cpu_gpr_a[r2], ctx->mem_idx,
4787 MO_LEUW);
4788 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4789 tcg_temp_free(temp);
4790 break;
4791 case OPC2_32_BO_ST_Q_PREINC:
4792 temp = tcg_temp_new();
4793 tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
4794 gen_st_preincr(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
4795 tcg_temp_free(temp);
4796 break;
4797 case OPC2_32_BO_ST_W_SHORTOFF:
4798 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
4799 break;
4800 case OPC2_32_BO_ST_W_POSTINC:
4801 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
4802 MO_LEUL);
4803 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4804 break;
4805 case OPC2_32_BO_ST_W_PREINC:
4806 gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
4807 break;
4808 default:
4809 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4810 }
4811 }
4812
4813 static void decode_bo_addrmode_bitreverse_circular(DisasContext *ctx)
4814 {
4815 uint32_t op2;
4816 uint32_t off10;
4817 int32_t r1, r2;
4818 TCGv temp, temp2, temp3;
4819
4820 r1 = MASK_OP_BO_S1D(ctx->opcode);
4821 r2 = MASK_OP_BO_S2(ctx->opcode);
4822 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
4823 op2 = MASK_OP_BO_OP2(ctx->opcode);
4824
4825 temp = tcg_temp_new();
4826 temp2 = tcg_temp_new();
4827 temp3 = tcg_const_i32(off10);
4828 CHECK_REG_PAIR(r2);
4829 tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
4830 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
4831
4832 switch (op2) {
4833 case OPC2_32_BO_CACHEA_WI_BR:
4834 case OPC2_32_BO_CACHEA_W_BR:
4835 case OPC2_32_BO_CACHEA_I_BR:
4836 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4837 break;
4838 case OPC2_32_BO_CACHEA_WI_CIRC:
4839 case OPC2_32_BO_CACHEA_W_CIRC:
4840 case OPC2_32_BO_CACHEA_I_CIRC:
4841 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4842 break;
4843 case OPC2_32_BO_ST_A_BR:
4844 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
4845 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4846 break;
4847 case OPC2_32_BO_ST_A_CIRC:
4848 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
4849 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4850 break;
4851 case OPC2_32_BO_ST_B_BR:
4852 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
4853 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4854 break;
4855 case OPC2_32_BO_ST_B_CIRC:
4856 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
4857 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4858 break;
4859 case OPC2_32_BO_ST_D_BR:
4860 CHECK_REG_PAIR(r1);
4861 gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp2, ctx);
4862 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4863 break;
4864 case OPC2_32_BO_ST_D_CIRC:
4865 CHECK_REG_PAIR(r1);
4866 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
4867 tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
4868 tcg_gen_addi_tl(temp, temp, 4);
4869 tcg_gen_rem_tl(temp, temp, temp2);
4870 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
4871 tcg_gen_qemu_st_tl(cpu_gpr_d[r1+1], temp2, ctx->mem_idx, MO_LEUL);
4872 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4873 break;
4874 case OPC2_32_BO_ST_DA_BR:
4875 CHECK_REG_PAIR(r1);
4876 gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp2, ctx);
4877 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4878 break;
4879 case OPC2_32_BO_ST_DA_CIRC:
4880 CHECK_REG_PAIR(r1);
4881 tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
4882 tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
4883 tcg_gen_addi_tl(temp, temp, 4);
4884 tcg_gen_rem_tl(temp, temp, temp2);
4885 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
4886 tcg_gen_qemu_st_tl(cpu_gpr_a[r1+1], temp2, ctx->mem_idx, MO_LEUL);
4887 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4888 break;
4889 case OPC2_32_BO_ST_H_BR:
4890 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
4891 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4892 break;
4893 case OPC2_32_BO_ST_H_CIRC:
4894 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
4895 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4896 break;
4897 case OPC2_32_BO_ST_Q_BR:
4898 tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
4899 tcg_gen_qemu_st_tl(temp, temp2, ctx->mem_idx, MO_LEUW);
4900 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4901 break;
4902 case OPC2_32_BO_ST_Q_CIRC:
4903 tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
4904 tcg_gen_qemu_st_tl(temp, temp2, ctx->mem_idx, MO_LEUW);
4905 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4906 break;
4907 case OPC2_32_BO_ST_W_BR:
4908 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
4909 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
4910 break;
4911 case OPC2_32_BO_ST_W_CIRC:
4912 tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
4913 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
4914 break;
4915 default:
4916 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
4917 }
4918 tcg_temp_free(temp);
4919 tcg_temp_free(temp2);
4920 tcg_temp_free(temp3);
4921 }
4922
4923 static void decode_bo_addrmode_ld_post_pre_base(DisasContext *ctx)
4924 {
4925 uint32_t op2;
4926 uint32_t off10;
4927 int32_t r1, r2;
4928 TCGv temp;
4929
4930 r1 = MASK_OP_BO_S1D(ctx->opcode);
4931 r2 = MASK_OP_BO_S2(ctx->opcode);
4932 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
4933 op2 = MASK_OP_BO_OP2(ctx->opcode);
4934
4935 switch (op2) {
4936 case OPC2_32_BO_LD_A_SHORTOFF:
4937 gen_offset_ld(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LEUL);
4938 break;
4939 case OPC2_32_BO_LD_A_POSTINC:
4940 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
4941 MO_LEUL);
4942 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4943 break;
4944 case OPC2_32_BO_LD_A_PREINC:
4945 gen_ld_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LEUL);
4946 break;
4947 case OPC2_32_BO_LD_B_SHORTOFF:
4948 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
4949 break;
4950 case OPC2_32_BO_LD_B_POSTINC:
4951 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
4952 MO_SB);
4953 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4954 break;
4955 case OPC2_32_BO_LD_B_PREINC:
4956 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
4957 break;
4958 case OPC2_32_BO_LD_BU_SHORTOFF:
4959 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
4960 break;
4961 case OPC2_32_BO_LD_BU_POSTINC:
4962 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
4963 MO_UB);
4964 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4965 break;
4966 case OPC2_32_BO_LD_BU_PREINC:
4967 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
4968 break;
4969 case OPC2_32_BO_LD_D_SHORTOFF:
4970 CHECK_REG_PAIR(r1);
4971 gen_offset_ld_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
4972 off10, ctx);
4973 break;
4974 case OPC2_32_BO_LD_D_POSTINC:
4975 CHECK_REG_PAIR(r1);
4976 gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
4977 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4978 break;
4979 case OPC2_32_BO_LD_D_PREINC:
4980 CHECK_REG_PAIR(r1);
4981 temp = tcg_temp_new();
4982 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
4983 gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
4984 tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
4985 tcg_temp_free(temp);
4986 break;
4987 case OPC2_32_BO_LD_DA_SHORTOFF:
4988 CHECK_REG_PAIR(r1);
4989 gen_offset_ld_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
4990 off10, ctx);
4991 break;
4992 case OPC2_32_BO_LD_DA_POSTINC:
4993 CHECK_REG_PAIR(r1);
4994 gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
4995 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
4996 break;
4997 case OPC2_32_BO_LD_DA_PREINC:
4998 CHECK_REG_PAIR(r1);
4999 temp = tcg_temp_new();
5000 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5001 gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
5002 tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
5003 tcg_temp_free(temp);
5004 break;
5005 case OPC2_32_BO_LD_H_SHORTOFF:
5006 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LESW);
5007 break;
5008 case OPC2_32_BO_LD_H_POSTINC:
5009 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
5010 MO_LESW);
5011 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5012 break;
5013 case OPC2_32_BO_LD_H_PREINC:
5014 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LESW);
5015 break;
5016 case OPC2_32_BO_LD_HU_SHORTOFF:
5017 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
5018 break;
5019 case OPC2_32_BO_LD_HU_POSTINC:
5020 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
5021 MO_LEUW);
5022 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5023 break;
5024 case OPC2_32_BO_LD_HU_PREINC:
5025 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
5026 break;
5027 case OPC2_32_BO_LD_Q_SHORTOFF:
5028 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
5029 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5030 break;
5031 case OPC2_32_BO_LD_Q_POSTINC:
5032 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
5033 MO_LEUW);
5034 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5035 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5036 break;
5037 case OPC2_32_BO_LD_Q_PREINC:
5038 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
5039 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5040 break;
5041 case OPC2_32_BO_LD_W_SHORTOFF:
5042 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
5043 break;
5044 case OPC2_32_BO_LD_W_POSTINC:
5045 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
5046 MO_LEUL);
5047 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5048 break;
5049 case OPC2_32_BO_LD_W_PREINC:
5050 gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
5051 break;
5052 default:
5053 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5054 }
5055 }
5056
5057 static void decode_bo_addrmode_ld_bitreverse_circular(DisasContext *ctx)
5058 {
5059 uint32_t op2;
5060 uint32_t off10;
5061 int r1, r2;
5062
5063 TCGv temp, temp2, temp3;
5064
5065 r1 = MASK_OP_BO_S1D(ctx->opcode);
5066 r2 = MASK_OP_BO_S2(ctx->opcode);
5067 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
5068 op2 = MASK_OP_BO_OP2(ctx->opcode);
5069
5070 temp = tcg_temp_new();
5071 temp2 = tcg_temp_new();
5072 temp3 = tcg_const_i32(off10);
5073 CHECK_REG_PAIR(r2);
5074 tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
5075 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
5076
5077
5078 switch (op2) {
5079 case OPC2_32_BO_LD_A_BR:
5080 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
5081 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5082 break;
5083 case OPC2_32_BO_LD_A_CIRC:
5084 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
5085 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5086 break;
5087 case OPC2_32_BO_LD_B_BR:
5088 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_SB);
5089 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5090 break;
5091 case OPC2_32_BO_LD_B_CIRC:
5092 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_SB);
5093 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5094 break;
5095 case OPC2_32_BO_LD_BU_BR:
5096 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
5097 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5098 break;
5099 case OPC2_32_BO_LD_BU_CIRC:
5100 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
5101 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5102 break;
5103 case OPC2_32_BO_LD_D_BR:
5104 CHECK_REG_PAIR(r1);
5105 gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp2, ctx);
5106 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5107 break;
5108 case OPC2_32_BO_LD_D_CIRC:
5109 CHECK_REG_PAIR(r1);
5110 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
5111 tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
5112 tcg_gen_addi_tl(temp, temp, 4);
5113 tcg_gen_rem_tl(temp, temp, temp2);
5114 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
5115 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1+1], temp2, ctx->mem_idx, MO_LEUL);
5116 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5117 break;
5118 case OPC2_32_BO_LD_DA_BR:
5119 CHECK_REG_PAIR(r1);
5120 gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp2, ctx);
5121 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5122 break;
5123 case OPC2_32_BO_LD_DA_CIRC:
5124 CHECK_REG_PAIR(r1);
5125 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
5126 tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
5127 tcg_gen_addi_tl(temp, temp, 4);
5128 tcg_gen_rem_tl(temp, temp, temp2);
5129 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
5130 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1+1], temp2, ctx->mem_idx, MO_LEUL);
5131 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5132 break;
5133 case OPC2_32_BO_LD_H_BR:
5134 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LESW);
5135 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5136 break;
5137 case OPC2_32_BO_LD_H_CIRC:
5138 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LESW);
5139 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5140 break;
5141 case OPC2_32_BO_LD_HU_BR:
5142 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
5143 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5144 break;
5145 case OPC2_32_BO_LD_HU_CIRC:
5146 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
5147 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5148 break;
5149 case OPC2_32_BO_LD_Q_BR:
5150 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
5151 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5152 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5153 break;
5154 case OPC2_32_BO_LD_Q_CIRC:
5155 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
5156 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5157 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5158 break;
5159 case OPC2_32_BO_LD_W_BR:
5160 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
5161 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5162 break;
5163 case OPC2_32_BO_LD_W_CIRC:
5164 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
5165 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5166 break;
5167 default:
5168 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5169 }
5170 tcg_temp_free(temp);
5171 tcg_temp_free(temp2);
5172 tcg_temp_free(temp3);
5173 }
5174
5175 static void decode_bo_addrmode_stctx_post_pre_base(DisasContext *ctx)
5176 {
5177 uint32_t op2;
5178 uint32_t off10;
5179 int r1, r2;
5180
5181 TCGv temp, temp2;
5182
5183 r1 = MASK_OP_BO_S1D(ctx->opcode);
5184 r2 = MASK_OP_BO_S2(ctx->opcode);
5185 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
5186 op2 = MASK_OP_BO_OP2(ctx->opcode);
5187
5188
5189 temp = tcg_temp_new();
5190 temp2 = tcg_temp_new();
5191
5192 switch (op2) {
5193 case OPC2_32_BO_LDLCX_SHORTOFF:
5194 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5195 gen_helper_ldlcx(cpu_env, temp);
5196 break;
5197 case OPC2_32_BO_LDMST_SHORTOFF:
5198 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5199 gen_ldmst(ctx, r1, temp);
5200 break;
5201 case OPC2_32_BO_LDMST_POSTINC:
5202 gen_ldmst(ctx, r1, cpu_gpr_a[r2]);
5203 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5204 break;
5205 case OPC2_32_BO_LDMST_PREINC:
5206 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5207 gen_ldmst(ctx, r1, cpu_gpr_a[r2]);
5208 break;
5209 case OPC2_32_BO_LDUCX_SHORTOFF:
5210 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5211 gen_helper_lducx(cpu_env, temp);
5212 break;
5213 case OPC2_32_BO_LEA_SHORTOFF:
5214 tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], off10);
5215 break;
5216 case OPC2_32_BO_STLCX_SHORTOFF:
5217 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5218 gen_helper_stlcx(cpu_env, temp);
5219 break;
5220 case OPC2_32_BO_STUCX_SHORTOFF:
5221 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5222 gen_helper_stucx(cpu_env, temp);
5223 break;
5224 case OPC2_32_BO_SWAP_W_SHORTOFF:
5225 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5226 gen_swap(ctx, r1, temp);
5227 break;
5228 case OPC2_32_BO_SWAP_W_POSTINC:
5229 gen_swap(ctx, r1, cpu_gpr_a[r2]);
5230 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5231 break;
5232 case OPC2_32_BO_SWAP_W_PREINC:
5233 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5234 gen_swap(ctx, r1, cpu_gpr_a[r2]);
5235 break;
5236 case OPC2_32_BO_CMPSWAP_W_SHORTOFF:
5237 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5238 gen_cmpswap(ctx, r1, temp);
5239 break;
5240 case OPC2_32_BO_CMPSWAP_W_POSTINC:
5241 gen_cmpswap(ctx, r1, cpu_gpr_a[r2]);
5242 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5243 break;
5244 case OPC2_32_BO_CMPSWAP_W_PREINC:
5245 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5246 gen_cmpswap(ctx, r1, cpu_gpr_a[r2]);
5247 break;
5248 case OPC2_32_BO_SWAPMSK_W_SHORTOFF:
5249 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
5250 gen_swapmsk(ctx, r1, temp);
5251 break;
5252 case OPC2_32_BO_SWAPMSK_W_POSTINC:
5253 gen_swapmsk(ctx, r1, cpu_gpr_a[r2]);
5254 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5255 break;
5256 case OPC2_32_BO_SWAPMSK_W_PREINC:
5257 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
5258 gen_swapmsk(ctx, r1, cpu_gpr_a[r2]);
5259 break;
5260 default:
5261 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5262 }
5263 tcg_temp_free(temp);
5264 tcg_temp_free(temp2);
5265 }
5266
5267 static void decode_bo_addrmode_ldmst_bitreverse_circular(DisasContext *ctx)
5268 {
5269 uint32_t op2;
5270 uint32_t off10;
5271 int r1, r2;
5272
5273 TCGv temp, temp2, temp3;
5274
5275 r1 = MASK_OP_BO_S1D(ctx->opcode);
5276 r2 = MASK_OP_BO_S2(ctx->opcode);
5277 off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
5278 op2 = MASK_OP_BO_OP2(ctx->opcode);
5279
5280 temp = tcg_temp_new();
5281 temp2 = tcg_temp_new();
5282 temp3 = tcg_const_i32(off10);
5283 CHECK_REG_PAIR(r2);
5284 tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
5285 tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
5286
5287 switch (op2) {
5288 case OPC2_32_BO_LDMST_BR:
5289 gen_ldmst(ctx, r1, temp2);
5290 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5291 break;
5292 case OPC2_32_BO_LDMST_CIRC:
5293 gen_ldmst(ctx, r1, temp2);
5294 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5295 break;
5296 case OPC2_32_BO_SWAP_W_BR:
5297 gen_swap(ctx, r1, temp2);
5298 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5299 break;
5300 case OPC2_32_BO_SWAP_W_CIRC:
5301 gen_swap(ctx, r1, temp2);
5302 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5303 break;
5304 case OPC2_32_BO_CMPSWAP_W_BR:
5305 gen_cmpswap(ctx, r1, temp2);
5306 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5307 break;
5308 case OPC2_32_BO_CMPSWAP_W_CIRC:
5309 gen_cmpswap(ctx, r1, temp2);
5310 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5311 break;
5312 case OPC2_32_BO_SWAPMSK_W_BR:
5313 gen_swapmsk(ctx, r1, temp2);
5314 gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
5315 break;
5316 case OPC2_32_BO_SWAPMSK_W_CIRC:
5317 gen_swapmsk(ctx, r1, temp2);
5318 gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
5319 break;
5320 default:
5321 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5322 }
5323
5324 tcg_temp_free(temp);
5325 tcg_temp_free(temp2);
5326 tcg_temp_free(temp3);
5327 }
5328
5329 static void decode_bol_opc(DisasContext *ctx, int32_t op1)
5330 {
5331 int r1, r2;
5332 int32_t address;
5333 TCGv temp;
5334
5335 r1 = MASK_OP_BOL_S1D(ctx->opcode);
5336 r2 = MASK_OP_BOL_S2(ctx->opcode);
5337 address = MASK_OP_BOL_OFF16_SEXT(ctx->opcode);
5338
5339 switch (op1) {
5340 case OPC1_32_BOL_LD_A_LONGOFF:
5341 temp = tcg_temp_new();
5342 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], address);
5343 tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LEUL);
5344 tcg_temp_free(temp);
5345 break;
5346 case OPC1_32_BOL_LD_W_LONGOFF:
5347 temp = tcg_temp_new();
5348 tcg_gen_addi_tl(temp, cpu_gpr_a[r2], address);
5349 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUL);
5350 tcg_temp_free(temp);
5351 break;
5352 case OPC1_32_BOL_LEA_LONGOFF:
5353 tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], address);
5354 break;
5355 case OPC1_32_BOL_ST_A_LONGOFF:
5356 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5357 gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], address, MO_LEUL);
5358 } else {
5359 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5360 }
5361 break;
5362 case OPC1_32_BOL_ST_W_LONGOFF:
5363 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LEUL);
5364 break;
5365 case OPC1_32_BOL_LD_B_LONGOFF:
5366 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5367 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_SB);
5368 } else {
5369 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5370 }
5371 break;
5372 case OPC1_32_BOL_LD_BU_LONGOFF:
5373 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5374 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_UB);
5375 } else {
5376 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5377 }
5378 break;
5379 case OPC1_32_BOL_LD_H_LONGOFF:
5380 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5381 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LESW);
5382 } else {
5383 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5384 }
5385 break;
5386 case OPC1_32_BOL_LD_HU_LONGOFF:
5387 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5388 gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LEUW);
5389 } else {
5390 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5391 }
5392 break;
5393 case OPC1_32_BOL_ST_B_LONGOFF:
5394 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5395 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_SB);
5396 } else {
5397 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5398 }
5399 break;
5400 case OPC1_32_BOL_ST_H_LONGOFF:
5401 if (has_feature(ctx, TRICORE_FEATURE_16)) {
5402 gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LESW);
5403 } else {
5404 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5405 }
5406 break;
5407 default:
5408 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5409 }
5410 }
5411
5412 /* RC format */
5413 static void decode_rc_logical_shift(DisasContext *ctx)
5414 {
5415 uint32_t op2;
5416 int r1, r2;
5417 int32_t const9;
5418 TCGv temp;
5419
5420 r2 = MASK_OP_RC_D(ctx->opcode);
5421 r1 = MASK_OP_RC_S1(ctx->opcode);
5422 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5423 op2 = MASK_OP_RC_OP2(ctx->opcode);
5424
5425 temp = tcg_temp_new();
5426
5427 switch (op2) {
5428 case OPC2_32_RC_AND:
5429 tcg_gen_andi_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5430 break;
5431 case OPC2_32_RC_ANDN:
5432 tcg_gen_andi_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], ~const9);
5433 break;
5434 case OPC2_32_RC_NAND:
5435 tcg_gen_movi_tl(temp, const9);
5436 tcg_gen_nand_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp);
5437 break;
5438 case OPC2_32_RC_NOR:
5439 tcg_gen_movi_tl(temp, const9);
5440 tcg_gen_nor_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp);
5441 break;
5442 case OPC2_32_RC_OR:
5443 tcg_gen_ori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5444 break;
5445 case OPC2_32_RC_ORN:
5446 tcg_gen_ori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], ~const9);
5447 break;
5448 case OPC2_32_RC_SH:
5449 const9 = sextract32(const9, 0, 6);
5450 gen_shi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5451 break;
5452 case OPC2_32_RC_SH_H:
5453 const9 = sextract32(const9, 0, 5);
5454 gen_sh_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5455 break;
5456 case OPC2_32_RC_SHA:
5457 const9 = sextract32(const9, 0, 6);
5458 gen_shaci(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5459 break;
5460 case OPC2_32_RC_SHA_H:
5461 const9 = sextract32(const9, 0, 5);
5462 gen_sha_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5463 break;
5464 case OPC2_32_RC_SHAS:
5465 gen_shasi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5466 break;
5467 case OPC2_32_RC_XNOR:
5468 tcg_gen_xori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5469 tcg_gen_not_tl(cpu_gpr_d[r2], cpu_gpr_d[r2]);
5470 break;
5471 case OPC2_32_RC_XOR:
5472 tcg_gen_xori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5473 break;
5474 default:
5475 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5476 }
5477 tcg_temp_free(temp);
5478 }
5479
5480 static void decode_rc_accumulator(DisasContext *ctx)
5481 {
5482 uint32_t op2;
5483 int r1, r2;
5484 int16_t const9;
5485
5486 TCGv temp;
5487
5488 r2 = MASK_OP_RC_D(ctx->opcode);
5489 r1 = MASK_OP_RC_S1(ctx->opcode);
5490 const9 = MASK_OP_RC_CONST9_SEXT(ctx->opcode);
5491
5492 op2 = MASK_OP_RC_OP2(ctx->opcode);
5493
5494 temp = tcg_temp_new();
5495
5496 switch (op2) {
5497 case OPC2_32_RC_ABSDIF:
5498 gen_absdifi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5499 break;
5500 case OPC2_32_RC_ABSDIFS:
5501 gen_absdifsi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5502 break;
5503 case OPC2_32_RC_ADD:
5504 gen_addi_d(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5505 break;
5506 case OPC2_32_RC_ADDC:
5507 gen_addci_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5508 break;
5509 case OPC2_32_RC_ADDS:
5510 gen_addsi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5511 break;
5512 case OPC2_32_RC_ADDS_U:
5513 gen_addsui(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5514 break;
5515 case OPC2_32_RC_ADDX:
5516 gen_addi_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5517 break;
5518 case OPC2_32_RC_AND_EQ:
5519 gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
5520 const9, &tcg_gen_and_tl);
5521 break;
5522 case OPC2_32_RC_AND_GE:
5523 gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5524 const9, &tcg_gen_and_tl);
5525 break;
5526 case OPC2_32_RC_AND_GE_U:
5527 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5528 gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5529 const9, &tcg_gen_and_tl);
5530 break;
5531 case OPC2_32_RC_AND_LT:
5532 gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
5533 const9, &tcg_gen_and_tl);
5534 break;
5535 case OPC2_32_RC_AND_LT_U:
5536 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5537 gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5538 const9, &tcg_gen_and_tl);
5539 break;
5540 case OPC2_32_RC_AND_NE:
5541 gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5542 const9, &tcg_gen_and_tl);
5543 break;
5544 case OPC2_32_RC_EQ:
5545 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5546 break;
5547 case OPC2_32_RC_EQANY_B:
5548 gen_eqany_bi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5549 break;
5550 case OPC2_32_RC_EQANY_H:
5551 gen_eqany_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5552 break;
5553 case OPC2_32_RC_GE:
5554 tcg_gen_setcondi_tl(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5555 break;
5556 case OPC2_32_RC_GE_U:
5557 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5558 tcg_gen_setcondi_tl(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5559 break;
5560 case OPC2_32_RC_LT:
5561 tcg_gen_setcondi_tl(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5562 break;
5563 case OPC2_32_RC_LT_U:
5564 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5565 tcg_gen_setcondi_tl(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5566 break;
5567 case OPC2_32_RC_MAX:
5568 tcg_gen_movi_tl(temp, const9);
5569 tcg_gen_movcond_tl(TCG_COND_GT, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
5570 cpu_gpr_d[r1], temp);
5571 break;
5572 case OPC2_32_RC_MAX_U:
5573 tcg_gen_movi_tl(temp, MASK_OP_RC_CONST9(ctx->opcode));
5574 tcg_gen_movcond_tl(TCG_COND_GTU, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
5575 cpu_gpr_d[r1], temp);
5576 break;
5577 case OPC2_32_RC_MIN:
5578 tcg_gen_movi_tl(temp, const9);
5579 tcg_gen_movcond_tl(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
5580 cpu_gpr_d[r1], temp);
5581 break;
5582 case OPC2_32_RC_MIN_U:
5583 tcg_gen_movi_tl(temp, MASK_OP_RC_CONST9(ctx->opcode));
5584 tcg_gen_movcond_tl(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
5585 cpu_gpr_d[r1], temp);
5586 break;
5587 case OPC2_32_RC_NE:
5588 tcg_gen_setcondi_tl(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5589 break;
5590 case OPC2_32_RC_OR_EQ:
5591 gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
5592 const9, &tcg_gen_or_tl);
5593 break;
5594 case OPC2_32_RC_OR_GE:
5595 gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5596 const9, &tcg_gen_or_tl);
5597 break;
5598 case OPC2_32_RC_OR_GE_U:
5599 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5600 gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5601 const9, &tcg_gen_or_tl);
5602 break;
5603 case OPC2_32_RC_OR_LT:
5604 gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
5605 const9, &tcg_gen_or_tl);
5606 break;
5607 case OPC2_32_RC_OR_LT_U:
5608 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5609 gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5610 const9, &tcg_gen_or_tl);
5611 break;
5612 case OPC2_32_RC_OR_NE:
5613 gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5614 const9, &tcg_gen_or_tl);
5615 break;
5616 case OPC2_32_RC_RSUB:
5617 tcg_gen_movi_tl(temp, const9);
5618 gen_sub_d(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
5619 break;
5620 case OPC2_32_RC_RSUBS:
5621 tcg_gen_movi_tl(temp, const9);
5622 gen_subs(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
5623 break;
5624 case OPC2_32_RC_RSUBS_U:
5625 tcg_gen_movi_tl(temp, const9);
5626 gen_subsu(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
5627 break;
5628 case OPC2_32_RC_SH_EQ:
5629 gen_sh_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5630 break;
5631 case OPC2_32_RC_SH_GE:
5632 gen_sh_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5633 break;
5634 case OPC2_32_RC_SH_GE_U:
5635 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5636 gen_sh_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5637 break;
5638 case OPC2_32_RC_SH_LT:
5639 gen_sh_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5640 break;
5641 case OPC2_32_RC_SH_LT_U:
5642 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5643 gen_sh_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5644 break;
5645 case OPC2_32_RC_SH_NE:
5646 gen_sh_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5647 break;
5648 case OPC2_32_RC_XOR_EQ:
5649 gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
5650 const9, &tcg_gen_xor_tl);
5651 break;
5652 case OPC2_32_RC_XOR_GE:
5653 gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5654 const9, &tcg_gen_xor_tl);
5655 break;
5656 case OPC2_32_RC_XOR_GE_U:
5657 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5658 gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5659 const9, &tcg_gen_xor_tl);
5660 break;
5661 case OPC2_32_RC_XOR_LT:
5662 gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
5663 const9, &tcg_gen_xor_tl);
5664 break;
5665 case OPC2_32_RC_XOR_LT_U:
5666 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5667 gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
5668 const9, &tcg_gen_xor_tl);
5669 break;
5670 case OPC2_32_RC_XOR_NE:
5671 gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
5672 const9, &tcg_gen_xor_tl);
5673 break;
5674 default:
5675 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5676 }
5677 tcg_temp_free(temp);
5678 }
5679
5680 static void decode_rc_serviceroutine(DisasContext *ctx)
5681 {
5682 uint32_t op2;
5683 uint32_t const9;
5684
5685 op2 = MASK_OP_RC_OP2(ctx->opcode);
5686 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5687
5688 switch (op2) {
5689 case OPC2_32_RC_BISR:
5690 gen_helper_1arg(bisr, const9);
5691 break;
5692 case OPC2_32_RC_SYSCALL:
5693 /* TODO: Add exception generation */
5694 break;
5695 default:
5696 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5697 }
5698 }
5699
5700 static void decode_rc_mul(DisasContext *ctx)
5701 {
5702 uint32_t op2;
5703 int r1, r2;
5704 int16_t const9;
5705
5706 r2 = MASK_OP_RC_D(ctx->opcode);
5707 r1 = MASK_OP_RC_S1(ctx->opcode);
5708 const9 = MASK_OP_RC_CONST9_SEXT(ctx->opcode);
5709
5710 op2 = MASK_OP_RC_OP2(ctx->opcode);
5711
5712 switch (op2) {
5713 case OPC2_32_RC_MUL_32:
5714 gen_muli_i32s(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5715 break;
5716 case OPC2_32_RC_MUL_64:
5717 CHECK_REG_PAIR(r2);
5718 gen_muli_i64s(cpu_gpr_d[r2], cpu_gpr_d[r2+1], cpu_gpr_d[r1], const9);
5719 break;
5720 case OPC2_32_RC_MULS_32:
5721 gen_mulsi_i32(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5722 break;
5723 case OPC2_32_RC_MUL_U_64:
5724 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5725 CHECK_REG_PAIR(r2);
5726 gen_muli_i64u(cpu_gpr_d[r2], cpu_gpr_d[r2+1], cpu_gpr_d[r1], const9);
5727 break;
5728 case OPC2_32_RC_MULS_U_32:
5729 const9 = MASK_OP_RC_CONST9(ctx->opcode);
5730 gen_mulsui_i32(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
5731 break;
5732 default:
5733 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5734 }
5735 }
5736
5737 /* RCPW format */
5738 static void decode_rcpw_insert(DisasContext *ctx)
5739 {
5740 uint32_t op2;
5741 int r1, r2;
5742 int32_t pos, width, const4;
5743
5744 TCGv temp;
5745
5746 op2 = MASK_OP_RCPW_OP2(ctx->opcode);
5747 r1 = MASK_OP_RCPW_S1(ctx->opcode);
5748 r2 = MASK_OP_RCPW_D(ctx->opcode);
5749 const4 = MASK_OP_RCPW_CONST4(ctx->opcode);
5750 width = MASK_OP_RCPW_WIDTH(ctx->opcode);
5751 pos = MASK_OP_RCPW_POS(ctx->opcode);
5752
5753 switch (op2) {
5754 case OPC2_32_RCPW_IMASK:
5755 CHECK_REG_PAIR(r2);
5756 /* if pos + width > 32 undefined result */
5757 if (pos + width <= 32) {
5758 tcg_gen_movi_tl(cpu_gpr_d[r2+1], ((1u << width) - 1) << pos);
5759 tcg_gen_movi_tl(cpu_gpr_d[r2], (const4 << pos));
5760 }
5761 break;
5762 case OPC2_32_RCPW_INSERT:
5763 /* if pos + width > 32 undefined result */
5764 if (pos + width <= 32) {
5765 temp = tcg_const_i32(const4);
5766 tcg_gen_deposit_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp, pos, width);
5767 tcg_temp_free(temp);
5768 }
5769 break;
5770 default:
5771 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5772 }
5773 }
5774
5775 /* RCRW format */
5776
5777 static void decode_rcrw_insert(DisasContext *ctx)
5778 {
5779 uint32_t op2;
5780 int r1, r3, r4;
5781 int32_t width, const4;
5782
5783 TCGv temp, temp2, temp3;
5784
5785 op2 = MASK_OP_RCRW_OP2(ctx->opcode);
5786 r1 = MASK_OP_RCRW_S1(ctx->opcode);
5787 r3 = MASK_OP_RCRW_S3(ctx->opcode);
5788 r4 = MASK_OP_RCRW_D(ctx->opcode);
5789 width = MASK_OP_RCRW_WIDTH(ctx->opcode);
5790 const4 = MASK_OP_RCRW_CONST4(ctx->opcode);
5791
5792 temp = tcg_temp_new();
5793 temp2 = tcg_temp_new();
5794
5795 switch (op2) {
5796 case OPC2_32_RCRW_IMASK:
5797 tcg_gen_andi_tl(temp, cpu_gpr_d[r4], 0x1f);
5798 tcg_gen_movi_tl(temp2, (1 << width) - 1);
5799 tcg_gen_shl_tl(cpu_gpr_d[r3 + 1], temp2, temp);
5800 tcg_gen_movi_tl(temp2, const4);
5801 tcg_gen_shl_tl(cpu_gpr_d[r3], temp2, temp);
5802 break;
5803 case OPC2_32_RCRW_INSERT:
5804 temp3 = tcg_temp_new();
5805
5806 tcg_gen_movi_tl(temp, width);
5807 tcg_gen_movi_tl(temp2, const4);
5808 tcg_gen_andi_tl(temp3, cpu_gpr_d[r4], 0x1f);
5809 gen_insert(cpu_gpr_d[r3], cpu_gpr_d[r1], temp2, temp, temp3);
5810
5811 tcg_temp_free(temp3);
5812 break;
5813 default:
5814 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5815 }
5816 tcg_temp_free(temp);
5817 tcg_temp_free(temp2);
5818 }
5819
5820 /* RCR format */
5821
5822 static void decode_rcr_cond_select(DisasContext *ctx)
5823 {
5824 uint32_t op2;
5825 int r1, r3, r4;
5826 int32_t const9;
5827
5828 TCGv temp, temp2;
5829
5830 op2 = MASK_OP_RCR_OP2(ctx->opcode);
5831 r1 = MASK_OP_RCR_S1(ctx->opcode);
5832 const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
5833 r3 = MASK_OP_RCR_S3(ctx->opcode);
5834 r4 = MASK_OP_RCR_D(ctx->opcode);
5835
5836 switch (op2) {
5837 case OPC2_32_RCR_CADD:
5838 gen_condi_add(TCG_COND_NE, cpu_gpr_d[r1], const9, cpu_gpr_d[r4],
5839 cpu_gpr_d[r3]);
5840 break;
5841 case OPC2_32_RCR_CADDN:
5842 gen_condi_add(TCG_COND_EQ, cpu_gpr_d[r1], const9, cpu_gpr_d[r4],
5843 cpu_gpr_d[r3]);
5844 break;
5845 case OPC2_32_RCR_SEL:
5846 temp = tcg_const_i32(0);
5847 temp2 = tcg_const_i32(const9);
5848 tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
5849 cpu_gpr_d[r1], temp2);
5850 tcg_temp_free(temp);
5851 tcg_temp_free(temp2);
5852 break;
5853 case OPC2_32_RCR_SELN:
5854 temp = tcg_const_i32(0);
5855 temp2 = tcg_const_i32(const9);
5856 tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
5857 cpu_gpr_d[r1], temp2);
5858 tcg_temp_free(temp);
5859 tcg_temp_free(temp2);
5860 break;
5861 default:
5862 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5863 }
5864 }
5865
5866 static void decode_rcr_madd(DisasContext *ctx)
5867 {
5868 uint32_t op2;
5869 int r1, r3, r4;
5870 int32_t const9;
5871
5872
5873 op2 = MASK_OP_RCR_OP2(ctx->opcode);
5874 r1 = MASK_OP_RCR_S1(ctx->opcode);
5875 const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
5876 r3 = MASK_OP_RCR_S3(ctx->opcode);
5877 r4 = MASK_OP_RCR_D(ctx->opcode);
5878
5879 switch (op2) {
5880 case OPC2_32_RCR_MADD_32:
5881 gen_maddi32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5882 break;
5883 case OPC2_32_RCR_MADD_64:
5884 CHECK_REG_PAIR(r4);
5885 CHECK_REG_PAIR(r3);
5886 gen_maddi64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5887 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5888 break;
5889 case OPC2_32_RCR_MADDS_32:
5890 gen_maddsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5891 break;
5892 case OPC2_32_RCR_MADDS_64:
5893 CHECK_REG_PAIR(r4);
5894 CHECK_REG_PAIR(r3);
5895 gen_maddsi_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5896 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5897 break;
5898 case OPC2_32_RCR_MADD_U_64:
5899 CHECK_REG_PAIR(r4);
5900 CHECK_REG_PAIR(r3);
5901 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5902 gen_maddui64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5903 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5904 break;
5905 case OPC2_32_RCR_MADDS_U_32:
5906 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5907 gen_maddsui_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5908 break;
5909 case OPC2_32_RCR_MADDS_U_64:
5910 CHECK_REG_PAIR(r4);
5911 CHECK_REG_PAIR(r3);
5912 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5913 gen_maddsui_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5914 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5915 break;
5916 default:
5917 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5918 }
5919 }
5920
5921 static void decode_rcr_msub(DisasContext *ctx)
5922 {
5923 uint32_t op2;
5924 int r1, r3, r4;
5925 int32_t const9;
5926
5927
5928 op2 = MASK_OP_RCR_OP2(ctx->opcode);
5929 r1 = MASK_OP_RCR_S1(ctx->opcode);
5930 const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
5931 r3 = MASK_OP_RCR_S3(ctx->opcode);
5932 r4 = MASK_OP_RCR_D(ctx->opcode);
5933
5934 switch (op2) {
5935 case OPC2_32_RCR_MSUB_32:
5936 gen_msubi32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5937 break;
5938 case OPC2_32_RCR_MSUB_64:
5939 CHECK_REG_PAIR(r4);
5940 CHECK_REG_PAIR(r3);
5941 gen_msubi64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5942 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5943 break;
5944 case OPC2_32_RCR_MSUBS_32:
5945 gen_msubsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5946 break;
5947 case OPC2_32_RCR_MSUBS_64:
5948 CHECK_REG_PAIR(r4);
5949 CHECK_REG_PAIR(r3);
5950 gen_msubsi_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5951 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5952 break;
5953 case OPC2_32_RCR_MSUB_U_64:
5954 CHECK_REG_PAIR(r4);
5955 CHECK_REG_PAIR(r3);
5956 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5957 gen_msubui64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5958 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5959 break;
5960 case OPC2_32_RCR_MSUBS_U_32:
5961 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5962 gen_msubsui_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
5963 break;
5964 case OPC2_32_RCR_MSUBS_U_64:
5965 CHECK_REG_PAIR(r4);
5966 CHECK_REG_PAIR(r3);
5967 const9 = MASK_OP_RCR_CONST9(ctx->opcode);
5968 gen_msubsui_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
5969 cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
5970 break;
5971 default:
5972 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
5973 }
5974 }
5975
5976 /* RLC format */
5977
5978 static void decode_rlc_opc(DisasContext *ctx,
5979 uint32_t op1)
5980 {
5981 int32_t const16;
5982 int r1, r2;
5983
5984 const16 = MASK_OP_RLC_CONST16_SEXT(ctx->opcode);
5985 r1 = MASK_OP_RLC_S1(ctx->opcode);
5986 r2 = MASK_OP_RLC_D(ctx->opcode);
5987
5988 switch (op1) {
5989 case OPC1_32_RLC_ADDI:
5990 gen_addi_d(cpu_gpr_d[r2], cpu_gpr_d[r1], const16);
5991 break;
5992 case OPC1_32_RLC_ADDIH:
5993 gen_addi_d(cpu_gpr_d[r2], cpu_gpr_d[r1], const16 << 16);
5994 break;
5995 case OPC1_32_RLC_ADDIH_A:
5996 tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r1], const16 << 16);
5997 break;
5998 case OPC1_32_RLC_MFCR:
5999 const16 = MASK_OP_RLC_CONST16(ctx->opcode);
6000 gen_mfcr(ctx, cpu_gpr_d[r2], const16);
6001 break;
6002 case OPC1_32_RLC_MOV:
6003 tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
6004 break;
6005 case OPC1_32_RLC_MOV_64:
6006 if (has_feature(ctx, TRICORE_FEATURE_16)) {
6007 CHECK_REG_PAIR(r2);
6008 tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
6009 tcg_gen_movi_tl(cpu_gpr_d[r2+1], const16 >> 15);
6010 } else {
6011 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6012 }
6013 break;
6014 case OPC1_32_RLC_MOV_U:
6015 const16 = MASK_OP_RLC_CONST16(ctx->opcode);
6016 tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
6017 break;
6018 case OPC1_32_RLC_MOV_H:
6019 tcg_gen_movi_tl(cpu_gpr_d[r2], const16 << 16);
6020 break;
6021 case OPC1_32_RLC_MOVH_A:
6022 tcg_gen_movi_tl(cpu_gpr_a[r2], const16 << 16);
6023 break;
6024 case OPC1_32_RLC_MTCR:
6025 const16 = MASK_OP_RLC_CONST16(ctx->opcode);
6026 gen_mtcr(ctx, cpu_gpr_d[r1], const16);
6027 break;
6028 default:
6029 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6030 }
6031 }
6032
6033 /* RR format */
6034 static void decode_rr_accumulator(DisasContext *ctx)
6035 {
6036 uint32_t op2;
6037 int r3, r2, r1;
6038
6039 TCGv temp;
6040
6041 r3 = MASK_OP_RR_D(ctx->opcode);
6042 r2 = MASK_OP_RR_S2(ctx->opcode);
6043 r1 = MASK_OP_RR_S1(ctx->opcode);
6044 op2 = MASK_OP_RR_OP2(ctx->opcode);
6045
6046 switch (op2) {
6047 case OPC2_32_RR_ABS:
6048 gen_abs(cpu_gpr_d[r3], cpu_gpr_d[r2]);
6049 break;
6050 case OPC2_32_RR_ABS_B:
6051 gen_helper_abs_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
6052 break;
6053 case OPC2_32_RR_ABS_H:
6054 gen_helper_abs_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
6055 break;
6056 case OPC2_32_RR_ABSDIF:
6057 gen_absdif(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6058 break;
6059 case OPC2_32_RR_ABSDIF_B:
6060 gen_helper_absdif_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6061 cpu_gpr_d[r2]);
6062 break;
6063 case OPC2_32_RR_ABSDIF_H:
6064 gen_helper_absdif_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6065 cpu_gpr_d[r2]);
6066 break;
6067 case OPC2_32_RR_ABSDIFS:
6068 gen_helper_absdif_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6069 cpu_gpr_d[r2]);
6070 break;
6071 case OPC2_32_RR_ABSDIFS_H:
6072 gen_helper_absdif_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6073 cpu_gpr_d[r2]);
6074 break;
6075 case OPC2_32_RR_ABSS:
6076 gen_helper_abs_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
6077 break;
6078 case OPC2_32_RR_ABSS_H:
6079 gen_helper_abs_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
6080 break;
6081 case OPC2_32_RR_ADD:
6082 gen_add_d(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6083 break;
6084 case OPC2_32_RR_ADD_B:
6085 gen_helper_add_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6086 break;
6087 case OPC2_32_RR_ADD_H:
6088 gen_helper_add_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6089 break;
6090 case OPC2_32_RR_ADDC:
6091 gen_addc_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6092 break;
6093 case OPC2_32_RR_ADDS:
6094 gen_adds(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6095 break;
6096 case OPC2_32_RR_ADDS_H:
6097 gen_helper_add_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6098 cpu_gpr_d[r2]);
6099 break;
6100 case OPC2_32_RR_ADDS_HU:
6101 gen_helper_add_h_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6102 cpu_gpr_d[r2]);
6103 break;
6104 case OPC2_32_RR_ADDS_U:
6105 gen_helper_add_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6106 cpu_gpr_d[r2]);
6107 break;
6108 case OPC2_32_RR_ADDX:
6109 gen_add_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6110 break;
6111 case OPC2_32_RR_AND_EQ:
6112 gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
6113 cpu_gpr_d[r2], &tcg_gen_and_tl);
6114 break;
6115 case OPC2_32_RR_AND_GE:
6116 gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6117 cpu_gpr_d[r2], &tcg_gen_and_tl);
6118 break;
6119 case OPC2_32_RR_AND_GE_U:
6120 gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6121 cpu_gpr_d[r2], &tcg_gen_and_tl);
6122 break;
6123 case OPC2_32_RR_AND_LT:
6124 gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6125 cpu_gpr_d[r2], &tcg_gen_and_tl);
6126 break;
6127 case OPC2_32_RR_AND_LT_U:
6128 gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6129 cpu_gpr_d[r2], &tcg_gen_and_tl);
6130 break;
6131 case OPC2_32_RR_AND_NE:
6132 gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6133 cpu_gpr_d[r2], &tcg_gen_and_tl);
6134 break;
6135 case OPC2_32_RR_EQ:
6136 tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
6137 cpu_gpr_d[r2]);
6138 break;
6139 case OPC2_32_RR_EQ_B:
6140 gen_helper_eq_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6141 break;
6142 case OPC2_32_RR_EQ_H:
6143 gen_helper_eq_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6144 break;
6145 case OPC2_32_RR_EQ_W:
6146 gen_cond_w(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6147 break;
6148 case OPC2_32_RR_EQANY_B:
6149 gen_helper_eqany_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6150 break;
6151 case OPC2_32_RR_EQANY_H:
6152 gen_helper_eqany_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6153 break;
6154 case OPC2_32_RR_GE:
6155 tcg_gen_setcond_tl(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6156 cpu_gpr_d[r2]);
6157 break;
6158 case OPC2_32_RR_GE_U:
6159 tcg_gen_setcond_tl(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6160 cpu_gpr_d[r2]);
6161 break;
6162 case OPC2_32_RR_LT:
6163 tcg_gen_setcond_tl(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6164 cpu_gpr_d[r2]);
6165 break;
6166 case OPC2_32_RR_LT_U:
6167 tcg_gen_setcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6168 cpu_gpr_d[r2]);
6169 break;
6170 case OPC2_32_RR_LT_B:
6171 gen_helper_lt_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6172 break;
6173 case OPC2_32_RR_LT_BU:
6174 gen_helper_lt_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6175 break;
6176 case OPC2_32_RR_LT_H:
6177 gen_helper_lt_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6178 break;
6179 case OPC2_32_RR_LT_HU:
6180 gen_helper_lt_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6181 break;
6182 case OPC2_32_RR_LT_W:
6183 gen_cond_w(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6184 break;
6185 case OPC2_32_RR_LT_WU:
6186 gen_cond_w(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6187 break;
6188 case OPC2_32_RR_MAX:
6189 tcg_gen_movcond_tl(TCG_COND_GT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6190 cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6191 break;
6192 case OPC2_32_RR_MAX_U:
6193 tcg_gen_movcond_tl(TCG_COND_GTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6194 cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6195 break;
6196 case OPC2_32_RR_MAX_B:
6197 gen_helper_max_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6198 break;
6199 case OPC2_32_RR_MAX_BU:
6200 gen_helper_max_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6201 break;
6202 case OPC2_32_RR_MAX_H:
6203 gen_helper_max_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6204 break;
6205 case OPC2_32_RR_MAX_HU:
6206 gen_helper_max_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6207 break;
6208 case OPC2_32_RR_MIN:
6209 tcg_gen_movcond_tl(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6210 cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6211 break;
6212 case OPC2_32_RR_MIN_U:
6213 tcg_gen_movcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6214 cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6215 break;
6216 case OPC2_32_RR_MIN_B:
6217 gen_helper_min_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6218 break;
6219 case OPC2_32_RR_MIN_BU:
6220 gen_helper_min_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6221 break;
6222 case OPC2_32_RR_MIN_H:
6223 gen_helper_min_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6224 break;
6225 case OPC2_32_RR_MIN_HU:
6226 gen_helper_min_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6227 break;
6228 case OPC2_32_RR_MOV:
6229 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r2]);
6230 break;
6231 case OPC2_32_RR_MOV_64:
6232 if (has_feature(ctx, TRICORE_FEATURE_16)) {
6233 temp = tcg_temp_new();
6234
6235 CHECK_REG_PAIR(r3);
6236 tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
6237 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r2]);
6238 tcg_gen_mov_tl(cpu_gpr_d[r3 + 1], temp);
6239
6240 tcg_temp_free(temp);
6241 } else {
6242 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6243 }
6244 break;
6245 case OPC2_32_RR_MOVS_64:
6246 if (has_feature(ctx, TRICORE_FEATURE_16)) {
6247 CHECK_REG_PAIR(r3);
6248 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r2]);
6249 tcg_gen_sari_tl(cpu_gpr_d[r3 + 1], cpu_gpr_d[r2], 31);
6250 } else {
6251 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6252 }
6253 break;
6254 case OPC2_32_RR_NE:
6255 tcg_gen_setcond_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6256 cpu_gpr_d[r2]);
6257 break;
6258 case OPC2_32_RR_OR_EQ:
6259 gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
6260 cpu_gpr_d[r2], &tcg_gen_or_tl);
6261 break;
6262 case OPC2_32_RR_OR_GE:
6263 gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6264 cpu_gpr_d[r2], &tcg_gen_or_tl);
6265 break;
6266 case OPC2_32_RR_OR_GE_U:
6267 gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6268 cpu_gpr_d[r2], &tcg_gen_or_tl);
6269 break;
6270 case OPC2_32_RR_OR_LT:
6271 gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6272 cpu_gpr_d[r2], &tcg_gen_or_tl);
6273 break;
6274 case OPC2_32_RR_OR_LT_U:
6275 gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6276 cpu_gpr_d[r2], &tcg_gen_or_tl);
6277 break;
6278 case OPC2_32_RR_OR_NE:
6279 gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6280 cpu_gpr_d[r2], &tcg_gen_or_tl);
6281 break;
6282 case OPC2_32_RR_SAT_B:
6283 gen_saturate(cpu_gpr_d[r3], cpu_gpr_d[r1], 0x7f, -0x80);
6284 break;
6285 case OPC2_32_RR_SAT_BU:
6286 gen_saturate_u(cpu_gpr_d[r3], cpu_gpr_d[r1], 0xff);
6287 break;
6288 case OPC2_32_RR_SAT_H:
6289 gen_saturate(cpu_gpr_d[r3], cpu_gpr_d[r1], 0x7fff, -0x8000);
6290 break;
6291 case OPC2_32_RR_SAT_HU:
6292 gen_saturate_u(cpu_gpr_d[r3], cpu_gpr_d[r1], 0xffff);
6293 break;
6294 case OPC2_32_RR_SH_EQ:
6295 gen_sh_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
6296 cpu_gpr_d[r2]);
6297 break;
6298 case OPC2_32_RR_SH_GE:
6299 gen_sh_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6300 cpu_gpr_d[r2]);
6301 break;
6302 case OPC2_32_RR_SH_GE_U:
6303 gen_sh_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6304 cpu_gpr_d[r2]);
6305 break;
6306 case OPC2_32_RR_SH_LT:
6307 gen_sh_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6308 cpu_gpr_d[r2]);
6309 break;
6310 case OPC2_32_RR_SH_LT_U:
6311 gen_sh_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6312 cpu_gpr_d[r2]);
6313 break;
6314 case OPC2_32_RR_SH_NE:
6315 gen_sh_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6316 cpu_gpr_d[r2]);
6317 break;
6318 case OPC2_32_RR_SUB:
6319 gen_sub_d(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6320 break;
6321 case OPC2_32_RR_SUB_B:
6322 gen_helper_sub_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6323 break;
6324 case OPC2_32_RR_SUB_H:
6325 gen_helper_sub_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6326 break;
6327 case OPC2_32_RR_SUBC:
6328 gen_subc_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6329 break;
6330 case OPC2_32_RR_SUBS:
6331 gen_subs(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6332 break;
6333 case OPC2_32_RR_SUBS_U:
6334 gen_subsu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6335 break;
6336 case OPC2_32_RR_SUBS_H:
6337 gen_helper_sub_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6338 cpu_gpr_d[r2]);
6339 break;
6340 case OPC2_32_RR_SUBS_HU:
6341 gen_helper_sub_h_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6342 cpu_gpr_d[r2]);
6343 break;
6344 case OPC2_32_RR_SUBX:
6345 gen_sub_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6346 break;
6347 case OPC2_32_RR_XOR_EQ:
6348 gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
6349 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6350 break;
6351 case OPC2_32_RR_XOR_GE:
6352 gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6353 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6354 break;
6355 case OPC2_32_RR_XOR_GE_U:
6356 gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6357 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6358 break;
6359 case OPC2_32_RR_XOR_LT:
6360 gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
6361 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6362 break;
6363 case OPC2_32_RR_XOR_LT_U:
6364 gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
6365 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6366 break;
6367 case OPC2_32_RR_XOR_NE:
6368 gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
6369 cpu_gpr_d[r2], &tcg_gen_xor_tl);
6370 break;
6371 default:
6372 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6373 }
6374 }
6375
6376 static void decode_rr_logical_shift(DisasContext *ctx)
6377 {
6378 uint32_t op2;
6379 int r3, r2, r1;
6380 TCGv temp;
6381
6382 r3 = MASK_OP_RR_D(ctx->opcode);
6383 r2 = MASK_OP_RR_S2(ctx->opcode);
6384 r1 = MASK_OP_RR_S1(ctx->opcode);
6385
6386 temp = tcg_temp_new();
6387 op2 = MASK_OP_RR_OP2(ctx->opcode);
6388
6389 switch (op2) {
6390 case OPC2_32_RR_AND:
6391 tcg_gen_and_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6392 break;
6393 case OPC2_32_RR_ANDN:
6394 tcg_gen_andc_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6395 break;
6396 case OPC2_32_RR_CLO:
6397 tcg_gen_not_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6398 tcg_gen_clzi_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], TARGET_LONG_BITS);
6399 break;
6400 case OPC2_32_RR_CLO_H:
6401 gen_helper_clo_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6402 break;
6403 case OPC2_32_RR_CLS:
6404 tcg_gen_clrsb_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6405 break;
6406 case OPC2_32_RR_CLS_H:
6407 gen_helper_cls_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6408 break;
6409 case OPC2_32_RR_CLZ:
6410 tcg_gen_clzi_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], TARGET_LONG_BITS);
6411 break;
6412 case OPC2_32_RR_CLZ_H:
6413 gen_helper_clz_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6414 break;
6415 case OPC2_32_RR_NAND:
6416 tcg_gen_nand_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6417 break;
6418 case OPC2_32_RR_NOR:
6419 tcg_gen_nor_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6420 break;
6421 case OPC2_32_RR_OR:
6422 tcg_gen_or_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6423 break;
6424 case OPC2_32_RR_ORN:
6425 tcg_gen_orc_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6426 break;
6427 case OPC2_32_RR_SH:
6428 gen_helper_sh(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6429 break;
6430 case OPC2_32_RR_SH_H:
6431 gen_helper_sh_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6432 break;
6433 case OPC2_32_RR_SHA:
6434 gen_helper_sha(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6435 break;
6436 case OPC2_32_RR_SHA_H:
6437 gen_helper_sha_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6438 break;
6439 case OPC2_32_RR_SHAS:
6440 gen_shas(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6441 break;
6442 case OPC2_32_RR_XNOR:
6443 tcg_gen_eqv_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6444 break;
6445 case OPC2_32_RR_XOR:
6446 tcg_gen_xor_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6447 break;
6448 default:
6449 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6450 }
6451 tcg_temp_free(temp);
6452 }
6453
6454 static void decode_rr_address(DisasContext *ctx)
6455 {
6456 uint32_t op2, n;
6457 int r1, r2, r3;
6458 TCGv temp;
6459
6460 op2 = MASK_OP_RR_OP2(ctx->opcode);
6461 r3 = MASK_OP_RR_D(ctx->opcode);
6462 r2 = MASK_OP_RR_S2(ctx->opcode);
6463 r1 = MASK_OP_RR_S1(ctx->opcode);
6464 n = MASK_OP_RR_N(ctx->opcode);
6465
6466 switch (op2) {
6467 case OPC2_32_RR_ADD_A:
6468 tcg_gen_add_tl(cpu_gpr_a[r3], cpu_gpr_a[r1], cpu_gpr_a[r2]);
6469 break;
6470 case OPC2_32_RR_ADDSC_A:
6471 temp = tcg_temp_new();
6472 tcg_gen_shli_tl(temp, cpu_gpr_d[r1], n);
6473 tcg_gen_add_tl(cpu_gpr_a[r3], cpu_gpr_a[r2], temp);
6474 tcg_temp_free(temp);
6475 break;
6476 case OPC2_32_RR_ADDSC_AT:
6477 temp = tcg_temp_new();
6478 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 3);
6479 tcg_gen_add_tl(temp, cpu_gpr_a[r2], temp);
6480 tcg_gen_andi_tl(cpu_gpr_a[r3], temp, 0xFFFFFFFC);
6481 tcg_temp_free(temp);
6482 break;
6483 case OPC2_32_RR_EQ_A:
6484 tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_a[r1],
6485 cpu_gpr_a[r2]);
6486 break;
6487 case OPC2_32_RR_EQZ:
6488 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_a[r1], 0);
6489 break;
6490 case OPC2_32_RR_GE_A:
6491 tcg_gen_setcond_tl(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_a[r1],
6492 cpu_gpr_a[r2]);
6493 break;
6494 case OPC2_32_RR_LT_A:
6495 tcg_gen_setcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_a[r1],
6496 cpu_gpr_a[r2]);
6497 break;
6498 case OPC2_32_RR_MOV_A:
6499 tcg_gen_mov_tl(cpu_gpr_a[r3], cpu_gpr_d[r2]);
6500 break;
6501 case OPC2_32_RR_MOV_AA:
6502 tcg_gen_mov_tl(cpu_gpr_a[r3], cpu_gpr_a[r2]);
6503 break;
6504 case OPC2_32_RR_MOV_D:
6505 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_a[r2]);
6506 break;
6507 case OPC2_32_RR_NE_A:
6508 tcg_gen_setcond_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_a[r1],
6509 cpu_gpr_a[r2]);
6510 break;
6511 case OPC2_32_RR_NEZ_A:
6512 tcg_gen_setcondi_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_a[r1], 0);
6513 break;
6514 case OPC2_32_RR_SUB_A:
6515 tcg_gen_sub_tl(cpu_gpr_a[r3], cpu_gpr_a[r1], cpu_gpr_a[r2]);
6516 break;
6517 default:
6518 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6519 }
6520 }
6521
6522 static void decode_rr_idirect(DisasContext *ctx)
6523 {
6524 uint32_t op2;
6525 int r1;
6526
6527 op2 = MASK_OP_RR_OP2(ctx->opcode);
6528 r1 = MASK_OP_RR_S1(ctx->opcode);
6529
6530 switch (op2) {
6531 case OPC2_32_RR_JI:
6532 tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
6533 break;
6534 case OPC2_32_RR_JLI:
6535 tcg_gen_movi_tl(cpu_gpr_a[11], ctx->pc_succ_insn);
6536 tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
6537 break;
6538 case OPC2_32_RR_CALLI:
6539 gen_helper_1arg(call, ctx->pc_succ_insn);
6540 tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
6541 break;
6542 case OPC2_32_RR_FCALLI:
6543 gen_fcall_save_ctx(ctx);
6544 tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
6545 break;
6546 default:
6547 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6548 }
6549 tcg_gen_exit_tb(NULL, 0);
6550 ctx->base.is_jmp = DISAS_NORETURN;
6551 }
6552
6553 static void decode_rr_divide(DisasContext *ctx)
6554 {
6555 uint32_t op2;
6556 int r1, r2, r3;
6557
6558 TCGv temp, temp2, temp3;
6559
6560 op2 = MASK_OP_RR_OP2(ctx->opcode);
6561 r3 = MASK_OP_RR_D(ctx->opcode);
6562 r2 = MASK_OP_RR_S2(ctx->opcode);
6563 r1 = MASK_OP_RR_S1(ctx->opcode);
6564
6565 switch (op2) {
6566 case OPC2_32_RR_BMERGE:
6567 gen_helper_bmerge(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6568 break;
6569 case OPC2_32_RR_BSPLIT:
6570 CHECK_REG_PAIR(r3);
6571 gen_bsplit(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
6572 break;
6573 case OPC2_32_RR_DVINIT_B:
6574 CHECK_REG_PAIR(r3);
6575 gen_dvinit_b(ctx, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
6576 cpu_gpr_d[r2]);
6577 break;
6578 case OPC2_32_RR_DVINIT_BU:
6579 temp = tcg_temp_new();
6580 temp2 = tcg_temp_new();
6581 temp3 = tcg_temp_new();
6582 CHECK_REG_PAIR(r3);
6583 tcg_gen_shri_tl(temp3, cpu_gpr_d[r1], 8);
6584 /* reset av */
6585 tcg_gen_movi_tl(cpu_PSW_AV, 0);
6586 if (!has_feature(ctx, TRICORE_FEATURE_131)) {
6587 /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */
6588 tcg_gen_abs_tl(temp, temp3);
6589 tcg_gen_abs_tl(temp2, cpu_gpr_d[r2]);
6590 tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);
6591 } else {
6592 /* overflow = (D[b] == 0) */
6593 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
6594 }
6595 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
6596 /* sv */
6597 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
6598 /* write result */
6599 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 24);
6600 tcg_gen_mov_tl(cpu_gpr_d[r3+1], temp3);
6601
6602 tcg_temp_free(temp);
6603 tcg_temp_free(temp2);
6604 tcg_temp_free(temp3);
6605 break;
6606 case OPC2_32_RR_DVINIT_H:
6607 CHECK_REG_PAIR(r3);
6608 gen_dvinit_h(ctx, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
6609 cpu_gpr_d[r2]);
6610 break;
6611 case OPC2_32_RR_DVINIT_HU:
6612 temp = tcg_temp_new();
6613 temp2 = tcg_temp_new();
6614 temp3 = tcg_temp_new();
6615 CHECK_REG_PAIR(r3);
6616 tcg_gen_shri_tl(temp3, cpu_gpr_d[r1], 16);
6617 /* reset av */
6618 tcg_gen_movi_tl(cpu_PSW_AV, 0);
6619 if (!has_feature(ctx, TRICORE_FEATURE_131)) {
6620 /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */
6621 tcg_gen_abs_tl(temp, temp3);
6622 tcg_gen_abs_tl(temp2, cpu_gpr_d[r2]);
6623 tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);
6624 } else {
6625 /* overflow = (D[b] == 0) */
6626 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
6627 }
6628 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
6629 /* sv */
6630 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
6631 /* write result */
6632 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 16);
6633 tcg_gen_mov_tl(cpu_gpr_d[r3+1], temp3);
6634 tcg_temp_free(temp);
6635 tcg_temp_free(temp2);
6636 tcg_temp_free(temp3);
6637 break;
6638 case OPC2_32_RR_DVINIT:
6639 temp = tcg_temp_new();
6640 temp2 = tcg_temp_new();
6641 CHECK_REG_PAIR(r3);
6642 /* overflow = ((D[b] == 0) ||
6643 ((D[b] == 0xFFFFFFFF) && (D[a] == 0x80000000))) */
6644 tcg_gen_setcondi_tl(TCG_COND_EQ, temp, cpu_gpr_d[r2], 0xffffffff);
6645 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r1], 0x80000000);
6646 tcg_gen_and_tl(temp, temp, temp2);
6647 tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r2], 0);
6648 tcg_gen_or_tl(cpu_PSW_V, temp, temp2);
6649 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
6650 /* sv */
6651 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
6652 /* reset av */
6653 tcg_gen_movi_tl(cpu_PSW_AV, 0);
6654 /* write result */
6655 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6656 /* sign extend to high reg */
6657 tcg_gen_sari_tl(cpu_gpr_d[r3+1], cpu_gpr_d[r1], 31);
6658 tcg_temp_free(temp);
6659 tcg_temp_free(temp2);
6660 break;
6661 case OPC2_32_RR_DVINIT_U:
6662 /* overflow = (D[b] == 0) */
6663 tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
6664 tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
6665 /* sv */
6666 tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
6667 /* reset av */
6668 tcg_gen_movi_tl(cpu_PSW_AV, 0);
6669 /* write result */
6670 tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6671 /* zero extend to high reg*/
6672 tcg_gen_movi_tl(cpu_gpr_d[r3+1], 0);
6673 break;
6674 case OPC2_32_RR_PARITY:
6675 gen_helper_parity(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6676 break;
6677 case OPC2_32_RR_UNPACK:
6678 CHECK_REG_PAIR(r3);
6679 gen_unpack(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
6680 break;
6681 case OPC2_32_RR_CRC32:
6682 if (has_feature(ctx, TRICORE_FEATURE_161)) {
6683 gen_helper_crc32(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6684 } else {
6685 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6686 }
6687 break;
6688 case OPC2_32_RR_DIV:
6689 if (has_feature(ctx, TRICORE_FEATURE_16)) {
6690 GEN_HELPER_RR(divide, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
6691 cpu_gpr_d[r2]);
6692 } else {
6693 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6694 }
6695 break;
6696 case OPC2_32_RR_DIV_U:
6697 if (has_feature(ctx, TRICORE_FEATURE_16)) {
6698 GEN_HELPER_RR(divide_u, cpu_gpr_d[r3], cpu_gpr_d[r3+1],
6699 cpu_gpr_d[r1], cpu_gpr_d[r2]);
6700 } else {
6701 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6702 }
6703 break;
6704 case OPC2_32_RR_MUL_F:
6705 gen_helper_fmul(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6706 break;
6707 case OPC2_32_RR_DIV_F:
6708 gen_helper_fdiv(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6709 break;
6710 case OPC2_32_RR_CMP_F:
6711 gen_helper_fcmp(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
6712 break;
6713 case OPC2_32_RR_FTOI:
6714 gen_helper_ftoi(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6715 break;
6716 case OPC2_32_RR_ITOF:
6717 gen_helper_itof(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6718 break;
6719 case OPC2_32_RR_FTOUZ:
6720 gen_helper_ftouz(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6721 break;
6722 case OPC2_32_RR_UPDFL:
6723 gen_helper_updfl(cpu_env, cpu_gpr_d[r1]);
6724 break;
6725 case OPC2_32_RR_UTOF:
6726 gen_helper_utof(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6727 break;
6728 case OPC2_32_RR_FTOIZ:
6729 gen_helper_ftoiz(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6730 break;
6731 case OPC2_32_RR_QSEED_F:
6732 gen_helper_qseed(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1]);
6733 break;
6734 default:
6735 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6736 }
6737 }
6738
6739 /* RR1 Format */
6740 static void decode_rr1_mul(DisasContext *ctx)
6741 {
6742 uint32_t op2;
6743
6744 int r1, r2, r3;
6745 TCGv n;
6746 TCGv_i64 temp64;
6747
6748 r1 = MASK_OP_RR1_S1(ctx->opcode);
6749 r2 = MASK_OP_RR1_S2(ctx->opcode);
6750 r3 = MASK_OP_RR1_D(ctx->opcode);
6751 n = tcg_const_i32(MASK_OP_RR1_N(ctx->opcode));
6752 op2 = MASK_OP_RR1_OP2(ctx->opcode);
6753
6754 switch (op2) {
6755 case OPC2_32_RR1_MUL_H_32_LL:
6756 temp64 = tcg_temp_new_i64();
6757 CHECK_REG_PAIR(r3);
6758 GEN_HELPER_LL(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6759 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6760 gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
6761 tcg_temp_free_i64(temp64);
6762 break;
6763 case OPC2_32_RR1_MUL_H_32_LU:
6764 temp64 = tcg_temp_new_i64();
6765 CHECK_REG_PAIR(r3);
6766 GEN_HELPER_LU(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6767 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6768 gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
6769 tcg_temp_free_i64(temp64);
6770 break;
6771 case OPC2_32_RR1_MUL_H_32_UL:
6772 temp64 = tcg_temp_new_i64();
6773 CHECK_REG_PAIR(r3);
6774 GEN_HELPER_UL(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6775 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6776 gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
6777 tcg_temp_free_i64(temp64);
6778 break;
6779 case OPC2_32_RR1_MUL_H_32_UU:
6780 temp64 = tcg_temp_new_i64();
6781 CHECK_REG_PAIR(r3);
6782 GEN_HELPER_UU(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6783 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6784 gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
6785 tcg_temp_free_i64(temp64);
6786 break;
6787 case OPC2_32_RR1_MULM_H_64_LL:
6788 temp64 = tcg_temp_new_i64();
6789 CHECK_REG_PAIR(r3);
6790 GEN_HELPER_LL(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6791 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6792 /* reset V bit */
6793 tcg_gen_movi_tl(cpu_PSW_V, 0);
6794 /* reset AV bit */
6795 tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
6796 tcg_temp_free_i64(temp64);
6797 break;
6798 case OPC2_32_RR1_MULM_H_64_LU:
6799 temp64 = tcg_temp_new_i64();
6800 CHECK_REG_PAIR(r3);
6801 GEN_HELPER_LU(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6802 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6803 /* reset V bit */
6804 tcg_gen_movi_tl(cpu_PSW_V, 0);
6805 /* reset AV bit */
6806 tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
6807 tcg_temp_free_i64(temp64);
6808 break;
6809 case OPC2_32_RR1_MULM_H_64_UL:
6810 temp64 = tcg_temp_new_i64();
6811 CHECK_REG_PAIR(r3);
6812 GEN_HELPER_UL(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6813 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6814 /* reset V bit */
6815 tcg_gen_movi_tl(cpu_PSW_V, 0);
6816 /* reset AV bit */
6817 tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
6818 tcg_temp_free_i64(temp64);
6819 break;
6820 case OPC2_32_RR1_MULM_H_64_UU:
6821 temp64 = tcg_temp_new_i64();
6822 CHECK_REG_PAIR(r3);
6823 GEN_HELPER_UU(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6824 tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
6825 /* reset V bit */
6826 tcg_gen_movi_tl(cpu_PSW_V, 0);
6827 /* reset AV bit */
6828 tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
6829 tcg_temp_free_i64(temp64);
6830
6831 break;
6832 case OPC2_32_RR1_MULR_H_16_LL:
6833 GEN_HELPER_LL(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6834 gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
6835 break;
6836 case OPC2_32_RR1_MULR_H_16_LU:
6837 GEN_HELPER_LU(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6838 gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
6839 break;
6840 case OPC2_32_RR1_MULR_H_16_UL:
6841 GEN_HELPER_UL(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6842 gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
6843 break;
6844 case OPC2_32_RR1_MULR_H_16_UU:
6845 GEN_HELPER_UU(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
6846 gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
6847 break;
6848 default:
6849 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6850 }
6851 tcg_temp_free(n);
6852 }
6853
6854 static void decode_rr1_mulq(DisasContext *ctx)
6855 {
6856 uint32_t op2;
6857 int r1, r2, r3;
6858 uint32_t n;
6859
6860 TCGv temp, temp2;
6861
6862 r1 = MASK_OP_RR1_S1(ctx->opcode);
6863 r2 = MASK_OP_RR1_S2(ctx->opcode);
6864 r3 = MASK_OP_RR1_D(ctx->opcode);
6865 n = MASK_OP_RR1_N(ctx->opcode);
6866 op2 = MASK_OP_RR1_OP2(ctx->opcode);
6867
6868 temp = tcg_temp_new();
6869 temp2 = tcg_temp_new();
6870
6871 switch (op2) {
6872 case OPC2_32_RR1_MUL_Q_32:
6873 gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], cpu_gpr_d[r2], n, 32);
6874 break;
6875 case OPC2_32_RR1_MUL_Q_64:
6876 CHECK_REG_PAIR(r3);
6877 gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
6878 n, 0);
6879 break;
6880 case OPC2_32_RR1_MUL_Q_32_L:
6881 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
6882 gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], temp, n, 16);
6883 break;
6884 case OPC2_32_RR1_MUL_Q_64_L:
6885 CHECK_REG_PAIR(r3);
6886 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
6887 gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp, n, 0);
6888 break;
6889 case OPC2_32_RR1_MUL_Q_32_U:
6890 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
6891 gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], temp, n, 16);
6892 break;
6893 case OPC2_32_RR1_MUL_Q_64_U:
6894 CHECK_REG_PAIR(r3);
6895 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
6896 gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp, n, 0);
6897 break;
6898 case OPC2_32_RR1_MUL_Q_32_LL:
6899 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
6900 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
6901 gen_mul_q_16(cpu_gpr_d[r3], temp, temp2, n);
6902 break;
6903 case OPC2_32_RR1_MUL_Q_32_UU:
6904 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
6905 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
6906 gen_mul_q_16(cpu_gpr_d[r3], temp, temp2, n);
6907 break;
6908 case OPC2_32_RR1_MULR_Q_32_L:
6909 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
6910 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
6911 gen_mulr_q(cpu_gpr_d[r3], temp, temp2, n);
6912 break;
6913 case OPC2_32_RR1_MULR_Q_32_U:
6914 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
6915 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
6916 gen_mulr_q(cpu_gpr_d[r3], temp, temp2, n);
6917 break;
6918 default:
6919 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6920 }
6921 tcg_temp_free(temp);
6922 tcg_temp_free(temp2);
6923 }
6924
6925 /* RR2 format */
6926 static void decode_rr2_mul(DisasContext *ctx)
6927 {
6928 uint32_t op2;
6929 int r1, r2, r3;
6930
6931 op2 = MASK_OP_RR2_OP2(ctx->opcode);
6932 r1 = MASK_OP_RR2_S1(ctx->opcode);
6933 r2 = MASK_OP_RR2_S2(ctx->opcode);
6934 r3 = MASK_OP_RR2_D(ctx->opcode);
6935 switch (op2) {
6936 case OPC2_32_RR2_MUL_32:
6937 gen_mul_i32s(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
6938 break;
6939 case OPC2_32_RR2_MUL_64:
6940 CHECK_REG_PAIR(r3);
6941 gen_mul_i64s(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
6942 cpu_gpr_d[r2]);
6943 break;
6944 case OPC2_32_RR2_MULS_32:
6945 gen_helper_mul_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6946 cpu_gpr_d[r2]);
6947 break;
6948 case OPC2_32_RR2_MUL_U_64:
6949 CHECK_REG_PAIR(r3);
6950 gen_mul_i64u(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
6951 cpu_gpr_d[r2]);
6952 break;
6953 case OPC2_32_RR2_MULS_U_32:
6954 gen_helper_mul_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
6955 cpu_gpr_d[r2]);
6956 break;
6957 default:
6958 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
6959 }
6960 }
6961
6962 /* RRPW format */
6963 static void decode_rrpw_extract_insert(DisasContext *ctx)
6964 {
6965 uint32_t op2;
6966 int r1, r2, r3;
6967 int32_t pos, width;
6968 TCGv temp;
6969
6970 op2 = MASK_OP_RRPW_OP2(ctx->opcode);
6971 r1 = MASK_OP_RRPW_S1(ctx->opcode);
6972 r2 = MASK_OP_RRPW_S2(ctx->opcode);
6973 r3 = MASK_OP_RRPW_D(ctx->opcode);
6974 pos = MASK_OP_RRPW_POS(ctx->opcode);
6975 width = MASK_OP_RRPW_WIDTH(ctx->opcode);
6976
6977 switch (op2) {
6978 case OPC2_32_RRPW_EXTR:
6979 if (width == 0) {
6980 tcg_gen_movi_tl(cpu_gpr_d[r3], 0);
6981 break;
6982 }
6983
6984 if (pos + width <= 32) {
6985 /* optimize special cases */
6986 if ((pos == 0) && (width == 8)) {
6987 tcg_gen_ext8s_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6988 } else if ((pos == 0) && (width == 16)) {
6989 tcg_gen_ext16s_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
6990 } else {
6991 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 32 - pos - width);
6992 tcg_gen_sari_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 32 - width);
6993 }
6994 }
6995 break;
6996 case OPC2_32_RRPW_EXTR_U:
6997 if (width == 0) {
6998 tcg_gen_movi_tl(cpu_gpr_d[r3], 0);
6999 } else {
7000 tcg_gen_shri_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], pos);
7001 tcg_gen_andi_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], ~0u >> (32-width));
7002 }
7003 break;
7004 case OPC2_32_RRPW_IMASK:
7005 CHECK_REG_PAIR(r3);
7006
7007 if (pos + width <= 32) {
7008 temp = tcg_temp_new();
7009 tcg_gen_movi_tl(temp, ((1u << width) - 1) << pos);
7010 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r2], pos);
7011 tcg_gen_mov_tl(cpu_gpr_d[r3 + 1], temp);
7012 tcg_temp_free(temp);
7013 }
7014
7015 break;
7016 case OPC2_32_RRPW_INSERT:
7017 if (pos + width <= 32) {
7018 tcg_gen_deposit_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
7019 pos, width);
7020 }
7021 break;
7022 default:
7023 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7024 }
7025 }
7026
7027 /* RRR format */
7028 static void decode_rrr_cond_select(DisasContext *ctx)
7029 {
7030 uint32_t op2;
7031 int r1, r2, r3, r4;
7032 TCGv temp;
7033
7034 op2 = MASK_OP_RRR_OP2(ctx->opcode);
7035 r1 = MASK_OP_RRR_S1(ctx->opcode);
7036 r2 = MASK_OP_RRR_S2(ctx->opcode);
7037 r3 = MASK_OP_RRR_S3(ctx->opcode);
7038 r4 = MASK_OP_RRR_D(ctx->opcode);
7039
7040 switch (op2) {
7041 case OPC2_32_RRR_CADD:
7042 gen_cond_add(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
7043 cpu_gpr_d[r4], cpu_gpr_d[r3]);
7044 break;
7045 case OPC2_32_RRR_CADDN:
7046 gen_cond_add(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
7047 cpu_gpr_d[r3]);
7048 break;
7049 case OPC2_32_RRR_CSUB:
7050 gen_cond_sub(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
7051 cpu_gpr_d[r3]);
7052 break;
7053 case OPC2_32_RRR_CSUBN:
7054 gen_cond_sub(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
7055 cpu_gpr_d[r3]);
7056 break;
7057 case OPC2_32_RRR_SEL:
7058 temp = tcg_const_i32(0);
7059 tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
7060 cpu_gpr_d[r1], cpu_gpr_d[r2]);
7061 tcg_temp_free(temp);
7062 break;
7063 case OPC2_32_RRR_SELN:
7064 temp = tcg_const_i32(0);
7065 tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
7066 cpu_gpr_d[r1], cpu_gpr_d[r2]);
7067 tcg_temp_free(temp);
7068 break;
7069 default:
7070 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7071 }
7072 }
7073
7074 static void decode_rrr_divide(DisasContext *ctx)
7075 {
7076 uint32_t op2;
7077
7078 int r1, r2, r3, r4;
7079
7080 op2 = MASK_OP_RRR_OP2(ctx->opcode);
7081 r1 = MASK_OP_RRR_S1(ctx->opcode);
7082 r2 = MASK_OP_RRR_S2(ctx->opcode);
7083 r3 = MASK_OP_RRR_S3(ctx->opcode);
7084 r4 = MASK_OP_RRR_D(ctx->opcode);
7085
7086 switch (op2) {
7087 case OPC2_32_RRR_DVADJ:
7088 CHECK_REG_PAIR(r3);
7089 CHECK_REG_PAIR(r4);
7090 GEN_HELPER_RRR(dvadj, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7091 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7092 break;
7093 case OPC2_32_RRR_DVSTEP:
7094 CHECK_REG_PAIR(r3);
7095 CHECK_REG_PAIR(r4);
7096 GEN_HELPER_RRR(dvstep, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7097 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7098 break;
7099 case OPC2_32_RRR_DVSTEP_U:
7100 CHECK_REG_PAIR(r3);
7101 CHECK_REG_PAIR(r4);
7102 GEN_HELPER_RRR(dvstep_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7103 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7104 break;
7105 case OPC2_32_RRR_IXMAX:
7106 CHECK_REG_PAIR(r3);
7107 CHECK_REG_PAIR(r4);
7108 GEN_HELPER_RRR(ixmax, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7109 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7110 break;
7111 case OPC2_32_RRR_IXMAX_U:
7112 CHECK_REG_PAIR(r3);
7113 CHECK_REG_PAIR(r4);
7114 GEN_HELPER_RRR(ixmax_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7115 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7116 break;
7117 case OPC2_32_RRR_IXMIN:
7118 CHECK_REG_PAIR(r3);
7119 CHECK_REG_PAIR(r4);
7120 GEN_HELPER_RRR(ixmin, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7121 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7122 break;
7123 case OPC2_32_RRR_IXMIN_U:
7124 CHECK_REG_PAIR(r3);
7125 CHECK_REG_PAIR(r4);
7126 GEN_HELPER_RRR(ixmin_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7127 cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7128 break;
7129 case OPC2_32_RRR_PACK:
7130 CHECK_REG_PAIR(r3);
7131 gen_helper_pack(cpu_gpr_d[r4], cpu_PSW_C, cpu_gpr_d[r3],
7132 cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
7133 break;
7134 case OPC2_32_RRR_ADD_F:
7135 gen_helper_fadd(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r3]);
7136 break;
7137 case OPC2_32_RRR_SUB_F:
7138 gen_helper_fsub(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r3]);
7139 break;
7140 case OPC2_32_RRR_MADD_F:
7141 gen_helper_fmadd(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7142 cpu_gpr_d[r2], cpu_gpr_d[r3]);
7143 break;
7144 case OPC2_32_RRR_MSUB_F:
7145 gen_helper_fmsub(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7146 cpu_gpr_d[r2], cpu_gpr_d[r3]);
7147 break;
7148 default:
7149 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7150 }
7151 }
7152
7153 /* RRR2 format */
7154 static void decode_rrr2_madd(DisasContext *ctx)
7155 {
7156 uint32_t op2;
7157 uint32_t r1, r2, r3, r4;
7158
7159 op2 = MASK_OP_RRR2_OP2(ctx->opcode);
7160 r1 = MASK_OP_RRR2_S1(ctx->opcode);
7161 r2 = MASK_OP_RRR2_S2(ctx->opcode);
7162 r3 = MASK_OP_RRR2_S3(ctx->opcode);
7163 r4 = MASK_OP_RRR2_D(ctx->opcode);
7164 switch (op2) {
7165 case OPC2_32_RRR2_MADD_32:
7166 gen_madd32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3],
7167 cpu_gpr_d[r2]);
7168 break;
7169 case OPC2_32_RRR2_MADD_64:
7170 CHECK_REG_PAIR(r4);
7171 CHECK_REG_PAIR(r3);
7172 gen_madd64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7173 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7174 break;
7175 case OPC2_32_RRR2_MADDS_32:
7176 gen_helper_madd32_ssov(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7177 cpu_gpr_d[r3], cpu_gpr_d[r2]);
7178 break;
7179 case OPC2_32_RRR2_MADDS_64:
7180 CHECK_REG_PAIR(r4);
7181 CHECK_REG_PAIR(r3);
7182 gen_madds_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7183 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7184 break;
7185 case OPC2_32_RRR2_MADD_U_64:
7186 CHECK_REG_PAIR(r4);
7187 CHECK_REG_PAIR(r3);
7188 gen_maddu64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7189 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7190 break;
7191 case OPC2_32_RRR2_MADDS_U_32:
7192 gen_helper_madd32_suov(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7193 cpu_gpr_d[r3], cpu_gpr_d[r2]);
7194 break;
7195 case OPC2_32_RRR2_MADDS_U_64:
7196 CHECK_REG_PAIR(r4);
7197 CHECK_REG_PAIR(r3);
7198 gen_maddsu_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7199 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7200 break;
7201 default:
7202 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7203 }
7204 }
7205
7206 static void decode_rrr2_msub(DisasContext *ctx)
7207 {
7208 uint32_t op2;
7209 uint32_t r1, r2, r3, r4;
7210
7211 op2 = MASK_OP_RRR2_OP2(ctx->opcode);
7212 r1 = MASK_OP_RRR2_S1(ctx->opcode);
7213 r2 = MASK_OP_RRR2_S2(ctx->opcode);
7214 r3 = MASK_OP_RRR2_S3(ctx->opcode);
7215 r4 = MASK_OP_RRR2_D(ctx->opcode);
7216
7217 switch (op2) {
7218 case OPC2_32_RRR2_MSUB_32:
7219 gen_msub32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3],
7220 cpu_gpr_d[r2]);
7221 break;
7222 case OPC2_32_RRR2_MSUB_64:
7223 CHECK_REG_PAIR(r4);
7224 CHECK_REG_PAIR(r3);
7225 gen_msub64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7226 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7227 break;
7228 case OPC2_32_RRR2_MSUBS_32:
7229 gen_helper_msub32_ssov(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7230 cpu_gpr_d[r3], cpu_gpr_d[r2]);
7231 break;
7232 case OPC2_32_RRR2_MSUBS_64:
7233 CHECK_REG_PAIR(r4);
7234 CHECK_REG_PAIR(r3);
7235 gen_msubs_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7236 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7237 break;
7238 case OPC2_32_RRR2_MSUB_U_64:
7239 gen_msubu64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7240 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7241 break;
7242 case OPC2_32_RRR2_MSUBS_U_32:
7243 gen_helper_msub32_suov(cpu_gpr_d[r4], cpu_env, cpu_gpr_d[r1],
7244 cpu_gpr_d[r3], cpu_gpr_d[r2]);
7245 break;
7246 case OPC2_32_RRR2_MSUBS_U_64:
7247 CHECK_REG_PAIR(r4);
7248 CHECK_REG_PAIR(r3);
7249 gen_msubsu_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
7250 cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
7251 break;
7252 default:
7253 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7254 }
7255 }
7256
7257 /* RRR1 format */
7258 static void decode_rrr1_madd(DisasContext *ctx)
7259 {
7260 uint32_t op2;
7261 uint32_t r1, r2, r3, r4, n;
7262
7263 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
7264 r1 = MASK_OP_RRR1_S1(ctx->opcode);
7265 r2 = MASK_OP_RRR1_S2(ctx->opcode);
7266 r3 = MASK_OP_RRR1_S3(ctx->opcode);
7267 r4 = MASK_OP_RRR1_D(ctx->opcode);
7268 n = MASK_OP_RRR1_N(ctx->opcode);
7269
7270 switch (op2) {
7271 case OPC2_32_RRR1_MADD_H_LL:
7272 CHECK_REG_PAIR(r4);
7273 CHECK_REG_PAIR(r3);
7274 gen_madd_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7275 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7276 break;
7277 case OPC2_32_RRR1_MADD_H_LU:
7278 CHECK_REG_PAIR(r4);
7279 CHECK_REG_PAIR(r3);
7280 gen_madd_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7281 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7282 break;
7283 case OPC2_32_RRR1_MADD_H_UL:
7284 CHECK_REG_PAIR(r4);
7285 CHECK_REG_PAIR(r3);
7286 gen_madd_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7287 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7288 break;
7289 case OPC2_32_RRR1_MADD_H_UU:
7290 CHECK_REG_PAIR(r4);
7291 CHECK_REG_PAIR(r3);
7292 gen_madd_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7293 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7294 break;
7295 case OPC2_32_RRR1_MADDS_H_LL:
7296 CHECK_REG_PAIR(r4);
7297 CHECK_REG_PAIR(r3);
7298 gen_madds_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7299 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7300 break;
7301 case OPC2_32_RRR1_MADDS_H_LU:
7302 CHECK_REG_PAIR(r4);
7303 CHECK_REG_PAIR(r3);
7304 gen_madds_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7305 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7306 break;
7307 case OPC2_32_RRR1_MADDS_H_UL:
7308 CHECK_REG_PAIR(r4);
7309 CHECK_REG_PAIR(r3);
7310 gen_madds_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7311 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7312 break;
7313 case OPC2_32_RRR1_MADDS_H_UU:
7314 CHECK_REG_PAIR(r4);
7315 CHECK_REG_PAIR(r3);
7316 gen_madds_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7317 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7318 break;
7319 case OPC2_32_RRR1_MADDM_H_LL:
7320 CHECK_REG_PAIR(r4);
7321 CHECK_REG_PAIR(r3);
7322 gen_maddm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7323 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7324 break;
7325 case OPC2_32_RRR1_MADDM_H_LU:
7326 CHECK_REG_PAIR(r4);
7327 CHECK_REG_PAIR(r3);
7328 gen_maddm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7329 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7330 break;
7331 case OPC2_32_RRR1_MADDM_H_UL:
7332 CHECK_REG_PAIR(r4);
7333 CHECK_REG_PAIR(r3);
7334 gen_maddm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7335 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7336 break;
7337 case OPC2_32_RRR1_MADDM_H_UU:
7338 CHECK_REG_PAIR(r4);
7339 CHECK_REG_PAIR(r3);
7340 gen_maddm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7341 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7342 break;
7343 case OPC2_32_RRR1_MADDMS_H_LL:
7344 CHECK_REG_PAIR(r4);
7345 CHECK_REG_PAIR(r3);
7346 gen_maddms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7347 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7348 break;
7349 case OPC2_32_RRR1_MADDMS_H_LU:
7350 CHECK_REG_PAIR(r4);
7351 CHECK_REG_PAIR(r3);
7352 gen_maddms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7353 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7354 break;
7355 case OPC2_32_RRR1_MADDMS_H_UL:
7356 CHECK_REG_PAIR(r4);
7357 CHECK_REG_PAIR(r3);
7358 gen_maddms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7359 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7360 break;
7361 case OPC2_32_RRR1_MADDMS_H_UU:
7362 CHECK_REG_PAIR(r4);
7363 CHECK_REG_PAIR(r3);
7364 gen_maddms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7365 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7366 break;
7367 case OPC2_32_RRR1_MADDR_H_LL:
7368 gen_maddr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7369 cpu_gpr_d[r2], n, MODE_LL);
7370 break;
7371 case OPC2_32_RRR1_MADDR_H_LU:
7372 gen_maddr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7373 cpu_gpr_d[r2], n, MODE_LU);
7374 break;
7375 case OPC2_32_RRR1_MADDR_H_UL:
7376 gen_maddr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7377 cpu_gpr_d[r2], n, MODE_UL);
7378 break;
7379 case OPC2_32_RRR1_MADDR_H_UU:
7380 gen_maddr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7381 cpu_gpr_d[r2], n, MODE_UU);
7382 break;
7383 case OPC2_32_RRR1_MADDRS_H_LL:
7384 gen_maddr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7385 cpu_gpr_d[r2], n, MODE_LL);
7386 break;
7387 case OPC2_32_RRR1_MADDRS_H_LU:
7388 gen_maddr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7389 cpu_gpr_d[r2], n, MODE_LU);
7390 break;
7391 case OPC2_32_RRR1_MADDRS_H_UL:
7392 gen_maddr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7393 cpu_gpr_d[r2], n, MODE_UL);
7394 break;
7395 case OPC2_32_RRR1_MADDRS_H_UU:
7396 gen_maddr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7397 cpu_gpr_d[r2], n, MODE_UU);
7398 break;
7399 default:
7400 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7401 }
7402 }
7403
7404 static void decode_rrr1_maddq_h(DisasContext *ctx)
7405 {
7406 uint32_t op2;
7407 uint32_t r1, r2, r3, r4, n;
7408 TCGv temp, temp2;
7409
7410 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
7411 r1 = MASK_OP_RRR1_S1(ctx->opcode);
7412 r2 = MASK_OP_RRR1_S2(ctx->opcode);
7413 r3 = MASK_OP_RRR1_S3(ctx->opcode);
7414 r4 = MASK_OP_RRR1_D(ctx->opcode);
7415 n = MASK_OP_RRR1_N(ctx->opcode);
7416
7417 temp = tcg_const_i32(n);
7418 temp2 = tcg_temp_new();
7419
7420 switch (op2) {
7421 case OPC2_32_RRR1_MADD_Q_32:
7422 gen_madd32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7423 cpu_gpr_d[r2], n, 32);
7424 break;
7425 case OPC2_32_RRR1_MADD_Q_64:
7426 CHECK_REG_PAIR(r4);
7427 CHECK_REG_PAIR(r3);
7428 gen_madd64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7429 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7430 n);
7431 break;
7432 case OPC2_32_RRR1_MADD_Q_32_L:
7433 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7434 gen_madd32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7435 temp, n, 16);
7436 break;
7437 case OPC2_32_RRR1_MADD_Q_64_L:
7438 CHECK_REG_PAIR(r4);
7439 CHECK_REG_PAIR(r3);
7440 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7441 gen_madd64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7442 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7443 n);
7444 break;
7445 case OPC2_32_RRR1_MADD_Q_32_U:
7446 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7447 gen_madd32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7448 temp, n, 16);
7449 break;
7450 case OPC2_32_RRR1_MADD_Q_64_U:
7451 CHECK_REG_PAIR(r4);
7452 CHECK_REG_PAIR(r3);
7453 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7454 gen_madd64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7455 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7456 n);
7457 break;
7458 case OPC2_32_RRR1_MADD_Q_32_LL:
7459 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7460 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7461 gen_m16add32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7462 break;
7463 case OPC2_32_RRR1_MADD_Q_64_LL:
7464 CHECK_REG_PAIR(r4);
7465 CHECK_REG_PAIR(r3);
7466 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7467 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7468 gen_m16add64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7469 cpu_gpr_d[r3+1], temp, temp2, n);
7470 break;
7471 case OPC2_32_RRR1_MADD_Q_32_UU:
7472 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7473 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7474 gen_m16add32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7475 break;
7476 case OPC2_32_RRR1_MADD_Q_64_UU:
7477 CHECK_REG_PAIR(r4);
7478 CHECK_REG_PAIR(r3);
7479 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7480 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7481 gen_m16add64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7482 cpu_gpr_d[r3+1], temp, temp2, n);
7483 break;
7484 case OPC2_32_RRR1_MADDS_Q_32:
7485 gen_madds32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7486 cpu_gpr_d[r2], n, 32);
7487 break;
7488 case OPC2_32_RRR1_MADDS_Q_64:
7489 CHECK_REG_PAIR(r4);
7490 CHECK_REG_PAIR(r3);
7491 gen_madds64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7492 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7493 n);
7494 break;
7495 case OPC2_32_RRR1_MADDS_Q_32_L:
7496 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7497 gen_madds32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7498 temp, n, 16);
7499 break;
7500 case OPC2_32_RRR1_MADDS_Q_64_L:
7501 CHECK_REG_PAIR(r4);
7502 CHECK_REG_PAIR(r3);
7503 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7504 gen_madds64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7505 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7506 n);
7507 break;
7508 case OPC2_32_RRR1_MADDS_Q_32_U:
7509 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7510 gen_madds32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7511 temp, n, 16);
7512 break;
7513 case OPC2_32_RRR1_MADDS_Q_64_U:
7514 CHECK_REG_PAIR(r4);
7515 CHECK_REG_PAIR(r3);
7516 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7517 gen_madds64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7518 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7519 n);
7520 break;
7521 case OPC2_32_RRR1_MADDS_Q_32_LL:
7522 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7523 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7524 gen_m16adds32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7525 break;
7526 case OPC2_32_RRR1_MADDS_Q_64_LL:
7527 CHECK_REG_PAIR(r4);
7528 CHECK_REG_PAIR(r3);
7529 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7530 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7531 gen_m16adds64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7532 cpu_gpr_d[r3+1], temp, temp2, n);
7533 break;
7534 case OPC2_32_RRR1_MADDS_Q_32_UU:
7535 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7536 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7537 gen_m16adds32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7538 break;
7539 case OPC2_32_RRR1_MADDS_Q_64_UU:
7540 CHECK_REG_PAIR(r4);
7541 CHECK_REG_PAIR(r3);
7542 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7543 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7544 gen_m16adds64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7545 cpu_gpr_d[r3+1], temp, temp2, n);
7546 break;
7547 case OPC2_32_RRR1_MADDR_H_64_UL:
7548 CHECK_REG_PAIR(r3);
7549 gen_maddr64_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r3+1],
7550 cpu_gpr_d[r1], cpu_gpr_d[r2], n, 2);
7551 break;
7552 case OPC2_32_RRR1_MADDRS_H_64_UL:
7553 CHECK_REG_PAIR(r3);
7554 gen_maddr64s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r3+1],
7555 cpu_gpr_d[r1], cpu_gpr_d[r2], n, 2);
7556 break;
7557 case OPC2_32_RRR1_MADDR_Q_32_LL:
7558 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7559 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7560 gen_maddr_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7561 break;
7562 case OPC2_32_RRR1_MADDR_Q_32_UU:
7563 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7564 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7565 gen_maddr_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7566 break;
7567 case OPC2_32_RRR1_MADDRS_Q_32_LL:
7568 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7569 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7570 gen_maddrs_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7571 break;
7572 case OPC2_32_RRR1_MADDRS_Q_32_UU:
7573 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7574 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7575 gen_maddrs_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7576 break;
7577 default:
7578 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7579 }
7580 tcg_temp_free(temp);
7581 tcg_temp_free(temp2);
7582 }
7583
7584 static void decode_rrr1_maddsu_h(DisasContext *ctx)
7585 {
7586 uint32_t op2;
7587 uint32_t r1, r2, r3, r4, n;
7588
7589 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
7590 r1 = MASK_OP_RRR1_S1(ctx->opcode);
7591 r2 = MASK_OP_RRR1_S2(ctx->opcode);
7592 r3 = MASK_OP_RRR1_S3(ctx->opcode);
7593 r4 = MASK_OP_RRR1_D(ctx->opcode);
7594 n = MASK_OP_RRR1_N(ctx->opcode);
7595
7596 switch (op2) {
7597 case OPC2_32_RRR1_MADDSU_H_32_LL:
7598 CHECK_REG_PAIR(r4);
7599 CHECK_REG_PAIR(r3);
7600 gen_maddsu_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7601 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7602 break;
7603 case OPC2_32_RRR1_MADDSU_H_32_LU:
7604 CHECK_REG_PAIR(r4);
7605 CHECK_REG_PAIR(r3);
7606 gen_maddsu_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7607 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7608 break;
7609 case OPC2_32_RRR1_MADDSU_H_32_UL:
7610 CHECK_REG_PAIR(r4);
7611 CHECK_REG_PAIR(r3);
7612 gen_maddsu_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7613 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7614 break;
7615 case OPC2_32_RRR1_MADDSU_H_32_UU:
7616 CHECK_REG_PAIR(r4);
7617 CHECK_REG_PAIR(r3);
7618 gen_maddsu_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7619 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7620 break;
7621 case OPC2_32_RRR1_MADDSUS_H_32_LL:
7622 CHECK_REG_PAIR(r4);
7623 CHECK_REG_PAIR(r3);
7624 gen_maddsus_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7625 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7626 n, MODE_LL);
7627 break;
7628 case OPC2_32_RRR1_MADDSUS_H_32_LU:
7629 CHECK_REG_PAIR(r4);
7630 CHECK_REG_PAIR(r3);
7631 gen_maddsus_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7632 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7633 n, MODE_LU);
7634 break;
7635 case OPC2_32_RRR1_MADDSUS_H_32_UL:
7636 CHECK_REG_PAIR(r4);
7637 CHECK_REG_PAIR(r3);
7638 gen_maddsus_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7639 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7640 n, MODE_UL);
7641 break;
7642 case OPC2_32_RRR1_MADDSUS_H_32_UU:
7643 CHECK_REG_PAIR(r4);
7644 CHECK_REG_PAIR(r3);
7645 gen_maddsus_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7646 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7647 n, MODE_UU);
7648 break;
7649 case OPC2_32_RRR1_MADDSUM_H_64_LL:
7650 CHECK_REG_PAIR(r4);
7651 CHECK_REG_PAIR(r3);
7652 gen_maddsum_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7653 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7654 n, MODE_LL);
7655 break;
7656 case OPC2_32_RRR1_MADDSUM_H_64_LU:
7657 CHECK_REG_PAIR(r4);
7658 CHECK_REG_PAIR(r3);
7659 gen_maddsum_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7660 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7661 n, MODE_LU);
7662 break;
7663 case OPC2_32_RRR1_MADDSUM_H_64_UL:
7664 CHECK_REG_PAIR(r4);
7665 CHECK_REG_PAIR(r3);
7666 gen_maddsum_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7667 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7668 n, MODE_UL);
7669 break;
7670 case OPC2_32_RRR1_MADDSUM_H_64_UU:
7671 CHECK_REG_PAIR(r4);
7672 CHECK_REG_PAIR(r3);
7673 gen_maddsum_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7674 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7675 n, MODE_UU);
7676 break;
7677 case OPC2_32_RRR1_MADDSUMS_H_64_LL:
7678 CHECK_REG_PAIR(r4);
7679 CHECK_REG_PAIR(r3);
7680 gen_maddsums_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7681 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7682 n, MODE_LL);
7683 break;
7684 case OPC2_32_RRR1_MADDSUMS_H_64_LU:
7685 CHECK_REG_PAIR(r4);
7686 CHECK_REG_PAIR(r3);
7687 gen_maddsums_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7688 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7689 n, MODE_LU);
7690 break;
7691 case OPC2_32_RRR1_MADDSUMS_H_64_UL:
7692 CHECK_REG_PAIR(r4);
7693 CHECK_REG_PAIR(r3);
7694 gen_maddsums_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7695 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7696 n, MODE_UL);
7697 break;
7698 case OPC2_32_RRR1_MADDSUMS_H_64_UU:
7699 CHECK_REG_PAIR(r4);
7700 CHECK_REG_PAIR(r3);
7701 gen_maddsums_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7702 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7703 n, MODE_UU);
7704 break;
7705 case OPC2_32_RRR1_MADDSUR_H_16_LL:
7706 gen_maddsur32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7707 cpu_gpr_d[r2], n, MODE_LL);
7708 break;
7709 case OPC2_32_RRR1_MADDSUR_H_16_LU:
7710 gen_maddsur32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7711 cpu_gpr_d[r2], n, MODE_LU);
7712 break;
7713 case OPC2_32_RRR1_MADDSUR_H_16_UL:
7714 gen_maddsur32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7715 cpu_gpr_d[r2], n, MODE_UL);
7716 break;
7717 case OPC2_32_RRR1_MADDSUR_H_16_UU:
7718 gen_maddsur32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7719 cpu_gpr_d[r2], n, MODE_UU);
7720 break;
7721 case OPC2_32_RRR1_MADDSURS_H_16_LL:
7722 gen_maddsur32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7723 cpu_gpr_d[r2], n, MODE_LL);
7724 break;
7725 case OPC2_32_RRR1_MADDSURS_H_16_LU:
7726 gen_maddsur32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7727 cpu_gpr_d[r2], n, MODE_LU);
7728 break;
7729 case OPC2_32_RRR1_MADDSURS_H_16_UL:
7730 gen_maddsur32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7731 cpu_gpr_d[r2], n, MODE_UL);
7732 break;
7733 case OPC2_32_RRR1_MADDSURS_H_16_UU:
7734 gen_maddsur32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7735 cpu_gpr_d[r2], n, MODE_UU);
7736 break;
7737 default:
7738 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7739 }
7740 }
7741
7742 static void decode_rrr1_msub(DisasContext *ctx)
7743 {
7744 uint32_t op2;
7745 uint32_t r1, r2, r3, r4, n;
7746
7747 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
7748 r1 = MASK_OP_RRR1_S1(ctx->opcode);
7749 r2 = MASK_OP_RRR1_S2(ctx->opcode);
7750 r3 = MASK_OP_RRR1_S3(ctx->opcode);
7751 r4 = MASK_OP_RRR1_D(ctx->opcode);
7752 n = MASK_OP_RRR1_N(ctx->opcode);
7753
7754 switch (op2) {
7755 case OPC2_32_RRR1_MSUB_H_LL:
7756 CHECK_REG_PAIR(r4);
7757 CHECK_REG_PAIR(r3);
7758 gen_msub_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7759 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7760 break;
7761 case OPC2_32_RRR1_MSUB_H_LU:
7762 CHECK_REG_PAIR(r4);
7763 CHECK_REG_PAIR(r3);
7764 gen_msub_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7765 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7766 break;
7767 case OPC2_32_RRR1_MSUB_H_UL:
7768 CHECK_REG_PAIR(r4);
7769 CHECK_REG_PAIR(r3);
7770 gen_msub_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7771 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7772 break;
7773 case OPC2_32_RRR1_MSUB_H_UU:
7774 CHECK_REG_PAIR(r4);
7775 CHECK_REG_PAIR(r3);
7776 gen_msub_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7777 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7778 break;
7779 case OPC2_32_RRR1_MSUBS_H_LL:
7780 CHECK_REG_PAIR(r4);
7781 CHECK_REG_PAIR(r3);
7782 gen_msubs_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7783 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7784 break;
7785 case OPC2_32_RRR1_MSUBS_H_LU:
7786 CHECK_REG_PAIR(r4);
7787 CHECK_REG_PAIR(r3);
7788 gen_msubs_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7789 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7790 break;
7791 case OPC2_32_RRR1_MSUBS_H_UL:
7792 CHECK_REG_PAIR(r4);
7793 CHECK_REG_PAIR(r3);
7794 gen_msubs_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7795 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7796 break;
7797 case OPC2_32_RRR1_MSUBS_H_UU:
7798 CHECK_REG_PAIR(r4);
7799 CHECK_REG_PAIR(r3);
7800 gen_msubs_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7801 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7802 break;
7803 case OPC2_32_RRR1_MSUBM_H_LL:
7804 CHECK_REG_PAIR(r4);
7805 CHECK_REG_PAIR(r3);
7806 gen_msubm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7807 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7808 break;
7809 case OPC2_32_RRR1_MSUBM_H_LU:
7810 CHECK_REG_PAIR(r4);
7811 CHECK_REG_PAIR(r3);
7812 gen_msubm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7813 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7814 break;
7815 case OPC2_32_RRR1_MSUBM_H_UL:
7816 CHECK_REG_PAIR(r4);
7817 CHECK_REG_PAIR(r3);
7818 gen_msubm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7819 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7820 break;
7821 case OPC2_32_RRR1_MSUBM_H_UU:
7822 CHECK_REG_PAIR(r4);
7823 CHECK_REG_PAIR(r3);
7824 gen_msubm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7825 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7826 break;
7827 case OPC2_32_RRR1_MSUBMS_H_LL:
7828 CHECK_REG_PAIR(r4);
7829 CHECK_REG_PAIR(r3);
7830 gen_msubms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7831 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
7832 break;
7833 case OPC2_32_RRR1_MSUBMS_H_LU:
7834 CHECK_REG_PAIR(r4);
7835 CHECK_REG_PAIR(r3);
7836 gen_msubms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7837 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
7838 break;
7839 case OPC2_32_RRR1_MSUBMS_H_UL:
7840 CHECK_REG_PAIR(r4);
7841 CHECK_REG_PAIR(r3);
7842 gen_msubms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7843 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
7844 break;
7845 case OPC2_32_RRR1_MSUBMS_H_UU:
7846 CHECK_REG_PAIR(r4);
7847 CHECK_REG_PAIR(r3);
7848 gen_msubms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7849 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
7850 break;
7851 case OPC2_32_RRR1_MSUBR_H_LL:
7852 gen_msubr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7853 cpu_gpr_d[r2], n, MODE_LL);
7854 break;
7855 case OPC2_32_RRR1_MSUBR_H_LU:
7856 gen_msubr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7857 cpu_gpr_d[r2], n, MODE_LU);
7858 break;
7859 case OPC2_32_RRR1_MSUBR_H_UL:
7860 gen_msubr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7861 cpu_gpr_d[r2], n, MODE_UL);
7862 break;
7863 case OPC2_32_RRR1_MSUBR_H_UU:
7864 gen_msubr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7865 cpu_gpr_d[r2], n, MODE_UU);
7866 break;
7867 case OPC2_32_RRR1_MSUBRS_H_LL:
7868 gen_msubr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7869 cpu_gpr_d[r2], n, MODE_LL);
7870 break;
7871 case OPC2_32_RRR1_MSUBRS_H_LU:
7872 gen_msubr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7873 cpu_gpr_d[r2], n, MODE_LU);
7874 break;
7875 case OPC2_32_RRR1_MSUBRS_H_UL:
7876 gen_msubr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7877 cpu_gpr_d[r2], n, MODE_UL);
7878 break;
7879 case OPC2_32_RRR1_MSUBRS_H_UU:
7880 gen_msubr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7881 cpu_gpr_d[r2], n, MODE_UU);
7882 break;
7883 default:
7884 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
7885 }
7886 }
7887
7888 static void decode_rrr1_msubq_h(DisasContext *ctx)
7889 {
7890 uint32_t op2;
7891 uint32_t r1, r2, r3, r4, n;
7892 TCGv temp, temp2;
7893
7894 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
7895 r1 = MASK_OP_RRR1_S1(ctx->opcode);
7896 r2 = MASK_OP_RRR1_S2(ctx->opcode);
7897 r3 = MASK_OP_RRR1_S3(ctx->opcode);
7898 r4 = MASK_OP_RRR1_D(ctx->opcode);
7899 n = MASK_OP_RRR1_N(ctx->opcode);
7900
7901 temp = tcg_const_i32(n);
7902 temp2 = tcg_temp_new();
7903
7904 switch (op2) {
7905 case OPC2_32_RRR1_MSUB_Q_32:
7906 gen_msub32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7907 cpu_gpr_d[r2], n, 32);
7908 break;
7909 case OPC2_32_RRR1_MSUB_Q_64:
7910 CHECK_REG_PAIR(r4);
7911 CHECK_REG_PAIR(r3);
7912 gen_msub64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7913 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7914 n);
7915 break;
7916 case OPC2_32_RRR1_MSUB_Q_32_L:
7917 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7918 gen_msub32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7919 temp, n, 16);
7920 break;
7921 case OPC2_32_RRR1_MSUB_Q_64_L:
7922 CHECK_REG_PAIR(r4);
7923 CHECK_REG_PAIR(r3);
7924 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7925 gen_msub64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7926 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7927 n);
7928 break;
7929 case OPC2_32_RRR1_MSUB_Q_32_U:
7930 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7931 gen_msub32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7932 temp, n, 16);
7933 break;
7934 case OPC2_32_RRR1_MSUB_Q_64_U:
7935 CHECK_REG_PAIR(r4);
7936 CHECK_REG_PAIR(r3);
7937 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7938 gen_msub64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7939 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7940 n);
7941 break;
7942 case OPC2_32_RRR1_MSUB_Q_32_LL:
7943 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7944 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7945 gen_m16sub32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7946 break;
7947 case OPC2_32_RRR1_MSUB_Q_64_LL:
7948 CHECK_REG_PAIR(r4);
7949 CHECK_REG_PAIR(r3);
7950 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
7951 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
7952 gen_m16sub64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7953 cpu_gpr_d[r3+1], temp, temp2, n);
7954 break;
7955 case OPC2_32_RRR1_MSUB_Q_32_UU:
7956 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7957 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7958 gen_m16sub32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
7959 break;
7960 case OPC2_32_RRR1_MSUB_Q_64_UU:
7961 CHECK_REG_PAIR(r4);
7962 CHECK_REG_PAIR(r3);
7963 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
7964 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
7965 gen_m16sub64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7966 cpu_gpr_d[r3+1], temp, temp2, n);
7967 break;
7968 case OPC2_32_RRR1_MSUBS_Q_32:
7969 gen_msubs32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7970 cpu_gpr_d[r2], n, 32);
7971 break;
7972 case OPC2_32_RRR1_MSUBS_Q_64:
7973 CHECK_REG_PAIR(r4);
7974 CHECK_REG_PAIR(r3);
7975 gen_msubs64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7976 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
7977 n);
7978 break;
7979 case OPC2_32_RRR1_MSUBS_Q_32_L:
7980 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7981 gen_msubs32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7982 temp, n, 16);
7983 break;
7984 case OPC2_32_RRR1_MSUBS_Q_64_L:
7985 CHECK_REG_PAIR(r4);
7986 CHECK_REG_PAIR(r3);
7987 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
7988 gen_msubs64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
7989 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
7990 n);
7991 break;
7992 case OPC2_32_RRR1_MSUBS_Q_32_U:
7993 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
7994 gen_msubs32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
7995 temp, n, 16);
7996 break;
7997 case OPC2_32_RRR1_MSUBS_Q_64_U:
7998 CHECK_REG_PAIR(r4);
7999 CHECK_REG_PAIR(r3);
8000 tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
8001 gen_msubs64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8002 cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp,
8003 n);
8004 break;
8005 case OPC2_32_RRR1_MSUBS_Q_32_LL:
8006 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
8007 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
8008 gen_m16subs32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8009 break;
8010 case OPC2_32_RRR1_MSUBS_Q_64_LL:
8011 CHECK_REG_PAIR(r4);
8012 CHECK_REG_PAIR(r3);
8013 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
8014 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
8015 gen_m16subs64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8016 cpu_gpr_d[r3+1], temp, temp2, n);
8017 break;
8018 case OPC2_32_RRR1_MSUBS_Q_32_UU:
8019 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
8020 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
8021 gen_m16subs32_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8022 break;
8023 case OPC2_32_RRR1_MSUBS_Q_64_UU:
8024 CHECK_REG_PAIR(r4);
8025 CHECK_REG_PAIR(r3);
8026 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
8027 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
8028 gen_m16subs64_q(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8029 cpu_gpr_d[r3+1], temp, temp2, n);
8030 break;
8031 case OPC2_32_RRR1_MSUBR_H_64_UL:
8032 CHECK_REG_PAIR(r3);
8033 gen_msubr64_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r3+1],
8034 cpu_gpr_d[r1], cpu_gpr_d[r2], n, 2);
8035 break;
8036 case OPC2_32_RRR1_MSUBRS_H_64_UL:
8037 CHECK_REG_PAIR(r3);
8038 gen_msubr64s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r3+1],
8039 cpu_gpr_d[r1], cpu_gpr_d[r2], n, 2);
8040 break;
8041 case OPC2_32_RRR1_MSUBR_Q_32_LL:
8042 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
8043 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
8044 gen_msubr_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8045 break;
8046 case OPC2_32_RRR1_MSUBR_Q_32_UU:
8047 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
8048 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
8049 gen_msubr_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8050 break;
8051 case OPC2_32_RRR1_MSUBRS_Q_32_LL:
8052 tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
8053 tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
8054 gen_msubrs_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8055 break;
8056 case OPC2_32_RRR1_MSUBRS_Q_32_UU:
8057 tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
8058 tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
8059 gen_msubrs_q(cpu_gpr_d[r4], cpu_gpr_d[r3], temp, temp2, n);
8060 break;
8061 default:
8062 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8063 }
8064 tcg_temp_free(temp);
8065 tcg_temp_free(temp2);
8066 }
8067
8068 static void decode_rrr1_msubad_h(DisasContext *ctx)
8069 {
8070 uint32_t op2;
8071 uint32_t r1, r2, r3, r4, n;
8072
8073 op2 = MASK_OP_RRR1_OP2(ctx->opcode);
8074 r1 = MASK_OP_RRR1_S1(ctx->opcode);
8075 r2 = MASK_OP_RRR1_S2(ctx->opcode);
8076 r3 = MASK_OP_RRR1_S3(ctx->opcode);
8077 r4 = MASK_OP_RRR1_D(ctx->opcode);
8078 n = MASK_OP_RRR1_N(ctx->opcode);
8079
8080 switch (op2) {
8081 case OPC2_32_RRR1_MSUBAD_H_32_LL:
8082 CHECK_REG_PAIR(r4);
8083 CHECK_REG_PAIR(r3);
8084 gen_msubad_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8085 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LL);
8086 break;
8087 case OPC2_32_RRR1_MSUBAD_H_32_LU:
8088 CHECK_REG_PAIR(r4);
8089 CHECK_REG_PAIR(r3);
8090 gen_msubad_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8091 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_LU);
8092 break;
8093 case OPC2_32_RRR1_MSUBAD_H_32_UL:
8094 CHECK_REG_PAIR(r4);
8095 CHECK_REG_PAIR(r3);
8096 gen_msubad_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8097 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UL);
8098 break;
8099 case OPC2_32_RRR1_MSUBAD_H_32_UU:
8100 CHECK_REG_PAIR(r4);
8101 CHECK_REG_PAIR(r3);
8102 gen_msubad_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8103 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2], n, MODE_UU);
8104 break;
8105 case OPC2_32_RRR1_MSUBADS_H_32_LL:
8106 CHECK_REG_PAIR(r4);
8107 CHECK_REG_PAIR(r3);
8108 gen_msubads_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8109 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8110 n, MODE_LL);
8111 break;
8112 case OPC2_32_RRR1_MSUBADS_H_32_LU:
8113 CHECK_REG_PAIR(r4);
8114 CHECK_REG_PAIR(r3);
8115 gen_msubads_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8116 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8117 n, MODE_LU);
8118 break;
8119 case OPC2_32_RRR1_MSUBADS_H_32_UL:
8120 CHECK_REG_PAIR(r4);
8121 CHECK_REG_PAIR(r3);
8122 gen_msubads_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8123 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8124 n, MODE_UL);
8125 break;
8126 case OPC2_32_RRR1_MSUBADS_H_32_UU:
8127 CHECK_REG_PAIR(r4);
8128 CHECK_REG_PAIR(r3);
8129 gen_msubads_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8130 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8131 n, MODE_UU);
8132 break;
8133 case OPC2_32_RRR1_MSUBADM_H_64_LL:
8134 CHECK_REG_PAIR(r4);
8135 CHECK_REG_PAIR(r3);
8136 gen_msubadm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8137 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8138 n, MODE_LL);
8139 break;
8140 case OPC2_32_RRR1_MSUBADM_H_64_LU:
8141 CHECK_REG_PAIR(r4);
8142 CHECK_REG_PAIR(r3);
8143 gen_msubadm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8144 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8145 n, MODE_LU);
8146 break;
8147 case OPC2_32_RRR1_MSUBADM_H_64_UL:
8148 CHECK_REG_PAIR(r4);
8149 CHECK_REG_PAIR(r3);
8150 gen_msubadm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8151 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8152 n, MODE_UL);
8153 break;
8154 case OPC2_32_RRR1_MSUBADM_H_64_UU:
8155 CHECK_REG_PAIR(r4);
8156 CHECK_REG_PAIR(r3);
8157 gen_msubadm_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8158 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8159 n, MODE_UU);
8160 break;
8161 case OPC2_32_RRR1_MSUBADMS_H_64_LL:
8162 CHECK_REG_PAIR(r4);
8163 CHECK_REG_PAIR(r3);
8164 gen_msubadms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8165 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8166 n, MODE_LL);
8167 break;
8168 case OPC2_32_RRR1_MSUBADMS_H_64_LU:
8169 CHECK_REG_PAIR(r4);
8170 CHECK_REG_PAIR(r3);
8171 gen_msubadms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8172 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8173 n, MODE_LU);
8174 break;
8175 case OPC2_32_RRR1_MSUBADMS_H_64_UL:
8176 CHECK_REG_PAIR(r4);
8177 CHECK_REG_PAIR(r3);
8178 gen_msubadms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8179 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8180 n, MODE_UL);
8181 break;
8182 case OPC2_32_RRR1_MSUBADMS_H_64_UU:
8183 CHECK_REG_PAIR(r4);
8184 CHECK_REG_PAIR(r3);
8185 gen_msubadms_h(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
8186 cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
8187 n, MODE_UU);
8188 break;
8189 case OPC2_32_RRR1_MSUBADR_H_16_LL:
8190 gen_msubadr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8191 cpu_gpr_d[r2], n, MODE_LL);
8192 break;
8193 case OPC2_32_RRR1_MSUBADR_H_16_LU:
8194 gen_msubadr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8195 cpu_gpr_d[r2], n, MODE_LU);
8196 break;
8197 case OPC2_32_RRR1_MSUBADR_H_16_UL:
8198 gen_msubadr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8199 cpu_gpr_d[r2], n, MODE_UL);
8200 break;
8201 case OPC2_32_RRR1_MSUBADR_H_16_UU:
8202 gen_msubadr32_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8203 cpu_gpr_d[r2], n, MODE_UU);
8204 break;
8205 case OPC2_32_RRR1_MSUBADRS_H_16_LL:
8206 gen_msubadr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8207 cpu_gpr_d[r2], n, MODE_LL);
8208 break;
8209 case OPC2_32_RRR1_MSUBADRS_H_16_LU:
8210 gen_msubadr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8211 cpu_gpr_d[r2], n, MODE_LU);
8212 break;
8213 case OPC2_32_RRR1_MSUBADRS_H_16_UL:
8214 gen_msubadr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8215 cpu_gpr_d[r2], n, MODE_UL);
8216 break;
8217 case OPC2_32_RRR1_MSUBADRS_H_16_UU:
8218 gen_msubadr32s_h(cpu_gpr_d[r4], cpu_gpr_d[r3], cpu_gpr_d[r1],
8219 cpu_gpr_d[r2], n, MODE_UU);
8220 break;
8221 default:
8222 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8223 }
8224 }
8225
8226 /* RRRR format */
8227 static void decode_rrrr_extract_insert(DisasContext *ctx)
8228 {
8229 uint32_t op2;
8230 int r1, r2, r3, r4;
8231 TCGv tmp_width, tmp_pos;
8232
8233 r1 = MASK_OP_RRRR_S1(ctx->opcode);
8234 r2 = MASK_OP_RRRR_S2(ctx->opcode);
8235 r3 = MASK_OP_RRRR_S3(ctx->opcode);
8236 r4 = MASK_OP_RRRR_D(ctx->opcode);
8237 op2 = MASK_OP_RRRR_OP2(ctx->opcode);
8238
8239 tmp_pos = tcg_temp_new();
8240 tmp_width = tcg_temp_new();
8241
8242 switch (op2) {
8243 case OPC2_32_RRRR_DEXTR:
8244 tcg_gen_andi_tl(tmp_pos, cpu_gpr_d[r3], 0x1f);
8245 if (r1 == r2) {
8246 tcg_gen_rotl_tl(cpu_gpr_d[r4], cpu_gpr_d[r1], tmp_pos);
8247 } else {
8248 tcg_gen_shl_tl(tmp_width, cpu_gpr_d[r1], tmp_pos);
8249 tcg_gen_subfi_tl(tmp_pos, 32, tmp_pos);
8250 tcg_gen_shr_tl(tmp_pos, cpu_gpr_d[r2], tmp_pos);
8251 tcg_gen_or_tl(cpu_gpr_d[r4], tmp_width, tmp_pos);
8252 }
8253 break;
8254 case OPC2_32_RRRR_EXTR:
8255 case OPC2_32_RRRR_EXTR_U:
8256 CHECK_REG_PAIR(r3);
8257 tcg_gen_andi_tl(tmp_width, cpu_gpr_d[r3+1], 0x1f);
8258 tcg_gen_andi_tl(tmp_pos, cpu_gpr_d[r3], 0x1f);
8259 tcg_gen_add_tl(tmp_pos, tmp_pos, tmp_width);
8260 tcg_gen_subfi_tl(tmp_pos, 32, tmp_pos);
8261 tcg_gen_shl_tl(cpu_gpr_d[r4], cpu_gpr_d[r1], tmp_pos);
8262 tcg_gen_subfi_tl(tmp_width, 32, tmp_width);
8263 if (op2 == OPC2_32_RRRR_EXTR) {
8264 tcg_gen_sar_tl(cpu_gpr_d[r4], cpu_gpr_d[r4], tmp_width);
8265 } else {
8266 tcg_gen_shr_tl(cpu_gpr_d[r4], cpu_gpr_d[r4], tmp_width);
8267 }
8268 break;
8269 case OPC2_32_RRRR_INSERT:
8270 CHECK_REG_PAIR(r3);
8271 tcg_gen_andi_tl(tmp_width, cpu_gpr_d[r3+1], 0x1f);
8272 tcg_gen_andi_tl(tmp_pos, cpu_gpr_d[r3], 0x1f);
8273 gen_insert(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r2], tmp_width,
8274 tmp_pos);
8275 break;
8276 default:
8277 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8278 }
8279 tcg_temp_free(tmp_pos);
8280 tcg_temp_free(tmp_width);
8281 }
8282
8283 /* RRRW format */
8284 static void decode_rrrw_extract_insert(DisasContext *ctx)
8285 {
8286 uint32_t op2;
8287 int r1, r2, r3, r4;
8288 int32_t width;
8289
8290 TCGv temp, temp2;
8291
8292 op2 = MASK_OP_RRRW_OP2(ctx->opcode);
8293 r1 = MASK_OP_RRRW_S1(ctx->opcode);
8294 r2 = MASK_OP_RRRW_S2(ctx->opcode);
8295 r3 = MASK_OP_RRRW_S3(ctx->opcode);
8296 r4 = MASK_OP_RRRW_D(ctx->opcode);
8297 width = MASK_OP_RRRW_WIDTH(ctx->opcode);
8298
8299 temp = tcg_temp_new();
8300
8301 switch (op2) {
8302 case OPC2_32_RRRW_EXTR:
8303 tcg_gen_andi_tl(temp, cpu_gpr_d[r3], 0x1f);
8304 tcg_gen_addi_tl(temp, temp, width);
8305 tcg_gen_subfi_tl(temp, 32, temp);
8306 tcg_gen_shl_tl(cpu_gpr_d[r4], cpu_gpr_d[r1], temp);
8307 tcg_gen_sari_tl(cpu_gpr_d[r4], cpu_gpr_d[r4], 32 - width);
8308 break;
8309 case OPC2_32_RRRW_EXTR_U:
8310 if (width == 0) {
8311 tcg_gen_movi_tl(cpu_gpr_d[r4], 0);
8312 } else {
8313 tcg_gen_andi_tl(temp, cpu_gpr_d[r3], 0x1f);
8314 tcg_gen_shr_tl(cpu_gpr_d[r4], cpu_gpr_d[r1], temp);
8315 tcg_gen_andi_tl(cpu_gpr_d[r4], cpu_gpr_d[r4], ~0u >> (32-width));
8316 }
8317 break;
8318 case OPC2_32_RRRW_IMASK:
8319 temp2 = tcg_temp_new();
8320
8321 tcg_gen_andi_tl(temp, cpu_gpr_d[r3], 0x1f);
8322 tcg_gen_movi_tl(temp2, (1 << width) - 1);
8323 tcg_gen_shl_tl(temp2, temp2, temp);
8324 tcg_gen_shl_tl(cpu_gpr_d[r4], cpu_gpr_d[r2], temp);
8325 tcg_gen_mov_tl(cpu_gpr_d[r4+1], temp2);
8326
8327 tcg_temp_free(temp2);
8328 break;
8329 case OPC2_32_RRRW_INSERT:
8330 temp2 = tcg_temp_new();
8331
8332 tcg_gen_movi_tl(temp, width);
8333 tcg_gen_andi_tl(temp2, cpu_gpr_d[r3], 0x1f);
8334 gen_insert(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r2], temp, temp2);
8335
8336 tcg_temp_free(temp2);
8337 break;
8338 default:
8339 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8340 }
8341 tcg_temp_free(temp);
8342 }
8343
8344 /* SYS Format*/
8345 static void decode_sys_interrupts(DisasContext *ctx)
8346 {
8347 uint32_t op2;
8348 uint32_t r1;
8349 TCGLabel *l1;
8350 TCGv tmp;
8351
8352 op2 = MASK_OP_SYS_OP2(ctx->opcode);
8353 r1 = MASK_OP_SYS_S1D(ctx->opcode);
8354
8355 switch (op2) {
8356 case OPC2_32_SYS_DEBUG:
8357 /* raise EXCP_DEBUG */
8358 break;
8359 case OPC2_32_SYS_DISABLE:
8360 tcg_gen_andi_tl(cpu_ICR, cpu_ICR, ~MASK_ICR_IE_1_3);
8361 break;
8362 case OPC2_32_SYS_DSYNC:
8363 break;
8364 case OPC2_32_SYS_ENABLE:
8365 tcg_gen_ori_tl(cpu_ICR, cpu_ICR, MASK_ICR_IE_1_3);
8366 break;
8367 case OPC2_32_SYS_ISYNC:
8368 break;
8369 case OPC2_32_SYS_NOP:
8370 break;
8371 case OPC2_32_SYS_RET:
8372 gen_compute_branch(ctx, op2, 0, 0, 0, 0);
8373 break;
8374 case OPC2_32_SYS_FRET:
8375 gen_fret(ctx);
8376 break;
8377 case OPC2_32_SYS_RFE:
8378 gen_helper_rfe(cpu_env);
8379 tcg_gen_exit_tb(NULL, 0);
8380 ctx->base.is_jmp = DISAS_NORETURN;
8381 break;
8382 case OPC2_32_SYS_RFM:
8383 if ((ctx->hflags & TRICORE_HFLAG_KUU) == TRICORE_HFLAG_SM) {
8384 tmp = tcg_temp_new();
8385 l1 = gen_new_label();
8386
8387 tcg_gen_ld32u_tl(tmp, cpu_env, offsetof(CPUTriCoreState, DBGSR));
8388 tcg_gen_andi_tl(tmp, tmp, MASK_DBGSR_DE);
8389 tcg_gen_brcondi_tl(TCG_COND_NE, tmp, 1, l1);
8390 gen_helper_rfm(cpu_env);
8391 gen_set_label(l1);
8392 tcg_gen_exit_tb(NULL, 0);
8393 ctx->base.is_jmp = DISAS_NORETURN;
8394 tcg_temp_free(tmp);
8395 } else {
8396 /* generate privilege trap */
8397 }
8398 break;
8399 case OPC2_32_SYS_RSLCX:
8400 gen_helper_rslcx(cpu_env);
8401 break;
8402 case OPC2_32_SYS_SVLCX:
8403 gen_helper_svlcx(cpu_env);
8404 break;
8405 case OPC2_32_SYS_RESTORE:
8406 if (has_feature(ctx, TRICORE_FEATURE_16)) {
8407 if ((ctx->hflags & TRICORE_HFLAG_KUU) == TRICORE_HFLAG_SM ||
8408 (ctx->hflags & TRICORE_HFLAG_KUU) == TRICORE_HFLAG_UM1) {
8409 tcg_gen_deposit_tl(cpu_ICR, cpu_ICR, cpu_gpr_d[r1], 8, 1);
8410 } /* else raise privilege trap */
8411 } else {
8412 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8413 }
8414 break;
8415 case OPC2_32_SYS_TRAPSV:
8416 l1 = gen_new_label();
8417 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_PSW_SV, 0, l1);
8418 generate_trap(ctx, TRAPC_ASSERT, TIN5_SOVF);
8419 gen_set_label(l1);
8420 break;
8421 case OPC2_32_SYS_TRAPV:
8422 l1 = gen_new_label();
8423 tcg_gen_brcondi_tl(TCG_COND_GE, cpu_PSW_V, 0, l1);
8424 generate_trap(ctx, TRAPC_ASSERT, TIN5_OVF);
8425 gen_set_label(l1);
8426 break;
8427 default:
8428 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8429 }
8430 }
8431
8432 static void decode_32Bit_opc(DisasContext *ctx)
8433 {
8434 int op1;
8435 int32_t r1, r2, r3;
8436 int32_t address, const16;
8437 int8_t b, const4;
8438 int32_t bpos;
8439 TCGv temp, temp2, temp3;
8440
8441 op1 = MASK_OP_MAJOR(ctx->opcode);
8442
8443 /* handle JNZ.T opcode only being 7 bit long */
8444 if (unlikely((op1 & 0x7f) == OPCM_32_BRN_JTT)) {
8445 op1 = OPCM_32_BRN_JTT;
8446 }
8447
8448 switch (op1) {
8449 /* ABS-format */
8450 case OPCM_32_ABS_LDW:
8451 decode_abs_ldw(ctx);
8452 break;
8453 case OPCM_32_ABS_LDB:
8454 decode_abs_ldb(ctx);
8455 break;
8456 case OPCM_32_ABS_LDMST_SWAP:
8457 decode_abs_ldst_swap(ctx);
8458 break;
8459 case OPCM_32_ABS_LDST_CONTEXT:
8460 decode_abs_ldst_context(ctx);
8461 break;
8462 case OPCM_32_ABS_STORE:
8463 decode_abs_store(ctx);
8464 break;
8465 case OPCM_32_ABS_STOREB_H:
8466 decode_abs_storeb_h(ctx);
8467 break;
8468 case OPC1_32_ABS_STOREQ:
8469 address = MASK_OP_ABS_OFF18(ctx->opcode);
8470 r1 = MASK_OP_ABS_S1D(ctx->opcode);
8471 temp = tcg_const_i32(EA_ABS_FORMAT(address));
8472 temp2 = tcg_temp_new();
8473
8474 tcg_gen_shri_tl(temp2, cpu_gpr_d[r1], 16);
8475 tcg_gen_qemu_st_tl(temp2, temp, ctx->mem_idx, MO_LEUW);
8476
8477 tcg_temp_free(temp2);
8478 tcg_temp_free(temp);
8479 break;
8480 case OPC1_32_ABS_LD_Q:
8481 address = MASK_OP_ABS_OFF18(ctx->opcode);
8482 r1 = MASK_OP_ABS_S1D(ctx->opcode);
8483 temp = tcg_const_i32(EA_ABS_FORMAT(address));
8484
8485 tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
8486 tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
8487
8488 tcg_temp_free(temp);
8489 break;
8490 case OPC1_32_ABS_LEA:
8491 address = MASK_OP_ABS_OFF18(ctx->opcode);
8492 r1 = MASK_OP_ABS_S1D(ctx->opcode);
8493 tcg_gen_movi_tl(cpu_gpr_a[r1], EA_ABS_FORMAT(address));
8494 break;
8495 /* ABSB-format */
8496 case OPC1_32_ABSB_ST_T:
8497 address = MASK_OP_ABS_OFF18(ctx->opcode);
8498 b = MASK_OP_ABSB_B(ctx->opcode);
8499 bpos = MASK_OP_ABSB_BPOS(ctx->opcode);
8500
8501 temp = tcg_const_i32(EA_ABS_FORMAT(address));
8502 temp2 = tcg_temp_new();
8503
8504 tcg_gen_qemu_ld_tl(temp2, temp, ctx->mem_idx, MO_UB);
8505 tcg_gen_andi_tl(temp2, temp2, ~(0x1u << bpos));
8506 tcg_gen_ori_tl(temp2, temp2, (b << bpos));
8507 tcg_gen_qemu_st_tl(temp2, temp, ctx->mem_idx, MO_UB);
8508
8509 tcg_temp_free(temp);
8510 tcg_temp_free(temp2);
8511 break;
8512 /* B-format */
8513 case OPC1_32_B_CALL:
8514 case OPC1_32_B_CALLA:
8515 case OPC1_32_B_FCALL:
8516 case OPC1_32_B_FCALLA:
8517 case OPC1_32_B_J:
8518 case OPC1_32_B_JA:
8519 case OPC1_32_B_JL:
8520 case OPC1_32_B_JLA:
8521 address = MASK_OP_B_DISP24_SEXT(ctx->opcode);
8522 gen_compute_branch(ctx, op1, 0, 0, 0, address);
8523 break;
8524 /* Bit-format */
8525 case OPCM_32_BIT_ANDACC:
8526 decode_bit_andacc(ctx);
8527 break;
8528 case OPCM_32_BIT_LOGICAL_T1:
8529 decode_bit_logical_t(ctx);
8530 break;
8531 case OPCM_32_BIT_INSERT:
8532 decode_bit_insert(ctx);
8533 break;
8534 case OPCM_32_BIT_LOGICAL_T2:
8535 decode_bit_logical_t2(ctx);
8536 break;
8537 case OPCM_32_BIT_ORAND:
8538 decode_bit_orand(ctx);
8539 break;
8540 case OPCM_32_BIT_SH_LOGIC1:
8541 decode_bit_sh_logic1(ctx);
8542 break;
8543 case OPCM_32_BIT_SH_LOGIC2:
8544 decode_bit_sh_logic2(ctx);
8545 break;
8546 /* BO Format */
8547 case OPCM_32_BO_ADDRMODE_POST_PRE_BASE:
8548 decode_bo_addrmode_post_pre_base(ctx);
8549 break;
8550 case OPCM_32_BO_ADDRMODE_BITREVERSE_CIRCULAR:
8551 decode_bo_addrmode_bitreverse_circular(ctx);
8552 break;
8553 case OPCM_32_BO_ADDRMODE_LD_POST_PRE_BASE:
8554 decode_bo_addrmode_ld_post_pre_base(ctx);
8555 break;
8556 case OPCM_32_BO_ADDRMODE_LD_BITREVERSE_CIRCULAR:
8557 decode_bo_addrmode_ld_bitreverse_circular(ctx);
8558 break;
8559 case OPCM_32_BO_ADDRMODE_STCTX_POST_PRE_BASE:
8560 decode_bo_addrmode_stctx_post_pre_base(ctx);
8561 break;
8562 case OPCM_32_BO_ADDRMODE_LDMST_BITREVERSE_CIRCULAR:
8563 decode_bo_addrmode_ldmst_bitreverse_circular(ctx);
8564 break;
8565 /* BOL-format */
8566 case OPC1_32_BOL_LD_A_LONGOFF:
8567 case OPC1_32_BOL_LD_W_LONGOFF:
8568 case OPC1_32_BOL_LEA_LONGOFF:
8569 case OPC1_32_BOL_ST_W_LONGOFF:
8570 case OPC1_32_BOL_ST_A_LONGOFF:
8571 case OPC1_32_BOL_LD_B_LONGOFF:
8572 case OPC1_32_BOL_LD_BU_LONGOFF:
8573 case OPC1_32_BOL_LD_H_LONGOFF:
8574 case OPC1_32_BOL_LD_HU_LONGOFF:
8575 case OPC1_32_BOL_ST_B_LONGOFF:
8576 case OPC1_32_BOL_ST_H_LONGOFF:
8577 decode_bol_opc(ctx, op1);
8578 break;
8579 /* BRC Format */
8580 case OPCM_32_BRC_EQ_NEQ:
8581 case OPCM_32_BRC_GE:
8582 case OPCM_32_BRC_JLT:
8583 case OPCM_32_BRC_JNE:
8584 const4 = MASK_OP_BRC_CONST4_SEXT(ctx->opcode);
8585 address = MASK_OP_BRC_DISP15_SEXT(ctx->opcode);
8586 r1 = MASK_OP_BRC_S1(ctx->opcode);
8587 gen_compute_branch(ctx, op1, r1, 0, const4, address);
8588 break;
8589 /* BRN Format */
8590 case OPCM_32_BRN_JTT:
8591 address = MASK_OP_BRN_DISP15_SEXT(ctx->opcode);
8592 r1 = MASK_OP_BRN_S1(ctx->opcode);
8593 gen_compute_branch(ctx, op1, r1, 0, 0, address);
8594 break;
8595 /* BRR Format */
8596 case OPCM_32_BRR_EQ_NEQ:
8597 case OPCM_32_BRR_ADDR_EQ_NEQ:
8598 case OPCM_32_BRR_GE:
8599 case OPCM_32_BRR_JLT:
8600 case OPCM_32_BRR_JNE:
8601 case OPCM_32_BRR_JNZ:
8602 case OPCM_32_BRR_LOOP:
8603 address = MASK_OP_BRR_DISP15_SEXT(ctx->opcode);
8604 r2 = MASK_OP_BRR_S2(ctx->opcode);
8605 r1 = MASK_OP_BRR_S1(ctx->opcode);
8606 gen_compute_branch(ctx, op1, r1, r2, 0, address);
8607 break;
8608 /* RC Format */
8609 case OPCM_32_RC_LOGICAL_SHIFT:
8610 decode_rc_logical_shift(ctx);
8611 break;
8612 case OPCM_32_RC_ACCUMULATOR:
8613 decode_rc_accumulator(ctx);
8614 break;
8615 case OPCM_32_RC_SERVICEROUTINE:
8616 decode_rc_serviceroutine(ctx);
8617 break;
8618 case OPCM_32_RC_MUL:
8619 decode_rc_mul(ctx);
8620 break;
8621 /* RCPW Format */
8622 case OPCM_32_RCPW_MASK_INSERT:
8623 decode_rcpw_insert(ctx);
8624 break;
8625 /* RCRR Format */
8626 case OPC1_32_RCRR_INSERT:
8627 r1 = MASK_OP_RCRR_S1(ctx->opcode);
8628 r2 = MASK_OP_RCRR_S3(ctx->opcode);
8629 r3 = MASK_OP_RCRR_D(ctx->opcode);
8630 const16 = MASK_OP_RCRR_CONST4(ctx->opcode);
8631 temp = tcg_const_i32(const16);
8632 temp2 = tcg_temp_new(); /* width*/
8633 temp3 = tcg_temp_new(); /* pos */
8634
8635 CHECK_REG_PAIR(r3);
8636
8637 tcg_gen_andi_tl(temp2, cpu_gpr_d[r3+1], 0x1f);
8638 tcg_gen_andi_tl(temp3, cpu_gpr_d[r3], 0x1f);
8639
8640 gen_insert(cpu_gpr_d[r2], cpu_gpr_d[r1], temp, temp2, temp3);
8641
8642 tcg_temp_free(temp);
8643 tcg_temp_free(temp2);
8644 tcg_temp_free(temp3);
8645 break;
8646 /* RCRW Format */
8647 case OPCM_32_RCRW_MASK_INSERT:
8648 decode_rcrw_insert(ctx);
8649 break;
8650 /* RCR Format */
8651 case OPCM_32_RCR_COND_SELECT:
8652 decode_rcr_cond_select(ctx);
8653 break;
8654 case OPCM_32_RCR_MADD:
8655 decode_rcr_madd(ctx);
8656 break;
8657 case OPCM_32_RCR_MSUB:
8658 decode_rcr_msub(ctx);
8659 break;
8660 /* RLC Format */
8661 case OPC1_32_RLC_ADDI:
8662 case OPC1_32_RLC_ADDIH:
8663 case OPC1_32_RLC_ADDIH_A:
8664 case OPC1_32_RLC_MFCR:
8665 case OPC1_32_RLC_MOV:
8666 case OPC1_32_RLC_MOV_64:
8667 case OPC1_32_RLC_MOV_U:
8668 case OPC1_32_RLC_MOV_H:
8669 case OPC1_32_RLC_MOVH_A:
8670 case OPC1_32_RLC_MTCR:
8671 decode_rlc_opc(ctx, op1);
8672 break;
8673 /* RR Format */
8674 case OPCM_32_RR_ACCUMULATOR:
8675 decode_rr_accumulator(ctx);
8676 break;
8677 case OPCM_32_RR_LOGICAL_SHIFT:
8678 decode_rr_logical_shift(ctx);
8679 break;
8680 case OPCM_32_RR_ADDRESS:
8681 decode_rr_address(ctx);
8682 break;
8683 case OPCM_32_RR_IDIRECT:
8684 decode_rr_idirect(ctx);
8685 break;
8686 case OPCM_32_RR_DIVIDE:
8687 decode_rr_divide(ctx);
8688 break;
8689 /* RR1 Format */
8690 case OPCM_32_RR1_MUL:
8691 decode_rr1_mul(ctx);
8692 break;
8693 case OPCM_32_RR1_MULQ:
8694 decode_rr1_mulq(ctx);
8695 break;
8696 /* RR2 format */
8697 case OPCM_32_RR2_MUL:
8698 decode_rr2_mul(ctx);
8699 break;
8700 /* RRPW format */
8701 case OPCM_32_RRPW_EXTRACT_INSERT:
8702 decode_rrpw_extract_insert(ctx);
8703 break;
8704 case OPC1_32_RRPW_DEXTR:
8705 r1 = MASK_OP_RRPW_S1(ctx->opcode);
8706 r2 = MASK_OP_RRPW_S2(ctx->opcode);
8707 r3 = MASK_OP_RRPW_D(ctx->opcode);
8708 const16 = MASK_OP_RRPW_POS(ctx->opcode);
8709 if (r1 == r2) {
8710 tcg_gen_rotli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], const16);
8711 } else {
8712 temp = tcg_temp_new();
8713 tcg_gen_shli_tl(temp, cpu_gpr_d[r1], const16);
8714 tcg_gen_shri_tl(cpu_gpr_d[r3], cpu_gpr_d[r2], 32 - const16);
8715 tcg_gen_or_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
8716 tcg_temp_free(temp);
8717 }
8718 break;
8719 /* RRR Format */
8720 case OPCM_32_RRR_COND_SELECT:
8721 decode_rrr_cond_select(ctx);
8722 break;
8723 case OPCM_32_RRR_DIVIDE:
8724 decode_rrr_divide(ctx);
8725 break;
8726 /* RRR2 Format */
8727 case OPCM_32_RRR2_MADD:
8728 decode_rrr2_madd(ctx);
8729 break;
8730 case OPCM_32_RRR2_MSUB:
8731 decode_rrr2_msub(ctx);
8732 break;
8733 /* RRR1 format */
8734 case OPCM_32_RRR1_MADD:
8735 decode_rrr1_madd(ctx);
8736 break;
8737 case OPCM_32_RRR1_MADDQ_H:
8738 decode_rrr1_maddq_h(ctx);
8739 break;
8740 case OPCM_32_RRR1_MADDSU_H:
8741 decode_rrr1_maddsu_h(ctx);
8742 break;
8743 case OPCM_32_RRR1_MSUB_H:
8744 decode_rrr1_msub(ctx);
8745 break;
8746 case OPCM_32_RRR1_MSUB_Q:
8747 decode_rrr1_msubq_h(ctx);
8748 break;
8749 case OPCM_32_RRR1_MSUBAD_H:
8750 decode_rrr1_msubad_h(ctx);
8751 break;
8752 /* RRRR format */
8753 case OPCM_32_RRRR_EXTRACT_INSERT:
8754 decode_rrrr_extract_insert(ctx);
8755 break;
8756 /* RRRW format */
8757 case OPCM_32_RRRW_EXTRACT_INSERT:
8758 decode_rrrw_extract_insert(ctx);
8759 break;
8760 /* SYS format */
8761 case OPCM_32_SYS_INTERRUPTS:
8762 decode_sys_interrupts(ctx);
8763 break;
8764 case OPC1_32_SYS_RSTV:
8765 tcg_gen_movi_tl(cpu_PSW_V, 0);
8766 tcg_gen_mov_tl(cpu_PSW_SV, cpu_PSW_V);
8767 tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
8768 tcg_gen_mov_tl(cpu_PSW_SAV, cpu_PSW_V);
8769 break;
8770 default:
8771 generate_trap(ctx, TRAPC_INSN_ERR, TIN2_IOPC);
8772 }
8773 }
8774
8775 static bool tricore_insn_is_16bit(uint32_t insn)
8776 {
8777 return (insn & 0x1) == 0;
8778 }
8779
8780 static void tricore_tr_init_disas_context(DisasContextBase *dcbase,
8781 CPUState *cs)
8782 {
8783 DisasContext *ctx = container_of(dcbase, DisasContext, base);
8784 CPUTriCoreState *env = cs->env_ptr;
8785 ctx->mem_idx = cpu_mmu_index(env, false);
8786 ctx->hflags = (uint32_t)ctx->base.tb->flags;
8787 ctx->features = env->features;
8788 }
8789
8790 static void tricore_tr_tb_start(DisasContextBase *db, CPUState *cpu)
8791 {
8792 }
8793
8794 static void tricore_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu)
8795 {
8796 DisasContext *ctx = container_of(dcbase, DisasContext, base);
8797
8798 tcg_gen_insn_start(ctx->base.pc_next);
8799 }
8800
8801 static bool insn_crosses_page(CPUTriCoreState *env, DisasContext *ctx)
8802 {
8803 /*
8804 * Return true if the insn at ctx->base.pc_next might cross a page boundary.
8805 * (False positives are OK, false negatives are not.)
8806 * Our caller ensures we are only called if dc->base.pc_next is less than
8807 * 4 bytes from the page boundary, so we cross the page if the first
8808 * 16 bits indicate that this is a 32 bit insn.
8809 */
8810 uint16_t insn = cpu_lduw_code(env, ctx->base.pc_next);
8811
8812 return !tricore_insn_is_16bit(insn);
8813 }
8814
8815
8816 static void tricore_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
8817 {
8818 DisasContext *ctx = container_of(dcbase, DisasContext, base);
8819 CPUTriCoreState *env = cpu->env_ptr;
8820 uint16_t insn_lo;
8821 bool is_16bit;
8822
8823 insn_lo = cpu_lduw_code(env, ctx->base.pc_next);
8824 is_16bit = tricore_insn_is_16bit(insn_lo);
8825 if (is_16bit) {
8826 ctx->opcode = insn_lo;
8827 ctx->pc_succ_insn = ctx->base.pc_next + 2;
8828 decode_16Bit_opc(ctx);
8829 } else {
8830 uint32_t insn_hi = cpu_lduw_code(env, ctx->base.pc_next + 2);
8831 ctx->opcode = insn_hi << 16 | insn_lo;
8832 ctx->pc_succ_insn = ctx->base.pc_next + 4;
8833 decode_32Bit_opc(ctx);
8834 }
8835 ctx->base.pc_next = ctx->pc_succ_insn;
8836
8837 if (ctx->base.is_jmp == DISAS_NEXT) {
8838 target_ulong page_start;
8839
8840 page_start = ctx->base.pc_first & TARGET_PAGE_MASK;
8841 if (ctx->base.pc_next - page_start >= TARGET_PAGE_SIZE
8842 || (ctx->base.pc_next - page_start >= TARGET_PAGE_SIZE - 3
8843 && insn_crosses_page(env, ctx))) {
8844 ctx->base.is_jmp = DISAS_TOO_MANY;
8845 }
8846 }
8847 }
8848
8849 static void tricore_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu)
8850 {
8851 DisasContext *ctx = container_of(dcbase, DisasContext, base);
8852
8853 switch (ctx->base.is_jmp) {
8854 case DISAS_TOO_MANY:
8855 gen_goto_tb(ctx, 0, ctx->base.pc_next);
8856 break;
8857 case DISAS_NORETURN:
8858 break;
8859 default:
8860 g_assert_not_reached();
8861 }
8862 }
8863
8864 static void tricore_tr_disas_log(const DisasContextBase *dcbase,
8865 CPUState *cpu, FILE *logfile)
8866 {
8867 fprintf(logfile, "IN: %s\n", lookup_symbol(dcbase->pc_first));
8868 target_disas(logfile, cpu, dcbase->pc_first, dcbase->tb->size);
8869 }
8870
8871 static const TranslatorOps tricore_tr_ops = {
8872 .init_disas_context = tricore_tr_init_disas_context,
8873 .tb_start = tricore_tr_tb_start,
8874 .insn_start = tricore_tr_insn_start,
8875 .translate_insn = tricore_tr_translate_insn,
8876 .tb_stop = tricore_tr_tb_stop,
8877 .disas_log = tricore_tr_disas_log,
8878 };
8879
8880
8881 void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int max_insns,
8882 target_ulong pc, void *host_pc)
8883 {
8884 DisasContext ctx;
8885 translator_loop(cs, tb, max_insns, pc, host_pc,
8886 &tricore_tr_ops, &ctx.base);
8887 }
8888
8889 /*
8890 *
8891 * Initialization
8892 *
8893 */
8894
8895 void cpu_state_reset(CPUTriCoreState *env)
8896 {
8897 /* Reset Regs to Default Value */
8898 env->PSW = 0xb80;
8899 fpu_set_state(env);
8900 }
8901
8902 static void tricore_tcg_init_csfr(void)
8903 {
8904 cpu_PCXI = tcg_global_mem_new(cpu_env,
8905 offsetof(CPUTriCoreState, PCXI), "PCXI");
8906 cpu_PSW = tcg_global_mem_new(cpu_env,
8907 offsetof(CPUTriCoreState, PSW), "PSW");
8908 cpu_PC = tcg_global_mem_new(cpu_env,
8909 offsetof(CPUTriCoreState, PC), "PC");
8910 cpu_ICR = tcg_global_mem_new(cpu_env,
8911 offsetof(CPUTriCoreState, ICR), "ICR");
8912 }
8913
8914 void tricore_tcg_init(void)
8915 {
8916 int i;
8917
8918 /* reg init */
8919 for (i = 0 ; i < 16 ; i++) {
8920 cpu_gpr_a[i] = tcg_global_mem_new(cpu_env,
8921 offsetof(CPUTriCoreState, gpr_a[i]),
8922 regnames_a[i]);
8923 }
8924 for (i = 0 ; i < 16 ; i++) {
8925 cpu_gpr_d[i] = tcg_global_mem_new(cpu_env,
8926 offsetof(CPUTriCoreState, gpr_d[i]),
8927 regnames_d[i]);
8928 }
8929 tricore_tcg_init_csfr();
8930 /* init PSW flag cache */
8931 cpu_PSW_C = tcg_global_mem_new(cpu_env,
8932 offsetof(CPUTriCoreState, PSW_USB_C),
8933 "PSW_C");
8934 cpu_PSW_V = tcg_global_mem_new(cpu_env,
8935 offsetof(CPUTriCoreState, PSW_USB_V),
8936 "PSW_V");
8937 cpu_PSW_SV = tcg_global_mem_new(cpu_env,
8938 offsetof(CPUTriCoreState, PSW_USB_SV),
8939 "PSW_SV");
8940 cpu_PSW_AV = tcg_global_mem_new(cpu_env,
8941 offsetof(CPUTriCoreState, PSW_USB_AV),
8942 "PSW_AV");
8943 cpu_PSW_SAV = tcg_global_mem_new(cpu_env,
8944 offsetof(CPUTriCoreState, PSW_USB_SAV),
8945 "PSW_SAV");
8946 }
QEMU mirror