target-arm/helper.c

   1 #include "cpu.h"
   2 #include "exec/gdbstub.h"
   3 #include "helper.h"
   4 #include "qemu/host-utils.h"
   5 #include "sysemu/arch_init.h"
   6 #include "sysemu/sysemu.h"
   7 #include "qemu/bitops.h"
   8
   9 #ifndef CONFIG_USER_ONLY
  10 static inline int get_phys_addr(CPUARMState *env, uint32_t address,
  11                                 int access_type, int is_user,
  12                                 hwaddr *phys_ptr, int *prot,
  13                                 target_ulong *page_size);
  14 #endif
  15
  16 static int vfp_gdb_get_reg(CPUARMState *env, uint8_t *buf, int reg)
  17 {
  18     int nregs;
  19
  20     /* VFP data registers are always little-endian.  */
  21     nregs = arm_feature(env, ARM_FEATURE_VFP3) ? 32 : 16;
  22     if (reg < nregs) {
  23         stfq_le_p(buf, env->vfp.regs[reg]);
  24         return 8;
  25     }
  26     if (arm_feature(env, ARM_FEATURE_NEON)) {
  27         /* Aliases for Q regs.  */
  28         nregs += 16;
  29         if (reg < nregs) {
  30             stfq_le_p(buf, env->vfp.regs[(reg - 32) * 2]);
  31             stfq_le_p(buf + 8, env->vfp.regs[(reg - 32) * 2 + 1]);
  32             return 16;
  33         }
  34     }
  35     switch (reg - nregs) {
  36     case 0: stl_p(buf, env->vfp.xregs[ARM_VFP_FPSID]); return 4;
  37     case 1: stl_p(buf, env->vfp.xregs[ARM_VFP_FPSCR]); return 4;
  38     case 2: stl_p(buf, env->vfp.xregs[ARM_VFP_FPEXC]); return 4;
  39     }
  40     return 0;
  41 }
  42
  43 static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg)
  44 {
  45     int nregs;
  46
  47     nregs = arm_feature(env, ARM_FEATURE_VFP3) ? 32 : 16;
  48     if (reg < nregs) {
  49         env->vfp.regs[reg] = ldfq_le_p(buf);
  50         return 8;
  51     }
  52     if (arm_feature(env, ARM_FEATURE_NEON)) {
  53         nregs += 16;
  54         if (reg < nregs) {
  55             env->vfp.regs[(reg - 32) * 2] = ldfq_le_p(buf);
  56             env->vfp.regs[(reg - 32) * 2 + 1] = ldfq_le_p(buf + 8);
  57             return 16;
  58         }
  59     }
  60     switch (reg - nregs) {
  61     case 0: env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); return 4;
  62     case 1: env->vfp.xregs[ARM_VFP_FPSCR] = ldl_p(buf); return 4;
  63     case 2: env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); return 4;
  64     }
  65     return 0;
  66 }
  67
  68 static int aarch64_fpu_gdb_get_reg(CPUARMState *env, uint8_t *buf, int reg)
  69 {
  70     switch (reg) {
  71     case 0 ... 31:
  72         /* 128 bit FP register */
  73         stfq_le_p(buf, env->vfp.regs[reg * 2]);
  74         stfq_le_p(buf + 8, env->vfp.regs[reg * 2 + 1]);
  75         return 16;
  76     case 32:
  77         /* FPSR */
  78         stl_p(buf, vfp_get_fpsr(env));
  79         return 4;
  80     case 33:
  81         /* FPCR */
  82         stl_p(buf, vfp_get_fpcr(env));
  83         return 4;
  84     default:
  85         return 0;
  86     }
  87 }
  88
  89 static int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg)
  90 {
  91     switch (reg) {
  92     case 0 ... 31:
  93         /* 128 bit FP register */
  94         env->vfp.regs[reg * 2] = ldfq_le_p(buf);
  95         env->vfp.regs[reg * 2 + 1] = ldfq_le_p(buf + 8);
  96         return 16;
  97     case 32:
  98         /* FPSR */
  99         vfp_set_fpsr(env, ldl_p(buf));
 100         return 4;
 101     case 33:
 102         /* FPCR */
 103         vfp_set_fpcr(env, ldl_p(buf));
 104         return 4;
 105     default:
 106         return 0;
 107     }
 108 }
 109
 110 static uint64_t raw_read(CPUARMState *env, const ARMCPRegInfo *ri)
 111 {
 112     if (cpreg_field_is_64bit(ri)) {
 113         return CPREG_FIELD64(env, ri);
 114     } else {
 115         return CPREG_FIELD32(env, ri);
 116     }
 117 }
 118
 119 static void raw_write(CPUARMState *env, const ARMCPRegInfo *ri,
 120                       uint64_t value)
 121 {
 122     if (cpreg_field_is_64bit(ri)) {
 123         CPREG_FIELD64(env, ri) = value;
 124     } else {
 125         CPREG_FIELD32(env, ri) = value;
 126     }
 127 }
 128
 129 static uint64_t read_raw_cp_reg(CPUARMState *env, const ARMCPRegInfo *ri)
 130 {
 131     /* Raw read of a coprocessor register (as needed for migration, etc). */
 132     if (ri->type & ARM_CP_CONST) {
 133         return ri->resetvalue;
 134     } else if (ri->raw_readfn) {
 135         return ri->raw_readfn(env, ri);
 136     } else if (ri->readfn) {
 137         return ri->readfn(env, ri);
 138     } else {
 139         return raw_read(env, ri);
 140     }
 141 }
 142
 143 static void write_raw_cp_reg(CPUARMState *env, const ARMCPRegInfo *ri,
 144                              uint64_t v)
 145 {
 146     /* Raw write of a coprocessor register (as needed for migration, etc).
 147      * Note that constant registers are treated as write-ignored; the
 148      * caller should check for success by whether a readback gives the
 149      * value written.
 150      */
 151     if (ri->type & ARM_CP_CONST) {
 152         return;
 153     } else if (ri->raw_writefn) {
 154         ri->raw_writefn(env, ri, v);
 155     } else if (ri->writefn) {
 156         ri->writefn(env, ri, v);
 157     } else {
 158         raw_write(env, ri, v);
 159     }
 160 }
 161
 162 bool write_cpustate_to_list(ARMCPU *cpu)
 163 {
 164     /* Write the coprocessor state from cpu->env to the (index,value) list. */
 165     int i;
 166     bool ok = true;
 167
 168     for (i = 0; i < cpu->cpreg_array_len; i++) {
 169         uint32_t regidx = kvm_to_cpreg_id(cpu->cpreg_indexes[i]);
 170         const ARMCPRegInfo *ri;
 171
 172         ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 173         if (!ri) {
 174             ok = false;
 175             continue;
 176         }
 177         if (ri->type & ARM_CP_NO_MIGRATE) {
 178             continue;
 179         }
 180         cpu->cpreg_values[i] = read_raw_cp_reg(&cpu->env, ri);
 181     }
 182     return ok;
 183 }
 184
 185 bool write_list_to_cpustate(ARMCPU *cpu)
 186 {
 187     int i;
 188     bool ok = true;
 189
 190     for (i = 0; i < cpu->cpreg_array_len; i++) {
 191         uint32_t regidx = kvm_to_cpreg_id(cpu->cpreg_indexes[i]);
 192         uint64_t v = cpu->cpreg_values[i];
 193         const ARMCPRegInfo *ri;
 194
 195         ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 196         if (!ri) {
 197             ok = false;
 198             continue;
 199         }
 200         if (ri->type & ARM_CP_NO_MIGRATE) {
 201             continue;
 202         }
 203         /* Write value and confirm it reads back as written
 204          * (to catch read-only registers and partially read-only
 205          * registers where the incoming migration value doesn't match)
 206          */
 207         write_raw_cp_reg(&cpu->env, ri, v);
 208         if (read_raw_cp_reg(&cpu->env, ri) != v) {
 209             ok = false;
 210         }
 211     }
 212     return ok;
 213 }
 214
 215 static void add_cpreg_to_list(gpointer key, gpointer opaque)
 216 {
 217     ARMCPU *cpu = opaque;
 218     uint64_t regidx;
 219     const ARMCPRegInfo *ri;
 220
 221     regidx = *(uint32_t *)key;
 222     ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 223
 224     if (!(ri->type & ARM_CP_NO_MIGRATE)) {
 225         cpu->cpreg_indexes[cpu->cpreg_array_len] = cpreg_to_kvm_id(regidx);
 226         /* The value array need not be initialized at this point */
 227         cpu->cpreg_array_len++;
 228     }
 229 }
 230
 231 static void count_cpreg(gpointer key, gpointer opaque)
 232 {
 233     ARMCPU *cpu = opaque;
 234     uint64_t regidx;
 235     const ARMCPRegInfo *ri;
 236
 237     regidx = *(uint32_t *)key;
 238     ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
 239
 240     if (!(ri->type & ARM_CP_NO_MIGRATE)) {
 241         cpu->cpreg_array_len++;
 242     }
 243 }
 244
 245 static gint cpreg_key_compare(gconstpointer a, gconstpointer b)
 246 {
 247     uint64_t aidx = cpreg_to_kvm_id(*(uint32_t *)a);
 248     uint64_t bidx = cpreg_to_kvm_id(*(uint32_t *)b);
 249
 250     if (aidx > bidx) {
 251         return 1;
 252     }
 253     if (aidx < bidx) {
 254         return -1;
 255     }
 256     return 0;
 257 }
 258
 259 static void cpreg_make_keylist(gpointer key, gpointer value, gpointer udata)
 260 {
 261     GList **plist = udata;
 262
 263     *plist = g_list_prepend(*plist, key);
 264 }
 265
 266 void init_cpreg_list(ARMCPU *cpu)
 267 {
 268     /* Initialise the cpreg_tuples[] array based on the cp_regs hash.
 269      * Note that we require cpreg_tuples[] to be sorted by key ID.
 270      */
 271     GList *keys = NULL;
 272     int arraylen;
 273
 274     g_hash_table_foreach(cpu->cp_regs, cpreg_make_keylist, &keys);
 275
 276     keys = g_list_sort(keys, cpreg_key_compare);
 277
 278     cpu->cpreg_array_len = 0;
 279
 280     g_list_foreach(keys, count_cpreg, cpu);
 281
 282     arraylen = cpu->cpreg_array_len;
 283     cpu->cpreg_indexes = g_new(uint64_t, arraylen);
 284     cpu->cpreg_values = g_new(uint64_t, arraylen);
 285     cpu->cpreg_vmstate_indexes = g_new(uint64_t, arraylen);
 286     cpu->cpreg_vmstate_values = g_new(uint64_t, arraylen);
 287     cpu->cpreg_vmstate_array_len = cpu->cpreg_array_len;
 288     cpu->cpreg_array_len = 0;
 289
 290     g_list_foreach(keys, add_cpreg_to_list, cpu);
 291
 292     assert(cpu->cpreg_array_len == arraylen);
 293
 294     g_list_free(keys);
 295 }
 296
 297 static void dacr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 298 {
 299     env->cp15.c3 = value;
 300     tlb_flush(env, 1); /* Flush TLB as domain not tracked in TLB */
 301 }
 302
 303 static void fcse_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 304 {
 305     if (env->cp15.c13_fcse != value) {
 306         /* Unlike real hardware the qemu TLB uses virtual addresses,
 307          * not modified virtual addresses, so this causes a TLB flush.
 308          */
 309         tlb_flush(env, 1);
 310         env->cp15.c13_fcse = value;
 311     }
 312 }
 313
 314 static void contextidr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 315                              uint64_t value)
 316 {
 317     if (env->cp15.c13_context != value && !arm_feature(env, ARM_FEATURE_MPU)) {
 318         /* For VMSA (when not using the LPAE long descriptor page table
 319          * format) this register includes the ASID, so do a TLB flush.
 320          * For PMSA it is purely a process ID and no action is needed.
 321          */
 322         tlb_flush(env, 1);
 323     }
 324     env->cp15.c13_context = value;
 325 }
 326
 327 static void tlbiall_write(CPUARMState *env, const ARMCPRegInfo *ri,
 328                           uint64_t value)
 329 {
 330     /* Invalidate all (TLBIALL) */
 331     tlb_flush(env, 1);
 332 }
 333
 334 static void tlbimva_write(CPUARMState *env, const ARMCPRegInfo *ri,
 335                           uint64_t value)
 336 {
 337     /* Invalidate single TLB entry by MVA and ASID (TLBIMVA) */
 338     tlb_flush_page(env, value & TARGET_PAGE_MASK);
 339 }
 340
 341 static void tlbiasid_write(CPUARMState *env, const ARMCPRegInfo *ri,
 342                            uint64_t value)
 343 {
 344     /* Invalidate by ASID (TLBIASID) */
 345     tlb_flush(env, value == 0);
 346 }
 347
 348 static void tlbimvaa_write(CPUARMState *env, const ARMCPRegInfo *ri,
 349                            uint64_t value)
 350 {
 351     /* Invalidate single entry by MVA, all ASIDs (TLBIMVAA) */
 352     tlb_flush_page(env, value & TARGET_PAGE_MASK);
 353 }
 354
 355 static const ARMCPRegInfo cp_reginfo[] = {
 356     /* DBGDIDR: just RAZ. In particular this means the "debug architecture
 357      * version" bits will read as a reserved value, which should cause
 358      * Linux to not try to use the debug hardware.
 359      */
 360     { .name = "DBGDIDR", .cp = 14, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 0,
 361       .access = PL0_R, .type = ARM_CP_CONST, .resetvalue = 0 },
 362     /* MMU Domain access control / MPU write buffer control */
 363     { .name = "DACR", .cp = 15,
 364       .crn = 3, .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY,
 365       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c3),
 366       .resetvalue = 0, .writefn = dacr_write, .raw_writefn = raw_write, },
 367     { .name = "FCSEIDR", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 0,
 368       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c13_fcse),
 369       .resetvalue = 0, .writefn = fcse_write, .raw_writefn = raw_write, },
 370     { .name = "CONTEXTIDR", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 1,
 371       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c13_context),
 372       .resetvalue = 0, .writefn = contextidr_write, .raw_writefn = raw_write, },
 373     /* ??? This covers not just the impdef TLB lockdown registers but also
 374      * some v7VMSA registers relating to TEX remap, so it is overly broad.
 375      */
 376     { .name = "TLB_LOCKDOWN", .cp = 15, .crn = 10, .crm = CP_ANY,
 377       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_NOP },
 378     /* MMU TLB control. Note that the wildcarding means we cover not just
 379      * the unified TLB ops but also the dside/iside/inner-shareable variants.
 380      */
 381     { .name = "TLBIALL", .cp = 15, .crn = 8, .crm = CP_ANY,
 382       .opc1 = CP_ANY, .opc2 = 0, .access = PL1_W, .writefn = tlbiall_write,
 383       .type = ARM_CP_NO_MIGRATE },
 384     { .name = "TLBIMVA", .cp = 15, .crn = 8, .crm = CP_ANY,
 385       .opc1 = CP_ANY, .opc2 = 1, .access = PL1_W, .writefn = tlbimva_write,
 386       .type = ARM_CP_NO_MIGRATE },
 387     { .name = "TLBIASID", .cp = 15, .crn = 8, .crm = CP_ANY,
 388       .opc1 = CP_ANY, .opc2 = 2, .access = PL1_W, .writefn = tlbiasid_write,
 389       .type = ARM_CP_NO_MIGRATE },
 390     { .name = "TLBIMVAA", .cp = 15, .crn = 8, .crm = CP_ANY,
 391       .opc1 = CP_ANY, .opc2 = 3, .access = PL1_W, .writefn = tlbimvaa_write,
 392       .type = ARM_CP_NO_MIGRATE },
 393     /* Cache maintenance ops; some of this space may be overridden later. */
 394     { .name = "CACHEMAINT", .cp = 15, .crn = 7, .crm = CP_ANY,
 395       .opc1 = 0, .opc2 = CP_ANY, .access = PL1_W,
 396       .type = ARM_CP_NOP | ARM_CP_OVERRIDE },
 397     REGINFO_SENTINEL
 398 };
 399
 400 static const ARMCPRegInfo not_v6_cp_reginfo[] = {
 401     /* Not all pre-v6 cores implemented this WFI, so this is slightly
 402      * over-broad.
 403      */
 404     { .name = "WFI_v5", .cp = 15, .crn = 7, .crm = 8, .opc1 = 0, .opc2 = 2,
 405       .access = PL1_W, .type = ARM_CP_WFI },
 406     REGINFO_SENTINEL
 407 };
 408
 409 static const ARMCPRegInfo not_v7_cp_reginfo[] = {
 410     /* Standard v6 WFI (also used in some pre-v6 cores); not in v7 (which
 411      * is UNPREDICTABLE; we choose to NOP as most implementations do).
 412      */
 413     { .name = "WFI_v6", .cp = 15, .crn = 7, .crm = 0, .opc1 = 0, .opc2 = 4,
 414       .access = PL1_W, .type = ARM_CP_WFI },
 415     /* L1 cache lockdown. Not architectural in v6 and earlier but in practice
 416      * implemented in 926, 946, 1026, 1136, 1176 and 11MPCore. StrongARM and
 417      * OMAPCP will override this space.
 418      */
 419     { .name = "DLOCKDOWN", .cp = 15, .crn = 9, .crm = 0, .opc1 = 0, .opc2 = 0,
 420       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_data),
 421       .resetvalue = 0 },
 422     { .name = "ILOCKDOWN", .cp = 15, .crn = 9, .crm = 0, .opc1 = 0, .opc2 = 1,
 423       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_insn),
 424       .resetvalue = 0 },
 425     /* v6 doesn't have the cache ID registers but Linux reads them anyway */
 426     { .name = "DUMMY", .cp = 15, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = CP_ANY,
 427       .access = PL1_R, .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE,
 428       .resetvalue = 0 },
 429     REGINFO_SENTINEL
 430 };
 431
 432 static void cpacr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 433                         uint64_t value)
 434 {
 435     if (env->cp15.c1_coproc != value) {
 436         env->cp15.c1_coproc = value;
 437         /* ??? Is this safe when called from within a TB?  */
 438         tb_flush(env);
 439     }
 440 }
 441
 442 static const ARMCPRegInfo v6_cp_reginfo[] = {
 443     /* prefetch by MVA in v6, NOP in v7 */
 444     { .name = "MVA_prefetch",
 445       .cp = 15, .crn = 7, .crm = 13, .opc1 = 0, .opc2 = 1,
 446       .access = PL1_W, .type = ARM_CP_NOP },
 447     { .name = "ISB", .cp = 15, .crn = 7, .crm = 5, .opc1 = 0, .opc2 = 4,
 448       .access = PL0_W, .type = ARM_CP_NOP },
 449     { .name = "DSB", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 4,
 450       .access = PL0_W, .type = ARM_CP_NOP },
 451     { .name = "DMB", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 5,
 452       .access = PL0_W, .type = ARM_CP_NOP },
 453     { .name = "IFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 2,
 454       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c6_insn),
 455       .resetvalue = 0, },
 456     /* Watchpoint Fault Address Register : should actually only be present
 457      * for 1136, 1176, 11MPCore.
 458      */
 459     { .name = "WFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 1,
 460       .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0, },
 461     { .name = "CPACR", .cp = 15, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 2,
 462       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c1_coproc),
 463       .resetvalue = 0, .writefn = cpacr_write },
 464     REGINFO_SENTINEL
 465 };
 466
 467 static CPAccessResult pmreg_access(CPUARMState *env, const ARMCPRegInfo *ri)
 468 {
 469     /* Perfomance monitor registers user accessibility is controlled
 470      * by PMUSERENR.
 471      */
 472     if (arm_current_pl(env) == 0 && !env->cp15.c9_pmuserenr) {
 473         return CP_ACCESS_TRAP;
 474     }
 475     return CP_ACCESS_OK;
 476 }
 477
 478 static void pmcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 479                        uint64_t value)
 480 {
 481     /* only the DP, X, D and E bits are writable */
 482     env->cp15.c9_pmcr &= ~0x39;
 483     env->cp15.c9_pmcr |= (value & 0x39);
 484 }
 485
 486 static void pmcntenset_write(CPUARMState *env, const ARMCPRegInfo *ri,
 487                             uint64_t value)
 488 {
 489     value &= (1 << 31);
 490     env->cp15.c9_pmcnten |= value;
 491 }
 492
 493 static void pmcntenclr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 494                              uint64_t value)
 495 {
 496     value &= (1 << 31);
 497     env->cp15.c9_pmcnten &= ~value;
 498 }
 499
 500 static void pmovsr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 501                          uint64_t value)
 502 {
 503     env->cp15.c9_pmovsr &= ~value;
 504 }
 505
 506 static void pmxevtyper_write(CPUARMState *env, const ARMCPRegInfo *ri,
 507                              uint64_t value)
 508 {
 509     env->cp15.c9_pmxevtyper = value & 0xff;
 510 }
 511
 512 static void pmuserenr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 513                             uint64_t value)
 514 {
 515     env->cp15.c9_pmuserenr = value & 1;
 516 }
 517
 518 static void pmintenset_write(CPUARMState *env, const ARMCPRegInfo *ri,
 519                              uint64_t value)
 520 {
 521     /* We have no event counters so only the C bit can be changed */
 522     value &= (1 << 31);
 523     env->cp15.c9_pminten |= value;
 524 }
 525
 526 static void pmintenclr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 527                              uint64_t value)
 528 {
 529     value &= (1 << 31);
 530     env->cp15.c9_pminten &= ~value;
 531 }
 532
 533 static void vbar_write(CPUARMState *env, const ARMCPRegInfo *ri,
 534                        uint64_t value)
 535 {
 536     env->cp15.c12_vbar = value & ~0x1Ful;
 537 }
 538
 539 static uint64_t ccsidr_read(CPUARMState *env, const ARMCPRegInfo *ri)
 540 {
 541     ARMCPU *cpu = arm_env_get_cpu(env);
 542     return cpu->ccsidr[env->cp15.c0_cssel];
 543 }
 544
 545 static void csselr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 546                          uint64_t value)
 547 {
 548     env->cp15.c0_cssel = value & 0xf;
 549 }
 550
 551 static const ARMCPRegInfo v7_cp_reginfo[] = {
 552     /* DBGDRAR, DBGDSAR: always RAZ since we don't implement memory mapped
 553      * debug components
 554      */
 555     { .name = "DBGDRAR", .cp = 14, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 0,
 556       .access = PL0_R, .type = ARM_CP_CONST, .resetvalue = 0 },
 557     { .name = "DBGDSAR", .cp = 14, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0,
 558       .access = PL0_R, .type = ARM_CP_CONST, .resetvalue = 0 },
 559     /* the old v6 WFI, UNPREDICTABLE in v7 but we choose to NOP */
 560     { .name = "NOP", .cp = 15, .crn = 7, .crm = 0, .opc1 = 0, .opc2 = 4,
 561       .access = PL1_W, .type = ARM_CP_NOP },
 562     /* Performance monitors are implementation defined in v7,
 563      * but with an ARM recommended set of registers, which we
 564      * follow (although we don't actually implement any counters)
 565      *
 566      * Performance registers fall into three categories:
 567      *  (a) always UNDEF in PL0, RW in PL1 (PMINTENSET, PMINTENCLR)
 568      *  (b) RO in PL0 (ie UNDEF on write), RW in PL1 (PMUSERENR)
 569      *  (c) UNDEF in PL0 if PMUSERENR.EN==0, otherwise accessible (all others)
 570      * For the cases controlled by PMUSERENR we must set .access to PL0_RW
 571      * or PL0_RO as appropriate and then check PMUSERENR in the helper fn.
 572      */
 573     { .name = "PMCNTENSET", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 1,
 574       .access = PL0_RW, .resetvalue = 0,
 575       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcnten),
 576       .writefn = pmcntenset_write,
 577       .accessfn = pmreg_access,
 578       .raw_writefn = raw_write },
 579     { .name = "PMCNTENCLR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 2,
 580       .access = PL0_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcnten),
 581       .accessfn = pmreg_access,
 582       .writefn = pmcntenclr_write,
 583       .type = ARM_CP_NO_MIGRATE },
 584     { .name = "PMOVSR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 3,
 585       .access = PL0_RW, .fieldoffset = offsetof(CPUARMState, cp15.c9_pmovsr),
 586       .accessfn = pmreg_access,
 587       .writefn = pmovsr_write,
 588       .raw_writefn = raw_write },
 589     /* Unimplemented so WI. */
 590     { .name = "PMSWINC", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 4,
 591       .access = PL0_W, .accessfn = pmreg_access, .type = ARM_CP_NOP },
 592     /* Since we don't implement any events, writing to PMSELR is UNPREDICTABLE.
 593      * We choose to RAZ/WI.
 594      */
 595     { .name = "PMSELR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 5,
 596       .access = PL0_RW, .type = ARM_CP_CONST, .resetvalue = 0,
 597       .accessfn = pmreg_access },
 598     /* Unimplemented, RAZ/WI. */
 599     { .name = "PMCCNTR", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 0,
 600       .access = PL0_RW, .type = ARM_CP_CONST, .resetvalue = 0,
 601       .accessfn = pmreg_access },
 602     { .name = "PMXEVTYPER", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 1,
 603       .access = PL0_RW,
 604       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmxevtyper),
 605       .accessfn = pmreg_access, .writefn = pmxevtyper_write,
 606       .raw_writefn = raw_write },
 607     /* Unimplemented, RAZ/WI. */
 608     { .name = "PMXEVCNTR", .cp = 15, .crn = 9, .crm = 13, .opc1 = 0, .opc2 = 2,
 609       .access = PL0_RW, .type = ARM_CP_CONST, .resetvalue = 0,
 610       .accessfn = pmreg_access },
 611     { .name = "PMUSERENR", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 0,
 612       .access = PL0_R | PL1_RW,
 613       .fieldoffset = offsetof(CPUARMState, cp15.c9_pmuserenr),
 614       .resetvalue = 0,
 615       .writefn = pmuserenr_write, .raw_writefn = raw_write },
 616     { .name = "PMINTENSET", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 1,
 617       .access = PL1_RW,
 618       .fieldoffset = offsetof(CPUARMState, cp15.c9_pminten),
 619       .resetvalue = 0,
 620       .writefn = pmintenset_write, .raw_writefn = raw_write },
 621     { .name = "PMINTENCLR", .cp = 15, .crn = 9, .crm = 14, .opc1 = 0, .opc2 = 2,
 622       .access = PL1_RW, .type = ARM_CP_NO_MIGRATE,
 623       .fieldoffset = offsetof(CPUARMState, cp15.c9_pminten),
 624       .resetvalue = 0, .writefn = pmintenclr_write, },
 625     { .name = "VBAR", .cp = 15, .crn = 12, .crm = 0, .opc1 = 0, .opc2 = 0,
 626       .access = PL1_RW, .writefn = vbar_write,
 627       .fieldoffset = offsetof(CPUARMState, cp15.c12_vbar),
 628       .resetvalue = 0 },
 629     { .name = "SCR", .cp = 15, .crn = 1, .crm = 1, .opc1 = 0, .opc2 = 0,
 630       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c1_scr),
 631       .resetvalue = 0, },
 632     { .name = "CCSIDR", .state = ARM_CP_STATE_BOTH,
 633       .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = 0,
 634       .access = PL1_R, .readfn = ccsidr_read, .type = ARM_CP_NO_MIGRATE },
 635     { .name = "CSSELR", .state = ARM_CP_STATE_BOTH,
 636       .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 2, .opc2 = 0,
 637       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c0_cssel),
 638       .writefn = csselr_write, .resetvalue = 0 },
 639     /* Auxiliary ID register: this actually has an IMPDEF value but for now
 640      * just RAZ for all cores:
 641      */
 642     { .name = "AIDR", .cp = 15, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = 7,
 643       .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
 644     REGINFO_SENTINEL
 645 };
 646
 647 static void teecr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 648                         uint64_t value)
 649 {
 650     value &= 1;
 651     env->teecr = value;
 652 }
 653
 654 static CPAccessResult teehbr_access(CPUARMState *env, const ARMCPRegInfo *ri)
 655 {
 656     if (arm_current_pl(env) == 0 && (env->teecr & 1)) {
 657         return CP_ACCESS_TRAP;
 658     }
 659     return CP_ACCESS_OK;
 660 }
 661
 662 static const ARMCPRegInfo t2ee_cp_reginfo[] = {
 663     { .name = "TEECR", .cp = 14, .crn = 0, .crm = 0, .opc1 = 6, .opc2 = 0,
 664       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, teecr),
 665       .resetvalue = 0,
 666       .writefn = teecr_write },
 667     { .name = "TEEHBR", .cp = 14, .crn = 1, .crm = 0, .opc1 = 6, .opc2 = 0,
 668       .access = PL0_RW, .fieldoffset = offsetof(CPUARMState, teehbr),
 669       .accessfn = teehbr_access, .resetvalue = 0 },
 670     REGINFO_SENTINEL
 671 };
 672
 673 static const ARMCPRegInfo v6k_cp_reginfo[] = {
 674     { .name = "TPIDR_EL0", .state = ARM_CP_STATE_AA64,
 675       .opc0 = 3, .opc1 = 3, .opc2 = 2, .crn = 13, .crm = 0,
 676       .access = PL0_RW,
 677       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el0), .resetvalue = 0 },
 678     { .name = "TPIDRURW", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 2,
 679       .access = PL0_RW,
 680       .fieldoffset = offsetoflow32(CPUARMState, cp15.tpidr_el0),
 681       .resetfn = arm_cp_reset_ignore },
 682     { .name = "TPIDRRO_EL0", .state = ARM_CP_STATE_AA64,
 683       .opc0 = 3, .opc1 = 3, .opc2 = 3, .crn = 13, .crm = 0,
 684       .access = PL0_R|PL1_W,
 685       .fieldoffset = offsetof(CPUARMState, cp15.tpidrro_el0), .resetvalue = 0 },
 686     { .name = "TPIDRURO", .cp = 15, .crn = 13, .crm = 0, .opc1 = 0, .opc2 = 3,
 687       .access = PL0_R|PL1_W,
 688       .fieldoffset = offsetoflow32(CPUARMState, cp15.tpidrro_el0),
 689       .resetfn = arm_cp_reset_ignore },
 690     { .name = "TPIDR_EL1", .state = ARM_CP_STATE_BOTH,
 691       .opc0 = 3, .opc1 = 0, .opc2 = 4, .crn = 13, .crm = 0,
 692       .access = PL1_RW,
 693       .fieldoffset = offsetof(CPUARMState, cp15.tpidr_el1), .resetvalue = 0 },
 694     REGINFO_SENTINEL
 695 };
 696
 697 #ifndef CONFIG_USER_ONLY
 698
 699 static CPAccessResult gt_cntfrq_access(CPUARMState *env, const ARMCPRegInfo *ri)
 700 {
 701     /* CNTFRQ: not visible from PL0 if both PL0PCTEN and PL0VCTEN are zero */
 702     if (arm_current_pl(env) == 0 && !extract32(env->cp15.c14_cntkctl, 0, 2)) {
 703         return CP_ACCESS_TRAP;
 704     }
 705     return CP_ACCESS_OK;
 706 }
 707
 708 static CPAccessResult gt_counter_access(CPUARMState *env, int timeridx)
 709 {
 710     /* CNT[PV]CT: not visible from PL0 if ELO[PV]CTEN is zero */
 711     if (arm_current_pl(env) == 0 &&
 712         !extract32(env->cp15.c14_cntkctl, timeridx, 1)) {
 713         return CP_ACCESS_TRAP;
 714     }
 715     return CP_ACCESS_OK;
 716 }
 717
 718 static CPAccessResult gt_timer_access(CPUARMState *env, int timeridx)
 719 {
 720     /* CNT[PV]_CVAL, CNT[PV]_CTL, CNT[PV]_TVAL: not visible from PL0 if
 721      * EL0[PV]TEN is zero.
 722      */
 723     if (arm_current_pl(env) == 0 &&
 724         !extract32(env->cp15.c14_cntkctl, 9 - timeridx, 1)) {
 725         return CP_ACCESS_TRAP;
 726     }
 727     return CP_ACCESS_OK;
 728 }
 729
 730 static CPAccessResult gt_pct_access(CPUARMState *env,
 731                                          const ARMCPRegInfo *ri)
 732 {
 733     return gt_counter_access(env, GTIMER_PHYS);
 734 }
 735
 736 static CPAccessResult gt_vct_access(CPUARMState *env,
 737                                          const ARMCPRegInfo *ri)
 738 {
 739     return gt_counter_access(env, GTIMER_VIRT);
 740 }
 741
 742 static CPAccessResult gt_ptimer_access(CPUARMState *env, const ARMCPRegInfo *ri)
 743 {
 744     return gt_timer_access(env, GTIMER_PHYS);
 745 }
 746
 747 static CPAccessResult gt_vtimer_access(CPUARMState *env, const ARMCPRegInfo *ri)
 748 {
 749     return gt_timer_access(env, GTIMER_VIRT);
 750 }
 751
 752 static uint64_t gt_get_countervalue(CPUARMState *env)
 753 {
 754     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) / GTIMER_SCALE;
 755 }
 756
 757 static void gt_recalc_timer(ARMCPU *cpu, int timeridx)
 758 {
 759     ARMGenericTimer *gt = &cpu->env.cp15.c14_timer[timeridx];
 760
 761     if (gt->ctl & 1) {
 762         /* Timer enabled: calculate and set current ISTATUS, irq, and
 763          * reset timer to when ISTATUS next has to change
 764          */
 765         uint64_t count = gt_get_countervalue(&cpu->env);
 766         /* Note that this must be unsigned 64 bit arithmetic: */
 767         int istatus = count >= gt->cval;
 768         uint64_t nexttick;
 769
 770         gt->ctl = deposit32(gt->ctl, 2, 1, istatus);
 771         qemu_set_irq(cpu->gt_timer_outputs[timeridx],
 772                      (istatus && !(gt->ctl & 2)));
 773         if (istatus) {
 774             /* Next transition is when count rolls back over to zero */
 775             nexttick = UINT64_MAX;
 776         } else {
 777             /* Next transition is when we hit cval */
 778             nexttick = gt->cval;
 779         }
 780         /* Note that the desired next expiry time might be beyond the
 781          * signed-64-bit range of a QEMUTimer -- in this case we just
 782          * set the timer for as far in the future as possible. When the
 783          * timer expires we will reset the timer for any remaining period.
 784          */
 785         if (nexttick > INT64_MAX / GTIMER_SCALE) {
 786             nexttick = INT64_MAX / GTIMER_SCALE;
 787         }
 788         timer_mod(cpu->gt_timer[timeridx], nexttick);
 789     } else {
 790         /* Timer disabled: ISTATUS and timer output always clear */
 791         gt->ctl &= ~4;
 792         qemu_set_irq(cpu->gt_timer_outputs[timeridx], 0);
 793         timer_del(cpu->gt_timer[timeridx]);
 794     }
 795 }
 796
 797 static void gt_cnt_reset(CPUARMState *env, const ARMCPRegInfo *ri)
 798 {
 799     ARMCPU *cpu = arm_env_get_cpu(env);
 800     int timeridx = ri->opc1 & 1;
 801
 802     timer_del(cpu->gt_timer[timeridx]);
 803 }
 804
 805 static uint64_t gt_cnt_read(CPUARMState *env, const ARMCPRegInfo *ri)
 806 {
 807     return gt_get_countervalue(env);
 808 }
 809
 810 static void gt_cval_write(CPUARMState *env, const ARMCPRegInfo *ri,
 811                           uint64_t value)
 812 {
 813     int timeridx = ri->opc1 & 1;
 814
 815     env->cp15.c14_timer[timeridx].cval = value;
 816     gt_recalc_timer(arm_env_get_cpu(env), timeridx);
 817 }
 818
 819 static uint64_t gt_tval_read(CPUARMState *env, const ARMCPRegInfo *ri)
 820 {
 821     int timeridx = ri->crm & 1;
 822
 823     return (uint32_t)(env->cp15.c14_timer[timeridx].cval -
 824                       gt_get_countervalue(env));
 825 }
 826
 827 static void gt_tval_write(CPUARMState *env, const ARMCPRegInfo *ri,
 828                           uint64_t value)
 829 {
 830     int timeridx = ri->crm & 1;
 831
 832     env->cp15.c14_timer[timeridx].cval = gt_get_countervalue(env) +
 833         + sextract64(value, 0, 32);
 834     gt_recalc_timer(arm_env_get_cpu(env), timeridx);
 835 }
 836
 837 static void gt_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
 838                          uint64_t value)
 839 {
 840     ARMCPU *cpu = arm_env_get_cpu(env);
 841     int timeridx = ri->crm & 1;
 842     uint32_t oldval = env->cp15.c14_timer[timeridx].ctl;
 843
 844     env->cp15.c14_timer[timeridx].ctl = value & 3;
 845     if ((oldval ^ value) & 1) {
 846         /* Enable toggled */
 847         gt_recalc_timer(cpu, timeridx);
 848     } else if ((oldval & value) & 2) {
 849         /* IMASK toggled: don't need to recalculate,
 850          * just set the interrupt line based on ISTATUS
 851          */
 852         qemu_set_irq(cpu->gt_timer_outputs[timeridx],
 853                      (oldval & 4) && (value & 2));
 854     }
 855 }
 856
 857 void arm_gt_ptimer_cb(void *opaque)
 858 {
 859     ARMCPU *cpu = opaque;
 860
 861     gt_recalc_timer(cpu, GTIMER_PHYS);
 862 }
 863
 864 void arm_gt_vtimer_cb(void *opaque)
 865 {
 866     ARMCPU *cpu = opaque;
 867
 868     gt_recalc_timer(cpu, GTIMER_VIRT);
 869 }
 870
 871 static const ARMCPRegInfo generic_timer_cp_reginfo[] = {
 872     /* Note that CNTFRQ is purely reads-as-written for the benefit
 873      * of software; writing it doesn't actually change the timer frequency.
 874      * Our reset value matches the fixed frequency we implement the timer at.
 875      */
 876     { .name = "CNTFRQ", .cp = 15, .crn = 14, .crm = 0, .opc1 = 0, .opc2 = 0,
 877       .access = PL1_RW | PL0_R,
 878       .fieldoffset = offsetof(CPUARMState, cp15.c14_cntfrq),
 879       .resetvalue = (1000 * 1000 * 1000) / GTIMER_SCALE,
 880       .accessfn = gt_cntfrq_access,
 881     },
 882     /* overall control: mostly access permissions */
 883     { .name = "CNTKCTL", .cp = 15, .crn = 14, .crm = 1, .opc1 = 0, .opc2 = 0,
 884       .access = PL1_RW,
 885       .fieldoffset = offsetof(CPUARMState, cp15.c14_cntkctl),
 886       .resetvalue = 0,
 887     },
 888     /* per-timer control */
 889     { .name = "CNTP_CTL", .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 1,
 890       .type = ARM_CP_IO, .access = PL1_RW | PL0_R,
 891       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_PHYS].ctl),
 892       .resetvalue = 0,
 893       .accessfn = gt_ptimer_access,
 894       .writefn = gt_ctl_write, .raw_writefn = raw_write,
 895     },
 896     { .name = "CNTV_CTL", .cp = 15, .crn = 14, .crm = 3, .opc1 = 0, .opc2 = 1,
 897       .type = ARM_CP_IO, .access = PL1_RW | PL0_R,
 898       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_VIRT].ctl),
 899       .resetvalue = 0,
 900       .accessfn = gt_vtimer_access,
 901       .writefn = gt_ctl_write, .raw_writefn = raw_write,
 902     },
 903     /* TimerValue views: a 32 bit downcounting view of the underlying state */
 904     { .name = "CNTP_TVAL", .cp = 15, .crn = 14, .crm = 2, .opc1 = 0, .opc2 = 0,
 905       .type = ARM_CP_NO_MIGRATE | ARM_CP_IO, .access = PL1_RW | PL0_R,
 906       .accessfn = gt_ptimer_access,
 907       .readfn = gt_tval_read, .writefn = gt_tval_write,
 908     },
 909     { .name = "CNTV_TVAL", .cp = 15, .crn = 14, .crm = 3, .opc1 = 0, .opc2 = 0,
 910       .type = ARM_CP_NO_MIGRATE | ARM_CP_IO, .access = PL1_RW | PL0_R,
 911       .accessfn = gt_vtimer_access,
 912       .readfn = gt_tval_read, .writefn = gt_tval_write,
 913     },
 914     /* The counter itself */
 915     { .name = "CNTPCT", .cp = 15, .crm = 14, .opc1 = 0,
 916       .access = PL0_R, .type = ARM_CP_64BIT | ARM_CP_NO_MIGRATE | ARM_CP_IO,
 917       .accessfn = gt_pct_access,
 918       .readfn = gt_cnt_read, .resetfn = gt_cnt_reset,
 919     },
 920     { .name = "CNTVCT", .cp = 15, .crm = 14, .opc1 = 1,
 921       .access = PL0_R, .type = ARM_CP_64BIT | ARM_CP_NO_MIGRATE | ARM_CP_IO,
 922       .accessfn = gt_vct_access,
 923       .readfn = gt_cnt_read, .resetfn = gt_cnt_reset,
 924     },
 925     /* Comparison value, indicating when the timer goes off */
 926     { .name = "CNTP_CVAL", .cp = 15, .crm = 14, .opc1 = 2,
 927       .access = PL1_RW | PL0_R,
 928       .type = ARM_CP_64BIT | ARM_CP_IO,
 929       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_PHYS].cval),
 930       .resetvalue = 0,
 931       .accessfn = gt_ptimer_access,
 932       .writefn = gt_cval_write, .raw_writefn = raw_write,
 933     },
 934     { .name = "CNTV_CVAL", .cp = 15, .crm = 14, .opc1 = 3,
 935       .access = PL1_RW | PL0_R,
 936       .type = ARM_CP_64BIT | ARM_CP_IO,
 937       .fieldoffset = offsetof(CPUARMState, cp15.c14_timer[GTIMER_VIRT].cval),
 938       .resetvalue = 0,
 939       .accessfn = gt_vtimer_access,
 940       .writefn = gt_cval_write, .raw_writefn = raw_write,
 941     },
 942     REGINFO_SENTINEL
 943 };
 944
 945 #else
 946 /* In user-mode none of the generic timer registers are accessible,
 947  * and their implementation depends on QEMU_CLOCK_VIRTUAL and qdev gpio outputs,
 948  * so instead just don't register any of them.
 949  */
 950 static const ARMCPRegInfo generic_timer_cp_reginfo[] = {
 951     REGINFO_SENTINEL
 952 };
 953
 954 #endif
 955
 956 static void par_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 957 {
 958     if (arm_feature(env, ARM_FEATURE_LPAE)) {
 959         env->cp15.c7_par = value;
 960     } else if (arm_feature(env, ARM_FEATURE_V7)) {
 961         env->cp15.c7_par = value & 0xfffff6ff;
 962     } else {
 963         env->cp15.c7_par = value & 0xfffff1ff;
 964     }
 965 }
 966
 967 #ifndef CONFIG_USER_ONLY
 968 /* get_phys_addr() isn't present for user-mode-only targets */
 969
 970 /* Return true if extended addresses are enabled, ie this is an
 971  * LPAE implementation and we are using the long-descriptor translation
 972  * table format because the TTBCR EAE bit is set.
 973  */
 974 static inline bool extended_addresses_enabled(CPUARMState *env)
 975 {
 976     return arm_feature(env, ARM_FEATURE_LPAE)
 977         && (env->cp15.c2_control & (1U << 31));
 978 }
 979
 980 static CPAccessResult ats_access(CPUARMState *env, const ARMCPRegInfo *ri)
 981 {
 982     if (ri->opc2 & 4) {
 983         /* Other states are only available with TrustZone; in
 984          * a non-TZ implementation these registers don't exist
 985          * at all, which is an Uncategorized trap. This underdecoding
 986          * is safe because the reginfo is NO_MIGRATE.
 987          */
 988         return CP_ACCESS_TRAP_UNCATEGORIZED;
 989     }
 990     return CP_ACCESS_OK;
 991 }
 992
 993 static void ats_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 994 {
 995     hwaddr phys_addr;
 996     target_ulong page_size;
 997     int prot;
 998     int ret, is_user = ri->opc2 & 2;
 999     int access_type = ri->opc2 & 1;
1000
1001     ret = get_phys_addr(env, value, access_type, is_user,
1002                         &phys_addr, &prot, &page_size);
1003     if (extended_addresses_enabled(env)) {
1004         /* ret is a DFSR/IFSR value for the long descriptor
1005          * translation table format, but with WnR always clear.
1006          * Convert it to a 64-bit PAR.
1007          */
1008         uint64_t par64 = (1 << 11); /* LPAE bit always set */
1009         if (ret == 0) {
1010             par64 |= phys_addr & ~0xfffULL;
1011             /* We don't set the ATTR or SH fields in the PAR. */
1012         } else {
1013             par64 |= 1; /* F */
1014             par64 |= (ret & 0x3f) << 1; /* FS */
1015             /* Note that S2WLK and FSTAGE are always zero, because we don't
1016              * implement virtualization and therefore there can't be a stage 2
1017              * fault.
1018              */
1019         }
1020         env->cp15.c7_par = par64;
1021         env->cp15.c7_par_hi = par64 >> 32;
1022     } else {
1023         /* ret is a DFSR/IFSR value for the short descriptor
1024          * translation table format (with WnR always clear).
1025          * Convert it to a 32-bit PAR.
1026          */
1027         if (ret == 0) {
1028             /* We do not set any attribute bits in the PAR */
1029             if (page_size == (1 << 24)
1030                 && arm_feature(env, ARM_FEATURE_V7)) {
1031                 env->cp15.c7_par = (phys_addr & 0xff000000) | 1 << 1;
1032             } else {
1033                 env->cp15.c7_par = phys_addr & 0xfffff000;
1034             }
1035         } else {
1036             env->cp15.c7_par = ((ret & (1 << 10)) >> 5) |
1037                 ((ret & (1 << 12)) >> 6) |
1038                 ((ret & 0xf) << 1) | 1;
1039         }
1040         env->cp15.c7_par_hi = 0;
1041     }
1042 }
1043 #endif
1044
1045 static const ARMCPRegInfo vapa_cp_reginfo[] = {
1046     { .name = "PAR", .cp = 15, .crn = 7, .crm = 4, .opc1 = 0, .opc2 = 0,
1047       .access = PL1_RW, .resetvalue = 0,
1048       .fieldoffset = offsetof(CPUARMState, cp15.c7_par),
1049       .writefn = par_write },
1050 #ifndef CONFIG_USER_ONLY
1051     { .name = "ATS", .cp = 15, .crn = 7, .crm = 8, .opc1 = 0, .opc2 = CP_ANY,
1052       .access = PL1_W, .accessfn = ats_access,
1053       .writefn = ats_write, .type = ARM_CP_NO_MIGRATE },
1054 #endif
1055     REGINFO_SENTINEL
1056 };
1057
1058 /* Return basic MPU access permission bits.  */
1059 static uint32_t simple_mpu_ap_bits(uint32_t val)
1060 {
1061     uint32_t ret;
1062     uint32_t mask;
1063     int i;
1064     ret = 0;
1065     mask = 3;
1066     for (i = 0; i < 16; i += 2) {
1067         ret |= (val >> i) & mask;
1068         mask <<= 2;
1069     }
1070     return ret;
1071 }
1072
1073 /* Pad basic MPU access permission bits to extended format.  */
1074 static uint32_t extended_mpu_ap_bits(uint32_t val)
1075 {
1076     uint32_t ret;
1077     uint32_t mask;
1078     int i;
1079     ret = 0;
1080     mask = 3;
1081     for (i = 0; i < 16; i += 2) {
1082         ret |= (val & mask) << i;
1083         mask <<= 2;
1084     }
1085     return ret;
1086 }
1087
1088 static void pmsav5_data_ap_write(CPUARMState *env, const ARMCPRegInfo *ri,
1089                                  uint64_t value)
1090 {
1091     env->cp15.c5_data = extended_mpu_ap_bits(value);
1092 }
1093
1094 static uint64_t pmsav5_data_ap_read(CPUARMState *env, const ARMCPRegInfo *ri)
1095 {
1096     return simple_mpu_ap_bits(env->cp15.c5_data);
1097 }
1098
1099 static void pmsav5_insn_ap_write(CPUARMState *env, const ARMCPRegInfo *ri,
1100                                  uint64_t value)
1101 {
1102     env->cp15.c5_insn = extended_mpu_ap_bits(value);
1103 }
1104
1105 static uint64_t pmsav5_insn_ap_read(CPUARMState *env, const ARMCPRegInfo *ri)
1106 {
1107     return simple_mpu_ap_bits(env->cp15.c5_insn);
1108 }
1109
1110 static const ARMCPRegInfo pmsav5_cp_reginfo[] = {
1111     { .name = "DATA_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 0,
1112       .access = PL1_RW, .type = ARM_CP_NO_MIGRATE,
1113       .fieldoffset = offsetof(CPUARMState, cp15.c5_data), .resetvalue = 0,
1114       .readfn = pmsav5_data_ap_read, .writefn = pmsav5_data_ap_write, },
1115     { .name = "INSN_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 1,
1116       .access = PL1_RW, .type = ARM_CP_NO_MIGRATE,
1117       .fieldoffset = offsetof(CPUARMState, cp15.c5_insn), .resetvalue = 0,
1118       .readfn = pmsav5_insn_ap_read, .writefn = pmsav5_insn_ap_write, },
1119     { .name = "DATA_EXT_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 2,
1120       .access = PL1_RW,
1121       .fieldoffset = offsetof(CPUARMState, cp15.c5_data), .resetvalue = 0, },
1122     { .name = "INSN_EXT_AP", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 3,
1123       .access = PL1_RW,
1124       .fieldoffset = offsetof(CPUARMState, cp15.c5_insn), .resetvalue = 0, },
1125     { .name = "DCACHE_CFG", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0,
1126       .access = PL1_RW,
1127       .fieldoffset = offsetof(CPUARMState, cp15.c2_data), .resetvalue = 0, },
1128     { .name = "ICACHE_CFG", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 1,
1129       .access = PL1_RW,
1130       .fieldoffset = offsetof(CPUARMState, cp15.c2_insn), .resetvalue = 0, },
1131     /* Protection region base and size registers */
1132     { .name = "946_PRBS0", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0,
1133       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1134       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[0]) },
1135     { .name = "946_PRBS1", .cp = 15, .crn = 6, .crm = 1, .opc1 = 0,
1136       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1137       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[1]) },
1138     { .name = "946_PRBS2", .cp = 15, .crn = 6, .crm = 2, .opc1 = 0,
1139       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1140       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[2]) },
1141     { .name = "946_PRBS3", .cp = 15, .crn = 6, .crm = 3, .opc1 = 0,
1142       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1143       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[3]) },
1144     { .name = "946_PRBS4", .cp = 15, .crn = 6, .crm = 4, .opc1 = 0,
1145       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1146       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[4]) },
1147     { .name = "946_PRBS5", .cp = 15, .crn = 6, .crm = 5, .opc1 = 0,
1148       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1149       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[5]) },
1150     { .name = "946_PRBS6", .cp = 15, .crn = 6, .crm = 6, .opc1 = 0,
1151       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1152       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[6]) },
1153     { .name = "946_PRBS7", .cp = 15, .crn = 6, .crm = 7, .opc1 = 0,
1154       .opc2 = CP_ANY, .access = PL1_RW, .resetvalue = 0,
1155       .fieldoffset = offsetof(CPUARMState, cp15.c6_region[7]) },
1156     REGINFO_SENTINEL
1157 };
1158
1159 static void vmsa_ttbcr_raw_write(CPUARMState *env, const ARMCPRegInfo *ri,
1160                                  uint64_t value)
1161 {
1162     int maskshift = extract32(value, 0, 3);
1163
1164     if (arm_feature(env, ARM_FEATURE_LPAE) && (value & (1 << 31))) {
1165         value &= ~((7 << 19) | (3 << 14) | (0xf << 3));
1166     } else {
1167         value &= 7;
1168     }
1169     /* Note that we always calculate c2_mask and c2_base_mask, but
1170      * they are only used for short-descriptor tables (ie if EAE is 0);
1171      * for long-descriptor tables the TTBCR fields are used differently
1172      * and the c2_mask and c2_base_mask values are meaningless.
1173      */
1174     env->cp15.c2_control = value;
1175     env->cp15.c2_mask = ~(((uint32_t)0xffffffffu) >> maskshift);
1176     env->cp15.c2_base_mask = ~((uint32_t)0x3fffu >> maskshift);
1177 }
1178
1179 static void vmsa_ttbcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1180                              uint64_t value)
1181 {
1182     if (arm_feature(env, ARM_FEATURE_LPAE)) {
1183         /* With LPAE the TTBCR could result in a change of ASID
1184          * via the TTBCR.A1 bit, so do a TLB flush.
1185          */
1186         tlb_flush(env, 1);
1187     }
1188     vmsa_ttbcr_raw_write(env, ri, value);
1189 }
1190
1191 static void vmsa_ttbcr_reset(CPUARMState *env, const ARMCPRegInfo *ri)
1192 {
1193     env->cp15.c2_base_mask = 0xffffc000u;
1194     env->cp15.c2_control = 0;
1195     env->cp15.c2_mask = 0;
1196 }
1197
1198 static const ARMCPRegInfo vmsa_cp_reginfo[] = {
1199     { .name = "DFSR", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 0,
1200       .access = PL1_RW,
1201       .fieldoffset = offsetof(CPUARMState, cp15.c5_data), .resetvalue = 0, },
1202     { .name = "IFSR", .cp = 15, .crn = 5, .crm = 0, .opc1 = 0, .opc2 = 1,
1203       .access = PL1_RW,
1204       .fieldoffset = offsetof(CPUARMState, cp15.c5_insn), .resetvalue = 0, },
1205     { .name = "TTBR0", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 0,
1206       .access = PL1_RW,
1207       .fieldoffset = offsetof(CPUARMState, cp15.c2_base0), .resetvalue = 0, },
1208     { .name = "TTBR1", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 1,
1209       .access = PL1_RW,
1210       .fieldoffset = offsetof(CPUARMState, cp15.c2_base1), .resetvalue = 0, },
1211     { .name = "TTBCR", .cp = 15, .crn = 2, .crm = 0, .opc1 = 0, .opc2 = 2,
1212       .access = PL1_RW, .writefn = vmsa_ttbcr_write,
1213       .resetfn = vmsa_ttbcr_reset, .raw_writefn = vmsa_ttbcr_raw_write,
1214       .fieldoffset = offsetof(CPUARMState, cp15.c2_control) },
1215     { .name = "DFAR", .cp = 15, .crn = 6, .crm = 0, .opc1 = 0, .opc2 = 0,
1216       .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c6_data),
1217       .resetvalue = 0, },
1218     REGINFO_SENTINEL
1219 };
1220
1221 static void omap_ticonfig_write(CPUARMState *env, const ARMCPRegInfo *ri,
1222                                 uint64_t value)
1223 {
1224     env->cp15.c15_ticonfig = value & 0xe7;
1225     /* The OS_TYPE bit in this register changes the reported CPUID! */
1226     env->cp15.c0_cpuid = (value & (1 << 5)) ?
1227         ARM_CPUID_TI915T : ARM_CPUID_TI925T;
1228 }
1229
1230 static void omap_threadid_write(CPUARMState *env, const ARMCPRegInfo *ri,
1231                                 uint64_t value)
1232 {
1233     env->cp15.c15_threadid = value & 0xffff;
1234 }
1235
1236 static void omap_wfi_write(CPUARMState *env, const ARMCPRegInfo *ri,
1237                            uint64_t value)
1238 {
1239     /* Wait-for-interrupt (deprecated) */
1240     cpu_interrupt(CPU(arm_env_get_cpu(env)), CPU_INTERRUPT_HALT);
1241 }
1242
1243 static void omap_cachemaint_write(CPUARMState *env, const ARMCPRegInfo *ri,
1244                                   uint64_t value)
1245 {
1246     /* On OMAP there are registers indicating the max/min index of dcache lines
1247      * containing a dirty line; cache flush operations have to reset these.
1248      */
1249     env->cp15.c15_i_max = 0x000;
1250     env->cp15.c15_i_min = 0xff0;
1251 }
1252
1253 static const ARMCPRegInfo omap_cp_reginfo[] = {
1254     { .name = "DFSR", .cp = 15, .crn = 5, .crm = CP_ANY,
1255       .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW, .type = ARM_CP_OVERRIDE,
1256       .fieldoffset = offsetof(CPUARMState, cp15.c5_data), .resetvalue = 0, },
1257     { .name = "", .cp = 15, .crn = 15, .crm = 0, .opc1 = 0, .opc2 = 0,
1258       .access = PL1_RW, .type = ARM_CP_NOP },
1259     { .name = "TICONFIG", .cp = 15, .crn = 15, .crm = 1, .opc1 = 0, .opc2 = 0,
1260       .access = PL1_RW,
1261       .fieldoffset = offsetof(CPUARMState, cp15.c15_ticonfig), .resetvalue = 0,
1262       .writefn = omap_ticonfig_write },
1263     { .name = "IMAX", .cp = 15, .crn = 15, .crm = 2, .opc1 = 0, .opc2 = 0,
1264       .access = PL1_RW,
1265       .fieldoffset = offsetof(CPUARMState, cp15.c15_i_max), .resetvalue = 0, },
1266     { .name = "IMIN", .cp = 15, .crn = 15, .crm = 3, .opc1 = 0, .opc2 = 0,
1267       .access = PL1_RW, .resetvalue = 0xff0,
1268       .fieldoffset = offsetof(CPUARMState, cp15.c15_i_min) },
1269     { .name = "THREADID", .cp = 15, .crn = 15, .crm = 4, .opc1 = 0, .opc2 = 0,
1270       .access = PL1_RW,
1271       .fieldoffset = offsetof(CPUARMState, cp15.c15_threadid), .resetvalue = 0,
1272       .writefn = omap_threadid_write },
1273     { .name = "TI925T_STATUS", .cp = 15, .crn = 15,
1274       .crm = 8, .opc1 = 0, .opc2 = 0, .access = PL1_RW,
1275       .type = ARM_CP_NO_MIGRATE,
1276       .readfn = arm_cp_read_zero, .writefn = omap_wfi_write, },
1277     /* TODO: Peripheral port remap register:
1278      * On OMAP2 mcr p15, 0, rn, c15, c2, 4 sets up the interrupt controller
1279      * base address at $rn & ~0xfff and map size of 0x200 << ($rn & 0xfff),
1280      * when MMU is off.
1281      */
1282     { .name = "OMAP_CACHEMAINT", .cp = 15, .crn = 7, .crm = CP_ANY,
1283       .opc1 = 0, .opc2 = CP_ANY, .access = PL1_W,
1284       .type = ARM_CP_OVERRIDE | ARM_CP_NO_MIGRATE,
1285       .writefn = omap_cachemaint_write },
1286     { .name = "C9", .cp = 15, .crn = 9,
1287       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_RW,
1288       .type = ARM_CP_CONST | ARM_CP_OVERRIDE, .resetvalue = 0 },
1289     REGINFO_SENTINEL
1290 };
1291
1292 static void xscale_cpar_write(CPUARMState *env, const ARMCPRegInfo *ri,
1293                               uint64_t value)
1294 {
1295     value &= 0x3fff;
1296     if (env->cp15.c15_cpar != value) {
1297         /* Changes cp0 to cp13 behavior, so needs a TB flush.  */
1298         tb_flush(env);
1299         env->cp15.c15_cpar = value;
1300     }
1301 }
1302
1303 static const ARMCPRegInfo xscale_cp_reginfo[] = {
1304     { .name = "XSCALE_CPAR",
1305       .cp = 15, .crn = 15, .crm = 1, .opc1 = 0, .opc2 = 0, .access = PL1_RW,
1306       .fieldoffset = offsetof(CPUARMState, cp15.c15_cpar), .resetvalue = 0,
1307       .writefn = xscale_cpar_write, },
1308     { .name = "XSCALE_AUXCR",
1309       .cp = 15, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 1, .access = PL1_RW,
1310       .fieldoffset = offsetof(CPUARMState, cp15.c1_xscaleauxcr),
1311       .resetvalue = 0, },
1312     REGINFO_SENTINEL
1313 };
1314
1315 static const ARMCPRegInfo dummy_c15_cp_reginfo[] = {
1316     /* RAZ/WI the whole crn=15 space, when we don't have a more specific
1317      * implementation of this implementation-defined space.
1318      * Ideally this should eventually disappear in favour of actually
1319      * implementing the correct behaviour for all cores.
1320      */
1321     { .name = "C15_IMPDEF", .cp = 15, .crn = 15,
1322       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY,
1323       .access = PL1_RW,
1324       .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE | ARM_CP_OVERRIDE,
1325       .resetvalue = 0 },
1326     REGINFO_SENTINEL
1327 };
1328
1329 static const ARMCPRegInfo cache_dirty_status_cp_reginfo[] = {
1330     /* Cache status: RAZ because we have no cache so it's always clean */
1331     { .name = "CDSR", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 6,
1332       .access = PL1_R, .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE,
1333       .resetvalue = 0 },
1334     REGINFO_SENTINEL
1335 };
1336
1337 static const ARMCPRegInfo cache_block_ops_cp_reginfo[] = {
1338     /* We never have a a block transfer operation in progress */
1339     { .name = "BXSR", .cp = 15, .crn = 7, .crm = 12, .opc1 = 0, .opc2 = 4,
1340       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE,
1341       .resetvalue = 0 },
1342     /* The cache ops themselves: these all NOP for QEMU */
1343     { .name = "IICR", .cp = 15, .crm = 5, .opc1 = 0,
1344       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1345     { .name = "IDCR", .cp = 15, .crm = 6, .opc1 = 0,
1346       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1347     { .name = "CDCR", .cp = 15, .crm = 12, .opc1 = 0,
1348       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1349     { .name = "PIR", .cp = 15, .crm = 12, .opc1 = 1,
1350       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1351     { .name = "PDR", .cp = 15, .crm = 12, .opc1 = 2,
1352       .access = PL0_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1353     { .name = "CIDCR", .cp = 15, .crm = 14, .opc1 = 0,
1354       .access = PL1_W, .type = ARM_CP_NOP|ARM_CP_64BIT },
1355     REGINFO_SENTINEL
1356 };
1357
1358 static const ARMCPRegInfo cache_test_clean_cp_reginfo[] = {
1359     /* The cache test-and-clean instructions always return (1 << 30)
1360      * to indicate that there are no dirty cache lines.
1361      */
1362     { .name = "TC_DCACHE", .cp = 15, .crn = 7, .crm = 10, .opc1 = 0, .opc2 = 3,
1363       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE,
1364       .resetvalue = (1 << 30) },
1365     { .name = "TCI_DCACHE", .cp = 15, .crn = 7, .crm = 14, .opc1 = 0, .opc2 = 3,
1366       .access = PL0_R, .type = ARM_CP_CONST | ARM_CP_NO_MIGRATE,
1367       .resetvalue = (1 << 30) },
1368     REGINFO_SENTINEL
1369 };
1370
1371 static const ARMCPRegInfo strongarm_cp_reginfo[] = {
1372     /* Ignore ReadBuffer accesses */
1373     { .name = "C9_READBUFFER", .cp = 15, .crn = 9,
1374       .crm = CP_ANY, .opc1 = CP_ANY, .opc2 = CP_ANY,
1375       .access = PL1_RW, .resetvalue = 0,
1376       .type = ARM_CP_CONST | ARM_CP_OVERRIDE | ARM_CP_NO_MIGRATE },
1377     REGINFO_SENTINEL
1378 };
1379
1380 static uint64_t mpidr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1381 {
1382     CPUState *cs = CPU(arm_env_get_cpu(env));
1383     uint32_t mpidr = cs->cpu_index;
1384     /* We don't support setting cluster ID ([8..11])
1385      * so these bits always RAZ.
1386      */
1387     if (arm_feature(env, ARM_FEATURE_V7MP)) {
1388         mpidr |= (1U << 31);
1389         /* Cores which are uniprocessor (non-coherent)
1390          * but still implement the MP extensions set
1391          * bit 30. (For instance, A9UP.) However we do
1392          * not currently model any of those cores.
1393          */
1394     }
1395     return mpidr;
1396 }
1397
1398 static const ARMCPRegInfo mpidr_cp_reginfo[] = {
1399     { .name = "MPIDR", .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 5,
1400       .access = PL1_R, .readfn = mpidr_read, .type = ARM_CP_NO_MIGRATE },
1401     REGINFO_SENTINEL
1402 };
1403
1404 static uint64_t par64_read(CPUARMState *env, const ARMCPRegInfo *ri)
1405 {
1406     return ((uint64_t)env->cp15.c7_par_hi << 32) | env->cp15.c7_par;
1407 }
1408
1409 static void par64_write(CPUARMState *env, const ARMCPRegInfo *ri,
1410                         uint64_t value)
1411 {
1412     env->cp15.c7_par_hi = value >> 32;
1413     env->cp15.c7_par = value;
1414 }
1415
1416 static void par64_reset(CPUARMState *env, const ARMCPRegInfo *ri)
1417 {
1418     env->cp15.c7_par_hi = 0;
1419     env->cp15.c7_par = 0;
1420 }
1421
1422 static uint64_t ttbr064_read(CPUARMState *env, const ARMCPRegInfo *ri)
1423 {
1424     return ((uint64_t)env->cp15.c2_base0_hi << 32) | env->cp15.c2_base0;
1425 }
1426
1427 static void ttbr064_raw_write(CPUARMState *env, const ARMCPRegInfo *ri,
1428                               uint64_t value)
1429 {
1430     env->cp15.c2_base0_hi = value >> 32;
1431     env->cp15.c2_base0 = value;
1432 }
1433
1434 static void ttbr064_write(CPUARMState *env, const ARMCPRegInfo *ri,
1435                           uint64_t value)
1436 {
1437     /* Writes to the 64 bit format TTBRs may change the ASID */
1438     tlb_flush(env, 1);
1439     ttbr064_raw_write(env, ri, value);
1440 }
1441
1442 static void ttbr064_reset(CPUARMState *env, const ARMCPRegInfo *ri)
1443 {
1444     env->cp15.c2_base0_hi = 0;
1445     env->cp15.c2_base0 = 0;
1446 }
1447
1448 static uint64_t ttbr164_read(CPUARMState *env, const ARMCPRegInfo *ri)
1449 {
1450     return ((uint64_t)env->cp15.c2_base1_hi << 32) | env->cp15.c2_base1;
1451 }
1452
1453 static void ttbr164_write(CPUARMState *env, const ARMCPRegInfo *ri,
1454                           uint64_t value)
1455 {
1456     env->cp15.c2_base1_hi = value >> 32;
1457     env->cp15.c2_base1 = value;
1458 }
1459
1460 static void ttbr164_reset(CPUARMState *env, const ARMCPRegInfo *ri)
1461 {
1462     env->cp15.c2_base1_hi = 0;
1463     env->cp15.c2_base1 = 0;
1464 }
1465
1466 static const ARMCPRegInfo lpae_cp_reginfo[] = {
1467     /* NOP AMAIR0/1: the override is because these clash with the rather
1468      * broadly specified TLB_LOCKDOWN entry in the generic cp_reginfo.
1469      */
1470     { .name = "AMAIR0", .cp = 15, .crn = 10, .crm = 3, .opc1 = 0, .opc2 = 0,
1471       .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_OVERRIDE,
1472       .resetvalue = 0 },
1473     { .name = "AMAIR1", .cp = 15, .crn = 10, .crm = 3, .opc1 = 0, .opc2 = 1,
1474       .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_OVERRIDE,
1475       .resetvalue = 0 },
1476     /* 64 bit access versions of the (dummy) debug registers */
1477     { .name = "DBGDRAR", .cp = 14, .crm = 1, .opc1 = 0,
1478       .access = PL0_R, .type = ARM_CP_CONST|ARM_CP_64BIT, .resetvalue = 0 },
1479     { .name = "DBGDSAR", .cp = 14, .crm = 2, .opc1 = 0,
1480       .access = PL0_R, .type = ARM_CP_CONST|ARM_CP_64BIT, .resetvalue = 0 },
1481     { .name = "PAR", .cp = 15, .crm = 7, .opc1 = 0,
1482       .access = PL1_RW, .type = ARM_CP_64BIT,
1483       .readfn = par64_read, .writefn = par64_write, .resetfn = par64_reset },
1484     { .name = "TTBR0", .cp = 15, .crm = 2, .opc1 = 0,
1485       .access = PL1_RW, .type = ARM_CP_64BIT, .readfn = ttbr064_read,
1486       .writefn = ttbr064_write, .raw_writefn = ttbr064_raw_write,
1487       .resetfn = ttbr064_reset },
1488     { .name = "TTBR1", .cp = 15, .crm = 2, .opc1 = 1,
1489       .access = PL1_RW, .type = ARM_CP_64BIT, .readfn = ttbr164_read,
1490       .writefn = ttbr164_write, .resetfn = ttbr164_reset },
1491     REGINFO_SENTINEL
1492 };
1493
1494 static uint64_t aa64_fpcr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1495 {
1496     return vfp_get_fpcr(env);
1497 }
1498
1499 static void aa64_fpcr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1500                             uint64_t value)
1501 {
1502     vfp_set_fpcr(env, value);
1503 }
1504
1505 static uint64_t aa64_fpsr_read(CPUARMState *env, const ARMCPRegInfo *ri)
1506 {
1507     return vfp_get_fpsr(env);
1508 }
1509
1510 static void aa64_fpsr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1511                             uint64_t value)
1512 {
1513     vfp_set_fpsr(env, value);
1514 }
1515
1516 static const ARMCPRegInfo v8_cp_reginfo[] = {
1517     /* Minimal set of EL0-visible registers. This will need to be expanded
1518      * significantly for system emulation of AArch64 CPUs.
1519      */
1520     { .name = "NZCV", .state = ARM_CP_STATE_AA64,
1521       .opc0 = 3, .opc1 = 3, .opc2 = 0, .crn = 4, .crm = 2,
1522       .access = PL0_RW, .type = ARM_CP_NZCV },
1523     { .name = "FPCR", .state = ARM_CP_STATE_AA64,
1524       .opc0 = 3, .opc1 = 3, .opc2 = 0, .crn = 4, .crm = 4,
1525       .access = PL0_RW, .readfn = aa64_fpcr_read, .writefn = aa64_fpcr_write },
1526     { .name = "FPSR", .state = ARM_CP_STATE_AA64,
1527       .opc0 = 3, .opc1 = 3, .opc2 = 1, .crn = 4, .crm = 4,
1528       .access = PL0_RW, .readfn = aa64_fpsr_read, .writefn = aa64_fpsr_write },
1529     /* Prohibit use of DC ZVA. OPTME: implement DC ZVA and allow its use.
1530      * For system mode the DZP bit here will need to be computed, not constant.
1531      */
1532     { .name = "DCZID_EL0", .state = ARM_CP_STATE_AA64,
1533       .opc0 = 3, .opc1 = 3, .opc2 = 7, .crn = 0, .crm = 0,
1534       .access = PL0_R, .type = ARM_CP_CONST,
1535       .resetvalue = 0x10 },
1536     { .name = "CURRENTEL", .state = ARM_CP_STATE_AA64,
1537       .opc0 = 3, .opc1 = 0, .opc2 = 2, .crn = 4, .crm = 2,
1538       .access = PL1_R, .type = ARM_CP_CURRENTEL },
1539     REGINFO_SENTINEL
1540 };
1541
1542 static void sctlr_write(CPUARMState *env, const ARMCPRegInfo *ri,
1543                         uint64_t value)
1544 {
1545     env->cp15.c1_sys = value;
1546     /* ??? Lots of these bits are not implemented.  */
1547     /* This may enable/disable the MMU, so do a TLB flush.  */
1548     tlb_flush(env, 1);
1549 }
1550
1551 static CPAccessResult ctr_el0_access(CPUARMState *env, const ARMCPRegInfo *ri)
1552 {
1553     /* Only accessible in EL0 if SCTLR.UCT is set (and only in AArch64,
1554      * but the AArch32 CTR has its own reginfo struct)
1555      */
1556     if (arm_current_pl(env) == 0 && !(env->cp15.c1_sys & SCTLR_UCT)) {
1557         return CP_ACCESS_TRAP;
1558     }
1559     return CP_ACCESS_OK;
1560 }
1561
1562 void register_cp_regs_for_features(ARMCPU *cpu)
1563 {
1564     /* Register all the coprocessor registers based on feature bits */
1565     CPUARMState *env = &cpu->env;
1566     if (arm_feature(env, ARM_FEATURE_M)) {
1567         /* M profile has no coprocessor registers */
1568         return;
1569     }
1570
1571     define_arm_cp_regs(cpu, cp_reginfo);
1572     if (arm_feature(env, ARM_FEATURE_V6)) {
1573         /* The ID registers all have impdef reset values */
1574         ARMCPRegInfo v6_idregs[] = {
1575             { .name = "ID_PFR0", .cp = 15, .crn = 0, .crm = 1,
1576               .opc1 = 0, .opc2 = 0, .access = PL1_R, .type = ARM_CP_CONST,
1577               .resetvalue = cpu->id_pfr0 },
1578             { .name = "ID_PFR1", .cp = 15, .crn = 0, .crm = 1,
1579               .opc1 = 0, .opc2 = 1, .access = PL1_R, .type = ARM_CP_CONST,
1580               .resetvalue = cpu->id_pfr1 },
1581             { .name = "ID_DFR0", .cp = 15, .crn = 0, .crm = 1,
1582               .opc1 = 0, .opc2 = 2, .access = PL1_R, .type = ARM_CP_CONST,
1583               .resetvalue = cpu->id_dfr0 },
1584             { .name = "ID_AFR0", .cp = 15, .crn = 0, .crm = 1,
1585               .opc1 = 0, .opc2 = 3, .access = PL1_R, .type = ARM_CP_CONST,
1586               .resetvalue = cpu->id_afr0 },
1587             { .name = "ID_MMFR0", .cp = 15, .crn = 0, .crm = 1,
1588               .opc1 = 0, .opc2 = 4, .access = PL1_R, .type = ARM_CP_CONST,
1589               .resetvalue = cpu->id_mmfr0 },
1590             { .name = "ID_MMFR1", .cp = 15, .crn = 0, .crm = 1,
1591               .opc1 = 0, .opc2 = 5, .access = PL1_R, .type = ARM_CP_CONST,
1592               .resetvalue = cpu->id_mmfr1 },
1593             { .name = "ID_MMFR2", .cp = 15, .crn = 0, .crm = 1,
1594               .opc1 = 0, .opc2 = 6, .access = PL1_R, .type = ARM_CP_CONST,
1595               .resetvalue = cpu->id_mmfr2 },
1596             { .name = "ID_MMFR3", .cp = 15, .crn = 0, .crm = 1,
1597               .opc1 = 0, .opc2 = 7, .access = PL1_R, .type = ARM_CP_CONST,
1598               .resetvalue = cpu->id_mmfr3 },
1599             { .name = "ID_ISAR0", .cp = 15, .crn = 0, .crm = 2,
1600               .opc1 = 0, .opc2 = 0, .access = PL1_R, .type = ARM_CP_CONST,
1601               .resetvalue = cpu->id_isar0 },
1602             { .name = "ID_ISAR1", .cp = 15, .crn = 0, .crm = 2,
1603               .opc1 = 0, .opc2 = 1, .access = PL1_R, .type = ARM_CP_CONST,
1604               .resetvalue = cpu->id_isar1 },
1605             { .name = "ID_ISAR2", .cp = 15, .crn = 0, .crm = 2,
1606               .opc1 = 0, .opc2 = 2, .access = PL1_R, .type = ARM_CP_CONST,
1607               .resetvalue = cpu->id_isar2 },
1608             { .name = "ID_ISAR3", .cp = 15, .crn = 0, .crm = 2,
1609               .opc1 = 0, .opc2 = 3, .access = PL1_R, .type = ARM_CP_CONST,
1610               .resetvalue = cpu->id_isar3 },
1611             { .name = "ID_ISAR4", .cp = 15, .crn = 0, .crm = 2,
1612               .opc1 = 0, .opc2 = 4, .access = PL1_R, .type = ARM_CP_CONST,
1613               .resetvalue = cpu->id_isar4 },
1614             { .name = "ID_ISAR5", .cp = 15, .crn = 0, .crm = 2,
1615               .opc1 = 0, .opc2 = 5, .access = PL1_R, .type = ARM_CP_CONST,
1616               .resetvalue = cpu->id_isar5 },
1617             /* 6..7 are as yet unallocated and must RAZ */
1618             { .name = "ID_ISAR6", .cp = 15, .crn = 0, .crm = 2,
1619               .opc1 = 0, .opc2 = 6, .access = PL1_R, .type = ARM_CP_CONST,
1620               .resetvalue = 0 },
1621             { .name = "ID_ISAR7", .cp = 15, .crn = 0, .crm = 2,
1622               .opc1 = 0, .opc2 = 7, .access = PL1_R, .type = ARM_CP_CONST,
1623               .resetvalue = 0 },
1624             REGINFO_SENTINEL
1625         };
1626         define_arm_cp_regs(cpu, v6_idregs);
1627         define_arm_cp_regs(cpu, v6_cp_reginfo);
1628     } else {
1629         define_arm_cp_regs(cpu, not_v6_cp_reginfo);
1630     }
1631     if (arm_feature(env, ARM_FEATURE_V6K)) {
1632         define_arm_cp_regs(cpu, v6k_cp_reginfo);
1633     }
1634     if (arm_feature(env, ARM_FEATURE_V7)) {
1635         /* v7 performance monitor control register: same implementor
1636          * field as main ID register, and we implement no event counters.
1637          */
1638         ARMCPRegInfo pmcr = {
1639             .name = "PMCR", .cp = 15, .crn = 9, .crm = 12, .opc1 = 0, .opc2 = 0,
1640             .access = PL0_RW, .resetvalue = cpu->midr & 0xff000000,
1641             .fieldoffset = offsetof(CPUARMState, cp15.c9_pmcr),
1642             .accessfn = pmreg_access, .writefn = pmcr_write,
1643             .raw_writefn = raw_write,
1644         };
1645         ARMCPRegInfo clidr = {
1646             .name = "CLIDR", .state = ARM_CP_STATE_BOTH,
1647             .opc0 = 3, .crn = 0, .crm = 0, .opc1 = 1, .opc2 = 1,
1648             .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = cpu->clidr
1649         };
1650         define_one_arm_cp_reg(cpu, &pmcr);
1651         define_one_arm_cp_reg(cpu, &clidr);
1652         define_arm_cp_regs(cpu, v7_cp_reginfo);
1653     } else {
1654         define_arm_cp_regs(cpu, not_v7_cp_reginfo);
1655     }
1656     if (arm_feature(env, ARM_FEATURE_V8)) {
1657         define_arm_cp_regs(cpu, v8_cp_reginfo);
1658     }
1659     if (arm_feature(env, ARM_FEATURE_MPU)) {
1660         /* These are the MPU registers prior to PMSAv6. Any new
1661          * PMSA core later than the ARM946 will require that we
1662          * implement the PMSAv6 or PMSAv7 registers, which are
1663          * completely different.
1664          */
1665         assert(!arm_feature(env, ARM_FEATURE_V6));
1666         define_arm_cp_regs(cpu, pmsav5_cp_reginfo);
1667     } else {
1668         define_arm_cp_regs(cpu, vmsa_cp_reginfo);
1669     }
1670     if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
1671         define_arm_cp_regs(cpu, t2ee_cp_reginfo);
1672     }
1673     if (arm_feature(env, ARM_FEATURE_GENERIC_TIMER)) {
1674         define_arm_cp_regs(cpu, generic_timer_cp_reginfo);
1675     }
1676     if (arm_feature(env, ARM_FEATURE_VAPA)) {
1677         define_arm_cp_regs(cpu, vapa_cp_reginfo);
1678     }
1679     if (arm_feature(env, ARM_FEATURE_CACHE_TEST_CLEAN)) {
1680         define_arm_cp_regs(cpu, cache_test_clean_cp_reginfo);
1681     }
1682     if (arm_feature(env, ARM_FEATURE_CACHE_DIRTY_REG)) {
1683         define_arm_cp_regs(cpu, cache_dirty_status_cp_reginfo);
1684     }
1685     if (arm_feature(env, ARM_FEATURE_CACHE_BLOCK_OPS)) {
1686         define_arm_cp_regs(cpu, cache_block_ops_cp_reginfo);
1687     }
1688     if (arm_feature(env, ARM_FEATURE_OMAPCP)) {
1689         define_arm_cp_regs(cpu, omap_cp_reginfo);
1690     }
1691     if (arm_feature(env, ARM_FEATURE_STRONGARM)) {
1692         define_arm_cp_regs(cpu, strongarm_cp_reginfo);
1693     }
1694     if (arm_feature(env, ARM_FEATURE_XSCALE)) {
1695         define_arm_cp_regs(cpu, xscale_cp_reginfo);
1696     }
1697     if (arm_feature(env, ARM_FEATURE_DUMMY_C15_REGS)) {
1698         define_arm_cp_regs(cpu, dummy_c15_cp_reginfo);
1699     }
1700     if (arm_feature(env, ARM_FEATURE_LPAE)) {
1701         define_arm_cp_regs(cpu, lpae_cp_reginfo);
1702     }
1703     /* Slightly awkwardly, the OMAP and StrongARM cores need all of
1704      * cp15 crn=0 to be writes-ignored, whereas for other cores they should
1705      * be read-only (ie write causes UNDEF exception).
1706      */
1707     {
1708         ARMCPRegInfo id_cp_reginfo[] = {
1709             /* Note that the MIDR isn't a simple constant register because
1710              * of the TI925 behaviour where writes to another register can
1711              * cause the MIDR value to change.
1712              *
1713              * Unimplemented registers in the c15 0 0 0 space default to
1714              * MIDR. Define MIDR first as this entire space, then CTR, TCMTR
1715              * and friends override accordingly.
1716              */
1717             { .name = "MIDR",
1718               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = CP_ANY,
1719               .access = PL1_R, .resetvalue = cpu->midr,
1720               .writefn = arm_cp_write_ignore, .raw_writefn = raw_write,
1721               .fieldoffset = offsetof(CPUARMState, cp15.c0_cpuid),
1722               .type = ARM_CP_OVERRIDE },
1723             { .name = "MIDR_EL1", .state = ARM_CP_STATE_AA64,
1724               .opc0 = 3, .opc1 = 0, .opc2 = 0, .crn = 0, .crm = 0,
1725               .access = PL1_R, .resetvalue = cpu->midr, .type = ARM_CP_CONST },
1726             { .name = "CTR",
1727               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 1,
1728               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = cpu->ctr },
1729             { .name = "CTR_EL0", .state = ARM_CP_STATE_AA64,
1730               .opc0 = 3, .opc1 = 3, .opc2 = 1, .crn = 0, .crm = 0,
1731               .access = PL0_R, .accessfn = ctr_el0_access,
1732               .type = ARM_CP_CONST, .resetvalue = cpu->ctr },
1733             { .name = "TCMTR",
1734               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 2,
1735               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1736             { .name = "TLBTR",
1737               .cp = 15, .crn = 0, .crm = 0, .opc1 = 0, .opc2 = 3,
1738               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1739             /* crn = 0 op1 = 0 crm = 3..7 : currently unassigned; we RAZ. */
1740             { .name = "DUMMY",
1741               .cp = 15, .crn = 0, .crm = 3, .opc1 = 0, .opc2 = CP_ANY,
1742               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1743             { .name = "DUMMY",
1744               .cp = 15, .crn = 0, .crm = 4, .opc1 = 0, .opc2 = CP_ANY,
1745               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1746             { .name = "DUMMY",
1747               .cp = 15, .crn = 0, .crm = 5, .opc1 = 0, .opc2 = CP_ANY,
1748               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1749             { .name = "DUMMY",
1750               .cp = 15, .crn = 0, .crm = 6, .opc1 = 0, .opc2 = CP_ANY,
1751               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1752             { .name = "DUMMY",
1753               .cp = 15, .crn = 0, .crm = 7, .opc1 = 0, .opc2 = CP_ANY,
1754               .access = PL1_R, .type = ARM_CP_CONST, .resetvalue = 0 },
1755             REGINFO_SENTINEL
1756         };
1757         ARMCPRegInfo crn0_wi_reginfo = {
1758             .name = "CRN0_WI", .cp = 15, .crn = 0, .crm = CP_ANY,
1759             .opc1 = CP_ANY, .opc2 = CP_ANY, .access = PL1_W,
1760             .type = ARM_CP_NOP | ARM_CP_OVERRIDE
1761         };
1762         if (arm_feature(env, ARM_FEATURE_OMAPCP) ||
1763             arm_feature(env, ARM_FEATURE_STRONGARM)) {
1764             ARMCPRegInfo *r;
1765             /* Register the blanket "writes ignored" value first to cover the
1766              * whole space. Then update the specific ID registers to allow write
1767              * access, so that they ignore writes rather than causing them to
1768              * UNDEF.
1769              */
1770             define_one_arm_cp_reg(cpu, &crn0_wi_reginfo);
1771             for (r = id_cp_reginfo; r->type != ARM_CP_SENTINEL; r++) {
1772                 r->access = PL1_RW;
1773             }
1774         }
1775         define_arm_cp_regs(cpu, id_cp_reginfo);
1776     }
1777
1778     if (arm_feature(env, ARM_FEATURE_MPIDR)) {
1779         define_arm_cp_regs(cpu, mpidr_cp_reginfo);
1780     }
1781
1782     if (arm_feature(env, ARM_FEATURE_AUXCR)) {
1783         ARMCPRegInfo auxcr = {
1784             .name = "AUXCR", .cp = 15, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 1,
1785             .access = PL1_RW, .type = ARM_CP_CONST,
1786             .resetvalue = cpu->reset_auxcr
1787         };
1788         define_one_arm_cp_reg(cpu, &auxcr);
1789     }
1790
1791     if (arm_feature(env, ARM_FEATURE_CBAR)) {
1792         ARMCPRegInfo cbar = {
1793             .name = "CBAR", .cp = 15, .crn = 15, .crm = 0, .opc1 = 4, .opc2 = 0,
1794             .access = PL1_R|PL3_W, .resetvalue = cpu->reset_cbar,
1795             .fieldoffset = offsetof(CPUARMState, cp15.c15_config_base_address)
1796         };
1797         define_one_arm_cp_reg(cpu, &cbar);
1798     }
1799
1800     /* Generic registers whose values depend on the implementation */
1801     {
1802         ARMCPRegInfo sctlr = {
1803             .name = "SCTLR", .cp = 15, .crn = 1, .crm = 0, .opc1 = 0, .opc2 = 0,
1804             .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c1_sys),
1805             .writefn = sctlr_write, .resetvalue = cpu->reset_sctlr,
1806             .raw_writefn = raw_write,
1807         };
1808         if (arm_feature(env, ARM_FEATURE_XSCALE)) {
1809             /* Normally we would always end the TB on an SCTLR write, but Linux
1810              * arch/arm/mach-pxa/sleep.S expects two instructions following
1811              * an MMU enable to execute from cache.  Imitate this behaviour.
1812              */
1813             sctlr.type |= ARM_CP_SUPPRESS_TB_END;
1814         }
1815         define_one_arm_cp_reg(cpu, &sctlr);
1816     }
1817 }
1818
1819 ARMCPU *cpu_arm_init(const char *cpu_model)
1820 {
1821     ARMCPU *cpu;
1822     ObjectClass *oc;
1823
1824     oc = cpu_class_by_name(TYPE_ARM_CPU, cpu_model);
1825     if (!oc) {
1826         return NULL;
1827     }
1828     cpu = ARM_CPU(object_new(object_class_get_name(oc)));
1829
1830     /* TODO this should be set centrally, once possible */
1831     object_property_set_bool(OBJECT(cpu), true, "realized", NULL);
1832
1833     return cpu;
1834 }
1835
1836 void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu)
1837 {
1838     CPUState *cs = CPU(cpu);
1839     CPUARMState *env = &cpu->env;
1840
1841     if (arm_feature(env, ARM_FEATURE_AARCH64)) {
1842         gdb_register_coprocessor(cs, aarch64_fpu_gdb_get_reg,
1843                                  aarch64_fpu_gdb_set_reg,
1844                                  34, "aarch64-fpu.xml", 0);
1845     } else if (arm_feature(env, ARM_FEATURE_NEON)) {
1846         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
1847                                  51, "arm-neon.xml", 0);
1848     } else if (arm_feature(env, ARM_FEATURE_VFP3)) {
1849         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
1850                                  35, "arm-vfp3.xml", 0);
1851     } else if (arm_feature(env, ARM_FEATURE_VFP)) {
1852         gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg,
1853                                  19, "arm-vfp.xml", 0);
1854     }
1855 }
1856
1857 /* Sort alphabetically by type name, except for "any". */
1858 static gint arm_cpu_list_compare(gconstpointer a, gconstpointer b)
1859 {
1860     ObjectClass *class_a = (ObjectClass *)a;
1861     ObjectClass *class_b = (ObjectClass *)b;
1862     const char *name_a, *name_b;
1863
1864     name_a = object_class_get_name(class_a);
1865     name_b = object_class_get_name(class_b);
1866     if (strcmp(name_a, "any-" TYPE_ARM_CPU) == 0) {
1867         return 1;
1868     } else if (strcmp(name_b, "any-" TYPE_ARM_CPU) == 0) {
1869         return -1;
1870     } else {
1871         return strcmp(name_a, name_b);
1872     }
1873 }
1874
1875 static void arm_cpu_list_entry(gpointer data, gpointer user_data)
1876 {
1877     ObjectClass *oc = data;
1878     CPUListState *s = user_data;
1879     const char *typename;
1880     char *name;
1881
1882     typename = object_class_get_name(oc);
1883     name = g_strndup(typename, strlen(typename) - strlen("-" TYPE_ARM_CPU));
1884     (*s->cpu_fprintf)(s->file, "  %s\n",
1885                       name);
1886     g_free(name);
1887 }
1888
1889 void arm_cpu_list(FILE *f, fprintf_function cpu_fprintf)
1890 {
1891     CPUListState s = {
1892         .file = f,
1893         .cpu_fprintf = cpu_fprintf,
1894     };
1895     GSList *list;
1896
1897     list = object_class_get_list(TYPE_ARM_CPU, false);
1898     list = g_slist_sort(list, arm_cpu_list_compare);
1899     (*cpu_fprintf)(f, "Available CPUs:\n");
1900     g_slist_foreach(list, arm_cpu_list_entry, &s);
1901     g_slist_free(list);
1902 #ifdef CONFIG_KVM
1903     /* The 'host' CPU type is dynamically registered only if KVM is
1904      * enabled, so we have to special-case it here:
1905      */
1906     (*cpu_fprintf)(f, "  host (only available in KVM mode)\n");
1907 #endif
1908 }
1909
1910 static void arm_cpu_add_definition(gpointer data, gpointer user_data)
1911 {
1912     ObjectClass *oc = data;
1913     CpuDefinitionInfoList **cpu_list = user_data;
1914     CpuDefinitionInfoList *entry;
1915     CpuDefinitionInfo *info;
1916     const char *typename;
1917
1918     typename = object_class_get_name(oc);
1919     info = g_malloc0(sizeof(*info));
1920     info->name = g_strndup(typename,
1921                            strlen(typename) - strlen("-" TYPE_ARM_CPU));
1922
1923     entry = g_malloc0(sizeof(*entry));
1924     entry->value = info;
1925     entry->next = *cpu_list;
1926     *cpu_list = entry;
1927 }
1928
1929 CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp)
1930 {
1931     CpuDefinitionInfoList *cpu_list = NULL;
1932     GSList *list;
1933
1934     list = object_class_get_list(TYPE_ARM_CPU, false);
1935     g_slist_foreach(list, arm_cpu_add_definition, &cpu_list);
1936     g_slist_free(list);
1937
1938     return cpu_list;
1939 }
1940
1941 static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r,
1942                                    void *opaque, int state,
1943                                    int crm, int opc1, int opc2)
1944 {
1945     /* Private utility function for define_one_arm_cp_reg_with_opaque():
1946      * add a single reginfo struct to the hash table.
1947      */
1948     uint32_t *key = g_new(uint32_t, 1);
1949     ARMCPRegInfo *r2 = g_memdup(r, sizeof(ARMCPRegInfo));
1950     int is64 = (r->type & ARM_CP_64BIT) ? 1 : 0;
1951     if (r->state == ARM_CP_STATE_BOTH && state == ARM_CP_STATE_AA32) {
1952         /* The AArch32 view of a shared register sees the lower 32 bits
1953          * of a 64 bit backing field. It is not migratable as the AArch64
1954          * view handles that. AArch64 also handles reset.
1955          * We assume it is a cp15 register.
1956          */
1957         r2->cp = 15;
1958         r2->type |= ARM_CP_NO_MIGRATE;
1959         r2->resetfn = arm_cp_reset_ignore;
1960 #ifdef HOST_WORDS_BIGENDIAN
1961         if (r2->fieldoffset) {
1962             r2->fieldoffset += sizeof(uint32_t);
1963         }
1964 #endif
1965     }
1966     if (state == ARM_CP_STATE_AA64) {
1967         /* To allow abbreviation of ARMCPRegInfo
1968          * definitions, we treat cp == 0 as equivalent to
1969          * the value for "standard guest-visible sysreg".
1970          */
1971         if (r->cp == 0) {
1972             r2->cp = CP_REG_ARM64_SYSREG_CP;
1973         }
1974         *key = ENCODE_AA64_CP_REG(r2->cp, r2->crn, crm,
1975                                   r2->opc0, opc1, opc2);
1976     } else {
1977         *key = ENCODE_CP_REG(r2->cp, is64, r2->crn, crm, opc1, opc2);
1978     }
1979     if (opaque) {
1980         r2->opaque = opaque;
1981     }
1982     /* reginfo passed to helpers is correct for the actual access,
1983      * and is never ARM_CP_STATE_BOTH:
1984      */
1985     r2->state = state;
1986     /* Make sure reginfo passed to helpers for wildcarded regs
1987      * has the correct crm/opc1/opc2 for this reg, not CP_ANY:
1988      */
1989     r2->crm = crm;
1990     r2->opc1 = opc1;
1991     r2->opc2 = opc2;
1992     /* By convention, for wildcarded registers only the first
1993      * entry is used for migration; the others are marked as
1994      * NO_MIGRATE so we don't try to transfer the register
1995      * multiple times. Special registers (ie NOP/WFI) are
1996      * never migratable.
1997      */
1998     if ((r->type & ARM_CP_SPECIAL) ||
1999         ((r->crm == CP_ANY) && crm != 0) ||
2000         ((r->opc1 == CP_ANY) && opc1 != 0) ||
2001         ((r->opc2 == CP_ANY) && opc2 != 0)) {
2002         r2->type |= ARM_CP_NO_MIGRATE;
2003     }
2004
2005     /* Overriding of an existing definition must be explicitly
2006      * requested.
2007      */
2008     if (!(r->type & ARM_CP_OVERRIDE)) {
2009         ARMCPRegInfo *oldreg;
2010         oldreg = g_hash_table_lookup(cpu->cp_regs, key);
2011         if (oldreg && !(oldreg->type & ARM_CP_OVERRIDE)) {
2012             fprintf(stderr, "Register redefined: cp=%d %d bit "
2013                     "crn=%d crm=%d opc1=%d opc2=%d, "
2014                     "was %s, now %s\n", r2->cp, 32 + 32 * is64,
2015                     r2->crn, r2->crm, r2->opc1, r2->opc2,
2016                     oldreg->name, r2->name);
2017             g_assert_not_reached();
2018         }
2019     }
2020     g_hash_table_insert(cpu->cp_regs, key, r2);
2021 }
2022
2023
2024 void define_one_arm_cp_reg_with_opaque(ARMCPU *cpu,
2025                                        const ARMCPRegInfo *r, void *opaque)
2026 {
2027     /* Define implementations of coprocessor registers.
2028      * We store these in a hashtable because typically
2029      * there are less than 150 registers in a space which
2030      * is 16*16*16*8*8 = 262144 in size.
2031      * Wildcarding is supported for the crm, opc1 and opc2 fields.
2032      * If a register is defined twice then the second definition is
2033      * used, so this can be used to define some generic registers and
2034      * then override them with implementation specific variations.
2035      * At least one of the original and the second definition should
2036      * include ARM_CP_OVERRIDE in its type bits -- this is just a guard
2037      * against accidental use.
2038      *
2039      * The state field defines whether the register is to be
2040      * visible in the AArch32 or AArch64 execution state. If the
2041      * state is set to ARM_CP_STATE_BOTH then we synthesise a
2042      * reginfo structure for the AArch32 view, which sees the lower
2043      * 32 bits of the 64 bit register.
2044      *
2045      * Only registers visible in AArch64 may set r->opc0; opc0 cannot
2046      * be wildcarded. AArch64 registers are always considered to be 64
2047      * bits; the ARM_CP_64BIT* flag applies only to the AArch32 view of
2048      * the register, if any.
2049      */
2050     int crm, opc1, opc2, state;
2051     int crmmin = (r->crm == CP_ANY) ? 0 : r->crm;
2052     int crmmax = (r->crm == CP_ANY) ? 15 : r->crm;
2053     int opc1min = (r->opc1 == CP_ANY) ? 0 : r->opc1;
2054     int opc1max = (r->opc1 == CP_ANY) ? 7 : r->opc1;
2055     int opc2min = (r->opc2 == CP_ANY) ? 0 : r->opc2;
2056     int opc2max = (r->opc2 == CP_ANY) ? 7 : r->opc2;
2057     /* 64 bit registers have only CRm and Opc1 fields */
2058     assert(!((r->type & ARM_CP_64BIT) && (r->opc2 || r->crn)));
2059     /* op0 only exists in the AArch64 encodings */
2060     assert((r->state != ARM_CP_STATE_AA32) || (r->opc0 == 0));
2061     /* AArch64 regs are all 64 bit so ARM_CP_64BIT is meaningless */
2062     assert((r->state != ARM_CP_STATE_AA64) || !(r->type & ARM_CP_64BIT));
2063     /* The AArch64 pseudocode CheckSystemAccess() specifies that op1
2064      * encodes a minimum access level for the register. We roll this
2065      * runtime check into our general permission check code, so check
2066      * here that the reginfo's specified permissions are strict enough
2067      * to encompass the generic architectural permission check.
2068      */
2069     if (r->state != ARM_CP_STATE_AA32) {
2070         int mask = 0;
2071         switch (r->opc1) {
2072         case 0: case 1: case 2:
2073             /* min_EL EL1 */
2074             mask = PL1_RW;
2075             break;
2076         case 3:
2077             /* min_EL EL0 */
2078             mask = PL0_RW;
2079             break;
2080         case 4:
2081             /* min_EL EL2 */
2082             mask = PL2_RW;
2083             break;
2084         case 5:
2085             /* unallocated encoding, so not possible */
2086             assert(false);
2087             break;
2088         case 6:
2089             /* min_EL EL3 */
2090             mask = PL3_RW;
2091             break;
2092         case 7:
2093             /* min_EL EL1, secure mode only (we don't check the latter) */
2094             mask = PL1_RW;
2095             break;
2096         default:
2097             /* broken reginfo with out-of-range opc1 */
2098             assert(false);
2099             break;
2100         }
2101         /* assert our permissions are not too lax (stricter is fine) */
2102         assert((r->access & ~mask) == 0);
2103     }
2104
2105     /* Check that the register definition has enough info to handle
2106      * reads and writes if they are permitted.
2107      */
2108     if (!(r->type & (ARM_CP_SPECIAL|ARM_CP_CONST))) {
2109         if (r->access & PL3_R) {
2110             assert(r->fieldoffset || r->readfn);
2111         }
2112         if (r->access & PL3_W) {
2113             assert(r->fieldoffset || r->writefn);
2114         }
2115     }
2116     /* Bad type field probably means missing sentinel at end of reg list */
2117     assert(cptype_valid(r->type));
2118     for (crm = crmmin; crm <= crmmax; crm++) {
2119         for (opc1 = opc1min; opc1 <= opc1max; opc1++) {
2120             for (opc2 = opc2min; opc2 <= opc2max; opc2++) {
2121                 for (state = ARM_CP_STATE_AA32;
2122                      state <= ARM_CP_STATE_AA64; state++) {
2123                     if (r->state != state && r->state != ARM_CP_STATE_BOTH) {
2124                         continue;
2125                     }
2126                     add_cpreg_to_hashtable(cpu, r, opaque, state,
2127                                            crm, opc1, opc2);
2128                 }
2129             }
2130         }
2131     }
2132 }
2133
2134 void define_arm_cp_regs_with_opaque(ARMCPU *cpu,
2135                                     const ARMCPRegInfo *regs, void *opaque)
2136 {
2137     /* Define a whole list of registers */
2138     const ARMCPRegInfo *r;
2139     for (r = regs; r->type != ARM_CP_SENTINEL; r++) {
2140         define_one_arm_cp_reg_with_opaque(cpu, r, opaque);
2141     }
2142 }
2143
2144 const ARMCPRegInfo *get_arm_cp_reginfo(GHashTable *cpregs, uint32_t encoded_cp)
2145 {
2146     return g_hash_table_lookup(cpregs, &encoded_cp);
2147 }
2148
2149 void arm_cp_write_ignore(CPUARMState *env, const ARMCPRegInfo *ri,
2150                          uint64_t value)
2151 {
2152     /* Helper coprocessor write function for write-ignore registers */
2153 }
2154
2155 uint64_t arm_cp_read_zero(CPUARMState *env, const ARMCPRegInfo *ri)
2156 {
2157     /* Helper coprocessor write function for read-as-zero registers */
2158     return 0;
2159 }
2160
2161 void arm_cp_reset_ignore(CPUARMState *env, const ARMCPRegInfo *opaque)
2162 {
2163     /* Helper coprocessor reset function for do-nothing-on-reset registers */
2164 }
2165
2166 static int bad_mode_switch(CPUARMState *env, int mode)
2167 {
2168     /* Return true if it is not valid for us to switch to
2169      * this CPU mode (ie all the UNPREDICTABLE cases in
2170      * the ARM ARM CPSRWriteByInstr pseudocode).
2171      */
2172     switch (mode) {
2173     case ARM_CPU_MODE_USR:
2174     case ARM_CPU_MODE_SYS:
2175     case ARM_CPU_MODE_SVC:
2176     case ARM_CPU_MODE_ABT:
2177     case ARM_CPU_MODE_UND:
2178     case ARM_CPU_MODE_IRQ:
2179     case ARM_CPU_MODE_FIQ:
2180         return 0;
2181     default:
2182         return 1;
2183     }
2184 }
2185
2186 uint32_t cpsr_read(CPUARMState *env)
2187 {
2188     int ZF;
2189     ZF = (env->ZF == 0);
2190     return env->uncached_cpsr | (env->NF & 0x80000000) | (ZF << 30) |
2191         (env->CF << 29) | ((env->VF & 0x80000000) >> 3) | (env->QF << 27)
2192         | (env->thumb << 5) | ((env->condexec_bits & 3) << 25)
2193         | ((env->condexec_bits & 0xfc) << 8)
2194         | (env->GE << 16);
2195 }
2196
2197 void cpsr_write(CPUARMState *env, uint32_t val, uint32_t mask)
2198 {
2199     if (mask & CPSR_NZCV) {
2200         env->ZF = (~val) & CPSR_Z;
2201         env->NF = val;
2202         env->CF = (val >> 29) & 1;
2203         env->VF = (val << 3) & 0x80000000;
2204     }
2205     if (mask & CPSR_Q)
2206         env->QF = ((val & CPSR_Q) != 0);
2207     if (mask & CPSR_T)
2208         env->thumb = ((val & CPSR_T) != 0);
2209     if (mask & CPSR_IT_0_1) {
2210         env->condexec_bits &= ~3;
2211         env->condexec_bits |= (val >> 25) & 3;
2212     }
2213     if (mask & CPSR_IT_2_7) {
2214         env->condexec_bits &= 3;
2215         env->condexec_bits |= (val >> 8) & 0xfc;
2216     }
2217     if (mask & CPSR_GE) {
2218         env->GE = (val >> 16) & 0xf;
2219     }
2220
2221     if ((env->uncached_cpsr ^ val) & mask & CPSR_M) {
2222         if (bad_mode_switch(env, val & CPSR_M)) {
2223             /* Attempt to switch to an invalid mode: this is UNPREDICTABLE.
2224              * We choose to ignore the attempt and leave the CPSR M field
2225              * untouched.
2226              */
2227             mask &= ~CPSR_M;
2228         } else {
2229             switch_mode(env, val & CPSR_M);
2230         }
2231     }
2232     mask &= ~CACHED_CPSR_BITS;
2233     env->uncached_cpsr = (env->uncached_cpsr & ~mask) | (val & mask);
2234 }
2235
2236 /* Sign/zero extend */
2237 uint32_t HELPER(sxtb16)(uint32_t x)
2238 {
2239     uint32_t res;
2240     res = (uint16_t)(int8_t)x;
2241     res |= (uint32_t)(int8_t)(x >> 16) << 16;
2242     return res;
2243 }
2244
2245 uint32_t HELPER(uxtb16)(uint32_t x)
2246 {
2247     uint32_t res;
2248     res = (uint16_t)(uint8_t)x;
2249     res |= (uint32_t)(uint8_t)(x >> 16) << 16;
2250     return res;
2251 }
2252
2253 uint32_t HELPER(clz)(uint32_t x)
2254 {
2255     return clz32(x);
2256 }
2257
2258 int32_t HELPER(sdiv)(int32_t num, int32_t den)
2259 {
2260     if (den == 0)
2261       return 0;
2262     if (num == INT_MIN && den == -1)
2263       return INT_MIN;
2264     return num / den;
2265 }
2266
2267 uint32_t HELPER(udiv)(uint32_t num, uint32_t den)
2268 {
2269     if (den == 0)
2270       return 0;
2271     return num / den;
2272 }
2273
2274 uint32_t HELPER(rbit)(uint32_t x)
2275 {
2276     x =  ((x & 0xff000000) >> 24)
2277        | ((x & 0x00ff0000) >> 8)
2278        | ((x & 0x0000ff00) << 8)
2279        | ((x & 0x000000ff) << 24);
2280     x =  ((x & 0xf0f0f0f0) >> 4)
2281        | ((x & 0x0f0f0f0f) << 4);
2282     x =  ((x & 0x88888888) >> 3)
2283        | ((x & 0x44444444) >> 1)
2284        | ((x & 0x22222222) << 1)
2285        | ((x & 0x11111111) << 3);
2286     return x;
2287 }
2288
2289 #if defined(CONFIG_USER_ONLY)
2290
2291 void arm_cpu_do_interrupt(CPUState *cs)
2292 {
2293     ARMCPU *cpu = ARM_CPU(cs);
2294     CPUARMState *env = &cpu->env;
2295
2296     env->exception_index = -1;
2297 }
2298
2299 int cpu_arm_handle_mmu_fault (CPUARMState *env, target_ulong address, int rw,
2300                               int mmu_idx)
2301 {
2302     if (rw == 2) {
2303         env->exception_index = EXCP_PREFETCH_ABORT;
2304         env->cp15.c6_insn = address;
2305     } else {
2306         env->exception_index = EXCP_DATA_ABORT;
2307         env->cp15.c6_data = address;
2308     }
2309     return 1;
2310 }
2311
2312 /* These should probably raise undefined insn exceptions.  */
2313 void HELPER(v7m_msr)(CPUARMState *env, uint32_t reg, uint32_t val)
2314 {
2315     cpu_abort(env, "v7m_mrs %d\n", reg);
2316 }
2317
2318 uint32_t HELPER(v7m_mrs)(CPUARMState *env, uint32_t reg)
2319 {
2320     cpu_abort(env, "v7m_mrs %d\n", reg);
2321     return 0;
2322 }
2323
2324 void switch_mode(CPUARMState *env, int mode)
2325 {
2326     if (mode != ARM_CPU_MODE_USR)
2327         cpu_abort(env, "Tried to switch out of user mode\n");
2328 }
2329
2330 void HELPER(set_r13_banked)(CPUARMState *env, uint32_t mode, uint32_t val)
2331 {
2332     cpu_abort(env, "banked r13 write\n");
2333 }
2334
2335 uint32_t HELPER(get_r13_banked)(CPUARMState *env, uint32_t mode)
2336 {
2337     cpu_abort(env, "banked r13 read\n");
2338     return 0;
2339 }
2340
2341 #else
2342
2343 /* Map CPU modes onto saved register banks.  */
2344 int bank_number(int mode)
2345 {
2346     switch (mode) {
2347     case ARM_CPU_MODE_USR:
2348     case ARM_CPU_MODE_SYS:
2349         return 0;
2350     case ARM_CPU_MODE_SVC:
2351         return 1;
2352     case ARM_CPU_MODE_ABT:
2353         return 2;
2354     case ARM_CPU_MODE_UND:
2355         return 3;
2356     case ARM_CPU_MODE_IRQ:
2357         return 4;
2358     case ARM_CPU_MODE_FIQ:
2359         return 5;
2360     }
2361     hw_error("bank number requested for bad CPSR mode value 0x%x\n", mode);
2362 }
2363
2364 void switch_mode(CPUARMState *env, int mode)
2365 {
2366     int old_mode;
2367     int i;
2368
2369     old_mode = env->uncached_cpsr & CPSR_M;
2370     if (mode == old_mode)
2371         return;
2372
2373     if (old_mode == ARM_CPU_MODE_FIQ) {
2374         memcpy (env->fiq_regs, env->regs + 8, 5 * sizeof(uint32_t));
2375         memcpy (env->regs + 8, env->usr_regs, 5 * sizeof(uint32_t));
2376     } else if (mode == ARM_CPU_MODE_FIQ) {
2377         memcpy (env->usr_regs, env->regs + 8, 5 * sizeof(uint32_t));
2378         memcpy (env->regs + 8, env->fiq_regs, 5 * sizeof(uint32_t));
2379     }
2380
2381     i = bank_number(old_mode);
2382     env->banked_r13[i] = env->regs[13];
2383     env->banked_r14[i] = env->regs[14];
2384     env->banked_spsr[i] = env->spsr;
2385
2386     i = bank_number(mode);
2387     env->regs[13] = env->banked_r13[i];
2388     env->regs[14] = env->banked_r14[i];
2389     env->spsr = env->banked_spsr[i];
2390 }
2391
2392 static void v7m_push(CPUARMState *env, uint32_t val)
2393 {
2394     CPUState *cs = ENV_GET_CPU(env);
2395     env->regs[13] -= 4;
2396     stl_phys(cs->as, env->regs[13], val);
2397 }
2398
2399 static uint32_t v7m_pop(CPUARMState *env)
2400 {
2401     CPUState *cs = ENV_GET_CPU(env);
2402     uint32_t val;
2403     val = ldl_phys(cs->as, env->regs[13]);
2404     env->regs[13] += 4;
2405     return val;
2406 }
2407
2408 /* Switch to V7M main or process stack pointer.  */
2409 static void switch_v7m_sp(CPUARMState *env, int process)
2410 {
2411     uint32_t tmp;
2412     if (env->v7m.current_sp != process) {
2413         tmp = env->v7m.other_sp;
2414         env->v7m.other_sp = env->regs[13];
2415         env->regs[13] = tmp;
2416         env->v7m.current_sp = process;
2417     }
2418 }
2419
2420 static void do_v7m_exception_exit(CPUARMState *env)
2421 {
2422     uint32_t type;
2423     uint32_t xpsr;
2424
2425     type = env->regs[15];
2426     if (env->v7m.exception != 0)
2427         armv7m_nvic_complete_irq(env->nvic, env->v7m.exception);
2428
2429     /* Switch to the target stack.  */
2430     switch_v7m_sp(env, (type & 4) != 0);
2431     /* Pop registers.  */
2432     env->regs[0] = v7m_pop(env);
2433     env->regs[1] = v7m_pop(env);
2434     env->regs[2] = v7m_pop(env);
2435     env->regs[3] = v7m_pop(env);
2436     env->regs[12] = v7m_pop(env);
2437     env->regs[14] = v7m_pop(env);
2438     env->regs[15] = v7m_pop(env);
2439     xpsr = v7m_pop(env);
2440     xpsr_write(env, xpsr, 0xfffffdff);
2441     /* Undo stack alignment.  */
2442     if (xpsr & 0x200)
2443         env->regs[13] |= 4;
2444     /* ??? The exception return type specifies Thread/Handler mode.  However
2445        this is also implied by the xPSR value. Not sure what to do
2446        if there is a mismatch.  */
2447     /* ??? Likewise for mismatches between the CONTROL register and the stack
2448        pointer.  */
2449 }
2450
2451 /* Exception names for debug logging; note that not all of these
2452  * precisely correspond to architectural exceptions.
2453  */
2454 static const char * const excnames[] = {
2455     [EXCP_UDEF] = "Undefined Instruction",
2456     [EXCP_SWI] = "SVC",
2457     [EXCP_PREFETCH_ABORT] = "Prefetch Abort",
2458     [EXCP_DATA_ABORT] = "Data Abort",
2459     [EXCP_IRQ] = "IRQ",
2460     [EXCP_FIQ] = "FIQ",
2461     [EXCP_BKPT] = "Breakpoint",
2462     [EXCP_EXCEPTION_EXIT] = "QEMU v7M exception exit",
2463     [EXCP_KERNEL_TRAP] = "QEMU intercept of kernel commpage",
2464     [EXCP_STREX] = "QEMU intercept of STREX",
2465 };
2466
2467 static inline void arm_log_exception(int idx)
2468 {
2469     if (qemu_loglevel_mask(CPU_LOG_INT)) {
2470         const char *exc = NULL;
2471
2472         if (idx >= 0 && idx < ARRAY_SIZE(excnames)) {
2473             exc = excnames[idx];
2474         }
2475         if (!exc) {
2476             exc = "unknown";
2477         }
2478         qemu_log_mask(CPU_LOG_INT, "Taking exception %d [%s]\n", idx, exc);
2479     }
2480 }
2481
2482 void arm_v7m_cpu_do_interrupt(CPUState *cs)
2483 {
2484     ARMCPU *cpu = ARM_CPU(cs);
2485     CPUARMState *env = &cpu->env;
2486     uint32_t xpsr = xpsr_read(env);
2487     uint32_t lr;
2488     uint32_t addr;
2489
2490     arm_log_exception(env->exception_index);
2491
2492     lr = 0xfffffff1;
2493     if (env->v7m.current_sp)
2494         lr |= 4;
2495     if (env->v7m.exception == 0)
2496         lr |= 8;
2497
2498     /* For exceptions we just mark as pending on the NVIC, and let that
2499        handle it.  */
2500     /* TODO: Need to escalate if the current priority is higher than the
2501        one we're raising.  */
2502     switch (env->exception_index) {
2503     case EXCP_UDEF:
2504         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE);
2505         return;
2506     case EXCP_SWI:
2507         /* The PC already points to the next instruction.  */
2508         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SVC);
2509         return;
2510     case EXCP_PREFETCH_ABORT:
2511     case EXCP_DATA_ABORT:
2512         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_MEM);
2513         return;
2514     case EXCP_BKPT:
2515         if (semihosting_enabled) {
2516             int nr;
2517             nr = arm_lduw_code(env, env->regs[15], env->bswap_code) & 0xff;
2518             if (nr == 0xab) {
2519                 env->regs[15] += 2;
2520                 env->regs[0] = do_arm_semihosting(env);
2521                 qemu_log_mask(CPU_LOG_INT, "...handled as semihosting call\n");
2522                 return;
2523             }
2524         }
2525         armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_DEBUG);
2526         return;
2527     case EXCP_IRQ:
2528         env->v7m.exception = armv7m_nvic_acknowledge_irq(env->nvic);
2529         break;
2530     case EXCP_EXCEPTION_EXIT:
2531         do_v7m_exception_exit(env);
2532         return;
2533     default:
2534         cpu_abort(env, "Unhandled exception 0x%x\n", env->exception_index);
2535         return; /* Never happens.  Keep compiler happy.  */
2536     }
2537
2538     /* Align stack pointer.  */
2539     /* ??? Should only do this if Configuration Control Register
2540        STACKALIGN bit is set.  */
2541     if (env->regs[13] & 4) {
2542         env->regs[13] -= 4;
2543         xpsr |= 0x200;
2544     }
2545     /* Switch to the handler mode.  */
2546     v7m_push(env, xpsr);
2547     v7m_push(env, env->regs[15]);
2548     v7m_push(env, env->regs[14]);
2549     v7m_push(env, env->regs[12]);
2550     v7m_push(env, env->regs[3]);
2551     v7m_push(env, env->regs[2]);
2552     v7m_push(env, env->regs[1]);
2553     v7m_push(env, env->regs[0]);
2554     switch_v7m_sp(env, 0);
2555     /* Clear IT bits */
2556     env->condexec_bits = 0;
2557     env->regs[14] = lr;
2558     addr = ldl_phys(cs->as, env->v7m.vecbase + env->v7m.exception * 4);
2559     env->regs[15] = addr & 0xfffffffe;
2560     env->thumb = addr & 1;
2561 }
2562
2563 /* Handle a CPU exception.  */
2564 void arm_cpu_do_interrupt(CPUState *cs)
2565 {
2566     ARMCPU *cpu = ARM_CPU(cs);
2567     CPUARMState *env = &cpu->env;
2568     uint32_t addr;
2569     uint32_t mask;
2570     int new_mode;
2571     uint32_t offset;
2572
2573     assert(!IS_M(env));
2574
2575     arm_log_exception(env->exception_index);
2576
2577     /* TODO: Vectored interrupt controller.  */
2578     switch (env->exception_index) {
2579     case EXCP_UDEF:
2580         new_mode = ARM_CPU_MODE_UND;
2581         addr = 0x04;
2582         mask = CPSR_I;
2583         if (env->thumb)
2584             offset = 2;
2585         else
2586             offset = 4;
2587         break;
2588     case EXCP_SWI:
2589         if (semihosting_enabled) {
2590             /* Check for semihosting interrupt.  */
2591             if (env->thumb) {
2592                 mask = arm_lduw_code(env, env->regs[15] - 2, env->bswap_code)
2593                     & 0xff;
2594             } else {
2595                 mask = arm_ldl_code(env, env->regs[15] - 4, env->bswap_code)
2596                     & 0xffffff;
2597             }
2598             /* Only intercept calls from privileged modes, to provide some
2599                semblance of security.  */
2600             if (((mask == 0x123456 && !env->thumb)
2601                     || (mask == 0xab && env->thumb))
2602                   && (env->uncached_cpsr & CPSR_M) != ARM_CPU_MODE_USR) {
2603                 env->regs[0] = do_arm_semihosting(env);
2604                 qemu_log_mask(CPU_LOG_INT, "...handled as semihosting call\n");
2605                 return;
2606             }
2607         }
2608         new_mode = ARM_CPU_MODE_SVC;
2609         addr = 0x08;
2610         mask = CPSR_I;
2611         /* The PC already points to the next instruction.  */
2612         offset = 0;
2613         break;
2614     case EXCP_BKPT:
2615         /* See if this is a semihosting syscall.  */
2616         if (env->thumb && semihosting_enabled) {
2617             mask = arm_lduw_code(env, env->regs[15], env->bswap_code) & 0xff;
2618             if (mask == 0xab
2619                   && (env->uncached_cpsr & CPSR_M) != ARM_CPU_MODE_USR) {
2620                 env->regs[15] += 2;
2621                 env->regs[0] = do_arm_semihosting(env);
2622                 qemu_log_mask(CPU_LOG_INT, "...handled as semihosting call\n");
2623                 return;
2624             }
2625         }
2626         env->cp15.c5_insn = 2;
2627         /* Fall through to prefetch abort.  */
2628     case EXCP_PREFETCH_ABORT:
2629         qemu_log_mask(CPU_LOG_INT, "...with IFSR 0x%x IFAR 0x%x\n",
2630                       env->cp15.c5_insn, env->cp15.c6_insn);
2631         new_mode = ARM_CPU_MODE_ABT;
2632         addr = 0x0c;
2633         mask = CPSR_A | CPSR_I;
2634         offset = 4;
2635         break;
2636     case EXCP_DATA_ABORT:
2637         qemu_log_mask(CPU_LOG_INT, "...with DFSR 0x%x DFAR 0x%x\n",
2638                       env->cp15.c5_data, env->cp15.c6_data);
2639         new_mode = ARM_CPU_MODE_ABT;
2640         addr = 0x10;
2641         mask = CPSR_A | CPSR_I;
2642         offset = 8;
2643         break;
2644     case EXCP_IRQ:
2645         new_mode = ARM_CPU_MODE_IRQ;
2646         addr = 0x18;
2647         /* Disable IRQ and imprecise data aborts.  */
2648         mask = CPSR_A | CPSR_I;
2649         offset = 4;
2650         break;
2651     case EXCP_FIQ:
2652         new_mode = ARM_CPU_MODE_FIQ;
2653         addr = 0x1c;
2654         /* Disable FIQ, IRQ and imprecise data aborts.  */
2655         mask = CPSR_A | CPSR_I | CPSR_F;
2656         offset = 4;
2657         break;
2658     default:
2659         cpu_abort(env, "Unhandled exception 0x%x\n", env->exception_index);
2660         return; /* Never happens.  Keep compiler happy.  */
2661     }
2662     /* High vectors.  */
2663     if (env->cp15.c1_sys & SCTLR_V) {
2664         /* when enabled, base address cannot be remapped.  */
2665         addr += 0xffff0000;
2666     } else {
2667         /* ARM v7 architectures provide a vector base address register to remap
2668          * the interrupt vector table.
2669          * This register is only followed in non-monitor mode, and has a secure
2670          * and un-secure copy. Since the cpu is always in a un-secure operation
2671          * and is never in monitor mode this feature is always active.
2672          * Note: only bits 31:5 are valid.
2673          */
2674         addr += env->cp15.c12_vbar;
2675     }
2676     switch_mode (env, new_mode);
2677     env->spsr = cpsr_read(env);
2678     /* Clear IT bits.  */
2679     env->condexec_bits = 0;
2680     /* Switch to the new mode, and to the correct instruction set.  */
2681     env->uncached_cpsr = (env->uncached_cpsr & ~CPSR_M) | new_mode;
2682     env->uncached_cpsr |= mask;
2683     /* this is a lie, as the was no c1_sys on V4T/V5, but who cares
2684      * and we should just guard the thumb mode on V4 */
2685     if (arm_feature(env, ARM_FEATURE_V4T)) {
2686         env->thumb = (env->cp15.c1_sys & SCTLR_TE) != 0;
2687     }
2688     env->regs[14] = env->regs[15] + offset;
2689     env->regs[15] = addr;
2690     cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
2691 }
2692
2693 /* Check section/page access permissions.
2694    Returns the page protection flags, or zero if the access is not
2695    permitted.  */
2696 static inline int check_ap(CPUARMState *env, int ap, int domain_prot,
2697                            int access_type, int is_user)
2698 {
2699   int prot_ro;
2700
2701   if (domain_prot == 3) {
2702     return PAGE_READ | PAGE_WRITE;
2703   }
2704
2705   if (access_type == 1)
2706       prot_ro = 0;
2707   else
2708       prot_ro = PAGE_READ;
2709
2710   switch (ap) {
2711   case 0:
2712       if (arm_feature(env, ARM_FEATURE_V7)) {
2713           return 0;
2714       }
2715       if (access_type == 1)
2716           return 0;
2717       switch (env->cp15.c1_sys & (SCTLR_S | SCTLR_R)) {
2718       case SCTLR_S:
2719           return is_user ? 0 : PAGE_READ;
2720       case SCTLR_R:
2721           return PAGE_READ;
2722       default:
2723           return 0;
2724       }
2725   case 1:
2726       return is_user ? 0 : PAGE_READ | PAGE_WRITE;
2727   case 2:
2728       if (is_user)
2729           return prot_ro;
2730       else
2731           return PAGE_READ | PAGE_WRITE;
2732   case 3:
2733       return PAGE_READ | PAGE_WRITE;
2734   case 4: /* Reserved.  */
2735       return 0;
2736   case 5:
2737       return is_user ? 0 : prot_ro;
2738   case 6:
2739       return prot_ro;
2740   case 7:
2741       if (!arm_feature (env, ARM_FEATURE_V6K))
2742           return 0;
2743       return prot_ro;
2744   default:
2745       abort();
2746   }
2747 }
2748
2749 static uint32_t get_level1_table_address(CPUARMState *env, uint32_t address)
2750 {
2751     uint32_t table;
2752
2753     if (address & env->cp15.c2_mask)
2754         table = env->cp15.c2_base1 & 0xffffc000;
2755     else
2756         table = env->cp15.c2_base0 & env->cp15.c2_base_mask;
2757
2758     table |= (address >> 18) & 0x3ffc;
2759     return table;
2760 }
2761
2762 static int get_phys_addr_v5(CPUARMState *env, uint32_t address, int access_type,
2763                             int is_user, hwaddr *phys_ptr,
2764                             int *prot, target_ulong *page_size)
2765 {
2766     CPUState *cs = ENV_GET_CPU(env);
2767     int code;
2768     uint32_t table;
2769     uint32_t desc;
2770     int type;
2771     int ap;
2772     int domain;
2773     int domain_prot;
2774     hwaddr phys_addr;
2775
2776     /* Pagetable walk.  */
2777     /* Lookup l1 descriptor.  */
2778     table = get_level1_table_address(env, address);
2779     desc = ldl_phys(cs->as, table);
2780     type = (desc & 3);
2781     domain = (desc >> 5) & 0x0f;
2782     domain_prot = (env->cp15.c3 >> (domain * 2)) & 3;
2783     if (type == 0) {
2784         /* Section translation fault.  */
2785         code = 5;
2786         goto do_fault;
2787     }
2788     if (domain_prot == 0 || domain_prot == 2) {
2789         if (type == 2)
2790             code = 9; /* Section domain fault.  */
2791         else
2792             code = 11; /* Page domain fault.  */
2793         goto do_fault;
2794     }
2795     if (type == 2) {
2796         /* 1Mb section.  */
2797         phys_addr = (desc & 0xfff00000) | (address & 0x000fffff);
2798         ap = (desc >> 10) & 3;
2799         code = 13;
2800         *page_size = 1024 * 1024;
2801     } else {
2802         /* Lookup l2 entry.  */
2803         if (type == 1) {
2804             /* Coarse pagetable.  */
2805             table = (desc & 0xfffffc00) | ((address >> 10) & 0x3fc);
2806         } else {
2807             /* Fine pagetable.  */
2808             table = (desc & 0xfffff000) | ((address >> 8) & 0xffc);
2809         }
2810         desc = ldl_phys(cs->as, table);
2811         switch (desc & 3) {
2812         case 0: /* Page translation fault.  */
2813             code = 7;
2814             goto do_fault;
2815         case 1: /* 64k page.  */
2816             phys_addr = (desc & 0xffff0000) | (address & 0xffff);
2817             ap = (desc >> (4 + ((address >> 13) & 6))) & 3;
2818             *page_size = 0x10000;
2819             break;
2820         case 2: /* 4k page.  */
2821             phys_addr = (desc & 0xfffff000) | (address & 0xfff);
2822             ap = (desc >> (4 + ((address >> 9) & 6))) & 3;
2823             *page_size = 0x1000;
2824             break;
2825         case 3: /* 1k page.  */
2826             if (type == 1) {
2827                 if (arm_feature(env, ARM_FEATURE_XSCALE)) {
2828                     phys_addr = (desc & 0xfffff000) | (address & 0xfff);
2829                 } else {
2830                     /* Page translation fault.  */
2831                     code = 7;
2832                     goto do_fault;
2833                 }
2834             } else {
2835                 phys_addr = (desc & 0xfffffc00) | (address & 0x3ff);
2836             }
2837             ap = (desc >> 4) & 3;
2838             *page_size = 0x400;
2839             break;
2840         default:
2841             /* Never happens, but compiler isn't smart enough to tell.  */
2842             abort();
2843         }
2844         code = 15;
2845     }
2846     *prot = check_ap(env, ap, domain_prot, access_type, is_user);
2847     if (!*prot) {
2848         /* Access permission fault.  */
2849         goto do_fault;
2850     }
2851     *prot |= PAGE_EXEC;
2852     *phys_ptr = phys_addr;
2853     return 0;
2854 do_fault:
2855     return code | (domain << 4);
2856 }
2857
2858 static int get_phys_addr_v6(CPUARMState *env, uint32_t address, int access_type,
2859                             int is_user, hwaddr *phys_ptr,
2860                             int *prot, target_ulong *page_size)
2861 {
2862     CPUState *cs = ENV_GET_CPU(env);
2863     int code;
2864     uint32_t table;
2865     uint32_t desc;
2866     uint32_t xn;
2867     uint32_t pxn = 0;
2868     int type;
2869     int ap;
2870     int domain = 0;
2871     int domain_prot;
2872     hwaddr phys_addr;
2873
2874     /* Pagetable walk.  */
2875     /* Lookup l1 descriptor.  */
2876     table = get_level1_table_address(env, address);
2877     desc = ldl_phys(cs->as, table);
2878     type = (desc & 3);
2879     if (type == 0 || (type == 3 && !arm_feature(env, ARM_FEATURE_PXN))) {
2880         /* Section translation fault, or attempt to use the encoding
2881          * which is Reserved on implementations without PXN.
2882          */
2883         code = 5;
2884         goto do_fault;
2885     }
2886     if ((type == 1) || !(desc & (1 << 18))) {
2887         /* Page or Section.  */
2888         domain = (desc >> 5) & 0x0f;
2889     }
2890     domain_prot = (env->cp15.c3 >> (domain * 2)) & 3;
2891     if (domain_prot == 0 || domain_prot == 2) {
2892         if (type != 1) {
2893             code = 9; /* Section domain fault.  */
2894         } else {
2895             code = 11; /* Page domain fault.  */
2896         }
2897         goto do_fault;
2898     }
2899     if (type != 1) {
2900         if (desc & (1 << 18)) {
2901             /* Supersection.  */
2902             phys_addr = (desc & 0xff000000) | (address & 0x00ffffff);
2903             *page_size = 0x1000000;
2904         } else {
2905             /* Section.  */
2906             phys_addr = (desc & 0xfff00000) | (address & 0x000fffff);
2907             *page_size = 0x100000;
2908         }
2909         ap = ((desc >> 10) & 3) | ((desc >> 13) & 4);
2910         xn = desc & (1 << 4);
2911         pxn = desc & 1;
2912         code = 13;
2913     } else {
2914         if (arm_feature(env, ARM_FEATURE_PXN)) {
2915             pxn = (desc >> 2) & 1;
2916         }
2917         /* Lookup l2 entry.  */
2918         table = (desc & 0xfffffc00) | ((address >> 10) & 0x3fc);
2919         desc = ldl_phys(cs->as, table);
2920         ap = ((desc >> 4) & 3) | ((desc >> 7) & 4);
2921         switch (desc & 3) {
2922         case 0: /* Page translation fault.  */
2923             code = 7;
2924             goto do_fault;
2925         case 1: /* 64k page.  */
2926             phys_addr = (desc & 0xffff0000) | (address & 0xffff);
2927             xn = desc & (1 << 15);
2928             *page_size = 0x10000;
2929             break;
2930         case 2: case 3: /* 4k page.  */
2931             phys_addr = (desc & 0xfffff000) | (address & 0xfff);
2932             xn = desc & 1;
2933             *page_size = 0x1000;
2934             break;
2935         default:
2936             /* Never happens, but compiler isn't smart enough to tell.  */
2937             abort();
2938         }
2939         code = 15;
2940     }
2941     if (domain_prot == 3) {
2942         *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
2943     } else {
2944         if (pxn && !is_user) {
2945             xn = 1;
2946         }
2947         if (xn && access_type == 2)
2948             goto do_fault;
2949
2950         /* The simplified model uses AP[0] as an access control bit.  */
2951         if ((env->cp15.c1_sys & SCTLR_AFE) && (ap & 1) == 0) {
2952             /* Access flag fault.  */
2953             code = (code == 15) ? 6 : 3;
2954             goto do_fault;
2955         }
2956         *prot = check_ap(env, ap, domain_prot, access_type, is_user);
2957         if (!*prot) {
2958             /* Access permission fault.  */
2959             goto do_fault;
2960         }
2961         if (!xn) {
2962             *prot |= PAGE_EXEC;
2963         }
2964     }
2965     *phys_ptr = phys_addr;
2966     return 0;
2967 do_fault:
2968     return code | (domain << 4);
2969 }
2970
2971 /* Fault type for long-descriptor MMU fault reporting; this corresponds
2972  * to bits [5..2] in the STATUS field in long-format DFSR/IFSR.
2973  */
2974 typedef enum {
2975     translation_fault = 1,
2976     access_fault = 2,
2977     permission_fault = 3,
2978 } MMUFaultType;
2979
2980 static int get_phys_addr_lpae(CPUARMState *env, uint32_t address,
2981                               int access_type, int is_user,
2982                               hwaddr *phys_ptr, int *prot,
2983                               target_ulong *page_size_ptr)
2984 {
2985     CPUState *cs = ENV_GET_CPU(env);
2986     /* Read an LPAE long-descriptor translation table. */
2987     MMUFaultType fault_type = translation_fault;
2988     uint32_t level = 1;
2989     uint32_t epd;
2990     uint32_t tsz;
2991     uint64_t ttbr;
2992     int ttbr_select;
2993     int n;
2994     hwaddr descaddr;
2995     uint32_t tableattrs;
2996     target_ulong page_size;
2997     uint32_t attrs;
2998
2999     /* Determine whether this address is in the region controlled by
3000      * TTBR0 or TTBR1 (or if it is in neither region and should fault).
3001      * This is a Non-secure PL0/1 stage 1 translation, so controlled by
3002      * TTBCR/TTBR0/TTBR1 in accordance with ARM ARM DDI0406C table B-32:
3003      */
3004     uint32_t t0sz = extract32(env->cp15.c2_control, 0, 3);
3005     uint32_t t1sz = extract32(env->cp15.c2_control, 16, 3);
3006     if (t0sz && !extract32(address, 32 - t0sz, t0sz)) {
3007         /* there is a ttbr0 region and we are in it (high bits all zero) */
3008         ttbr_select = 0;
3009     } else if (t1sz && !extract32(~address, 32 - t1sz, t1sz)) {
3010         /* there is a ttbr1 region and we are in it (high bits all one) */
3011         ttbr_select = 1;
3012     } else if (!t0sz) {
3013         /* ttbr0 region is "everything not in the ttbr1 region" */
3014         ttbr_select = 0;
3015     } else if (!t1sz) {
3016         /* ttbr1 region is "everything not in the ttbr0 region" */
3017         ttbr_select = 1;
3018     } else {
3019         /* in the gap between the two regions, this is a Translation fault */
3020         fault_type = translation_fault;
3021         goto do_fault;
3022     }
3023
3024     /* Note that QEMU ignores shareability and cacheability attributes,
3025      * so we don't need to do anything with the SH, ORGN, IRGN fields
3026      * in the TTBCR.  Similarly, TTBCR:A1 selects whether we get the
3027      * ASID from TTBR0 or TTBR1, but QEMU's TLB doesn't currently
3028      * implement any ASID-like capability so we can ignore it (instead
3029      * we will always flush the TLB any time the ASID is changed).
3030      */
3031     if (ttbr_select == 0) {
3032         ttbr = ((uint64_t)env->cp15.c2_base0_hi << 32) | env->cp15.c2_base0;
3033         epd = extract32(env->cp15.c2_control, 7, 1);
3034         tsz = t0sz;
3035     } else {
3036         ttbr = ((uint64_t)env->cp15.c2_base1_hi << 32) | env->cp15.c2_base1;
3037         epd = extract32(env->cp15.c2_control, 23, 1);
3038         tsz = t1sz;
3039     }
3040
3041     if (epd) {
3042         /* Translation table walk disabled => Translation fault on TLB miss */
3043         goto do_fault;
3044     }
3045
3046     /* If the region is small enough we will skip straight to a 2nd level
3047      * lookup. This affects the number of bits of the address used in
3048      * combination with the TTBR to find the first descriptor. ('n' here
3049      * matches the usage in the ARM ARM sB3.6.6, where bits [39..n] are
3050      * from the TTBR, [n-1..3] from the vaddr, and [2..0] always zero).
3051      */
3052     if (tsz > 1) {
3053         level = 2;
3054         n = 14 - tsz;
3055     } else {
3056         n = 5 - tsz;
3057     }
3058
3059     /* Clear the vaddr bits which aren't part of the within-region address,
3060      * so that we don't have to special case things when calculating the
3061      * first descriptor address.
3062      */
3063     address &= (0xffffffffU >> tsz);
3064
3065     /* Now we can extract the actual base address from the TTBR */
3066     descaddr = extract64(ttbr, 0, 40);
3067     descaddr &= ~((1ULL << n) - 1);
3068
3069     tableattrs = 0;
3070     for (;;) {
3071         uint64_t descriptor;
3072
3073         descaddr |= ((address >> (9 * (4 - level))) & 0xff8);
3074         descriptor = ldq_phys(cs->as, descaddr);
3075         if (!(descriptor & 1) ||
3076             (!(descriptor & 2) && (level == 3))) {
3077             /* Invalid, or the Reserved level 3 encoding */
3078             goto do_fault;
3079         }
3080         descaddr = descriptor & 0xfffffff000ULL;
3081
3082         if ((descriptor & 2) && (level < 3)) {
3083             /* Table entry. The top five bits are attributes which  may
3084              * propagate down through lower levels of the table (and
3085              * which are all arranged so that 0 means "no effect", so
3086              * we can gather them up by ORing in the bits at each level).
3087              */
3088             tableattrs |= extract64(descriptor, 59, 5);
3089             level++;
3090             continue;
3091         }
3092         /* Block entry at level 1 or 2, or page entry at level 3.
3093          * These are basically the same thing, although the number
3094          * of bits we pull in from the vaddr varies.
3095          */
3096         page_size = (1 << (39 - (9 * level)));
3097         descaddr |= (address & (page_size - 1));
3098         /* Extract attributes from the descriptor and merge with table attrs */
3099         attrs = extract64(descriptor, 2, 10)
3100             | (extract64(descriptor, 52, 12) << 10);
3101         attrs |= extract32(tableattrs, 0, 2) << 11; /* XN, PXN */
3102         attrs |= extract32(tableattrs, 3, 1) << 5; /* APTable[1] => AP[2] */
3103         /* The sense of AP[1] vs APTable[0] is reversed, as APTable[0] == 1
3104          * means "force PL1 access only", which means forcing AP[1] to 0.
3105          */
3106         if (extract32(tableattrs, 2, 1)) {
3107             attrs &= ~(1 << 4);
3108         }
3109         /* Since we're always in the Non-secure state, NSTable is ignored. */
3110         break;
3111     }
3112     /* Here descaddr is the final physical address, and attributes
3113      * are all in attrs.
3114      */
3115     fault_type = access_fault;
3116     if ((attrs & (1 << 8)) == 0) {
3117         /* Access flag */
3118         goto do_fault;
3119     }
3120     fault_type = permission_fault;
3121     if (is_user && !(attrs & (1 << 4))) {
3122         /* Unprivileged access not enabled */
3123         goto do_fault;
3124     }
3125     *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
3126     if (attrs & (1 << 12) || (!is_user && (attrs & (1 << 11)))) {
3127         /* XN or PXN */
3128         if (access_type == 2) {
3129             goto do_fault;
3130         }
3131         *prot &= ~PAGE_EXEC;
3132     }
3133     if (attrs & (1 << 5)) {
3134         /* Write access forbidden */
3135         if (access_type == 1) {
3136             goto do_fault;
3137         }
3138         *prot &= ~PAGE_WRITE;
3139     }
3140
3141     *phys_ptr = descaddr;
3142     *page_size_ptr = page_size;
3143     return 0;
3144
3145 do_fault:
3146     /* Long-descriptor format IFSR/DFSR value */
3147     return (1 << 9) | (fault_type << 2) | level;
3148 }
3149
3150 static int get_phys_addr_mpu(CPUARMState *env, uint32_t address,
3151                              int access_type, int is_user,
3152                              hwaddr *phys_ptr, int *prot)
3153 {
3154     int n;
3155     uint32_t mask;
3156     uint32_t base;
3157
3158     *phys_ptr = address;
3159     for (n = 7; n >= 0; n--) {
3160         base = env->cp15.c6_region[n];
3161         if ((base & 1) == 0)
3162             continue;
3163         mask = 1 << ((base >> 1) & 0x1f);
3164         /* Keep this shift separate from the above to avoid an
3165            (undefined) << 32.  */
3166         mask = (mask << 1) - 1;
3167         if (((base ^ address) & ~mask) == 0)
3168             break;
3169     }
3170     if (n < 0)
3171         return 2;
3172
3173     if (access_type == 2) {
3174         mask = env->cp15.c5_insn;
3175     } else {
3176         mask = env->cp15.c5_data;
3177     }
3178     mask = (mask >> (n * 4)) & 0xf;
3179     switch (mask) {
3180     case 0:
3181         return 1;
3182     case 1:
3183         if (is_user)
3184           return 1;
3185         *prot = PAGE_READ | PAGE_WRITE;
3186         break;
3187     case 2:
3188         *prot = PAGE_READ;
3189         if (!is_user)
3190             *prot |= PAGE_WRITE;
3191         break;
3192     case 3:
3193         *prot = PAGE_READ | PAGE_WRITE;
3194         break;
3195     case 5:
3196         if (is_user)
3197             return 1;
3198         *prot = PAGE_READ;
3199         break;
3200     case 6:
3201         *prot = PAGE_READ;
3202         break;
3203     default:
3204         /* Bad permission.  */
3205         return 1;
3206     }
3207     *prot |= PAGE_EXEC;
3208     return 0;
3209 }
3210
3211 /* get_phys_addr - get the physical address for this virtual address
3212  *
3213  * Find the physical address corresponding to the given virtual address,
3214  * by doing a translation table walk on MMU based systems or using the
3215  * MPU state on MPU based systems.
3216  *
3217  * Returns 0 if the translation was successful. Otherwise, phys_ptr,
3218  * prot and page_size are not filled in, and the return value provides
3219  * information on why the translation aborted, in the format of a
3220  * DFSR/IFSR fault register, with the following caveats:
3221  *  * we honour the short vs long DFSR format differences.
3222  *  * the WnR bit is never set (the caller must do this).
3223  *  * for MPU based systems we don't bother to return a full FSR format
3224  *    value.
3225  *
3226  * @env: CPUARMState
3227  * @address: virtual address to get physical address for
3228  * @access_type: 0 for read, 1 for write, 2 for execute
3229  * @is_user: 0 for privileged access, 1 for user
3230  * @phys_ptr: set to the physical address corresponding to the virtual address
3231  * @prot: set to the permissions for the page containing phys_ptr
3232  * @page_size: set to the size of the page containing phys_ptr
3233  */
3234 static inline int get_phys_addr(CPUARMState *env, uint32_t address,
3235                                 int access_type, int is_user,
3236                                 hwaddr *phys_ptr, int *prot,
3237                                 target_ulong *page_size)
3238 {
3239     /* Fast Context Switch Extension.  */
3240     if (address < 0x02000000)
3241         address += env->cp15.c13_fcse;
3242
3243     if ((env->cp15.c1_sys & SCTLR_M) == 0) {
3244         /* MMU/MPU disabled.  */
3245         *phys_ptr = address;
3246         *prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
3247         *page_size = TARGET_PAGE_SIZE;
3248         return 0;
3249     } else if (arm_feature(env, ARM_FEATURE_MPU)) {
3250         *page_size = TARGET_PAGE_SIZE;
3251         return get_phys_addr_mpu(env, address, access_type, is_user, phys_ptr,
3252                                  prot);
3253     } else if (extended_addresses_enabled(env)) {
3254         return get_phys_addr_lpae(env, address, access_type, is_user, phys_ptr,
3255                                   prot, page_size);
3256     } else if (env->cp15.c1_sys & SCTLR_XP) {
3257         return get_phys_addr_v6(env, address, access_type, is_user, phys_ptr,
3258                                 prot, page_size);
3259     } else {
3260         return get_phys_addr_v5(env, address, access_type, is_user, phys_ptr,
3261                                 prot, page_size);
3262     }
3263 }
3264
3265 int cpu_arm_handle_mmu_fault (CPUARMState *env, target_ulong address,
3266                               int access_type, int mmu_idx)
3267 {
3268     hwaddr phys_addr;
3269     target_ulong page_size;
3270     int prot;
3271     int ret, is_user;
3272
3273     is_user = mmu_idx == MMU_USER_IDX;
3274     ret = get_phys_addr(env, address, access_type, is_user, &phys_addr, &prot,
3275                         &page_size);
3276     if (ret == 0) {
3277         /* Map a single [sub]page.  */
3278         phys_addr &= ~(hwaddr)0x3ff;
3279         address &= ~(uint32_t)0x3ff;
3280         tlb_set_page (env, address, phys_addr, prot, mmu_idx, page_size);
3281         return 0;
3282     }
3283
3284     if (access_type == 2) {
3285         env->cp15.c5_insn = ret;
3286         env->cp15.c6_insn = address;
3287         env->exception_index = EXCP_PREFETCH_ABORT;
3288     } else {
3289         env->cp15.c5_data = ret;
3290         if (access_type == 1 && arm_feature(env, ARM_FEATURE_V6))
3291             env->cp15.c5_data |= (1 << 11);
3292         env->cp15.c6_data = address;
3293         env->exception_index = EXCP_DATA_ABORT;
3294     }
3295     return 1;
3296 }
3297
3298 hwaddr arm_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
3299 {
3300     ARMCPU *cpu = ARM_CPU(cs);
3301     hwaddr phys_addr;
3302     target_ulong page_size;
3303     int prot;
3304     int ret;
3305
3306     ret = get_phys_addr(&cpu->env, addr, 0, 0, &phys_addr, &prot, &page_size);
3307
3308     if (ret != 0) {
3309         return -1;
3310     }
3311
3312     return phys_addr;
3313 }
3314
3315 void HELPER(set_r13_banked)(CPUARMState *env, uint32_t mode, uint32_t val)
3316 {
3317     if ((env->uncached_cpsr & CPSR_M) == mode) {
3318         env->regs[13] = val;
3319     } else {
3320         env->banked_r13[bank_number(mode)] = val;
3321     }
3322 }
3323
3324 uint32_t HELPER(get_r13_banked)(CPUARMState *env, uint32_t mode)
3325 {
3326     if ((env->uncached_cpsr & CPSR_M) == mode) {
3327         return env->regs[13];
3328     } else {
3329         return env->banked_r13[bank_number(mode)];
3330     }
3331 }
3332
3333 uint32_t HELPER(v7m_mrs)(CPUARMState *env, uint32_t reg)
3334 {
3335     switch (reg) {
3336     case 0: /* APSR */
3337         return xpsr_read(env) & 0xf8000000;
3338     case 1: /* IAPSR */
3339         return xpsr_read(env) & 0xf80001ff;
3340     case 2: /* EAPSR */
3341         return xpsr_read(env) & 0xff00fc00;
3342     case 3: /* xPSR */
3343         return xpsr_read(env) & 0xff00fdff;
3344     case 5: /* IPSR */
3345         return xpsr_read(env) & 0x000001ff;
3346     case 6: /* EPSR */
3347         return xpsr_read(env) & 0x0700fc00;
3348     case 7: /* IEPSR */
3349         return xpsr_read(env) & 0x0700edff;
3350     case 8: /* MSP */
3351         return env->v7m.current_sp ? env->v7m.other_sp : env->regs[13];
3352     case 9: /* PSP */
3353         return env->v7m.current_sp ? env->regs[13] : env->v7m.other_sp;
3354     case 16: /* PRIMASK */
3355         return (env->uncached_cpsr & CPSR_I) != 0;
3356     case 17: /* BASEPRI */
3357     case 18: /* BASEPRI_MAX */
3358         return env->v7m.basepri;
3359     case 19: /* FAULTMASK */
3360         return (env->uncached_cpsr & CPSR_F) != 0;
3361     case 20: /* CONTROL */
3362         return env->v7m.control;
3363     default:
3364         /* ??? For debugging only.  */
3365         cpu_abort(env, "Unimplemented system register read (%d)\n", reg);
3366         return 0;
3367     }
3368 }
3369
3370 void HELPER(v7m_msr)(CPUARMState *env, uint32_t reg, uint32_t val)
3371 {
3372     switch (reg) {
3373     case 0: /* APSR */
3374         xpsr_write(env, val, 0xf8000000);
3375         break;
3376     case 1: /* IAPSR */
3377         xpsr_write(env, val, 0xf8000000);
3378         break;
3379     case 2: /* EAPSR */
3380         xpsr_write(env, val, 0xfe00fc00);
3381         break;
3382     case 3: /* xPSR */
3383         xpsr_write(env, val, 0xfe00fc00);
3384         break;
3385     case 5: /* IPSR */
3386         /* IPSR bits are readonly.  */
3387         break;
3388     case 6: /* EPSR */
3389         xpsr_write(env, val, 0x0600fc00);
3390         break;
3391     case 7: /* IEPSR */
3392         xpsr_write(env, val, 0x0600fc00);
3393         break;
3394     case 8: /* MSP */
3395         if (env->v7m.current_sp)
3396             env->v7m.other_sp = val;
3397         else
3398             env->regs[13] = val;
3399         break;
3400     case 9: /* PSP */
3401         if (env->v7m.current_sp)
3402             env->regs[13] = val;
3403         else
3404             env->v7m.other_sp = val;
3405         break;
3406     case 16: /* PRIMASK */
3407         if (val & 1)
3408             env->uncached_cpsr |= CPSR_I;
3409         else
3410             env->uncached_cpsr &= ~CPSR_I;
3411         break;
3412     case 17: /* BASEPRI */
3413         env->v7m.basepri = val & 0xff;
3414         break;
3415     case 18: /* BASEPRI_MAX */
3416         val &= 0xff;
3417         if (val != 0 && (val < env->v7m.basepri || env->v7m.basepri == 0))
3418             env->v7m.basepri = val;
3419         break;
3420     case 19: /* FAULTMASK */
3421         if (val & 1)
3422             env->uncached_cpsr |= CPSR_F;
3423         else
3424             env->uncached_cpsr &= ~CPSR_F;
3425         break;
3426     case 20: /* CONTROL */
3427         env->v7m.control = val & 3;
3428         switch_v7m_sp(env, (val & 2) != 0);
3429         break;
3430     default:
3431         /* ??? For debugging only.  */
3432         cpu_abort(env, "Unimplemented system register write (%d)\n", reg);
3433         return;
3434     }
3435 }
3436
3437 #endif
3438
3439 /* Note that signed overflow is undefined in C.  The following routines are
3440    careful to use unsigned types where modulo arithmetic is required.
3441    Failure to do so _will_ break on newer gcc.  */
3442
3443 /* Signed saturating arithmetic.  */
3444
3445 /* Perform 16-bit signed saturating addition.  */
3446 static inline uint16_t add16_sat(uint16_t a, uint16_t b)
3447 {
3448     uint16_t res;
3449
3450     res = a + b;
3451     if (((res ^ a) & 0x8000) && !((a ^ b) & 0x8000)) {
3452         if (a & 0x8000)
3453             res = 0x8000;
3454         else
3455             res = 0x7fff;
3456     }
3457     return res;
3458 }
3459
3460 /* Perform 8-bit signed saturating addition.  */
3461 static inline uint8_t add8_sat(uint8_t a, uint8_t b)
3462 {
3463     uint8_t res;
3464
3465     res = a + b;
3466     if (((res ^ a) & 0x80) && !((a ^ b) & 0x80)) {
3467         if (a & 0x80)
3468             res = 0x80;
3469         else
3470             res = 0x7f;
3471     }
3472     return res;
3473 }
3474
3475 /* Perform 16-bit signed saturating subtraction.  */
3476 static inline uint16_t sub16_sat(uint16_t a, uint16_t b)
3477 {
3478     uint16_t res;
3479
3480     res = a - b;
3481     if (((res ^ a) & 0x8000) && ((a ^ b) & 0x8000)) {
3482         if (a & 0x8000)
3483             res = 0x8000;
3484         else
3485             res = 0x7fff;
3486     }
3487     return res;
3488 }
3489
3490 /* Perform 8-bit signed saturating subtraction.  */
3491 static inline uint8_t sub8_sat(uint8_t a, uint8_t b)
3492 {
3493     uint8_t res;
3494
3495     res = a - b;
3496     if (((res ^ a) & 0x80) && ((a ^ b) & 0x80)) {
3497         if (a & 0x80)
3498             res = 0x80;
3499         else
3500             res = 0x7f;
3501     }
3502     return res;
3503 }
3504
3505 #define ADD16(a, b, n) RESULT(add16_sat(a, b), n, 16);
3506 #define SUB16(a, b, n) RESULT(sub16_sat(a, b), n, 16);
3507 #define ADD8(a, b, n)  RESULT(add8_sat(a, b), n, 8);
3508 #define SUB8(a, b, n)  RESULT(sub8_sat(a, b), n, 8);
3509 #define PFX q
3510
3511 #include "op_addsub.h"
3512
3513 /* Unsigned saturating arithmetic.  */
3514 static inline uint16_t add16_usat(uint16_t a, uint16_t b)
3515 {
3516     uint16_t res;
3517     res = a + b;
3518     if (res < a)
3519         res = 0xffff;
3520     return res;
3521 }
3522
3523 static inline uint16_t sub16_usat(uint16_t a, uint16_t b)
3524 {
3525     if (a > b)
3526         return a - b;
3527     else
3528         return 0;
3529 }
3530
3531 static inline uint8_t add8_usat(uint8_t a, uint8_t b)
3532 {
3533     uint8_t res;
3534     res = a + b;
3535     if (res < a)
3536         res = 0xff;
3537     return res;
3538 }
3539
3540 static inline uint8_t sub8_usat(uint8_t a, uint8_t b)
3541 {
3542     if (a > b)
3543         return a - b;
3544     else
3545         return 0;
3546 }
3547
3548 #define ADD16(a, b, n) RESULT(add16_usat(a, b), n, 16);
3549 #define SUB16(a, b, n) RESULT(sub16_usat(a, b), n, 16);
3550 #define ADD8(a, b, n)  RESULT(add8_usat(a, b), n, 8);
3551 #define SUB8(a, b, n)  RESULT(sub8_usat(a, b), n, 8);
3552 #define PFX uq
3553
3554 #include "op_addsub.h"
3555
3556 /* Signed modulo arithmetic.  */
3557 #define SARITH16(a, b, n, op) do { \
3558     int32_t sum; \
3559     sum = (int32_t)(int16_t)(a) op (int32_t)(int16_t)(b); \
3560     RESULT(sum, n, 16); \
3561     if (sum >= 0) \
3562         ge |= 3 << (n * 2); \
3563     } while(0)
3564
3565 #define SARITH8(a, b, n, op) do { \
3566     int32_t sum; \
3567     sum = (int32_t)(int8_t)(a) op (int32_t)(int8_t)(b); \
3568     RESULT(sum, n, 8); \
3569     if (sum >= 0) \
3570         ge |= 1 << n; \
3571     } while(0)
3572
3573
3574 #define ADD16(a, b, n) SARITH16(a, b, n, +)
3575 #define SUB16(a, b, n) SARITH16(a, b, n, -)
3576 #define ADD8(a, b, n)  SARITH8(a, b, n, +)
3577 #define SUB8(a, b, n)  SARITH8(a, b, n, -)
3578 #define PFX s
3579 #define ARITH_GE
3580
3581 #include "op_addsub.h"
3582
3583 /* Unsigned modulo arithmetic.  */
3584 #define ADD16(a, b, n) do { \
3585     uint32_t sum; \
3586     sum = (uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b); \
3587     RESULT(sum, n, 16); \
3588     if ((sum >> 16) == 1) \
3589         ge |= 3 << (n * 2); \
3590     } while(0)
3591
3592 #define ADD8(a, b, n) do { \
3593     uint32_t sum; \
3594     sum = (uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b); \
3595     RESULT(sum, n, 8); \
3596     if ((sum >> 8) == 1) \
3597         ge |= 1 << n; \
3598     } while(0)
3599
3600 #define SUB16(a, b, n) do { \
3601     uint32_t sum; \
3602     sum = (uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b); \
3603     RESULT(sum, n, 16); \
3604     if ((sum >> 16) == 0) \
3605         ge |= 3 << (n * 2); \
3606     } while(0)
3607
3608 #define SUB8(a, b, n) do { \
3609     uint32_t sum; \
3610     sum = (uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b); \
3611     RESULT(sum, n, 8); \
3612     if ((sum >> 8) == 0) \
3613         ge |= 1 << n; \
3614     } while(0)
3615
3616 #define PFX u
3617 #define ARITH_GE
3618
3619 #include "op_addsub.h"
3620
3621 /* Halved signed arithmetic.  */
3622 #define ADD16(a, b, n) \
3623   RESULT(((int32_t)(int16_t)(a) + (int32_t)(int16_t)(b)) >> 1, n, 16)
3624 #define SUB16(a, b, n) \
3625   RESULT(((int32_t)(int16_t)(a) - (int32_t)(int16_t)(b)) >> 1, n, 16)
3626 #define ADD8(a, b, n) \
3627   RESULT(((int32_t)(int8_t)(a) + (int32_t)(int8_t)(b)) >> 1, n, 8)
3628 #define SUB8(a, b, n) \
3629   RESULT(((int32_t)(int8_t)(a) - (int32_t)(int8_t)(b)) >> 1, n, 8)
3630 #define PFX sh
3631
3632 #include "op_addsub.h"
3633
3634 /* Halved unsigned arithmetic.  */
3635 #define ADD16(a, b, n) \
3636   RESULT(((uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b)) >> 1, n, 16)
3637 #define SUB16(a, b, n) \
3638   RESULT(((uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b)) >> 1, n, 16)
3639 #define ADD8(a, b, n) \
3640   RESULT(((uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b)) >> 1, n, 8)
3641 #define SUB8(a, b, n) \
3642   RESULT(((uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b)) >> 1, n, 8)
3643 #define PFX uh
3644
3645 #include "op_addsub.h"
3646
3647 static inline uint8_t do_usad(uint8_t a, uint8_t b)
3648 {
3649     if (a > b)
3650         return a - b;
3651     else
3652         return b - a;
3653 }
3654
3655 /* Unsigned sum of absolute byte differences.  */
3656 uint32_t HELPER(usad8)(uint32_t a, uint32_t b)
3657 {
3658     uint32_t sum;
3659     sum = do_usad(a, b);
3660     sum += do_usad(a >> 8, b >> 8);
3661     sum += do_usad(a >> 16, b >>16);
3662     sum += do_usad(a >> 24, b >> 24);
3663     return sum;
3664 }
3665
3666 /* For ARMv6 SEL instruction.  */
3667 uint32_t HELPER(sel_flags)(uint32_t flags, uint32_t a, uint32_t b)
3668 {
3669     uint32_t mask;
3670
3671     mask = 0;
3672     if (flags & 1)
3673         mask |= 0xff;
3674     if (flags & 2)
3675         mask |= 0xff00;
3676     if (flags & 4)
3677         mask |= 0xff0000;
3678     if (flags & 8)
3679         mask |= 0xff000000;
3680     return (a & mask) | (b & ~mask);
3681 }
3682
3683 /* VFP support.  We follow the convention used for VFP instructions:
3684    Single precision routines have a "s" suffix, double precision a
3685    "d" suffix.  */
3686
3687 /* Convert host exception flags to vfp form.  */
3688 static inline int vfp_exceptbits_from_host(int host_bits)
3689 {
3690     int target_bits = 0;
3691
3692     if (host_bits & float_flag_invalid)
3693         target_bits |= 1;
3694     if (host_bits & float_flag_divbyzero)
3695         target_bits |= 2;
3696     if (host_bits & float_flag_overflow)
3697         target_bits |= 4;
3698     if (host_bits & (float_flag_underflow | float_flag_output_denormal))
3699         target_bits |= 8;
3700     if (host_bits & float_flag_inexact)
3701         target_bits |= 0x10;
3702     if (host_bits & float_flag_input_denormal)
3703         target_bits |= 0x80;
3704     return target_bits;
3705 }
3706
3707 uint32_t HELPER(vfp_get_fpscr)(CPUARMState *env)
3708 {
3709     int i;
3710     uint32_t fpscr;
3711
3712     fpscr = (env->vfp.xregs[ARM_VFP_FPSCR] & 0xffc8ffff)
3713             | (env->vfp.vec_len << 16)
3714             | (env->vfp.vec_stride << 20);
3715     i = get_float_exception_flags(&env->vfp.fp_status);
3716     i |= get_float_exception_flags(&env->vfp.standard_fp_status);
3717     fpscr |= vfp_exceptbits_from_host(i);
3718     return fpscr;
3719 }
3720
3721 uint32_t vfp_get_fpscr(CPUARMState *env)
3722 {
3723     return HELPER(vfp_get_fpscr)(env);
3724 }
3725
3726 /* Convert vfp exception flags to target form.  */
3727 static inline int vfp_exceptbits_to_host(int target_bits)
3728 {
3729     int host_bits = 0;
3730
3731     if (target_bits & 1)
3732         host_bits |= float_flag_invalid;
3733     if (target_bits & 2)
3734         host_bits |= float_flag_divbyzero;
3735     if (target_bits & 4)
3736         host_bits |= float_flag_overflow;
3737     if (target_bits & 8)
3738         host_bits |= float_flag_underflow;
3739     if (target_bits & 0x10)
3740         host_bits |= float_flag_inexact;
3741     if (target_bits & 0x80)
3742         host_bits |= float_flag_input_denormal;
3743     return host_bits;
3744 }
3745
3746 void HELPER(vfp_set_fpscr)(CPUARMState *env, uint32_t val)
3747 {
3748     int i;
3749     uint32_t changed;
3750
3751     changed = env->vfp.xregs[ARM_VFP_FPSCR];
3752     env->vfp.xregs[ARM_VFP_FPSCR] = (val & 0xffc8ffff);
3753     env->vfp.vec_len = (val >> 16) & 7;
3754     env->vfp.vec_stride = (val >> 20) & 3;
3755
3756     changed ^= val;
3757     if (changed & (3 << 22)) {
3758         i = (val >> 22) & 3;
3759         switch (i) {
3760         case FPROUNDING_TIEEVEN:
3761             i = float_round_nearest_even;
3762             break;
3763         case FPROUNDING_POSINF:
3764             i = float_round_up;
3765             break;
3766         case FPROUNDING_NEGINF:
3767             i = float_round_down;
3768             break;
3769         case FPROUNDING_ZERO:
3770             i = float_round_to_zero;
3771             break;
3772         }
3773         set_float_rounding_mode(i, &env->vfp.fp_status);
3774     }
3775     if (changed & (1 << 24)) {
3776         set_flush_to_zero((val & (1 << 24)) != 0, &env->vfp.fp_status);
3777         set_flush_inputs_to_zero((val & (1 << 24)) != 0, &env->vfp.fp_status);
3778     }
3779     if (changed & (1 << 25))
3780         set_default_nan_mode((val & (1 << 25)) != 0, &env->vfp.fp_status);
3781
3782     i = vfp_exceptbits_to_host(val);
3783     set_float_exception_flags(i, &env->vfp.fp_status);
3784     set_float_exception_flags(0, &env->vfp.standard_fp_status);
3785 }
3786
3787 void vfp_set_fpscr(CPUARMState *env, uint32_t val)
3788 {
3789     HELPER(vfp_set_fpscr)(env, val);
3790 }
3791
3792 #define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
3793
3794 #define VFP_BINOP(name) \
3795 float32 VFP_HELPER(name, s)(float32 a, float32 b, void *fpstp) \
3796 { \
3797     float_status *fpst = fpstp; \
3798     return float32_ ## name(a, b, fpst); \
3799 } \
3800 float64 VFP_HELPER(name, d)(float64 a, float64 b, void *fpstp) \
3801 { \
3802     float_status *fpst = fpstp; \
3803     return float64_ ## name(a, b, fpst); \
3804 }
3805 VFP_BINOP(add)
3806 VFP_BINOP(sub)
3807 VFP_BINOP(mul)
3808 VFP_BINOP(div)
3809 VFP_BINOP(min)
3810 VFP_BINOP(max)
3811 VFP_BINOP(minnum)
3812 VFP_BINOP(maxnum)
3813 #undef VFP_BINOP
3814
3815 float32 VFP_HELPER(neg, s)(float32 a)
3816 {
3817     return float32_chs(a);
3818 }
3819
3820 float64 VFP_HELPER(neg, d)(float64 a)
3821 {
3822     return float64_chs(a);
3823 }
3824
3825 float32 VFP_HELPER(abs, s)(float32 a)
3826 {
3827     return float32_abs(a);
3828 }
3829
3830 float64 VFP_HELPER(abs, d)(float64 a)
3831 {
3832     return float64_abs(a);
3833 }
3834
3835 float32 VFP_HELPER(sqrt, s)(float32 a, CPUARMState *env)
3836 {
3837     return float32_sqrt(a, &env->vfp.fp_status);
3838 }
3839
3840 float64 VFP_HELPER(sqrt, d)(float64 a, CPUARMState *env)
3841 {
3842     return float64_sqrt(a, &env->vfp.fp_status);
3843 }
3844
3845 /* XXX: check quiet/signaling case */
3846 #define DO_VFP_cmp(p, type) \
3847 void VFP_HELPER(cmp, p)(type a, type b, CPUARMState *env)  \
3848 { \
3849     uint32_t flags; \
3850     switch(type ## _compare_quiet(a, b, &env->vfp.fp_status)) { \
3851     case 0: flags = 0x6; break; \
3852     case -1: flags = 0x8; break; \
3853     case 1: flags = 0x2; break; \
3854     default: case 2: flags = 0x3; break; \
3855     } \
3856     env->vfp.xregs[ARM_VFP_FPSCR] = (flags << 28) \
3857         | (env->vfp.xregs[ARM_VFP_FPSCR] & 0x0fffffff); \
3858 } \
3859 void VFP_HELPER(cmpe, p)(type a, type b, CPUARMState *env) \
3860 { \
3861     uint32_t flags; \
3862     switch(type ## _compare(a, b, &env->vfp.fp_status)) { \
3863     case 0: flags = 0x6; break; \
3864     case -1: flags = 0x8; break; \
3865     case 1: flags = 0x2; break; \
3866     default: case 2: flags = 0x3; break; \
3867     } \
3868     env->vfp.xregs[ARM_VFP_FPSCR] = (flags << 28) \
3869         | (env->vfp.xregs[ARM_VFP_FPSCR] & 0x0fffffff); \
3870 }
3871 DO_VFP_cmp(s, float32)
3872 DO_VFP_cmp(d, float64)
3873 #undef DO_VFP_cmp
3874
3875 /* Integer to float and float to integer conversions */
3876
3877 #define CONV_ITOF(name, fsz, sign) \
3878     float##fsz HELPER(name)(uint32_t x, void *fpstp) \
3879 { \
3880     float_status *fpst = fpstp; \
3881     return sign##int32_to_##float##fsz((sign##int32_t)x, fpst); \
3882 }
3883
3884 #define CONV_FTOI(name, fsz, sign, round) \
3885 uint32_t HELPER(name)(float##fsz x, void *fpstp) \
3886 { \
3887     float_status *fpst = fpstp; \
3888     if (float##fsz##_is_any_nan(x)) { \
3889         float_raise(float_flag_invalid, fpst); \
3890         return 0; \
3891     } \
3892     return float##fsz##_to_##sign##int32##round(x, fpst); \
3893 }
3894
3895 #define FLOAT_CONVS(name, p, fsz, sign) \
3896 CONV_ITOF(vfp_##name##to##p, fsz, sign) \
3897 CONV_FTOI(vfp_to##name##p, fsz, sign, ) \
3898 CONV_FTOI(vfp_to##name##z##p, fsz, sign, _round_to_zero)
3899
3900 FLOAT_CONVS(si, s, 32, )
3901 FLOAT_CONVS(si, d, 64, )
3902 FLOAT_CONVS(ui, s, 32, u)
3903 FLOAT_CONVS(ui, d, 64, u)
3904
3905 #undef CONV_ITOF
3906 #undef CONV_FTOI
3907 #undef FLOAT_CONVS
3908
3909 /* floating point conversion */
3910 float64 VFP_HELPER(fcvtd, s)(float32 x, CPUARMState *env)
3911 {
3912     float64 r = float32_to_float64(x, &env->vfp.fp_status);
3913     /* ARM requires that S<->D conversion of any kind of NaN generates
3914      * a quiet NaN by forcing the most significant frac bit to 1.
3915      */
3916     return float64_maybe_silence_nan(r);
3917 }
3918
3919 float32 VFP_HELPER(fcvts, d)(float64 x, CPUARMState *env)
3920 {
3921     float32 r =  float64_to_float32(x, &env->vfp.fp_status);
3922     /* ARM requires that S<->D conversion of any kind of NaN generates
3923      * a quiet NaN by forcing the most significant frac bit to 1.
3924      */
3925     return float32_maybe_silence_nan(r);
3926 }
3927
3928 /* VFP3 fixed point conversion.  */
3929 #define VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype) \
3930 float##fsz HELPER(vfp_##name##to##p)(uint##isz##_t  x, uint32_t shift, \
3931                                      void *fpstp) \
3932 { \
3933     float_status *fpst = fpstp; \
3934     float##fsz tmp; \
3935     tmp = itype##_to_##float##fsz(x, fpst); \
3936     return float##fsz##_scalbn(tmp, -(int)shift, fpst); \
3937 }
3938
3939 /* Notice that we want only input-denormal exception flags from the
3940  * scalbn operation: the other possible flags (overflow+inexact if
3941  * we overflow to infinity, output-denormal) aren't correct for the
3942  * complete scale-and-convert operation.
3943  */
3944 #define VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, round) \
3945 uint##isz##_t HELPER(vfp_to##name##p##round)(float##fsz x, \
3946                                              uint32_t shift, \
3947                                              void *fpstp) \
3948 { \
3949     float_status *fpst = fpstp; \
3950     int old_exc_flags = get_float_exception_flags(fpst); \
3951     float##fsz tmp; \
3952     if (float##fsz##_is_any_nan(x)) { \
3953         float_raise(float_flag_invalid, fpst); \
3954         return 0; \
3955     } \
3956     tmp = float##fsz##_scalbn(x, shift, fpst); \
3957     old_exc_flags |= get_float_exception_flags(fpst) \
3958         & float_flag_input_denormal; \
3959     set_float_exception_flags(old_exc_flags, fpst); \
3960     return float##fsz##_to_##itype##round(tmp, fpst); \
3961 }
3962
3963 #define VFP_CONV_FIX(name, p, fsz, isz, itype)                   \
3964 VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
3965 VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, _round_to_zero) \
3966 VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, )
3967
3968 #define VFP_CONV_FIX_A64(name, p, fsz, isz, itype)               \
3969 VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
3970 VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, )
3971
3972 VFP_CONV_FIX(sh, d, 64, 64, int16)
3973 VFP_CONV_FIX(sl, d, 64, 64, int32)
3974 VFP_CONV_FIX_A64(sq, d, 64, 64, int64)
3975 VFP_CONV_FIX(uh, d, 64, 64, uint16)
3976 VFP_CONV_FIX(ul, d, 64, 64, uint32)
3977 VFP_CONV_FIX_A64(uq, d, 64, 64, uint64)
3978 VFP_CONV_FIX(sh, s, 32, 32, int16)
3979 VFP_CONV_FIX(sl, s, 32, 32, int32)
3980 VFP_CONV_FIX_A64(sq, s, 32, 64, int64)
3981 VFP_CONV_FIX(uh, s, 32, 32, uint16)
3982 VFP_CONV_FIX(ul, s, 32, 32, uint32)
3983 VFP_CONV_FIX_A64(uq, s, 32, 64, uint64)
3984 #undef VFP_CONV_FIX
3985 #undef VFP_CONV_FIX_FLOAT
3986 #undef VFP_CONV_FLOAT_FIX_ROUND
3987
3988 /* Set the current fp rounding mode and return the old one.
3989  * The argument is a softfloat float_round_ value.
3990  */
3991 uint32_t HELPER(set_rmode)(uint32_t rmode, CPUARMState *env)
3992 {
3993     float_status *fp_status = &env->vfp.fp_status;
3994
3995     uint32_t prev_rmode = get_float_rounding_mode(fp_status);
3996     set_float_rounding_mode(rmode, fp_status);
3997
3998     return prev_rmode;
3999 }
4000
4001 /* Set the current fp rounding mode in the standard fp status and return
4002  * the old one. This is for NEON instructions that need to change the
4003  * rounding mode but wish to use the standard FPSCR values for everything
4004  * else. Always set the rounding mode back to the correct value after
4005  * modifying it.
4006  * The argument is a softfloat float_round_ value.
4007  */
4008 uint32_t HELPER(set_neon_rmode)(uint32_t rmode, CPUARMState *env)
4009 {
4010     float_status *fp_status = &env->vfp.standard_fp_status;
4011
4012     uint32_t prev_rmode = get_float_rounding_mode(fp_status);
4013     set_float_rounding_mode(rmode, fp_status);
4014
4015     return prev_rmode;
4016 }
4017
4018 /* Half precision conversions.  */
4019 static float32 do_fcvt_f16_to_f32(uint32_t a, CPUARMState *env, float_status *s)
4020 {
4021     int ieee = (env->vfp.xregs[ARM_VFP_FPSCR] & (1 << 26)) == 0;
4022     float32 r = float16_to_float32(make_float16(a), ieee, s);
4023     if (ieee) {
4024         return float32_maybe_silence_nan(r);
4025     }
4026     return r;
4027 }
4028
4029 static uint32_t do_fcvt_f32_to_f16(float32 a, CPUARMState *env, float_status *s)
4030 {
4031     int ieee = (env->vfp.xregs[ARM_VFP_FPSCR] & (1 << 26)) == 0;
4032     float16 r = float32_to_float16(a, ieee, s);
4033     if (ieee) {
4034         r = float16_maybe_silence_nan(r);
4035     }
4036     return float16_val(r);
4037 }
4038
4039 float32 HELPER(neon_fcvt_f16_to_f32)(uint32_t a, CPUARMState *env)
4040 {
4041     return do_fcvt_f16_to_f32(a, env, &env->vfp.standard_fp_status);
4042 }
4043
4044 uint32_t HELPER(neon_fcvt_f32_to_f16)(float32 a, CPUARMState *env)
4045 {
4046     return do_fcvt_f32_to_f16(a, env, &env->vfp.standard_fp_status);
4047 }
4048
4049 float32 HELPER(vfp_fcvt_f16_to_f32)(uint32_t a, CPUARMState *env)
4050 {
4051     return do_fcvt_f16_to_f32(a, env, &env->vfp.fp_status);
4052 }
4053
4054 uint32_t HELPER(vfp_fcvt_f32_to_f16)(float32 a, CPUARMState *env)
4055 {
4056     return do_fcvt_f32_to_f16(a, env, &env->vfp.fp_status);
4057 }
4058
4059 float64 HELPER(vfp_fcvt_f16_to_f64)(uint32_t a, CPUARMState *env)
4060 {
4061     int ieee = (env->vfp.xregs[ARM_VFP_FPSCR] & (1 << 26)) == 0;
4062     float64 r = float16_to_float64(make_float16(a), ieee, &env->vfp.fp_status);
4063     if (ieee) {
4064         return float64_maybe_silence_nan(r);
4065     }
4066     return r;
4067 }
4068
4069 uint32_t HELPER(vfp_fcvt_f64_to_f16)(float64 a, CPUARMState *env)
4070 {
4071     int ieee = (env->vfp.xregs[ARM_VFP_FPSCR] & (1 << 26)) == 0;
4072     float16 r = float64_to_float16(a, ieee, &env->vfp.fp_status);
4073     if (ieee) {
4074         r = float16_maybe_silence_nan(r);
4075     }
4076     return float16_val(r);
4077 }
4078
4079 #define float32_two make_float32(0x40000000)
4080 #define float32_three make_float32(0x40400000)
4081 #define float32_one_point_five make_float32(0x3fc00000)
4082
4083 float32 HELPER(recps_f32)(float32 a, float32 b, CPUARMState *env)
4084 {
4085     float_status *s = &env->vfp.standard_fp_status;
4086     if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
4087         (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
4088         if (!(float32_is_zero(a) || float32_is_zero(b))) {
4089             float_raise(float_flag_input_denormal, s);
4090         }
4091         return float32_two;
4092     }
4093     return float32_sub(float32_two, float32_mul(a, b, s), s);
4094 }
4095
4096 float32 HELPER(rsqrts_f32)(float32 a, float32 b, CPUARMState *env)
4097 {
4098     float_status *s = &env->vfp.standard_fp_status;
4099     float32 product;
4100     if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
4101         (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
4102         if (!(float32_is_zero(a) || float32_is_zero(b))) {
4103             float_raise(float_flag_input_denormal, s);
4104         }
4105         return float32_one_point_five;
4106     }
4107     product = float32_mul(a, b, s);
4108     return float32_div(float32_sub(float32_three, product, s), float32_two, s);
4109 }
4110
4111 /* NEON helpers.  */
4112
4113 /* Constants 256 and 512 are used in some helpers; we avoid relying on
4114  * int->float conversions at run-time.  */
4115 #define float64_256 make_float64(0x4070000000000000LL)
4116 #define float64_512 make_float64(0x4080000000000000LL)
4117
4118 /* The algorithm that must be used to calculate the estimate
4119  * is specified by the ARM ARM.
4120  */
4121 static float64 recip_estimate(float64 a, CPUARMState *env)
4122 {
4123     /* These calculations mustn't set any fp exception flags,
4124      * so we use a local copy of the fp_status.
4125      */
4126     float_status dummy_status = env->vfp.standard_fp_status;
4127     float_status *s = &dummy_status;
4128     /* q = (int)(a * 512.0) */
4129     float64 q = float64_mul(float64_512, a, s);
4130     int64_t q_int = float64_to_int64_round_to_zero(q, s);
4131
4132     /* r = 1.0 / (((double)q + 0.5) / 512.0) */
4133     q = int64_to_float64(q_int, s);
4134     q = float64_add(q, float64_half, s);
4135     q = float64_div(q, float64_512, s);
4136     q = float64_div(float64_one, q, s);
4137
4138     /* s = (int)(256.0 * r + 0.5) */
4139     q = float64_mul(q, float64_256, s);
4140     q = float64_add(q, float64_half, s);
4141     q_int = float64_to_int64_round_to_zero(q, s);
4142
4143     /* return (double)s / 256.0 */
4144     return float64_div(int64_to_float64(q_int, s), float64_256, s);
4145 }
4146
4147 float32 HELPER(recpe_f32)(float32 a, CPUARMState *env)
4148 {
4149     float_status *s = &env->vfp.standard_fp_status;
4150     float64 f64;
4151     uint32_t val32 = float32_val(a);
4152
4153     int result_exp;
4154     int a_exp = (val32  & 0x7f800000) >> 23;
4155     int sign = val32 & 0x80000000;
4156
4157     if (float32_is_any_nan(a)) {
4158         if (float32_is_signaling_nan(a)) {
4159             float_raise(float_flag_invalid, s);
4160         }
4161         return float32_default_nan;
4162     } else if (float32_is_infinity(a)) {
4163         return float32_set_sign(float32_zero, float32_is_neg(a));
4164     } else if (float32_is_zero_or_denormal(a)) {
4165         if (!float32_is_zero(a)) {
4166             float_raise(float_flag_input_denormal, s);
4167         }
4168         float_raise(float_flag_divbyzero, s);
4169         return float32_set_sign(float32_infinity, float32_is_neg(a));
4170     } else if (a_exp >= 253) {
4171         float_raise(float_flag_underflow, s);
4172         return float32_set_sign(float32_zero, float32_is_neg(a));
4173     }
4174
4175     f64 = make_float64((0x3feULL << 52)
4176                        | ((int64_t)(val32 & 0x7fffff) << 29));
4177
4178     result_exp = 253 - a_exp;
4179
4180     f64 = recip_estimate(f64, env);
4181
4182     val32 = sign
4183         | ((result_exp & 0xff) << 23)
4184         | ((float64_val(f64) >> 29) & 0x7fffff);
4185     return make_float32(val32);
4186 }
4187
4188 /* The algorithm that must be used to calculate the estimate
4189  * is specified by the ARM ARM.
4190  */
4191 static float64 recip_sqrt_estimate(float64 a, CPUARMState *env)
4192 {
4193     /* These calculations mustn't set any fp exception flags,
4194      * so we use a local copy of the fp_status.
4195      */
4196     float_status dummy_status = env->vfp.standard_fp_status;
4197     float_status *s = &dummy_status;
4198     float64 q;
4199     int64_t q_int;
4200
4201     if (float64_lt(a, float64_half, s)) {
4202         /* range 0.25 <= a < 0.5 */
4203
4204         /* a in units of 1/512 rounded down */
4205         /* q0 = (int)(a * 512.0);  */
4206         q = float64_mul(float64_512, a, s);
4207         q_int = float64_to_int64_round_to_zero(q, s);
4208
4209         /* reciprocal root r */
4210         /* r = 1.0 / sqrt(((double)q0 + 0.5) / 512.0);  */
4211         q = int64_to_float64(q_int, s);
4212         q = float64_add(q, float64_half, s);
4213         q = float64_div(q, float64_512, s);
4214         q = float64_sqrt(q, s);
4215         q = float64_div(float64_one, q, s);
4216     } else {
4217         /* range 0.5 <= a < 1.0 */
4218
4219         /* a in units of 1/256 rounded down */
4220         /* q1 = (int)(a * 256.0); */
4221         q = float64_mul(float64_256, a, s);
4222         int64_t q_int = float64_to_int64_round_to_zero(q, s);
4223
4224         /* reciprocal root r */
4225         /* r = 1.0 /sqrt(((double)q1 + 0.5) / 256); */
4226         q = int64_to_float64(q_int, s);
4227         q = float64_add(q, float64_half, s);
4228         q = float64_div(q, float64_256, s);
4229         q = float64_sqrt(q, s);
4230         q = float64_div(float64_one, q, s);
4231     }
4232     /* r in units of 1/256 rounded to nearest */
4233     /* s = (int)(256.0 * r + 0.5); */
4234
4235     q = float64_mul(q, float64_256,s );
4236     q = float64_add(q, float64_half, s);
4237     q_int = float64_to_int64_round_to_zero(q, s);
4238
4239     /* return (double)s / 256.0;*/
4240     return float64_div(int64_to_float64(q_int, s), float64_256, s);
4241 }
4242
4243 float32 HELPER(rsqrte_f32)(float32 a, CPUARMState *env)
4244 {
4245     float_status *s = &env->vfp.standard_fp_status;
4246     int result_exp;
4247     float64 f64;
4248     uint32_t val;
4249     uint64_t val64;
4250
4251     val = float32_val(a);
4252
4253     if (float32_is_any_nan(a)) {
4254         if (float32_is_signaling_nan(a)) {
4255             float_raise(float_flag_invalid, s);
4256         }
4257         return float32_default_nan;
4258     } else if (float32_is_zero_or_denormal(a)) {
4259         if (!float32_is_zero(a)) {
4260             float_raise(float_flag_input_denormal, s);
4261         }
4262         float_raise(float_flag_divbyzero, s);
4263         return float32_set_sign(float32_infinity, float32_is_neg(a));
4264     } else if (float32_is_neg(a)) {
4265         float_raise(float_flag_invalid, s);
4266         return float32_default_nan;
4267     } else if (float32_is_infinity(a)) {
4268         return float32_zero;
4269     }
4270
4271     /* Normalize to a double-precision value between 0.25 and 1.0,
4272      * preserving the parity of the exponent.  */
4273     if ((val & 0x800000) == 0) {
4274         f64 = make_float64(((uint64_t)(val & 0x80000000) << 32)
4275                            | (0x3feULL << 52)
4276                            | ((uint64_t)(val & 0x7fffff) << 29));
4277     } else {
4278         f64 = make_float64(((uint64_t)(val & 0x80000000) << 32)
4279                            | (0x3fdULL << 52)
4280                            | ((uint64_t)(val & 0x7fffff) << 29));
4281     }
4282
4283     result_exp = (380 - ((val & 0x7f800000) >> 23)) / 2;
4284
4285     f64 = recip_sqrt_estimate(f64, env);
4286
4287     val64 = float64_val(f64);
4288
4289     val = ((result_exp & 0xff) << 23)
4290         | ((val64 >> 29)  & 0x7fffff);
4291     return make_float32(val);
4292 }
4293
4294 uint32_t HELPER(recpe_u32)(uint32_t a, CPUARMState *env)
4295 {
4296     float64 f64;
4297
4298     if ((a & 0x80000000) == 0) {
4299         return 0xffffffff;
4300     }
4301
4302     f64 = make_float64((0x3feULL << 52)
4303                        | ((int64_t)(a & 0x7fffffff) << 21));
4304
4305     f64 = recip_estimate (f64, env);
4306
4307     return 0x80000000 | ((float64_val(f64) >> 21) & 0x7fffffff);
4308 }
4309
4310 uint32_t HELPER(rsqrte_u32)(uint32_t a, CPUARMState *env)
4311 {
4312     float64 f64;
4313
4314     if ((a & 0xc0000000) == 0) {
4315         return 0xffffffff;
4316     }
4317
4318     if (a & 0x80000000) {
4319         f64 = make_float64((0x3feULL << 52)
4320                            | ((uint64_t)(a & 0x7fffffff) << 21));
4321     } else { /* bits 31-30 == '01' */
4322         f64 = make_float64((0x3fdULL << 52)
4323                            | ((uint64_t)(a & 0x3fffffff) << 22));
4324     }
4325
4326     f64 = recip_sqrt_estimate(f64, env);
4327
4328     return 0x80000000 | ((float64_val(f64) >> 21) & 0x7fffffff);
4329 }
4330
4331 /* VFPv4 fused multiply-accumulate */
4332 float32 VFP_HELPER(muladd, s)(float32 a, float32 b, float32 c, void *fpstp)
4333 {
4334     float_status *fpst = fpstp;
4335     return float32_muladd(a, b, c, 0, fpst);
4336 }
4337
4338 float64 VFP_HELPER(muladd, d)(float64 a, float64 b, float64 c, void *fpstp)
4339 {
4340     float_status *fpst = fpstp;
4341     return float64_muladd(a, b, c, 0, fpst);
4342 }
4343
4344 /* ARMv8 round to integral */
4345 float32 HELPER(rints_exact)(float32 x, void *fp_status)
4346 {
4347     return float32_round_to_int(x, fp_status);
4348 }
4349
4350 float64 HELPER(rintd_exact)(float64 x, void *fp_status)
4351 {
4352     return float64_round_to_int(x, fp_status);
4353 }
4354
4355 float32 HELPER(rints)(float32 x, void *fp_status)
4356 {
4357     int old_flags = get_float_exception_flags(fp_status), new_flags;
4358     float32 ret;
4359
4360     ret = float32_round_to_int(x, fp_status);
4361
4362     /* Suppress any inexact exceptions the conversion produced */
4363     if (!(old_flags & float_flag_inexact)) {
4364         new_flags = get_float_exception_flags(fp_status);
4365         set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
4366     }
4367
4368     return ret;
4369 }
4370
4371 float64 HELPER(rintd)(float64 x, void *fp_status)
4372 {
4373     int old_flags = get_float_exception_flags(fp_status), new_flags;
4374     float64 ret;
4375
4376     ret = float64_round_to_int(x, fp_status);
4377
4378     new_flags = get_float_exception_flags(fp_status);
4379
4380     /* Suppress any inexact exceptions the conversion produced */
4381     if (!(old_flags & float_flag_inexact)) {
4382         new_flags = get_float_exception_flags(fp_status);
4383         set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
4384     }
4385
4386     return ret;
4387 }
4388
4389 /* Convert ARM rounding mode to softfloat */
4390 int arm_rmode_to_sf(int rmode)
4391 {
4392     switch (rmode) {
4393     case FPROUNDING_TIEAWAY:
4394         rmode = float_round_ties_away;
4395         break;
4396     case FPROUNDING_ODD:
4397         /* FIXME: add support for TIEAWAY and ODD */
4398         qemu_log_mask(LOG_UNIMP, "arm: unimplemented rounding mode: %d\n",
4399                       rmode);
4400     case FPROUNDING_TIEEVEN:
4401     default:
4402         rmode = float_round_nearest_even;
4403         break;
4404     case FPROUNDING_POSINF:
4405         rmode = float_round_up;
4406         break;
4407     case FPROUNDING_NEGINF:
4408         rmode = float_round_down;
4409         break;
4410     case FPROUNDING_ZERO:
4411         rmode = float_round_to_zero;
4412         break;
4413     }
4414     return rmode;
4415 }