vcs.maemo.org Git - qemu/blob - target-cris/translate.c

   1 /*
   2  *  CRIS emulation for qemu: main translation routines.
   3  *
   4  *  Copyright (c) 2008 AXIS Communications AB
   5  *  Written by Edgar E. Iglesias.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /*
  23  * FIXME:
  24  * The condition code translation is in desperate need of attention. It's slow
  25  * and for system simulation it seems buggy. It sucks.
  26  */
  27
  28 #include <stdarg.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <inttypes.h>
  33 #include <assert.h>
  34
  35 #include "cpu.h"
  36 #include "exec-all.h"
  37 #include "disas.h"
  38 #include "tcg-op.h"
  39 #include "helper.h"
  40 #include "crisv32-decode.h"
  41 #include "qemu-common.h"
  42
  43 #define CRIS_STATS 0
  44 #if CRIS_STATS
  45 #define STATS(x) x
  46 #else
  47 #define STATS(x)
  48 #endif
  49
  50 #define DISAS_CRIS 0
  51 #if DISAS_CRIS
  52 #define DIS(x) x
  53 #else
  54 #define DIS(x)
  55 #endif
  56
  57 #define D(x)
  58 #define BUG() (gen_BUG(dc, __FILE__, __LINE__))
  59 #define BUG_ON(x) ({if (x) BUG();})
  60
  61 #define DISAS_SWI 5
  62
  63 /* Used by the decoder.  */
  64 #define EXTRACT_FIELD(src, start, end) \
  65             (((src) >> start) & ((1 << (end - start + 1)) - 1))
  66
  67 #define CC_MASK_NZ 0xc
  68 #define CC_MASK_NZV 0xe
  69 #define CC_MASK_NZVC 0xf
  70 #define CC_MASK_RNZV 0x10e
  71
  72 TCGv cpu_env;
  73 TCGv cpu_T[2];
  74 TCGv cpu_R[16];
  75 TCGv cpu_PR[16];
  76 TCGv cc_src;
  77 TCGv cc_dest;
  78 TCGv cc_result;
  79 TCGv cc_op;
  80 TCGv cc_size;
  81 TCGv cc_mask;
  82
  83 TCGv env_btarget;
  84 TCGv env_pc;
  85
  86 /* This is the state at translation time.  */
  87 typedef struct DisasContext {
  88         CPUState *env;
  89         target_ulong pc, ppc;
  90
  91         /* Decoder.  */
  92         uint32_t ir;
  93         uint32_t opcode;
  94         unsigned int op1;
  95         unsigned int op2;
  96         unsigned int zsize, zzsize;
  97         unsigned int mode;
  98         unsigned int postinc;
  99
 100         int update_cc;
 101         int cc_op;
 102         int cc_size;
 103         uint32_t cc_mask;
 104         int flags_live; /* Wether or not $ccs is uptodate.  */
 105         int flagx_live; /* Wether or not flags_x has the x flag known at
 106                            translation time.  */
 107         int flags_x;
 108         int clear_x; /* Clear x after this insn?  */
 109
 110         int user; /* user or kernel mode.  */
 111         int is_jmp;
 112         int dyn_jmp;
 113
 114         uint32_t delayed_pc;
 115         int delayed_branch;
 116         int bcc;
 117         uint32_t condlabel;
 118
 119         struct TranslationBlock *tb;
 120         int singlestep_enabled;
 121 } DisasContext;
 122
 123 void cris_prepare_jmp (DisasContext *dc, uint32_t dst);
 124 static void gen_BUG(DisasContext *dc, char *file, int line)
 125 {
 126         printf ("BUG: pc=%x %s %d\n", dc->pc, file, line);
 127         fprintf (logfile, "BUG: pc=%x %s %d\n", dc->pc, file, line);
 128         cpu_dump_state (dc->env, stdout, fprintf, 0);
 129         fflush(NULL);
 130         cris_prepare_jmp (dc, 0x70000000 + line);
 131 }
 132
 133 const char *regnames[] =
 134 {
 135         "$r0", "$r1", "$r2", "$r3",
 136         "$r4", "$r5", "$r6", "$r7",
 137         "$r8", "$r9", "$r10", "$r11",
 138         "$r12", "$r13", "$sp", "$acr",
 139 };
 140 const char *pregnames[] =
 141 {
 142         "$bz", "$vr", "$pid", "$srs",
 143         "$wz", "$exs", "$eda", "$mof",
 144         "$dz", "$ebp", "$erp", "$srp",
 145         "$nrp", "$ccs", "$usp", "$spc",
 146 };
 147
 148 /* We need this table to handle preg-moves with implicit width.  */
 149 int preg_sizes[] = {
 150         1, /* bz.  */
 151         1, /* vr.  */
 152         4, /* pid.  */
 153         1, /* srs.  */
 154         2, /* wz.  */
 155         4, 4, 4,
 156         4, 4, 4, 4,
 157         4, 4, 4, 4,
 158 };
 159
 160 #define t_gen_mov_TN_env(tn, member) \
 161  _t_gen_mov_TN_env((tn), offsetof(CPUState, member))
 162 #define t_gen_mov_env_TN(member, tn) \
 163  _t_gen_mov_env_TN(offsetof(CPUState, member), (tn))
 164
 165 static inline void t_gen_mov_TN_reg(TCGv tn, int r)
 166 {
 167         if (r < 0 || r > 15)
 168                 fprintf(stderr, "wrong register read $r%d\n", r);
 169         tcg_gen_mov_tl(tn, cpu_R[r]);
 170 }
 171 static inline void t_gen_mov_reg_TN(int r, TCGv tn)
 172 {
 173         if (r < 0 || r > 15)
 174                 fprintf(stderr, "wrong register write $r%d\n", r);
 175         tcg_gen_mov_tl(cpu_R[r], tn);
 176 }
 177
 178 static inline void _t_gen_mov_TN_env(TCGv tn, int offset)
 179 {
 180         if (offset > sizeof (CPUState))
 181                 fprintf(stderr, "wrong load from env from off=%d\n", offset);
 182         tcg_gen_ld_tl(tn, cpu_env, offset);
 183 }
 184 static inline void _t_gen_mov_env_TN(int offset, TCGv tn)
 185 {
 186         if (offset > sizeof (CPUState))
 187                 fprintf(stderr, "wrong store to env at off=%d\n", offset);
 188         tcg_gen_st_tl(tn, cpu_env, offset);
 189 }
 190
 191 static inline void t_gen_mov_TN_preg(TCGv tn, int r)
 192 {
 193         if (r < 0 || r > 15)
 194                 fprintf(stderr, "wrong register read $p%d\n", r);
 195         if (r == PR_BZ || r == PR_WZ || r == PR_DZ)
 196                 tcg_gen_mov_tl(tn, tcg_const_tl(0));
 197         else if (r == PR_VR)
 198                 tcg_gen_mov_tl(tn, tcg_const_tl(32));
 199         else if (r == PR_EXS) {
 200                 printf("read from EXS!\n");
 201                 tcg_gen_mov_tl(tn, cpu_PR[r]);
 202         }
 203         else if (r == PR_EDA) {
 204                 printf("read from EDA!\n");
 205                 tcg_gen_mov_tl(tn, cpu_PR[r]);
 206         }
 207         else
 208                 tcg_gen_mov_tl(tn, cpu_PR[r]);
 209 }
 210 static inline void t_gen_mov_preg_TN(int r, TCGv tn)
 211 {
 212         if (r < 0 || r > 15)
 213                 fprintf(stderr, "wrong register write $p%d\n", r);
 214         if (r == PR_BZ || r == PR_WZ || r == PR_DZ)
 215                 return;
 216         else if (r == PR_SRS)
 217                 tcg_gen_andi_tl(cpu_PR[r], tn, 3);
 218         else {
 219                 if (r == PR_PID) {
 220                         tcg_gen_helper_0_0(helper_tlb_flush);
 221                 }
 222                 tcg_gen_mov_tl(cpu_PR[r], tn);
 223         }
 224 }
 225
 226 static inline void t_gen_raise_exception(uint32_t index)
 227 {
 228         tcg_gen_helper_0_1(helper_raise_exception, tcg_const_tl(index));
 229 }
 230
 231 static void t_gen_lsl(TCGv d, TCGv a, TCGv b)
 232 {
 233         int l1;
 234
 235         l1 = gen_new_label();
 236         /* Speculative shift. */
 237         tcg_gen_shl_tl(d, a, b);
 238         tcg_gen_brcond_tl(TCG_COND_LEU, b, tcg_const_tl(31), l1);
 239         /* Clear dst if shift operands were to large.  */
 240         tcg_gen_movi_tl(d, 0);
 241         gen_set_label(l1);
 242 }
 243
 244 static void t_gen_lsr(TCGv d, TCGv a, TCGv b)
 245 {
 246         int l1;
 247
 248         l1 = gen_new_label();
 249         /* Speculative shift. */
 250         tcg_gen_shr_tl(d, a, b);
 251         tcg_gen_brcond_tl(TCG_COND_LEU, b, tcg_const_tl(31), l1);
 252         /* Clear dst if shift operands were to large.  */
 253         tcg_gen_movi_tl(d, 0);
 254         gen_set_label(l1);
 255 }
 256
 257 static void t_gen_asr(TCGv d, TCGv a, TCGv b)
 258 {
 259         int l1;
 260
 261         l1 = gen_new_label();
 262         /* Speculative shift. */
 263         tcg_gen_sar_tl(d, a, b);
 264         tcg_gen_brcond_tl(TCG_COND_LEU, b, tcg_const_tl(31), l1);
 265         /* Clear dst if shift operands were to large.  */
 266         tcg_gen_sar_tl(d, a, tcg_const_tl(30));
 267         gen_set_label(l1);
 268 }
 269
 270 /* 64-bit signed mul, lower result in d and upper in d2.  */
 271 static void t_gen_muls(TCGv d, TCGv d2, TCGv a, TCGv b)
 272 {
 273         TCGv t0, t1;
 274
 275         t0 = tcg_temp_new(TCG_TYPE_I64);
 276         t1 = tcg_temp_new(TCG_TYPE_I64);
 277
 278         tcg_gen_ext32s_i64(t0, a);
 279         tcg_gen_ext32s_i64(t1, b);
 280         tcg_gen_mul_i64(t0, t0, t1);
 281
 282         tcg_gen_trunc_i64_i32(d, t0);
 283         tcg_gen_shri_i64(t0, t0, 32);
 284         tcg_gen_trunc_i64_i32(d2, t0);
 285
 286         tcg_gen_discard_i64(t0);
 287         tcg_gen_discard_i64(t1);
 288 }
 289
 290 /* 64-bit unsigned muls, lower result in d and upper in d2.  */
 291 static void t_gen_mulu(TCGv d, TCGv d2, TCGv a, TCGv b)
 292 {
 293         TCGv t0, t1;
 294
 295         t0 = tcg_temp_new(TCG_TYPE_I64);
 296         t1 = tcg_temp_new(TCG_TYPE_I64);
 297
 298         tcg_gen_extu_i32_i64(t0, a);
 299         tcg_gen_extu_i32_i64(t1, b);
 300         tcg_gen_mul_i64(t0, t0, t1);
 301
 302         tcg_gen_trunc_i64_i32(d, t0);
 303         tcg_gen_shri_i64(t0, t0, 32);
 304         tcg_gen_trunc_i64_i32(d2, t0);
 305
 306         tcg_gen_discard_i64(t0);
 307         tcg_gen_discard_i64(t1);
 308 }
 309
 310 /* 32bit branch-free binary search for counting leading zeros.  */
 311 static void t_gen_lz_i32(TCGv d, TCGv x)
 312 {
 313         TCGv y, m, n;
 314
 315         y = tcg_temp_new(TCG_TYPE_I32);
 316         m = tcg_temp_new(TCG_TYPE_I32);
 317         n = tcg_temp_new(TCG_TYPE_I32);
 318
 319         /* y = -(x >> 16)  */
 320         tcg_gen_shri_i32(y, x, 16);
 321         tcg_gen_sub_i32(y, tcg_const_i32(0), y);
 322
 323         /* m = (y >> 16) & 16  */
 324         tcg_gen_sari_i32(m, y, 16);
 325         tcg_gen_andi_i32(m, m, 16);
 326
 327         /* n = 16 - m  */
 328         tcg_gen_sub_i32(n, tcg_const_i32(16), m);
 329         /* x = x >> m  */
 330         tcg_gen_shr_i32(x, x, m);
 331
 332         /* y = x - 0x100  */
 333         tcg_gen_subi_i32(y, x, 0x100);
 334         /* m = (y >> 16) & 8  */
 335         tcg_gen_sari_i32(m, y, 16);
 336         tcg_gen_andi_i32(m, m, 8);
 337         /* n = n + m  */
 338         tcg_gen_add_i32(n, n, m);
 339         /* x = x << m  */
 340         tcg_gen_shl_i32(x, x, m);
 341
 342         /* y = x - 0x1000  */
 343         tcg_gen_subi_i32(y, x, 0x1000);
 344         /* m = (y >> 16) & 4  */
 345         tcg_gen_sari_i32(m, y, 16);
 346         tcg_gen_andi_i32(m, m, 4);
 347         /* n = n + m  */
 348         tcg_gen_add_i32(n, n, m);
 349         /* x = x << m  */
 350         tcg_gen_shl_i32(x, x, m);
 351
 352         /* y = x - 0x4000  */
 353         tcg_gen_subi_i32(y, x, 0x4000);
 354         /* m = (y >> 16) & 2  */
 355         tcg_gen_sari_i32(m, y, 16);
 356         tcg_gen_andi_i32(m, m, 2);
 357         /* n = n + m  */
 358         tcg_gen_add_i32(n, n, m);
 359         /* x = x << m  */
 360         tcg_gen_shl_i32(x, x, m);
 361
 362         /* y = x >> 14  */
 363         tcg_gen_shri_i32(y, x, 14);
 364         /* m = y & ~(y >> 1)  */
 365         tcg_gen_sari_i32(m, y, 1);
 366         tcg_gen_xori_i32(m, m, 0xffffffff);
 367         tcg_gen_and_i32(m, m, y);
 368
 369         /* d = n + 2 - m  */
 370         tcg_gen_addi_i32(d, n, 2);
 371         tcg_gen_sub_i32(d, d, m);
 372
 373         tcg_gen_discard_i32(y);
 374         tcg_gen_discard_i32(m);
 375         tcg_gen_discard_i32(n);
 376 }
 377
 378 static void t_gen_btst(TCGv d, TCGv s)
 379 {
 380         TCGv sbit;
 381         TCGv bset;
 382         int l1;
 383
 384         /* des ref:
 385            The N flag is set according to the selected bit in the dest reg.
 386            The Z flag is set if the selected bit and all bits to the right are
 387            zero.
 388            The X flag is cleared.
 389            Other flags are left untouched.
 390            The destination reg is not affected.
 391
 392         unsigned int fz, sbit, bset, mask, masked_t0;
 393
 394         sbit = T1 & 31;
 395         bset = !!(T0 & (1 << sbit));
 396         mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1;
 397         masked_t0 = T0 & mask;
 398         fz = !(masked_t0 | bset);
 399
 400         // Clear the X, N and Z flags.
 401         T0 = env->pregs[PR_CCS] & ~(X_FLAG | N_FLAG | Z_FLAG);
 402         // Set the N and Z flags accordingly.
 403         T0 |= (bset << 3) | (fz << 2);
 404         */
 405
 406         l1 = gen_new_label();
 407         sbit = tcg_temp_new(TCG_TYPE_TL);
 408         bset = tcg_temp_new(TCG_TYPE_TL);
 409
 410         /* Compute bset and sbit.  */
 411         tcg_gen_andi_tl(sbit, s, 31);
 412         tcg_gen_shl_tl(s, tcg_const_tl(1), sbit);
 413         tcg_gen_and_tl(bset, d, s);
 414         tcg_gen_shr_tl(bset, bset, sbit);
 415         /* Displace to N_FLAG.  */
 416         tcg_gen_shli_tl(bset, bset, 3);
 417
 418         tcg_gen_shl_tl(sbit, tcg_const_tl(2), sbit);
 419         tcg_gen_subi_tl(sbit, sbit, 1);
 420         tcg_gen_and_tl(sbit, d, sbit);
 421
 422         tcg_gen_andi_tl(d, cpu_PR[PR_CCS], ~(X_FLAG | N_FLAG | Z_FLAG));
 423         /* or in the N_FLAG.  */
 424         tcg_gen_or_tl(d, d, bset);
 425         tcg_gen_brcond_tl(TCG_COND_NE, sbit, tcg_const_tl(0), l1);
 426         /* or in the Z_FLAG.  */
 427         tcg_gen_ori_tl(d, d, Z_FLAG);
 428         gen_set_label(l1);
 429
 430         tcg_gen_discard_tl(sbit);
 431         tcg_gen_discard_tl(bset);
 432 }
 433
 434 static void t_gen_cris_dstep(TCGv d, TCGv s)
 435 {
 436         int l1;
 437
 438         l1 = gen_new_label();
 439
 440         /*
 441          * d <<= 1
 442          * if (d >= s)
 443          *    d -= s;
 444          */
 445         tcg_gen_shli_tl(d, d, 1);
 446         tcg_gen_brcond_tl(TCG_COND_LTU, d, s, l1);
 447         tcg_gen_sub_tl(d, d, s);
 448         gen_set_label(l1);
 449 }
 450
 451 /* Extended arithmetics on CRIS.  */
 452 static inline void t_gen_add_flag(TCGv d, int flag)
 453 {
 454         TCGv c;
 455
 456         c = tcg_temp_new(TCG_TYPE_TL);
 457         t_gen_mov_TN_preg(c, PR_CCS);
 458         /* Propagate carry into d.  */
 459         tcg_gen_andi_tl(c, c, 1 << flag);
 460         if (flag)
 461                 tcg_gen_shri_tl(c, c, flag);
 462         tcg_gen_add_tl(d, d, c);
 463         tcg_gen_discard_tl(c);
 464 }
 465
 466 static inline void t_gen_addx_carry(TCGv d)
 467 {
 468         TCGv x, c;
 469
 470         x = tcg_temp_new(TCG_TYPE_TL);
 471         c = tcg_temp_new(TCG_TYPE_TL);
 472         t_gen_mov_TN_preg(x, PR_CCS);
 473         tcg_gen_mov_tl(c, x);
 474
 475         /* Propagate carry into d if X is set. Branch free.  */
 476         tcg_gen_andi_tl(c, c, C_FLAG);
 477         tcg_gen_andi_tl(x, x, X_FLAG);
 478         tcg_gen_shri_tl(x, x, 4);
 479
 480         tcg_gen_and_tl(x, x, c);
 481         tcg_gen_add_tl(d, d, x);
 482         tcg_gen_discard_tl(x);
 483         tcg_gen_discard_tl(c);
 484 }
 485
 486 static inline void t_gen_subx_carry(TCGv d)
 487 {
 488         TCGv x, c;
 489
 490         x = tcg_temp_new(TCG_TYPE_TL);
 491         c = tcg_temp_new(TCG_TYPE_TL);
 492         t_gen_mov_TN_preg(x, PR_CCS);
 493         tcg_gen_mov_tl(c, x);
 494
 495         /* Propagate carry into d if X is set. Branch free.  */
 496         tcg_gen_andi_tl(c, c, C_FLAG);
 497         tcg_gen_andi_tl(x, x, X_FLAG);
 498         tcg_gen_shri_tl(x, x, 4);
 499
 500         tcg_gen_and_tl(x, x, c);
 501         tcg_gen_sub_tl(d, d, x);
 502         tcg_gen_discard_tl(x);
 503         tcg_gen_discard_tl(c);
 504 }
 505
 506 /* Swap the two bytes within each half word of the s operand.
 507    T0 = ((T0 << 8) & 0xff00ff00) | ((T0 >> 8) & 0x00ff00ff)  */
 508 static inline void t_gen_swapb(TCGv d, TCGv s)
 509 {
 510         TCGv t, org_s;
 511
 512         t = tcg_temp_new(TCG_TYPE_TL);
 513         org_s = tcg_temp_new(TCG_TYPE_TL);
 514
 515         /* d and s may refer to the same object.  */
 516         tcg_gen_mov_tl(org_s, s);
 517         tcg_gen_shli_tl(t, org_s, 8);
 518         tcg_gen_andi_tl(d, t, 0xff00ff00);
 519         tcg_gen_shri_tl(t, org_s, 8);
 520         tcg_gen_andi_tl(t, t, 0x00ff00ff);
 521         tcg_gen_or_tl(d, d, t);
 522         tcg_gen_discard_tl(t);
 523         tcg_gen_discard_tl(org_s);
 524 }
 525
 526 /* Swap the halfwords of the s operand.  */
 527 static inline void t_gen_swapw(TCGv d, TCGv s)
 528 {
 529         TCGv t;
 530         /* d and s refer the same object.  */
 531         t = tcg_temp_new(TCG_TYPE_TL);
 532         tcg_gen_mov_tl(t, s);
 533         tcg_gen_shli_tl(d, t, 16);
 534         tcg_gen_shri_tl(t, t, 16);
 535         tcg_gen_or_tl(d, d, t);
 536         tcg_gen_discard_tl(t);
 537 }
 538
 539 /* Reverse the within each byte.
 540    T0 = (((T0 << 7) & 0x80808080) |
 541    ((T0 << 5) & 0x40404040) |
 542    ((T0 << 3) & 0x20202020) |
 543    ((T0 << 1) & 0x10101010) |
 544    ((T0 >> 1) & 0x08080808) |
 545    ((T0 >> 3) & 0x04040404) |
 546    ((T0 >> 5) & 0x02020202) |
 547    ((T0 >> 7) & 0x01010101));
 548  */
 549 static inline void t_gen_swapr(TCGv d, TCGv s)
 550 {
 551         struct {
 552                 int shift; /* LSL when positive, LSR when negative.  */
 553                 uint32_t mask;
 554         } bitrev [] = {
 555                 {7, 0x80808080},
 556                 {5, 0x40404040},
 557                 {3, 0x20202020},
 558                 {1, 0x10101010},
 559                 {-1, 0x08080808},
 560                 {-3, 0x04040404},
 561                 {-5, 0x02020202},
 562                 {-7, 0x01010101}
 563         };
 564         int i;
 565         TCGv t, org_s;
 566
 567         /* d and s refer the same object.  */
 568         t = tcg_temp_new(TCG_TYPE_TL);
 569         org_s = tcg_temp_new(TCG_TYPE_TL);
 570         tcg_gen_mov_tl(org_s, s);
 571
 572         tcg_gen_shli_tl(t, org_s,  bitrev[0].shift);
 573         tcg_gen_andi_tl(d, t,  bitrev[0].mask);
 574         for (i = 1; i < sizeof bitrev / sizeof bitrev[0]; i++) {
 575                 if (bitrev[i].shift >= 0) {
 576                         tcg_gen_shli_tl(t, org_s,  bitrev[i].shift);
 577                 } else {
 578                         tcg_gen_shri_tl(t, org_s,  -bitrev[i].shift);
 579                 }
 580                 tcg_gen_andi_tl(t, t,  bitrev[i].mask);
 581                 tcg_gen_or_tl(d, d, t);
 582         }
 583         tcg_gen_discard_tl(t);
 584         tcg_gen_discard_tl(org_s);
 585 }
 586
 587 static void t_gen_cc_jmp(target_ulong pc_true, target_ulong pc_false)
 588 {
 589         TCGv btaken;
 590         int l1;
 591
 592         l1 = gen_new_label();
 593         btaken = tcg_temp_new(TCG_TYPE_TL);
 594
 595         /* Conditional jmp.  */
 596         t_gen_mov_TN_env(btaken, btaken);
 597         tcg_gen_movi_tl(env_pc, pc_false);
 598         tcg_gen_brcond_tl(TCG_COND_EQ, btaken, tcg_const_tl(0), l1);
 599         tcg_gen_movi_tl(env_pc, pc_true);
 600         gen_set_label(l1);
 601
 602         tcg_gen_discard_tl(btaken);
 603 }
 604
 605 static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
 606 {
 607         TranslationBlock *tb;
 608         tb = dc->tb;
 609         if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
 610                 tcg_gen_goto_tb(n);
 611                 tcg_gen_movi_tl(env_pc, dest);
 612                 tcg_gen_exit_tb((long)tb + n);
 613         } else {
 614                 tcg_gen_mov_tl(env_pc, cpu_T[0]);
 615                 tcg_gen_exit_tb(0);
 616         }
 617 }
 618
 619 /* Sign extend at translation time.  */
 620 static int sign_extend(unsigned int val, unsigned int width)
 621 {
 622         int sval;
 623
 624         /* LSL.  */
 625         val <<= 31 - width;
 626         sval = val;
 627         /* ASR.  */
 628         sval >>= 31 - width;
 629         return sval;
 630 }
 631
 632 static inline void cris_clear_x_flag(DisasContext *dc)
 633 {
 634         if (!dc->flagx_live
 635             || (dc->flagx_live && dc->flags_x)
 636             || dc->cc_op != CC_OP_FLAGS)
 637                 tcg_gen_andi_i32(cpu_PR[PR_CCS], cpu_PR[PR_CCS], ~X_FLAG);
 638         dc->flagx_live = 1;
 639         dc->flags_x = 0;
 640 }
 641
 642 static void cris_evaluate_flags(DisasContext *dc)
 643 {
 644         if (!dc->flags_live) {
 645                 tcg_gen_movi_tl(cc_op, dc->cc_op);
 646                 tcg_gen_movi_tl(cc_size, dc->cc_size);
 647                 tcg_gen_movi_tl(cc_mask, dc->cc_mask);
 648
 649                 switch (dc->cc_op)
 650                 {
 651                         case CC_OP_MCP:
 652                                 tcg_gen_helper_0_0(helper_evaluate_flags_mcp);
 653                                 break;
 654                         case CC_OP_MULS:
 655                                 tcg_gen_helper_0_0(helper_evaluate_flags_muls);
 656                                 break;
 657                         case CC_OP_MULU:
 658                                 tcg_gen_helper_0_0(helper_evaluate_flags_mulu);
 659                                 break;
 660                         case CC_OP_MOVE:
 661                                 switch (dc->cc_size)
 662                                 {
 663                                         case 4:
 664                                                 tcg_gen_helper_0_0(helper_evaluate_flags_move_4);
 665                                                 break;
 666                                         case 2:
 667                                                 tcg_gen_helper_0_0(helper_evaluate_flags_move_2);
 668                                                 break;
 669                                         default:
 670                                                 tcg_gen_helper_0_0(helper_evaluate_flags);
 671                                                 break;
 672                                 }
 673                                 break;
 674                         case CC_OP_FLAGS:
 675                                 /* live.  */
 676                                 break;
 677                         default:
 678                         {
 679                                 switch (dc->cc_size)
 680                                 {
 681                                         case 4:
 682                                                 tcg_gen_helper_0_0(helper_evaluate_flags_alu_4);
 683                                                 break;
 684                                         default:
 685                                                 tcg_gen_helper_0_0(helper_evaluate_flags);
 686                                                 break;
 687                                 }
 688                         }
 689                         break;
 690                 }
 691                 dc->flags_live = 1;
 692         }
 693 }
 694
 695 static void cris_cc_mask(DisasContext *dc, unsigned int mask)
 696 {
 697         uint32_t ovl;
 698
 699         /* Check if we need to evaluate the condition codes due to
 700            CC overlaying.  */
 701         ovl = (dc->cc_mask ^ mask) & ~mask;
 702         if (ovl) {
 703                 /* TODO: optimize this case. It trigs all the time.  */
 704                 cris_evaluate_flags (dc);
 705         }
 706         dc->cc_mask = mask;
 707         dc->update_cc = 1;
 708
 709         if (mask == 0)
 710                 dc->update_cc = 0;
 711         else
 712                 dc->flags_live = 0;
 713 }
 714
 715 static void cris_update_cc_op(DisasContext *dc, int op, int size)
 716 {
 717         dc->cc_op = op;
 718         dc->cc_size = size;
 719         dc->flags_live = 0;
 720 }
 721
 722 /* op is the operation.
 723    T0, T1 are the operands.
 724    dst is the destination reg.
 725 */
 726 static void crisv32_alu_op(DisasContext *dc, int op, int rd, int size)
 727 {
 728         int writeback = 1;
 729         if (dc->update_cc) {
 730                 cris_update_cc_op(dc, op, size);
 731                 tcg_gen_mov_tl(cc_dest, cpu_T[0]);
 732
 733                 /* FIXME: This shouldn't be needed. But we don't pass the
 734                  tests without it. Investigate.  */
 735                 t_gen_mov_env_TN(cc_x_live, tcg_const_tl(dc->flagx_live));
 736                 t_gen_mov_env_TN(cc_x, tcg_const_tl(dc->flags_x));
 737         }
 738
 739         /* Emit the ALU insns.  */
 740         switch (op)
 741         {
 742                 case CC_OP_ADD:
 743                         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 744                         /* Extended arithmetics.  */
 745                         t_gen_addx_carry(cpu_T[0]);
 746                         break;
 747                 case CC_OP_ADDC:
 748                         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 749                         t_gen_add_flag(cpu_T[0], 0); /* C_FLAG.  */
 750                         break;
 751                 case CC_OP_MCP:
 752                         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 753                         t_gen_add_flag(cpu_T[0], 8); /* R_FLAG.  */
 754                         break;
 755                 case CC_OP_SUB:
 756                         tcg_gen_sub_tl(cpu_T[1], tcg_const_tl(0), cpu_T[1]);
 757                         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 758                         tcg_gen_sub_tl(cpu_T[1], tcg_const_tl(0), cpu_T[1]);
 759                         /* CRIS flag evaluation needs ~src.  */
 760                         tcg_gen_xori_tl(cpu_T[1], cpu_T[1], -1);
 761
 762                         /* Extended arithmetics.  */
 763                         t_gen_subx_carry(cpu_T[0]);
 764                         break;
 765                 case CC_OP_MOVE:
 766                         tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
 767                         break;
 768                 case CC_OP_OR:
 769                         tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 770                         break;
 771                 case CC_OP_AND:
 772                         tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 773                         break;
 774                 case CC_OP_XOR:
 775                         tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 776                         break;
 777                 case CC_OP_LSL:
 778                         t_gen_lsl(cpu_T[0], cpu_T[0], cpu_T[1]);
 779                         break;
 780                 case CC_OP_LSR:
 781                         t_gen_lsr(cpu_T[0], cpu_T[0], cpu_T[1]);
 782                         break;
 783                 case CC_OP_ASR:
 784                         t_gen_asr(cpu_T[0], cpu_T[0], cpu_T[1]);
 785                         break;
 786                 case CC_OP_NEG:
 787                         /* Hopefully the TCG backend recognizes this pattern
 788                            and makes a real neg out of it.  */
 789                         tcg_gen_sub_tl(cpu_T[0], tcg_const_tl(0), cpu_T[1]);
 790                         /* Extended arithmetics.  */
 791                         t_gen_subx_carry(cpu_T[0]);
 792                         break;
 793                 case CC_OP_LZ:
 794                         t_gen_lz_i32(cpu_T[0], cpu_T[1]);
 795                         break;
 796                 case CC_OP_BTST:
 797                         t_gen_btst(cpu_T[0], cpu_T[1]);
 798                         writeback = 0;
 799                         break;
 800                 case CC_OP_MULS:
 801                 {
 802                         TCGv mof;
 803                         mof = tcg_temp_new(TCG_TYPE_TL);
 804                         t_gen_muls(cpu_T[0], mof, cpu_T[0], cpu_T[1]);
 805                         t_gen_mov_preg_TN(PR_MOF, mof);
 806                         tcg_gen_discard_tl(mof);
 807                 }
 808                 break;
 809                 case CC_OP_MULU:
 810                 {
 811                         TCGv mof;
 812                         mof = tcg_temp_new(TCG_TYPE_TL);
 813                         t_gen_mulu(cpu_T[0], mof, cpu_T[0], cpu_T[1]);
 814                         t_gen_mov_preg_TN(PR_MOF, mof);
 815                         tcg_gen_discard_tl(mof);
 816                 }
 817                 break;
 818                 case CC_OP_DSTEP:
 819                         t_gen_cris_dstep(cpu_T[0], cpu_T[1]);
 820                         break;
 821                 case CC_OP_BOUND:
 822                 {
 823                         int l1;
 824                         l1 = gen_new_label();
 825                         tcg_gen_brcond_tl(TCG_COND_LEU,
 826                                           cpu_T[0], cpu_T[1], l1);
 827                         tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
 828                         gen_set_label(l1);
 829                 }
 830                 break;
 831                 case CC_OP_CMP:
 832                         tcg_gen_sub_tl(cpu_T[1], tcg_const_tl(0), cpu_T[1]);
 833                         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 834                         /* CRIS flag evaluation needs ~src.  */
 835                         tcg_gen_sub_tl(cpu_T[1], tcg_const_tl(0), cpu_T[1]);
 836                         /* CRIS flag evaluation needs ~src.  */
 837                         tcg_gen_xori_tl(cpu_T[1], cpu_T[1], -1);
 838
 839                         /* Extended arithmetics.  */
 840                         t_gen_subx_carry(cpu_T[0]);
 841                         writeback = 0;
 842                         break;
 843                 default:
 844                         fprintf (logfile, "illegal ALU op.\n");
 845                         BUG();
 846                         break;
 847         }
 848
 849         if (dc->update_cc)
 850                 tcg_gen_mov_tl(cc_src, cpu_T[1]);
 851
 852         if (size == 1)
 853                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
 854         else if (size == 2)
 855                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffff);
 856
 857         /* Writeback.  */
 858         if (writeback) {
 859                 if (size == 4)
 860                         t_gen_mov_reg_TN(rd, cpu_T[0]);
 861                 else {
 862                         tcg_gen_mov_tl(cpu_T[1], cpu_T[0]);
 863                         t_gen_mov_TN_reg(cpu_T[0], rd);
 864                         if (size == 1)
 865                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], ~0xff);
 866                         else
 867                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], ~0xffff);
 868                         tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
 869                         t_gen_mov_reg_TN(rd, cpu_T[0]);
 870                         tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
 871                 }
 872         }
 873         if (dc->update_cc)
 874                 tcg_gen_mov_tl(cc_result, cpu_T[0]);
 875
 876         {
 877                 /* TODO: Optimize this.  */
 878                 if (!dc->flagx_live)
 879                         cris_evaluate_flags(dc);
 880         }
 881 }
 882
 883 static int arith_cc(DisasContext *dc)
 884 {
 885         if (dc->update_cc) {
 886                 switch (dc->cc_op) {
 887                         case CC_OP_ADD: return 1;
 888                         case CC_OP_SUB: return 1;
 889                         case CC_OP_LSL: return 1;
 890                         case CC_OP_LSR: return 1;
 891                         case CC_OP_ASR: return 1;
 892                         case CC_OP_CMP: return 1;
 893                         default:
 894                                 return 0;
 895                 }
 896         }
 897         return 0;
 898 }
 899
 900 static void gen_tst_cc (DisasContext *dc, int cond)
 901 {
 902         int arith_opt;
 903
 904         /* TODO: optimize more condition codes.  */
 905
 906         /*
 907          * If the flags are live, we've gotta look into the bits of CCS.
 908          * Otherwise, if we just did an arithmetic operation we try to
 909          * evaluate the condition code faster.
 910          *
 911          * When this function is done, T0 should be non-zero if the condition
 912          * code is true.
 913          */
 914         arith_opt = arith_cc(dc) && !dc->flags_live;
 915         switch (cond) {
 916                 case CC_EQ:
 917                         if (arith_opt) {
 918                                 /* If cc_result is zero, T0 should be
 919                                    non-zero otherwise T0 should be zero.  */
 920                                 int l1;
 921                                 l1 = gen_new_label();
 922                                 tcg_gen_movi_tl(cpu_T[0], 0);
 923                                 tcg_gen_brcond_tl(TCG_COND_NE, cc_result,
 924                                                   tcg_const_tl(0), l1);
 925                                 tcg_gen_movi_tl(cpu_T[0], 1);
 926                                 gen_set_label(l1);
 927                         }
 928                         else {
 929                                 cris_evaluate_flags(dc);
 930                                 tcg_gen_andi_tl(cpu_T[0],
 931                                                 cpu_PR[PR_CCS], Z_FLAG);
 932                         }
 933                         break;
 934                 case CC_NE:
 935                         if (arith_opt)
 936                                 tcg_gen_mov_tl(cpu_T[0], cc_result);
 937                         else {
 938                                 cris_evaluate_flags(dc);
 939                                 tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
 940                                                 Z_FLAG);
 941                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], Z_FLAG);
 942                         }
 943                         break;
 944                 case CC_CS:
 945                         cris_evaluate_flags(dc);
 946                         tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], C_FLAG);
 947                         break;
 948                 case CC_CC:
 949                         cris_evaluate_flags(dc);
 950                         tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
 951                                         C_FLAG);
 952                         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], C_FLAG);
 953                         break;
 954                 case CC_VS:
 955                         cris_evaluate_flags(dc);
 956                         tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], V_FLAG);
 957                         break;
 958                 case CC_VC:
 959                         cris_evaluate_flags(dc);
 960                         tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
 961                                         V_FLAG);
 962                         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], V_FLAG);
 963                         break;
 964                 case CC_PL:
 965                         if (arith_opt)
 966                                 tcg_gen_shli_tl(cpu_T[0], cc_result, 31);
 967                         else {
 968                                 cris_evaluate_flags(dc);
 969                                 tcg_gen_xori_tl(cpu_T[0], cpu_PR[PR_CCS],
 970                                                 N_FLAG);
 971                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
 972                         }
 973                         break;
 974                 case CC_MI:
 975                         if (arith_opt) {
 976                                 tcg_gen_shli_tl(cpu_T[0], cc_result, 31);
 977                                 tcg_gen_xori_tl(cpu_T[0], cpu_T[0], 1);
 978                         }
 979                         else {
 980                                 cris_evaluate_flags(dc);
 981                                 tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS],
 982                                                 N_FLAG);
 983                         }
 984                         break;
 985                 case CC_LS:
 986                         cris_evaluate_flags(dc);
 987                         tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS],
 988                                         C_FLAG | Z_FLAG);
 989                         break;
 990                 case CC_HI:
 991                         cris_evaluate_flags(dc);
 992                         {
 993                                 TCGv tmp;
 994
 995                                 tmp = tcg_temp_new(TCG_TYPE_TL);
 996                                 tcg_gen_xori_tl(tmp, cpu_PR[PR_CCS],
 997                                                 C_FLAG | Z_FLAG);
 998                                 /* Overlay the C flag on top of the Z.  */
 999                                 tcg_gen_shli_tl(cpu_T[0], tmp, 2);
1000                                 tcg_gen_and_tl(cpu_T[0], tmp, cpu_T[0]);
1001                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], Z_FLAG);
1002
1003                                 tcg_gen_discard_tl(tmp);
1004                         }
1005                         break;
1006                 case CC_GE:
1007                         cris_evaluate_flags(dc);
1008                         /* Overlay the V flag on top of the N.  */
1009                         tcg_gen_shli_tl(cpu_T[0], cpu_PR[PR_CCS], 2);
1010                         tcg_gen_xor_tl(cpu_T[0],
1011                                        cpu_PR[PR_CCS], cpu_T[0]);
1012                         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
1013                         tcg_gen_xori_tl(cpu_T[0], cpu_T[0], N_FLAG);
1014                         break;
1015                 case CC_LT:
1016                         cris_evaluate_flags(dc);
1017                         /* Overlay the V flag on top of the N.  */
1018                         tcg_gen_shli_tl(cpu_T[0], cpu_PR[PR_CCS], 2);
1019                         tcg_gen_xor_tl(cpu_T[0],
1020                                        cpu_PR[PR_CCS], cpu_T[0]);
1021                         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], N_FLAG);
1022                         break;
1023                 case CC_GT:
1024                         cris_evaluate_flags(dc);
1025                         {
1026                                 TCGv n, z;
1027
1028                                 n = tcg_temp_new(TCG_TYPE_TL);
1029                                 z = tcg_temp_new(TCG_TYPE_TL);
1030
1031                                 /* To avoid a shift we overlay everything on
1032                                    the V flag.  */
1033                                 tcg_gen_shri_tl(n, cpu_PR[PR_CCS], 2);
1034                                 tcg_gen_shri_tl(z, cpu_PR[PR_CCS], 1);
1035                                 /* invert Z.  */
1036                                 tcg_gen_xori_tl(z, z, 2);
1037
1038                                 tcg_gen_xor_tl(n, n, cpu_PR[PR_CCS]);
1039                                 tcg_gen_xori_tl(n, n, 2);
1040                                 tcg_gen_and_tl(cpu_T[0], z, n);
1041                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 2);
1042
1043                                 tcg_gen_discard_tl(n);
1044                                 tcg_gen_discard_tl(z);
1045                         }
1046                         break;
1047                 case CC_LE:
1048                         cris_evaluate_flags(dc);
1049                         {
1050                                 TCGv n, z;
1051
1052                                 n = tcg_temp_new(TCG_TYPE_TL);
1053                                 z = tcg_temp_new(TCG_TYPE_TL);
1054
1055                                 /* To avoid a shift we overlay everything on
1056                                    the V flag.  */
1057                                 tcg_gen_shri_tl(n, cpu_PR[PR_CCS], 2);
1058                                 tcg_gen_shri_tl(z, cpu_PR[PR_CCS], 1);
1059
1060                                 tcg_gen_xor_tl(n, n, cpu_PR[PR_CCS]);
1061                                 tcg_gen_or_tl(cpu_T[0], z, n);
1062                                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 2);
1063
1064                                 tcg_gen_discard_tl(n);
1065                                 tcg_gen_discard_tl(z);
1066                         }
1067                         break;
1068                 case CC_P:
1069                         cris_evaluate_flags(dc);
1070                         tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], P_FLAG);
1071                         break;
1072                 case CC_A:
1073                         cris_evaluate_flags(dc);
1074                         tcg_gen_movi_tl(cpu_T[0], 1);
1075                         break;
1076                 default:
1077                         BUG();
1078                         break;
1079         };
1080 }
1081
1082 static void cris_prepare_cc_branch (DisasContext *dc, int offset, int cond)
1083 {
1084         /* This helps us re-schedule the micro-code to insns in delay-slots
1085            before the actual jump.  */
1086         dc->delayed_branch = 2;
1087         dc->delayed_pc = dc->pc + offset;
1088         dc->bcc = cond;
1089         if (cond != CC_A)
1090         {
1091                 gen_tst_cc (dc, cond);
1092                 t_gen_mov_env_TN(btaken, cpu_T[0]);
1093         }
1094         tcg_gen_movi_tl(env_btarget, dc->delayed_pc);
1095 }
1096
1097
1098 /* Dynamic jumps, when the dest is in a live reg for example.  */
1099 void cris_prepare_dyn_jmp (DisasContext *dc)
1100 {
1101         /* This helps us re-schedule the micro-code to insns in delay-slots
1102            before the actual jump.  */
1103         dc->delayed_branch = 2;
1104         dc->dyn_jmp = 1;
1105         dc->bcc = CC_A;
1106 }
1107
1108 void cris_prepare_jmp (DisasContext *dc, uint32_t dst)
1109 {
1110         /* This helps us re-schedule the micro-code to insns in delay-slots
1111            before the actual jump.  */
1112         dc->delayed_branch = 2;
1113         dc->delayed_pc = dst;
1114         dc->dyn_jmp = 0;
1115         dc->bcc = CC_A;
1116 }
1117
1118 void gen_load(DisasContext *dc, TCGv dst, TCGv addr,
1119               unsigned int size, int sign)
1120 {
1121         int mem_index = cpu_mmu_index(dc->env);
1122
1123         if (size == 1) {
1124                 if (sign)
1125                         tcg_gen_qemu_ld8s(dst, addr, mem_index);
1126                 else
1127                         tcg_gen_qemu_ld8u(dst, addr, mem_index);
1128         }
1129         else if (size == 2) {
1130                 if (sign)
1131                         tcg_gen_qemu_ld16s(dst, addr, mem_index);
1132                 else
1133                         tcg_gen_qemu_ld16u(dst, addr, mem_index);
1134         }
1135         else {
1136                 tcg_gen_qemu_ld32s(dst, addr, mem_index);
1137         }
1138 }
1139
1140 void gen_store (DisasContext *dc, TCGv addr, TCGv val,
1141                 unsigned int size)
1142 {
1143         int mem_index = cpu_mmu_index(dc->env);
1144
1145         cris_evaluate_flags(dc);
1146
1147         /* Remember, operands are flipped. CRIS has reversed order.  */
1148         if (size == 1)
1149                 tcg_gen_qemu_st8(val, addr, mem_index);
1150         else if (size == 2)
1151                 tcg_gen_qemu_st16(val, addr, mem_index);
1152         else
1153                 tcg_gen_qemu_st32(val, addr, mem_index);
1154 }
1155
1156 static inline void t_gen_sext(TCGv d, TCGv s, int size)
1157 {
1158         if (size == 1)
1159                 tcg_gen_ext8s_i32(d, s);
1160         else if (size == 2)
1161                 tcg_gen_ext16s_i32(d, s);
1162         else
1163                 tcg_gen_mov_tl(d, s);
1164 }
1165
1166 static inline void t_gen_zext(TCGv d, TCGv s, int size)
1167 {
1168         /* TCG-FIXME: this is not optimal. Many archs have fast zext insns.  */
1169         if (size == 1)
1170                 tcg_gen_andi_i32(d, s, 0xff);
1171         else if (size == 2)
1172                 tcg_gen_andi_i32(d, s, 0xffff);
1173         else
1174                 tcg_gen_mov_tl(d, s);
1175 }
1176
1177 #if DISAS_CRIS
1178 static char memsize_char(int size)
1179 {
1180         switch (size)
1181         {
1182                 case 1: return 'b';  break;
1183                 case 2: return 'w';  break;
1184                 case 4: return 'd';  break;
1185                 default:
1186                         return 'x';
1187                         break;
1188         }
1189 }
1190 #endif
1191
1192 static unsigned int memsize_z(DisasContext *dc)
1193 {
1194         return dc->zsize + 1;
1195 }
1196
1197 static unsigned int memsize_zz(DisasContext *dc)
1198 {
1199         switch (dc->zzsize)
1200         {
1201                 case 0: return 1;
1202                 case 1: return 2;
1203                 default:
1204                         return 4;
1205         }
1206 }
1207
1208 static inline void do_postinc (DisasContext *dc, int size)
1209 {
1210         if (dc->postinc)
1211                 tcg_gen_addi_tl(cpu_R[dc->op1], cpu_R[dc->op1], size);
1212 }
1213
1214
1215 static void dec_prep_move_r(DisasContext *dc, int rs, int rd,
1216                             int size, int s_ext)
1217 {
1218         if (s_ext)
1219                 t_gen_sext(cpu_T[1], cpu_R[rs], size);
1220         else
1221                 t_gen_zext(cpu_T[1], cpu_R[rs], size);
1222 }
1223
1224 /* Prepare T0 and T1 for a register alu operation.
1225    s_ext decides if the operand1 should be sign-extended or zero-extended when
1226    needed.  */
1227 static void dec_prep_alu_r(DisasContext *dc, int rs, int rd,
1228                           int size, int s_ext)
1229 {
1230         dec_prep_move_r(dc, rs, rd, size, s_ext);
1231
1232         if (s_ext)
1233                 t_gen_sext(cpu_T[0], cpu_R[rd], size);
1234         else
1235                 t_gen_zext(cpu_T[0], cpu_R[rd], size);
1236 }
1237
1238 /* Prepare T0 and T1 for a memory + alu operation.
1239    s_ext decides if the operand1 should be sign-extended or zero-extended when
1240    needed.  */
1241 static int dec_prep_alu_m(DisasContext *dc, int s_ext, int memsize)
1242 {
1243         unsigned int rs, rd;
1244         uint32_t imm;
1245         int is_imm;
1246         int insn_len = 2;
1247
1248         rs = dc->op1;
1249         rd = dc->op2;
1250         is_imm = rs == 15 && dc->postinc;
1251
1252         /* Load [$rs] onto T1.  */
1253         if (is_imm) {
1254                 insn_len = 2 + memsize;
1255                 if (memsize == 1)
1256                         insn_len++;
1257
1258                 if (memsize != 4) {
1259                         if (s_ext) {
1260                                 if (memsize == 1)
1261                                         imm = ldsb_code(dc->pc + 2);
1262                                 else
1263                                         imm = ldsw_code(dc->pc + 2);
1264                         } else {
1265                                 if (memsize == 1)
1266                                         imm = ldub_code(dc->pc + 2);
1267                                 else
1268                                         imm = lduw_code(dc->pc + 2);
1269                         }
1270                 } else
1271                         imm = ldl_code(dc->pc + 2);
1272
1273                 DIS(fprintf (logfile, "imm=%x rd=%d sext=%d ms=%d\n",
1274                             imm, rd, s_ext, memsize));
1275                 tcg_gen_movi_tl(cpu_T[1], imm);
1276                 dc->postinc = 0;
1277         } else {
1278                 gen_load(dc, cpu_T[1], cpu_R[rs], memsize, 0);
1279                 if (s_ext)
1280                         t_gen_sext(cpu_T[1], cpu_T[1], memsize);
1281                 else
1282                         t_gen_zext(cpu_T[1], cpu_T[1], memsize);
1283         }
1284
1285         /* put dest in T0.  */
1286         t_gen_mov_TN_reg(cpu_T[0], rd);
1287         return insn_len;
1288 }
1289
1290 #if DISAS_CRIS
1291 static const char *cc_name(int cc)
1292 {
1293         static char *cc_names[16] = {
1294                 "cc", "cs", "ne", "eq", "vc", "vs", "pl", "mi",
1295                 "ls", "hi", "ge", "lt", "gt", "le", "a", "p"
1296         };
1297         assert(cc < 16);
1298         return cc_names[cc];
1299 }
1300 #endif
1301
1302 /* Start of insn decoders.  */
1303
1304 static unsigned int dec_bccq(DisasContext *dc)
1305 {
1306         int32_t offset;
1307         int sign;
1308         uint32_t cond = dc->op2;
1309         int tmp;
1310
1311         offset = EXTRACT_FIELD (dc->ir, 1, 7);
1312         sign = EXTRACT_FIELD(dc->ir, 0, 0);
1313
1314         offset *= 2;
1315         offset |= sign << 8;
1316         tmp = offset;
1317         offset = sign_extend(offset, 8);
1318
1319         /* op2 holds the condition-code.  */
1320         cris_cc_mask(dc, 0);
1321         cris_prepare_cc_branch (dc, offset, cond);
1322         return 2;
1323 }
1324 static unsigned int dec_addoq(DisasContext *dc)
1325 {
1326         int32_t imm;
1327
1328         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 7);
1329         imm = sign_extend(dc->op1, 7);
1330
1331         DIS(fprintf (logfile, "addoq %d, $r%u\n", imm, dc->op2));
1332         cris_cc_mask(dc, 0);
1333         /* Fetch register operand,  */
1334         tcg_gen_addi_tl(cpu_R[R_ACR], cpu_R[dc->op2], imm);
1335         return 2;
1336 }
1337 static unsigned int dec_addq(DisasContext *dc)
1338 {
1339         DIS(fprintf (logfile, "addq %u, $r%u\n", dc->op1, dc->op2));
1340
1341         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1342
1343         cris_cc_mask(dc, CC_MASK_NZVC);
1344         /* Fetch register operand,  */
1345         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1346         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1347         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, 4);
1348         return 2;
1349 }
1350 static unsigned int dec_moveq(DisasContext *dc)
1351 {
1352         uint32_t imm;
1353
1354         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1355         imm = sign_extend(dc->op1, 5);
1356         DIS(fprintf (logfile, "moveq %d, $r%u\n", imm, dc->op2));
1357
1358         t_gen_mov_reg_TN(dc->op2, tcg_const_tl(imm));
1359         return 2;
1360 }
1361 static unsigned int dec_subq(DisasContext *dc)
1362 {
1363         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1364
1365         DIS(fprintf (logfile, "subq %u, $r%u\n", dc->op1, dc->op2));
1366
1367         cris_cc_mask(dc, CC_MASK_NZVC);
1368         /* Fetch register operand,  */
1369         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1370         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1371         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
1372         return 2;
1373 }
1374 static unsigned int dec_cmpq(DisasContext *dc)
1375 {
1376         uint32_t imm;
1377         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1378         imm = sign_extend(dc->op1, 5);
1379
1380         DIS(fprintf (logfile, "cmpq %d, $r%d\n", imm, dc->op2));
1381         cris_cc_mask(dc, CC_MASK_NZVC);
1382         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1383         tcg_gen_movi_tl(cpu_T[1], imm);
1384         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, 4);
1385         return 2;
1386 }
1387 static unsigned int dec_andq(DisasContext *dc)
1388 {
1389         uint32_t imm;
1390         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1391         imm = sign_extend(dc->op1, 5);
1392
1393         DIS(fprintf (logfile, "andq %d, $r%d\n", imm, dc->op2));
1394         cris_cc_mask(dc, CC_MASK_NZ);
1395         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1396         tcg_gen_movi_tl(cpu_T[1], imm);
1397         crisv32_alu_op(dc, CC_OP_AND, dc->op2, 4);
1398         return 2;
1399 }
1400 static unsigned int dec_orq(DisasContext *dc)
1401 {
1402         uint32_t imm;
1403         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 5);
1404         imm = sign_extend(dc->op1, 5);
1405         DIS(fprintf (logfile, "orq %d, $r%d\n", imm, dc->op2));
1406         cris_cc_mask(dc, CC_MASK_NZ);
1407         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1408         tcg_gen_movi_tl(cpu_T[1], imm);
1409         crisv32_alu_op(dc, CC_OP_OR, dc->op2, 4);
1410         return 2;
1411 }
1412 static unsigned int dec_btstq(DisasContext *dc)
1413 {
1414         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1415         DIS(fprintf (logfile, "btstq %u, $r%d\n", dc->op1, dc->op2));
1416
1417         cris_cc_mask(dc, CC_MASK_NZ);
1418         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1419         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1420         crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4);
1421
1422         cris_update_cc_op(dc, CC_OP_FLAGS, 4);
1423         t_gen_mov_preg_TN(PR_CCS, cpu_T[0]);
1424         dc->flags_live = 1;
1425         return 2;
1426 }
1427 static unsigned int dec_asrq(DisasContext *dc)
1428 {
1429         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1430         DIS(fprintf (logfile, "asrq %u, $r%d\n", dc->op1, dc->op2));
1431         cris_cc_mask(dc, CC_MASK_NZ);
1432         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1433         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1434         crisv32_alu_op(dc, CC_OP_ASR, dc->op2, 4);
1435         return 2;
1436 }
1437 static unsigned int dec_lslq(DisasContext *dc)
1438 {
1439         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1440         DIS(fprintf (logfile, "lslq %u, $r%d\n", dc->op1, dc->op2));
1441
1442         cris_cc_mask(dc, CC_MASK_NZ);
1443         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1444         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1445         crisv32_alu_op(dc, CC_OP_LSL, dc->op2, 4);
1446         return 2;
1447 }
1448 static unsigned int dec_lsrq(DisasContext *dc)
1449 {
1450         dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);
1451         DIS(fprintf (logfile, "lsrq %u, $r%d\n", dc->op1, dc->op2));
1452
1453         cris_cc_mask(dc, CC_MASK_NZ);
1454         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1455         tcg_gen_movi_tl(cpu_T[1], dc->op1);
1456         crisv32_alu_op(dc, CC_OP_LSR, dc->op2, 4);
1457         return 2;
1458 }
1459
1460 static unsigned int dec_move_r(DisasContext *dc)
1461 {
1462         int size = memsize_zz(dc);
1463
1464         DIS(fprintf (logfile, "move.%c $r%u, $r%u\n",
1465                     memsize_char(size), dc->op1, dc->op2));
1466
1467         cris_cc_mask(dc, CC_MASK_NZ);
1468         dec_prep_move_r(dc, dc->op1, dc->op2, size, 0);
1469         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, size);
1470         return 2;
1471 }
1472
1473 static unsigned int dec_scc_r(DisasContext *dc)
1474 {
1475         int cond = dc->op2;
1476
1477         DIS(fprintf (logfile, "s%s $r%u\n",
1478                     cc_name(cond), dc->op1));
1479
1480         if (cond != CC_A)
1481         {
1482                 int l1;
1483
1484                 gen_tst_cc (dc, cond);
1485
1486                 l1 = gen_new_label();
1487                 tcg_gen_movi_tl(cpu_R[dc->op1], 0);
1488                 tcg_gen_brcond_tl(TCG_COND_EQ, cpu_T[0], tcg_const_tl(0), l1);
1489                 tcg_gen_movi_tl(cpu_R[dc->op1], 1);
1490                 gen_set_label(l1);
1491         }
1492         else
1493                 tcg_gen_movi_tl(cpu_R[dc->op1], 1);
1494
1495         cris_cc_mask(dc, 0);
1496         return 2;
1497 }
1498
1499 static unsigned int dec_and_r(DisasContext *dc)
1500 {
1501         int size = memsize_zz(dc);
1502
1503         DIS(fprintf (logfile, "and.%c $r%u, $r%u\n",
1504                     memsize_char(size), dc->op1, dc->op2));
1505         cris_cc_mask(dc, CC_MASK_NZ);
1506         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1507         crisv32_alu_op(dc, CC_OP_AND, dc->op2, size);
1508         return 2;
1509 }
1510
1511 static unsigned int dec_lz_r(DisasContext *dc)
1512 {
1513         DIS(fprintf (logfile, "lz $r%u, $r%u\n",
1514                     dc->op1, dc->op2));
1515         cris_cc_mask(dc, CC_MASK_NZ);
1516         dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1517         crisv32_alu_op(dc, CC_OP_LZ, dc->op2, 4);
1518         return 2;
1519 }
1520
1521 static unsigned int dec_lsl_r(DisasContext *dc)
1522 {
1523         int size = memsize_zz(dc);
1524
1525         DIS(fprintf (logfile, "lsl.%c $r%u, $r%u\n",
1526                     memsize_char(size), dc->op1, dc->op2));
1527         cris_cc_mask(dc, CC_MASK_NZ);
1528         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1529         tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1530         crisv32_alu_op(dc, CC_OP_LSL, dc->op2, size);
1531         return 2;
1532 }
1533
1534 static unsigned int dec_lsr_r(DisasContext *dc)
1535 {
1536         int size = memsize_zz(dc);
1537
1538         DIS(fprintf (logfile, "lsr.%c $r%u, $r%u\n",
1539                     memsize_char(size), dc->op1, dc->op2));
1540         cris_cc_mask(dc, CC_MASK_NZ);
1541         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1542         tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1543         crisv32_alu_op(dc, CC_OP_LSR, dc->op2, size);
1544         return 2;
1545 }
1546
1547 static unsigned int dec_asr_r(DisasContext *dc)
1548 {
1549         int size = memsize_zz(dc);
1550
1551         DIS(fprintf (logfile, "asr.%c $r%u, $r%u\n",
1552                     memsize_char(size), dc->op1, dc->op2));
1553         cris_cc_mask(dc, CC_MASK_NZ);
1554         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1);
1555         tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1556         crisv32_alu_op(dc, CC_OP_ASR, dc->op2, size);
1557         return 2;
1558 }
1559
1560 static unsigned int dec_muls_r(DisasContext *dc)
1561 {
1562         int size = memsize_zz(dc);
1563
1564         DIS(fprintf (logfile, "muls.%c $r%u, $r%u\n",
1565                     memsize_char(size), dc->op1, dc->op2));
1566         cris_cc_mask(dc, CC_MASK_NZV);
1567         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1);
1568         t_gen_sext(cpu_T[0], cpu_T[0], size);
1569         crisv32_alu_op(dc, CC_OP_MULS, dc->op2, 4);
1570         return 2;
1571 }
1572
1573 static unsigned int dec_mulu_r(DisasContext *dc)
1574 {
1575         int size = memsize_zz(dc);
1576
1577         DIS(fprintf (logfile, "mulu.%c $r%u, $r%u\n",
1578                     memsize_char(size), dc->op1, dc->op2));
1579         cris_cc_mask(dc, CC_MASK_NZV);
1580         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1581         t_gen_zext(cpu_T[0], cpu_T[0], size);
1582         crisv32_alu_op(dc, CC_OP_MULU, dc->op2, 4);
1583         return 2;
1584 }
1585
1586
1587 static unsigned int dec_dstep_r(DisasContext *dc)
1588 {
1589         DIS(fprintf (logfile, "dstep $r%u, $r%u\n", dc->op1, dc->op2));
1590         cris_cc_mask(dc, CC_MASK_NZ);
1591         t_gen_mov_TN_reg(cpu_T[1], dc->op1);
1592         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1593         crisv32_alu_op(dc, CC_OP_DSTEP, dc->op2, 4);
1594         return 2;
1595 }
1596
1597 static unsigned int dec_xor_r(DisasContext *dc)
1598 {
1599         int size = memsize_zz(dc);
1600         DIS(fprintf (logfile, "xor.%c $r%u, $r%u\n",
1601                     memsize_char(size), dc->op1, dc->op2));
1602         BUG_ON(size != 4); /* xor is dword.  */
1603         cris_cc_mask(dc, CC_MASK_NZ);
1604         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1605         crisv32_alu_op(dc, CC_OP_XOR, dc->op2, 4);
1606         return 2;
1607 }
1608
1609 static unsigned int dec_bound_r(DisasContext *dc)
1610 {
1611         int size = memsize_zz(dc);
1612         DIS(fprintf (logfile, "bound.%c $r%u, $r%u\n",
1613                     memsize_char(size), dc->op1, dc->op2));
1614         cris_cc_mask(dc, CC_MASK_NZ);
1615         /* TODO: needs optmimization.  */
1616         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1617         /* rd should be 4.  */
1618         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1619         crisv32_alu_op(dc, CC_OP_BOUND, dc->op2, 4);
1620         return 2;
1621 }
1622
1623 static unsigned int dec_cmp_r(DisasContext *dc)
1624 {
1625         int size = memsize_zz(dc);
1626         DIS(fprintf (logfile, "cmp.%c $r%u, $r%u\n",
1627                     memsize_char(size), dc->op1, dc->op2));
1628         cris_cc_mask(dc, CC_MASK_NZVC);
1629         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1630         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, size);
1631         return 2;
1632 }
1633
1634 static unsigned int dec_abs_r(DisasContext *dc)
1635 {
1636         int l1;
1637
1638         DIS(fprintf (logfile, "abs $r%u, $r%u\n",
1639                     dc->op1, dc->op2));
1640         cris_cc_mask(dc, CC_MASK_NZ);
1641         dec_prep_move_r(dc, dc->op1, dc->op2, 4, 0);
1642
1643         /* TODO: consider a branch free approach.  */
1644         l1 = gen_new_label();
1645         tcg_gen_brcond_tl(TCG_COND_GE, cpu_T[1], tcg_const_tl(0), l1);
1646         tcg_gen_sub_tl(cpu_T[1], tcg_const_tl(0), cpu_T[1]);
1647         gen_set_label(l1);
1648         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
1649         return 2;
1650 }
1651
1652 static unsigned int dec_add_r(DisasContext *dc)
1653 {
1654         int size = memsize_zz(dc);
1655         DIS(fprintf (logfile, "add.%c $r%u, $r%u\n",
1656                     memsize_char(size), dc->op1, dc->op2));
1657         cris_cc_mask(dc, CC_MASK_NZVC);
1658         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1659         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, size);
1660         return 2;
1661 }
1662
1663 static unsigned int dec_addc_r(DisasContext *dc)
1664 {
1665         DIS(fprintf (logfile, "addc $r%u, $r%u\n",
1666                     dc->op1, dc->op2));
1667         cris_evaluate_flags(dc);
1668         cris_cc_mask(dc, CC_MASK_NZVC);
1669         dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1670         crisv32_alu_op(dc, CC_OP_ADDC, dc->op2, 4);
1671         return 2;
1672 }
1673
1674 static unsigned int dec_mcp_r(DisasContext *dc)
1675 {
1676         DIS(fprintf (logfile, "mcp $p%u, $r%u\n",
1677                      dc->op2, dc->op1));
1678         cris_evaluate_flags(dc);
1679         cris_cc_mask(dc, CC_MASK_RNZV);
1680         t_gen_mov_TN_reg(cpu_T[0], dc->op1);
1681         t_gen_mov_TN_preg(cpu_T[1], dc->op2);
1682         crisv32_alu_op(dc, CC_OP_MCP, dc->op1, 4);
1683         return 2;
1684 }
1685
1686 #if DISAS_CRIS
1687 static char * swapmode_name(int mode, char *modename) {
1688         int i = 0;
1689         if (mode & 8)
1690                 modename[i++] = 'n';
1691         if (mode & 4)
1692                 modename[i++] = 'w';
1693         if (mode & 2)
1694                 modename[i++] = 'b';
1695         if (mode & 1)
1696                 modename[i++] = 'r';
1697         modename[i++] = 0;
1698         return modename;
1699 }
1700 #endif
1701
1702 static unsigned int dec_swap_r(DisasContext *dc)
1703 {
1704         DIS(char modename[4]);
1705         DIS(fprintf (logfile, "swap%s $r%u\n",
1706                      swapmode_name(dc->op2, modename), dc->op1));
1707
1708         cris_cc_mask(dc, CC_MASK_NZ);
1709         t_gen_mov_TN_reg(cpu_T[0], dc->op1);
1710         if (dc->op2 & 8)
1711                 tcg_gen_xori_tl(cpu_T[0], cpu_T[0], -1);
1712         if (dc->op2 & 4)
1713                 t_gen_swapw(cpu_T[0], cpu_T[0]);
1714         if (dc->op2 & 2)
1715                 t_gen_swapb(cpu_T[0], cpu_T[0]);
1716         if (dc->op2 & 1)
1717                 t_gen_swapr(cpu_T[0], cpu_T[0]);
1718         tcg_gen_mov_tl(cpu_T[1], cpu_T[0]);
1719         crisv32_alu_op(dc, CC_OP_MOVE, dc->op1, 4);
1720         return 2;
1721 }
1722
1723 static unsigned int dec_or_r(DisasContext *dc)
1724 {
1725         int size = memsize_zz(dc);
1726         DIS(fprintf (logfile, "or.%c $r%u, $r%u\n",
1727                     memsize_char(size), dc->op1, dc->op2));
1728         cris_cc_mask(dc, CC_MASK_NZ);
1729         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1730         crisv32_alu_op(dc, CC_OP_OR, dc->op2, size);
1731         return 2;
1732 }
1733
1734 static unsigned int dec_addi_r(DisasContext *dc)
1735 {
1736         DIS(fprintf (logfile, "addi.%c $r%u, $r%u\n",
1737                     memsize_char(memsize_zz(dc)), dc->op2, dc->op1));
1738         cris_cc_mask(dc, 0);
1739         dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1740         t_gen_lsl(cpu_T[0], cpu_T[0], tcg_const_tl(dc->zzsize));
1741         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1742         t_gen_mov_reg_TN(dc->op1, cpu_T[0]);
1743         return 2;
1744 }
1745
1746 static unsigned int dec_addi_acr(DisasContext *dc)
1747 {
1748         DIS(fprintf (logfile, "addi.%c $r%u, $r%u, $acr\n",
1749                   memsize_char(memsize_zz(dc)), dc->op2, dc->op1));
1750         cris_cc_mask(dc, 0);
1751         dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1752         t_gen_lsl(cpu_T[0], cpu_T[0], tcg_const_tl(dc->zzsize));
1753
1754         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1755         t_gen_mov_reg_TN(R_ACR, cpu_T[0]);
1756         return 2;
1757 }
1758
1759 static unsigned int dec_neg_r(DisasContext *dc)
1760 {
1761         int size = memsize_zz(dc);
1762         DIS(fprintf (logfile, "neg.%c $r%u, $r%u\n",
1763                     memsize_char(size), dc->op1, dc->op2));
1764         cris_cc_mask(dc, CC_MASK_NZVC);
1765         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1766         crisv32_alu_op(dc, CC_OP_NEG, dc->op2, size);
1767         return 2;
1768 }
1769
1770 static unsigned int dec_btst_r(DisasContext *dc)
1771 {
1772         DIS(fprintf (logfile, "btst $r%u, $r%u\n",
1773                     dc->op1, dc->op2));
1774         cris_cc_mask(dc, CC_MASK_NZ);
1775         dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1776         crisv32_alu_op(dc, CC_OP_BTST, dc->op2, 4);
1777
1778         cris_update_cc_op(dc, CC_OP_FLAGS, 4);
1779         t_gen_mov_preg_TN(PR_CCS, cpu_T[0]);
1780         dc->flags_live = 1;
1781         return 2;
1782 }
1783
1784 static unsigned int dec_sub_r(DisasContext *dc)
1785 {
1786         int size = memsize_zz(dc);
1787         DIS(fprintf (logfile, "sub.%c $r%u, $r%u\n",
1788                     memsize_char(size), dc->op1, dc->op2));
1789         cris_cc_mask(dc, CC_MASK_NZVC);
1790         dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1791         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, size);
1792         return 2;
1793 }
1794
1795 /* Zero extension. From size to dword.  */
1796 static unsigned int dec_movu_r(DisasContext *dc)
1797 {
1798         int size = memsize_z(dc);
1799         DIS(fprintf (logfile, "movu.%c $r%u, $r%u\n",
1800                     memsize_char(size),
1801                     dc->op1, dc->op2));
1802
1803         cris_cc_mask(dc, CC_MASK_NZ);
1804         dec_prep_move_r(dc, dc->op1, dc->op2, size, 0);
1805         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
1806         return 2;
1807 }
1808
1809 /* Sign extension. From size to dword.  */
1810 static unsigned int dec_movs_r(DisasContext *dc)
1811 {
1812         int size = memsize_z(dc);
1813         DIS(fprintf (logfile, "movs.%c $r%u, $r%u\n",
1814                     memsize_char(size),
1815                     dc->op1, dc->op2));
1816
1817         cris_cc_mask(dc, CC_MASK_NZ);
1818         t_gen_mov_TN_reg(cpu_T[0], dc->op1);
1819         /* Size can only be qi or hi.  */
1820         t_gen_sext(cpu_T[1], cpu_T[0], size);
1821         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
1822         return 2;
1823 }
1824
1825 /* zero extension. From size to dword.  */
1826 static unsigned int dec_addu_r(DisasContext *dc)
1827 {
1828         int size = memsize_z(dc);
1829         DIS(fprintf (logfile, "addu.%c $r%u, $r%u\n",
1830                     memsize_char(size),
1831                     dc->op1, dc->op2));
1832
1833         cris_cc_mask(dc, CC_MASK_NZVC);
1834         t_gen_mov_TN_reg(cpu_T[1], dc->op1);
1835         /* Size can only be qi or hi.  */
1836         t_gen_zext(cpu_T[1], cpu_T[1], size);
1837         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1838         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, 4);
1839         return 2;
1840 }
1841
1842 /* Sign extension. From size to dword.  */
1843 static unsigned int dec_adds_r(DisasContext *dc)
1844 {
1845         int size = memsize_z(dc);
1846         DIS(fprintf (logfile, "adds.%c $r%u, $r%u\n",
1847                     memsize_char(size),
1848                     dc->op1, dc->op2));
1849
1850         cris_cc_mask(dc, CC_MASK_NZVC);
1851         t_gen_mov_TN_reg(cpu_T[1], dc->op1);
1852         /* Size can only be qi or hi.  */
1853         t_gen_sext(cpu_T[1], cpu_T[1], size);
1854         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1855
1856         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, 4);
1857         return 2;
1858 }
1859
1860 /* Zero extension. From size to dword.  */
1861 static unsigned int dec_subu_r(DisasContext *dc)
1862 {
1863         int size = memsize_z(dc);
1864         DIS(fprintf (logfile, "subu.%c $r%u, $r%u\n",
1865                     memsize_char(size),
1866                     dc->op1, dc->op2));
1867
1868         cris_cc_mask(dc, CC_MASK_NZVC);
1869         t_gen_mov_TN_reg(cpu_T[1], dc->op1);
1870         /* Size can only be qi or hi.  */
1871         t_gen_zext(cpu_T[1], cpu_T[1], size);
1872         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1873         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
1874         return 2;
1875 }
1876
1877 /* Sign extension. From size to dword.  */
1878 static unsigned int dec_subs_r(DisasContext *dc)
1879 {
1880         int size = memsize_z(dc);
1881         DIS(fprintf (logfile, "subs.%c $r%u, $r%u\n",
1882                     memsize_char(size),
1883                     dc->op1, dc->op2));
1884
1885         cris_cc_mask(dc, CC_MASK_NZVC);
1886         t_gen_mov_TN_reg(cpu_T[1], dc->op1);
1887         /* Size can only be qi or hi.  */
1888         t_gen_sext(cpu_T[1], cpu_T[1], size);
1889         t_gen_mov_TN_reg(cpu_T[0], dc->op2);
1890         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
1891         return 2;
1892 }
1893
1894 static unsigned int dec_setclrf(DisasContext *dc)
1895 {
1896         uint32_t flags;
1897         int set = (~dc->opcode >> 2) & 1;
1898
1899         flags = (EXTRACT_FIELD(dc->ir, 12, 15) << 4)
1900                 | EXTRACT_FIELD(dc->ir, 0, 3);
1901         DIS(fprintf (logfile, "set=%d flags=%x\n", set, flags));
1902         if (set && flags == 0)
1903                 DIS(fprintf (logfile, "nop\n"));
1904         else if (!set && (flags & 0x20))
1905                 DIS(fprintf (logfile, "di\n"));
1906         else
1907                 DIS(fprintf (logfile, "%sf %x\n",
1908                             set ? "set" : "clr",
1909                             flags));
1910
1911         if (set && (flags & X_FLAG)) {
1912                 dc->flagx_live = 1;
1913                 dc->flags_x = 1;
1914         }
1915
1916         /* Simply decode the flags.  */
1917         cris_evaluate_flags (dc);
1918         cris_update_cc_op(dc, CC_OP_FLAGS, 4);
1919         tcg_gen_movi_tl(cc_op, dc->cc_op);
1920
1921         if (set) {
1922                 if (!dc->user && (flags & U_FLAG)) {
1923                         /* Enter user mode.  */
1924                         t_gen_mov_env_TN(ksp, cpu_R[R_SP]);
1925                         tcg_gen_mov_tl(cpu_R[R_SP], cpu_PR[PR_USP]);
1926                         dc->is_jmp = DISAS_UPDATE;
1927                 }
1928                 tcg_gen_ori_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], flags);
1929         }
1930         else
1931                 tcg_gen_andi_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], ~flags);
1932
1933         dc->flags_live = 1;
1934         dc->clear_x = 0;
1935         return 2;
1936 }
1937
1938 static unsigned int dec_move_rs(DisasContext *dc)
1939 {
1940         DIS(fprintf (logfile, "move $r%u, $s%u\n", dc->op1, dc->op2));
1941         cris_cc_mask(dc, 0);
1942         tcg_gen_helper_0_2(helper_movl_sreg_reg,
1943                            tcg_const_tl(dc->op2), tcg_const_tl(dc->op1));
1944         return 2;
1945 }
1946 static unsigned int dec_move_sr(DisasContext *dc)
1947 {
1948         DIS(fprintf (logfile, "move $s%u, $r%u\n", dc->op2, dc->op1));
1949         cris_cc_mask(dc, 0);
1950         tcg_gen_helper_0_2(helper_movl_reg_sreg,
1951                            tcg_const_tl(dc->op1), tcg_const_tl(dc->op2));
1952         return 2;
1953 }
1954
1955 static unsigned int dec_move_rp(DisasContext *dc)
1956 {
1957         DIS(fprintf (logfile, "move $r%u, $p%u\n", dc->op1, dc->op2));
1958         cris_cc_mask(dc, 0);
1959
1960         if (dc->op2 == PR_CCS) {
1961                 cris_evaluate_flags(dc);
1962                 t_gen_mov_TN_reg(cpu_T[0], dc->op1);
1963                 if (dc->user) {
1964                         /* User space is not allowed to touch all flags.  */
1965                         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0x39f);
1966                         tcg_gen_andi_tl(cpu_T[1], cpu_PR[PR_CCS], ~0x39f);
1967                         tcg_gen_or_tl(cpu_T[0], cpu_T[1], cpu_T[0]);
1968                 }
1969         }
1970         else
1971                 t_gen_mov_TN_reg(cpu_T[0], dc->op1);
1972
1973         t_gen_mov_preg_TN(dc->op2, cpu_T[0]);
1974         if (dc->op2 == PR_CCS) {
1975                 cris_update_cc_op(dc, CC_OP_FLAGS, 4);
1976                 dc->flags_live = 1;
1977         }
1978         return 2;
1979 }
1980 static unsigned int dec_move_pr(DisasContext *dc)
1981 {
1982         DIS(fprintf (logfile, "move $p%u, $r%u\n", dc->op1, dc->op2));
1983         cris_cc_mask(dc, 0);
1984         /* Support register 0 is hardwired to zero.
1985            Treat it specially. */
1986         if (dc->op2 == 0)
1987                 tcg_gen_movi_tl(cpu_T[1], 0);
1988         else if (dc->op2 == PR_CCS) {
1989                 cris_evaluate_flags(dc);
1990                 t_gen_mov_TN_preg(cpu_T[1], dc->op2);
1991         } else
1992                 t_gen_mov_TN_preg(cpu_T[1], dc->op2);
1993         crisv32_alu_op(dc, CC_OP_MOVE, dc->op1, preg_sizes[dc->op2]);
1994         return 2;
1995 }
1996
1997 static unsigned int dec_move_mr(DisasContext *dc)
1998 {
1999         int memsize = memsize_zz(dc);
2000         int insn_len;
2001         DIS(fprintf (logfile, "move.%c [$r%u%s, $r%u\n",
2002                     memsize_char(memsize),
2003                     dc->op1, dc->postinc ? "+]" : "]",
2004                     dc->op2));
2005
2006         insn_len = dec_prep_alu_m(dc, 0, memsize);
2007         cris_cc_mask(dc, CC_MASK_NZ);
2008         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, memsize);
2009         do_postinc(dc, memsize);
2010         return insn_len;
2011 }
2012
2013 static unsigned int dec_movs_m(DisasContext *dc)
2014 {
2015         int memsize = memsize_z(dc);
2016         int insn_len;
2017         DIS(fprintf (logfile, "movs.%c [$r%u%s, $r%u\n",
2018                     memsize_char(memsize),
2019                     dc->op1, dc->postinc ? "+]" : "]",
2020                     dc->op2));
2021
2022         /* sign extend.  */
2023         insn_len = dec_prep_alu_m(dc, 1, memsize);
2024         cris_cc_mask(dc, CC_MASK_NZ);
2025         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
2026         do_postinc(dc, memsize);
2027         return insn_len;
2028 }
2029
2030 static unsigned int dec_addu_m(DisasContext *dc)
2031 {
2032         int memsize = memsize_z(dc);
2033         int insn_len;
2034         DIS(fprintf (logfile, "addu.%c [$r%u%s, $r%u\n",
2035                     memsize_char(memsize),
2036                     dc->op1, dc->postinc ? "+]" : "]",
2037                     dc->op2));
2038
2039         /* sign extend.  */
2040         insn_len = dec_prep_alu_m(dc, 0, memsize);
2041         cris_cc_mask(dc, CC_MASK_NZVC);
2042         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, 4);
2043         do_postinc(dc, memsize);
2044         return insn_len;
2045 }
2046
2047 static unsigned int dec_adds_m(DisasContext *dc)
2048 {
2049         int memsize = memsize_z(dc);
2050         int insn_len;
2051         DIS(fprintf (logfile, "adds.%c [$r%u%s, $r%u\n",
2052                     memsize_char(memsize),
2053                     dc->op1, dc->postinc ? "+]" : "]",
2054                     dc->op2));
2055
2056         /* sign extend.  */
2057         insn_len = dec_prep_alu_m(dc, 1, memsize);
2058         cris_cc_mask(dc, CC_MASK_NZVC);
2059         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, 4);
2060         do_postinc(dc, memsize);
2061         return insn_len;
2062 }
2063
2064 static unsigned int dec_subu_m(DisasContext *dc)
2065 {
2066         int memsize = memsize_z(dc);
2067         int insn_len;
2068         DIS(fprintf (logfile, "subu.%c [$r%u%s, $r%u\n",
2069                     memsize_char(memsize),
2070                     dc->op1, dc->postinc ? "+]" : "]",
2071                     dc->op2));
2072
2073         /* sign extend.  */
2074         insn_len = dec_prep_alu_m(dc, 0, memsize);
2075         cris_cc_mask(dc, CC_MASK_NZVC);
2076         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
2077         do_postinc(dc, memsize);
2078         return insn_len;
2079 }
2080
2081 static unsigned int dec_subs_m(DisasContext *dc)
2082 {
2083         int memsize = memsize_z(dc);
2084         int insn_len;
2085         DIS(fprintf (logfile, "subs.%c [$r%u%s, $r%u\n",
2086                     memsize_char(memsize),
2087                     dc->op1, dc->postinc ? "+]" : "]",
2088                     dc->op2));
2089
2090         /* sign extend.  */
2091         insn_len = dec_prep_alu_m(dc, 1, memsize);
2092         cris_cc_mask(dc, CC_MASK_NZVC);
2093         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, 4);
2094         do_postinc(dc, memsize);
2095         return insn_len;
2096 }
2097
2098 static unsigned int dec_movu_m(DisasContext *dc)
2099 {
2100         int memsize = memsize_z(dc);
2101         int insn_len;
2102
2103         DIS(fprintf (logfile, "movu.%c [$r%u%s, $r%u\n",
2104                     memsize_char(memsize),
2105                     dc->op1, dc->postinc ? "+]" : "]",
2106                     dc->op2));
2107
2108         insn_len = dec_prep_alu_m(dc, 0, memsize);
2109         cris_cc_mask(dc, CC_MASK_NZ);
2110         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
2111         do_postinc(dc, memsize);
2112         return insn_len;
2113 }
2114
2115 static unsigned int dec_cmpu_m(DisasContext *dc)
2116 {
2117         int memsize = memsize_z(dc);
2118         int insn_len;
2119         DIS(fprintf (logfile, "cmpu.%c [$r%u%s, $r%u\n",
2120                     memsize_char(memsize),
2121                     dc->op1, dc->postinc ? "+]" : "]",
2122                     dc->op2));
2123
2124         insn_len = dec_prep_alu_m(dc, 0, memsize);
2125         cris_cc_mask(dc, CC_MASK_NZVC);
2126         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, 4);
2127         do_postinc(dc, memsize);
2128         return insn_len;
2129 }
2130
2131 static unsigned int dec_cmps_m(DisasContext *dc)
2132 {
2133         int memsize = memsize_z(dc);
2134         int insn_len;
2135         DIS(fprintf (logfile, "cmps.%c [$r%u%s, $r%u\n",
2136                     memsize_char(memsize),
2137                     dc->op1, dc->postinc ? "+]" : "]",
2138                     dc->op2));
2139
2140         insn_len = dec_prep_alu_m(dc, 1, memsize);
2141         cris_cc_mask(dc, CC_MASK_NZVC);
2142         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, memsize_zz(dc));
2143         do_postinc(dc, memsize);
2144         return insn_len;
2145 }
2146
2147 static unsigned int dec_cmp_m(DisasContext *dc)
2148 {
2149         int memsize = memsize_zz(dc);
2150         int insn_len;
2151         DIS(fprintf (logfile, "cmp.%c [$r%u%s, $r%u\n",
2152                     memsize_char(memsize),
2153                     dc->op1, dc->postinc ? "+]" : "]",
2154                     dc->op2));
2155
2156         insn_len = dec_prep_alu_m(dc, 0, memsize);
2157         cris_cc_mask(dc, CC_MASK_NZVC);
2158         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, memsize_zz(dc));
2159         do_postinc(dc, memsize);
2160         return insn_len;
2161 }
2162
2163 static unsigned int dec_test_m(DisasContext *dc)
2164 {
2165         int memsize = memsize_zz(dc);
2166         int insn_len;
2167         DIS(fprintf (logfile, "test.%d [$r%u%s] op2=%x\n",
2168                     memsize_char(memsize),
2169                     dc->op1, dc->postinc ? "+]" : "]",
2170                     dc->op2));
2171
2172         cris_evaluate_flags(dc);
2173
2174         insn_len = dec_prep_alu_m(dc, 0, memsize);
2175         cris_cc_mask(dc, CC_MASK_NZ);
2176         tcg_gen_andi_tl(cpu_PR[PR_CCS], cpu_PR[PR_CCS], ~3);
2177
2178         tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
2179         tcg_gen_movi_tl(cpu_T[1], 0);
2180         crisv32_alu_op(dc, CC_OP_CMP, dc->op2, memsize_zz(dc));
2181         do_postinc(dc, memsize);
2182         return insn_len;
2183 }
2184
2185 static unsigned int dec_and_m(DisasContext *dc)
2186 {
2187         int memsize = memsize_zz(dc);
2188         int insn_len;
2189         DIS(fprintf (logfile, "and.%d [$r%u%s, $r%u\n",
2190                     memsize_char(memsize),
2191                     dc->op1, dc->postinc ? "+]" : "]",
2192                     dc->op2));
2193
2194         insn_len = dec_prep_alu_m(dc, 0, memsize);
2195         cris_cc_mask(dc, CC_MASK_NZ);
2196         crisv32_alu_op(dc, CC_OP_AND, dc->op2, memsize_zz(dc));
2197         do_postinc(dc, memsize);
2198         return insn_len;
2199 }
2200
2201 static unsigned int dec_add_m(DisasContext *dc)
2202 {
2203         int memsize = memsize_zz(dc);
2204         int insn_len;
2205         DIS(fprintf (logfile, "add.%d [$r%u%s, $r%u\n",
2206                     memsize_char(memsize),
2207                     dc->op1, dc->postinc ? "+]" : "]",
2208                     dc->op2));
2209
2210         insn_len = dec_prep_alu_m(dc, 0, memsize);
2211         cris_cc_mask(dc, CC_MASK_NZVC);
2212         crisv32_alu_op(dc, CC_OP_ADD, dc->op2, memsize_zz(dc));
2213         do_postinc(dc, memsize);
2214         return insn_len;
2215 }
2216
2217 static unsigned int dec_addo_m(DisasContext *dc)
2218 {
2219         int memsize = memsize_zz(dc);
2220         int insn_len;
2221         DIS(fprintf (logfile, "add.%d [$r%u%s, $r%u\n",
2222                     memsize_char(memsize),
2223                     dc->op1, dc->postinc ? "+]" : "]",
2224                     dc->op2));
2225
2226         insn_len = dec_prep_alu_m(dc, 1, memsize);
2227         cris_cc_mask(dc, 0);
2228         crisv32_alu_op(dc, CC_OP_ADD, R_ACR, 4);
2229         do_postinc(dc, memsize);
2230         return insn_len;
2231 }
2232
2233 static unsigned int dec_bound_m(DisasContext *dc)
2234 {
2235         int memsize = memsize_zz(dc);
2236         int insn_len;
2237         DIS(fprintf (logfile, "bound.%d [$r%u%s, $r%u\n",
2238                     memsize_char(memsize),
2239                     dc->op1, dc->postinc ? "+]" : "]",
2240                     dc->op2));
2241
2242         insn_len = dec_prep_alu_m(dc, 0, memsize);
2243         cris_cc_mask(dc, CC_MASK_NZ);
2244         crisv32_alu_op(dc, CC_OP_BOUND, dc->op2, 4);
2245         do_postinc(dc, memsize);
2246         return insn_len;
2247 }
2248
2249 static unsigned int dec_addc_mr(DisasContext *dc)
2250 {
2251         int insn_len = 2;
2252         DIS(fprintf (logfile, "addc [$r%u%s, $r%u\n",
2253                     dc->op1, dc->postinc ? "+]" : "]",
2254                     dc->op2));
2255
2256         cris_evaluate_flags(dc);
2257         insn_len = dec_prep_alu_m(dc, 0, 4);
2258         cris_cc_mask(dc, CC_MASK_NZVC);
2259         crisv32_alu_op(dc, CC_OP_ADDC, dc->op2, 4);
2260         do_postinc(dc, 4);
2261         return insn_len;
2262 }
2263
2264 static unsigned int dec_sub_m(DisasContext *dc)
2265 {
2266         int memsize = memsize_zz(dc);
2267         int insn_len;
2268         DIS(fprintf (logfile, "sub.%c [$r%u%s, $r%u ir=%x zz=%x\n",
2269                     memsize_char(memsize),
2270                     dc->op1, dc->postinc ? "+]" : "]",
2271                     dc->op2, dc->ir, dc->zzsize));
2272
2273         insn_len = dec_prep_alu_m(dc, 0, memsize);
2274         cris_cc_mask(dc, CC_MASK_NZVC);
2275         crisv32_alu_op(dc, CC_OP_SUB, dc->op2, memsize);
2276         do_postinc(dc, memsize);
2277         return insn_len;
2278 }
2279
2280 static unsigned int dec_or_m(DisasContext *dc)
2281 {
2282         int memsize = memsize_zz(dc);
2283         int insn_len;
2284         DIS(fprintf (logfile, "or.%d [$r%u%s, $r%u pc=%x\n",
2285                     memsize_char(memsize),
2286                     dc->op1, dc->postinc ? "+]" : "]",
2287                     dc->op2, dc->pc));
2288
2289         insn_len = dec_prep_alu_m(dc, 0, memsize);
2290         cris_cc_mask(dc, CC_MASK_NZ);
2291         crisv32_alu_op(dc, CC_OP_OR, dc->op2, memsize_zz(dc));
2292         do_postinc(dc, memsize);
2293         return insn_len;
2294 }
2295
2296 static unsigned int dec_move_mp(DisasContext *dc)
2297 {
2298         int memsize = memsize_zz(dc);
2299         int insn_len = 2;
2300
2301         DIS(fprintf (logfile, "move.%c [$r%u%s, $p%u\n",
2302                     memsize_char(memsize),
2303                     dc->op1,
2304                     dc->postinc ? "+]" : "]",
2305                     dc->op2));
2306
2307         insn_len = dec_prep_alu_m(dc, 0, memsize);
2308         cris_cc_mask(dc, 0);
2309         if (dc->op2 == PR_CCS) {
2310                 cris_evaluate_flags(dc);
2311                 if (dc->user) {
2312                         /* User space is not allowed to touch all flags.  */
2313                         tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 0x39f);
2314                         tcg_gen_andi_tl(cpu_T[0], cpu_PR[PR_CCS], ~0x39f);
2315                         tcg_gen_or_tl(cpu_T[1], cpu_T[0], cpu_T[1]);
2316                 }
2317         }
2318
2319         t_gen_mov_preg_TN(dc->op2, cpu_T[1]);
2320
2321         do_postinc(dc, memsize);
2322         return insn_len;
2323 }
2324
2325 static unsigned int dec_move_pm(DisasContext *dc)
2326 {
2327         int memsize;
2328
2329         memsize = preg_sizes[dc->op2];
2330
2331         DIS(fprintf (logfile, "move.%c $p%u, [$r%u%s\n",
2332                      memsize_char(memsize),
2333                      dc->op2, dc->op1, dc->postinc ? "+]" : "]"));
2334
2335         /* prepare store. Address in T0, value in T1.  */
2336         if (dc->op2 == PR_CCS)
2337                 cris_evaluate_flags(dc);
2338         t_gen_mov_TN_preg(cpu_T[1], dc->op2);
2339
2340         gen_store(dc, cpu_R[dc->op1], cpu_T[1], memsize);
2341
2342         cris_cc_mask(dc, 0);
2343         if (dc->postinc)
2344                 tcg_gen_addi_tl(cpu_R[dc->op1], cpu_R[dc->op1], memsize);
2345         return 2;
2346 }
2347
2348 static unsigned int dec_movem_mr(DisasContext *dc)
2349 {
2350         TCGv tmp[16];
2351         int i;
2352
2353         DIS(fprintf (logfile, "movem [$r%u%s, $r%u\n", dc->op1,
2354                     dc->postinc ? "+]" : "]", dc->op2));
2355
2356         /* fetch the address into T0 and T1.  */
2357         for (i = 0; i <= dc->op2; i++) {
2358                 tmp[i] = tcg_temp_new(TCG_TYPE_TL);
2359                 /* Perform the load onto regnum i. Always dword wide.  */
2360                 tcg_gen_addi_tl(cpu_T[0], cpu_R[dc->op1], i * 4);
2361                 gen_load(dc, tmp[i], cpu_T[0], 4, 0);
2362         }
2363
2364         for (i = 0; i <= dc->op2; i++) {
2365                 tcg_gen_mov_tl(cpu_R[i], tmp[i]);
2366                 tcg_gen_discard_tl(tmp[i]);
2367         }
2368
2369         /* writeback the updated pointer value.  */
2370         if (dc->postinc)
2371                 tcg_gen_addi_tl(cpu_R[dc->op1], cpu_R[dc->op1], i * 4);
2372
2373         /* gen_load might want to evaluate the previous insns flags.  */
2374         cris_cc_mask(dc, 0);
2375         return 2;
2376 }
2377
2378 static unsigned int dec_movem_rm(DisasContext *dc)
2379 {
2380         int i;
2381
2382         DIS(fprintf (logfile, "movem $r%u, [$r%u%s\n", dc->op2, dc->op1,
2383                      dc->postinc ? "+]" : "]"));
2384
2385         for (i = 0; i <= dc->op2; i++) {
2386                 /* Displace addr.  */
2387                 tcg_gen_addi_tl(cpu_T[0], cpu_R[dc->op1], i * 4);
2388                 /* Perform the store.  */
2389                 gen_store(dc, cpu_T[0], cpu_R[i], 4);
2390         }
2391         if (dc->postinc)
2392                 tcg_gen_addi_tl(cpu_R[dc->op1], cpu_R[dc->op1], i * 4);
2393         cris_cc_mask(dc, 0);
2394         return 2;
2395 }
2396
2397 static unsigned int dec_move_rm(DisasContext *dc)
2398 {
2399         int memsize;
2400
2401         memsize = memsize_zz(dc);
2402
2403         DIS(fprintf (logfile, "move.%d $r%u, [$r%u]\n",
2404                      memsize, dc->op2, dc->op1));
2405
2406         /* prepare store.  */
2407         gen_store(dc, cpu_R[dc->op1], cpu_R[dc->op2], memsize);
2408
2409         if (dc->postinc)
2410                 tcg_gen_addi_tl(cpu_R[dc->op1], cpu_R[dc->op1], memsize);
2411         cris_cc_mask(dc, 0);
2412         return 2;
2413 }
2414
2415 static unsigned int dec_lapcq(DisasContext *dc)
2416 {
2417         DIS(fprintf (logfile, "lapcq %x, $r%u\n",
2418                     dc->pc + dc->op1*2, dc->op2));
2419         cris_cc_mask(dc, 0);
2420         tcg_gen_movi_tl(cpu_T[1], dc->pc + dc->op1 * 2);
2421         crisv32_alu_op(dc, CC_OP_MOVE, dc->op2, 4);
2422         return 2;
2423 }
2424
2425 static unsigned int dec_lapc_im(DisasContext *dc)
2426 {
2427         unsigned int rd;
2428         int32_t imm;
2429         int32_t pc;
2430
2431         rd = dc->op2;
2432
2433         cris_cc_mask(dc, 0);
2434         imm = ldl_code(dc->pc + 2);
2435         DIS(fprintf (logfile, "lapc 0x%x, $r%u\n", imm + dc->pc, dc->op2));
2436
2437         pc = dc->pc;
2438         pc += imm;
2439         t_gen_mov_reg_TN(rd, tcg_const_tl(pc));
2440         return 6;
2441 }
2442
2443 /* Jump to special reg.  */
2444 static unsigned int dec_jump_p(DisasContext *dc)
2445 {
2446         DIS(fprintf (logfile, "jump $p%u\n", dc->op2));
2447
2448         if (dc->op2 == PR_CCS)
2449                 cris_evaluate_flags(dc);
2450         t_gen_mov_TN_preg(cpu_T[0], dc->op2);
2451         /* rete will often have low bit set to indicate delayslot.  */
2452         tcg_gen_andi_tl(env_btarget, cpu_T[0], ~1);
2453         cris_cc_mask(dc, 0);
2454         cris_prepare_dyn_jmp(dc);
2455         return 2;
2456 }
2457
2458 /* Jump and save.  */
2459 static unsigned int dec_jas_r(DisasContext *dc)
2460 {
2461         DIS(fprintf (logfile, "jas $r%u, $p%u\n", dc->op1, dc->op2));
2462         cris_cc_mask(dc, 0);
2463         /* Store the return address in Pd.  */
2464         tcg_gen_mov_tl(env_btarget, cpu_R[dc->op1]);
2465         if (dc->op2 > 15)
2466                 abort();
2467         tcg_gen_movi_tl(cpu_T[0], dc->pc + 4);
2468         tcg_gen_mov_tl(cpu_PR[dc->op2], cpu_T[0]);
2469
2470         cris_prepare_dyn_jmp(dc);
2471         return 2;
2472 }
2473
2474 static unsigned int dec_jas_im(DisasContext *dc)
2475 {
2476         uint32_t imm;
2477
2478         imm = ldl_code(dc->pc + 2);
2479
2480         DIS(fprintf (logfile, "jas 0x%x\n", imm));
2481         cris_cc_mask(dc, 0);
2482         /* Store the return address in Pd.  */
2483         tcg_gen_movi_tl(env_btarget, imm);
2484         t_gen_mov_preg_TN(dc->op2, tcg_const_tl(dc->pc + 8));
2485         cris_prepare_dyn_jmp(dc);
2486         return 6;
2487 }
2488
2489 static unsigned int dec_jasc_im(DisasContext *dc)
2490 {
2491         uint32_t imm;
2492
2493         imm = ldl_code(dc->pc + 2);
2494
2495         DIS(fprintf (logfile, "jasc 0x%x\n", imm));
2496         cris_cc_mask(dc, 0);
2497         /* Store the return address in Pd.  */
2498         tcg_gen_movi_tl(cpu_T[0], imm);
2499         tcg_gen_mov_tl(env_btarget, cpu_T[0]);
2500         tcg_gen_movi_tl(cpu_T[0], dc->pc + 8 + 4);
2501         t_gen_mov_preg_TN(dc->op2, cpu_T[0]);
2502         cris_prepare_dyn_jmp(dc);
2503         return 6;
2504 }
2505
2506 static unsigned int dec_jasc_r(DisasContext *dc)
2507 {
2508         DIS(fprintf (logfile, "jasc_r $r%u, $p%u\n", dc->op1, dc->op2));
2509         cris_cc_mask(dc, 0);
2510         /* Store the return address in Pd.  */
2511         t_gen_mov_TN_reg(cpu_T[0], dc->op1);
2512         tcg_gen_mov_tl(env_btarget, cpu_T[0]);
2513         tcg_gen_movi_tl(cpu_T[0], dc->pc + 4 + 4);
2514         t_gen_mov_preg_TN(dc->op2, cpu_T[0]);
2515         cris_prepare_dyn_jmp(dc);
2516         return 2;
2517 }
2518
2519 static unsigned int dec_bcc_im(DisasContext *dc)
2520 {
2521         int32_t offset;
2522         uint32_t cond = dc->op2;
2523
2524         offset = ldsw_code(dc->pc + 2);
2525
2526         DIS(fprintf (logfile, "b%s %d pc=%x dst=%x\n",
2527                     cc_name(cond), offset,
2528                     dc->pc, dc->pc + offset));
2529
2530         cris_cc_mask(dc, 0);
2531         /* op2 holds the condition-code.  */
2532         cris_prepare_cc_branch (dc, offset, cond);
2533         return 4;
2534 }
2535
2536 static unsigned int dec_bas_im(DisasContext *dc)
2537 {
2538         int32_t simm;
2539
2540
2541         simm = ldl_code(dc->pc + 2);
2542
2543         DIS(fprintf (logfile, "bas 0x%x, $p%u\n", dc->pc + simm, dc->op2));
2544         cris_cc_mask(dc, 0);
2545         /* Stor the return address in Pd.  */
2546         tcg_gen_movi_tl(cpu_T[0], dc->pc + simm);
2547         tcg_gen_mov_tl(env_btarget, cpu_T[0]);
2548         tcg_gen_movi_tl(cpu_T[0], dc->pc + 8);
2549         t_gen_mov_preg_TN(dc->op2, cpu_T[0]);
2550         cris_prepare_dyn_jmp(dc);
2551         return 6;
2552 }
2553
2554 static unsigned int dec_basc_im(DisasContext *dc)
2555 {
2556         int32_t simm;
2557         simm = ldl_code(dc->pc + 2);
2558
2559         DIS(fprintf (logfile, "basc 0x%x, $p%u\n", dc->pc + simm, dc->op2));
2560         cris_cc_mask(dc, 0);
2561         /* Stor the return address in Pd.  */
2562         tcg_gen_movi_tl(cpu_T[0], dc->pc + simm);
2563         tcg_gen_mov_tl(env_btarget, cpu_T[0]);
2564         tcg_gen_movi_tl(cpu_T[0], dc->pc + 12);
2565         t_gen_mov_preg_TN(dc->op2, cpu_T[0]);
2566         cris_prepare_dyn_jmp(dc);
2567         return 6;
2568 }
2569
2570 static unsigned int dec_rfe_etc(DisasContext *dc)
2571 {
2572         DIS(fprintf (logfile, "rfe_etc opc=%x pc=0x%x op1=%d op2=%d\n",
2573                     dc->opcode, dc->pc, dc->op1, dc->op2));
2574
2575         cris_cc_mask(dc, 0);
2576
2577         if (dc->op2 == 15) /* ignore halt.  */
2578                 return 2;
2579
2580         switch (dc->op2 & 7) {
2581                 case 2:
2582                         /* rfe.  */
2583                         cris_evaluate_flags(dc);
2584                         tcg_gen_helper_0_0(helper_rfe);
2585                         dc->is_jmp = DISAS_UPDATE;
2586                         break;
2587                 case 5:
2588                         /* rfn.  */
2589                         BUG();
2590                         break;
2591                 case 6:
2592                         /* break.  */
2593                         tcg_gen_movi_tl(cpu_T[0], dc->pc);
2594                         t_gen_mov_env_TN(pc, cpu_T[0]);
2595                         /* Breaks start at 16 in the exception vector.  */
2596                         t_gen_mov_env_TN(trap_vector,
2597                                          tcg_const_tl(dc->op1 + 16));
2598                         t_gen_raise_exception(EXCP_BREAK);
2599                         dc->is_jmp = DISAS_UPDATE;
2600                         break;
2601                 default:
2602                         printf ("op2=%x\n", dc->op2);
2603                         BUG();
2604                         break;
2605
2606         }
2607         return 2;
2608 }
2609
2610 static unsigned int dec_ftag_fidx_d_m(DisasContext *dc)
2611 {
2612         /* Ignore D-cache flushes.  */
2613         return 2;
2614 }
2615
2616 static unsigned int dec_ftag_fidx_i_m(DisasContext *dc)
2617 {
2618         /* Ignore I-cache flushes.  */
2619         return 2;
2620 }
2621
2622 static unsigned int dec_null(DisasContext *dc)
2623 {
2624         printf ("unknown insn pc=%x opc=%x op1=%x op2=%x\n",
2625                 dc->pc, dc->opcode, dc->op1, dc->op2);
2626         fflush(NULL);
2627         BUG();
2628         return 2;
2629 }
2630
2631 struct decoder_info {
2632         struct {
2633                 uint32_t bits;
2634                 uint32_t mask;
2635         };
2636         unsigned int (*dec)(DisasContext *dc);
2637 } decinfo[] = {
2638         /* Order matters here.  */
2639         {DEC_MOVEQ, dec_moveq},
2640         {DEC_BTSTQ, dec_btstq},
2641         {DEC_CMPQ, dec_cmpq},
2642         {DEC_ADDOQ, dec_addoq},
2643         {DEC_ADDQ, dec_addq},
2644         {DEC_SUBQ, dec_subq},
2645         {DEC_ANDQ, dec_andq},
2646         {DEC_ORQ, dec_orq},
2647         {DEC_ASRQ, dec_asrq},
2648         {DEC_LSLQ, dec_lslq},
2649         {DEC_LSRQ, dec_lsrq},
2650         {DEC_BCCQ, dec_bccq},
2651
2652         {DEC_BCC_IM, dec_bcc_im},
2653         {DEC_JAS_IM, dec_jas_im},
2654         {DEC_JAS_R, dec_jas_r},
2655         {DEC_JASC_IM, dec_jasc_im},
2656         {DEC_JASC_R, dec_jasc_r},
2657         {DEC_BAS_IM, dec_bas_im},
2658         {DEC_BASC_IM, dec_basc_im},
2659         {DEC_JUMP_P, dec_jump_p},
2660         {DEC_LAPC_IM, dec_lapc_im},
2661         {DEC_LAPCQ, dec_lapcq},
2662
2663         {DEC_RFE_ETC, dec_rfe_etc},
2664         {DEC_ADDC_MR, dec_addc_mr},
2665
2666         {DEC_MOVE_MP, dec_move_mp},
2667         {DEC_MOVE_PM, dec_move_pm},
2668         {DEC_MOVEM_MR, dec_movem_mr},
2669         {DEC_MOVEM_RM, dec_movem_rm},
2670         {DEC_MOVE_PR, dec_move_pr},
2671         {DEC_SCC_R, dec_scc_r},
2672         {DEC_SETF, dec_setclrf},
2673         {DEC_CLEARF, dec_setclrf},
2674
2675         {DEC_MOVE_SR, dec_move_sr},
2676         {DEC_MOVE_RP, dec_move_rp},
2677         {DEC_SWAP_R, dec_swap_r},
2678         {DEC_ABS_R, dec_abs_r},
2679         {DEC_LZ_R, dec_lz_r},
2680         {DEC_MOVE_RS, dec_move_rs},
2681         {DEC_BTST_R, dec_btst_r},
2682         {DEC_ADDC_R, dec_addc_r},
2683
2684         {DEC_DSTEP_R, dec_dstep_r},
2685         {DEC_XOR_R, dec_xor_r},
2686         {DEC_MCP_R, dec_mcp_r},
2687         {DEC_CMP_R, dec_cmp_r},
2688
2689         {DEC_ADDI_R, dec_addi_r},
2690         {DEC_ADDI_ACR, dec_addi_acr},
2691
2692         {DEC_ADD_R, dec_add_r},
2693         {DEC_SUB_R, dec_sub_r},
2694
2695         {DEC_ADDU_R, dec_addu_r},
2696         {DEC_ADDS_R, dec_adds_r},
2697         {DEC_SUBU_R, dec_subu_r},
2698         {DEC_SUBS_R, dec_subs_r},
2699         {DEC_LSL_R, dec_lsl_r},
2700
2701         {DEC_AND_R, dec_and_r},
2702         {DEC_OR_R, dec_or_r},
2703         {DEC_BOUND_R, dec_bound_r},
2704         {DEC_ASR_R, dec_asr_r},
2705         {DEC_LSR_R, dec_lsr_r},
2706
2707         {DEC_MOVU_R, dec_movu_r},
2708         {DEC_MOVS_R, dec_movs_r},
2709         {DEC_NEG_R, dec_neg_r},
2710         {DEC_MOVE_R, dec_move_r},
2711
2712         {DEC_FTAG_FIDX_I_M, dec_ftag_fidx_i_m},
2713         {DEC_FTAG_FIDX_D_M, dec_ftag_fidx_d_m},
2714
2715         {DEC_MULS_R, dec_muls_r},
2716         {DEC_MULU_R, dec_mulu_r},
2717
2718         {DEC_ADDU_M, dec_addu_m},
2719         {DEC_ADDS_M, dec_adds_m},
2720         {DEC_SUBU_M, dec_subu_m},
2721         {DEC_SUBS_M, dec_subs_m},
2722
2723         {DEC_CMPU_M, dec_cmpu_m},
2724         {DEC_CMPS_M, dec_cmps_m},
2725         {DEC_MOVU_M, dec_movu_m},
2726         {DEC_MOVS_M, dec_movs_m},
2727
2728         {DEC_CMP_M, dec_cmp_m},
2729         {DEC_ADDO_M, dec_addo_m},
2730         {DEC_BOUND_M, dec_bound_m},
2731         {DEC_ADD_M, dec_add_m},
2732         {DEC_SUB_M, dec_sub_m},
2733         {DEC_AND_M, dec_and_m},
2734         {DEC_OR_M, dec_or_m},
2735         {DEC_MOVE_RM, dec_move_rm},
2736         {DEC_TEST_M, dec_test_m},
2737         {DEC_MOVE_MR, dec_move_mr},
2738
2739         {{0, 0}, dec_null}
2740 };
2741
2742 static inline unsigned int
2743 cris_decoder(DisasContext *dc)
2744 {
2745         unsigned int insn_len = 2;
2746         int i;
2747
2748         /* Load a halfword onto the instruction register.  */
2749         dc->ir = lduw_code(dc->pc);
2750
2751         /* Now decode it.  */
2752         dc->opcode   = EXTRACT_FIELD(dc->ir, 4, 11);
2753         dc->op1      = EXTRACT_FIELD(dc->ir, 0, 3);
2754         dc->op2      = EXTRACT_FIELD(dc->ir, 12, 15);
2755         dc->zsize    = EXTRACT_FIELD(dc->ir, 4, 4);
2756         dc->zzsize   = EXTRACT_FIELD(dc->ir, 4, 5);
2757         dc->postinc  = EXTRACT_FIELD(dc->ir, 10, 10);
2758
2759         /* Large switch for all insns.  */
2760         for (i = 0; i < sizeof decinfo / sizeof decinfo[0]; i++) {
2761                 if ((dc->opcode & decinfo[i].mask) == decinfo[i].bits)
2762                 {
2763                         insn_len = decinfo[i].dec(dc);
2764                         break;
2765                 }
2766         }
2767
2768         return insn_len;
2769 }
2770
2771 static void check_breakpoint(CPUState *env, DisasContext *dc)
2772 {
2773         int j;
2774         if (env->nb_breakpoints > 0) {
2775                 for(j = 0; j < env->nb_breakpoints; j++) {
2776                         if (env->breakpoints[j] == dc->pc) {
2777                                 cris_evaluate_flags (dc);
2778                                 tcg_gen_movi_tl(cpu_T[0], dc->pc);
2779                                 t_gen_mov_env_TN(pc, cpu_T[0]);
2780                                 t_gen_raise_exception(EXCP_DEBUG);
2781                                 dc->is_jmp = DISAS_UPDATE;
2782                         }
2783                 }
2784         }
2785 }
2786
2787 /* generate intermediate code for basic block 'tb'.  */
2788 struct DisasContext ctx;
2789 static int
2790 gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
2791                                int search_pc)
2792 {
2793         uint16_t *gen_opc_end;
2794         uint32_t pc_start;
2795         unsigned int insn_len;
2796         int j, lj;
2797         struct DisasContext *dc = &ctx;
2798         uint32_t next_page_start;
2799
2800         if (!logfile)
2801                 logfile = stderr;
2802
2803         /* Odd PC indicates that branch is rexecuting due to exception in the
2804          * delayslot, like in real hw.
2805          * FIXME: we need to handle the case were the branch and the insn in
2806          *         the delayslot do not share pages.
2807          */
2808         pc_start = tb->pc & ~1;
2809         dc->env = env;
2810         dc->tb = tb;
2811
2812         gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
2813
2814         dc->is_jmp = DISAS_NEXT;
2815         dc->ppc = pc_start;
2816         dc->pc = pc_start;
2817         dc->singlestep_enabled = env->singlestep_enabled;
2818         dc->flags_live = 1;
2819         dc->flagx_live = 0;
2820         dc->flags_x = 0;
2821         dc->cc_mask = 0;
2822         cris_update_cc_op(dc, CC_OP_FLAGS, 4);
2823
2824         dc->user = env->pregs[PR_CCS] & U_FLAG;
2825         dc->delayed_branch = 0;
2826
2827         if (loglevel & CPU_LOG_TB_IN_ASM) {
2828                 fprintf(logfile,
2829                         "search=%d pc=%x ccs=%x pid=%x usp=%x dbg=%x %x %x\n"
2830                         "%x.%x.%x.%x\n"
2831                         "%x.%x.%x.%x\n"
2832                         "%x.%x.%x.%x\n"
2833                         "%x.%x.%x.%x\n",
2834                         search_pc, env->pc, env->pregs[PR_CCS],
2835                         env->pregs[PR_PID], env->pregs[PR_USP],
2836                         env->debug1, env->debug2, env->debug3,
2837                         env->regs[0], env->regs[1], env->regs[2], env->regs[3],
2838                         env->regs[4], env->regs[5], env->regs[6], env->regs[7],
2839                         env->regs[8], env->regs[9],
2840                         env->regs[10], env->regs[11],
2841                         env->regs[12], env->regs[13],
2842                         env->regs[14], env->regs[15]);
2843
2844         }
2845
2846         next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
2847         lj = -1;
2848         do
2849         {
2850                 check_breakpoint(env, dc);
2851                 if (dc->is_jmp == DISAS_JUMP
2852                     || dc->is_jmp == DISAS_SWI)
2853                         goto done;
2854
2855                 if (search_pc) {
2856                         j = gen_opc_ptr - gen_opc_buf;
2857                         if (lj < j) {
2858                                 lj++;
2859                                 while (lj < j)
2860                                         gen_opc_instr_start[lj++] = 0;
2861                         }
2862                         if (dc->delayed_branch == 1) {
2863                                 gen_opc_pc[lj] = dc->ppc | 1;
2864                                 gen_opc_instr_start[lj] = 0;
2865                         }
2866                         else {
2867                                 gen_opc_pc[lj] = dc->pc;
2868                                 gen_opc_instr_start[lj] = 1;
2869                         }
2870                 }
2871
2872                 dc->clear_x = 1;
2873                 insn_len = cris_decoder(dc);
2874                 dc->ppc = dc->pc;
2875                 dc->pc += insn_len;
2876                 if (dc->clear_x)
2877                         cris_clear_x_flag(dc);
2878
2879                 /* Check for delayed branches here. If we do it before
2880                    actually genereating any host code, the simulator will just
2881                    loop doing nothing for on this program location.  */
2882                 if (dc->delayed_branch) {
2883                         dc->delayed_branch--;
2884                         if (dc->delayed_branch == 0)
2885                         {
2886                                 if (dc->bcc == CC_A) {
2887                                         tcg_gen_mov_tl(env_pc, env_btarget);
2888                                         dc->is_jmp = DISAS_JUMP;
2889                                 }
2890                                 else {
2891                                         t_gen_cc_jmp(dc->delayed_pc, dc->pc);
2892                                         dc->is_jmp = DISAS_JUMP;
2893                                 }
2894                         }
2895                 }
2896
2897                 /* If we are rexecuting a branch due to exceptions on
2898                    delay slots dont break.  */
2899                 if (!(tb->pc & 1) && env->singlestep_enabled)
2900                         break;
2901         } while (!dc->is_jmp && gen_opc_ptr < gen_opc_end
2902                  && ((dc->pc < next_page_start) || dc->delayed_branch));
2903
2904         if (dc->delayed_branch == 1) {
2905                 /* Reexecute the last insn.  */
2906                 dc->pc = dc->ppc | 1;
2907         }
2908
2909         if (!dc->is_jmp) {
2910                 D(printf("!jmp pc=%x jmp=%d db=%d\n", dc->pc,
2911                          dc->is_jmp, dc->delayed_branch));
2912                 /* T0 and env_pc should hold the new pc.  */
2913                 tcg_gen_movi_tl(cpu_T[0], dc->pc);
2914                 tcg_gen_mov_tl(env_pc, cpu_T[0]);
2915         }
2916
2917         cris_evaluate_flags (dc);
2918   done:
2919         if (__builtin_expect(env->singlestep_enabled, 0)) {
2920                 t_gen_raise_exception(EXCP_DEBUG);
2921         } else {
2922                 switch(dc->is_jmp) {
2923                         case DISAS_NEXT:
2924                                 gen_goto_tb(dc, 1, dc->pc);
2925                                 break;
2926                         default:
2927                         case DISAS_JUMP:
2928                         case DISAS_UPDATE:
2929                                 /* indicate that the hash table must be used
2930                                    to find the next TB */
2931                                 tcg_gen_exit_tb(0);
2932                                 break;
2933                         case DISAS_SWI:
2934                         case DISAS_TB_JUMP:
2935                                 /* nothing more to generate */
2936                                 break;
2937                 }
2938         }
2939         *gen_opc_ptr = INDEX_op_end;
2940         if (search_pc) {
2941                 j = gen_opc_ptr - gen_opc_buf;
2942                 lj++;
2943                 while (lj <= j)
2944                         gen_opc_instr_start[lj++] = 0;
2945         } else {
2946                 tb->size = dc->pc - pc_start;
2947         }
2948
2949 #ifdef DEBUG_DISAS
2950         if (loglevel & CPU_LOG_TB_IN_ASM) {
2951                 fprintf(logfile, "--------------\n");
2952                 fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
2953                 target_disas(logfile, pc_start, dc->pc - pc_start, 0);
2954                 fprintf(logfile, "\nisize=%d osize=%d\n",
2955                         dc->pc - pc_start, gen_opc_ptr - gen_opc_buf);
2956         }
2957 #endif
2958         return 0;
2959 }
2960
2961 int gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
2962 {
2963     return gen_intermediate_code_internal(env, tb, 0);
2964 }
2965
2966 int gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
2967 {
2968     return gen_intermediate_code_internal(env, tb, 1);
2969 }
2970
2971 void cpu_dump_state (CPUState *env, FILE *f,
2972                      int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
2973                      int flags)
2974 {
2975         int i;
2976         uint32_t srs;
2977
2978         if (!env || !f)
2979                 return;
2980
2981         cpu_fprintf(f, "PC=%x CCS=%x btaken=%d btarget=%x\n"
2982                     "cc_op=%d cc_src=%d cc_dest=%d cc_result=%x cc_mask=%x\n"
2983                     "debug=%x %x %x\n",
2984                     env->pc, env->pregs[PR_CCS], env->btaken, env->btarget,
2985                     env->cc_op,
2986                     env->cc_src, env->cc_dest, env->cc_result, env->cc_mask,
2987                     env->debug1, env->debug2, env->debug3);
2988
2989         for (i = 0; i < 16; i++) {
2990                 cpu_fprintf(f, "r%2.2d=%8.8x ", i, env->regs[i]);
2991                 if ((i + 1) % 4 == 0)
2992                         cpu_fprintf(f, "\n");
2993         }
2994         cpu_fprintf(f, "\nspecial regs:\n");
2995         for (i = 0; i < 16; i++) {
2996                 cpu_fprintf(f, "p%2.2d=%8.8x ", i, env->pregs[i]);
2997                 if ((i + 1) % 4 == 0)
2998                         cpu_fprintf(f, "\n");
2999         }
3000         srs = env->pregs[PR_SRS];
3001         cpu_fprintf(f, "\nsupport function regs bank %x:\n", srs);
3002         if (srs < 256) {
3003                 for (i = 0; i < 16; i++) {
3004                         cpu_fprintf(f, "s%2.2d=%8.8x ",
3005                                     i, env->sregs[srs][i]);
3006                         if ((i + 1) % 4 == 0)
3007                                 cpu_fprintf(f, "\n");
3008                 }
3009         }
3010         cpu_fprintf(f, "\n\n");
3011
3012 }
3013
3014 static void tcg_macro_func(TCGContext *s, int macro_id, const int *dead_args)
3015 {
3016 }
3017
3018 CPUCRISState *cpu_cris_init (const char *cpu_model)
3019 {
3020         CPUCRISState *env;
3021         int i;
3022
3023         env = qemu_mallocz(sizeof(CPUCRISState));
3024         if (!env)
3025                 return NULL;
3026         cpu_exec_init(env);
3027
3028         tcg_set_macro_func(&tcg_ctx, tcg_macro_func);
3029         cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
3030 #if TARGET_LONG_BITS > HOST_LONG_BITS
3031         cpu_T[0] = tcg_global_mem_new(TCG_TYPE_TL,
3032                                       TCG_AREG0, offsetof(CPUState, t0), "T0");
3033         cpu_T[1] = tcg_global_mem_new(TCG_TYPE_TL,
3034                                       TCG_AREG0, offsetof(CPUState, t1), "T1");
3035 #else
3036         cpu_T[0] = tcg_global_reg_new(TCG_TYPE_TL, TCG_AREG1, "T0");
3037         cpu_T[1] = tcg_global_reg_new(TCG_TYPE_TL, TCG_AREG2, "T1");
3038 #endif
3039
3040         cc_src = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3041                                     offsetof(CPUState, cc_src), "cc_src");
3042         cc_dest = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3043                                      offsetof(CPUState, cc_dest),
3044                                      "cc_dest");
3045         cc_result = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3046                                        offsetof(CPUState, cc_result),
3047                                        "cc_result");
3048         cc_op = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3049                                    offsetof(CPUState, cc_op), "cc_op");
3050         cc_size = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3051                                      offsetof(CPUState, cc_size),
3052                                      "cc_size");
3053         cc_mask = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3054                                      offsetof(CPUState, cc_mask),
3055                                      "cc_mask");
3056
3057         env_pc = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3058                                      offsetof(CPUState, pc),
3059                                      "pc");
3060         env_btarget = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3061                                      offsetof(CPUState, btarget),
3062                                      "btarget");
3063
3064         for (i = 0; i < 16; i++) {
3065                 cpu_R[i] = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3066                                               offsetof(CPUState, regs[i]),
3067                                               regnames[i]);
3068         }
3069         for (i = 0; i < 16; i++) {
3070                 cpu_PR[i] = tcg_global_mem_new(TCG_TYPE_PTR, TCG_AREG0,
3071                                                offsetof(CPUState, pregs[i]),
3072                                                pregnames[i]);
3073         }
3074
3075         TCG_HELPER(helper_raise_exception);
3076         TCG_HELPER(helper_store);
3077         TCG_HELPER(helper_dump);
3078         TCG_HELPER(helper_dummy);
3079
3080         TCG_HELPER(helper_tlb_flush);
3081         TCG_HELPER(helper_movl_sreg_reg);
3082         TCG_HELPER(helper_movl_reg_sreg);
3083         TCG_HELPER(helper_rfe);
3084
3085         TCG_HELPER(helper_evaluate_flags_muls);
3086         TCG_HELPER(helper_evaluate_flags_mulu);
3087         TCG_HELPER(helper_evaluate_flags_mcp);
3088         TCG_HELPER(helper_evaluate_flags_alu_4);
3089         TCG_HELPER(helper_evaluate_flags_move_4);
3090         TCG_HELPER(helper_evaluate_flags_move_2);
3091         TCG_HELPER(helper_evaluate_flags);
3092
3093         cpu_reset(env);
3094         return env;
3095 }
3096
3097 void cpu_reset (CPUCRISState *env)
3098 {
3099         memset(env, 0, offsetof(CPUCRISState, breakpoints));
3100         tlb_flush(env, 1);
3101
3102 #if defined(CONFIG_USER_ONLY)
3103         /* start in user mode with interrupts enabled.  */
3104         env->pregs[PR_CCS] |= U_FLAG | I_FLAG;
3105 #else
3106         env->pregs[PR_CCS] = 0;
3107 #endif
3108 }
3109
3110 void gen_pc_load(CPUState *env, struct TranslationBlock *tb,
3111                  unsigned long searched_pc, int pc_pos, void *puc)
3112 {
3113         env->pc = gen_opc_pc[pc_pos];
3114 }