target/arm/helper.c

   1 #include "qemu/osdep.h"
   2 #include "target/arm/idau.h"
   3 #include "trace.h"
   4 #include "cpu.h"
   5 #include "internals.h"
   6 #include "exec/gdbstub.h"
   7 #include "exec/helper-proto.h"
   8 #include "qemu/host-utils.h"
   9 #include "sysemu/arch_init.h"
  10 #include "sysemu/sysemu.h"
  11 #include "qemu/bitops.h"
  12 #include "qemu/crc32c.h"
  13 #include "qemu/qemu-print.h"
  14 #include "exec/exec-all.h"
  15 #include "exec/cpu_ldst.h"
  16 #include "arm_ldst.h"
  17 #include <zlib.h> /* For crc32 */
  18 #include "exec/semihost.h"
  19 #include "sysemu/cpus.h"
  20 #include "sysemu/kvm.h"
  21 #include "fpu/softfloat.h"
  22 #include "qemu/range.h"
  23 #include "qapi/qapi-commands-target.h"
  24
  25 #define ARM_CPU_FREQ 1000000000 /* FIXME: 1 GHz, should be configurable */
  26
  27 #ifndef CONFIG_USER_ONLY
  28 /* Cacheability and shareability attributes for a memory access */
  29 typedef struct ARMCacheAttrs {
  30     unsigned int attrs:8; /* as in the MAIR register encoding */
  31     unsigned int shareability:2; /* as in the SH field of the VMSAv8-64 PTEs */
  32 } ARMCacheAttrs;
  33
  34 static bool get_phys_addr(CPUARMState *env, target_ulong address,
  35                           MMUAccessType access_type, ARMMMUIdx mmu_idx,
  36                           hwaddr *phys_ptr, MemTxAttrs *attrs, int *prot,
  37                           target_ulong *page_size,
  38                           ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs);
  39
  40 static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address,
  41                                MMUAccessType access_type, ARMMMUIdx mmu_idx,
  42                                hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot,
  43                                target_ulong *page_size_ptr,
  44                                ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs);
  45
  46 /* Security attributes for an address, as returned by v8m_security_lookup. */
  47 typedef struct V8M_SAttributes {
  48     bool subpage; /* true if these attrs don't cover the whole TARGET_PAGE */
  49     bool ns;
  50     bool nsc;
  51     uint8_t sregion;
  52     bool srvalid;
  53     uint8_t iregion;
  54     bool irvalid;
  55 } V8M_SAttributes;
  56
  57 static void v8m_security_lookup(CPUARMState *env, uint32_t address,
  58                                 MMUAccessType access_type, ARMMMUIdx mmu_idx,
  59                                 V8M_SAttributes *sattrs);
  60 #endif
  61
  62 static void switch_mode(CPUARMState *env, int mode);
  63
  64 static int vfp_gdb_get_reg(CPUARMState *env, uint8_t *buf, int reg)
  65 {
  66     int nregs;
  67
  68     /* VFP data registers are always little-endian.  */
  69     nregs = arm_feature(env, ARM_FEATURE_VFP3) ? 32 : 16;
  70     if (reg < nregs) {
  71         stq_le_p(buf, *aa32_vfp_dreg(env, reg));
  72         return 8;
  73     }
  74     if (arm_feature(env, ARM_FEATURE_NEON)) {
  75         /* Aliases for Q regs.  */
  76         nregs += 16;
  77         if (reg < nregs) {
  78             uint64_t *q = aa32_vfp_qreg(env, reg - 32);
  79             stq_le_p(buf, q[0]);
  80             stq_le_p(buf + 8, q[1]);
  81             return 16;
  82         }
  83     }
  84     switch (reg - nregs) {
  85     case 0: stl_p(buf, env->vfp.xregs[ARM_VFP_FPSID]); return 4;
  86     case 1: stl_p(buf, vfp_get_fpscr(env)); return 4;
  87     case 2: stl_p(buf, env->vfp.xregs[ARM_VFP_FPEXC]); return 4;
  88     }
  89     return 0;
  90 }
  91
  92 static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg)
  93 {
  94     int nregs;
  95
  96     nregs = arm_feature(env, ARM_FEATURE_VFP3) ? 32 : 16;
  97     if (reg < nregs) {
  98         *aa32_vfp_dreg(env, reg) = ldq_le_p(buf);
  99         return 8;
 100     }
 101     if (arm_feature(env, ARM_FEATURE_NEON)) {
 102         nregs += 16;
 103         if (reg < nregs) {
 104             uint64_t *q = aa32_vfp_qreg(env, reg - 32);
 105             q[0] = ldq_le_p(buf);
 106             q[1] = ldq_le_p(buf + 8);
 107             return 16;
 108         }
 109     }
 110     switch (reg - nregs) {
 111     case 0: env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); return 4;
 112     case 1: vfp_set_fpscr(env, ldl_p(buf)); return 4;
 113     case 2: env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); return 4;
 114     }
 115     return 0;
 116 }
 117
 118 static int aarch64_fpu_gdb_get_reg(CPUARMState *env, uint8_t *buf, int reg)
 119 {
 120     switch (reg) {
 121     case 0 ... 31:
 122         /* 128 bit FP register */
 123         {
 124             uint64_t *q = aa64_vfp_qreg(env, reg);
 125             stq_le_p(buf, q[0]);
 126             stq_le_p(buf + 8, q[1]);
 127             return 16;
 128         }
 129     case 32:
 130         /* FPSR */
 131         stl_p(buf, vfp_get_fpsr(env));
 132         return 4;
 133     case 33:
 134         /* FPCR */
 135         stl_p(buf, vfp_get_fpcr(env));
 136         return 4;
 137     default:
 138         return 0;
 139     }
 140 }
 141
 142 static int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg)
 143 {
 144     switch (reg) {
 145     case 0 ... 31:
 146         /* 128 bit FP register */
 147         {
 148             uint64_t *q = aa64_vfp_qreg(env, reg);
 149             q[0] = ldq_le_p(buf);
 150             q[1] = ldq_le_p(buf + 8);
 151             return 16;
 152         }
 153     case 32:
 154         /* FPSR */
 155         vfp_set_fpsr(env, ldl_p(buf));
 156         return 4;
 157     case 33:
 158         /* FPCR */
 159         vfp_set_fpcr(env, ldl_p(buf));
 160         return 4;
 161     default:
 162         return 0;
 163     }
 164 }
 165
 166 static uint64_t raw_read(CPUARMState *env, const ARMCPRegInfo *ri)
 167 {
 168     assert(ri->fieldoffset);
 169     if (cpreg_field_is_64bit(ri)) {
 170         return CPREG_FIELD64(env, ri);
 171     } else {
 172         return CPREG_FIELD32(env, ri);
 173     }
 174 }
 175
 176 static void raw_write(CPUARMState *env, const ARMCPRegInfo *ri,
 177                       uint64_t value)
 178 {
 179     assert(ri->fieldoffset);
 180     if (cpreg_field_is_64bit(ri)) {
 181         CPREG_FIELD64(env, ri) = value;
 182     } else {
 183         CPREG_FIELD32(env, ri) = value;
 184     }
 185 }
 186
 187 static void *raw_ptr(CPUARMState *env, const ARMCPRegInfo *ri)
 188 {
 189     return (char *)env + ri->fieldoffset;
 190 }
 191
 192 uint64_t read_raw_cp_reg(CPUARMState *env, const ARMCPRegInfo *ri)
 193 {
 194     /* Raw read of a coprocessor register (as needed for migration, etc). */
 195     if (ri->type & ARM_CP_CONST) {
 196         return ri->resetvalue;
 197     } else if (ri->raw_readfn) {
 198         return ri->raw_readfn(env, ri);
 199     } else if (ri->readfn) {
 200         return ri->readfn(env, ri);
 201     } else {
 202         return raw_read(env, ri);
 203     }
 204 }
 205
 206 static void write_raw_cp_reg(CPUARMState *env, const ARMCPRegInfo *ri,
 207                              uint64_t v)
 208 {
 209     /* Raw write of a coprocessor register (as needed for migration, etc).
 210      * Note that constant registers are treated as write-ignored; the
 211      * caller should check for success by whether a readback gives the
 212      * value written.
 213      */
 214     if (ri->type & ARM_CP_CONST) {
 215         return;
 216     } else if (ri->raw_writefn) {
 217         ri->raw_writefn(env, ri, v);
 218     } else if (ri->writefn) {
 219         ri->writefn(env, ri, v);
 220     } else {
 221         raw_write(env, ri, v);
 222     }
 223 }
 224
 225 static int arm_gdb_get_sysreg(CPUARMState *env, uint8_t *buf, int reg)
 226 {
 227     ARMCPU *cpu = arm_env_get_cpu(env);
 228     const ARMCPRegInfo *ri;
 229     uint32_t key;
 230
 231     key = cpu->dyn_xml.cpregs_keys[reg];
 232     ri = get_arm_cp_reginfo(cpu->cp_regs, key);
 233     if (ri) {
 234         if (cpreg_field_is_64bit(ri)) {
 235             return gdb_get_reg64(buf, (uint64_t)read_raw_cp_reg(env, ri));
 236         } else {
 237             return gdb_get_reg32(buf, (uint32_t)read_raw_cp_reg(env, ri));
 238         }
 239     }
 240     return 0;
 241 }
 242
 243 static int arm_gdb_set_sysreg(CPUARMState *env, uint8_t *buf, int reg)
 244 {
 245     return 0;
 246 }
 247
 248 static bool raw_accessors_invalid(const ARMCPRegInfo *ri)
 249 {
 250    /* Return true if the regdef would cause an assertion if you called
 251     * read_raw_cp_reg() or write_raw_cp_reg() on it (ie if it is a
 252     * program bug for it not to have the NO_RAW flag).
 253     * NB that returning false here doesn't necessarily mean that calling
 254     * read/write_raw_cp_reg() is safe, because we can't distinguish "has
 255     * read/write access functions which are safe for raw use" from "has
 256     * read/write access functions which have side effects but has forgotten
 257     * to provide raw access functions".
 258     * The tests here line up with the conditions in read/write_raw_cp_reg()
 259     * and assertions in raw_read()/raw_write().
 260     */
 261     if ((ri->type & ARM_CP_CONST) ||
 262         ri->fieldoffset ||
 263         ((ri->raw_writefn || ri->writefn) && (ri->raw_readfn || ri->readfn))) {
 264         return false;
 265     }
 266     return true;
 267 }
 268
 269 bool write_cpustate_to_list(ARMCPU *cpu)
 270 {
 271     /* Write the coprocessor state from cpu->env to the (index,value) list. */
 272     int i;
 273     bool ok = true;
 274
 275     for (i = 0; i < cpu->cpreg_array_len; i++) {
 276         uint32_t regidx = kvm_to_cpreg_id(cpu->cpreg_indexes[i]);
 277         const ARMCPRegInfo *ri;
 278
 279         ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 280         if (!ri) {
 281             ok = false;
 282             continue;
 283         }
 284         if (ri->type & ARM_CP_NO_RAW) {
 285             continue;
 286         }
 287         cpu->cpreg_values[i] = read_raw_cp_reg(&cpu->env, ri);
 288     }
 289     return ok;
 290 }
 291
 292 bool write_list_to_cpustate(ARMCPU *cpu)
 293 {
 294     int i;
 295     bool ok = true;
 296
 297     for (i = 0; i < cpu->cpreg_array_len; i++) {
 298         uint32_t regidx = kvm_to_cpreg_id(cpu->cpreg_indexes[i]);
 299         uint64_t v = cpu->cpreg_values[i];
 300         const ARMCPRegInfo *ri;
 301
 302         ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 303         if (!ri) {
 304             ok = false;
 305             continue;
 306         }
 307         if (ri->type & ARM_CP_NO_RAW) {
 308             continue;
 309         }
 310         /* Write value and confirm it reads back as written
 311          * (to catch read-only registers and partially read-only
 312          * registers where the incoming migration value doesn't match)
 313          */
 314         write_raw_cp_reg(&cpu->env, ri, v);
 315         if (read_raw_cp_reg(&cpu->env, ri) != v) {
 316             ok = false;
 317         }
 318     }
 319     return ok;
 320 }
 321
 322 static void add_cpreg_to_list(gpointer key, gpointer opaque)
 323 {
 324     ARMCPU *cpu = opaque;
 325     uint64_t regidx;
 326     const ARMCPRegInfo *ri;
 327
 328     regidx = *(uint32_t *)key;
 329     ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 330
 331     if (!(ri->type & (ARM_CP_NO_RAW|ARM_CP_ALIAS))) {
 332         cpu->cpreg_indexes[cpu->cpreg_array_len] = cpreg_to_kvm_id(regidx);
 333         /* The value array need not be initialized at this point */
 334         cpu->cpreg_array_len++;
 335     }
 336 }
 337
 338 static void count_cpreg(gpointer key, gpointer opaque)
 339 {
 340     ARMCPU *cpu = opaque;
 341     uint64_t regidx;
 342     const ARMCPRegInfo *ri;
 343
 344     regidx = *(uint32_t *)key;
 345     ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 346
 347     if (!(ri->type & (ARM_CP_NO_RAW|ARM_CP_ALIAS))) {
 348         cpu->cpreg_array_len++;
 349     }
 350 }
 351
 352 static gint cpreg_key_compare(gconstpointer a, gconstpointer b)
 353 {
 354     uint64_t aidx = cpreg_to_kvm_id(*(uint32_t *)a);
 355     uint64_t bidx = cpreg_to_kvm_id(*(uint32_t *)b);
 356
 357     if (aidx > bidx) {
 358         return 1;
 359     }
 360     if (aidx < bidx) {
 361         return -1;
 362     }
 363     return 0;
 364 }
 365
 366 void init_cpreg_list(ARMCPU *cpu)
 367 {
 368     /* Initialise the cpreg_tuples[] array based on the cp_regs hash.
 369      * Note that we require cpreg_tuples[] to be sorted by key ID.
 370      */
 371     GList *keys;
 372     int arraylen;
 373
 374     keys = g_hash_table_get_keys(cpu->cp_regs);
 375     keys = g_list_sort(keys, cpreg_key_compare);
 376
 377     cpu->cpreg_array_len = 0;
 378
 379     g_list_foreach(keys, count_cpreg, cpu);
 380
 381     arraylen = cpu->cpreg_array_len;
 382     cpu->cpreg_indexes = g_new(uint64_t, arraylen);
 383     cpu->cpreg_values = g_new(uint64_t, arraylen);
 384     cpu->cpreg_vmstate_indexes = g_new(uint64_t, arraylen);
 385     cpu->cpreg_vmstate_values = g_new(uint64_t, arraylen);
 386     cpu->cpreg_vmstate_array_len = cpu->cpreg_array_len;
 387     cpu->cpreg_array_len = 0;
 388
 389     g_list_foreach(keys, add_cpreg_to_list, cpu);
 390
 391     assert(cpu->cpreg_array_len == arraylen);
 392
 393     g_list_free(keys);
 394 }
 395
 396 /*
 397  * Some registers are not accessible if EL3.NS=0 and EL3 is using AArch32 but
 398  * they are accessible when EL3 is using AArch64 regardless of EL3.NS.
 399  *
 400  * access_el3_aa32ns: Used to check AArch32 register views.
 401  * access_el3_aa32ns_aa64any: Used to check both AArch32/64 register views.
 402  */
 403 static CPAccessResult access_el3_aa32ns(CPUARMState *env,
 404                                         const ARMCPRegInfo *ri,
 405                                         bool isread)
 406 {
 407     bool secure = arm_is_secure_below_el3(env);
 408
 409     assert(!arm_el_is_aa64(env, 3));
 410     if (secure) {
 411         return CP_ACCESS_TRAP_UNCATEGORIZED;
 412     }
 413     return CP_ACCESS_OK;
 414 }
 415
 416 static CPAccessResult access_el3_aa32ns_aa64any(CPUARMState *env,
 417                                                 const ARMCPRegInfo *ri,
 418                                                 bool isread)
 419 {
 420     if (!arm_el_is_aa64(env, 3)) {
 421         return access_el3_aa32ns(env, ri, isread);
 422     }
 423     return CP_ACCESS_OK;
 424 }
 425
 426 /* Some secure-only AArch32 registers trap to EL3 if used from
 427  * Secure EL1 (but are just ordinary UNDEF in other non-EL3 contexts).
 428  * Note that an access from Secure EL1 can only happen if EL3 is AArch64.
 429  * We assume that the .access field is set to PL1_RW.
 430  */
 431 static CPAccessResult access_trap_aa32s_el1(CPUARMState *env,
 432                                             const ARMCPRegInfo *ri,
 433                                             bool isread)
 434 {
 435     if (arm_current_el(env) == 3) {
 436         return CP_ACCESS_OK;
 437     }
 438     if (arm_is_secure_below_el3(env)) {
 439         return CP_ACCESS_TRAP_EL3;
 440     }
 441     /* This will be EL1 NS and EL2 NS, which just UNDEF */
 442     return CP_ACCESS_TRAP_UNCATEGORIZED;
 443 }
 444
 445 /* Check for traps to "powerdown debug" registers, which are controlled
 446  * by MDCR.TDOSA
 447  */
 448 static CPAccessResult access_tdosa(CPUARMState *env, const ARMCPRegInfo *ri,
 449                                    bool isread)
 450 {
 451     int el = arm_current_el(env);
 452     bool mdcr_el2_tdosa = (env->cp15.mdcr_el2 & MDCR_TDOSA) ||
 453         (env->cp15.mdcr_el2 & MDCR_TDE) ||
 454         (arm_hcr_el2_eff(env) & HCR_TGE);
 455
 456     if (el < 2 && mdcr_el2_tdosa && !arm_is_secure_below_el3(env)) {
 457         return CP_ACCESS_TRAP_EL2;
 458     }
 459     if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDOSA)) {
 460         return CP_ACCESS_TRAP_EL3;
 461     }
 462     return CP_ACCESS_OK;
 463 }
 464
 465 /* Check for traps to "debug ROM" registers, which are controlled
 466  * by MDCR_EL2.TDRA for EL2 but by the more general MDCR_EL3.TDA for EL3.
 467  */
 468 static CPAccessResult access_tdra(CPUARMState *env, const ARMCPRegInfo *ri,
 469                                   bool isread)
 470 {
 471     int el = arm_current_el(env);
 472     bool mdcr_el2_tdra = (env->cp15.mdcr_el2 & MDCR_TDRA) ||
 473         (env->cp15.mdcr_el2 & MDCR_TDE) ||
 474         (arm_hcr_el2_eff(env) & HCR_TGE);
 475
 476     if (el < 2 && mdcr_el2_tdra && !arm_is_secure_below_el3(env)) {
 477         return CP_ACCESS_TRAP_EL2;
 478     }
 479     if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDA)) {
 480         return CP_ACCESS_TRAP_EL3;
 481     }
 482     return CP_ACCESS_OK;
 483 }
 484
 485 /* Check for traps to general debug registers, which are controlled
 486  * by MDCR_EL2.TDA for EL2 and MDCR_EL3.TDA for EL3.
 487  */
 488 static CPAccessResult access_tda(CPUARMState *env, const ARMCPRegInfo *ri,
 489                                   bool isread)
 490 {
 491     int el = arm_current_el(env);
 492     bool mdcr_el2_tda = (env->cp15.mdcr_el2 & MDCR_TDA) ||
 493         (env->cp15.mdcr_el2 & MDCR_TDE) ||
 494         (arm_hcr_el2_eff(env) & HCR_TGE);
 495
 496     if (el < 2 && mdcr_el2_tda && !arm_is_secure_below_el3(env)) {
 497         return CP_ACCESS_TRAP_EL2;
 498     }
 499     if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TDA)) {
 500         return CP_ACCESS_TRAP_EL3;
 501     }
 502     return CP_ACCESS_OK;
 503 }
 504
 505 /* Check for traps to performance monitor registers, which are controlled
 506  * by MDCR_EL2.TPM for EL2 and MDCR_EL3.TPM for EL3.
 507  */
 508 static CPAccessResult access_tpm(CPUARMState *env, const ARMCPRegInfo *ri,
 509                                  bool isread)
 510 {
 511     int el = arm_current_el(env);
 512
 513     if (el < 2 && (env->cp15.mdcr_el2 & MDCR_TPM)
 514         && !arm_is_secure_below_el3(env)) {
 515         return CP_ACCESS_TRAP_EL2;
 516     }
 517     if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TPM)) {
 518         return CP_ACCESS_TRAP_EL3;
 519     }
 520     return CP_ACCESS_OK;
 521 }
 522
 523 static void dacr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 524 {
 525     ARMCPU *cpu = arm_env_get_cpu(env);
 526
 527     raw_write(env, ri, value);
 528     tlb_flush(CPU(cpu)); /* Flush TLB as domain not tracked in TLB */
 529 }
 530
 531 static void fcse_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 532 {
 533     ARMCPU *cpu = arm_env_get_cpu(env);
 534
 535     if (raw_read(env, ri) != value) {
 536         /* Unlike real hardware the qemu TLB uses virtual addresses,
 537          * not modified virtual addresses, so this causes a TLB flush.
 538          */
 539         tlb_flush(CPU(cpu));
 540         raw_write(env, ri, value);
 541     }
 542 }
 543
 544 static void contextidr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 545                              uint64_t value)
 546 {
 547     ARMCPU *cpu = arm_env_get_cpu(env);
 548
 549     if (raw_read(env, ri) != value && !arm_feature(env, ARM_FEATURE_PMSA)
 550         && !extended_addresses_enabled(env)) {
 551         /* For VMSA (when not using the LPAE long descriptor page table
 552          * format) this register includes the ASID, so do a TLB flush.
 553          * For PMSA it is purely a process ID and no action is needed.
 554          */
 555         tlb_flush(CPU(cpu));
 556     }
 557     raw_write(env, ri, value);
 558 }
 559
 560 /* IS variants of TLB operations must affect all cores */
 561 static void tlbiall_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 562                              uint64_t value)
 563 {
 564     CPUState *cs = ENV_GET_CPU(env);
 565
 566     tlb_flush_all_cpus_synced(cs);
 567 }
 568
 569 static void tlbiasid_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 570                              uint64_t value)
 571 {
 572     CPUState *cs = ENV_GET_CPU(env);
 573
 574     tlb_flush_all_cpus_synced(cs);
 575 }
 576
 577 static void tlbimva_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 578                              uint64_t value)
 579 {
 580     CPUState *cs = ENV_GET_CPU(env);
 581
 582     tlb_flush_page_all_cpus_synced(cs, value & TARGET_PAGE_MASK);
 583 }
 584
 585 static void tlbimvaa_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 586                              uint64_t value)
 587 {
 588     CPUState *cs = ENV_GET_CPU(env);
 589
 590     tlb_flush_page_all_cpus_synced(cs, value & TARGET_PAGE_MASK);
 591 }
 592
 593 /*
 594  * Non-IS variants of TLB operations are upgraded to
 595  * IS versions if we are at NS EL1 and HCR_EL2.FB is set to
 596  * force broadcast of these operations.
 597  */
 598 static bool tlb_force_broadcast(CPUARMState *env)
 599 {
 600     return (env->cp15.hcr_el2 & HCR_FB) &&
 601         arm_current_el(env) == 1 && arm_is_secure_below_el3(env);
 602 }
 603
 604 static void tlbiall_write(CPUARMState *env, const ARMCPRegInfo *ri,
 605                           uint64_t value)
 606 {
 607     /* Invalidate all (TLBIALL) */
 608     ARMCPU *cpu = arm_env_get_cpu(env);
 609
 610     if (tlb_force_broadcast(env)) {
 611         tlbiall_is_write(env, NULL, value);
 612         return;
 613     }
 614
 615     tlb_flush(CPU(cpu));
 616 }
 617
 618 static void tlbimva_write(CPUARMState *env, const ARMCPRegInfo *ri,
 619                           uint64_t value)
 620 {
 621     /* Invalidate single TLB entry by MVA and ASID (TLBIMVA) */
 622     ARMCPU *cpu = arm_env_get_cpu(env);
 623
 624     if (tlb_force_broadcast(env)) {
 625         tlbimva_is_write(env, NULL, value);
 626         return;
 627     }
 628
 629     tlb_flush_page(CPU(cpu), value & TARGET_PAGE_MASK);
 630 }
 631
 632 static void tlbiasid_write(CPUARMState *env, const ARMCPRegInfo *ri,
 633                            uint64_t value)
 634 {
 635     /* Invalidate by ASID (TLBIASID) */
 636     ARMCPU *cpu = arm_env_get_cpu(env);
 637
 638     if (tlb_force_broadcast(env)) {
 639         tlbiasid_is_write(env, NULL, value);
 640         return;
 641     }
 642
 643     tlb_flush(CPU(cpu));
 644 }
 645
 646 static void tlbimvaa_write(CPUARMState *env, const ARMCPRegInfo *ri,
 647                            uint64_t value)
 648 {
 649     /* Invalidate single entry by MVA, all ASIDs (TLBIMVAA) */
 650     ARMCPU *cpu = arm_env_get_cpu(env);
 651
 652     if (tlb_force_broadcast(env)) {
 653         tlbimvaa_is_write(env, NULL, value);
 654         return;
 655     }
 656
 657     tlb_flush_page(CPU(cpu), value & TARGET_PAGE_MASK);
 658 }
 659
 660 static void tlbiall_nsnh_write(CPUARMState *env, const ARMCPRegInfo *ri,
 661                                uint64_t value)
 662 {
 663     CPUState *cs = ENV_GET_CPU(env);
 664
 665     tlb_flush_by_mmuidx(cs,
 666                         ARMMMUIdxBit_S12NSE1 |
 667                         ARMMMUIdxBit_S12NSE0 |
 668                         ARMMMUIdxBit_S2NS);
 669 }
 670
 671 static void tlbiall_nsnh_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 672                                   uint64_t value)
 673 {
 674     CPUState *cs = ENV_GET_CPU(env);
 675
 676     tlb_flush_by_mmuidx_all_cpus_synced(cs,
 677                                         ARMMMUIdxBit_S12NSE1 |
 678                                         ARMMMUIdxBit_S12NSE0 |
 679                                         ARMMMUIdxBit_S2NS);
 680 }
 681
 682 static void tlbiipas2_write(CPUARMState *env, const ARMCPRegInfo *ri,
 683                             uint64_t value)
 684 {
 685     /* Invalidate by IPA. This has to invalidate any structures that
 686      * contain only stage 2 translation information, but does not need
 687      * to apply to structures that contain combined stage 1 and stage 2
 688      * translation information.
 689      * This must NOP if EL2 isn't implemented or SCR_EL3.NS is zero.
 690      */
 691     CPUState *cs = ENV_GET_CPU(env);
 692     uint64_t pageaddr;
 693
 694     if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) {
 695         return;
 696     }
 697
 698     pageaddr = sextract64(value << 12, 0, 40);
 699
 700     tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_S2NS);
 701 }
 702
 703 static void tlbiipas2_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 704                                uint64_t value)
 705 {
 706     CPUState *cs = ENV_GET_CPU(env);
 707     uint64_t pageaddr;
 708
 709     if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) {
 710         return;
 711     }
 712
 713     pageaddr = sextract64(value << 12, 0, 40);
 714
 715     tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
 716                                              ARMMMUIdxBit_S2NS);
 717 }
 718
 719 static void tlbiall_hyp_write(CPUARMState *env, const ARMCPRegInfo *ri,
 720                               uint64_t value)
 721 {
 722     CPUState *cs = ENV_GET_CPU(env);
 723
 724     tlb_flush_by_mmuidx(cs, ARMMMUIdxBit_S1E2);
 725 }
 726
 727 static void tlbiall_hyp_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 728                                  uint64_t value)
 729 {
 730     CPUState *cs = ENV_GET_CPU(env);
 731
 732     tlb_flush_by_mmuidx_all_cpus_synced(cs, ARMMMUIdxBit_S1E2);
 733 }
 734
 735 static void tlbimva_hyp_write(CPUARMState *env, const ARMCPRegInfo *ri,
 736                               uint64_t value)
 737 {
 738     CPUState *cs = ENV_GET_CPU(env);
 739     uint64_t pageaddr = value & ~MAKE_64BIT_MASK(0, 12);
 740
 741     tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_S1E2);
 742 }
 743
 744 static void tlbimva_hyp_is_write(CPUARMState *env, const ARMCPRegInfo *ri,
 745                                  uint64_t value)
 746 {
 747     CPUState *cs = ENV_GET_CPU(env);
 748     uint64_t pageaddr = value & ~MAKE_64BIT_MASK(0, 12);
 749
 750     tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
 751                                              ARMMMUIdxBit_S1E2);
 752 }
 753
 754 static const ARMCPRegInfo cp_reginfo[] = {
 755     /* Define the secure and non-secure FCSE identifier CP registers
 756      * separately because there is no secure bank in V8 (no _EL3).  This allows
 757      * the secure register to be properly reset and migrated. There is also no
 758      * v8 EL1 version of the register so the non-secure instance stands alone.
 759      */
 760     { .name = "FCSEIDR",
 761       .cp = 15, .opc1 = 0, .crn = 13, .crm = 0, .opc2 = 0,
 762       .access = PL1_RW, .secure = ARM_CP_SECSTATE_NS,
 763       .fieldoffset = offsetof(CPUARMState, cp15.fcseidr_ns),
 764       .resetvalue = 0, .writefn = fcse_write, .raw_writefn = raw_write, },
 765     { .name = "FCSEIDR_S",
 766       .cp = 15, .opc1 = 0, .crn = 13, .crm = 0, .opc2 = 0,
 767       .access = PL1_RW, .secure = ARM_CP_SECSTATE_S,
 768       .fieldoffset = offsetof(CPUARMState, cp15.fcseidr_s),
 769       .resetvalue = 0, .writefn = fcse_write, .raw_writefn = raw_write, },
 770     /* Define the secure and non-secure context identifier CP registers
 771      * separately because there is no secure bank in V8 (no _EL3).  This allows
 772      * the secure register to be properly reset and migrated.  In the
 773      * non-secure case, the 32-bit register will have reset and migration
 774      * disabled during registration as it is handled by the 64-bit instance.
 775      */
 776     { .name = "CONTEXTIDR_EL1", .state = ARM_CP_STATE_BOTH,
 777       .opc0 = 3, .opc1 = 0, .crn = 13, .crm = 0, .opc2 = 1,
 778       .access = PL1_RW, .secure = ARM_CP_SECSTATE_NS,
 779       .fieldoffset = offsetof(CPUARMState, cp15.contextidr_el[1]),
 780       .resetvalue = 0, .writefn = contextidr_write, .raw_writefn = raw_write, },
 781     { .name = "CONTEXTIDR_S", .state = ARM_CP_STATE_AA32,
 782       .cp = 15, .opc1 = 0, .crn = 13, .crm = 0, .opc2 = 1,
 783       .access = PL1_RW, .secure = ARM_CP_SECSTATE_S,
 784       .fieldoffset = offsetof(CPUARMState, cp15.contextidr_s),
 785       .resetvalue = 0, .writefn = contextidr_write, .raw_writefn = raw_write, },
 786     REGINFO_SENTINEL
 787 };
 788
 789 static const ARMCPRegInfo not_v8_cp_reginfo[] = {
 790     /* NB: Some of these registers exist in v8 but with more precise
 791      * definitions that don't use CP_ANY wildcards (mostly in v8_cp_reginfo[]).
 792      */
 793     /* MMU Domain access control / MPU write buffer control */
 794     { .name = "DACR",
 795       .cp = 15, .opc1 = CP_ANY, .crn = 3, .crm = CP_ANY, .opc2 = CP_ANY,
 796       .access = PL1_RW, .resetvalue = 0,
 797       .writefn = dacr_write, .raw_writefn = raw_write,
 798       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.dacr_s),
 799                              offsetoflow32(CPUARMState, cp15.dacr_ns) } },
 800     /* ARMv7 allocates a range of implementation defined TLB LOCKDOWN regs.
 801      * For v6 and v5, these mappings are overly broad.
 802      */
 803     { .name = "TLB_LOCKDOWN", .cp = 15, .crn = 10, .crm = 0,
 804       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_NOP },
 805     { .name = "TLB_LOCKDOWN", .cp = 15, .crn = 10, .crm = 1,
 806       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_NOP },
 807     { .name = "TLB_LOCKDOWN", .cp = 15, .crn = 10, .crm = 4,
 808       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_NOP },
 809     { .name = "TLB_LOCKDOWN", .cp = 15, .crn = 10, .crm = 8,
 810       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_NOP },
 811     /* Cache maintenance ops; some of this space may be overridden later. */
 812     { .name = "CACHEMAINT", .cp = 15, .crn = 7, .crm = CP_ANY,
 813       .opc1 = 0, .opc2 = CP_ANY, .access = PL1_W,
 814       .type = ARM_CP_NOP | ARM_CP_OVERRIDE },
 815     REGINFO_SENTINEL
 816 };
 817
 818 static const ARMCPRegInfo not_v6_cp_reginfo[] = {
 819     /* Not all pre-v6 cores implemented this WFI, so this is slightly
 820      * over-broad.
 821      */
 822     { .name = "WFI_v5", .cp = 15, .crn = 7, .crm = 8, .opc1 = 0, .opc2 = 2,
 823       .access = PL1_W, .type = ARM_CP_WFI },
 824     REGINFO_SENTINEL
 825 };
 826
 827 static const ARMCPRegInfo not_v7_cp_reginfo[] = {
 828     /* Standard v6 WFI (also used in some pre-v6 cores); not in v7 (which
 829      * is UNPREDICTABLE; we choose to NOP as most implementations do).
 830      */
 831     { .name = "WFI_v6", .cp = 15, .crn = 7, .crm = 0, .opc1 = 0, .opc2 = 4,
 832       .access = PL1_W, .type = ARM_CP_WFI },
 833     /* L1 cache lockdown. Not architectural in v6 and earlier but in practice
 834      * implemented in 926, 946, 1026, 1136, 1176 and 11MPCore. StrongARM and
 835      * OMAPCP will override this space.
 836      */
 837     { .name = "DLOCKDOWN", .cp = 15, .crn = 9, .crm = 0, .opc1 = 0, .opc2 = 0,
 838       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_data),
 839       .resetvalue = 0 },
 840     { .name = "ILOCKDOWN", .cp = 15, .crn = 9, .crm = 0, .opc1 = 0, .opc2 = 1,
 841       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_insn),
 842       .resetvalue = 0 },
 843     /* v6 doesn't have the cache ID registers but Linux reads them anyway */
 844     { .name = "DUMMY", .cp = 15, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = CP_ANY,
 845       .access = PL1_R, .type = ARM_CP_CONST | ARM_CP_NO_RAW,
 846       .resetvalue = 0 },
 847     /* We don't implement pre-v7 debug but most CPUs had at least a DBGDIDR;
 848      * implementing it as RAZ means the "debug architecture version" bits
 849      * will read as a reserved value, which should cause Linux to not try
 850      * to use the debug hardware.
 851      */
 852     { .name = "DBGDIDR", .cp = 14, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 0,
 853       .access = PL0_R, .type = ARM_CP_CONST, .resetvalue = 0 },
 854     /* MMU TLB control. Note that the wildcarding means we cover not just
 855      * the unified TLB ops but also the dside/iside/inner-shareable variants.
 856      */
 857     { .name = "TLBIALL", .cp = 15, .crn = 8, .crm = CP_ANY,
 858       .opc1 = CP_ANY, .opc2 = 0, .access = PL1_W, .writefn = tlbiall_write,
 859       .type = ARM_CP_NO_RAW },
 860     { .name = "TLBIMVA", .cp = 15, .crn = 8, .crm = CP_ANY,
 861       .opc1 = CP_ANY, .opc2 = 1, .access = PL1_W, .writefn = tlbimva_write,
 862       .type = ARM_CP_NO_RAW },
 863     { .name = "TLBIASID", .cp = 15, .crn = 8, .crm = CP_ANY,
 864       .opc1 = CP_ANY, .opc2 = 2, .access = PL1_W, .writefn = tlbiasid_write,
 865       .type = ARM_CP_NO_RAW },
 866     { .name = "TLBIMVAA", .cp = 15, .crn = 8, .crm = CP_ANY,
 867       .opc1 = CP_ANY, .opc2 = 3, .access = PL1_W, .writefn = tlbimvaa_write,
 868       .type = ARM_CP_NO_RAW },
 869     { .name = "PRRR", .cp = 15, .crn = 10, .crm = 2,
 870       .opc1 = 0, .opc2 = 0, .access = PL1_RW, .type = ARM_CP_NOP },
 871     { .name = "NMRR", .cp = 15, .crn = 10, .crm = 2,
 872       .opc1 = 0, .opc2 = 1, .access = PL1_RW, .type = ARM_CP_NOP },
 873     REGINFO_SENTINEL
 874 };
 875
 876 static void cpacr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 877                         uint64_t value)
 878 {
 879     uint32_t mask = 0;
 880
 881     /* In ARMv8 most bits of CPACR_EL1 are RES0. */
 882     if (!arm_feature(env, ARM_FEATURE_V8)) {
 883         /* ARMv7 defines bits for unimplemented coprocessors as RAZ/WI.
 884          * ASEDIS [31] and D32DIS [30] are both UNK/SBZP without VFP.
 885          * TRCDIS [28] is RAZ/WI since we do not implement a trace macrocell.
 886          */
 887         if (arm_feature(env, ARM_FEATURE_VFP)) {
 888             /* VFP coprocessor: cp10 & cp11 [23:20] */
 889             mask |= (1 << 31) | (1 << 30) | (0xf << 20);
 890
 891             if (!arm_feature(env, ARM_FEATURE_NEON)) {
 892                 /* ASEDIS [31] bit is RAO/WI */
 893                 value |= (1 << 31);
 894             }
 895
 896             /* VFPv3 and upwards with NEON implement 32 double precision
 897              * registers (D0-D31).
 898              */
 899             if (!arm_feature(env, ARM_FEATURE_NEON) ||
 900                     !arm_feature(env, ARM_FEATURE_VFP3)) {
 901                 /* D32DIS [30] is RAO/WI if D16-31 are not implemented. */
 902                 value |= (1 << 30);
 903             }
 904         }
 905         value &= mask;
 906     }
 907     env->cp15.cpacr_el1 = value;
 908 }
 909
 910 static void cpacr_reset(CPUARMState *env, const ARMCPRegInfo *ri)
 911 {
 912     /* Call cpacr_write() so that we reset with the correct RAO bits set
 913      * for our CPU features.
 914      */
 915     cpacr_write(env, ri, 0);
 916 }
 917
 918 static CPAccessResult cpacr_access(CPUARMState *env, const ARMCPRegInfo *ri,
 919                                    bool isread)
 920 {
 921     if (arm_feature(env, ARM_FEATURE_V8)) {
 922         /* Check if CPACR accesses are to be trapped to EL2 */
 923         if (arm_current_el(env) == 1 &&
 924             (env->cp15.cptr_el[2] & CPTR_TCPAC) && !arm_is_secure(env)) {
 925             return CP_ACCESS_TRAP_EL2;
 926         /* Check if CPACR accesses are to be trapped to EL3 */
 927         } else if (arm_current_el(env) < 3 &&
 928                    (env->cp15.cptr_el[3] & CPTR_TCPAC)) {
 929             return CP_ACCESS_TRAP_EL3;
 930         }
 931     }
 932
 933     return CP_ACCESS_OK;
 934 }
 935
 936 static CPAccessResult cptr_access(CPUARMState *env, const ARMCPRegInfo *ri,
 937                                   bool isread)
 938 {
 939     /* Check if CPTR accesses are set to trap to EL3 */
 940     if (arm_current_el(env) == 2 && (env->cp15.cptr_el[3] & CPTR_TCPAC)) {
 941         return CP_ACCESS_TRAP_EL3;
 942     }
 943
 944     return CP_ACCESS_OK;
 945 }
 946
 947 static const ARMCPRegInfo v6_cp_reginfo[] = {
 948     /* prefetch by MVA in v6, NOP in v7 */
 949     { .name = "MVA_prefetch",
 950       .cp = 15, .crn = 7, .crm = 13, .opc1 = 0, .opc2 = 1,
 951       .access = PL1_W, .type = ARM_CP_NOP },
 952     /* We need to break the TB after ISB to execute self-modifying code
 953      * correctly and also to take any pending interrupts immediately.
 954      * So use arm_cp_write_ignore() function instead of ARM_CP_NOP flag.
 955      */
 956     { .name = "ISB", .cp = 15, .crn = 7, .crm = 5, .opc1 = 0, .opc2 = 4,
 957       .access = PL0_W, .type = ARM_CP_NO_RAW, .writefn = arm_cp_write_ignore },
 958     { .name = "DSB", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 4,
 959       .access = PL0_W, .type = ARM_CP_NOP },
 960     { .name = "DMB", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 5,
 961       .access = PL0_W, .type = ARM_CP_NOP },
 962     { .name = "IFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 2,
 963       .access = PL1_RW,
 964       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.ifar_s),
 965                              offsetof(CPUARMState, cp15.ifar_ns) },
 966       .resetvalue = 0, },
 967     /* Watchpoint Fault Address Register : should actually only be present
 968      * for 1136, 1176, 11MPCore.
 969      */
 970     { .name = "WFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 1,
 971       .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0, },
 972     { .name = "CPACR", .state = ARM_CP_STATE_BOTH, .opc0 = 3,
 973       .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 2, .accessfn = cpacr_access,
 974       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.cpacr_el1),
 975       .resetfn = cpacr_reset, .writefn = cpacr_write },
 976     REGINFO_SENTINEL
 977 };
 978
 979 /* Definitions for the PMU registers */
 980 #define PMCRN_MASK  0xf800
 981 #define PMCRN_SHIFT 11
 982 #define PMCRLC  0x40
 983 #define PMCRDP  0x10
 984 #define PMCRD   0x8
 985 #define PMCRC   0x4
 986 #define PMCRP   0x2
 987 #define PMCRE   0x1
 988
 989 #define PMXEVTYPER_P          0x80000000
 990 #define PMXEVTYPER_U          0x40000000
 991 #define PMXEVTYPER_NSK        0x20000000
 992 #define PMXEVTYPER_NSU        0x10000000
 993 #define PMXEVTYPER_NSH        0x08000000
 994 #define PMXEVTYPER_M          0x04000000
 995 #define PMXEVTYPER_MT         0x02000000
 996 #define PMXEVTYPER_EVTCOUNT   0x0000ffff
 997 #define PMXEVTYPER_MASK       (PMXEVTYPER_P | PMXEVTYPER_U | PMXEVTYPER_NSK | \
 998                                PMXEVTYPER_NSU | PMXEVTYPER_NSH | \
 999                                PMXEVTYPER_M | PMXEVTYPER_MT | \
1000                                PMXEVTYPER_EVTCOUNT)
1001
1002 #define PMCCFILTR             0xf8000000
1003 #define PMCCFILTR_M           PMXEVTYPER_M
1004 #define PMCCFILTR_EL0         (PMCCFILTR | PMCCFILTR_M)
1005
1006 static inline uint32_t pmu_num_counters(CPUARMState *env)
1007 {
1008   return (env->cp15.c9_pmcr & PMCRN_MASK) >> PMCRN_SHIFT;
1009 }
1010
1011 /* Bits allowed to be set/cleared for PMCNTEN* and PMINTEN* */
1012 static inline uint64_t pmu_counter_mask(CPUARMState *env)
1013 {
1014   return (1 << 31) | ((1 << pmu_num_counters(env)) - 1);
1015 }
1016
1017 typedef struct pm_event {
1018     uint16_t number; /* PMEVTYPER.evtCount is 16 bits wide */
1019     /* If the event is supported on this CPU (used to generate PMCEID[01]) */
1020     bool (*supported)(CPUARMState *);
1021     /*
1022      * Retrieve the current count of the underlying event. The programmed
1023      * counters hold a difference from the return value from this function
1024      */
1025     uint64_t (*get_count)(CPUARMState *);
1026     /*
1027      * Return how many nanoseconds it will take (at a minimum) for count events
1028      * to occur. A negative value indicates the counter will never overflow, or
1029      * that the counter has otherwise arranged for the overflow bit to be set
1030      * and the PMU interrupt to be raised on overflow.
1031      */
1032     int64_t (*ns_per_count)(uint64_t);
1033 } pm_event;
1034
1035 static bool event_always_supported(CPUARMState *env)
1036 {
1037     return true;
1038 }
1039
1040 static uint64_t swinc_get_count(CPUARMState *env)
1041 {
1042     /*
1043      * SW_INCR events are written directly to the pmevcntr's by writes to
1044      * PMSWINC, so there is no underlying count maintained by the PMU itself
1045      */
1046     return 0;
1047 }
1048
1049 static int64_t swinc_ns_per(uint64_t ignored)
1050 {
1051     return -1;
1052 }
1053
1054 /*
1055  * Return the underlying cycle count for the PMU cycle counters. If we're in
1056  * usermode, simply return 0.
1057  */
1058 static uint64_t cycles_get_count(CPUARMState *env)
1059 {
1060 #ifndef CONFIG_USER_ONLY
1061     return muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL),
1062                    ARM_CPU_FREQ, NANOSECONDS_PER_SECOND);
1063 #else
1064     return cpu_get_host_ticks();
1065 #endif
1066 }
1067
1068 #ifndef CONFIG_USER_ONLY
1069 static int64_t cycles_ns_per(uint64_t cycles)
1070 {
1071     return (ARM_CPU_FREQ / NANOSECONDS_PER_SECOND) * cycles;
1072 }
1073
1074 static bool instructions_supported(CPUARMState *env)
1075 {
1076     return use_icount == 1 /* Precise instruction counting */;
1077 }
1078
1079 static uint64_t instructions_get_count(CPUARMState *env)
1080 {
1081     return (uint64_t)cpu_get_icount_raw();
1082 }
1083
1084 static int64_t instructions_ns_per(uint64_t icount)
1085 {
1086     return cpu_icount_to_ns((int64_t)icount);
1087 }
1088 #endif
1089
1090 static const pm_event pm_events[] = {
1091     { .number = 0x000, /* SW_INCR */
1092       .supported = event_always_supported,
1093       .get_count = swinc_get_count,
1094       .ns_per_count = swinc_ns_per,
1095     },
1096 #ifndef CONFIG_USER_ONLY
1097     { .number = 0x008, /* INST_RETIRED, Instruction architecturally executed */
1098       .supported = instructions_supported,
1099       .get_count = instructions_get_count,
1100       .ns_per_count = instructions_ns_per,
1101     },
1102     { .number = 0x011, /* CPU_CYCLES, Cycle */
1103       .supported = event_always_supported,
1104       .get_count = cycles_get_count,
1105       .ns_per_count = cycles_ns_per,
1106     }
1107 #endif
1108 };
1109
1110 /*
1111  * Note: Before increasing MAX_EVENT_ID beyond 0x3f into the 0x40xx range of
1112  * events (i.e. the statistical profiling extension), this implementation
1113  * should first be updated to something sparse instead of the current
1114  * supported_event_map[] array.
1115  */
1116 #define MAX_EVENT_ID 0x11
1117 #define UNSUPPORTED_EVENT UINT16_MAX
1118 static uint16_t supported_event_map[MAX_EVENT_ID + 1];
1119
1120 /*
1121  * Called upon CPU initialization to initialize PMCEID[01]_EL0 and build a map
1122  * of ARM event numbers to indices in our pm_events array.
1123  *
1124  * Note: Events in the 0x40XX range are not currently supported.
1125  */
1126 void pmu_init(ARMCPU *cpu)
1127 {
1128     unsigned int i;
1129
1130     /*
1131      * Empty supported_event_map and cpu->pmceid[01] before adding supported
1132      * events to them
1133      */
1134     for (i = 0; i < ARRAY_SIZE(supported_event_map); i++) {
1135         supported_event_map[i] = UNSUPPORTED_EVENT;
1136     }
1137     cpu->pmceid0 = 0;
1138     cpu->pmceid1 = 0;
1139
1140     for (i = 0; i < ARRAY_SIZE(pm_events); i++) {
1141         const pm_event *cnt = &pm_events[i];
1142         assert(cnt->number <= MAX_EVENT_ID);
1143         /* We do not currently support events in the 0x40xx range */
1144         assert(cnt->number <= 0x3f);
1145
1146         if (cnt->supported(&cpu->env)) {
1147             supported_event_map[cnt->number] = i;
1148             uint64_t event_mask = 1ULL << (cnt->number & 0x1f);
1149             if (cnt->number & 0x20) {
1150                 cpu->pmceid1 |= event_mask;
1151             } else {
1152                 cpu->pmceid0 |= event_mask;
1153             }
1154         }
1155     }
1156 }
1157
1158 /*
1159  * Check at runtime whether a PMU event is supported for the current machine
1160  */
1161 static bool event_supported(uint16_t number)
1162 {
1163     if (number > MAX_EVENT_ID) {
1164         return false;
1165     }
1166     return supported_event_map[number] != UNSUPPORTED_EVENT;
1167 }
1168
1169 static CPAccessResult pmreg_access(CPUARMState *env, const ARMCPRegInfo *ri,
1170                                    bool isread)
1171 {
1172     /* Performance monitor registers user accessibility is controlled
1173      * by PMUSERENR. MDCR_EL2.TPM and MDCR_EL3.TPM allow configurable
1174      * trapping to EL2 or EL3 for other accesses.
1175      */
1176     int el = arm_current_el(env);
1177
1178     if (el == 0 && !(env->cp15.c9_pmuserenr & 1)) {
1179         return CP_ACCESS_TRAP;
1180     }
1181     if (el < 2 && (env->cp15.mdcr_el2 & MDCR_TPM)
1182         && !arm_is_secure_below_el3(env)) {
1183         return CP_ACCESS_TRAP_EL2;
1184     }
1185     if (el < 3 && (env->cp15.mdcr_el3 & MDCR_TPM)) {
1186         return CP_ACCESS_TRAP_EL3;
1187     }
1188
1189     return CP_ACCESS_OK;
1190 }
1191
1192 static CPAccessResult pmreg_access_xevcntr(CPUARMState *env,
1193                                            const ARMCPRegInfo *ri,
1194                                            bool isread)
1195 {
1196     /* ER: event counter read trap control */
1197     if (arm_feature(env, ARM_FEATURE_V8)
1198         && arm_current_el(env) == 0
1199         && (env->cp15.c9_pmuserenr & (1 << 3)) != 0
1200         && isread) {
1201         return CP_ACCESS_OK;
1202     }
1203
1204     return pmreg_access(env, ri, isread);
1205 }
1206
1207 static CPAccessResult pmreg_access_swinc(CPUARMState *env,
1208                                          const ARMCPRegInfo *ri,
1209                                          bool isread)
1210 {
1211     /* SW: software increment write trap control */
1212     if (arm_feature(env, ARM_FEATURE_V8)
1213         && arm_current_el(env) == 0
1214         && (env->cp15.c9_pmuserenr & (1 << 1)) != 0
1215         && !isread) {
1216         return CP_ACCESS_OK;
1217     }
1218
1219     return pmreg_access(env, ri, isread);
1220 }
1221
1222 static CPAccessResult pmreg_access_selr(CPUARMState *env,
1223                                         const ARMCPRegInfo *ri,
1224                                         bool isread)
1225 {
1226     /* ER: event counter read trap control */
1227     if (arm_feature(env, ARM_FEATURE_V8)
1228         && arm_current_el(env) == 0
1229         && (env->cp15.c9_pmuserenr & (1 << 3)) != 0) {
1230         return CP_ACCESS_OK;
1231     }
1232
1233     return pmreg_access(env, ri, isread);
1234 }
1235
1236 static CPAccessResult pmreg_access_ccntr(CPUARMState *env,
1237                                          const ARMCPRegInfo *ri,
1238                                          bool isread)
1239 {
1240     /* CR: cycle counter read trap control */
1241     if (arm_feature(env, ARM_FEATURE_V8)
1242         && arm_current_el(env) == 0
1243         && (env->cp15.c9_pmuserenr & (1 << 2)) != 0
1244         && isread) {
1245         return CP_ACCESS_OK;
1246     }
1247
1248     return pmreg_access(env, ri, isread);
1249 }
1250
1251 /* Returns true if the counter (pass 31 for PMCCNTR) should count events using
1252  * the current EL, security state, and register configuration.
1253  */
1254 static bool pmu_counter_enabled(CPUARMState *env, uint8_t counter)
1255 {
1256     uint64_t filter;
1257     bool e, p, u, nsk, nsu, nsh, m;
1258     bool enabled, prohibited, filtered;
1259     bool secure = arm_is_secure(env);
1260     int el = arm_current_el(env);
1261     uint8_t hpmn = env->cp15.mdcr_el2 & MDCR_HPMN;
1262
1263     if (!arm_feature(env, ARM_FEATURE_PMU)) {
1264         return false;
1265     }
1266
1267     if (!arm_feature(env, ARM_FEATURE_EL2) ||
1268             (counter < hpmn || counter == 31)) {
1269         e = env->cp15.c9_pmcr & PMCRE;
1270     } else {
1271         e = env->cp15.mdcr_el2 & MDCR_HPME;
1272     }
1273     enabled = e && (env->cp15.c9_pmcnten & (1 << counter));
1274
1275     if (!secure) {
1276         if (el == 2 && (counter < hpmn || counter == 31)) {
1277             prohibited = env->cp15.mdcr_el2 & MDCR_HPMD;
1278         } else {
1279             prohibited = false;
1280         }
1281     } else {
1282         prohibited = arm_feature(env, ARM_FEATURE_EL3) &&
1283            (env->cp15.mdcr_el3 & MDCR_SPME);
1284     }
1285
1286     if (prohibited && counter == 31) {
1287         prohibited = env->cp15.c9_pmcr & PMCRDP;
1288     }
1289
1290     if (counter == 31) {
1291         filter = env->cp15.pmccfiltr_el0;
1292     } else {
1293         filter = env->cp15.c14_pmevtyper[counter];
1294     }
1295
1296     p   = filter & PMXEVTYPER_P;
1297     u   = filter & PMXEVTYPER_U;
1298     nsk = arm_feature(env, ARM_FEATURE_EL3) && (filter & PMXEVTYPER_NSK);
1299     nsu = arm_feature(env, ARM_FEATURE_EL3) && (filter & PMXEVTYPER_NSU);
1300     nsh = arm_feature(env, ARM_FEATURE_EL2) && (filter & PMXEVTYPER_NSH);
1301     m   = arm_el_is_aa64(env, 1) &&
1302               arm_feature(env, ARM_FEATURE_EL3) && (filter & PMXEVTYPER_M);
1303
1304     if (el == 0) {
1305         filtered = secure ? u : u != nsu;
1306     } else if (el == 1) {
1307         filtered = secure ? p : p != nsk;
1308     } else if (el == 2) {
1309         filtered = !nsh;
1310     } else { /* EL3 */
1311         filtered = m != p;
1312     }
1313
1314     if (counter != 31) {
1315         /*
1316          * If not checking PMCCNTR, ensure the counter is setup to an event we
1317          * support
1318          */
1319         uint16_t event = filter & PMXEVTYPER_EVTCOUNT;
1320         if (!event_supported(event)) {
1321             return false;
1322         }
1323     }
1324
1325     return enabled && !prohibited && !filtered;
1326 }
1327
1328 static void pmu_update_irq(CPUARMState *env)
1329 {
1330     ARMCPU *cpu = arm_env_get_cpu(env);
1331     qemu_set_irq(cpu->pmu_interrupt, (env->cp15.c9_pmcr & PMCRE) &&
1332             (env->cp15.c9_pminten & env->cp15.c9_pmovsr));
1333 }
1334
1335 /*
1336  * Ensure c15_ccnt is the guest-visible count so that operations such as
1337  * enabling/disabling the counter or filtering, modifying the count itself,
1338  * etc. can be done logically. This is essentially a no-op if the counter is
1339  * not enabled at the time of the call.
1340  */
1341 static void pmccntr_op_start(CPUARMState *env)
1342 {
1343     uint64_t cycles = cycles_get_count(env);
1344
1345     if (pmu_counter_enabled(env, 31)) {
1346         uint64_t eff_cycles = cycles;
1347         if (env->cp15.c9_pmcr & PMCRD) {
1348             /* Increment once every 64 processor clock cycles */
1349             eff_cycles /= 64;
1350         }
1351
1352         uint64_t new_pmccntr = eff_cycles - env->cp15.c15_ccnt_delta;
1353
1354         uint64_t overflow_mask = env->cp15.c9_pmcr & PMCRLC ? \
1355                                  1ull << 63 : 1ull << 31;
1356         if (env->cp15.c15_ccnt & ~new_pmccntr & overflow_mask) {
1357             env->cp15.c9_pmovsr |= (1 << 31);
1358             pmu_update_irq(env);
1359         }
1360
1361         env->cp15.c15_ccnt = new_pmccntr;
1362     }
1363     env->cp15.c15_ccnt_delta = cycles;
1364 }
1365
1366 /*
1367  * If PMCCNTR is enabled, recalculate the delta between the clock and the
1368  * guest-visible count. A call to pmccntr_op_finish should follow every call to
1369  * pmccntr_op_start.
1370  */
1371 static void pmccntr_op_finish(CPUARMState *env)
1372 {
1373     if (pmu_counter_enabled(env, 31)) {
1374 #ifndef CONFIG_USER_ONLY
1375         /* Calculate when the counter will next overflow */
1376         uint64_t remaining_cycles = -env->cp15.c15_ccnt;
1377         if (!(env->cp15.c9_pmcr & PMCRLC)) {
1378             remaining_cycles = (uint32_t)remaining_cycles;
1379         }
1380         int64_t overflow_in = cycles_ns_per(remaining_cycles);
1381
1382         if (overflow_in > 0) {
1383             int64_t overflow_at = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
1384                 overflow_in;
1385             ARMCPU *cpu = arm_env_get_cpu(env);
1386             timer_mod_anticipate_ns(cpu->pmu_timer, overflow_at);
1387         }
1388 #endif
1389
1390         uint64_t prev_cycles = env->cp15.c15_ccnt_delta;
1391         if (env->cp15.c9_pmcr & PMCRD) {
1392             /* Increment once every 64 processor clock cycles */
1393             prev_cycles /= 64;
1394         }
1395         env->cp15.c15_ccnt_delta = prev_cycles - env->cp15.c15_ccnt;
1396     }
1397 }
1398
1399 static void pmevcntr_op_start(CPUARMState *env, uint8_t counter)
1400 {
1401
1402     uint16_t event = env->cp15.c14_pmevtyper[counter] & PMXEVTYPER_EVTCOUNT;
1403     uint64_t count = 0;
1404     if (event_supported(event)) {
1405         uint16_t event_idx = supported_event_map[event];
1406         count = pm_events[event_idx].get_count(env);
1407     }
1408
1409     if (pmu_counter_enabled(env, counter)) {
1410         uint32_t new_pmevcntr = count - env->cp15.c14_pmevcntr_delta[counter];
1411
1412         if (env->cp15.c14_pmevcntr[counter] & ~new_pmevcntr & INT32_MIN) {
1413             env->cp15.c9_pmovsr |= (1 << counter);
1414             pmu_update_irq(env);
1415         }
1416         env->cp15.c14_pmevcntr[counter] = new_pmevcntr;
1417     }
1418     env->cp15.c14_pmevcntr_delta[counter] = count;
1419 }
1420
1421 static void pmevcntr_op_finish(CPUARMState *env, uint8_t counter)
1422 {
1423     if (pmu_counter_enabled(env, counter)) {
1424 #ifndef CONFIG_USER_ONLY
1425         uint16_t event = env->cp15.c14_pmevtyper[counter] & PMXEVTYPER_EVTCOUNT;
1426         uint16_t event_idx = supported_event_map[event];
1427         uint64_t delta = UINT32_MAX -
1428             (uint32_t)env->cp15.c14_pmevcntr[counter] + 1;
1429         int64_t overflow_in = pm_events[event_idx].ns_per_count(delta);
1430
1431         if (overflow_in > 0) {
1432             int64_t overflow_at = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
1433                 overflow_in;
1434             ARMCPU *cpu = arm_env_get_cpu(env);
1435             timer_mod_anticipate_ns(cpu->pmu_timer, overflow_at);
1436         }
1437 #endif
1438
1439         env->cp15.c14_pmevcntr_delta[counter] -=
1440             env->cp15.c14_pmevcntr[counter];
1441     }
1442 }
1443
1444 void pmu_op_start(CPUARMState *env)
1445 {
1446     unsigned int i;
1447     pmccntr_op_start(env);
1448     for (i = 0; i < pmu_num_counters(env); i++) {
1449         pmevcntr_op_start(env, i);
1450     }
1451 }
1452
1453 void pmu_op_finish(CPUARMState *env)
1454 {
1455     unsigned int i;
1456     pmccntr_op_finish(env);
1457     for (i = 0; i < pmu_num_counters(env); i++) {
1458         pmevcntr_op_finish(env, i);
1459     }
1460 }
1461
1462 void pmu_pre_el_change(ARMCPU *cpu, void *ignored)
1463 {
1464     pmu_op_start(&cpu->env);
1465 }
1466
1467 void pmu_post_el_change(ARMCPU *cpu, void *ignored)
1468 {
1469     pmu_op_finish(&cpu->env);
1470 }
1471
1472 void arm_pmu_timer_cb(void *opaque)
1473 {
1474     ARMCPU *cpu = opaque;
1475
1476     /*
1477      * Update all the counter values based on the current underlying counts,
1478      * triggering interrupts to be raised, if necessary. pmu_op_finish() also
1479      * has the effect of setting the cpu->pmu_timer to the next earliest time a
1480      * counter may expire.
1481      */
1482     pmu_op_start(&cpu->env);
1483     pmu_op_finish(&cpu->env);
1484 }
1485
1486 static void pmcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1487                        uint64_t value)
1488 {
1489     pmu_op_start(env);
1490
1491     if (value & PMCRC) {
1492         /* The counter has been reset */
1493         env->cp15.c15_ccnt = 0;
1494     }
1495
1496     if (value & PMCRP) {
1497         unsigned int i;
1498         for (i = 0; i < pmu_num_counters(env); i++) {
1499             env->cp15.c14_pmevcntr[i] = 0;
1500         }
1501     }
1502
1503     /* only the DP, X, D and E bits are writable */
1504     env->cp15.c9_pmcr &= ~0x39;
1505     env->cp15.c9_pmcr |= (value & 0x39);
1506
1507     pmu_op_finish(env);
1508 }
1509
1510 static void pmswinc_write(CPUARMState *env, const ARMCPRegInfo *ri,
1511                           uint64_t value)
1512 {
1513     unsigned int i;
1514     for (i = 0; i < pmu_num_counters(env); i++) {
1515         /* Increment a counter's count iff: */
1516         if ((value & (1 << i)) && /* counter's bit is set */
1517                 /* counter is enabled and not filtered */
1518                 pmu_counter_enabled(env, i) &&
1519                 /* counter is SW_INCR */
1520                 (env->cp15.c14_pmevtyper[i] & PMXEVTYPER_EVTCOUNT) == 0x0) {
1521             pmevcntr_op_start(env, i);
1522
1523             /*
1524              * Detect if this write causes an overflow since we can't predict
1525              * PMSWINC overflows like we can for other events
1526              */
1527             uint32_t new_pmswinc = env->cp15.c14_pmevcntr[i] + 1;
1528
1529             if (env->cp15.c14_pmevcntr[i] & ~new_pmswinc & INT32_MIN) {
1530                 env->cp15.c9_pmovsr |= (1 << i);
1531                 pmu_update_irq(env);
1532             }
1533
1534             env->cp15.c14_pmevcntr[i] = new_pmswinc;
1535
1536             pmevcntr_op_finish(env, i);
1537         }
1538     }
1539 }
1540
1541 static uint64_t pmccntr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1542 {
1543     uint64_t ret;
1544     pmccntr_op_start(env);
1545     ret = env->cp15.c15_ccnt;
1546     pmccntr_op_finish(env);
1547     return ret;
1548 }
1549
1550 static void pmselr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1551                          uint64_t value)
1552 {
1553     /* The value of PMSELR.SEL affects the behavior of PMXEVTYPER and
1554      * PMXEVCNTR. We allow [0..31] to be written to PMSELR here; in the
1555      * meanwhile, we check PMSELR.SEL when PMXEVTYPER and PMXEVCNTR are
1556      * accessed.
1557      */
1558     env->cp15.c9_pmselr = value & 0x1f;
1559 }
1560
1561 static void pmccntr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1562                         uint64_t value)
1563 {
1564     pmccntr_op_start(env);
1565     env->cp15.c15_ccnt = value;
1566     pmccntr_op_finish(env);
1567 }
1568
1569 static void pmccntr_write32(CPUARMState *env, const ARMCPRegInfo *ri,
1570                             uint64_t value)
1571 {
1572     uint64_t cur_val = pmccntr_read(env, NULL);
1573
1574     pmccntr_write(env, ri, deposit64(cur_val, 0, 32, value));
1575 }
1576
1577 static void pmccfiltr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1578                             uint64_t value)
1579 {
1580     pmccntr_op_start(env);
1581     env->cp15.pmccfiltr_el0 = value & PMCCFILTR_EL0;
1582     pmccntr_op_finish(env);
1583 }
1584
1585 static void pmccfiltr_write_a32(CPUARMState *env, const ARMCPRegInfo *ri,
1586                             uint64_t value)
1587 {
1588     pmccntr_op_start(env);
1589     /* M is not accessible from AArch32 */
1590     env->cp15.pmccfiltr_el0 = (env->cp15.pmccfiltr_el0 & PMCCFILTR_M) |
1591         (value & PMCCFILTR);
1592     pmccntr_op_finish(env);
1593 }
1594
1595 static uint64_t pmccfiltr_read_a32(CPUARMState *env, const ARMCPRegInfo *ri)
1596 {
1597     /* M is not visible in AArch32 */
1598     return env->cp15.pmccfiltr_el0 & PMCCFILTR;
1599 }
1600
1601 static void pmcntenset_write(CPUARMState *env, const ARMCPRegInfo *ri,
1602                             uint64_t value)
1603 {
1604     value &= pmu_counter_mask(env);
1605     env->cp15.c9_pmcnten |= value;
1606 }
1607
1608 static void pmcntenclr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1609                              uint64_t value)
1610 {
1611     value &= pmu_counter_mask(env);
1612     env->cp15.c9_pmcnten &= ~value;
1613 }
1614
1615 static void pmovsr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1616                          uint64_t value)
1617 {
1618     value &= pmu_counter_mask(env);
1619     env->cp15.c9_pmovsr &= ~value;
1620     pmu_update_irq(env);
1621 }
1622
1623 static void pmovsset_write(CPUARMState *env, const ARMCPRegInfo *ri,
1624                          uint64_t value)
1625 {
1626     value &= pmu_counter_mask(env);
1627     env->cp15.c9_pmovsr |= value;
1628     pmu_update_irq(env);
1629 }
1630
1631 static void pmevtyper_write(CPUARMState *env, const ARMCPRegInfo *ri,
1632                              uint64_t value, const uint8_t counter)
1633 {
1634     if (counter == 31) {
1635         pmccfiltr_write(env, ri, value);
1636     } else if (counter < pmu_num_counters(env)) {
1637         pmevcntr_op_start(env, counter);
1638
1639         /*
1640          * If this counter's event type is changing, store the current
1641          * underlying count for the new type in c14_pmevcntr_delta[counter] so
1642          * pmevcntr_op_finish has the correct baseline when it converts back to
1643          * a delta.
1644          */
1645         uint16_t old_event = env->cp15.c14_pmevtyper[counter] &
1646             PMXEVTYPER_EVTCOUNT;
1647         uint16_t new_event = value & PMXEVTYPER_EVTCOUNT;
1648         if (old_event != new_event) {
1649             uint64_t count = 0;
1650             if (event_supported(new_event)) {
1651                 uint16_t event_idx = supported_event_map[new_event];
1652                 count = pm_events[event_idx].get_count(env);
1653             }
1654             env->cp15.c14_pmevcntr_delta[counter] = count;
1655         }
1656
1657         env->cp15.c14_pmevtyper[counter] = value & PMXEVTYPER_MASK;
1658         pmevcntr_op_finish(env, counter);
1659     }
1660     /* Attempts to access PMXEVTYPER are CONSTRAINED UNPREDICTABLE when
1661      * PMSELR value is equal to or greater than the number of implemented
1662      * counters, but not equal to 0x1f. We opt to behave as a RAZ/WI.
1663      */
1664 }
1665
1666 static uint64_t pmevtyper_read(CPUARMState *env, const ARMCPRegInfo *ri,
1667                                const uint8_t counter)
1668 {
1669     if (counter == 31) {
1670         return env->cp15.pmccfiltr_el0;
1671     } else if (counter < pmu_num_counters(env)) {
1672         return env->cp15.c14_pmevtyper[counter];
1673     } else {
1674       /*
1675        * We opt to behave as a RAZ/WI when attempts to access PMXEVTYPER
1676        * are CONSTRAINED UNPREDICTABLE. See comments in pmevtyper_write().
1677        */
1678         return 0;
1679     }
1680 }
1681
1682 static void pmevtyper_writefn(CPUARMState *env, const ARMCPRegInfo *ri,
1683                               uint64_t value)
1684 {
1685     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1686     pmevtyper_write(env, ri, value, counter);
1687 }
1688
1689 static void pmevtyper_rawwrite(CPUARMState *env, const ARMCPRegInfo *ri,
1690                                uint64_t value)
1691 {
1692     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1693     env->cp15.c14_pmevtyper[counter] = value;
1694
1695     /*
1696      * pmevtyper_rawwrite is called between a pair of pmu_op_start and
1697      * pmu_op_finish calls when loading saved state for a migration. Because
1698      * we're potentially updating the type of event here, the value written to
1699      * c14_pmevcntr_delta by the preceeding pmu_op_start call may be for a
1700      * different counter type. Therefore, we need to set this value to the
1701      * current count for the counter type we're writing so that pmu_op_finish
1702      * has the correct count for its calculation.
1703      */
1704     uint16_t event = value & PMXEVTYPER_EVTCOUNT;
1705     if (event_supported(event)) {
1706         uint16_t event_idx = supported_event_map[event];
1707         env->cp15.c14_pmevcntr_delta[counter] =
1708             pm_events[event_idx].get_count(env);
1709     }
1710 }
1711
1712 static uint64_t pmevtyper_readfn(CPUARMState *env, const ARMCPRegInfo *ri)
1713 {
1714     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1715     return pmevtyper_read(env, ri, counter);
1716 }
1717
1718 static void pmxevtyper_write(CPUARMState *env, const ARMCPRegInfo *ri,
1719                              uint64_t value)
1720 {
1721     pmevtyper_write(env, ri, value, env->cp15.c9_pmselr & 31);
1722 }
1723
1724 static uint64_t pmxevtyper_read(CPUARMState *env, const ARMCPRegInfo *ri)
1725 {
1726     return pmevtyper_read(env, ri, env->cp15.c9_pmselr & 31);
1727 }
1728
1729 static void pmevcntr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1730                              uint64_t value, uint8_t counter)
1731 {
1732     if (counter < pmu_num_counters(env)) {
1733         pmevcntr_op_start(env, counter);
1734         env->cp15.c14_pmevcntr[counter] = value;
1735         pmevcntr_op_finish(env, counter);
1736     }
1737     /*
1738      * We opt to behave as a RAZ/WI when attempts to access PM[X]EVCNTR
1739      * are CONSTRAINED UNPREDICTABLE.
1740      */
1741 }
1742
1743 static uint64_t pmevcntr_read(CPUARMState *env, const ARMCPRegInfo *ri,
1744                               uint8_t counter)
1745 {
1746     if (counter < pmu_num_counters(env)) {
1747         uint64_t ret;
1748         pmevcntr_op_start(env, counter);
1749         ret = env->cp15.c14_pmevcntr[counter];
1750         pmevcntr_op_finish(env, counter);
1751         return ret;
1752     } else {
1753       /* We opt to behave as a RAZ/WI when attempts to access PM[X]EVCNTR
1754        * are CONSTRAINED UNPREDICTABLE. */
1755         return 0;
1756     }
1757 }
1758
1759 static void pmevcntr_writefn(CPUARMState *env, const ARMCPRegInfo *ri,
1760                              uint64_t value)
1761 {
1762     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1763     pmevcntr_write(env, ri, value, counter);
1764 }
1765
1766 static uint64_t pmevcntr_readfn(CPUARMState *env, const ARMCPRegInfo *ri)
1767 {
1768     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1769     return pmevcntr_read(env, ri, counter);
1770 }
1771
1772 static void pmevcntr_rawwrite(CPUARMState *env, const ARMCPRegInfo *ri,
1773                              uint64_t value)
1774 {
1775     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1776     assert(counter < pmu_num_counters(env));
1777     env->cp15.c14_pmevcntr[counter] = value;
1778     pmevcntr_write(env, ri, value, counter);
1779 }
1780
1781 static uint64_t pmevcntr_rawread(CPUARMState *env, const ARMCPRegInfo *ri)
1782 {
1783     uint8_t counter = ((ri->crm & 3) << 3) | (ri->opc2 & 7);
1784     assert(counter < pmu_num_counters(env));
1785     return env->cp15.c14_pmevcntr[counter];
1786 }
1787
1788 static void pmxevcntr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1789                              uint64_t value)
1790 {
1791     pmevcntr_write(env, ri, value, env->cp15.c9_pmselr & 31);
1792 }
1793
1794 static uint64_t pmxevcntr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1795 {
1796     return pmevcntr_read(env, ri, env->cp15.c9_pmselr & 31);
1797 }
1798
1799 static void pmuserenr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1800                             uint64_t value)
1801 {
1802     if (arm_feature(env, ARM_FEATURE_V8)) {
1803         env->cp15.c9_pmuserenr = value & 0xf;
1804     } else {
1805         env->cp15.c9_pmuserenr = value & 1;
1806     }
1807 }
1808
1809 static void pmintenset_write(CPUARMState *env, const ARMCPRegInfo *ri,
1810                              uint64_t value)
1811 {
1812     /* We have no event counters so only the C bit can be changed */
1813     value &= pmu_counter_mask(env);
1814     env->cp15.c9_pminten |= value;
1815     pmu_update_irq(env);
1816 }
1817
1818 static void pmintenclr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1819                              uint64_t value)
1820 {
1821     value &= pmu_counter_mask(env);
1822     env->cp15.c9_pminten &= ~value;
1823     pmu_update_irq(env);
1824 }
1825
1826 static void vbar_write(CPUARMState *env, const ARMCPRegInfo *ri,
1827                        uint64_t value)
1828 {
1829     /* Note that even though the AArch64 view of this register has bits
1830      * [10:0] all RES0 we can only mask the bottom 5, to comply with the
1831      * architectural requirements for bits which are RES0 only in some
1832      * contexts. (ARMv8 would permit us to do no masking at all, but ARMv7
1833      * requires the bottom five bits to be RAZ/WI because they're UNK/SBZP.)
1834      */
1835     raw_write(env, ri, value & ~0x1FULL);
1836 }
1837
1838 static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
1839 {
1840     /* Begin with base v8.0 state.  */
1841     uint32_t valid_mask = 0x3fff;
1842     ARMCPU *cpu = arm_env_get_cpu(env);
1843
1844     if (arm_el_is_aa64(env, 3)) {
1845         value |= SCR_FW | SCR_AW;   /* these two bits are RES1.  */
1846         valid_mask &= ~SCR_NET;
1847     } else {
1848         valid_mask &= ~(SCR_RW | SCR_ST);
1849     }
1850
1851     if (!arm_feature(env, ARM_FEATURE_EL2)) {
1852         valid_mask &= ~SCR_HCE;
1853
1854         /* On ARMv7, SMD (or SCD as it is called in v7) is only
1855          * supported if EL2 exists. The bit is UNK/SBZP when
1856          * EL2 is unavailable. In QEMU ARMv7, we force it to always zero
1857          * when EL2 is unavailable.
1858          * On ARMv8, this bit is always available.
1859          */
1860         if (arm_feature(env, ARM_FEATURE_V7) &&
1861             !arm_feature(env, ARM_FEATURE_V8)) {
1862             valid_mask &= ~SCR_SMD;
1863         }
1864     }
1865     if (cpu_isar_feature(aa64_lor, cpu)) {
1866         valid_mask |= SCR_TLOR;
1867     }
1868     if (cpu_isar_feature(aa64_pauth, cpu)) {
1869         valid_mask |= SCR_API | SCR_APK;
1870     }
1871
1872     /* Clear all-context RES0 bits.  */
1873     value &= valid_mask;
1874     raw_write(env, ri, value);
1875 }
1876
1877 static uint64_t ccsidr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1878 {
1879     ARMCPU *cpu = arm_env_get_cpu(env);
1880
1881     /* Acquire the CSSELR index from the bank corresponding to the CCSIDR
1882      * bank
1883      */
1884     uint32_t index = A32_BANKED_REG_GET(env, csselr,
1885                                         ri->secure & ARM_CP_SECSTATE_S);
1886
1887     return cpu->ccsidr[index];
1888 }
1889
1890 static void csselr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1891                          uint64_t value)
1892 {
1893     raw_write(env, ri, value & 0xf);
1894 }
1895
1896 static uint64_t isr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1897 {
1898     CPUState *cs = ENV_GET_CPU(env);
1899     uint64_t hcr_el2 = arm_hcr_el2_eff(env);
1900     uint64_t ret = 0;
1901
1902     if (hcr_el2 & HCR_IMO) {
1903         if (cs->interrupt_request & CPU_INTERRUPT_VIRQ) {
1904             ret |= CPSR_I;
1905         }
1906     } else {
1907         if (cs->interrupt_request & CPU_INTERRUPT_HARD) {
1908             ret |= CPSR_I;
1909         }
1910     }
1911
1912     if (hcr_el2 & HCR_FMO) {
1913         if (cs->interrupt_request & CPU_INTERRUPT_VFIQ) {
1914             ret |= CPSR_F;
1915         }
1916     } else {
1917         if (cs->interrupt_request & CPU_INTERRUPT_FIQ) {
1918             ret |= CPSR_F;
1919         }
1920     }
1921
1922     /* External aborts are not possible in QEMU so A bit is always clear */
1923     return ret;
1924 }
1925
1926 static const ARMCPRegInfo v7_cp_reginfo[] = {
1927     /* the old v6 WFI, UNPREDICTABLE in v7 but we choose to NOP */
1928     { .name = "NOP", .cp = 15, .crn = 7, .crm = 0, .opc1 = 0, .opc2 = 4,
1929       .access = PL1_W, .type = ARM_CP_NOP },
1930     /* Performance monitors are implementation defined in v7,
1931      * but with an ARM recommended set of registers, which we
1932      * follow.
1933      *
1934      * Performance registers fall into three categories:
1935      *  (a) always UNDEF in PL0, RW in PL1 (PMINTENSET, PMINTENCLR)
1936      *  (b) RO in PL0 (ie UNDEF on write), RW in PL1 (PMUSERENR)
1937      *  (c) UNDEF in PL0 if PMUSERENR.EN==0, otherwise accessible (all others)
1938      * For the cases controlled by PMUSERENR we must set .access to PL0_RW
1939      * or PL0_RO as appropriate and then check PMUSERENR in the helper fn.
1940      */
1941     { .name = "PMCNTENSET", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 1,
1942       .access = PL0_RW, .type = ARM_CP_ALIAS,
1943       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmcnten),
1944       .writefn = pmcntenset_write,
1945       .accessfn = pmreg_access,
1946       .raw_writefn = raw_write },
1947     { .name = "PMCNTENSET_EL0", .state = ARM_CP_STATE_AA64,
1948       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 1,
1949       .access = PL0_RW, .accessfn = pmreg_access,
1950       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcnten), .resetvalue = 0,
1951       .writefn = pmcntenset_write, .raw_writefn = raw_write },
1952     { .name = "PMCNTENCLR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 2,
1953       .access = PL0_RW,
1954       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmcnten),
1955       .accessfn = pmreg_access,
1956       .writefn = pmcntenclr_write,
1957       .type = ARM_CP_ALIAS },
1958     { .name = "PMCNTENCLR_EL0", .state = ARM_CP_STATE_AA64,
1959       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 2,
1960       .access = PL0_RW, .accessfn = pmreg_access,
1961       .type = ARM_CP_ALIAS,
1962       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcnten),
1963       .writefn = pmcntenclr_write },
1964     { .name = "PMOVSR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 3,
1965       .access = PL0_RW, .type = ARM_CP_IO,
1966       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmovsr),
1967       .accessfn = pmreg_access,
1968       .writefn = pmovsr_write,
1969       .raw_writefn = raw_write },
1970     { .name = "PMOVSCLR_EL0", .state = ARM_CP_STATE_AA64,
1971       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 3,
1972       .access = PL0_RW, .accessfn = pmreg_access,
1973       .type = ARM_CP_ALIAS | ARM_CP_IO,
1974       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmovsr),
1975       .writefn = pmovsr_write,
1976       .raw_writefn = raw_write },
1977     { .name = "PMSWINC", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 4,
1978       .access = PL0_W, .accessfn = pmreg_access_swinc,
1979       .type = ARM_CP_NO_RAW | ARM_CP_IO,
1980       .writefn = pmswinc_write },
1981     { .name = "PMSWINC_EL0", .state = ARM_CP_STATE_AA64,
1982       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 4,
1983       .access = PL0_W, .accessfn = pmreg_access_swinc,
1984       .type = ARM_CP_NO_RAW | ARM_CP_IO,
1985       .writefn = pmswinc_write },
1986     { .name = "PMSELR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 5,
1987       .access = PL0_RW, .type = ARM_CP_ALIAS,
1988       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmselr),
1989       .accessfn = pmreg_access_selr, .writefn = pmselr_write,
1990       .raw_writefn = raw_write},
1991     { .name = "PMSELR_EL0", .state = ARM_CP_STATE_AA64,
1992       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 5,
1993       .access = PL0_RW, .accessfn = pmreg_access_selr,
1994       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmselr),
1995       .writefn = pmselr_write, .raw_writefn = raw_write, },
1996     { .name = "PMCCNTR", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 0,
1997       .access = PL0_RW, .resetvalue = 0, .type = ARM_CP_ALIAS | ARM_CP_IO,
1998       .readfn = pmccntr_read, .writefn = pmccntr_write32,
1999       .accessfn = pmreg_access_ccntr },
2000     { .name = "PMCCNTR_EL0", .state = ARM_CP_STATE_AA64,
2001       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 13, .opc2 = 0,
2002       .access = PL0_RW, .accessfn = pmreg_access_ccntr,
2003       .type = ARM_CP_IO,
2004       .fieldoffset = offsetof(CPUARMState, cp15.c15_ccnt),
2005       .readfn = pmccntr_read, .writefn = pmccntr_write,
2006       .raw_readfn = raw_read, .raw_writefn = raw_write, },
2007     { .name = "PMCCFILTR", .cp = 15, .opc1 = 0, .crn = 14, .crm = 15, .opc2 = 7,
2008       .writefn = pmccfiltr_write_a32, .readfn = pmccfiltr_read_a32,
2009       .access = PL0_RW, .accessfn = pmreg_access,
2010       .type = ARM_CP_ALIAS | ARM_CP_IO,
2011       .resetvalue = 0, },
2012     { .name = "PMCCFILTR_EL0", .state = ARM_CP_STATE_AA64,
2013       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 15, .opc2 = 7,
2014       .writefn = pmccfiltr_write, .raw_writefn = raw_write,
2015       .access = PL0_RW, .accessfn = pmreg_access,
2016       .type = ARM_CP_IO,
2017       .fieldoffset = offsetof(CPUARMState, cp15.pmccfiltr_el0),
2018       .resetvalue = 0, },
2019     { .name = "PMXEVTYPER", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 1,
2020       .access = PL0_RW, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2021       .accessfn = pmreg_access,
2022       .writefn = pmxevtyper_write, .readfn = pmxevtyper_read },
2023     { .name = "PMXEVTYPER_EL0", .state = ARM_CP_STATE_AA64,
2024       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 13, .opc2 = 1,
2025       .access = PL0_RW, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2026       .accessfn = pmreg_access,
2027       .writefn = pmxevtyper_write, .readfn = pmxevtyper_read },
2028     { .name = "PMXEVCNTR", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 2,
2029       .access = PL0_RW, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2030       .accessfn = pmreg_access_xevcntr,
2031       .writefn = pmxevcntr_write, .readfn = pmxevcntr_read },
2032     { .name = "PMXEVCNTR_EL0", .state = ARM_CP_STATE_AA64,
2033       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 13, .opc2 = 2,
2034       .access = PL0_RW, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2035       .accessfn = pmreg_access_xevcntr,
2036       .writefn = pmxevcntr_write, .readfn = pmxevcntr_read },
2037     { .name = "PMUSERENR", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 0,
2038       .access = PL0_R | PL1_RW, .accessfn = access_tpm,
2039       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmuserenr),
2040       .resetvalue = 0,
2041       .writefn = pmuserenr_write, .raw_writefn = raw_write },
2042     { .name = "PMUSERENR_EL0", .state = ARM_CP_STATE_AA64,
2043       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 14, .opc2 = 0,
2044       .access = PL0_R | PL1_RW, .accessfn = access_tpm, .type = ARM_CP_ALIAS,
2045       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmuserenr),
2046       .resetvalue = 0,
2047       .writefn = pmuserenr_write, .raw_writefn = raw_write },
2048     { .name = "PMINTENSET", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 1,
2049       .access = PL1_RW, .accessfn = access_tpm,
2050       .type = ARM_CP_ALIAS | ARM_CP_IO,
2051       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pminten),
2052       .resetvalue = 0,
2053       .writefn = pmintenset_write, .raw_writefn = raw_write },
2054     { .name = "PMINTENSET_EL1", .state = ARM_CP_STATE_AA64,
2055       .opc0 = 3, .opc1 = 0, .crn = 9, .crm = 14, .opc2 = 1,
2056       .access = PL1_RW, .accessfn = access_tpm,
2057       .type = ARM_CP_IO,
2058       .fieldoffset = offsetof(CPUARMState, cp15.c9_pminten),
2059       .writefn = pmintenset_write, .raw_writefn = raw_write,
2060       .resetvalue = 0x0 },
2061     { .name = "PMINTENCLR", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 2,
2062       .access = PL1_RW, .accessfn = access_tpm,
2063       .type = ARM_CP_ALIAS | ARM_CP_IO,
2064       .fieldoffset = offsetof(CPUARMState, cp15.c9_pminten),
2065       .writefn = pmintenclr_write, },
2066     { .name = "PMINTENCLR_EL1", .state = ARM_CP_STATE_AA64,
2067       .opc0 = 3, .opc1 = 0, .crn = 9, .crm = 14, .opc2 = 2,
2068       .access = PL1_RW, .accessfn = access_tpm,
2069       .type = ARM_CP_ALIAS | ARM_CP_IO,
2070       .fieldoffset = offsetof(CPUARMState, cp15.c9_pminten),
2071       .writefn = pmintenclr_write },
2072     { .name = "CCSIDR", .state = ARM_CP_STATE_BOTH,
2073       .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = 0,
2074       .access = PL1_R, .readfn = ccsidr_read, .type = ARM_CP_NO_RAW },
2075     { .name = "CSSELR", .state = ARM_CP_STATE_BOTH,
2076       .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 2, .opc2 = 0,
2077       .access = PL1_RW, .writefn = csselr_write, .resetvalue = 0,
2078       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.csselr_s),
2079                              offsetof(CPUARMState, cp15.csselr_ns) } },
2080     /* Auxiliary ID register: this actually has an IMPDEF value but for now
2081      * just RAZ for all cores:
2082      */
2083     { .name = "AIDR", .state = ARM_CP_STATE_BOTH,
2084       .opc0 = 3, .opc1 = 1, .crn = 0, .crm = 0, .opc2 = 7,
2085       .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
2086     /* Auxiliary fault status registers: these also are IMPDEF, and we
2087      * choose to RAZ/WI for all cores.
2088      */
2089     { .name = "AFSR0_EL1", .state = ARM_CP_STATE_BOTH,
2090       .opc0 = 3, .opc1 = 0, .crn = 5, .crm = 1, .opc2 = 0,
2091       .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
2092     { .name = "AFSR1_EL1", .state = ARM_CP_STATE_BOTH,
2093       .opc0 = 3, .opc1 = 0, .crn = 5, .crm = 1, .opc2 = 1,
2094       .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
2095     /* MAIR can just read-as-written because we don't implement caches
2096      * and so don't need to care about memory attributes.
2097      */
2098     { .name = "MAIR_EL1", .state = ARM_CP_STATE_AA64,
2099       .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 2, .opc2 = 0,
2100       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.mair_el[1]),
2101       .resetvalue = 0 },
2102     { .name = "MAIR_EL3", .state = ARM_CP_STATE_AA64,
2103       .opc0 = 3, .opc1 = 6, .crn = 10, .crm = 2, .opc2 = 0,
2104       .access = PL3_RW, .fieldoffset = offsetof(CPUARMState, cp15.mair_el[3]),
2105       .resetvalue = 0 },
2106     /* For non-long-descriptor page tables these are PRRR and NMRR;
2107      * regardless they still act as reads-as-written for QEMU.
2108      */
2109      /* MAIR0/1 are defined separately from their 64-bit counterpart which
2110       * allows them to assign the correct fieldoffset based on the endianness
2111       * handled in the field definitions.
2112       */
2113     { .name = "MAIR0", .state = ARM_CP_STATE_AA32,
2114       .cp = 15, .opc1 = 0, .crn = 10, .crm = 2, .opc2 = 0, .access = PL1_RW,
2115       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.mair0_s),
2116                              offsetof(CPUARMState, cp15.mair0_ns) },
2117       .resetfn = arm_cp_reset_ignore },
2118     { .name = "MAIR1", .state = ARM_CP_STATE_AA32,
2119       .cp = 15, .opc1 = 0, .crn = 10, .crm = 2, .opc2 = 1, .access = PL1_RW,
2120       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.mair1_s),
2121                              offsetof(CPUARMState, cp15.mair1_ns) },
2122       .resetfn = arm_cp_reset_ignore },
2123     { .name = "ISR_EL1", .state = ARM_CP_STATE_BOTH,
2124       .opc0 = 3, .opc1 = 0, .crn = 12, .crm = 1, .opc2 = 0,
2125       .type = ARM_CP_NO_RAW, .access = PL1_R, .readfn = isr_read },
2126     /* 32 bit ITLB invalidates */
2127     { .name = "ITLBIALL", .cp = 15, .opc1 = 0, .crn = 8, .crm = 5, .opc2 = 0,
2128       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiall_write },
2129     { .name = "ITLBIMVA", .cp = 15, .opc1 = 0, .crn = 8, .crm = 5, .opc2 = 1,
2130       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_write },
2131     { .name = "ITLBIASID", .cp = 15, .opc1 = 0, .crn = 8, .crm = 5, .opc2 = 2,
2132       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiasid_write },
2133     /* 32 bit DTLB invalidates */
2134     { .name = "DTLBIALL", .cp = 15, .opc1 = 0, .crn = 8, .crm = 6, .opc2 = 0,
2135       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiall_write },
2136     { .name = "DTLBIMVA", .cp = 15, .opc1 = 0, .crn = 8, .crm = 6, .opc2 = 1,
2137       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_write },
2138     { .name = "DTLBIASID", .cp = 15, .opc1 = 0, .crn = 8, .crm = 6, .opc2 = 2,
2139       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiasid_write },
2140     /* 32 bit TLB invalidates */
2141     { .name = "TLBIALL", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 0,
2142       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiall_write },
2143     { .name = "TLBIMVA", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 1,
2144       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_write },
2145     { .name = "TLBIASID", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 2,
2146       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiasid_write },
2147     { .name = "TLBIMVAA", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 3,
2148       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimvaa_write },
2149     REGINFO_SENTINEL
2150 };
2151
2152 static const ARMCPRegInfo v7mp_cp_reginfo[] = {
2153     /* 32 bit TLB invalidates, Inner Shareable */
2154     { .name = "TLBIALLIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 0,
2155       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbiall_is_write },
2156     { .name = "TLBIMVAIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 1,
2157       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_is_write },
2158     { .name = "TLBIASIDIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 2,
2159       .type = ARM_CP_NO_RAW, .access = PL1_W,
2160       .writefn = tlbiasid_is_write },
2161     { .name = "TLBIMVAAIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 3,
2162       .type = ARM_CP_NO_RAW, .access = PL1_W,
2163       .writefn = tlbimvaa_is_write },
2164     REGINFO_SENTINEL
2165 };
2166
2167 static const ARMCPRegInfo pmovsset_cp_reginfo[] = {
2168     /* PMOVSSET is not implemented in v7 before v7ve */
2169     { .name = "PMOVSSET", .cp = 15, .opc1 = 0, .crn = 9, .crm = 14, .opc2 = 3,
2170       .access = PL0_RW, .accessfn = pmreg_access,
2171       .type = ARM_CP_ALIAS | ARM_CP_IO,
2172       .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmovsr),
2173       .writefn = pmovsset_write,
2174       .raw_writefn = raw_write },
2175     { .name = "PMOVSSET_EL0", .state = ARM_CP_STATE_AA64,
2176       .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 14, .opc2 = 3,
2177       .access = PL0_RW, .accessfn = pmreg_access,
2178       .type = ARM_CP_ALIAS | ARM_CP_IO,
2179       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmovsr),
2180       .writefn = pmovsset_write,
2181       .raw_writefn = raw_write },
2182     REGINFO_SENTINEL
2183 };
2184
2185 static void teecr_write(CPUARMState *env, const ARMCPRegInfo *ri,
2186                         uint64_t value)
2187 {
2188     value &= 1;
2189     env->teecr = value;
2190 }
2191
2192 static CPAccessResult teehbr_access(CPUARMState *env, const ARMCPRegInfo *ri,
2193                                     bool isread)
2194 {
2195     if (arm_current_el(env) == 0 && (env->teecr & 1)) {
2196         return CP_ACCESS_TRAP;
2197     }
2198     return CP_ACCESS_OK;
2199 }
2200
2201 static const ARMCPRegInfo t2ee_cp_reginfo[] = {
2202     { .name = "TEECR", .cp = 14, .crn = 0, .crm = 0, .opc1 = 6, .opc2 = 0,
2203       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, teecr),
2204       .resetvalue = 0,
2205       .writefn = teecr_write },
2206     { .name = "TEEHBR", .cp = 14, .crn = 1, .crm = 0, .opc1 = 6, .opc2 = 0,
2207       .access = PL0_RW, .fieldoffset = offsetof(CPUARMState, teehbr),
2208       .accessfn = teehbr_access, .resetvalue = 0 },
2209     REGINFO_SENTINEL
2210 };
2211
2212 static const ARMCPRegInfo v6k_cp_reginfo[] = {
2213     { .name = "TPIDR_EL0", .state = ARM_CP_STATE_AA64,
2214       .opc0 = 3, .opc1 = 3, .opc2 = 2, .crn = 13, .crm = 0,
2215       .access = PL0_RW,
2216       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el[0]), .resetvalue = 0 },
2217     { .name = "TPIDRURW", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 2,
2218       .access = PL0_RW,
2219       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.tpidrurw_s),
2220                              offsetoflow32(CPUARMState, cp15.tpidrurw_ns) },
2221       .resetfn = arm_cp_reset_ignore },
2222     { .name = "TPIDRRO_EL0", .state = ARM_CP_STATE_AA64,
2223       .opc0 = 3, .opc1 = 3, .opc2 = 3, .crn = 13, .crm = 0,
2224       .access = PL0_R|PL1_W,
2225       .fieldoffset = offsetof(CPUARMState, cp15.tpidrro_el[0]),
2226       .resetvalue = 0},
2227     { .name = "TPIDRURO", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 3,
2228       .access = PL0_R|PL1_W,
2229       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.tpidruro_s),
2230                              offsetoflow32(CPUARMState, cp15.tpidruro_ns) },
2231       .resetfn = arm_cp_reset_ignore },
2232     { .name = "TPIDR_EL1", .state = ARM_CP_STATE_AA64,
2233       .opc0 = 3, .opc1 = 0, .opc2 = 4, .crn = 13, .crm = 0,
2234       .access = PL1_RW,
2235       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el[1]), .resetvalue = 0 },
2236     { .name = "TPIDRPRW", .opc1 = 0, .cp = 15, .crn = 13, .crm = 0, .opc2 = 4,
2237       .access = PL1_RW,
2238       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.tpidrprw_s),
2239                              offsetoflow32(CPUARMState, cp15.tpidrprw_ns) },
2240       .resetvalue = 0 },
2241     REGINFO_SENTINEL
2242 };
2243
2244 #ifndef CONFIG_USER_ONLY
2245
2246 static CPAccessResult gt_cntfrq_access(CPUARMState *env, const ARMCPRegInfo *ri,
2247                                        bool isread)
2248 {
2249     /* CNTFRQ: not visible from PL0 if both PL0PCTEN and PL0VCTEN are zero.
2250      * Writable only at the highest implemented exception level.
2251      */
2252     int el = arm_current_el(env);
2253
2254     switch (el) {
2255     case 0:
2256         if (!extract32(env->cp15.c14_cntkctl, 0, 2)) {
2257             return CP_ACCESS_TRAP;
2258         }
2259         break;
2260     case 1:
2261         if (!isread && ri->state == ARM_CP_STATE_AA32 &&
2262             arm_is_secure_below_el3(env)) {
2263             /* Accesses from 32-bit Secure EL1 UNDEF (*not* trap to EL3!) */
2264             return CP_ACCESS_TRAP_UNCATEGORIZED;
2265         }
2266         break;
2267     case 2:
2268     case 3:
2269         break;
2270     }
2271
2272     if (!isread && el < arm_highest_el(env)) {
2273         return CP_ACCESS_TRAP_UNCATEGORIZED;
2274     }
2275
2276     return CP_ACCESS_OK;
2277 }
2278
2279 static CPAccessResult gt_counter_access(CPUARMState *env, int timeridx,
2280                                         bool isread)
2281 {
2282     unsigned int cur_el = arm_current_el(env);
2283     bool secure = arm_is_secure(env);
2284
2285     /* CNT[PV]CT: not visible from PL0 if ELO[PV]CTEN is zero */
2286     if (cur_el == 0 &&
2287         !extract32(env->cp15.c14_cntkctl, timeridx, 1)) {
2288         return CP_ACCESS_TRAP;
2289     }
2290
2291     if (arm_feature(env, ARM_FEATURE_EL2) &&
2292         timeridx == GTIMER_PHYS && !secure && cur_el < 2 &&
2293         !extract32(env->cp15.cnthctl_el2, 0, 1)) {
2294         return CP_ACCESS_TRAP_EL2;
2295     }
2296     return CP_ACCESS_OK;
2297 }
2298
2299 static CPAccessResult gt_timer_access(CPUARMState *env, int timeridx,
2300                                       bool isread)
2301 {
2302     unsigned int cur_el = arm_current_el(env);
2303     bool secure = arm_is_secure(env);
2304
2305     /* CNT[PV]_CVAL, CNT[PV]_CTL, CNT[PV]_TVAL: not visible from PL0 if
2306      * EL0[PV]TEN is zero.
2307      */
2308     if (cur_el == 0 &&
2309         !extract32(env->cp15.c14_cntkctl, 9 - timeridx, 1)) {
2310         return CP_ACCESS_TRAP;
2311     }
2312
2313     if (arm_feature(env, ARM_FEATURE_EL2) &&
2314         timeridx == GTIMER_PHYS && !secure && cur_el < 2 &&
2315         !extract32(env->cp15.cnthctl_el2, 1, 1)) {
2316         return CP_ACCESS_TRAP_EL2;
2317     }
2318     return CP_ACCESS_OK;
2319 }
2320
2321 static CPAccessResult gt_pct_access(CPUARMState *env,
2322                                     const ARMCPRegInfo *ri,
2323                                     bool isread)
2324 {
2325     return gt_counter_access(env, GTIMER_PHYS, isread);
2326 }
2327
2328 static CPAccessResult gt_vct_access(CPUARMState *env,
2329                                     const ARMCPRegInfo *ri,
2330                                     bool isread)
2331 {
2332     return gt_counter_access(env, GTIMER_VIRT, isread);
2333 }
2334
2335 static CPAccessResult gt_ptimer_access(CPUARMState *env, const ARMCPRegInfo *ri,
2336                                        bool isread)
2337 {
2338     return gt_timer_access(env, GTIMER_PHYS, isread);
2339 }
2340
2341 static CPAccessResult gt_vtimer_access(CPUARMState *env, const ARMCPRegInfo *ri,
2342                                        bool isread)
2343 {
2344     return gt_timer_access(env, GTIMER_VIRT, isread);
2345 }
2346
2347 static CPAccessResult gt_stimer_access(CPUARMState *env,
2348                                        const ARMCPRegInfo *ri,
2349                                        bool isread)
2350 {
2351     /* The AArch64 register view of the secure physical timer is
2352      * always accessible from EL3, and configurably accessible from
2353      * Secure EL1.
2354      */
2355     switch (arm_current_el(env)) {
2356     case 1:
2357         if (!arm_is_secure(env)) {
2358             return CP_ACCESS_TRAP;
2359         }
2360         if (!(env->cp15.scr_el3 & SCR_ST)) {
2361             return CP_ACCESS_TRAP_EL3;
2362         }
2363         return CP_ACCESS_OK;
2364     case 0:
2365     case 2:
2366         return CP_ACCESS_TRAP;
2367     case 3:
2368         return CP_ACCESS_OK;
2369     default:
2370         g_assert_not_reached();
2371     }
2372 }
2373
2374 static uint64_t gt_get_countervalue(CPUARMState *env)
2375 {
2376     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) / GTIMER_SCALE;
2377 }
2378
2379 static void gt_recalc_timer(ARMCPU *cpu, int timeridx)
2380 {
2381     ARMGenericTimer *gt = &cpu->env.cp15.c14_timer[timeridx];
2382
2383     if (gt->ctl & 1) {
2384         /* Timer enabled: calculate and set current ISTATUS, irq, and
2385          * reset timer to when ISTATUS next has to change
2386          */
2387         uint64_t offset = timeridx == GTIMER_VIRT ?
2388                                       cpu->env.cp15.cntvoff_el2 : 0;
2389         uint64_t count = gt_get_countervalue(&cpu->env);
2390         /* Note that this must be unsigned 64 bit arithmetic: */
2391         int istatus = count - offset >= gt->cval;
2392         uint64_t nexttick;
2393         int irqstate;
2394
2395         gt->ctl = deposit32(gt->ctl, 2, 1, istatus);
2396
2397         irqstate = (istatus && !(gt->ctl & 2));
2398         qemu_set_irq(cpu->gt_timer_outputs[timeridx], irqstate);
2399
2400         if (istatus) {
2401             /* Next transition is when count rolls back over to zero */
2402             nexttick = UINT64_MAX;
2403         } else {
2404             /* Next transition is when we hit cval */
2405             nexttick = gt->cval + offset;
2406         }
2407         /* Note that the desired next expiry time might be beyond the
2408          * signed-64-bit range of a QEMUTimer -- in this case we just
2409          * set the timer for as far in the future as possible. When the
2410          * timer expires we will reset the timer for any remaining period.
2411          */
2412         if (nexttick > INT64_MAX / GTIMER_SCALE) {
2413             nexttick = INT64_MAX / GTIMER_SCALE;
2414         }
2415         timer_mod(cpu->gt_timer[timeridx], nexttick);
2416         trace_arm_gt_recalc(timeridx, irqstate, nexttick);
2417     } else {
2418         /* Timer disabled: ISTATUS and timer output always clear */
2419         gt->ctl &= ~4;
2420         qemu_set_irq(cpu->gt_timer_outputs[timeridx], 0);
2421         timer_del(cpu->gt_timer[timeridx]);
2422         trace_arm_gt_recalc_disabled(timeridx);
2423     }
2424 }
2425
2426 static void gt_timer_reset(CPUARMState *env, const ARMCPRegInfo *ri,
2427                            int timeridx)
2428 {
2429     ARMCPU *cpu = arm_env_get_cpu(env);
2430
2431     timer_del(cpu->gt_timer[timeridx]);
2432 }
2433
2434 static uint64_t gt_cnt_read(CPUARMState *env, const ARMCPRegInfo *ri)
2435 {
2436     return gt_get_countervalue(env);
2437 }
2438
2439 static uint64_t gt_virt_cnt_read(CPUARMState *env, const ARMCPRegInfo *ri)
2440 {
2441     return gt_get_countervalue(env) - env->cp15.cntvoff_el2;
2442 }
2443
2444 static void gt_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2445                           int timeridx,
2446                           uint64_t value)
2447 {
2448     trace_arm_gt_cval_write(timeridx, value);
2449     env->cp15.c14_timer[timeridx].cval = value;
2450     gt_recalc_timer(arm_env_get_cpu(env), timeridx);
2451 }
2452
2453 static uint64_t gt_tval_read(CPUARMState *env, const ARMCPRegInfo *ri,
2454                              int timeridx)
2455 {
2456     uint64_t offset = timeridx == GTIMER_VIRT ? env->cp15.cntvoff_el2 : 0;
2457
2458     return (uint32_t)(env->cp15.c14_timer[timeridx].cval -
2459                       (gt_get_countervalue(env) - offset));
2460 }
2461
2462 static void gt_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2463                           int timeridx,
2464                           uint64_t value)
2465 {
2466     uint64_t offset = timeridx == GTIMER_VIRT ? env->cp15.cntvoff_el2 : 0;
2467
2468     trace_arm_gt_tval_write(timeridx, value);
2469     env->cp15.c14_timer[timeridx].cval = gt_get_countervalue(env) - offset +
2470                                          sextract64(value, 0, 32);
2471     gt_recalc_timer(arm_env_get_cpu(env), timeridx);
2472 }
2473
2474 static void gt_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
2475                          int timeridx,
2476                          uint64_t value)
2477 {
2478     ARMCPU *cpu = arm_env_get_cpu(env);
2479     uint32_t oldval = env->cp15.c14_timer[timeridx].ctl;
2480
2481     trace_arm_gt_ctl_write(timeridx, value);
2482     env->cp15.c14_timer[timeridx].ctl = deposit64(oldval, 0, 2, value);
2483     if ((oldval ^ value) & 1) {
2484         /* Enable toggled */
2485         gt_recalc_timer(cpu, timeridx);
2486     } else if ((oldval ^ value) & 2) {
2487         /* IMASK toggled: don't need to recalculate,
2488          * just set the interrupt line based on ISTATUS
2489          */
2490         int irqstate = (oldval & 4) && !(value & 2);
2491
2492         trace_arm_gt_imask_toggle(timeridx, irqstate);
2493         qemu_set_irq(cpu->gt_timer_outputs[timeridx], irqstate);
2494     }
2495 }
2496
2497 static void gt_phys_timer_reset(CPUARMState *env, const ARMCPRegInfo *ri)
2498 {
2499     gt_timer_reset(env, ri, GTIMER_PHYS);
2500 }
2501
2502 static void gt_phys_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2503                                uint64_t value)
2504 {
2505     gt_cval_write(env, ri, GTIMER_PHYS, value);
2506 }
2507
2508 static uint64_t gt_phys_tval_read(CPUARMState *env, const ARMCPRegInfo *ri)
2509 {
2510     return gt_tval_read(env, ri, GTIMER_PHYS);
2511 }
2512
2513 static void gt_phys_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2514                                uint64_t value)
2515 {
2516     gt_tval_write(env, ri, GTIMER_PHYS, value);
2517 }
2518
2519 static void gt_phys_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
2520                               uint64_t value)
2521 {
2522     gt_ctl_write(env, ri, GTIMER_PHYS, value);
2523 }
2524
2525 static void gt_virt_timer_reset(CPUARMState *env, const ARMCPRegInfo *ri)
2526 {
2527     gt_timer_reset(env, ri, GTIMER_VIRT);
2528 }
2529
2530 static void gt_virt_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2531                                uint64_t value)
2532 {
2533     gt_cval_write(env, ri, GTIMER_VIRT, value);
2534 }
2535
2536 static uint64_t gt_virt_tval_read(CPUARMState *env, const ARMCPRegInfo *ri)
2537 {
2538     return gt_tval_read(env, ri, GTIMER_VIRT);
2539 }
2540
2541 static void gt_virt_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2542                                uint64_t value)
2543 {
2544     gt_tval_write(env, ri, GTIMER_VIRT, value);
2545 }
2546
2547 static void gt_virt_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
2548                               uint64_t value)
2549 {
2550     gt_ctl_write(env, ri, GTIMER_VIRT, value);
2551 }
2552
2553 static void gt_cntvoff_write(CPUARMState *env, const ARMCPRegInfo *ri,
2554                               uint64_t value)
2555 {
2556     ARMCPU *cpu = arm_env_get_cpu(env);
2557
2558     trace_arm_gt_cntvoff_write(value);
2559     raw_write(env, ri, value);
2560     gt_recalc_timer(cpu, GTIMER_VIRT);
2561 }
2562
2563 static void gt_hyp_timer_reset(CPUARMState *env, const ARMCPRegInfo *ri)
2564 {
2565     gt_timer_reset(env, ri, GTIMER_HYP);
2566 }
2567
2568 static void gt_hyp_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2569                               uint64_t value)
2570 {
2571     gt_cval_write(env, ri, GTIMER_HYP, value);
2572 }
2573
2574 static uint64_t gt_hyp_tval_read(CPUARMState *env, const ARMCPRegInfo *ri)
2575 {
2576     return gt_tval_read(env, ri, GTIMER_HYP);
2577 }
2578
2579 static void gt_hyp_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2580                               uint64_t value)
2581 {
2582     gt_tval_write(env, ri, GTIMER_HYP, value);
2583 }
2584
2585 static void gt_hyp_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
2586                               uint64_t value)
2587 {
2588     gt_ctl_write(env, ri, GTIMER_HYP, value);
2589 }
2590
2591 static void gt_sec_timer_reset(CPUARMState *env, const ARMCPRegInfo *ri)
2592 {
2593     gt_timer_reset(env, ri, GTIMER_SEC);
2594 }
2595
2596 static void gt_sec_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2597                               uint64_t value)
2598 {
2599     gt_cval_write(env, ri, GTIMER_SEC, value);
2600 }
2601
2602 static uint64_t gt_sec_tval_read(CPUARMState *env, const ARMCPRegInfo *ri)
2603 {
2604     return gt_tval_read(env, ri, GTIMER_SEC);
2605 }
2606
2607 static void gt_sec_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
2608                               uint64_t value)
2609 {
2610     gt_tval_write(env, ri, GTIMER_SEC, value);
2611 }
2612
2613 static void gt_sec_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
2614                               uint64_t value)
2615 {
2616     gt_ctl_write(env, ri, GTIMER_SEC, value);
2617 }
2618
2619 void arm_gt_ptimer_cb(void *opaque)
2620 {
2621     ARMCPU *cpu = opaque;
2622
2623     gt_recalc_timer(cpu, GTIMER_PHYS);
2624 }
2625
2626 void arm_gt_vtimer_cb(void *opaque)
2627 {
2628     ARMCPU *cpu = opaque;
2629
2630     gt_recalc_timer(cpu, GTIMER_VIRT);
2631 }
2632
2633 void arm_gt_htimer_cb(void *opaque)
2634 {
2635     ARMCPU *cpu = opaque;
2636
2637     gt_recalc_timer(cpu, GTIMER_HYP);
2638 }
2639
2640 void arm_gt_stimer_cb(void *opaque)
2641 {
2642     ARMCPU *cpu = opaque;
2643
2644     gt_recalc_timer(cpu, GTIMER_SEC);
2645 }
2646
2647 static const ARMCPRegInfo generic_timer_cp_reginfo[] = {
2648     /* Note that CNTFRQ is purely reads-as-written for the benefit
2649      * of software; writing it doesn't actually change the timer frequency.
2650      * Our reset value matches the fixed frequency we implement the timer at.
2651      */
2652     { .name = "CNTFRQ", .cp = 15, .crn = 14, .crm = 0, .opc1 = 0, .opc2 = 0,
2653       .type = ARM_CP_ALIAS,
2654       .access = PL1_RW | PL0_R, .accessfn = gt_cntfrq_access,
2655       .fieldoffset = offsetoflow32(CPUARMState, cp15.c14_cntfrq),
2656     },
2657     { .name = "CNTFRQ_EL0", .state = ARM_CP_STATE_AA64,
2658       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 0, .opc2 = 0,
2659       .access = PL1_RW | PL0_R, .accessfn = gt_cntfrq_access,
2660       .fieldoffset = offsetof(CPUARMState, cp15.c14_cntfrq),
2661       .resetvalue = (1000 * 1000 * 1000) / GTIMER_SCALE,
2662     },
2663     /* overall control: mostly access permissions */
2664     { .name = "CNTKCTL", .state = ARM_CP_STATE_BOTH,
2665       .opc0 = 3, .opc1 = 0, .crn = 14, .crm = 1, .opc2 = 0,
2666       .access = PL1_RW,
2667       .fieldoffset = offsetof(CPUARMState, cp15.c14_cntkctl),
2668       .resetvalue = 0,
2669     },
2670     /* per-timer control */
2671     { .name = "CNTP_CTL", .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 1,
2672       .secure = ARM_CP_SECSTATE_NS,
2673       .type = ARM_CP_IO | ARM_CP_ALIAS, .access = PL0_RW,
2674       .accessfn = gt_ptimer_access,
2675       .fieldoffset = offsetoflow32(CPUARMState,
2676                                    cp15.c14_timer[GTIMER_PHYS].ctl),
2677       .writefn = gt_phys_ctl_write, .raw_writefn = raw_write,
2678     },
2679     { .name = "CNTP_CTL_S",
2680       .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 1,
2681       .secure = ARM_CP_SECSTATE_S,
2682       .type = ARM_CP_IO | ARM_CP_ALIAS, .access = PL0_RW,
2683       .accessfn = gt_ptimer_access,
2684       .fieldoffset = offsetoflow32(CPUARMState,
2685                                    cp15.c14_timer[GTIMER_SEC].ctl),
2686       .writefn = gt_sec_ctl_write, .raw_writefn = raw_write,
2687     },
2688     { .name = "CNTP_CTL_EL0", .state = ARM_CP_STATE_AA64,
2689       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 2, .opc2 = 1,
2690       .type = ARM_CP_IO, .access = PL0_RW,
2691       .accessfn = gt_ptimer_access,
2692       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_PHYS].ctl),
2693       .resetvalue = 0,
2694       .writefn = gt_phys_ctl_write, .raw_writefn = raw_write,
2695     },
2696     { .name = "CNTV_CTL", .cp = 15, .crn = 14, .crm = 3, .opc1 = 0, .opc2 = 1,
2697       .type = ARM_CP_IO | ARM_CP_ALIAS, .access = PL0_RW,
2698       .accessfn = gt_vtimer_access,
2699       .fieldoffset = offsetoflow32(CPUARMState,
2700                                    cp15.c14_timer[GTIMER_VIRT].ctl),
2701       .writefn = gt_virt_ctl_write, .raw_writefn = raw_write,
2702     },
2703     { .name = "CNTV_CTL_EL0", .state = ARM_CP_STATE_AA64,
2704       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 3, .opc2 = 1,
2705       .type = ARM_CP_IO, .access = PL0_RW,
2706       .accessfn = gt_vtimer_access,
2707       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_VIRT].ctl),
2708       .resetvalue = 0,
2709       .writefn = gt_virt_ctl_write, .raw_writefn = raw_write,
2710     },
2711     /* TimerValue views: a 32 bit downcounting view of the underlying state */
2712     { .name = "CNTP_TVAL", .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 0,
2713       .secure = ARM_CP_SECSTATE_NS,
2714       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL0_RW,
2715       .accessfn = gt_ptimer_access,
2716       .readfn = gt_phys_tval_read, .writefn = gt_phys_tval_write,
2717     },
2718     { .name = "CNTP_TVAL_S",
2719       .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 0,
2720       .secure = ARM_CP_SECSTATE_S,
2721       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL0_RW,
2722       .accessfn = gt_ptimer_access,
2723       .readfn = gt_sec_tval_read, .writefn = gt_sec_tval_write,
2724     },
2725     { .name = "CNTP_TVAL_EL0", .state = ARM_CP_STATE_AA64,
2726       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 2, .opc2 = 0,
2727       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL0_RW,
2728       .accessfn = gt_ptimer_access, .resetfn = gt_phys_timer_reset,
2729       .readfn = gt_phys_tval_read, .writefn = gt_phys_tval_write,
2730     },
2731     { .name = "CNTV_TVAL", .cp = 15, .crn = 14, .crm = 3, .opc1 = 0, .opc2 = 0,
2732       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL0_RW,
2733       .accessfn = gt_vtimer_access,
2734       .readfn = gt_virt_tval_read, .writefn = gt_virt_tval_write,
2735     },
2736     { .name = "CNTV_TVAL_EL0", .state = ARM_CP_STATE_AA64,
2737       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 3, .opc2 = 0,
2738       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL0_RW,
2739       .accessfn = gt_vtimer_access, .resetfn = gt_virt_timer_reset,
2740       .readfn = gt_virt_tval_read, .writefn = gt_virt_tval_write,
2741     },
2742     /* The counter itself */
2743     { .name = "CNTPCT", .cp = 15, .crm = 14, .opc1 = 0,
2744       .access = PL0_R, .type = ARM_CP_64BIT | ARM_CP_NO_RAW | ARM_CP_IO,
2745       .accessfn = gt_pct_access,
2746       .readfn = gt_cnt_read, .resetfn = arm_cp_reset_ignore,
2747     },
2748     { .name = "CNTPCT_EL0", .state = ARM_CP_STATE_AA64,
2749       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 0, .opc2 = 1,
2750       .access = PL0_R, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2751       .accessfn = gt_pct_access, .readfn = gt_cnt_read,
2752     },
2753     { .name = "CNTVCT", .cp = 15, .crm = 14, .opc1 = 1,
2754       .access = PL0_R, .type = ARM_CP_64BIT | ARM_CP_NO_RAW | ARM_CP_IO,
2755       .accessfn = gt_vct_access,
2756       .readfn = gt_virt_cnt_read, .resetfn = arm_cp_reset_ignore,
2757     },
2758     { .name = "CNTVCT_EL0", .state = ARM_CP_STATE_AA64,
2759       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 0, .opc2 = 2,
2760       .access = PL0_R, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2761       .accessfn = gt_vct_access, .readfn = gt_virt_cnt_read,
2762     },
2763     /* Comparison value, indicating when the timer goes off */
2764     { .name = "CNTP_CVAL", .cp = 15, .crm = 14, .opc1 = 2,
2765       .secure = ARM_CP_SECSTATE_NS,
2766       .access = PL0_RW,
2767       .type = ARM_CP_64BIT | ARM_CP_IO | ARM_CP_ALIAS,
2768       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_PHYS].cval),
2769       .accessfn = gt_ptimer_access,
2770       .writefn = gt_phys_cval_write, .raw_writefn = raw_write,
2771     },
2772     { .name = "CNTP_CVAL_S", .cp = 15, .crm = 14, .opc1 = 2,
2773       .secure = ARM_CP_SECSTATE_S,
2774       .access = PL0_RW,
2775       .type = ARM_CP_64BIT | ARM_CP_IO | ARM_CP_ALIAS,
2776       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_SEC].cval),
2777       .accessfn = gt_ptimer_access,
2778       .writefn = gt_sec_cval_write, .raw_writefn = raw_write,
2779     },
2780     { .name = "CNTP_CVAL_EL0", .state = ARM_CP_STATE_AA64,
2781       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 2, .opc2 = 2,
2782       .access = PL0_RW,
2783       .type = ARM_CP_IO,
2784       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_PHYS].cval),
2785       .resetvalue = 0, .accessfn = gt_ptimer_access,
2786       .writefn = gt_phys_cval_write, .raw_writefn = raw_write,
2787     },
2788     { .name = "CNTV_CVAL", .cp = 15, .crm = 14, .opc1 = 3,
2789       .access = PL0_RW,
2790       .type = ARM_CP_64BIT | ARM_CP_IO | ARM_CP_ALIAS,
2791       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_VIRT].cval),
2792       .accessfn = gt_vtimer_access,
2793       .writefn = gt_virt_cval_write, .raw_writefn = raw_write,
2794     },
2795     { .name = "CNTV_CVAL_EL0", .state = ARM_CP_STATE_AA64,
2796       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 3, .opc2 = 2,
2797       .access = PL0_RW,
2798       .type = ARM_CP_IO,
2799       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_VIRT].cval),
2800       .resetvalue = 0, .accessfn = gt_vtimer_access,
2801       .writefn = gt_virt_cval_write, .raw_writefn = raw_write,
2802     },
2803     /* Secure timer -- this is actually restricted to only EL3
2804      * and configurably Secure-EL1 via the accessfn.
2805      */
2806     { .name = "CNTPS_TVAL_EL1", .state = ARM_CP_STATE_AA64,
2807       .opc0 = 3, .opc1 = 7, .crn = 14, .crm = 2, .opc2 = 0,
2808       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL1_RW,
2809       .accessfn = gt_stimer_access,
2810       .readfn = gt_sec_tval_read,
2811       .writefn = gt_sec_tval_write,
2812       .resetfn = gt_sec_timer_reset,
2813     },
2814     { .name = "CNTPS_CTL_EL1", .state = ARM_CP_STATE_AA64,
2815       .opc0 = 3, .opc1 = 7, .crn = 14, .crm = 2, .opc2 = 1,
2816       .type = ARM_CP_IO, .access = PL1_RW,
2817       .accessfn = gt_stimer_access,
2818       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_SEC].ctl),
2819       .resetvalue = 0,
2820       .writefn = gt_sec_ctl_write, .raw_writefn = raw_write,
2821     },
2822     { .name = "CNTPS_CVAL_EL1", .state = ARM_CP_STATE_AA64,
2823       .opc0 = 3, .opc1 = 7, .crn = 14, .crm = 2, .opc2 = 2,
2824       .type = ARM_CP_IO, .access = PL1_RW,
2825       .accessfn = gt_stimer_access,
2826       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_SEC].cval),
2827       .writefn = gt_sec_cval_write, .raw_writefn = raw_write,
2828     },
2829     REGINFO_SENTINEL
2830 };
2831
2832 #else
2833
2834 /* In user-mode most of the generic timer registers are inaccessible
2835  * however modern kernels (4.12+) allow access to cntvct_el0
2836  */
2837
2838 static uint64_t gt_virt_cnt_read(CPUARMState *env, const ARMCPRegInfo *ri)
2839 {
2840     /* Currently we have no support for QEMUTimer in linux-user so we
2841      * can't call gt_get_countervalue(env), instead we directly
2842      * call the lower level functions.
2843      */
2844     return cpu_get_clock() / GTIMER_SCALE;
2845 }
2846
2847 static const ARMCPRegInfo generic_timer_cp_reginfo[] = {
2848     { .name = "CNTFRQ_EL0", .state = ARM_CP_STATE_AA64,
2849       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 0, .opc2 = 0,
2850       .type = ARM_CP_CONST, .access = PL0_R /* no PL1_RW in linux-user */,
2851       .fieldoffset = offsetof(CPUARMState, cp15.c14_cntfrq),
2852       .resetvalue = NANOSECONDS_PER_SECOND / GTIMER_SCALE,
2853     },
2854     { .name = "CNTVCT_EL0", .state = ARM_CP_STATE_AA64,
2855       .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 0, .opc2 = 2,
2856       .access = PL0_R, .type = ARM_CP_NO_RAW | ARM_CP_IO,
2857       .readfn = gt_virt_cnt_read,
2858     },
2859     REGINFO_SENTINEL
2860 };
2861
2862 #endif
2863
2864 static void par_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
2865 {
2866     if (arm_feature(env, ARM_FEATURE_LPAE)) {
2867         raw_write(env, ri, value);
2868     } else if (arm_feature(env, ARM_FEATURE_V7)) {
2869         raw_write(env, ri, value & 0xfffff6ff);
2870     } else {
2871         raw_write(env, ri, value & 0xfffff1ff);
2872     }
2873 }
2874
2875 #ifndef CONFIG_USER_ONLY
2876 /* get_phys_addr() isn't present for user-mode-only targets */
2877
2878 static CPAccessResult ats_access(CPUARMState *env, const ARMCPRegInfo *ri,
2879                                  bool isread)
2880 {
2881     if (ri->opc2 & 4) {
2882         /* The ATS12NSO* operations must trap to EL3 if executed in
2883          * Secure EL1 (which can only happen if EL3 is AArch64).
2884          * They are simply UNDEF if executed from NS EL1.
2885          * They function normally from EL2 or EL3.
2886          */
2887         if (arm_current_el(env) == 1) {
2888             if (arm_is_secure_below_el3(env)) {
2889                 return CP_ACCESS_TRAP_UNCATEGORIZED_EL3;
2890             }
2891             return CP_ACCESS_TRAP_UNCATEGORIZED;
2892         }
2893     }
2894     return CP_ACCESS_OK;
2895 }
2896
2897 static uint64_t do_ats_write(CPUARMState *env, uint64_t value,
2898                              MMUAccessType access_type, ARMMMUIdx mmu_idx)
2899 {
2900     hwaddr phys_addr;
2901     target_ulong page_size;
2902     int prot;
2903     bool ret;
2904     uint64_t par64;
2905     bool format64 = false;
2906     MemTxAttrs attrs = {};
2907     ARMMMUFaultInfo fi = {};
2908     ARMCacheAttrs cacheattrs = {};
2909
2910     ret = get_phys_addr(env, value, access_type, mmu_idx, &phys_addr, &attrs,
2911                         &prot, &page_size, &fi, &cacheattrs);
2912
2913     if (is_a64(env)) {
2914         format64 = true;
2915     } else if (arm_feature(env, ARM_FEATURE_LPAE)) {
2916         /*
2917          * ATS1Cxx:
2918          * * TTBCR.EAE determines whether the result is returned using the
2919          *   32-bit or the 64-bit PAR format
2920          * * Instructions executed in Hyp mode always use the 64bit format
2921          *
2922          * ATS1S2NSOxx uses the 64bit format if any of the following is true:
2923          * * The Non-secure TTBCR.EAE bit is set to 1
2924          * * The implementation includes EL2, and the value of HCR.VM is 1
2925          *
2926          * (Note that HCR.DC makes HCR.VM behave as if it is 1.)
2927          *
2928          * ATS1Hx always uses the 64bit format.
2929          */
2930         format64 = arm_s1_regime_using_lpae_format(env, mmu_idx);
2931
2932         if (arm_feature(env, ARM_FEATURE_EL2)) {
2933             if (mmu_idx == ARMMMUIdx_S12NSE0 || mmu_idx == ARMMMUIdx_S12NSE1) {
2934                 format64 |= env->cp15.hcr_el2 & (HCR_VM | HCR_DC);
2935             } else {
2936                 format64 |= arm_current_el(env) == 2;
2937             }
2938         }
2939     }
2940
2941     if (format64) {
2942         /* Create a 64-bit PAR */
2943         par64 = (1 << 11); /* LPAE bit always set */
2944         if (!ret) {
2945             par64 |= phys_addr & ~0xfffULL;
2946             if (!attrs.secure) {
2947                 par64 |= (1 << 9); /* NS */
2948             }
2949             par64 |= (uint64_t)cacheattrs.attrs << 56; /* ATTR */
2950             par64 |= cacheattrs.shareability << 7; /* SH */
2951         } else {
2952             uint32_t fsr = arm_fi_to_lfsc(&fi);
2953
2954             par64 |= 1; /* F */
2955             par64 |= (fsr & 0x3f) << 1; /* FS */
2956             if (fi.stage2) {
2957                 par64 |= (1 << 9); /* S */
2958             }
2959             if (fi.s1ptw) {
2960                 par64 |= (1 << 8); /* PTW */
2961             }
2962         }
2963     } else {
2964         /* fsr is a DFSR/IFSR value for the short descriptor
2965          * translation table format (with WnR always clear).
2966          * Convert it to a 32-bit PAR.
2967          */
2968         if (!ret) {
2969             /* We do not set any attribute bits in the PAR */
2970             if (page_size == (1 << 24)
2971                 && arm_feature(env, ARM_FEATURE_V7)) {
2972                 par64 = (phys_addr & 0xff000000) | (1 << 1);
2973             } else {
2974                 par64 = phys_addr & 0xfffff000;
2975             }
2976             if (!attrs.secure) {
2977                 par64 |= (1 << 9); /* NS */
2978             }
2979         } else {
2980             uint32_t fsr = arm_fi_to_sfsc(&fi);
2981
2982             par64 = ((fsr & (1 << 10)) >> 5) | ((fsr & (1 << 12)) >> 6) |
2983                     ((fsr & 0xf) << 1) | 1;
2984         }
2985     }
2986     return par64;
2987 }
2988
2989 static void ats_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
2990 {
2991     MMUAccessType access_type = ri->opc2 & 1 ? MMU_DATA_STORE : MMU_DATA_LOAD;
2992     uint64_t par64;
2993     ARMMMUIdx mmu_idx;
2994     int el = arm_current_el(env);
2995     bool secure = arm_is_secure_below_el3(env);
2996
2997     switch (ri->opc2 & 6) {
2998     case 0:
2999         /* stage 1 current state PL1: ATS1CPR, ATS1CPW */
3000         switch (el) {
3001         case 3:
3002             mmu_idx = ARMMMUIdx_S1E3;
3003             break;
3004         case 2:
3005             mmu_idx = ARMMMUIdx_S1NSE1;
3006             break;
3007         case 1:
3008             mmu_idx = secure ? ARMMMUIdx_S1SE1 : ARMMMUIdx_S1NSE1;
3009             break;
3010         default:
3011             g_assert_not_reached();
3012         }
3013         break;
3014     case 2:
3015         /* stage 1 current state PL0: ATS1CUR, ATS1CUW */
3016         switch (el) {
3017         case 3:
3018             mmu_idx = ARMMMUIdx_S1SE0;
3019             break;
3020         case 2:
3021             mmu_idx = ARMMMUIdx_S1NSE0;
3022             break;
3023         case 1:
3024             mmu_idx = secure ? ARMMMUIdx_S1SE0 : ARMMMUIdx_S1NSE0;
3025             break;
3026         default:
3027             g_assert_not_reached();
3028         }
3029         break;
3030     case 4:
3031         /* stage 1+2 NonSecure PL1: ATS12NSOPR, ATS12NSOPW */
3032         mmu_idx = ARMMMUIdx_S12NSE1;
3033         break;
3034     case 6:
3035         /* stage 1+2 NonSecure PL0: ATS12NSOUR, ATS12NSOUW */
3036         mmu_idx = ARMMMUIdx_S12NSE0;
3037         break;
3038     default:
3039         g_assert_not_reached();
3040     }
3041
3042     par64 = do_ats_write(env, value, access_type, mmu_idx);
3043
3044     A32_BANKED_CURRENT_REG_SET(env, par, par64);
3045 }
3046
3047 static void ats1h_write(CPUARMState *env, const ARMCPRegInfo *ri,
3048                         uint64_t value)
3049 {
3050     MMUAccessType access_type = ri->opc2 & 1 ? MMU_DATA_STORE : MMU_DATA_LOAD;
3051     uint64_t par64;
3052
3053     par64 = do_ats_write(env, value, access_type, ARMMMUIdx_S1E2);
3054
3055     A32_BANKED_CURRENT_REG_SET(env, par, par64);
3056 }
3057
3058 static CPAccessResult at_s1e2_access(CPUARMState *env, const ARMCPRegInfo *ri,
3059                                      bool isread)
3060 {
3061     if (arm_current_el(env) == 3 && !(env->cp15.scr_el3 & SCR_NS)) {
3062         return CP_ACCESS_TRAP;
3063     }
3064     return CP_ACCESS_OK;
3065 }
3066
3067 static void ats_write64(CPUARMState *env, const ARMCPRegInfo *ri,
3068                         uint64_t value)
3069 {
3070     MMUAccessType access_type = ri->opc2 & 1 ? MMU_DATA_STORE : MMU_DATA_LOAD;
3071     ARMMMUIdx mmu_idx;
3072     int secure = arm_is_secure_below_el3(env);
3073
3074     switch (ri->opc2 & 6) {
3075     case 0:
3076         switch (ri->opc1) {
3077         case 0: /* AT S1E1R, AT S1E1W */
3078             mmu_idx = secure ? ARMMMUIdx_S1SE1 : ARMMMUIdx_S1NSE1;
3079             break;
3080         case 4: /* AT S1E2R, AT S1E2W */
3081             mmu_idx = ARMMMUIdx_S1E2;
3082             break;
3083         case 6: /* AT S1E3R, AT S1E3W */
3084             mmu_idx = ARMMMUIdx_S1E3;
3085             break;
3086         default:
3087             g_assert_not_reached();
3088         }
3089         break;
3090     case 2: /* AT S1E0R, AT S1E0W */
3091         mmu_idx = secure ? ARMMMUIdx_S1SE0 : ARMMMUIdx_S1NSE0;
3092         break;
3093     case 4: /* AT S12E1R, AT S12E1W */
3094         mmu_idx = secure ? ARMMMUIdx_S1SE1 : ARMMMUIdx_S12NSE1;
3095         break;
3096     case 6: /* AT S12E0R, AT S12E0W */
3097         mmu_idx = secure ? ARMMMUIdx_S1SE0 : ARMMMUIdx_S12NSE0;
3098         break;
3099     default:
3100         g_assert_not_reached();
3101     }
3102
3103     env->cp15.par_el[1] = do_ats_write(env, value, access_type, mmu_idx);
3104 }
3105 #endif
3106
3107 static const ARMCPRegInfo vapa_cp_reginfo[] = {
3108     { .name = "PAR", .cp = 15, .crn = 7, .crm = 4, .opc1 = 0, .opc2 = 0,
3109       .access = PL1_RW, .resetvalue = 0,
3110       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.par_s),
3111                              offsetoflow32(CPUARMState, cp15.par_ns) },
3112       .writefn = par_write },
3113 #ifndef CONFIG_USER_ONLY
3114     /* This underdecoding is safe because the reginfo is NO_RAW. */
3115     { .name = "ATS", .cp = 15, .crn = 7, .crm = 8, .opc1 = 0, .opc2 = CP_ANY,
3116       .access = PL1_W, .accessfn = ats_access,
3117       .writefn = ats_write, .type = ARM_CP_NO_RAW },
3118 #endif
3119     REGINFO_SENTINEL
3120 };
3121
3122 /* Return basic MPU access permission bits.  */
3123 static uint32_t simple_mpu_ap_bits(uint32_t val)
3124 {
3125     uint32_t ret;
3126     uint32_t mask;
3127     int i;
3128     ret = 0;
3129     mask = 3;
3130     for (i = 0; i < 16; i += 2) {
3131         ret |= (val >> i) & mask;
3132         mask <<= 2;
3133     }
3134     return ret;
3135 }
3136
3137 /* Pad basic MPU access permission bits to extended format.  */
3138 static uint32_t extended_mpu_ap_bits(uint32_t val)
3139 {
3140     uint32_t ret;
3141     uint32_t mask;
3142     int i;
3143     ret = 0;
3144     mask = 3;
3145     for (i = 0; i < 16; i += 2) {
3146         ret |= (val & mask) << i;
3147         mask <<= 2;
3148     }
3149     return ret;
3150 }
3151
3152 static void pmsav5_data_ap_write(CPUARMState *env, const ARMCPRegInfo *ri,
3153                                  uint64_t value)
3154 {
3155     env->cp15.pmsav5_data_ap = extended_mpu_ap_bits(value);
3156 }
3157
3158 static uint64_t pmsav5_data_ap_read(CPUARMState *env, const ARMCPRegInfo *ri)
3159 {
3160     return simple_mpu_ap_bits(env->cp15.pmsav5_data_ap);
3161 }
3162
3163 static void pmsav5_insn_ap_write(CPUARMState *env, const ARMCPRegInfo *ri,
3164                                  uint64_t value)
3165 {
3166     env->cp15.pmsav5_insn_ap = extended_mpu_ap_bits(value);
3167 }
3168
3169 static uint64_t pmsav5_insn_ap_read(CPUARMState *env, const ARMCPRegInfo *ri)
3170 {
3171     return simple_mpu_ap_bits(env->cp15.pmsav5_insn_ap);
3172 }
3173
3174 static uint64_t pmsav7_read(CPUARMState *env, const ARMCPRegInfo *ri)
3175 {
3176     uint32_t *u32p = *(uint32_t **)raw_ptr(env, ri);
3177
3178     if (!u32p) {
3179         return 0;
3180     }
3181
3182     u32p += env->pmsav7.rnr[M_REG_NS];
3183     return *u32p;
3184 }
3185
3186 static void pmsav7_write(CPUARMState *env, const ARMCPRegInfo *ri,
3187                          uint64_t value)
3188 {
3189     ARMCPU *cpu = arm_env_get_cpu(env);
3190     uint32_t *u32p = *(uint32_t **)raw_ptr(env, ri);
3191
3192     if (!u32p) {
3193         return;
3194     }
3195
3196     u32p += env->pmsav7.rnr[M_REG_NS];
3197     tlb_flush(CPU(cpu)); /* Mappings may have changed - purge! */
3198     *u32p = value;
3199 }
3200
3201 static void pmsav7_rgnr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3202                               uint64_t value)
3203 {
3204     ARMCPU *cpu = arm_env_get_cpu(env);
3205     uint32_t nrgs = cpu->pmsav7_dregion;
3206
3207     if (value >= nrgs) {
3208         qemu_log_mask(LOG_GUEST_ERROR,
3209                       "PMSAv7 RGNR write >= # supported regions, %" PRIu32
3210                       " > %" PRIu32 "\n", (uint32_t)value, nrgs);
3211         return;
3212     }
3213
3214     raw_write(env, ri, value);
3215 }
3216
3217 static const ARMCPRegInfo pmsav7_cp_reginfo[] = {
3218     /* Reset for all these registers is handled in arm_cpu_reset(),
3219      * because the PMSAv7 is also used by M-profile CPUs, which do
3220      * not register cpregs but still need the state to be reset.
3221      */
3222     { .name = "DRBAR", .cp = 15, .crn = 6, .opc1 = 0, .crm = 1, .opc2 = 0,
3223       .access = PL1_RW, .type = ARM_CP_NO_RAW,
3224       .fieldoffset = offsetof(CPUARMState, pmsav7.drbar),
3225       .readfn = pmsav7_read, .writefn = pmsav7_write,
3226       .resetfn = arm_cp_reset_ignore },
3227     { .name = "DRSR", .cp = 15, .crn = 6, .opc1 = 0, .crm = 1, .opc2 = 2,
3228       .access = PL1_RW, .type = ARM_CP_NO_RAW,
3229       .fieldoffset = offsetof(CPUARMState, pmsav7.drsr),
3230       .readfn = pmsav7_read, .writefn = pmsav7_write,
3231       .resetfn = arm_cp_reset_ignore },
3232     { .name = "DRACR", .cp = 15, .crn = 6, .opc1 = 0, .crm = 1, .opc2 = 4,
3233       .access = PL1_RW, .type = ARM_CP_NO_RAW,
3234       .fieldoffset = offsetof(CPUARMState, pmsav7.dracr),
3235       .readfn = pmsav7_read, .writefn = pmsav7_write,
3236       .resetfn = arm_cp_reset_ignore },
3237     { .name = "RGNR", .cp = 15, .crn = 6, .opc1 = 0, .crm = 2, .opc2 = 0,
3238       .access = PL1_RW,
3239       .fieldoffset = offsetof(CPUARMState, pmsav7.rnr[M_REG_NS]),
3240       .writefn = pmsav7_rgnr_write,
3241       .resetfn = arm_cp_reset_ignore },
3242     REGINFO_SENTINEL
3243 };
3244
3245 static const ARMCPRegInfo pmsav5_cp_reginfo[] = {
3246     { .name = "DATA_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 0,
3247       .access = PL1_RW, .type = ARM_CP_ALIAS,
3248       .fieldoffset = offsetof(CPUARMState, cp15.pmsav5_data_ap),
3249       .readfn = pmsav5_data_ap_read, .writefn = pmsav5_data_ap_write, },
3250     { .name = "INSN_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 1,
3251       .access = PL1_RW, .type = ARM_CP_ALIAS,
3252       .fieldoffset = offsetof(CPUARMState, cp15.pmsav5_insn_ap),
3253       .readfn = pmsav5_insn_ap_read, .writefn = pmsav5_insn_ap_write, },
3254     { .name = "DATA_EXT_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 2,
3255       .access = PL1_RW,
3256       .fieldoffset = offsetof(CPUARMState, cp15.pmsav5_data_ap),
3257       .resetvalue = 0, },
3258     { .name = "INSN_EXT_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 3,
3259       .access = PL1_RW,
3260       .fieldoffset = offsetof(CPUARMState, cp15.pmsav5_insn_ap),
3261       .resetvalue = 0, },
3262     { .name = "DCACHE_CFG", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0,
3263       .access = PL1_RW,
3264       .fieldoffset = offsetof(CPUARMState, cp15.c2_data), .resetvalue = 0, },
3265     { .name = "ICACHE_CFG", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 1,
3266       .access = PL1_RW,
3267       .fieldoffset = offsetof(CPUARMState, cp15.c2_insn), .resetvalue = 0, },
3268     /* Protection region base and size registers */
3269     { .name = "946_PRBS0", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0,
3270       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3271       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[0]) },
3272     { .name = "946_PRBS1", .cp = 15, .crn = 6, .crm = 1, .opc1 = 0,
3273       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3274       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[1]) },
3275     { .name = "946_PRBS2", .cp = 15, .crn = 6, .crm = 2, .opc1 = 0,
3276       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3277       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[2]) },
3278     { .name = "946_PRBS3", .cp = 15, .crn = 6, .crm = 3, .opc1 = 0,
3279       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3280       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[3]) },
3281     { .name = "946_PRBS4", .cp = 15, .crn = 6, .crm = 4, .opc1 = 0,
3282       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3283       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[4]) },
3284     { .name = "946_PRBS5", .cp = 15, .crn = 6, .crm = 5, .opc1 = 0,
3285       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3286       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[5]) },
3287     { .name = "946_PRBS6", .cp = 15, .crn = 6, .crm = 6, .opc1 = 0,
3288       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3289       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[6]) },
3290     { .name = "946_PRBS7", .cp = 15, .crn = 6, .crm = 7, .opc1 = 0,
3291       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
3292       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[7]) },
3293     REGINFO_SENTINEL
3294 };
3295
3296 static void vmsa_ttbcr_raw_write(CPUARMState *env, const ARMCPRegInfo *ri,
3297                                  uint64_t value)
3298 {
3299     TCR *tcr = raw_ptr(env, ri);
3300     int maskshift = extract32(value, 0, 3);
3301
3302     if (!arm_feature(env, ARM_FEATURE_V8)) {
3303         if (arm_feature(env, ARM_FEATURE_LPAE) && (value & TTBCR_EAE)) {
3304             /* Pre ARMv8 bits [21:19], [15:14] and [6:3] are UNK/SBZP when
3305              * using Long-desciptor translation table format */
3306             value &= ~((7 << 19) | (3 << 14) | (0xf << 3));
3307         } else if (arm_feature(env, ARM_FEATURE_EL3)) {
3308             /* In an implementation that includes the Security Extensions
3309              * TTBCR has additional fields PD0 [4] and PD1 [5] for
3310              * Short-descriptor translation table format.
3311              */
3312             value &= TTBCR_PD1 | TTBCR_PD0 | TTBCR_N;
3313         } else {
3314             value &= TTBCR_N;
3315         }
3316     }
3317
3318     /* Update the masks corresponding to the TCR bank being written
3319      * Note that we always calculate mask and base_mask, but
3320      * they are only used for short-descriptor tables (ie if EAE is 0);
3321      * for long-descriptor tables the TCR fields are used differently
3322      * and the mask and base_mask values are meaningless.
3323      */
3324     tcr->raw_tcr = value;
3325     tcr->mask = ~(((uint32_t)0xffffffffu) >> maskshift);
3326     tcr->base_mask = ~((uint32_t)0x3fffu >> maskshift);
3327 }
3328
3329 static void vmsa_ttbcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3330                              uint64_t value)
3331 {
3332     ARMCPU *cpu = arm_env_get_cpu(env);
3333     TCR *tcr = raw_ptr(env, ri);
3334
3335     if (arm_feature(env, ARM_FEATURE_LPAE)) {
3336         /* With LPAE the TTBCR could result in a change of ASID
3337          * via the TTBCR.A1 bit, so do a TLB flush.
3338          */
3339         tlb_flush(CPU(cpu));
3340     }
3341     /* Preserve the high half of TCR_EL1, set via TTBCR2.  */
3342     value = deposit64(tcr->raw_tcr, 0, 32, value);
3343     vmsa_ttbcr_raw_write(env, ri, value);
3344 }
3345
3346 static void vmsa_ttbcr_reset(CPUARMState *env, const ARMCPRegInfo *ri)
3347 {
3348     TCR *tcr = raw_ptr(env, ri);
3349
3350     /* Reset both the TCR as well as the masks corresponding to the bank of
3351      * the TCR being reset.
3352      */
3353     tcr->raw_tcr = 0;
3354     tcr->mask = 0;
3355     tcr->base_mask = 0xffffc000u;
3356 }
3357
3358 static void vmsa_tcr_el1_write(CPUARMState *env, const ARMCPRegInfo *ri,
3359                                uint64_t value)
3360 {
3361     ARMCPU *cpu = arm_env_get_cpu(env);
3362     TCR *tcr = raw_ptr(env, ri);
3363
3364     /* For AArch64 the A1 bit could result in a change of ASID, so TLB flush. */
3365     tlb_flush(CPU(cpu));
3366     tcr->raw_tcr = value;
3367 }
3368
3369 static void vmsa_ttbr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3370                             uint64_t value)
3371 {
3372     /* If the ASID changes (with a 64-bit write), we must flush the TLB.  */
3373     if (cpreg_field_is_64bit(ri) &&
3374         extract64(raw_read(env, ri) ^ value, 48, 16) != 0) {
3375         ARMCPU *cpu = arm_env_get_cpu(env);
3376         tlb_flush(CPU(cpu));
3377     }
3378     raw_write(env, ri, value);
3379 }
3380
3381 static void vttbr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3382                         uint64_t value)
3383 {
3384     ARMCPU *cpu = arm_env_get_cpu(env);
3385     CPUState *cs = CPU(cpu);
3386
3387     /* Accesses to VTTBR may change the VMID so we must flush the TLB.  */
3388     if (raw_read(env, ri) != value) {
3389         tlb_flush_by_mmuidx(cs,
3390                             ARMMMUIdxBit_S12NSE1 |
3391                             ARMMMUIdxBit_S12NSE0 |
3392                             ARMMMUIdxBit_S2NS);
3393         raw_write(env, ri, value);
3394     }
3395 }
3396
3397 static const ARMCPRegInfo vmsa_pmsa_cp_reginfo[] = {
3398     { .name = "DFSR", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 0,
3399       .access = PL1_RW, .type = ARM_CP_ALIAS,
3400       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.dfsr_s),
3401                              offsetoflow32(CPUARMState, cp15.dfsr_ns) }, },
3402     { .name = "IFSR", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 1,
3403       .access = PL1_RW, .resetvalue = 0,
3404       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.ifsr_s),
3405                              offsetoflow32(CPUARMState, cp15.ifsr_ns) } },
3406     { .name = "DFAR", .cp = 15, .opc1 = 0, .crn = 6, .crm = 0, .opc2 = 0,
3407       .access = PL1_RW, .resetvalue = 0,
3408       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.dfar_s),
3409                              offsetof(CPUARMState, cp15.dfar_ns) } },
3410     { .name = "FAR_EL1", .state = ARM_CP_STATE_AA64,
3411       .opc0 = 3, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 0,
3412       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.far_el[1]),
3413       .resetvalue = 0, },
3414     REGINFO_SENTINEL
3415 };
3416
3417 static const ARMCPRegInfo vmsa_cp_reginfo[] = {
3418     { .name = "ESR_EL1", .state = ARM_CP_STATE_AA64,
3419       .opc0 = 3, .crn = 5, .crm = 2, .opc1 = 0, .opc2 = 0,
3420       .access = PL1_RW,
3421       .fieldoffset = offsetof(CPUARMState, cp15.esr_el[1]), .resetvalue = 0, },
3422     { .name = "TTBR0_EL1", .state = ARM_CP_STATE_BOTH,
3423       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 0, .opc2 = 0,
3424       .access = PL1_RW, .writefn = vmsa_ttbr_write, .resetvalue = 0,
3425       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.ttbr0_s),
3426                              offsetof(CPUARMState, cp15.ttbr0_ns) } },
3427     { .name = "TTBR1_EL1", .state = ARM_CP_STATE_BOTH,
3428       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 0, .opc2 = 1,
3429       .access = PL1_RW, .writefn = vmsa_ttbr_write, .resetvalue = 0,
3430       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.ttbr1_s),
3431                              offsetof(CPUARMState, cp15.ttbr1_ns) } },
3432     { .name = "TCR_EL1", .state = ARM_CP_STATE_AA64,
3433       .opc0 = 3, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 2,
3434       .access = PL1_RW, .writefn = vmsa_tcr_el1_write,
3435       .resetfn = vmsa_ttbcr_reset, .raw_writefn = raw_write,
3436       .fieldoffset = offsetof(CPUARMState, cp15.tcr_el[1]) },
3437     { .name = "TTBCR", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 2,
3438       .access = PL1_RW, .type = ARM_CP_ALIAS, .writefn = vmsa_ttbcr_write,
3439       .raw_writefn = vmsa_ttbcr_raw_write,
3440       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.tcr_el[3]),
3441                              offsetoflow32(CPUARMState, cp15.tcr_el[1])} },
3442     REGINFO_SENTINEL
3443 };
3444
3445 /* Note that unlike TTBCR, writing to TTBCR2 does not require flushing
3446  * qemu tlbs nor adjusting cached masks.
3447  */
3448 static const ARMCPRegInfo ttbcr2_reginfo = {
3449     .name = "TTBCR2", .cp = 15, .opc1 = 0, .crn = 2, .crm = 0, .opc2 = 3,
3450     .access = PL1_RW, .type = ARM_CP_ALIAS,
3451     .bank_fieldoffsets = { offsetofhigh32(CPUARMState, cp15.tcr_el[3]),
3452                            offsetofhigh32(CPUARMState, cp15.tcr_el[1]) },
3453 };
3454
3455 static void omap_ticonfig_write(CPUARMState *env, const ARMCPRegInfo *ri,
3456                                 uint64_t value)
3457 {
3458     env->cp15.c15_ticonfig = value & 0xe7;
3459     /* The OS_TYPE bit in this register changes the reported CPUID! */
3460     env->cp15.c0_cpuid = (value & (1 << 5)) ?
3461         ARM_CPUID_TI915T : ARM_CPUID_TI925T;
3462 }
3463
3464 static void omap_threadid_write(CPUARMState *env, const ARMCPRegInfo *ri,
3465                                 uint64_t value)
3466 {
3467     env->cp15.c15_threadid = value & 0xffff;
3468 }
3469
3470 static void omap_wfi_write(CPUARMState *env, const ARMCPRegInfo *ri,
3471                            uint64_t value)
3472 {
3473     /* Wait-for-interrupt (deprecated) */
3474     cpu_interrupt(CPU(arm_env_get_cpu(env)), CPU_INTERRUPT_HALT);
3475 }
3476
3477 static void omap_cachemaint_write(CPUARMState *env, const ARMCPRegInfo *ri,
3478                                   uint64_t value)
3479 {
3480     /* On OMAP there are registers indicating the max/min index of dcache lines
3481      * containing a dirty line; cache flush operations have to reset these.
3482      */
3483     env->cp15.c15_i_max = 0x000;
3484     env->cp15.c15_i_min = 0xff0;
3485 }
3486
3487 static const ARMCPRegInfo omap_cp_reginfo[] = {
3488     { .name = "DFSR", .cp = 15, .crn = 5, .crm = CP_ANY,
3489       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_OVERRIDE,
3490       .fieldoffset = offsetoflow32(CPUARMState, cp15.esr_el[1]),
3491       .resetvalue = 0, },
3492     { .name = "", .cp = 15, .crn = 15, .crm = 0, .opc1 = 0, .opc2 = 0,
3493       .access = PL1_RW, .type = ARM_CP_NOP },
3494     { .name = "TICONFIG", .cp = 15, .crn = 15, .crm = 1, .opc1 = 0, .opc2 = 0,
3495       .access = PL1_RW,
3496       .fieldoffset = offsetof(CPUARMState, cp15.c15_ticonfig), .resetvalue = 0,
3497       .writefn = omap_ticonfig_write },
3498     { .name = "IMAX", .cp = 15, .crn = 15, .crm = 2, .opc1 = 0, .opc2 = 0,
3499       .access = PL1_RW,
3500       .fieldoffset = offsetof(CPUARMState, cp15.c15_i_max), .resetvalue = 0, },
3501     { .name = "IMIN", .cp = 15, .crn = 15, .crm = 3, .opc1 = 0, .opc2 = 0,
3502       .access = PL1_RW, .resetvalue = 0xff0,
3503       .fieldoffset = offsetof(CPUARMState, cp15.c15_i_min) },
3504     { .name = "THREADID", .cp = 15, .crn = 15, .crm = 4, .opc1 = 0, .opc2 = 0,
3505       .access = PL1_RW,
3506       .fieldoffset = offsetof(CPUARMState, cp15.c15_threadid), .resetvalue = 0,
3507       .writefn = omap_threadid_write },
3508     { .name = "TI925T_STATUS", .cp = 15, .crn = 15,
3509       .crm = 8, .opc1 = 0, .opc2 = 0, .access = PL1_RW,
3510       .type = ARM_CP_NO_RAW,
3511       .readfn = arm_cp_read_zero, .writefn = omap_wfi_write, },
3512     /* TODO: Peripheral port remap register:
3513      * On OMAP2 mcr p15, 0, rn, c15, c2, 4 sets up the interrupt controller
3514      * base address at $rn & ~0xfff and map size of 0x200 << ($rn & 0xfff),
3515      * when MMU is off.
3516      */
3517     { .name = "OMAP_CACHEMAINT", .cp = 15, .crn = 7, .crm = CP_ANY,
3518       .opc1 = 0, .opc2 = CP_ANY, .access = PL1_W,
3519       .type = ARM_CP_OVERRIDE | ARM_CP_NO_RAW,
3520       .writefn = omap_cachemaint_write },
3521     { .name = "C9", .cp = 15, .crn = 9,
3522       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW,
3523       .type = ARM_CP_CONST | ARM_CP_OVERRIDE, .resetvalue = 0 },
3524     REGINFO_SENTINEL
3525 };
3526
3527 static void xscale_cpar_write(CPUARMState *env, const ARMCPRegInfo *ri,
3528                               uint64_t value)
3529 {
3530     env->cp15.c15_cpar = value & 0x3fff;
3531 }
3532
3533 static const ARMCPRegInfo xscale_cp_reginfo[] = {
3534     { .name = "XSCALE_CPAR",
3535       .cp = 15, .crn = 15, .crm = 1, .opc1 = 0, .opc2 = 0, .access = PL1_RW,
3536       .fieldoffset = offsetof(CPUARMState, cp15.c15_cpar), .resetvalue = 0,
3537       .writefn = xscale_cpar_write, },
3538     { .name = "XSCALE_AUXCR",
3539       .cp = 15, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 1, .access = PL1_RW,
3540       .fieldoffset = offsetof(CPUARMState, cp15.c1_xscaleauxcr),
3541       .resetvalue = 0, },
3542     /* XScale specific cache-lockdown: since we have no cache we NOP these
3543      * and hope the guest does not really rely on cache behaviour.
3544      */
3545     { .name = "XSCALE_LOCK_ICACHE_LINE",
3546       .cp = 15, .opc1 = 0, .crn = 9, .crm = 1, .opc2 = 0,
3547       .access = PL1_W, .type = ARM_CP_NOP },
3548     { .name = "XSCALE_UNLOCK_ICACHE",
3549       .cp = 15, .opc1 = 0, .crn = 9, .crm = 1, .opc2 = 1,
3550       .access = PL1_W, .type = ARM_CP_NOP },
3551     { .name = "XSCALE_DCACHE_LOCK",
3552       .cp = 15, .opc1 = 0, .crn = 9, .crm = 2, .opc2 = 0,
3553       .access = PL1_RW, .type = ARM_CP_NOP },
3554     { .name = "XSCALE_UNLOCK_DCACHE",
3555       .cp = 15, .opc1 = 0, .crn = 9, .crm = 2, .opc2 = 1,
3556       .access = PL1_W, .type = ARM_CP_NOP },
3557     REGINFO_SENTINEL
3558 };
3559
3560 static const ARMCPRegInfo dummy_c15_cp_reginfo[] = {
3561     /* RAZ/WI the whole crn=15 space, when we don't have a more specific
3562      * implementation of this implementation-defined space.
3563      * Ideally this should eventually disappear in favour of actually
3564      * implementing the correct behaviour for all cores.
3565      */
3566     { .name = "C15_IMPDEF", .cp = 15, .crn = 15,
3567       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY,
3568       .access = PL1_RW,
3569       .type = ARM_CP_CONST | ARM_CP_NO_RAW | ARM_CP_OVERRIDE,
3570       .resetvalue = 0 },
3571     REGINFO_SENTINEL
3572 };
3573
3574 static const ARMCPRegInfo cache_dirty_status_cp_reginfo[] = {
3575     /* Cache status: RAZ because we have no cache so it's always clean */
3576     { .name = "CDSR", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 6,
3577       .access = PL1_R, .type = ARM_CP_CONST | ARM_CP_NO_RAW,
3578       .resetvalue = 0 },
3579     REGINFO_SENTINEL
3580 };
3581
3582 static const ARMCPRegInfo cache_block_ops_cp_reginfo[] = {
3583     /* We never have a a block transfer operation in progress */
3584     { .name = "BXSR", .cp = 15, .crn = 7, .crm = 12, .opc1 = 0, .opc2 = 4,
3585       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_RAW,
3586       .resetvalue = 0 },
3587     /* The cache ops themselves: these all NOP for QEMU */
3588     { .name = "IICR", .cp = 15, .crm = 5, .opc1 = 0,
3589       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3590     { .name = "IDCR", .cp = 15, .crm = 6, .opc1 = 0,
3591       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3592     { .name = "CDCR", .cp = 15, .crm = 12, .opc1 = 0,
3593       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3594     { .name = "PIR", .cp = 15, .crm = 12, .opc1 = 1,
3595       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3596     { .name = "PDR", .cp = 15, .crm = 12, .opc1 = 2,
3597       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3598     { .name = "CIDCR", .cp = 15, .crm = 14, .opc1 = 0,
3599       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
3600     REGINFO_SENTINEL
3601 };
3602
3603 static const ARMCPRegInfo cache_test_clean_cp_reginfo[] = {
3604     /* The cache test-and-clean instructions always return (1 << 30)
3605      * to indicate that there are no dirty cache lines.
3606      */
3607     { .name = "TC_DCACHE", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 3,
3608       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_RAW,
3609       .resetvalue = (1 << 30) },
3610     { .name = "TCI_DCACHE", .cp = 15, .crn = 7, .crm = 14, .opc1 = 0, .opc2 = 3,
3611       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_RAW,
3612       .resetvalue = (1 << 30) },
3613     REGINFO_SENTINEL
3614 };
3615
3616 static const ARMCPRegInfo strongarm_cp_reginfo[] = {
3617     /* Ignore ReadBuffer accesses */
3618     { .name = "C9_READBUFFER", .cp = 15, .crn = 9,
3619       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY,
3620       .access = PL1_RW, .resetvalue = 0,
3621       .type = ARM_CP_CONST | ARM_CP_OVERRIDE | ARM_CP_NO_RAW },
3622     REGINFO_SENTINEL
3623 };
3624
3625 static uint64_t midr_read(CPUARMState *env, const ARMCPRegInfo *ri)
3626 {
3627     ARMCPU *cpu = arm_env_get_cpu(env);
3628     unsigned int cur_el = arm_current_el(env);
3629     bool secure = arm_is_secure(env);
3630
3631     if (arm_feature(&cpu->env, ARM_FEATURE_EL2) && !secure && cur_el == 1) {
3632         return env->cp15.vpidr_el2;
3633     }
3634     return raw_read(env, ri);
3635 }
3636
3637 static uint64_t mpidr_read_val(CPUARMState *env)
3638 {
3639     ARMCPU *cpu = ARM_CPU(arm_env_get_cpu(env));
3640     uint64_t mpidr = cpu->mp_affinity;
3641
3642     if (arm_feature(env, ARM_FEATURE_V7MP)) {
3643         mpidr |= (1U << 31);
3644         /* Cores which are uniprocessor (non-coherent)
3645          * but still implement the MP extensions set
3646          * bit 30. (For instance, Cortex-R5).
3647          */
3648         if (cpu->mp_is_up) {
3649             mpidr |= (1u << 30);
3650         }
3651     }
3652     return mpidr;
3653 }
3654
3655 static uint64_t mpidr_read(CPUARMState *env, const ARMCPRegInfo *ri)
3656 {
3657     unsigned int cur_el = arm_current_el(env);
3658     bool secure = arm_is_secure(env);
3659
3660     if (arm_feature(env, ARM_FEATURE_EL2) && !secure && cur_el == 1) {
3661         return env->cp15.vmpidr_el2;
3662     }
3663     return mpidr_read_val(env);
3664 }
3665
3666 static const ARMCPRegInfo lpae_cp_reginfo[] = {
3667     /* NOP AMAIR0/1 */
3668     { .name = "AMAIR0", .state = ARM_CP_STATE_BOTH,
3669       .opc0 = 3, .crn = 10, .crm = 3, .opc1 = 0, .opc2 = 0,
3670       .access = PL1_RW, .type = ARM_CP_CONST,
3671       .resetvalue = 0 },
3672     /* AMAIR1 is mapped to AMAIR_EL1[63:32] */
3673     { .name = "AMAIR1", .cp = 15, .crn = 10, .crm = 3, .opc1 = 0, .opc2 = 1,
3674       .access = PL1_RW, .type = ARM_CP_CONST,
3675       .resetvalue = 0 },
3676     { .name = "PAR", .cp = 15, .crm = 7, .opc1 = 0,
3677       .access = PL1_RW, .type = ARM_CP_64BIT, .resetvalue = 0,
3678       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.par_s),
3679                              offsetof(CPUARMState, cp15.par_ns)} },
3680     { .name = "TTBR0", .cp = 15, .crm = 2, .opc1 = 0,
3681       .access = PL1_RW, .type = ARM_CP_64BIT | ARM_CP_ALIAS,
3682       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.ttbr0_s),
3683                              offsetof(CPUARMState, cp15.ttbr0_ns) },
3684       .writefn = vmsa_ttbr_write, },
3685     { .name = "TTBR1", .cp = 15, .crm = 2, .opc1 = 1,
3686       .access = PL1_RW, .type = ARM_CP_64BIT | ARM_CP_ALIAS,
3687       .bank_fieldoffsets = { offsetof(CPUARMState, cp15.ttbr1_s),
3688                              offsetof(CPUARMState, cp15.ttbr1_ns) },
3689       .writefn = vmsa_ttbr_write, },
3690     REGINFO_SENTINEL
3691 };
3692
3693 static uint64_t aa64_fpcr_read(CPUARMState *env, const ARMCPRegInfo *ri)
3694 {
3695     return vfp_get_fpcr(env);
3696 }
3697
3698 static void aa64_fpcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3699                             uint64_t value)
3700 {
3701     vfp_set_fpcr(env, value);
3702 }
3703
3704 static uint64_t aa64_fpsr_read(CPUARMState *env, const ARMCPRegInfo *ri)
3705 {
3706     return vfp_get_fpsr(env);
3707 }
3708
3709 static void aa64_fpsr_write(CPUARMState *env, const ARMCPRegInfo *ri,
3710                             uint64_t value)
3711 {
3712     vfp_set_fpsr(env, value);
3713 }
3714
3715 static CPAccessResult aa64_daif_access(CPUARMState *env, const ARMCPRegInfo *ri,
3716                                        bool isread)
3717 {
3718     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_UMA)) {
3719         return CP_ACCESS_TRAP;
3720     }
3721     return CP_ACCESS_OK;
3722 }
3723
3724 static void aa64_daif_write(CPUARMState *env, const ARMCPRegInfo *ri,
3725                             uint64_t value)
3726 {
3727     env->daif = value & PSTATE_DAIF;
3728 }
3729
3730 static CPAccessResult aa64_cacheop_access(CPUARMState *env,
3731                                           const ARMCPRegInfo *ri,
3732                                           bool isread)
3733 {
3734     /* Cache invalidate/clean: NOP, but EL0 must UNDEF unless
3735      * SCTLR_EL1.UCI is set.
3736      */
3737     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_UCI)) {
3738         return CP_ACCESS_TRAP;
3739     }
3740     return CP_ACCESS_OK;
3741 }
3742
3743 /* See: D4.7.2 TLB maintenance requirements and the TLB maintenance instructions
3744  * Page D4-1736 (DDI0487A.b)
3745  */
3746
3747 static void tlbi_aa64_vmalle1is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3748                                       uint64_t value)
3749 {
3750     CPUState *cs = ENV_GET_CPU(env);
3751     bool sec = arm_is_secure_below_el3(env);
3752
3753     if (sec) {
3754         tlb_flush_by_mmuidx_all_cpus_synced(cs,
3755                                             ARMMMUIdxBit_S1SE1 |
3756                                             ARMMMUIdxBit_S1SE0);
3757     } else {
3758         tlb_flush_by_mmuidx_all_cpus_synced(cs,
3759                                             ARMMMUIdxBit_S12NSE1 |
3760                                             ARMMMUIdxBit_S12NSE0);
3761     }
3762 }
3763
3764 static void tlbi_aa64_vmalle1_write(CPUARMState *env, const ARMCPRegInfo *ri,
3765                                     uint64_t value)
3766 {
3767     CPUState *cs = ENV_GET_CPU(env);
3768
3769     if (tlb_force_broadcast(env)) {
3770         tlbi_aa64_vmalle1is_write(env, NULL, value);
3771         return;
3772     }
3773
3774     if (arm_is_secure_below_el3(env)) {
3775         tlb_flush_by_mmuidx(cs,
3776                             ARMMMUIdxBit_S1SE1 |
3777                             ARMMMUIdxBit_S1SE0);
3778     } else {
3779         tlb_flush_by_mmuidx(cs,
3780                             ARMMMUIdxBit_S12NSE1 |
3781                             ARMMMUIdxBit_S12NSE0);
3782     }
3783 }
3784
3785 static void tlbi_aa64_alle1_write(CPUARMState *env, const ARMCPRegInfo *ri,
3786                                   uint64_t value)
3787 {
3788     /* Note that the 'ALL' scope must invalidate both stage 1 and
3789      * stage 2 translations, whereas most other scopes only invalidate
3790      * stage 1 translations.
3791      */
3792     ARMCPU *cpu = arm_env_get_cpu(env);
3793     CPUState *cs = CPU(cpu);
3794
3795     if (arm_is_secure_below_el3(env)) {
3796         tlb_flush_by_mmuidx(cs,
3797                             ARMMMUIdxBit_S1SE1 |
3798                             ARMMMUIdxBit_S1SE0);
3799     } else {
3800         if (arm_feature(env, ARM_FEATURE_EL2)) {
3801             tlb_flush_by_mmuidx(cs,
3802                                 ARMMMUIdxBit_S12NSE1 |
3803                                 ARMMMUIdxBit_S12NSE0 |
3804                                 ARMMMUIdxBit_S2NS);
3805         } else {
3806             tlb_flush_by_mmuidx(cs,
3807                                 ARMMMUIdxBit_S12NSE1 |
3808                                 ARMMMUIdxBit_S12NSE0);
3809         }
3810     }
3811 }
3812
3813 static void tlbi_aa64_alle2_write(CPUARMState *env, const ARMCPRegInfo *ri,
3814                                   uint64_t value)
3815 {
3816     ARMCPU *cpu = arm_env_get_cpu(env);
3817     CPUState *cs = CPU(cpu);
3818
3819     tlb_flush_by_mmuidx(cs, ARMMMUIdxBit_S1E2);
3820 }
3821
3822 static void tlbi_aa64_alle3_write(CPUARMState *env, const ARMCPRegInfo *ri,
3823                                   uint64_t value)
3824 {
3825     ARMCPU *cpu = arm_env_get_cpu(env);
3826     CPUState *cs = CPU(cpu);
3827
3828     tlb_flush_by_mmuidx(cs, ARMMMUIdxBit_S1E3);
3829 }
3830
3831 static void tlbi_aa64_alle1is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3832                                     uint64_t value)
3833 {
3834     /* Note that the 'ALL' scope must invalidate both stage 1 and
3835      * stage 2 translations, whereas most other scopes only invalidate
3836      * stage 1 translations.
3837      */
3838     CPUState *cs = ENV_GET_CPU(env);
3839     bool sec = arm_is_secure_below_el3(env);
3840     bool has_el2 = arm_feature(env, ARM_FEATURE_EL2);
3841
3842     if (sec) {
3843         tlb_flush_by_mmuidx_all_cpus_synced(cs,
3844                                             ARMMMUIdxBit_S1SE1 |
3845                                             ARMMMUIdxBit_S1SE0);
3846     } else if (has_el2) {
3847         tlb_flush_by_mmuidx_all_cpus_synced(cs,
3848                                             ARMMMUIdxBit_S12NSE1 |
3849                                             ARMMMUIdxBit_S12NSE0 |
3850                                             ARMMMUIdxBit_S2NS);
3851     } else {
3852           tlb_flush_by_mmuidx_all_cpus_synced(cs,
3853                                               ARMMMUIdxBit_S12NSE1 |
3854                                               ARMMMUIdxBit_S12NSE0);
3855     }
3856 }
3857
3858 static void tlbi_aa64_alle2is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3859                                     uint64_t value)
3860 {
3861     CPUState *cs = ENV_GET_CPU(env);
3862
3863     tlb_flush_by_mmuidx_all_cpus_synced(cs, ARMMMUIdxBit_S1E2);
3864 }
3865
3866 static void tlbi_aa64_alle3is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3867                                     uint64_t value)
3868 {
3869     CPUState *cs = ENV_GET_CPU(env);
3870
3871     tlb_flush_by_mmuidx_all_cpus_synced(cs, ARMMMUIdxBit_S1E3);
3872 }
3873
3874 static void tlbi_aa64_vae2_write(CPUARMState *env, const ARMCPRegInfo *ri,
3875                                  uint64_t value)
3876 {
3877     /* Invalidate by VA, EL2
3878      * Currently handles both VAE2 and VALE2, since we don't support
3879      * flush-last-level-only.
3880      */
3881     ARMCPU *cpu = arm_env_get_cpu(env);
3882     CPUState *cs = CPU(cpu);
3883     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3884
3885     tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_S1E2);
3886 }
3887
3888 static void tlbi_aa64_vae3_write(CPUARMState *env, const ARMCPRegInfo *ri,
3889                                  uint64_t value)
3890 {
3891     /* Invalidate by VA, EL3
3892      * Currently handles both VAE3 and VALE3, since we don't support
3893      * flush-last-level-only.
3894      */
3895     ARMCPU *cpu = arm_env_get_cpu(env);
3896     CPUState *cs = CPU(cpu);
3897     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3898
3899     tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_S1E3);
3900 }
3901
3902 static void tlbi_aa64_vae1is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3903                                    uint64_t value)
3904 {
3905     ARMCPU *cpu = arm_env_get_cpu(env);
3906     CPUState *cs = CPU(cpu);
3907     bool sec = arm_is_secure_below_el3(env);
3908     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3909
3910     if (sec) {
3911         tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
3912                                                  ARMMMUIdxBit_S1SE1 |
3913                                                  ARMMMUIdxBit_S1SE0);
3914     } else {
3915         tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
3916                                                  ARMMMUIdxBit_S12NSE1 |
3917                                                  ARMMMUIdxBit_S12NSE0);
3918     }
3919 }
3920
3921 static void tlbi_aa64_vae1_write(CPUARMState *env, const ARMCPRegInfo *ri,
3922                                  uint64_t value)
3923 {
3924     /* Invalidate by VA, EL1&0 (AArch64 version).
3925      * Currently handles all of VAE1, VAAE1, VAALE1 and VALE1,
3926      * since we don't support flush-for-specific-ASID-only or
3927      * flush-last-level-only.
3928      */
3929     ARMCPU *cpu = arm_env_get_cpu(env);
3930     CPUState *cs = CPU(cpu);
3931     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3932
3933     if (tlb_force_broadcast(env)) {
3934         tlbi_aa64_vae1is_write(env, NULL, value);
3935         return;
3936     }
3937
3938     if (arm_is_secure_below_el3(env)) {
3939         tlb_flush_page_by_mmuidx(cs, pageaddr,
3940                                  ARMMMUIdxBit_S1SE1 |
3941                                  ARMMMUIdxBit_S1SE0);
3942     } else {
3943         tlb_flush_page_by_mmuidx(cs, pageaddr,
3944                                  ARMMMUIdxBit_S12NSE1 |
3945                                  ARMMMUIdxBit_S12NSE0);
3946     }
3947 }
3948
3949 static void tlbi_aa64_vae2is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3950                                    uint64_t value)
3951 {
3952     CPUState *cs = ENV_GET_CPU(env);
3953     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3954
3955     tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
3956                                              ARMMMUIdxBit_S1E2);
3957 }
3958
3959 static void tlbi_aa64_vae3is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3960                                    uint64_t value)
3961 {
3962     CPUState *cs = ENV_GET_CPU(env);
3963     uint64_t pageaddr = sextract64(value << 12, 0, 56);
3964
3965     tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
3966                                              ARMMMUIdxBit_S1E3);
3967 }
3968
3969 static void tlbi_aa64_ipas2e1_write(CPUARMState *env, const ARMCPRegInfo *ri,
3970                                     uint64_t value)
3971 {
3972     /* Invalidate by IPA. This has to invalidate any structures that
3973      * contain only stage 2 translation information, but does not need
3974      * to apply to structures that contain combined stage 1 and stage 2
3975      * translation information.
3976      * This must NOP if EL2 isn't implemented or SCR_EL3.NS is zero.
3977      */
3978     ARMCPU *cpu = arm_env_get_cpu(env);
3979     CPUState *cs = CPU(cpu);
3980     uint64_t pageaddr;
3981
3982     if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) {
3983         return;
3984     }
3985
3986     pageaddr = sextract64(value << 12, 0, 48);
3987
3988     tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_S2NS);
3989 }
3990
3991 static void tlbi_aa64_ipas2e1is_write(CPUARMState *env, const ARMCPRegInfo *ri,
3992                                       uint64_t value)
3993 {
3994     CPUState *cs = ENV_GET_CPU(env);
3995     uint64_t pageaddr;
3996
3997     if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) {
3998         return;
3999     }
4000
4001     pageaddr = sextract64(value << 12, 0, 48);
4002
4003     tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr,
4004                                              ARMMMUIdxBit_S2NS);
4005 }
4006
4007 static CPAccessResult aa64_zva_access(CPUARMState *env, const ARMCPRegInfo *ri,
4008                                       bool isread)
4009 {
4010     /* We don't implement EL2, so the only control on DC ZVA is the
4011      * bit in the SCTLR which can prohibit access for EL0.
4012      */
4013     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_DZE)) {
4014         return CP_ACCESS_TRAP;
4015     }
4016     return CP_ACCESS_OK;
4017 }
4018
4019 static uint64_t aa64_dczid_read(CPUARMState *env, const ARMCPRegInfo *ri)
4020 {
4021     ARMCPU *cpu = arm_env_get_cpu(env);
4022     int dzp_bit = 1 << 4;
4023
4024     /* DZP indicates whether DC ZVA access is allowed */
4025     if (aa64_zva_access(env, NULL, false) == CP_ACCESS_OK) {
4026         dzp_bit = 0;
4027     }
4028     return cpu->dcz_blocksize | dzp_bit;
4029 }
4030
4031 static CPAccessResult sp_el0_access(CPUARMState *env, const ARMCPRegInfo *ri,
4032                                     bool isread)
4033 {
4034     if (!(env->pstate & PSTATE_SP)) {
4035         /* Access to SP_EL0 is undefined if it's being used as
4036          * the stack pointer.
4037          */
4038         return CP_ACCESS_TRAP_UNCATEGORIZED;
4039     }
4040     return CP_ACCESS_OK;
4041 }
4042
4043 static uint64_t spsel_read(CPUARMState *env, const ARMCPRegInfo *ri)
4044 {
4045     return env->pstate & PSTATE_SP;
4046 }
4047
4048 static void spsel_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t val)
4049 {
4050     update_spsel(env, val);
4051 }
4052
4053 static void sctlr_write(CPUARMState *env, const ARMCPRegInfo *ri,
4054                         uint64_t value)
4055 {
4056     ARMCPU *cpu = arm_env_get_cpu(env);
4057
4058     if (raw_read(env, ri) == value) {
4059         /* Skip the TLB flush if nothing actually changed; Linux likes
4060          * to do a lot of pointless SCTLR writes.
4061          */
4062         return;
4063     }
4064
4065     if (arm_feature(env, ARM_FEATURE_PMSA) && !cpu->has_mpu) {
4066         /* M bit is RAZ/WI for PMSA with no MPU implemented */
4067         value &= ~SCTLR_M;
4068     }
4069
4070     raw_write(env, ri, value);
4071     /* ??? Lots of these bits are not implemented.  */
4072     /* This may enable/disable the MMU, so do a TLB flush.  */
4073     tlb_flush(CPU(cpu));
4074 }
4075
4076 static CPAccessResult fpexc32_access(CPUARMState *env, const ARMCPRegInfo *ri,
4077                                      bool isread)
4078 {
4079     if ((env->cp15.cptr_el[2] & CPTR_TFP) && arm_current_el(env) == 2) {
4080         return CP_ACCESS_TRAP_FP_EL2;
4081     }
4082     if (env->cp15.cptr_el[3] & CPTR_TFP) {
4083         return CP_ACCESS_TRAP_FP_EL3;
4084     }
4085     return CP_ACCESS_OK;
4086 }
4087
4088 static void sdcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
4089                        uint64_t value)
4090 {
4091     env->cp15.mdcr_el3 = value & SDCR_VALID_MASK;
4092 }
4093
4094 static const ARMCPRegInfo v8_cp_reginfo[] = {
4095     /* Minimal set of EL0-visible registers. This will need to be expanded
4096      * significantly for system emulation of AArch64 CPUs.
4097      */
4098     { .name = "NZCV", .state = ARM_CP_STATE_AA64,
4099       .opc0 = 3, .opc1 = 3, .opc2 = 0, .crn = 4, .crm = 2,
4100       .access = PL0_RW, .type = ARM_CP_NZCV },
4101     { .name = "DAIF", .state = ARM_CP_STATE_AA64,
4102       .opc0 = 3, .opc1 = 3, .opc2 = 1, .crn = 4, .crm = 2,
4103       .type = ARM_CP_NO_RAW,
4104       .access = PL0_RW, .accessfn = aa64_daif_access,
4105       .fieldoffset = offsetof(CPUARMState, daif),
4106       .writefn = aa64_daif_write, .resetfn = arm_cp_reset_ignore },
4107     { .name = "FPCR", .state = ARM_CP_STATE_AA64,
4108       .opc0 = 3, .opc1 = 3, .opc2 = 0, .crn = 4, .crm = 4,
4109       .access = PL0_RW, .type = ARM_CP_FPU | ARM_CP_SUPPRESS_TB_END,
4110       .readfn = aa64_fpcr_read, .writefn = aa64_fpcr_write },
4111     { .name = "FPSR", .state = ARM_CP_STATE_AA64,
4112       .opc0 = 3, .opc1 = 3, .opc2 = 1, .crn = 4, .crm = 4,
4113       .access = PL0_RW, .type = ARM_CP_FPU | ARM_CP_SUPPRESS_TB_END,
4114       .readfn = aa64_fpsr_read, .writefn = aa64_fpsr_write },
4115     { .name = "DCZID_EL0", .state = ARM_CP_STATE_AA64,
4116       .opc0 = 3, .opc1 = 3, .opc2 = 7, .crn = 0, .crm = 0,
4117       .access = PL0_R, .type = ARM_CP_NO_RAW,
4118       .readfn = aa64_dczid_read },
4119     { .name = "DC_ZVA", .state = ARM_CP_STATE_AA64,
4120       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 4, .opc2 = 1,
4121       .access = PL0_W, .type = ARM_CP_DC_ZVA,
4122 #ifndef CONFIG_USER_ONLY
4123       /* Avoid overhead of an access check that always passes in user-mode */
4124       .accessfn = aa64_zva_access,
4125 #endif
4126     },
4127     { .name = "CURRENTEL", .state = ARM_CP_STATE_AA64,
4128       .opc0 = 3, .opc1 = 0, .opc2 = 2, .crn = 4, .crm = 2,
4129       .access = PL1_R, .type = ARM_CP_CURRENTEL },
4130     /* Cache ops: all NOPs since we don't emulate caches */
4131     { .name = "IC_IALLUIS", .state = ARM_CP_STATE_AA64,
4132       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 1, .opc2 = 0,
4133       .access = PL1_W, .type = ARM_CP_NOP },
4134     { .name = "IC_IALLU", .state = ARM_CP_STATE_AA64,
4135       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 5, .opc2 = 0,
4136       .access = PL1_W, .type = ARM_CP_NOP },
4137     { .name = "IC_IVAU", .state = ARM_CP_STATE_AA64,
4138       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 5, .opc2 = 1,
4139       .access = PL0_W, .type = ARM_CP_NOP,
4140       .accessfn = aa64_cacheop_access },
4141     { .name = "DC_IVAC", .state = ARM_CP_STATE_AA64,
4142       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 6, .opc2 = 1,
4143       .access = PL1_W, .type = ARM_CP_NOP },
4144     { .name = "DC_ISW", .state = ARM_CP_STATE_AA64,
4145       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 6, .opc2 = 2,
4146       .access = PL1_W, .type = ARM_CP_NOP },
4147     { .name = "DC_CVAC", .state = ARM_CP_STATE_AA64,
4148       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 10, .opc2 = 1,
4149       .access = PL0_W, .type = ARM_CP_NOP,
4150       .accessfn = aa64_cacheop_access },
4151     { .name = "DC_CSW", .state = ARM_CP_STATE_AA64,
4152       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 10, .opc2 = 2,
4153       .access = PL1_W, .type = ARM_CP_NOP },
4154     { .name = "DC_CVAU", .state = ARM_CP_STATE_AA64,
4155       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 11, .opc2 = 1,
4156       .access = PL0_W, .type = ARM_CP_NOP,
4157       .accessfn = aa64_cacheop_access },
4158     { .name = "DC_CIVAC", .state = ARM_CP_STATE_AA64,
4159       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 14, .opc2 = 1,
4160       .access = PL0_W, .type = ARM_CP_NOP,
4161       .accessfn = aa64_cacheop_access },
4162     { .name = "DC_CISW", .state = ARM_CP_STATE_AA64,
4163       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 14, .opc2 = 2,
4164       .access = PL1_W, .type = ARM_CP_NOP },
4165     /* TLBI operations */
4166     { .name = "TLBI_VMALLE1IS", .state = ARM_CP_STATE_AA64,
4167       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 0,
4168       .access = PL1_W, .type = ARM_CP_NO_RAW,
4169       .writefn = tlbi_aa64_vmalle1is_write },
4170     { .name = "TLBI_VAE1IS", .state = ARM_CP_STATE_AA64,
4171       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 1,
4172       .access = PL1_W, .type = ARM_CP_NO_RAW,
4173       .writefn = tlbi_aa64_vae1is_write },
4174     { .name = "TLBI_ASIDE1IS", .state = ARM_CP_STATE_AA64,
4175       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 2,
4176       .access = PL1_W, .type = ARM_CP_NO_RAW,
4177       .writefn = tlbi_aa64_vmalle1is_write },
4178     { .name = "TLBI_VAAE1IS", .state = ARM_CP_STATE_AA64,
4179       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 3,
4180       .access = PL1_W, .type = ARM_CP_NO_RAW,
4181       .writefn = tlbi_aa64_vae1is_write },
4182     { .name = "TLBI_VALE1IS", .state = ARM_CP_STATE_AA64,
4183       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 5,
4184       .access = PL1_W, .type = ARM_CP_NO_RAW,
4185       .writefn = tlbi_aa64_vae1is_write },
4186     { .name = "TLBI_VAALE1IS", .state = ARM_CP_STATE_AA64,
4187       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 7,
4188       .access = PL1_W, .type = ARM_CP_NO_RAW,
4189       .writefn = tlbi_aa64_vae1is_write },
4190     { .name = "TLBI_VMALLE1", .state = ARM_CP_STATE_AA64,
4191       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 0,
4192       .access = PL1_W, .type = ARM_CP_NO_RAW,
4193       .writefn = tlbi_aa64_vmalle1_write },
4194     { .name = "TLBI_VAE1", .state = ARM_CP_STATE_AA64,
4195       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 1,
4196       .access = PL1_W, .type = ARM_CP_NO_RAW,
4197       .writefn = tlbi_aa64_vae1_write },
4198     { .name = "TLBI_ASIDE1", .state = ARM_CP_STATE_AA64,
4199       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 2,
4200       .access = PL1_W, .type = ARM_CP_NO_RAW,
4201       .writefn = tlbi_aa64_vmalle1_write },
4202     { .name = "TLBI_VAAE1", .state = ARM_CP_STATE_AA64,
4203       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 3,
4204       .access = PL1_W, .type = ARM_CP_NO_RAW,
4205       .writefn = tlbi_aa64_vae1_write },
4206     { .name = "TLBI_VALE1", .state = ARM_CP_STATE_AA64,
4207       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 5,
4208       .access = PL1_W, .type = ARM_CP_NO_RAW,
4209       .writefn = tlbi_aa64_vae1_write },
4210     { .name = "TLBI_VAALE1", .state = ARM_CP_STATE_AA64,
4211       .opc0 = 1, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 7,
4212       .access = PL1_W, .type = ARM_CP_NO_RAW,
4213       .writefn = tlbi_aa64_vae1_write },
4214     { .name = "TLBI_IPAS2E1IS", .state = ARM_CP_STATE_AA64,
4215       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 1,
4216       .access = PL2_W, .type = ARM_CP_NO_RAW,
4217       .writefn = tlbi_aa64_ipas2e1is_write },
4218     { .name = "TLBI_IPAS2LE1IS", .state = ARM_CP_STATE_AA64,
4219       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 5,
4220       .access = PL2_W, .type = ARM_CP_NO_RAW,
4221       .writefn = tlbi_aa64_ipas2e1is_write },
4222     { .name = "TLBI_ALLE1IS", .state = ARM_CP_STATE_AA64,
4223       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 4,
4224       .access = PL2_W, .type = ARM_CP_NO_RAW,
4225       .writefn = tlbi_aa64_alle1is_write },
4226     { .name = "TLBI_VMALLS12E1IS", .state = ARM_CP_STATE_AA64,
4227       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 6,
4228       .access = PL2_W, .type = ARM_CP_NO_RAW,
4229       .writefn = tlbi_aa64_alle1is_write },
4230     { .name = "TLBI_IPAS2E1", .state = ARM_CP_STATE_AA64,
4231       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 1,
4232       .access = PL2_W, .type = ARM_CP_NO_RAW,
4233       .writefn = tlbi_aa64_ipas2e1_write },
4234     { .name = "TLBI_IPAS2LE1", .state = ARM_CP_STATE_AA64,
4235       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 5,
4236       .access = PL2_W, .type = ARM_CP_NO_RAW,
4237       .writefn = tlbi_aa64_ipas2e1_write },
4238     { .name = "TLBI_ALLE1", .state = ARM_CP_STATE_AA64,
4239       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 4,
4240       .access = PL2_W, .type = ARM_CP_NO_RAW,
4241       .writefn = tlbi_aa64_alle1_write },
4242     { .name = "TLBI_VMALLS12E1", .state = ARM_CP_STATE_AA64,
4243       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 6,
4244       .access = PL2_W, .type = ARM_CP_NO_RAW,
4245       .writefn = tlbi_aa64_alle1is_write },
4246 #ifndef CONFIG_USER_ONLY
4247     /* 64 bit address translation operations */
4248     { .name = "AT_S1E1R", .state = ARM_CP_STATE_AA64,
4249       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 8, .opc2 = 0,
4250       .access = PL1_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4251     { .name = "AT_S1E1W", .state = ARM_CP_STATE_AA64,
4252       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 8, .opc2 = 1,
4253       .access = PL1_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4254     { .name = "AT_S1E0R", .state = ARM_CP_STATE_AA64,
4255       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 8, .opc2 = 2,
4256       .access = PL1_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4257     { .name = "AT_S1E0W", .state = ARM_CP_STATE_AA64,
4258       .opc0 = 1, .opc1 = 0, .crn = 7, .crm = 8, .opc2 = 3,
4259       .access = PL1_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4260     { .name = "AT_S12E1R", .state = ARM_CP_STATE_AA64,
4261       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 4,
4262       .access = PL2_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4263     { .name = "AT_S12E1W", .state = ARM_CP_STATE_AA64,
4264       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 5,
4265       .access = PL2_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4266     { .name = "AT_S12E0R", .state = ARM_CP_STATE_AA64,
4267       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 6,
4268       .access = PL2_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4269     { .name = "AT_S12E0W", .state = ARM_CP_STATE_AA64,
4270       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 7,
4271       .access = PL2_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4272     /* AT S1E2* are elsewhere as they UNDEF from EL3 if EL2 is not present */
4273     { .name = "AT_S1E3R", .state = ARM_CP_STATE_AA64,
4274       .opc0 = 1, .opc1 = 6, .crn = 7, .crm = 8, .opc2 = 0,
4275       .access = PL3_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4276     { .name = "AT_S1E3W", .state = ARM_CP_STATE_AA64,
4277       .opc0 = 1, .opc1 = 6, .crn = 7, .crm = 8, .opc2 = 1,
4278       .access = PL3_W, .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4279     { .name = "PAR_EL1", .state = ARM_CP_STATE_AA64,
4280       .type = ARM_CP_ALIAS,
4281       .opc0 = 3, .opc1 = 0, .crn = 7, .crm = 4, .opc2 = 0,
4282       .access = PL1_RW, .resetvalue = 0,
4283       .fieldoffset = offsetof(CPUARMState, cp15.par_el[1]),
4284       .writefn = par_write },
4285 #endif
4286     /* TLB invalidate last level of translation table walk */
4287     { .name = "TLBIMVALIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 5,
4288       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_is_write },
4289     { .name = "TLBIMVAALIS", .cp = 15, .opc1 = 0, .crn = 8, .crm = 3, .opc2 = 7,
4290       .type = ARM_CP_NO_RAW, .access = PL1_W,
4291       .writefn = tlbimvaa_is_write },
4292     { .name = "TLBIMVAL", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 5,
4293       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimva_write },
4294     { .name = "TLBIMVAAL", .cp = 15, .opc1 = 0, .crn = 8, .crm = 7, .opc2 = 7,
4295       .type = ARM_CP_NO_RAW, .access = PL1_W, .writefn = tlbimvaa_write },
4296     { .name = "TLBIMVALH", .cp = 15, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 5,
4297       .type = ARM_CP_NO_RAW, .access = PL2_W,
4298       .writefn = tlbimva_hyp_write },
4299     { .name = "TLBIMVALHIS",
4300       .cp = 15, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 5,
4301       .type = ARM_CP_NO_RAW, .access = PL2_W,
4302       .writefn = tlbimva_hyp_is_write },
4303     { .name = "TLBIIPAS2",
4304       .cp = 15, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 1,
4305       .type = ARM_CP_NO_RAW, .access = PL2_W,
4306       .writefn = tlbiipas2_write },
4307     { .name = "TLBIIPAS2IS",
4308       .cp = 15, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 1,
4309       .type = ARM_CP_NO_RAW, .access = PL2_W,
4310       .writefn = tlbiipas2_is_write },
4311     { .name = "TLBIIPAS2L",
4312       .cp = 15, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 5,
4313       .type = ARM_CP_NO_RAW, .access = PL2_W,
4314       .writefn = tlbiipas2_write },
4315     { .name = "TLBIIPAS2LIS",
4316       .cp = 15, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 5,
4317       .type = ARM_CP_NO_RAW, .access = PL2_W,
4318       .writefn = tlbiipas2_is_write },
4319     /* 32 bit cache operations */
4320     { .name = "ICIALLUIS", .cp = 15, .opc1 = 0, .crn = 7, .crm = 1, .opc2 = 0,
4321       .type = ARM_CP_NOP, .access = PL1_W },
4322     { .name = "BPIALLUIS", .cp = 15, .opc1 = 0, .crn = 7, .crm = 1, .opc2 = 6,
4323       .type = ARM_CP_NOP, .access = PL1_W },
4324     { .name = "ICIALLU", .cp = 15, .opc1 = 0, .crn = 7, .crm = 5, .opc2 = 0,
4325       .type = ARM_CP_NOP, .access = PL1_W },
4326     { .name = "ICIMVAU", .cp = 15, .opc1 = 0, .crn = 7, .crm = 5, .opc2 = 1,
4327       .type = ARM_CP_NOP, .access = PL1_W },
4328     { .name = "BPIALL", .cp = 15, .opc1 = 0, .crn = 7, .crm = 5, .opc2 = 6,
4329       .type = ARM_CP_NOP, .access = PL1_W },
4330     { .name = "BPIMVA", .cp = 15, .opc1 = 0, .crn = 7, .crm = 5, .opc2 = 7,
4331       .type = ARM_CP_NOP, .access = PL1_W },
4332     { .name = "DCIMVAC", .cp = 15, .opc1 = 0, .crn = 7, .crm = 6, .opc2 = 1,
4333       .type = ARM_CP_NOP, .access = PL1_W },
4334     { .name = "DCISW", .cp = 15, .opc1 = 0, .crn = 7, .crm = 6, .opc2 = 2,
4335       .type = ARM_CP_NOP, .access = PL1_W },
4336     { .name = "DCCMVAC", .cp = 15, .opc1 = 0, .crn = 7, .crm = 10, .opc2 = 1,
4337       .type = ARM_CP_NOP, .access = PL1_W },
4338     { .name = "DCCSW", .cp = 15, .opc1 = 0, .crn = 7, .crm = 10, .opc2 = 2,
4339       .type = ARM_CP_NOP, .access = PL1_W },
4340     { .name = "DCCMVAU", .cp = 15, .opc1 = 0, .crn = 7, .crm = 11, .opc2 = 1,
4341       .type = ARM_CP_NOP, .access = PL1_W },
4342     { .name = "DCCIMVAC", .cp = 15, .opc1 = 0, .crn = 7, .crm = 14, .opc2 = 1,
4343       .type = ARM_CP_NOP, .access = PL1_W },
4344     { .name = "DCCISW", .cp = 15, .opc1 = 0, .crn = 7, .crm = 14, .opc2 = 2,
4345       .type = ARM_CP_NOP, .access = PL1_W },
4346     /* MMU Domain access control / MPU write buffer control */
4347     { .name = "DACR", .cp = 15, .opc1 = 0, .crn = 3, .crm = 0, .opc2 = 0,
4348       .access = PL1_RW, .resetvalue = 0,
4349       .writefn = dacr_write, .raw_writefn = raw_write,
4350       .bank_fieldoffsets = { offsetoflow32(CPUARMState, cp15.dacr_s),
4351                              offsetoflow32(CPUARMState, cp15.dacr_ns) } },
4352     { .name = "ELR_EL1", .state = ARM_CP_STATE_AA64,
4353       .type = ARM_CP_ALIAS,
4354       .opc0 = 3, .opc1 = 0, .crn = 4, .crm = 0, .opc2 = 1,
4355       .access = PL1_RW,
4356       .fieldoffset = offsetof(CPUARMState, elr_el[1]) },
4357     { .name = "SPSR_EL1", .state = ARM_CP_STATE_AA64,
4358       .type = ARM_CP_ALIAS,
4359       .opc0 = 3, .opc1 = 0, .crn = 4, .crm = 0, .opc2 = 0,
4360       .access = PL1_RW,
4361       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_SVC]) },
4362     /* We rely on the access checks not allowing the guest to write to the
4363      * state field when SPSel indicates that it's being used as the stack
4364      * pointer.
4365      */
4366     { .name = "SP_EL0", .state = ARM_CP_STATE_AA64,
4367       .opc0 = 3, .opc1 = 0, .crn = 4, .crm = 1, .opc2 = 0,
4368       .access = PL1_RW, .accessfn = sp_el0_access,
4369       .type = ARM_CP_ALIAS,
4370       .fieldoffset = offsetof(CPUARMState, sp_el[0]) },
4371     { .name = "SP_EL1", .state = ARM_CP_STATE_AA64,
4372       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 1, .opc2 = 0,
4373       .access = PL2_RW, .type = ARM_CP_ALIAS,
4374       .fieldoffset = offsetof(CPUARMState, sp_el[1]) },
4375     { .name = "SPSel", .state = ARM_CP_STATE_AA64,
4376       .opc0 = 3, .opc1 = 0, .crn = 4, .crm = 2, .opc2 = 0,
4377       .type = ARM_CP_NO_RAW,
4378       .access = PL1_RW, .readfn = spsel_read, .writefn = spsel_write },
4379     { .name = "FPEXC32_EL2", .state = ARM_CP_STATE_AA64,
4380       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 3, .opc2 = 0,
4381       .type = ARM_CP_ALIAS,
4382       .fieldoffset = offsetof(CPUARMState, vfp.xregs[ARM_VFP_FPEXC]),
4383       .access = PL2_RW, .accessfn = fpexc32_access },
4384     { .name = "DACR32_EL2", .state = ARM_CP_STATE_AA64,
4385       .opc0 = 3, .opc1 = 4, .crn = 3, .crm = 0, .opc2 = 0,
4386       .access = PL2_RW, .resetvalue = 0,
4387       .writefn = dacr_write, .raw_writefn = raw_write,
4388       .fieldoffset = offsetof(CPUARMState, cp15.dacr32_el2) },
4389     { .name = "IFSR32_EL2", .state = ARM_CP_STATE_AA64,
4390       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 0, .opc2 = 1,
4391       .access = PL2_RW, .resetvalue = 0,
4392       .fieldoffset = offsetof(CPUARMState, cp15.ifsr32_el2) },
4393     { .name = "SPSR_IRQ", .state = ARM_CP_STATE_AA64,
4394       .type = ARM_CP_ALIAS,
4395       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 3, .opc2 = 0,
4396       .access = PL2_RW,
4397       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_IRQ]) },
4398     { .name = "SPSR_ABT", .state = ARM_CP_STATE_AA64,
4399       .type = ARM_CP_ALIAS,
4400       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 3, .opc2 = 1,
4401       .access = PL2_RW,
4402       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_ABT]) },
4403     { .name = "SPSR_UND", .state = ARM_CP_STATE_AA64,
4404       .type = ARM_CP_ALIAS,
4405       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 3, .opc2 = 2,
4406       .access = PL2_RW,
4407       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_UND]) },
4408     { .name = "SPSR_FIQ", .state = ARM_CP_STATE_AA64,
4409       .type = ARM_CP_ALIAS,
4410       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 3, .opc2 = 3,
4411       .access = PL2_RW,
4412       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_FIQ]) },
4413     { .name = "MDCR_EL3", .state = ARM_CP_STATE_AA64,
4414       .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 3, .opc2 = 1,
4415       .resetvalue = 0,
4416       .access = PL3_RW, .fieldoffset = offsetof(CPUARMState, cp15.mdcr_el3) },
4417     { .name = "SDCR", .type = ARM_CP_ALIAS,
4418       .cp = 15, .opc1 = 0, .crn = 1, .crm = 3, .opc2 = 1,
4419       .access = PL1_RW, .accessfn = access_trap_aa32s_el1,
4420       .writefn = sdcr_write,
4421       .fieldoffset = offsetoflow32(CPUARMState, cp15.mdcr_el3) },
4422     REGINFO_SENTINEL
4423 };
4424
4425 /* Used to describe the behaviour of EL2 regs when EL2 does not exist.  */
4426 static const ARMCPRegInfo el3_no_el2_cp_reginfo[] = {
4427     { .name = "VBAR_EL2", .state = ARM_CP_STATE_BOTH,
4428       .opc0 = 3, .opc1 = 4, .crn = 12, .crm = 0, .opc2 = 0,
4429       .access = PL2_RW,
4430       .readfn = arm_cp_read_zero, .writefn = arm_cp_write_ignore },
4431     { .name = "HCR_EL2", .state = ARM_CP_STATE_BOTH,
4432       .type = ARM_CP_NO_RAW,
4433       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 0,
4434       .access = PL2_RW,
4435       .type = ARM_CP_CONST, .resetvalue = 0 },
4436     { .name = "HACR_EL2", .state = ARM_CP_STATE_BOTH,
4437       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 7,
4438       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4439     { .name = "ESR_EL2", .state = ARM_CP_STATE_BOTH,
4440       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 2, .opc2 = 0,
4441       .access = PL2_RW,
4442       .type = ARM_CP_CONST, .resetvalue = 0 },
4443     { .name = "CPTR_EL2", .state = ARM_CP_STATE_BOTH,
4444       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 2,
4445       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4446     { .name = "MAIR_EL2", .state = ARM_CP_STATE_BOTH,
4447       .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 0,
4448       .access = PL2_RW, .type = ARM_CP_CONST,
4449       .resetvalue = 0 },
4450     { .name = "HMAIR1", .state = ARM_CP_STATE_AA32,
4451       .cp = 15, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 1,
4452       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4453     { .name = "AMAIR_EL2", .state = ARM_CP_STATE_BOTH,
4454       .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 0,
4455       .access = PL2_RW, .type = ARM_CP_CONST,
4456       .resetvalue = 0 },
4457     { .name = "HAMAIR1", .state = ARM_CP_STATE_AA32,
4458       .cp = 15, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 1,
4459       .access = PL2_RW, .type = ARM_CP_CONST,
4460       .resetvalue = 0 },
4461     { .name = "AFSR0_EL2", .state = ARM_CP_STATE_BOTH,
4462       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 0,
4463       .access = PL2_RW, .type = ARM_CP_CONST,
4464       .resetvalue = 0 },
4465     { .name = "AFSR1_EL2", .state = ARM_CP_STATE_BOTH,
4466       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 1,
4467       .access = PL2_RW, .type = ARM_CP_CONST,
4468       .resetvalue = 0 },
4469     { .name = "TCR_EL2", .state = ARM_CP_STATE_BOTH,
4470       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 2,
4471       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4472     { .name = "VTCR_EL2", .state = ARM_CP_STATE_BOTH,
4473       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 2,
4474       .access = PL2_RW, .accessfn = access_el3_aa32ns_aa64any,
4475       .type = ARM_CP_CONST, .resetvalue = 0 },
4476     { .name = "VTTBR", .state = ARM_CP_STATE_AA32,
4477       .cp = 15, .opc1 = 6, .crm = 2,
4478       .access = PL2_RW, .accessfn = access_el3_aa32ns,
4479       .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 },
4480     { .name = "VTTBR_EL2", .state = ARM_CP_STATE_AA64,
4481       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 0,
4482       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4483     { .name = "SCTLR_EL2", .state = ARM_CP_STATE_BOTH,
4484       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 0, .opc2 = 0,
4485       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4486     { .name = "TPIDR_EL2", .state = ARM_CP_STATE_BOTH,
4487       .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 2,
4488       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4489     { .name = "TTBR0_EL2", .state = ARM_CP_STATE_AA64,
4490       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 0,
4491       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4492     { .name = "HTTBR", .cp = 15, .opc1 = 4, .crm = 2,
4493       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST,
4494       .resetvalue = 0 },
4495     { .name = "CNTHCTL_EL2", .state = ARM_CP_STATE_BOTH,
4496       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 1, .opc2 = 0,
4497       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4498     { .name = "CNTVOFF_EL2", .state = ARM_CP_STATE_AA64,
4499       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 0, .opc2 = 3,
4500       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4501     { .name = "CNTVOFF", .cp = 15, .opc1 = 4, .crm = 14,
4502       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST,
4503       .resetvalue = 0 },
4504     { .name = "CNTHP_CVAL_EL2", .state = ARM_CP_STATE_AA64,
4505       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 2,
4506       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4507     { .name = "CNTHP_CVAL", .cp = 15, .opc1 = 6, .crm = 14,
4508       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST,
4509       .resetvalue = 0 },
4510     { .name = "CNTHP_TVAL_EL2", .state = ARM_CP_STATE_BOTH,
4511       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 0,
4512       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4513     { .name = "CNTHP_CTL_EL2", .state = ARM_CP_STATE_BOTH,
4514       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 1,
4515       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4516     { .name = "MDCR_EL2", .state = ARM_CP_STATE_BOTH,
4517       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 1,
4518       .access = PL2_RW, .accessfn = access_tda,
4519       .type = ARM_CP_CONST, .resetvalue = 0 },
4520     { .name = "HPFAR_EL2", .state = ARM_CP_STATE_BOTH,
4521       .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 4,
4522       .access = PL2_RW, .accessfn = access_el3_aa32ns_aa64any,
4523       .type = ARM_CP_CONST, .resetvalue = 0 },
4524     { .name = "HSTR_EL2", .state = ARM_CP_STATE_BOTH,
4525       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 3,
4526       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4527     { .name = "FAR_EL2", .state = ARM_CP_STATE_BOTH,
4528       .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 0,
4529       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4530     { .name = "HIFAR", .state = ARM_CP_STATE_AA32,
4531       .type = ARM_CP_CONST,
4532       .cp = 15, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 2,
4533       .access = PL2_RW, .resetvalue = 0 },
4534     REGINFO_SENTINEL
4535 };
4536
4537 /* Ditto, but for registers which exist in ARMv8 but not v7 */
4538 static const ARMCPRegInfo el3_no_el2_v8_cp_reginfo[] = {
4539     { .name = "HCR2", .state = ARM_CP_STATE_AA32,
4540       .cp = 15, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 4,
4541       .access = PL2_RW,
4542       .type = ARM_CP_CONST, .resetvalue = 0 },
4543     REGINFO_SENTINEL
4544 };
4545
4546 static void hcr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
4547 {
4548     ARMCPU *cpu = arm_env_get_cpu(env);
4549     uint64_t valid_mask = HCR_MASK;
4550
4551     if (arm_feature(env, ARM_FEATURE_EL3)) {
4552         valid_mask &= ~HCR_HCD;
4553     } else if (cpu->psci_conduit != QEMU_PSCI_CONDUIT_SMC) {
4554         /* Architecturally HCR.TSC is RES0 if EL3 is not implemented.
4555          * However, if we're using the SMC PSCI conduit then QEMU is
4556          * effectively acting like EL3 firmware and so the guest at
4557          * EL2 should retain the ability to prevent EL1 from being
4558          * able to make SMC calls into the ersatz firmware, so in
4559          * that case HCR.TSC should be read/write.
4560          */
4561         valid_mask &= ~HCR_TSC;
4562     }
4563     if (cpu_isar_feature(aa64_lor, cpu)) {
4564         valid_mask |= HCR_TLOR;
4565     }
4566     if (cpu_isar_feature(aa64_pauth, cpu)) {
4567         valid_mask |= HCR_API | HCR_APK;
4568     }
4569
4570     /* Clear RES0 bits.  */
4571     value &= valid_mask;
4572
4573     /* These bits change the MMU setup:
4574      * HCR_VM enables stage 2 translation
4575      * HCR_PTW forbids certain page-table setups
4576      * HCR_DC Disables stage1 and enables stage2 translation
4577      */
4578     if ((env->cp15.hcr_el2 ^ value) & (HCR_VM | HCR_PTW | HCR_DC)) {
4579         tlb_flush(CPU(cpu));
4580     }
4581     env->cp15.hcr_el2 = value;
4582
4583     /*
4584      * Updates to VI and VF require us to update the status of
4585      * virtual interrupts, which are the logical OR of these bits
4586      * and the state of the input lines from the GIC. (This requires
4587      * that we have the iothread lock, which is done by marking the
4588      * reginfo structs as ARM_CP_IO.)
4589      * Note that if a write to HCR pends a VIRQ or VFIQ it is never
4590      * possible for it to be taken immediately, because VIRQ and
4591      * VFIQ are masked unless running at EL0 or EL1, and HCR
4592      * can only be written at EL2.
4593      */
4594     g_assert(qemu_mutex_iothread_locked());
4595     arm_cpu_update_virq(cpu);
4596     arm_cpu_update_vfiq(cpu);
4597 }
4598
4599 static void hcr_writehigh(CPUARMState *env, const ARMCPRegInfo *ri,
4600                           uint64_t value)
4601 {
4602     /* Handle HCR2 write, i.e. write to high half of HCR_EL2 */
4603     value = deposit64(env->cp15.hcr_el2, 32, 32, value);
4604     hcr_write(env, NULL, value);
4605 }
4606
4607 static void hcr_writelow(CPUARMState *env, const ARMCPRegInfo *ri,
4608                          uint64_t value)
4609 {
4610     /* Handle HCR write, i.e. write to low half of HCR_EL2 */
4611     value = deposit64(env->cp15.hcr_el2, 0, 32, value);
4612     hcr_write(env, NULL, value);
4613 }
4614
4615 /*
4616  * Return the effective value of HCR_EL2.
4617  * Bits that are not included here:
4618  * RW       (read from SCR_EL3.RW as needed)
4619  */
4620 uint64_t arm_hcr_el2_eff(CPUARMState *env)
4621 {
4622     uint64_t ret = env->cp15.hcr_el2;
4623
4624     if (arm_is_secure_below_el3(env)) {
4625         /*
4626          * "This register has no effect if EL2 is not enabled in the
4627          * current Security state".  This is ARMv8.4-SecEL2 speak for
4628          * !(SCR_EL3.NS==1 || SCR_EL3.EEL2==1).
4629          *
4630          * Prior to that, the language was "In an implementation that
4631          * includes EL3, when the value of SCR_EL3.NS is 0 the PE behaves
4632          * as if this field is 0 for all purposes other than a direct
4633          * read or write access of HCR_EL2".  With lots of enumeration
4634          * on a per-field basis.  In current QEMU, this is condition
4635          * is arm_is_secure_below_el3.
4636          *
4637          * Since the v8.4 language applies to the entire register, and
4638          * appears to be backward compatible, use that.
4639          */
4640         ret = 0;
4641     } else if (ret & HCR_TGE) {
4642         /* These bits are up-to-date as of ARMv8.4.  */
4643         if (ret & HCR_E2H) {
4644             ret &= ~(HCR_VM | HCR_FMO | HCR_IMO | HCR_AMO |
4645                      HCR_BSU_MASK | HCR_DC | HCR_TWI | HCR_TWE |
4646                      HCR_TID0 | HCR_TID2 | HCR_TPCP | HCR_TPU |
4647                      HCR_TDZ | HCR_CD | HCR_ID | HCR_MIOCNCE);
4648         } else {
4649             ret |= HCR_FMO | HCR_IMO | HCR_AMO;
4650         }
4651         ret &= ~(HCR_SWIO | HCR_PTW | HCR_VF | HCR_VI | HCR_VSE |
4652                  HCR_FB | HCR_TID1 | HCR_TID3 | HCR_TSC | HCR_TACR |
4653                  HCR_TSW | HCR_TTLB | HCR_TVM | HCR_HCD | HCR_TRVM |
4654                  HCR_TLOR);
4655     }
4656
4657     return ret;
4658 }
4659
4660 static const ARMCPRegInfo el2_cp_reginfo[] = {
4661     { .name = "HCR_EL2", .state = ARM_CP_STATE_AA64,
4662       .type = ARM_CP_IO,
4663       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 0,
4664       .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.hcr_el2),
4665       .writefn = hcr_write },
4666     { .name = "HCR", .state = ARM_CP_STATE_AA32,
4667       .type = ARM_CP_ALIAS | ARM_CP_IO,
4668       .cp = 15, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 0,
4669       .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.hcr_el2),
4670       .writefn = hcr_writelow },
4671     { .name = "HACR_EL2", .state = ARM_CP_STATE_BOTH,
4672       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 7,
4673       .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
4674     { .name = "ELR_EL2", .state = ARM_CP_STATE_AA64,
4675       .type = ARM_CP_ALIAS,
4676       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 0, .opc2 = 1,
4677       .access = PL2_RW,
4678       .fieldoffset = offsetof(CPUARMState, elr_el[2]) },
4679     { .name = "ESR_EL2", .state = ARM_CP_STATE_BOTH,
4680       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 2, .opc2 = 0,
4681       .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.esr_el[2]) },
4682     { .name = "FAR_EL2", .state = ARM_CP_STATE_BOTH,
4683       .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 0,
4684       .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.far_el[2]) },
4685     { .name = "HIFAR", .state = ARM_CP_STATE_AA32,
4686       .type = ARM_CP_ALIAS,
4687       .cp = 15, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 2,
4688       .access = PL2_RW,
4689       .fieldoffset = offsetofhigh32(CPUARMState, cp15.far_el[2]) },
4690     { .name = "SPSR_EL2", .state = ARM_CP_STATE_AA64,
4691       .type = ARM_CP_ALIAS,
4692       .opc0 = 3, .opc1 = 4, .crn = 4, .crm = 0, .opc2 = 0,
4693       .access = PL2_RW,
4694       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_HYP]) },
4695     { .name = "VBAR_EL2", .state = ARM_CP_STATE_BOTH,
4696       .opc0 = 3, .opc1 = 4, .crn = 12, .crm = 0, .opc2 = 0,
4697       .access = PL2_RW, .writefn = vbar_write,
4698       .fieldoffset = offsetof(CPUARMState, cp15.vbar_el[2]),
4699       .resetvalue = 0 },
4700     { .name = "SP_EL2", .state = ARM_CP_STATE_AA64,
4701       .opc0 = 3, .opc1 = 6, .crn = 4, .crm = 1, .opc2 = 0,
4702       .access = PL3_RW, .type = ARM_CP_ALIAS,
4703       .fieldoffset = offsetof(CPUARMState, sp_el[2]) },
4704     { .name = "CPTR_EL2", .state = ARM_CP_STATE_BOTH,
4705       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 2,
4706       .access = PL2_RW, .accessfn = cptr_access, .resetvalue = 0,
4707       .fieldoffset = offsetof(CPUARMState, cp15.cptr_el[2]) },
4708     { .name = "MAIR_EL2", .state = ARM_CP_STATE_BOTH,
4709       .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 0,
4710       .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.mair_el[2]),
4711       .resetvalue = 0 },
4712     { .name = "HMAIR1", .state = ARM_CP_STATE_AA32,
4713       .cp = 15, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 1,
4714       .access = PL2_RW, .type = ARM_CP_ALIAS,
4715       .fieldoffset = offsetofhigh32(CPUARMState, cp15.mair_el[2]) },
4716     { .name = "AMAIR_EL2", .state = ARM_CP_STATE_BOTH,
4717       .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 0,
4718       .access = PL2_RW, .type = ARM_CP_CONST,
4719       .resetvalue = 0 },
4720     /* HAMAIR1 is mapped to AMAIR_EL2[63:32] */
4721     { .name = "HAMAIR1", .state = ARM_CP_STATE_AA32,
4722       .cp = 15, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 1,
4723       .access = PL2_RW, .type = ARM_CP_CONST,
4724       .resetvalue = 0 },
4725     { .name = "AFSR0_EL2", .state = ARM_CP_STATE_BOTH,
4726       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 0,
4727       .access = PL2_RW, .type = ARM_CP_CONST,
4728       .resetvalue = 0 },
4729     { .name = "AFSR1_EL2", .state = ARM_CP_STATE_BOTH,
4730       .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 1,
4731       .access = PL2_RW, .type = ARM_CP_CONST,
4732       .resetvalue = 0 },
4733     { .name = "TCR_EL2", .state = ARM_CP_STATE_BOTH,
4734       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 2,
4735       .access = PL2_RW,
4736       /* no .writefn needed as this can't cause an ASID change;
4737        * no .raw_writefn or .resetfn needed as we never use mask/base_mask
4738        */
4739       .fieldoffset = offsetof(CPUARMState, cp15.tcr_el[2]) },
4740     { .name = "VTCR", .state = ARM_CP_STATE_AA32,
4741       .cp = 15, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 2,
4742       .type = ARM_CP_ALIAS,
4743       .access = PL2_RW, .accessfn = access_el3_aa32ns,
4744       .fieldoffset = offsetof(CPUARMState, cp15.vtcr_el2) },
4745     { .name = "VTCR_EL2", .state = ARM_CP_STATE_AA64,
4746       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 2,
4747       .access = PL2_RW,
4748       /* no .writefn needed as this can't cause an ASID change;
4749        * no .raw_writefn or .resetfn needed as we never use mask/base_mask
4750        */
4751       .fieldoffset = offsetof(CPUARMState, cp15.vtcr_el2) },
4752     { .name = "VTTBR", .state = ARM_CP_STATE_AA32,
4753       .cp = 15, .opc1 = 6, .crm = 2,
4754       .type = ARM_CP_64BIT | ARM_CP_ALIAS,
4755       .access = PL2_RW, .accessfn = access_el3_aa32ns,
4756       .fieldoffset = offsetof(CPUARMState, cp15.vttbr_el2),
4757       .writefn = vttbr_write },
4758     { .name = "VTTBR_EL2", .state = ARM_CP_STATE_AA64,
4759       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 0,
4760       .access = PL2_RW, .writefn = vttbr_write,
4761       .fieldoffset = offsetof(CPUARMState, cp15.vttbr_el2) },
4762     { .name = "SCTLR_EL2", .state = ARM_CP_STATE_BOTH,
4763       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 0, .opc2 = 0,
4764       .access = PL2_RW, .raw_writefn = raw_write, .writefn = sctlr_write,
4765       .fieldoffset = offsetof(CPUARMState, cp15.sctlr_el[2]) },
4766     { .name = "TPIDR_EL2", .state = ARM_CP_STATE_BOTH,
4767       .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 2,
4768       .access = PL2_RW, .resetvalue = 0,
4769       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el[2]) },
4770     { .name = "TTBR0_EL2", .state = ARM_CP_STATE_AA64,
4771       .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 0,
4772       .access = PL2_RW, .resetvalue = 0,
4773       .fieldoffset = offsetof(CPUARMState, cp15.ttbr0_el[2]) },
4774     { .name = "HTTBR", .cp = 15, .opc1 = 4, .crm = 2,
4775       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_ALIAS,
4776       .fieldoffset = offsetof(CPUARMState, cp15.ttbr0_el[2]) },
4777     { .name = "TLBIALLNSNH",
4778       .cp = 15, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 4,
4779       .type = ARM_CP_NO_RAW, .access = PL2_W,
4780       .writefn = tlbiall_nsnh_write },
4781     { .name = "TLBIALLNSNHIS",
4782       .cp = 15, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 4,
4783       .type = ARM_CP_NO_RAW, .access = PL2_W,
4784       .writefn = tlbiall_nsnh_is_write },
4785     { .name = "TLBIALLH", .cp = 15, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 0,
4786       .type = ARM_CP_NO_RAW, .access = PL2_W,
4787       .writefn = tlbiall_hyp_write },
4788     { .name = "TLBIALLHIS", .cp = 15, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 0,
4789       .type = ARM_CP_NO_RAW, .access = PL2_W,
4790       .writefn = tlbiall_hyp_is_write },
4791     { .name = "TLBIMVAH", .cp = 15, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 1,
4792       .type = ARM_CP_NO_RAW, .access = PL2_W,
4793       .writefn = tlbimva_hyp_write },
4794     { .name = "TLBIMVAHIS", .cp = 15, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 1,
4795       .type = ARM_CP_NO_RAW, .access = PL2_W,
4796       .writefn = tlbimva_hyp_is_write },
4797     { .name = "TLBI_ALLE2", .state = ARM_CP_STATE_AA64,
4798       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 0,
4799       .type = ARM_CP_NO_RAW, .access = PL2_W,
4800       .writefn = tlbi_aa64_alle2_write },
4801     { .name = "TLBI_VAE2", .state = ARM_CP_STATE_AA64,
4802       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 1,
4803       .type = ARM_CP_NO_RAW, .access = PL2_W,
4804       .writefn = tlbi_aa64_vae2_write },
4805     { .name = "TLBI_VALE2", .state = ARM_CP_STATE_AA64,
4806       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 5,
4807       .access = PL2_W, .type = ARM_CP_NO_RAW,
4808       .writefn = tlbi_aa64_vae2_write },
4809     { .name = "TLBI_ALLE2IS", .state = ARM_CP_STATE_AA64,
4810       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 0,
4811       .access = PL2_W, .type = ARM_CP_NO_RAW,
4812       .writefn = tlbi_aa64_alle2is_write },
4813     { .name = "TLBI_VAE2IS", .state = ARM_CP_STATE_AA64,
4814       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 1,
4815       .type = ARM_CP_NO_RAW, .access = PL2_W,
4816       .writefn = tlbi_aa64_vae2is_write },
4817     { .name = "TLBI_VALE2IS", .state = ARM_CP_STATE_AA64,
4818       .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 5,
4819       .access = PL2_W, .type = ARM_CP_NO_RAW,
4820       .writefn = tlbi_aa64_vae2is_write },
4821 #ifndef CONFIG_USER_ONLY
4822     /* Unlike the other EL2-related AT operations, these must
4823      * UNDEF from EL3 if EL2 is not implemented, which is why we
4824      * define them here rather than with the rest of the AT ops.
4825      */
4826     { .name = "AT_S1E2R", .state = ARM_CP_STATE_AA64,
4827       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 0,
4828       .access = PL2_W, .accessfn = at_s1e2_access,
4829       .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4830     { .name = "AT_S1E2W", .state = ARM_CP_STATE_AA64,
4831       .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 1,
4832       .access = PL2_W, .accessfn = at_s1e2_access,
4833       .type = ARM_CP_NO_RAW, .writefn = ats_write64 },
4834     /* The AArch32 ATS1H* operations are CONSTRAINED UNPREDICTABLE
4835      * if EL2 is not implemented; we choose to UNDEF. Behaviour at EL3
4836      * with SCR.NS == 0 outside Monitor mode is UNPREDICTABLE; we choose
4837      * to behave as if SCR.NS was 1.
4838      */
4839     { .name = "ATS1HR", .cp = 15, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 0,
4840       .access = PL2_W,
4841       .writefn = ats1h_write, .type = ARM_CP_NO_RAW },
4842     { .name = "ATS1HW", .cp = 15, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 1,
4843       .access = PL2_W,
4844       .writefn = ats1h_write, .type = ARM_CP_NO_RAW },
4845     { .name = "CNTHCTL_EL2", .state = ARM_CP_STATE_BOTH,
4846       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 1, .opc2 = 0,
4847       /* ARMv7 requires bit 0 and 1 to reset to 1. ARMv8 defines the
4848        * reset values as IMPDEF. We choose to reset to 3 to comply with
4849        * both ARMv7 and ARMv8.
4850        */
4851       .access = PL2_RW, .resetvalue = 3,
4852       .fieldoffset = offsetof(CPUARMState, cp15.cnthctl_el2) },
4853     { .name = "CNTVOFF_EL2", .state = ARM_CP_STATE_AA64,
4854       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 0, .opc2 = 3,
4855       .access = PL2_RW, .type = ARM_CP_IO, .resetvalue = 0,
4856       .writefn = gt_cntvoff_write,
4857       .fieldoffset = offsetof(CPUARMState, cp15.cntvoff_el2) },
4858     { .name = "CNTVOFF", .cp = 15, .opc1 = 4, .crm = 14,
4859       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_ALIAS | ARM_CP_IO,
4860       .writefn = gt_cntvoff_write,
4861       .fieldoffset = offsetof(CPUARMState, cp15.cntvoff_el2) },
4862     { .name = "CNTHP_CVAL_EL2", .state = ARM_CP_STATE_AA64,
4863       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 2,
4864       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_HYP].cval),
4865       .type = ARM_CP_IO, .access = PL2_RW,
4866       .writefn = gt_hyp_cval_write, .raw_writefn = raw_write },
4867     { .name = "CNTHP_CVAL", .cp = 15, .opc1 = 6, .crm = 14,
4868       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_HYP].cval),
4869       .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_IO,
4870       .writefn = gt_hyp_cval_write, .raw_writefn = raw_write },
4871     { .name = "CNTHP_TVAL_EL2", .state = ARM_CP_STATE_BOTH,
4872       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 0,
4873       .type = ARM_CP_NO_RAW | ARM_CP_IO, .access = PL2_RW,
4874       .resetfn = gt_hyp_timer_reset,
4875       .readfn = gt_hyp_tval_read, .writefn = gt_hyp_tval_write },
4876     { .name = "CNTHP_CTL_EL2", .state = ARM_CP_STATE_BOTH,
4877       .type = ARM_CP_IO,
4878       .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 1,
4879       .access = PL2_RW,
4880       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_HYP].ctl),
4881       .resetvalue = 0,
4882       .writefn = gt_hyp_ctl_write, .raw_writefn = raw_write },
4883 #endif
4884     /* The only field of MDCR_EL2 that has a defined architectural reset value
4885      * is MDCR_EL2.HPMN which should reset to the value of PMCR_EL0.N; but we
4886      * don't implement any PMU event counters, so using zero as a reset
4887      * value for MDCR_EL2 is okay
4888      */
4889     { .name = "MDCR_EL2", .state = ARM_CP_STATE_BOTH,
4890       .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 1,
4891       .access = PL2_RW, .resetvalue = 0,
4892       .fieldoffset = offsetof(CPUARMState, cp15.mdcr_el2), },
4893     { .name = "HPFAR", .state = ARM_CP_STATE_AA32,
4894       .cp = 15, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 4,
4895       .access = PL2_RW, .accessfn = access_el3_aa32ns,
4896       .fieldoffset = offsetof(CPUARMState, cp15.hpfar_el2) },
4897     { .name = "HPFAR_EL2", .state = ARM_CP_STATE_AA64,
4898       .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 4,
4899       .access = PL2_RW,
4900       .fieldoffset = offsetof(CPUARMState, cp15.hpfar_el2) },
4901     { .name = "HSTR_EL2", .state = ARM_CP_STATE_BOTH,
4902       .cp = 15, .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 3,
4903       .access = PL2_RW,
4904       .fieldoffset = offsetof(CPUARMState, cp15.hstr_el2) },
4905     REGINFO_SENTINEL
4906 };
4907
4908 static const ARMCPRegInfo el2_v8_cp_reginfo[] = {
4909     { .name = "HCR2", .state = ARM_CP_STATE_AA32,
4910       .type = ARM_CP_ALIAS | ARM_CP_IO,
4911       .cp = 15, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 4,
4912       .access = PL2_RW,
4913       .fieldoffset = offsetofhigh32(CPUARMState, cp15.hcr_el2),
4914       .writefn = hcr_writehigh },
4915     REGINFO_SENTINEL
4916 };
4917
4918 static CPAccessResult nsacr_access(CPUARMState *env, const ARMCPRegInfo *ri,
4919                                    bool isread)
4920 {
4921     /* The NSACR is RW at EL3, and RO for NS EL1 and NS EL2.
4922      * At Secure EL1 it traps to EL3.
4923      */
4924     if (arm_current_el(env) == 3) {
4925         return CP_ACCESS_OK;
4926     }
4927     if (arm_is_secure_below_el3(env)) {
4928         return CP_ACCESS_TRAP_EL3;
4929     }
4930     /* Accesses from EL1 NS and EL2 NS are UNDEF for write but allow reads. */
4931     if (isread) {
4932         return CP_ACCESS_OK;
4933     }
4934     return CP_ACCESS_TRAP_UNCATEGORIZED;
4935 }
4936
4937 static const ARMCPRegInfo el3_cp_reginfo[] = {
4938     { .name = "SCR_EL3", .state = ARM_CP_STATE_AA64,
4939       .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 1, .opc2 = 0,
4940       .access = PL3_RW, .fieldoffset = offsetof(CPUARMState, cp15.scr_el3),
4941       .resetvalue = 0, .writefn = scr_write },
4942     { .name = "SCR",  .type = ARM_CP_ALIAS,
4943       .cp = 15, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 0,
4944       .access = PL1_RW, .accessfn = access_trap_aa32s_el1,
4945       .fieldoffset = offsetoflow32(CPUARMState, cp15.scr_el3),
4946       .writefn = scr_write },
4947     { .name = "SDER32_EL3", .state = ARM_CP_STATE_AA64,
4948       .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 1, .opc2 = 1,
4949       .access = PL3_RW, .resetvalue = 0,
4950       .fieldoffset = offsetof(CPUARMState, cp15.sder) },
4951     { .name = "SDER",
4952       .cp = 15, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 1,
4953       .access = PL3_RW, .resetvalue = 0,
4954       .fieldoffset = offsetoflow32(CPUARMState, cp15.sder) },
4955     { .name = "MVBAR", .cp = 15, .opc1 = 0, .crn = 12, .crm = 0, .opc2 = 1,
4956       .access = PL1_RW, .accessfn = access_trap_aa32s_el1,
4957       .writefn = vbar_write, .resetvalue = 0,
4958       .fieldoffset = offsetof(CPUARMState, cp15.mvbar) },
4959     { .name = "TTBR0_EL3", .state = ARM_CP_STATE_AA64,
4960       .opc0 = 3, .opc1 = 6, .crn = 2, .crm = 0, .opc2 = 0,
4961       .access = PL3_RW, .resetvalue = 0,
4962       .fieldoffset = offsetof(CPUARMState, cp15.ttbr0_el[3]) },
4963     { .name = "TCR_EL3", .state = ARM_CP_STATE_AA64,
4964       .opc0 = 3, .opc1 = 6, .crn = 2, .crm = 0, .opc2 = 2,
4965       .access = PL3_RW,
4966       /* no .writefn needed as this can't cause an ASID change;
4967        * we must provide a .raw_writefn and .resetfn because we handle
4968        * reset and migration for the AArch32 TTBCR(S), which might be
4969        * using mask and base_mask.
4970        */
4971       .resetfn = vmsa_ttbcr_reset, .raw_writefn = vmsa_ttbcr_raw_write,
4972       .fieldoffset = offsetof(CPUARMState, cp15.tcr_el[3]) },
4973     { .name = "ELR_EL3", .state = ARM_CP_STATE_AA64,
4974       .type = ARM_CP_ALIAS,
4975       .opc0 = 3, .opc1 = 6, .crn = 4, .crm = 0, .opc2 = 1,
4976       .access = PL3_RW,
4977       .fieldoffset = offsetof(CPUARMState, elr_el[3]) },
4978     { .name = "ESR_EL3", .state = ARM_CP_STATE_AA64,
4979       .opc0 = 3, .opc1 = 6, .crn = 5, .crm = 2, .opc2 = 0,
4980       .access = PL3_RW, .fieldoffset = offsetof(CPUARMState, cp15.esr_el[3]) },
4981     { .name = "FAR_EL3", .state = ARM_CP_STATE_AA64,
4982       .opc0 = 3, .opc1 = 6, .crn = 6, .crm = 0, .opc2 = 0,
4983       .access = PL3_RW, .fieldoffset = offsetof(CPUARMState, cp15.far_el[3]) },
4984     { .name = "SPSR_EL3", .state = ARM_CP_STATE_AA64,
4985       .type = ARM_CP_ALIAS,
4986       .opc0 = 3, .opc1 = 6, .crn = 4, .crm = 0, .opc2 = 0,
4987       .access = PL3_RW,
4988       .fieldoffset = offsetof(CPUARMState, banked_spsr[BANK_MON]) },
4989     { .name = "VBAR_EL3", .state = ARM_CP_STATE_AA64,
4990       .opc0 = 3, .opc1 = 6, .crn = 12, .crm = 0, .opc2 = 0,
4991       .access = PL3_RW, .writefn = vbar_write,
4992       .fieldoffset = offsetof(CPUARMState, cp15.vbar_el[3]),
4993       .resetvalue = 0 },
4994     { .name = "CPTR_EL3", .state = ARM_CP_STATE_AA64,
4995       .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 1, .opc2 = 2,
4996       .access = PL3_RW, .accessfn = cptr_access, .resetvalue = 0,
4997       .fieldoffset = offsetof(CPUARMState, cp15.cptr_el[3]) },
4998     { .name = "TPIDR_EL3", .state = ARM_CP_STATE_AA64,
4999       .opc0 = 3, .opc1 = 6, .crn = 13, .crm = 0, .opc2 = 2,
5000       .access = PL3_RW, .resetvalue = 0,
5001       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el[3]) },
5002     { .name = "AMAIR_EL3", .state = ARM_CP_STATE_AA64,
5003       .opc0 = 3, .opc1 = 6, .crn = 10, .crm = 3, .opc2 = 0,
5004       .access = PL3_RW, .type = ARM_CP_CONST,
5005       .resetvalue = 0 },
5006     { .name = "AFSR0_EL3", .state = ARM_CP_STATE_BOTH,
5007       .opc0 = 3, .opc1 = 6, .crn = 5, .crm = 1, .opc2 = 0,
5008       .access = PL3_RW, .type = ARM_CP_CONST,
5009       .resetvalue = 0 },
5010     { .name = "AFSR1_EL3", .state = ARM_CP_STATE_BOTH,
5011       .opc0 = 3, .opc1 = 6, .crn = 5, .crm = 1, .opc2 = 1,
5012       .access = PL3_RW, .type = ARM_CP_CONST,
5013       .resetvalue = 0 },
5014     { .name = "TLBI_ALLE3IS", .state = ARM_CP_STATE_AA64,
5015       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 3, .opc2 = 0,
5016       .access = PL3_W, .type = ARM_CP_NO_RAW,
5017       .writefn = tlbi_aa64_alle3is_write },
5018     { .name = "TLBI_VAE3IS", .state = ARM_CP_STATE_AA64,
5019       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 3, .opc2 = 1,
5020       .access = PL3_W, .type = ARM_CP_NO_RAW,
5021       .writefn = tlbi_aa64_vae3is_write },
5022     { .name = "TLBI_VALE3IS", .state = ARM_CP_STATE_AA64,
5023       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 3, .opc2 = 5,
5024       .access = PL3_W, .type = ARM_CP_NO_RAW,
5025       .writefn = tlbi_aa64_vae3is_write },
5026     { .name = "TLBI_ALLE3", .state = ARM_CP_STATE_AA64,
5027       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 7, .opc2 = 0,
5028       .access = PL3_W, .type = ARM_CP_NO_RAW,
5029       .writefn = tlbi_aa64_alle3_write },
5030     { .name = "TLBI_VAE3", .state = ARM_CP_STATE_AA64,
5031       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 7, .opc2 = 1,
5032       .access = PL3_W, .type = ARM_CP_NO_RAW,
5033       .writefn = tlbi_aa64_vae3_write },
5034     { .name = "TLBI_VALE3", .state = ARM_CP_STATE_AA64,
5035       .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 7, .opc2 = 5,
5036       .access = PL3_W, .type = ARM_CP_NO_RAW,
5037       .writefn = tlbi_aa64_vae3_write },
5038     REGINFO_SENTINEL
5039 };
5040
5041 static CPAccessResult ctr_el0_access(CPUARMState *env, const ARMCPRegInfo *ri,
5042                                      bool isread)
5043 {
5044     /* Only accessible in EL0 if SCTLR.UCT is set (and only in AArch64,
5045      * but the AArch32 CTR has its own reginfo struct)
5046      */
5047     if (arm_current_el(env) == 0 && !(env->cp15.sctlr_el[1] & SCTLR_UCT)) {
5048         return CP_ACCESS_TRAP;
5049     }
5050     return CP_ACCESS_OK;
5051 }
5052
5053 static void oslar_write(CPUARMState *env, const ARMCPRegInfo *ri,
5054                         uint64_t value)
5055 {
5056     /* Writes to OSLAR_EL1 may update the OS lock status, which can be
5057      * read via a bit in OSLSR_EL1.
5058      */
5059     int oslock;
5060
5061     if (ri->state == ARM_CP_STATE_AA32) {
5062         oslock = (value == 0xC5ACCE55);
5063     } else {
5064         oslock = value & 1;
5065     }
5066
5067     env->cp15.oslsr_el1 = deposit32(env->cp15.oslsr_el1, 1, 1, oslock);
5068 }
5069
5070 static const ARMCPRegInfo debug_cp_reginfo[] = {
5071     /* DBGDRAR, DBGDSAR: always RAZ since we don't implement memory mapped
5072      * debug components. The AArch64 version of DBGDRAR is named MDRAR_EL1;
5073      * unlike DBGDRAR it is never accessible from EL0.
5074      * DBGDSAR is deprecated and must RAZ from v8 anyway, so it has no AArch64
5075      * accessor.
5076      */
5077     { .name = "DBGDRAR", .cp = 14, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 0,
5078       .access = PL0_R, .accessfn = access_tdra,
5079       .type = ARM_CP_CONST, .resetvalue = 0 },
5080     { .name = "MDRAR_EL1", .state = ARM_CP_STATE_AA64,
5081       .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 0,
5082       .access = PL1_R, .accessfn = access_tdra,
5083       .type = ARM_CP_CONST, .resetvalue = 0 },
5084     { .name = "DBGDSAR", .cp = 14, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0,
5085       .access = PL0_R, .accessfn = access_tdra,
5086       .type = ARM_CP_CONST, .resetvalue = 0 },
5087     /* Monitor debug system control register; the 32-bit alias is DBGDSCRext. */
5088     { .name = "MDSCR_EL1", .state = ARM_CP_STATE_BOTH,
5089       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 2,
5090       .access = PL1_RW, .accessfn = access_tda,
5091       .fieldoffset = offsetof(CPUARMState, cp15.mdscr_el1),
5092       .resetvalue = 0 },
5093     /* MDCCSR_EL0, aka DBGDSCRint. This is a read-only mirror of MDSCR_EL1.
5094      * We don't implement the configurable EL0 access.
5095      */
5096     { .name = "MDCCSR_EL0", .state = ARM_CP_STATE_BOTH,
5097       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 0,
5098       .type = ARM_CP_ALIAS,
5099       .access = PL1_R, .accessfn = access_tda,
5100       .fieldoffset = offsetof(CPUARMState, cp15.mdscr_el1), },
5101     { .name = "OSLAR_EL1", .state = ARM_CP_STATE_BOTH,
5102       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 4,
5103       .access = PL1_W, .type = ARM_CP_NO_RAW,
5104       .accessfn = access_tdosa,
5105       .writefn = oslar_write },
5106     { .name = "OSLSR_EL1", .state = ARM_CP_STATE_BOTH,
5107       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 4,
5108       .access = PL1_R, .resetvalue = 10,
5109       .accessfn = access_tdosa,
5110       .fieldoffset = offsetof(CPUARMState, cp15.oslsr_el1) },
5111     /* Dummy OSDLR_EL1: 32-bit Linux will read this */
5112     { .name = "OSDLR_EL1", .state = ARM_CP_STATE_BOTH,
5113       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 1, .crm = 3, .opc2 = 4,
5114       .access = PL1_RW, .accessfn = access_tdosa,
5115       .type = ARM_CP_NOP },
5116     /* Dummy DBGVCR: Linux wants to clear this on startup, but we don't
5117      * implement vector catch debug events yet.
5118      */
5119     { .name = "DBGVCR",
5120       .cp = 14, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 0,
5121       .access = PL1_RW, .accessfn = access_tda,
5122       .type = ARM_CP_NOP },
5123     /* Dummy DBGVCR32_EL2 (which is only for a 64-bit hypervisor
5124      * to save and restore a 32-bit guest's DBGVCR)
5125      */
5126     { .name = "DBGVCR32_EL2", .state = ARM_CP_STATE_AA64,
5127       .opc0 = 2, .opc1 = 4, .crn = 0, .crm = 7, .opc2 = 0,
5128       .access = PL2_RW, .accessfn = access_tda,
5129       .type = ARM_CP_NOP },
5130     /* Dummy MDCCINT_EL1, since we don't implement the Debug Communications
5131      * Channel but Linux may try to access this register. The 32-bit
5132      * alias is DBGDCCINT.
5133      */
5134     { .name = "MDCCINT_EL1", .state = ARM_CP_STATE_BOTH,
5135       .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 0,
5136       .access = PL1_RW, .accessfn = access_tda,
5137       .type = ARM_CP_NOP },
5138     REGINFO_SENTINEL
5139 };
5140
5141 static const ARMCPRegInfo debug_lpae_cp_reginfo[] = {
5142     /* 64 bit access versions of the (dummy) debug registers */
5143     { .name = "DBGDRAR", .cp = 14, .crm = 1, .opc1 = 0,
5144       .access = PL0_R, .type = ARM_CP_CONST|ARM_CP_64BIT, .resetvalue = 0 },
5145     { .name = "DBGDSAR", .cp = 14, .crm = 2, .opc1 = 0,
5146       .access = PL0_R, .type = ARM_CP_CONST|ARM_CP_64BIT, .resetvalue = 0 },
5147     REGINFO_SENTINEL
5148 };
5149
5150 /* Return the exception level to which exceptions should be taken
5151  * via SVEAccessTrap.  If an exception should be routed through
5152  * AArch64.AdvSIMDFPAccessTrap, return 0; fp_exception_el should
5153  * take care of raising that exception.
5154  * C.f. the ARM pseudocode function CheckSVEEnabled.
5155  */
5156 int sve_exception_el(CPUARMState *env, int el)
5157 {
5158 #ifndef CONFIG_USER_ONLY
5159     if (el <= 1) {
5160         bool disabled = false;
5161
5162         /* The CPACR.ZEN controls traps to EL1:
5163          * 0, 2 : trap EL0 and EL1 accesses
5164          * 1    : trap only EL0 accesses
5165          * 3    : trap no accesses
5166          */
5167         if (!extract32(env->cp15.cpacr_el1, 16, 1)) {
5168             disabled = true;
5169         } else if (!extract32(env->cp15.cpacr_el1, 17, 1)) {
5170             disabled = el == 0;
5171         }
5172         if (disabled) {
5173             /* route_to_el2 */
5174             return (arm_feature(env, ARM_FEATURE_EL2)
5175                     && (arm_hcr_el2_eff(env) & HCR_TGE) ? 2 : 1);
5176         }
5177
5178         /* Check CPACR.FPEN.  */
5179         if (!extract32(env->cp15.cpacr_el1, 20, 1)) {
5180             disabled = true;
5181         } else if (!extract32(env->cp15.cpacr_el1, 21, 1)) {
5182             disabled = el == 0;
5183         }
5184         if (disabled) {
5185             return 0;
5186         }
5187     }
5188
5189     /* CPTR_EL2.  Since TZ and TFP are positive,
5190      * they will be zero when EL2 is not present.
5191      */
5192     if (el <= 2 && !arm_is_secure_below_el3(env)) {
5193         if (env->cp15.cptr_el[2] & CPTR_TZ) {
5194             return 2;
5195         }
5196         if (env->cp15.cptr_el[2] & CPTR_TFP) {
5197             return 0;
5198         }
5199     }
5200
5201     /* CPTR_EL3.  Since EZ is negative we must check for EL3.  */
5202     if (arm_feature(env, ARM_FEATURE_EL3)
5203         && !(env->cp15.cptr_el[3] & CPTR_EZ)) {
5204         return 3;
5205     }
5206 #endif
5207     return 0;
5208 }
5209
5210 /*
5211  * Given that SVE is enabled, return the vector length for EL.
5212  */
5213 uint32_t sve_zcr_len_for_el(CPUARMState *env, int el)
5214 {
5215     ARMCPU *cpu = arm_env_get_cpu(env);
5216     uint32_t zcr_len = cpu->sve_max_vq - 1;
5217
5218     if (el <= 1) {
5219         zcr_len = MIN(zcr_len, 0xf & (uint32_t)env->vfp.zcr_el[1]);
5220     }
5221     if (el < 2 && arm_feature(env, ARM_FEATURE_EL2)) {
5222         zcr_len = MIN(zcr_len, 0xf & (uint32_t)env->vfp.zcr_el[2]);
5223     }
5224     if (el < 3 && arm_feature(env, ARM_FEATURE_EL3)) {
5225         zcr_len = MIN(zcr_len, 0xf & (uint32_t)env->vfp.zcr_el[3]);
5226     }
5227     return zcr_len;
5228 }
5229
5230 static void zcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
5231                       uint64_t value)
5232 {
5233     int cur_el = arm_current_el(env);
5234     int old_len = sve_zcr_len_for_el(env, cur_el);
5235     int new_len;
5236
5237     /* Bits other than [3:0] are RAZ/WI.  */
5238     raw_write(env, ri, value & 0xf);
5239
5240     /*
5241      * Because we arrived here, we know both FP and SVE are enabled;
5242      * otherwise we would have trapped access to the ZCR_ELn register.
5243      */
5244     new_len = sve_zcr_len_for_el(env, cur_el);
5245     if (new_len < old_len) {
5246         aarch64_sve_narrow_vq(env, new_len + 1);
5247     }
5248 }
5249
5250 static const ARMCPRegInfo zcr_el1_reginfo = {
5251     .name = "ZCR_EL1", .state = ARM_CP_STATE_AA64,
5252     .opc0 = 3, .opc1 = 0, .crn = 1, .crm = 2, .opc2 = 0,
5253     .access = PL1_RW, .type = ARM_CP_SVE,
5254     .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[1]),
5255     .writefn = zcr_write, .raw_writefn = raw_write
5256 };
5257
5258 static const ARMCPRegInfo zcr_el2_reginfo = {
5259     .name = "ZCR_EL2", .state = ARM_CP_STATE_AA64,
5260     .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 2, .opc2 = 0,
5261     .access = PL2_RW, .type = ARM_CP_SVE,
5262     .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[2]),
5263     .writefn = zcr_write, .raw_writefn = raw_write
5264 };
5265
5266 static const ARMCPRegInfo zcr_no_el2_reginfo = {
5267     .name = "ZCR_EL2", .state = ARM_CP_STATE_AA64,
5268     .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 2, .opc2 = 0,
5269     .access = PL2_RW, .type = ARM_CP_SVE,
5270     .readfn = arm_cp_read_zero, .writefn = arm_cp_write_ignore
5271 };
5272
5273 static const ARMCPRegInfo zcr_el3_reginfo = {
5274     .name = "ZCR_EL3", .state = ARM_CP_STATE_AA64,
5275     .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 2, .opc2 = 0,
5276     .access = PL3_RW, .type = ARM_CP_SVE,
5277     .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[3]),
5278     .writefn = zcr_write, .raw_writefn = raw_write
5279 };
5280
5281 void hw_watchpoint_update(ARMCPU *cpu, int n)
5282 {
5283     CPUARMState *env = &cpu->env;
5284     vaddr len = 0;
5285     vaddr wvr = env->cp15.dbgwvr[n];
5286     uint64_t wcr = env->cp15.dbgwcr[n];
5287     int mask;
5288     int flags = BP_CPU | BP_STOP_BEFORE_ACCESS;
5289
5290     if (env->cpu_watchpoint[n]) {
5291         cpu_watchpoint_remove_by_ref(CPU(cpu), env->cpu_watchpoint[n]);
5292         env->cpu_watchpoint[n] = NULL;
5293     }
5294
5295     if (!extract64(wcr, 0, 1)) {
5296         /* E bit clear : watchpoint disabled */
5297         return;
5298     }
5299
5300     switch (extract64(wcr, 3, 2)) {
5301     case 0:
5302         /* LSC 00 is reserved and must behave as if the wp is disabled */
5303         return;
5304     case 1:
5305         flags |= BP_MEM_READ;
5306         break;
5307     case 2:
5308         flags |= BP_MEM_WRITE;
5309         break;
5310     case 3:
5311         flags |= BP_MEM_ACCESS;
5312         break;
5313     }
5314
5315     /* Attempts to use both MASK and BAS fields simultaneously are
5316      * CONSTRAINED UNPREDICTABLE; we opt to ignore BAS in this case,
5317      * thus generating a watchpoint for every byte in the masked region.
5318      */
5319     mask = extract64(wcr, 24, 4);
5320     if (mask == 1 || mask == 2) {
5321         /* Reserved values of MASK; we must act as if the mask value was
5322          * some non-reserved value, or as if the watchpoint were disabled.
5323          * We choose the latter.
5324          */
5325         return;
5326     } else if (mask) {
5327         /* Watchpoint covers an aligned area up to 2GB in size */
5328         len = 1ULL << mask;
5329         /* If masked bits in WVR are not zero it's CONSTRAINED UNPREDICTABLE
5330          * whether the watchpoint fires when the unmasked bits match; we opt
5331          * to generate the exceptions.
5332          */
5333         wvr &= ~(len - 1);
5334     } else {
5335         /* Watchpoint covers bytes defined by the byte address select bits */
5336         int bas = extract64(wcr, 5, 8);
5337         int basstart;
5338
5339         if (bas == 0) {
5340             /* This must act as if the watchpoint is disabled */
5341             return;
5342         }
5343
5344         if (extract64(wvr, 2, 1)) {
5345             /* Deprecated case of an only 4-aligned address. BAS[7:4] are
5346              * ignored, and BAS[3:0] define which bytes to watch.
5347              */
5348             bas &= 0xf;
5349         }
5350         /* The BAS bits are supposed to be programmed to indicate a contiguous
5351          * range of bytes. Otherwise it is CONSTRAINED UNPREDICTABLE whether
5352          * we fire for each byte in the word/doubleword addressed by the WVR.
5353          * We choose to ignore any non-zero bits after the first range of 1s.
5354          */
5355         basstart = ctz32(bas);
5356         len = cto32(bas >> basstart);
5357         wvr += basstart;
5358     }
5359
5360     cpu_watchpoint_insert(CPU(cpu), wvr, len, flags,
5361                           &env->cpu_watchpoint[n]);
5362 }
5363
5364 void hw_watchpoint_update_all(ARMCPU *cpu)
5365 {
5366     int i;
5367     CPUARMState *env = &cpu->env;
5368
5369     /* Completely clear out existing QEMU watchpoints and our array, to
5370      * avoid possible stale entries following migration load.
5371      */
5372     cpu_watchpoint_remove_all(CPU(cpu), BP_CPU);
5373     memset(env->cpu_watchpoint, 0, sizeof(env->cpu_watchpoint));
5374
5375     for (i = 0; i < ARRAY_SIZE(cpu->env.cpu_watchpoint); i++) {
5376         hw_watchpoint_update(cpu, i);
5377     }
5378 }
5379
5380 static void dbgwvr_write(CPUARMState *env, const ARMCPRegInfo *ri,
5381                          uint64_t value)
5382 {
5383     ARMCPU *cpu = arm_env_get_cpu(env);
5384     int i = ri->crm;
5385
5386     /* Bits [63:49] are hardwired to the value of bit [48]; that is, the
5387      * register reads and behaves as if values written are sign extended.
5388      * Bits [1:0] are RES0.
5389      */
5390     value = sextract64(value, 0, 49) & ~3ULL;
5391
5392     raw_write(env, ri, value);
5393     hw_watchpoint_update(cpu, i);
5394 }
5395
5396 static void dbgwcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
5397                          uint64_t value)
5398 {
5399     ARMCPU *cpu = arm_env_get_cpu(env);
5400     int i = ri->crm;
5401
5402     raw_write(env, ri, value);
5403     hw_watchpoint_update(cpu, i);
5404 }
5405
5406 void hw_breakpoint_update(ARMCPU *cpu, int n)
5407 {
5408     CPUARMState *env = &cpu->env;
5409     uint64_t bvr = env->cp15.dbgbvr[n];
5410     uint64_t bcr = env->cp15.dbgbcr[n];
5411     vaddr addr;
5412     int bt;
5413     int flags = BP_CPU;
5414
5415     if (env->cpu_breakpoint[n]) {
5416         cpu_breakpoint_remove_by_ref(CPU(cpu), env->cpu_breakpoint[n]);
5417         env->cpu_breakpoint[n] = NULL;
5418     }
5419
5420     if (!extract64(bcr, 0, 1)) {
5421         /* E bit clear : watchpoint disabled */
5422         return;
5423     }
5424
5425     bt = extract64(bcr, 20, 4);
5426
5427     switch (bt) {
5428     case 4: /* unlinked address mismatch (reserved if AArch64) */
5429     case 5: /* linked address mismatch (reserved if AArch64) */
5430         qemu_log_mask(LOG_UNIMP,
5431                       "arm: address mismatch breakpoint types not implemented\n");
5432         return;
5433     case 0: /* unlinked address match */
5434     case 1: /* linked address match */
5435     {
5436         /* Bits [63:49] are hardwired to the value of bit [48]; that is,
5437          * we behave as if the register was sign extended. Bits [1:0] are
5438          * RES0. The BAS field is used to allow setting breakpoints on 16
5439          * bit wide instructions; it is CONSTRAINED UNPREDICTABLE whether
5440          * a bp will fire if the addresses covered by the bp and the addresses
5441          * covered by the insn overlap but the insn doesn't start at the
5442          * start of the bp address range. We choose to require the insn and
5443          * the bp to have the same address. The constraints on writing to
5444          * BAS enforced in dbgbcr_write mean we have only four cases:
5445          *  0b0000  => no breakpoint
5446          *  0b0011  => breakpoint on addr
5447          *  0b1100  => breakpoint on addr + 2
5448          *  0b1111  => breakpoint on addr
5449          * See also figure D2-3 in the v8 ARM ARM (DDI0487A.c).
5450          */
5451         int bas = extract64(bcr, 5, 4);
5452         addr = sextract64(bvr, 0, 49) & ~3ULL;
5453         if (bas == 0) {
5454             return;
5455         }
5456         if (bas == 0xc) {
5457             addr += 2;
5458         }
5459         break;
5460     }
5461     case 2: /* unlinked context ID match */
5462     case 8: /* unlinked VMID match (reserved if no EL2) */
5463     case 10: /* unlinked context ID and VMID match (reserved if no EL2) */
5464         qemu_log_mask(LOG_UNIMP,
5465                       "arm: unlinked context breakpoint types not implemented\n");
5466         return;
5467     case 9: /* linked VMID match (reserved if no EL2) */
5468     case 11: /* linked context ID and VMID match (reserved if no EL2) */
5469     case 3: /* linked context ID match */
5470     default:
5471         /* We must generate no events for Linked context matches (unless
5472          * they are linked to by some other bp/wp, which is handled in
5473          * updates for the linking bp/wp). We choose to also generate no events
5474          * for reserved values.
5475          */
5476         return;
5477     }
5478
5479     cpu_breakpoint_insert(CPU(cpu), addr, flags, &env->cpu_breakpoint[n]);
5480 }
5481
5482 void hw_breakpoint_update_all(ARMCPU *cpu)
5483 {
5484     int i;
5485     CPUARMState *env = &cpu->env;
5486
5487     /* Completely clear out existing QEMU breakpoints and our array, to
5488      * avoid possible stale entries following migration load.
5489      */
5490     cpu_breakpoint_remove_all(CPU(cpu), BP_CPU);
5491     memset(env->cpu_breakpoint, 0, sizeof(env->cpu_breakpoint));
5492
5493     for (i = 0; i < ARRAY_SIZE(cpu->env.cpu_breakpoint); i++) {
5494         hw_breakpoint_update(cpu, i);
5495     }
5496 }
5497
5498 static void dbgbvr_write(CPUARMState *env, const ARMCPRegInfo *ri,
5499                          uint64_t value)
5500 {
5501     ARMCPU *cpu = arm_env_get_cpu(env);
5502     int i = ri->crm;
5503
5504     raw_write(env, ri, value);
5505     hw_breakpoint_update(cpu, i);
5506 }
5507
5508 static void dbgbcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
5509                          uint64_t value)
5510 {
5511     ARMCPU *cpu = arm_env_get_cpu(env);
5512     int i = ri->crm;
5513
5514     /* BAS[3] is a read-only copy of BAS[2], and BAS[1] a read-only
5515      * copy of BAS[0].
5516      */
5517     value = deposit64(value, 6, 1, extract64(value, 5, 1));
5518     value = deposit64(value, 8, 1, extract64(value, 7, 1));
5519
5520     raw_write(env, ri, value);
5521     hw_breakpoint_update(cpu, i);
5522 }
5523
5524 static void define_debug_regs(ARMCPU *cpu)
5525 {
5526     /* Define v7 and v8 architectural debug registers.
5527      * These are just dummy implementations for now.
5528      */
5529     int i;
5530     int wrps, brps, ctx_cmps;
5531     ARMCPRegInfo dbgdidr = {
5532         .name = "DBGDIDR", .cp = 14, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 0,
5533         .access = PL0_R, .accessfn = access_tda,
5534         .type = ARM_CP_CONST, .resetvalue = cpu->dbgdidr,
5535     };
5536
5537     /* Note that all these register fields hold "number of Xs minus 1". */
5538     brps = extract32(cpu->dbgdidr, 24, 4);
5539     wrps = extract32(cpu->dbgdidr, 28, 4);
5540     ctx_cmps = extract32(cpu->dbgdidr, 20, 4);
5541
5542     assert(ctx_cmps <= brps);
5543
5544     /* The DBGDIDR and ID_AA64DFR0_EL1 define various properties
5545      * of the debug registers such as number of breakpoints;
5546      * check that if they both exist then they agree.
5547      */
5548     if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
5549         assert(extract32(cpu->id_aa64dfr0, 12, 4) == brps);
5550         assert(extract32(cpu->id_aa64dfr0, 20, 4) == wrps);
5551         assert(extract32(cpu->id_aa64dfr0, 28, 4) == ctx_cmps);
5552     }
5553
5554     define_one_arm_cp_reg(cpu, &dbgdidr);
5555     define_arm_cp_regs(cpu, debug_cp_reginfo);
5556
5557     if (arm_feature(&cpu->env, ARM_FEATURE_LPAE)) {
5558         define_arm_cp_regs(cpu, debug_lpae_cp_reginfo);
5559     }
5560
5561     for (i = 0; i < brps + 1; i++) {
5562         ARMCPRegInfo dbgregs[] = {
5563             { .name = "DBGBVR", .state = ARM_CP_STATE_BOTH,
5564               .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 4,
5565               .access = PL1_RW, .accessfn = access_tda,
5566               .fieldoffset = offsetof(CPUARMState, cp15.dbgbvr[i]),
5567               .writefn = dbgbvr_write, .raw_writefn = raw_write
5568             },
5569             { .name = "DBGBCR", .state = ARM_CP_STATE_BOTH,
5570               .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 5,
5571               .access = PL1_RW, .accessfn = access_tda,
5572               .fieldoffset = offsetof(CPUARMState, cp15.dbgbcr[i]),
5573               .writefn = dbgbcr_write, .raw_writefn = raw_write
5574             },
5575             REGINFO_SENTINEL
5576         };
5577         define_arm_cp_regs(cpu, dbgregs);
5578     }
5579
5580     for (i = 0; i < wrps + 1; i++) {
5581         ARMCPRegInfo dbgregs[] = {
5582             { .name = "DBGWVR", .state = ARM_CP_STATE_BOTH,
5583               .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 6,
5584               .access = PL1_RW, .accessfn = access_tda,
5585               .fieldoffset = offsetof(CPUARMState, cp15.dbgwvr[i]),
5586               .writefn = dbgwvr_write, .raw_writefn = raw_write
5587             },
5588             { .name = "DBGWCR", .state = ARM_CP_STATE_BOTH,
5589               .cp = 14, .opc0 = 2, .opc1 = 0, .crn = 0, .crm = i, .opc2 = 7,
5590               .access = PL1_RW, .accessfn = access_tda,
5591               .fieldoffset = offsetof(CPUARMState, cp15.dbgwcr[i]),
5592               .writefn = dbgwcr_write, .raw_writefn = raw_write
5593             },
5594             REGINFO_SENTINEL
5595         };
5596         define_arm_cp_regs(cpu, dbgregs);
5597     }
5598 }
5599
5600 /* We don't know until after realize whether there's a GICv3
5601  * attached, and that is what registers the gicv3 sysregs.
5602  * So we have to fill in the GIC fields in ID_PFR/ID_PFR1_EL1/ID_AA64PFR0_EL1
5603  * at runtime.
5604  */
5605 static uint64_t id_pfr1_read(CPUARMState *env, const ARMCPRegInfo *ri)
5606 {
5607     ARMCPU *cpu = arm_env_get_cpu(env);
5608     uint64_t pfr1 = cpu->id_pfr1;
5609
5610     if (env->gicv3state) {
5611         pfr1 |= 1 << 28;
5612     }
5613     return pfr1;
5614 }
5615
5616 static uint64_t id_aa64pfr0_read(CPUARMState *env, const ARMCPRegInfo *ri)
5617 {
5618     ARMCPU *cpu = arm_env_get_cpu(env);
5619     uint64_t pfr0 = cpu->isar.id_aa64pfr0;
5620
5621     if (env->gicv3state) {
5622         pfr0 |= 1 << 24;
5623     }
5624     return pfr0;
5625 }
5626
5627 /* Shared logic between LORID and the rest of the LOR* registers.
5628  * Secure state has already been delt with.
5629  */
5630 static CPAccessResult access_lor_ns(CPUARMState *env)
5631 {
5632     int el = arm_current_el(env);
5633
5634     if (el < 2 && (arm_hcr_el2_eff(env) & HCR_TLOR)) {
5635         return CP_ACCESS_TRAP_EL2;
5636     }
5637     if (el < 3 && (env->cp15.scr_el3 & SCR_TLOR)) {
5638         return CP_ACCESS_TRAP_EL3;
5639     }
5640     return CP_ACCESS_OK;
5641 }
5642
5643 static CPAccessResult access_lorid(CPUARMState *env, const ARMCPRegInfo *ri,
5644                                    bool isread)
5645 {
5646     if (arm_is_secure_below_el3(env)) {
5647         /* Access ok in secure mode.  */
5648         return CP_ACCESS_OK;
5649     }
5650     return access_lor_ns(env);
5651 }
5652
5653 static CPAccessResult access_lor_other(CPUARMState *env,
5654                                        const ARMCPRegInfo *ri, bool isread)
5655 {
5656     if (arm_is_secure_below_el3(env)) {
5657         /* Access denied in secure mode.  */
5658         return CP_ACCESS_TRAP;
5659     }
5660     return access_lor_ns(env);
5661 }
5662
5663 #ifdef TARGET_AARCH64
5664 static CPAccessResult access_pauth(CPUARMState *env, const ARMCPRegInfo *ri,
5665                                    bool isread)
5666 {
5667     int el = arm_current_el(env);
5668
5669     if (el < 2 &&
5670         arm_feature(env, ARM_FEATURE_EL2) &&
5671         !(arm_hcr_el2_eff(env) & HCR_APK)) {
5672         return CP_ACCESS_TRAP_EL2;
5673     }
5674     if (el < 3 &&
5675         arm_feature(env, ARM_FEATURE_EL3) &&
5676         !(env->cp15.scr_el3 & SCR_APK)) {
5677         return CP_ACCESS_TRAP_EL3;
5678     }
5679     return CP_ACCESS_OK;
5680 }
5681
5682 static const ARMCPRegInfo pauth_reginfo[] = {
5683     { .name = "APDAKEYLO_EL1", .state = ARM_CP_STATE_AA64,
5684       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 2, .opc2 = 0,
5685       .access = PL1_RW, .accessfn = access_pauth,
5686       .fieldoffset = offsetof(CPUARMState, apda_key.lo) },
5687     { .name = "APDAKEYHI_EL1", .state = ARM_CP_STATE_AA64,
5688       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 2, .opc2 = 1,
5689       .access = PL1_RW, .accessfn = access_pauth,
5690       .fieldoffset = offsetof(CPUARMState, apda_key.hi) },
5691     { .name = "APDBKEYLO_EL1", .state = ARM_CP_STATE_AA64,
5692       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 2, .opc2 = 2,
5693       .access = PL1_RW, .accessfn = access_pauth,
5694       .fieldoffset = offsetof(CPUARMState, apdb_key.lo) },
5695     { .name = "APDBKEYHI_EL1", .state = ARM_CP_STATE_AA64,
5696       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 2, .opc2 = 3,
5697       .access = PL1_RW, .accessfn = access_pauth,
5698       .fieldoffset = offsetof(CPUARMState, apdb_key.hi) },
5699     { .name = "APGAKEYLO_EL1", .state = ARM_CP_STATE_AA64,
5700       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 3, .opc2 = 0,
5701       .access = PL1_RW, .accessfn = access_pauth,
5702       .fieldoffset = offsetof(CPUARMState, apga_key.lo) },
5703     { .name = "APGAKEYHI_EL1", .state = ARM_CP_STATE_AA64,
5704       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 3, .opc2 = 1,
5705       .access = PL1_RW, .accessfn = access_pauth,
5706       .fieldoffset = offsetof(CPUARMState, apga_key.hi) },
5707     { .name = "APIAKEYLO_EL1", .state = ARM_CP_STATE_AA64,
5708       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 1, .opc2 = 0,
5709       .access = PL1_RW, .accessfn = access_pauth,
5710       .fieldoffset = offsetof(CPUARMState, apia_key.lo) },
5711     { .name = "APIAKEYHI_EL1", .state = ARM_CP_STATE_AA64,
5712       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 1, .opc2 = 1,
5713       .access = PL1_RW, .accessfn = access_pauth,
5714       .fieldoffset = offsetof(CPUARMState, apia_key.hi) },
5715     { .name = "APIBKEYLO_EL1", .state = ARM_CP_STATE_AA64,
5716       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 1, .opc2 = 2,
5717       .access = PL1_RW, .accessfn = access_pauth,
5718       .fieldoffset = offsetof(CPUARMState, apib_key.lo) },
5719     { .name = "APIBKEYHI_EL1", .state = ARM_CP_STATE_AA64,
5720       .opc0 = 3, .opc1 = 0, .crn = 2, .crm = 1, .opc2 = 3,
5721       .access = PL1_RW, .accessfn = access_pauth,
5722       .fieldoffset = offsetof(CPUARMState, apib_key.hi) },
5723     REGINFO_SENTINEL
5724 };
5725 #endif
5726
5727 static CPAccessResult access_predinv(CPUARMState *env, const ARMCPRegInfo *ri,
5728                                      bool isread)
5729 {
5730     int el = arm_current_el(env);
5731
5732     if (el == 0) {
5733         uint64_t sctlr = arm_sctlr(env, el);
5734         if (!(sctlr & SCTLR_EnRCTX)) {
5735             return CP_ACCESS_TRAP;
5736         }
5737     } else if (el == 1) {
5738         uint64_t hcr = arm_hcr_el2_eff(env);
5739         if (hcr & HCR_NV) {
5740             return CP_ACCESS_TRAP_EL2;
5741         }
5742     }
5743     return CP_ACCESS_OK;
5744 }
5745
5746 static const ARMCPRegInfo predinv_reginfo[] = {
5747     { .name = "CFP_RCTX", .state = ARM_CP_STATE_AA64,
5748       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 3, .opc2 = 4,
5749       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5750     { .name = "DVP_RCTX", .state = ARM_CP_STATE_AA64,
5751       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 3, .opc2 = 5,
5752       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5753     { .name = "CPP_RCTX", .state = ARM_CP_STATE_AA64,
5754       .opc0 = 1, .opc1 = 3, .crn = 7, .crm = 3, .opc2 = 7,
5755       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5756     /*
5757      * Note the AArch32 opcodes have a different OPC1.
5758      */
5759     { .name = "CFPRCTX", .state = ARM_CP_STATE_AA32,
5760       .cp = 15, .opc1 = 0, .crn = 7, .crm = 3, .opc2 = 4,
5761       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5762     { .name = "DVPRCTX", .state = ARM_CP_STATE_AA32,
5763       .cp = 15, .opc1 = 0, .crn = 7, .crm = 3, .opc2 = 5,
5764       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5765     { .name = "CPPRCTX", .state = ARM_CP_STATE_AA32,
5766       .cp = 15, .opc1 = 0, .crn = 7, .crm = 3, .opc2 = 7,
5767       .type = ARM_CP_NOP, .access = PL0_W, .accessfn = access_predinv },
5768     REGINFO_SENTINEL
5769 };
5770
5771 void register_cp_regs_for_features(ARMCPU *cpu)
5772 {
5773     /* Register all the coprocessor registers based on feature bits */
5774     CPUARMState *env = &cpu->env;
5775     if (arm_feature(env, ARM_FEATURE_M)) {
5776         /* M profile has no coprocessor registers */
5777         return;
5778     }
5779
5780     define_arm_cp_regs(cpu, cp_reginfo);
5781     if (!arm_feature(env, ARM_FEATURE_V8)) {
5782         /* Must go early as it is full of wildcards that may be
5783          * overridden by later definitions.
5784          */
5785         define_arm_cp_regs(cpu, not_v8_cp_reginfo);
5786     }
5787
5788     if (arm_feature(env, ARM_FEATURE_V6)) {
5789         /* The ID registers all have impdef reset values */
5790         ARMCPRegInfo v6_idregs[] = {
5791             { .name = "ID_PFR0", .state = ARM_CP_STATE_BOTH,
5792               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 0,
5793               .access = PL1_R, .type = ARM_CP_CONST,
5794               .resetvalue = cpu->id_pfr0 },
5795             /* ID_PFR1 is not a plain ARM_CP_CONST because we don't know
5796              * the value of the GIC field until after we define these regs.
5797              */
5798             { .name = "ID_PFR1", .state = ARM_CP_STATE_BOTH,
5799               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 1,
5800               .access = PL1_R, .type = ARM_CP_NO_RAW,
5801               .readfn = id_pfr1_read,
5802               .writefn = arm_cp_write_ignore },
5803             { .name = "ID_DFR0", .state = ARM_CP_STATE_BOTH,
5804               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 2,
5805               .access = PL1_R, .type = ARM_CP_CONST,
5806               .resetvalue = cpu->id_dfr0 },
5807             { .name = "ID_AFR0", .state = ARM_CP_STATE_BOTH,
5808               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 3,
5809               .access = PL1_R, .type = ARM_CP_CONST,
5810               .resetvalue = cpu->id_afr0 },
5811             { .name = "ID_MMFR0", .state = ARM_CP_STATE_BOTH,
5812               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 4,
5813               .access = PL1_R, .type = ARM_CP_CONST,
5814               .resetvalue = cpu->id_mmfr0 },
5815             { .name = "ID_MMFR1", .state = ARM_CP_STATE_BOTH,
5816               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 5,
5817               .access = PL1_R, .type = ARM_CP_CONST,
5818               .resetvalue = cpu->id_mmfr1 },
5819             { .name = "ID_MMFR2", .state = ARM_CP_STATE_BOTH,
5820               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 6,
5821               .access = PL1_R, .type = ARM_CP_CONST,
5822               .resetvalue = cpu->id_mmfr2 },
5823             { .name = "ID_MMFR3", .state = ARM_CP_STATE_BOTH,
5824               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 1, .opc2 = 7,
5825               .access = PL1_R, .type = ARM_CP_CONST,
5826               .resetvalue = cpu->id_mmfr3 },
5827             { .name = "ID_ISAR0", .state = ARM_CP_STATE_BOTH,
5828               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 0,
5829               .access = PL1_R, .type = ARM_CP_CONST,
5830               .resetvalue = cpu->isar.id_isar0 },
5831             { .name = "ID_ISAR1", .state = ARM_CP_STATE_BOTH,
5832               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 1,
5833               .access = PL1_R, .type = ARM_CP_CONST,
5834               .resetvalue = cpu->isar.id_isar1 },
5835             { .name = "ID_ISAR2", .state = ARM_CP_STATE_BOTH,
5836               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 2,
5837               .access = PL1_R, .type = ARM_CP_CONST,
5838               .resetvalue = cpu->isar.id_isar2 },
5839             { .name = "ID_ISAR3", .state = ARM_CP_STATE_BOTH,
5840               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 3,
5841               .access = PL1_R, .type = ARM_CP_CONST,
5842               .resetvalue = cpu->isar.id_isar3 },
5843             { .name = "ID_ISAR4", .state = ARM_CP_STATE_BOTH,
5844               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 4,
5845               .access = PL1_R, .type = ARM_CP_CONST,
5846               .resetvalue = cpu->isar.id_isar4 },
5847             { .name = "ID_ISAR5", .state = ARM_CP_STATE_BOTH,
5848               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 5,
5849               .access = PL1_R, .type = ARM_CP_CONST,
5850               .resetvalue = cpu->isar.id_isar5 },
5851             { .name = "ID_MMFR4", .state = ARM_CP_STATE_BOTH,
5852               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 6,
5853               .access = PL1_R, .type = ARM_CP_CONST,
5854               .resetvalue = cpu->id_mmfr4 },
5855             { .name = "ID_ISAR6", .state = ARM_CP_STATE_BOTH,
5856               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 2, .opc2 = 7,
5857               .access = PL1_R, .type = ARM_CP_CONST,
5858               .resetvalue = cpu->isar.id_isar6 },
5859             REGINFO_SENTINEL
5860         };
5861         define_arm_cp_regs(cpu, v6_idregs);
5862         define_arm_cp_regs(cpu, v6_cp_reginfo);
5863     } else {
5864         define_arm_cp_regs(cpu, not_v6_cp_reginfo);
5865     }
5866     if (arm_feature(env, ARM_FEATURE_V6K)) {
5867         define_arm_cp_regs(cpu, v6k_cp_reginfo);
5868     }
5869     if (arm_feature(env, ARM_FEATURE_V7MP) &&
5870         !arm_feature(env, ARM_FEATURE_PMSA)) {
5871         define_arm_cp_regs(cpu, v7mp_cp_reginfo);
5872     }
5873     if (arm_feature(env, ARM_FEATURE_V7VE)) {
5874         define_arm_cp_regs(cpu, pmovsset_cp_reginfo);
5875     }
5876     if (arm_feature(env, ARM_FEATURE_V7)) {
5877         /* v7 performance monitor control register: same implementor
5878          * field as main ID register, and we implement four counters in
5879          * addition to the cycle count register.
5880          */
5881         unsigned int i, pmcrn = 4;
5882         ARMCPRegInfo pmcr = {
5883             .name = "PMCR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 0,
5884             .access = PL0_RW,
5885             .type = ARM_CP_IO | ARM_CP_ALIAS,
5886             .fieldoffset = offsetoflow32(CPUARMState, cp15.c9_pmcr),
5887             .accessfn = pmreg_access, .writefn = pmcr_write,
5888             .raw_writefn = raw_write,
5889         };
5890         ARMCPRegInfo pmcr64 = {
5891             .name = "PMCR_EL0", .state = ARM_CP_STATE_AA64,
5892             .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 0,
5893             .access = PL0_RW, .accessfn = pmreg_access,
5894             .type = ARM_CP_IO,
5895             .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcr),
5896             .resetvalue = (cpu->midr & 0xff000000) | (pmcrn << PMCRN_SHIFT),
5897             .writefn = pmcr_write, .raw_writefn = raw_write,
5898         };
5899         define_one_arm_cp_reg(cpu, &pmcr);
5900         define_one_arm_cp_reg(cpu, &pmcr64);
5901         for (i = 0; i < pmcrn; i++) {
5902             char *pmevcntr_name = g_strdup_printf("PMEVCNTR%d", i);
5903             char *pmevcntr_el0_name = g_strdup_printf("PMEVCNTR%d_EL0", i);
5904             char *pmevtyper_name = g_strdup_printf("PMEVTYPER%d", i);
5905             char *pmevtyper_el0_name = g_strdup_printf("PMEVTYPER%d_EL0", i);
5906             ARMCPRegInfo pmev_regs[] = {
5907                 { .name = pmevcntr_name, .cp = 15, .crn = 14,
5908                   .crm = 8 | (3 & (i >> 3)), .opc1 = 0, .opc2 = i & 7,
5909                   .access = PL0_RW, .type = ARM_CP_IO | ARM_CP_ALIAS,
5910                   .readfn = pmevcntr_readfn, .writefn = pmevcntr_writefn,
5911                   .accessfn = pmreg_access },
5912                 { .name = pmevcntr_el0_name, .state = ARM_CP_STATE_AA64,
5913                   .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 8 | (3 & (i >> 3)),
5914                   .opc2 = i & 7, .access = PL0_RW, .accessfn = pmreg_access,
5915                   .type = ARM_CP_IO,
5916                   .readfn = pmevcntr_readfn, .writefn = pmevcntr_writefn,
5917                   .raw_readfn = pmevcntr_rawread,
5918                   .raw_writefn = pmevcntr_rawwrite },
5919                 { .name = pmevtyper_name, .cp = 15, .crn = 14,
5920                   .crm = 12 | (3 & (i >> 3)), .opc1 = 0, .opc2 = i & 7,
5921                   .access = PL0_RW, .type = ARM_CP_IO | ARM_CP_ALIAS,
5922                   .readfn = pmevtyper_readfn, .writefn = pmevtyper_writefn,
5923                   .accessfn = pmreg_access },
5924                 { .name = pmevtyper_el0_name, .state = ARM_CP_STATE_AA64,
5925                   .opc0 = 3, .opc1 = 3, .crn = 14, .crm = 12 | (3 & (i >> 3)),
5926                   .opc2 = i & 7, .access = PL0_RW, .accessfn = pmreg_access,
5927                   .type = ARM_CP_IO,
5928                   .readfn = pmevtyper_readfn, .writefn = pmevtyper_writefn,
5929                   .raw_writefn = pmevtyper_rawwrite },
5930                 REGINFO_SENTINEL
5931             };
5932             define_arm_cp_regs(cpu, pmev_regs);
5933             g_free(pmevcntr_name);
5934             g_free(pmevcntr_el0_name);
5935             g_free(pmevtyper_name);
5936             g_free(pmevtyper_el0_name);
5937         }
5938         ARMCPRegInfo clidr = {
5939             .name = "CLIDR", .state = ARM_CP_STATE_BOTH,
5940             .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = 1,
5941             .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = cpu->clidr
5942         };
5943         define_one_arm_cp_reg(cpu, &clidr);
5944         define_arm_cp_regs(cpu, v7_cp_reginfo);
5945         define_debug_regs(cpu);
5946     } else {
5947         define_arm_cp_regs(cpu, not_v7_cp_reginfo);
5948     }
5949     if (FIELD_EX32(cpu->id_dfr0, ID_DFR0, PERFMON) >= 4 &&
5950             FIELD_EX32(cpu->id_dfr0, ID_DFR0, PERFMON) != 0xf) {
5951         ARMCPRegInfo v81_pmu_regs[] = {
5952             { .name = "PMCEID2", .state = ARM_CP_STATE_AA32,
5953               .cp = 15, .opc1 = 0, .crn = 9, .crm = 14, .opc2 = 4,
5954               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
5955               .resetvalue = extract64(cpu->pmceid0, 32, 32) },
5956             { .name = "PMCEID3", .state = ARM_CP_STATE_AA32,
5957               .cp = 15, .opc1 = 0, .crn = 9, .crm = 14, .opc2 = 5,
5958               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
5959               .resetvalue = extract64(cpu->pmceid1, 32, 32) },
5960             REGINFO_SENTINEL
5961         };
5962         define_arm_cp_regs(cpu, v81_pmu_regs);
5963     }
5964     if (arm_feature(env, ARM_FEATURE_V8)) {
5965         /* AArch64 ID registers, which all have impdef reset values.
5966          * Note that within the ID register ranges the unused slots
5967          * must all RAZ, not UNDEF; future architecture versions may
5968          * define new registers here.
5969          */
5970         ARMCPRegInfo v8_idregs[] = {
5971             /* ID_AA64PFR0_EL1 is not a plain ARM_CP_CONST because we don't
5972              * know the right value for the GIC field until after we
5973              * define these regs.
5974              */
5975             { .name = "ID_AA64PFR0_EL1", .state = ARM_CP_STATE_AA64,
5976               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 0,
5977               .access = PL1_R, .type = ARM_CP_NO_RAW,
5978               .readfn = id_aa64pfr0_read,
5979               .writefn = arm_cp_write_ignore },
5980             { .name = "ID_AA64PFR1_EL1", .state = ARM_CP_STATE_AA64,
5981               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 1,
5982               .access = PL1_R, .type = ARM_CP_CONST,
5983               .resetvalue = cpu->isar.id_aa64pfr1},
5984             { .name = "ID_AA64PFR2_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
5985               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 2,
5986               .access = PL1_R, .type = ARM_CP_CONST,
5987               .resetvalue = 0 },
5988             { .name = "ID_AA64PFR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
5989               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 3,
5990               .access = PL1_R, .type = ARM_CP_CONST,
5991               .resetvalue = 0 },
5992             { .name = "ID_AA64ZFR0_EL1", .state = ARM_CP_STATE_AA64,
5993               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 4,
5994               .access = PL1_R, .type = ARM_CP_CONST,
5995               /* At present, only SVEver == 0 is defined anyway.  */
5996               .resetvalue = 0 },
5997             { .name = "ID_AA64PFR5_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
5998               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 5,
5999               .access = PL1_R, .type = ARM_CP_CONST,
6000               .resetvalue = 0 },
6001             { .name = "ID_AA64PFR6_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6002               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 6,
6003               .access = PL1_R, .type = ARM_CP_CONST,
6004               .resetvalue = 0 },
6005             { .name = "ID_AA64PFR7_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6006               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 4, .opc2 = 7,
6007               .access = PL1_R, .type = ARM_CP_CONST,
6008               .resetvalue = 0 },
6009             { .name = "ID_AA64DFR0_EL1", .state = ARM_CP_STATE_AA64,
6010               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 0,
6011               .access = PL1_R, .type = ARM_CP_CONST,
6012               .resetvalue = cpu->id_aa64dfr0 },
6013             { .name = "ID_AA64DFR1_EL1", .state = ARM_CP_STATE_AA64,
6014               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 1,
6015               .access = PL1_R, .type = ARM_CP_CONST,
6016               .resetvalue = cpu->id_aa64dfr1 },
6017             { .name = "ID_AA64DFR2_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6018               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 2,
6019               .access = PL1_R, .type = ARM_CP_CONST,
6020               .resetvalue = 0 },
6021             { .name = "ID_AA64DFR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6022               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 3,
6023               .access = PL1_R, .type = ARM_CP_CONST,
6024               .resetvalue = 0 },
6025             { .name = "ID_AA64AFR0_EL1", .state = ARM_CP_STATE_AA64,
6026               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 4,
6027               .access = PL1_R, .type = ARM_CP_CONST,
6028               .resetvalue = cpu->id_aa64afr0 },
6029             { .name = "ID_AA64AFR1_EL1", .state = ARM_CP_STATE_AA64,
6030               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 5,
6031               .access = PL1_R, .type = ARM_CP_CONST,
6032               .resetvalue = cpu->id_aa64afr1 },
6033             { .name = "ID_AA64AFR2_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6034               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 6,
6035               .access = PL1_R, .type = ARM_CP_CONST,
6036               .resetvalue = 0 },
6037             { .name = "ID_AA64AFR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6038               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 5, .opc2 = 7,
6039               .access = PL1_R, .type = ARM_CP_CONST,
6040               .resetvalue = 0 },
6041             { .name = "ID_AA64ISAR0_EL1", .state = ARM_CP_STATE_AA64,
6042               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 0,
6043               .access = PL1_R, .type = ARM_CP_CONST,
6044               .resetvalue = cpu->isar.id_aa64isar0 },
6045             { .name = "ID_AA64ISAR1_EL1", .state = ARM_CP_STATE_AA64,
6046               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 1,
6047               .access = PL1_R, .type = ARM_CP_CONST,
6048               .resetvalue = cpu->isar.id_aa64isar1 },
6049             { .name = "ID_AA64ISAR2_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6050               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 2,
6051               .access = PL1_R, .type = ARM_CP_CONST,
6052               .resetvalue = 0 },
6053             { .name = "ID_AA64ISAR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6054               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 3,
6055               .access = PL1_R, .type = ARM_CP_CONST,
6056               .resetvalue = 0 },
6057             { .name = "ID_AA64ISAR4_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6058               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 4,
6059               .access = PL1_R, .type = ARM_CP_CONST,
6060               .resetvalue = 0 },
6061             { .name = "ID_AA64ISAR5_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6062               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 5,
6063               .access = PL1_R, .type = ARM_CP_CONST,
6064               .resetvalue = 0 },
6065             { .name = "ID_AA64ISAR6_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6066               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 6,
6067               .access = PL1_R, .type = ARM_CP_CONST,
6068               .resetvalue = 0 },
6069             { .name = "ID_AA64ISAR7_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6070               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 6, .opc2 = 7,
6071               .access = PL1_R, .type = ARM_CP_CONST,
6072               .resetvalue = 0 },
6073             { .name = "ID_AA64MMFR0_EL1", .state = ARM_CP_STATE_AA64,
6074               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 0,
6075               .access = PL1_R, .type = ARM_CP_CONST,
6076               .resetvalue = cpu->isar.id_aa64mmfr0 },
6077             { .name = "ID_AA64MMFR1_EL1", .state = ARM_CP_STATE_AA64,
6078               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 1,
6079               .access = PL1_R, .type = ARM_CP_CONST,
6080               .resetvalue = cpu->isar.id_aa64mmfr1 },
6081             { .name = "ID_AA64MMFR2_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6082               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 2,
6083               .access = PL1_R, .type = ARM_CP_CONST,
6084               .resetvalue = 0 },
6085             { .name = "ID_AA64MMFR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6086               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 3,
6087               .access = PL1_R, .type = ARM_CP_CONST,
6088               .resetvalue = 0 },
6089             { .name = "ID_AA64MMFR4_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6090               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 4,
6091               .access = PL1_R, .type = ARM_CP_CONST,
6092               .resetvalue = 0 },
6093             { .name = "ID_AA64MMFR5_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6094               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 5,
6095               .access = PL1_R, .type = ARM_CP_CONST,
6096               .resetvalue = 0 },
6097             { .name = "ID_AA64MMFR6_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6098               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 6,
6099               .access = PL1_R, .type = ARM_CP_CONST,
6100               .resetvalue = 0 },
6101             { .name = "ID_AA64MMFR7_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6102               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 7, .opc2 = 7,
6103               .access = PL1_R, .type = ARM_CP_CONST,
6104               .resetvalue = 0 },
6105             { .name = "MVFR0_EL1", .state = ARM_CP_STATE_AA64,
6106               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 0,
6107               .access = PL1_R, .type = ARM_CP_CONST,
6108               .resetvalue = cpu->isar.mvfr0 },
6109             { .name = "MVFR1_EL1", .state = ARM_CP_STATE_AA64,
6110               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 1,
6111               .access = PL1_R, .type = ARM_CP_CONST,
6112               .resetvalue = cpu->isar.mvfr1 },
6113             { .name = "MVFR2_EL1", .state = ARM_CP_STATE_AA64,
6114               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 2,
6115               .access = PL1_R, .type = ARM_CP_CONST,
6116               .resetvalue = cpu->isar.mvfr2 },
6117             { .name = "MVFR3_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6118               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 3,
6119               .access = PL1_R, .type = ARM_CP_CONST,
6120               .resetvalue = 0 },
6121             { .name = "MVFR4_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6122               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 4,
6123               .access = PL1_R, .type = ARM_CP_CONST,
6124               .resetvalue = 0 },
6125             { .name = "MVFR5_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6126               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 5,
6127               .access = PL1_R, .type = ARM_CP_CONST,
6128               .resetvalue = 0 },
6129             { .name = "MVFR6_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6130               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 6,
6131               .access = PL1_R, .type = ARM_CP_CONST,
6132               .resetvalue = 0 },
6133             { .name = "MVFR7_EL1_RESERVED", .state = ARM_CP_STATE_AA64,
6134               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 3, .opc2 = 7,
6135               .access = PL1_R, .type = ARM_CP_CONST,
6136               .resetvalue = 0 },
6137             { .name = "PMCEID0", .state = ARM_CP_STATE_AA32,
6138               .cp = 15, .opc1 = 0, .crn = 9, .crm = 12, .opc2 = 6,
6139               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
6140               .resetvalue = extract64(cpu->pmceid0, 0, 32) },
6141             { .name = "PMCEID0_EL0", .state = ARM_CP_STATE_AA64,
6142               .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 6,
6143               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
6144               .resetvalue = cpu->pmceid0 },
6145             { .name = "PMCEID1", .state = ARM_CP_STATE_AA32,
6146               .cp = 15, .opc1 = 0, .crn = 9, .crm = 12, .opc2 = 7,
6147               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
6148               .resetvalue = extract64(cpu->pmceid1, 0, 32) },
6149             { .name = "PMCEID1_EL0", .state = ARM_CP_STATE_AA64,
6150               .opc0 = 3, .opc1 = 3, .crn = 9, .crm = 12, .opc2 = 7,
6151               .access = PL0_R, .accessfn = pmreg_access, .type = ARM_CP_CONST,
6152               .resetvalue = cpu->pmceid1 },
6153             REGINFO_SENTINEL
6154         };
6155 #ifdef CONFIG_USER_ONLY
6156         ARMCPRegUserSpaceInfo v8_user_idregs[] = {
6157             { .name = "ID_AA64PFR0_EL1",
6158               .exported_bits = 0x000f000f00ff0000,
6159               .fixed_bits    = 0x0000000000000011 },
6160             { .name = "ID_AA64PFR1_EL1",
6161               .exported_bits = 0x00000000000000f0 },
6162             { .name = "ID_AA64PFR*_EL1_RESERVED",
6163               .is_glob = true                     },
6164             { .name = "ID_AA64ZFR0_EL1"           },
6165             { .name = "ID_AA64MMFR0_EL1",
6166               .fixed_bits    = 0x00000000ff000000 },
6167             { .name = "ID_AA64MMFR1_EL1"          },
6168             { .name = "ID_AA64MMFR*_EL1_RESERVED",
6169               .is_glob = true                     },
6170             { .name = "ID_AA64DFR0_EL1",
6171               .fixed_bits    = 0x0000000000000006 },
6172             { .name = "ID_AA64DFR1_EL1"           },
6173             { .name = "ID_AA64DFR*_EL1_RESERVED",
6174               .is_glob = true                     },
6175             { .name = "ID_AA64AFR*",
6176               .is_glob = true                     },
6177             { .name = "ID_AA64ISAR0_EL1",
6178               .exported_bits = 0x00fffffff0fffff0 },
6179             { .name = "ID_AA64ISAR1_EL1",
6180               .exported_bits = 0x000000f0ffffffff },
6181             { .name = "ID_AA64ISAR*_EL1_RESERVED",
6182               .is_glob = true                     },
6183             REGUSERINFO_SENTINEL
6184         };
6185         modify_arm_cp_regs(v8_idregs, v8_user_idregs);
6186 #endif
6187         /* RVBAR_EL1 is only implemented if EL1 is the highest EL */
6188         if (!arm_feature(env, ARM_FEATURE_EL3) &&
6189             !arm_feature(env, ARM_FEATURE_EL2)) {
6190             ARMCPRegInfo rvbar = {
6191                 .name = "RVBAR_EL1", .state = ARM_CP_STATE_AA64,
6192                 .opc0 = 3, .opc1 = 0, .crn = 12, .crm = 0, .opc2 = 1,
6193                 .type = ARM_CP_CONST, .access = PL1_R, .resetvalue = cpu->rvbar
6194             };
6195             define_one_arm_cp_reg(cpu, &rvbar);
6196         }
6197         define_arm_cp_regs(cpu, v8_idregs);
6198         define_arm_cp_regs(cpu, v8_cp_reginfo);
6199     }
6200     if (arm_feature(env, ARM_FEATURE_EL2)) {
6201         uint64_t vmpidr_def = mpidr_read_val(env);
6202         ARMCPRegInfo vpidr_regs[] = {
6203             { .name = "VPIDR", .state = ARM_CP_STATE_AA32,
6204               .cp = 15, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0,
6205               .access = PL2_RW, .accessfn = access_el3_aa32ns,
6206               .resetvalue = cpu->midr, .type = ARM_CP_ALIAS,
6207               .fieldoffset = offsetoflow32(CPUARMState, cp15.vpidr_el2) },
6208             { .name = "VPIDR_EL2", .state = ARM_CP_STATE_AA64,
6209               .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0,
6210               .access = PL2_RW, .resetvalue = cpu->midr,
6211               .fieldoffset = offsetof(CPUARMState, cp15.vpidr_el2) },
6212             { .name = "VMPIDR", .state = ARM_CP_STATE_AA32,
6213               .cp = 15, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5,
6214               .access = PL2_RW, .accessfn = access_el3_aa32ns,
6215               .resetvalue = vmpidr_def, .type = ARM_CP_ALIAS,
6216               .fieldoffset = offsetoflow32(CPUARMState, cp15.vmpidr_el2) },
6217             { .name = "VMPIDR_EL2", .state = ARM_CP_STATE_AA64,
6218               .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5,
6219               .access = PL2_RW,
6220               .resetvalue = vmpidr_def,
6221               .fieldoffset = offsetof(CPUARMState, cp15.vmpidr_el2) },
6222             REGINFO_SENTINEL
6223         };
6224         define_arm_cp_regs(cpu, vpidr_regs);
6225         define_arm_cp_regs(cpu, el2_cp_reginfo);
6226         if (arm_feature(env, ARM_FEATURE_V8)) {
6227             define_arm_cp_regs(cpu, el2_v8_cp_reginfo);
6228         }
6229         /* RVBAR_EL2 is only implemented if EL2 is the highest EL */
6230         if (!arm_feature(env, ARM_FEATURE_EL3)) {
6231             ARMCPRegInfo rvbar = {
6232                 .name = "RVBAR_EL2", .state = ARM_CP_STATE_AA64,
6233                 .opc0 = 3, .opc1 = 4, .crn = 12, .crm = 0, .opc2 = 1,
6234                 .type = ARM_CP_CONST, .access = PL2_R, .resetvalue = cpu->rvbar
6235             };
6236             define_one_arm_cp_reg(cpu, &rvbar);
6237         }
6238     } else {
6239         /* If EL2 is missing but higher ELs are enabled, we need to
6240          * register the no_el2 reginfos.
6241          */
6242         if (arm_feature(env, ARM_FEATURE_EL3)) {
6243             /* When EL3 exists but not EL2, VPIDR and VMPIDR take the value
6244              * of MIDR_EL1 and MPIDR_EL1.
6245              */
6246             ARMCPRegInfo vpidr_regs[] = {
6247                 { .name = "VPIDR_EL2", .state = ARM_CP_STATE_BOTH,
6248                   .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0,
6249                   .access = PL2_RW, .accessfn = access_el3_aa32ns_aa64any,
6250                   .type = ARM_CP_CONST, .resetvalue = cpu->midr,
6251                   .fieldoffset = offsetof(CPUARMState, cp15.vpidr_el2) },
6252                 { .name = "VMPIDR_EL2", .state = ARM_CP_STATE_BOTH,
6253                   .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5,
6254                   .access = PL2_RW, .accessfn = access_el3_aa32ns_aa64any,
6255                   .type = ARM_CP_NO_RAW,
6256                   .writefn = arm_cp_write_ignore, .readfn = mpidr_read },
6257                 REGINFO_SENTINEL
6258             };
6259             define_arm_cp_regs(cpu, vpidr_regs);
6260             define_arm_cp_regs(cpu, el3_no_el2_cp_reginfo);
6261             if (arm_feature(env, ARM_FEATURE_V8)) {
6262                 define_arm_cp_regs(cpu, el3_no_el2_v8_cp_reginfo);
6263             }
6264         }
6265     }
6266     if (arm_feature(env, ARM_FEATURE_EL3)) {
6267         define_arm_cp_regs(cpu, el3_cp_reginfo);
6268         ARMCPRegInfo el3_regs[] = {
6269             { .name = "RVBAR_EL3", .state = ARM_CP_STATE_AA64,
6270               .opc0 = 3, .opc1 = 6, .crn = 12, .crm = 0, .opc2 = 1,
6271               .type = ARM_CP_CONST, .access = PL3_R, .resetvalue = cpu->rvbar },
6272             { .name = "SCTLR_EL3", .state = ARM_CP_STATE_AA64,
6273               .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 0, .opc2 = 0,
6274               .access = PL3_RW,
6275               .raw_writefn = raw_write, .writefn = sctlr_write,
6276               .fieldoffset = offsetof(CPUARMState, cp15.sctlr_el[3]),
6277               .resetvalue = cpu->reset_sctlr },
6278             REGINFO_SENTINEL
6279         };
6280
6281         define_arm_cp_regs(cpu, el3_regs);
6282     }
6283     /* The behaviour of NSACR is sufficiently various that we don't
6284      * try to describe it in a single reginfo:
6285      *  if EL3 is 64 bit, then trap to EL3 from S EL1,
6286      *     reads as constant 0xc00 from NS EL1 and NS EL2
6287      *  if EL3 is 32 bit, then RW at EL3, RO at NS EL1 and NS EL2
6288      *  if v7 without EL3, register doesn't exist
6289      *  if v8 without EL3, reads as constant 0xc00 from NS EL1 and NS EL2
6290      */
6291     if (arm_feature(env, ARM_FEATURE_EL3)) {
6292         if (arm_feature(env, ARM_FEATURE_AARCH64)) {
6293             ARMCPRegInfo nsacr = {
6294                 .name = "NSACR", .type = ARM_CP_CONST,
6295                 .cp = 15, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 2,
6296                 .access = PL1_RW, .accessfn = nsacr_access,
6297                 .resetvalue = 0xc00
6298             };
6299             define_one_arm_cp_reg(cpu, &nsacr);
6300         } else {
6301             ARMCPRegInfo nsacr = {
6302                 .name = "NSACR",
6303                 .cp = 15, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 2,
6304                 .access = PL3_RW | PL1_R,
6305                 .resetvalue = 0,
6306                 .fieldoffset = offsetof(CPUARMState, cp15.nsacr)
6307             };
6308             define_one_arm_cp_reg(cpu, &nsacr);
6309         }
6310     } else {
6311         if (arm_feature(env, ARM_FEATURE_V8)) {
6312             ARMCPRegInfo nsacr = {
6313                 .name = "NSACR", .type = ARM_CP_CONST,
6314                 .cp = 15, .opc1 = 0, .crn = 1, .crm = 1, .opc2 = 2,
6315                 .access = PL1_R,
6316                 .resetvalue = 0xc00
6317             };
6318             define_one_arm_cp_reg(cpu, &nsacr);
6319         }
6320     }
6321
6322     if (arm_feature(env, ARM_FEATURE_PMSA)) {
6323         if (arm_feature(env, ARM_FEATURE_V6)) {
6324             /* PMSAv6 not implemented */
6325             assert(arm_feature(env, ARM_FEATURE_V7));
6326             define_arm_cp_regs(cpu, vmsa_pmsa_cp_reginfo);
6327             define_arm_cp_regs(cpu, pmsav7_cp_reginfo);
6328         } else {
6329             define_arm_cp_regs(cpu, pmsav5_cp_reginfo);
6330         }
6331     } else {
6332         define_arm_cp_regs(cpu, vmsa_pmsa_cp_reginfo);
6333         define_arm_cp_regs(cpu, vmsa_cp_reginfo);
6334         /* TTCBR2 is introduced with ARMv8.2-A32HPD.  */
6335         if (FIELD_EX32(cpu->id_mmfr4, ID_MMFR4, HPDS) != 0) {
6336             define_one_arm_cp_reg(cpu, &ttbcr2_reginfo);
6337         }
6338     }
6339     if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
6340         define_arm_cp_regs(cpu, t2ee_cp_reginfo);
6341     }
6342     if (arm_feature(env, ARM_FEATURE_GENERIC_TIMER)) {
6343         define_arm_cp_regs(cpu, generic_timer_cp_reginfo);
6344     }
6345     if (arm_feature(env, ARM_FEATURE_VAPA)) {
6346         define_arm_cp_regs(cpu, vapa_cp_reginfo);
6347     }
6348     if (arm_feature(env, ARM_FEATURE_CACHE_TEST_CLEAN)) {
6349         define_arm_cp_regs(cpu, cache_test_clean_cp_reginfo);
6350     }
6351     if (arm_feature(env, ARM_FEATURE_CACHE_DIRTY_REG)) {
6352         define_arm_cp_regs(cpu, cache_dirty_status_cp_reginfo);
6353     }
6354     if (arm_feature(env, ARM_FEATURE_CACHE_BLOCK_OPS)) {
6355         define_arm_cp_regs(cpu, cache_block_ops_cp_reginfo);
6356     }
6357     if (arm_feature(env, ARM_FEATURE_OMAPCP)) {
6358         define_arm_cp_regs(cpu, omap_cp_reginfo);
6359     }
6360     if (arm_feature(env, ARM_FEATURE_STRONGARM)) {
6361         define_arm_cp_regs(cpu, strongarm_cp_reginfo);
6362     }
6363     if (arm_feature(env, ARM_FEATURE_XSCALE)) {
6364         define_arm_cp_regs(cpu, xscale_cp_reginfo);
6365     }
6366     if (arm_feature(env, ARM_FEATURE_DUMMY_C15_REGS)) {
6367         define_arm_cp_regs(cpu, dummy_c15_cp_reginfo);
6368     }
6369     if (arm_feature(env, ARM_FEATURE_LPAE)) {
6370         define_arm_cp_regs(cpu, lpae_cp_reginfo);
6371     }
6372     /* Slightly awkwardly, the OMAP and StrongARM cores need all of
6373      * cp15 crn=0 to be writes-ignored, whereas for other cores they should
6374      * be read-only (ie write causes UNDEF exception).
6375      */
6376     {
6377         ARMCPRegInfo id_pre_v8_midr_cp_reginfo[] = {
6378             /* Pre-v8 MIDR space.
6379              * Note that the MIDR isn't a simple constant register because
6380              * of the TI925 behaviour where writes to another register can
6381              * cause the MIDR value to change.
6382              *
6383              * Unimplemented registers in the c15 0 0 0 space default to
6384              * MIDR. Define MIDR first as this entire space, then CTR, TCMTR
6385              * and friends override accordingly.
6386              */
6387             { .name = "MIDR",
6388               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = CP_ANY,
6389               .access = PL1_R, .resetvalue = cpu->midr,
6390               .writefn = arm_cp_write_ignore, .raw_writefn = raw_write,
6391               .readfn = midr_read,
6392               .fieldoffset = offsetof(CPUARMState, cp15.c0_cpuid),
6393               .type = ARM_CP_OVERRIDE },
6394             /* crn = 0 op1 = 0 crm = 3..7 : currently unassigned; we RAZ. */
6395             { .name = "DUMMY",
6396               .cp = 15, .crn = 0, .crm = 3, .opc1 = 0, .opc2 = CP_ANY,
6397               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6398             { .name = "DUMMY",
6399               .cp = 15, .crn = 0, .crm = 4, .opc1 = 0, .opc2 = CP_ANY,
6400               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6401             { .name = "DUMMY",
6402               .cp = 15, .crn = 0, .crm = 5, .opc1 = 0, .opc2 = CP_ANY,
6403               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6404             { .name = "DUMMY",
6405               .cp = 15, .crn = 0, .crm = 6, .opc1 = 0, .opc2 = CP_ANY,
6406               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6407             { .name = "DUMMY",
6408               .cp = 15, .crn = 0, .crm = 7, .opc1 = 0, .opc2 = CP_ANY,
6409               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6410             REGINFO_SENTINEL
6411         };
6412         ARMCPRegInfo id_v8_midr_cp_reginfo[] = {
6413             { .name = "MIDR_EL1", .state = ARM_CP_STATE_BOTH,
6414               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 0, .opc2 = 0,
6415               .access = PL1_R, .type = ARM_CP_NO_RAW, .resetvalue = cpu->midr,
6416               .fieldoffset = offsetof(CPUARMState, cp15.c0_cpuid),
6417               .readfn = midr_read },
6418             /* crn = 0 op1 = 0 crm = 0 op2 = 4,7 : AArch32 aliases of MIDR */
6419             { .name = "MIDR", .type = ARM_CP_ALIAS | ARM_CP_CONST,
6420               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 4,
6421               .access = PL1_R, .resetvalue = cpu->midr },
6422             { .name = "MIDR", .type = ARM_CP_ALIAS | ARM_CP_CONST,
6423               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 7,
6424               .access = PL1_R, .resetvalue = cpu->midr },
6425             { .name = "REVIDR_EL1", .state = ARM_CP_STATE_BOTH,
6426               .opc0 = 3, .opc1 = 0, .crn = 0, .crm = 0, .opc2 = 6,
6427               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = cpu->revidr },
6428             REGINFO_SENTINEL
6429         };
6430         ARMCPRegInfo id_cp_reginfo[] = {
6431             /* These are common to v8 and pre-v8 */
6432             { .name = "CTR",
6433               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 1,
6434               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = cpu->ctr },
6435             { .name = "CTR_EL0", .state = ARM_CP_STATE_AA64,
6436               .opc0 = 3, .opc1 = 3, .opc2 = 1, .crn = 0, .crm = 0,
6437               .access = PL0_R, .accessfn = ctr_el0_access,
6438               .type = ARM_CP_CONST, .resetvalue = cpu->ctr },
6439             /* TCMTR and TLBTR exist in v8 but have no 64-bit versions */
6440             { .name = "TCMTR",
6441               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 2,
6442               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
6443             REGINFO_SENTINEL
6444         };
6445         /* TLBTR is specific to VMSA */
6446         ARMCPRegInfo id_tlbtr_reginfo = {
6447               .name = "TLBTR",
6448               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 3,
6449               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0,
6450         };
6451         /* MPUIR is specific to PMSA V6+ */
6452         ARMCPRegInfo id_mpuir_reginfo = {
6453               .name = "MPUIR",
6454               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 4,
6455               .access = PL1_R, .type = ARM_CP_CONST,
6456               .resetvalue = cpu->pmsav7_dregion << 8
6457         };
6458         ARMCPRegInfo crn0_wi_reginfo = {
6459             .name = "CRN0_WI", .cp = 15, .crn = 0, .crm = CP_ANY,
6460             .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_W,
6461             .type = ARM_CP_NOP | ARM_CP_OVERRIDE
6462         };
6463 #ifdef CONFIG_USER_ONLY
6464         ARMCPRegUserSpaceInfo id_v8_user_midr_cp_reginfo[] = {
6465             { .name = "MIDR_EL1",
6466               .exported_bits = 0x00000000ffffffff },
6467             { .name = "REVIDR_EL1"                },
6468             REGUSERINFO_SENTINEL
6469         };
6470         modify_arm_cp_regs(id_v8_midr_cp_reginfo, id_v8_user_midr_cp_reginfo);
6471 #endif
6472         if (arm_feature(env, ARM_FEATURE_OMAPCP) ||
6473             arm_feature(env, ARM_FEATURE_STRONGARM)) {
6474             ARMCPRegInfo *r;
6475             /* Register the blanket "writes ignored" value first to cover the
6476              * whole space. Then update the specific ID registers to allow write
6477              * access, so that they ignore writes rather than causing them to
6478              * UNDEF.
6479              */
6480             define_one_arm_cp_reg(cpu, &crn0_wi_reginfo);
6481             for (r = id_pre_v8_midr_cp_reginfo;
6482                  r->type != ARM_CP_SENTINEL; r++) {
6483                 r->access = PL1_RW;
6484             }
6485             for (r = id_cp_reginfo; r->type != ARM_CP_SENTINEL; r++) {
6486                 r->access = PL1_RW;
6487             }
6488             id_mpuir_reginfo.access = PL1_RW;
6489             id_tlbtr_reginfo.access = PL1_RW;
6490         }
6491         if (arm_feature(env, ARM_FEATURE_V8)) {
6492             define_arm_cp_regs(cpu, id_v8_midr_cp_reginfo);
6493         } else {
6494             define_arm_cp_regs(cpu, id_pre_v8_midr_cp_reginfo);
6495         }
6496         define_arm_cp_regs(cpu, id_cp_reginfo);
6497         if (!arm_feature(env, ARM_FEATURE_PMSA)) {
6498             define_one_arm_cp_reg(cpu, &id_tlbtr_reginfo);
6499         } else if (arm_feature(env, ARM_FEATURE_V7)) {
6500             define_one_arm_cp_reg(cpu, &id_mpuir_reginfo);
6501         }
6502     }
6503
6504     if (arm_feature(env, ARM_FEATURE_MPIDR)) {
6505         ARMCPRegInfo mpidr_cp_reginfo[] = {
6506             { .name = "MPIDR_EL1", .state = ARM_CP_STATE_BOTH,
6507               .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 5,
6508               .access = PL1_R, .readfn = mpidr_read, .type = ARM_CP_NO_RAW },
6509             REGINFO_SENTINEL
6510         };
6511 #ifdef CONFIG_USER_ONLY
6512         ARMCPRegUserSpaceInfo mpidr_user_cp_reginfo[] = {
6513             { .name = "MPIDR_EL1",
6514               .fixed_bits = 0x0000000080000000 },
6515             REGUSERINFO_SENTINEL
6516         };
6517         modify_arm_cp_regs(mpidr_cp_reginfo, mpidr_user_cp_reginfo);
6518 #endif
6519         define_arm_cp_regs(cpu, mpidr_cp_reginfo);
6520     }
6521
6522     if (arm_feature(env, ARM_FEATURE_AUXCR)) {
6523         ARMCPRegInfo auxcr_reginfo[] = {
6524             { .name = "ACTLR_EL1", .state = ARM_CP_STATE_BOTH,
6525               .opc0 = 3, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 1,
6526               .access = PL1_RW, .type = ARM_CP_CONST,
6527               .resetvalue = cpu->reset_auxcr },
6528             { .name = "ACTLR_EL2", .state = ARM_CP_STATE_BOTH,
6529               .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 0, .opc2 = 1,
6530               .access = PL2_RW, .type = ARM_CP_CONST,
6531               .resetvalue = 0 },
6532             { .name = "ACTLR_EL3", .state = ARM_CP_STATE_AA64,
6533               .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 0, .opc2 = 1,
6534               .access = PL3_RW, .type = ARM_CP_CONST,
6535               .resetvalue = 0 },
6536             REGINFO_SENTINEL
6537         };
6538         define_arm_cp_regs(cpu, auxcr_reginfo);
6539         if (arm_feature(env, ARM_FEATURE_V8)) {
6540             /* HACTLR2 maps to ACTLR_EL2[63:32] and is not in ARMv7 */
6541             ARMCPRegInfo hactlr2_reginfo = {
6542                 .name = "HACTLR2", .state = ARM_CP_STATE_AA32,
6543                 .cp = 15, .opc1 = 4, .crn = 1, .crm = 0, .opc2 = 3,
6544                 .access = PL2_RW, .type = ARM_CP_CONST,
6545                 .resetvalue = 0
6546             };
6547             define_one_arm_cp_reg(cpu, &hactlr2_reginfo);
6548         }
6549     }
6550
6551     if (arm_feature(env, ARM_FEATURE_CBAR)) {
6552         if (arm_feature(env, ARM_FEATURE_AARCH64)) {
6553             /* 32 bit view is [31:18] 0...0 [43:32]. */
6554             uint32_t cbar32 = (extract64(cpu->reset_cbar, 18, 14) << 18)
6555                 | extract64(cpu->reset_cbar, 32, 12);
6556             ARMCPRegInfo cbar_reginfo[] = {
6557                 { .name = "CBAR",
6558                   .type = ARM_CP_CONST,
6559                   .cp = 15, .crn = 15, .crm = 0, .opc1 = 4, .opc2 = 0,
6560                   .access = PL1_R, .resetvalue = cpu->reset_cbar },
6561                 { .name = "CBAR_EL1", .state = ARM_CP_STATE_AA64,
6562                   .type = ARM_CP_CONST,
6563                   .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 3, .opc2 = 0,
6564                   .access = PL1_R, .resetvalue = cbar32 },
6565                 REGINFO_SENTINEL
6566             };
6567             /* We don't implement a r/w 64 bit CBAR currently */
6568             assert(arm_feature(env, ARM_FEATURE_CBAR_RO));
6569             define_arm_cp_regs(cpu, cbar_reginfo);
6570         } else {
6571             ARMCPRegInfo cbar = {
6572                 .name = "CBAR",
6573                 .cp = 15, .crn = 15, .crm = 0, .opc1 = 4, .opc2 = 0,
6574                 .access = PL1_R|PL3_W, .resetvalue = cpu->reset_cbar,
6575                 .fieldoffset = offsetof(CPUARMState,
6576                                         cp15.c15_config_base_address)
6577             };
6578             if (arm_feature(env, ARM_FEATURE_CBAR_RO)) {
6579                 cbar.access = PL1_R;
6580                 cbar.fieldoffset = 0;
6581                 cbar.type = ARM_CP_CONST;
6582             }
6583             define_one_arm_cp_reg(cpu, &cbar);
6584         }
6585     }
6586
6587     if (arm_feature(env, ARM_FEATURE_VBAR)) {
6588         ARMCPRegInfo vbar_cp_reginfo[] = {
6589             { .name = "VBAR", .state = ARM_CP_STATE_BOTH,
6590               .opc0 = 3, .crn = 12, .crm = 0, .opc1 = 0, .opc2 = 0,
6591               .access = PL1_RW, .writefn = vbar_write,
6592               .bank_fieldoffsets = { offsetof(CPUARMState, cp15.vbar_s),
6593                                      offsetof(CPUARMState, cp15.vbar_ns) },
6594               .resetvalue = 0 },
6595             REGINFO_SENTINEL
6596         };
6597         define_arm_cp_regs(cpu, vbar_cp_reginfo);
6598     }
6599
6600     /* Generic registers whose values depend on the implementation */
6601     {
6602         ARMCPRegInfo sctlr = {
6603             .name = "SCTLR", .state = ARM_CP_STATE_BOTH,
6604             .opc0 = 3, .opc1 = 0, .crn = 1, .crm = 0, .opc2 = 0,
6605             .access = PL1_RW,
6606             .bank_fieldoffsets = { offsetof(CPUARMState, cp15.sctlr_s),
6607                                    offsetof(CPUARMState, cp15.sctlr_ns) },
6608             .writefn = sctlr_write, .resetvalue = cpu->reset_sctlr,
6609             .raw_writefn = raw_write,
6610         };
6611         if (arm_feature(env, ARM_FEATURE_XSCALE)) {
6612             /* Normally we would always end the TB on an SCTLR write, but Linux
6613              * arch/arm/mach-pxa/sleep.S expects two instructions following
6614              * an MMU enable to execute from cache.  Imitate this behaviour.
6615              */
6616             sctlr.type |= ARM_CP_SUPPRESS_TB_END;
6617         }
6618         define_one_arm_cp_reg(cpu, &sctlr);
6619     }
6620
6621     if (cpu_isar_feature(aa64_lor, cpu)) {
6622         /*
6623          * A trivial implementation of ARMv8.1-LOR leaves all of these
6624          * registers fixed at 0, which indicates that there are zero
6625          * supported Limited Ordering regions.
6626          */
6627         static const ARMCPRegInfo lor_reginfo[] = {
6628             { .name = "LORSA_EL1", .state = ARM_CP_STATE_AA64,
6629               .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 4, .opc2 = 0,
6630               .access = PL1_RW, .accessfn = access_lor_other,
6631               .type = ARM_CP_CONST, .resetvalue = 0 },
6632             { .name = "LOREA_EL1", .state = ARM_CP_STATE_AA64,
6633               .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 4, .opc2 = 1,
6634               .access = PL1_RW, .accessfn = access_lor_other,
6635               .type = ARM_CP_CONST, .resetvalue = 0 },
6636             { .name = "LORN_EL1", .state = ARM_CP_STATE_AA64,
6637               .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 4, .opc2 = 2,
6638               .access = PL1_RW, .accessfn = access_lor_other,
6639               .type = ARM_CP_CONST, .resetvalue = 0 },
6640             { .name = "LORC_EL1", .state = ARM_CP_STATE_AA64,
6641               .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 4, .opc2 = 3,
6642               .access = PL1_RW, .accessfn = access_lor_other,
6643               .type = ARM_CP_CONST, .resetvalue = 0 },
6644             { .name = "LORID_EL1", .state = ARM_CP_STATE_AA64,
6645               .opc0 = 3, .opc1 = 0, .crn = 10, .crm = 4, .opc2 = 7,
6646               .access = PL1_R, .accessfn = access_lorid,
6647               .type = ARM_CP_CONST, .resetvalue = 0 },
6648             REGINFO_SENTINEL
6649         };
6650         define_arm_cp_regs(cpu, lor_reginfo);
6651     }
6652
6653     if (cpu_isar_feature(aa64_sve, cpu)) {
6654         define_one_arm_cp_reg(cpu, &zcr_el1_reginfo);
6655         if (arm_feature(env, ARM_FEATURE_EL2)) {
6656             define_one_arm_cp_reg(cpu, &zcr_el2_reginfo);
6657         } else {
6658             define_one_arm_cp_reg(cpu, &zcr_no_el2_reginfo);
6659         }
6660         if (arm_feature(env, ARM_FEATURE_EL3)) {
6661             define_one_arm_cp_reg(cpu, &zcr_el3_reginfo);
6662         }
6663     }
6664
6665 #ifdef TARGET_AARCH64
6666     if (cpu_isar_feature(aa64_pauth, cpu)) {
6667         define_arm_cp_regs(cpu, pauth_reginfo);
6668     }
6669 #endif
6670
6671     /*
6672      * While all v8.0 cpus support aarch64, QEMU does have configurations
6673      * that do not set ID_AA64ISAR1, e.g. user-only qemu-arm -cpu max,
6674      * which will set ID_ISAR6.
6675      */
6676     if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)
6677         ? cpu_isar_feature(aa64_predinv, cpu)
6678         : cpu_isar_feature(aa32_predinv, cpu)) {
6679         define_arm_cp_regs(cpu, predinv_reginfo);
6680     }
6681 }
6682
6683 void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu)
6684 {
6685     CPUState *cs = CPU(cpu);
6686     CPUARMState *env = &cpu->env;
6687
6688     if (arm_feature(env, ARM_FEATURE_AARCH64)) {
6689         gdb_register_coprocessor(cs, aarch64_fpu_gdb_get_reg,
6690                                  aarch64_fpu_gdb_set_reg,
6691                                  34, "aarch64-fpu.xml", 0);
6692     } else if (arm_feature(env, ARM_FEATURE_NEON)) {
6693         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
6694                                  51, "arm-neon.xml", 0);
6695     } else if (arm_feature(env, ARM_FEATURE_VFP3)) {
6696         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
6697                                  35, "arm-vfp3.xml", 0);
6698     } else if (arm_feature(env, ARM_FEATURE_VFP)) {
6699         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
6700                                  19, "arm-vfp.xml", 0);
6701     }
6702     gdb_register_coprocessor(cs, arm_gdb_get_sysreg, arm_gdb_set_sysreg,
6703                              arm_gen_dynamic_xml(cs),
6704                              "system-registers.xml", 0);
6705 }
6706
6707 /* Sort alphabetically by type name, except for "any". */
6708 static gint arm_cpu_list_compare(gconstpointer a, gconstpointer b)
6709 {
6710     ObjectClass *class_a = (ObjectClass *)a;
6711     ObjectClass *class_b = (ObjectClass *)b;
6712     const char *name_a, *name_b;
6713
6714     name_a = object_class_get_name(class_a);
6715     name_b = object_class_get_name(class_b);
6716     if (strcmp(name_a, "any-" TYPE_ARM_CPU) == 0) {
6717         return 1;
6718     } else if (strcmp(name_b, "any-" TYPE_ARM_CPU) == 0) {
6719         return -1;
6720     } else {
6721         return strcmp(name_a, name_b);
6722     }
6723 }
6724
6725 static void arm_cpu_list_entry(gpointer data, gpointer user_data)
6726 {
6727     ObjectClass *oc = data;
6728     const char *typename;
6729     char *name;
6730
6731     typename = object_class_get_name(oc);
6732     name = g_strndup(typename, strlen(typename) - strlen("-" TYPE_ARM_CPU));
6733     qemu_printf("  %s\n", name);
6734     g_free(name);
6735 }
6736
6737 void arm_cpu_list(void)
6738 {
6739     GSList *list;
6740
6741     list = object_class_get_list(TYPE_ARM_CPU, false);
6742     list = g_slist_sort(list, arm_cpu_list_compare);
6743     qemu_printf("Available CPUs:\n");
6744     g_slist_foreach(list, arm_cpu_list_entry, NULL);
6745     g_slist_free(list);
6746 }
6747
6748 static void arm_cpu_add_definition(gpointer data, gpointer user_data)
6749 {
6750     ObjectClass *oc = data;
6751     CpuDefinitionInfoList **cpu_list = user_data;
6752     CpuDefinitionInfoList *entry;
6753     CpuDefinitionInfo *info;
6754     const char *typename;
6755
6756     typename = object_class_get_name(oc);
6757     info = g_malloc0(sizeof(*info));
6758     info->name = g_strndup(typename,
6759                            strlen(typename) - strlen("-" TYPE_ARM_CPU));
6760     info->q_typename = g_strdup(typename);
6761
6762     entry = g_malloc0(sizeof(*entry));
6763     entry->value = info;
6764     entry->next = *cpu_list;
6765     *cpu_list = entry;
6766 }
6767
6768 CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp)
6769 {
6770     CpuDefinitionInfoList *cpu_list = NULL;
6771     GSList *list;
6772
6773     list = object_class_get_list(TYPE_ARM_CPU, false);
6774     g_slist_foreach(list, arm_cpu_add_definition, &cpu_list);
6775     g_slist_free(list);
6776
6777     return cpu_list;
6778 }
6779
6780 static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r,
6781                                    void *opaque, int state, int secstate,
6782                                    int crm, int opc1, int opc2,
6783                                    const char *name)
6784 {
6785     /* Private utility function for define_one_arm_cp_reg_with_opaque():
6786      * add a single reginfo struct to the hash table.
6787      */
6788     uint32_t *key = g_new(uint32_t, 1);
6789     ARMCPRegInfo *r2 = g_memdup(r, sizeof(ARMCPRegInfo));
6790     int is64 = (r->type & ARM_CP_64BIT) ? 1 : 0;
6791     int ns = (secstate & ARM_CP_SECSTATE_NS) ? 1 : 0;
6792
6793     r2->name = g_strdup(name);
6794     /* Reset the secure state to the specific incoming state.  This is
6795      * necessary as the register may have been defined with both states.
6796      */
6797     r2->secure = secstate;
6798
6799     if (r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1]) {
6800         /* Register is banked (using both entries in array).
6801          * Overwriting fieldoffset as the array is only used to define
6802          * banked registers but later only fieldoffset is used.
6803          */
6804         r2->fieldoffset = r->bank_fieldoffsets[ns];
6805     }
6806
6807     if (state == ARM_CP_STATE_AA32) {
6808         if (r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1]) {
6809             /* If the register is banked then we don't need to migrate or
6810              * reset the 32-bit instance in certain cases:
6811              *
6812              * 1) If the register has both 32-bit and 64-bit instances then we
6813              *    can count on the 64-bit instance taking care of the
6814              *    non-secure bank.
6815              * 2) If ARMv8 is enabled then we can count on a 64-bit version
6816              *    taking care of the secure bank.  This requires that separate
6817              *    32 and 64-bit definitions are provided.
6818              */
6819             if ((r->state == ARM_CP_STATE_BOTH && ns) ||
6820                 (arm_feature(&cpu->env, ARM_FEATURE_V8) && !ns)) {
6821                 r2->type |= ARM_CP_ALIAS;
6822             }
6823         } else if ((secstate != r->secure) && !ns) {
6824             /* The register is not banked so we only want to allow migration of
6825              * the non-secure instance.
6826              */
6827             r2->type |= ARM_CP_ALIAS;
6828         }
6829
6830         if (r->state == ARM_CP_STATE_BOTH) {
6831             /* We assume it is a cp15 register if the .cp field is left unset.
6832              */
6833             if (r2->cp == 0) {
6834                 r2->cp = 15;
6835             }
6836
6837 #ifdef HOST_WORDS_BIGENDIAN
6838             if (r2->fieldoffset) {
6839                 r2->fieldoffset += sizeof(uint32_t);
6840             }
6841 #endif
6842         }
6843     }
6844     if (state == ARM_CP_STATE_AA64) {
6845         /* To allow abbreviation of ARMCPRegInfo
6846          * definitions, we treat cp == 0 as equivalent to
6847          * the value for "standard guest-visible sysreg".
6848          * STATE_BOTH definitions are also always "standard
6849          * sysreg" in their AArch64 view (the .cp value may
6850          * be non-zero for the benefit of the AArch32 view).
6851          */
6852         if (r->cp == 0 || r->state == ARM_CP_STATE_BOTH) {
6853             r2->cp = CP_REG_ARM64_SYSREG_CP;
6854         }
6855         *key = ENCODE_AA64_CP_REG(r2->cp, r2->crn, crm,
6856                                   r2->opc0, opc1, opc2);
6857     } else {
6858         *key = ENCODE_CP_REG(r2->cp, is64, ns, r2->crn, crm, opc1, opc2);
6859     }
6860     if (opaque) {
6861         r2->opaque = opaque;
6862     }
6863     /* reginfo passed to helpers is correct for the actual access,
6864      * and is never ARM_CP_STATE_BOTH:
6865      */
6866     r2->state = state;
6867     /* Make sure reginfo passed to helpers for wildcarded regs
6868      * has the correct crm/opc1/opc2 for this reg, not CP_ANY:
6869      */
6870     r2->crm = crm;
6871     r2->opc1 = opc1;
6872     r2->opc2 = opc2;
6873     /* By convention, for wildcarded registers only the first
6874      * entry is used for migration; the others are marked as
6875      * ALIAS so we don't try to transfer the register
6876      * multiple times. Special registers (ie NOP/WFI) are
6877      * never migratable and not even raw-accessible.
6878      */
6879     if ((r->type & ARM_CP_SPECIAL)) {
6880         r2->type |= ARM_CP_NO_RAW;
6881     }
6882     if (((r->crm == CP_ANY) && crm != 0) ||
6883         ((r->opc1 == CP_ANY) && opc1 != 0) ||
6884         ((r->opc2 == CP_ANY) && opc2 != 0)) {
6885         r2->type |= ARM_CP_ALIAS | ARM_CP_NO_GDB;
6886     }
6887
6888     /* Check that raw accesses are either forbidden or handled. Note that
6889      * we can't assert this earlier because the setup of fieldoffset for
6890      * banked registers has to be done first.
6891      */
6892     if (!(r2->type & ARM_CP_NO_RAW)) {
6893         assert(!raw_accessors_invalid(r2));
6894     }
6895
6896     /* Overriding of an existing definition must be explicitly
6897      * requested.
6898      */
6899     if (!(r->type & ARM_CP_OVERRIDE)) {
6900         ARMCPRegInfo *oldreg;
6901         oldreg = g_hash_table_lookup(cpu->cp_regs, key);
6902         if (oldreg && !(oldreg->type & ARM_CP_OVERRIDE)) {
6903             fprintf(stderr, "Register redefined: cp=%d %d bit "
6904                     "crn=%d crm=%d opc1=%d opc2=%d, "
6905                     "was %s, now %s\n", r2->cp, 32 + 32 * is64,
6906                     r2->crn, r2->crm, r2->opc1, r2->opc2,
6907                     oldreg->name, r2->name);
6908             g_assert_not_reached();
6909         }
6910     }
6911     g_hash_table_insert(cpu->cp_regs, key, r2);
6912 }
6913
6914
6915 void define_one_arm_cp_reg_with_opaque(ARMCPU *cpu,
6916                                        const ARMCPRegInfo *r, void *opaque)
6917 {
6918     /* Define implementations of coprocessor registers.
6919      * We store these in a hashtable because typically
6920      * there are less than 150 registers in a space which
6921      * is 16*16*16*8*8 = 262144 in size.
6922      * Wildcarding is supported for the crm, opc1 and opc2 fields.
6923      * If a register is defined twice then the second definition is
6924      * used, so this can be used to define some generic registers and
6925      * then override them with implementation specific variations.
6926      * At least one of the original and the second definition should
6927      * include ARM_CP_OVERRIDE in its type bits -- this is just a guard
6928      * against accidental use.
6929      *
6930      * The state field defines whether the register is to be
6931      * visible in the AArch32 or AArch64 execution state. If the
6932      * state is set to ARM_CP_STATE_BOTH then we synthesise a
6933      * reginfo structure for the AArch32 view, which sees the lower
6934      * 32 bits of the 64 bit register.
6935      *
6936      * Only registers visible in AArch64 may set r->opc0; opc0 cannot
6937      * be wildcarded. AArch64 registers are always considered to be 64
6938      * bits; the ARM_CP_64BIT* flag applies only to the AArch32 view of
6939      * the register, if any.
6940      */
6941     int crm, opc1, opc2, state;
6942     int crmmin = (r->crm == CP_ANY) ? 0 : r->crm;
6943     int crmmax = (r->crm == CP_ANY) ? 15 : r->crm;
6944     int opc1min = (r->opc1 == CP_ANY) ? 0 : r->opc1;
6945     int opc1max = (r->opc1 == CP_ANY) ? 7 : r->opc1;
6946     int opc2min = (r->opc2 == CP_ANY) ? 0 : r->opc2;
6947     int opc2max = (r->opc2 == CP_ANY) ? 7 : r->opc2;
6948     /* 64 bit registers have only CRm and Opc1 fields */
6949     assert(!((r->type & ARM_CP_64BIT) && (r->opc2 || r->crn)));
6950     /* op0 only exists in the AArch64 encodings */
6951     assert((r->state != ARM_CP_STATE_AA32) || (r->opc0 == 0));
6952     /* AArch64 regs are all 64 bit so ARM_CP_64BIT is meaningless */
6953     assert((r->state != ARM_CP_STATE_AA64) || !(r->type & ARM_CP_64BIT));
6954     /* The AArch64 pseudocode CheckSystemAccess() specifies that op1
6955      * encodes a minimum access level for the register. We roll this
6956      * runtime check into our general permission check code, so check
6957      * here that the reginfo's specified permissions are strict enough
6958      * to encompass the generic architectural permission check.
6959      */
6960     if (r->state != ARM_CP_STATE_AA32) {
6961         int mask = 0;
6962         switch (r->opc1) {
6963         case 0:
6964             /* min_EL EL1, but some accessible to EL0 via kernel ABI */
6965             mask = PL0U_R | PL1_RW;
6966             break;
6967         case 1: case 2:
6968             /* min_EL EL1 */
6969             mask = PL1_RW;
6970             break;
6971         case 3:
6972             /* min_EL EL0 */
6973             mask = PL0_RW;
6974             break;
6975         case 4:
6976             /* min_EL EL2 */
6977             mask = PL2_RW;
6978             break;
6979         case 5:
6980             /* unallocated encoding, so not possible */
6981             assert(false);
6982             break;
6983         case 6:
6984             /* min_EL EL3 */
6985             mask = PL3_RW;
6986             break;
6987         case 7:
6988             /* min_EL EL1, secure mode only (we don't check the latter) */
6989             mask = PL1_RW;
6990             break;
6991         default:
6992             /* broken reginfo with out-of-range opc1 */
6993             assert(false);
6994             break;
6995         }
6996         /* assert our permissions are not too lax (stricter is fine) */
6997         assert((r->access & ~mask) == 0);
6998     }
6999
7000     /* Check that the register definition has enough info to handle
7001      * reads and writes if they are permitted.
7002      */
7003     if (!(r->type & (ARM_CP_SPECIAL|ARM_CP_CONST))) {
7004         if (r->access & PL3_R) {
7005             assert((r->fieldoffset ||
7006                    (r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1])) ||
7007                    r->readfn);
7008         }
7009         if (r->access & PL3_W) {
7010             assert((r->fieldoffset ||
7011                    (r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1])) ||
7012                    r->writefn);
7013         }
7014     }
7015     /* Bad type field probably means missing sentinel at end of reg list */
7016     assert(cptype_valid(r->type));
7017     for (crm = crmmin; crm <= crmmax; crm++) {
7018         for (opc1 = opc1min; opc1 <= opc1max; opc1++) {
7019             for (opc2 = opc2min; opc2 <= opc2max; opc2++) {
7020                 for (state = ARM_CP_STATE_AA32;
7021                      state <= ARM_CP_STATE_AA64; state++) {
7022                     if (r->state != state && r->state != ARM_CP_STATE_BOTH) {
7023                         continue;
7024                     }
7025                     if (state == ARM_CP_STATE_AA32) {
7026                         /* Under AArch32 CP registers can be common
7027                          * (same for secure and non-secure world) or banked.
7028                          */
7029                         char *name;
7030
7031                         switch (r->secure) {
7032                         case ARM_CP_SECSTATE_S:
7033                         case ARM_CP_SECSTATE_NS:
7034                             add_cpreg_to_hashtable(cpu, r, opaque, state,
7035                                                    r->secure, crm, opc1, opc2,
7036                                                    r->name);
7037                             break;
7038                         default:
7039                             name = g_strdup_printf("%s_S", r->name);
7040                             add_cpreg_to_hashtable(cpu, r, opaque, state,
7041                                                    ARM_CP_SECSTATE_S,
7042                                                    crm, opc1, opc2, name);
7043                             g_free(name);
7044                             add_cpreg_to_hashtable(cpu, r, opaque, state,
7045                                                    ARM_CP_SECSTATE_NS,
7046                                                    crm, opc1, opc2, r->name);
7047                             break;
7048                         }
7049                     } else {
7050                         /* AArch64 registers get mapped to non-secure instance
7051                          * of AArch32 */
7052                         add_cpreg_to_hashtable(cpu, r, opaque, state,
7053                                                ARM_CP_SECSTATE_NS,
7054                                                crm, opc1, opc2, r->name);
7055                     }
7056                 }
7057             }
7058         }
7059     }
7060 }
7061
7062 void define_arm_cp_regs_with_opaque(ARMCPU *cpu,
7063                                     const ARMCPRegInfo *regs, void *opaque)
7064 {
7065     /* Define a whole list of registers */
7066     const ARMCPRegInfo *r;
7067     for (r = regs; r->type != ARM_CP_SENTINEL; r++) {
7068         define_one_arm_cp_reg_with_opaque(cpu, r, opaque);
7069     }
7070 }
7071
7072 /*
7073  * Modify ARMCPRegInfo for access from userspace.
7074  *
7075  * This is a data driven modification directed by
7076  * ARMCPRegUserSpaceInfo. All registers become ARM_CP_CONST as
7077  * user-space cannot alter any values and dynamic values pertaining to
7078  * execution state are hidden from user space view anyway.
7079  */
7080 void modify_arm_cp_regs(ARMCPRegInfo *regs, const ARMCPRegUserSpaceInfo *mods)
7081 {
7082     const ARMCPRegUserSpaceInfo *m;
7083     ARMCPRegInfo *r;
7084
7085     for (m = mods; m->name; m++) {
7086         GPatternSpec *pat = NULL;
7087         if (m->is_glob) {
7088             pat = g_pattern_spec_new(m->name);
7089         }
7090         for (r = regs; r->type != ARM_CP_SENTINEL; r++) {
7091             if (pat && g_pattern_match_string(pat, r->name)) {
7092                 r->type = ARM_CP_CONST;
7093                 r->access = PL0U_R;
7094                 r->resetvalue = 0;
7095                 /* continue */
7096             } else if (strcmp(r->name, m->name) == 0) {
7097                 r->type = ARM_CP_CONST;
7098                 r->access = PL0U_R;
7099                 r->resetvalue &= m->exported_bits;
7100                 r->resetvalue |= m->fixed_bits;
7101                 break;
7102             }
7103         }
7104         if (pat) {
7105             g_pattern_spec_free(pat);
7106         }
7107     }
7108 }
7109
7110 const ARMCPRegInfo *get_arm_cp_reginfo(GHashTable *cpregs, uint32_t encoded_cp)
7111 {
7112     return g_hash_table_lookup(cpregs, &encoded_cp);
7113 }
7114
7115 void arm_cp_write_ignore(CPUARMState *env, const ARMCPRegInfo *ri,
7116                          uint64_t value)
7117 {
7118     /* Helper coprocessor write function for write-ignore registers */
7119 }
7120
7121 uint64_t arm_cp_read_zero(CPUARMState *env, const ARMCPRegInfo *ri)
7122 {
7123     /* Helper coprocessor write function for read-as-zero registers */
7124     return 0;
7125 }
7126
7127 void arm_cp_reset_ignore(CPUARMState *env, const ARMCPRegInfo *opaque)
7128 {
7129     /* Helper coprocessor reset function for do-nothing-on-reset registers */
7130 }
7131
7132 static int bad_mode_switch(CPUARMState *env, int mode, CPSRWriteType write_type)
7133 {
7134     /* Return true if it is not valid for us to switch to
7135      * this CPU mode (ie all the UNPREDICTABLE cases in
7136      * the ARM ARM CPSRWriteByInstr pseudocode).
7137      */
7138
7139     /* Changes to or from Hyp via MSR and CPS are illegal. */
7140     if (write_type == CPSRWriteByInstr &&
7141         ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_HYP ||
7142          mode == ARM_CPU_MODE_HYP)) {
7143         return 1;
7144     }
7145
7146     switch (mode) {
7147     case ARM_CPU_MODE_USR:
7148         return 0;
7149     case ARM_CPU_MODE_SYS:
7150     case ARM_CPU_MODE_SVC:
7151     case ARM_CPU_MODE_ABT:
7152     case ARM_CPU_MODE_UND:
7153     case ARM_CPU_MODE_IRQ:
7154     case ARM_CPU_MODE_FIQ:
7155         /* Note that we don't implement the IMPDEF NSACR.RFR which in v7
7156          * allows FIQ mode to be Secure-only. (In v8 this doesn't exist.)
7157          */
7158         /* If HCR.TGE is set then changes from Monitor to NS PL1 via MSR
7159          * and CPS are treated as illegal mode changes.
7160          */
7161         if (write_type == CPSRWriteByInstr &&
7162             (env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_MON &&
7163             (arm_hcr_el2_eff(env) & HCR_TGE)) {
7164             return 1;
7165         }
7166         return 0;
7167     case ARM_CPU_MODE_HYP:
7168         return !arm_feature(env, ARM_FEATURE_EL2)
7169             || arm_current_el(env) < 2 || arm_is_secure_below_el3(env);
7170     case ARM_CPU_MODE_MON:
7171         return arm_current_el(env) < 3;
7172     default:
7173         return 1;
7174     }
7175 }
7176
7177 uint32_t cpsr_read(CPUARMState *env)
7178 {
7179     int ZF;
7180     ZF = (env->ZF == 0);
7181     return env->uncached_cpsr | (env->NF & 0x80000000) | (ZF << 30) |
7182         (env->CF << 29) | ((env->VF & 0x80000000) >> 3) | (env->QF << 27)
7183         | (env->thumb << 5) | ((env->condexec_bits & 3) << 25)
7184         | ((env->condexec_bits & 0xfc) << 8)
7185         | (env->GE << 16) | (env->daif & CPSR_AIF);
7186 }
7187
7188 void cpsr_write(CPUARMState *env, uint32_t val, uint32_t mask,
7189                 CPSRWriteType write_type)
7190 {
7191     uint32_t changed_daif;
7192
7193     if (mask & CPSR_NZCV) {
7194         env->ZF = (~val) & CPSR_Z;
7195         env->NF = val;
7196         env->CF = (val >> 29) & 1;
7197         env->VF = (val << 3) & 0x80000000;
7198     }
7199     if (mask & CPSR_Q)
7200         env->QF = ((val & CPSR_Q) != 0);
7201     if (mask & CPSR_T)
7202         env->thumb = ((val & CPSR_T) != 0);
7203     if (mask & CPSR_IT_0_1) {
7204         env->condexec_bits &= ~3;
7205         env->condexec_bits |= (val >> 25) & 3;
7206     }
7207     if (mask & CPSR_IT_2_7) {
7208         env->condexec_bits &= 3;
7209         env->condexec_bits |= (val >> 8) & 0xfc;
7210     }
7211     if (mask & CPSR_GE) {
7212         env->GE = (val >> 16) & 0xf;
7213     }
7214
7215     /* In a V7 implementation that includes the security extensions but does
7216      * not include Virtualization Extensions the SCR.FW and SCR.AW bits control
7217      * whether non-secure software is allowed to change the CPSR_F and CPSR_A
7218      * bits respectively.
7219      *
7220      * In a V8 implementation, it is permitted for privileged software to
7221      * change the CPSR A/F bits regardless of the SCR.AW/FW bits.
7222      */
7223     if (write_type != CPSRWriteRaw && !arm_feature(env, ARM_FEATURE_V8) &&
7224         arm_feature(env, ARM_FEATURE_EL3) &&
7225         !arm_feature(env, ARM_FEATURE_EL2) &&
7226         !arm_is_secure(env)) {
7227
7228         changed_daif = (env->daif ^ val) & mask;
7229
7230         if (changed_daif & CPSR_A) {
7231             /* Check to see if we are allowed to change the masking of async
7232              * abort exceptions from a non-secure state.
7233              */
7234             if (!(env->cp15.scr_el3 & SCR_AW)) {
7235                 qemu_log_mask(LOG_GUEST_ERROR,
7236                               "Ignoring attempt to switch CPSR_A flag from "
7237                               "non-secure world with SCR.AW bit clear\n");
7238                 mask &= ~CPSR_A;
7239             }
7240         }
7241
7242         if (changed_daif & CPSR_F) {
7243             /* Check to see if we are allowed to change the masking of FIQ
7244              * exceptions from a non-secure state.
7245              */
7246             if (!(env->cp15.scr_el3 & SCR_FW)) {
7247                 qemu_log_mask(LOG_GUEST_ERROR,
7248                               "Ignoring attempt to switch CPSR_F flag from "
7249                               "non-secure world with SCR.FW bit clear\n");
7250                 mask &= ~CPSR_F;
7251             }
7252
7253             /* Check whether non-maskable FIQ (NMFI) support is enabled.
7254              * If this bit is set software is not allowed to mask
7255              * FIQs, but is allowed to set CPSR_F to 0.
7256              */
7257             if ((A32_BANKED_CURRENT_REG_GET(env, sctlr) & SCTLR_NMFI) &&
7258                 (val & CPSR_F)) {
7259                 qemu_log_mask(LOG_GUEST_ERROR,
7260                               "Ignoring attempt to enable CPSR_F flag "
7261                               "(non-maskable FIQ [NMFI] support enabled)\n");
7262                 mask &= ~CPSR_F;
7263             }
7264         }
7265     }
7266
7267     env->daif &= ~(CPSR_AIF & mask);
7268     env->daif |= val & CPSR_AIF & mask;
7269
7270     if (write_type != CPSRWriteRaw &&
7271         ((env->uncached_cpsr ^ val) & mask & CPSR_M)) {
7272         if ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_USR) {
7273             /* Note that we can only get here in USR mode if this is a
7274              * gdb stub write; for this case we follow the architectural
7275              * behaviour for guest writes in USR mode of ignoring an attempt
7276              * to switch mode. (Those are caught by translate.c for writes
7277              * triggered by guest instructions.)
7278              */
7279             mask &= ~CPSR_M;
7280         } else if (bad_mode_switch(env, val & CPSR_M, write_type)) {
7281             /* Attempt to switch to an invalid mode: this is UNPREDICTABLE in
7282              * v7, and has defined behaviour in v8:
7283              *  + leave CPSR.M untouched
7284              *  + allow changes to the other CPSR fields
7285              *  + set PSTATE.IL
7286              * For user changes via the GDB stub, we don't set PSTATE.IL,
7287              * as this would be unnecessarily harsh for a user error.
7288              */
7289             mask &= ~CPSR_M;
7290             if (write_type != CPSRWriteByGDBStub &&
7291                 arm_feature(env, ARM_FEATURE_V8)) {
7292                 mask |= CPSR_IL;
7293                 val |= CPSR_IL;
7294             }
7295             qemu_log_mask(LOG_GUEST_ERROR,
7296                           "Illegal AArch32 mode switch attempt from %s to %s\n",
7297                           aarch32_mode_name(env->uncached_cpsr),
7298                           aarch32_mode_name(val));
7299         } else {
7300             qemu_log_mask(CPU_LOG_INT, "%s %s to %s PC 0x%" PRIx32 "\n",
7301                           write_type == CPSRWriteExceptionReturn ?
7302                           "Exception return from AArch32" :
7303                           "AArch32 mode switch from",
7304                           aarch32_mode_name(env->uncached_cpsr),
7305                           aarch32_mode_name(val), env->regs[15]);
7306             switch_mode(env, val & CPSR_M);
7307         }
7308     }
7309     mask &= ~CACHED_CPSR_BITS;
7310     env->uncached_cpsr = (env->uncached_cpsr & ~mask) | (val & mask);
7311 }
7312
7313 /* Sign/zero extend */
7314 uint32_t HELPER(sxtb16)(uint32_t x)
7315 {
7316     uint32_t res;
7317     res = (uint16_t)(int8_t)x;
7318     res |= (uint32_t)(int8_t)(x >> 16) << 16;
7319     return res;
7320 }
7321
7322 uint32_t HELPER(uxtb16)(uint32_t x)
7323 {
7324     uint32_t res;
7325     res = (uint16_t)(uint8_t)x;
7326     res |= (uint32_t)(uint8_t)(x >> 16) << 16;
7327     return res;
7328 }
7329
7330 int32_t HELPER(sdiv)(int32_t num, int32_t den)
7331 {
7332     if (den == 0)
7333       return 0;
7334     if (num == INT_MIN && den == -1)
7335       return INT_MIN;
7336     return num / den;
7337 }
7338
7339 uint32_t HELPER(udiv)(uint32_t num, uint32_t den)
7340 {
7341     if (den == 0)
7342       return 0;
7343     return num / den;
7344 }
7345
7346 uint32_t HELPER(rbit)(uint32_t x)
7347 {
7348     return revbit32(x);
7349 }
7350
7351 #ifdef CONFIG_USER_ONLY
7352
7353 /* These should probably raise undefined insn exceptions.  */
7354 void HELPER(v7m_msr)(CPUARMState *env, uint32_t reg, uint32_t val)
7355 {
7356     ARMCPU *cpu = arm_env_get_cpu(env);
7357
7358     cpu_abort(CPU(cpu), "v7m_msr %d\n", reg);
7359 }
7360
7361 uint32_t HELPER(v7m_mrs)(CPUARMState *env, uint32_t reg)
7362 {
7363     ARMCPU *cpu = arm_env_get_cpu(env);
7364
7365     cpu_abort(CPU(cpu), "v7m_mrs %d\n", reg);
7366     return 0;
7367 }
7368
7369 void HELPER(v7m_bxns)(CPUARMState *env, uint32_t dest)
7370 {
7371     /* translate.c should never generate calls here in user-only mode */
7372     g_assert_not_reached();
7373 }
7374
7375 void HELPER(v7m_blxns)(CPUARMState *env, uint32_t dest)
7376 {
7377     /* translate.c should never generate calls here in user-only mode */
7378     g_assert_not_reached();
7379 }
7380
7381 uint32_t HELPER(v7m_tt)(CPUARMState *env, uint32_t addr, uint32_t op)
7382 {
7383     /* The TT instructions can be used by unprivileged code, but in
7384      * user-only emulation we don't have the MPU.
7385      * Luckily since we know we are NonSecure unprivileged (and that in
7386      * turn means that the A flag wasn't specified), all the bits in the
7387      * register must be zero:
7388      *  IREGION: 0 because IRVALID is 0
7389      *  IRVALID: 0 because NS
7390      *  S: 0 because NS
7391      *  NSRW: 0 because NS
7392      *  NSR: 0 because NS
7393      *  RW: 0 because unpriv and A flag not set
7394      *  R: 0 because unpriv and A flag not set
7395      *  SRVALID: 0 because NS
7396      *  MRVALID: 0 because unpriv and A flag not set
7397      *  SREGION: 0 becaus SRVALID is 0
7398      *  MREGION: 0 because MRVALID is 0
7399      */
7400     return 0;
7401 }
7402
7403 static void switch_mode(CPUARMState *env, int mode)
7404 {
7405     ARMCPU *cpu = arm_env_get_cpu(env);
7406
7407     if (mode != ARM_CPU_MODE_USR) {
7408         cpu_abort(CPU(cpu), "Tried to switch out of user mode\n");
7409     }
7410 }
7411
7412 uint32_t arm_phys_excp_target_el(CPUState *cs, uint32_t excp_idx,
7413                                  uint32_t cur_el, bool secure)
7414 {
7415     return 1;
7416 }
7417
7418 void aarch64_sync_64_to_32(CPUARMState *env)
7419 {
7420     g_assert_not_reached();
7421 }
7422
7423 #else
7424
7425 static void switch_mode(CPUARMState *env, int mode)
7426 {
7427     int old_mode;
7428     int i;
7429
7430     old_mode = env->uncached_cpsr & CPSR_M;
7431     if (mode == old_mode)
7432         return;
7433
7434     if (old_mode == ARM_CPU_MODE_FIQ) {
7435         memcpy (env->fiq_regs, env->regs + 8, 5 * sizeof(uint32_t));
7436         memcpy (env->regs + 8, env->usr_regs, 5 * sizeof(uint32_t));
7437     } else if (mode == ARM_CPU_MODE_FIQ) {
7438         memcpy (env->usr_regs, env->regs + 8, 5 * sizeof(uint32_t));
7439         memcpy (env->regs + 8, env->fiq_regs, 5 * sizeof(uint32_t));
7440     }
7441
7442     i = bank_number(old_mode);
7443     env->banked_r13[i] = env->regs[13];
7444     env->banked_spsr[i] = env->spsr;
7445
7446     i = bank_number(mode);
7447     env->regs[13] = env->banked_r13[i];
7448     env->spsr = env->banked_spsr[i];
7449
7450     env->banked_r14[r14_bank_number(old_mode)] = env->regs[14];
7451     env->regs[14] = env->banked_r14[r14_bank_number(mode)];
7452 }
7453
7454 /* Physical Interrupt Target EL Lookup Table
7455  *
7456  * [ From ARM ARM section G1.13.4 (Table G1-15) ]
7457  *
7458  * The below multi-dimensional table is used for looking up the target
7459  * exception level given numerous condition criteria.  Specifically, the
7460  * target EL is based on SCR and HCR routing controls as well as the
7461  * currently executing EL and secure state.
7462  *
7463  *    Dimensions:
7464  *    target_el_table[2][2][2][2][2][4]
7465  *                    |  |  |  |  |  +--- Current EL
7466  *                    |  |  |  |  +------ Non-secure(0)/Secure(1)
7467  *                    |  |  |  +--------- HCR mask override
7468  *                    |  |  +------------ SCR exec state control
7469  *                    |  +--------------- SCR mask override
7470  *                    +------------------ 32-bit(0)/64-bit(1) EL3
7471  *
7472  *    The table values are as such:
7473  *    0-3 = EL0-EL3
7474  *     -1 = Cannot occur
7475  *
7476  * The ARM ARM target EL table includes entries indicating that an "exception
7477  * is not taken".  The two cases where this is applicable are:
7478  *    1) An exception is taken from EL3 but the SCR does not have the exception
7479  *    routed to EL3.
7480  *    2) An exception is taken from EL2 but the HCR does not have the exception
7481  *    routed to EL2.
7482  * In these two cases, the below table contain a target of EL1.  This value is
7483  * returned as it is expected that the consumer of the table data will check
7484  * for "target EL >= current EL" to ensure the exception is not taken.
7485  *
7486  *            SCR     HCR
7487  *         64  EA     AMO                 From
7488  *        BIT IRQ     IMO      Non-secure         Secure
7489  *        EL3 FIQ  RW FMO   EL0 EL1 EL2 EL3   EL0 EL1 EL2 EL3
7490  */
7491 static const int8_t target_el_table[2][2][2][2][2][4] = {
7492     {{{{/* 0   0   0   0 */{ 1,  1,  2, -1 },{ 3, -1, -1,  3 },},
7493        {/* 0   0   0   1 */{ 2,  2,  2, -1 },{ 3, -1, -1,  3 },},},
7494       {{/* 0   0   1   0 */{ 1,  1,  2, -1 },{ 3, -1, -1,  3 },},
7495        {/* 0   0   1   1 */{ 2,  2,  2, -1 },{ 3, -1, -1,  3 },},},},
7496      {{{/* 0   1   0   0 */{ 3,  3,  3, -1 },{ 3, -1, -1,  3 },},
7497        {/* 0   1   0   1 */{ 3,  3,  3, -1 },{ 3, -1, -1,  3 },},},
7498       {{/* 0   1   1   0 */{ 3,  3,  3, -1 },{ 3, -1, -1,  3 },},
7499        {/* 0   1   1   1 */{ 3,  3,  3, -1 },{ 3, -1, -1,  3 },},},},},
7500     {{{{/* 1   0   0   0 */{ 1,  1,  2, -1 },{ 1,  1, -1,  1 },},
7501        {/* 1   0   0   1 */{ 2,  2,  2, -1 },{ 1,  1, -1,  1 },},},
7502       {{/* 1   0   1   0 */{ 1,  1,  1, -1 },{ 1,  1, -1,  1 },},
7503        {/* 1   0   1   1 */{ 2,  2,  2, -1 },{ 1,  1, -1,  1 },},},},
7504      {{{/* 1   1   0   0 */{ 3,  3,  3, -1 },{ 3,  3, -1,  3 },},
7505        {/* 1   1   0   1 */{ 3,  3,  3, -1 },{ 3,  3, -1,  3 },},},
7506       {{/* 1   1   1   0 */{ 3,  3,  3, -1 },{ 3,  3, -1,  3 },},
7507        {/* 1   1   1   1 */{ 3,  3,  3, -1 },{ 3,  3, -1,  3 },},},},},
7508 };
7509
7510 /*
7511  * Determine the target EL for physical exceptions
7512  */
7513 uint32_t arm_phys_excp_target_el(CPUState *cs, uint32_t excp_idx,
7514                                  uint32_t cur_el, bool secure)
7515 {
7516     CPUARMState *env = cs->env_ptr;
7517     bool rw;
7518     bool scr;
7519     bool hcr;
7520     int target_el;
7521     /* Is the highest EL AArch64? */
7522     bool is64 = arm_feature(env, ARM_FEATURE_AARCH64);
7523     uint64_t hcr_el2;
7524
7525     if (arm_feature(env, ARM_FEATURE_EL3)) {
7526         rw = ((env->cp15.scr_el3 & SCR_RW) == SCR_RW);
7527     } else {
7528         /* Either EL2 is the highest EL (and so the EL2 register width
7529          * is given by is64); or there is no EL2 or EL3, in which case
7530          * the value of 'rw' does not affect the table lookup anyway.
7531          */
7532         rw = is64;
7533     }
7534
7535     hcr_el2 = arm_hcr_el2_eff(env);
7536     switch (excp_idx) {
7537     case EXCP_IRQ:
7538         scr = ((env->cp15.scr_el3 & SCR_IRQ) == SCR_IRQ);
7539         hcr = hcr_el2 & HCR_IMO;
7540         break;
7541     case EXCP_FIQ:
7542         scr = ((env->cp15.scr_el3 & SCR_FIQ) == SCR_FIQ);
7543         hcr = hcr_el2 & HCR_FMO;
7544         break;
7545     default:
7546         scr = ((env->cp15.scr_el3 & SCR_EA) == SCR_EA);
7547         hcr = hcr_el2 & HCR_AMO;
7548         break;
7549     };
7550
7551     /* Perform a table-lookup for the target EL given the current state */
7552     target_el = target_el_table[is64][scr][rw][hcr][secure][cur_el];
7553
7554     assert(target_el > 0);
7555
7556     return target_el;
7557 }
7558
7559 /*
7560  * Return true if the v7M CPACR permits access to the FPU for the specified
7561  * security state and privilege level.
7562  */
7563 static bool v7m_cpacr_pass(CPUARMState *env, bool is_secure, bool is_priv)
7564 {
7565     switch (extract32(env->v7m.cpacr[is_secure], 20, 2)) {
7566     case 0:
7567     case 2: /* UNPREDICTABLE: we treat like 0 */
7568         return false;
7569     case 1:
7570         return is_priv;
7571     case 3:
7572         return true;
7573     default:
7574         g_assert_not_reached();
7575     }
7576 }
7577
7578 static bool v7m_stack_write(ARMCPU *cpu, uint32_t addr, uint32_t value,
7579                             ARMMMUIdx mmu_idx, bool ignfault)
7580 {
7581     CPUState *cs = CPU(cpu);
7582     CPUARMState *env = &cpu->env;
7583     MemTxAttrs attrs = {};
7584     MemTxResult txres;
7585     target_ulong page_size;
7586     hwaddr physaddr;
7587     int prot;
7588     ARMMMUFaultInfo fi = {};
7589     bool secure = mmu_idx & ARM_MMU_IDX_M_S;
7590     int exc;
7591     bool exc_secure;
7592
7593     if (get_phys_addr(env, addr, MMU_DATA_STORE, mmu_idx, &physaddr,
7594                       &attrs, &prot, &page_size, &fi, NULL)) {
7595         /* MPU/SAU lookup failed */
7596         if (fi.type == ARMFault_QEMU_SFault) {
7597             qemu_log_mask(CPU_LOG_INT,
7598                           "...SecureFault with SFSR.AUVIOL during stacking\n");
7599             env->v7m.sfsr |= R_V7M_SFSR_AUVIOL_MASK | R_V7M_SFSR_SFARVALID_MASK;
7600             env->v7m.sfar = addr;
7601             exc = ARMV7M_EXCP_SECURE;
7602             exc_secure = false;
7603         } else {
7604             qemu_log_mask(CPU_LOG_INT, "...MemManageFault with CFSR.MSTKERR\n");
7605             env->v7m.cfsr[secure] |= R_V7M_CFSR_MSTKERR_MASK;
7606             exc = ARMV7M_EXCP_MEM;
7607             exc_secure = secure;
7608         }
7609         goto pend_fault;
7610     }
7611     address_space_stl_le(arm_addressspace(cs, attrs), physaddr, value,
7612                          attrs, &txres);
7613     if (txres != MEMTX_OK) {
7614         /* BusFault trying to write the data */
7615         qemu_log_mask(CPU_LOG_INT, "...BusFault with BFSR.STKERR\n");
7616         env->v7m.cfsr[M_REG_NS] |= R_V7M_CFSR_STKERR_MASK;
7617         exc = ARMV7M_EXCP_BUS;
7618         exc_secure = false;
7619         goto pend_fault;
7620     }
7621     return true;
7622
7623 pend_fault:
7624     /* By pending the exception at this point we are making
7625      * the IMPDEF choice "overridden exceptions pended" (see the
7626      * MergeExcInfo() pseudocode). The other choice would be to not
7627      * pend them now and then make a choice about which to throw away
7628      * later if we have two derived exceptions.
7629      * The only case when we must not pend the exception but instead
7630      * throw it away is if we are doing the push of the callee registers
7631      * and we've already generated a derived exception. Even in this
7632      * case we will still update the fault status registers.
7633      */
7634     if (!ignfault) {
7635         armv7m_nvic_set_pending_derived(env->nvic, exc, exc_secure);
7636     }
7637     return false;
7638 }
7639
7640 static bool v7m_stack_read(ARMCPU *cpu, uint32_t *dest, uint32_t addr,
7641                            ARMMMUIdx mmu_idx)
7642 {
7643     CPUState *cs = CPU(cpu);
7644     CPUARMState *env = &cpu->env;
7645     MemTxAttrs attrs = {};
7646     MemTxResult txres;
7647     target_ulong page_size;
7648     hwaddr physaddr;
7649     int prot;
7650     ARMMMUFaultInfo fi = {};
7651     bool secure = mmu_idx & ARM_MMU_IDX_M_S;
7652     int exc;
7653     bool exc_secure;
7654     uint32_t value;
7655
7656     if (get_phys_addr(env, addr, MMU_DATA_LOAD, mmu_idx, &physaddr,
7657                       &attrs, &prot, &page_size, &fi, NULL)) {
7658         /* MPU/SAU lookup failed */
7659         if (fi.type == ARMFault_QEMU_SFault) {
7660             qemu_log_mask(CPU_LOG_INT,
7661                           "...SecureFault with SFSR.AUVIOL during unstack\n");
7662             env->v7m.sfsr |= R_V7M_SFSR_AUVIOL_MASK | R_V7M_SFSR_SFARVALID_MASK;
7663             env->v7m.sfar = addr;
7664             exc = ARMV7M_EXCP_SECURE;
7665             exc_secure = false;
7666         } else {
7667             qemu_log_mask(CPU_LOG_INT,
7668                           "...MemManageFault with CFSR.MUNSTKERR\n");
7669             env->v7m.cfsr[secure] |= R_V7M_CFSR_MUNSTKERR_MASK;
7670             exc = ARMV7M_EXCP_MEM;
7671             exc_secure = secure;
7672         }
7673         goto pend_fault;
7674     }
7675
7676     value = address_space_ldl(arm_addressspace(cs, attrs), physaddr,
7677                               attrs, &txres);
7678     if (txres != MEMTX_OK) {
7679         /* BusFault trying to read the data */
7680         qemu_log_mask(CPU_LOG_INT, "...BusFault with BFSR.UNSTKERR\n");
7681         env->v7m.cfsr[M_REG_NS] |= R_V7M_CFSR_UNSTKERR_MASK;
7682         exc = ARMV7M_EXCP_BUS;
7683         exc_secure = false;
7684         goto pend_fault;
7685     }
7686
7687     *dest = value;
7688     return true;
7689
7690 pend_fault:
7691     /* By pending the exception at this point we are making
7692      * the IMPDEF choice "overridden exceptions pended" (see the
7693      * MergeExcInfo() pseudocode). The other choice would be to not
7694      * pend them now and then make a choice about which to throw away
7695      * later if we have two derived exceptions.
7696      */
7697     armv7m_nvic_set_pending(env->nvic, exc, exc_secure);
7698     return false;
7699 }
7700
7701 /* Write to v7M CONTROL.SPSEL bit for the specified security bank.
7702  * This may change the current stack pointer between Main and Process
7703  * stack pointers if it is done for the CONTROL register for the current
7704  * security state.
7705  */
7706 static void write_v7m_control_spsel_for_secstate(CPUARMState *env,
7707                                                  bool new_spsel,
7708                                                  bool secstate)
7709 {
7710     bool old_is_psp = v7m_using_psp(env);
7711
7712     env->v7m.control[secstate] =
7713         deposit32(env->v7m.control[secstate],
7714                   R_V7M_CONTROL_SPSEL_SHIFT,
7715                   R_V7M_CONTROL_SPSEL_LENGTH, new_spsel);
7716
7717     if (secstate == env->v7m.secure) {
7718         bool new_is_psp = v7m_using_psp(env);
7719         uint32_t tmp;
7720
7721         if (old_is_psp != new_is_psp) {
7722             tmp = env->v7m.other_sp;
7723             env->v7m.other_sp = env->regs[13];
7724             env->regs[13] = tmp;
7725         }
7726     }
7727 }
7728
7729 /* Write to v7M CONTROL.SPSEL bit. This may change the current
7730  * stack pointer between Main and Process stack pointers.
7731  */
7732 static void write_v7m_control_spsel(CPUARMState *env, bool new_spsel)
7733 {
7734     write_v7m_control_spsel_for_secstate(env, new_spsel, env->v7m.secure);
7735 }
7736
7737 void write_v7m_exception(CPUARMState *env, uint32_t new_exc)
7738 {
7739     /* Write a new value to v7m.exception, thus transitioning into or out
7740      * of Handler mode; this may result in a change of active stack pointer.
7741      */
7742     bool new_is_psp, old_is_psp = v7m_using_psp(env);
7743     uint32_t tmp;
7744
7745     env->v7m.exception = new_exc;
7746
7747     new_is_psp = v7m_using_psp(env);
7748
7749     if (old_is_psp != new_is_psp) {
7750         tmp = env->v7m.other_sp;
7751         env->v7m.other_sp = env->regs[13];
7752         env->regs[13] = tmp;
7753     }
7754 }
7755
7756 /* Switch M profile security state between NS and S */
7757 static void switch_v7m_security_state(CPUARMState *env, bool new_secstate)
7758 {
7759     uint32_t new_ss_msp, new_ss_psp;
7760
7761     if (env->v7m.secure == new_secstate) {
7762         return;
7763     }
7764
7765     /* All the banked state is accessed by looking at env->v7m.secure
7766      * except for the stack pointer; rearrange the SP appropriately.
7767      */
7768     new_ss_msp = env->v7m.other_ss_msp;
7769     new_ss_psp = env->v7m.other_ss_psp;
7770
7771     if (v7m_using_psp(env)) {
7772         env->v7m.other_ss_psp = env->regs[13];
7773         env->v7m.other_ss_msp = env->v7m.other_sp;
7774     } else {
7775         env->v7m.other_ss_msp = env->regs[13];
7776         env->v7m.other_ss_psp = env->v7m.other_sp;
7777     }
7778
7779     env->v7m.secure = new_secstate;
7780
7781     if (v7m_using_psp(env)) {
7782         env->regs[13] = new_ss_psp;
7783         env->v7m.other_sp = new_ss_msp;
7784     } else {
7785         env->regs[13] = new_ss_msp;
7786         env->v7m.other_sp = new_ss_psp;
7787     }
7788 }
7789
7790 void HELPER(v7m_bxns)(CPUARMState *env, uint32_t dest)
7791 {
7792     /* Handle v7M BXNS:
7793      *  - if the return value is a magic value, do exception return (like BX)
7794      *  - otherwise bit 0 of the return value is the target security state
7795      */
7796     uint32_t min_magic;
7797
7798     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
7799         /* Covers FNC_RETURN and EXC_RETURN magic */
7800         min_magic = FNC_RETURN_MIN_MAGIC;
7801     } else {
7802         /* EXC_RETURN magic only */
7803         min_magic = EXC_RETURN_MIN_MAGIC;
7804     }
7805
7806     if (dest >= min_magic) {
7807         /* This is an exception return magic value; put it where
7808          * do_v7m_exception_exit() expects and raise EXCEPTION_EXIT.
7809          * Note that if we ever add gen_ss_advance() singlestep support to
7810          * M profile this should count as an "instruction execution complete"
7811          * event (compare gen_bx_excret_final_code()).
7812          */
7813         env->regs[15] = dest & ~1;
7814         env->thumb = dest & 1;
7815         HELPER(exception_internal)(env, EXCP_EXCEPTION_EXIT);
7816         /* notreached */
7817     }
7818
7819     /* translate.c should have made BXNS UNDEF unless we're secure */
7820     assert(env->v7m.secure);
7821
7822     switch_v7m_security_state(env, dest & 1);
7823     env->thumb = 1;
7824     env->regs[15] = dest & ~1;
7825 }
7826
7827 void HELPER(v7m_blxns)(CPUARMState *env, uint32_t dest)
7828 {
7829     /* Handle v7M BLXNS:
7830      *  - bit 0 of the destination address is the target security state
7831      */
7832
7833     /* At this point regs[15] is the address just after the BLXNS */
7834     uint32_t nextinst = env->regs[15] | 1;
7835     uint32_t sp = env->regs[13] - 8;
7836     uint32_t saved_psr;
7837
7838     /* translate.c will have made BLXNS UNDEF unless we're secure */
7839     assert(env->v7m.secure);
7840
7841     if (dest & 1) {
7842         /* target is Secure, so this is just a normal BLX,
7843          * except that the low bit doesn't indicate Thumb/not.
7844          */
7845         env->regs[14] = nextinst;
7846         env->thumb = 1;
7847         env->regs[15] = dest & ~1;
7848         return;
7849     }
7850
7851     /* Target is non-secure: first push a stack frame */
7852     if (!QEMU_IS_ALIGNED(sp, 8)) {
7853         qemu_log_mask(LOG_GUEST_ERROR,
7854                       "BLXNS with misaligned SP is UNPREDICTABLE\n");
7855     }
7856
7857     if (sp < v7m_sp_limit(env)) {
7858         raise_exception(env, EXCP_STKOF, 0, 1);
7859     }
7860
7861     saved_psr = env->v7m.exception;
7862     if (env->v7m.control[M_REG_S] & R_V7M_CONTROL_SFPA_MASK) {
7863         saved_psr |= XPSR_SFPA;
7864     }
7865
7866     /* Note that these stores can throw exceptions on MPU faults */
7867     cpu_stl_data(env, sp, nextinst);
7868     cpu_stl_data(env, sp + 4, saved_psr);
7869
7870     env->regs[13] = sp;
7871     env->regs[14] = 0xfeffffff;
7872     if (arm_v7m_is_handler_mode(env)) {
7873         /* Write a dummy value to IPSR, to avoid leaking the current secure
7874          * exception number to non-secure code. This is guaranteed not
7875          * to cause write_v7m_exception() to actually change stacks.
7876          */
7877         write_v7m_exception(env, 1);
7878     }
7879     switch_v7m_security_state(env, 0);
7880     env->thumb = 1;
7881     env->regs[15] = dest;
7882 }
7883
7884 static uint32_t *get_v7m_sp_ptr(CPUARMState *env, bool secure, bool threadmode,
7885                                 bool spsel)
7886 {
7887     /* Return a pointer to the location where we currently store the
7888      * stack pointer for the requested security state and thread mode.
7889      * This pointer will become invalid if the CPU state is updated
7890      * such that the stack pointers are switched around (eg changing
7891      * the SPSEL control bit).
7892      * Compare the v8M ARM ARM pseudocode LookUpSP_with_security_mode().
7893      * Unlike that pseudocode, we require the caller to pass us in the
7894      * SPSEL control bit value; this is because we also use this
7895      * function in handling of pushing of the callee-saves registers
7896      * part of the v8M stack frame (pseudocode PushCalleeStack()),
7897      * and in the tailchain codepath the SPSEL bit comes from the exception
7898      * return magic LR value from the previous exception. The pseudocode
7899      * opencodes the stack-selection in PushCalleeStack(), but we prefer
7900      * to make this utility function generic enough to do the job.
7901      */
7902     bool want_psp = threadmode && spsel;
7903
7904     if (secure == env->v7m.secure) {
7905         if (want_psp == v7m_using_psp(env)) {
7906             return &env->regs[13];
7907         } else {
7908             return &env->v7m.other_sp;
7909         }
7910     } else {
7911         if (want_psp) {
7912             return &env->v7m.other_ss_psp;
7913         } else {
7914             return &env->v7m.other_ss_msp;
7915         }
7916     }
7917 }
7918
7919 static bool arm_v7m_load_vector(ARMCPU *cpu, int exc, bool targets_secure,
7920                                 uint32_t *pvec)
7921 {
7922     CPUState *cs = CPU(cpu);
7923     CPUARMState *env = &cpu->env;
7924     MemTxResult result;
7925     uint32_t addr = env->v7m.vecbase[targets_secure] + exc * 4;
7926     uint32_t vector_entry;
7927     MemTxAttrs attrs = {};
7928     ARMMMUIdx mmu_idx;
7929     bool exc_secure;
7930
7931     mmu_idx = arm_v7m_mmu_idx_for_secstate_and_priv(env, targets_secure, true);
7932
7933     /* We don't do a get_phys_addr() here because the rules for vector
7934      * loads are special: they always use the default memory map, and
7935      * the default memory map permits reads from all addresses.
7936      * Since there's no easy way to pass through to pmsav8_mpu_lookup()
7937      * that we want this special case which would always say "yes",
7938      * we just do the SAU lookup here followed by a direct physical load.
7939      */
7940     attrs.secure = targets_secure;
7941     attrs.user = false;
7942
7943     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
7944         V8M_SAttributes sattrs = {};
7945
7946         v8m_security_lookup(env, addr, MMU_DATA_LOAD, mmu_idx, &sattrs);
7947         if (sattrs.ns) {
7948             attrs.secure = false;
7949         } else if (!targets_secure) {
7950             /* NS access to S memory */
7951             goto load_fail;
7952         }
7953     }
7954
7955     vector_entry = address_space_ldl(arm_addressspace(cs, attrs), addr,
7956                                      attrs, &result);
7957     if (result != MEMTX_OK) {
7958         goto load_fail;
7959     }
7960     *pvec = vector_entry;
7961     return true;
7962
7963 load_fail:
7964     /* All vector table fetch fails are reported as HardFault, with
7965      * HFSR.VECTTBL and .FORCED set. (FORCED is set because
7966      * technically the underlying exception is a MemManage or BusFault
7967      * that is escalated to HardFault.) This is a terminal exception,
7968      * so we will either take the HardFault immediately or else enter
7969      * lockup (the latter case is handled in armv7m_nvic_set_pending_derived()).
7970      */
7971     exc_secure = targets_secure ||
7972         !(cpu->env.v7m.aircr & R_V7M_AIRCR_BFHFNMINS_MASK);
7973     env->v7m.hfsr |= R_V7M_HFSR_VECTTBL_MASK | R_V7M_HFSR_FORCED_MASK;
7974     armv7m_nvic_set_pending_derived(env->nvic, ARMV7M_EXCP_HARD, exc_secure);
7975     return false;
7976 }
7977
7978 static bool v7m_push_callee_stack(ARMCPU *cpu, uint32_t lr, bool dotailchain,
7979                                   bool ignore_faults)
7980 {
7981     /* For v8M, push the callee-saves register part of the stack frame.
7982      * Compare the v8M pseudocode PushCalleeStack().
7983      * In the tailchaining case this may not be the current stack.
7984      */
7985     CPUARMState *env = &cpu->env;
7986     uint32_t *frame_sp_p;
7987     uint32_t frameptr;
7988     ARMMMUIdx mmu_idx;
7989     bool stacked_ok;
7990     uint32_t limit;
7991     bool want_psp;
7992
7993     if (dotailchain) {
7994         bool mode = lr & R_V7M_EXCRET_MODE_MASK;
7995         bool priv = !(env->v7m.control[M_REG_S] & R_V7M_CONTROL_NPRIV_MASK) ||
7996             !mode;
7997
7998         mmu_idx = arm_v7m_mmu_idx_for_secstate_and_priv(env, M_REG_S, priv);
7999         frame_sp_p = get_v7m_sp_ptr(env, M_REG_S, mode,
8000                                     lr & R_V7M_EXCRET_SPSEL_MASK);
8001         want_psp = mode && (lr & R_V7M_EXCRET_SPSEL_MASK);
8002         if (want_psp) {
8003             limit = env->v7m.psplim[M_REG_S];
8004         } else {
8005             limit = env->v7m.msplim[M_REG_S];
8006         }
8007     } else {
8008         mmu_idx = arm_mmu_idx(env);
8009         frame_sp_p = &env->regs[13];
8010         limit = v7m_sp_limit(env);
8011     }
8012
8013     frameptr = *frame_sp_p - 0x28;
8014     if (frameptr < limit) {
8015         /*
8016          * Stack limit failure: set SP to the limit value, and generate
8017          * STKOF UsageFault. Stack pushes below the limit must not be
8018          * performed. It is IMPDEF whether pushes above the limit are
8019          * performed; we choose not to.
8020          */
8021         qemu_log_mask(CPU_LOG_INT,
8022                       "...STKOF during callee-saves register stacking\n");
8023         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_STKOF_MASK;
8024         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE,
8025                                 env->v7m.secure);
8026         *frame_sp_p = limit;
8027         return true;
8028     }
8029
8030     /* Write as much of the stack frame as we can. A write failure may
8031      * cause us to pend a derived exception.
8032      */
8033     stacked_ok =
8034         v7m_stack_write(cpu, frameptr, 0xfefa125b, mmu_idx, ignore_faults) &&
8035         v7m_stack_write(cpu, frameptr + 0x8, env->regs[4], mmu_idx,
8036                         ignore_faults) &&
8037         v7m_stack_write(cpu, frameptr + 0xc, env->regs[5], mmu_idx,
8038                         ignore_faults) &&
8039         v7m_stack_write(cpu, frameptr + 0x10, env->regs[6], mmu_idx,
8040                         ignore_faults) &&
8041         v7m_stack_write(cpu, frameptr + 0x14, env->regs[7], mmu_idx,
8042                         ignore_faults) &&
8043         v7m_stack_write(cpu, frameptr + 0x18, env->regs[8], mmu_idx,
8044                         ignore_faults) &&
8045         v7m_stack_write(cpu, frameptr + 0x1c, env->regs[9], mmu_idx,
8046                         ignore_faults) &&
8047         v7m_stack_write(cpu, frameptr + 0x20, env->regs[10], mmu_idx,
8048                         ignore_faults) &&
8049         v7m_stack_write(cpu, frameptr + 0x24, env->regs[11], mmu_idx,
8050                         ignore_faults);
8051
8052     /* Update SP regardless of whether any of the stack accesses failed. */
8053     *frame_sp_p = frameptr;
8054
8055     return !stacked_ok;
8056 }
8057
8058 static void v7m_exception_taken(ARMCPU *cpu, uint32_t lr, bool dotailchain,
8059                                 bool ignore_stackfaults)
8060 {
8061     /* Do the "take the exception" parts of exception entry,
8062      * but not the pushing of state to the stack. This is
8063      * similar to the pseudocode ExceptionTaken() function.
8064      */
8065     CPUARMState *env = &cpu->env;
8066     uint32_t addr;
8067     bool targets_secure;
8068     int exc;
8069     bool push_failed = false;
8070
8071     armv7m_nvic_get_pending_irq_info(env->nvic, &exc, &targets_secure);
8072     qemu_log_mask(CPU_LOG_INT, "...taking pending %s exception %d\n",
8073                   targets_secure ? "secure" : "nonsecure", exc);
8074
8075     if (arm_feature(env, ARM_FEATURE_V8)) {
8076         if (arm_feature(env, ARM_FEATURE_M_SECURITY) &&
8077             (lr & R_V7M_EXCRET_S_MASK)) {
8078             /* The background code (the owner of the registers in the
8079              * exception frame) is Secure. This means it may either already
8080              * have or now needs to push callee-saves registers.
8081              */
8082             if (targets_secure) {
8083                 if (dotailchain && !(lr & R_V7M_EXCRET_ES_MASK)) {
8084                     /* We took an exception from Secure to NonSecure
8085                      * (which means the callee-saved registers got stacked)
8086                      * and are now tailchaining to a Secure exception.
8087                      * Clear DCRS so eventual return from this Secure
8088                      * exception unstacks the callee-saved registers.
8089                      */
8090                     lr &= ~R_V7M_EXCRET_DCRS_MASK;
8091                 }
8092             } else {
8093                 /* We're going to a non-secure exception; push the
8094                  * callee-saves registers to the stack now, if they're
8095                  * not already saved.
8096                  */
8097                 if (lr & R_V7M_EXCRET_DCRS_MASK &&
8098                     !(dotailchain && !(lr & R_V7M_EXCRET_ES_MASK))) {
8099                     push_failed = v7m_push_callee_stack(cpu, lr, dotailchain,
8100                                                         ignore_stackfaults);
8101                 }
8102                 lr |= R_V7M_EXCRET_DCRS_MASK;
8103             }
8104         }
8105
8106         lr &= ~R_V7M_EXCRET_ES_MASK;
8107         if (targets_secure || !arm_feature(env, ARM_FEATURE_M_SECURITY)) {
8108             lr |= R_V7M_EXCRET_ES_MASK;
8109         }
8110         lr &= ~R_V7M_EXCRET_SPSEL_MASK;
8111         if (env->v7m.control[targets_secure] & R_V7M_CONTROL_SPSEL_MASK) {
8112             lr |= R_V7M_EXCRET_SPSEL_MASK;
8113         }
8114
8115         /* Clear registers if necessary to prevent non-secure exception
8116          * code being able to see register values from secure code.
8117          * Where register values become architecturally UNKNOWN we leave
8118          * them with their previous values.
8119          */
8120         if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
8121             if (!targets_secure) {
8122                 /* Always clear the caller-saved registers (they have been
8123                  * pushed to the stack earlier in v7m_push_stack()).
8124                  * Clear callee-saved registers if the background code is
8125                  * Secure (in which case these regs were saved in
8126                  * v7m_push_callee_stack()).
8127                  */
8128                 int i;
8129
8130                 for (i = 0; i < 13; i++) {
8131                     /* r4..r11 are callee-saves, zero only if EXCRET.S == 1 */
8132                     if (i < 4 || i > 11 || (lr & R_V7M_EXCRET_S_MASK)) {
8133                         env->regs[i] = 0;
8134                     }
8135                 }
8136                 /* Clear EAPSR */
8137                 xpsr_write(env, 0, XPSR_NZCV | XPSR_Q | XPSR_GE | XPSR_IT);
8138             }
8139         }
8140     }
8141
8142     if (push_failed && !ignore_stackfaults) {
8143         /* Derived exception on callee-saves register stacking:
8144          * we might now want to take a different exception which
8145          * targets a different security state, so try again from the top.
8146          */
8147         qemu_log_mask(CPU_LOG_INT,
8148                       "...derived exception on callee-saves register stacking");
8149         v7m_exception_taken(cpu, lr, true, true);
8150         return;
8151     }
8152
8153     if (!arm_v7m_load_vector(cpu, exc, targets_secure, &addr)) {
8154         /* Vector load failed: derived exception */
8155         qemu_log_mask(CPU_LOG_INT, "...derived exception on vector table load");
8156         v7m_exception_taken(cpu, lr, true, true);
8157         return;
8158     }
8159
8160     /* Now we've done everything that might cause a derived exception
8161      * we can go ahead and activate whichever exception we're going to
8162      * take (which might now be the derived exception).
8163      */
8164     armv7m_nvic_acknowledge_irq(env->nvic);
8165
8166     /* Switch to target security state -- must do this before writing SPSEL */
8167     switch_v7m_security_state(env, targets_secure);
8168     write_v7m_control_spsel(env, 0);
8169     arm_clear_exclusive(env);
8170     /* Clear IT bits */
8171     env->condexec_bits = 0;
8172     env->regs[14] = lr;
8173     env->regs[15] = addr & 0xfffffffe;
8174     env->thumb = addr & 1;
8175 }
8176
8177 static bool v7m_push_stack(ARMCPU *cpu)
8178 {
8179     /* Do the "set up stack frame" part of exception entry,
8180      * similar to pseudocode PushStack().
8181      * Return true if we generate a derived exception (and so
8182      * should ignore further stack faults trying to process
8183      * that derived exception.)
8184      */
8185     bool stacked_ok;
8186     CPUARMState *env = &cpu->env;
8187     uint32_t xpsr = xpsr_read(env);
8188     uint32_t frameptr = env->regs[13];
8189     ARMMMUIdx mmu_idx = arm_mmu_idx(env);
8190
8191     /* Align stack pointer if the guest wants that */
8192     if ((frameptr & 4) &&
8193         (env->v7m.ccr[env->v7m.secure] & R_V7M_CCR_STKALIGN_MASK)) {
8194         frameptr -= 4;
8195         xpsr |= XPSR_SPREALIGN;
8196     }
8197
8198     frameptr -= 0x20;
8199
8200     if (arm_feature(env, ARM_FEATURE_V8)) {
8201         uint32_t limit = v7m_sp_limit(env);
8202
8203         if (frameptr < limit) {
8204             /*
8205              * Stack limit failure: set SP to the limit value, and generate
8206              * STKOF UsageFault. Stack pushes below the limit must not be
8207              * performed. It is IMPDEF whether pushes above the limit are
8208              * performed; we choose not to.
8209              */
8210             qemu_log_mask(CPU_LOG_INT,
8211                           "...STKOF during stacking\n");
8212             env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_STKOF_MASK;
8213             armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE,
8214                                     env->v7m.secure);
8215             env->regs[13] = limit;
8216             return true;
8217         }
8218     }
8219
8220     /* Write as much of the stack frame as we can. If we fail a stack
8221      * write this will result in a derived exception being pended
8222      * (which may be taken in preference to the one we started with
8223      * if it has higher priority).
8224      */
8225     stacked_ok =
8226         v7m_stack_write(cpu, frameptr, env->regs[0], mmu_idx, false) &&
8227         v7m_stack_write(cpu, frameptr + 4, env->regs[1], mmu_idx, false) &&
8228         v7m_stack_write(cpu, frameptr + 8, env->regs[2], mmu_idx, false) &&
8229         v7m_stack_write(cpu, frameptr + 12, env->regs[3], mmu_idx, false) &&
8230         v7m_stack_write(cpu, frameptr + 16, env->regs[12], mmu_idx, false) &&
8231         v7m_stack_write(cpu, frameptr + 20, env->regs[14], mmu_idx, false) &&
8232         v7m_stack_write(cpu, frameptr + 24, env->regs[15], mmu_idx, false) &&
8233         v7m_stack_write(cpu, frameptr + 28, xpsr, mmu_idx, false);
8234
8235     /* Update SP regardless of whether any of the stack accesses failed. */
8236     env->regs[13] = frameptr;
8237
8238     return !stacked_ok;
8239 }
8240
8241 static void do_v7m_exception_exit(ARMCPU *cpu)
8242 {
8243     CPUARMState *env = &cpu->env;
8244     uint32_t excret;
8245     uint32_t xpsr;
8246     bool ufault = false;
8247     bool sfault = false;
8248     bool return_to_sp_process;
8249     bool return_to_handler;
8250     bool rettobase = false;
8251     bool exc_secure = false;
8252     bool return_to_secure;
8253
8254     /* If we're not in Handler mode then jumps to magic exception-exit
8255      * addresses don't have magic behaviour. However for the v8M
8256      * security extensions the magic secure-function-return has to
8257      * work in thread mode too, so to avoid doing an extra check in
8258      * the generated code we allow exception-exit magic to also cause the
8259      * internal exception and bring us here in thread mode. Correct code
8260      * will never try to do this (the following insn fetch will always
8261      * fault) so we the overhead of having taken an unnecessary exception
8262      * doesn't matter.
8263      */
8264     if (!arm_v7m_is_handler_mode(env)) {
8265         return;
8266     }
8267
8268     /* In the spec pseudocode ExceptionReturn() is called directly
8269      * from BXWritePC() and gets the full target PC value including
8270      * bit zero. In QEMU's implementation we treat it as a normal
8271      * jump-to-register (which is then caught later on), and so split
8272      * the target value up between env->regs[15] and env->thumb in
8273      * gen_bx(). Reconstitute it.
8274      */
8275     excret = env->regs[15];
8276     if (env->thumb) {
8277         excret |= 1;
8278     }
8279
8280     qemu_log_mask(CPU_LOG_INT, "Exception return: magic PC %" PRIx32
8281                   " previous exception %d\n",
8282                   excret, env->v7m.exception);
8283
8284     if ((excret & R_V7M_EXCRET_RES1_MASK) != R_V7M_EXCRET_RES1_MASK) {
8285         qemu_log_mask(LOG_GUEST_ERROR, "M profile: zero high bits in exception "
8286                       "exit PC value 0x%" PRIx32 " are UNPREDICTABLE\n",
8287                       excret);
8288     }
8289
8290     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
8291         /* EXC_RETURN.ES validation check (R_SMFL). We must do this before
8292          * we pick which FAULTMASK to clear.
8293          */
8294         if (!env->v7m.secure &&
8295             ((excret & R_V7M_EXCRET_ES_MASK) ||
8296              !(excret & R_V7M_EXCRET_DCRS_MASK))) {
8297             sfault = 1;
8298             /* For all other purposes, treat ES as 0 (R_HXSR) */
8299             excret &= ~R_V7M_EXCRET_ES_MASK;
8300         }
8301         exc_secure = excret & R_V7M_EXCRET_ES_MASK;
8302     }
8303
8304     if (env->v7m.exception != ARMV7M_EXCP_NMI) {
8305         /* Auto-clear FAULTMASK on return from other than NMI.
8306          * If the security extension is implemented then this only
8307          * happens if the raw execution priority is >= 0; the
8308          * value of the ES bit in the exception return value indicates
8309          * which security state's faultmask to clear. (v8M ARM ARM R_KBNF.)
8310          */
8311         if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
8312             if (armv7m_nvic_raw_execution_priority(env->nvic) >= 0) {
8313                 env->v7m.faultmask[exc_secure] = 0;
8314             }
8315         } else {
8316             env->v7m.faultmask[M_REG_NS] = 0;
8317         }
8318     }
8319
8320     switch (armv7m_nvic_complete_irq(env->nvic, env->v7m.exception,
8321                                      exc_secure)) {
8322     case -1:
8323         /* attempt to exit an exception that isn't active */
8324         ufault = true;
8325         break;
8326     case 0:
8327         /* still an irq active now */
8328         break;
8329     case 1:
8330         /* we returned to base exception level, no nesting.
8331          * (In the pseudocode this is written using "NestedActivation != 1"
8332          * where we have 'rettobase == false'.)
8333          */
8334         rettobase = true;
8335         break;
8336     default:
8337         g_assert_not_reached();
8338     }
8339
8340     return_to_handler = !(excret & R_V7M_EXCRET_MODE_MASK);
8341     return_to_sp_process = excret & R_V7M_EXCRET_SPSEL_MASK;
8342     return_to_secure = arm_feature(env, ARM_FEATURE_M_SECURITY) &&
8343         (excret & R_V7M_EXCRET_S_MASK);
8344
8345     if (arm_feature(env, ARM_FEATURE_V8)) {
8346         if (!arm_feature(env, ARM_FEATURE_M_SECURITY)) {
8347             /* UNPREDICTABLE if S == 1 or DCRS == 0 or ES == 1 (R_XLCP);
8348              * we choose to take the UsageFault.
8349              */
8350             if ((excret & R_V7M_EXCRET_S_MASK) ||
8351                 (excret & R_V7M_EXCRET_ES_MASK) ||
8352                 !(excret & R_V7M_EXCRET_DCRS_MASK)) {
8353                 ufault = true;
8354             }
8355         }
8356         if (excret & R_V7M_EXCRET_RES0_MASK) {
8357             ufault = true;
8358         }
8359     } else {
8360         /* For v7M we only recognize certain combinations of the low bits */
8361         switch (excret & 0xf) {
8362         case 1: /* Return to Handler */
8363             break;
8364         case 13: /* Return to Thread using Process stack */
8365         case 9: /* Return to Thread using Main stack */
8366             /* We only need to check NONBASETHRDENA for v7M, because in
8367              * v8M this bit does not exist (it is RES1).
8368              */
8369             if (!rettobase &&
8370                 !(env->v7m.ccr[env->v7m.secure] &
8371                   R_V7M_CCR_NONBASETHRDENA_MASK)) {
8372                 ufault = true;
8373             }
8374             break;
8375         default:
8376             ufault = true;
8377         }
8378     }
8379
8380     /*
8381      * Set CONTROL.SPSEL from excret.SPSEL. Since we're still in
8382      * Handler mode (and will be until we write the new XPSR.Interrupt
8383      * field) this does not switch around the current stack pointer.
8384      * We must do this before we do any kind of tailchaining, including
8385      * for the derived exceptions on integrity check failures, or we will
8386      * give the guest an incorrect EXCRET.SPSEL value on exception entry.
8387      */
8388     write_v7m_control_spsel_for_secstate(env, return_to_sp_process, exc_secure);
8389
8390     if (sfault) {
8391         env->v7m.sfsr |= R_V7M_SFSR_INVER_MASK;
8392         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SECURE, false);
8393         qemu_log_mask(CPU_LOG_INT, "...taking SecureFault on existing "
8394                       "stackframe: failed EXC_RETURN.ES validity check\n");
8395         v7m_exception_taken(cpu, excret, true, false);
8396         return;
8397     }
8398
8399     if (ufault) {
8400         /* Bad exception return: instead of popping the exception
8401          * stack, directly take a usage fault on the current stack.
8402          */
8403         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_INVPC_MASK;
8404         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, env->v7m.secure);
8405         qemu_log_mask(CPU_LOG_INT, "...taking UsageFault on existing "
8406                       "stackframe: failed exception return integrity check\n");
8407         v7m_exception_taken(cpu, excret, true, false);
8408         return;
8409     }
8410
8411     /*
8412      * Tailchaining: if there is currently a pending exception that
8413      * is high enough priority to preempt execution at the level we're
8414      * about to return to, then just directly take that exception now,
8415      * avoiding an unstack-and-then-stack. Note that now we have
8416      * deactivated the previous exception by calling armv7m_nvic_complete_irq()
8417      * our current execution priority is already the execution priority we are
8418      * returning to -- none of the state we would unstack or set based on
8419      * the EXCRET value affects it.
8420      */
8421     if (armv7m_nvic_can_take_pending_exception(env->nvic)) {
8422         qemu_log_mask(CPU_LOG_INT, "...tailchaining to pending exception\n");
8423         v7m_exception_taken(cpu, excret, true, false);
8424         return;
8425     }
8426
8427     switch_v7m_security_state(env, return_to_secure);
8428
8429     {
8430         /* The stack pointer we should be reading the exception frame from
8431          * depends on bits in the magic exception return type value (and
8432          * for v8M isn't necessarily the stack pointer we will eventually
8433          * end up resuming execution with). Get a pointer to the location
8434          * in the CPU state struct where the SP we need is currently being
8435          * stored; we will use and modify it in place.
8436          * We use this limited C variable scope so we don't accidentally
8437          * use 'frame_sp_p' after we do something that makes it invalid.
8438          */
8439         uint32_t *frame_sp_p = get_v7m_sp_ptr(env,
8440                                               return_to_secure,
8441                                               !return_to_handler,
8442                                               return_to_sp_process);
8443         uint32_t frameptr = *frame_sp_p;
8444         bool pop_ok = true;
8445         ARMMMUIdx mmu_idx;
8446         bool return_to_priv = return_to_handler ||
8447             !(env->v7m.control[return_to_secure] & R_V7M_CONTROL_NPRIV_MASK);
8448
8449         mmu_idx = arm_v7m_mmu_idx_for_secstate_and_priv(env, return_to_secure,
8450                                                         return_to_priv);
8451
8452         if (!QEMU_IS_ALIGNED(frameptr, 8) &&
8453             arm_feature(env, ARM_FEATURE_V8)) {
8454             qemu_log_mask(LOG_GUEST_ERROR,
8455                           "M profile exception return with non-8-aligned SP "
8456                           "for destination state is UNPREDICTABLE\n");
8457         }
8458
8459         /* Do we need to pop callee-saved registers? */
8460         if (return_to_secure &&
8461             ((excret & R_V7M_EXCRET_ES_MASK) == 0 ||
8462              (excret & R_V7M_EXCRET_DCRS_MASK) == 0)) {
8463             uint32_t expected_sig = 0xfefa125b;
8464             uint32_t actual_sig;
8465
8466             pop_ok = v7m_stack_read(cpu, &actual_sig, frameptr, mmu_idx);
8467
8468             if (pop_ok && expected_sig != actual_sig) {
8469                 /* Take a SecureFault on the current stack */
8470                 env->v7m.sfsr |= R_V7M_SFSR_INVIS_MASK;
8471                 armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SECURE, false);
8472                 qemu_log_mask(CPU_LOG_INT, "...taking SecureFault on existing "
8473                               "stackframe: failed exception return integrity "
8474                               "signature check\n");
8475                 v7m_exception_taken(cpu, excret, true, false);
8476                 return;
8477             }
8478
8479             pop_ok = pop_ok &&
8480                 v7m_stack_read(cpu, &env->regs[4], frameptr + 0x8, mmu_idx) &&
8481                 v7m_stack_read(cpu, &env->regs[5], frameptr + 0xc, mmu_idx) &&
8482                 v7m_stack_read(cpu, &env->regs[6], frameptr + 0x10, mmu_idx) &&
8483                 v7m_stack_read(cpu, &env->regs[7], frameptr + 0x14, mmu_idx) &&
8484                 v7m_stack_read(cpu, &env->regs[8], frameptr + 0x18, mmu_idx) &&
8485                 v7m_stack_read(cpu, &env->regs[9], frameptr + 0x1c, mmu_idx) &&
8486                 v7m_stack_read(cpu, &env->regs[10], frameptr + 0x20, mmu_idx) &&
8487                 v7m_stack_read(cpu, &env->regs[11], frameptr + 0x24, mmu_idx);
8488
8489             frameptr += 0x28;
8490         }
8491
8492         /* Pop registers */
8493         pop_ok = pop_ok &&
8494             v7m_stack_read(cpu, &env->regs[0], frameptr, mmu_idx) &&
8495             v7m_stack_read(cpu, &env->regs[1], frameptr + 0x4, mmu_idx) &&
8496             v7m_stack_read(cpu, &env->regs[2], frameptr + 0x8, mmu_idx) &&
8497             v7m_stack_read(cpu, &env->regs[3], frameptr + 0xc, mmu_idx) &&
8498             v7m_stack_read(cpu, &env->regs[12], frameptr + 0x10, mmu_idx) &&
8499             v7m_stack_read(cpu, &env->regs[14], frameptr + 0x14, mmu_idx) &&
8500             v7m_stack_read(cpu, &env->regs[15], frameptr + 0x18, mmu_idx) &&
8501             v7m_stack_read(cpu, &xpsr, frameptr + 0x1c, mmu_idx);
8502
8503         if (!pop_ok) {
8504             /* v7m_stack_read() pended a fault, so take it (as a tail
8505              * chained exception on the same stack frame)
8506              */
8507             qemu_log_mask(CPU_LOG_INT, "...derived exception on unstacking\n");
8508             v7m_exception_taken(cpu, excret, true, false);
8509             return;
8510         }
8511
8512         /* Returning from an exception with a PC with bit 0 set is defined
8513          * behaviour on v8M (bit 0 is ignored), but for v7M it was specified
8514          * to be UNPREDICTABLE. In practice actual v7M hardware seems to ignore
8515          * the lsbit, and there are several RTOSes out there which incorrectly
8516          * assume the r15 in the stack frame should be a Thumb-style "lsbit
8517          * indicates ARM/Thumb" value, so ignore the bit on v7M as well, but
8518          * complain about the badly behaved guest.
8519          */
8520         if (env->regs[15] & 1) {
8521             env->regs[15] &= ~1U;
8522             if (!arm_feature(env, ARM_FEATURE_V8)) {
8523                 qemu_log_mask(LOG_GUEST_ERROR,
8524                               "M profile return from interrupt with misaligned "
8525                               "PC is UNPREDICTABLE on v7M\n");
8526             }
8527         }
8528
8529         if (arm_feature(env, ARM_FEATURE_V8)) {
8530             /* For v8M we have to check whether the xPSR exception field
8531              * matches the EXCRET value for return to handler/thread
8532              * before we commit to changing the SP and xPSR.
8533              */
8534             bool will_be_handler = (xpsr & XPSR_EXCP) != 0;
8535             if (return_to_handler != will_be_handler) {
8536                 /* Take an INVPC UsageFault on the current stack.
8537                  * By this point we will have switched to the security state
8538                  * for the background state, so this UsageFault will target
8539                  * that state.
8540                  */
8541                 armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE,
8542                                         env->v7m.secure);
8543                 env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_INVPC_MASK;
8544                 qemu_log_mask(CPU_LOG_INT, "...taking UsageFault on existing "
8545                               "stackframe: failed exception return integrity "
8546                               "check\n");
8547                 v7m_exception_taken(cpu, excret, true, false);
8548                 return;
8549             }
8550         }
8551
8552         /* Commit to consuming the stack frame */
8553         frameptr += 0x20;
8554         /* Undo stack alignment (the SPREALIGN bit indicates that the original
8555          * pre-exception SP was not 8-aligned and we added a padding word to
8556          * align it, so we undo this by ORing in the bit that increases it
8557          * from the current 8-aligned value to the 8-unaligned value. (Adding 4
8558          * would work too but a logical OR is how the pseudocode specifies it.)
8559          */
8560         if (xpsr & XPSR_SPREALIGN) {
8561             frameptr |= 4;
8562         }
8563         *frame_sp_p = frameptr;
8564     }
8565     /* This xpsr_write() will invalidate frame_sp_p as it may switch stack */
8566     xpsr_write(env, xpsr, ~XPSR_SPREALIGN);
8567
8568     /* The restored xPSR exception field will be zero if we're
8569      * resuming in Thread mode. If that doesn't match what the
8570      * exception return excret specified then this is a UsageFault.
8571      * v7M requires we make this check here; v8M did it earlier.
8572      */
8573     if (return_to_handler != arm_v7m_is_handler_mode(env)) {
8574         /* Take an INVPC UsageFault by pushing the stack again;
8575          * we know we're v7M so this is never a Secure UsageFault.
8576          */
8577         bool ignore_stackfaults;
8578
8579         assert(!arm_feature(env, ARM_FEATURE_V8));
8580         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, false);
8581         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_INVPC_MASK;
8582         ignore_stackfaults = v7m_push_stack(cpu);
8583         qemu_log_mask(CPU_LOG_INT, "...taking UsageFault on new stackframe: "
8584                       "failed exception return integrity check\n");
8585         v7m_exception_taken(cpu, excret, false, ignore_stackfaults);
8586         return;
8587     }
8588
8589     /* Otherwise, we have a successful exception exit. */
8590     arm_clear_exclusive(env);
8591     qemu_log_mask(CPU_LOG_INT, "...successful exception return\n");
8592 }
8593
8594 static bool do_v7m_function_return(ARMCPU *cpu)
8595 {
8596     /* v8M security extensions magic function return.
8597      * We may either:
8598      *  (1) throw an exception (longjump)
8599      *  (2) return true if we successfully handled the function return
8600      *  (3) return false if we failed a consistency check and have
8601      *      pended a UsageFault that needs to be taken now
8602      *
8603      * At this point the magic return value is split between env->regs[15]
8604      * and env->thumb. We don't bother to reconstitute it because we don't
8605      * need it (all values are handled the same way).
8606      */
8607     CPUARMState *env = &cpu->env;
8608     uint32_t newpc, newpsr, newpsr_exc;
8609
8610     qemu_log_mask(CPU_LOG_INT, "...really v7M secure function return\n");
8611
8612     {
8613         bool threadmode, spsel;
8614         TCGMemOpIdx oi;
8615         ARMMMUIdx mmu_idx;
8616         uint32_t *frame_sp_p;
8617         uint32_t frameptr;
8618
8619         /* Pull the return address and IPSR from the Secure stack */
8620         threadmode = !arm_v7m_is_handler_mode(env);
8621         spsel = env->v7m.control[M_REG_S] & R_V7M_CONTROL_SPSEL_MASK;
8622
8623         frame_sp_p = get_v7m_sp_ptr(env, true, threadmode, spsel);
8624         frameptr = *frame_sp_p;
8625
8626         /* These loads may throw an exception (for MPU faults). We want to
8627          * do them as secure, so work out what MMU index that is.
8628          */
8629         mmu_idx = arm_v7m_mmu_idx_for_secstate(env, true);
8630         oi = make_memop_idx(MO_LE, arm_to_core_mmu_idx(mmu_idx));
8631         newpc = helper_le_ldul_mmu(env, frameptr, oi, 0);
8632         newpsr = helper_le_ldul_mmu(env, frameptr + 4, oi, 0);
8633
8634         /* Consistency checks on new IPSR */
8635         newpsr_exc = newpsr & XPSR_EXCP;
8636         if (!((env->v7m.exception == 0 && newpsr_exc == 0) ||
8637               (env->v7m.exception == 1 && newpsr_exc != 0))) {
8638             /* Pend the fault and tell our caller to take it */
8639             env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_INVPC_MASK;
8640             armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE,
8641                                     env->v7m.secure);
8642             qemu_log_mask(CPU_LOG_INT,
8643                           "...taking INVPC UsageFault: "
8644                           "IPSR consistency check failed\n");
8645             return false;
8646         }
8647
8648         *frame_sp_p = frameptr + 8;
8649     }
8650
8651     /* This invalidates frame_sp_p */
8652     switch_v7m_security_state(env, true);
8653     env->v7m.exception = newpsr_exc;
8654     env->v7m.control[M_REG_S] &= ~R_V7M_CONTROL_SFPA_MASK;
8655     if (newpsr & XPSR_SFPA) {
8656         env->v7m.control[M_REG_S] |= R_V7M_CONTROL_SFPA_MASK;
8657     }
8658     xpsr_write(env, 0, XPSR_IT);
8659     env->thumb = newpc & 1;
8660     env->regs[15] = newpc & ~1;
8661
8662     qemu_log_mask(CPU_LOG_INT, "...function return successful\n");
8663     return true;
8664 }
8665
8666 static void arm_log_exception(int idx)
8667 {
8668     if (qemu_loglevel_mask(CPU_LOG_INT)) {
8669         const char *exc = NULL;
8670         static const char * const excnames[] = {
8671             [EXCP_UDEF] = "Undefined Instruction",
8672             [EXCP_SWI] = "SVC",
8673             [EXCP_PREFETCH_ABORT] = "Prefetch Abort",
8674             [EXCP_DATA_ABORT] = "Data Abort",
8675             [EXCP_IRQ] = "IRQ",
8676             [EXCP_FIQ] = "FIQ",
8677             [EXCP_BKPT] = "Breakpoint",
8678             [EXCP_EXCEPTION_EXIT] = "QEMU v7M exception exit",
8679             [EXCP_KERNEL_TRAP] = "QEMU intercept of kernel commpage",
8680             [EXCP_HVC] = "Hypervisor Call",
8681             [EXCP_HYP_TRAP] = "Hypervisor Trap",
8682             [EXCP_SMC] = "Secure Monitor Call",
8683             [EXCP_VIRQ] = "Virtual IRQ",
8684             [EXCP_VFIQ] = "Virtual FIQ",
8685             [EXCP_SEMIHOST] = "Semihosting call",
8686             [EXCP_NOCP] = "v7M NOCP UsageFault",
8687             [EXCP_INVSTATE] = "v7M INVSTATE UsageFault",
8688             [EXCP_STKOF] = "v8M STKOF UsageFault",
8689         };
8690
8691         if (idx >= 0 && idx < ARRAY_SIZE(excnames)) {
8692             exc = excnames[idx];
8693         }
8694         if (!exc) {
8695             exc = "unknown";
8696         }
8697         qemu_log_mask(CPU_LOG_INT, "Taking exception %d [%s]\n", idx, exc);
8698     }
8699 }
8700
8701 static bool v7m_read_half_insn(ARMCPU *cpu, ARMMMUIdx mmu_idx,
8702                                uint32_t addr, uint16_t *insn)
8703 {
8704     /* Load a 16-bit portion of a v7M instruction, returning true on success,
8705      * or false on failure (in which case we will have pended the appropriate
8706      * exception).
8707      * We need to do the instruction fetch's MPU and SAU checks
8708      * like this because there is no MMU index that would allow
8709      * doing the load with a single function call. Instead we must
8710      * first check that the security attributes permit the load
8711      * and that they don't mismatch on the two halves of the instruction,
8712      * and then we do the load as a secure load (ie using the security
8713      * attributes of the address, not the CPU, as architecturally required).
8714      */
8715     CPUState *cs = CPU(cpu);
8716     CPUARMState *env = &cpu->env;
8717     V8M_SAttributes sattrs = {};
8718     MemTxAttrs attrs = {};
8719     ARMMMUFaultInfo fi = {};
8720     MemTxResult txres;
8721     target_ulong page_size;
8722     hwaddr physaddr;
8723     int prot;
8724
8725     v8m_security_lookup(env, addr, MMU_INST_FETCH, mmu_idx, &sattrs);
8726     if (!sattrs.nsc || sattrs.ns) {
8727         /* This must be the second half of the insn, and it straddles a
8728          * region boundary with the second half not being S&NSC.
8729          */
8730         env->v7m.sfsr |= R_V7M_SFSR_INVEP_MASK;
8731         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SECURE, false);
8732         qemu_log_mask(CPU_LOG_INT,
8733                       "...really SecureFault with SFSR.INVEP\n");
8734         return false;
8735     }
8736     if (get_phys_addr(env, addr, MMU_INST_FETCH, mmu_idx,
8737                       &physaddr, &attrs, &prot, &page_size, &fi, NULL)) {
8738         /* the MPU lookup failed */
8739         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_IACCVIOL_MASK;
8740         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_MEM, env->v7m.secure);
8741         qemu_log_mask(CPU_LOG_INT, "...really MemManage with CFSR.IACCVIOL\n");
8742         return false;
8743     }
8744     *insn = address_space_lduw_le(arm_addressspace(cs, attrs), physaddr,
8745                                  attrs, &txres);
8746     if (txres != MEMTX_OK) {
8747         env->v7m.cfsr[M_REG_NS] |= R_V7M_CFSR_IBUSERR_MASK;
8748         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_BUS, false);
8749         qemu_log_mask(CPU_LOG_INT, "...really BusFault with CFSR.IBUSERR\n");
8750         return false;
8751     }
8752     return true;
8753 }
8754
8755 static bool v7m_handle_execute_nsc(ARMCPU *cpu)
8756 {
8757     /* Check whether this attempt to execute code in a Secure & NS-Callable
8758      * memory region is for an SG instruction; if so, then emulate the
8759      * effect of the SG instruction and return true. Otherwise pend
8760      * the correct kind of exception and return false.
8761      */
8762     CPUARMState *env = &cpu->env;
8763     ARMMMUIdx mmu_idx;
8764     uint16_t insn;
8765
8766     /* We should never get here unless get_phys_addr_pmsav8() caused
8767      * an exception for NS executing in S&NSC memory.
8768      */
8769     assert(!env->v7m.secure);
8770     assert(arm_feature(env, ARM_FEATURE_M_SECURITY));
8771
8772     /* We want to do the MPU lookup as secure; work out what mmu_idx that is */
8773     mmu_idx = arm_v7m_mmu_idx_for_secstate(env, true);
8774
8775     if (!v7m_read_half_insn(cpu, mmu_idx, env->regs[15], &insn)) {
8776         return false;
8777     }
8778
8779     if (!env->thumb) {
8780         goto gen_invep;
8781     }
8782
8783     if (insn != 0xe97f) {
8784         /* Not an SG instruction first half (we choose the IMPDEF
8785          * early-SG-check option).
8786          */
8787         goto gen_invep;
8788     }
8789
8790     if (!v7m_read_half_insn(cpu, mmu_idx, env->regs[15] + 2, &insn)) {
8791         return false;
8792     }
8793
8794     if (insn != 0xe97f) {
8795         /* Not an SG instruction second half (yes, both halves of the SG
8796          * insn have the same hex value)
8797          */
8798         goto gen_invep;
8799     }
8800
8801     /* OK, we have confirmed that we really have an SG instruction.
8802      * We know we're NS in S memory so don't need to repeat those checks.
8803      */
8804     qemu_log_mask(CPU_LOG_INT, "...really an SG instruction at 0x%08" PRIx32
8805                   ", executing it\n", env->regs[15]);
8806     env->regs[14] &= ~1;
8807     switch_v7m_security_state(env, true);
8808     xpsr_write(env, 0, XPSR_IT);
8809     env->regs[15] += 4;
8810     return true;
8811
8812 gen_invep:
8813     env->v7m.sfsr |= R_V7M_SFSR_INVEP_MASK;
8814     armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SECURE, false);
8815     qemu_log_mask(CPU_LOG_INT,
8816                   "...really SecureFault with SFSR.INVEP\n");
8817     return false;
8818 }
8819
8820 void arm_v7m_cpu_do_interrupt(CPUState *cs)
8821 {
8822     ARMCPU *cpu = ARM_CPU(cs);
8823     CPUARMState *env = &cpu->env;
8824     uint32_t lr;
8825     bool ignore_stackfaults;
8826
8827     arm_log_exception(cs->exception_index);
8828
8829     /* For exceptions we just mark as pending on the NVIC, and let that
8830        handle it.  */
8831     switch (cs->exception_index) {
8832     case EXCP_UDEF:
8833         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, env->v7m.secure);
8834         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_UNDEFINSTR_MASK;
8835         break;
8836     case EXCP_NOCP:
8837     {
8838         /*
8839          * NOCP might be directed to something other than the current
8840          * security state if this fault is because of NSACR; we indicate
8841          * the target security state using exception.target_el.
8842          */
8843         int target_secstate;
8844
8845         if (env->exception.target_el == 3) {
8846             target_secstate = M_REG_S;
8847         } else {
8848             target_secstate = env->v7m.secure;
8849         }
8850         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, target_secstate);
8851         env->v7m.cfsr[target_secstate] |= R_V7M_CFSR_NOCP_MASK;
8852         break;
8853     }
8854     case EXCP_INVSTATE:
8855         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, env->v7m.secure);
8856         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_INVSTATE_MASK;
8857         break;
8858     case EXCP_STKOF:
8859         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE, env->v7m.secure);
8860         env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_STKOF_MASK;
8861         break;
8862     case EXCP_SWI:
8863         /* The PC already points to the next instruction.  */
8864         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SVC, env->v7m.secure);
8865         break;
8866     case EXCP_PREFETCH_ABORT:
8867     case EXCP_DATA_ABORT:
8868         /* Note that for M profile we don't have a guest facing FSR, but
8869          * the env->exception.fsr will be populated by the code that
8870          * raises the fault, in the A profile short-descriptor format.
8871          */
8872         switch (env->exception.fsr & 0xf) {
8873         case M_FAKE_FSR_NSC_EXEC:
8874             /* Exception generated when we try to execute code at an address
8875              * which is marked as Secure & Non-Secure Callable and the CPU
8876              * is in the Non-Secure state. The only instruction which can
8877              * be executed like this is SG (and that only if both halves of
8878              * the SG instruction have the same security attributes.)
8879              * Everything else must generate an INVEP SecureFault, so we
8880              * emulate the SG instruction here.
8881              */
8882             if (v7m_handle_execute_nsc(cpu)) {
8883                 return;
8884             }
8885             break;
8886         case M_FAKE_FSR_SFAULT:
8887             /* Various flavours of SecureFault for attempts to execute or
8888              * access data in the wrong security state.
8889              */
8890             switch (cs->exception_index) {
8891             case EXCP_PREFETCH_ABORT:
8892                 if (env->v7m.secure) {
8893                     env->v7m.sfsr |= R_V7M_SFSR_INVTRAN_MASK;
8894                     qemu_log_mask(CPU_LOG_INT,
8895                                   "...really SecureFault with SFSR.INVTRAN\n");
8896                 } else {
8897                     env->v7m.sfsr |= R_V7M_SFSR_INVEP_MASK;
8898                     qemu_log_mask(CPU_LOG_INT,
8899                                   "...really SecureFault with SFSR.INVEP\n");
8900                 }
8901                 break;
8902             case EXCP_DATA_ABORT:
8903                 /* This must be an NS access to S memory */
8904                 env->v7m.sfsr |= R_V7M_SFSR_AUVIOL_MASK;
8905                 qemu_log_mask(CPU_LOG_INT,
8906                               "...really SecureFault with SFSR.AUVIOL\n");
8907                 break;
8908             }
8909             armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SECURE, false);
8910             break;
8911         case 0x8: /* External Abort */
8912             switch (cs->exception_index) {
8913             case EXCP_PREFETCH_ABORT:
8914                 env->v7m.cfsr[M_REG_NS] |= R_V7M_CFSR_IBUSERR_MASK;
8915                 qemu_log_mask(CPU_LOG_INT, "...with CFSR.IBUSERR\n");
8916                 break;
8917             case EXCP_DATA_ABORT:
8918                 env->v7m.cfsr[M_REG_NS] |=
8919                     (R_V7M_CFSR_PRECISERR_MASK | R_V7M_CFSR_BFARVALID_MASK);
8920                 env->v7m.bfar = env->exception.vaddress;
8921                 qemu_log_mask(CPU_LOG_INT,
8922                               "...with CFSR.PRECISERR and BFAR 0x%x\n",
8923                               env->v7m.bfar);
8924                 break;
8925             }
8926             armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_BUS, false);
8927             break;
8928         default:
8929             /* All other FSR values are either MPU faults or "can't happen
8930              * for M profile" cases.
8931              */
8932             switch (cs->exception_index) {
8933             case EXCP_PREFETCH_ABORT:
8934                 env->v7m.cfsr[env->v7m.secure] |= R_V7M_CFSR_IACCVIOL_MASK;
8935                 qemu_log_mask(CPU_LOG_INT, "...with CFSR.IACCVIOL\n");
8936                 break;
8937             case EXCP_DATA_ABORT:
8938                 env->v7m.cfsr[env->v7m.secure] |=
8939                     (R_V7M_CFSR_DACCVIOL_MASK | R_V7M_CFSR_MMARVALID_MASK);
8940                 env->v7m.mmfar[env->v7m.secure] = env->exception.vaddress;
8941                 qemu_log_mask(CPU_LOG_INT,
8942                               "...with CFSR.DACCVIOL and MMFAR 0x%x\n",
8943                               env->v7m.mmfar[env->v7m.secure]);
8944                 break;
8945             }
8946             armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_MEM,
8947                                     env->v7m.secure);
8948             break;
8949         }
8950         break;
8951     case EXCP_BKPT:
8952         if (semihosting_enabled()) {
8953             int nr;
8954             nr = arm_lduw_code(env, env->regs[15], arm_sctlr_b(env)) & 0xff;
8955             if (nr == 0xab) {
8956                 env->regs[15] += 2;
8957                 qemu_log_mask(CPU_LOG_INT,
8958                               "...handling as semihosting call 0x%x\n",
8959                               env->regs[0]);
8960                 env->regs[0] = do_arm_semihosting(env);
8961                 return;
8962             }
8963         }
8964         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_DEBUG, false);
8965         break;
8966     case EXCP_IRQ:
8967         break;
8968     case EXCP_EXCEPTION_EXIT:
8969         if (env->regs[15] < EXC_RETURN_MIN_MAGIC) {
8970             /* Must be v8M security extension function return */
8971             assert(env->regs[15] >= FNC_RETURN_MIN_MAGIC);
8972             assert(arm_feature(env, ARM_FEATURE_M_SECURITY));
8973             if (do_v7m_function_return(cpu)) {
8974                 return;
8975             }
8976         } else {
8977             do_v7m_exception_exit(cpu);
8978             return;
8979         }
8980         break;
8981     default:
8982         cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index);
8983         return; /* Never happens.  Keep compiler happy.  */
8984     }
8985
8986     if (arm_feature(env, ARM_FEATURE_V8)) {
8987         lr = R_V7M_EXCRET_RES1_MASK |
8988             R_V7M_EXCRET_DCRS_MASK |
8989             R_V7M_EXCRET_FTYPE_MASK;
8990         /* The S bit indicates whether we should return to Secure
8991          * or NonSecure (ie our current state).
8992          * The ES bit indicates whether we're taking this exception
8993          * to Secure or NonSecure (ie our target state). We set it
8994          * later, in v7m_exception_taken().
8995          * The SPSEL bit is also set in v7m_exception_taken() for v8M.
8996          * This corresponds to the ARM ARM pseudocode for v8M setting
8997          * some LR bits in PushStack() and some in ExceptionTaken();
8998          * the distinction matters for the tailchain cases where we
8999          * can take an exception without pushing the stack.
9000          */
9001         if (env->v7m.secure) {
9002             lr |= R_V7M_EXCRET_S_MASK;
9003         }
9004     } else {
9005         lr = R_V7M_EXCRET_RES1_MASK |
9006             R_V7M_EXCRET_S_MASK |
9007             R_V7M_EXCRET_DCRS_MASK |
9008             R_V7M_EXCRET_FTYPE_MASK |
9009             R_V7M_EXCRET_ES_MASK;
9010         if (env->v7m.control[M_REG_NS] & R_V7M_CONTROL_SPSEL_MASK) {
9011             lr |= R_V7M_EXCRET_SPSEL_MASK;
9012         }
9013     }
9014     if (!arm_v7m_is_handler_mode(env)) {
9015         lr |= R_V7M_EXCRET_MODE_MASK;
9016     }
9017
9018     ignore_stackfaults = v7m_push_stack(cpu);
9019     v7m_exception_taken(cpu, lr, false, ignore_stackfaults);
9020 }
9021
9022 /* Function used to synchronize QEMU's AArch64 register set with AArch32
9023  * register set.  This is necessary when switching between AArch32 and AArch64
9024  * execution state.
9025  */
9026 void aarch64_sync_32_to_64(CPUARMState *env)
9027 {
9028     int i;
9029     uint32_t mode = env->uncached_cpsr & CPSR_M;
9030
9031     /* We can blanket copy R[0:7] to X[0:7] */
9032     for (i = 0; i < 8; i++) {
9033         env->xregs[i] = env->regs[i];
9034     }
9035
9036     /* Unless we are in FIQ mode, x8-x12 come from the user registers r8-r12.
9037      * Otherwise, they come from the banked user regs.
9038      */
9039     if (mode == ARM_CPU_MODE_FIQ) {
9040         for (i = 8; i < 13; i++) {
9041             env->xregs[i] = env->usr_regs[i - 8];
9042         }
9043     } else {
9044         for (i = 8; i < 13; i++) {
9045             env->xregs[i] = env->regs[i];
9046         }
9047     }
9048
9049     /* Registers x13-x23 are the various mode SP and FP registers. Registers
9050      * r13 and r14 are only copied if we are in that mode, otherwise we copy
9051      * from the mode banked register.
9052      */
9053     if (mode == ARM_CPU_MODE_USR || mode == ARM_CPU_MODE_SYS) {
9054         env->xregs[13] = env->regs[13];
9055         env->xregs[14] = env->regs[14];
9056     } else {
9057         env->xregs[13] = env->banked_r13[bank_number(ARM_CPU_MODE_USR)];
9058         /* HYP is an exception in that it is copied from r14 */
9059         if (mode == ARM_CPU_MODE_HYP) {
9060             env->xregs[14] = env->regs[14];
9061         } else {
9062             env->xregs[14] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_USR)];
9063         }
9064     }
9065
9066     if (mode == ARM_CPU_MODE_HYP) {
9067         env->xregs[15] = env->regs[13];
9068     } else {
9069         env->xregs[15] = env->banked_r13[bank_number(ARM_CPU_MODE_HYP)];
9070     }
9071
9072     if (mode == ARM_CPU_MODE_IRQ) {
9073         env->xregs[16] = env->regs[14];
9074         env->xregs[17] = env->regs[13];
9075     } else {
9076         env->xregs[16] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_IRQ)];
9077         env->xregs[17] = env->banked_r13[bank_number(ARM_CPU_MODE_IRQ)];
9078     }
9079
9080     if (mode == ARM_CPU_MODE_SVC) {
9081         env->xregs[18] = env->regs[14];
9082         env->xregs[19] = env->regs[13];
9083     } else {
9084         env->xregs[18] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_SVC)];
9085         env->xregs[19] = env->banked_r13[bank_number(ARM_CPU_MODE_SVC)];
9086     }
9087
9088     if (mode == ARM_CPU_MODE_ABT) {
9089         env->xregs[20] = env->regs[14];
9090         env->xregs[21] = env->regs[13];
9091     } else {
9092         env->xregs[20] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_ABT)];
9093         env->xregs[21] = env->banked_r13[bank_number(ARM_CPU_MODE_ABT)];
9094     }
9095
9096     if (mode == ARM_CPU_MODE_UND) {
9097         env->xregs[22] = env->regs[14];
9098         env->xregs[23] = env->regs[13];
9099     } else {
9100         env->xregs[22] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_UND)];
9101         env->xregs[23] = env->banked_r13[bank_number(ARM_CPU_MODE_UND)];
9102     }
9103
9104     /* Registers x24-x30 are mapped to r8-r14 in FIQ mode.  If we are in FIQ
9105      * mode, then we can copy from r8-r14.  Otherwise, we copy from the
9106      * FIQ bank for r8-r14.
9107      */
9108     if (mode == ARM_CPU_MODE_FIQ) {
9109         for (i = 24; i < 31; i++) {
9110             env->xregs[i] = env->regs[i - 16];   /* X[24:30] <- R[8:14] */
9111         }
9112     } else {
9113         for (i = 24; i < 29; i++) {
9114             env->xregs[i] = env->fiq_regs[i - 24];
9115         }
9116         env->xregs[29] = env->banked_r13[bank_number(ARM_CPU_MODE_FIQ)];
9117         env->xregs[30] = env->banked_r14[r14_bank_number(ARM_CPU_MODE_FIQ)];
9118     }
9119
9120     env->pc = env->regs[15];
9121 }
9122
9123 /* Function used to synchronize QEMU's AArch32 register set with AArch64
9124  * register set.  This is necessary when switching between AArch32 and AArch64
9125  * execution state.
9126  */
9127 void aarch64_sync_64_to_32(CPUARMState *env)
9128 {
9129     int i;
9130     uint32_t mode = env->uncached_cpsr & CPSR_M;
9131
9132     /* We can blanket copy X[0:7] to R[0:7] */
9133     for (i = 0; i < 8; i++) {
9134         env->regs[i] = env->xregs[i];
9135     }
9136
9137     /* Unless we are in FIQ mode, r8-r12 come from the user registers x8-x12.
9138      * Otherwise, we copy x8-x12 into the banked user regs.
9139      */
9140     if (mode == ARM_CPU_MODE_FIQ) {
9141         for (i = 8; i < 13; i++) {
9142             env->usr_regs[i - 8] = env->xregs[i];
9143         }
9144     } else {
9145         for (i = 8; i < 13; i++) {
9146             env->regs[i] = env->xregs[i];
9147         }
9148     }
9149
9150     /* Registers r13 & r14 depend on the current mode.
9151      * If we are in a given mode, we copy the corresponding x registers to r13
9152      * and r14.  Otherwise, we copy the x register to the banked r13 and r14
9153      * for the mode.
9154      */
9155     if (mode == ARM_CPU_MODE_USR || mode == ARM_CPU_MODE_SYS) {
9156         env->regs[13] = env->xregs[13];
9157         env->regs[14] = env->xregs[14];
9158     } else {
9159         env->banked_r13[bank_number(ARM_CPU_MODE_USR)] = env->xregs[13];
9160
9161         /* HYP is an exception in that it does not have its own banked r14 but
9162          * shares the USR r14
9163          */
9164         if (mode == ARM_CPU_MODE_HYP) {
9165             env->regs[14] = env->xregs[14];
9166         } else {
9167             env->banked_r14[r14_bank_number(ARM_CPU_MODE_USR)] = env->xregs[14];
9168         }
9169     }
9170
9171     if (mode == ARM_CPU_MODE_HYP) {
9172         env->regs[13] = env->xregs[15];
9173     } else {
9174         env->banked_r13[bank_number(ARM_CPU_MODE_HYP)] = env->xregs[15];
9175     }
9176
9177     if (mode == ARM_CPU_MODE_IRQ) {
9178         env->regs[14] = env->xregs[16];
9179         env->regs[13] = env->xregs[17];
9180     } else {
9181         env->banked_r14[r14_bank_number(ARM_CPU_MODE_IRQ)] = env->xregs[16];
9182         env->banked_r13[bank_number(ARM_CPU_MODE_IRQ)] = env->xregs[17];
9183     }
9184
9185     if (mode == ARM_CPU_MODE_SVC) {
9186         env->regs[14] = env->xregs[18];
9187         env->regs[13] = env->xregs[19];
9188     } else {
9189         env->banked_r14[r14_bank_number(ARM_CPU_MODE_SVC)] = env->xregs[18];
9190         env->banked_r13[bank_number(ARM_CPU_MODE_SVC)] = env->xregs[19];
9191     }
9192
9193     if (mode == ARM_CPU_MODE_ABT) {
9194         env->regs[14] = env->xregs[20];
9195         env->regs[13] = env->xregs[21];
9196     } else {
9197         env->banked_r14[r14_bank_number(ARM_CPU_MODE_ABT)] = env->xregs[20];
9198         env->banked_r13[bank_number(ARM_CPU_MODE_ABT)] = env->xregs[21];
9199     }
9200
9201     if (mode == ARM_CPU_MODE_UND) {
9202         env->regs[14] = env->xregs[22];
9203         env->regs[13] = env->xregs[23];
9204     } else {
9205         env->banked_r14[r14_bank_number(ARM_CPU_MODE_UND)] = env->xregs[22];
9206         env->banked_r13[bank_number(ARM_CPU_MODE_UND)] = env->xregs[23];
9207     }
9208
9209     /* Registers x24-x30 are mapped to r8-r14 in FIQ mode.  If we are in FIQ
9210      * mode, then we can copy to r8-r14.  Otherwise, we copy to the
9211      * FIQ bank for r8-r14.
9212      */
9213     if (mode == ARM_CPU_MODE_FIQ) {
9214         for (i = 24; i < 31; i++) {
9215             env->regs[i - 16] = env->xregs[i];   /* X[24:30] -> R[8:14] */
9216         }
9217     } else {
9218         for (i = 24; i < 29; i++) {
9219             env->fiq_regs[i - 24] = env->xregs[i];
9220         }
9221         env->banked_r13[bank_number(ARM_CPU_MODE_FIQ)] = env->xregs[29];
9222         env->banked_r14[r14_bank_number(ARM_CPU_MODE_FIQ)] = env->xregs[30];
9223     }
9224
9225     env->regs[15] = env->pc;
9226 }
9227
9228 static void take_aarch32_exception(CPUARMState *env, int new_mode,
9229                                    uint32_t mask, uint32_t offset,
9230                                    uint32_t newpc)
9231 {
9232     /* Change the CPU state so as to actually take the exception. */
9233     switch_mode(env, new_mode);
9234     /*
9235      * For exceptions taken to AArch32 we must clear the SS bit in both
9236      * PSTATE and in the old-state value we save to SPSR_<mode>, so zero it now.
9237      */
9238     env->uncached_cpsr &= ~PSTATE_SS;
9239     env->spsr = cpsr_read(env);
9240     /* Clear IT bits.  */
9241     env->condexec_bits = 0;
9242     /* Switch to the new mode, and to the correct instruction set.  */
9243     env->uncached_cpsr = (env->uncached_cpsr & ~CPSR_M) | new_mode;
9244     /* Set new mode endianness */
9245     env->uncached_cpsr &= ~CPSR_E;
9246     if (env->cp15.sctlr_el[arm_current_el(env)] & SCTLR_EE) {
9247         env->uncached_cpsr |= CPSR_E;
9248     }
9249     /* J and IL must always be cleared for exception entry */
9250     env->uncached_cpsr &= ~(CPSR_IL | CPSR_J);
9251     env->daif |= mask;
9252
9253     if (new_mode == ARM_CPU_MODE_HYP) {
9254         env->thumb = (env->cp15.sctlr_el[2] & SCTLR_TE) != 0;
9255         env->elr_el[2] = env->regs[15];
9256     } else {
9257         /*
9258          * this is a lie, as there was no c1_sys on V4T/V5, but who cares
9259          * and we should just guard the thumb mode on V4
9260          */
9261         if (arm_feature(env, ARM_FEATURE_V4T)) {
9262             env->thumb =
9263                 (A32_BANKED_CURRENT_REG_GET(env, sctlr) & SCTLR_TE) != 0;
9264         }
9265         env->regs[14] = env->regs[15] + offset;
9266     }
9267     env->regs[15] = newpc;
9268 }
9269
9270 static void arm_cpu_do_interrupt_aarch32_hyp(CPUState *cs)
9271 {
9272     /*
9273      * Handle exception entry to Hyp mode; this is sufficiently
9274      * different to entry to other AArch32 modes that we handle it
9275      * separately here.
9276      *
9277      * The vector table entry used is always the 0x14 Hyp mode entry point,
9278      * unless this is an UNDEF/HVC/abort taken from Hyp to Hyp.
9279      * The offset applied to the preferred return address is always zero
9280      * (see DDI0487C.a section G1.12.3).
9281      * PSTATE A/I/F masks are set based only on the SCR.EA/IRQ/FIQ values.
9282      */
9283     uint32_t addr, mask;
9284     ARMCPU *cpu = ARM_CPU(cs);
9285     CPUARMState *env = &cpu->env;
9286
9287     switch (cs->exception_index) {
9288     case EXCP_UDEF:
9289         addr = 0x04;
9290         break;
9291     case EXCP_SWI:
9292         addr = 0x14;
9293         break;
9294     case EXCP_BKPT:
9295         /* Fall through to prefetch abort.  */
9296     case EXCP_PREFETCH_ABORT:
9297         env->cp15.ifar_s = env->exception.vaddress;
9298         qemu_log_mask(CPU_LOG_INT, "...with HIFAR 0x%x\n",
9299                       (uint32_t)env->exception.vaddress);
9300         addr = 0x0c;
9301         break;
9302     case EXCP_DATA_ABORT:
9303         env->cp15.dfar_s = env->exception.vaddress;
9304         qemu_log_mask(CPU_LOG_INT, "...with HDFAR 0x%x\n",
9305                       (uint32_t)env->exception.vaddress);
9306         addr = 0x10;
9307         break;
9308     case EXCP_IRQ:
9309         addr = 0x18;
9310         break;
9311     case EXCP_FIQ:
9312         addr = 0x1c;
9313         break;
9314     case EXCP_HVC:
9315         addr = 0x08;
9316         break;
9317     case EXCP_HYP_TRAP:
9318         addr = 0x14;
9319     default:
9320         cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index);
9321     }
9322
9323     if (cs->exception_index != EXCP_IRQ && cs->exception_index != EXCP_FIQ) {
9324         if (!arm_feature(env, ARM_FEATURE_V8)) {
9325             /*
9326              * QEMU syndrome values are v8-style. v7 has the IL bit
9327              * UNK/SBZP for "field not valid" cases, where v8 uses RES1.
9328              * If this is a v7 CPU, squash the IL bit in those cases.
9329              */
9330             if (cs->exception_index == EXCP_PREFETCH_ABORT ||
9331                 (cs->exception_index == EXCP_DATA_ABORT &&
9332                  !(env->exception.syndrome & ARM_EL_ISV)) ||
9333                 syn_get_ec(env->exception.syndrome) == EC_UNCATEGORIZED) {
9334                 env->exception.syndrome &= ~ARM_EL_IL;
9335             }
9336         }
9337         env->cp15.esr_el[2] = env->exception.syndrome;
9338     }
9339
9340     if (arm_current_el(env) != 2 && addr < 0x14) {
9341         addr = 0x14;
9342     }
9343
9344     mask = 0;
9345     if (!(env->cp15.scr_el3 & SCR_EA)) {
9346         mask |= CPSR_A;
9347     }
9348     if (!(env->cp15.scr_el3 & SCR_IRQ)) {
9349         mask |= CPSR_I;
9350     }
9351     if (!(env->cp15.scr_el3 & SCR_FIQ)) {
9352         mask |= CPSR_F;
9353     }
9354
9355     addr += env->cp15.hvbar;
9356
9357     take_aarch32_exception(env, ARM_CPU_MODE_HYP, mask, 0, addr);
9358 }
9359
9360 static void arm_cpu_do_interrupt_aarch32(CPUState *cs)
9361 {
9362     ARMCPU *cpu = ARM_CPU(cs);
9363     CPUARMState *env = &cpu->env;
9364     uint32_t addr;
9365     uint32_t mask;
9366     int new_mode;
9367     uint32_t offset;
9368     uint32_t moe;
9369
9370     /* If this is a debug exception we must update the DBGDSCR.MOE bits */
9371     switch (syn_get_ec(env->exception.syndrome)) {
9372     case EC_BREAKPOINT:
9373     case EC_BREAKPOINT_SAME_EL:
9374         moe = 1;
9375         break;
9376     case EC_WATCHPOINT:
9377     case EC_WATCHPOINT_SAME_EL:
9378         moe = 10;
9379         break;
9380     case EC_AA32_BKPT:
9381         moe = 3;
9382         break;
9383     case EC_VECTORCATCH:
9384         moe = 5;
9385         break;
9386     default:
9387         moe = 0;
9388         break;
9389     }
9390
9391     if (moe) {
9392         env->cp15.mdscr_el1 = deposit64(env->cp15.mdscr_el1, 2, 4, moe);
9393     }
9394
9395     if (env->exception.target_el == 2) {
9396         arm_cpu_do_interrupt_aarch32_hyp(cs);
9397         return;
9398     }
9399
9400     switch (cs->exception_index) {
9401     case EXCP_UDEF:
9402         new_mode = ARM_CPU_MODE_UND;
9403         addr = 0x04;
9404         mask = CPSR_I;
9405         if (env->thumb)
9406             offset = 2;
9407         else
9408             offset = 4;
9409         break;
9410     case EXCP_SWI:
9411         new_mode = ARM_CPU_MODE_SVC;
9412         addr = 0x08;
9413         mask = CPSR_I;
9414         /* The PC already points to the next instruction.  */
9415         offset = 0;
9416         break;
9417     case EXCP_BKPT:
9418         /* Fall through to prefetch abort.  */
9419     case EXCP_PREFETCH_ABORT:
9420         A32_BANKED_CURRENT_REG_SET(env, ifsr, env->exception.fsr);
9421         A32_BANKED_CURRENT_REG_SET(env, ifar, env->exception.vaddress);
9422         qemu_log_mask(CPU_LOG_INT, "...with IFSR 0x%x IFAR 0x%x\n",
9423                       env->exception.fsr, (uint32_t)env->exception.vaddress);
9424         new_mode = ARM_CPU_MODE_ABT;
9425         addr = 0x0c;
9426         mask = CPSR_A | CPSR_I;
9427         offset = 4;
9428         break;
9429     case EXCP_DATA_ABORT:
9430         A32_BANKED_CURRENT_REG_SET(env, dfsr, env->exception.fsr);
9431         A32_BANKED_CURRENT_REG_SET(env, dfar, env->exception.vaddress);
9432         qemu_log_mask(CPU_LOG_INT, "...with DFSR 0x%x DFAR 0x%x\n",
9433                       env->exception.fsr,
9434                       (uint32_t)env->exception.vaddress);
9435         new_mode = ARM_CPU_MODE_ABT;
9436         addr = 0x10;
9437         mask = CPSR_A | CPSR_I;
9438         offset = 8;
9439         break;
9440     case EXCP_IRQ:
9441         new_mode = ARM_CPU_MODE_IRQ;
9442         addr = 0x18;
9443         /* Disable IRQ and imprecise data aborts.  */
9444         mask = CPSR_A | CPSR_I;
9445         offset = 4;
9446         if (env->cp15.scr_el3 & SCR_IRQ) {
9447             /* IRQ routed to monitor mode */
9448             new_mode = ARM_CPU_MODE_MON;
9449             mask |= CPSR_F;
9450         }
9451         break;
9452     case EXCP_FIQ:
9453         new_mode = ARM_CPU_MODE_FIQ;
9454         addr = 0x1c;
9455         /* Disable FIQ, IRQ and imprecise data aborts.  */
9456         mask = CPSR_A | CPSR_I | CPSR_F;
9457         if (env->cp15.scr_el3 & SCR_FIQ) {
9458             /* FIQ routed to monitor mode */
9459             new_mode = ARM_CPU_MODE_MON;
9460         }
9461         offset = 4;
9462         break;
9463     case EXCP_VIRQ:
9464         new_mode = ARM_CPU_MODE_IRQ;
9465         addr = 0x18;
9466         /* Disable IRQ and imprecise data aborts.  */
9467         mask = CPSR_A | CPSR_I;
9468         offset = 4;
9469         break;
9470     case EXCP_VFIQ:
9471         new_mode = ARM_CPU_MODE_FIQ;
9472         addr = 0x1c;
9473         /* Disable FIQ, IRQ and imprecise data aborts.  */
9474         mask = CPSR_A | CPSR_I | CPSR_F;
9475         offset = 4;
9476         break;
9477     case EXCP_SMC:
9478         new_mode = ARM_CPU_MODE_MON;
9479         addr = 0x08;
9480         mask = CPSR_A | CPSR_I | CPSR_F;
9481         offset = 0;
9482         break;
9483     default:
9484         cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index);
9485         return; /* Never happens.  Keep compiler happy.  */
9486     }
9487
9488     if (new_mode == ARM_CPU_MODE_MON) {
9489         addr += env->cp15.mvbar;
9490     } else if (A32_BANKED_CURRENT_REG_GET(env, sctlr) & SCTLR_V) {
9491         /* High vectors. When enabled, base address cannot be remapped. */
9492         addr += 0xffff0000;
9493     } else {
9494         /* ARM v7 architectures provide a vector base address register to remap
9495          * the interrupt vector table.
9496          * This register is only followed in non-monitor mode, and is banked.
9497          * Note: only bits 31:5 are valid.
9498          */
9499         addr += A32_BANKED_CURRENT_REG_GET(env, vbar);
9500     }
9501
9502     if ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_MON) {
9503         env->cp15.scr_el3 &= ~SCR_NS;
9504     }
9505
9506     take_aarch32_exception(env, new_mode, mask, offset, addr);
9507 }
9508
9509 /* Handle exception entry to a target EL which is using AArch64 */
9510 static void arm_cpu_do_interrupt_aarch64(CPUState *cs)
9511 {
9512     ARMCPU *cpu = ARM_CPU(cs);
9513     CPUARMState *env = &cpu->env;
9514     unsigned int new_el = env->exception.target_el;
9515     target_ulong addr = env->cp15.vbar_el[new_el];
9516     unsigned int new_mode = aarch64_pstate_mode(new_el, true);
9517     unsigned int cur_el = arm_current_el(env);
9518
9519     /*
9520      * Note that new_el can never be 0.  If cur_el is 0, then
9521      * el0_a64 is is_a64(), else el0_a64 is ignored.
9522      */
9523     aarch64_sve_change_el(env, cur_el, new_el, is_a64(env));
9524
9525     if (cur_el < new_el) {
9526         /* Entry vector offset depends on whether the implemented EL
9527          * immediately lower than the target level is using AArch32 or AArch64
9528          */
9529         bool is_aa64;
9530
9531         switch (new_el) {
9532         case 3:
9533             is_aa64 = (env->cp15.scr_el3 & SCR_RW) != 0;
9534             break;
9535         case 2:
9536             is_aa64 = (env->cp15.hcr_el2 & HCR_RW) != 0;
9537             break;
9538         case 1:
9539             is_aa64 = is_a64(env);
9540             break;
9541         default:
9542             g_assert_not_reached();
9543         }
9544
9545         if (is_aa64) {
9546             addr += 0x400;
9547         } else {
9548             addr += 0x600;
9549         }
9550     } else if (pstate_read(env) & PSTATE_SP) {
9551         addr += 0x200;
9552     }
9553
9554     switch (cs->exception_index) {
9555     case EXCP_PREFETCH_ABORT:
9556     case EXCP_DATA_ABORT:
9557         env->cp15.far_el[new_el] = env->exception.vaddress;
9558         qemu_log_mask(CPU_LOG_INT, "...with FAR 0x%" PRIx64 "\n",
9559                       env->cp15.far_el[new_el]);
9560         /* fall through */
9561     case EXCP_BKPT:
9562     case EXCP_UDEF:
9563     case EXCP_SWI:
9564     case EXCP_HVC:
9565     case EXCP_HYP_TRAP:
9566     case EXCP_SMC:
9567         if (syn_get_ec(env->exception.syndrome) == EC_ADVSIMDFPACCESSTRAP) {
9568             /*
9569              * QEMU internal FP/SIMD syndromes from AArch32 include the
9570              * TA and coproc fields which are only exposed if the exception
9571              * is taken to AArch32 Hyp mode. Mask them out to get a valid
9572              * AArch64 format syndrome.
9573              */
9574             env->exception.syndrome &= ~MAKE_64BIT_MASK(0, 20);
9575         }
9576         env->cp15.esr_el[new_el] = env->exception.syndrome;
9577         break;
9578     case EXCP_IRQ:
9579     case EXCP_VIRQ:
9580         addr += 0x80;
9581         break;
9582     case EXCP_FIQ:
9583     case EXCP_VFIQ:
9584         addr += 0x100;
9585         break;
9586     case EXCP_SEMIHOST:
9587         qemu_log_mask(CPU_LOG_INT,
9588                       "...handling as semihosting call 0x%" PRIx64 "\n",
9589                       env->xregs[0]);
9590         env->xregs[0] = do_arm_semihosting(env);
9591         return;
9592     default:
9593         cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index);
9594     }
9595
9596     if (is_a64(env)) {
9597         env->banked_spsr[aarch64_banked_spsr_index(new_el)] = pstate_read(env);
9598         aarch64_save_sp(env, arm_current_el(env));
9599         env->elr_el[new_el] = env->pc;
9600     } else {
9601         env->banked_spsr[aarch64_banked_spsr_index(new_el)] = cpsr_read(env);
9602         env->elr_el[new_el] = env->regs[15];
9603
9604         aarch64_sync_32_to_64(env);
9605
9606         env->condexec_bits = 0;
9607     }
9608     qemu_log_mask(CPU_LOG_INT, "...with ELR 0x%" PRIx64 "\n",
9609                   env->elr_el[new_el]);
9610
9611     pstate_write(env, PSTATE_DAIF | new_mode);
9612     env->aarch64 = 1;
9613     aarch64_restore_sp(env, new_el);
9614
9615     env->pc = addr;
9616
9617     qemu_log_mask(CPU_LOG_INT, "...to EL%d PC 0x%" PRIx64 " PSTATE 0x%x\n",
9618                   new_el, env->pc, pstate_read(env));
9619 }
9620
9621 static inline bool check_for_semihosting(CPUState *cs)
9622 {
9623     /* Check whether this exception is a semihosting call; if so
9624      * then handle it and return true; otherwise return false.
9625      */
9626     ARMCPU *cpu = ARM_CPU(cs);
9627     CPUARMState *env = &cpu->env;
9628
9629     if (is_a64(env)) {
9630         if (cs->exception_index == EXCP_SEMIHOST) {
9631             /* This is always the 64-bit semihosting exception.
9632              * The "is this usermode" and "is semihosting enabled"
9633              * checks have been done at translate time.
9634              */
9635             qemu_log_mask(CPU_LOG_INT,
9636                           "...handling as semihosting call 0x%" PRIx64 "\n",
9637                           env->xregs[0]);
9638             env->xregs[0] = do_arm_semihosting(env);
9639             return true;
9640         }
9641         return false;
9642     } else {
9643         uint32_t imm;
9644
9645         /* Only intercept calls from privileged modes, to provide some
9646          * semblance of security.
9647          */
9648         if (cs->exception_index != EXCP_SEMIHOST &&
9649             (!semihosting_enabled() ||
9650              ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_USR))) {
9651             return false;
9652         }
9653
9654         switch (cs->exception_index) {
9655         case EXCP_SEMIHOST:
9656             /* This is always a semihosting call; the "is this usermode"
9657              * and "is semihosting enabled" checks have been done at
9658              * translate time.
9659              */
9660             break;
9661         case EXCP_SWI:
9662             /* Check for semihosting interrupt.  */
9663             if (env->thumb) {
9664                 imm = arm_lduw_code(env, env->regs[15] - 2, arm_sctlr_b(env))
9665                     & 0xff;
9666                 if (imm == 0xab) {
9667                     break;
9668                 }
9669             } else {
9670                 imm = arm_ldl_code(env, env->regs[15] - 4, arm_sctlr_b(env))
9671                     & 0xffffff;
9672                 if (imm == 0x123456) {
9673                     break;
9674                 }
9675             }
9676             return false;
9677         case EXCP_BKPT:
9678             /* See if this is a semihosting syscall.  */
9679             if (env->thumb) {
9680                 imm = arm_lduw_code(env, env->regs[15], arm_sctlr_b(env))
9681                     & 0xff;
9682                 if (imm == 0xab) {
9683                     env->regs[15] += 2;
9684                     break;
9685                 }
9686             }
9687             return false;
9688         default:
9689             return false;
9690         }
9691
9692         qemu_log_mask(CPU_LOG_INT,
9693                       "...handling as semihosting call 0x%x\n",
9694                       env->regs[0]);
9695         env->regs[0] = do_arm_semihosting(env);
9696         return true;
9697     }
9698 }
9699
9700 /* Handle a CPU exception for A and R profile CPUs.
9701  * Do any appropriate logging, handle PSCI calls, and then hand off
9702  * to the AArch64-entry or AArch32-entry function depending on the
9703  * target exception level's register width.
9704  */
9705 void arm_cpu_do_interrupt(CPUState *cs)
9706 {
9707     ARMCPU *cpu = ARM_CPU(cs);
9708     CPUARMState *env = &cpu->env;
9709     unsigned int new_el = env->exception.target_el;
9710
9711     assert(!arm_feature(env, ARM_FEATURE_M));
9712
9713     arm_log_exception(cs->exception_index);
9714     qemu_log_mask(CPU_LOG_INT, "...from EL%d to EL%d\n", arm_current_el(env),
9715                   new_el);
9716     if (qemu_loglevel_mask(CPU_LOG_INT)
9717         && !excp_is_internal(cs->exception_index)) {
9718         qemu_log_mask(CPU_LOG_INT, "...with ESR 0x%x/0x%" PRIx32 "\n",
9719                       syn_get_ec(env->exception.syndrome),
9720                       env->exception.syndrome);
9721     }
9722
9723     if (arm_is_psci_call(cpu, cs->exception_index)) {
9724         arm_handle_psci_call(cpu);
9725         qemu_log_mask(CPU_LOG_INT, "...handled as PSCI call\n");
9726         return;
9727     }
9728
9729     /* Semihosting semantics depend on the register width of the
9730      * code that caused the exception, not the target exception level,
9731      * so must be handled here.
9732      */
9733     if (check_for_semihosting(cs)) {
9734         return;
9735     }
9736
9737     /* Hooks may change global state so BQL should be held, also the
9738      * BQL needs to be held for any modification of
9739      * cs->interrupt_request.
9740      */
9741     g_assert(qemu_mutex_iothread_locked());
9742
9743     arm_call_pre_el_change_hook(cpu);
9744
9745     assert(!excp_is_internal(cs->exception_index));
9746     if (arm_el_is_aa64(env, new_el)) {
9747         arm_cpu_do_interrupt_aarch64(cs);
9748     } else {
9749         arm_cpu_do_interrupt_aarch32(cs);
9750     }
9751
9752     arm_call_el_change_hook(cpu);
9753
9754     if (!kvm_enabled()) {
9755         cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
9756     }
9757 }
9758 #endif /* !CONFIG_USER_ONLY */
9759
9760 /* Return the exception level which controls this address translation regime */
9761 static inline uint32_t regime_el(CPUARMState *env, ARMMMUIdx mmu_idx)
9762 {
9763     switch (mmu_idx) {
9764     case ARMMMUIdx_S2NS:
9765     case ARMMMUIdx_S1E2:
9766         return 2;
9767     case ARMMMUIdx_S1E3:
9768         return 3;
9769     case ARMMMUIdx_S1SE0:
9770         return arm_el_is_aa64(env, 3) ? 1 : 3;
9771     case ARMMMUIdx_S1SE1:
9772     case ARMMMUIdx_S1NSE0:
9773     case ARMMMUIdx_S1NSE1:
9774     case ARMMMUIdx_MPrivNegPri:
9775     case ARMMMUIdx_MUserNegPri:
9776     case ARMMMUIdx_MPriv:
9777     case ARMMMUIdx_MUser:
9778     case ARMMMUIdx_MSPrivNegPri:
9779     case ARMMMUIdx_MSUserNegPri:
9780     case ARMMMUIdx_MSPriv:
9781     case ARMMMUIdx_MSUser:
9782         return 1;
9783     default:
9784         g_assert_not_reached();
9785     }
9786 }
9787
9788 #ifndef CONFIG_USER_ONLY
9789
9790 /* Return the SCTLR value which controls this address translation regime */
9791 static inline uint32_t regime_sctlr(CPUARMState *env, ARMMMUIdx mmu_idx)
9792 {
9793     return env->cp15.sctlr_el[regime_el(env, mmu_idx)];
9794 }
9795
9796 /* Return true if the specified stage of address translation is disabled */
9797 static inline bool regime_translation_disabled(CPUARMState *env,
9798                                                ARMMMUIdx mmu_idx)
9799 {
9800     if (arm_feature(env, ARM_FEATURE_M)) {
9801         switch (env->v7m.mpu_ctrl[regime_is_secure(env, mmu_idx)] &
9802                 (R_V7M_MPU_CTRL_ENABLE_MASK | R_V7M_MPU_CTRL_HFNMIENA_MASK)) {
9803         case R_V7M_MPU_CTRL_ENABLE_MASK:
9804             /* Enabled, but not for HardFault and NMI */
9805             return mmu_idx & ARM_MMU_IDX_M_NEGPRI;
9806         case R_V7M_MPU_CTRL_ENABLE_MASK | R_V7M_MPU_CTRL_HFNMIENA_MASK:
9807             /* Enabled for all cases */
9808             return false;
9809         case 0:
9810         default:
9811             /* HFNMIENA set and ENABLE clear is UNPREDICTABLE, but
9812              * we warned about that in armv7m_nvic.c when the guest set it.
9813              */
9814             return true;
9815         }
9816     }
9817
9818     if (mmu_idx == ARMMMUIdx_S2NS) {
9819         /* HCR.DC means HCR.VM behaves as 1 */
9820         return (env->cp15.hcr_el2 & (HCR_DC | HCR_VM)) == 0;
9821     }
9822
9823     if (env->cp15.hcr_el2 & HCR_TGE) {
9824         /* TGE means that NS EL0/1 act as if SCTLR_EL1.M is zero */
9825         if (!regime_is_secure(env, mmu_idx) && regime_el(env, mmu_idx) == 1) {
9826             return true;
9827         }
9828     }
9829
9830     if ((env->cp15.hcr_el2 & HCR_DC) &&
9831         (mmu_idx == ARMMMUIdx_S1NSE0 || mmu_idx == ARMMMUIdx_S1NSE1)) {
9832         /* HCR.DC means SCTLR_EL1.M behaves as 0 */
9833         return true;
9834     }
9835
9836     return (regime_sctlr(env, mmu_idx) & SCTLR_M) == 0;
9837 }
9838
9839 static inline bool regime_translation_big_endian(CPUARMState *env,
9840                                                  ARMMMUIdx mmu_idx)
9841 {
9842     return (regime_sctlr(env, mmu_idx) & SCTLR_EE) != 0;
9843 }
9844
9845 /* Return the TTBR associated with this translation regime */
9846 static inline uint64_t regime_ttbr(CPUARMState *env, ARMMMUIdx mmu_idx,
9847                                    int ttbrn)
9848 {
9849     if (mmu_idx == ARMMMUIdx_S2NS) {
9850         return env->cp15.vttbr_el2;
9851     }
9852     if (ttbrn == 0) {
9853         return env->cp15.ttbr0_el[regime_el(env, mmu_idx)];
9854     } else {
9855         return env->cp15.ttbr1_el[regime_el(env, mmu_idx)];
9856     }
9857 }
9858
9859 #endif /* !CONFIG_USER_ONLY */
9860
9861 /* Return the TCR controlling this translation regime */
9862 static inline TCR *regime_tcr(CPUARMState *env, ARMMMUIdx mmu_idx)
9863 {
9864     if (mmu_idx == ARMMMUIdx_S2NS) {
9865         return &env->cp15.vtcr_el2;
9866     }
9867     return &env->cp15.tcr_el[regime_el(env, mmu_idx)];
9868 }
9869
9870 /* Convert a possible stage1+2 MMU index into the appropriate
9871  * stage 1 MMU index
9872  */
9873 static inline ARMMMUIdx stage_1_mmu_idx(ARMMMUIdx mmu_idx)
9874 {
9875     if (mmu_idx == ARMMMUIdx_S12NSE0 || mmu_idx == ARMMMUIdx_S12NSE1) {
9876         mmu_idx += (ARMMMUIdx_S1NSE0 - ARMMMUIdx_S12NSE0);
9877     }
9878     return mmu_idx;
9879 }
9880
9881 /* Return true if the translation regime is using LPAE format page tables */
9882 static inline bool regime_using_lpae_format(CPUARMState *env,
9883                                             ARMMMUIdx mmu_idx)
9884 {
9885     int el = regime_el(env, mmu_idx);
9886     if (el == 2 || arm_el_is_aa64(env, el)) {
9887         return true;
9888     }
9889     if (arm_feature(env, ARM_FEATURE_LPAE)
9890         && (regime_tcr(env, mmu_idx)->raw_tcr & TTBCR_EAE)) {
9891         return true;
9892     }
9893     return false;
9894 }
9895
9896 /* Returns true if the stage 1 translation regime is using LPAE format page
9897  * tables. Used when raising alignment exceptions, whose FSR changes depending
9898  * on whether the long or short descriptor format is in use. */
9899 bool arm_s1_regime_using_lpae_format(CPUARMState *env, ARMMMUIdx mmu_idx)
9900 {
9901     mmu_idx = stage_1_mmu_idx(mmu_idx);
9902
9903     return regime_using_lpae_format(env, mmu_idx);
9904 }
9905
9906 #ifndef CONFIG_USER_ONLY
9907 static inline bool regime_is_user(CPUARMState *env, ARMMMUIdx mmu_idx)
9908 {
9909     switch (mmu_idx) {
9910     case ARMMMUIdx_S1SE0:
9911     case ARMMMUIdx_S1NSE0:
9912     case ARMMMUIdx_MUser:
9913     case ARMMMUIdx_MSUser:
9914     case ARMMMUIdx_MUserNegPri:
9915     case ARMMMUIdx_MSUserNegPri:
9916         return true;
9917     default:
9918         return false;
9919     case ARMMMUIdx_S12NSE0:
9920     case ARMMMUIdx_S12NSE1:
9921         g_assert_not_reached();
9922     }
9923 }
9924
9925 /* Translate section/page access permissions to page
9926  * R/W protection flags
9927  *
9928  * @env:         CPUARMState
9929  * @mmu_idx:     MMU index indicating required translation regime
9930  * @ap:          The 3-bit access permissions (AP[2:0])
9931  * @domain_prot: The 2-bit domain access permissions
9932  */
9933 static inline int ap_to_rw_prot(CPUARMState *env, ARMMMUIdx mmu_idx,
9934                                 int ap, int domain_prot)
9935 {
9936     bool is_user = regime_is_user(env, mmu_idx);
9937
9938     if (domain_prot == 3) {
9939         return PAGE_READ | PAGE_WRITE;
9940     }
9941
9942     switch (ap) {
9943     case 0:
9944         if (arm_feature(env, ARM_FEATURE_V7)) {
9945             return 0;
9946         }
9947         switch (regime_sctlr(env, mmu_idx) & (SCTLR_S | SCTLR_R)) {
9948         case SCTLR_S:
9949             return is_user ? 0 : PAGE_READ;
9950         case SCTLR_R:
9951             return PAGE_READ;
9952         default:
9953             return 0;
9954         }
9955     case 1:
9956         return is_user ? 0 : PAGE_READ | PAGE_WRITE;
9957     case 2:
9958         if (is_user) {
9959             return PAGE_READ;
9960         } else {
9961             return PAGE_READ | PAGE_WRITE;
9962         }
9963     case 3:
9964         return PAGE_READ | PAGE_WRITE;
9965     case 4: /* Reserved.  */
9966         return 0;
9967     case 5:
9968         return is_user ? 0 : PAGE_READ;
9969     case 6:
9970         return PAGE_READ;
9971     case 7:
9972         if (!arm_feature(env, ARM_FEATURE_V6K)) {
9973             return 0;
9974         }
9975         return PAGE_READ;
9976     default:
9977         g_assert_not_reached();
9978     }
9979 }
9980
9981 /* Translate section/page access permissions to page
9982  * R/W protection flags.
9983  *
9984  * @ap:      The 2-bit simple AP (AP[2:1])
9985  * @is_user: TRUE if accessing from PL0
9986  */
9987 static inline int simple_ap_to_rw_prot_is_user(int ap, bool is_user)
9988 {
9989     switch (ap) {
9990     case 0:
9991         return is_user ? 0 : PAGE_READ | PAGE_WRITE;
9992     case 1:
9993         return PAGE_READ | PAGE_WRITE;
9994     case 2:
9995         return is_user ? 0 : PAGE_READ;
9996     case 3:
9997         return PAGE_READ;
9998     default:
9999         g_assert_not_reached();
10000     }
10001 }
10002
10003 static inline int
10004 simple_ap_to_rw_prot(CPUARMState *env, ARMMMUIdx mmu_idx, int ap)
10005 {
10006     return simple_ap_to_rw_prot_is_user(ap, regime_is_user(env, mmu_idx));
10007 }
10008
10009 /* Translate S2 section/page access permissions to protection flags
10010  *
10011  * @env:     CPUARMState
10012  * @s2ap:    The 2-bit stage2 access permissions (S2AP)
10013  * @xn:      XN (execute-never) bit
10014  */
10015 static int get_S2prot(CPUARMState *env, int s2ap, int xn)
10016 {
10017     int prot = 0;
10018
10019     if (s2ap & 1) {
10020         prot |= PAGE_READ;
10021     }
10022     if (s2ap & 2) {
10023         prot |= PAGE_WRITE;
10024     }
10025     if (!xn) {
10026         if (arm_el_is_aa64(env, 2) || prot & PAGE_READ) {
10027             prot |= PAGE_EXEC;
10028         }
10029     }
10030     return prot;
10031 }
10032
10033 /* Translate section/page access permissions to protection flags
10034  *
10035  * @env:     CPUARMState
10036  * @mmu_idx: MMU index indicating required translation regime
10037  * @is_aa64: TRUE if AArch64
10038  * @ap:      The 2-bit simple AP (AP[2:1])
10039  * @ns:      NS (non-secure) bit
10040  * @xn:      XN (execute-never) bit
10041  * @pxn:     PXN (privileged execute-never) bit
10042  */
10043 static int get_S1prot(CPUARMState *env, ARMMMUIdx mmu_idx, bool is_aa64,
10044                       int ap, int ns, int xn, int pxn)
10045 {
10046     bool is_user = regime_is_user(env, mmu_idx);
10047     int prot_rw, user_rw;
10048     bool have_wxn;
10049     int wxn = 0;
10050
10051     assert(mmu_idx != ARMMMUIdx_S2NS);
10052
10053     user_rw = simple_ap_to_rw_prot_is_user(ap, true);
10054     if (is_user) {
10055         prot_rw = user_rw;
10056     } else {
10057         prot_rw = simple_ap_to_rw_prot_is_user(ap, false);
10058     }
10059
10060     if (ns && arm_is_secure(env) && (env->cp15.scr_el3 & SCR_SIF)) {
10061         return prot_rw;
10062     }
10063
10064     /* TODO have_wxn should be replaced with
10065      *   ARM_FEATURE_V8 || (ARM_FEATURE_V7 && ARM_FEATURE_EL2)
10066      * when ARM_FEATURE_EL2 starts getting set. For now we assume all LPAE
10067      * compatible processors have EL2, which is required for [U]WXN.
10068      */
10069     have_wxn = arm_feature(env, ARM_FEATURE_LPAE);
10070
10071     if (have_wxn) {
10072         wxn = regime_sctlr(env, mmu_idx) & SCTLR_WXN;
10073     }
10074
10075     if (is_aa64) {
10076         switch (regime_el(env, mmu_idx)) {
10077         case 1:
10078             if (!is_user) {
10079                 xn = pxn || (user_rw & PAGE_WRITE);
10080             }
10081             break;
10082         case 2:
10083         case 3:
10084             break;
10085         }
10086     } else if (arm_feature(env, ARM_FEATURE_V7)) {
10087         switch (regime_el(env, mmu_idx)) {
10088         case 1:
10089         case 3:
10090             if (is_user) {
10091                 xn = xn || !(user_rw & PAGE_READ);
10092             } else {
10093                 int uwxn = 0;
10094                 if (have_wxn) {
10095                     uwxn = regime_sctlr(env, mmu_idx) & SCTLR_UWXN;
10096                 }
10097                 xn = xn || !(prot_rw & PAGE_READ) || pxn ||
10098                      (uwxn && (user_rw & PAGE_WRITE));
10099             }
10100             break;
10101         case 2:
10102             break;
10103         }
10104     } else {
10105         xn = wxn = 0;
10106     }
10107
10108     if (xn || (wxn && (prot_rw & PAGE_WRITE))) {
10109         return prot_rw;
10110     }
10111     return prot_rw | PAGE_EXEC;
10112 }
10113
10114 static bool get_level1_table_address(CPUARMState *env, ARMMMUIdx mmu_idx,
10115                                      uint32_t *table, uint32_t address)
10116 {
10117     /* Note that we can only get here for an AArch32 PL0/PL1 lookup */
10118     TCR *tcr = regime_tcr(env, mmu_idx);
10119
10120     if (address & tcr->mask) {
10121         if (tcr->raw_tcr & TTBCR_PD1) {
10122             /* Translation table walk disabled for TTBR1 */
10123             return false;
10124         }
10125         *table = regime_ttbr(env, mmu_idx, 1) & 0xffffc000;
10126     } else {
10127         if (tcr->raw_tcr & TTBCR_PD0) {
10128             /* Translation table walk disabled for TTBR0 */
10129             return false;
10130         }
10131         *table = regime_ttbr(env, mmu_idx, 0) & tcr->base_mask;
10132     }
10133     *table |= (address >> 18) & 0x3ffc;
10134     return true;
10135 }
10136
10137 /* Translate a S1 pagetable walk through S2 if needed.  */
10138 static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx,
10139                                hwaddr addr, MemTxAttrs txattrs,
10140                                ARMMMUFaultInfo *fi)
10141 {
10142     if ((mmu_idx == ARMMMUIdx_S1NSE0 || mmu_idx == ARMMMUIdx_S1NSE1) &&
10143         !regime_translation_disabled(env, ARMMMUIdx_S2NS)) {
10144         target_ulong s2size;
10145         hwaddr s2pa;
10146         int s2prot;
10147         int ret;
10148         ARMCacheAttrs cacheattrs = {};
10149         ARMCacheAttrs *pcacheattrs = NULL;
10150
10151         if (env->cp15.hcr_el2 & HCR_PTW) {
10152             /*
10153              * PTW means we must fault if this S1 walk touches S2 Device
10154              * memory; otherwise we don't care about the attributes and can
10155              * save the S2 translation the effort of computing them.
10156              */
10157             pcacheattrs = &cacheattrs;
10158         }
10159
10160         ret = get_phys_addr_lpae(env, addr, 0, ARMMMUIdx_S2NS, &s2pa,
10161                                  &txattrs, &s2prot, &s2size, fi, pcacheattrs);
10162         if (ret) {
10163             assert(fi->type != ARMFault_None);
10164             fi->s2addr = addr;
10165             fi->stage2 = true;
10166             fi->s1ptw = true;
10167             return ~0;
10168         }
10169         if (pcacheattrs && (pcacheattrs->attrs & 0xf0) == 0) {
10170             /* Access was to Device memory: generate Permission fault */
10171             fi->type = ARMFault_Permission;
10172             fi->s2addr = addr;
10173             fi->stage2 = true;
10174             fi->s1ptw = true;
10175             return ~0;
10176         }
10177         addr = s2pa;
10178     }
10179     return addr;
10180 }
10181
10182 /* All loads done in the course of a page table walk go through here. */
10183 static uint32_t arm_ldl_ptw(CPUState *cs, hwaddr addr, bool is_secure,
10184                             ARMMMUIdx mmu_idx, ARMMMUFaultInfo *fi)
10185 {
10186     ARMCPU *cpu = ARM_CPU(cs);
10187     CPUARMState *env = &cpu->env;
10188     MemTxAttrs attrs = {};
10189     MemTxResult result = MEMTX_OK;
10190     AddressSpace *as;
10191     uint32_t data;
10192
10193     attrs.secure = is_secure;
10194     as = arm_addressspace(cs, attrs);
10195     addr = S1_ptw_translate(env, mmu_idx, addr, attrs, fi);
10196     if (fi->s1ptw) {
10197         return 0;
10198     }
10199     if (regime_translation_big_endian(env, mmu_idx)) {
10200         data = address_space_ldl_be(as, addr, attrs, &result);
10201     } else {
10202         data = address_space_ldl_le(as, addr, attrs, &result);
10203     }
10204     if (result == MEMTX_OK) {
10205         return data;
10206     }
10207     fi->type = ARMFault_SyncExternalOnWalk;
10208     fi->ea = arm_extabort_type(result);
10209     return 0;
10210 }
10211
10212 static uint64_t arm_ldq_ptw(CPUState *cs, hwaddr addr, bool is_secure,
10213                             ARMMMUIdx mmu_idx, ARMMMUFaultInfo *fi)
10214 {
10215     ARMCPU *cpu = ARM_CPU(cs);
10216     CPUARMState *env = &cpu->env;
10217     MemTxAttrs attrs = {};
10218     MemTxResult result = MEMTX_OK;
10219     AddressSpace *as;
10220     uint64_t data;
10221
10222     attrs.secure = is_secure;
10223     as = arm_addressspace(cs, attrs);
10224     addr = S1_ptw_translate(env, mmu_idx, addr, attrs, fi);
10225     if (fi->s1ptw) {
10226         return 0;
10227     }
10228     if (regime_translation_big_endian(env, mmu_idx)) {
10229         data = address_space_ldq_be(as, addr, attrs, &result);
10230     } else {
10231         data = address_space_ldq_le(as, addr, attrs, &result);
10232     }
10233     if (result == MEMTX_OK) {
10234         return data;
10235     }
10236     fi->type = ARMFault_SyncExternalOnWalk;
10237     fi->ea = arm_extabort_type(result);
10238     return 0;
10239 }
10240
10241 static bool get_phys_addr_v5(CPUARMState *env, uint32_t address,
10242                              MMUAccessType access_type, ARMMMUIdx mmu_idx,
10243                              hwaddr *phys_ptr, int *prot,
10244                              target_ulong *page_size,
10245                              ARMMMUFaultInfo *fi)
10246 {
10247     CPUState *cs = CPU(arm_env_get_cpu(env));
10248     int level = 1;
10249     uint32_t table;
10250     uint32_t desc;
10251     int type;
10252     int ap;
10253     int domain = 0;
10254     int domain_prot;
10255     hwaddr phys_addr;
10256     uint32_t dacr;
10257
10258     /* Pagetable walk.  */
10259     /* Lookup l1 descriptor.  */
10260     if (!get_level1_table_address(env, mmu_idx, &table, address)) {
10261         /* Section translation fault if page walk is disabled by PD0 or PD1 */
10262         fi->type = ARMFault_Translation;
10263         goto do_fault;
10264     }
10265     desc = arm_ldl_ptw(cs, table, regime_is_secure(env, mmu_idx),
10266                        mmu_idx, fi);
10267     if (fi->type != ARMFault_None) {
10268         goto do_fault;
10269     }
10270     type = (desc & 3);
10271     domain = (desc >> 5) & 0x0f;
10272     if (regime_el(env, mmu_idx) == 1) {
10273         dacr = env->cp15.dacr_ns;
10274     } else {
10275         dacr = env->cp15.dacr_s;
10276     }
10277     domain_prot = (dacr >> (domain * 2)) & 3;
10278     if (type == 0) {
10279         /* Section translation fault.  */
10280         fi->type = ARMFault_Translation;
10281         goto do_fault;
10282     }
10283     if (type != 2) {
10284         level = 2;
10285     }
10286     if (domain_prot == 0 || domain_prot == 2) {
10287         fi->type = ARMFault_Domain;
10288         goto do_fault;
10289     }
10290     if (type == 2) {
10291         /* 1Mb section.  */
10292         phys_addr = (desc & 0xfff00000) | (address & 0x000fffff);
10293         ap = (desc >> 10) & 3;
10294         *page_size = 1024 * 1024;
10295     } else {
10296         /* Lookup l2 entry.  */
10297         if (type == 1) {
10298             /* Coarse pagetable.  */
10299             table = (desc & 0xfffffc00) | ((address >> 10) & 0x3fc);
10300         } else {
10301             /* Fine pagetable.  */
10302             table = (desc & 0xfffff000) | ((address >> 8) & 0xffc);
10303         }
10304         desc = arm_ldl_ptw(cs, table, regime_is_secure(env, mmu_idx),
10305                            mmu_idx, fi);
10306         if (fi->type != ARMFault_None) {
10307             goto do_fault;
10308         }
10309         switch (desc & 3) {
10310         case 0: /* Page translation fault.  */
10311             fi->type = ARMFault_Translation;
10312             goto do_fault;
10313         case 1: /* 64k page.  */
10314             phys_addr = (desc & 0xffff0000) | (address & 0xffff);
10315             ap = (desc >> (4 + ((address >> 13) & 6))) & 3;
10316             *page_size = 0x10000;
10317             break;
10318         case 2: /* 4k page.  */
10319             phys_addr = (desc & 0xfffff000) | (address & 0xfff);
10320             ap = (desc >> (4 + ((address >> 9) & 6))) & 3;
10321             *page_size = 0x1000;
10322             break;
10323         case 3: /* 1k page, or ARMv6/XScale "extended small (4k) page" */
10324             if (type == 1) {
10325                 /* ARMv6/XScale extended small page format */
10326                 if (arm_feature(env, ARM_FEATURE_XSCALE)
10327                     || arm_feature(env, ARM_FEATURE_V6)) {
10328                     phys_addr = (desc & 0xfffff000) | (address & 0xfff);
10329                     *page_size = 0x1000;
10330                 } else {
10331                     /* UNPREDICTABLE in ARMv5; we choose to take a
10332                      * page translation fault.
10333                      */
10334                     fi->type = ARMFault_Translation;
10335                     goto do_fault;
10336                 }
10337             } else {
10338                 phys_addr = (desc & 0xfffffc00) | (address & 0x3ff);
10339                 *page_size = 0x400;
10340             }
10341             ap = (desc >> 4) & 3;
10342             break;
10343         default:
10344             /* Never happens, but compiler isn't smart enough to tell.  */
10345             abort();
10346         }
10347     }
10348     *prot = ap_to_rw_prot(env, mmu_idx, ap, domain_prot);
10349     *prot |= *prot ? PAGE_EXEC : 0;
10350     if (!(*prot & (1 << access_type))) {
10351         /* Access permission fault.  */
10352         fi->type = ARMFault_Permission;
10353         goto do_fault;
10354     }
10355     *phys_ptr = phys_addr;
10356     return false;
10357 do_fault:
10358     fi->domain = domain;
10359     fi->level = level;
10360     return true;
10361 }
10362
10363 static bool get_phys_addr_v6(CPUARMState *env, uint32_t address,
10364                              MMUAccessType access_type, ARMMMUIdx mmu_idx,
10365                              hwaddr *phys_ptr, MemTxAttrs *attrs, int *prot,
10366                              target_ulong *page_size, ARMMMUFaultInfo *fi)
10367 {
10368     CPUState *cs = CPU(arm_env_get_cpu(env));
10369     int level = 1;
10370     uint32_t table;
10371     uint32_t desc;
10372     uint32_t xn;
10373     uint32_t pxn = 0;
10374     int type;
10375     int ap;
10376     int domain = 0;
10377     int domain_prot;
10378     hwaddr phys_addr;
10379     uint32_t dacr;
10380     bool ns;
10381
10382     /* Pagetable walk.  */
10383     /* Lookup l1 descriptor.  */
10384     if (!get_level1_table_address(env, mmu_idx, &table, address)) {
10385         /* Section translation fault if page walk is disabled by PD0 or PD1 */
10386         fi->type = ARMFault_Translation;
10387         goto do_fault;
10388     }
10389     desc = arm_ldl_ptw(cs, table, regime_is_secure(env, mmu_idx),
10390                        mmu_idx, fi);
10391     if (fi->type != ARMFault_None) {
10392         goto do_fault;
10393     }
10394     type = (desc & 3);
10395     if (type == 0 || (type == 3 && !arm_feature(env, ARM_FEATURE_PXN))) {
10396         /* Section translation fault, or attempt to use the encoding
10397          * which is Reserved on implementations without PXN.
10398          */
10399         fi->type = ARMFault_Translation;
10400         goto do_fault;
10401     }
10402     if ((type == 1) || !(desc & (1 << 18))) {
10403         /* Page or Section.  */
10404         domain = (desc >> 5) & 0x0f;
10405     }
10406     if (regime_el(env, mmu_idx) == 1) {
10407         dacr = env->cp15.dacr_ns;
10408     } else {
10409         dacr = env->cp15.dacr_s;
10410     }
10411     if (type == 1) {
10412         level = 2;
10413     }
10414     domain_prot = (dacr >> (domain * 2)) & 3;
10415     if (domain_prot == 0 || domain_prot == 2) {
10416         /* Section or Page domain fault */
10417         fi->type = ARMFault_Domain;
10418         goto do_fault;
10419     }
10420     if (type != 1) {
10421         if (desc & (1 << 18)) {
10422             /* Supersection.  */
10423             phys_addr = (desc & 0xff000000) | (address & 0x00ffffff);
10424             phys_addr |= (uint64_t)extract32(desc, 20, 4) << 32;
10425             phys_addr |= (uint64_t)extract32(desc, 5, 4) << 36;
10426             *page_size = 0x1000000;
10427         } else {
10428             /* Section.  */
10429             phys_addr = (desc & 0xfff00000) | (address & 0x000fffff);
10430             *page_size = 0x100000;
10431         }
10432         ap = ((desc >> 10) & 3) | ((desc >> 13) & 4);
10433         xn = desc & (1 << 4);
10434         pxn = desc & 1;
10435         ns = extract32(desc, 19, 1);
10436     } else {
10437         if (arm_feature(env, ARM_FEATURE_PXN)) {
10438             pxn = (desc >> 2) & 1;
10439         }
10440         ns = extract32(desc, 3, 1);
10441         /* Lookup l2 entry.  */
10442         table = (desc & 0xfffffc00) | ((address >> 10) & 0x3fc);
10443         desc = arm_ldl_ptw(cs, table, regime_is_secure(env, mmu_idx),
10444                            mmu_idx, fi);
10445         if (fi->type != ARMFault_None) {
10446             goto do_fault;
10447         }
10448         ap = ((desc >> 4) & 3) | ((desc >> 7) & 4);
10449         switch (desc & 3) {
10450         case 0: /* Page translation fault.  */
10451             fi->type = ARMFault_Translation;
10452             goto do_fault;
10453         case 1: /* 64k page.  */
10454             phys_addr = (desc & 0xffff0000) | (address & 0xffff);
10455             xn = desc & (1 << 15);
10456             *page_size = 0x10000;
10457             break;
10458         case 2: case 3: /* 4k page.  */
10459             phys_addr = (desc & 0xfffff000) | (address & 0xfff);
10460             xn = desc & 1;
10461             *page_size = 0x1000;
10462             break;
10463         default:
10464             /* Never happens, but compiler isn't smart enough to tell.  */
10465             abort();
10466         }
10467     }
10468     if (domain_prot == 3) {
10469         *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
10470     } else {
10471         if (pxn && !regime_is_user(env, mmu_idx)) {
10472             xn = 1;
10473         }
10474         if (xn && access_type == MMU_INST_FETCH) {
10475             fi->type = ARMFault_Permission;
10476             goto do_fault;
10477         }
10478
10479         if (arm_feature(env, ARM_FEATURE_V6K) &&
10480                 (regime_sctlr(env, mmu_idx) & SCTLR_AFE)) {
10481             /* The simplified model uses AP[0] as an access control bit.  */
10482             if ((ap & 1) == 0) {
10483                 /* Access flag fault.  */
10484                 fi->type = ARMFault_AccessFlag;
10485                 goto do_fault;
10486             }
10487             *prot = simple_ap_to_rw_prot(env, mmu_idx, ap >> 1);
10488         } else {
10489             *prot = ap_to_rw_prot(env, mmu_idx, ap, domain_prot);
10490         }
10491         if (*prot && !xn) {
10492             *prot |= PAGE_EXEC;
10493         }
10494         if (!(*prot & (1 << access_type))) {
10495             /* Access permission fault.  */
10496             fi->type = ARMFault_Permission;
10497             goto do_fault;
10498         }
10499     }
10500     if (ns) {
10501         /* The NS bit will (as required by the architecture) have no effect if
10502          * the CPU doesn't support TZ or this is a non-secure translation
10503          * regime, because the attribute will already be non-secure.
10504          */
10505         attrs->secure = false;
10506     }
10507     *phys_ptr = phys_addr;
10508     return false;
10509 do_fault:
10510     fi->domain = domain;
10511     fi->level = level;
10512     return true;
10513 }
10514
10515 /*
10516  * check_s2_mmu_setup
10517  * @cpu:        ARMCPU
10518  * @is_aa64:    True if the translation regime is in AArch64 state
10519  * @startlevel: Suggested starting level
10520  * @inputsize:  Bitsize of IPAs
10521  * @stride:     Page-table stride (See the ARM ARM)
10522  *
10523  * Returns true if the suggested S2 translation parameters are OK and
10524  * false otherwise.
10525  */
10526 static bool check_s2_mmu_setup(ARMCPU *cpu, bool is_aa64, int level,
10527                                int inputsize, int stride)
10528 {
10529     const int grainsize = stride + 3;
10530     int startsizecheck;
10531
10532     /* Negative levels are never allowed.  */
10533     if (level < 0) {
10534         return false;
10535     }
10536
10537     startsizecheck = inputsize - ((3 - level) * stride + grainsize);
10538     if (startsizecheck < 1 || startsizecheck > stride + 4) {
10539         return false;
10540     }
10541
10542     if (is_aa64) {
10543         CPUARMState *env = &cpu->env;
10544         unsigned int pamax = arm_pamax(cpu);
10545
10546         switch (stride) {
10547         case 13: /* 64KB Pages.  */
10548             if (level == 0 || (level == 1 && pamax <= 42)) {
10549                 return false;
10550             }
10551             break;
10552         case 11: /* 16KB Pages.  */
10553             if (level == 0 || (level == 1 && pamax <= 40)) {
10554                 return false;
10555             }
10556             break;
10557         case 9: /* 4KB Pages.  */
10558             if (level == 0 && pamax <= 42) {
10559                 return false;
10560             }
10561             break;
10562         default:
10563             g_assert_not_reached();
10564         }
10565
10566         /* Inputsize checks.  */
10567         if (inputsize > pamax &&
10568             (arm_el_is_aa64(env, 1) || inputsize > 40)) {
10569             /* This is CONSTRAINED UNPREDICTABLE and we choose to fault.  */
10570             return false;
10571         }
10572     } else {
10573         /* AArch32 only supports 4KB pages. Assert on that.  */
10574         assert(stride == 9);
10575
10576         if (level == 0) {
10577             return false;
10578         }
10579     }
10580     return true;
10581 }
10582
10583 /* Translate from the 4-bit stage 2 representation of
10584  * memory attributes (without cache-allocation hints) to
10585  * the 8-bit representation of the stage 1 MAIR registers
10586  * (which includes allocation hints).
10587  *
10588  * ref: shared/translation/attrs/S2AttrDecode()
10589  *      .../S2ConvertAttrsHints()
10590  */
10591 static uint8_t convert_stage2_attrs(CPUARMState *env, uint8_t s2attrs)
10592 {
10593     uint8_t hiattr = extract32(s2attrs, 2, 2);
10594     uint8_t loattr = extract32(s2attrs, 0, 2);
10595     uint8_t hihint = 0, lohint = 0;
10596
10597     if (hiattr != 0) { /* normal memory */
10598         if ((env->cp15.hcr_el2 & HCR_CD) != 0) { /* cache disabled */
10599             hiattr = loattr = 1; /* non-cacheable */
10600         } else {
10601             if (hiattr != 1) { /* Write-through or write-back */
10602                 hihint = 3; /* RW allocate */
10603             }
10604             if (loattr != 1) { /* Write-through or write-back */
10605                 lohint = 3; /* RW allocate */
10606             }
10607         }
10608     }
10609
10610     return (hiattr << 6) | (hihint << 4) | (loattr << 2) | lohint;
10611 }
10612 #endif /* !CONFIG_USER_ONLY */
10613
10614 ARMVAParameters aa64_va_parameters_both(CPUARMState *env, uint64_t va,
10615                                         ARMMMUIdx mmu_idx)
10616 {
10617     uint64_t tcr = regime_tcr(env, mmu_idx)->raw_tcr;
10618     uint32_t el = regime_el(env, mmu_idx);
10619     bool tbi, tbid, epd, hpd, using16k, using64k;
10620     int select, tsz;
10621
10622     /*
10623      * Bit 55 is always between the two regions, and is canonical for
10624      * determining if address tagging is enabled.
10625      */
10626     select = extract64(va, 55, 1);
10627
10628     if (el > 1) {
10629         tsz = extract32(tcr, 0, 6);
10630         using64k = extract32(tcr, 14, 1);
10631         using16k = extract32(tcr, 15, 1);
10632         if (mmu_idx == ARMMMUIdx_S2NS) {
10633             /* VTCR_EL2 */
10634             tbi = tbid = hpd = false;
10635         } else {
10636             tbi = extract32(tcr, 20, 1);
10637             hpd = extract32(tcr, 24, 1);
10638             tbid = extract32(tcr, 29, 1);
10639         }
10640         epd = false;
10641     } else if (!select) {
10642         tsz = extract32(tcr, 0, 6);
10643         epd = extract32(tcr, 7, 1);
10644         using64k = extract32(tcr, 14, 1);
10645         using16k = extract32(tcr, 15, 1);
10646         tbi = extract64(tcr, 37, 1);
10647         hpd = extract64(tcr, 41, 1);
10648         tbid = extract64(tcr, 51, 1);
10649     } else {
10650         int tg = extract32(tcr, 30, 2);
10651         using16k = tg == 1;
10652         using64k = tg == 3;
10653         tsz = extract32(tcr, 16, 6);
10654         epd = extract32(tcr, 23, 1);
10655         tbi = extract64(tcr, 38, 1);
10656         hpd = extract64(tcr, 42, 1);
10657         tbid = extract64(tcr, 52, 1);
10658     }
10659     tsz = MIN(tsz, 39);  /* TODO: ARMv8.4-TTST */
10660     tsz = MAX(tsz, 16);  /* TODO: ARMv8.2-LVA  */
10661
10662     return (ARMVAParameters) {
10663         .tsz = tsz,
10664         .select = select,
10665         .tbi = tbi,
10666         .tbid = tbid,
10667         .epd = epd,
10668         .hpd = hpd,
10669         .using16k = using16k,
10670         .using64k = using64k,
10671     };
10672 }
10673
10674 ARMVAParameters aa64_va_parameters(CPUARMState *env, uint64_t va,
10675                                    ARMMMUIdx mmu_idx, bool data)
10676 {
10677     ARMVAParameters ret = aa64_va_parameters_both(env, va, mmu_idx);
10678
10679     /* Present TBI as a composite with TBID.  */
10680     ret.tbi &= (data || !ret.tbid);
10681     return ret;
10682 }
10683
10684 #ifndef CONFIG_USER_ONLY
10685 static ARMVAParameters aa32_va_parameters(CPUARMState *env, uint32_t va,
10686                                           ARMMMUIdx mmu_idx)
10687 {
10688     uint64_t tcr = regime_tcr(env, mmu_idx)->raw_tcr;
10689     uint32_t el = regime_el(env, mmu_idx);
10690     int select, tsz;
10691     bool epd, hpd;
10692
10693     if (mmu_idx == ARMMMUIdx_S2NS) {
10694         /* VTCR */
10695         bool sext = extract32(tcr, 4, 1);
10696         bool sign = extract32(tcr, 3, 1);
10697
10698         /*
10699          * If the sign-extend bit is not the same as t0sz[3], the result
10700          * is unpredictable. Flag this as a guest error.
10701          */
10702         if (sign != sext) {
10703             qemu_log_mask(LOG_GUEST_ERROR,
10704                           "AArch32: VTCR.S / VTCR.T0SZ[3] mismatch\n");
10705         }
10706         tsz = sextract32(tcr, 0, 4) + 8;
10707         select = 0;
10708         hpd = false;
10709         epd = false;
10710     } else if (el == 2) {
10711         /* HTCR */
10712         tsz = extract32(tcr, 0, 3);
10713         select = 0;
10714         hpd = extract64(tcr, 24, 1);
10715         epd = false;
10716     } else {
10717         int t0sz = extract32(tcr, 0, 3);
10718         int t1sz = extract32(tcr, 16, 3);
10719
10720         if (t1sz == 0) {
10721             select = va > (0xffffffffu >> t0sz);
10722         } else {
10723             /* Note that we will detect errors later.  */
10724             select = va >= ~(0xffffffffu >> t1sz);
10725         }
10726         if (!select) {
10727             tsz = t0sz;
10728             epd = extract32(tcr, 7, 1);
10729             hpd = extract64(tcr, 41, 1);
10730         } else {
10731             tsz = t1sz;
10732             epd = extract32(tcr, 23, 1);
10733             hpd = extract64(tcr, 42, 1);
10734         }
10735         /* For aarch32, hpd0 is not enabled without t2e as well.  */
10736         hpd &= extract32(tcr, 6, 1);
10737     }
10738
10739     return (ARMVAParameters) {
10740         .tsz = tsz,
10741         .select = select,
10742         .epd = epd,
10743         .hpd = hpd,
10744     };
10745 }
10746
10747 static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address,
10748                                MMUAccessType access_type, ARMMMUIdx mmu_idx,
10749                                hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot,
10750                                target_ulong *page_size_ptr,
10751                                ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs)
10752 {
10753     ARMCPU *cpu = arm_env_get_cpu(env);
10754     CPUState *cs = CPU(cpu);
10755     /* Read an LPAE long-descriptor translation table. */
10756     ARMFaultType fault_type = ARMFault_Translation;
10757     uint32_t level;
10758     ARMVAParameters param;
10759     uint64_t ttbr;
10760     hwaddr descaddr, indexmask, indexmask_grainsize;
10761     uint32_t tableattrs;
10762     target_ulong page_size;
10763     uint32_t attrs;
10764     int32_t stride;
10765     int addrsize, inputsize;
10766     TCR *tcr = regime_tcr(env, mmu_idx);
10767     int ap, ns, xn, pxn;
10768     uint32_t el = regime_el(env, mmu_idx);
10769     bool ttbr1_valid;
10770     uint64_t descaddrmask;
10771     bool aarch64 = arm_el_is_aa64(env, el);
10772     bool guarded = false;
10773
10774     /* TODO:
10775      * This code does not handle the different format TCR for VTCR_EL2.
10776      * This code also does not support shareability levels.
10777      * Attribute and permission bit handling should also be checked when adding
10778      * support for those page table walks.
10779      */
10780     if (aarch64) {
10781         param = aa64_va_parameters(env, address, mmu_idx,
10782                                    access_type != MMU_INST_FETCH);
10783         level = 0;
10784         /* If we are in 64-bit EL2 or EL3 then there is no TTBR1, so mark it
10785          * invalid.
10786          */
10787         ttbr1_valid = (el < 2);
10788         addrsize = 64 - 8 * param.tbi;
10789         inputsize = 64 - param.tsz;
10790     } else {
10791         param = aa32_va_parameters(env, address, mmu_idx);
10792         level = 1;
10793         /* There is no TTBR1 for EL2 */
10794         ttbr1_valid = (el != 2);
10795         addrsize = (mmu_idx == ARMMMUIdx_S2NS ? 40 : 32);
10796         inputsize = addrsize - param.tsz;
10797     }
10798
10799     /*
10800      * We determined the region when collecting the parameters, but we
10801      * have not yet validated that the address is valid for the region.
10802      * Extract the top bits and verify that they all match select.
10803      *
10804      * For aa32, if inputsize == addrsize, then we have selected the
10805      * region by exclusion in aa32_va_parameters and there is no more
10806      * validation to do here.
10807      */
10808     if (inputsize < addrsize) {
10809         target_ulong top_bits = sextract64(address, inputsize,
10810                                            addrsize - inputsize);
10811         if (-top_bits != param.select || (param.select && !ttbr1_valid)) {
10812             /* The gap between the two regions is a Translation fault */
10813             fault_type = ARMFault_Translation;
10814             goto do_fault;
10815         }
10816     }
10817
10818     if (param.using64k) {
10819         stride = 13;
10820     } else if (param.using16k) {
10821         stride = 11;
10822     } else {
10823         stride = 9;
10824     }
10825
10826     /* Note that QEMU ignores shareability and cacheability attributes,
10827      * so we don't need to do anything with the SH, ORGN, IRGN fields
10828      * in the TTBCR.  Similarly, TTBCR:A1 selects whether we get the
10829      * ASID from TTBR0 or TTBR1, but QEMU's TLB doesn't currently
10830      * implement any ASID-like capability so we can ignore it (instead
10831      * we will always flush the TLB any time the ASID is changed).
10832      */
10833     ttbr = regime_ttbr(env, mmu_idx, param.select);
10834
10835     /* Here we should have set up all the parameters for the translation:
10836      * inputsize, ttbr, epd, stride, tbi
10837      */
10838
10839     if (param.epd) {
10840         /* Translation table walk disabled => Translation fault on TLB miss
10841          * Note: This is always 0 on 64-bit EL2 and EL3.
10842          */
10843         goto do_fault;
10844     }
10845
10846     if (mmu_idx != ARMMMUIdx_S2NS) {
10847         /* The starting level depends on the virtual address size (which can
10848          * be up to 48 bits) and the translation granule size. It indicates
10849          * the number of strides (stride bits at a time) needed to
10850          * consume the bits of the input address. In the pseudocode this is:
10851          *  level = 4 - RoundUp((inputsize - grainsize) / stride)
10852          * where their 'inputsize' is our 'inputsize', 'grainsize' is
10853          * our 'stride + 3' and 'stride' is our 'stride'.
10854          * Applying the usual "rounded up m/n is (m+n-1)/n" and simplifying:
10855          * = 4 - (inputsize - stride - 3 + stride - 1) / stride
10856          * = 4 - (inputsize - 4) / stride;
10857          */
10858         level = 4 - (inputsize - 4) / stride;
10859     } else {
10860         /* For stage 2 translations the starting level is specified by the
10861          * VTCR_EL2.SL0 field (whose interpretation depends on the page size)
10862          */
10863         uint32_t sl0 = extract32(tcr->raw_tcr, 6, 2);
10864         uint32_t startlevel;
10865         bool ok;
10866
10867         if (!aarch64 || stride == 9) {
10868             /* AArch32 or 4KB pages */
10869             startlevel = 2 - sl0;
10870         } else {
10871             /* 16KB or 64KB pages */
10872             startlevel = 3 - sl0;
10873         }
10874
10875         /* Check that the starting level is valid. */
10876         ok = check_s2_mmu_setup(cpu, aarch64, startlevel,
10877                                 inputsize, stride);
10878         if (!ok) {
10879             fault_type = ARMFault_Translation;
10880             goto do_fault;
10881         }
10882         level = startlevel;
10883     }
10884
10885     indexmask_grainsize = (1ULL << (stride + 3)) - 1;
10886     indexmask = (1ULL << (inputsize - (stride * (4 - level)))) - 1;
10887
10888     /* Now we can extract the actual base address from the TTBR */
10889     descaddr = extract64(ttbr, 0, 48);
10890     descaddr &= ~indexmask;
10891
10892     /* The address field in the descriptor goes up to bit 39 for ARMv7
10893      * but up to bit 47 for ARMv8, but we use the descaddrmask
10894      * up to bit 39 for AArch32, because we don't need other bits in that case
10895      * to construct next descriptor address (anyway they should be all zeroes).
10896      */
10897     descaddrmask = ((1ull << (aarch64 ? 48 : 40)) - 1) &
10898                    ~indexmask_grainsize;
10899
10900     /* Secure accesses start with the page table in secure memory and
10901      * can be downgraded to non-secure at any step. Non-secure accesses
10902      * remain non-secure. We implement this by just ORing in the NSTable/NS
10903      * bits at each step.
10904      */
10905     tableattrs = regime_is_secure(env, mmu_idx) ? 0 : (1 << 4);
10906     for (;;) {
10907         uint64_t descriptor;
10908         bool nstable;
10909
10910         descaddr |= (address >> (stride * (4 - level))) & indexmask;
10911         descaddr &= ~7ULL;
10912         nstable = extract32(tableattrs, 4, 1);
10913         descriptor = arm_ldq_ptw(cs, descaddr, !nstable, mmu_idx, fi);
10914         if (fi->type != ARMFault_None) {
10915             goto do_fault;
10916         }
10917
10918         if (!(descriptor & 1) ||
10919             (!(descriptor & 2) && (level == 3))) {
10920             /* Invalid, or the Reserved level 3 encoding */
10921             goto do_fault;
10922         }
10923         descaddr = descriptor & descaddrmask;
10924
10925         if ((descriptor & 2) && (level < 3)) {
10926             /* Table entry. The top five bits are attributes which may
10927              * propagate down through lower levels of the table (and
10928              * which are all arranged so that 0 means "no effect", so
10929              * we can gather them up by ORing in the bits at each level).
10930              */
10931             tableattrs |= extract64(descriptor, 59, 5);
10932             level++;
10933             indexmask = indexmask_grainsize;
10934             continue;
10935         }
10936         /* Block entry at level 1 or 2, or page entry at level 3.
10937          * These are basically the same thing, although the number
10938          * of bits we pull in from the vaddr varies.
10939          */
10940         page_size = (1ULL << ((stride * (4 - level)) + 3));
10941         descaddr |= (address & (page_size - 1));
10942         /* Extract attributes from the descriptor */
10943         attrs = extract64(descriptor, 2, 10)
10944             | (extract64(descriptor, 52, 12) << 10);
10945
10946         if (mmu_idx == ARMMMUIdx_S2NS) {
10947             /* Stage 2 table descriptors do not include any attribute fields */
10948             break;
10949         }
10950         /* Merge in attributes from table descriptors */
10951         attrs |= nstable << 3; /* NS */
10952         guarded = extract64(descriptor, 50, 1);  /* GP */
10953         if (param.hpd) {
10954             /* HPD disables all the table attributes except NSTable.  */
10955             break;
10956         }
10957         attrs |= extract32(tableattrs, 0, 2) << 11;     /* XN, PXN */
10958         /* The sense of AP[1] vs APTable[0] is reversed, as APTable[0] == 1
10959          * means "force PL1 access only", which means forcing AP[1] to 0.
10960          */
10961         attrs &= ~(extract32(tableattrs, 2, 1) << 4);   /* !APT[0] => AP[1] */
10962         attrs |= extract32(tableattrs, 3, 1) << 5;      /* APT[1] => AP[2] */
10963         break;
10964     }
10965     /* Here descaddr is the final physical address, and attributes
10966      * are all in attrs.
10967      */
10968     fault_type = ARMFault_AccessFlag;
10969     if ((attrs & (1 << 8)) == 0) {
10970         /* Access flag */
10971         goto do_fault;
10972     }
10973
10974     ap = extract32(attrs, 4, 2);
10975     xn = extract32(attrs, 12, 1);
10976
10977     if (mmu_idx == ARMMMUIdx_S2NS) {
10978         ns = true;
10979         *prot = get_S2prot(env, ap, xn);
10980     } else {
10981         ns = extract32(attrs, 3, 1);
10982         pxn = extract32(attrs, 11, 1);
10983         *prot = get_S1prot(env, mmu_idx, aarch64, ap, ns, xn, pxn);
10984     }
10985
10986     fault_type = ARMFault_Permission;
10987     if (!(*prot & (1 << access_type))) {
10988         goto do_fault;
10989     }
10990
10991     if (ns) {
10992         /* The NS bit will (as required by the architecture) have no effect if
10993          * the CPU doesn't support TZ or this is a non-secure translation
10994          * regime, because the attribute will already be non-secure.
10995          */
10996         txattrs->secure = false;
10997     }
10998     /* When in aarch64 mode, and BTI is enabled, remember GP in the IOTLB.  */
10999     if (aarch64 && guarded && cpu_isar_feature(aa64_bti, cpu)) {
11000         txattrs->target_tlb_bit0 = true;
11001     }
11002
11003     if (cacheattrs != NULL) {
11004         if (mmu_idx == ARMMMUIdx_S2NS) {
11005             cacheattrs->attrs = convert_stage2_attrs(env,
11006                                                      extract32(attrs, 0, 4));
11007         } else {
11008             /* Index into MAIR registers for cache attributes */
11009             uint8_t attrindx = extract32(attrs, 0, 3);
11010             uint64_t mair = env->cp15.mair_el[regime_el(env, mmu_idx)];
11011             assert(attrindx <= 7);
11012             cacheattrs->attrs = extract64(mair, attrindx * 8, 8);
11013         }
11014         cacheattrs->shareability = extract32(attrs, 6, 2);
11015     }
11016
11017     *phys_ptr = descaddr;
11018     *page_size_ptr = page_size;
11019     return false;
11020
11021 do_fault:
11022     fi->type = fault_type;
11023     fi->level = level;
11024     /* Tag the error as S2 for failed S1 PTW at S2 or ordinary S2.  */
11025     fi->stage2 = fi->s1ptw || (mmu_idx == ARMMMUIdx_S2NS);
11026     return true;
11027 }
11028
11029 static inline void get_phys_addr_pmsav7_default(CPUARMState *env,
11030                                                 ARMMMUIdx mmu_idx,
11031                                                 int32_t address, int *prot)
11032 {
11033     if (!arm_feature(env, ARM_FEATURE_M)) {
11034         *prot = PAGE_READ | PAGE_WRITE;
11035         switch (address) {
11036         case 0xF0000000 ... 0xFFFFFFFF:
11037             if (regime_sctlr(env, mmu_idx) & SCTLR_V) {
11038                 /* hivecs execing is ok */
11039                 *prot |= PAGE_EXEC;
11040             }
11041             break;
11042         case 0x00000000 ... 0x7FFFFFFF:
11043             *prot |= PAGE_EXEC;
11044             break;
11045         }
11046     } else {
11047         /* Default system address map for M profile cores.
11048          * The architecture specifies which regions are execute-never;
11049          * at the MPU level no other checks are defined.
11050          */
11051         switch (address) {
11052         case 0x00000000 ... 0x1fffffff: /* ROM */
11053         case 0x20000000 ... 0x3fffffff: /* SRAM */
11054         case 0x60000000 ... 0x7fffffff: /* RAM */
11055         case 0x80000000 ... 0x9fffffff: /* RAM */
11056             *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
11057             break;
11058         case 0x40000000 ... 0x5fffffff: /* Peripheral */
11059         case 0xa0000000 ... 0xbfffffff: /* Device */
11060         case 0xc0000000 ... 0xdfffffff: /* Device */
11061         case 0xe0000000 ... 0xffffffff: /* System */
11062             *prot = PAGE_READ | PAGE_WRITE;
11063             break;
11064         default:
11065             g_assert_not_reached();
11066         }
11067     }
11068 }
11069
11070 static bool pmsav7_use_background_region(ARMCPU *cpu,
11071                                          ARMMMUIdx mmu_idx, bool is_user)
11072 {
11073     /* Return true if we should use the default memory map as a
11074      * "background" region if there are no hits against any MPU regions.
11075      */
11076     CPUARMState *env = &cpu->env;
11077
11078     if (is_user) {
11079         return false;
11080     }
11081
11082     if (arm_feature(env, ARM_FEATURE_M)) {
11083         return env->v7m.mpu_ctrl[regime_is_secure(env, mmu_idx)]
11084             & R_V7M_MPU_CTRL_PRIVDEFENA_MASK;
11085     } else {
11086         return regime_sctlr(env, mmu_idx) & SCTLR_BR;
11087     }
11088 }
11089
11090 static inline bool m_is_ppb_region(CPUARMState *env, uint32_t address)
11091 {
11092     /* True if address is in the M profile PPB region 0xe0000000 - 0xe00fffff */
11093     return arm_feature(env, ARM_FEATURE_M) &&
11094         extract32(address, 20, 12) == 0xe00;
11095 }
11096
11097 static inline bool m_is_system_region(CPUARMState *env, uint32_t address)
11098 {
11099     /* True if address is in the M profile system region
11100      * 0xe0000000 - 0xffffffff
11101      */
11102     return arm_feature(env, ARM_FEATURE_M) && extract32(address, 29, 3) == 0x7;
11103 }
11104
11105 static bool get_phys_addr_pmsav7(CPUARMState *env, uint32_t address,
11106                                  MMUAccessType access_type, ARMMMUIdx mmu_idx,
11107                                  hwaddr *phys_ptr, int *prot,
11108                                  target_ulong *page_size,
11109                                  ARMMMUFaultInfo *fi)
11110 {
11111     ARMCPU *cpu = arm_env_get_cpu(env);
11112     int n;
11113     bool is_user = regime_is_user(env, mmu_idx);
11114
11115     *phys_ptr = address;
11116     *page_size = TARGET_PAGE_SIZE;
11117     *prot = 0;
11118
11119     if (regime_translation_disabled(env, mmu_idx) ||
11120         m_is_ppb_region(env, address)) {
11121         /* MPU disabled or M profile PPB access: use default memory map.
11122          * The other case which uses the default memory map in the
11123          * v7M ARM ARM pseudocode is exception vector reads from the vector
11124          * table. In QEMU those accesses are done in arm_v7m_load_vector(),
11125          * which always does a direct read using address_space_ldl(), rather
11126          * than going via this function, so we don't need to check that here.
11127          */
11128         get_phys_addr_pmsav7_default(env, mmu_idx, address, prot);
11129     } else { /* MPU enabled */
11130         for (n = (int)cpu->pmsav7_dregion - 1; n >= 0; n--) {
11131             /* region search */
11132             uint32_t base = env->pmsav7.drbar[n];
11133             uint32_t rsize = extract32(env->pmsav7.drsr[n], 1, 5);
11134             uint32_t rmask;
11135             bool srdis = false;
11136
11137             if (!(env->pmsav7.drsr[n] & 0x1)) {
11138                 continue;
11139             }
11140
11141             if (!rsize) {
11142                 qemu_log_mask(LOG_GUEST_ERROR,
11143                               "DRSR[%d]: Rsize field cannot be 0\n", n);
11144                 continue;
11145             }
11146             rsize++;
11147             rmask = (1ull << rsize) - 1;
11148
11149             if (base & rmask) {
11150                 qemu_log_mask(LOG_GUEST_ERROR,
11151                               "DRBAR[%d]: 0x%" PRIx32 " misaligned "
11152                               "to DRSR region size, mask = 0x%" PRIx32 "\n",
11153                               n, base, rmask);
11154                 continue;
11155             }
11156
11157             if (address < base || address > base + rmask) {
11158                 /*
11159                  * Address not in this region. We must check whether the
11160                  * region covers addresses in the same page as our address.
11161                  * In that case we must not report a size that covers the
11162                  * whole page for a subsequent hit against a different MPU
11163                  * region or the background region, because it would result in
11164                  * incorrect TLB hits for subsequent accesses to addresses that
11165                  * are in this MPU region.
11166                  */
11167                 if (ranges_overlap(base, rmask,
11168                                    address & TARGET_PAGE_MASK,
11169                                    TARGET_PAGE_SIZE)) {
11170                     *page_size = 1;
11171                 }
11172                 continue;
11173             }
11174
11175             /* Region matched */
11176
11177             if (rsize >= 8) { /* no subregions for regions < 256 bytes */
11178                 int i, snd;
11179                 uint32_t srdis_mask;
11180
11181                 rsize -= 3; /* sub region size (power of 2) */
11182                 snd = ((address - base) >> rsize) & 0x7;
11183                 srdis = extract32(env->pmsav7.drsr[n], snd + 8, 1);
11184
11185                 srdis_mask = srdis ? 0x3 : 0x0;
11186                 for (i = 2; i <= 8 && rsize < TARGET_PAGE_BITS; i *= 2) {
11187                     /* This will check in groups of 2, 4 and then 8, whether
11188                      * the subregion bits are consistent. rsize is incremented
11189                      * back up to give the region size, considering consistent
11190                      * adjacent subregions as one region. Stop testing if rsize
11191                      * is already big enough for an entire QEMU page.
11192                      */
11193                     int snd_rounded = snd & ~(i - 1);
11194                     uint32_t srdis_multi = extract32(env->pmsav7.drsr[n],
11195                                                      snd_rounded + 8, i);
11196                     if (srdis_mask ^ srdis_multi) {
11197                         break;
11198                     }
11199                     srdis_mask = (srdis_mask << i) | srdis_mask;
11200                     rsize++;
11201                 }
11202             }
11203             if (srdis) {
11204                 continue;
11205             }
11206             if (rsize < TARGET_PAGE_BITS) {
11207                 *page_size = 1 << rsize;
11208             }
11209             break;
11210         }
11211
11212         if (n == -1) { /* no hits */
11213             if (!pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
11214                 /* background fault */
11215                 fi->type = ARMFault_Background;
11216                 return true;
11217             }
11218             get_phys_addr_pmsav7_default(env, mmu_idx, address, prot);
11219         } else { /* a MPU hit! */
11220             uint32_t ap = extract32(env->pmsav7.dracr[n], 8, 3);
11221             uint32_t xn = extract32(env->pmsav7.dracr[n], 12, 1);
11222
11223             if (m_is_system_region(env, address)) {
11224                 /* System space is always execute never */
11225                 xn = 1;
11226             }
11227
11228             if (is_user) { /* User mode AP bit decoding */
11229                 switch (ap) {
11230                 case 0:
11231                 case 1:
11232                 case 5:
11233                     break; /* no access */
11234                 case 3:
11235                     *prot |= PAGE_WRITE;
11236                     /* fall through */
11237                 case 2:
11238                 case 6:
11239                     *prot |= PAGE_READ | PAGE_EXEC;
11240                     break;
11241                 case 7:
11242                     /* for v7M, same as 6; for R profile a reserved value */
11243                     if (arm_feature(env, ARM_FEATURE_M)) {
11244                         *prot |= PAGE_READ | PAGE_EXEC;
11245                         break;
11246                     }
11247                     /* fall through */
11248                 default:
11249                     qemu_log_mask(LOG_GUEST_ERROR,
11250                                   "DRACR[%d]: Bad value for AP bits: 0x%"
11251                                   PRIx32 "\n", n, ap);
11252                 }
11253             } else { /* Priv. mode AP bits decoding */
11254                 switch (ap) {
11255                 case 0:
11256                     break; /* no access */
11257                 case 1:
11258                 case 2:
11259                 case 3:
11260                     *prot |= PAGE_WRITE;
11261                     /* fall through */
11262                 case 5:
11263                 case 6:
11264                     *prot |= PAGE_READ | PAGE_EXEC;
11265                     break;
11266                 case 7:
11267                     /* for v7M, same as 6; for R profile a reserved value */
11268                     if (arm_feature(env, ARM_FEATURE_M)) {
11269                         *prot |= PAGE_READ | PAGE_EXEC;
11270                         break;
11271                     }
11272                     /* fall through */
11273                 default:
11274                     qemu_log_mask(LOG_GUEST_ERROR,
11275                                   "DRACR[%d]: Bad value for AP bits: 0x%"
11276                                   PRIx32 "\n", n, ap);
11277                 }
11278             }
11279
11280             /* execute never */
11281             if (xn) {
11282                 *prot &= ~PAGE_EXEC;
11283             }
11284         }
11285     }
11286
11287     fi->type = ARMFault_Permission;
11288     fi->level = 1;
11289     return !(*prot & (1 << access_type));
11290 }
11291
11292 static bool v8m_is_sau_exempt(CPUARMState *env,
11293                               uint32_t address, MMUAccessType access_type)
11294 {
11295     /* The architecture specifies that certain address ranges are
11296      * exempt from v8M SAU/IDAU checks.
11297      */
11298     return
11299         (access_type == MMU_INST_FETCH && m_is_system_region(env, address)) ||
11300         (address >= 0xe0000000 && address <= 0xe0002fff) ||
11301         (address >= 0xe000e000 && address <= 0xe000efff) ||
11302         (address >= 0xe002e000 && address <= 0xe002efff) ||
11303         (address >= 0xe0040000 && address <= 0xe0041fff) ||
11304         (address >= 0xe00ff000 && address <= 0xe00fffff);
11305 }
11306
11307 static void v8m_security_lookup(CPUARMState *env, uint32_t address,
11308                                 MMUAccessType access_type, ARMMMUIdx mmu_idx,
11309                                 V8M_SAttributes *sattrs)
11310 {
11311     /* Look up the security attributes for this address. Compare the
11312      * pseudocode SecurityCheck() function.
11313      * We assume the caller has zero-initialized *sattrs.
11314      */
11315     ARMCPU *cpu = arm_env_get_cpu(env);
11316     int r;
11317     bool idau_exempt = false, idau_ns = true, idau_nsc = true;
11318     int idau_region = IREGION_NOTVALID;
11319     uint32_t addr_page_base = address & TARGET_PAGE_MASK;
11320     uint32_t addr_page_limit = addr_page_base + (TARGET_PAGE_SIZE - 1);
11321
11322     if (cpu->idau) {
11323         IDAUInterfaceClass *iic = IDAU_INTERFACE_GET_CLASS(cpu->idau);
11324         IDAUInterface *ii = IDAU_INTERFACE(cpu->idau);
11325
11326         iic->check(ii, address, &idau_region, &idau_exempt, &idau_ns,
11327                    &idau_nsc);
11328     }
11329
11330     if (access_type == MMU_INST_FETCH && extract32(address, 28, 4) == 0xf) {
11331         /* 0xf0000000..0xffffffff is always S for insn fetches */
11332         return;
11333     }
11334
11335     if (idau_exempt || v8m_is_sau_exempt(env, address, access_type)) {
11336         sattrs->ns = !regime_is_secure(env, mmu_idx);
11337         return;
11338     }
11339
11340     if (idau_region != IREGION_NOTVALID) {
11341         sattrs->irvalid = true;
11342         sattrs->iregion = idau_region;
11343     }
11344
11345     switch (env->sau.ctrl & 3) {
11346     case 0: /* SAU.ENABLE == 0, SAU.ALLNS == 0 */
11347         break;
11348     case 2: /* SAU.ENABLE == 0, SAU.ALLNS == 1 */
11349         sattrs->ns = true;
11350         break;
11351     default: /* SAU.ENABLE == 1 */
11352         for (r = 0; r < cpu->sau_sregion; r++) {
11353             if (env->sau.rlar[r] & 1) {
11354                 uint32_t base = env->sau.rbar[r] & ~0x1f;
11355                 uint32_t limit = env->sau.rlar[r] | 0x1f;
11356
11357                 if (base <= address && limit >= address) {
11358                     if (base > addr_page_base || limit < addr_page_limit) {
11359                         sattrs->subpage = true;
11360                     }
11361                     if (sattrs->srvalid) {
11362                         /* If we hit in more than one region then we must report
11363                          * as Secure, not NS-Callable, with no valid region
11364                          * number info.
11365                          */
11366                         sattrs->ns = false;
11367                         sattrs->nsc = false;
11368                         sattrs->sregion = 0;
11369                         sattrs->srvalid = false;
11370                         break;
11371                     } else {
11372                         if (env->sau.rlar[r] & 2) {
11373                             sattrs->nsc = true;
11374                         } else {
11375                             sattrs->ns = true;
11376                         }
11377                         sattrs->srvalid = true;
11378                         sattrs->sregion = r;
11379                     }
11380                 } else {
11381                     /*
11382                      * Address not in this region. We must check whether the
11383                      * region covers addresses in the same page as our address.
11384                      * In that case we must not report a size that covers the
11385                      * whole page for a subsequent hit against a different MPU
11386                      * region or the background region, because it would result
11387                      * in incorrect TLB hits for subsequent accesses to
11388                      * addresses that are in this MPU region.
11389                      */
11390                     if (limit >= base &&
11391                         ranges_overlap(base, limit - base + 1,
11392                                        addr_page_base,
11393                                        TARGET_PAGE_SIZE)) {
11394                         sattrs->subpage = true;
11395                     }
11396                 }
11397             }
11398         }
11399         break;
11400     }
11401
11402     /*
11403      * The IDAU will override the SAU lookup results if it specifies
11404      * higher security than the SAU does.
11405      */
11406     if (!idau_ns) {
11407         if (sattrs->ns || (!idau_nsc && sattrs->nsc)) {
11408             sattrs->ns = false;
11409             sattrs->nsc = idau_nsc;
11410         }
11411     }
11412 }
11413
11414 static bool pmsav8_mpu_lookup(CPUARMState *env, uint32_t address,
11415                               MMUAccessType access_type, ARMMMUIdx mmu_idx,
11416                               hwaddr *phys_ptr, MemTxAttrs *txattrs,
11417                               int *prot, bool *is_subpage,
11418                               ARMMMUFaultInfo *fi, uint32_t *mregion)
11419 {
11420     /* Perform a PMSAv8 MPU lookup (without also doing the SAU check
11421      * that a full phys-to-virt translation does).
11422      * mregion is (if not NULL) set to the region number which matched,
11423      * or -1 if no region number is returned (MPU off, address did not
11424      * hit a region, address hit in multiple regions).
11425      * We set is_subpage to true if the region hit doesn't cover the
11426      * entire TARGET_PAGE the address is within.
11427      */
11428     ARMCPU *cpu = arm_env_get_cpu(env);
11429     bool is_user = regime_is_user(env, mmu_idx);
11430     uint32_t secure = regime_is_secure(env, mmu_idx);
11431     int n;
11432     int matchregion = -1;
11433     bool hit = false;
11434     uint32_t addr_page_base = address & TARGET_PAGE_MASK;
11435     uint32_t addr_page_limit = addr_page_base + (TARGET_PAGE_SIZE - 1);
11436
11437     *is_subpage = false;
11438     *phys_ptr = address;
11439     *prot = 0;
11440     if (mregion) {
11441         *mregion = -1;
11442     }
11443
11444     /* Unlike the ARM ARM pseudocode, we don't need to check whether this
11445      * was an exception vector read from the vector table (which is always
11446      * done using the default system address map), because those accesses
11447      * are done in arm_v7m_load_vector(), which always does a direct
11448      * read using address_space_ldl(), rather than going via this function.
11449      */
11450     if (regime_translation_disabled(env, mmu_idx)) { /* MPU disabled */
11451         hit = true;
11452     } else if (m_is_ppb_region(env, address)) {
11453         hit = true;
11454     } else {
11455         if (pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
11456             hit = true;
11457         }
11458
11459         for (n = (int)cpu->pmsav7_dregion - 1; n >= 0; n--) {
11460             /* region search */
11461             /* Note that the base address is bits [31:5] from the register
11462              * with bits [4:0] all zeroes, but the limit address is bits
11463              * [31:5] from the register with bits [4:0] all ones.
11464              */
11465             uint32_t base = env->pmsav8.rbar[secure][n] & ~0x1f;
11466             uint32_t limit = env->pmsav8.rlar[secure][n] | 0x1f;
11467
11468             if (!(env->pmsav8.rlar[secure][n] & 0x1)) {
11469                 /* Region disabled */
11470                 continue;
11471             }
11472
11473             if (address < base || address > limit) {
11474                 /*
11475                  * Address not in this region. We must check whether the
11476                  * region covers addresses in the same page as our address.
11477                  * In that case we must not report a size that covers the
11478                  * whole page for a subsequent hit against a different MPU
11479                  * region or the background region, because it would result in
11480                  * incorrect TLB hits for subsequent accesses to addresses that
11481                  * are in this MPU region.
11482                  */
11483                 if (limit >= base &&
11484                     ranges_overlap(base, limit - base + 1,
11485                                    addr_page_base,
11486                                    TARGET_PAGE_SIZE)) {
11487                     *is_subpage = true;
11488                 }
11489                 continue;
11490             }
11491
11492             if (base > addr_page_base || limit < addr_page_limit) {
11493                 *is_subpage = true;
11494             }
11495
11496             if (matchregion != -1) {
11497                 /* Multiple regions match -- always a failure (unlike
11498                  * PMSAv7 where highest-numbered-region wins)
11499                  */
11500                 fi->type = ARMFault_Permission;
11501                 fi->level = 1;
11502                 return true;
11503             }
11504
11505             matchregion = n;
11506             hit = true;
11507         }
11508     }
11509
11510     if (!hit) {
11511         /* background fault */
11512         fi->type = ARMFault_Background;
11513         return true;
11514     }
11515
11516     if (matchregion == -1) {
11517         /* hit using the background region */
11518         get_phys_addr_pmsav7_default(env, mmu_idx, address, prot);
11519     } else {
11520         uint32_t ap = extract32(env->pmsav8.rbar[secure][matchregion], 1, 2);
11521         uint32_t xn = extract32(env->pmsav8.rbar[secure][matchregion], 0, 1);
11522
11523         if (m_is_system_region(env, address)) {
11524             /* System space is always execute never */
11525             xn = 1;
11526         }
11527
11528         *prot = simple_ap_to_rw_prot(env, mmu_idx, ap);
11529         if (*prot && !xn) {
11530             *prot |= PAGE_EXEC;
11531         }
11532         /* We don't need to look the attribute up in the MAIR0/MAIR1
11533          * registers because that only tells us about cacheability.
11534          */
11535         if (mregion) {
11536             *mregion = matchregion;
11537         }
11538     }
11539
11540     fi->type = ARMFault_Permission;
11541     fi->level = 1;
11542     return !(*prot & (1 << access_type));
11543 }
11544
11545
11546 static bool get_phys_addr_pmsav8(CPUARMState *env, uint32_t address,
11547                                  MMUAccessType access_type, ARMMMUIdx mmu_idx,
11548                                  hwaddr *phys_ptr, MemTxAttrs *txattrs,
11549                                  int *prot, target_ulong *page_size,
11550                                  ARMMMUFaultInfo *fi)
11551 {
11552     uint32_t secure = regime_is_secure(env, mmu_idx);
11553     V8M_SAttributes sattrs = {};
11554     bool ret;
11555     bool mpu_is_subpage;
11556
11557     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
11558         v8m_security_lookup(env, address, access_type, mmu_idx, &sattrs);
11559         if (access_type == MMU_INST_FETCH) {
11560             /* Instruction fetches always use the MMU bank and the
11561              * transaction attribute determined by the fetch address,
11562              * regardless of CPU state. This is painful for QEMU
11563              * to handle, because it would mean we need to encode
11564              * into the mmu_idx not just the (user, negpri) information
11565              * for the current security state but also that for the
11566              * other security state, which would balloon the number
11567              * of mmu_idx values needed alarmingly.
11568              * Fortunately we can avoid this because it's not actually
11569              * possible to arbitrarily execute code from memory with
11570              * the wrong security attribute: it will always generate
11571              * an exception of some kind or another, apart from the
11572              * special case of an NS CPU executing an SG instruction
11573              * in S&NSC memory. So we always just fail the translation
11574              * here and sort things out in the exception handler
11575              * (including possibly emulating an SG instruction).
11576              */
11577             if (sattrs.ns != !secure) {
11578                 if (sattrs.nsc) {
11579                     fi->type = ARMFault_QEMU_NSCExec;
11580                 } else {
11581                     fi->type = ARMFault_QEMU_SFault;
11582                 }
11583                 *page_size = sattrs.subpage ? 1 : TARGET_PAGE_SIZE;
11584                 *phys_ptr = address;
11585                 *prot = 0;
11586                 return true;
11587             }
11588         } else {
11589             /* For data accesses we always use the MMU bank indicated
11590              * by the current CPU state, but the security attributes
11591              * might downgrade a secure access to nonsecure.
11592              */
11593             if (sattrs.ns) {
11594                 txattrs->secure = false;
11595             } else if (!secure) {
11596                 /* NS access to S memory must fault.
11597                  * Architecturally we should first check whether the
11598                  * MPU information for this address indicates that we
11599                  * are doing an unaligned access to Device memory, which
11600                  * should generate a UsageFault instead. QEMU does not
11601                  * currently check for that kind of unaligned access though.
11602                  * If we added it we would need to do so as a special case
11603                  * for M_FAKE_FSR_SFAULT in arm_v7m_cpu_do_interrupt().
11604                  */
11605                 fi->type = ARMFault_QEMU_SFault;
11606                 *page_size = sattrs.subpage ? 1 : TARGET_PAGE_SIZE;
11607                 *phys_ptr = address;
11608                 *prot = 0;
11609                 return true;
11610             }
11611         }
11612     }
11613
11614     ret = pmsav8_mpu_lookup(env, address, access_type, mmu_idx, phys_ptr,
11615                             txattrs, prot, &mpu_is_subpage, fi, NULL);
11616     *page_size = sattrs.subpage || mpu_is_subpage ? 1 : TARGET_PAGE_SIZE;
11617     return ret;
11618 }
11619
11620 static bool get_phys_addr_pmsav5(CPUARMState *env, uint32_t address,
11621                                  MMUAccessType access_type, ARMMMUIdx mmu_idx,
11622                                  hwaddr *phys_ptr, int *prot,
11623                                  ARMMMUFaultInfo *fi)
11624 {
11625     int n;
11626     uint32_t mask;
11627     uint32_t base;
11628     bool is_user = regime_is_user(env, mmu_idx);
11629
11630     if (regime_translation_disabled(env, mmu_idx)) {
11631         /* MPU disabled.  */
11632         *phys_ptr = address;
11633         *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
11634         return false;
11635     }
11636
11637     *phys_ptr = address;
11638     for (n = 7; n >= 0; n--) {
11639         base = env->cp15.c6_region[n];
11640         if ((base & 1) == 0) {
11641             continue;
11642         }
11643         mask = 1 << ((base >> 1) & 0x1f);
11644         /* Keep this shift separate from the above to avoid an
11645            (undefined) << 32.  */
11646         mask = (mask << 1) - 1;
11647         if (((base ^ address) & ~mask) == 0) {
11648             break;
11649         }
11650     }
11651     if (n < 0) {
11652         fi->type = ARMFault_Background;
11653         return true;
11654     }
11655
11656     if (access_type == MMU_INST_FETCH) {
11657         mask = env->cp15.pmsav5_insn_ap;
11658     } else {
11659         mask = env->cp15.pmsav5_data_ap;
11660     }
11661     mask = (mask >> (n * 4)) & 0xf;
11662     switch (mask) {
11663     case 0:
11664         fi->type = ARMFault_Permission;
11665         fi->level = 1;
11666         return true;
11667     case 1:
11668         if (is_user) {
11669             fi->type = ARMFault_Permission;
11670             fi->level = 1;
11671             return true;
11672         }
11673         *prot = PAGE_READ | PAGE_WRITE;
11674         break;
11675     case 2:
11676         *prot = PAGE_READ;
11677         if (!is_user) {
11678             *prot |= PAGE_WRITE;
11679         }
11680         break;
11681     case 3:
11682         *prot = PAGE_READ | PAGE_WRITE;
11683         break;
11684     case 5:
11685         if (is_user) {
11686             fi->type = ARMFault_Permission;
11687             fi->level = 1;
11688             return true;
11689         }
11690         *prot = PAGE_READ;
11691         break;
11692     case 6:
11693         *prot = PAGE_READ;
11694         break;
11695     default:
11696         /* Bad permission.  */
11697         fi->type = ARMFault_Permission;
11698         fi->level = 1;
11699         return true;
11700     }
11701     *prot |= PAGE_EXEC;
11702     return false;
11703 }
11704
11705 /* Combine either inner or outer cacheability attributes for normal
11706  * memory, according to table D4-42 and pseudocode procedure
11707  * CombineS1S2AttrHints() of ARM DDI 0487B.b (the ARMv8 ARM).
11708  *
11709  * NB: only stage 1 includes allocation hints (RW bits), leading to
11710  * some asymmetry.
11711  */
11712 static uint8_t combine_cacheattr_nibble(uint8_t s1, uint8_t s2)
11713 {
11714     if (s1 == 4 || s2 == 4) {
11715         /* non-cacheable has precedence */
11716         return 4;
11717     } else if (extract32(s1, 2, 2) == 0 || extract32(s1, 2, 2) == 2) {
11718         /* stage 1 write-through takes precedence */
11719         return s1;
11720     } else if (extract32(s2, 2, 2) == 2) {
11721         /* stage 2 write-through takes precedence, but the allocation hint
11722          * is still taken from stage 1
11723          */
11724         return (2 << 2) | extract32(s1, 0, 2);
11725     } else { /* write-back */
11726         return s1;
11727     }
11728 }
11729
11730 /* Combine S1 and S2 cacheability/shareability attributes, per D4.5.4
11731  * and CombineS1S2Desc()
11732  *
11733  * @s1:      Attributes from stage 1 walk
11734  * @s2:      Attributes from stage 2 walk
11735  */
11736 static ARMCacheAttrs combine_cacheattrs(ARMCacheAttrs s1, ARMCacheAttrs s2)
11737 {
11738     uint8_t s1lo = extract32(s1.attrs, 0, 4), s2lo = extract32(s2.attrs, 0, 4);
11739     uint8_t s1hi = extract32(s1.attrs, 4, 4), s2hi = extract32(s2.attrs, 4, 4);
11740     ARMCacheAttrs ret;
11741
11742     /* Combine shareability attributes (table D4-43) */
11743     if (s1.shareability == 2 || s2.shareability == 2) {
11744         /* if either are outer-shareable, the result is outer-shareable */
11745         ret.shareability = 2;
11746     } else if (s1.shareability == 3 || s2.shareability == 3) {
11747         /* if either are inner-shareable, the result is inner-shareable */
11748         ret.shareability = 3;
11749     } else {
11750         /* both non-shareable */
11751         ret.shareability = 0;
11752     }
11753
11754     /* Combine memory type and cacheability attributes */
11755     if (s1hi == 0 || s2hi == 0) {
11756         /* Device has precedence over normal */
11757         if (s1lo == 0 || s2lo == 0) {
11758             /* nGnRnE has precedence over anything */
11759             ret.attrs = 0;
11760         } else if (s1lo == 4 || s2lo == 4) {
11761             /* non-Reordering has precedence over Reordering */
11762             ret.attrs = 4;  /* nGnRE */
11763         } else if (s1lo == 8 || s2lo == 8) {
11764             /* non-Gathering has precedence over Gathering */
11765             ret.attrs = 8;  /* nGRE */
11766         } else {
11767             ret.attrs = 0xc; /* GRE */
11768         }
11769
11770         /* Any location for which the resultant memory type is any
11771          * type of Device memory is always treated as Outer Shareable.
11772          */
11773         ret.shareability = 2;
11774     } else { /* Normal memory */
11775         /* Outer/inner cacheability combine independently */
11776         ret.attrs = combine_cacheattr_nibble(s1hi, s2hi) << 4
11777                   | combine_cacheattr_nibble(s1lo, s2lo);
11778
11779         if (ret.attrs == 0x44) {
11780             /* Any location for which the resultant memory type is Normal
11781              * Inner Non-cacheable, Outer Non-cacheable is always treated
11782              * as Outer Shareable.
11783              */
11784             ret.shareability = 2;
11785         }
11786     }
11787
11788     return ret;
11789 }
11790
11791
11792 /* get_phys_addr - get the physical address for this virtual address
11793  *
11794  * Find the physical address corresponding to the given virtual address,
11795  * by doing a translation table walk on MMU based systems or using the
11796  * MPU state on MPU based systems.
11797  *
11798  * Returns false if the translation was successful. Otherwise, phys_ptr, attrs,
11799  * prot and page_size may not be filled in, and the populated fsr value provides
11800  * information on why the translation aborted, in the format of a
11801  * DFSR/IFSR fault register, with the following caveats:
11802  *  * we honour the short vs long DFSR format differences.
11803  *  * the WnR bit is never set (the caller must do this).
11804  *  * for PSMAv5 based systems we don't bother to return a full FSR format
11805  *    value.
11806  *
11807  * @env: CPUARMState
11808  * @address: virtual address to get physical address for
11809  * @access_type: 0 for read, 1 for write, 2 for execute
11810  * @mmu_idx: MMU index indicating required translation regime
11811  * @phys_ptr: set to the physical address corresponding to the virtual address
11812  * @attrs: set to the memory transaction attributes to use
11813  * @prot: set to the permissions for the page containing phys_ptr
11814  * @page_size: set to the size of the page containing phys_ptr
11815  * @fi: set to fault info if the translation fails
11816  * @cacheattrs: (if non-NULL) set to the cacheability/shareability attributes
11817  */
11818 static bool get_phys_addr(CPUARMState *env, target_ulong address,
11819                           MMUAccessType access_type, ARMMMUIdx mmu_idx,
11820                           hwaddr *phys_ptr, MemTxAttrs *attrs, int *prot,
11821                           target_ulong *page_size,
11822                           ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs)
11823 {
11824     if (mmu_idx == ARMMMUIdx_S12NSE0 || mmu_idx == ARMMMUIdx_S12NSE1) {
11825         /* Call ourselves recursively to do the stage 1 and then stage 2
11826          * translations.
11827          */
11828         if (arm_feature(env, ARM_FEATURE_EL2)) {
11829             hwaddr ipa;
11830             int s2_prot;
11831             int ret;
11832             ARMCacheAttrs cacheattrs2 = {};
11833
11834             ret = get_phys_addr(env, address, access_type,
11835                                 stage_1_mmu_idx(mmu_idx), &ipa, attrs,
11836                                 prot, page_size, fi, cacheattrs);
11837
11838             /* If S1 fails or S2 is disabled, return early.  */
11839             if (ret || regime_translation_disabled(env, ARMMMUIdx_S2NS)) {
11840                 *phys_ptr = ipa;
11841                 return ret;
11842             }
11843
11844             /* S1 is done. Now do S2 translation.  */
11845             ret = get_phys_addr_lpae(env, ipa, access_type, ARMMMUIdx_S2NS,
11846                                      phys_ptr, attrs, &s2_prot,
11847                                      page_size, fi,
11848                                      cacheattrs != NULL ? &cacheattrs2 : NULL);
11849             fi->s2addr = ipa;
11850             /* Combine the S1 and S2 perms.  */
11851             *prot &= s2_prot;
11852
11853             /* Combine the S1 and S2 cache attributes, if needed */
11854             if (!ret && cacheattrs != NULL) {
11855                 if (env->cp15.hcr_el2 & HCR_DC) {
11856                     /*
11857                      * HCR.DC forces the first stage attributes to
11858                      *  Normal Non-Shareable,
11859                      *  Inner Write-Back Read-Allocate Write-Allocate,
11860                      *  Outer Write-Back Read-Allocate Write-Allocate.
11861                      */
11862                     cacheattrs->attrs = 0xff;
11863                     cacheattrs->shareability = 0;
11864                 }
11865                 *cacheattrs = combine_cacheattrs(*cacheattrs, cacheattrs2);
11866             }
11867
11868             return ret;
11869         } else {
11870             /*
11871              * For non-EL2 CPUs a stage1+stage2 translation is just stage 1.
11872              */
11873             mmu_idx = stage_1_mmu_idx(mmu_idx);
11874         }
11875     }
11876
11877     /* The page table entries may downgrade secure to non-secure, but
11878      * cannot upgrade an non-secure translation regime's attributes
11879      * to secure.
11880      */
11881     attrs->secure = regime_is_secure(env, mmu_idx);
11882     attrs->user = regime_is_user(env, mmu_idx);
11883
11884     /* Fast Context Switch Extension. This doesn't exist at all in v8.
11885      * In v7 and earlier it affects all stage 1 translations.
11886      */
11887     if (address < 0x02000000 && mmu_idx != ARMMMUIdx_S2NS
11888         && !arm_feature(env, ARM_FEATURE_V8)) {
11889         if (regime_el(env, mmu_idx) == 3) {
11890             address += env->cp15.fcseidr_s;
11891         } else {
11892             address += env->cp15.fcseidr_ns;
11893         }
11894     }
11895
11896     if (arm_feature(env, ARM_FEATURE_PMSA)) {
11897         bool ret;
11898         *page_size = TARGET_PAGE_SIZE;
11899
11900         if (arm_feature(env, ARM_FEATURE_V8)) {
11901             /* PMSAv8 */
11902             ret = get_phys_addr_pmsav8(env, address, access_type, mmu_idx,
11903                                        phys_ptr, attrs, prot, page_size, fi);
11904         } else if (arm_feature(env, ARM_FEATURE_V7)) {
11905             /* PMSAv7 */
11906             ret = get_phys_addr_pmsav7(env, address, access_type, mmu_idx,
11907                                        phys_ptr, prot, page_size, fi);
11908         } else {
11909             /* Pre-v7 MPU */
11910             ret = get_phys_addr_pmsav5(env, address, access_type, mmu_idx,
11911                                        phys_ptr, prot, fi);
11912         }
11913         qemu_log_mask(CPU_LOG_MMU, "PMSA MPU lookup for %s at 0x%08" PRIx32
11914                       " mmu_idx %u -> %s (prot %c%c%c)\n",
11915                       access_type == MMU_DATA_LOAD ? "reading" :
11916                       (access_type == MMU_DATA_STORE ? "writing" : "execute"),
11917                       (uint32_t)address, mmu_idx,
11918                       ret ? "Miss" : "Hit",
11919                       *prot & PAGE_READ ? 'r' : '-',
11920                       *prot & PAGE_WRITE ? 'w' : '-',
11921                       *prot & PAGE_EXEC ? 'x' : '-');
11922
11923         return ret;
11924     }
11925
11926     /* Definitely a real MMU, not an MPU */
11927
11928     if (regime_translation_disabled(env, mmu_idx)) {
11929         /* MMU disabled. */
11930         *phys_ptr = address;
11931         *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
11932         *page_size = TARGET_PAGE_SIZE;
11933         return 0;
11934     }
11935
11936     if (regime_using_lpae_format(env, mmu_idx)) {
11937         return get_phys_addr_lpae(env, address, access_type, mmu_idx,
11938                                   phys_ptr, attrs, prot, page_size,
11939                                   fi, cacheattrs);
11940     } else if (regime_sctlr(env, mmu_idx) & SCTLR_XP) {
11941         return get_phys_addr_v6(env, address, access_type, mmu_idx,
11942                                 phys_ptr, attrs, prot, page_size, fi);
11943     } else {
11944         return get_phys_addr_v5(env, address, access_type, mmu_idx,
11945                                     phys_ptr, prot, page_size, fi);
11946     }
11947 }
11948
11949 /* Walk the page table and (if the mapping exists) add the page
11950  * to the TLB. Return false on success, or true on failure. Populate
11951  * fsr with ARM DFSR/IFSR fault register format value on failure.
11952  */
11953 bool arm_tlb_fill(CPUState *cs, vaddr address,
11954                   MMUAccessType access_type, int mmu_idx,
11955                   ARMMMUFaultInfo *fi)
11956 {
11957     ARMCPU *cpu = ARM_CPU(cs);
11958     CPUARMState *env = &cpu->env;
11959     hwaddr phys_addr;
11960     target_ulong page_size;
11961     int prot;
11962     int ret;
11963     MemTxAttrs attrs = {};
11964
11965     ret = get_phys_addr(env, address, access_type,
11966                         core_to_arm_mmu_idx(env, mmu_idx), &phys_addr,
11967                         &attrs, &prot, &page_size, fi, NULL);
11968     if (!ret) {
11969         /*
11970          * Map a single [sub]page. Regions smaller than our declared
11971          * target page size are handled specially, so for those we
11972          * pass in the exact addresses.
11973          */
11974         if (page_size >= TARGET_PAGE_SIZE) {
11975             phys_addr &= TARGET_PAGE_MASK;
11976             address &= TARGET_PAGE_MASK;
11977         }
11978         tlb_set_page_with_attrs(cs, address, phys_addr, attrs,
11979                                 prot, mmu_idx, page_size);
11980         return 0;
11981     }
11982
11983     return ret;
11984 }
11985
11986 hwaddr arm_cpu_get_phys_page_attrs_debug(CPUState *cs, vaddr addr,
11987                                          MemTxAttrs *attrs)
11988 {
11989     ARMCPU *cpu = ARM_CPU(cs);
11990     CPUARMState *env = &cpu->env;
11991     hwaddr phys_addr;
11992     target_ulong page_size;
11993     int prot;
11994     bool ret;
11995     ARMMMUFaultInfo fi = {};
11996     ARMMMUIdx mmu_idx = arm_mmu_idx(env);
11997
11998     *attrs = (MemTxAttrs) {};
11999
12000     ret = get_phys_addr(env, addr, 0, mmu_idx, &phys_addr,
12001                         attrs, &prot, &page_size, &fi, NULL);
12002
12003     if (ret) {
12004         return -1;
12005     }
12006     return phys_addr;
12007 }
12008
12009 uint32_t HELPER(v7m_mrs)(CPUARMState *env, uint32_t reg)
12010 {
12011     uint32_t mask;
12012     unsigned el = arm_current_el(env);
12013
12014     /* First handle registers which unprivileged can read */
12015
12016     switch (reg) {
12017     case 0 ... 7: /* xPSR sub-fields */
12018         mask = 0;
12019         if ((reg & 1) && el) {
12020             mask |= XPSR_EXCP; /* IPSR (unpriv. reads as zero) */
12021         }
12022         if (!(reg & 4)) {
12023             mask |= XPSR_NZCV | XPSR_Q; /* APSR */
12024         }
12025         /* EPSR reads as zero */
12026         return xpsr_read(env) & mask;
12027         break;
12028     case 20: /* CONTROL */
12029         return env->v7m.control[env->v7m.secure];
12030     case 0x94: /* CONTROL_NS */
12031         /* We have to handle this here because unprivileged Secure code
12032          * can read the NS CONTROL register.
12033          */
12034         if (!env->v7m.secure) {
12035             return 0;
12036         }
12037         return env->v7m.control[M_REG_NS];
12038     }
12039
12040     if (el == 0) {
12041         return 0; /* unprivileged reads others as zero */
12042     }
12043
12044     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
12045         switch (reg) {
12046         case 0x88: /* MSP_NS */
12047             if (!env->v7m.secure) {
12048                 return 0;
12049             }
12050             return env->v7m.other_ss_msp;
12051         case 0x89: /* PSP_NS */
12052             if (!env->v7m.secure) {
12053                 return 0;
12054             }
12055             return env->v7m.other_ss_psp;
12056         case 0x8a: /* MSPLIM_NS */
12057             if (!env->v7m.secure) {
12058                 return 0;
12059             }
12060             return env->v7m.msplim[M_REG_NS];
12061         case 0x8b: /* PSPLIM_NS */
12062             if (!env->v7m.secure) {
12063                 return 0;
12064             }
12065             return env->v7m.psplim[M_REG_NS];
12066         case 0x90: /* PRIMASK_NS */
12067             if (!env->v7m.secure) {
12068                 return 0;
12069             }
12070             return env->v7m.primask[M_REG_NS];
12071         case 0x91: /* BASEPRI_NS */
12072             if (!env->v7m.secure) {
12073                 return 0;
12074             }
12075             return env->v7m.basepri[M_REG_NS];
12076         case 0x93: /* FAULTMASK_NS */
12077             if (!env->v7m.secure) {
12078                 return 0;
12079             }
12080             return env->v7m.faultmask[M_REG_NS];
12081         case 0x98: /* SP_NS */
12082         {
12083             /* This gives the non-secure SP selected based on whether we're
12084              * currently in handler mode or not, using the NS CONTROL.SPSEL.
12085              */
12086             bool spsel = env->v7m.control[M_REG_NS] & R_V7M_CONTROL_SPSEL_MASK;
12087
12088             if (!env->v7m.secure) {
12089                 return 0;
12090             }
12091             if (!arm_v7m_is_handler_mode(env) && spsel) {
12092                 return env->v7m.other_ss_psp;
12093             } else {
12094                 return env->v7m.other_ss_msp;
12095             }
12096         }
12097         default:
12098             break;
12099         }
12100     }
12101
12102     switch (reg) {
12103     case 8: /* MSP */
12104         return v7m_using_psp(env) ? env->v7m.other_sp : env->regs[13];
12105     case 9: /* PSP */
12106         return v7m_using_psp(env) ? env->regs[13] : env->v7m.other_sp;
12107     case 10: /* MSPLIM */
12108         if (!arm_feature(env, ARM_FEATURE_V8)) {
12109             goto bad_reg;
12110         }
12111         return env->v7m.msplim[env->v7m.secure];
12112     case 11: /* PSPLIM */
12113         if (!arm_feature(env, ARM_FEATURE_V8)) {
12114             goto bad_reg;
12115         }
12116         return env->v7m.psplim[env->v7m.secure];
12117     case 16: /* PRIMASK */
12118         return env->v7m.primask[env->v7m.secure];
12119     case 17: /* BASEPRI */
12120     case 18: /* BASEPRI_MAX */
12121         return env->v7m.basepri[env->v7m.secure];
12122     case 19: /* FAULTMASK */
12123         return env->v7m.faultmask[env->v7m.secure];
12124     default:
12125     bad_reg:
12126         qemu_log_mask(LOG_GUEST_ERROR, "Attempt to read unknown special"
12127                                        " register %d\n", reg);
12128         return 0;
12129     }
12130 }
12131
12132 void HELPER(v7m_msr)(CPUARMState *env, uint32_t maskreg, uint32_t val)
12133 {
12134     /* We're passed bits [11..0] of the instruction; extract
12135      * SYSm and the mask bits.
12136      * Invalid combinations of SYSm and mask are UNPREDICTABLE;
12137      * we choose to treat them as if the mask bits were valid.
12138      * NB that the pseudocode 'mask' variable is bits [11..10],
12139      * whereas ours is [11..8].
12140      */
12141     uint32_t mask = extract32(maskreg, 8, 4);
12142     uint32_t reg = extract32(maskreg, 0, 8);
12143
12144     if (arm_current_el(env) == 0 && reg > 7) {
12145         /* only xPSR sub-fields may be written by unprivileged */
12146         return;
12147     }
12148
12149     if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
12150         switch (reg) {
12151         case 0x88: /* MSP_NS */
12152             if (!env->v7m.secure) {
12153                 return;
12154             }
12155             env->v7m.other_ss_msp = val;
12156             return;
12157         case 0x89: /* PSP_NS */
12158             if (!env->v7m.secure) {
12159                 return;
12160             }
12161             env->v7m.other_ss_psp = val;
12162             return;
12163         case 0x8a: /* MSPLIM_NS */
12164             if (!env->v7m.secure) {
12165                 return;
12166             }
12167             env->v7m.msplim[M_REG_NS] = val & ~7;
12168             return;
12169         case 0x8b: /* PSPLIM_NS */
12170             if (!env->v7m.secure) {
12171                 return;
12172             }
12173             env->v7m.psplim[M_REG_NS] = val & ~7;
12174             return;
12175         case 0x90: /* PRIMASK_NS */
12176             if (!env->v7m.secure) {
12177                 return;
12178             }
12179             env->v7m.primask[M_REG_NS] = val & 1;
12180             return;
12181         case 0x91: /* BASEPRI_NS */
12182             if (!env->v7m.secure || !arm_feature(env, ARM_FEATURE_M_MAIN)) {
12183                 return;
12184             }
12185             env->v7m.basepri[M_REG_NS] = val & 0xff;
12186             return;
12187         case 0x93: /* FAULTMASK_NS */
12188             if (!env->v7m.secure || !arm_feature(env, ARM_FEATURE_M_MAIN)) {
12189                 return;
12190             }
12191             env->v7m.faultmask[M_REG_NS] = val & 1;
12192             return;
12193         case 0x94: /* CONTROL_NS */
12194             if (!env->v7m.secure) {
12195                 return;
12196             }
12197             write_v7m_control_spsel_for_secstate(env,
12198                                                  val & R_V7M_CONTROL_SPSEL_MASK,
12199                                                  M_REG_NS);
12200             if (arm_feature(env, ARM_FEATURE_M_MAIN)) {
12201                 env->v7m.control[M_REG_NS] &= ~R_V7M_CONTROL_NPRIV_MASK;
12202                 env->v7m.control[M_REG_NS] |= val & R_V7M_CONTROL_NPRIV_MASK;
12203             }
12204             return;
12205         case 0x98: /* SP_NS */
12206         {
12207             /* This gives the non-secure SP selected based on whether we're
12208              * currently in handler mode or not, using the NS CONTROL.SPSEL.
12209              */
12210             bool spsel = env->v7m.control[M_REG_NS] & R_V7M_CONTROL_SPSEL_MASK;
12211             bool is_psp = !arm_v7m_is_handler_mode(env) && spsel;
12212             uint32_t limit;
12213
12214             if (!env->v7m.secure) {
12215                 return;
12216             }
12217
12218             limit = is_psp ? env->v7m.psplim[false] : env->v7m.msplim[false];
12219
12220             if (val < limit) {
12221                 CPUState *cs = CPU(arm_env_get_cpu(env));
12222
12223                 cpu_restore_state(cs, GETPC(), true);
12224                 raise_exception(env, EXCP_STKOF, 0, 1);
12225             }
12226
12227             if (is_psp) {
12228                 env->v7m.other_ss_psp = val;
12229             } else {
12230                 env->v7m.other_ss_msp = val;
12231             }
12232             return;
12233         }
12234         default:
12235             break;
12236         }
12237     }
12238
12239     switch (reg) {
12240     case 0 ... 7: /* xPSR sub-fields */
12241         /* only APSR is actually writable */
12242         if (!(reg & 4)) {
12243             uint32_t apsrmask = 0;
12244
12245             if (mask & 8) {
12246                 apsrmask |= XPSR_NZCV | XPSR_Q;
12247             }
12248             if ((mask & 4) && arm_feature(env, ARM_FEATURE_THUMB_DSP)) {
12249                 apsrmask |= XPSR_GE;
12250             }
12251             xpsr_write(env, val, apsrmask);
12252         }
12253         break;
12254     case 8: /* MSP */
12255         if (v7m_using_psp(env)) {
12256             env->v7m.other_sp = val;
12257         } else {
12258             env->regs[13] = val;
12259         }
12260         break;
12261     case 9: /* PSP */
12262         if (v7m_using_psp(env)) {
12263             env->regs[13] = val;
12264         } else {
12265             env->v7m.other_sp = val;
12266         }
12267         break;
12268     case 10: /* MSPLIM */
12269         if (!arm_feature(env, ARM_FEATURE_V8)) {
12270             goto bad_reg;
12271         }
12272         env->v7m.msplim[env->v7m.secure] = val & ~7;
12273         break;
12274     case 11: /* PSPLIM */
12275         if (!arm_feature(env, ARM_FEATURE_V8)) {
12276             goto bad_reg;
12277         }
12278         env->v7m.psplim[env->v7m.secure] = val & ~7;
12279         break;
12280     case 16: /* PRIMASK */
12281         env->v7m.primask[env->v7m.secure] = val & 1;
12282         break;
12283     case 17: /* BASEPRI */
12284         if (!arm_feature(env, ARM_FEATURE_M_MAIN)) {
12285             goto bad_reg;
12286         }
12287         env->v7m.basepri[env->v7m.secure] = val & 0xff;
12288         break;
12289     case 18: /* BASEPRI_MAX */
12290         if (!arm_feature(env, ARM_FEATURE_M_MAIN)) {
12291             goto bad_reg;
12292         }
12293         val &= 0xff;
12294         if (val != 0 && (val < env->v7m.basepri[env->v7m.secure]
12295                          || env->v7m.basepri[env->v7m.secure] == 0)) {
12296             env->v7m.basepri[env->v7m.secure] = val;
12297         }
12298         break;
12299     case 19: /* FAULTMASK */
12300         if (!arm_feature(env, ARM_FEATURE_M_MAIN)) {
12301             goto bad_reg;
12302         }
12303         env->v7m.faultmask[env->v7m.secure] = val & 1;
12304         break;
12305     case 20: /* CONTROL */
12306         /* Writing to the SPSEL bit only has an effect if we are in
12307          * thread mode; other bits can be updated by any privileged code.
12308          * write_v7m_control_spsel() deals with updating the SPSEL bit in
12309          * env->v7m.control, so we only need update the others.
12310          * For v7M, we must just ignore explicit writes to SPSEL in handler
12311          * mode; for v8M the write is permitted but will have no effect.
12312          */
12313         if (arm_feature(env, ARM_FEATURE_V8) ||
12314             !arm_v7m_is_handler_mode(env)) {
12315             write_v7m_control_spsel(env, (val & R_V7M_CONTROL_SPSEL_MASK) != 0);
12316         }
12317         if (arm_feature(env, ARM_FEATURE_M_MAIN)) {
12318             env->v7m.control[env->v7m.secure] &= ~R_V7M_CONTROL_NPRIV_MASK;
12319             env->v7m.control[env->v7m.secure] |= val & R_V7M_CONTROL_NPRIV_MASK;
12320         }
12321         break;
12322     default:
12323     bad_reg:
12324         qemu_log_mask(LOG_GUEST_ERROR, "Attempt to write unknown special"
12325                                        " register %d\n", reg);
12326         return;
12327     }
12328 }
12329
12330 uint32_t HELPER(v7m_tt)(CPUARMState *env, uint32_t addr, uint32_t op)
12331 {
12332     /* Implement the TT instruction. op is bits [7:6] of the insn. */
12333     bool forceunpriv = op & 1;
12334     bool alt = op & 2;
12335     V8M_SAttributes sattrs = {};
12336     uint32_t tt_resp;
12337     bool r, rw, nsr, nsrw, mrvalid;
12338     int prot;
12339     ARMMMUFaultInfo fi = {};
12340     MemTxAttrs attrs = {};
12341     hwaddr phys_addr;
12342     ARMMMUIdx mmu_idx;
12343     uint32_t mregion;
12344     bool targetpriv;
12345     bool targetsec = env->v7m.secure;
12346     bool is_subpage;
12347
12348     /* Work out what the security state and privilege level we're
12349      * interested in is...
12350      */
12351     if (alt) {
12352         targetsec = !targetsec;
12353     }
12354
12355     if (forceunpriv) {
12356         targetpriv = false;
12357     } else {
12358         targetpriv = arm_v7m_is_handler_mode(env) ||
12359             !(env->v7m.control[targetsec] & R_V7M_CONTROL_NPRIV_MASK);
12360     }
12361
12362     /* ...and then figure out which MMU index this is */
12363     mmu_idx = arm_v7m_mmu_idx_for_secstate_and_priv(env, targetsec, targetpriv);
12364
12365     /* We know that the MPU and SAU don't care about the access type
12366      * for our purposes beyond that we don't want to claim to be
12367      * an insn fetch, so we arbitrarily call this a read.
12368      */
12369
12370     /* MPU region info only available for privileged or if
12371      * inspecting the other MPU state.
12372      */
12373     if (arm_current_el(env) != 0 || alt) {
12374         /* We can ignore the return value as prot is always set */
12375         pmsav8_mpu_lookup(env, addr, MMU_DATA_LOAD, mmu_idx,
12376                           &phys_addr, &attrs, &prot, &is_subpage,
12377                           &fi, &mregion);
12378         if (mregion == -1) {
12379             mrvalid = false;
12380             mregion = 0;
12381         } else {
12382             mrvalid = true;
12383         }
12384         r = prot & PAGE_READ;
12385         rw = prot & PAGE_WRITE;
12386     } else {
12387         r = false;
12388         rw = false;
12389         mrvalid = false;
12390         mregion = 0;
12391     }
12392
12393     if (env->v7m.secure) {
12394         v8m_security_lookup(env, addr, MMU_DATA_LOAD, mmu_idx, &sattrs);
12395         nsr = sattrs.ns && r;
12396         nsrw = sattrs.ns && rw;
12397     } else {
12398         sattrs.ns = true;
12399         nsr = false;
12400         nsrw = false;
12401     }
12402
12403     tt_resp = (sattrs.iregion << 24) |
12404         (sattrs.irvalid << 23) |
12405         ((!sattrs.ns) << 22) |
12406         (nsrw << 21) |
12407         (nsr << 20) |
12408         (rw << 19) |
12409         (r << 18) |
12410         (sattrs.srvalid << 17) |
12411         (mrvalid << 16) |
12412         (sattrs.sregion << 8) |
12413         mregion;
12414
12415     return tt_resp;
12416 }
12417
12418 #endif
12419
12420 void HELPER(dc_zva)(CPUARMState *env, uint64_t vaddr_in)
12421 {
12422     /* Implement DC ZVA, which zeroes a fixed-length block of memory.
12423      * Note that we do not implement the (architecturally mandated)
12424      * alignment fault for attempts to use this on Device memory
12425      * (which matches the usual QEMU behaviour of not implementing either
12426      * alignment faults or any memory attribute handling).
12427      */
12428
12429     ARMCPU *cpu = arm_env_get_cpu(env);
12430     uint64_t blocklen = 4 << cpu->dcz_blocksize;
12431     uint64_t vaddr = vaddr_in & ~(blocklen - 1);
12432
12433 #ifndef CONFIG_USER_ONLY
12434     {
12435         /* Slightly awkwardly, QEMU's TARGET_PAGE_SIZE may be less than
12436          * the block size so we might have to do more than one TLB lookup.
12437          * We know that in fact for any v8 CPU the page size is at least 4K
12438          * and the block size must be 2K or less, but TARGET_PAGE_SIZE is only
12439          * 1K as an artefact of legacy v5 subpage support being present in the
12440          * same QEMU executable.
12441          */
12442         int maxidx = DIV_ROUND_UP(blocklen, TARGET_PAGE_SIZE);
12443         void *hostaddr[maxidx];
12444         int try, i;
12445         unsigned mmu_idx = cpu_mmu_index(env, false);
12446         TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
12447
12448         for (try = 0; try < 2; try++) {
12449
12450             for (i = 0; i < maxidx; i++) {
12451                 hostaddr[i] = tlb_vaddr_to_host(env,
12452                                                 vaddr + TARGET_PAGE_SIZE * i,
12453                                                 1, mmu_idx);
12454                 if (!hostaddr[i]) {
12455                     break;
12456                 }
12457             }
12458             if (i == maxidx) {
12459                 /* If it's all in the TLB it's fair game for just writing to;
12460                  * we know we don't need to update dirty status, etc.
12461                  */
12462                 for (i = 0; i < maxidx - 1; i++) {
12463                     memset(hostaddr[i], 0, TARGET_PAGE_SIZE);
12464                 }
12465                 memset(hostaddr[i], 0, blocklen - (i * TARGET_PAGE_SIZE));
12466                 return;
12467             }
12468             /* OK, try a store and see if we can populate the tlb. This
12469              * might cause an exception if the memory isn't writable,
12470              * in which case we will longjmp out of here. We must for
12471              * this purpose use the actual register value passed to us
12472              * so that we get the fault address right.
12473              */
12474             helper_ret_stb_mmu(env, vaddr_in, 0, oi, GETPC());
12475             /* Now we can populate the other TLB entries, if any */
12476             for (i = 0; i < maxidx; i++) {
12477                 uint64_t va = vaddr + TARGET_PAGE_SIZE * i;
12478                 if (va != (vaddr_in & TARGET_PAGE_MASK)) {
12479                     helper_ret_stb_mmu(env, va, 0, oi, GETPC());
12480                 }
12481             }
12482         }
12483
12484         /* Slow path (probably attempt to do this to an I/O device or
12485          * similar, or clearing of a block of code we have translations
12486          * cached for). Just do a series of byte writes as the architecture
12487          * demands. It's not worth trying to use a cpu_physical_memory_map(),
12488          * memset(), unmap() sequence here because:
12489          *  + we'd need to account for the blocksize being larger than a page
12490          *  + the direct-RAM access case is almost always going to be dealt
12491          *    with in the fastpath code above, so there's no speed benefit
12492          *  + we would have to deal with the map returning NULL because the
12493          *    bounce buffer was in use
12494          */
12495         for (i = 0; i < blocklen; i++) {
12496             helper_ret_stb_mmu(env, vaddr + i, 0, oi, GETPC());
12497         }
12498     }
12499 #else
12500     memset(g2h(vaddr), 0, blocklen);
12501 #endif
12502 }
12503
12504 /* Note that signed overflow is undefined in C.  The following routines are
12505    careful to use unsigned types where modulo arithmetic is required.
12506    Failure to do so _will_ break on newer gcc.  */
12507
12508 /* Signed saturating arithmetic.  */
12509
12510 /* Perform 16-bit signed saturating addition.  */
12511 static inline uint16_t add16_sat(uint16_t a, uint16_t b)
12512 {
12513     uint16_t res;
12514
12515     res = a + b;
12516     if (((res ^ a) & 0x8000) && !((a ^ b) & 0x8000)) {
12517         if (a & 0x8000)
12518             res = 0x8000;
12519         else
12520             res = 0x7fff;
12521     }
12522     return res;
12523 }
12524
12525 /* Perform 8-bit signed saturating addition.  */
12526 static inline uint8_t add8_sat(uint8_t a, uint8_t b)
12527 {
12528     uint8_t res;
12529
12530     res = a + b;
12531     if (((res ^ a) & 0x80) && !((a ^ b) & 0x80)) {
12532         if (a & 0x80)
12533             res = 0x80;
12534         else
12535             res = 0x7f;
12536     }
12537     return res;
12538 }
12539
12540 /* Perform 16-bit signed saturating subtraction.  */
12541 static inline uint16_t sub16_sat(uint16_t a, uint16_t b)
12542 {
12543     uint16_t res;
12544
12545     res = a - b;
12546     if (((res ^ a) & 0x8000) && ((a ^ b) & 0x8000)) {
12547         if (a & 0x8000)
12548             res = 0x8000;
12549         else
12550             res = 0x7fff;
12551     }
12552     return res;
12553 }
12554
12555 /* Perform 8-bit signed saturating subtraction.  */
12556 static inline uint8_t sub8_sat(uint8_t a, uint8_t b)
12557 {
12558     uint8_t res;
12559
12560     res = a - b;
12561     if (((res ^ a) & 0x80) && ((a ^ b) & 0x80)) {
12562         if (a & 0x80)
12563             res = 0x80;
12564         else
12565             res = 0x7f;
12566     }
12567     return res;
12568 }
12569
12570 #define ADD16(a, b, n) RESULT(add16_sat(a, b), n, 16);
12571 #define SUB16(a, b, n) RESULT(sub16_sat(a, b), n, 16);
12572 #define ADD8(a, b, n)  RESULT(add8_sat(a, b), n, 8);
12573 #define SUB8(a, b, n)  RESULT(sub8_sat(a, b), n, 8);
12574 #define PFX q
12575
12576 #include "op_addsub.h"
12577
12578 /* Unsigned saturating arithmetic.  */
12579 static inline uint16_t add16_usat(uint16_t a, uint16_t b)
12580 {
12581     uint16_t res;
12582     res = a + b;
12583     if (res < a)
12584         res = 0xffff;
12585     return res;
12586 }
12587
12588 static inline uint16_t sub16_usat(uint16_t a, uint16_t b)
12589 {
12590     if (a > b)
12591         return a - b;
12592     else
12593         return 0;
12594 }
12595
12596 static inline uint8_t add8_usat(uint8_t a, uint8_t b)
12597 {
12598     uint8_t res;
12599     res = a + b;
12600     if (res < a)
12601         res = 0xff;
12602     return res;
12603 }
12604
12605 static inline uint8_t sub8_usat(uint8_t a, uint8_t b)
12606 {
12607     if (a > b)
12608         return a - b;
12609     else
12610         return 0;
12611 }
12612
12613 #define ADD16(a, b, n) RESULT(add16_usat(a, b), n, 16);
12614 #define SUB16(a, b, n) RESULT(sub16_usat(a, b), n, 16);
12615 #define ADD8(a, b, n)  RESULT(add8_usat(a, b), n, 8);
12616 #define SUB8(a, b, n)  RESULT(sub8_usat(a, b), n, 8);
12617 #define PFX uq
12618
12619 #include "op_addsub.h"
12620
12621 /* Signed modulo arithmetic.  */
12622 #define SARITH16(a, b, n, op) do { \
12623     int32_t sum; \
12624     sum = (int32_t)(int16_t)(a) op (int32_t)(int16_t)(b); \
12625     RESULT(sum, n, 16); \
12626     if (sum >= 0) \
12627         ge |= 3 << (n * 2); \
12628     } while(0)
12629
12630 #define SARITH8(a, b, n, op) do { \
12631     int32_t sum; \
12632     sum = (int32_t)(int8_t)(a) op (int32_t)(int8_t)(b); \
12633     RESULT(sum, n, 8); \
12634     if (sum >= 0) \
12635         ge |= 1 << n; \
12636     } while(0)
12637
12638
12639 #define ADD16(a, b, n) SARITH16(a, b, n, +)
12640 #define SUB16(a, b, n) SARITH16(a, b, n, -)
12641 #define ADD8(a, b, n)  SARITH8(a, b, n, +)
12642 #define SUB8(a, b, n)  SARITH8(a, b, n, -)
12643 #define PFX s
12644 #define ARITH_GE
12645
12646 #include "op_addsub.h"
12647
12648 /* Unsigned modulo arithmetic.  */
12649 #define ADD16(a, b, n) do { \
12650     uint32_t sum; \
12651     sum = (uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b); \
12652     RESULT(sum, n, 16); \
12653     if ((sum >> 16) == 1) \
12654         ge |= 3 << (n * 2); \
12655     } while(0)
12656
12657 #define ADD8(a, b, n) do { \
12658     uint32_t sum; \
12659     sum = (uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b); \
12660     RESULT(sum, n, 8); \
12661     if ((sum >> 8) == 1) \
12662         ge |= 1 << n; \
12663     } while(0)
12664
12665 #define SUB16(a, b, n) do { \
12666     uint32_t sum; \
12667     sum = (uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b); \
12668     RESULT(sum, n, 16); \
12669     if ((sum >> 16) == 0) \
12670         ge |= 3 << (n * 2); \
12671     } while(0)
12672
12673 #define SUB8(a, b, n) do { \
12674     uint32_t sum; \
12675     sum = (uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b); \
12676     RESULT(sum, n, 8); \
12677     if ((sum >> 8) == 0) \
12678         ge |= 1 << n; \
12679     } while(0)
12680
12681 #define PFX u
12682 #define ARITH_GE
12683
12684 #include "op_addsub.h"
12685
12686 /* Halved signed arithmetic.  */
12687 #define ADD16(a, b, n) \
12688   RESULT(((int32_t)(int16_t)(a) + (int32_t)(int16_t)(b)) >> 1, n, 16)
12689 #define SUB16(a, b, n) \
12690   RESULT(((int32_t)(int16_t)(a) - (int32_t)(int16_t)(b)) >> 1, n, 16)
12691 #define ADD8(a, b, n) \
12692   RESULT(((int32_t)(int8_t)(a) + (int32_t)(int8_t)(b)) >> 1, n, 8)
12693 #define SUB8(a, b, n) \
12694   RESULT(((int32_t)(int8_t)(a) - (int32_t)(int8_t)(b)) >> 1, n, 8)
12695 #define PFX sh
12696
12697 #include "op_addsub.h"
12698
12699 /* Halved unsigned arithmetic.  */
12700 #define ADD16(a, b, n) \
12701   RESULT(((uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b)) >> 1, n, 16)
12702 #define SUB16(a, b, n) \
12703   RESULT(((uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b)) >> 1, n, 16)
12704 #define ADD8(a, b, n) \
12705   RESULT(((uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b)) >> 1, n, 8)
12706 #define SUB8(a, b, n) \
12707   RESULT(((uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b)) >> 1, n, 8)
12708 #define PFX uh
12709
12710 #include "op_addsub.h"
12711
12712 static inline uint8_t do_usad(uint8_t a, uint8_t b)
12713 {
12714     if (a > b)
12715         return a - b;
12716     else
12717         return b - a;
12718 }
12719
12720 /* Unsigned sum of absolute byte differences.  */
12721 uint32_t HELPER(usad8)(uint32_t a, uint32_t b)
12722 {
12723     uint32_t sum;
12724     sum = do_usad(a, b);
12725     sum += do_usad(a >> 8, b >> 8);
12726     sum += do_usad(a >> 16, b >>16);
12727     sum += do_usad(a >> 24, b >> 24);
12728     return sum;
12729 }
12730
12731 /* For ARMv6 SEL instruction.  */
12732 uint32_t HELPER(sel_flags)(uint32_t flags, uint32_t a, uint32_t b)
12733 {
12734     uint32_t mask;
12735
12736     mask = 0;
12737     if (flags & 1)
12738         mask |= 0xff;
12739     if (flags & 2)
12740         mask |= 0xff00;
12741     if (flags & 4)
12742         mask |= 0xff0000;
12743     if (flags & 8)
12744         mask |= 0xff000000;
12745     return (a & mask) | (b & ~mask);
12746 }
12747
12748 /* CRC helpers.
12749  * The upper bytes of val (above the number specified by 'bytes') must have
12750  * been zeroed out by the caller.
12751  */
12752 uint32_t HELPER(crc32)(uint32_t acc, uint32_t val, uint32_t bytes)
12753 {
12754     uint8_t buf[4];
12755
12756     stl_le_p(buf, val);
12757
12758     /* zlib crc32 converts the accumulator and output to one's complement.  */
12759     return crc32(acc ^ 0xffffffff, buf, bytes) ^ 0xffffffff;
12760 }
12761
12762 uint32_t HELPER(crc32c)(uint32_t acc, uint32_t val, uint32_t bytes)
12763 {
12764     uint8_t buf[4];
12765
12766     stl_le_p(buf, val);
12767
12768     /* Linux crc32c converts the output to one's complement.  */
12769     return crc32c(acc, buf, bytes) ^ 0xffffffff;
12770 }
12771
12772 /* Return the exception level to which FP-disabled exceptions should
12773  * be taken, or 0 if FP is enabled.
12774  */
12775 int fp_exception_el(CPUARMState *env, int cur_el)
12776 {
12777 #ifndef CONFIG_USER_ONLY
12778     int fpen;
12779
12780     /* CPACR and the CPTR registers don't exist before v6, so FP is
12781      * always accessible
12782      */
12783     if (!arm_feature(env, ARM_FEATURE_V6)) {
12784         return 0;
12785     }
12786
12787     if (arm_feature(env, ARM_FEATURE_M)) {
12788         /* CPACR can cause a NOCP UsageFault taken to current security state */
12789         if (!v7m_cpacr_pass(env, env->v7m.secure, cur_el != 0)) {
12790             return 1;
12791         }
12792
12793         if (arm_feature(env, ARM_FEATURE_M_SECURITY) && !env->v7m.secure) {
12794             if (!extract32(env->v7m.nsacr, 10, 1)) {
12795                 /* FP insns cause a NOCP UsageFault taken to Secure */
12796                 return 3;
12797             }
12798         }
12799
12800         return 0;
12801     }
12802
12803     /* The CPACR controls traps to EL1, or PL1 if we're 32 bit:
12804      * 0, 2 : trap EL0 and EL1/PL1 accesses
12805      * 1    : trap only EL0 accesses
12806      * 3    : trap no accesses
12807      */
12808     fpen = extract32(env->cp15.cpacr_el1, 20, 2);
12809     switch (fpen) {
12810     case 0:
12811     case 2:
12812         if (cur_el == 0 || cur_el == 1) {
12813             /* Trap to PL1, which might be EL1 or EL3 */
12814             if (arm_is_secure(env) && !arm_el_is_aa64(env, 3)) {
12815                 return 3;
12816             }
12817             return 1;
12818         }
12819         if (cur_el == 3 && !is_a64(env)) {
12820             /* Secure PL1 running at EL3 */
12821             return 3;
12822         }
12823         break;
12824     case 1:
12825         if (cur_el == 0) {
12826             return 1;
12827         }
12828         break;
12829     case 3:
12830         break;
12831     }
12832
12833     /* For the CPTR registers we don't need to guard with an ARM_FEATURE
12834      * check because zero bits in the registers mean "don't trap".
12835      */
12836
12837     /* CPTR_EL2 : present in v7VE or v8 */
12838     if (cur_el <= 2 && extract32(env->cp15.cptr_el[2], 10, 1)
12839         && !arm_is_secure_below_el3(env)) {
12840         /* Trap FP ops at EL2, NS-EL1 or NS-EL0 to EL2 */
12841         return 2;
12842     }
12843
12844     /* CPTR_EL3 : present in v8 */
12845     if (extract32(env->cp15.cptr_el[3], 10, 1)) {
12846         /* Trap all FP ops to EL3 */
12847         return 3;
12848     }
12849 #endif
12850     return 0;
12851 }
12852
12853 ARMMMUIdx arm_v7m_mmu_idx_for_secstate_and_priv(CPUARMState *env,
12854                                                 bool secstate, bool priv)
12855 {
12856     ARMMMUIdx mmu_idx = ARM_MMU_IDX_M;
12857
12858     if (priv) {
12859         mmu_idx |= ARM_MMU_IDX_M_PRIV;
12860     }
12861
12862     if (armv7m_nvic_neg_prio_requested(env->nvic, secstate)) {
12863         mmu_idx |= ARM_MMU_IDX_M_NEGPRI;
12864     }
12865
12866     if (secstate) {
12867         mmu_idx |= ARM_MMU_IDX_M_S;
12868     }
12869
12870     return mmu_idx;
12871 }
12872
12873 /* Return the MMU index for a v7M CPU in the specified security state */
12874 ARMMMUIdx arm_v7m_mmu_idx_for_secstate(CPUARMState *env, bool secstate)
12875 {
12876     bool priv = arm_current_el(env) != 0;
12877
12878     return arm_v7m_mmu_idx_for_secstate_and_priv(env, secstate, priv);
12879 }
12880
12881 ARMMMUIdx arm_mmu_idx(CPUARMState *env)
12882 {
12883     int el;
12884
12885     if (arm_feature(env, ARM_FEATURE_M)) {
12886         return arm_v7m_mmu_idx_for_secstate(env, env->v7m.secure);
12887     }
12888
12889     el = arm_current_el(env);
12890     if (el < 2 && arm_is_secure_below_el3(env)) {
12891         return ARMMMUIdx_S1SE0 + el;
12892     } else {
12893         return ARMMMUIdx_S12NSE0 + el;
12894     }
12895 }
12896
12897 int cpu_mmu_index(CPUARMState *env, bool ifetch)
12898 {
12899     return arm_to_core_mmu_idx(arm_mmu_idx(env));
12900 }
12901
12902 #ifndef CONFIG_USER_ONLY
12903 ARMMMUIdx arm_stage1_mmu_idx(CPUARMState *env)
12904 {
12905     return stage_1_mmu_idx(arm_mmu_idx(env));
12906 }
12907 #endif
12908
12909 void cpu_get_tb_cpu_state(CPUARMState *env, target_ulong *pc,
12910                           target_ulong *cs_base, uint32_t *pflags)
12911 {
12912     ARMMMUIdx mmu_idx = arm_mmu_idx(env);
12913     int current_el = arm_current_el(env);
12914     int fp_el = fp_exception_el(env, current_el);
12915     uint32_t flags = 0;
12916
12917     if (is_a64(env)) {
12918         ARMCPU *cpu = arm_env_get_cpu(env);
12919         uint64_t sctlr;
12920
12921         *pc = env->pc;
12922         flags = FIELD_DP32(flags, TBFLAG_ANY, AARCH64_STATE, 1);
12923
12924         /* Get control bits for tagged addresses.  */
12925         {
12926             ARMMMUIdx stage1 = stage_1_mmu_idx(mmu_idx);
12927             ARMVAParameters p0 = aa64_va_parameters_both(env, 0, stage1);
12928             int tbii, tbid;
12929
12930             /* FIXME: ARMv8.1-VHE S2 translation regime.  */
12931             if (regime_el(env, stage1) < 2) {
12932                 ARMVAParameters p1 = aa64_va_parameters_both(env, -1, stage1);
12933                 tbid = (p1.tbi << 1) | p0.tbi;
12934                 tbii = tbid & ~((p1.tbid << 1) | p0.tbid);
12935             } else {
12936                 tbid = p0.tbi;
12937                 tbii = tbid & !p0.tbid;
12938             }
12939
12940             flags = FIELD_DP32(flags, TBFLAG_A64, TBII, tbii);
12941             flags = FIELD_DP32(flags, TBFLAG_A64, TBID, tbid);
12942         }
12943
12944         if (cpu_isar_feature(aa64_sve, cpu)) {
12945             int sve_el = sve_exception_el(env, current_el);
12946             uint32_t zcr_len;
12947
12948             /* If SVE is disabled, but FP is enabled,
12949              * then the effective len is 0.
12950              */
12951             if (sve_el != 0 && fp_el == 0) {
12952                 zcr_len = 0;
12953             } else {
12954                 zcr_len = sve_zcr_len_for_el(env, current_el);
12955             }
12956             flags = FIELD_DP32(flags, TBFLAG_A64, SVEEXC_EL, sve_el);
12957             flags = FIELD_DP32(flags, TBFLAG_A64, ZCR_LEN, zcr_len);
12958         }
12959
12960         sctlr = arm_sctlr(env, current_el);
12961
12962         if (cpu_isar_feature(aa64_pauth, cpu)) {
12963             /*
12964              * In order to save space in flags, we record only whether
12965              * pauth is "inactive", meaning all insns are implemented as
12966              * a nop, or "active" when some action must be performed.
12967              * The decision of which action to take is left to a helper.
12968              */
12969             if (sctlr & (SCTLR_EnIA | SCTLR_EnIB | SCTLR_EnDA | SCTLR_EnDB)) {
12970                 flags = FIELD_DP32(flags, TBFLAG_A64, PAUTH_ACTIVE, 1);
12971             }
12972         }
12973
12974         if (cpu_isar_feature(aa64_bti, cpu)) {
12975             /* Note that SCTLR_EL[23].BT == SCTLR_BT1.  */
12976             if (sctlr & (current_el == 0 ? SCTLR_BT0 : SCTLR_BT1)) {
12977                 flags = FIELD_DP32(flags, TBFLAG_A64, BT, 1);
12978             }
12979             flags = FIELD_DP32(flags, TBFLAG_A64, BTYPE, env->btype);
12980         }
12981     } else {
12982         *pc = env->regs[15];
12983         flags = FIELD_DP32(flags, TBFLAG_A32, THUMB, env->thumb);
12984         flags = FIELD_DP32(flags, TBFLAG_A32, VECLEN, env->vfp.vec_len);
12985         flags = FIELD_DP32(flags, TBFLAG_A32, VECSTRIDE, env->vfp.vec_stride);
12986         flags = FIELD_DP32(flags, TBFLAG_A32, CONDEXEC, env->condexec_bits);
12987         flags = FIELD_DP32(flags, TBFLAG_A32, SCTLR_B, arm_sctlr_b(env));
12988         flags = FIELD_DP32(flags, TBFLAG_A32, NS, !access_secure_reg(env));
12989         if (env->vfp.xregs[ARM_VFP_FPEXC] & (1 << 30)
12990             || arm_el_is_aa64(env, 1) || arm_feature(env, ARM_FEATURE_M)) {
12991             flags = FIELD_DP32(flags, TBFLAG_A32, VFPEN, 1);
12992         }
12993         flags = FIELD_DP32(flags, TBFLAG_A32, XSCALE_CPAR, env->cp15.c15_cpar);
12994     }
12995
12996     flags = FIELD_DP32(flags, TBFLAG_ANY, MMUIDX, arm_to_core_mmu_idx(mmu_idx));
12997
12998     /* The SS_ACTIVE and PSTATE_SS bits correspond to the state machine
12999      * states defined in the ARM ARM for software singlestep:
13000      *  SS_ACTIVE   PSTATE.SS   State
13001      *     0            x       Inactive (the TB flag for SS is always 0)
13002      *     1            0       Active-pending
13003      *     1            1       Active-not-pending
13004      */
13005     if (arm_singlestep_active(env)) {
13006         flags = FIELD_DP32(flags, TBFLAG_ANY, SS_ACTIVE, 1);
13007         if (is_a64(env)) {
13008             if (env->pstate & PSTATE_SS) {
13009                 flags = FIELD_DP32(flags, TBFLAG_ANY, PSTATE_SS, 1);
13010             }
13011         } else {
13012             if (env->uncached_cpsr & PSTATE_SS) {
13013                 flags = FIELD_DP32(flags, TBFLAG_ANY, PSTATE_SS, 1);
13014             }
13015         }
13016     }
13017     if (arm_cpu_data_is_big_endian(env)) {
13018         flags = FIELD_DP32(flags, TBFLAG_ANY, BE_DATA, 1);
13019     }
13020     flags = FIELD_DP32(flags, TBFLAG_ANY, FPEXC_EL, fp_el);
13021
13022     if (arm_v7m_is_handler_mode(env)) {
13023         flags = FIELD_DP32(flags, TBFLAG_A32, HANDLER, 1);
13024     }
13025
13026     /* v8M always applies stack limit checks unless CCR.STKOFHFNMIGN is
13027      * suppressing them because the requested execution priority is less than 0.
13028      */
13029     if (arm_feature(env, ARM_FEATURE_V8) &&
13030         arm_feature(env, ARM_FEATURE_M) &&
13031         !((mmu_idx  & ARM_MMU_IDX_M_NEGPRI) &&
13032           (env->v7m.ccr[env->v7m.secure] & R_V7M_CCR_STKOFHFNMIGN_MASK))) {
13033         flags = FIELD_DP32(flags, TBFLAG_A32, STACKCHECK, 1);
13034     }
13035
13036     *pflags = flags;
13037     *cs_base = 0;
13038 }
13039
13040 #ifdef TARGET_AARCH64
13041 /*
13042  * The manual says that when SVE is enabled and VQ is widened the
13043  * implementation is allowed to zero the previously inaccessible
13044  * portion of the registers.  The corollary to that is that when
13045  * SVE is enabled and VQ is narrowed we are also allowed to zero
13046  * the now inaccessible portion of the registers.
13047  *
13048  * The intent of this is that no predicate bit beyond VQ is ever set.
13049  * Which means that some operations on predicate registers themselves
13050  * may operate on full uint64_t or even unrolled across the maximum
13051  * uint64_t[4].  Performing 4 bits of host arithmetic unconditionally
13052  * may well be cheaper than conditionals to restrict the operation
13053  * to the relevant portion of a uint16_t[16].
13054  */
13055 void aarch64_sve_narrow_vq(CPUARMState *env, unsigned vq)
13056 {
13057     int i, j;
13058     uint64_t pmask;
13059
13060     assert(vq >= 1 && vq <= ARM_MAX_VQ);
13061     assert(vq <= arm_env_get_cpu(env)->sve_max_vq);
13062
13063     /* Zap the high bits of the zregs.  */
13064     for (i = 0; i < 32; i++) {
13065         memset(&env->vfp.zregs[i].d[2 * vq], 0, 16 * (ARM_MAX_VQ - vq));
13066     }
13067
13068     /* Zap the high bits of the pregs and ffr.  */
13069     pmask = 0;
13070     if (vq & 3) {
13071         pmask = ~(-1ULL << (16 * (vq & 3)));
13072     }
13073     for (j = vq / 4; j < ARM_MAX_VQ / 4; j++) {
13074         for (i = 0; i < 17; ++i) {
13075             env->vfp.pregs[i].p[j] &= pmask;
13076         }
13077         pmask = 0;
13078     }
13079 }
13080
13081 /*
13082  * Notice a change in SVE vector size when changing EL.
13083  */
13084 void aarch64_sve_change_el(CPUARMState *env, int old_el,
13085                            int new_el, bool el0_a64)
13086 {
13087     ARMCPU *cpu = arm_env_get_cpu(env);
13088     int old_len, new_len;
13089     bool old_a64, new_a64;
13090
13091     /* Nothing to do if no SVE.  */
13092     if (!cpu_isar_feature(aa64_sve, cpu)) {
13093         return;
13094     }
13095
13096     /* Nothing to do if FP is disabled in either EL.  */
13097     if (fp_exception_el(env, old_el) || fp_exception_el(env, new_el)) {
13098         return;
13099     }
13100
13101     /*
13102      * DDI0584A.d sec 3.2: "If SVE instructions are disabled or trapped
13103      * at ELx, or not available because the EL is in AArch32 state, then
13104      * for all purposes other than a direct read, the ZCR_ELx.LEN field
13105      * has an effective value of 0".
13106      *
13107      * Consider EL2 (aa64, vq=4) -> EL0 (aa32) -> EL1 (aa64, vq=0).
13108      * If we ignore aa32 state, we would fail to see the vq4->vq0 transition
13109      * from EL2->EL1.  Thus we go ahead and narrow when entering aa32 so that
13110      * we already have the correct register contents when encountering the
13111      * vq0->vq0 transition between EL0->EL1.
13112      */
13113     old_a64 = old_el ? arm_el_is_aa64(env, old_el) : el0_a64;
13114     old_len = (old_a64 && !sve_exception_el(env, old_el)
13115                ? sve_zcr_len_for_el(env, old_el) : 0);
13116     new_a64 = new_el ? arm_el_is_aa64(env, new_el) : el0_a64;
13117     new_len = (new_a64 && !sve_exception_el(env, new_el)
13118                ? sve_zcr_len_for_el(env, new_el) : 0);
13119
13120     /* When changing vector length, clear inaccessible state.  */
13121     if (new_len < old_len) {
13122         aarch64_sve_narrow_vq(env, new_len + 1);
13123     }
13124 }
13125 #endif