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