target-cris/op_helper.c

   1 /*
   2  *  CRIS helper routines
   3  *
   4  *  Copyright (c) 2007 AXIS Communications
   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, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "cpu.h"
  22 #include "mmu.h"
  23 #include "helper.h"
  24 #include "qemu/host-utils.h"
  25
  26 //#define CRIS_OP_HELPER_DEBUG
  27
  28
  29 #ifdef CRIS_OP_HELPER_DEBUG
  30 #define D(x) x
  31 #define D_LOG(...) qemu_log(__VA_ARGS__)
  32 #else
  33 #define D(x)
  34 #define D_LOG(...) do { } while (0)
  35 #endif
  36
  37 #if !defined(CONFIG_USER_ONLY)
  38 #include "exec/softmmu_exec.h"
  39
  40 #define MMUSUFFIX _mmu
  41
  42 #define SHIFT 0
  43 #include "exec/softmmu_template.h"
  44
  45 #define SHIFT 1
  46 #include "exec/softmmu_template.h"
  47
  48 #define SHIFT 2
  49 #include "exec/softmmu_template.h"
  50
  51 #define SHIFT 3
  52 #include "exec/softmmu_template.h"
  53
  54 /* Try to fill the TLB and return an exception if error. If retaddr is
  55    NULL, it means that the function was called in C code (i.e. not
  56    from generated code or from helper.c) */
  57 void tlb_fill(CPUCRISState *env, target_ulong addr, int is_write, int mmu_idx,
  58               uintptr_t retaddr)
  59 {
  60     CRISCPU *cpu = cris_env_get_cpu(env);
  61     int ret;
  62
  63     D_LOG("%s pc=%x tpc=%x ra=%p\n", __func__,
  64           env->pc, env->pregs[PR_EDA], (void *)retaddr);
  65     ret = cris_cpu_handle_mmu_fault(CPU(cpu), addr, is_write, mmu_idx);
  66     if (unlikely(ret)) {
  67         if (retaddr) {
  68             /* now we have a real cpu fault */
  69             if (cpu_restore_state(env, retaddr)) {
  70                 /* Evaluate flags after retranslation.  */
  71                 helper_top_evaluate_flags(env);
  72             }
  73         }
  74         cpu_loop_exit(env);
  75     }
  76 }
  77
  78 #endif
  79
  80 void helper_raise_exception(CPUCRISState *env, uint32_t index)
  81 {
  82         env->exception_index = index;
  83         cpu_loop_exit(env);
  84 }
  85
  86 void helper_tlb_flush_pid(CPUCRISState *env, uint32_t pid)
  87 {
  88 #if !defined(CONFIG_USER_ONLY)
  89         pid &= 0xff;
  90         if (pid != (env->pregs[PR_PID] & 0xff))
  91                 cris_mmu_flush_pid(env, env->pregs[PR_PID]);
  92 #endif
  93 }
  94
  95 void helper_spc_write(CPUCRISState *env, uint32_t new_spc)
  96 {
  97 #if !defined(CONFIG_USER_ONLY)
  98         tlb_flush_page(env, env->pregs[PR_SPC]);
  99         tlb_flush_page(env, new_spc);
 100 #endif
 101 }
 102
 103 void helper_dump(uint32_t a0, uint32_t a1, uint32_t a2)
 104 {
 105         qemu_log("%s: a0=%x a1=%x\n", __func__, a0, a1);
 106 }
 107
 108 /* Used by the tlb decoder.  */
 109 #define EXTRACT_FIELD(src, start, end) \
 110             (((src) >> start) & ((1 << (end - start + 1)) - 1))
 111
 112 void helper_movl_sreg_reg(CPUCRISState *env, uint32_t sreg, uint32_t reg)
 113 {
 114         uint32_t srs;
 115         srs = env->pregs[PR_SRS];
 116         srs &= 3;
 117         env->sregs[srs][sreg] = env->regs[reg];
 118
 119 #if !defined(CONFIG_USER_ONLY)
 120         if (srs == 1 || srs == 2) {
 121                 if (sreg == 6) {
 122                         /* Writes to tlb-hi write to mm_cause as a side
 123                            effect.  */
 124                         env->sregs[SFR_RW_MM_TLB_HI] = env->regs[reg];
 125                         env->sregs[SFR_R_MM_CAUSE] = env->regs[reg];
 126                 }
 127                 else if (sreg == 5) {
 128                         uint32_t set;
 129                         uint32_t idx;
 130                         uint32_t lo, hi;
 131                         uint32_t vaddr;
 132                         int tlb_v;
 133
 134                         idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
 135                         set >>= 4;
 136                         set &= 3;
 137
 138                         idx &= 15;
 139                         /* We've just made a write to tlb_lo.  */
 140                         lo = env->sregs[SFR_RW_MM_TLB_LO];
 141                         /* Writes are done via r_mm_cause.  */
 142                         hi = env->sregs[SFR_R_MM_CAUSE];
 143
 144                         vaddr = EXTRACT_FIELD(env->tlbsets[srs-1][set][idx].hi,
 145                                               13, 31);
 146                         vaddr <<= TARGET_PAGE_BITS;
 147                         tlb_v = EXTRACT_FIELD(env->tlbsets[srs-1][set][idx].lo,
 148                                             3, 3);
 149                         env->tlbsets[srs - 1][set][idx].lo = lo;
 150                         env->tlbsets[srs - 1][set][idx].hi = hi;
 151
 152                         D_LOG("tlb flush vaddr=%x v=%d pc=%x\n",
 153                                   vaddr, tlb_v, env->pc);
 154                         if (tlb_v) {
 155                                 tlb_flush_page(env, vaddr);
 156                         }
 157                 }
 158         }
 159 #endif
 160 }
 161
 162 void helper_movl_reg_sreg(CPUCRISState *env, uint32_t reg, uint32_t sreg)
 163 {
 164         uint32_t srs;
 165         env->pregs[PR_SRS] &= 3;
 166         srs = env->pregs[PR_SRS];
 167
 168 #if !defined(CONFIG_USER_ONLY)
 169         if (srs == 1 || srs == 2)
 170         {
 171                 uint32_t set;
 172                 uint32_t idx;
 173                 uint32_t lo, hi;
 174
 175                 idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
 176                 set >>= 4;
 177                 set &= 3;
 178                 idx &= 15;
 179
 180                 /* Update the mirror regs.  */
 181                 hi = env->tlbsets[srs - 1][set][idx].hi;
 182                 lo = env->tlbsets[srs - 1][set][idx].lo;
 183                 env->sregs[SFR_RW_MM_TLB_HI] = hi;
 184                 env->sregs[SFR_RW_MM_TLB_LO] = lo;
 185         }
 186 #endif
 187         env->regs[reg] = env->sregs[srs][sreg];
 188 }
 189
 190 static void cris_ccs_rshift(CPUCRISState *env)
 191 {
 192         uint32_t ccs;
 193
 194         /* Apply the ccs shift.  */
 195         ccs = env->pregs[PR_CCS];
 196         ccs = (ccs & 0xc0000000) | ((ccs & 0x0fffffff) >> 10);
 197         if (ccs & U_FLAG)
 198         {
 199                 /* Enter user mode.  */
 200                 env->ksp = env->regs[R_SP];
 201                 env->regs[R_SP] = env->pregs[PR_USP];
 202         }
 203
 204         env->pregs[PR_CCS] = ccs;
 205 }
 206
 207 void helper_rfe(CPUCRISState *env)
 208 {
 209         int rflag = env->pregs[PR_CCS] & R_FLAG;
 210
 211         D_LOG("rfe: erp=%x pid=%x ccs=%x btarget=%x\n",
 212                  env->pregs[PR_ERP], env->pregs[PR_PID],
 213                  env->pregs[PR_CCS],
 214                  env->btarget);
 215
 216         cris_ccs_rshift(env);
 217
 218         /* RFE sets the P_FLAG only if the R_FLAG is not set.  */
 219         if (!rflag)
 220                 env->pregs[PR_CCS] |= P_FLAG;
 221 }
 222
 223 void helper_rfn(CPUCRISState *env)
 224 {
 225         int rflag = env->pregs[PR_CCS] & R_FLAG;
 226
 227         D_LOG("rfn: erp=%x pid=%x ccs=%x btarget=%x\n",
 228                  env->pregs[PR_ERP], env->pregs[PR_PID],
 229                  env->pregs[PR_CCS],
 230                  env->btarget);
 231
 232         cris_ccs_rshift(env);
 233
 234         /* Set the P_FLAG only if the R_FLAG is not set.  */
 235         if (!rflag)
 236                 env->pregs[PR_CCS] |= P_FLAG;
 237
 238         /* Always set the M flag.  */
 239         env->pregs[PR_CCS] |= M_FLAG_V32;
 240 }
 241
 242 uint32_t helper_lz(uint32_t t0)
 243 {
 244         return clz32(t0);
 245 }
 246
 247 uint32_t helper_btst(CPUCRISState *env, uint32_t t0, uint32_t t1, uint32_t ccs)
 248 {
 249         /* FIXME: clean this up.  */
 250
 251         /* des ref:
 252            The N flag is set according to the selected bit in the dest reg.
 253            The Z flag is set if the selected bit and all bits to the right are
 254            zero.
 255            The X flag is cleared.
 256            Other flags are left untouched.
 257            The destination reg is not affected.*/
 258         unsigned int fz, sbit, bset, mask, masked_t0;
 259
 260         sbit = t1 & 31;
 261         bset = !!(t0 & (1 << sbit));
 262         mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1;
 263         masked_t0 = t0 & mask;
 264         fz = !(masked_t0 | bset);
 265
 266         /* Clear the X, N and Z flags.  */
 267         ccs = ccs & ~(X_FLAG | N_FLAG | Z_FLAG);
 268         if (env->pregs[PR_VR] < 32)
 269                 ccs &= ~(V_FLAG | C_FLAG);
 270         /* Set the N and Z flags accordingly.  */
 271         ccs |= (bset << 3) | (fz << 2);
 272         return ccs;
 273 }
 274
 275 static inline uint32_t evaluate_flags_writeback(CPUCRISState *env,
 276                                                 uint32_t flags, uint32_t ccs)
 277 {
 278         unsigned int x, z, mask;
 279
 280         /* Extended arithmetics, leave the z flag alone.  */
 281         x = env->cc_x;
 282         mask = env->cc_mask | X_FLAG;
 283         if (x) {
 284                 z = flags & Z_FLAG;
 285                 mask = mask & ~z;
 286         }
 287         flags &= mask;
 288
 289         /* all insn clear the x-flag except setf or clrf.  */
 290         ccs &= ~mask;
 291         ccs |= flags;
 292         return ccs;
 293 }
 294
 295 uint32_t helper_evaluate_flags_muls(CPUCRISState *env,
 296                                     uint32_t ccs, uint32_t res, uint32_t mof)
 297 {
 298         uint32_t flags = 0;
 299         int64_t tmp;
 300         int dneg;
 301
 302         dneg = ((int32_t)res) < 0;
 303
 304         tmp = mof;
 305         tmp <<= 32;
 306         tmp |= res;
 307         if (tmp == 0)
 308                 flags |= Z_FLAG;
 309         else if (tmp < 0)
 310                 flags |= N_FLAG;
 311         if ((dneg && mof != -1)
 312             || (!dneg && mof != 0))
 313                 flags |= V_FLAG;
 314         return evaluate_flags_writeback(env, flags, ccs);
 315 }
 316
 317 uint32_t helper_evaluate_flags_mulu(CPUCRISState *env,
 318                                     uint32_t ccs, uint32_t res, uint32_t mof)
 319 {
 320         uint32_t flags = 0;
 321         uint64_t tmp;
 322
 323         tmp = mof;
 324         tmp <<= 32;
 325         tmp |= res;
 326         if (tmp == 0)
 327                 flags |= Z_FLAG;
 328         else if (tmp >> 63)
 329                 flags |= N_FLAG;
 330         if (mof)
 331                 flags |= V_FLAG;
 332
 333         return evaluate_flags_writeback(env, flags, ccs);
 334 }
 335
 336 uint32_t helper_evaluate_flags_mcp(CPUCRISState *env, uint32_t ccs,
 337                                    uint32_t src, uint32_t dst, uint32_t res)
 338 {
 339         uint32_t flags = 0;
 340
 341         src = src & 0x80000000;
 342         dst = dst & 0x80000000;
 343
 344         if ((res & 0x80000000L) != 0L)
 345         {
 346                 flags |= N_FLAG;
 347                 if (!src && !dst)
 348                         flags |= V_FLAG;
 349                 else if (src & dst)
 350                         flags |= R_FLAG;
 351         }
 352         else
 353         {
 354                 if (res == 0L)
 355                         flags |= Z_FLAG;
 356                 if (src & dst)
 357                         flags |= V_FLAG;
 358                 if (dst | src)
 359                         flags |= R_FLAG;
 360         }
 361
 362         return evaluate_flags_writeback(env, flags, ccs);
 363 }
 364
 365 uint32_t helper_evaluate_flags_alu_4(CPUCRISState *env, uint32_t ccs,
 366                                      uint32_t src, uint32_t dst, uint32_t res)
 367 {
 368         uint32_t flags = 0;
 369
 370         src = src & 0x80000000;
 371         dst = dst & 0x80000000;
 372
 373         if ((res & 0x80000000L) != 0L)
 374         {
 375                 flags |= N_FLAG;
 376                 if (!src && !dst)
 377                         flags |= V_FLAG;
 378                 else if (src & dst)
 379                         flags |= C_FLAG;
 380         }
 381         else
 382         {
 383                 if (res == 0L)
 384                         flags |= Z_FLAG;
 385                 if (src & dst)
 386                         flags |= V_FLAG;
 387                 if (dst | src)
 388                         flags |= C_FLAG;
 389         }
 390
 391         return evaluate_flags_writeback(env, flags, ccs);
 392 }
 393
 394 uint32_t helper_evaluate_flags_sub_4(CPUCRISState *env, uint32_t ccs,
 395                                      uint32_t src, uint32_t dst, uint32_t res)
 396 {
 397         uint32_t flags = 0;
 398
 399         src = (~src) & 0x80000000;
 400         dst = dst & 0x80000000;
 401
 402         if ((res & 0x80000000L) != 0L)
 403         {
 404                 flags |= N_FLAG;
 405                 if (!src && !dst)
 406                         flags |= V_FLAG;
 407                 else if (src & dst)
 408                         flags |= C_FLAG;
 409         }
 410         else
 411         {
 412                 if (res == 0L)
 413                         flags |= Z_FLAG;
 414                 if (src & dst)
 415                         flags |= V_FLAG;
 416                 if (dst | src)
 417                         flags |= C_FLAG;
 418         }
 419
 420         flags ^= C_FLAG;
 421         return evaluate_flags_writeback(env, flags, ccs);
 422 }
 423
 424 uint32_t helper_evaluate_flags_move_4(CPUCRISState *env,
 425                                       uint32_t ccs, uint32_t res)
 426 {
 427         uint32_t flags = 0;
 428
 429         if ((int32_t)res < 0)
 430                 flags |= N_FLAG;
 431         else if (res == 0L)
 432                 flags |= Z_FLAG;
 433
 434         return evaluate_flags_writeback(env, flags, ccs);
 435 }
 436 uint32_t helper_evaluate_flags_move_2(CPUCRISState *env,
 437                                       uint32_t ccs, uint32_t res)
 438 {
 439         uint32_t flags = 0;
 440
 441         if ((int16_t)res < 0L)
 442                 flags |= N_FLAG;
 443         else if (res == 0)
 444                 flags |= Z_FLAG;
 445
 446         return evaluate_flags_writeback(env, flags, ccs);
 447 }
 448
 449 /* TODO: This is expensive. We could split things up and only evaluate part of
 450    CCR on a need to know basis. For now, we simply re-evaluate everything.  */
 451 void helper_evaluate_flags(CPUCRISState *env)
 452 {
 453         uint32_t src, dst, res;
 454         uint32_t flags = 0;
 455
 456         src = env->cc_src;
 457         dst = env->cc_dest;
 458         res = env->cc_result;
 459
 460         if (env->cc_op == CC_OP_SUB || env->cc_op == CC_OP_CMP)
 461                 src = ~src;
 462
 463         /* Now, evaluate the flags. This stuff is based on
 464            Per Zander's CRISv10 simulator.  */
 465         switch (env->cc_size)
 466         {
 467                 case 1:
 468                         if ((res & 0x80L) != 0L)
 469                         {
 470                                 flags |= N_FLAG;
 471                                 if (((src & 0x80L) == 0L)
 472                                     && ((dst & 0x80L) == 0L))
 473                                 {
 474                                         flags |= V_FLAG;
 475                                 }
 476                                 else if (((src & 0x80L) != 0L)
 477                                          && ((dst & 0x80L) != 0L))
 478                                 {
 479                                         flags |= C_FLAG;
 480                                 }
 481                         }
 482                         else
 483                         {
 484                                 if ((res & 0xFFL) == 0L)
 485                                 {
 486                                         flags |= Z_FLAG;
 487                                 }
 488                                 if (((src & 0x80L) != 0L)
 489                                     && ((dst & 0x80L) != 0L))
 490                                 {
 491                                         flags |= V_FLAG;
 492                                 }
 493                                 if ((dst & 0x80L) != 0L
 494                                     || (src & 0x80L) != 0L)
 495                                 {
 496                                         flags |= C_FLAG;
 497                                 }
 498                         }
 499                         break;
 500                 case 2:
 501                         if ((res & 0x8000L) != 0L)
 502                         {
 503                                 flags |= N_FLAG;
 504                                 if (((src & 0x8000L) == 0L)
 505                                     && ((dst & 0x8000L) == 0L))
 506                                 {
 507                                         flags |= V_FLAG;
 508                                 }
 509                                 else if (((src & 0x8000L) != 0L)
 510                                          && ((dst & 0x8000L) != 0L))
 511                                 {
 512                                         flags |= C_FLAG;
 513                                 }
 514                         }
 515                         else
 516                         {
 517                                 if ((res & 0xFFFFL) == 0L)
 518                                 {
 519                                         flags |= Z_FLAG;
 520                                 }
 521                                 if (((src & 0x8000L) != 0L)
 522                                     && ((dst & 0x8000L) != 0L))
 523                                 {
 524                                         flags |= V_FLAG;
 525                                 }
 526                                 if ((dst & 0x8000L) != 0L
 527                                     || (src & 0x8000L) != 0L)
 528                                 {
 529                                         flags |= C_FLAG;
 530                                 }
 531                         }
 532                         break;
 533                 case 4:
 534                         if ((res & 0x80000000L) != 0L)
 535                         {
 536                                 flags |= N_FLAG;
 537                                 if (((src & 0x80000000L) == 0L)
 538                                     && ((dst & 0x80000000L) == 0L))
 539                                 {
 540                                         flags |= V_FLAG;
 541                                 }
 542                                 else if (((src & 0x80000000L) != 0L) &&
 543                                          ((dst & 0x80000000L) != 0L))
 544                                 {
 545                                         flags |= C_FLAG;
 546                                 }
 547                         }
 548                         else
 549                         {
 550                                 if (res == 0L)
 551                                         flags |= Z_FLAG;
 552                                 if (((src & 0x80000000L) != 0L)
 553                                     && ((dst & 0x80000000L) != 0L))
 554                                         flags |= V_FLAG;
 555                                 if ((dst & 0x80000000L) != 0L
 556                                     || (src & 0x80000000L) != 0L)
 557                                         flags |= C_FLAG;
 558                         }
 559                         break;
 560                 default:
 561                         break;
 562         }
 563
 564         if (env->cc_op == CC_OP_SUB || env->cc_op == CC_OP_CMP)
 565                 flags ^= C_FLAG;
 566
 567         env->pregs[PR_CCS] = evaluate_flags_writeback(env, flags,
 568                                                       env->pregs[PR_CCS]);
 569 }
 570
 571 void helper_top_evaluate_flags(CPUCRISState *env)
 572 {
 573         switch (env->cc_op)
 574         {
 575                 case CC_OP_MCP:
 576                         env->pregs[PR_CCS] = helper_evaluate_flags_mcp(env,
 577                                         env->pregs[PR_CCS], env->cc_src,
 578                                         env->cc_dest, env->cc_result);
 579                         break;
 580                 case CC_OP_MULS:
 581                         env->pregs[PR_CCS] = helper_evaluate_flags_muls(env,
 582                                         env->pregs[PR_CCS], env->cc_result,
 583                                         env->pregs[PR_MOF]);
 584                         break;
 585                 case CC_OP_MULU:
 586                         env->pregs[PR_CCS] = helper_evaluate_flags_mulu(env,
 587                                         env->pregs[PR_CCS], env->cc_result,
 588                                         env->pregs[PR_MOF]);
 589                         break;
 590                 case CC_OP_MOVE:
 591                 case CC_OP_AND:
 592                 case CC_OP_OR:
 593                 case CC_OP_XOR:
 594                 case CC_OP_ASR:
 595                 case CC_OP_LSR:
 596                 case CC_OP_LSL:
 597                 switch (env->cc_size)
 598                 {
 599                         case 4:
 600                                 env->pregs[PR_CCS] =
 601                                         helper_evaluate_flags_move_4(env,
 602                                                         env->pregs[PR_CCS],
 603                                                         env->cc_result);
 604                                 break;
 605                         case 2:
 606                                 env->pregs[PR_CCS] =
 607                                         helper_evaluate_flags_move_2(env,
 608                                                         env->pregs[PR_CCS],
 609                                                         env->cc_result);
 610                                 break;
 611                         default:
 612                                 helper_evaluate_flags(env);
 613                                 break;
 614                 }
 615                 break;
 616                 case CC_OP_FLAGS:
 617                         /* live.  */
 618                         break;
 619                 case CC_OP_SUB:
 620                 case CC_OP_CMP:
 621                         if (env->cc_size == 4)
 622                                 env->pregs[PR_CCS] =
 623                                         helper_evaluate_flags_sub_4(env,
 624                                                 env->pregs[PR_CCS],
 625                                                 env->cc_src, env->cc_dest,
 626                                                 env->cc_result);
 627                         else
 628                                 helper_evaluate_flags(env);
 629                         break;
 630                 default:
 631                 {
 632                         switch (env->cc_size)
 633                         {
 634                         case 4:
 635                                 env->pregs[PR_CCS] =
 636                                         helper_evaluate_flags_alu_4(env,
 637                                                 env->pregs[PR_CCS],
 638                                                 env->cc_src, env->cc_dest,
 639                                                 env->cc_result);
 640                                 break;
 641                         default:
 642                                 helper_evaluate_flags(env);
 643                                 break;
 644                         }
 645                 }
 646                 break;
 647         }
 648 }