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