target-tricore/translate.c

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