target-arm/op_helper.c

   1 /*
   2  *  ARM helper routines
   3  *
   4  *  Copyright (c) 2005-2007 CodeSourcery, LLC
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "qemu/osdep.h"
  20 #include "cpu.h"
  21 #include "exec/helper-proto.h"
  22 #include "internals.h"
  23 #include "exec/cpu_ldst.h"
  24
  25 #define SIGNBIT (uint32_t)0x80000000
  26 #define SIGNBIT64 ((uint64_t)1 << 63)
  27
  28 static void raise_exception(CPUARMState *env, uint32_t excp,
  29                             uint32_t syndrome, uint32_t target_el)
  30 {
  31     CPUState *cs = CPU(arm_env_get_cpu(env));
  32
  33     assert(!excp_is_internal(excp));
  34     cs->exception_index = excp;
  35     env->exception.syndrome = syndrome;
  36     env->exception.target_el = target_el;
  37     cpu_loop_exit(cs);
  38 }
  39
  40 static int exception_target_el(CPUARMState *env)
  41 {
  42     int target_el = MAX(1, arm_current_el(env));
  43
  44     /* No such thing as secure EL1 if EL3 is aarch32, so update the target EL
  45      * to EL3 in this case.
  46      */
  47     if (arm_is_secure(env) && !arm_el_is_aa64(env, 3) && target_el == 1) {
  48         target_el = 3;
  49     }
  50
  51     return target_el;
  52 }
  53
  54 uint32_t HELPER(neon_tbl)(CPUARMState *env, uint32_t ireg, uint32_t def,
  55                           uint32_t rn, uint32_t maxindex)
  56 {
  57     uint32_t val;
  58     uint32_t tmp;
  59     int index;
  60     int shift;
  61     uint64_t *table;
  62     table = (uint64_t *)&env->vfp.regs[rn];
  63     val = 0;
  64     for (shift = 0; shift < 32; shift += 8) {
  65         index = (ireg >> shift) & 0xff;
  66         if (index < maxindex) {
  67             tmp = (table[index >> 3] >> ((index & 7) << 3)) & 0xff;
  68             val |= tmp << shift;
  69         } else {
  70             val |= def & (0xff << shift);
  71         }
  72     }
  73     return val;
  74 }
  75
  76 #if !defined(CONFIG_USER_ONLY)
  77
  78 /* try to fill the TLB and return an exception if error. If retaddr is
  79  * NULL, it means that the function was called in C code (i.e. not
  80  * from generated code or from helper.c)
  81  */
  82 void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
  83               uintptr_t retaddr)
  84 {
  85     bool ret;
  86     uint32_t fsr = 0;
  87     ARMMMUFaultInfo fi = {};
  88
  89     ret = arm_tlb_fill(cs, addr, is_write, mmu_idx, &fsr, &fi);
  90     if (unlikely(ret)) {
  91         ARMCPU *cpu = ARM_CPU(cs);
  92         CPUARMState *env = &cpu->env;
  93         uint32_t syn, exc;
  94         unsigned int target_el;
  95         bool same_el;
  96
  97         if (retaddr) {
  98             /* now we have a real cpu fault */
  99             cpu_restore_state(cs, retaddr);
 100         }
 101
 102         target_el = exception_target_el(env);
 103         if (fi.stage2) {
 104             target_el = 2;
 105             env->cp15.hpfar_el2 = extract64(fi.s2addr, 12, 47) << 4;
 106         }
 107         same_el = arm_current_el(env) == target_el;
 108         /* AArch64 syndrome does not have an LPAE bit */
 109         syn = fsr & ~(1 << 9);
 110
 111         /* For insn and data aborts we assume there is no instruction syndrome
 112          * information; this is always true for exceptions reported to EL1.
 113          */
 114         if (is_write == 2) {
 115             syn = syn_insn_abort(same_el, 0, fi.s1ptw, syn);
 116             exc = EXCP_PREFETCH_ABORT;
 117         } else {
 118             syn = syn_data_abort_no_iss(same_el,
 119                                         0, 0, fi.s1ptw, is_write == 1, syn);
 120             if (is_write == 1 && arm_feature(env, ARM_FEATURE_V6)) {
 121                 fsr |= (1 << 11);
 122             }
 123             exc = EXCP_DATA_ABORT;
 124         }
 125
 126         env->exception.vaddress = addr;
 127         env->exception.fsr = fsr;
 128         raise_exception(env, exc, syn, target_el);
 129     }
 130 }
 131
 132 /* Raise a data fault alignment exception for the specified virtual address */
 133 void arm_cpu_do_unaligned_access(CPUState *cs, vaddr vaddr, int is_write,
 134                                  int is_user, uintptr_t retaddr)
 135 {
 136     ARMCPU *cpu = ARM_CPU(cs);
 137     CPUARMState *env = &cpu->env;
 138     int target_el;
 139     bool same_el;
 140
 141     if (retaddr) {
 142         /* now we have a real cpu fault */
 143         cpu_restore_state(cs, retaddr);
 144     }
 145
 146     target_el = exception_target_el(env);
 147     same_el = (arm_current_el(env) == target_el);
 148
 149     env->exception.vaddress = vaddr;
 150
 151     /* the DFSR for an alignment fault depends on whether we're using
 152      * the LPAE long descriptor format, or the short descriptor format
 153      */
 154     if (arm_s1_regime_using_lpae_format(env, cpu_mmu_index(env, false))) {
 155         env->exception.fsr = 0x21;
 156     } else {
 157         env->exception.fsr = 0x1;
 158     }
 159
 160     if (is_write == 1 && arm_feature(env, ARM_FEATURE_V6)) {
 161         env->exception.fsr |= (1 << 11);
 162     }
 163
 164     raise_exception(env, EXCP_DATA_ABORT,
 165                     syn_data_abort_no_iss(same_el,
 166                                           0, 0, 0, is_write == 1, 0x21),
 167                     target_el);
 168 }
 169
 170 #endif /* !defined(CONFIG_USER_ONLY) */
 171
 172 uint32_t HELPER(add_setq)(CPUARMState *env, uint32_t a, uint32_t b)
 173 {
 174     uint32_t res = a + b;
 175     if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT))
 176         env->QF = 1;
 177     return res;
 178 }
 179
 180 uint32_t HELPER(add_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
 181 {
 182     uint32_t res = a + b;
 183     if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT)) {
 184         env->QF = 1;
 185         res = ~(((int32_t)a >> 31) ^ SIGNBIT);
 186     }
 187     return res;
 188 }
 189
 190 uint32_t HELPER(sub_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
 191 {
 192     uint32_t res = a - b;
 193     if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) {
 194         env->QF = 1;
 195         res = ~(((int32_t)a >> 31) ^ SIGNBIT);
 196     }
 197     return res;
 198 }
 199
 200 uint32_t HELPER(double_saturate)(CPUARMState *env, int32_t val)
 201 {
 202     uint32_t res;
 203     if (val >= 0x40000000) {
 204         res = ~SIGNBIT;
 205         env->QF = 1;
 206     } else if (val <= (int32_t)0xc0000000) {
 207         res = SIGNBIT;
 208         env->QF = 1;
 209     } else {
 210         res = val << 1;
 211     }
 212     return res;
 213 }
 214
 215 uint32_t HELPER(add_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
 216 {
 217     uint32_t res = a + b;
 218     if (res < a) {
 219         env->QF = 1;
 220         res = ~0;
 221     }
 222     return res;
 223 }
 224
 225 uint32_t HELPER(sub_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
 226 {
 227     uint32_t res = a - b;
 228     if (res > a) {
 229         env->QF = 1;
 230         res = 0;
 231     }
 232     return res;
 233 }
 234
 235 /* Signed saturation.  */
 236 static inline uint32_t do_ssat(CPUARMState *env, int32_t val, int shift)
 237 {
 238     int32_t top;
 239     uint32_t mask;
 240
 241     top = val >> shift;
 242     mask = (1u << shift) - 1;
 243     if (top > 0) {
 244         env->QF = 1;
 245         return mask;
 246     } else if (top < -1) {
 247         env->QF = 1;
 248         return ~mask;
 249     }
 250     return val;
 251 }
 252
 253 /* Unsigned saturation.  */
 254 static inline uint32_t do_usat(CPUARMState *env, int32_t val, int shift)
 255 {
 256     uint32_t max;
 257
 258     max = (1u << shift) - 1;
 259     if (val < 0) {
 260         env->QF = 1;
 261         return 0;
 262     } else if (val > max) {
 263         env->QF = 1;
 264         return max;
 265     }
 266     return val;
 267 }
 268
 269 /* Signed saturate.  */
 270 uint32_t HELPER(ssat)(CPUARMState *env, uint32_t x, uint32_t shift)
 271 {
 272     return do_ssat(env, x, shift);
 273 }
 274
 275 /* Dual halfword signed saturate.  */
 276 uint32_t HELPER(ssat16)(CPUARMState *env, uint32_t x, uint32_t shift)
 277 {
 278     uint32_t res;
 279
 280     res = (uint16_t)do_ssat(env, (int16_t)x, shift);
 281     res |= do_ssat(env, ((int32_t)x) >> 16, shift) << 16;
 282     return res;
 283 }
 284
 285 /* Unsigned saturate.  */
 286 uint32_t HELPER(usat)(CPUARMState *env, uint32_t x, uint32_t shift)
 287 {
 288     return do_usat(env, x, shift);
 289 }
 290
 291 /* Dual halfword unsigned saturate.  */
 292 uint32_t HELPER(usat16)(CPUARMState *env, uint32_t x, uint32_t shift)
 293 {
 294     uint32_t res;
 295
 296     res = (uint16_t)do_usat(env, (int16_t)x, shift);
 297     res |= do_usat(env, ((int32_t)x) >> 16, shift) << 16;
 298     return res;
 299 }
 300
 301 void HELPER(setend)(CPUARMState *env)
 302 {
 303     env->uncached_cpsr ^= CPSR_E;
 304 }
 305
 306 /* Function checks whether WFx (WFI/WFE) instructions are set up to be trapped.
 307  * The function returns the target EL (1-3) if the instruction is to be trapped;
 308  * otherwise it returns 0 indicating it is not trapped.
 309  */
 310 static inline int check_wfx_trap(CPUARMState *env, bool is_wfe)
 311 {
 312     int cur_el = arm_current_el(env);
 313     uint64_t mask;
 314
 315     /* If we are currently in EL0 then we need to check if SCTLR is set up for
 316      * WFx instructions being trapped to EL1. These trap bits don't exist in v7.
 317      */
 318     if (cur_el < 1 && arm_feature(env, ARM_FEATURE_V8)) {
 319         int target_el;
 320
 321         mask = is_wfe ? SCTLR_nTWE : SCTLR_nTWI;
 322         if (arm_is_secure_below_el3(env) && !arm_el_is_aa64(env, 3)) {
 323             /* Secure EL0 and Secure PL1 is at EL3 */
 324             target_el = 3;
 325         } else {
 326             target_el = 1;
 327         }
 328
 329         if (!(env->cp15.sctlr_el[target_el] & mask)) {
 330             return target_el;
 331         }
 332     }
 333
 334     /* We are not trapping to EL1; trap to EL2 if HCR_EL2 requires it
 335      * No need for ARM_FEATURE check as if HCR_EL2 doesn't exist the
 336      * bits will be zero indicating no trap.
 337      */
 338     if (cur_el < 2 && !arm_is_secure(env)) {
 339         mask = (is_wfe) ? HCR_TWE : HCR_TWI;
 340         if (env->cp15.hcr_el2 & mask) {
 341             return 2;
 342         }
 343     }
 344
 345     /* We are not trapping to EL1 or EL2; trap to EL3 if SCR_EL3 requires it */
 346     if (cur_el < 3) {
 347         mask = (is_wfe) ? SCR_TWE : SCR_TWI;
 348         if (env->cp15.scr_el3 & mask) {
 349             return 3;
 350         }
 351     }
 352
 353     return 0;
 354 }
 355
 356 void HELPER(wfi)(CPUARMState *env)
 357 {
 358     CPUState *cs = CPU(arm_env_get_cpu(env));
 359     int target_el = check_wfx_trap(env, false);
 360
 361     if (cpu_has_work(cs)) {
 362         /* Don't bother to go into our "low power state" if
 363          * we would just wake up immediately.
 364          */
 365         return;
 366     }
 367
 368     if (target_el) {
 369         env->pc -= 4;
 370         raise_exception(env, EXCP_UDEF, syn_wfx(1, 0xe, 0), target_el);
 371     }
 372
 373     cs->exception_index = EXCP_HLT;
 374     cs->halted = 1;
 375     cpu_loop_exit(cs);
 376 }
 377
 378 void HELPER(wfe)(CPUARMState *env)
 379 {
 380     /* This is a hint instruction that is semantically different
 381      * from YIELD even though we currently implement it identically.
 382      * Don't actually halt the CPU, just yield back to top
 383      * level loop. This is not going into a "low power state"
 384      * (ie halting until some event occurs), so we never take
 385      * a configurable trap to a different exception level.
 386      */
 387     HELPER(yield)(env);
 388 }
 389
 390 void HELPER(yield)(CPUARMState *env)
 391 {
 392     ARMCPU *cpu = arm_env_get_cpu(env);
 393     CPUState *cs = CPU(cpu);
 394
 395     /* This is a non-trappable hint instruction that generally indicates
 396      * that the guest is currently busy-looping. Yield control back to the
 397      * top level loop so that a more deserving VCPU has a chance to run.
 398      */
 399     cs->exception_index = EXCP_YIELD;
 400     cpu_loop_exit(cs);
 401 }
 402
 403 /* Raise an internal-to-QEMU exception. This is limited to only
 404  * those EXCP values which are special cases for QEMU to interrupt
 405  * execution and not to be used for exceptions which are passed to
 406  * the guest (those must all have syndrome information and thus should
 407  * use exception_with_syndrome).
 408  */
 409 void HELPER(exception_internal)(CPUARMState *env, uint32_t excp)
 410 {
 411     CPUState *cs = CPU(arm_env_get_cpu(env));
 412
 413     assert(excp_is_internal(excp));
 414     cs->exception_index = excp;
 415     cpu_loop_exit(cs);
 416 }
 417
 418 /* Raise an exception with the specified syndrome register value */
 419 void HELPER(exception_with_syndrome)(CPUARMState *env, uint32_t excp,
 420                                      uint32_t syndrome, uint32_t target_el)
 421 {
 422     raise_exception(env, excp, syndrome, target_el);
 423 }
 424
 425 uint32_t HELPER(cpsr_read)(CPUARMState *env)
 426 {
 427     return cpsr_read(env) & ~(CPSR_EXEC | CPSR_RESERVED);
 428 }
 429
 430 void HELPER(cpsr_write)(CPUARMState *env, uint32_t val, uint32_t mask)
 431 {
 432     cpsr_write(env, val, mask, CPSRWriteByInstr);
 433 }
 434
 435 /* Write the CPSR for a 32-bit exception return */
 436 void HELPER(cpsr_write_eret)(CPUARMState *env, uint32_t val)
 437 {
 438     cpsr_write(env, val, CPSR_ERET_MASK, CPSRWriteExceptionReturn);
 439 }
 440
 441 /* Access to user mode registers from privileged modes.  */
 442 uint32_t HELPER(get_user_reg)(CPUARMState *env, uint32_t regno)
 443 {
 444     uint32_t val;
 445
 446     if (regno == 13) {
 447         val = env->banked_r13[BANK_USRSYS];
 448     } else if (regno == 14) {
 449         val = env->banked_r14[BANK_USRSYS];
 450     } else if (regno >= 8
 451                && (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
 452         val = env->usr_regs[regno - 8];
 453     } else {
 454         val = env->regs[regno];
 455     }
 456     return val;
 457 }
 458
 459 void HELPER(set_user_reg)(CPUARMState *env, uint32_t regno, uint32_t val)
 460 {
 461     if (regno == 13) {
 462         env->banked_r13[BANK_USRSYS] = val;
 463     } else if (regno == 14) {
 464         env->banked_r14[BANK_USRSYS] = val;
 465     } else if (regno >= 8
 466                && (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
 467         env->usr_regs[regno - 8] = val;
 468     } else {
 469         env->regs[regno] = val;
 470     }
 471 }
 472
 473 void HELPER(set_r13_banked)(CPUARMState *env, uint32_t mode, uint32_t val)
 474 {
 475     if ((env->uncached_cpsr & CPSR_M) == mode) {
 476         env->regs[13] = val;
 477     } else {
 478         env->banked_r13[bank_number(mode)] = val;
 479     }
 480 }
 481
 482 uint32_t HELPER(get_r13_banked)(CPUARMState *env, uint32_t mode)
 483 {
 484     if ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_SYS) {
 485         /* SRS instruction is UNPREDICTABLE from System mode; we UNDEF.
 486          * Other UNPREDICTABLE and UNDEF cases were caught at translate time.
 487          */
 488         raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 489                         exception_target_el(env));
 490     }
 491
 492     if ((env->uncached_cpsr & CPSR_M) == mode) {
 493         return env->regs[13];
 494     } else {
 495         return env->banked_r13[bank_number(mode)];
 496     }
 497 }
 498
 499 static void msr_mrs_banked_exc_checks(CPUARMState *env, uint32_t tgtmode,
 500                                       uint32_t regno)
 501 {
 502     /* Raise an exception if the requested access is one of the UNPREDICTABLE
 503      * cases; otherwise return. This broadly corresponds to the pseudocode
 504      * BankedRegisterAccessValid() and SPSRAccessValid(),
 505      * except that we have already handled some cases at translate time.
 506      */
 507     int curmode = env->uncached_cpsr & CPSR_M;
 508
 509     if (curmode == tgtmode) {
 510         goto undef;
 511     }
 512
 513     if (tgtmode == ARM_CPU_MODE_USR) {
 514         switch (regno) {
 515         case 8 ... 12:
 516             if (curmode != ARM_CPU_MODE_FIQ) {
 517                 goto undef;
 518             }
 519             break;
 520         case 13:
 521             if (curmode == ARM_CPU_MODE_SYS) {
 522                 goto undef;
 523             }
 524             break;
 525         case 14:
 526             if (curmode == ARM_CPU_MODE_HYP || curmode == ARM_CPU_MODE_SYS) {
 527                 goto undef;
 528             }
 529             break;
 530         default:
 531             break;
 532         }
 533     }
 534
 535     if (tgtmode == ARM_CPU_MODE_HYP) {
 536         switch (regno) {
 537         case 17: /* ELR_Hyp */
 538             if (curmode != ARM_CPU_MODE_HYP && curmode != ARM_CPU_MODE_MON) {
 539                 goto undef;
 540             }
 541             break;
 542         default:
 543             if (curmode != ARM_CPU_MODE_MON) {
 544                 goto undef;
 545             }
 546             break;
 547         }
 548     }
 549
 550     return;
 551
 552 undef:
 553     raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 554                     exception_target_el(env));
 555 }
 556
 557 void HELPER(msr_banked)(CPUARMState *env, uint32_t value, uint32_t tgtmode,
 558                         uint32_t regno)
 559 {
 560     msr_mrs_banked_exc_checks(env, tgtmode, regno);
 561
 562     switch (regno) {
 563     case 16: /* SPSRs */
 564         env->banked_spsr[bank_number(tgtmode)] = value;
 565         break;
 566     case 17: /* ELR_Hyp */
 567         env->elr_el[2] = value;
 568         break;
 569     case 13:
 570         env->banked_r13[bank_number(tgtmode)] = value;
 571         break;
 572     case 14:
 573         env->banked_r14[bank_number(tgtmode)] = value;
 574         break;
 575     case 8 ... 12:
 576         switch (tgtmode) {
 577         case ARM_CPU_MODE_USR:
 578             env->usr_regs[regno - 8] = value;
 579             break;
 580         case ARM_CPU_MODE_FIQ:
 581             env->fiq_regs[regno - 8] = value;
 582             break;
 583         default:
 584             g_assert_not_reached();
 585         }
 586         break;
 587     default:
 588         g_assert_not_reached();
 589     }
 590 }
 591
 592 uint32_t HELPER(mrs_banked)(CPUARMState *env, uint32_t tgtmode, uint32_t regno)
 593 {
 594     msr_mrs_banked_exc_checks(env, tgtmode, regno);
 595
 596     switch (regno) {
 597     case 16: /* SPSRs */
 598         return env->banked_spsr[bank_number(tgtmode)];
 599     case 17: /* ELR_Hyp */
 600         return env->elr_el[2];
 601     case 13:
 602         return env->banked_r13[bank_number(tgtmode)];
 603     case 14:
 604         return env->banked_r14[bank_number(tgtmode)];
 605     case 8 ... 12:
 606         switch (tgtmode) {
 607         case ARM_CPU_MODE_USR:
 608             return env->usr_regs[regno - 8];
 609         case ARM_CPU_MODE_FIQ:
 610             return env->fiq_regs[regno - 8];
 611         default:
 612             g_assert_not_reached();
 613         }
 614     default:
 615         g_assert_not_reached();
 616     }
 617 }
 618
 619 void HELPER(access_check_cp_reg)(CPUARMState *env, void *rip, uint32_t syndrome,
 620                                  uint32_t isread)
 621 {
 622     const ARMCPRegInfo *ri = rip;
 623     int target_el;
 624
 625     if (arm_feature(env, ARM_FEATURE_XSCALE) && ri->cp < 14
 626         && extract32(env->cp15.c15_cpar, ri->cp, 1) == 0) {
 627         raise_exception(env, EXCP_UDEF, syndrome, exception_target_el(env));
 628     }
 629
 630     if (!ri->accessfn) {
 631         return;
 632     }
 633
 634     switch (ri->accessfn(env, ri, isread)) {
 635     case CP_ACCESS_OK:
 636         return;
 637     case CP_ACCESS_TRAP:
 638         target_el = exception_target_el(env);
 639         break;
 640     case CP_ACCESS_TRAP_EL2:
 641         /* Requesting a trap to EL2 when we're in EL3 or S-EL0/1 is
 642          * a bug in the access function.
 643          */
 644         assert(!arm_is_secure(env) && arm_current_el(env) != 3);
 645         target_el = 2;
 646         break;
 647     case CP_ACCESS_TRAP_EL3:
 648         target_el = 3;
 649         break;
 650     case CP_ACCESS_TRAP_UNCATEGORIZED:
 651         target_el = exception_target_el(env);
 652         syndrome = syn_uncategorized();
 653         break;
 654     case CP_ACCESS_TRAP_UNCATEGORIZED_EL2:
 655         target_el = 2;
 656         syndrome = syn_uncategorized();
 657         break;
 658     case CP_ACCESS_TRAP_UNCATEGORIZED_EL3:
 659         target_el = 3;
 660         syndrome = syn_uncategorized();
 661         break;
 662     case CP_ACCESS_TRAP_FP_EL2:
 663         target_el = 2;
 664         /* Since we are an implementation that takes exceptions on a trapped
 665          * conditional insn only if the insn has passed its condition code
 666          * check, we take the IMPDEF choice to always report CV=1 COND=0xe
 667          * (which is also the required value for AArch64 traps).
 668          */
 669         syndrome = syn_fp_access_trap(1, 0xe, false);
 670         break;
 671     case CP_ACCESS_TRAP_FP_EL3:
 672         target_el = 3;
 673         syndrome = syn_fp_access_trap(1, 0xe, false);
 674         break;
 675     default:
 676         g_assert_not_reached();
 677     }
 678
 679     raise_exception(env, EXCP_UDEF, syndrome, target_el);
 680 }
 681
 682 void HELPER(set_cp_reg)(CPUARMState *env, void *rip, uint32_t value)
 683 {
 684     const ARMCPRegInfo *ri = rip;
 685
 686     ri->writefn(env, ri, value);
 687 }
 688
 689 uint32_t HELPER(get_cp_reg)(CPUARMState *env, void *rip)
 690 {
 691     const ARMCPRegInfo *ri = rip;
 692
 693     return ri->readfn(env, ri);
 694 }
 695
 696 void HELPER(set_cp_reg64)(CPUARMState *env, void *rip, uint64_t value)
 697 {
 698     const ARMCPRegInfo *ri = rip;
 699
 700     ri->writefn(env, ri, value);
 701 }
 702
 703 uint64_t HELPER(get_cp_reg64)(CPUARMState *env, void *rip)
 704 {
 705     const ARMCPRegInfo *ri = rip;
 706
 707     return ri->readfn(env, ri);
 708 }
 709
 710 void HELPER(msr_i_pstate)(CPUARMState *env, uint32_t op, uint32_t imm)
 711 {
 712     /* MSR_i to update PSTATE. This is OK from EL0 only if UMA is set.
 713      * Note that SPSel is never OK from EL0; we rely on handle_msr_i()
 714      * to catch that case at translate time.
 715      */
 716     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_UMA)) {
 717         uint32_t syndrome = syn_aa64_sysregtrap(0, extract32(op, 0, 3),
 718                                                 extract32(op, 3, 3), 4,
 719                                                 imm, 0x1f, 0);
 720         raise_exception(env, EXCP_UDEF, syndrome, exception_target_el(env));
 721     }
 722
 723     switch (op) {
 724     case 0x05: /* SPSel */
 725         update_spsel(env, imm);
 726         break;
 727     case 0x1e: /* DAIFSet */
 728         env->daif |= (imm << 6) & PSTATE_DAIF;
 729         break;
 730     case 0x1f: /* DAIFClear */
 731         env->daif &= ~((imm << 6) & PSTATE_DAIF);
 732         break;
 733     default:
 734         g_assert_not_reached();
 735     }
 736 }
 737
 738 void HELPER(clear_pstate_ss)(CPUARMState *env)
 739 {
 740     env->pstate &= ~PSTATE_SS;
 741 }
 742
 743 void HELPER(pre_hvc)(CPUARMState *env)
 744 {
 745     ARMCPU *cpu = arm_env_get_cpu(env);
 746     int cur_el = arm_current_el(env);
 747     /* FIXME: Use actual secure state.  */
 748     bool secure = false;
 749     bool undef;
 750
 751     if (arm_is_psci_call(cpu, EXCP_HVC)) {
 752         /* If PSCI is enabled and this looks like a valid PSCI call then
 753          * that overrides the architecturally mandated HVC behaviour.
 754          */
 755         return;
 756     }
 757
 758     if (!arm_feature(env, ARM_FEATURE_EL2)) {
 759         /* If EL2 doesn't exist, HVC always UNDEFs */
 760         undef = true;
 761     } else if (arm_feature(env, ARM_FEATURE_EL3)) {
 762         /* EL3.HCE has priority over EL2.HCD. */
 763         undef = !(env->cp15.scr_el3 & SCR_HCE);
 764     } else {
 765         undef = env->cp15.hcr_el2 & HCR_HCD;
 766     }
 767
 768     /* In ARMv7 and ARMv8/AArch32, HVC is undef in secure state.
 769      * For ARMv8/AArch64, HVC is allowed in EL3.
 770      * Note that we've already trapped HVC from EL0 at translation
 771      * time.
 772      */
 773     if (secure && (!is_a64(env) || cur_el == 1)) {
 774         undef = true;
 775     }
 776
 777     if (undef) {
 778         raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 779                         exception_target_el(env));
 780     }
 781 }
 782
 783 void HELPER(pre_smc)(CPUARMState *env, uint32_t syndrome)
 784 {
 785     ARMCPU *cpu = arm_env_get_cpu(env);
 786     int cur_el = arm_current_el(env);
 787     bool secure = arm_is_secure(env);
 788     bool smd = env->cp15.scr_el3 & SCR_SMD;
 789     /* On ARMv8 with EL3 AArch64, SMD applies to both S and NS state.
 790      * On ARMv8 with EL3 AArch32, or ARMv7 with the Virtualization
 791      *  extensions, SMD only applies to NS state.
 792      * On ARMv7 without the Virtualization extensions, the SMD bit
 793      * doesn't exist, but we forbid the guest to set it to 1 in scr_write(),
 794      * so we need not special case this here.
 795      */
 796     bool undef = arm_feature(env, ARM_FEATURE_AARCH64) ? smd : smd && !secure;
 797
 798     if (arm_is_psci_call(cpu, EXCP_SMC)) {
 799         /* If PSCI is enabled and this looks like a valid PSCI call then
 800          * that overrides the architecturally mandated SMC behaviour.
 801          */
 802         return;
 803     }
 804
 805     if (!arm_feature(env, ARM_FEATURE_EL3)) {
 806         /* If we have no EL3 then SMC always UNDEFs */
 807         undef = true;
 808     } else if (!secure && cur_el == 1 && (env->cp15.hcr_el2 & HCR_TSC)) {
 809         /* In NS EL1, HCR controlled routing to EL2 has priority over SMD. */
 810         raise_exception(env, EXCP_HYP_TRAP, syndrome, 2);
 811     }
 812
 813     if (undef) {
 814         raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 815                         exception_target_el(env));
 816     }
 817 }
 818
 819 static int el_from_spsr(uint32_t spsr)
 820 {
 821     /* Return the exception level that this SPSR is requesting a return to,
 822      * or -1 if it is invalid (an illegal return)
 823      */
 824     if (spsr & PSTATE_nRW) {
 825         switch (spsr & CPSR_M) {
 826         case ARM_CPU_MODE_USR:
 827             return 0;
 828         case ARM_CPU_MODE_HYP:
 829             return 2;
 830         case ARM_CPU_MODE_FIQ:
 831         case ARM_CPU_MODE_IRQ:
 832         case ARM_CPU_MODE_SVC:
 833         case ARM_CPU_MODE_ABT:
 834         case ARM_CPU_MODE_UND:
 835         case ARM_CPU_MODE_SYS:
 836             return 1;
 837         case ARM_CPU_MODE_MON:
 838             /* Returning to Mon from AArch64 is never possible,
 839              * so this is an illegal return.
 840              */
 841         default:
 842             return -1;
 843         }
 844     } else {
 845         if (extract32(spsr, 1, 1)) {
 846             /* Return with reserved M[1] bit set */
 847             return -1;
 848         }
 849         if (extract32(spsr, 0, 4) == 1) {
 850             /* return to EL0 with M[0] bit set */
 851             return -1;
 852         }
 853         return extract32(spsr, 2, 2);
 854     }
 855 }
 856
 857 void HELPER(exception_return)(CPUARMState *env)
 858 {
 859     int cur_el = arm_current_el(env);
 860     unsigned int spsr_idx = aarch64_banked_spsr_index(cur_el);
 861     uint32_t spsr = env->banked_spsr[spsr_idx];
 862     int new_el;
 863     bool return_to_aa64 = (spsr & PSTATE_nRW) == 0;
 864
 865     aarch64_save_sp(env, cur_el);
 866
 867     env->exclusive_addr = -1;
 868
 869     /* We must squash the PSTATE.SS bit to zero unless both of the
 870      * following hold:
 871      *  1. debug exceptions are currently disabled
 872      *  2. singlestep will be active in the EL we return to
 873      * We check 1 here and 2 after we've done the pstate/cpsr write() to
 874      * transition to the EL we're going to.
 875      */
 876     if (arm_generate_debug_exceptions(env)) {
 877         spsr &= ~PSTATE_SS;
 878     }
 879
 880     new_el = el_from_spsr(spsr);
 881     if (new_el == -1) {
 882         goto illegal_return;
 883     }
 884     if (new_el > cur_el
 885         || (new_el == 2 && !arm_feature(env, ARM_FEATURE_EL2))) {
 886         /* Disallow return to an EL which is unimplemented or higher
 887          * than the current one.
 888          */
 889         goto illegal_return;
 890     }
 891
 892     if (new_el != 0 && arm_el_is_aa64(env, new_el) != return_to_aa64) {
 893         /* Return to an EL which is configured for a different register width */
 894         goto illegal_return;
 895     }
 896
 897     if (new_el == 2 && arm_is_secure_below_el3(env)) {
 898         /* Return to the non-existent secure-EL2 */
 899         goto illegal_return;
 900     }
 901
 902     if (new_el == 1 && (env->cp15.hcr_el2 & HCR_TGE)
 903         && !arm_is_secure_below_el3(env)) {
 904         goto illegal_return;
 905     }
 906
 907     if (!return_to_aa64) {
 908         env->aarch64 = 0;
 909         /* We do a raw CPSR write because aarch64_sync_64_to_32()
 910          * will sort the register banks out for us, and we've already
 911          * caught all the bad-mode cases in el_from_spsr().
 912          */
 913         cpsr_write(env, spsr, ~0, CPSRWriteRaw);
 914         if (!arm_singlestep_active(env)) {
 915             env->uncached_cpsr &= ~PSTATE_SS;
 916         }
 917         aarch64_sync_64_to_32(env);
 918
 919         if (spsr & CPSR_T) {
 920             env->regs[15] = env->elr_el[cur_el] & ~0x1;
 921         } else {
 922             env->regs[15] = env->elr_el[cur_el] & ~0x3;
 923         }
 924     } else {
 925         env->aarch64 = 1;
 926         pstate_write(env, spsr);
 927         if (!arm_singlestep_active(env)) {
 928             env->pstate &= ~PSTATE_SS;
 929         }
 930         aarch64_restore_sp(env, new_el);
 931         env->pc = env->elr_el[cur_el];
 932     }
 933
 934     return;
 935
 936 illegal_return:
 937     /* Illegal return events of various kinds have architecturally
 938      * mandated behaviour:
 939      * restore NZCV and DAIF from SPSR_ELx
 940      * set PSTATE.IL
 941      * restore PC from ELR_ELx
 942      * no change to exception level, execution state or stack pointer
 943      */
 944     env->pstate |= PSTATE_IL;
 945     env->pc = env->elr_el[cur_el];
 946     spsr &= PSTATE_NZCV | PSTATE_DAIF;
 947     spsr |= pstate_read(env) & ~(PSTATE_NZCV | PSTATE_DAIF);
 948     pstate_write(env, spsr);
 949     if (!arm_singlestep_active(env)) {
 950         env->pstate &= ~PSTATE_SS;
 951     }
 952 }
 953
 954 /* Return true if the linked breakpoint entry lbn passes its checks */
 955 static bool linked_bp_matches(ARMCPU *cpu, int lbn)
 956 {
 957     CPUARMState *env = &cpu->env;
 958     uint64_t bcr = env->cp15.dbgbcr[lbn];
 959     int brps = extract32(cpu->dbgdidr, 24, 4);
 960     int ctx_cmps = extract32(cpu->dbgdidr, 20, 4);
 961     int bt;
 962     uint32_t contextidr;
 963
 964     /* Links to unimplemented or non-context aware breakpoints are
 965      * CONSTRAINED UNPREDICTABLE: either behave as if disabled, or
 966      * as if linked to an UNKNOWN context-aware breakpoint (in which
 967      * case DBGWCR<n>_EL1.LBN must indicate that breakpoint).
 968      * We choose the former.
 969      */
 970     if (lbn > brps || lbn < (brps - ctx_cmps)) {
 971         return false;
 972     }
 973
 974     bcr = env->cp15.dbgbcr[lbn];
 975
 976     if (extract64(bcr, 0, 1) == 0) {
 977         /* Linked breakpoint disabled : generate no events */
 978         return false;
 979     }
 980
 981     bt = extract64(bcr, 20, 4);
 982
 983     /* We match the whole register even if this is AArch32 using the
 984      * short descriptor format (in which case it holds both PROCID and ASID),
 985      * since we don't implement the optional v7 context ID masking.
 986      */
 987     contextidr = extract64(env->cp15.contextidr_el[1], 0, 32);
 988
 989     switch (bt) {
 990     case 3: /* linked context ID match */
 991         if (arm_current_el(env) > 1) {
 992             /* Context matches never fire in EL2 or (AArch64) EL3 */
 993             return false;
 994         }
 995         return (contextidr == extract64(env->cp15.dbgbvr[lbn], 0, 32));
 996     case 5: /* linked address mismatch (reserved in AArch64) */
 997     case 9: /* linked VMID match (reserved if no EL2) */
 998     case 11: /* linked context ID and VMID match (reserved if no EL2) */
 999     default:
1000         /* Links to Unlinked context breakpoints must generate no
1001          * events; we choose to do the same for reserved values too.
1002          */
1003         return false;
1004     }
1005
1006     return false;
1007 }
1008
1009 static bool bp_wp_matches(ARMCPU *cpu, int n, bool is_wp)
1010 {
1011     CPUARMState *env = &cpu->env;
1012     uint64_t cr;
1013     int pac, hmc, ssc, wt, lbn;
1014     /* Note that for watchpoints the check is against the CPU security
1015      * state, not the S/NS attribute on the offending data access.
1016      */
1017     bool is_secure = arm_is_secure(env);
1018     int access_el = arm_current_el(env);
1019
1020     if (is_wp) {
1021         CPUWatchpoint *wp = env->cpu_watchpoint[n];
1022
1023         if (!wp || !(wp->flags & BP_WATCHPOINT_HIT)) {
1024             return false;
1025         }
1026         cr = env->cp15.dbgwcr[n];
1027         if (wp->hitattrs.user) {
1028             /* The LDRT/STRT/LDT/STT "unprivileged access" instructions should
1029              * match watchpoints as if they were accesses done at EL0, even if
1030              * the CPU is at EL1 or higher.
1031              */
1032             access_el = 0;
1033         }
1034     } else {
1035         uint64_t pc = is_a64(env) ? env->pc : env->regs[15];
1036
1037         if (!env->cpu_breakpoint[n] || env->cpu_breakpoint[n]->pc != pc) {
1038             return false;
1039         }
1040         cr = env->cp15.dbgbcr[n];
1041     }
1042     /* The WATCHPOINT_HIT flag guarantees us that the watchpoint is
1043      * enabled and that the address and access type match; for breakpoints
1044      * we know the address matched; check the remaining fields, including
1045      * linked breakpoints. We rely on WCR and BCR having the same layout
1046      * for the LBN, SSC, HMC, PAC/PMC and is-linked fields.
1047      * Note that some combinations of {PAC, HMC, SSC} are reserved and
1048      * must act either like some valid combination or as if the watchpoint
1049      * were disabled. We choose the former, and use this together with
1050      * the fact that EL3 must always be Secure and EL2 must always be
1051      * Non-Secure to simplify the code slightly compared to the full
1052      * table in the ARM ARM.
1053      */
1054     pac = extract64(cr, 1, 2);
1055     hmc = extract64(cr, 13, 1);
1056     ssc = extract64(cr, 14, 2);
1057
1058     switch (ssc) {
1059     case 0:
1060         break;
1061     case 1:
1062     case 3:
1063         if (is_secure) {
1064             return false;
1065         }
1066         break;
1067     case 2:
1068         if (!is_secure) {
1069             return false;
1070         }
1071         break;
1072     }
1073
1074     switch (access_el) {
1075     case 3:
1076     case 2:
1077         if (!hmc) {
1078             return false;
1079         }
1080         break;
1081     case 1:
1082         if (extract32(pac, 0, 1) == 0) {
1083             return false;
1084         }
1085         break;
1086     case 0:
1087         if (extract32(pac, 1, 1) == 0) {
1088             return false;
1089         }
1090         break;
1091     default:
1092         g_assert_not_reached();
1093     }
1094
1095     wt = extract64(cr, 20, 1);
1096     lbn = extract64(cr, 16, 4);
1097
1098     if (wt && !linked_bp_matches(cpu, lbn)) {
1099         return false;
1100     }
1101
1102     return true;
1103 }
1104
1105 static bool check_watchpoints(ARMCPU *cpu)
1106 {
1107     CPUARMState *env = &cpu->env;
1108     int n;
1109
1110     /* If watchpoints are disabled globally or we can't take debug
1111      * exceptions here then watchpoint firings are ignored.
1112      */
1113     if (extract32(env->cp15.mdscr_el1, 15, 1) == 0
1114         || !arm_generate_debug_exceptions(env)) {
1115         return false;
1116     }
1117
1118     for (n = 0; n < ARRAY_SIZE(env->cpu_watchpoint); n++) {
1119         if (bp_wp_matches(cpu, n, true)) {
1120             return true;
1121         }
1122     }
1123     return false;
1124 }
1125
1126 static bool check_breakpoints(ARMCPU *cpu)
1127 {
1128     CPUARMState *env = &cpu->env;
1129     int n;
1130
1131     /* If breakpoints are disabled globally or we can't take debug
1132      * exceptions here then breakpoint firings are ignored.
1133      */
1134     if (extract32(env->cp15.mdscr_el1, 15, 1) == 0
1135         || !arm_generate_debug_exceptions(env)) {
1136         return false;
1137     }
1138
1139     for (n = 0; n < ARRAY_SIZE(env->cpu_breakpoint); n++) {
1140         if (bp_wp_matches(cpu, n, false)) {
1141             return true;
1142         }
1143     }
1144     return false;
1145 }
1146
1147 void HELPER(check_breakpoints)(CPUARMState *env)
1148 {
1149     ARMCPU *cpu = arm_env_get_cpu(env);
1150
1151     if (check_breakpoints(cpu)) {
1152         HELPER(exception_internal(env, EXCP_DEBUG));
1153     }
1154 }
1155
1156 bool arm_debug_check_watchpoint(CPUState *cs, CPUWatchpoint *wp)
1157 {
1158     /* Called by core code when a CPU watchpoint fires; need to check if this
1159      * is also an architectural watchpoint match.
1160      */
1161     ARMCPU *cpu = ARM_CPU(cs);
1162
1163     return check_watchpoints(cpu);
1164 }
1165
1166 void arm_debug_excp_handler(CPUState *cs)
1167 {
1168     /* Called by core code when a watchpoint or breakpoint fires;
1169      * need to check which one and raise the appropriate exception.
1170      */
1171     ARMCPU *cpu = ARM_CPU(cs);
1172     CPUARMState *env = &cpu->env;
1173     CPUWatchpoint *wp_hit = cs->watchpoint_hit;
1174
1175     if (wp_hit) {
1176         if (wp_hit->flags & BP_CPU) {
1177             bool wnr = (wp_hit->flags & BP_WATCHPOINT_HIT_WRITE) != 0;
1178             bool same_el = arm_debug_target_el(env) == arm_current_el(env);
1179
1180             cs->watchpoint_hit = NULL;
1181
1182             if (extended_addresses_enabled(env)) {
1183                 env->exception.fsr = (1 << 9) | 0x22;
1184             } else {
1185                 env->exception.fsr = 0x2;
1186             }
1187             env->exception.vaddress = wp_hit->hitaddr;
1188             raise_exception(env, EXCP_DATA_ABORT,
1189                     syn_watchpoint(same_el, 0, wnr),
1190                     arm_debug_target_el(env));
1191         }
1192     } else {
1193         uint64_t pc = is_a64(env) ? env->pc : env->regs[15];
1194         bool same_el = (arm_debug_target_el(env) == arm_current_el(env));
1195
1196         /* (1) GDB breakpoints should be handled first.
1197          * (2) Do not raise a CPU exception if no CPU breakpoint has fired,
1198          * since singlestep is also done by generating a debug internal
1199          * exception.
1200          */
1201         if (cpu_breakpoint_test(cs, pc, BP_GDB)
1202             || !cpu_breakpoint_test(cs, pc, BP_CPU)) {
1203             return;
1204         }
1205
1206         if (extended_addresses_enabled(env)) {
1207             env->exception.fsr = (1 << 9) | 0x22;
1208         } else {
1209             env->exception.fsr = 0x2;
1210         }
1211         /* FAR is UNKNOWN, so doesn't need setting */
1212         raise_exception(env, EXCP_PREFETCH_ABORT,
1213                         syn_breakpoint(same_el),
1214                         arm_debug_target_el(env));
1215     }
1216 }
1217
1218 /* ??? Flag setting arithmetic is awkward because we need to do comparisons.
1219    The only way to do that in TCG is a conditional branch, which clobbers
1220    all our temporaries.  For now implement these as helper functions.  */
1221
1222 /* Similarly for variable shift instructions.  */
1223
1224 uint32_t HELPER(shl_cc)(CPUARMState *env, uint32_t x, uint32_t i)
1225 {
1226     int shift = i & 0xff;
1227     if (shift >= 32) {
1228         if (shift == 32)
1229             env->CF = x & 1;
1230         else
1231             env->CF = 0;
1232         return 0;
1233     } else if (shift != 0) {
1234         env->CF = (x >> (32 - shift)) & 1;
1235         return x << shift;
1236     }
1237     return x;
1238 }
1239
1240 uint32_t HELPER(shr_cc)(CPUARMState *env, uint32_t x, uint32_t i)
1241 {
1242     int shift = i & 0xff;
1243     if (shift >= 32) {
1244         if (shift == 32)
1245             env->CF = (x >> 31) & 1;
1246         else
1247             env->CF = 0;
1248         return 0;
1249     } else if (shift != 0) {
1250         env->CF = (x >> (shift - 1)) & 1;
1251         return x >> shift;
1252     }
1253     return x;
1254 }
1255
1256 uint32_t HELPER(sar_cc)(CPUARMState *env, uint32_t x, uint32_t i)
1257 {
1258     int shift = i & 0xff;
1259     if (shift >= 32) {
1260         env->CF = (x >> 31) & 1;
1261         return (int32_t)x >> 31;
1262     } else if (shift != 0) {
1263         env->CF = (x >> (shift - 1)) & 1;
1264         return (int32_t)x >> shift;
1265     }
1266     return x;
1267 }
1268
1269 uint32_t HELPER(ror_cc)(CPUARMState *env, uint32_t x, uint32_t i)
1270 {
1271     int shift1, shift;
1272     shift1 = i & 0xff;
1273     shift = shift1 & 0x1f;
1274     if (shift == 0) {
1275         if (shift1 != 0)
1276             env->CF = (x >> 31) & 1;
1277         return x;
1278     } else {
1279         env->CF = (x >> (shift - 1)) & 1;
1280         return ((uint32_t)x >> shift) | (x << (32 - shift));
1281     }
1282 }