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 "cpu.h"
  20 #include "exec/helper-proto.h"
  21 #include "internals.h"
  22 #include "exec/cpu_ldst.h"
  23
  24 #define SIGNBIT (uint32_t)0x80000000
  25 #define SIGNBIT64 ((uint64_t)1 << 63)
  26
  27 static void raise_exception(CPUARMState *env, uint32_t excp,
  28                             uint32_t syndrome, uint32_t target_el)
  29 {
  30     CPUState *cs = CPU(arm_env_get_cpu(env));
  31
  32     assert(!excp_is_internal(excp));
  33     cs->exception_index = excp;
  34     env->exception.syndrome = syndrome;
  35     env->exception.target_el = target_el;
  36     cpu_loop_exit(cs);
  37 }
  38
  39 static int exception_target_el(CPUARMState *env)
  40 {
  41     int target_el = MAX(1, arm_current_el(env));
  42
  43     /* No such thing as secure EL1 if EL3 is aarch32, so update the target EL
  44      * to EL3 in this case.
  45      */
  46     if (arm_is_secure(env) && !arm_el_is_aa64(env, 3) && target_el == 1) {
  47         target_el = 3;
  48     }
  49
  50     return target_el;
  51 }
  52
  53 uint32_t HELPER(neon_tbl)(CPUARMState *env, uint32_t ireg, uint32_t def,
  54                           uint32_t rn, uint32_t maxindex)
  55 {
  56     uint32_t val;
  57     uint32_t tmp;
  58     int index;
  59     int shift;
  60     uint64_t *table;
  61     table = (uint64_t *)&env->vfp.regs[rn];
  62     val = 0;
  63     for (shift = 0; shift < 32; shift += 8) {
  64         index = (ireg >> shift) & 0xff;
  65         if (index < maxindex) {
  66             tmp = (table[index >> 3] >> ((index & 7) << 3)) & 0xff;
  67             val |= tmp << shift;
  68         } else {
  69             val |= def & (0xff << shift);
  70         }
  71     }
  72     return val;
  73 }
  74
  75 #if !defined(CONFIG_USER_ONLY)
  76
  77 /* try to fill the TLB and return an exception if error. If retaddr is
  78  * NULL, it means that the function was called in C code (i.e. not
  79  * from generated code or from helper.c)
  80  */
  81 void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
  82               uintptr_t retaddr)
  83 {
  84     bool ret;
  85     uint32_t fsr = 0;
  86
  87     ret = arm_tlb_fill(cs, addr, is_write, mmu_idx, &fsr);
  88     if (unlikely(ret)) {
  89         ARMCPU *cpu = ARM_CPU(cs);
  90         CPUARMState *env = &cpu->env;
  91         uint32_t syn, exc;
  92         bool same_el = (arm_current_el(env) != 0);
  93
  94         if (retaddr) {
  95             /* now we have a real cpu fault */
  96             cpu_restore_state(cs, retaddr);
  97         }
  98
  99         /* AArch64 syndrome does not have an LPAE bit */
 100         syn = fsr & ~(1 << 9);
 101
 102         /* For insn and data aborts we assume there is no instruction syndrome
 103          * information; this is always true for exceptions reported to EL1.
 104          */
 105         if (is_write == 2) {
 106             syn = syn_insn_abort(same_el, 0, 0, syn);
 107             exc = EXCP_PREFETCH_ABORT;
 108         } else {
 109             syn = syn_data_abort(same_el, 0, 0, 0, is_write == 1, syn);
 110             if (is_write == 1 && arm_feature(env, ARM_FEATURE_V6)) {
 111                 fsr |= (1 << 11);
 112             }
 113             exc = EXCP_DATA_ABORT;
 114         }
 115
 116         env->exception.vaddress = addr;
 117         env->exception.fsr = fsr;
 118         raise_exception(env, exc, syn, exception_target_el(env));
 119     }
 120 }
 121 #endif
 122
 123 uint32_t HELPER(add_setq)(CPUARMState *env, uint32_t a, uint32_t b)
 124 {
 125     uint32_t res = a + b;
 126     if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT))
 127         env->QF = 1;
 128     return res;
 129 }
 130
 131 uint32_t HELPER(add_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
 132 {
 133     uint32_t res = a + b;
 134     if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT)) {
 135         env->QF = 1;
 136         res = ~(((int32_t)a >> 31) ^ SIGNBIT);
 137     }
 138     return res;
 139 }
 140
 141 uint32_t HELPER(sub_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
 142 {
 143     uint32_t res = a - b;
 144     if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) {
 145         env->QF = 1;
 146         res = ~(((int32_t)a >> 31) ^ SIGNBIT);
 147     }
 148     return res;
 149 }
 150
 151 uint32_t HELPER(double_saturate)(CPUARMState *env, int32_t val)
 152 {
 153     uint32_t res;
 154     if (val >= 0x40000000) {
 155         res = ~SIGNBIT;
 156         env->QF = 1;
 157     } else if (val <= (int32_t)0xc0000000) {
 158         res = SIGNBIT;
 159         env->QF = 1;
 160     } else {
 161         res = val << 1;
 162     }
 163     return res;
 164 }
 165
 166 uint32_t HELPER(add_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
 167 {
 168     uint32_t res = a + b;
 169     if (res < a) {
 170         env->QF = 1;
 171         res = ~0;
 172     }
 173     return res;
 174 }
 175
 176 uint32_t HELPER(sub_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
 177 {
 178     uint32_t res = a - b;
 179     if (res > a) {
 180         env->QF = 1;
 181         res = 0;
 182     }
 183     return res;
 184 }
 185
 186 /* Signed saturation.  */
 187 static inline uint32_t do_ssat(CPUARMState *env, int32_t val, int shift)
 188 {
 189     int32_t top;
 190     uint32_t mask;
 191
 192     top = val >> shift;
 193     mask = (1u << shift) - 1;
 194     if (top > 0) {
 195         env->QF = 1;
 196         return mask;
 197     } else if (top < -1) {
 198         env->QF = 1;
 199         return ~mask;
 200     }
 201     return val;
 202 }
 203
 204 /* Unsigned saturation.  */
 205 static inline uint32_t do_usat(CPUARMState *env, int32_t val, int shift)
 206 {
 207     uint32_t max;
 208
 209     max = (1u << shift) - 1;
 210     if (val < 0) {
 211         env->QF = 1;
 212         return 0;
 213     } else if (val > max) {
 214         env->QF = 1;
 215         return max;
 216     }
 217     return val;
 218 }
 219
 220 /* Signed saturate.  */
 221 uint32_t HELPER(ssat)(CPUARMState *env, uint32_t x, uint32_t shift)
 222 {
 223     return do_ssat(env, x, shift);
 224 }
 225
 226 /* Dual halfword signed saturate.  */
 227 uint32_t HELPER(ssat16)(CPUARMState *env, uint32_t x, uint32_t shift)
 228 {
 229     uint32_t res;
 230
 231     res = (uint16_t)do_ssat(env, (int16_t)x, shift);
 232     res |= do_ssat(env, ((int32_t)x) >> 16, shift) << 16;
 233     return res;
 234 }
 235
 236 /* Unsigned saturate.  */
 237 uint32_t HELPER(usat)(CPUARMState *env, uint32_t x, uint32_t shift)
 238 {
 239     return do_usat(env, x, shift);
 240 }
 241
 242 /* Dual halfword unsigned saturate.  */
 243 uint32_t HELPER(usat16)(CPUARMState *env, uint32_t x, uint32_t shift)
 244 {
 245     uint32_t res;
 246
 247     res = (uint16_t)do_usat(env, (int16_t)x, shift);
 248     res |= do_usat(env, ((int32_t)x) >> 16, shift) << 16;
 249     return res;
 250 }
 251
 252 /* Function checks whether WFx (WFI/WFE) instructions are set up to be trapped.
 253  * The function returns the target EL (1-3) if the instruction is to be trapped;
 254  * otherwise it returns 0 indicating it is not trapped.
 255  */
 256 static inline int check_wfx_trap(CPUARMState *env, bool is_wfe)
 257 {
 258     int cur_el = arm_current_el(env);
 259     uint64_t mask;
 260
 261     /* If we are currently in EL0 then we need to check if SCTLR is set up for
 262      * WFx instructions being trapped to EL1. These trap bits don't exist in v7.
 263      */
 264     if (cur_el < 1 && arm_feature(env, ARM_FEATURE_V8)) {
 265         int target_el;
 266
 267         mask = is_wfe ? SCTLR_nTWE : SCTLR_nTWI;
 268         if (arm_is_secure_below_el3(env) && !arm_el_is_aa64(env, 3)) {
 269             /* Secure EL0 and Secure PL1 is at EL3 */
 270             target_el = 3;
 271         } else {
 272             target_el = 1;
 273         }
 274
 275         if (!(env->cp15.sctlr_el[target_el] & mask)) {
 276             return target_el;
 277         }
 278     }
 279
 280     /* We are not trapping to EL1; trap to EL2 if HCR_EL2 requires it
 281      * No need for ARM_FEATURE check as if HCR_EL2 doesn't exist the
 282      * bits will be zero indicating no trap.
 283      */
 284     if (cur_el < 2 && !arm_is_secure(env)) {
 285         mask = (is_wfe) ? HCR_TWE : HCR_TWI;
 286         if (env->cp15.hcr_el2 & mask) {
 287             return 2;
 288         }
 289     }
 290
 291     /* We are not trapping to EL1 or EL2; trap to EL3 if SCR_EL3 requires it */
 292     if (cur_el < 3) {
 293         mask = (is_wfe) ? SCR_TWE : SCR_TWI;
 294         if (env->cp15.scr_el3 & mask) {
 295             return 3;
 296         }
 297     }
 298
 299     return 0;
 300 }
 301
 302 void HELPER(wfi)(CPUARMState *env)
 303 {
 304     CPUState *cs = CPU(arm_env_get_cpu(env));
 305     int target_el = check_wfx_trap(env, false);
 306
 307     if (cpu_has_work(cs)) {
 308         /* Don't bother to go into our "low power state" if
 309          * we would just wake up immediately.
 310          */
 311         return;
 312     }
 313
 314     if (target_el) {
 315         env->pc -= 4;
 316         raise_exception(env, EXCP_UDEF, syn_wfx(1, 0xe, 0), target_el);
 317     }
 318
 319     cs->exception_index = EXCP_HLT;
 320     cs->halted = 1;
 321     cpu_loop_exit(cs);
 322 }
 323
 324 void HELPER(wfe)(CPUARMState *env)
 325 {
 326     /* This is a hint instruction that is semantically different
 327      * from YIELD even though we currently implement it identically.
 328      * Don't actually halt the CPU, just yield back to top
 329      * level loop. This is not going into a "low power state"
 330      * (ie halting until some event occurs), so we never take
 331      * a configurable trap to a different exception level.
 332      */
 333     HELPER(yield)(env);
 334 }
 335
 336 void HELPER(yield)(CPUARMState *env)
 337 {
 338     ARMCPU *cpu = arm_env_get_cpu(env);
 339     CPUState *cs = CPU(cpu);
 340
 341     /* This is a non-trappable hint instruction that generally indicates
 342      * that the guest is currently busy-looping. Yield control back to the
 343      * top level loop so that a more deserving VCPU has a chance to run.
 344      */
 345     cs->exception_index = EXCP_YIELD;
 346     cpu_loop_exit(cs);
 347 }
 348
 349 /* Raise an internal-to-QEMU exception. This is limited to only
 350  * those EXCP values which are special cases for QEMU to interrupt
 351  * execution and not to be used for exceptions which are passed to
 352  * the guest (those must all have syndrome information and thus should
 353  * use exception_with_syndrome).
 354  */
 355 void HELPER(exception_internal)(CPUARMState *env, uint32_t excp)
 356 {
 357     CPUState *cs = CPU(arm_env_get_cpu(env));
 358
 359     assert(excp_is_internal(excp));
 360     cs->exception_index = excp;
 361     cpu_loop_exit(cs);
 362 }
 363
 364 /* Raise an exception with the specified syndrome register value */
 365 void HELPER(exception_with_syndrome)(CPUARMState *env, uint32_t excp,
 366                                      uint32_t syndrome, uint32_t target_el)
 367 {
 368     raise_exception(env, excp, syndrome, target_el);
 369 }
 370
 371 uint32_t HELPER(cpsr_read)(CPUARMState *env)
 372 {
 373     return cpsr_read(env) & ~(CPSR_EXEC | CPSR_RESERVED);
 374 }
 375
 376 void HELPER(cpsr_write)(CPUARMState *env, uint32_t val, uint32_t mask)
 377 {
 378     cpsr_write(env, val, mask);
 379 }
 380
 381 /* Access to user mode registers from privileged modes.  */
 382 uint32_t HELPER(get_user_reg)(CPUARMState *env, uint32_t regno)
 383 {
 384     uint32_t val;
 385
 386     if (regno == 13) {
 387         val = env->banked_r13[0];
 388     } else if (regno == 14) {
 389         val = env->banked_r14[0];
 390     } else if (regno >= 8
 391                && (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
 392         val = env->usr_regs[regno - 8];
 393     } else {
 394         val = env->regs[regno];
 395     }
 396     return val;
 397 }
 398
 399 void HELPER(set_user_reg)(CPUARMState *env, uint32_t regno, uint32_t val)
 400 {
 401     if (regno == 13) {
 402         env->banked_r13[0] = val;
 403     } else if (regno == 14) {
 404         env->banked_r14[0] = val;
 405     } else if (regno >= 8
 406                && (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
 407         env->usr_regs[regno - 8] = val;
 408     } else {
 409         env->regs[regno] = val;
 410     }
 411 }
 412
 413 void HELPER(access_check_cp_reg)(CPUARMState *env, void *rip, uint32_t syndrome)
 414 {
 415     const ARMCPRegInfo *ri = rip;
 416     int target_el;
 417
 418     if (arm_feature(env, ARM_FEATURE_XSCALE) && ri->cp < 14
 419         && extract32(env->cp15.c15_cpar, ri->cp, 1) == 0) {
 420         raise_exception(env, EXCP_UDEF, syndrome, exception_target_el(env));
 421     }
 422
 423     if (!ri->accessfn) {
 424         return;
 425     }
 426
 427     switch (ri->accessfn(env, ri)) {
 428     case CP_ACCESS_OK:
 429         return;
 430     case CP_ACCESS_TRAP:
 431         target_el = exception_target_el(env);
 432         break;
 433     case CP_ACCESS_TRAP_EL2:
 434         /* Requesting a trap to EL2 when we're in EL3 or S-EL0/1 is
 435          * a bug in the access function.
 436          */
 437         assert(!arm_is_secure(env) && arm_current_el(env) != 3);
 438         target_el = 2;
 439         break;
 440     case CP_ACCESS_TRAP_EL3:
 441         target_el = 3;
 442         break;
 443     case CP_ACCESS_TRAP_UNCATEGORIZED:
 444         target_el = exception_target_el(env);
 445         syndrome = syn_uncategorized();
 446         break;
 447     case CP_ACCESS_TRAP_UNCATEGORIZED_EL2:
 448         target_el = 2;
 449         syndrome = syn_uncategorized();
 450         break;
 451     case CP_ACCESS_TRAP_UNCATEGORIZED_EL3:
 452         target_el = 3;
 453         syndrome = syn_uncategorized();
 454         break;
 455     default:
 456         g_assert_not_reached();
 457     }
 458
 459     raise_exception(env, EXCP_UDEF, syndrome, target_el);
 460 }
 461
 462 void HELPER(set_cp_reg)(CPUARMState *env, void *rip, uint32_t value)
 463 {
 464     const ARMCPRegInfo *ri = rip;
 465
 466     ri->writefn(env, ri, value);
 467 }
 468
 469 uint32_t HELPER(get_cp_reg)(CPUARMState *env, void *rip)
 470 {
 471     const ARMCPRegInfo *ri = rip;
 472
 473     return ri->readfn(env, ri);
 474 }
 475
 476 void HELPER(set_cp_reg64)(CPUARMState *env, void *rip, uint64_t value)
 477 {
 478     const ARMCPRegInfo *ri = rip;
 479
 480     ri->writefn(env, ri, value);
 481 }
 482
 483 uint64_t HELPER(get_cp_reg64)(CPUARMState *env, void *rip)
 484 {
 485     const ARMCPRegInfo *ri = rip;
 486
 487     return ri->readfn(env, ri);
 488 }
 489
 490 void HELPER(msr_i_pstate)(CPUARMState *env, uint32_t op, uint32_t imm)
 491 {
 492     /* MSR_i to update PSTATE. This is OK from EL0 only if UMA is set.
 493      * Note that SPSel is never OK from EL0; we rely on handle_msr_i()
 494      * to catch that case at translate time.
 495      */
 496     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_UMA)) {
 497         uint32_t syndrome = syn_aa64_sysregtrap(0, extract32(op, 0, 3),
 498                                                 extract32(op, 3, 3), 4,
 499                                                 imm, 0x1f, 0);
 500         raise_exception(env, EXCP_UDEF, syndrome, exception_target_el(env));
 501     }
 502
 503     switch (op) {
 504     case 0x05: /* SPSel */
 505         update_spsel(env, imm);
 506         break;
 507     case 0x1e: /* DAIFSet */
 508         env->daif |= (imm << 6) & PSTATE_DAIF;
 509         break;
 510     case 0x1f: /* DAIFClear */
 511         env->daif &= ~((imm << 6) & PSTATE_DAIF);
 512         break;
 513     default:
 514         g_assert_not_reached();
 515     }
 516 }
 517
 518 void HELPER(clear_pstate_ss)(CPUARMState *env)
 519 {
 520     env->pstate &= ~PSTATE_SS;
 521 }
 522
 523 void HELPER(pre_hvc)(CPUARMState *env)
 524 {
 525     ARMCPU *cpu = arm_env_get_cpu(env);
 526     int cur_el = arm_current_el(env);
 527     /* FIXME: Use actual secure state.  */
 528     bool secure = false;
 529     bool undef;
 530
 531     if (arm_is_psci_call(cpu, EXCP_HVC)) {
 532         /* If PSCI is enabled and this looks like a valid PSCI call then
 533          * that overrides the architecturally mandated HVC behaviour.
 534          */
 535         return;
 536     }
 537
 538     if (!arm_feature(env, ARM_FEATURE_EL2)) {
 539         /* If EL2 doesn't exist, HVC always UNDEFs */
 540         undef = true;
 541     } else if (arm_feature(env, ARM_FEATURE_EL3)) {
 542         /* EL3.HCE has priority over EL2.HCD. */
 543         undef = !(env->cp15.scr_el3 & SCR_HCE);
 544     } else {
 545         undef = env->cp15.hcr_el2 & HCR_HCD;
 546     }
 547
 548     /* In ARMv7 and ARMv8/AArch32, HVC is undef in secure state.
 549      * For ARMv8/AArch64, HVC is allowed in EL3.
 550      * Note that we've already trapped HVC from EL0 at translation
 551      * time.
 552      */
 553     if (secure && (!is_a64(env) || cur_el == 1)) {
 554         undef = true;
 555     }
 556
 557     if (undef) {
 558         raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 559                         exception_target_el(env));
 560     }
 561 }
 562
 563 void HELPER(pre_smc)(CPUARMState *env, uint32_t syndrome)
 564 {
 565     ARMCPU *cpu = arm_env_get_cpu(env);
 566     int cur_el = arm_current_el(env);
 567     bool secure = arm_is_secure(env);
 568     bool smd = env->cp15.scr_el3 & SCR_SMD;
 569     /* On ARMv8 AArch32, SMD only applies to NS state.
 570      * On ARMv7 SMD only applies to NS state and only if EL2 is available.
 571      * For ARMv7 non EL2, we force SMD to zero so we don't need to re-check
 572      * the EL2 condition here.
 573      */
 574     bool undef = is_a64(env) ? smd : (!secure && smd);
 575
 576     if (arm_is_psci_call(cpu, EXCP_SMC)) {
 577         /* If PSCI is enabled and this looks like a valid PSCI call then
 578          * that overrides the architecturally mandated SMC behaviour.
 579          */
 580         return;
 581     }
 582
 583     if (!arm_feature(env, ARM_FEATURE_EL3)) {
 584         /* If we have no EL3 then SMC always UNDEFs */
 585         undef = true;
 586     } else if (!secure && cur_el == 1 && (env->cp15.hcr_el2 & HCR_TSC)) {
 587         /* In NS EL1, HCR controlled routing to EL2 has priority over SMD. */
 588         raise_exception(env, EXCP_HYP_TRAP, syndrome, 2);
 589     }
 590
 591     if (undef) {
 592         raise_exception(env, EXCP_UDEF, syn_uncategorized(),
 593                         exception_target_el(env));
 594     }
 595 }
 596
 597 void HELPER(exception_return)(CPUARMState *env)
 598 {
 599     int cur_el = arm_current_el(env);
 600     unsigned int spsr_idx = aarch64_banked_spsr_index(cur_el);
 601     uint32_t spsr = env->banked_spsr[spsr_idx];
 602     int new_el;
 603
 604     aarch64_save_sp(env, cur_el);
 605
 606     env->exclusive_addr = -1;
 607
 608     /* We must squash the PSTATE.SS bit to zero unless both of the
 609      * following hold:
 610      *  1. debug exceptions are currently disabled
 611      *  2. singlestep will be active in the EL we return to
 612      * We check 1 here and 2 after we've done the pstate/cpsr write() to
 613      * transition to the EL we're going to.
 614      */
 615     if (arm_generate_debug_exceptions(env)) {
 616         spsr &= ~PSTATE_SS;
 617     }
 618
 619     if (spsr & PSTATE_nRW) {
 620         /* TODO: We currently assume EL1/2/3 are running in AArch64.  */
 621         env->aarch64 = 0;
 622         new_el = 0;
 623         env->uncached_cpsr = 0x10;
 624         cpsr_write(env, spsr, ~0);
 625         if (!arm_singlestep_active(env)) {
 626             env->uncached_cpsr &= ~PSTATE_SS;
 627         }
 628         aarch64_sync_64_to_32(env);
 629
 630         env->regs[15] = env->elr_el[1] & ~0x1;
 631     } else {
 632         new_el = extract32(spsr, 2, 2);
 633         if (new_el > cur_el
 634             || (new_el == 2 && !arm_feature(env, ARM_FEATURE_EL2))) {
 635             /* Disallow return to an EL which is unimplemented or higher
 636              * than the current one.
 637              */
 638             goto illegal_return;
 639         }
 640         if (extract32(spsr, 1, 1)) {
 641             /* Return with reserved M[1] bit set */
 642             goto illegal_return;
 643         }
 644         if (new_el == 0 && (spsr & PSTATE_SP)) {
 645             /* Return to EL0 with M[0] bit set */
 646             goto illegal_return;
 647         }
 648         env->aarch64 = 1;
 649         pstate_write(env, spsr);
 650         if (!arm_singlestep_active(env)) {
 651             env->pstate &= ~PSTATE_SS;
 652         }
 653         aarch64_restore_sp(env, new_el);
 654         env->pc = env->elr_el[cur_el];
 655     }
 656
 657     return;
 658
 659 illegal_return:
 660     /* Illegal return events of various kinds have architecturally
 661      * mandated behaviour:
 662      * restore NZCV and DAIF from SPSR_ELx
 663      * set PSTATE.IL
 664      * restore PC from ELR_ELx
 665      * no change to exception level, execution state or stack pointer
 666      */
 667     env->pstate |= PSTATE_IL;
 668     env->pc = env->elr_el[cur_el];
 669     spsr &= PSTATE_NZCV | PSTATE_DAIF;
 670     spsr |= pstate_read(env) & ~(PSTATE_NZCV | PSTATE_DAIF);
 671     pstate_write(env, spsr);
 672     if (!arm_singlestep_active(env)) {
 673         env->pstate &= ~PSTATE_SS;
 674     }
 675 }
 676
 677 /* Return true if the linked breakpoint entry lbn passes its checks */
 678 static bool linked_bp_matches(ARMCPU *cpu, int lbn)
 679 {
 680     CPUARMState *env = &cpu->env;
 681     uint64_t bcr = env->cp15.dbgbcr[lbn];
 682     int brps = extract32(cpu->dbgdidr, 24, 4);
 683     int ctx_cmps = extract32(cpu->dbgdidr, 20, 4);
 684     int bt;
 685     uint32_t contextidr;
 686
 687     /* Links to unimplemented or non-context aware breakpoints are
 688      * CONSTRAINED UNPREDICTABLE: either behave as if disabled, or
 689      * as if linked to an UNKNOWN context-aware breakpoint (in which
 690      * case DBGWCR<n>_EL1.LBN must indicate that breakpoint).
 691      * We choose the former.
 692      */
 693     if (lbn > brps || lbn < (brps - ctx_cmps)) {
 694         return false;
 695     }
 696
 697     bcr = env->cp15.dbgbcr[lbn];
 698
 699     if (extract64(bcr, 0, 1) == 0) {
 700         /* Linked breakpoint disabled : generate no events */
 701         return false;
 702     }
 703
 704     bt = extract64(bcr, 20, 4);
 705
 706     /* We match the whole register even if this is AArch32 using the
 707      * short descriptor format (in which case it holds both PROCID and ASID),
 708      * since we don't implement the optional v7 context ID masking.
 709      */
 710     contextidr = extract64(env->cp15.contextidr_el[1], 0, 32);
 711
 712     switch (bt) {
 713     case 3: /* linked context ID match */
 714         if (arm_current_el(env) > 1) {
 715             /* Context matches never fire in EL2 or (AArch64) EL3 */
 716             return false;
 717         }
 718         return (contextidr == extract64(env->cp15.dbgbvr[lbn], 0, 32));
 719     case 5: /* linked address mismatch (reserved in AArch64) */
 720     case 9: /* linked VMID match (reserved if no EL2) */
 721     case 11: /* linked context ID and VMID match (reserved if no EL2) */
 722     default:
 723         /* Links to Unlinked context breakpoints must generate no
 724          * events; we choose to do the same for reserved values too.
 725          */
 726         return false;
 727     }
 728
 729     return false;
 730 }
 731
 732 static bool bp_wp_matches(ARMCPU *cpu, int n, bool is_wp)
 733 {
 734     CPUARMState *env = &cpu->env;
 735     uint64_t cr;
 736     int pac, hmc, ssc, wt, lbn;
 737     /* Note that for watchpoints the check is against the CPU security
 738      * state, not the S/NS attribute on the offending data access.
 739      */
 740     bool is_secure = arm_is_secure(env);
 741     int access_el = arm_current_el(env);
 742
 743     if (is_wp) {
 744         CPUWatchpoint *wp = env->cpu_watchpoint[n];
 745
 746         if (!wp || !(wp->flags & BP_WATCHPOINT_HIT)) {
 747             return false;
 748         }
 749         cr = env->cp15.dbgwcr[n];
 750         if (wp->hitattrs.user) {
 751             /* The LDRT/STRT/LDT/STT "unprivileged access" instructions should
 752              * match watchpoints as if they were accesses done at EL0, even if
 753              * the CPU is at EL1 or higher.
 754              */
 755             access_el = 0;
 756         }
 757     } else {
 758         uint64_t pc = is_a64(env) ? env->pc : env->regs[15];
 759
 760         if (!env->cpu_breakpoint[n] || env->cpu_breakpoint[n]->pc != pc) {
 761             return false;
 762         }
 763         cr = env->cp15.dbgbcr[n];
 764     }
 765     /* The WATCHPOINT_HIT flag guarantees us that the watchpoint is
 766      * enabled and that the address and access type match; for breakpoints
 767      * we know the address matched; check the remaining fields, including
 768      * linked breakpoints. We rely on WCR and BCR having the same layout
 769      * for the LBN, SSC, HMC, PAC/PMC and is-linked fields.
 770      * Note that some combinations of {PAC, HMC, SSC} are reserved and
 771      * must act either like some valid combination or as if the watchpoint
 772      * were disabled. We choose the former, and use this together with
 773      * the fact that EL3 must always be Secure and EL2 must always be
 774      * Non-Secure to simplify the code slightly compared to the full
 775      * table in the ARM ARM.
 776      */
 777     pac = extract64(cr, 1, 2);
 778     hmc = extract64(cr, 13, 1);
 779     ssc = extract64(cr, 14, 2);
 780
 781     switch (ssc) {
 782     case 0:
 783         break;
 784     case 1:
 785     case 3:
 786         if (is_secure) {
 787             return false;
 788         }
 789         break;
 790     case 2:
 791         if (!is_secure) {
 792             return false;
 793         }
 794         break;
 795     }
 796
 797     switch (access_el) {
 798     case 3:
 799     case 2:
 800         if (!hmc) {
 801             return false;
 802         }
 803         break;
 804     case 1:
 805         if (extract32(pac, 0, 1) == 0) {
 806             return false;
 807         }
 808         break;
 809     case 0:
 810         if (extract32(pac, 1, 1) == 0) {
 811             return false;
 812         }
 813         break;
 814     default:
 815         g_assert_not_reached();
 816     }
 817
 818     wt = extract64(cr, 20, 1);
 819     lbn = extract64(cr, 16, 4);
 820
 821     if (wt && !linked_bp_matches(cpu, lbn)) {
 822         return false;
 823     }
 824
 825     return true;
 826 }
 827
 828 static bool check_watchpoints(ARMCPU *cpu)
 829 {
 830     CPUARMState *env = &cpu->env;
 831     int n;
 832
 833     /* If watchpoints are disabled globally or we can't take debug
 834      * exceptions here then watchpoint firings are ignored.
 835      */
 836     if (extract32(env->cp15.mdscr_el1, 15, 1) == 0
 837         || !arm_generate_debug_exceptions(env)) {
 838         return false;
 839     }
 840
 841     for (n = 0; n < ARRAY_SIZE(env->cpu_watchpoint); n++) {
 842         if (bp_wp_matches(cpu, n, true)) {
 843             return true;
 844         }
 845     }
 846     return false;
 847 }
 848
 849 static bool check_breakpoints(ARMCPU *cpu)
 850 {
 851     CPUARMState *env = &cpu->env;
 852     int n;
 853
 854     /* If breakpoints are disabled globally or we can't take debug
 855      * exceptions here then breakpoint firings are ignored.
 856      */
 857     if (extract32(env->cp15.mdscr_el1, 15, 1) == 0
 858         || !arm_generate_debug_exceptions(env)) {
 859         return false;
 860     }
 861
 862     for (n = 0; n < ARRAY_SIZE(env->cpu_breakpoint); n++) {
 863         if (bp_wp_matches(cpu, n, false)) {
 864             return true;
 865         }
 866     }
 867     return false;
 868 }
 869
 870 void arm_debug_excp_handler(CPUState *cs)
 871 {
 872     /* Called by core code when a watchpoint or breakpoint fires;
 873      * need to check which one and raise the appropriate exception.
 874      */
 875     ARMCPU *cpu = ARM_CPU(cs);
 876     CPUARMState *env = &cpu->env;
 877     CPUWatchpoint *wp_hit = cs->watchpoint_hit;
 878
 879     if (wp_hit) {
 880         if (wp_hit->flags & BP_CPU) {
 881             cs->watchpoint_hit = NULL;
 882             if (check_watchpoints(cpu)) {
 883                 bool wnr = (wp_hit->flags & BP_WATCHPOINT_HIT_WRITE) != 0;
 884                 bool same_el = arm_debug_target_el(env) == arm_current_el(env);
 885
 886                 if (extended_addresses_enabled(env)) {
 887                     env->exception.fsr = (1 << 9) | 0x22;
 888                 } else {
 889                     env->exception.fsr = 0x2;
 890                 }
 891                 env->exception.vaddress = wp_hit->hitaddr;
 892                 raise_exception(env, EXCP_DATA_ABORT,
 893                                 syn_watchpoint(same_el, 0, wnr),
 894                                 arm_debug_target_el(env));
 895             } else {
 896                 cpu_resume_from_signal(cs, NULL);
 897             }
 898         }
 899     } else {
 900         if (check_breakpoints(cpu)) {
 901             bool same_el = (arm_debug_target_el(env) == arm_current_el(env));
 902             if (extended_addresses_enabled(env)) {
 903                 env->exception.fsr = (1 << 9) | 0x22;
 904             } else {
 905                 env->exception.fsr = 0x2;
 906             }
 907             /* FAR is UNKNOWN, so doesn't need setting */
 908             raise_exception(env, EXCP_PREFETCH_ABORT,
 909                             syn_breakpoint(same_el),
 910                             arm_debug_target_el(env));
 911         }
 912     }
 913 }
 914
 915 /* ??? Flag setting arithmetic is awkward because we need to do comparisons.
 916    The only way to do that in TCG is a conditional branch, which clobbers
 917    all our temporaries.  For now implement these as helper functions.  */
 918
 919 /* Similarly for variable shift instructions.  */
 920
 921 uint32_t HELPER(shl_cc)(CPUARMState *env, uint32_t x, uint32_t i)
 922 {
 923     int shift = i & 0xff;
 924     if (shift >= 32) {
 925         if (shift == 32)
 926             env->CF = x & 1;
 927         else
 928             env->CF = 0;
 929         return 0;
 930     } else if (shift != 0) {
 931         env->CF = (x >> (32 - shift)) & 1;
 932         return x << shift;
 933     }
 934     return x;
 935 }
 936
 937 uint32_t HELPER(shr_cc)(CPUARMState *env, uint32_t x, uint32_t i)
 938 {
 939     int shift = i & 0xff;
 940     if (shift >= 32) {
 941         if (shift == 32)
 942             env->CF = (x >> 31) & 1;
 943         else
 944             env->CF = 0;
 945         return 0;
 946     } else if (shift != 0) {
 947         env->CF = (x >> (shift - 1)) & 1;
 948         return x >> shift;
 949     }
 950     return x;
 951 }
 952
 953 uint32_t HELPER(sar_cc)(CPUARMState *env, uint32_t x, uint32_t i)
 954 {
 955     int shift = i & 0xff;
 956     if (shift >= 32) {
 957         env->CF = (x >> 31) & 1;
 958         return (int32_t)x >> 31;
 959     } else if (shift != 0) {
 960         env->CF = (x >> (shift - 1)) & 1;
 961         return (int32_t)x >> shift;
 962     }
 963     return x;
 964 }
 965
 966 uint32_t HELPER(ror_cc)(CPUARMState *env, uint32_t x, uint32_t i)
 967 {
 968     int shift1, shift;
 969     shift1 = i & 0xff;
 970     shift = shift1 & 0x1f;
 971     if (shift == 0) {
 972         if (shift1 != 0)
 973             env->CF = (x >> 31) & 1;
 974         return x;
 975     } else {
 976         env->CF = (x >> (shift - 1)) & 1;
 977         return ((uint32_t)x >> shift) | (x << (32 - shift));
 978     }
 979 }