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