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