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