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 "cpu.h"
  22 #include "disas/disas.h"
  23 #include "tcg-op.h"
  24 #include "exec/cpu_ldst.h"
  25
  26 #include "exec/helper-proto.h"
  27 #include "exec/helper-gen.h"
  28
  29 #include "tricore-opcodes.h"
  30
  31 /*
  32  * TCG registers
  33  */
  34 static TCGv cpu_PC;
  35 static TCGv cpu_PCXI;
  36 static TCGv cpu_PSW;
  37 static TCGv cpu_ICR;
  38 /* GPR registers */
  39 static TCGv cpu_gpr_a[16];
  40 static TCGv cpu_gpr_d[16];
  41 /* PSW Flag cache */
  42 static TCGv cpu_PSW_C;
  43 static TCGv cpu_PSW_V;
  44 static TCGv cpu_PSW_SV;
  45 static TCGv cpu_PSW_AV;
  46 static TCGv cpu_PSW_SAV;
  47 /* CPU env */
  48 static TCGv_ptr cpu_env;
  49
  50 #include "exec/gen-icount.h"
  51
  52 static const char *regnames_a[] = {
  53       "a0"  , "a1"  , "a2"  , "a3" , "a4"  , "a5" ,
  54       "a6"  , "a7"  , "a8"  , "a9" , "sp" , "a11" ,
  55       "a12" , "a13" , "a14" , "a15",
  56     };
  57
  58 static const char *regnames_d[] = {
  59       "d0"  , "d1"  , "d2"  , "d3" , "d4"  , "d5"  ,
  60       "d6"  , "d7"  , "d8"  , "d9" , "d10" , "d11" ,
  61       "d12" , "d13" , "d14" , "d15",
  62     };
  63
  64 typedef struct DisasContext {
  65     struct TranslationBlock *tb;
  66     target_ulong pc, saved_pc, next_pc;
  67     uint32_t opcode;
  68     int singlestep_enabled;
  69     /* Routine used to access memory */
  70     int mem_idx;
  71     uint32_t hflags, saved_hflags;
  72     int bstate;
  73 } DisasContext;
  74
  75 enum {
  76
  77     BS_NONE   = 0,
  78     BS_STOP   = 1,
  79     BS_BRANCH = 2,
  80     BS_EXCP   = 3,
  81 };
  82
  83 void tricore_cpu_dump_state(CPUState *cs, FILE *f,
  84                             fprintf_function cpu_fprintf, int flags)
  85 {
  86     TriCoreCPU *cpu = TRICORE_CPU(cs);
  87     CPUTriCoreState *env = &cpu->env;
  88     uint32_t psw;
  89     int i;
  90
  91     psw = psw_read(env);
  92
  93     cpu_fprintf(f, "PC: " TARGET_FMT_lx, env->PC);
  94     cpu_fprintf(f, " PSW: " TARGET_FMT_lx, psw);
  95     cpu_fprintf(f, " ICR: " TARGET_FMT_lx, env->ICR);
  96     cpu_fprintf(f, "\nPCXI: " TARGET_FMT_lx, env->PCXI);
  97     cpu_fprintf(f, " FCX: " TARGET_FMT_lx, env->FCX);
  98     cpu_fprintf(f, " LCX: " TARGET_FMT_lx, env->LCX);
  99
 100     for (i = 0; i < 16; ++i) {
 101         if ((i & 3) == 0) {
 102             cpu_fprintf(f, "\nGPR A%02d:", i);
 103         }
 104         cpu_fprintf(f, " " TARGET_FMT_lx, env->gpr_a[i]);
 105     }
 106     for (i = 0; i < 16; ++i) {
 107         if ((i & 3) == 0) {
 108             cpu_fprintf(f, "\nGPR D%02d:", i);
 109         }
 110         cpu_fprintf(f, " " TARGET_FMT_lx, env->gpr_d[i]);
 111     }
 112     cpu_fprintf(f, "\n");
 113 }
 114
 115 /*
 116  * Functions to generate micro-ops
 117  */
 118
 119 /* Makros for generating helpers */
 120
 121 #define gen_helper_1arg(name, arg) do {                           \
 122     TCGv_i32 helper_tmp = tcg_const_i32(arg);                     \
 123     gen_helper_##name(cpu_env, helper_tmp);                       \
 124     tcg_temp_free_i32(helper_tmp);                                \
 125     } while (0)
 126
 127 #define GEN_HELPER_LL(name, ret, arg0, arg1, n) do {         \
 128     TCGv arg00 = tcg_temp_new();                             \
 129     TCGv arg01 = tcg_temp_new();                             \
 130     TCGv arg11 = tcg_temp_new();                             \
 131     tcg_gen_sari_tl(arg00, arg0, 16);                        \
 132     tcg_gen_ext16s_tl(arg01, arg0);                          \
 133     tcg_gen_ext16s_tl(arg11, arg1);                          \
 134     gen_helper_##name(ret, arg00, arg01, arg11, arg11, n);   \
 135     tcg_temp_free(arg00);                                    \
 136     tcg_temp_free(arg01);                                    \
 137     tcg_temp_free(arg11);                                    \
 138 } while (0)
 139
 140 #define GEN_HELPER_LU(name, ret, arg0, arg1, n) do {         \
 141     TCGv arg00 = tcg_temp_new();                             \
 142     TCGv arg01 = tcg_temp_new();                             \
 143     TCGv arg10 = tcg_temp_new();                             \
 144     TCGv arg11 = tcg_temp_new();                             \
 145     tcg_gen_sari_tl(arg00, arg0, 16);                        \
 146     tcg_gen_ext16s_tl(arg01, arg0);                          \
 147     tcg_gen_sari_tl(arg11, arg1, 16);                        \
 148     tcg_gen_ext16s_tl(arg10, arg1);                          \
 149     gen_helper_##name(ret, arg00, arg01, arg10, arg11, n);   \
 150     tcg_temp_free(arg00);                                    \
 151     tcg_temp_free(arg01);                                    \
 152     tcg_temp_free(arg10);                                    \
 153     tcg_temp_free(arg11);                                    \
 154 } while (0)
 155
 156 #define GEN_HELPER_UL(name, ret, arg0, arg1, n) do {         \
 157     TCGv arg00 = tcg_temp_new();                             \
 158     TCGv arg01 = tcg_temp_new();                             \
 159     TCGv arg10 = tcg_temp_new();                             \
 160     TCGv arg11 = tcg_temp_new();                             \
 161     tcg_gen_sari_tl(arg00, arg0, 16);                        \
 162     tcg_gen_ext16s_tl(arg01, arg0);                          \
 163     tcg_gen_sari_tl(arg10, arg1, 16);                        \
 164     tcg_gen_ext16s_tl(arg11, arg1);                          \
 165     gen_helper_##name(ret, arg00, arg01, arg10, arg11, n);   \
 166     tcg_temp_free(arg00);                                    \
 167     tcg_temp_free(arg01);                                    \
 168     tcg_temp_free(arg10);                                    \
 169     tcg_temp_free(arg11);                                    \
 170 } while (0)
 171
 172 #define GEN_HELPER_UU(name, ret, arg0, arg1, n) do {         \
 173     TCGv arg00 = tcg_temp_new();                             \
 174     TCGv arg01 = tcg_temp_new();                             \
 175     TCGv arg11 = tcg_temp_new();                             \
 176     tcg_gen_sari_tl(arg01, arg0, 16);                        \
 177     tcg_gen_ext16s_tl(arg00, arg0);                          \
 178     tcg_gen_sari_tl(arg11, arg1, 16);                        \
 179     gen_helper_##name(ret, arg00, arg01, arg11, arg11, n);   \
 180     tcg_temp_free(arg00);                                    \
 181     tcg_temp_free(arg01);                                    \
 182     tcg_temp_free(arg11);                                    \
 183 } while (0)
 184
 185 #define GEN_HELPER_RRR(name, rl, rh, al1, ah1, arg2) do {    \
 186     TCGv_i64 ret = tcg_temp_new_i64();                       \
 187     TCGv_i64 arg1 = tcg_temp_new_i64();                      \
 188                                                              \
 189     tcg_gen_concat_i32_i64(arg1, al1, ah1);                  \
 190     gen_helper_##name(ret, arg1, arg2);                      \
 191     tcg_gen_extr_i64_i32(rl, rh, ret);                       \
 192                                                              \
 193     tcg_temp_free_i64(ret);                                  \
 194     tcg_temp_free_i64(arg1);                                 \
 195 } while (0)
 196
 197 #define EA_ABS_FORMAT(con) (((con & 0x3C000) << 14) + (con & 0x3FFF))
 198 #define EA_B_ABSOLUT(con) (((offset & 0xf00000) << 8) | \
 199                            ((offset & 0x0fffff) << 1))
 200
 201 /* Functions for load/save to/from memory */
 202
 203 static inline void gen_offset_ld(DisasContext *ctx, TCGv r1, TCGv r2,
 204                                  int16_t con, TCGMemOp mop)
 205 {
 206     TCGv temp = tcg_temp_new();
 207     tcg_gen_addi_tl(temp, r2, con);
 208     tcg_gen_qemu_ld_tl(r1, temp, ctx->mem_idx, mop);
 209     tcg_temp_free(temp);
 210 }
 211
 212 static inline void gen_offset_st(DisasContext *ctx, TCGv r1, TCGv r2,
 213                                  int16_t con, TCGMemOp mop)
 214 {
 215     TCGv temp = tcg_temp_new();
 216     tcg_gen_addi_tl(temp, r2, con);
 217     tcg_gen_qemu_st_tl(r1, temp, ctx->mem_idx, mop);
 218     tcg_temp_free(temp);
 219 }
 220
 221 static void gen_st_2regs_64(TCGv rh, TCGv rl, TCGv address, DisasContext *ctx)
 222 {
 223     TCGv_i64 temp = tcg_temp_new_i64();
 224
 225     tcg_gen_concat_i32_i64(temp, rl, rh);
 226     tcg_gen_qemu_st_i64(temp, address, ctx->mem_idx, MO_LEQ);
 227
 228     tcg_temp_free_i64(temp);
 229 }
 230
 231 static void gen_offset_st_2regs(TCGv rh, TCGv rl, TCGv base, int16_t con,
 232                                 DisasContext *ctx)
 233 {
 234     TCGv temp = tcg_temp_new();
 235     tcg_gen_addi_tl(temp, base, con);
 236     gen_st_2regs_64(rh, rl, temp, ctx);
 237     tcg_temp_free(temp);
 238 }
 239
 240 static void gen_ld_2regs_64(TCGv rh, TCGv rl, TCGv address, DisasContext *ctx)
 241 {
 242     TCGv_i64 temp = tcg_temp_new_i64();
 243
 244     tcg_gen_qemu_ld_i64(temp, address, ctx->mem_idx, MO_LEQ);
 245     /* write back to two 32 bit regs */
 246     tcg_gen_extr_i64_i32(rl, rh, temp);
 247
 248     tcg_temp_free_i64(temp);
 249 }
 250
 251 static void gen_offset_ld_2regs(TCGv rh, TCGv rl, TCGv base, int16_t con,
 252                                 DisasContext *ctx)
 253 {
 254     TCGv temp = tcg_temp_new();
 255     tcg_gen_addi_tl(temp, base, con);
 256     gen_ld_2regs_64(rh, rl, temp, ctx);
 257     tcg_temp_free(temp);
 258 }
 259
 260 static void gen_st_preincr(DisasContext *ctx, TCGv r1, TCGv r2, int16_t off,
 261                            TCGMemOp mop)
 262 {
 263     TCGv temp = tcg_temp_new();
 264     tcg_gen_addi_tl(temp, r2, off);
 265     tcg_gen_qemu_st_tl(r1, temp, ctx->mem_idx, mop);
 266     tcg_gen_mov_tl(r2, temp);
 267     tcg_temp_free(temp);
 268 }
 269
 270 static void gen_ld_preincr(DisasContext *ctx, TCGv r1, TCGv r2, int16_t off,
 271                            TCGMemOp mop)
 272 {
 273     TCGv temp = tcg_temp_new();
 274     tcg_gen_addi_tl(temp, r2, off);
 275     tcg_gen_qemu_ld_tl(r1, temp, ctx->mem_idx, mop);
 276     tcg_gen_mov_tl(r2, temp);
 277     tcg_temp_free(temp);
 278 }
 279
 280 /* M(EA, word) = (M(EA, word) & ~E[a][63:32]) | (E[a][31:0] & E[a][63:32]); */
 281 static void gen_ldmst(DisasContext *ctx, int ereg, TCGv ea)
 282 {
 283     TCGv temp = tcg_temp_new();
 284     TCGv temp2 = tcg_temp_new();
 285
 286     /* temp = (M(EA, word) */
 287     tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
 288     /* temp = temp & ~E[a][63:32]) */
 289     tcg_gen_andc_tl(temp, temp, cpu_gpr_d[ereg+1]);
 290     /* temp2 = (E[a][31:0] & E[a][63:32]); */
 291     tcg_gen_and_tl(temp2, cpu_gpr_d[ereg], cpu_gpr_d[ereg+1]);
 292     /* temp = temp | temp2; */
 293     tcg_gen_or_tl(temp, temp, temp2);
 294     /* M(EA, word) = temp; */
 295     tcg_gen_qemu_st_tl(temp, ea, ctx->mem_idx, MO_LEUL);
 296
 297     tcg_temp_free(temp);
 298     tcg_temp_free(temp2);
 299 }
 300
 301 /* tmp = M(EA, word);
 302    M(EA, word) = D[a];
 303    D[a] = tmp[31:0];*/
 304 static void gen_swap(DisasContext *ctx, int reg, TCGv ea)
 305 {
 306     TCGv temp = tcg_temp_new();
 307
 308     tcg_gen_qemu_ld_tl(temp, ea, ctx->mem_idx, MO_LEUL);
 309     tcg_gen_qemu_st_tl(cpu_gpr_d[reg], ea, ctx->mem_idx, MO_LEUL);
 310     tcg_gen_mov_tl(cpu_gpr_d[reg], temp);
 311
 312     tcg_temp_free(temp);
 313 }
 314
 315 /* We generate loads and store to core special function register (csfr) through
 316    the function gen_mfcr and gen_mtcr. To handle access permissions, we use 3
 317    makros R, A and E, which allow read-only, all and endinit protected access.
 318    These makros also specify in which ISA version the csfr was introduced. */
 319 #define R(ADDRESS, REG, FEATURE)                                         \
 320     case ADDRESS:                                                        \
 321         if (tricore_feature(env, FEATURE)) {                             \
 322             tcg_gen_ld_tl(ret, cpu_env, offsetof(CPUTriCoreState, REG)); \
 323         }                                                                \
 324         break;
 325 #define A(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE)
 326 #define E(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE)
 327 static inline void gen_mfcr(CPUTriCoreState *env, TCGv ret, int32_t offset)
 328 {
 329     /* since we're caching PSW make this a special case */
 330     if (offset == 0xfe04) {
 331         gen_helper_psw_read(ret, cpu_env);
 332     } else {
 333         switch (offset) {
 334 #include "csfr.def"
 335         }
 336     }
 337 }
 338 #undef R
 339 #undef A
 340 #undef E
 341
 342 #define R(ADDRESS, REG, FEATURE) /* don't gen writes to read-only reg,
 343                                     since no execption occurs */
 344 #define A(ADDRESS, REG, FEATURE) R(ADDRESS, REG, FEATURE)                \
 345     case ADDRESS:                                                        \
 346         if (tricore_feature(env, FEATURE)) {                             \
 347             tcg_gen_st_tl(r1, cpu_env, offsetof(CPUTriCoreState, REG));  \
 348         }                                                                \
 349         break;
 350 /* Endinit protected registers
 351    TODO: Since the endinit bit is in a register of a not yet implemented
 352          watchdog device, we handle endinit protected registers like
 353          all-access registers for now. */
 354 #define E(ADDRESS, REG, FEATURE) A(ADDRESS, REG, FEATURE)
 355 static inline void gen_mtcr(CPUTriCoreState *env, DisasContext *ctx, TCGv r1,
 356                             int32_t offset)
 357 {
 358     if ((ctx->hflags & TRICORE_HFLAG_KUU) == TRICORE_HFLAG_SM) {
 359         /* since we're caching PSW make this a special case */
 360         if (offset == 0xfe04) {
 361             gen_helper_psw_write(cpu_env, r1);
 362         } else {
 363             switch (offset) {
 364 #include "csfr.def"
 365             }
 366         }
 367     } else {
 368         /* generate privilege trap */
 369     }
 370 }
 371
 372 /* Functions for arithmetic instructions  */
 373
 374 static inline void gen_add_d(TCGv ret, TCGv r1, TCGv r2)
 375 {
 376     TCGv t0 = tcg_temp_new_i32();
 377     TCGv result = tcg_temp_new_i32();
 378     /* Addition and set V/SV bits */
 379     tcg_gen_add_tl(result, r1, r2);
 380     /* calc V bit */
 381     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 382     tcg_gen_xor_tl(t0, r1, r2);
 383     tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
 384     /* Calc SV bit */
 385     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 386     /* Calc AV/SAV bits */
 387     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 388     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 389     /* calc SAV */
 390     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 391     /* write back result */
 392     tcg_gen_mov_tl(ret, result);
 393
 394     tcg_temp_free(result);
 395     tcg_temp_free(t0);
 396 }
 397
 398 /* ret = r2 + (r1 * r3); */
 399 static inline void gen_madd32_d(TCGv ret, TCGv r1, TCGv r2, TCGv r3)
 400 {
 401     TCGv_i64 t1 = tcg_temp_new_i64();
 402     TCGv_i64 t2 = tcg_temp_new_i64();
 403     TCGv_i64 t3 = tcg_temp_new_i64();
 404
 405     tcg_gen_ext_i32_i64(t1, r1);
 406     tcg_gen_ext_i32_i64(t2, r2);
 407     tcg_gen_ext_i32_i64(t3, r3);
 408
 409     tcg_gen_mul_i64(t1, t1, t3);
 410     tcg_gen_add_i64(t1, t2, t1);
 411
 412     tcg_gen_trunc_i64_i32(ret, t1);
 413     /* calc V
 414        t1 > 0x7fffffff */
 415     tcg_gen_setcondi_i64(TCG_COND_GT, t3, t1, 0x7fffffffLL);
 416     /* t1 < -0x80000000 */
 417     tcg_gen_setcondi_i64(TCG_COND_LT, t2, t1, -0x80000000LL);
 418     tcg_gen_or_i64(t2, t2, t3);
 419     tcg_gen_trunc_i64_i32(cpu_PSW_V, t2);
 420     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 421     /* Calc SV bit */
 422     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 423     /* Calc AV/SAV bits */
 424     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
 425     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
 426     /* calc SAV */
 427     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 428
 429     tcg_temp_free_i64(t1);
 430     tcg_temp_free_i64(t2);
 431     tcg_temp_free_i64(t3);
 432 }
 433
 434 static inline void gen_maddi32_d(TCGv ret, TCGv r1, TCGv r2, int32_t con)
 435 {
 436     TCGv temp = tcg_const_i32(con);
 437     gen_madd32_d(ret, r1, r2, temp);
 438     tcg_temp_free(temp);
 439 }
 440
 441 static inline void
 442 gen_madd64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 443              TCGv r3)
 444 {
 445     TCGv t1 = tcg_temp_new();
 446     TCGv t2 = tcg_temp_new();
 447     TCGv t3 = tcg_temp_new();
 448     TCGv t4 = tcg_temp_new();
 449
 450     tcg_gen_muls2_tl(t1, t2, r1, r3);
 451     /* only the add can overflow */
 452     tcg_gen_add2_tl(t3, t4, r2_low, r2_high, t1, t2);
 453     /* calc V bit */
 454     tcg_gen_xor_tl(cpu_PSW_V, t4, r2_high);
 455     tcg_gen_xor_tl(t1, r2_high, t2);
 456     tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t1);
 457     /* Calc SV bit */
 458     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 459     /* Calc AV/SAV bits */
 460     tcg_gen_add_tl(cpu_PSW_AV, t4, t4);
 461     tcg_gen_xor_tl(cpu_PSW_AV, t4, cpu_PSW_AV);
 462     /* calc SAV */
 463     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 464     /* write back the result */
 465     tcg_gen_mov_tl(ret_low, t3);
 466     tcg_gen_mov_tl(ret_high, t4);
 467
 468     tcg_temp_free(t1);
 469     tcg_temp_free(t2);
 470     tcg_temp_free(t3);
 471     tcg_temp_free(t4);
 472 }
 473
 474 static inline void
 475 gen_maddu64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 476               TCGv r3)
 477 {
 478     TCGv_i64 t1 = tcg_temp_new_i64();
 479     TCGv_i64 t2 = tcg_temp_new_i64();
 480     TCGv_i64 t3 = tcg_temp_new_i64();
 481
 482     tcg_gen_extu_i32_i64(t1, r1);
 483     tcg_gen_concat_i32_i64(t2, r2_low, r2_high);
 484     tcg_gen_extu_i32_i64(t3, r3);
 485
 486     tcg_gen_mul_i64(t1, t1, t3);
 487     tcg_gen_add_i64(t2, t2, t1);
 488     /* write back result */
 489     tcg_gen_extr_i64_i32(ret_low, ret_high, t2);
 490     /* only the add overflows, if t2 < t1
 491        calc V bit */
 492     tcg_gen_setcond_i64(TCG_COND_LTU, t2, t2, t1);
 493     tcg_gen_trunc_i64_i32(cpu_PSW_V, t2);
 494     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 495     /* Calc SV bit */
 496     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 497     /* Calc AV/SAV bits */
 498     tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
 499     tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
 500     /* calc SAV */
 501     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 502
 503     tcg_temp_free_i64(t1);
 504     tcg_temp_free_i64(t2);
 505     tcg_temp_free_i64(t3);
 506 }
 507
 508 static inline void
 509 gen_maddi64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 510               int32_t con)
 511 {
 512     TCGv temp = tcg_const_i32(con);
 513     gen_madd64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
 514     tcg_temp_free(temp);
 515 }
 516
 517 static inline void
 518 gen_maddui64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 519                int32_t con)
 520 {
 521     TCGv temp = tcg_const_i32(con);
 522     gen_maddu64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
 523     tcg_temp_free(temp);
 524 }
 525
 526 /* ret = r2 - (r1 * r3); */
 527 static inline void gen_msub32_d(TCGv ret, TCGv r1, TCGv r2, TCGv r3)
 528 {
 529     TCGv_i64 t1 = tcg_temp_new_i64();
 530     TCGv_i64 t2 = tcg_temp_new_i64();
 531     TCGv_i64 t3 = tcg_temp_new_i64();
 532
 533     tcg_gen_ext_i32_i64(t1, r1);
 534     tcg_gen_ext_i32_i64(t2, r2);
 535     tcg_gen_ext_i32_i64(t3, r3);
 536
 537     tcg_gen_mul_i64(t1, t1, t3);
 538     tcg_gen_sub_i64(t1, t2, t1);
 539
 540     tcg_gen_trunc_i64_i32(ret, t1);
 541     /* calc V
 542        t2 > 0x7fffffff */
 543     tcg_gen_setcondi_i64(TCG_COND_GT, t3, t1, 0x7fffffffLL);
 544     /* result < -0x80000000 */
 545     tcg_gen_setcondi_i64(TCG_COND_LT, t2, t1, -0x80000000LL);
 546     tcg_gen_or_i64(t2, t2, t3);
 547     tcg_gen_trunc_i64_i32(cpu_PSW_V, t2);
 548     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 549
 550     /* Calc SV bit */
 551     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 552     /* Calc AV/SAV bits */
 553     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
 554     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
 555     /* calc SAV */
 556     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 557
 558     tcg_temp_free_i64(t1);
 559     tcg_temp_free_i64(t2);
 560     tcg_temp_free_i64(t3);
 561 }
 562
 563 static inline void gen_msubi32_d(TCGv ret, TCGv r1, TCGv r2, int32_t con)
 564 {
 565     TCGv temp = tcg_const_i32(con);
 566     gen_msub32_d(ret, r1, r2, temp);
 567     tcg_temp_free(temp);
 568 }
 569
 570 static inline void
 571 gen_msub64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 572              TCGv r3)
 573 {
 574     TCGv t1 = tcg_temp_new();
 575     TCGv t2 = tcg_temp_new();
 576     TCGv t3 = tcg_temp_new();
 577     TCGv t4 = tcg_temp_new();
 578
 579     tcg_gen_muls2_tl(t1, t2, r1, r3);
 580     /* only the sub can overflow */
 581     tcg_gen_sub2_tl(t3, t4, r2_low, r2_high, t1, t2);
 582     /* calc V bit */
 583     tcg_gen_xor_tl(cpu_PSW_V, t4, r2_high);
 584     tcg_gen_xor_tl(t1, r2_high, t2);
 585     tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, t1);
 586     /* Calc SV bit */
 587     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 588     /* Calc AV/SAV bits */
 589     tcg_gen_add_tl(cpu_PSW_AV, t4, t4);
 590     tcg_gen_xor_tl(cpu_PSW_AV, t4, cpu_PSW_AV);
 591     /* calc SAV */
 592     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 593     /* write back the result */
 594     tcg_gen_mov_tl(ret_low, t3);
 595     tcg_gen_mov_tl(ret_high, t4);
 596
 597     tcg_temp_free(t1);
 598     tcg_temp_free(t2);
 599     tcg_temp_free(t3);
 600     tcg_temp_free(t4);
 601 }
 602
 603 static inline void
 604 gen_msubi64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 605               int32_t con)
 606 {
 607     TCGv temp = tcg_const_i32(con);
 608     gen_msub64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
 609     tcg_temp_free(temp);
 610 }
 611
 612 static inline void
 613 gen_msubu64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 614               TCGv r3)
 615 {
 616     TCGv_i64 t1 = tcg_temp_new_i64();
 617     TCGv_i64 t2 = tcg_temp_new_i64();
 618     TCGv_i64 t3 = tcg_temp_new_i64();
 619
 620     tcg_gen_extu_i32_i64(t1, r1);
 621     tcg_gen_concat_i32_i64(t2, r2_low, r2_high);
 622     tcg_gen_extu_i32_i64(t3, r3);
 623
 624     tcg_gen_mul_i64(t1, t1, t3);
 625     tcg_gen_sub_i64(t3, t2, t1);
 626     tcg_gen_extr_i64_i32(ret_low, ret_high, t3);
 627     /* calc V bit, only the sub can overflow, if t1 > t2 */
 628     tcg_gen_setcond_i64(TCG_COND_GTU, t1, t1, t2);
 629     tcg_gen_trunc_i64_i32(cpu_PSW_V, t1);
 630     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 631     /* Calc SV bit */
 632     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 633     /* Calc AV/SAV bits */
 634     tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
 635     tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
 636     /* calc SAV */
 637     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 638
 639     tcg_temp_free_i64(t1);
 640     tcg_temp_free_i64(t2);
 641     tcg_temp_free_i64(t3);
 642 }
 643
 644 static inline void
 645 gen_msubui64_d(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
 646                int32_t con)
 647 {
 648     TCGv temp = tcg_const_i32(con);
 649     gen_msubu64_d(ret_low, ret_high, r1, r2_low, r2_high, temp);
 650     tcg_temp_free(temp);
 651 }
 652
 653 static inline void gen_addi_d(TCGv ret, TCGv r1, target_ulong r2)
 654 {
 655     TCGv temp = tcg_const_i32(r2);
 656     gen_add_d(ret, r1, temp);
 657     tcg_temp_free(temp);
 658 }
 659 /* calculate the carry bit too */
 660 static inline void gen_add_CC(TCGv ret, TCGv r1, TCGv r2)
 661 {
 662     TCGv t0    = tcg_temp_new_i32();
 663     TCGv result = tcg_temp_new_i32();
 664
 665     tcg_gen_movi_tl(t0, 0);
 666     /* Addition and set C/V/SV bits */
 667     tcg_gen_add2_i32(result, cpu_PSW_C, r1, t0, r2, t0);
 668     /* calc V bit */
 669     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 670     tcg_gen_xor_tl(t0, r1, r2);
 671     tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
 672     /* Calc SV bit */
 673     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 674     /* Calc AV/SAV bits */
 675     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 676     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 677     /* calc SAV */
 678     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 679     /* write back result */
 680     tcg_gen_mov_tl(ret, result);
 681
 682     tcg_temp_free(result);
 683     tcg_temp_free(t0);
 684 }
 685
 686 static inline void gen_addi_CC(TCGv ret, TCGv r1, int32_t con)
 687 {
 688     TCGv temp = tcg_const_i32(con);
 689     gen_add_CC(ret, r1, temp);
 690     tcg_temp_free(temp);
 691 }
 692
 693 static inline void gen_addc_CC(TCGv ret, TCGv r1, TCGv r2)
 694 {
 695     TCGv carry = tcg_temp_new_i32();
 696     TCGv t0    = tcg_temp_new_i32();
 697     TCGv result = tcg_temp_new_i32();
 698
 699     tcg_gen_movi_tl(t0, 0);
 700     tcg_gen_setcondi_tl(TCG_COND_NE, carry, cpu_PSW_C, 0);
 701     /* Addition, carry and set C/V/SV bits */
 702     tcg_gen_add2_i32(result, cpu_PSW_C, r1, t0, carry, t0);
 703     tcg_gen_add2_i32(result, cpu_PSW_C, result, cpu_PSW_C, r2, t0);
 704     /* calc V bit */
 705     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 706     tcg_gen_xor_tl(t0, r1, r2);
 707     tcg_gen_andc_tl(cpu_PSW_V, cpu_PSW_V, t0);
 708     /* Calc SV bit */
 709     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 710     /* Calc AV/SAV bits */
 711     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 712     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 713     /* calc SAV */
 714     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 715     /* write back result */
 716     tcg_gen_mov_tl(ret, result);
 717
 718     tcg_temp_free(result);
 719     tcg_temp_free(t0);
 720     tcg_temp_free(carry);
 721 }
 722
 723 static inline void gen_addci_CC(TCGv ret, TCGv r1, int32_t con)
 724 {
 725     TCGv temp = tcg_const_i32(con);
 726     gen_addc_CC(ret, r1, temp);
 727     tcg_temp_free(temp);
 728 }
 729
 730 static inline void gen_cond_add(TCGCond cond, TCGv r1, TCGv r2, TCGv r3,
 731                                 TCGv r4)
 732 {
 733     TCGv temp = tcg_temp_new();
 734     TCGv temp2 = tcg_temp_new();
 735     TCGv result = tcg_temp_new();
 736     TCGv mask = tcg_temp_new();
 737     TCGv t0 = tcg_const_i32(0);
 738
 739     /* create mask for sticky bits */
 740     tcg_gen_setcond_tl(cond, mask, r4, t0);
 741     tcg_gen_shli_tl(mask, mask, 31);
 742
 743     tcg_gen_add_tl(result, r1, r2);
 744     /* Calc PSW_V */
 745     tcg_gen_xor_tl(temp, result, r1);
 746     tcg_gen_xor_tl(temp2, r1, r2);
 747     tcg_gen_andc_tl(temp, temp, temp2);
 748     tcg_gen_movcond_tl(cond, cpu_PSW_V, r4, t0, temp, cpu_PSW_V);
 749     /* Set PSW_SV */
 750     tcg_gen_and_tl(temp, temp, mask);
 751     tcg_gen_or_tl(cpu_PSW_SV, temp, cpu_PSW_SV);
 752     /* calc AV bit */
 753     tcg_gen_add_tl(temp, result, result);
 754     tcg_gen_xor_tl(temp, temp, result);
 755     tcg_gen_movcond_tl(cond, cpu_PSW_AV, r4, t0, temp, cpu_PSW_AV);
 756     /* calc SAV bit */
 757     tcg_gen_and_tl(temp, temp, mask);
 758     tcg_gen_or_tl(cpu_PSW_SAV, temp, cpu_PSW_SAV);
 759     /* write back result */
 760     tcg_gen_movcond_tl(cond, r3, r4, t0, result, r1);
 761
 762     tcg_temp_free(t0);
 763     tcg_temp_free(temp);
 764     tcg_temp_free(temp2);
 765     tcg_temp_free(result);
 766     tcg_temp_free(mask);
 767 }
 768
 769 static inline void gen_condi_add(TCGCond cond, TCGv r1, int32_t r2,
 770                                  TCGv r3, TCGv r4)
 771 {
 772     TCGv temp = tcg_const_i32(r2);
 773     gen_cond_add(cond, r1, temp, r3, r4);
 774     tcg_temp_free(temp);
 775 }
 776
 777 static inline void gen_sub_d(TCGv ret, TCGv r1, TCGv r2)
 778 {
 779     TCGv temp = tcg_temp_new_i32();
 780     TCGv result = tcg_temp_new_i32();
 781
 782     tcg_gen_sub_tl(result, r1, r2);
 783     /* calc V bit */
 784     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 785     tcg_gen_xor_tl(temp, r1, r2);
 786     tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
 787     /* calc SV bit */
 788     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 789     /* Calc AV bit */
 790     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 791     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 792     /* calc SAV bit */
 793     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 794     /* write back result */
 795     tcg_gen_mov_tl(ret, result);
 796
 797     tcg_temp_free(temp);
 798     tcg_temp_free(result);
 799 }
 800
 801 static inline void gen_sub_CC(TCGv ret, TCGv r1, TCGv r2)
 802 {
 803     TCGv result = tcg_temp_new();
 804     TCGv temp = tcg_temp_new();
 805
 806     tcg_gen_sub_tl(result, r1, r2);
 807     /* calc C bit */
 808     tcg_gen_setcond_tl(TCG_COND_GEU, cpu_PSW_C, r1, r2);
 809     /* calc V bit */
 810     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 811     tcg_gen_xor_tl(temp, r1, r2);
 812     tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
 813     /* calc SV bit */
 814     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 815     /* Calc AV bit */
 816     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 817     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 818     /* calc SAV bit */
 819     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 820     /* write back result */
 821     tcg_gen_mov_tl(ret, result);
 822
 823     tcg_temp_free(result);
 824     tcg_temp_free(temp);
 825 }
 826
 827 static inline void gen_subc_CC(TCGv ret, TCGv r1, TCGv r2)
 828 {
 829     TCGv temp = tcg_temp_new();
 830     tcg_gen_not_tl(temp, r2);
 831     gen_addc_CC(ret, r1, temp);
 832     tcg_temp_free(temp);
 833 }
 834
 835 static inline void gen_cond_sub(TCGCond cond, TCGv r1, TCGv r2, TCGv r3,
 836                                 TCGv r4)
 837 {
 838     TCGv temp = tcg_temp_new();
 839     TCGv temp2 = tcg_temp_new();
 840     TCGv result = tcg_temp_new();
 841     TCGv mask = tcg_temp_new();
 842     TCGv t0 = tcg_const_i32(0);
 843
 844     /* create mask for sticky bits */
 845     tcg_gen_setcond_tl(cond, mask, r4, t0);
 846     tcg_gen_shli_tl(mask, mask, 31);
 847
 848     tcg_gen_sub_tl(result, r1, r2);
 849     /* Calc PSW_V */
 850     tcg_gen_xor_tl(temp, result, r1);
 851     tcg_gen_xor_tl(temp2, r1, r2);
 852     tcg_gen_and_tl(temp, temp, temp2);
 853     tcg_gen_movcond_tl(cond, cpu_PSW_V, r4, t0, temp, cpu_PSW_V);
 854     /* Set PSW_SV */
 855     tcg_gen_and_tl(temp, temp, mask);
 856     tcg_gen_or_tl(cpu_PSW_SV, temp, cpu_PSW_SV);
 857     /* calc AV bit */
 858     tcg_gen_add_tl(temp, result, result);
 859     tcg_gen_xor_tl(temp, temp, result);
 860     tcg_gen_movcond_tl(cond, cpu_PSW_AV, r4, t0, temp, cpu_PSW_AV);
 861     /* calc SAV bit */
 862     tcg_gen_and_tl(temp, temp, mask);
 863     tcg_gen_or_tl(cpu_PSW_SAV, temp, cpu_PSW_SAV);
 864     /* write back result */
 865     tcg_gen_movcond_tl(cond, r3, r4, t0, result, r1);
 866
 867     tcg_temp_free(t0);
 868     tcg_temp_free(temp);
 869     tcg_temp_free(temp2);
 870     tcg_temp_free(result);
 871     tcg_temp_free(mask);
 872 }
 873
 874 static inline void gen_abs(TCGv ret, TCGv r1)
 875 {
 876     TCGv temp = tcg_temp_new();
 877     TCGv t0 = tcg_const_i32(0);
 878
 879     tcg_gen_neg_tl(temp, r1);
 880     tcg_gen_movcond_tl(TCG_COND_GE, ret, r1, t0, r1, temp);
 881     /* overflow can only happen, if r1 = 0x80000000 */
 882     tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, r1, 0x80000000);
 883     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 884     /* calc SV bit */
 885     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 886     /* Calc AV bit */
 887     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
 888     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
 889     /* calc SAV bit */
 890     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 891
 892     tcg_temp_free(temp);
 893     tcg_temp_free(t0);
 894 }
 895
 896 static inline void gen_absdif(TCGv ret, TCGv r1, TCGv r2)
 897 {
 898     TCGv temp = tcg_temp_new_i32();
 899     TCGv result = tcg_temp_new_i32();
 900
 901     tcg_gen_sub_tl(result, r1, r2);
 902     tcg_gen_sub_tl(temp, r2, r1);
 903     tcg_gen_movcond_tl(TCG_COND_GT, result, r1, r2, result, temp);
 904
 905     /* calc V bit */
 906     tcg_gen_xor_tl(cpu_PSW_V, result, r1);
 907     tcg_gen_xor_tl(temp, result, r2);
 908     tcg_gen_movcond_tl(TCG_COND_GT, cpu_PSW_V, r1, r2, cpu_PSW_V, temp);
 909     tcg_gen_xor_tl(temp, r1, r2);
 910     tcg_gen_and_tl(cpu_PSW_V, cpu_PSW_V, temp);
 911     /* calc SV bit */
 912     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 913     /* Calc AV bit */
 914     tcg_gen_add_tl(cpu_PSW_AV, result, result);
 915     tcg_gen_xor_tl(cpu_PSW_AV, result, cpu_PSW_AV);
 916     /* calc SAV bit */
 917     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 918     /* write back result */
 919     tcg_gen_mov_tl(ret, result);
 920
 921     tcg_temp_free(temp);
 922     tcg_temp_free(result);
 923 }
 924
 925 static inline void gen_absdifi(TCGv ret, TCGv r1, int32_t con)
 926 {
 927     TCGv temp = tcg_const_i32(con);
 928     gen_absdif(ret, r1, temp);
 929     tcg_temp_free(temp);
 930 }
 931
 932 static inline void gen_absdifsi(TCGv ret, TCGv r1, int32_t con)
 933 {
 934     TCGv temp = tcg_const_i32(con);
 935     gen_helper_absdif_ssov(ret, cpu_env, r1, temp);
 936     tcg_temp_free(temp);
 937 }
 938
 939 static inline void gen_mul_i32s(TCGv ret, TCGv r1, TCGv r2)
 940 {
 941     TCGv high = tcg_temp_new();
 942     TCGv low = tcg_temp_new();
 943
 944     tcg_gen_muls2_tl(low, high, r1, r2);
 945     tcg_gen_mov_tl(ret, low);
 946     /* calc V bit */
 947     tcg_gen_sari_tl(low, low, 31);
 948     tcg_gen_setcond_tl(TCG_COND_NE, cpu_PSW_V, high, low);
 949     tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
 950     /* calc SV bit */
 951     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 952     /* Calc AV bit */
 953     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
 954     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
 955     /* calc SAV bit */
 956     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 957
 958     tcg_temp_free(high);
 959     tcg_temp_free(low);
 960 }
 961
 962 static inline void gen_muli_i32s(TCGv ret, TCGv r1, int32_t con)
 963 {
 964     TCGv temp = tcg_const_i32(con);
 965     gen_mul_i32s(ret, r1, temp);
 966     tcg_temp_free(temp);
 967 }
 968
 969 static inline void gen_mul_i64s(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2)
 970 {
 971     tcg_gen_muls2_tl(ret_low, ret_high, r1, r2);
 972     /* clear V bit */
 973     tcg_gen_movi_tl(cpu_PSW_V, 0);
 974     /* calc SV bit */
 975     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 976     /* Calc AV bit */
 977     tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
 978     tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
 979     /* calc SAV bit */
 980     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
 981 }
 982
 983 static inline void gen_muli_i64s(TCGv ret_low, TCGv ret_high, TCGv r1,
 984                                 int32_t con)
 985 {
 986     TCGv temp = tcg_const_i32(con);
 987     gen_mul_i64s(ret_low, ret_high, r1, temp);
 988     tcg_temp_free(temp);
 989 }
 990
 991 static inline void gen_mul_i64u(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2)
 992 {
 993     tcg_gen_mulu2_tl(ret_low, ret_high, r1, r2);
 994     /* clear V bit */
 995     tcg_gen_movi_tl(cpu_PSW_V, 0);
 996     /* calc SV bit */
 997     tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
 998     /* Calc AV bit */
 999     tcg_gen_add_tl(cpu_PSW_AV, ret_high, ret_high);
1000     tcg_gen_xor_tl(cpu_PSW_AV, ret_high, cpu_PSW_AV);
1001     /* calc SAV bit */
1002     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1003 }
1004
1005 static inline void gen_muli_i64u(TCGv ret_low, TCGv ret_high, TCGv r1,
1006                                 int32_t con)
1007 {
1008     TCGv temp = tcg_const_i32(con);
1009     gen_mul_i64u(ret_low, ret_high, r1, temp);
1010     tcg_temp_free(temp);
1011 }
1012
1013 static inline void gen_mulsi_i32(TCGv ret, TCGv r1, int32_t con)
1014 {
1015     TCGv temp = tcg_const_i32(con);
1016     gen_helper_mul_ssov(ret, cpu_env, r1, temp);
1017     tcg_temp_free(temp);
1018 }
1019
1020 static inline void gen_mulsui_i32(TCGv ret, TCGv r1, int32_t con)
1021 {
1022     TCGv temp = tcg_const_i32(con);
1023     gen_helper_mul_suov(ret, cpu_env, r1, temp);
1024     tcg_temp_free(temp);
1025 }
1026 /* gen_maddsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9); */
1027 static inline void gen_maddsi_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
1028 {
1029     TCGv temp = tcg_const_i32(con);
1030     gen_helper_madd32_ssov(ret, cpu_env, r1, r2, temp);
1031     tcg_temp_free(temp);
1032 }
1033
1034 static inline void gen_maddsui_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
1035 {
1036     TCGv temp = tcg_const_i32(con);
1037     gen_helper_madd32_suov(ret, cpu_env, r1, r2, temp);
1038     tcg_temp_free(temp);
1039 }
1040
1041 static void
1042 gen_mul_q(TCGv rl, TCGv rh, TCGv arg1, TCGv arg2, uint32_t n, uint32_t up_shift)
1043 {
1044     TCGv temp = tcg_temp_new();
1045     TCGv_i64 temp_64 = tcg_temp_new_i64();
1046     TCGv_i64 temp2_64 = tcg_temp_new_i64();
1047
1048     if (n == 0) {
1049         if (up_shift == 32) {
1050             tcg_gen_muls2_tl(rh, rl, arg1, arg2);
1051         } else if (up_shift == 16) {
1052             tcg_gen_ext_i32_i64(temp_64, arg1);
1053             tcg_gen_ext_i32_i64(temp2_64, arg2);
1054
1055             tcg_gen_mul_i64(temp_64, temp_64, temp2_64);
1056             tcg_gen_shri_i64(temp_64, temp_64, up_shift);
1057             tcg_gen_extr_i64_i32(rl, rh, temp_64);
1058         } else {
1059             tcg_gen_muls2_tl(rl, rh, arg1, arg2);
1060         }
1061         /* reset v bit */
1062         tcg_gen_movi_tl(cpu_PSW_V, 0);
1063     } else { /* n is exspected to be 1 */
1064         tcg_gen_ext_i32_i64(temp_64, arg1);
1065         tcg_gen_ext_i32_i64(temp2_64, arg2);
1066
1067         tcg_gen_mul_i64(temp_64, temp_64, temp2_64);
1068
1069         if (up_shift == 0) {
1070             tcg_gen_shli_i64(temp_64, temp_64, 1);
1071         } else {
1072             tcg_gen_shri_i64(temp_64, temp_64, up_shift - 1);
1073         }
1074         tcg_gen_extr_i64_i32(rl, rh, temp_64);
1075         /* overflow only occours if r1 = r2 = 0x8000 */
1076         if (up_shift == 0) {/* result is 64 bit */
1077             tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, rh,
1078                                 0x80000000);
1079         } else { /* result is 32 bit */
1080             tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, rl,
1081                                 0x80000000);
1082         }
1083         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1084         /* calc sv overflow bit */
1085         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
1086     }
1087     /* calc av overflow bit */
1088     if (up_shift == 0) {
1089         tcg_gen_add_tl(cpu_PSW_AV, rh, rh);
1090         tcg_gen_xor_tl(cpu_PSW_AV, rh, cpu_PSW_AV);
1091     } else {
1092         tcg_gen_add_tl(cpu_PSW_AV, rl, rl);
1093         tcg_gen_xor_tl(cpu_PSW_AV, rl, cpu_PSW_AV);
1094     }
1095     /* calc sav overflow bit */
1096     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1097     tcg_temp_free(temp);
1098     tcg_temp_free_i64(temp_64);
1099     tcg_temp_free_i64(temp2_64);
1100 }
1101
1102 static void
1103 gen_mul_q_16(TCGv ret, TCGv arg1, TCGv arg2, uint32_t n)
1104 {
1105     TCGv temp = tcg_temp_new();
1106     if (n == 0) {
1107         tcg_gen_mul_tl(ret, arg1, arg2);
1108     } else { /* n is exspected to be 1 */
1109         tcg_gen_mul_tl(ret, arg1, arg2);
1110         tcg_gen_shli_tl(ret, ret, 1);
1111         /* catch special case r1 = r2 = 0x8000 */
1112         tcg_gen_setcondi_tl(TCG_COND_EQ, temp, ret, 0x80000000);
1113         tcg_gen_sub_tl(ret, ret, temp);
1114     }
1115     /* reset v bit */
1116     tcg_gen_movi_tl(cpu_PSW_V, 0);
1117     /* calc av overflow bit */
1118     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
1119     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
1120     /* calc sav overflow bit */
1121     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1122
1123     tcg_temp_free(temp);
1124 }
1125
1126 static void gen_mulr_q(TCGv ret, TCGv arg1, TCGv arg2, uint32_t n)
1127 {
1128     TCGv temp = tcg_temp_new();
1129     if (n == 0) {
1130         tcg_gen_mul_tl(ret, arg1, arg2);
1131         tcg_gen_addi_tl(ret, ret, 0x8000);
1132     } else {
1133         tcg_gen_mul_tl(ret, arg1, arg2);
1134         tcg_gen_shli_tl(ret, ret, 1);
1135         tcg_gen_addi_tl(ret, ret, 0x8000);
1136         /* catch special case r1 = r2 = 0x8000 */
1137         tcg_gen_setcondi_tl(TCG_COND_EQ, temp, ret, 0x80008000);
1138         tcg_gen_muli_tl(temp, temp, 0x8001);
1139         tcg_gen_sub_tl(ret, ret, temp);
1140     }
1141     /* reset v bit */
1142     tcg_gen_movi_tl(cpu_PSW_V, 0);
1143     /* calc av overflow bit */
1144     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
1145     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
1146     /* calc sav overflow bit */
1147     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1148     /* cut halfword off */
1149     tcg_gen_andi_tl(ret, ret, 0xffff0000);
1150
1151     tcg_temp_free(temp);
1152 }
1153
1154 static inline void
1155 gen_maddsi_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1156               int32_t con)
1157 {
1158     TCGv temp = tcg_const_i32(con);
1159     TCGv_i64 temp64 = tcg_temp_new_i64();
1160     tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
1161     gen_helper_madd64_ssov(temp64, cpu_env, r1, temp64, temp);
1162     tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
1163     tcg_temp_free(temp);
1164     tcg_temp_free_i64(temp64);
1165 }
1166
1167 static inline void
1168 gen_maddsui_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1169                int32_t con)
1170 {
1171     TCGv temp = tcg_const_i32(con);
1172     TCGv_i64 temp64 = tcg_temp_new_i64();
1173     tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
1174     gen_helper_madd64_suov(temp64, cpu_env, r1, temp64, temp);
1175     tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
1176     tcg_temp_free(temp);
1177     tcg_temp_free_i64(temp64);
1178 }
1179
1180 static inline void gen_msubsi_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
1181 {
1182     TCGv temp = tcg_const_i32(con);
1183     gen_helper_msub32_ssov(ret, cpu_env, r1, r2, temp);
1184     tcg_temp_free(temp);
1185 }
1186
1187 static inline void gen_msubsui_32(TCGv ret, TCGv r1, TCGv r2, int32_t con)
1188 {
1189     TCGv temp = tcg_const_i32(con);
1190     gen_helper_msub32_suov(ret, cpu_env, r1, r2, temp);
1191     tcg_temp_free(temp);
1192 }
1193
1194 static inline void
1195 gen_msubsi_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1196               int32_t con)
1197 {
1198     TCGv temp = tcg_const_i32(con);
1199     TCGv_i64 temp64 = tcg_temp_new_i64();
1200     tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
1201     gen_helper_msub64_ssov(temp64, cpu_env, r1, temp64, temp);
1202     tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
1203     tcg_temp_free(temp);
1204     tcg_temp_free_i64(temp64);
1205 }
1206
1207 static inline void
1208 gen_msubsui_64(TCGv ret_low, TCGv ret_high, TCGv r1, TCGv r2_low, TCGv r2_high,
1209                int32_t con)
1210 {
1211     TCGv temp = tcg_const_i32(con);
1212     TCGv_i64 temp64 = tcg_temp_new_i64();
1213     tcg_gen_concat_i32_i64(temp64, r2_low, r2_high);
1214     gen_helper_msub64_suov(temp64, cpu_env, r1, temp64, temp);
1215     tcg_gen_extr_i64_i32(ret_low, ret_high, temp64);
1216     tcg_temp_free(temp);
1217     tcg_temp_free_i64(temp64);
1218 }
1219
1220 static void gen_saturate(TCGv ret, TCGv arg, int32_t up, int32_t low)
1221 {
1222     TCGv sat_neg = tcg_const_i32(low);
1223     TCGv temp = tcg_const_i32(up);
1224
1225     /* sat_neg = (arg < low ) ? low : arg; */
1226     tcg_gen_movcond_tl(TCG_COND_LT, sat_neg, arg, sat_neg, sat_neg, arg);
1227
1228     /* ret = (sat_neg > up ) ? up  : sat_neg; */
1229     tcg_gen_movcond_tl(TCG_COND_GT, ret, sat_neg, temp, temp, sat_neg);
1230
1231     tcg_temp_free(sat_neg);
1232     tcg_temp_free(temp);
1233 }
1234
1235 static void gen_saturate_u(TCGv ret, TCGv arg, int32_t up)
1236 {
1237     TCGv temp = tcg_const_i32(up);
1238     /* sat_neg = (arg > up ) ? up : arg; */
1239     tcg_gen_movcond_tl(TCG_COND_GTU, ret, arg, temp, temp, arg);
1240     tcg_temp_free(temp);
1241 }
1242
1243 static void gen_shi(TCGv ret, TCGv r1, int32_t shift_count)
1244 {
1245     if (shift_count == -32) {
1246         tcg_gen_movi_tl(ret, 0);
1247     } else if (shift_count >= 0) {
1248         tcg_gen_shli_tl(ret, r1, shift_count);
1249     } else {
1250         tcg_gen_shri_tl(ret, r1, -shift_count);
1251     }
1252 }
1253
1254 static void gen_sh_hi(TCGv ret, TCGv r1, int32_t shiftcount)
1255 {
1256     TCGv temp_low, temp_high;
1257
1258     if (shiftcount == -16) {
1259         tcg_gen_movi_tl(ret, 0);
1260     } else {
1261         temp_high = tcg_temp_new();
1262         temp_low = tcg_temp_new();
1263
1264         tcg_gen_andi_tl(temp_low, r1, 0xffff);
1265         tcg_gen_andi_tl(temp_high, r1, 0xffff0000);
1266         gen_shi(temp_low, temp_low, shiftcount);
1267         gen_shi(ret, temp_high, shiftcount);
1268         tcg_gen_deposit_tl(ret, ret, temp_low, 0, 16);
1269
1270         tcg_temp_free(temp_low);
1271         tcg_temp_free(temp_high);
1272     }
1273 }
1274
1275 static void gen_shaci(TCGv ret, TCGv r1, int32_t shift_count)
1276 {
1277     uint32_t msk, msk_start;
1278     TCGv temp = tcg_temp_new();
1279     TCGv temp2 = tcg_temp_new();
1280     TCGv t_0 = tcg_const_i32(0);
1281
1282     if (shift_count == 0) {
1283         /* Clear PSW.C and PSW.V */
1284         tcg_gen_movi_tl(cpu_PSW_C, 0);
1285         tcg_gen_mov_tl(cpu_PSW_V, cpu_PSW_C);
1286         tcg_gen_mov_tl(ret, r1);
1287     } else if (shift_count == -32) {
1288         /* set PSW.C */
1289         tcg_gen_mov_tl(cpu_PSW_C, r1);
1290         /* fill ret completly with sign bit */
1291         tcg_gen_sari_tl(ret, r1, 31);
1292         /* clear PSW.V */
1293         tcg_gen_movi_tl(cpu_PSW_V, 0);
1294     } else if (shift_count > 0) {
1295         TCGv t_max = tcg_const_i32(0x7FFFFFFF >> shift_count);
1296         TCGv t_min = tcg_const_i32(((int32_t) -0x80000000) >> shift_count);
1297
1298         /* calc carry */
1299         msk_start = 32 - shift_count;
1300         msk = ((1 << shift_count) - 1) << msk_start;
1301         tcg_gen_andi_tl(cpu_PSW_C, r1, msk);
1302         /* calc v/sv bits */
1303         tcg_gen_setcond_tl(TCG_COND_GT, temp, r1, t_max);
1304         tcg_gen_setcond_tl(TCG_COND_LT, temp2, r1, t_min);
1305         tcg_gen_or_tl(cpu_PSW_V, temp, temp2);
1306         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
1307         /* calc sv */
1308         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_V, cpu_PSW_SV);
1309         /* do shift */
1310         tcg_gen_shli_tl(ret, r1, shift_count);
1311
1312         tcg_temp_free(t_max);
1313         tcg_temp_free(t_min);
1314     } else {
1315         /* clear PSW.V */
1316         tcg_gen_movi_tl(cpu_PSW_V, 0);
1317         /* calc carry */
1318         msk = (1 << -shift_count) - 1;
1319         tcg_gen_andi_tl(cpu_PSW_C, r1, msk);
1320         /* do shift */
1321         tcg_gen_sari_tl(ret, r1, -shift_count);
1322     }
1323     /* calc av overflow bit */
1324     tcg_gen_add_tl(cpu_PSW_AV, ret, ret);
1325     tcg_gen_xor_tl(cpu_PSW_AV, ret, cpu_PSW_AV);
1326     /* calc sav overflow bit */
1327     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1328
1329     tcg_temp_free(temp);
1330     tcg_temp_free(temp2);
1331     tcg_temp_free(t_0);
1332 }
1333
1334 static void gen_shas(TCGv ret, TCGv r1, TCGv r2)
1335 {
1336     gen_helper_sha_ssov(ret, cpu_env, r1, r2);
1337 }
1338
1339 static void gen_shasi(TCGv ret, TCGv r1, int32_t con)
1340 {
1341     TCGv temp = tcg_const_i32(con);
1342     gen_shas(ret, r1, temp);
1343     tcg_temp_free(temp);
1344 }
1345
1346 static void gen_sha_hi(TCGv ret, TCGv r1, int32_t shift_count)
1347 {
1348     TCGv low, high;
1349
1350     if (shift_count == 0) {
1351         tcg_gen_mov_tl(ret, r1);
1352     } else if (shift_count > 0) {
1353         low = tcg_temp_new();
1354         high = tcg_temp_new();
1355
1356         tcg_gen_andi_tl(high, r1, 0xffff0000);
1357         tcg_gen_shli_tl(low, r1, shift_count);
1358         tcg_gen_shli_tl(ret, high, shift_count);
1359         tcg_gen_deposit_tl(ret, ret, low, 0, 16);
1360
1361         tcg_temp_free(low);
1362         tcg_temp_free(high);
1363     } else {
1364         low = tcg_temp_new();
1365         high = tcg_temp_new();
1366
1367         tcg_gen_ext16s_tl(low, r1);
1368         tcg_gen_sari_tl(low, low, -shift_count);
1369         tcg_gen_sari_tl(ret, r1, -shift_count);
1370         tcg_gen_deposit_tl(ret, ret, low, 0, 16);
1371
1372         tcg_temp_free(low);
1373         tcg_temp_free(high);
1374     }
1375
1376 }
1377
1378 /* ret = {ret[30:0], (r1 cond r2)}; */
1379 static void gen_sh_cond(int cond, TCGv ret, TCGv r1, TCGv r2)
1380 {
1381     TCGv temp = tcg_temp_new();
1382     TCGv temp2 = tcg_temp_new();
1383
1384     tcg_gen_shli_tl(temp, ret, 1);
1385     tcg_gen_setcond_tl(cond, temp2, r1, r2);
1386     tcg_gen_or_tl(ret, temp, temp2);
1387
1388     tcg_temp_free(temp);
1389     tcg_temp_free(temp2);
1390 }
1391
1392 static void gen_sh_condi(int cond, TCGv ret, TCGv r1, int32_t con)
1393 {
1394     TCGv temp = tcg_const_i32(con);
1395     gen_sh_cond(cond, ret, r1, temp);
1396     tcg_temp_free(temp);
1397 }
1398
1399 static inline void gen_adds(TCGv ret, TCGv r1, TCGv r2)
1400 {
1401     gen_helper_add_ssov(ret, cpu_env, r1, r2);
1402 }
1403
1404 static inline void gen_addsi(TCGv ret, TCGv r1, int32_t con)
1405 {
1406     TCGv temp = tcg_const_i32(con);
1407     gen_helper_add_ssov(ret, cpu_env, r1, temp);
1408     tcg_temp_free(temp);
1409 }
1410
1411 static inline void gen_addsui(TCGv ret, TCGv r1, int32_t con)
1412 {
1413     TCGv temp = tcg_const_i32(con);
1414     gen_helper_add_suov(ret, cpu_env, r1, temp);
1415     tcg_temp_free(temp);
1416 }
1417
1418 static inline void gen_subs(TCGv ret, TCGv r1, TCGv r2)
1419 {
1420     gen_helper_sub_ssov(ret, cpu_env, r1, r2);
1421 }
1422
1423 static inline void gen_subsu(TCGv ret, TCGv r1, TCGv r2)
1424 {
1425     gen_helper_sub_suov(ret, cpu_env, r1, r2);
1426 }
1427
1428 static inline void gen_bit_2op(TCGv ret, TCGv r1, TCGv r2,
1429                                int pos1, int pos2,
1430                                void(*op1)(TCGv, TCGv, TCGv),
1431                                void(*op2)(TCGv, TCGv, TCGv))
1432 {
1433     TCGv temp1, temp2;
1434
1435     temp1 = tcg_temp_new();
1436     temp2 = tcg_temp_new();
1437
1438     tcg_gen_shri_tl(temp2, r2, pos2);
1439     tcg_gen_shri_tl(temp1, r1, pos1);
1440
1441     (*op1)(temp1, temp1, temp2);
1442     (*op2)(temp1 , ret, temp1);
1443
1444     tcg_gen_deposit_tl(ret, ret, temp1, 0, 1);
1445
1446     tcg_temp_free(temp1);
1447     tcg_temp_free(temp2);
1448 }
1449
1450 /* ret = r1[pos1] op1 r2[pos2]; */
1451 static inline void gen_bit_1op(TCGv ret, TCGv r1, TCGv r2,
1452                                int pos1, int pos2,
1453                                void(*op1)(TCGv, TCGv, TCGv))
1454 {
1455     TCGv temp1, temp2;
1456
1457     temp1 = tcg_temp_new();
1458     temp2 = tcg_temp_new();
1459
1460     tcg_gen_shri_tl(temp2, r2, pos2);
1461     tcg_gen_shri_tl(temp1, r1, pos1);
1462
1463     (*op1)(ret, temp1, temp2);
1464
1465     tcg_gen_andi_tl(ret, ret, 0x1);
1466
1467     tcg_temp_free(temp1);
1468     tcg_temp_free(temp2);
1469 }
1470
1471 static inline void gen_accumulating_cond(int cond, TCGv ret, TCGv r1, TCGv r2,
1472                                          void(*op)(TCGv, TCGv, TCGv))
1473 {
1474     TCGv temp = tcg_temp_new();
1475     TCGv temp2 = tcg_temp_new();
1476     /* temp = (arg1 cond arg2 )*/
1477     tcg_gen_setcond_tl(cond, temp, r1, r2);
1478     /* temp2 = ret[0]*/
1479     tcg_gen_andi_tl(temp2, ret, 0x1);
1480     /* temp = temp insn temp2 */
1481     (*op)(temp, temp, temp2);
1482     /* ret = {ret[31:1], temp} */
1483     tcg_gen_deposit_tl(ret, ret, temp, 0, 1);
1484
1485     tcg_temp_free(temp);
1486     tcg_temp_free(temp2);
1487 }
1488
1489 static inline void
1490 gen_accumulating_condi(int cond, TCGv ret, TCGv r1, int32_t con,
1491                        void(*op)(TCGv, TCGv, TCGv))
1492 {
1493     TCGv temp = tcg_const_i32(con);
1494     gen_accumulating_cond(cond, ret, r1, temp, op);
1495     tcg_temp_free(temp);
1496 }
1497
1498 /* ret = (r1 cond r2) ? 0xFFFFFFFF ? 0x00000000;*/
1499 static inline void gen_cond_w(TCGCond cond, TCGv ret, TCGv r1, TCGv r2)
1500 {
1501     tcg_gen_setcond_tl(cond, ret, r1, r2);
1502     tcg_gen_neg_tl(ret, ret);
1503 }
1504
1505 static inline void gen_eqany_bi(TCGv ret, TCGv r1, int32_t con)
1506 {
1507     TCGv b0 = tcg_temp_new();
1508     TCGv b1 = tcg_temp_new();
1509     TCGv b2 = tcg_temp_new();
1510     TCGv b3 = tcg_temp_new();
1511
1512     /* byte 0 */
1513     tcg_gen_andi_tl(b0, r1, 0xff);
1514     tcg_gen_setcondi_tl(TCG_COND_EQ, b0, b0, con & 0xff);
1515
1516     /* byte 1 */
1517     tcg_gen_andi_tl(b1, r1, 0xff00);
1518     tcg_gen_setcondi_tl(TCG_COND_EQ, b1, b1, con & 0xff00);
1519
1520     /* byte 2 */
1521     tcg_gen_andi_tl(b2, r1, 0xff0000);
1522     tcg_gen_setcondi_tl(TCG_COND_EQ, b2, b2, con & 0xff0000);
1523
1524     /* byte 3 */
1525     tcg_gen_andi_tl(b3, r1, 0xff000000);
1526     tcg_gen_setcondi_tl(TCG_COND_EQ, b3, b3, con & 0xff000000);
1527
1528     /* combine them */
1529     tcg_gen_or_tl(ret, b0, b1);
1530     tcg_gen_or_tl(ret, ret, b2);
1531     tcg_gen_or_tl(ret, ret, b3);
1532
1533     tcg_temp_free(b0);
1534     tcg_temp_free(b1);
1535     tcg_temp_free(b2);
1536     tcg_temp_free(b3);
1537 }
1538
1539 static inline void gen_eqany_hi(TCGv ret, TCGv r1, int32_t con)
1540 {
1541     TCGv h0 = tcg_temp_new();
1542     TCGv h1 = tcg_temp_new();
1543
1544     /* halfword 0 */
1545     tcg_gen_andi_tl(h0, r1, 0xffff);
1546     tcg_gen_setcondi_tl(TCG_COND_EQ, h0, h0, con & 0xffff);
1547
1548     /* halfword 1 */
1549     tcg_gen_andi_tl(h1, r1, 0xffff0000);
1550     tcg_gen_setcondi_tl(TCG_COND_EQ, h1, h1, con & 0xffff0000);
1551
1552     /* combine them */
1553     tcg_gen_or_tl(ret, h0, h1);
1554
1555     tcg_temp_free(h0);
1556     tcg_temp_free(h1);
1557 }
1558 /* mask = ((1 << width) -1) << pos;
1559    ret = (r1 & ~mask) | (r2 << pos) & mask); */
1560 static inline void gen_insert(TCGv ret, TCGv r1, TCGv r2, TCGv width, TCGv pos)
1561 {
1562     TCGv mask = tcg_temp_new();
1563     TCGv temp = tcg_temp_new();
1564     TCGv temp2 = tcg_temp_new();
1565
1566     tcg_gen_movi_tl(mask, 1);
1567     tcg_gen_shl_tl(mask, mask, width);
1568     tcg_gen_subi_tl(mask, mask, 1);
1569     tcg_gen_shl_tl(mask, mask, pos);
1570
1571     tcg_gen_shl_tl(temp, r2, pos);
1572     tcg_gen_and_tl(temp, temp, mask);
1573     tcg_gen_andc_tl(temp2, r1, mask);
1574     tcg_gen_or_tl(ret, temp, temp2);
1575
1576     tcg_temp_free(mask);
1577     tcg_temp_free(temp);
1578     tcg_temp_free(temp2);
1579 }
1580
1581 static inline void gen_bsplit(TCGv rl, TCGv rh, TCGv r1)
1582 {
1583     TCGv_i64 temp = tcg_temp_new_i64();
1584
1585     gen_helper_bsplit(temp, r1);
1586     tcg_gen_extr_i64_i32(rl, rh, temp);
1587
1588     tcg_temp_free_i64(temp);
1589 }
1590
1591 static inline void gen_unpack(TCGv rl, TCGv rh, TCGv r1)
1592 {
1593     TCGv_i64 temp = tcg_temp_new_i64();
1594
1595     gen_helper_unpack(temp, r1);
1596     tcg_gen_extr_i64_i32(rl, rh, temp);
1597
1598     tcg_temp_free_i64(temp);
1599 }
1600
1601 static inline void
1602 gen_dvinit_b(CPUTriCoreState *env, TCGv rl, TCGv rh, TCGv r1, TCGv r2)
1603 {
1604     TCGv_i64 ret = tcg_temp_new_i64();
1605
1606     if (!tricore_feature(env, TRICORE_FEATURE_131)) {
1607         gen_helper_dvinit_b_13(ret, cpu_env, r1, r2);
1608     } else {
1609         gen_helper_dvinit_b_131(ret, cpu_env, r1, r2);
1610     }
1611     tcg_gen_extr_i64_i32(rl, rh, ret);
1612
1613     tcg_temp_free_i64(ret);
1614 }
1615
1616 static inline void
1617 gen_dvinit_h(CPUTriCoreState *env, TCGv rl, TCGv rh, TCGv r1, TCGv r2)
1618 {
1619     TCGv_i64 ret = tcg_temp_new_i64();
1620
1621     if (!tricore_feature(env, TRICORE_FEATURE_131)) {
1622         gen_helper_dvinit_h_13(ret, cpu_env, r1, r2);
1623     } else {
1624         gen_helper_dvinit_h_131(ret, cpu_env, r1, r2);
1625     }
1626     tcg_gen_extr_i64_i32(rl, rh, ret);
1627
1628     tcg_temp_free_i64(ret);
1629 }
1630
1631 static void gen_calc_usb_mul_h(TCGv arg_low, TCGv arg_high)
1632 {
1633     TCGv temp = tcg_temp_new();
1634     /* calc AV bit */
1635     tcg_gen_add_tl(temp, arg_low, arg_low);
1636     tcg_gen_xor_tl(temp, temp, arg_low);
1637     tcg_gen_add_tl(cpu_PSW_AV, arg_high, arg_high);
1638     tcg_gen_xor_tl(cpu_PSW_AV, cpu_PSW_AV, arg_high);
1639     tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp);
1640     /* calc SAV bit */
1641     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1642     tcg_gen_movi_tl(cpu_PSW_V, 0);
1643     tcg_temp_free(temp);
1644 }
1645
1646 static void gen_calc_usb_mulr_h(TCGv arg)
1647 {
1648     TCGv temp = tcg_temp_new();
1649     /* calc AV bit */
1650     tcg_gen_add_tl(temp, arg, arg);
1651     tcg_gen_xor_tl(temp, temp, arg);
1652     tcg_gen_shli_tl(cpu_PSW_AV, temp, 16);
1653     tcg_gen_or_tl(cpu_PSW_AV, cpu_PSW_AV, temp);
1654     /* calc SAV bit */
1655     tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
1656     /* clear V bit */
1657     tcg_gen_movi_tl(cpu_PSW_V, 0);
1658     tcg_temp_free(temp);
1659 }
1660
1661 /* helpers for generating program flow micro-ops */
1662
1663 static inline void gen_save_pc(target_ulong pc)
1664 {
1665     tcg_gen_movi_tl(cpu_PC, pc);
1666 }
1667
1668 static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
1669 {
1670     TranslationBlock *tb;
1671     tb = ctx->tb;
1672     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) &&
1673         likely(!ctx->singlestep_enabled)) {
1674         tcg_gen_goto_tb(n);
1675         gen_save_pc(dest);
1676         tcg_gen_exit_tb((uintptr_t)tb + n);
1677     } else {
1678         gen_save_pc(dest);
1679         if (ctx->singlestep_enabled) {
1680             /* raise exception debug */
1681         }
1682         tcg_gen_exit_tb(0);
1683     }
1684 }
1685
1686 static inline void gen_branch_cond(DisasContext *ctx, TCGCond cond, TCGv r1,
1687                                    TCGv r2, int16_t address)
1688 {
1689     int jumpLabel;
1690     jumpLabel = gen_new_label();
1691     tcg_gen_brcond_tl(cond, r1, r2, jumpLabel);
1692
1693     gen_goto_tb(ctx, 1, ctx->next_pc);
1694
1695     gen_set_label(jumpLabel);
1696     gen_goto_tb(ctx, 0, ctx->pc + address * 2);
1697 }
1698
1699 static inline void gen_branch_condi(DisasContext *ctx, TCGCond cond, TCGv r1,
1700                                     int r2, int16_t address)
1701 {
1702     TCGv temp = tcg_const_i32(r2);
1703     gen_branch_cond(ctx, cond, r1, temp, address);
1704     tcg_temp_free(temp);
1705 }
1706
1707 static void gen_loop(DisasContext *ctx, int r1, int32_t offset)
1708 {
1709     int l1;
1710     l1 = gen_new_label();
1711
1712     tcg_gen_subi_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], 1);
1713     tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr_a[r1], -1, l1);
1714     gen_goto_tb(ctx, 1, ctx->pc + offset);
1715     gen_set_label(l1);
1716     gen_goto_tb(ctx, 0, ctx->next_pc);
1717 }
1718
1719 static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
1720                                int r2 , int32_t constant , int32_t offset)
1721 {
1722     TCGv temp, temp2;
1723     int n;
1724
1725     switch (opc) {
1726 /* SB-format jumps */
1727     case OPC1_16_SB_J:
1728     case OPC1_32_B_J:
1729         gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
1730         break;
1731     case OPC1_32_B_CALL:
1732     case OPC1_16_SB_CALL:
1733         gen_helper_1arg(call, ctx->next_pc);
1734         gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
1735         break;
1736     case OPC1_16_SB_JZ:
1737         gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
1738         break;
1739     case OPC1_16_SB_JNZ:
1740         gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
1741         break;
1742 /* SBC-format jumps */
1743     case OPC1_16_SBC_JEQ:
1744         gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
1745         break;
1746     case OPC1_16_SBC_JNE:
1747         gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
1748         break;
1749 /* SBRN-format jumps */
1750     case OPC1_16_SBRN_JZ_T:
1751         temp = tcg_temp_new();
1752         tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
1753         gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
1754         tcg_temp_free(temp);
1755         break;
1756     case OPC1_16_SBRN_JNZ_T:
1757         temp = tcg_temp_new();
1758         tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
1759         gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
1760         tcg_temp_free(temp);
1761         break;
1762 /* SBR-format jumps */
1763     case OPC1_16_SBR_JEQ:
1764         gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
1765                         offset);
1766         break;
1767     case OPC1_16_SBR_JNE:
1768         gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
1769                         offset);
1770         break;
1771     case OPC1_16_SBR_JNZ:
1772         gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
1773         break;
1774     case OPC1_16_SBR_JNZ_A:
1775         gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
1776         break;
1777     case OPC1_16_SBR_JGEZ:
1778         gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
1779         break;
1780     case OPC1_16_SBR_JGTZ:
1781         gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
1782         break;
1783     case OPC1_16_SBR_JLEZ:
1784         gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
1785         break;
1786     case OPC1_16_SBR_JLTZ:
1787         gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
1788         break;
1789     case OPC1_16_SBR_JZ:
1790         gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
1791         break;
1792     case OPC1_16_SBR_JZ_A:
1793         gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
1794         break;
1795     case OPC1_16_SBR_LOOP:
1796         gen_loop(ctx, r1, offset * 2 - 32);
1797         break;
1798 /* SR-format jumps */
1799     case OPC1_16_SR_JI:
1800         tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
1801         tcg_gen_exit_tb(0);
1802         break;
1803     case OPC2_16_SR_RET:
1804         gen_helper_ret(cpu_env);
1805         tcg_gen_exit_tb(0);
1806         break;
1807 /* B-format */
1808     case OPC1_32_B_CALLA:
1809         gen_helper_1arg(call, ctx->next_pc);
1810         gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
1811         break;
1812     case OPC1_32_B_JLA:
1813         tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
1814         /* fall through */
1815     case OPC1_32_B_JA:
1816         gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
1817         break;
1818     case OPC1_32_B_JL:
1819         tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
1820         gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
1821         break;
1822 /* BOL format */
1823     case OPCM_32_BRC_EQ_NEQ:
1824          if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
1825             gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
1826          } else {
1827             gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
1828          }
1829          break;
1830     case OPCM_32_BRC_GE:
1831          if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
1832             gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
1833          } else {
1834             constant = MASK_OP_BRC_CONST4(ctx->opcode);
1835             gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
1836                              offset);
1837          }
1838          break;
1839     case OPCM_32_BRC_JLT:
1840          if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
1841             gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
1842          } else {
1843             constant = MASK_OP_BRC_CONST4(ctx->opcode);
1844             gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
1845                              offset);
1846          }
1847          break;
1848     case OPCM_32_BRC_JNE:
1849         temp = tcg_temp_new();
1850         if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
1851             tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
1852             /* subi is unconditional */
1853             tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
1854             gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
1855         } else {
1856             tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
1857             /* addi is unconditional */
1858             tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
1859             gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
1860         }
1861         tcg_temp_free(temp);
1862         break;
1863 /* BRN format */
1864     case OPCM_32_BRN_JTT:
1865         n = MASK_OP_BRN_N(ctx->opcode);
1866
1867         temp = tcg_temp_new();
1868         tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
1869
1870         if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
1871             gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
1872         } else {
1873             gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
1874         }
1875         tcg_temp_free(temp);
1876         break;
1877 /* BRR Format */
1878     case OPCM_32_BRR_EQ_NEQ:
1879         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
1880             gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
1881                             offset);
1882         } else {
1883             gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
1884                             offset);
1885         }
1886         break;
1887     case OPCM_32_BRR_ADDR_EQ_NEQ:
1888         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
1889             gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
1890                             offset);
1891         } else {
1892             gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
1893                             offset);
1894         }
1895         break;
1896     case OPCM_32_BRR_GE:
1897         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
1898             gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
1899                             offset);
1900         } else {
1901             gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
1902                             offset);
1903         }
1904         break;
1905     case OPCM_32_BRR_JLT:
1906         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
1907             gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
1908                             offset);
1909         } else {
1910             gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
1911                             offset);
1912         }
1913         break;
1914     case OPCM_32_BRR_LOOP:
1915         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
1916             gen_loop(ctx, r1, offset * 2);
1917         } else {
1918             /* OPC2_32_BRR_LOOPU */
1919             gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
1920         }
1921         break;
1922     case OPCM_32_BRR_JNE:
1923         temp = tcg_temp_new();
1924         temp2 = tcg_temp_new();
1925         if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
1926             tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
1927             /* also save r2, in case of r1 == r2, so r2 is not decremented */
1928             tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
1929             /* subi is unconditional */
1930             tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
1931             gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
1932         } else {
1933             tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
1934             /* also save r2, in case of r1 == r2, so r2 is not decremented */
1935             tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
1936             /* addi is unconditional */
1937             tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
1938             gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
1939         }
1940         tcg_temp_free(temp);
1941         tcg_temp_free(temp2);
1942         break;
1943     case OPCM_32_BRR_JNZ:
1944         if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
1945             gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
1946         } else {
1947             gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
1948         }
1949         break;
1950     default:
1951         printf("Branch Error at %x\n", ctx->pc);
1952     }
1953     ctx->bstate = BS_BRANCH;
1954 }
1955
1956
1957 /*
1958  * Functions for decoding instructions
1959  */
1960
1961 static void decode_src_opc(DisasContext *ctx, int op1)
1962 {
1963     int r1;
1964     int32_t const4;
1965     TCGv temp, temp2;
1966
1967     r1 = MASK_OP_SRC_S1D(ctx->opcode);
1968     const4 = MASK_OP_SRC_CONST4_SEXT(ctx->opcode);
1969
1970     switch (op1) {
1971     case OPC1_16_SRC_ADD:
1972         gen_addi_d(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
1973         break;
1974     case OPC1_16_SRC_ADD_A15:
1975         gen_addi_d(cpu_gpr_d[r1], cpu_gpr_d[15], const4);
1976         break;
1977     case OPC1_16_SRC_ADD_15A:
1978         gen_addi_d(cpu_gpr_d[15], cpu_gpr_d[r1], const4);
1979         break;
1980     case OPC1_16_SRC_ADD_A:
1981         tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], const4);
1982         break;
1983     case OPC1_16_SRC_CADD:
1984         gen_condi_add(TCG_COND_NE, cpu_gpr_d[r1], const4, cpu_gpr_d[r1],
1985                       cpu_gpr_d[15]);
1986         break;
1987     case OPC1_16_SRC_CADDN:
1988         gen_condi_add(TCG_COND_EQ, cpu_gpr_d[r1], const4, cpu_gpr_d[r1],
1989                       cpu_gpr_d[15]);
1990         break;
1991     case OPC1_16_SRC_CMOV:
1992         temp = tcg_const_tl(0);
1993         temp2 = tcg_const_tl(const4);
1994         tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
1995                            temp2, cpu_gpr_d[r1]);
1996         tcg_temp_free(temp);
1997         tcg_temp_free(temp2);
1998         break;
1999     case OPC1_16_SRC_CMOVN:
2000         temp = tcg_const_tl(0);
2001         temp2 = tcg_const_tl(const4);
2002         tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
2003                            temp2, cpu_gpr_d[r1]);
2004         tcg_temp_free(temp);
2005         tcg_temp_free(temp2);
2006         break;
2007     case OPC1_16_SRC_EQ:
2008         tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[15], cpu_gpr_d[r1],
2009                             const4);
2010         break;
2011     case OPC1_16_SRC_LT:
2012         tcg_gen_setcondi_tl(TCG_COND_LT, cpu_gpr_d[15], cpu_gpr_d[r1],
2013                             const4);
2014         break;
2015     case OPC1_16_SRC_MOV:
2016         tcg_gen_movi_tl(cpu_gpr_d[r1], const4);
2017         break;
2018     case OPC1_16_SRC_MOV_A:
2019         const4 = MASK_OP_SRC_CONST4(ctx->opcode);
2020         tcg_gen_movi_tl(cpu_gpr_a[r1], const4);
2021         break;
2022     case OPC1_16_SRC_SH:
2023         gen_shi(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
2024         break;
2025     case OPC1_16_SRC_SHA:
2026         gen_shaci(cpu_gpr_d[r1], cpu_gpr_d[r1], const4);
2027         break;
2028     }
2029 }
2030
2031 static void decode_srr_opc(DisasContext *ctx, int op1)
2032 {
2033     int r1, r2;
2034     TCGv temp;
2035
2036     r1 = MASK_OP_SRR_S1D(ctx->opcode);
2037     r2 = MASK_OP_SRR_S2(ctx->opcode);
2038
2039     switch (op1) {
2040     case OPC1_16_SRR_ADD:
2041         gen_add_d(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2042         break;
2043     case OPC1_16_SRR_ADD_A15:
2044         gen_add_d(cpu_gpr_d[r1], cpu_gpr_d[15], cpu_gpr_d[r2]);
2045         break;
2046     case OPC1_16_SRR_ADD_15A:
2047         gen_add_d(cpu_gpr_d[15], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2048         break;
2049     case OPC1_16_SRR_ADD_A:
2050         tcg_gen_add_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], cpu_gpr_a[r2]);
2051         break;
2052     case OPC1_16_SRR_ADDS:
2053         gen_adds(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2054         break;
2055     case OPC1_16_SRR_AND:
2056         tcg_gen_and_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2057         break;
2058     case OPC1_16_SRR_CMOV:
2059         temp = tcg_const_tl(0);
2060         tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
2061                            cpu_gpr_d[r2], cpu_gpr_d[r1]);
2062         tcg_temp_free(temp);
2063         break;
2064     case OPC1_16_SRR_CMOVN:
2065         temp = tcg_const_tl(0);
2066         tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15], temp,
2067                            cpu_gpr_d[r2], cpu_gpr_d[r1]);
2068         tcg_temp_free(temp);
2069         break;
2070     case OPC1_16_SRR_EQ:
2071         tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[15], cpu_gpr_d[r1],
2072                            cpu_gpr_d[r2]);
2073         break;
2074     case OPC1_16_SRR_LT:
2075         tcg_gen_setcond_tl(TCG_COND_LT, cpu_gpr_d[15], cpu_gpr_d[r1],
2076                            cpu_gpr_d[r2]);
2077         break;
2078     case OPC1_16_SRR_MOV:
2079         tcg_gen_mov_tl(cpu_gpr_d[r1], cpu_gpr_d[r2]);
2080         break;
2081     case OPC1_16_SRR_MOV_A:
2082         tcg_gen_mov_tl(cpu_gpr_a[r1], cpu_gpr_d[r2]);
2083         break;
2084     case OPC1_16_SRR_MOV_AA:
2085         tcg_gen_mov_tl(cpu_gpr_a[r1], cpu_gpr_a[r2]);
2086         break;
2087     case OPC1_16_SRR_MOV_D:
2088         tcg_gen_mov_tl(cpu_gpr_d[r1], cpu_gpr_a[r2]);
2089         break;
2090     case OPC1_16_SRR_MUL:
2091         gen_mul_i32s(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2092         break;
2093     case OPC1_16_SRR_OR:
2094         tcg_gen_or_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2095         break;
2096     case OPC1_16_SRR_SUB:
2097         gen_sub_d(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2098         break;
2099     case OPC1_16_SRR_SUB_A15B:
2100         gen_sub_d(cpu_gpr_d[r1], cpu_gpr_d[15], cpu_gpr_d[r2]);
2101         break;
2102     case OPC1_16_SRR_SUB_15AB:
2103         gen_sub_d(cpu_gpr_d[15], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2104         break;
2105     case OPC1_16_SRR_SUBS:
2106         gen_subs(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2107         break;
2108     case OPC1_16_SRR_XOR:
2109         tcg_gen_xor_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], cpu_gpr_d[r2]);
2110         break;
2111     }
2112 }
2113
2114 static void decode_ssr_opc(DisasContext *ctx, int op1)
2115 {
2116     int r1, r2;
2117
2118     r1 = MASK_OP_SSR_S1(ctx->opcode);
2119     r2 = MASK_OP_SSR_S2(ctx->opcode);
2120
2121     switch (op1) {
2122     case OPC1_16_SSR_ST_A:
2123         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
2124         break;
2125     case OPC1_16_SSR_ST_A_POSTINC:
2126         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
2127         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
2128         break;
2129     case OPC1_16_SSR_ST_B:
2130         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
2131         break;
2132     case OPC1_16_SSR_ST_B_POSTINC:
2133         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
2134         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 1);
2135         break;
2136     case OPC1_16_SSR_ST_H:
2137         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUW);
2138         break;
2139     case OPC1_16_SSR_ST_H_POSTINC:
2140         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUW);
2141         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 2);
2142         break;
2143     case OPC1_16_SSR_ST_W:
2144         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
2145         break;
2146     case OPC1_16_SSR_ST_W_POSTINC:
2147         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LEUL);
2148         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
2149         break;
2150     }
2151 }
2152
2153 static void decode_sc_opc(DisasContext *ctx, int op1)
2154 {
2155     int32_t const16;
2156
2157     const16 = MASK_OP_SC_CONST8(ctx->opcode);
2158
2159     switch (op1) {
2160     case OPC1_16_SC_AND:
2161         tcg_gen_andi_tl(cpu_gpr_d[15], cpu_gpr_d[15], const16);
2162         break;
2163     case OPC1_16_SC_BISR:
2164         gen_helper_1arg(bisr, const16 & 0xff);
2165         break;
2166     case OPC1_16_SC_LD_A:
2167         gen_offset_ld(ctx, cpu_gpr_a[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
2168         break;
2169     case OPC1_16_SC_LD_W:
2170         gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
2171         break;
2172     case OPC1_16_SC_MOV:
2173         tcg_gen_movi_tl(cpu_gpr_d[15], const16);
2174         break;
2175     case OPC1_16_SC_OR:
2176         tcg_gen_ori_tl(cpu_gpr_d[15], cpu_gpr_d[15], const16);
2177         break;
2178     case OPC1_16_SC_ST_A:
2179         gen_offset_st(ctx, cpu_gpr_a[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
2180         break;
2181     case OPC1_16_SC_ST_W:
2182         gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[10], const16 * 4, MO_LESL);
2183         break;
2184     case OPC1_16_SC_SUB_A:
2185         tcg_gen_subi_tl(cpu_gpr_a[10], cpu_gpr_a[10], const16);
2186         break;
2187     }
2188 }
2189
2190 static void decode_slr_opc(DisasContext *ctx, int op1)
2191 {
2192     int r1, r2;
2193
2194     r1 = MASK_OP_SLR_D(ctx->opcode);
2195     r2 = MASK_OP_SLR_S2(ctx->opcode);
2196
2197     switch (op1) {
2198 /* SLR-format */
2199     case OPC1_16_SLR_LD_A:
2200         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
2201         break;
2202     case OPC1_16_SLR_LD_A_POSTINC:
2203         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESL);
2204         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
2205         break;
2206     case OPC1_16_SLR_LD_BU:
2207         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
2208         break;
2209     case OPC1_16_SLR_LD_BU_POSTINC:
2210         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_UB);
2211         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 1);
2212         break;
2213     case OPC1_16_SLR_LD_H:
2214         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
2215         break;
2216     case OPC1_16_SLR_LD_H_POSTINC:
2217         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
2218         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 2);
2219         break;
2220     case OPC1_16_SLR_LD_W:
2221         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
2222         break;
2223     case OPC1_16_SLR_LD_W_POSTINC:
2224         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx, MO_LESW);
2225         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], 4);
2226         break;
2227     }
2228 }
2229
2230 static void decode_sro_opc(DisasContext *ctx, int op1)
2231 {
2232     int r2;
2233     int32_t address;
2234
2235     r2 = MASK_OP_SRO_S2(ctx->opcode);
2236     address = MASK_OP_SRO_OFF4(ctx->opcode);
2237
2238 /* SRO-format */
2239     switch (op1) {
2240     case OPC1_16_SRO_LD_A:
2241         gen_offset_ld(ctx, cpu_gpr_a[15], cpu_gpr_a[r2], address * 4, MO_LESL);
2242         break;
2243     case OPC1_16_SRO_LD_BU:
2244         gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_UB);
2245         break;
2246     case OPC1_16_SRO_LD_H:
2247         gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_LESW);
2248         break;
2249     case OPC1_16_SRO_LD_W:
2250         gen_offset_ld(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 4, MO_LESL);
2251         break;
2252     case OPC1_16_SRO_ST_A:
2253         gen_offset_st(ctx, cpu_gpr_a[15], cpu_gpr_a[r2], address * 4, MO_LESL);
2254         break;
2255     case OPC1_16_SRO_ST_B:
2256         gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address, MO_UB);
2257         break;
2258     case OPC1_16_SRO_ST_H:
2259         gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 2, MO_LESW);
2260         break;
2261     case OPC1_16_SRO_ST_W:
2262         gen_offset_st(ctx, cpu_gpr_d[15], cpu_gpr_a[r2], address * 4, MO_LESL);
2263         break;
2264     }
2265 }
2266
2267 static void decode_sr_system(CPUTriCoreState *env, DisasContext *ctx)
2268 {
2269     uint32_t op2;
2270     op2 = MASK_OP_SR_OP2(ctx->opcode);
2271
2272     switch (op2) {
2273     case OPC2_16_SR_NOP:
2274         break;
2275     case OPC2_16_SR_RET:
2276         gen_compute_branch(ctx, op2, 0, 0, 0, 0);
2277         break;
2278     case OPC2_16_SR_RFE:
2279         gen_helper_rfe(cpu_env);
2280         tcg_gen_exit_tb(0);
2281         ctx->bstate = BS_BRANCH;
2282         break;
2283     case OPC2_16_SR_DEBUG:
2284         /* raise EXCP_DEBUG */
2285         break;
2286     }
2287 }
2288
2289 static void decode_sr_accu(CPUTriCoreState *env, DisasContext *ctx)
2290 {
2291     uint32_t op2;
2292     uint32_t r1;
2293     TCGv temp;
2294
2295     r1 = MASK_OP_SR_S1D(ctx->opcode);
2296     op2 = MASK_OP_SR_OP2(ctx->opcode);
2297
2298     switch (op2) {
2299     case OPC2_16_SR_RSUB:
2300         /* overflow only if r1 = -0x80000000 */
2301         temp = tcg_const_i32(-0x80000000);
2302         /* calc V bit */
2303         tcg_gen_setcond_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r1], temp);
2304         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
2305         /* calc SV bit */
2306         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
2307         /* sub */
2308         tcg_gen_neg_tl(cpu_gpr_d[r1], cpu_gpr_d[r1]);
2309         /* calc av */
2310         tcg_gen_add_tl(cpu_PSW_AV, cpu_gpr_d[r1], cpu_gpr_d[r1]);
2311         tcg_gen_xor_tl(cpu_PSW_AV, cpu_gpr_d[r1], cpu_PSW_AV);
2312         /* calc sav */
2313         tcg_gen_or_tl(cpu_PSW_SAV, cpu_PSW_SAV, cpu_PSW_AV);
2314         tcg_temp_free(temp);
2315         break;
2316     case OPC2_16_SR_SAT_B:
2317         gen_saturate(cpu_gpr_d[r1], cpu_gpr_d[r1], 0x7f, -0x80);
2318         break;
2319     case OPC2_16_SR_SAT_BU:
2320         gen_saturate_u(cpu_gpr_d[r1], cpu_gpr_d[r1], 0xff);
2321         break;
2322     case OPC2_16_SR_SAT_H:
2323         gen_saturate(cpu_gpr_d[r1], cpu_gpr_d[r1], 0x7fff, -0x8000);
2324         break;
2325     case OPC2_16_SR_SAT_HU:
2326         gen_saturate_u(cpu_gpr_d[r1], cpu_gpr_d[r1], 0xffff);
2327         break;
2328     }
2329 }
2330
2331 static void decode_16Bit_opc(CPUTriCoreState *env, DisasContext *ctx)
2332 {
2333     int op1;
2334     int r1, r2;
2335     int32_t const16;
2336     int32_t address;
2337     TCGv temp;
2338
2339     op1 = MASK_OP_MAJOR(ctx->opcode);
2340
2341     /* handle ADDSC.A opcode only being 6 bit long */
2342     if (unlikely((op1 & 0x3f) == OPC1_16_SRRS_ADDSC_A)) {
2343         op1 = OPC1_16_SRRS_ADDSC_A;
2344     }
2345
2346     switch (op1) {
2347     case OPC1_16_SRC_ADD:
2348     case OPC1_16_SRC_ADD_A15:
2349     case OPC1_16_SRC_ADD_15A:
2350     case OPC1_16_SRC_ADD_A:
2351     case OPC1_16_SRC_CADD:
2352     case OPC1_16_SRC_CADDN:
2353     case OPC1_16_SRC_CMOV:
2354     case OPC1_16_SRC_CMOVN:
2355     case OPC1_16_SRC_EQ:
2356     case OPC1_16_SRC_LT:
2357     case OPC1_16_SRC_MOV:
2358     case OPC1_16_SRC_MOV_A:
2359     case OPC1_16_SRC_SH:
2360     case OPC1_16_SRC_SHA:
2361         decode_src_opc(ctx, op1);
2362         break;
2363 /* SRR-format */
2364     case OPC1_16_SRR_ADD:
2365     case OPC1_16_SRR_ADD_A15:
2366     case OPC1_16_SRR_ADD_15A:
2367     case OPC1_16_SRR_ADD_A:
2368     case OPC1_16_SRR_ADDS:
2369     case OPC1_16_SRR_AND:
2370     case OPC1_16_SRR_CMOV:
2371     case OPC1_16_SRR_CMOVN:
2372     case OPC1_16_SRR_EQ:
2373     case OPC1_16_SRR_LT:
2374     case OPC1_16_SRR_MOV:
2375     case OPC1_16_SRR_MOV_A:
2376     case OPC1_16_SRR_MOV_AA:
2377     case OPC1_16_SRR_MOV_D:
2378     case OPC1_16_SRR_MUL:
2379     case OPC1_16_SRR_OR:
2380     case OPC1_16_SRR_SUB:
2381     case OPC1_16_SRR_SUB_A15B:
2382     case OPC1_16_SRR_SUB_15AB:
2383     case OPC1_16_SRR_SUBS:
2384     case OPC1_16_SRR_XOR:
2385         decode_srr_opc(ctx, op1);
2386         break;
2387 /* SSR-format */
2388     case OPC1_16_SSR_ST_A:
2389     case OPC1_16_SSR_ST_A_POSTINC:
2390     case OPC1_16_SSR_ST_B:
2391     case OPC1_16_SSR_ST_B_POSTINC:
2392     case OPC1_16_SSR_ST_H:
2393     case OPC1_16_SSR_ST_H_POSTINC:
2394     case OPC1_16_SSR_ST_W:
2395     case OPC1_16_SSR_ST_W_POSTINC:
2396         decode_ssr_opc(ctx, op1);
2397         break;
2398 /* SRRS-format */
2399     case OPC1_16_SRRS_ADDSC_A:
2400         r2 = MASK_OP_SRRS_S2(ctx->opcode);
2401         r1 = MASK_OP_SRRS_S1D(ctx->opcode);
2402         const16 = MASK_OP_SRRS_N(ctx->opcode);
2403         temp = tcg_temp_new();
2404         tcg_gen_shli_tl(temp, cpu_gpr_d[15], const16);
2405         tcg_gen_add_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], temp);
2406         tcg_temp_free(temp);
2407         break;
2408 /* SLRO-format */
2409     case OPC1_16_SLRO_LD_A:
2410         r1 = MASK_OP_SLRO_D(ctx->opcode);
2411         const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
2412         gen_offset_ld(ctx, cpu_gpr_a[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
2413         break;
2414     case OPC1_16_SLRO_LD_BU:
2415         r1 = MASK_OP_SLRO_D(ctx->opcode);
2416         const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
2417         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16, MO_UB);
2418         break;
2419     case OPC1_16_SLRO_LD_H:
2420         r1 = MASK_OP_SLRO_D(ctx->opcode);
2421         const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
2422         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 2, MO_LESW);
2423         break;
2424     case OPC1_16_SLRO_LD_W:
2425         r1 = MASK_OP_SLRO_D(ctx->opcode);
2426         const16 = MASK_OP_SLRO_OFF4(ctx->opcode);
2427         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
2428         break;
2429 /* SB-format */
2430     case OPC1_16_SB_CALL:
2431     case OPC1_16_SB_J:
2432     case OPC1_16_SB_JNZ:
2433     case OPC1_16_SB_JZ:
2434         address = MASK_OP_SB_DISP8_SEXT(ctx->opcode);
2435         gen_compute_branch(ctx, op1, 0, 0, 0, address);
2436         break;
2437 /* SBC-format */
2438     case OPC1_16_SBC_JEQ:
2439     case OPC1_16_SBC_JNE:
2440         address = MASK_OP_SBC_DISP4(ctx->opcode);
2441         const16 = MASK_OP_SBC_CONST4_SEXT(ctx->opcode);
2442         gen_compute_branch(ctx, op1, 0, 0, const16, address);
2443         break;
2444 /* SBRN-format */
2445     case OPC1_16_SBRN_JNZ_T:
2446     case OPC1_16_SBRN_JZ_T:
2447         address = MASK_OP_SBRN_DISP4(ctx->opcode);
2448         const16 = MASK_OP_SBRN_N(ctx->opcode);
2449         gen_compute_branch(ctx, op1, 0, 0, const16, address);
2450         break;
2451 /* SBR-format */
2452     case OPC1_16_SBR_JEQ:
2453     case OPC1_16_SBR_JGEZ:
2454     case OPC1_16_SBR_JGTZ:
2455     case OPC1_16_SBR_JLEZ:
2456     case OPC1_16_SBR_JLTZ:
2457     case OPC1_16_SBR_JNE:
2458     case OPC1_16_SBR_JNZ:
2459     case OPC1_16_SBR_JNZ_A:
2460     case OPC1_16_SBR_JZ:
2461     case OPC1_16_SBR_JZ_A:
2462     case OPC1_16_SBR_LOOP:
2463         r1 = MASK_OP_SBR_S2(ctx->opcode);
2464         address = MASK_OP_SBR_DISP4(ctx->opcode);
2465         gen_compute_branch(ctx, op1, r1, 0, 0, address);
2466         break;
2467 /* SC-format */
2468     case OPC1_16_SC_AND:
2469     case OPC1_16_SC_BISR:
2470     case OPC1_16_SC_LD_A:
2471     case OPC1_16_SC_LD_W:
2472     case OPC1_16_SC_MOV:
2473     case OPC1_16_SC_OR:
2474     case OPC1_16_SC_ST_A:
2475     case OPC1_16_SC_ST_W:
2476     case OPC1_16_SC_SUB_A:
2477         decode_sc_opc(ctx, op1);
2478         break;
2479 /* SLR-format */
2480     case OPC1_16_SLR_LD_A:
2481     case OPC1_16_SLR_LD_A_POSTINC:
2482     case OPC1_16_SLR_LD_BU:
2483     case OPC1_16_SLR_LD_BU_POSTINC:
2484     case OPC1_16_SLR_LD_H:
2485     case OPC1_16_SLR_LD_H_POSTINC:
2486     case OPC1_16_SLR_LD_W:
2487     case OPC1_16_SLR_LD_W_POSTINC:
2488         decode_slr_opc(ctx, op1);
2489         break;
2490 /* SRO-format */
2491     case OPC1_16_SRO_LD_A:
2492     case OPC1_16_SRO_LD_BU:
2493     case OPC1_16_SRO_LD_H:
2494     case OPC1_16_SRO_LD_W:
2495     case OPC1_16_SRO_ST_A:
2496     case OPC1_16_SRO_ST_B:
2497     case OPC1_16_SRO_ST_H:
2498     case OPC1_16_SRO_ST_W:
2499         decode_sro_opc(ctx, op1);
2500         break;
2501 /* SSRO-format */
2502     case OPC1_16_SSRO_ST_A:
2503         r1 = MASK_OP_SSRO_S1(ctx->opcode);
2504         const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
2505         gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
2506         break;
2507     case OPC1_16_SSRO_ST_B:
2508         r1 = MASK_OP_SSRO_S1(ctx->opcode);
2509         const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
2510         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16, MO_UB);
2511         break;
2512     case OPC1_16_SSRO_ST_H:
2513         r1 = MASK_OP_SSRO_S1(ctx->opcode);
2514         const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
2515         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 2, MO_LESW);
2516         break;
2517     case OPC1_16_SSRO_ST_W:
2518         r1 = MASK_OP_SSRO_S1(ctx->opcode);
2519         const16 = MASK_OP_SSRO_OFF4(ctx->opcode);
2520         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[15], const16 * 4, MO_LESL);
2521         break;
2522 /* SR-format */
2523     case OPCM_16_SR_SYSTEM:
2524         decode_sr_system(env, ctx);
2525         break;
2526     case OPCM_16_SR_ACCU:
2527         decode_sr_accu(env, ctx);
2528         break;
2529     case OPC1_16_SR_JI:
2530         r1 = MASK_OP_SR_S1D(ctx->opcode);
2531         gen_compute_branch(ctx, op1, r1, 0, 0, 0);
2532         break;
2533     case OPC1_16_SR_NOT:
2534         r1 = MASK_OP_SR_S1D(ctx->opcode);
2535         tcg_gen_not_tl(cpu_gpr_d[r1], cpu_gpr_d[r1]);
2536         break;
2537     }
2538 }
2539
2540 /*
2541  * 32 bit instructions
2542  */
2543
2544 /* ABS-format */
2545 static void decode_abs_ldw(CPUTriCoreState *env, DisasContext *ctx)
2546 {
2547     int32_t op2;
2548     int32_t r1;
2549     uint32_t address;
2550     TCGv temp;
2551
2552     r1 = MASK_OP_ABS_S1D(ctx->opcode);
2553     address = MASK_OP_ABS_OFF18(ctx->opcode);
2554     op2 = MASK_OP_ABS_OP2(ctx->opcode);
2555
2556     temp = tcg_const_i32(EA_ABS_FORMAT(address));
2557
2558     switch (op2) {
2559     case OPC2_32_ABS_LD_A:
2560         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LESL);
2561         break;
2562     case OPC2_32_ABS_LD_D:
2563         gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
2564         break;
2565     case OPC2_32_ABS_LD_DA:
2566         gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
2567         break;
2568     case OPC2_32_ABS_LD_W:
2569         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESL);
2570         break;
2571     }
2572
2573     tcg_temp_free(temp);
2574 }
2575
2576 static void decode_abs_ldb(CPUTriCoreState *env, DisasContext *ctx)
2577 {
2578     int32_t op2;
2579     int32_t r1;
2580     uint32_t address;
2581     TCGv temp;
2582
2583     r1 = MASK_OP_ABS_S1D(ctx->opcode);
2584     address = MASK_OP_ABS_OFF18(ctx->opcode);
2585     op2 = MASK_OP_ABS_OP2(ctx->opcode);
2586
2587     temp = tcg_const_i32(EA_ABS_FORMAT(address));
2588
2589     switch (op2) {
2590     case OPC2_32_ABS_LD_B:
2591         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_SB);
2592         break;
2593     case OPC2_32_ABS_LD_BU:
2594         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_UB);
2595         break;
2596     case OPC2_32_ABS_LD_H:
2597         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESW);
2598         break;
2599     case OPC2_32_ABS_LD_HU:
2600         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
2601         break;
2602     }
2603
2604     tcg_temp_free(temp);
2605 }
2606
2607 static void decode_abs_ldst_swap(CPUTriCoreState *env, DisasContext *ctx)
2608 {
2609     int32_t op2;
2610     int32_t r1;
2611     uint32_t address;
2612     TCGv temp;
2613
2614     r1 = MASK_OP_ABS_S1D(ctx->opcode);
2615     address = MASK_OP_ABS_OFF18(ctx->opcode);
2616     op2 = MASK_OP_ABS_OP2(ctx->opcode);
2617
2618     temp = tcg_const_i32(EA_ABS_FORMAT(address));
2619
2620     switch (op2) {
2621     case OPC2_32_ABS_LDMST:
2622         gen_ldmst(ctx, r1, temp);
2623         break;
2624     case OPC2_32_ABS_SWAP_W:
2625         gen_swap(ctx, r1, temp);
2626         break;
2627     }
2628
2629     tcg_temp_free(temp);
2630 }
2631
2632 static void decode_abs_ldst_context(CPUTriCoreState *env, DisasContext *ctx)
2633 {
2634     uint32_t op2;
2635     int32_t off18;
2636
2637     off18 = MASK_OP_ABS_OFF18(ctx->opcode);
2638     op2   = MASK_OP_ABS_OP2(ctx->opcode);
2639
2640     switch (op2) {
2641     case OPC2_32_ABS_LDLCX:
2642         gen_helper_1arg(ldlcx, EA_ABS_FORMAT(off18));
2643         break;
2644     case OPC2_32_ABS_LDUCX:
2645         gen_helper_1arg(lducx, EA_ABS_FORMAT(off18));
2646         break;
2647     case OPC2_32_ABS_STLCX:
2648         gen_helper_1arg(stlcx, EA_ABS_FORMAT(off18));
2649         break;
2650     case OPC2_32_ABS_STUCX:
2651         gen_helper_1arg(stucx, EA_ABS_FORMAT(off18));
2652         break;
2653     }
2654 }
2655
2656 static void decode_abs_store(CPUTriCoreState *env, DisasContext *ctx)
2657 {
2658     int32_t op2;
2659     int32_t r1;
2660     uint32_t address;
2661     TCGv temp;
2662
2663     r1 = MASK_OP_ABS_S1D(ctx->opcode);
2664     address = MASK_OP_ABS_OFF18(ctx->opcode);
2665     op2 = MASK_OP_ABS_OP2(ctx->opcode);
2666
2667     temp = tcg_const_i32(EA_ABS_FORMAT(address));
2668
2669     switch (op2) {
2670     case OPC2_32_ABS_ST_A:
2671         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LESL);
2672         break;
2673     case OPC2_32_ABS_ST_D:
2674         gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
2675         break;
2676     case OPC2_32_ABS_ST_DA:
2677         gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
2678         break;
2679     case OPC2_32_ABS_ST_W:
2680         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LESL);
2681         break;
2682
2683     }
2684     tcg_temp_free(temp);
2685 }
2686
2687 static void decode_abs_storeb_h(CPUTriCoreState *env, DisasContext *ctx)
2688 {
2689     int32_t op2;
2690     int32_t r1;
2691     uint32_t address;
2692     TCGv temp;
2693
2694     r1 = MASK_OP_ABS_S1D(ctx->opcode);
2695     address = MASK_OP_ABS_OFF18(ctx->opcode);
2696     op2 = MASK_OP_ABS_OP2(ctx->opcode);
2697
2698     temp = tcg_const_i32(EA_ABS_FORMAT(address));
2699
2700     switch (op2) {
2701     case OPC2_32_ABS_ST_B:
2702         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_UB);
2703         break;
2704     case OPC2_32_ABS_ST_H:
2705         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
2706         break;
2707     }
2708     tcg_temp_free(temp);
2709 }
2710
2711 /* Bit-format */
2712
2713 static void decode_bit_andacc(CPUTriCoreState *env, DisasContext *ctx)
2714 {
2715     uint32_t op2;
2716     int r1, r2, r3;
2717     int pos1, pos2;
2718
2719     r1 = MASK_OP_BIT_S1(ctx->opcode);
2720     r2 = MASK_OP_BIT_S2(ctx->opcode);
2721     r3 = MASK_OP_BIT_D(ctx->opcode);
2722     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2723     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2724     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2725
2726
2727     switch (op2) {
2728     case OPC2_32_BIT_AND_AND_T:
2729         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2730                     pos1, pos2, &tcg_gen_and_tl, &tcg_gen_and_tl);
2731         break;
2732     case OPC2_32_BIT_AND_ANDN_T:
2733         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2734                     pos1, pos2, &tcg_gen_andc_tl, &tcg_gen_and_tl);
2735         break;
2736     case OPC2_32_BIT_AND_NOR_T:
2737         if (TCG_TARGET_HAS_andc_i32) {
2738             gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2739                         pos1, pos2, &tcg_gen_or_tl, &tcg_gen_andc_tl);
2740         } else {
2741             gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2742                         pos1, pos2, &tcg_gen_nor_tl, &tcg_gen_and_tl);
2743         }
2744         break;
2745     case OPC2_32_BIT_AND_OR_T:
2746         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2747                     pos1, pos2, &tcg_gen_or_tl, &tcg_gen_and_tl);
2748         break;
2749     }
2750 }
2751
2752 static void decode_bit_logical_t(CPUTriCoreState *env, DisasContext *ctx)
2753 {
2754     uint32_t op2;
2755     int r1, r2, r3;
2756     int pos1, pos2;
2757     r1 = MASK_OP_BIT_S1(ctx->opcode);
2758     r2 = MASK_OP_BIT_S2(ctx->opcode);
2759     r3 = MASK_OP_BIT_D(ctx->opcode);
2760     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2761     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2762     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2763
2764     switch (op2) {
2765     case OPC2_32_BIT_AND_T:
2766         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2767                     pos1, pos2, &tcg_gen_and_tl);
2768         break;
2769     case OPC2_32_BIT_ANDN_T:
2770         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2771                     pos1, pos2, &tcg_gen_andc_tl);
2772         break;
2773     case OPC2_32_BIT_NOR_T:
2774         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2775                     pos1, pos2, &tcg_gen_nor_tl);
2776         break;
2777     case OPC2_32_BIT_OR_T:
2778         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2779                     pos1, pos2, &tcg_gen_or_tl);
2780         break;
2781     }
2782 }
2783
2784 static void decode_bit_insert(CPUTriCoreState *env, DisasContext *ctx)
2785 {
2786     uint32_t op2;
2787     int r1, r2, r3;
2788     int pos1, pos2;
2789     TCGv temp;
2790     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2791     r1 = MASK_OP_BIT_S1(ctx->opcode);
2792     r2 = MASK_OP_BIT_S2(ctx->opcode);
2793     r3 = MASK_OP_BIT_D(ctx->opcode);
2794     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2795     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2796
2797     temp = tcg_temp_new();
2798
2799     tcg_gen_shri_tl(temp, cpu_gpr_d[r2], pos2);
2800     if (op2 == OPC2_32_BIT_INSN_T) {
2801         tcg_gen_not_tl(temp, temp);
2802     }
2803     tcg_gen_deposit_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], temp, pos1, 1);
2804     tcg_temp_free(temp);
2805 }
2806
2807 static void decode_bit_logical_t2(CPUTriCoreState *env, DisasContext *ctx)
2808 {
2809     uint32_t op2;
2810
2811     int r1, r2, r3;
2812     int pos1, pos2;
2813
2814     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2815     r1 = MASK_OP_BIT_S1(ctx->opcode);
2816     r2 = MASK_OP_BIT_S2(ctx->opcode);
2817     r3 = MASK_OP_BIT_D(ctx->opcode);
2818     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2819     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2820
2821     switch (op2) {
2822     case OPC2_32_BIT_NAND_T:
2823         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2824                     pos1, pos2, &tcg_gen_nand_tl);
2825         break;
2826     case OPC2_32_BIT_ORN_T:
2827         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2828                     pos1, pos2, &tcg_gen_orc_tl);
2829         break;
2830     case OPC2_32_BIT_XNOR_T:
2831         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2832                     pos1, pos2, &tcg_gen_eqv_tl);
2833         break;
2834     case OPC2_32_BIT_XOR_T:
2835         gen_bit_1op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2836                     pos1, pos2, &tcg_gen_xor_tl);
2837         break;
2838     }
2839 }
2840
2841 static void decode_bit_orand(CPUTriCoreState *env, DisasContext *ctx)
2842 {
2843     uint32_t op2;
2844
2845     int r1, r2, r3;
2846     int pos1, pos2;
2847
2848     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2849     r1 = MASK_OP_BIT_S1(ctx->opcode);
2850     r2 = MASK_OP_BIT_S2(ctx->opcode);
2851     r3 = MASK_OP_BIT_D(ctx->opcode);
2852     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2853     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2854
2855     switch (op2) {
2856     case OPC2_32_BIT_OR_AND_T:
2857         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2858                     pos1, pos2, &tcg_gen_and_tl, &tcg_gen_or_tl);
2859         break;
2860     case OPC2_32_BIT_OR_ANDN_T:
2861         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2862                     pos1, pos2, &tcg_gen_andc_tl, &tcg_gen_or_tl);
2863         break;
2864     case OPC2_32_BIT_OR_NOR_T:
2865         if (TCG_TARGET_HAS_orc_i32) {
2866             gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2867                         pos1, pos2, &tcg_gen_or_tl, &tcg_gen_orc_tl);
2868         } else {
2869             gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2870                         pos1, pos2, &tcg_gen_nor_tl, &tcg_gen_or_tl);
2871         }
2872         break;
2873     case OPC2_32_BIT_OR_OR_T:
2874         gen_bit_2op(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
2875                     pos1, pos2, &tcg_gen_or_tl, &tcg_gen_or_tl);
2876         break;
2877     }
2878 }
2879
2880 static void decode_bit_sh_logic1(CPUTriCoreState *env, DisasContext *ctx)
2881 {
2882     uint32_t op2;
2883     int r1, r2, r3;
2884     int pos1, pos2;
2885     TCGv temp;
2886
2887     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2888     r1 = MASK_OP_BIT_S1(ctx->opcode);
2889     r2 = MASK_OP_BIT_S2(ctx->opcode);
2890     r3 = MASK_OP_BIT_D(ctx->opcode);
2891     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2892     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2893
2894     temp = tcg_temp_new();
2895
2896     switch (op2) {
2897     case OPC2_32_BIT_SH_AND_T:
2898         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2899                     pos1, pos2, &tcg_gen_and_tl);
2900         break;
2901     case OPC2_32_BIT_SH_ANDN_T:
2902         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2903                     pos1, pos2, &tcg_gen_andc_tl);
2904         break;
2905     case OPC2_32_BIT_SH_NOR_T:
2906         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2907                     pos1, pos2, &tcg_gen_nor_tl);
2908         break;
2909     case OPC2_32_BIT_SH_OR_T:
2910         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2911                     pos1, pos2, &tcg_gen_or_tl);
2912         break;
2913     }
2914     tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 1);
2915     tcg_gen_add_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
2916     tcg_temp_free(temp);
2917 }
2918
2919 static void decode_bit_sh_logic2(CPUTriCoreState *env, DisasContext *ctx)
2920 {
2921     uint32_t op2;
2922     int r1, r2, r3;
2923     int pos1, pos2;
2924     TCGv temp;
2925
2926     op2 = MASK_OP_BIT_OP2(ctx->opcode);
2927     r1 = MASK_OP_BIT_S1(ctx->opcode);
2928     r2 = MASK_OP_BIT_S2(ctx->opcode);
2929     r3 = MASK_OP_BIT_D(ctx->opcode);
2930     pos1 = MASK_OP_BIT_POS1(ctx->opcode);
2931     pos2 = MASK_OP_BIT_POS2(ctx->opcode);
2932
2933     temp = tcg_temp_new();
2934
2935     switch (op2) {
2936     case OPC2_32_BIT_SH_NAND_T:
2937         gen_bit_1op(temp, cpu_gpr_d[r1] , cpu_gpr_d[r2] ,
2938                     pos1, pos2, &tcg_gen_nand_tl);
2939         break;
2940     case OPC2_32_BIT_SH_ORN_T:
2941         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2942                     pos1, pos2, &tcg_gen_orc_tl);
2943         break;
2944     case OPC2_32_BIT_SH_XNOR_T:
2945         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2946                     pos1, pos2, &tcg_gen_eqv_tl);
2947         break;
2948     case OPC2_32_BIT_SH_XOR_T:
2949         gen_bit_1op(temp, cpu_gpr_d[r1], cpu_gpr_d[r2],
2950                     pos1, pos2, &tcg_gen_xor_tl);
2951         break;
2952     }
2953     tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 1);
2954     tcg_gen_add_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
2955     tcg_temp_free(temp);
2956 }
2957
2958 /* BO-format */
2959
2960
2961 static void decode_bo_addrmode_post_pre_base(CPUTriCoreState *env,
2962                                              DisasContext *ctx)
2963 {
2964     uint32_t op2;
2965     uint32_t off10;
2966     int32_t r1, r2;
2967     TCGv temp;
2968
2969     r1 = MASK_OP_BO_S1D(ctx->opcode);
2970     r2  = MASK_OP_BO_S2(ctx->opcode);
2971     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
2972     op2 = MASK_OP_BO_OP2(ctx->opcode);
2973
2974     switch (op2) {
2975     case OPC2_32_BO_CACHEA_WI_SHORTOFF:
2976     case OPC2_32_BO_CACHEA_W_SHORTOFF:
2977     case OPC2_32_BO_CACHEA_I_SHORTOFF:
2978         /* instruction to access the cache */
2979         break;
2980     case OPC2_32_BO_CACHEA_WI_POSTINC:
2981     case OPC2_32_BO_CACHEA_W_POSTINC:
2982     case OPC2_32_BO_CACHEA_I_POSTINC:
2983         /* instruction to access the cache, but we still need to handle
2984            the addressing mode */
2985         tcg_gen_addi_tl(cpu_gpr_d[r2], cpu_gpr_d[r2], off10);
2986         break;
2987     case OPC2_32_BO_CACHEA_WI_PREINC:
2988     case OPC2_32_BO_CACHEA_W_PREINC:
2989     case OPC2_32_BO_CACHEA_I_PREINC:
2990         /* instruction to access the cache, but we still need to handle
2991            the addressing mode */
2992         tcg_gen_addi_tl(cpu_gpr_d[r2], cpu_gpr_d[r2], off10);
2993         break;
2994     case OPC2_32_BO_CACHEI_WI_SHORTOFF:
2995     case OPC2_32_BO_CACHEI_W_SHORTOFF:
2996         /* TODO: Raise illegal opcode trap,
2997                  if !tricore_feature(TRICORE_FEATURE_131) */
2998         break;
2999     case OPC2_32_BO_CACHEI_W_POSTINC:
3000     case OPC2_32_BO_CACHEI_WI_POSTINC:
3001         if (tricore_feature(env, TRICORE_FEATURE_131)) {
3002             tcg_gen_addi_tl(cpu_gpr_d[r2], cpu_gpr_d[r2], off10);
3003         } /* TODO: else raise illegal opcode trap */
3004         break;
3005     case OPC2_32_BO_CACHEI_W_PREINC:
3006     case OPC2_32_BO_CACHEI_WI_PREINC:
3007         if (tricore_feature(env, TRICORE_FEATURE_131)) {
3008             tcg_gen_addi_tl(cpu_gpr_d[r2], cpu_gpr_d[r2], off10);
3009         } /* TODO: else raise illegal opcode trap */
3010         break;
3011     case OPC2_32_BO_ST_A_SHORTOFF:
3012         gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
3013         break;
3014     case OPC2_32_BO_ST_A_POSTINC:
3015         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
3016                            MO_LESL);
3017         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3018         break;
3019     case OPC2_32_BO_ST_A_PREINC:
3020         gen_st_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
3021         break;
3022     case OPC2_32_BO_ST_B_SHORTOFF:
3023         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
3024         break;
3025     case OPC2_32_BO_ST_B_POSTINC:
3026         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3027                            MO_UB);
3028         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3029         break;
3030     case OPC2_32_BO_ST_B_PREINC:
3031         gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
3032         break;
3033     case OPC2_32_BO_ST_D_SHORTOFF:
3034         gen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
3035                             off10, ctx);
3036         break;
3037     case OPC2_32_BO_ST_D_POSTINC:
3038         gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
3039         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3040         break;
3041     case OPC2_32_BO_ST_D_PREINC:
3042         temp = tcg_temp_new();
3043         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3044         gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
3045         tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
3046         tcg_temp_free(temp);
3047         break;
3048     case OPC2_32_BO_ST_DA_SHORTOFF:
3049         gen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
3050                             off10, ctx);
3051         break;
3052     case OPC2_32_BO_ST_DA_POSTINC:
3053         gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
3054         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3055         break;
3056     case OPC2_32_BO_ST_DA_PREINC:
3057         temp = tcg_temp_new();
3058         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3059         gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
3060         tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
3061         tcg_temp_free(temp);
3062         break;
3063     case OPC2_32_BO_ST_H_SHORTOFF:
3064         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3065         break;
3066     case OPC2_32_BO_ST_H_POSTINC:
3067         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3068                            MO_LEUW);
3069         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3070         break;
3071     case OPC2_32_BO_ST_H_PREINC:
3072         gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3073         break;
3074     case OPC2_32_BO_ST_Q_SHORTOFF:
3075         temp = tcg_temp_new();
3076         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
3077         gen_offset_st(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
3078         tcg_temp_free(temp);
3079         break;
3080     case OPC2_32_BO_ST_Q_POSTINC:
3081         temp = tcg_temp_new();
3082         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
3083         tcg_gen_qemu_st_tl(temp, cpu_gpr_a[r2], ctx->mem_idx,
3084                            MO_LEUW);
3085         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3086         tcg_temp_free(temp);
3087         break;
3088     case OPC2_32_BO_ST_Q_PREINC:
3089         temp = tcg_temp_new();
3090         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
3091         gen_st_preincr(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
3092         tcg_temp_free(temp);
3093         break;
3094     case OPC2_32_BO_ST_W_SHORTOFF:
3095         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3096         break;
3097     case OPC2_32_BO_ST_W_POSTINC:
3098         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3099                            MO_LEUL);
3100         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3101         break;
3102     case OPC2_32_BO_ST_W_PREINC:
3103         gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3104         break;
3105     }
3106 }
3107
3108 static void decode_bo_addrmode_bitreverse_circular(CPUTriCoreState *env,
3109                                                    DisasContext *ctx)
3110 {
3111     uint32_t op2;
3112     uint32_t off10;
3113     int32_t r1, r2;
3114     TCGv temp, temp2, temp3;
3115
3116     r1 = MASK_OP_BO_S1D(ctx->opcode);
3117     r2  = MASK_OP_BO_S2(ctx->opcode);
3118     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
3119     op2 = MASK_OP_BO_OP2(ctx->opcode);
3120
3121     temp = tcg_temp_new();
3122     temp2 = tcg_temp_new();
3123     temp3 = tcg_const_i32(off10);
3124
3125     tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
3126     tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3127
3128     switch (op2) {
3129     case OPC2_32_BO_CACHEA_WI_BR:
3130     case OPC2_32_BO_CACHEA_W_BR:
3131     case OPC2_32_BO_CACHEA_I_BR:
3132         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3133         break;
3134     case OPC2_32_BO_CACHEA_WI_CIRC:
3135     case OPC2_32_BO_CACHEA_W_CIRC:
3136     case OPC2_32_BO_CACHEA_I_CIRC:
3137         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3138         break;
3139     case OPC2_32_BO_ST_A_BR:
3140         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3141         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3142         break;
3143     case OPC2_32_BO_ST_A_CIRC:
3144         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3145         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3146         break;
3147     case OPC2_32_BO_ST_B_BR:
3148         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
3149         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3150         break;
3151     case OPC2_32_BO_ST_B_CIRC:
3152         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
3153         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3154         break;
3155     case OPC2_32_BO_ST_D_BR:
3156         gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp2, ctx);
3157         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3158         break;
3159     case OPC2_32_BO_ST_D_CIRC:
3160         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3161         tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
3162         tcg_gen_addi_tl(temp, temp, 4);
3163         tcg_gen_rem_tl(temp, temp, temp2);
3164         tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3165         tcg_gen_qemu_st_tl(cpu_gpr_d[r1+1], temp2, ctx->mem_idx, MO_LEUL);
3166         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3167         break;
3168     case OPC2_32_BO_ST_DA_BR:
3169         gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp2, ctx);
3170         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3171         break;
3172     case OPC2_32_BO_ST_DA_CIRC:
3173         tcg_gen_qemu_st_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3174         tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
3175         tcg_gen_addi_tl(temp, temp, 4);
3176         tcg_gen_rem_tl(temp, temp, temp2);
3177         tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3178         tcg_gen_qemu_st_tl(cpu_gpr_a[r1+1], temp2, ctx->mem_idx, MO_LEUL);
3179         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3180         break;
3181     case OPC2_32_BO_ST_H_BR:
3182         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3183         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3184         break;
3185     case OPC2_32_BO_ST_H_CIRC:
3186         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3187         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3188         break;
3189     case OPC2_32_BO_ST_Q_BR:
3190         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
3191         tcg_gen_qemu_st_tl(temp, temp2, ctx->mem_idx, MO_LEUW);
3192         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3193         break;
3194     case OPC2_32_BO_ST_Q_CIRC:
3195         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
3196         tcg_gen_qemu_st_tl(temp, temp2, ctx->mem_idx, MO_LEUW);
3197         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3198         break;
3199     case OPC2_32_BO_ST_W_BR:
3200         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3201         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3202         break;
3203     case OPC2_32_BO_ST_W_CIRC:
3204         tcg_gen_qemu_st_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3205         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3206         break;
3207     }
3208     tcg_temp_free(temp);
3209     tcg_temp_free(temp2);
3210     tcg_temp_free(temp3);
3211 }
3212
3213 static void decode_bo_addrmode_ld_post_pre_base(CPUTriCoreState *env,
3214                                                 DisasContext *ctx)
3215 {
3216     uint32_t op2;
3217     uint32_t off10;
3218     int32_t r1, r2;
3219     TCGv temp;
3220
3221     r1 = MASK_OP_BO_S1D(ctx->opcode);
3222     r2  = MASK_OP_BO_S2(ctx->opcode);
3223     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
3224     op2 = MASK_OP_BO_OP2(ctx->opcode);
3225
3226     switch (op2) {
3227     case OPC2_32_BO_LD_A_SHORTOFF:
3228         gen_offset_ld(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3229         break;
3230     case OPC2_32_BO_LD_A_POSTINC:
3231         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
3232                            MO_LEUL);
3233         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3234         break;
3235     case OPC2_32_BO_LD_A_PREINC:
3236         gen_ld_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3237         break;
3238     case OPC2_32_BO_LD_B_SHORTOFF:
3239         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
3240         break;
3241     case OPC2_32_BO_LD_B_POSTINC:
3242         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3243                            MO_SB);
3244         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3245         break;
3246     case OPC2_32_BO_LD_B_PREINC:
3247         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
3248         break;
3249     case OPC2_32_BO_LD_BU_SHORTOFF:
3250         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
3251         break;
3252     case OPC2_32_BO_LD_BU_POSTINC:
3253         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3254                            MO_UB);
3255         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3256         break;
3257     case OPC2_32_BO_LD_BU_PREINC:
3258         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_SB);
3259         break;
3260     case OPC2_32_BO_LD_D_SHORTOFF:
3261         gen_offset_ld_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
3262                             off10, ctx);
3263         break;
3264     case OPC2_32_BO_LD_D_POSTINC:
3265         gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
3266         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3267         break;
3268     case OPC2_32_BO_LD_D_PREINC:
3269         temp = tcg_temp_new();
3270         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3271         gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
3272         tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
3273         tcg_temp_free(temp);
3274         break;
3275     case OPC2_32_BO_LD_DA_SHORTOFF:
3276         gen_offset_ld_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
3277                             off10, ctx);
3278         break;
3279     case OPC2_32_BO_LD_DA_POSTINC:
3280         gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
3281         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3282         break;
3283     case OPC2_32_BO_LD_DA_PREINC:
3284         temp = tcg_temp_new();
3285         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3286         gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
3287         tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
3288         tcg_temp_free(temp);
3289         break;
3290     case OPC2_32_BO_LD_H_SHORTOFF:
3291         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LESW);
3292         break;
3293     case OPC2_32_BO_LD_H_POSTINC:
3294         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3295                            MO_LESW);
3296         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3297         break;
3298     case OPC2_32_BO_LD_H_PREINC:
3299         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LESW);
3300         break;
3301     case OPC2_32_BO_LD_HU_SHORTOFF:
3302         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3303         break;
3304     case OPC2_32_BO_LD_HU_POSTINC:
3305         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3306                            MO_LEUW);
3307         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3308         break;
3309     case OPC2_32_BO_LD_HU_PREINC:
3310         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3311         break;
3312     case OPC2_32_BO_LD_Q_SHORTOFF:
3313         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3314         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
3315         break;
3316     case OPC2_32_BO_LD_Q_POSTINC:
3317         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3318                            MO_LEUW);
3319         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
3320         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3321         break;
3322     case OPC2_32_BO_LD_Q_PREINC:
3323         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
3324         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
3325         break;
3326     case OPC2_32_BO_LD_W_SHORTOFF:
3327         gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3328         break;
3329     case OPC2_32_BO_LD_W_POSTINC:
3330         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
3331                            MO_LEUL);
3332         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3333         break;
3334     case OPC2_32_BO_LD_W_PREINC:
3335         gen_ld_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
3336         break;
3337     }
3338 }
3339
3340 static void decode_bo_addrmode_ld_bitreverse_circular(CPUTriCoreState *env,
3341                                                 DisasContext *ctx)
3342 {
3343     uint32_t op2;
3344     uint32_t off10;
3345     int r1, r2;
3346
3347     TCGv temp, temp2, temp3;
3348
3349     r1 = MASK_OP_BO_S1D(ctx->opcode);
3350     r2 = MASK_OP_BO_S2(ctx->opcode);
3351     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
3352     op2 = MASK_OP_BO_OP2(ctx->opcode);
3353
3354     temp = tcg_temp_new();
3355     temp2 = tcg_temp_new();
3356     temp3 = tcg_const_i32(off10);
3357
3358     tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
3359     tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3360
3361
3362     switch (op2) {
3363     case OPC2_32_BO_LD_A_BR:
3364         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3365         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3366         break;
3367     case OPC2_32_BO_LD_A_CIRC:
3368         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3369         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3370         break;
3371     case OPC2_32_BO_LD_B_BR:
3372         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_SB);
3373         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3374         break;
3375     case OPC2_32_BO_LD_B_CIRC:
3376         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_SB);
3377         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3378         break;
3379     case OPC2_32_BO_LD_BU_BR:
3380         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
3381         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3382         break;
3383     case OPC2_32_BO_LD_BU_CIRC:
3384         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_UB);
3385         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3386         break;
3387     case OPC2_32_BO_LD_D_BR:
3388         gen_ld_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp2, ctx);
3389         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3390         break;
3391     case OPC2_32_BO_LD_D_CIRC:
3392         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3393         tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
3394         tcg_gen_addi_tl(temp, temp, 4);
3395         tcg_gen_rem_tl(temp, temp, temp2);
3396         tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3397         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1+1], temp2, ctx->mem_idx, MO_LEUL);
3398         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3399         break;
3400     case OPC2_32_BO_LD_DA_BR:
3401         gen_ld_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp2, ctx);
3402         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3403         break;
3404     case OPC2_32_BO_LD_DA_CIRC:
3405         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp2, ctx->mem_idx, MO_LEUL);
3406         tcg_gen_shri_tl(temp2, cpu_gpr_a[r2+1], 16);
3407         tcg_gen_addi_tl(temp, temp, 4);
3408         tcg_gen_rem_tl(temp, temp, temp2);
3409         tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3410         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1+1], temp2, ctx->mem_idx, MO_LEUL);
3411         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3412         break;
3413     case OPC2_32_BO_LD_H_BR:
3414         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LESW);
3415         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3416         break;
3417     case OPC2_32_BO_LD_H_CIRC:
3418         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LESW);
3419         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3420         break;
3421     case OPC2_32_BO_LD_HU_BR:
3422         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3423         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3424         break;
3425     case OPC2_32_BO_LD_HU_CIRC:
3426         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3427         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3428         break;
3429     case OPC2_32_BO_LD_Q_BR:
3430         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3431         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
3432         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3433         break;
3434     case OPC2_32_BO_LD_Q_CIRC:
3435         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUW);
3436         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
3437         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3438         break;
3439     case OPC2_32_BO_LD_W_BR:
3440         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3441         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3442         break;
3443     case OPC2_32_BO_LD_W_CIRC:
3444         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp2, ctx->mem_idx, MO_LEUL);
3445         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3446         break;
3447     }
3448     tcg_temp_free(temp);
3449     tcg_temp_free(temp2);
3450     tcg_temp_free(temp3);
3451 }
3452
3453 static void decode_bo_addrmode_stctx_post_pre_base(CPUTriCoreState *env,
3454                                                    DisasContext *ctx)
3455 {
3456     uint32_t op2;
3457     uint32_t off10;
3458     int r1, r2;
3459
3460     TCGv temp, temp2;
3461
3462     r1 = MASK_OP_BO_S1D(ctx->opcode);
3463     r2 = MASK_OP_BO_S2(ctx->opcode);
3464     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
3465     op2 = MASK_OP_BO_OP2(ctx->opcode);
3466
3467
3468     temp = tcg_temp_new();
3469     temp2 = tcg_temp_new();
3470
3471     switch (op2) {
3472     case OPC2_32_BO_LDLCX_SHORTOFF:
3473         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3474         gen_helper_ldlcx(cpu_env, temp);
3475         break;
3476     case OPC2_32_BO_LDMST_SHORTOFF:
3477         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3478         gen_ldmst(ctx, r1, temp);
3479         break;
3480     case OPC2_32_BO_LDMST_POSTINC:
3481         gen_ldmst(ctx, r1, cpu_gpr_a[r2]);
3482         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3483         break;
3484     case OPC2_32_BO_LDMST_PREINC:
3485         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3486         gen_ldmst(ctx, r1, cpu_gpr_a[r2]);
3487         break;
3488     case OPC2_32_BO_LDUCX_SHORTOFF:
3489         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3490         gen_helper_lducx(cpu_env, temp);
3491         break;
3492     case OPC2_32_BO_LEA_SHORTOFF:
3493         tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], off10);
3494         break;
3495     case OPC2_32_BO_STLCX_SHORTOFF:
3496         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3497         gen_helper_stlcx(cpu_env, temp);
3498         break;
3499     case OPC2_32_BO_STUCX_SHORTOFF:
3500         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3501         gen_helper_stucx(cpu_env, temp);
3502         break;
3503     case OPC2_32_BO_SWAP_W_SHORTOFF:
3504         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
3505         gen_swap(ctx, r1, temp);
3506         break;
3507     case OPC2_32_BO_SWAP_W_POSTINC:
3508         gen_swap(ctx, r1, cpu_gpr_a[r2]);
3509         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3510         break;
3511     case OPC2_32_BO_SWAP_W_PREINC:
3512         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
3513         gen_swap(ctx, r1, cpu_gpr_a[r2]);
3514         break;
3515     }
3516     tcg_temp_free(temp);
3517     tcg_temp_free(temp2);
3518 }
3519
3520 static void decode_bo_addrmode_ldmst_bitreverse_circular(CPUTriCoreState *env,
3521                                                          DisasContext *ctx)
3522 {
3523     uint32_t op2;
3524     uint32_t off10;
3525     int r1, r2;
3526
3527     TCGv temp, temp2, temp3;
3528
3529     r1 = MASK_OP_BO_S1D(ctx->opcode);
3530     r2 = MASK_OP_BO_S2(ctx->opcode);
3531     off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
3532     op2 = MASK_OP_BO_OP2(ctx->opcode);
3533
3534     temp = tcg_temp_new();
3535     temp2 = tcg_temp_new();
3536     temp3 = tcg_const_i32(off10);
3537
3538     tcg_gen_ext16u_tl(temp, cpu_gpr_a[r2+1]);
3539     tcg_gen_add_tl(temp2, cpu_gpr_a[r2], temp);
3540
3541     switch (op2) {
3542     case OPC2_32_BO_LDMST_BR:
3543         gen_ldmst(ctx, r1, temp2);
3544         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3545         break;
3546     case OPC2_32_BO_LDMST_CIRC:
3547         gen_ldmst(ctx, r1, temp2);
3548         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3549         break;
3550     case OPC2_32_BO_SWAP_W_BR:
3551         gen_swap(ctx, r1, temp2);
3552         gen_helper_br_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1]);
3553         break;
3554     case OPC2_32_BO_SWAP_W_CIRC:
3555         gen_swap(ctx, r1, temp2);
3556         gen_helper_circ_update(cpu_gpr_a[r2+1], cpu_gpr_a[r2+1], temp3);
3557         break;
3558     }
3559     tcg_temp_free(temp);
3560     tcg_temp_free(temp2);
3561     tcg_temp_free(temp3);
3562 }
3563
3564 static void decode_bol_opc(CPUTriCoreState *env, DisasContext *ctx, int32_t op1)
3565 {
3566     int r1, r2;
3567     int32_t address;
3568     TCGv temp;
3569
3570     r1 = MASK_OP_BOL_S1D(ctx->opcode);
3571     r2 = MASK_OP_BOL_S2(ctx->opcode);
3572     address = MASK_OP_BOL_OFF16_SEXT(ctx->opcode);
3573
3574     switch (op1) {
3575     case OPC1_32_BOL_LD_A_LONGOFF:
3576         temp = tcg_temp_new();
3577         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], address);
3578         tcg_gen_qemu_ld_tl(cpu_gpr_a[r1], temp, ctx->mem_idx, MO_LEUL);
3579         tcg_temp_free(temp);
3580         break;
3581     case OPC1_32_BOL_LD_W_LONGOFF:
3582         temp = tcg_temp_new();
3583         tcg_gen_addi_tl(temp, cpu_gpr_a[r2], address);
3584         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUL);
3585         tcg_temp_free(temp);
3586         break;
3587     case OPC1_32_BOL_LEA_LONGOFF:
3588         tcg_gen_addi_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], address);
3589         break;
3590     case OPC1_32_BOL_ST_A_LONGOFF:
3591         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3592             gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], address, MO_LEUL);
3593         } else {
3594             /* raise illegal opcode trap */
3595         }
3596         break;
3597     case OPC1_32_BOL_ST_W_LONGOFF:
3598         gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LEUL);
3599         break;
3600     case OPC1_32_BOL_LD_B_LONGOFF:
3601         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3602             gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_SB);
3603         } else {
3604             /* raise illegal opcode trap */
3605         }
3606         break;
3607     case OPC1_32_BOL_LD_BU_LONGOFF:
3608         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3609             gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_UB);
3610         } else {
3611             /* raise illegal opcode trap */
3612         }
3613         break;
3614     case OPC1_32_BOL_LD_H_LONGOFF:
3615         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3616             gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LESW);
3617         } else {
3618             /* raise illegal opcode trap */
3619         }
3620         break;
3621     case OPC1_32_BOL_LD_HU_LONGOFF:
3622         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3623             gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LEUW);
3624         } else {
3625             /* raise illegal opcode trap */
3626         }
3627         break;
3628     case OPC1_32_BOL_ST_B_LONGOFF:
3629         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3630             gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_SB);
3631         } else {
3632             /* raise illegal opcode trap */
3633         }
3634         break;
3635     case OPC1_32_BOL_ST_H_LONGOFF:
3636         if (tricore_feature(env, TRICORE_FEATURE_16)) {
3637             gen_offset_ld(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], address, MO_LESW);
3638         } else {
3639             /* raise illegal opcode trap */
3640         }
3641         break;
3642     }
3643 }
3644
3645 /* RC format */
3646 static void decode_rc_logical_shift(CPUTriCoreState *env, DisasContext *ctx)
3647 {
3648     uint32_t op2;
3649     int r1, r2;
3650     int32_t const9;
3651     TCGv temp;
3652
3653     r2 = MASK_OP_RC_D(ctx->opcode);
3654     r1 = MASK_OP_RC_S1(ctx->opcode);
3655     const9 = MASK_OP_RC_CONST9(ctx->opcode);
3656     op2 = MASK_OP_RC_OP2(ctx->opcode);
3657
3658     temp = tcg_temp_new();
3659
3660     switch (op2) {
3661     case OPC2_32_RC_AND:
3662         tcg_gen_andi_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3663         break;
3664     case OPC2_32_RC_ANDN:
3665         tcg_gen_andi_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], ~const9);
3666         break;
3667     case OPC2_32_RC_NAND:
3668         tcg_gen_movi_tl(temp, const9);
3669         tcg_gen_nand_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp);
3670         break;
3671     case OPC2_32_RC_NOR:
3672         tcg_gen_movi_tl(temp, const9);
3673         tcg_gen_nor_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp);
3674         break;
3675     case OPC2_32_RC_OR:
3676         tcg_gen_ori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3677         break;
3678     case OPC2_32_RC_ORN:
3679         tcg_gen_ori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], ~const9);
3680         break;
3681     case OPC2_32_RC_SH:
3682         const9 = sextract32(const9, 0, 6);
3683         gen_shi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3684         break;
3685     case OPC2_32_RC_SH_H:
3686         const9 = sextract32(const9, 0, 5);
3687         gen_sh_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3688         break;
3689     case OPC2_32_RC_SHA:
3690         const9 = sextract32(const9, 0, 6);
3691         gen_shaci(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3692         break;
3693     case OPC2_32_RC_SHA_H:
3694         const9 = sextract32(const9, 0, 5);
3695         gen_sha_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3696         break;
3697     case OPC2_32_RC_SHAS:
3698         gen_shasi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3699         break;
3700     case OPC2_32_RC_XNOR:
3701         tcg_gen_xori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3702         tcg_gen_not_tl(cpu_gpr_d[r2], cpu_gpr_d[r2]);
3703         break;
3704     case OPC2_32_RC_XOR:
3705         tcg_gen_xori_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3706         break;
3707     }
3708     tcg_temp_free(temp);
3709 }
3710
3711 static void decode_rc_accumulator(CPUTriCoreState *env, DisasContext *ctx)
3712 {
3713     uint32_t op2;
3714     int r1, r2;
3715     int16_t const9;
3716
3717     TCGv temp;
3718
3719     r2 = MASK_OP_RC_D(ctx->opcode);
3720     r1 = MASK_OP_RC_S1(ctx->opcode);
3721     const9 = MASK_OP_RC_CONST9_SEXT(ctx->opcode);
3722
3723     op2 = MASK_OP_RC_OP2(ctx->opcode);
3724
3725     temp = tcg_temp_new();
3726
3727     switch (op2) {
3728     case OPC2_32_RC_ABSDIF:
3729         gen_absdifi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3730         break;
3731     case OPC2_32_RC_ABSDIFS:
3732         gen_absdifsi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3733         break;
3734     case OPC2_32_RC_ADD:
3735         gen_addi_d(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3736         break;
3737     case OPC2_32_RC_ADDC:
3738         gen_addci_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3739         break;
3740     case OPC2_32_RC_ADDS:
3741         gen_addsi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3742         break;
3743     case OPC2_32_RC_ADDS_U:
3744         gen_addsui(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3745         break;
3746     case OPC2_32_RC_ADDX:
3747         gen_addi_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3748         break;
3749     case OPC2_32_RC_AND_EQ:
3750         gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
3751                                const9, &tcg_gen_and_tl);
3752         break;
3753     case OPC2_32_RC_AND_GE:
3754         gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3755                                const9, &tcg_gen_and_tl);
3756         break;
3757     case OPC2_32_RC_AND_GE_U:
3758         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3759         gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3760                                const9, &tcg_gen_and_tl);
3761         break;
3762     case OPC2_32_RC_AND_LT:
3763         gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
3764                                const9, &tcg_gen_and_tl);
3765         break;
3766     case OPC2_32_RC_AND_LT_U:
3767         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3768         gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3769                                const9, &tcg_gen_and_tl);
3770         break;
3771     case OPC2_32_RC_AND_NE:
3772         gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3773                                const9, &tcg_gen_and_tl);
3774         break;
3775     case OPC2_32_RC_EQ:
3776         tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3777         break;
3778     case OPC2_32_RC_EQANY_B:
3779         gen_eqany_bi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3780         break;
3781     case OPC2_32_RC_EQANY_H:
3782         gen_eqany_hi(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3783         break;
3784     case OPC2_32_RC_GE:
3785         tcg_gen_setcondi_tl(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3786         break;
3787     case OPC2_32_RC_GE_U:
3788         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3789         tcg_gen_setcondi_tl(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3790         break;
3791     case OPC2_32_RC_LT:
3792         tcg_gen_setcondi_tl(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3793         break;
3794     case OPC2_32_RC_LT_U:
3795         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3796         tcg_gen_setcondi_tl(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3797         break;
3798     case OPC2_32_RC_MAX:
3799         tcg_gen_movi_tl(temp, const9);
3800         tcg_gen_movcond_tl(TCG_COND_GT, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
3801                            cpu_gpr_d[r1], temp);
3802         break;
3803     case OPC2_32_RC_MAX_U:
3804         tcg_gen_movi_tl(temp, MASK_OP_RC_CONST9(ctx->opcode));
3805         tcg_gen_movcond_tl(TCG_COND_GTU, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
3806                            cpu_gpr_d[r1], temp);
3807         break;
3808     case OPC2_32_RC_MIN:
3809         tcg_gen_movi_tl(temp, const9);
3810         tcg_gen_movcond_tl(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
3811                            cpu_gpr_d[r1], temp);
3812         break;
3813     case OPC2_32_RC_MIN_U:
3814         tcg_gen_movi_tl(temp, MASK_OP_RC_CONST9(ctx->opcode));
3815         tcg_gen_movcond_tl(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], temp,
3816                            cpu_gpr_d[r1], temp);
3817         break;
3818     case OPC2_32_RC_NE:
3819         tcg_gen_setcondi_tl(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3820         break;
3821     case OPC2_32_RC_OR_EQ:
3822         gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
3823                                const9, &tcg_gen_or_tl);
3824         break;
3825     case OPC2_32_RC_OR_GE:
3826         gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3827                                const9, &tcg_gen_or_tl);
3828         break;
3829     case OPC2_32_RC_OR_GE_U:
3830         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3831         gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3832                                const9, &tcg_gen_or_tl);
3833         break;
3834     case OPC2_32_RC_OR_LT:
3835         gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
3836                                const9, &tcg_gen_or_tl);
3837         break;
3838     case OPC2_32_RC_OR_LT_U:
3839         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3840         gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3841                                const9, &tcg_gen_or_tl);
3842         break;
3843     case OPC2_32_RC_OR_NE:
3844         gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3845                                const9, &tcg_gen_or_tl);
3846         break;
3847     case OPC2_32_RC_RSUB:
3848         tcg_gen_movi_tl(temp, const9);
3849         gen_sub_d(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
3850         break;
3851     case OPC2_32_RC_RSUBS:
3852         tcg_gen_movi_tl(temp, const9);
3853         gen_subs(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
3854         break;
3855     case OPC2_32_RC_RSUBS_U:
3856         tcg_gen_movi_tl(temp, const9);
3857         gen_subsu(cpu_gpr_d[r2], temp, cpu_gpr_d[r1]);
3858         break;
3859     case OPC2_32_RC_SH_EQ:
3860         gen_sh_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3861         break;
3862     case OPC2_32_RC_SH_GE:
3863         gen_sh_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3864         break;
3865     case OPC2_32_RC_SH_GE_U:
3866         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3867         gen_sh_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3868         break;
3869     case OPC2_32_RC_SH_LT:
3870         gen_sh_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3871         break;
3872     case OPC2_32_RC_SH_LT_U:
3873         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3874         gen_sh_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3875         break;
3876     case OPC2_32_RC_SH_NE:
3877         gen_sh_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3878         break;
3879     case OPC2_32_RC_XOR_EQ:
3880         gen_accumulating_condi(TCG_COND_EQ, cpu_gpr_d[r2], cpu_gpr_d[r1],
3881                                const9, &tcg_gen_xor_tl);
3882         break;
3883     case OPC2_32_RC_XOR_GE:
3884         gen_accumulating_condi(TCG_COND_GE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3885                                const9, &tcg_gen_xor_tl);
3886         break;
3887     case OPC2_32_RC_XOR_GE_U:
3888         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3889         gen_accumulating_condi(TCG_COND_GEU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3890                                const9, &tcg_gen_xor_tl);
3891         break;
3892     case OPC2_32_RC_XOR_LT:
3893         gen_accumulating_condi(TCG_COND_LT, cpu_gpr_d[r2], cpu_gpr_d[r1],
3894                                const9, &tcg_gen_xor_tl);
3895         break;
3896     case OPC2_32_RC_XOR_LT_U:
3897         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3898         gen_accumulating_condi(TCG_COND_LTU, cpu_gpr_d[r2], cpu_gpr_d[r1],
3899                                const9, &tcg_gen_xor_tl);
3900         break;
3901     case OPC2_32_RC_XOR_NE:
3902         gen_accumulating_condi(TCG_COND_NE, cpu_gpr_d[r2], cpu_gpr_d[r1],
3903                                const9, &tcg_gen_xor_tl);
3904         break;
3905     }
3906     tcg_temp_free(temp);
3907 }
3908
3909 static void decode_rc_serviceroutine(CPUTriCoreState *env, DisasContext *ctx)
3910 {
3911     uint32_t op2;
3912     uint32_t const9;
3913
3914     op2 = MASK_OP_RC_OP2(ctx->opcode);
3915     const9 = MASK_OP_RC_CONST9(ctx->opcode);
3916
3917     switch (op2) {
3918     case OPC2_32_RC_BISR:
3919         gen_helper_1arg(bisr, const9);
3920         break;
3921     case OPC2_32_RC_SYSCALL:
3922         /* TODO: Add exception generation */
3923         break;
3924     }
3925 }
3926
3927 static void decode_rc_mul(CPUTriCoreState *env, DisasContext *ctx)
3928 {
3929     uint32_t op2;
3930     int r1, r2;
3931     int16_t const9;
3932
3933     r2 = MASK_OP_RC_D(ctx->opcode);
3934     r1 = MASK_OP_RC_S1(ctx->opcode);
3935     const9 = MASK_OP_RC_CONST9_SEXT(ctx->opcode);
3936
3937     op2 = MASK_OP_RC_OP2(ctx->opcode);
3938
3939     switch (op2) {
3940     case OPC2_32_RC_MUL_32:
3941         gen_muli_i32s(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3942         break;
3943     case OPC2_32_RC_MUL_64:
3944         gen_muli_i64s(cpu_gpr_d[r2], cpu_gpr_d[r2+1], cpu_gpr_d[r1], const9);
3945         break;
3946     case OPC2_32_RC_MULS_32:
3947         gen_mulsi_i32(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3948         break;
3949     case OPC2_32_RC_MUL_U_64:
3950         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3951         gen_muli_i64u(cpu_gpr_d[r2], cpu_gpr_d[r2+1], cpu_gpr_d[r1], const9);
3952         break;
3953     case OPC2_32_RC_MULS_U_32:
3954         const9 = MASK_OP_RC_CONST9(ctx->opcode);
3955         gen_mulsui_i32(cpu_gpr_d[r2], cpu_gpr_d[r1], const9);
3956         break;
3957     }
3958 }
3959
3960 /* RCPW format */
3961 static void decode_rcpw_insert(CPUTriCoreState *env, DisasContext *ctx)
3962 {
3963     uint32_t op2;
3964     int r1, r2;
3965     int32_t pos, width, const4;
3966
3967     TCGv temp;
3968
3969     op2    = MASK_OP_RCPW_OP2(ctx->opcode);
3970     r1     = MASK_OP_RCPW_S1(ctx->opcode);
3971     r2     = MASK_OP_RCPW_D(ctx->opcode);
3972     const4 = MASK_OP_RCPW_CONST4(ctx->opcode);
3973     width  = MASK_OP_RCPW_WIDTH(ctx->opcode);
3974     pos    = MASK_OP_RCPW_POS(ctx->opcode);
3975
3976     switch (op2) {
3977     case OPC2_32_RCPW_IMASK:
3978         /* if pos + width > 31 undefined result */
3979         if (pos + width <= 31) {
3980             tcg_gen_movi_tl(cpu_gpr_d[r2+1], ((1u << width) - 1) << pos);
3981             tcg_gen_movi_tl(cpu_gpr_d[r2], (const4 << pos));
3982         }
3983         break;
3984     case OPC2_32_RCPW_INSERT:
3985         /* if pos + width > 32 undefined result */
3986         if (pos + width <= 32) {
3987             temp = tcg_const_i32(const4);
3988             tcg_gen_deposit_tl(cpu_gpr_d[r2], cpu_gpr_d[r1], temp, pos, width);
3989             tcg_temp_free(temp);
3990         }
3991         break;
3992     }
3993 }
3994
3995 /* RCRW format */
3996
3997 static void decode_rcrw_insert(CPUTriCoreState *env, DisasContext *ctx)
3998 {
3999     uint32_t op2;
4000     int r1, r3, r4;
4001     int32_t width, const4;
4002
4003     TCGv temp, temp2, temp3;
4004
4005     op2    = MASK_OP_RCRW_OP2(ctx->opcode);
4006     r1     = MASK_OP_RCRW_S1(ctx->opcode);
4007     r3     = MASK_OP_RCRW_S3(ctx->opcode);
4008     r4     = MASK_OP_RCRW_D(ctx->opcode);
4009     width  = MASK_OP_RCRW_WIDTH(ctx->opcode);
4010     const4 = MASK_OP_RCRW_CONST4(ctx->opcode);
4011
4012     temp = tcg_temp_new();
4013     temp2 = tcg_temp_new();
4014
4015     switch (op2) {
4016     case OPC2_32_RCRW_IMASK:
4017         tcg_gen_andi_tl(temp, cpu_gpr_d[r4], 0x1f);
4018         tcg_gen_movi_tl(temp2, (1 << width) - 1);
4019         tcg_gen_shl_tl(cpu_gpr_d[r3 + 1], temp2, temp);
4020         tcg_gen_movi_tl(temp2, const4);
4021         tcg_gen_shl_tl(cpu_gpr_d[r3], temp2, temp);
4022         break;
4023     case OPC2_32_RCRW_INSERT:
4024         temp3 = tcg_temp_new();
4025
4026         tcg_gen_movi_tl(temp, width);
4027         tcg_gen_movi_tl(temp2, const4);
4028         tcg_gen_andi_tl(temp3, cpu_gpr_d[r4], 0x1f);
4029         gen_insert(cpu_gpr_d[r3], cpu_gpr_d[r1], temp2, temp, temp3);
4030
4031         tcg_temp_free(temp3);
4032         break;
4033     }
4034     tcg_temp_free(temp);
4035     tcg_temp_free(temp2);
4036 }
4037
4038 /* RCR format */
4039
4040 static void decode_rcr_cond_select(CPUTriCoreState *env, DisasContext *ctx)
4041 {
4042     uint32_t op2;
4043     int r1, r3, r4;
4044     int32_t const9;
4045
4046     TCGv temp, temp2;
4047
4048     op2 = MASK_OP_RCR_OP2(ctx->opcode);
4049     r1 = MASK_OP_RCR_S1(ctx->opcode);
4050     const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
4051     r3 = MASK_OP_RCR_S3(ctx->opcode);
4052     r4 = MASK_OP_RCR_D(ctx->opcode);
4053
4054     switch (op2) {
4055     case OPC2_32_RCR_CADD:
4056         gen_condi_add(TCG_COND_NE, cpu_gpr_d[r1], const9, cpu_gpr_d[r3],
4057                       cpu_gpr_d[r4]);
4058         break;
4059     case OPC2_32_RCR_CADDN:
4060         gen_condi_add(TCG_COND_EQ, cpu_gpr_d[r1], const9, cpu_gpr_d[r3],
4061                       cpu_gpr_d[r4]);
4062         break;
4063     case OPC2_32_RCR_SEL:
4064         temp = tcg_const_i32(0);
4065         temp2 = tcg_const_i32(const9);
4066         tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
4067                            cpu_gpr_d[r1], temp2);
4068         tcg_temp_free(temp);
4069         tcg_temp_free(temp2);
4070         break;
4071     case OPC2_32_RCR_SELN:
4072         temp = tcg_const_i32(0);
4073         temp2 = tcg_const_i32(const9);
4074         tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
4075                            cpu_gpr_d[r1], temp2);
4076         tcg_temp_free(temp);
4077         tcg_temp_free(temp2);
4078         break;
4079     }
4080 }
4081
4082 static void decode_rcr_madd(CPUTriCoreState *env, DisasContext *ctx)
4083 {
4084     uint32_t op2;
4085     int r1, r3, r4;
4086     int32_t const9;
4087
4088
4089     op2 = MASK_OP_RCR_OP2(ctx->opcode);
4090     r1 = MASK_OP_RCR_S1(ctx->opcode);
4091     const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
4092     r3 = MASK_OP_RCR_S3(ctx->opcode);
4093     r4 = MASK_OP_RCR_D(ctx->opcode);
4094
4095     switch (op2) {
4096     case OPC2_32_RCR_MADD_32:
4097         gen_maddi32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4098         break;
4099     case OPC2_32_RCR_MADD_64:
4100         gen_maddi64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4101                       cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4102         break;
4103     case OPC2_32_RCR_MADDS_32:
4104         gen_maddsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4105         break;
4106     case OPC2_32_RCR_MADDS_64:
4107         gen_maddsi_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4108                       cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4109         break;
4110     case OPC2_32_RCR_MADD_U_64:
4111         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4112         gen_maddui64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4113                        cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4114         break;
4115     case OPC2_32_RCR_MADDS_U_32:
4116         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4117         gen_maddsui_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4118         break;
4119     case OPC2_32_RCR_MADDS_U_64:
4120         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4121         gen_maddsui_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4122                        cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4123         break;
4124     }
4125 }
4126
4127 static void decode_rcr_msub(CPUTriCoreState *env, DisasContext *ctx)
4128 {
4129     uint32_t op2;
4130     int r1, r3, r4;
4131     int32_t const9;
4132
4133
4134     op2 = MASK_OP_RCR_OP2(ctx->opcode);
4135     r1 = MASK_OP_RCR_S1(ctx->opcode);
4136     const9 = MASK_OP_RCR_CONST9_SEXT(ctx->opcode);
4137     r3 = MASK_OP_RCR_S3(ctx->opcode);
4138     r4 = MASK_OP_RCR_D(ctx->opcode);
4139
4140     switch (op2) {
4141     case OPC2_32_RCR_MSUB_32:
4142         gen_msubi32_d(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4143         break;
4144     case OPC2_32_RCR_MSUB_64:
4145         gen_msubi64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4146                       cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4147         break;
4148     case OPC2_32_RCR_MSUBS_32:
4149         gen_msubsi_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4150         break;
4151     case OPC2_32_RCR_MSUBS_64:
4152         gen_msubsi_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4153                       cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4154         break;
4155     case OPC2_32_RCR_MSUB_U_64:
4156         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4157         gen_msubui64_d(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4158                        cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4159         break;
4160     case OPC2_32_RCR_MSUBS_U_32:
4161         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4162         gen_msubsui_32(cpu_gpr_d[r4], cpu_gpr_d[r1], cpu_gpr_d[r3], const9);
4163         break;
4164     case OPC2_32_RCR_MSUBS_U_64:
4165         const9 = MASK_OP_RCR_CONST9(ctx->opcode);
4166         gen_msubsui_64(cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r1],
4167                        cpu_gpr_d[r3], cpu_gpr_d[r3+1], const9);
4168         break;
4169     }
4170 }
4171
4172 /* RLC format */
4173
4174 static void decode_rlc_opc(CPUTriCoreState *env, DisasContext *ctx,
4175                            uint32_t op1)
4176 {
4177     int32_t const16;
4178     int r1, r2;
4179
4180     const16 = MASK_OP_RLC_CONST16_SEXT(ctx->opcode);
4181     r1      = MASK_OP_RLC_S1(ctx->opcode);
4182     r2      = MASK_OP_RLC_D(ctx->opcode);
4183
4184     switch (op1) {
4185     case OPC1_32_RLC_ADDI:
4186         gen_addi_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const16);
4187         break;
4188     case OPC1_32_RLC_ADDIH:
4189         gen_addi_CC(cpu_gpr_d[r2], cpu_gpr_d[r1], const16 << 16);
4190         break;
4191     case OPC1_32_RLC_ADDIH_A:
4192         tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r1], const16 << 16);
4193         break;
4194     case OPC1_32_RLC_MFCR:
4195         const16 = MASK_OP_RLC_CONST16(ctx->opcode);
4196         gen_mfcr(env, cpu_gpr_d[r2], const16);
4197         break;
4198     case OPC1_32_RLC_MOV:
4199         tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
4200         break;
4201     case OPC1_32_RLC_MOV_64:
4202         if (tricore_feature(env, TRICORE_FEATURE_16)) {
4203             if ((r2 & 0x1) != 0) {
4204                 /* TODO: raise OPD trap */
4205             }
4206             tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
4207             tcg_gen_movi_tl(cpu_gpr_d[r2+1], const16 >> 15);
4208         } else {
4209             /* TODO: raise illegal opcode trap */
4210         }
4211         break;
4212     case OPC1_32_RLC_MOV_U:
4213         const16 = MASK_OP_RLC_CONST16(ctx->opcode);
4214         tcg_gen_movi_tl(cpu_gpr_d[r2], const16);
4215         break;
4216     case OPC1_32_RLC_MOV_H:
4217         tcg_gen_movi_tl(cpu_gpr_d[r2], const16 << 16);
4218         break;
4219     case OPC1_32_RLC_MOVH_A:
4220         tcg_gen_movi_tl(cpu_gpr_a[r2], const16 << 16);
4221         break;
4222     case OPC1_32_RLC_MTCR:
4223         const16 = MASK_OP_RLC_CONST16(ctx->opcode);
4224         gen_mtcr(env, ctx, cpu_gpr_d[r1], const16);
4225         break;
4226     }
4227 }
4228
4229 /* RR format */
4230 static void decode_rr_accumulator(CPUTriCoreState *env, DisasContext *ctx)
4231 {
4232     uint32_t op2;
4233     int r3, r2, r1;
4234
4235     r3 = MASK_OP_RR_D(ctx->opcode);
4236     r2 = MASK_OP_RR_S2(ctx->opcode);
4237     r1 = MASK_OP_RR_S1(ctx->opcode);
4238     op2 = MASK_OP_RR_OP2(ctx->opcode);
4239
4240     switch (op2) {
4241     case OPC2_32_RR_ABS:
4242         gen_abs(cpu_gpr_d[r3], cpu_gpr_d[r2]);
4243         break;
4244     case OPC2_32_RR_ABS_B:
4245         gen_helper_abs_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
4246         break;
4247     case OPC2_32_RR_ABS_H:
4248         gen_helper_abs_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
4249         break;
4250     case OPC2_32_RR_ABSDIF:
4251         gen_absdif(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4252         break;
4253     case OPC2_32_RR_ABSDIF_B:
4254         gen_helper_absdif_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4255                             cpu_gpr_d[r2]);
4256         break;
4257     case OPC2_32_RR_ABSDIF_H:
4258         gen_helper_absdif_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4259                             cpu_gpr_d[r2]);
4260         break;
4261     case OPC2_32_RR_ABSDIFS:
4262         gen_helper_absdif_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4263                                cpu_gpr_d[r2]);
4264         break;
4265     case OPC2_32_RR_ABSDIFS_H:
4266         gen_helper_absdif_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4267                                  cpu_gpr_d[r2]);
4268         break;
4269     case OPC2_32_RR_ABSS:
4270         gen_helper_abs_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
4271         break;
4272     case OPC2_32_RR_ABSS_H:
4273         gen_helper_abs_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r2]);
4274         break;
4275     case OPC2_32_RR_ADD:
4276         gen_add_d(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4277         break;
4278     case OPC2_32_RR_ADD_B:
4279         gen_helper_add_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
4280         break;
4281     case OPC2_32_RR_ADD_H:
4282         gen_helper_add_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
4283         break;
4284     case OPC2_32_RR_ADDC:
4285         gen_addc_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4286         break;
4287     case OPC2_32_RR_ADDS:
4288         gen_adds(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4289         break;
4290     case OPC2_32_RR_ADDS_H:
4291         gen_helper_add_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4292                               cpu_gpr_d[r2]);
4293         break;
4294     case OPC2_32_RR_ADDS_HU:
4295         gen_helper_add_h_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4296                               cpu_gpr_d[r2]);
4297         break;
4298     case OPC2_32_RR_ADDS_U:
4299         gen_helper_add_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4300                             cpu_gpr_d[r2]);
4301         break;
4302     case OPC2_32_RR_ADDX:
4303         gen_add_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4304         break;
4305     case OPC2_32_RR_AND_EQ:
4306         gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
4307                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4308         break;
4309     case OPC2_32_RR_AND_GE:
4310         gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4311                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4312         break;
4313     case OPC2_32_RR_AND_GE_U:
4314         gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4315                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4316         break;
4317     case OPC2_32_RR_AND_LT:
4318         gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4319                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4320         break;
4321     case OPC2_32_RR_AND_LT_U:
4322         gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4323                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4324         break;
4325     case OPC2_32_RR_AND_NE:
4326         gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4327                               cpu_gpr_d[r2], &tcg_gen_and_tl);
4328         break;
4329     case OPC2_32_RR_EQ:
4330         tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
4331                            cpu_gpr_d[r2]);
4332         break;
4333     case OPC2_32_RR_EQ_B:
4334         gen_helper_eq_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4335         break;
4336     case OPC2_32_RR_EQ_H:
4337         gen_helper_eq_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4338         break;
4339     case OPC2_32_RR_EQ_W:
4340         gen_cond_w(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4341         break;
4342     case OPC2_32_RR_EQANY_B:
4343         gen_helper_eqany_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4344         break;
4345     case OPC2_32_RR_EQANY_H:
4346         gen_helper_eqany_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4347         break;
4348     case OPC2_32_RR_GE:
4349         tcg_gen_setcond_tl(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4350                            cpu_gpr_d[r2]);
4351         break;
4352     case OPC2_32_RR_GE_U:
4353         tcg_gen_setcond_tl(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4354                            cpu_gpr_d[r2]);
4355         break;
4356     case OPC2_32_RR_LT:
4357         tcg_gen_setcond_tl(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4358                            cpu_gpr_d[r2]);
4359         break;
4360     case OPC2_32_RR_LT_U:
4361         tcg_gen_setcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4362                            cpu_gpr_d[r2]);
4363         break;
4364     case OPC2_32_RR_LT_B:
4365         gen_helper_lt_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4366         break;
4367     case OPC2_32_RR_LT_BU:
4368         gen_helper_lt_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4369         break;
4370     case OPC2_32_RR_LT_H:
4371         gen_helper_lt_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4372         break;
4373     case OPC2_32_RR_LT_HU:
4374         gen_helper_lt_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4375         break;
4376     case OPC2_32_RR_LT_W:
4377         gen_cond_w(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4378         break;
4379     case OPC2_32_RR_LT_WU:
4380         gen_cond_w(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4381         break;
4382     case OPC2_32_RR_MAX:
4383         tcg_gen_movcond_tl(TCG_COND_GT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4384                            cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4385         break;
4386     case OPC2_32_RR_MAX_U:
4387         tcg_gen_movcond_tl(TCG_COND_GTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4388                            cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4389         break;
4390     case OPC2_32_RR_MAX_B:
4391         gen_helper_max_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4392         break;
4393     case OPC2_32_RR_MAX_BU:
4394         gen_helper_max_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4395         break;
4396     case OPC2_32_RR_MAX_H:
4397         gen_helper_max_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4398         break;
4399     case OPC2_32_RR_MAX_HU:
4400         gen_helper_max_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4401         break;
4402     case OPC2_32_RR_MIN:
4403         tcg_gen_movcond_tl(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4404                            cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4405         break;
4406     case OPC2_32_RR_MIN_U:
4407         tcg_gen_movcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4408                            cpu_gpr_d[r2], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4409         break;
4410     case OPC2_32_RR_MIN_B:
4411         gen_helper_min_b(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4412         break;
4413     case OPC2_32_RR_MIN_BU:
4414         gen_helper_min_bu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4415         break;
4416     case OPC2_32_RR_MIN_H:
4417         gen_helper_min_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4418         break;
4419     case OPC2_32_RR_MIN_HU:
4420         gen_helper_min_hu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4421         break;
4422     case OPC2_32_RR_MOV:
4423         tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r2]);
4424         break;
4425     case OPC2_32_RR_NE:
4426         tcg_gen_setcond_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4427                            cpu_gpr_d[r2]);
4428         break;
4429     case OPC2_32_RR_OR_EQ:
4430         gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
4431                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4432         break;
4433     case OPC2_32_RR_OR_GE:
4434         gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4435                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4436         break;
4437     case OPC2_32_RR_OR_GE_U:
4438         gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4439                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4440         break;
4441     case OPC2_32_RR_OR_LT:
4442         gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4443                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4444         break;
4445     case OPC2_32_RR_OR_LT_U:
4446         gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4447                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4448         break;
4449     case OPC2_32_RR_OR_NE:
4450         gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4451                               cpu_gpr_d[r2], &tcg_gen_or_tl);
4452         break;
4453     case OPC2_32_RR_SAT_B:
4454         gen_saturate(cpu_gpr_d[r3], cpu_gpr_d[r1], 0x7f, -0x80);
4455         break;
4456     case OPC2_32_RR_SAT_BU:
4457         gen_saturate_u(cpu_gpr_d[r3], cpu_gpr_d[r1], 0xff);
4458         break;
4459     case OPC2_32_RR_SAT_H:
4460         gen_saturate(cpu_gpr_d[r3], cpu_gpr_d[r1], 0x7fff, -0x8000);
4461         break;
4462     case OPC2_32_RR_SAT_HU:
4463         gen_saturate_u(cpu_gpr_d[r3], cpu_gpr_d[r1], 0xffff);
4464         break;
4465     case OPC2_32_RR_SH_EQ:
4466         gen_sh_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
4467                     cpu_gpr_d[r2]);
4468         break;
4469     case OPC2_32_RR_SH_GE:
4470         gen_sh_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4471                     cpu_gpr_d[r2]);
4472         break;
4473     case OPC2_32_RR_SH_GE_U:
4474         gen_sh_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4475                     cpu_gpr_d[r2]);
4476         break;
4477     case OPC2_32_RR_SH_LT:
4478         gen_sh_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4479                     cpu_gpr_d[r2]);
4480         break;
4481     case OPC2_32_RR_SH_LT_U:
4482         gen_sh_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4483                     cpu_gpr_d[r2]);
4484         break;
4485     case OPC2_32_RR_SH_NE:
4486         gen_sh_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4487                     cpu_gpr_d[r2]);
4488         break;
4489     case OPC2_32_RR_SUB:
4490         gen_sub_d(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4491         break;
4492     case OPC2_32_RR_SUB_B:
4493         gen_helper_sub_b(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
4494         break;
4495     case OPC2_32_RR_SUB_H:
4496         gen_helper_sub_h(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
4497         break;
4498     case OPC2_32_RR_SUBC:
4499         gen_subc_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4500         break;
4501     case OPC2_32_RR_SUBS:
4502         gen_subs(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4503         break;
4504     case OPC2_32_RR_SUBS_U:
4505         gen_subsu(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4506         break;
4507     case OPC2_32_RR_SUBS_H:
4508         gen_helper_sub_h_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4509                               cpu_gpr_d[r2]);
4510         break;
4511     case OPC2_32_RR_SUBS_HU:
4512         gen_helper_sub_h_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
4513                               cpu_gpr_d[r2]);
4514         break;
4515     case OPC2_32_RR_SUBX:
4516         gen_sub_CC(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4517         break;
4518     case OPC2_32_RR_XOR_EQ:
4519         gen_accumulating_cond(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_d[r1],
4520                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4521         break;
4522     case OPC2_32_RR_XOR_GE:
4523         gen_accumulating_cond(TCG_COND_GE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4524                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4525         break;
4526     case OPC2_32_RR_XOR_GE_U:
4527         gen_accumulating_cond(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4528                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4529         break;
4530     case OPC2_32_RR_XOR_LT:
4531         gen_accumulating_cond(TCG_COND_LT, cpu_gpr_d[r3], cpu_gpr_d[r1],
4532                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4533         break;
4534     case OPC2_32_RR_XOR_LT_U:
4535         gen_accumulating_cond(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_d[r1],
4536                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4537         break;
4538     case OPC2_32_RR_XOR_NE:
4539         gen_accumulating_cond(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_d[r1],
4540                               cpu_gpr_d[r2], &tcg_gen_xor_tl);
4541         break;
4542     }
4543 }
4544
4545 static void decode_rr_logical_shift(CPUTriCoreState *env, DisasContext *ctx)
4546 {
4547     uint32_t op2;
4548     int r3, r2, r1;
4549     TCGv temp;
4550
4551     r3 = MASK_OP_RR_D(ctx->opcode);
4552     r2 = MASK_OP_RR_S2(ctx->opcode);
4553     r1 = MASK_OP_RR_S1(ctx->opcode);
4554
4555     temp = tcg_temp_new();
4556     op2 = MASK_OP_RR_OP2(ctx->opcode);
4557
4558     switch (op2) {
4559     case OPC2_32_RR_AND:
4560         tcg_gen_and_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4561         break;
4562     case OPC2_32_RR_ANDN:
4563         tcg_gen_andc_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4564         break;
4565     case OPC2_32_RR_CLO:
4566         gen_helper_clo(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4567         break;
4568     case OPC2_32_RR_CLO_H:
4569         gen_helper_clo_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4570         break;
4571     case OPC2_32_RR_CLS:
4572         gen_helper_cls(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4573         break;
4574     case OPC2_32_RR_CLS_H:
4575         gen_helper_cls_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4576         break;
4577     case OPC2_32_RR_CLZ:
4578         gen_helper_clz(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4579         break;
4580     case OPC2_32_RR_CLZ_H:
4581         gen_helper_clz_h(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4582         break;
4583     case OPC2_32_RR_NAND:
4584         tcg_gen_nand_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4585         break;
4586     case OPC2_32_RR_NOR:
4587         tcg_gen_nor_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4588         break;
4589     case OPC2_32_RR_OR:
4590         tcg_gen_or_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4591         break;
4592     case OPC2_32_RR_ORN:
4593         tcg_gen_orc_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4594         break;
4595     case OPC2_32_RR_SH:
4596         gen_helper_sh(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4597         break;
4598     case OPC2_32_RR_SH_H:
4599         gen_helper_sh_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4600         break;
4601     case OPC2_32_RR_SHA:
4602         gen_helper_sha(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1], cpu_gpr_d[r2]);
4603         break;
4604     case OPC2_32_RR_SHA_H:
4605         gen_helper_sha_h(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4606         break;
4607     case OPC2_32_RR_SHAS:
4608         gen_shas(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4609         break;
4610     case OPC2_32_RR_XNOR:
4611         tcg_gen_eqv_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4612         break;
4613     case OPC2_32_RR_XOR:
4614         tcg_gen_xor_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4615         break;
4616     }
4617     tcg_temp_free(temp);
4618 }
4619
4620 static void decode_rr_address(CPUTriCoreState *env, DisasContext *ctx)
4621 {
4622     uint32_t op2, n;
4623     int r1, r2, r3;
4624     TCGv temp;
4625
4626     op2 = MASK_OP_RR_OP2(ctx->opcode);
4627     r3 = MASK_OP_RR_D(ctx->opcode);
4628     r2 = MASK_OP_RR_S2(ctx->opcode);
4629     r1 = MASK_OP_RR_S1(ctx->opcode);
4630     n = MASK_OP_RR_N(ctx->opcode);
4631
4632     switch (op2) {
4633     case OPC2_32_RR_ADD_A:
4634         tcg_gen_add_tl(cpu_gpr_a[r3], cpu_gpr_a[r1], cpu_gpr_a[r2]);
4635         break;
4636     case OPC2_32_RR_ADDSC_A:
4637         temp = tcg_temp_new();
4638         tcg_gen_shli_tl(temp, cpu_gpr_d[r1], n);
4639         tcg_gen_add_tl(cpu_gpr_a[r3], cpu_gpr_a[r2], temp);
4640         tcg_temp_free(temp);
4641         break;
4642     case OPC2_32_RR_ADDSC_AT:
4643         temp = tcg_temp_new();
4644         tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 3);
4645         tcg_gen_add_tl(temp, cpu_gpr_a[r2], temp);
4646         tcg_gen_andi_tl(cpu_gpr_a[r3], temp, 0xFFFFFFFC);
4647         tcg_temp_free(temp);
4648         break;
4649     case OPC2_32_RR_EQ_A:
4650         tcg_gen_setcond_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_a[r1],
4651                            cpu_gpr_a[r2]);
4652         break;
4653     case OPC2_32_RR_EQZ:
4654         tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_gpr_d[r3], cpu_gpr_a[r1], 0);
4655         break;
4656     case OPC2_32_RR_GE_A:
4657         tcg_gen_setcond_tl(TCG_COND_GEU, cpu_gpr_d[r3], cpu_gpr_a[r1],
4658                            cpu_gpr_a[r2]);
4659         break;
4660     case OPC2_32_RR_LT_A:
4661         tcg_gen_setcond_tl(TCG_COND_LTU, cpu_gpr_d[r3], cpu_gpr_a[r1],
4662                            cpu_gpr_a[r2]);
4663         break;
4664     case OPC2_32_RR_MOV_A:
4665         tcg_gen_mov_tl(cpu_gpr_a[r3], cpu_gpr_d[r2]);
4666         break;
4667     case OPC2_32_RR_MOV_AA:
4668         tcg_gen_mov_tl(cpu_gpr_a[r3], cpu_gpr_a[r2]);
4669         break;
4670     case OPC2_32_RR_MOV_D:
4671         tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_a[r2]);
4672         break;
4673     case OPC2_32_RR_NE_A:
4674         tcg_gen_setcond_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_a[r1],
4675                            cpu_gpr_a[r2]);
4676         break;
4677     case OPC2_32_RR_NEZ_A:
4678         tcg_gen_setcondi_tl(TCG_COND_NE, cpu_gpr_d[r3], cpu_gpr_a[r1], 0);
4679         break;
4680     case OPC2_32_RR_SUB_A:
4681         tcg_gen_sub_tl(cpu_gpr_a[r3], cpu_gpr_a[r1], cpu_gpr_a[r2]);
4682         break;
4683     }
4684 }
4685
4686 static void decode_rr_idirect(CPUTriCoreState *env, DisasContext *ctx)
4687 {
4688     uint32_t op2;
4689     int r1;
4690
4691     op2 = MASK_OP_RR_OP2(ctx->opcode);
4692     r1 = MASK_OP_RR_S1(ctx->opcode);
4693
4694     switch (op2) {
4695     case OPC2_32_RR_JI:
4696         tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
4697         break;
4698     case OPC2_32_RR_JLI:
4699         tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
4700         tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
4701         break;
4702     case OPC2_32_RR_CALLI:
4703         gen_helper_1arg(call, ctx->next_pc);
4704         tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], ~0x1);
4705         break;
4706     }
4707     tcg_gen_exit_tb(0);
4708     ctx->bstate = BS_BRANCH;
4709 }
4710
4711 static void decode_rr_divide(CPUTriCoreState *env, DisasContext *ctx)
4712 {
4713     uint32_t op2;
4714     int r1, r2, r3;
4715
4716     TCGv temp, temp2;
4717
4718     op2 = MASK_OP_RR_OP2(ctx->opcode);
4719     r3 = MASK_OP_RR_D(ctx->opcode);
4720     r2 = MASK_OP_RR_S2(ctx->opcode);
4721     r1 = MASK_OP_RR_S1(ctx->opcode);
4722
4723     switch (op2) {
4724     case OPC2_32_RR_BMERGE:
4725         gen_helper_bmerge(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
4726         break;
4727     case OPC2_32_RR_BSPLIT:
4728         gen_bsplit(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
4729         break;
4730     case OPC2_32_RR_DVINIT_B:
4731         gen_dvinit_b(env, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
4732                      cpu_gpr_d[r2]);
4733         break;
4734     case OPC2_32_RR_DVINIT_BU:
4735         temp = tcg_temp_new();
4736         temp2 = tcg_temp_new();
4737         /* reset av */
4738         tcg_gen_movi_tl(cpu_PSW_AV, 0);
4739         if (!tricore_feature(env, TRICORE_FEATURE_131)) {
4740             /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */
4741             tcg_gen_neg_tl(temp, cpu_gpr_d[r3+1]);
4742             /* use cpu_PSW_AV to compare against 0 */
4743             tcg_gen_movcond_tl(TCG_COND_LT, temp, cpu_gpr_d[r3+1], cpu_PSW_AV,
4744                                temp, cpu_gpr_d[r3+1]);
4745             tcg_gen_neg_tl(temp2, cpu_gpr_d[r2]);
4746             tcg_gen_movcond_tl(TCG_COND_LT, temp2, cpu_gpr_d[r2], cpu_PSW_AV,
4747                                temp2, cpu_gpr_d[r2]);
4748             tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);
4749         } else {
4750             /* overflow = (D[b] == 0) */
4751             tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
4752         }
4753         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
4754         /* sv */
4755         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
4756         /* write result */
4757         tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 8);
4758         tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 24);
4759         tcg_gen_mov_tl(cpu_gpr_d[r3+1], temp);
4760
4761         tcg_temp_free(temp);
4762         tcg_temp_free(temp2);
4763         break;
4764     case OPC2_32_RR_DVINIT_H:
4765         gen_dvinit_h(env, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
4766                      cpu_gpr_d[r2]);
4767         break;
4768     case OPC2_32_RR_DVINIT_HU:
4769         temp = tcg_temp_new();
4770         temp2 = tcg_temp_new();
4771         /* reset av */
4772         tcg_gen_movi_tl(cpu_PSW_AV, 0);
4773         if (!tricore_feature(env, TRICORE_FEATURE_131)) {
4774             /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */
4775             tcg_gen_neg_tl(temp, cpu_gpr_d[r3+1]);
4776             /* use cpu_PSW_AV to compare against 0 */
4777             tcg_gen_movcond_tl(TCG_COND_LT, temp, cpu_gpr_d[r3+1], cpu_PSW_AV,
4778                                temp, cpu_gpr_d[r3+1]);
4779             tcg_gen_neg_tl(temp2, cpu_gpr_d[r2]);
4780             tcg_gen_movcond_tl(TCG_COND_LT, temp2, cpu_gpr_d[r2], cpu_PSW_AV,
4781                                temp2, cpu_gpr_d[r2]);
4782             tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);
4783         } else {
4784             /* overflow = (D[b] == 0) */
4785             tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
4786         }
4787         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
4788         /* sv */
4789         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
4790         /* write result */
4791         tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
4792         tcg_gen_shri_tl(cpu_gpr_d[r3+1], temp, 16);
4793         tcg_gen_shli_tl(cpu_gpr_d[r3], temp, 16);
4794         tcg_temp_free(temp);
4795         tcg_temp_free(temp2);
4796         break;
4797     case OPC2_32_RR_DVINIT:
4798         temp = tcg_temp_new();
4799         temp2 = tcg_temp_new();
4800         /* overflow = ((D[b] == 0) ||
4801                       ((D[b] == 0xFFFFFFFF) && (D[a] == 0x80000000))) */
4802         tcg_gen_setcondi_tl(TCG_COND_EQ, temp, cpu_gpr_d[r2], 0xffffffff);
4803         tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r1], 0x80000000);
4804         tcg_gen_and_tl(temp, temp, temp2);
4805         tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r2], 0);
4806         tcg_gen_or_tl(cpu_PSW_V, temp, temp2);
4807         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
4808         /* sv */
4809         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
4810         /* reset av */
4811        tcg_gen_movi_tl(cpu_PSW_AV, 0);
4812         /* write result */
4813         tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4814         /* sign extend to high reg */
4815         tcg_gen_sari_tl(cpu_gpr_d[r3+1], cpu_gpr_d[r1], 31);
4816         tcg_temp_free(temp);
4817         tcg_temp_free(temp2);
4818         break;
4819     case OPC2_32_RR_DVINIT_U:
4820         /* overflow = (D[b] == 0) */
4821         tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);
4822         tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);
4823         /* sv */
4824         tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);
4825         /* reset av */
4826         tcg_gen_movi_tl(cpu_PSW_AV, 0);
4827         /* write result */
4828         tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4829         /* zero extend to high reg*/
4830         tcg_gen_movi_tl(cpu_gpr_d[r3+1], 0);
4831         break;
4832     case OPC2_32_RR_PARITY:
4833         gen_helper_parity(cpu_gpr_d[r3], cpu_gpr_d[r1]);
4834         break;
4835     case OPC2_32_RR_UNPACK:
4836         gen_unpack(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
4837         break;
4838     }
4839 }
4840
4841 /* RR1 Format */
4842 static void decode_rr1_mul(CPUTriCoreState *env, DisasContext *ctx)
4843 {
4844     uint32_t op2;
4845
4846     int r1, r2, r3;
4847     TCGv n;
4848     TCGv_i64 temp64;
4849
4850     r1 = MASK_OP_RR1_S1(ctx->opcode);
4851     r2 = MASK_OP_RR1_S2(ctx->opcode);
4852     r3 = MASK_OP_RR1_D(ctx->opcode);
4853     n  = tcg_const_i32(MASK_OP_RR1_N(ctx->opcode));
4854     op2 = MASK_OP_RR1_OP2(ctx->opcode);
4855
4856     switch (op2) {
4857     case OPC2_32_RR1_MUL_H_32_LL:
4858         temp64 = tcg_temp_new_i64();
4859         GEN_HELPER_LL(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4860         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4861         gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
4862         tcg_temp_free_i64(temp64);
4863         break;
4864     case OPC2_32_RR1_MUL_H_32_LU:
4865         temp64 = tcg_temp_new_i64();
4866         GEN_HELPER_LU(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4867         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4868         gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
4869         tcg_temp_free_i64(temp64);
4870         break;
4871     case OPC2_32_RR1_MUL_H_32_UL:
4872         temp64 = tcg_temp_new_i64();
4873         GEN_HELPER_UL(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4874         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4875         gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
4876         tcg_temp_free_i64(temp64);
4877         break;
4878     case OPC2_32_RR1_MUL_H_32_UU:
4879         temp64 = tcg_temp_new_i64();
4880         GEN_HELPER_UU(mul_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4881         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4882         gen_calc_usb_mul_h(cpu_gpr_d[r3], cpu_gpr_d[r3+1]);
4883         tcg_temp_free_i64(temp64);
4884         break;
4885     case OPC2_32_RR1_MULM_H_64_LL:
4886         temp64 = tcg_temp_new_i64();
4887         GEN_HELPER_LL(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4888         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4889         /* reset V bit */
4890         tcg_gen_movi_tl(cpu_PSW_V, 0);
4891         /* reset AV bit */
4892         tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
4893         tcg_temp_free_i64(temp64);
4894         break;
4895     case OPC2_32_RR1_MULM_H_64_LU:
4896         temp64 = tcg_temp_new_i64();
4897         GEN_HELPER_LU(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4898         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4899         /* reset V bit */
4900         tcg_gen_movi_tl(cpu_PSW_V, 0);
4901         /* reset AV bit */
4902         tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
4903         tcg_temp_free_i64(temp64);
4904         break;
4905     case OPC2_32_RR1_MULM_H_64_UL:
4906         temp64 = tcg_temp_new_i64();
4907         GEN_HELPER_UL(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4908         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4909         /* reset V bit */
4910         tcg_gen_movi_tl(cpu_PSW_V, 0);
4911         /* reset AV bit */
4912         tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
4913         tcg_temp_free_i64(temp64);
4914         break;
4915     case OPC2_32_RR1_MULM_H_64_UU:
4916         temp64 = tcg_temp_new_i64();
4917         GEN_HELPER_UU(mulm_h, temp64, cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4918         tcg_gen_extr_i64_i32(cpu_gpr_d[r3], cpu_gpr_d[r3+1], temp64);
4919         /* reset V bit */
4920         tcg_gen_movi_tl(cpu_PSW_V, 0);
4921         /* reset AV bit */
4922         tcg_gen_mov_tl(cpu_PSW_AV, cpu_PSW_V);
4923         tcg_temp_free_i64(temp64);
4924
4925         break;
4926     case OPC2_32_RR1_MULR_H_16_LL:
4927         GEN_HELPER_LL(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4928         gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
4929         break;
4930     case OPC2_32_RR1_MULR_H_16_LU:
4931         GEN_HELPER_LU(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4932         gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
4933         break;
4934     case OPC2_32_RR1_MULR_H_16_UL:
4935         GEN_HELPER_UL(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4936         gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
4937         break;
4938     case OPC2_32_RR1_MULR_H_16_UU:
4939         GEN_HELPER_UU(mulr_h, cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2], n);
4940         gen_calc_usb_mulr_h(cpu_gpr_d[r3]);
4941         break;
4942     }
4943     tcg_temp_free(n);
4944 }
4945
4946 static void decode_rr1_mulq(CPUTriCoreState *env, DisasContext *ctx)
4947 {
4948     uint32_t op2;
4949     int r1, r2, r3;
4950     uint32_t n;
4951
4952     TCGv temp, temp2;
4953
4954     r1 = MASK_OP_RR1_S1(ctx->opcode);
4955     r2 = MASK_OP_RR1_S2(ctx->opcode);
4956     r3 = MASK_OP_RR1_D(ctx->opcode);
4957     n  = MASK_OP_RR1_N(ctx->opcode);
4958     op2 = MASK_OP_RR1_OP2(ctx->opcode);
4959
4960     temp = tcg_temp_new();
4961     temp2 = tcg_temp_new();
4962
4963     switch (op2) {
4964     case OPC2_32_RR1_MUL_Q_32:
4965         gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], cpu_gpr_d[r2], n, 32);
4966         break;
4967     case OPC2_32_RR1_MUL_Q_64:
4968         gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], cpu_gpr_d[r2],
4969                   n, 0);
4970         break;
4971     case OPC2_32_RR1_MUL_Q_32_L:
4972         tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
4973         gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], temp, n, 16);
4974         break;
4975     case OPC2_32_RR1_MUL_Q_64_L:
4976         tcg_gen_ext16s_tl(temp, cpu_gpr_d[r2]);
4977         gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp, n, 0);
4978         break;
4979     case OPC2_32_RR1_MUL_Q_32_U:
4980         tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
4981         gen_mul_q(cpu_gpr_d[r3], temp, cpu_gpr_d[r1], temp, n, 16);
4982         break;
4983     case OPC2_32_RR1_MUL_Q_64_U:
4984         tcg_gen_sari_tl(temp, cpu_gpr_d[r2], 16);
4985         gen_mul_q(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1], temp, n, 0);
4986         break;
4987     case OPC2_32_RR1_MUL_Q_32_LL:
4988         tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
4989         tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
4990         gen_mul_q_16(cpu_gpr_d[r3], temp, temp2, n);
4991         break;
4992     case OPC2_32_RR1_MUL_Q_32_UU:
4993         tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
4994         tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
4995         gen_mul_q_16(cpu_gpr_d[r3], temp, temp2, n);
4996         break;
4997     case OPC2_32_RR1_MULR_Q_32_L:
4998         tcg_gen_ext16s_tl(temp, cpu_gpr_d[r1]);
4999         tcg_gen_ext16s_tl(temp2, cpu_gpr_d[r2]);
5000         gen_mulr_q(cpu_gpr_d[r3], temp, temp2, n);
5001         break;
5002     case OPC2_32_RR1_MULR_Q_32_U:
5003         tcg_gen_sari_tl(temp, cpu_gpr_d[r1], 16);
5004         tcg_gen_sari_tl(temp2, cpu_gpr_d[r2], 16);
5005         gen_mulr_q(cpu_gpr_d[r3], temp, temp2, n);
5006         break;
5007     }
5008     tcg_temp_free(temp);
5009     tcg_temp_free(temp2);
5010 }
5011
5012 /* RR2 format */
5013 static void decode_rr2_mul(CPUTriCoreState *env, DisasContext *ctx)
5014 {
5015     uint32_t op2;
5016     int r1, r2, r3;
5017
5018     op2 = MASK_OP_RR2_OP2(ctx->opcode);
5019     r1  = MASK_OP_RR2_S1(ctx->opcode);
5020     r2  = MASK_OP_RR2_S2(ctx->opcode);
5021     r3  = MASK_OP_RR2_D(ctx->opcode);
5022     switch (op2) {
5023     case OPC2_32_RR2_MUL_32:
5024         gen_mul_i32s(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);
5025         break;
5026     case OPC2_32_RR2_MUL_64:
5027         gen_mul_i64s(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
5028                      cpu_gpr_d[r2]);
5029         break;
5030     case OPC2_32_RR2_MULS_32:
5031         gen_helper_mul_ssov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
5032                             cpu_gpr_d[r2]);
5033         break;
5034     case OPC2_32_RR2_MUL_U_64:
5035         gen_mul_i64u(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],
5036                      cpu_gpr_d[r2]);
5037         break;
5038     case OPC2_32_RR2_MULS_U_32:
5039         gen_helper_mul_suov(cpu_gpr_d[r3], cpu_env, cpu_gpr_d[r1],
5040                             cpu_gpr_d[r2]);
5041         break;
5042     }
5043 }
5044
5045 /* RRPW format */
5046 static void decode_rrpw_extract_insert(CPUTriCoreState *env, DisasContext *ctx)
5047 {
5048     uint32_t op2;
5049     int r1, r2, r3;
5050     int32_t pos, width;
5051
5052     op2 = MASK_OP_RRPW_OP2(ctx->opcode);
5053     r1 = MASK_OP_RRPW_S1(ctx->opcode);
5054     r2 = MASK_OP_RRPW_S2(ctx->opcode);
5055     r3 = MASK_OP_RRPW_D(ctx->opcode);
5056     pos = MASK_OP_RRPW_POS(ctx->opcode);
5057     width = MASK_OP_RRPW_WIDTH(ctx->opcode);
5058
5059     switch (op2) {
5060     case OPC2_32_RRPW_EXTR:
5061         if (pos + width <= 31) {
5062             /* optimize special cases */
5063             if ((pos == 0) && (width == 8)) {
5064                 tcg_gen_ext8s_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
5065             } else if ((pos == 0) && (width == 16)) {
5066                 tcg_gen_ext16s_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);
5067             } else {
5068                 tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 32 - pos - width);
5069                 tcg_gen_sari_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], 32 - width);
5070             }
5071         }
5072         break;
5073     case OPC2_32_RRPW_EXTR_U:
5074         if (width == 0) {
5075             tcg_gen_movi_tl(cpu_gpr_d[r3], 0);
5076         } else {
5077             tcg_gen_shri_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], pos);
5078             tcg_gen_andi_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], ~0u >> (32-width));
5079         }
5080         break;
5081     case OPC2_32_RRPW_IMASK:
5082         if (pos + width <= 31) {
5083             tcg_gen_movi_tl(cpu_gpr_d[r3+1], ((1u << width) - 1) << pos);
5084             tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r2], pos);
5085         }
5086         break;
5087     case OPC2_32_RRPW_INSERT:
5088         if (pos + width <= 31) {
5089             tcg_gen_deposit_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2],
5090                                width, pos);
5091         }
5092         break;
5093     }
5094 }
5095
5096 /* RRR format */
5097 static void decode_rrr_cond_select(CPUTriCoreState *env, DisasContext *ctx)
5098 {
5099     uint32_t op2;
5100     int r1, r2, r3, r4;
5101     TCGv temp;
5102
5103     op2 = MASK_OP_RRR_OP2(ctx->opcode);
5104     r1  = MASK_OP_RRR_S1(ctx->opcode);
5105     r2  = MASK_OP_RRR_S2(ctx->opcode);
5106     r3  = MASK_OP_RRR_S3(ctx->opcode);
5107     r4  = MASK_OP_RRR_D(ctx->opcode);
5108
5109     switch (op2) {
5110     case OPC2_32_RRR_CADD:
5111         gen_cond_add(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
5112                      cpu_gpr_d[r4], cpu_gpr_d[r3]);
5113         break;
5114     case OPC2_32_RRR_CADDN:
5115         gen_cond_add(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
5116                      cpu_gpr_d[r3]);
5117         break;
5118     case OPC2_32_RRR_CSUB:
5119         gen_cond_sub(TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
5120                      cpu_gpr_d[r3]);
5121         break;
5122     case OPC2_32_RRR_CSUBN:
5123         gen_cond_sub(TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2], cpu_gpr_d[r4],
5124                      cpu_gpr_d[r3]);
5125         break;
5126     case OPC2_32_RRR_SEL:
5127         temp = tcg_const_i32(0);
5128         tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
5129                            cpu_gpr_d[r1], cpu_gpr_d[r2]);
5130         tcg_temp_free(temp);
5131         break;
5132     case OPC2_32_RRR_SELN:
5133         temp = tcg_const_i32(0);
5134         tcg_gen_movcond_tl(TCG_COND_EQ, cpu_gpr_d[r4], cpu_gpr_d[r3], temp,
5135                            cpu_gpr_d[r1], cpu_gpr_d[r2]);
5136         tcg_temp_free(temp);
5137         break;
5138     }
5139 }
5140
5141 static void decode_rrr_divide(CPUTriCoreState *env, DisasContext *ctx)
5142 {
5143     uint32_t op2;
5144
5145     int r1, r2, r3, r4;
5146
5147     op2 = MASK_OP_RRR_OP2(ctx->opcode);
5148     r1 = MASK_OP_RRR_S1(ctx->opcode);
5149     r2 = MASK_OP_RRR_S2(ctx->opcode);
5150     r3 = MASK_OP_RRR_S3(ctx->opcode);
5151     r4 = MASK_OP_RRR_D(ctx->opcode);
5152
5153     switch (op2) {
5154     case OPC2_32_RRR_DVADJ:
5155         GEN_HELPER_RRR(dvadj, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5156                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5157         break;
5158     case OPC2_32_RRR_DVSTEP:
5159         GEN_HELPER_RRR(dvstep, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5160                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5161         break;
5162     case OPC2_32_RRR_DVSTEP_U:
5163         GEN_HELPER_RRR(dvstep_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5164                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5165         break;
5166     case OPC2_32_RRR_IXMAX:
5167         GEN_HELPER_RRR(ixmax, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5168                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5169         break;
5170     case OPC2_32_RRR_IXMAX_U:
5171         GEN_HELPER_RRR(ixmax_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5172                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5173         break;
5174     case OPC2_32_RRR_IXMIN:
5175         GEN_HELPER_RRR(ixmin, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5176                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5177         break;
5178     case OPC2_32_RRR_IXMIN_U:
5179         GEN_HELPER_RRR(ixmin_u, cpu_gpr_d[r4], cpu_gpr_d[r4+1], cpu_gpr_d[r3],
5180                        cpu_gpr_d[r3+1], cpu_gpr_d[r2]);
5181         break;
5182     case OPC2_32_RRR_PACK:
5183         gen_helper_pack(cpu_gpr_d[r4], cpu_PSW_C, cpu_gpr_d[r3],
5184                         cpu_gpr_d[r3+1], cpu_gpr_d[r1]);
5185         break;
5186     }
5187 }
5188
5189 static void decode_32Bit_opc(CPUTriCoreState *env, DisasContext *ctx)
5190 {
5191     int op1;
5192     int32_t r1, r2, r3;
5193     int32_t address, const16;
5194     int8_t b, const4;
5195     int32_t bpos;
5196     TCGv temp, temp2, temp3;
5197
5198     op1 = MASK_OP_MAJOR(ctx->opcode);
5199
5200     /* handle JNZ.T opcode only being 7 bit long */
5201     if (unlikely((op1 & 0x7f) == OPCM_32_BRN_JTT)) {
5202         op1 = OPCM_32_BRN_JTT;
5203     }
5204
5205     switch (op1) {
5206 /* ABS-format */
5207     case OPCM_32_ABS_LDW:
5208         decode_abs_ldw(env, ctx);
5209         break;
5210     case OPCM_32_ABS_LDB:
5211         decode_abs_ldb(env, ctx);
5212         break;
5213     case OPCM_32_ABS_LDMST_SWAP:
5214         decode_abs_ldst_swap(env, ctx);
5215         break;
5216     case OPCM_32_ABS_LDST_CONTEXT:
5217         decode_abs_ldst_context(env, ctx);
5218         break;
5219     case OPCM_32_ABS_STORE:
5220         decode_abs_store(env, ctx);
5221         break;
5222     case OPCM_32_ABS_STOREB_H:
5223         decode_abs_storeb_h(env, ctx);
5224         break;
5225     case OPC1_32_ABS_STOREQ:
5226         address = MASK_OP_ABS_OFF18(ctx->opcode);
5227         r1 = MASK_OP_ABS_S1D(ctx->opcode);
5228         temp = tcg_const_i32(EA_ABS_FORMAT(address));
5229         temp2 = tcg_temp_new();
5230
5231         tcg_gen_shri_tl(temp2, cpu_gpr_d[r1], 16);
5232         tcg_gen_qemu_st_tl(temp2, temp, ctx->mem_idx, MO_LEUW);
5233
5234         tcg_temp_free(temp2);
5235         tcg_temp_free(temp);
5236         break;
5237     case OPC1_32_ABS_LD_Q:
5238         address = MASK_OP_ABS_OFF18(ctx->opcode);
5239         r1 = MASK_OP_ABS_S1D(ctx->opcode);
5240         temp = tcg_const_i32(EA_ABS_FORMAT(address));
5241
5242         tcg_gen_qemu_ld_tl(cpu_gpr_d[r1], temp, ctx->mem_idx, MO_LEUW);
5243         tcg_gen_shli_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 16);
5244
5245         tcg_temp_free(temp);
5246         break;
5247     case OPC1_32_ABS_LEA:
5248         address = MASK_OP_ABS_OFF18(ctx->opcode);
5249         r1 = MASK_OP_ABS_S1D(ctx->opcode);
5250         tcg_gen_movi_tl(cpu_gpr_a[r1], EA_ABS_FORMAT(address));
5251         break;
5252 /* ABSB-format */
5253     case OPC1_32_ABSB_ST_T:
5254         address = MASK_OP_ABS_OFF18(ctx->opcode);
5255         b = MASK_OP_ABSB_B(ctx->opcode);
5256         bpos = MASK_OP_ABSB_BPOS(ctx->opcode);
5257
5258         temp = tcg_const_i32(EA_ABS_FORMAT(address));
5259         temp2 = tcg_temp_new();
5260
5261         tcg_gen_qemu_ld_tl(temp2, temp, ctx->mem_idx, MO_UB);
5262         tcg_gen_andi_tl(temp2, temp2, ~(0x1u << bpos));
5263         tcg_gen_ori_tl(temp2, temp2, (b << bpos));
5264         tcg_gen_qemu_st_tl(temp2, temp, ctx->mem_idx, MO_UB);
5265
5266         tcg_temp_free(temp);
5267         tcg_temp_free(temp2);
5268         break;
5269 /* B-format */
5270     case OPC1_32_B_CALL:
5271     case OPC1_32_B_CALLA:
5272     case OPC1_32_B_J:
5273     case OPC1_32_B_JA:
5274     case OPC1_32_B_JL:
5275     case OPC1_32_B_JLA:
5276         address = MASK_OP_B_DISP24_SEXT(ctx->opcode);
5277         gen_compute_branch(ctx, op1, 0, 0, 0, address);
5278         break;
5279 /* Bit-format */
5280     case OPCM_32_BIT_ANDACC:
5281         decode_bit_andacc(env, ctx);
5282         break;
5283     case OPCM_32_BIT_LOGICAL_T1:
5284         decode_bit_logical_t(env, ctx);
5285         break;
5286     case OPCM_32_BIT_INSERT:
5287         decode_bit_insert(env, ctx);
5288         break;
5289     case OPCM_32_BIT_LOGICAL_T2:
5290         decode_bit_logical_t2(env, ctx);
5291         break;
5292     case OPCM_32_BIT_ORAND:
5293         decode_bit_orand(env, ctx);
5294         break;
5295     case OPCM_32_BIT_SH_LOGIC1:
5296         decode_bit_sh_logic1(env, ctx);
5297         break;
5298     case OPCM_32_BIT_SH_LOGIC2:
5299         decode_bit_sh_logic2(env, ctx);
5300         break;
5301     /* BO Format */
5302     case OPCM_32_BO_ADDRMODE_POST_PRE_BASE:
5303         decode_bo_addrmode_post_pre_base(env, ctx);
5304         break;
5305     case OPCM_32_BO_ADDRMODE_BITREVERSE_CIRCULAR:
5306         decode_bo_addrmode_bitreverse_circular(env, ctx);
5307         break;
5308     case OPCM_32_BO_ADDRMODE_LD_POST_PRE_BASE:
5309         decode_bo_addrmode_ld_post_pre_base(env, ctx);
5310         break;
5311     case OPCM_32_BO_ADDRMODE_LD_BITREVERSE_CIRCULAR:
5312         decode_bo_addrmode_ld_bitreverse_circular(env, ctx);
5313         break;
5314     case OPCM_32_BO_ADDRMODE_STCTX_POST_PRE_BASE:
5315         decode_bo_addrmode_stctx_post_pre_base(env, ctx);
5316         break;
5317     case OPCM_32_BO_ADDRMODE_LDMST_BITREVERSE_CIRCULAR:
5318         decode_bo_addrmode_ldmst_bitreverse_circular(env, ctx);
5319         break;
5320 /* BOL-format */
5321     case OPC1_32_BOL_LD_A_LONGOFF:
5322     case OPC1_32_BOL_LD_W_LONGOFF:
5323     case OPC1_32_BOL_LEA_LONGOFF:
5324     case OPC1_32_BOL_ST_W_LONGOFF:
5325     case OPC1_32_BOL_ST_A_LONGOFF:
5326     case OPC1_32_BOL_LD_B_LONGOFF:
5327     case OPC1_32_BOL_LD_BU_LONGOFF:
5328     case OPC1_32_BOL_LD_H_LONGOFF:
5329     case OPC1_32_BOL_LD_HU_LONGOFF:
5330     case OPC1_32_BOL_ST_B_LONGOFF:
5331     case OPC1_32_BOL_ST_H_LONGOFF:
5332         decode_bol_opc(env, ctx, op1);
5333         break;
5334 /* BRC Format */
5335     case OPCM_32_BRC_EQ_NEQ:
5336     case OPCM_32_BRC_GE:
5337     case OPCM_32_BRC_JLT:
5338     case OPCM_32_BRC_JNE:
5339         const4 = MASK_OP_BRC_CONST4_SEXT(ctx->opcode);
5340         address = MASK_OP_BRC_DISP15_SEXT(ctx->opcode);
5341         r1 = MASK_OP_BRC_S1(ctx->opcode);
5342         gen_compute_branch(ctx, op1, r1, 0, const4, address);
5343         break;
5344 /* BRN Format */
5345     case OPCM_32_BRN_JTT:
5346         address = MASK_OP_BRN_DISP15_SEXT(ctx->opcode);
5347         r1 = MASK_OP_BRN_S1(ctx->opcode);
5348         gen_compute_branch(ctx, op1, r1, 0, 0, address);
5349         break;
5350 /* BRR Format */
5351     case OPCM_32_BRR_EQ_NEQ:
5352     case OPCM_32_BRR_ADDR_EQ_NEQ:
5353     case OPCM_32_BRR_GE:
5354     case OPCM_32_BRR_JLT:
5355     case OPCM_32_BRR_JNE:
5356     case OPCM_32_BRR_JNZ:
5357     case OPCM_32_BRR_LOOP:
5358         address = MASK_OP_BRR_DISP15_SEXT(ctx->opcode);
5359         r2 = MASK_OP_BRR_S2(ctx->opcode);
5360         r1 = MASK_OP_BRR_S1(ctx->opcode);
5361         gen_compute_branch(ctx, op1, r1, r2, 0, address);
5362         break;
5363 /* RC Format */
5364     case OPCM_32_RC_LOGICAL_SHIFT:
5365         decode_rc_logical_shift(env, ctx);
5366         break;
5367     case OPCM_32_RC_ACCUMULATOR:
5368         decode_rc_accumulator(env, ctx);
5369         break;
5370     case OPCM_32_RC_SERVICEROUTINE:
5371         decode_rc_serviceroutine(env, ctx);
5372         break;
5373     case OPCM_32_RC_MUL:
5374         decode_rc_mul(env, ctx);
5375         break;
5376 /* RCPW Format */
5377     case OPCM_32_RCPW_MASK_INSERT:
5378         decode_rcpw_insert(env, ctx);
5379         break;
5380 /* RCRR Format */
5381     case OPC1_32_RCRR_INSERT:
5382         r1 = MASK_OP_RCRR_S1(ctx->opcode);
5383         r2 = MASK_OP_RCRR_S3(ctx->opcode);
5384         r3 = MASK_OP_RCRR_D(ctx->opcode);
5385         const16 = MASK_OP_RCRR_CONST4(ctx->opcode);
5386         temp = tcg_const_i32(const16);
5387         temp2 = tcg_temp_new(); /* width*/
5388         temp3 = tcg_temp_new(); /* pos */
5389
5390         tcg_gen_andi_tl(temp2, cpu_gpr_d[r3+1], 0x1f);
5391         tcg_gen_andi_tl(temp3, cpu_gpr_d[r3], 0x1f);
5392
5393         gen_insert(cpu_gpr_d[r2], cpu_gpr_d[r1], temp, temp2, temp3);
5394
5395         tcg_temp_free(temp);
5396         tcg_temp_free(temp2);
5397         tcg_temp_free(temp3);
5398         break;
5399 /* RCRW Format */
5400     case OPCM_32_RCRW_MASK_INSERT:
5401         decode_rcrw_insert(env, ctx);
5402         break;
5403 /* RCR Format */
5404     case OPCM_32_RCR_COND_SELECT:
5405         decode_rcr_cond_select(env, ctx);
5406         break;
5407     case OPCM_32_RCR_MADD:
5408         decode_rcr_madd(env, ctx);
5409         break;
5410     case OPCM_32_RCR_MSUB:
5411         decode_rcr_msub(env, ctx);
5412         break;
5413 /* RLC Format */
5414     case OPC1_32_RLC_ADDI:
5415     case OPC1_32_RLC_ADDIH:
5416     case OPC1_32_RLC_ADDIH_A:
5417     case OPC1_32_RLC_MFCR:
5418     case OPC1_32_RLC_MOV:
5419     case OPC1_32_RLC_MOV_64:
5420     case OPC1_32_RLC_MOV_U:
5421     case OPC1_32_RLC_MOV_H:
5422     case OPC1_32_RLC_MOVH_A:
5423     case OPC1_32_RLC_MTCR:
5424         decode_rlc_opc(env, ctx, op1);
5425         break;
5426 /* RR Format */
5427     case OPCM_32_RR_ACCUMULATOR:
5428         decode_rr_accumulator(env, ctx);
5429         break;
5430     case OPCM_32_RR_LOGICAL_SHIFT:
5431         decode_rr_logical_shift(env, ctx);
5432         break;
5433     case OPCM_32_RR_ADDRESS:
5434         decode_rr_address(env, ctx);
5435         break;
5436     case OPCM_32_RR_IDIRECT:
5437         decode_rr_idirect(env, ctx);
5438         break;
5439     case OPCM_32_RR_DIVIDE:
5440         decode_rr_divide(env, ctx);
5441         break;
5442 /* RR1 Format */
5443     case OPCM_32_RR1_MUL:
5444         decode_rr1_mul(env, ctx);
5445         break;
5446     case OPCM_32_RR1_MULQ:
5447         decode_rr1_mulq(env, ctx);
5448         break;
5449 /* RR2 format */
5450     case OPCM_32_RR2_MUL:
5451         decode_rr2_mul(env, ctx);
5452         break;
5453 /* RRPW format */
5454     case OPCM_32_RRPW_EXTRACT_INSERT:
5455         decode_rrpw_extract_insert(env, ctx);
5456         break;
5457     case OPC1_32_RRPW_DEXTR:
5458         r1 = MASK_OP_RRPW_S1(ctx->opcode);
5459         r2 = MASK_OP_RRPW_S2(ctx->opcode);
5460         r3 = MASK_OP_RRPW_D(ctx->opcode);
5461         const16 = MASK_OP_RRPW_POS(ctx->opcode);
5462         if (r1 == r2) {
5463             tcg_gen_rotli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], const16);
5464         } else {
5465             temp = tcg_temp_new();
5466             tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r2], const16);
5467             tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 32 - const16);
5468             tcg_gen_or_tl(cpu_gpr_d[r3], cpu_gpr_d[r3], temp);
5469             tcg_temp_free(temp);
5470         }
5471         break;
5472 /* RRR Format */
5473     case OPCM_32_RRR_COND_SELECT:
5474         decode_rrr_cond_select(env, ctx);
5475         break;
5476     case OPCM_32_RRR_DIVIDE:
5477         decode_rrr_divide(env, ctx);
5478     }
5479 }
5480
5481 static void decode_opc(CPUTriCoreState *env, DisasContext *ctx, int *is_branch)
5482 {
5483     /* 16-Bit Instruction */
5484     if ((ctx->opcode & 0x1) == 0) {
5485         ctx->next_pc = ctx->pc + 2;
5486         decode_16Bit_opc(env, ctx);
5487     /* 32-Bit Instruction */
5488     } else {
5489         ctx->next_pc = ctx->pc + 4;
5490         decode_32Bit_opc(env, ctx);
5491     }
5492 }
5493
5494 static inline void
5495 gen_intermediate_code_internal(TriCoreCPU *cpu, struct TranslationBlock *tb,
5496                               int search_pc)
5497 {
5498     CPUState *cs = CPU(cpu);
5499     CPUTriCoreState *env = &cpu->env;
5500     DisasContext ctx;
5501     target_ulong pc_start;
5502     int num_insns;
5503     uint16_t *gen_opc_end;
5504
5505     if (search_pc) {
5506         qemu_log("search pc %d\n", search_pc);
5507     }
5508
5509     num_insns = 0;
5510     pc_start = tb->pc;
5511     gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
5512     ctx.pc = pc_start;
5513     ctx.saved_pc = -1;
5514     ctx.tb = tb;
5515     ctx.singlestep_enabled = cs->singlestep_enabled;
5516     ctx.bstate = BS_NONE;
5517     ctx.mem_idx = cpu_mmu_index(env);
5518
5519     tcg_clear_temp_count();
5520     gen_tb_start(tb);
5521     while (ctx.bstate == BS_NONE) {
5522         ctx.opcode = cpu_ldl_code(env, ctx.pc);
5523         decode_opc(env, &ctx, 0);
5524
5525         num_insns++;
5526
5527         if (tcg_ctx.gen_opc_ptr >= gen_opc_end) {
5528             gen_save_pc(ctx.next_pc);
5529             tcg_gen_exit_tb(0);
5530             break;
5531         }
5532         if (singlestep) {
5533             gen_save_pc(ctx.next_pc);
5534             tcg_gen_exit_tb(0);
5535             break;
5536         }
5537         ctx.pc = ctx.next_pc;
5538     }
5539
5540     gen_tb_end(tb, num_insns);
5541     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
5542     if (search_pc) {
5543         printf("done_generating search pc\n");
5544     } else {
5545         tb->size = ctx.pc - pc_start;
5546         tb->icount = num_insns;
5547     }
5548     if (tcg_check_temp_count()) {
5549         printf("LEAK at %08x\n", env->PC);
5550     }
5551
5552 #ifdef DEBUG_DISAS
5553     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
5554         qemu_log("IN: %s\n", lookup_symbol(pc_start));
5555         log_target_disas(env, pc_start, ctx.pc - pc_start, 0);
5556         qemu_log("\n");
5557     }
5558 #endif
5559 }
5560
5561 void
5562 gen_intermediate_code(CPUTriCoreState *env, struct TranslationBlock *tb)
5563 {
5564     gen_intermediate_code_internal(tricore_env_get_cpu(env), tb, false);
5565 }
5566
5567 void
5568 gen_intermediate_code_pc(CPUTriCoreState *env, struct TranslationBlock *tb)
5569 {
5570     gen_intermediate_code_internal(tricore_env_get_cpu(env), tb, true);
5571 }
5572
5573 void
5574 restore_state_to_opc(CPUTriCoreState *env, TranslationBlock *tb, int pc_pos)
5575 {
5576     env->PC = tcg_ctx.gen_opc_pc[pc_pos];
5577 }
5578 /*
5579  *
5580  * Initialization
5581  *
5582  */
5583
5584 void cpu_state_reset(CPUTriCoreState *env)
5585 {
5586     /* Reset Regs to Default Value */
5587     env->PSW = 0xb80;
5588 }
5589
5590 static void tricore_tcg_init_csfr(void)
5591 {
5592     cpu_PCXI = tcg_global_mem_new(TCG_AREG0,
5593                           offsetof(CPUTriCoreState, PCXI), "PCXI");
5594     cpu_PSW = tcg_global_mem_new(TCG_AREG0,
5595                           offsetof(CPUTriCoreState, PSW), "PSW");
5596     cpu_PC = tcg_global_mem_new(TCG_AREG0,
5597                           offsetof(CPUTriCoreState, PC), "PC");
5598     cpu_ICR = tcg_global_mem_new(TCG_AREG0,
5599                           offsetof(CPUTriCoreState, ICR), "ICR");
5600 }
5601
5602 void tricore_tcg_init(void)
5603 {
5604     int i;
5605     static int inited;
5606     if (inited) {
5607         return;
5608     }
5609     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
5610     /* reg init */
5611     for (i = 0 ; i < 16 ; i++) {
5612         cpu_gpr_a[i] = tcg_global_mem_new(TCG_AREG0,
5613                                           offsetof(CPUTriCoreState, gpr_a[i]),
5614                                           regnames_a[i]);
5615     }
5616     for (i = 0 ; i < 16 ; i++) {
5617         cpu_gpr_d[i] = tcg_global_mem_new(TCG_AREG0,
5618                                   offsetof(CPUTriCoreState, gpr_d[i]),
5619                                            regnames_d[i]);
5620     }
5621     tricore_tcg_init_csfr();
5622     /* init PSW flag cache */
5623     cpu_PSW_C = tcg_global_mem_new(TCG_AREG0,
5624                                    offsetof(CPUTriCoreState, PSW_USB_C),
5625                                    "PSW_C");
5626     cpu_PSW_V = tcg_global_mem_new(TCG_AREG0,
5627                                    offsetof(CPUTriCoreState, PSW_USB_V),
5628                                    "PSW_V");
5629     cpu_PSW_SV = tcg_global_mem_new(TCG_AREG0,
5630                                     offsetof(CPUTriCoreState, PSW_USB_SV),
5631                                     "PSW_SV");
5632     cpu_PSW_AV = tcg_global_mem_new(TCG_AREG0,
5633                                     offsetof(CPUTriCoreState, PSW_USB_AV),
5634                                     "PSW_AV");
5635     cpu_PSW_SAV = tcg_global_mem_new(TCG_AREG0,
5636                                      offsetof(CPUTriCoreState, PSW_USB_SAV),
5637                                      "PSW_SAV");
5638 }