misc.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2022 Arm Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2009 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __ARCH_ARM_REGS_MISC_HH__
#define __ARCH_ARM_REGS_MISC_HH__
 
#include <bitset>
#include <tuple>
 
#include "arch/arm/regs/misc_types.hh"
#include "base/compiler.hh"
#include "dev/arm/generic_timer_miscregs_types.hh"
 
namespace gem5
{
 
class ThreadContext;
 
 
namespace ArmISA
{
    enum MiscRegIndex
    {
        MISCREG_CPSR = 0,
        MISCREG_SPSR,
        MISCREG_SPSR_FIQ,
        MISCREG_SPSR_IRQ,
        MISCREG_SPSR_SVC,
        MISCREG_SPSR_MON,
        MISCREG_SPSR_ABT,
        MISCREG_SPSR_HYP,
        MISCREG_SPSR_UND,
        MISCREG_ELR_HYP,
        MISCREG_FPSID,
        MISCREG_FPSCR,
        MISCREG_MVFR1,
        MISCREG_MVFR0,
        MISCREG_FPEXC,
 
        // Helper registers
        MISCREG_CPSR_MODE,
        MISCREG_CPSR_Q,
        MISCREG_FPSCR_EXC,
        MISCREG_FPSCR_QC,
        MISCREG_LOCKADDR,
        MISCREG_LOCKFLAG,
        MISCREG_PRRR_MAIR0,
        MISCREG_PRRR_MAIR0_NS,
        MISCREG_PRRR_MAIR0_S,
        MISCREG_NMRR_MAIR1,
        MISCREG_NMRR_MAIR1_NS,
        MISCREG_NMRR_MAIR1_S,
        MISCREG_PMXEVTYPER_PMCCFILTR,
        MISCREG_SCTLR_RST,
        MISCREG_SEV_MAILBOX,
        MISCREG_TLBINEEDSYNC,
 
        // AArch32 CP14 registers (debug/trace/ThumbEE/Jazelle control)
        MISCREG_DBGDIDR,
        MISCREG_DBGDSCRint,
        MISCREG_DBGDCCINT,
        MISCREG_DBGDTRTXint,
        MISCREG_DBGDTRRXint,
        MISCREG_DBGWFAR,
        MISCREG_DBGVCR,
        MISCREG_DBGDTRRXext,
        MISCREG_DBGDSCRext,
        MISCREG_DBGDTRTXext,
        MISCREG_DBGOSECCR,
        MISCREG_DBGBVR0,
        MISCREG_DBGBVR1,
        MISCREG_DBGBVR2,
        MISCREG_DBGBVR3,
        MISCREG_DBGBVR4,
        MISCREG_DBGBVR5,
        MISCREG_DBGBVR6,
        MISCREG_DBGBVR7,
        MISCREG_DBGBVR8,
        MISCREG_DBGBVR9,
        MISCREG_DBGBVR10,
        MISCREG_DBGBVR11,
        MISCREG_DBGBVR12,
        MISCREG_DBGBVR13,
        MISCREG_DBGBVR14,
        MISCREG_DBGBVR15,
        MISCREG_DBGBCR0,
        MISCREG_DBGBCR1,
        MISCREG_DBGBCR2,
        MISCREG_DBGBCR3,
        MISCREG_DBGBCR4,
        MISCREG_DBGBCR5,
        MISCREG_DBGBCR6,
        MISCREG_DBGBCR7,
        MISCREG_DBGBCR8,
        MISCREG_DBGBCR9,
        MISCREG_DBGBCR10,
        MISCREG_DBGBCR11,
        MISCREG_DBGBCR12,
        MISCREG_DBGBCR13,
        MISCREG_DBGBCR14,
        MISCREG_DBGBCR15,
        MISCREG_DBGWVR0,
        MISCREG_DBGWVR1,
        MISCREG_DBGWVR2,
        MISCREG_DBGWVR3,
        MISCREG_DBGWVR4,
        MISCREG_DBGWVR5,
        MISCREG_DBGWVR6,
        MISCREG_DBGWVR7,
        MISCREG_DBGWVR8,
        MISCREG_DBGWVR9,
        MISCREG_DBGWVR10,
        MISCREG_DBGWVR11,
        MISCREG_DBGWVR12,
        MISCREG_DBGWVR13,
        MISCREG_DBGWVR14,
        MISCREG_DBGWVR15,
        MISCREG_DBGWCR0,
        MISCREG_DBGWCR1,
        MISCREG_DBGWCR2,
        MISCREG_DBGWCR3,
        MISCREG_DBGWCR4,
        MISCREG_DBGWCR5,
        MISCREG_DBGWCR6,
        MISCREG_DBGWCR7,
        MISCREG_DBGWCR8,
        MISCREG_DBGWCR9,
        MISCREG_DBGWCR10,
        MISCREG_DBGWCR11,
        MISCREG_DBGWCR12,
        MISCREG_DBGWCR13,
        MISCREG_DBGWCR14,
        MISCREG_DBGWCR15,
        MISCREG_DBGDRAR,
        MISCREG_DBGBXVR0,
        MISCREG_DBGBXVR1,
        MISCREG_DBGBXVR2,
        MISCREG_DBGBXVR3,
        MISCREG_DBGBXVR4,
        MISCREG_DBGBXVR5,
        MISCREG_DBGBXVR6,
        MISCREG_DBGBXVR7,
        MISCREG_DBGBXVR8,
        MISCREG_DBGBXVR9,
        MISCREG_DBGBXVR10,
        MISCREG_DBGBXVR11,
        MISCREG_DBGBXVR12,
        MISCREG_DBGBXVR13,
        MISCREG_DBGBXVR14,
        MISCREG_DBGBXVR15,
        MISCREG_DBGOSLAR,
        MISCREG_DBGOSLSR,
        MISCREG_DBGOSDLR,
        MISCREG_DBGPRCR,
        MISCREG_DBGDSAR,
        MISCREG_DBGCLAIMSET,
        MISCREG_DBGCLAIMCLR,
        MISCREG_DBGAUTHSTATUS,
        MISCREG_DBGDEVID2,
        MISCREG_DBGDEVID1,
        MISCREG_DBGDEVID0,
        MISCREG_TEECR,  // not in ARM DDI 0487A.b+
        MISCREG_JIDR,
        MISCREG_TEEHBR, // not in ARM DDI 0487A.b+
        MISCREG_JOSCR,
        MISCREG_JMCR,
 
        // AArch32 CP15 registers (system control)
        MISCREG_MIDR,
        MISCREG_CTR,
        MISCREG_TCMTR,
        MISCREG_TLBTR,
        MISCREG_MPIDR,
        MISCREG_REVIDR,
        MISCREG_ID_PFR0,
        MISCREG_ID_PFR1,
        MISCREG_ID_DFR0,
        MISCREG_ID_AFR0,
        MISCREG_ID_MMFR0,
        MISCREG_ID_MMFR1,
        MISCREG_ID_MMFR2,
        MISCREG_ID_MMFR3,
        MISCREG_ID_MMFR4,
        MISCREG_ID_ISAR0,
        MISCREG_ID_ISAR1,
        MISCREG_ID_ISAR2,
        MISCREG_ID_ISAR3,
        MISCREG_ID_ISAR4,
        MISCREG_ID_ISAR5,
        MISCREG_ID_ISAR6,
        MISCREG_CCSIDR,
        MISCREG_CLIDR,
        MISCREG_AIDR,
        MISCREG_CSSELR,
        MISCREG_CSSELR_NS,
        MISCREG_CSSELR_S,
        MISCREG_VPIDR,
        MISCREG_VMPIDR,
        MISCREG_SCTLR,
        MISCREG_SCTLR_NS,
        MISCREG_SCTLR_S,
        MISCREG_ACTLR,
        MISCREG_ACTLR_NS,
        MISCREG_ACTLR_S,
        MISCREG_CPACR,
        MISCREG_SDCR,
        MISCREG_SCR,
        MISCREG_SDER,
        MISCREG_NSACR,
        MISCREG_HSCTLR,
        MISCREG_HACTLR,
        MISCREG_HCR,
        MISCREG_HCR2,
        MISCREG_HDCR,
        MISCREG_HCPTR,
        MISCREG_HSTR,
        MISCREG_HACR,
        MISCREG_TTBR0,
        MISCREG_TTBR0_NS,
        MISCREG_TTBR0_S,
        MISCREG_TTBR1,
        MISCREG_TTBR1_NS,
        MISCREG_TTBR1_S,
        MISCREG_TTBCR,
        MISCREG_TTBCR_NS,
        MISCREG_TTBCR_S,
        MISCREG_HTCR,
        MISCREG_VTCR,
        MISCREG_DACR,
        MISCREG_DACR_NS,
        MISCREG_DACR_S,
        MISCREG_DFSR,
        MISCREG_DFSR_NS,
        MISCREG_DFSR_S,
        MISCREG_IFSR,
        MISCREG_IFSR_NS,
        MISCREG_IFSR_S,
        MISCREG_ADFSR,
        MISCREG_ADFSR_NS,
        MISCREG_ADFSR_S,
        MISCREG_AIFSR,
        MISCREG_AIFSR_NS,
        MISCREG_AIFSR_S,
        MISCREG_HADFSR,
        MISCREG_HAIFSR,
        MISCREG_HSR,
        MISCREG_DFAR,
        MISCREG_DFAR_NS,
        MISCREG_DFAR_S,
        MISCREG_IFAR,
        MISCREG_IFAR_NS,
        MISCREG_IFAR_S,
        MISCREG_HDFAR,
        MISCREG_HIFAR,
        MISCREG_HPFAR,
        MISCREG_ICIALLUIS,
        MISCREG_BPIALLIS,
        MISCREG_PAR,
        MISCREG_PAR_NS,
        MISCREG_PAR_S,
        MISCREG_ICIALLU,
        MISCREG_ICIMVAU,
        MISCREG_CP15ISB,
        MISCREG_BPIALL,
        MISCREG_BPIMVA,
        MISCREG_DCIMVAC,
        MISCREG_DCISW,
        MISCREG_ATS1CPR,
        MISCREG_ATS1CPW,
        MISCREG_ATS1CUR,
        MISCREG_ATS1CUW,
        MISCREG_ATS12NSOPR,
        MISCREG_ATS12NSOPW,
        MISCREG_ATS12NSOUR,
        MISCREG_ATS12NSOUW,
        MISCREG_DCCMVAC,
        MISCREG_DCCSW,
        MISCREG_CP15DSB,
        MISCREG_CP15DMB,
        MISCREG_DCCMVAU,
        MISCREG_DCCIMVAC,
        MISCREG_DCCISW,
        MISCREG_ATS1HR,
        MISCREG_ATS1HW,
        MISCREG_TLBIALLIS,
        MISCREG_TLBIMVAIS,
        MISCREG_TLBIASIDIS,
        MISCREG_TLBIMVAAIS,
        MISCREG_TLBIMVALIS,
        MISCREG_TLBIMVAALIS,
        MISCREG_ITLBIALL,
        MISCREG_ITLBIMVA,
        MISCREG_ITLBIASID,
        MISCREG_DTLBIALL,
        MISCREG_DTLBIMVA,
        MISCREG_DTLBIASID,
        MISCREG_TLBIALL,
        MISCREG_TLBIMVA,
        MISCREG_TLBIASID,
        MISCREG_TLBIMVAA,
        MISCREG_TLBIMVAL,
        MISCREG_TLBIMVAAL,
        MISCREG_TLBIIPAS2IS,
        MISCREG_TLBIIPAS2LIS,
        MISCREG_TLBIALLHIS,
        MISCREG_TLBIMVAHIS,
        MISCREG_TLBIALLNSNHIS,
        MISCREG_TLBIMVALHIS,
        MISCREG_TLBIIPAS2,
        MISCREG_TLBIIPAS2L,
        MISCREG_TLBIALLH,
        MISCREG_TLBIMVAH,
        MISCREG_TLBIALLNSNH,
        MISCREG_TLBIMVALH,
        MISCREG_PMCR,
        MISCREG_PMCNTENSET,
        MISCREG_PMCNTENCLR,
        MISCREG_PMOVSR,
        MISCREG_PMSWINC,
        MISCREG_PMSELR,
        MISCREG_PMCEID0,
        MISCREG_PMCEID1,
        MISCREG_PMCCNTR,
        MISCREG_PMXEVTYPER,
        MISCREG_PMCCFILTR,
        MISCREG_PMXEVCNTR,
        MISCREG_PMUSERENR,
        MISCREG_PMINTENSET,
        MISCREG_PMINTENCLR,
        MISCREG_PMOVSSET,
        MISCREG_L2CTLR,
        MISCREG_L2ECTLR,
        MISCREG_PRRR,
        MISCREG_PRRR_NS,
        MISCREG_PRRR_S,
        MISCREG_MAIR0,
        MISCREG_MAIR0_NS,
        MISCREG_MAIR0_S,
        MISCREG_NMRR,
        MISCREG_NMRR_NS,
        MISCREG_NMRR_S,
        MISCREG_MAIR1,
        MISCREG_MAIR1_NS,
        MISCREG_MAIR1_S,
        MISCREG_AMAIR0,
        MISCREG_AMAIR0_NS,
        MISCREG_AMAIR0_S,
        MISCREG_AMAIR1,
        MISCREG_AMAIR1_NS,
        MISCREG_AMAIR1_S,
        MISCREG_HMAIR0,
        MISCREG_HMAIR1,
        MISCREG_HAMAIR0,
        MISCREG_HAMAIR1,
        MISCREG_VBAR,
        MISCREG_VBAR_NS,
        MISCREG_VBAR_S,
        MISCREG_MVBAR,
        MISCREG_RMR,
        MISCREG_ISR,
        MISCREG_HVBAR,
        MISCREG_FCSEIDR,
        MISCREG_CONTEXTIDR,
        MISCREG_CONTEXTIDR_NS,
        MISCREG_CONTEXTIDR_S,
        MISCREG_TPIDRURW,
        MISCREG_TPIDRURW_NS,
        MISCREG_TPIDRURW_S,
        MISCREG_TPIDRURO,
        MISCREG_TPIDRURO_NS,
        MISCREG_TPIDRURO_S,
        MISCREG_TPIDRPRW,
        MISCREG_TPIDRPRW_NS,
        MISCREG_TPIDRPRW_S,
        MISCREG_HTPIDR,
        // BEGIN Generic Timer (AArch32)
        MISCREG_CNTFRQ,
        MISCREG_CNTPCT,
        MISCREG_CNTVCT,
        MISCREG_CNTP_CTL,
        MISCREG_CNTP_CTL_NS,
        MISCREG_CNTP_CTL_S,
        MISCREG_CNTP_CVAL,
        MISCREG_CNTP_CVAL_NS,
        MISCREG_CNTP_CVAL_S,
        MISCREG_CNTP_TVAL,
        MISCREG_CNTP_TVAL_NS,
        MISCREG_CNTP_TVAL_S,
        MISCREG_CNTV_CTL,
        MISCREG_CNTV_CVAL,
        MISCREG_CNTV_TVAL,
        MISCREG_CNTKCTL,
        MISCREG_CNTHCTL,
        MISCREG_CNTHP_CTL,
        MISCREG_CNTHP_CVAL,
        MISCREG_CNTHP_TVAL,
        MISCREG_CNTVOFF,
        // END Generic Timer (AArch32)
        MISCREG_IL1DATA0,
        MISCREG_IL1DATA1,
        MISCREG_IL1DATA2,
        MISCREG_IL1DATA3,
        MISCREG_DL1DATA0,
        MISCREG_DL1DATA1,
        MISCREG_DL1DATA2,
        MISCREG_DL1DATA3,
        MISCREG_DL1DATA4,
        MISCREG_RAMINDEX,
        MISCREG_L2ACTLR,
        MISCREG_CBAR,
        MISCREG_HTTBR,
        MISCREG_VTTBR,
        MISCREG_CPUMERRSR,
        MISCREG_L2MERRSR,
 
        // AArch64 registers (Op0=2)
        MISCREG_MDCCINT_EL1,
        MISCREG_OSDTRRX_EL1,
        MISCREG_MDSCR_EL1,
        MISCREG_OSDTRTX_EL1,
        MISCREG_OSECCR_EL1,
        MISCREG_DBGBVR0_EL1,
        MISCREG_DBGBVR1_EL1,
        MISCREG_DBGBVR2_EL1,
        MISCREG_DBGBVR3_EL1,
        MISCREG_DBGBVR4_EL1,
        MISCREG_DBGBVR5_EL1,
        MISCREG_DBGBVR6_EL1,
        MISCREG_DBGBVR7_EL1,
        MISCREG_DBGBVR8_EL1,
        MISCREG_DBGBVR9_EL1,
        MISCREG_DBGBVR10_EL1,
        MISCREG_DBGBVR11_EL1,
        MISCREG_DBGBVR12_EL1,
        MISCREG_DBGBVR13_EL1,
        MISCREG_DBGBVR14_EL1,
        MISCREG_DBGBVR15_EL1,
        MISCREG_DBGBCR0_EL1,
        MISCREG_DBGBCR1_EL1,
        MISCREG_DBGBCR2_EL1,
        MISCREG_DBGBCR3_EL1,
        MISCREG_DBGBCR4_EL1,
        MISCREG_DBGBCR5_EL1,
        MISCREG_DBGBCR6_EL1,
        MISCREG_DBGBCR7_EL1,
        MISCREG_DBGBCR8_EL1,
        MISCREG_DBGBCR9_EL1,
        MISCREG_DBGBCR10_EL1,
        MISCREG_DBGBCR11_EL1,
        MISCREG_DBGBCR12_EL1,
        MISCREG_DBGBCR13_EL1,
        MISCREG_DBGBCR14_EL1,
        MISCREG_DBGBCR15_EL1,
        MISCREG_DBGWVR0_EL1,
        MISCREG_DBGWVR1_EL1,
        MISCREG_DBGWVR2_EL1,
        MISCREG_DBGWVR3_EL1,
        MISCREG_DBGWVR4_EL1,
        MISCREG_DBGWVR5_EL1,
        MISCREG_DBGWVR6_EL1,
        MISCREG_DBGWVR7_EL1,
        MISCREG_DBGWVR8_EL1,
        MISCREG_DBGWVR9_EL1,
        MISCREG_DBGWVR10_EL1,
        MISCREG_DBGWVR11_EL1,
        MISCREG_DBGWVR12_EL1,
        MISCREG_DBGWVR13_EL1,
        MISCREG_DBGWVR14_EL1,
        MISCREG_DBGWVR15_EL1,
        MISCREG_DBGWCR0_EL1,
        MISCREG_DBGWCR1_EL1,
        MISCREG_DBGWCR2_EL1,
        MISCREG_DBGWCR3_EL1,
        MISCREG_DBGWCR4_EL1,
        MISCREG_DBGWCR5_EL1,
        MISCREG_DBGWCR6_EL1,
        MISCREG_DBGWCR7_EL1,
        MISCREG_DBGWCR8_EL1,
        MISCREG_DBGWCR9_EL1,
        MISCREG_DBGWCR10_EL1,
        MISCREG_DBGWCR11_EL1,
        MISCREG_DBGWCR12_EL1,
        MISCREG_DBGWCR13_EL1,
        MISCREG_DBGWCR14_EL1,
        MISCREG_DBGWCR15_EL1,
        MISCREG_MDCCSR_EL0,
        MISCREG_MDDTR_EL0,
        MISCREG_MDDTRTX_EL0,
        MISCREG_MDDTRRX_EL0,
        MISCREG_DBGVCR32_EL2,
        MISCREG_MDRAR_EL1,
        MISCREG_OSLAR_EL1,
        MISCREG_OSLSR_EL1,
        MISCREG_OSDLR_EL1,
        MISCREG_DBGPRCR_EL1,
        MISCREG_DBGCLAIMSET_EL1,
        MISCREG_DBGCLAIMCLR_EL1,
        MISCREG_DBGAUTHSTATUS_EL1,
        MISCREG_TEECR32_EL1, // not in ARM DDI 0487A.b+
        MISCREG_TEEHBR32_EL1, // not in ARM DDI 0487A.b+
 
        // AArch64 registers (Op0=1,3)
        MISCREG_MIDR_EL1,
        MISCREG_MPIDR_EL1,
        MISCREG_REVIDR_EL1,
        MISCREG_ID_PFR0_EL1,
        MISCREG_ID_PFR1_EL1,
        MISCREG_ID_DFR0_EL1,
        MISCREG_ID_AFR0_EL1,
        MISCREG_ID_MMFR0_EL1,
        MISCREG_ID_MMFR1_EL1,
        MISCREG_ID_MMFR2_EL1,
        MISCREG_ID_MMFR3_EL1,
        MISCREG_ID_MMFR4_EL1,
        MISCREG_ID_ISAR0_EL1,
        MISCREG_ID_ISAR1_EL1,
        MISCREG_ID_ISAR2_EL1,
        MISCREG_ID_ISAR3_EL1,
        MISCREG_ID_ISAR4_EL1,
        MISCREG_ID_ISAR5_EL1,
        MISCREG_ID_ISAR6_EL1,
        MISCREG_MVFR0_EL1,
        MISCREG_MVFR1_EL1,
        MISCREG_MVFR2_EL1,
        MISCREG_ID_AA64PFR0_EL1,
        MISCREG_ID_AA64PFR1_EL1,
        MISCREG_ID_AA64DFR0_EL1,
        MISCREG_ID_AA64DFR1_EL1,
        MISCREG_ID_AA64AFR0_EL1,
        MISCREG_ID_AA64AFR1_EL1,
        MISCREG_ID_AA64ISAR0_EL1,
        MISCREG_ID_AA64ISAR1_EL1,
        MISCREG_ID_AA64MMFR0_EL1,
        MISCREG_ID_AA64MMFR1_EL1,
        MISCREG_CCSIDR_EL1,
        MISCREG_CLIDR_EL1,
        MISCREG_AIDR_EL1,
        MISCREG_CSSELR_EL1,
        MISCREG_CTR_EL0,
        MISCREG_DCZID_EL0,
        MISCREG_VPIDR_EL2,
        MISCREG_VMPIDR_EL2,
        MISCREG_SCTLR_EL1,
        MISCREG_SCTLR_EL12,
        MISCREG_ACTLR_EL1,
        MISCREG_CPACR_EL1,
        MISCREG_CPACR_EL12,
        MISCREG_SCTLR_EL2,
        MISCREG_ACTLR_EL2,
        MISCREG_HCR_EL2,
        MISCREG_MDCR_EL2,
        MISCREG_CPTR_EL2,
        MISCREG_HSTR_EL2,
        MISCREG_HACR_EL2,
        MISCREG_SCTLR_EL3,
        MISCREG_ACTLR_EL3,
        MISCREG_SCR_EL3,
        MISCREG_SDER32_EL3,
        MISCREG_CPTR_EL3,
        MISCREG_MDCR_EL3,
        MISCREG_TTBR0_EL1,
        MISCREG_TTBR0_EL12,
        MISCREG_TTBR1_EL1,
        MISCREG_TTBR1_EL12,
        MISCREG_TCR_EL1,
        MISCREG_TCR_EL12,
        MISCREG_TTBR0_EL2,
        MISCREG_TCR_EL2,
        MISCREG_VTTBR_EL2,
        MISCREG_VTCR_EL2,
        MISCREG_VSTTBR_EL2,
        MISCREG_VSTCR_EL2,
        MISCREG_TTBR0_EL3,
        MISCREG_TCR_EL3,
        MISCREG_DACR32_EL2,
        MISCREG_SPSR_EL1,
        MISCREG_SPSR_EL12,
        MISCREG_ELR_EL1,
        MISCREG_ELR_EL12,
        MISCREG_SP_EL0,
        MISCREG_SPSEL,
        MISCREG_CURRENTEL,
        MISCREG_NZCV,
        MISCREG_DAIF,
        MISCREG_FPCR,
        MISCREG_FPSR,
        MISCREG_DSPSR_EL0,
        MISCREG_DLR_EL0,
        MISCREG_SPSR_EL2,
        MISCREG_ELR_EL2,
        MISCREG_SP_EL1,
        MISCREG_SPSR_IRQ_AA64,
        MISCREG_SPSR_ABT_AA64,
        MISCREG_SPSR_UND_AA64,
        MISCREG_SPSR_FIQ_AA64,
        MISCREG_SPSR_EL3,
        MISCREG_ELR_EL3,
        MISCREG_SP_EL2,
        MISCREG_AFSR0_EL1,
        MISCREG_AFSR0_EL12,
        MISCREG_AFSR1_EL1,
        MISCREG_AFSR1_EL12,
        MISCREG_ESR_EL1,
        MISCREG_ESR_EL12,
        MISCREG_IFSR32_EL2,
        MISCREG_AFSR0_EL2,
        MISCREG_AFSR1_EL2,
        MISCREG_ESR_EL2,
        MISCREG_FPEXC32_EL2,
        MISCREG_AFSR0_EL3,
        MISCREG_AFSR1_EL3,
        MISCREG_ESR_EL3,
        MISCREG_FAR_EL1,
        MISCREG_FAR_EL12,
        MISCREG_FAR_EL2,
        MISCREG_HPFAR_EL2,
        MISCREG_FAR_EL3,
        MISCREG_IC_IALLUIS,
        MISCREG_PAR_EL1,
        MISCREG_IC_IALLU,
        MISCREG_DC_IVAC_Xt,
        MISCREG_DC_ISW_Xt,
        MISCREG_AT_S1E1R_Xt,
        MISCREG_AT_S1E1W_Xt,
        MISCREG_AT_S1E0R_Xt,
        MISCREG_AT_S1E0W_Xt,
        MISCREG_DC_CSW_Xt,
        MISCREG_DC_CISW_Xt,
        MISCREG_DC_ZVA_Xt,
        MISCREG_IC_IVAU_Xt,
        MISCREG_DC_CVAC_Xt,
        MISCREG_DC_CVAU_Xt,
        MISCREG_DC_CIVAC_Xt,
        MISCREG_AT_S1E2R_Xt,
        MISCREG_AT_S1E2W_Xt,
        MISCREG_AT_S12E1R_Xt,
        MISCREG_AT_S12E1W_Xt,
        MISCREG_AT_S12E0R_Xt,
        MISCREG_AT_S12E0W_Xt,
        MISCREG_AT_S1E3R_Xt,
        MISCREG_AT_S1E3W_Xt,
        MISCREG_TLBI_VMALLE1IS,
        MISCREG_TLBI_VAE1IS_Xt,
        MISCREG_TLBI_ASIDE1IS_Xt,
        MISCREG_TLBI_VAAE1IS_Xt,
        MISCREG_TLBI_VALE1IS_Xt,
        MISCREG_TLBI_VAALE1IS_Xt,
        MISCREG_TLBI_VMALLE1,
        MISCREG_TLBI_VAE1_Xt,
        MISCREG_TLBI_ASIDE1_Xt,
        MISCREG_TLBI_VAAE1_Xt,
        MISCREG_TLBI_VALE1_Xt,
        MISCREG_TLBI_VAALE1_Xt,
        MISCREG_TLBI_IPAS2E1IS_Xt,
        MISCREG_TLBI_IPAS2LE1IS_Xt,
        MISCREG_TLBI_ALLE2IS,
        MISCREG_TLBI_VAE2IS_Xt,
        MISCREG_TLBI_ALLE1IS,
        MISCREG_TLBI_VALE2IS_Xt,
        MISCREG_TLBI_VMALLS12E1IS,
        MISCREG_TLBI_IPAS2E1_Xt,
        MISCREG_TLBI_IPAS2LE1_Xt,
        MISCREG_TLBI_ALLE2,
        MISCREG_TLBI_VAE2_Xt,
        MISCREG_TLBI_ALLE1,
        MISCREG_TLBI_VALE2_Xt,
        MISCREG_TLBI_VMALLS12E1,
        MISCREG_TLBI_ALLE3IS,
        MISCREG_TLBI_VAE3IS_Xt,
        MISCREG_TLBI_VALE3IS_Xt,
        MISCREG_TLBI_ALLE3,
        MISCREG_TLBI_VAE3_Xt,
        MISCREG_TLBI_VALE3_Xt,
        MISCREG_PMINTENSET_EL1,
        MISCREG_PMINTENCLR_EL1,
        MISCREG_PMCR_EL0,
        MISCREG_PMCNTENSET_EL0,
        MISCREG_PMCNTENCLR_EL0,
        MISCREG_PMOVSCLR_EL0,
        MISCREG_PMSWINC_EL0,
        MISCREG_PMSELR_EL0,
        MISCREG_PMCEID0_EL0,
        MISCREG_PMCEID1_EL0,
        MISCREG_PMCCNTR_EL0,
        MISCREG_PMXEVTYPER_EL0,
        MISCREG_PMCCFILTR_EL0,
        MISCREG_PMXEVCNTR_EL0,
        MISCREG_PMUSERENR_EL0,
        MISCREG_PMOVSSET_EL0,
        MISCREG_MAIR_EL1,
        MISCREG_MAIR_EL12,
        MISCREG_AMAIR_EL1,
        MISCREG_AMAIR_EL12,
        MISCREG_MAIR_EL2,
        MISCREG_AMAIR_EL2,
        MISCREG_MAIR_EL3,
        MISCREG_AMAIR_EL3,
        MISCREG_L2CTLR_EL1,
        MISCREG_L2ECTLR_EL1,
        MISCREG_VBAR_EL1,
        MISCREG_VBAR_EL12,
        MISCREG_RVBAR_EL1,
        MISCREG_ISR_EL1,
        MISCREG_VBAR_EL2,
        MISCREG_RVBAR_EL2,
        MISCREG_VBAR_EL3,
        MISCREG_RVBAR_EL3,
        MISCREG_RMR_EL3,
        MISCREG_CONTEXTIDR_EL1,
        MISCREG_CONTEXTIDR_EL12,
        MISCREG_TPIDR_EL1,
        MISCREG_TPIDR_EL0,
        MISCREG_TPIDRRO_EL0,
        MISCREG_TPIDR_EL2,
        MISCREG_TPIDR_EL3,
        // BEGIN Generic Timer (AArch64)
        MISCREG_CNTFRQ_EL0,
        MISCREG_CNTPCT_EL0,
        MISCREG_CNTVCT_EL0,
        MISCREG_CNTP_CTL_EL0,
        MISCREG_CNTP_CVAL_EL0,
        MISCREG_CNTP_TVAL_EL0,
        MISCREG_CNTV_CTL_EL0,
        MISCREG_CNTV_CVAL_EL0,
        MISCREG_CNTV_TVAL_EL0,
        MISCREG_CNTP_CTL_EL02,
        MISCREG_CNTP_CVAL_EL02,
        MISCREG_CNTP_TVAL_EL02,
        MISCREG_CNTV_CTL_EL02,
        MISCREG_CNTV_CVAL_EL02,
        MISCREG_CNTV_TVAL_EL02,
        MISCREG_CNTKCTL_EL1,
        MISCREG_CNTKCTL_EL12,
        MISCREG_CNTPS_CTL_EL1,
        MISCREG_CNTPS_CVAL_EL1,
        MISCREG_CNTPS_TVAL_EL1,
        MISCREG_CNTHCTL_EL2,
        MISCREG_CNTHP_CTL_EL2,
        MISCREG_CNTHP_CVAL_EL2,
        MISCREG_CNTHP_TVAL_EL2,
        MISCREG_CNTHPS_CTL_EL2,
        MISCREG_CNTHPS_CVAL_EL2,
        MISCREG_CNTHPS_TVAL_EL2,
        // IF Armv8.1-VHE
        MISCREG_CNTHV_CTL_EL2,
        MISCREG_CNTHV_CVAL_EL2,
        MISCREG_CNTHV_TVAL_EL2,
        MISCREG_CNTHVS_CTL_EL2,
        MISCREG_CNTHVS_CVAL_EL2,
        MISCREG_CNTHVS_TVAL_EL2,
        // ENDIF Armv8.1-VHE
        MISCREG_CNTVOFF_EL2,
        // END Generic Timer (AArch64)
        MISCREG_PMEVCNTR0_EL0,
        MISCREG_PMEVCNTR1_EL0,
        MISCREG_PMEVCNTR2_EL0,
        MISCREG_PMEVCNTR3_EL0,
        MISCREG_PMEVCNTR4_EL0,
        MISCREG_PMEVCNTR5_EL0,
        MISCREG_PMEVTYPER0_EL0,
        MISCREG_PMEVTYPER1_EL0,
        MISCREG_PMEVTYPER2_EL0,
        MISCREG_PMEVTYPER3_EL0,
        MISCREG_PMEVTYPER4_EL0,
        MISCREG_PMEVTYPER5_EL0,
        MISCREG_IL1DATA0_EL1,
        MISCREG_IL1DATA1_EL1,
        MISCREG_IL1DATA2_EL1,
        MISCREG_IL1DATA3_EL1,
        MISCREG_DL1DATA0_EL1,
        MISCREG_DL1DATA1_EL1,
        MISCREG_DL1DATA2_EL1,
        MISCREG_DL1DATA3_EL1,
        MISCREG_DL1DATA4_EL1,
        MISCREG_L2ACTLR_EL1,
        MISCREG_CPUACTLR_EL1,
        MISCREG_CPUECTLR_EL1,
        MISCREG_CPUMERRSR_EL1,
        MISCREG_L2MERRSR_EL1,
        MISCREG_CBAR_EL1,
        MISCREG_CONTEXTIDR_EL2,
 
        // Introduced in ARMv8.1
        MISCREG_TTBR1_EL2,
 
        MISCREG_ID_AA64MMFR2_EL1,
 
        //PAuth Key Regsiters
        MISCREG_APDAKeyHi_EL1,
        MISCREG_APDAKeyLo_EL1,
        MISCREG_APDBKeyHi_EL1,
        MISCREG_APDBKeyLo_EL1,
        MISCREG_APGAKeyHi_EL1,
        MISCREG_APGAKeyLo_EL1,
        MISCREG_APIAKeyHi_EL1,
        MISCREG_APIAKeyLo_EL1,
        MISCREG_APIBKeyHi_EL1,
        MISCREG_APIBKeyLo_EL1,
 
        // GICv3, CPU interface
        MISCREG_ICC_PMR_EL1,
        MISCREG_ICC_IAR0_EL1,
        MISCREG_ICC_EOIR0_EL1,
        MISCREG_ICC_HPPIR0_EL1,
        MISCREG_ICC_BPR0_EL1,
        MISCREG_ICC_AP0R0_EL1,
        MISCREG_ICC_AP0R1_EL1,
        MISCREG_ICC_AP0R2_EL1,
        MISCREG_ICC_AP0R3_EL1,
        MISCREG_ICC_AP1R0_EL1,
        MISCREG_ICC_AP1R0_EL1_NS,
        MISCREG_ICC_AP1R0_EL1_S,
        MISCREG_ICC_AP1R1_EL1,
        MISCREG_ICC_AP1R1_EL1_NS,
        MISCREG_ICC_AP1R1_EL1_S,
        MISCREG_ICC_AP1R2_EL1,
        MISCREG_ICC_AP1R2_EL1_NS,
        MISCREG_ICC_AP1R2_EL1_S,
        MISCREG_ICC_AP1R3_EL1,
        MISCREG_ICC_AP1R3_EL1_NS,
        MISCREG_ICC_AP1R3_EL1_S,
        MISCREG_ICC_DIR_EL1,
        MISCREG_ICC_RPR_EL1,
        MISCREG_ICC_SGI1R_EL1,
        MISCREG_ICC_ASGI1R_EL1,
        MISCREG_ICC_SGI0R_EL1,
        MISCREG_ICC_IAR1_EL1,
        MISCREG_ICC_EOIR1_EL1,
        MISCREG_ICC_HPPIR1_EL1,
        MISCREG_ICC_BPR1_EL1,
        MISCREG_ICC_BPR1_EL1_NS,
        MISCREG_ICC_BPR1_EL1_S,
        MISCREG_ICC_CTLR_EL1,
        MISCREG_ICC_CTLR_EL1_NS,
        MISCREG_ICC_CTLR_EL1_S,
        MISCREG_ICC_SRE_EL1,
        MISCREG_ICC_SRE_EL1_NS,
        MISCREG_ICC_SRE_EL1_S,
        MISCREG_ICC_IGRPEN0_EL1,
        MISCREG_ICC_IGRPEN1_EL1,
        MISCREG_ICC_IGRPEN1_EL1_NS,
        MISCREG_ICC_IGRPEN1_EL1_S,
        MISCREG_ICC_SRE_EL2,
        MISCREG_ICC_CTLR_EL3,
        MISCREG_ICC_SRE_EL3,
        MISCREG_ICC_IGRPEN1_EL3,
 
        // GICv3, CPU interface, virtualization
        MISCREG_ICH_AP0R0_EL2,
        MISCREG_ICH_AP0R1_EL2,
        MISCREG_ICH_AP0R2_EL2,
        MISCREG_ICH_AP0R3_EL2,
        MISCREG_ICH_AP1R0_EL2,
        MISCREG_ICH_AP1R1_EL2,
        MISCREG_ICH_AP1R2_EL2,
        MISCREG_ICH_AP1R3_EL2,
        MISCREG_ICH_HCR_EL2,
        MISCREG_ICH_VTR_EL2,
        MISCREG_ICH_MISR_EL2,
        MISCREG_ICH_EISR_EL2,
        MISCREG_ICH_ELRSR_EL2,
        MISCREG_ICH_VMCR_EL2,
        MISCREG_ICH_LR0_EL2,
        MISCREG_ICH_LR1_EL2,
        MISCREG_ICH_LR2_EL2,
        MISCREG_ICH_LR3_EL2,
        MISCREG_ICH_LR4_EL2,
        MISCREG_ICH_LR5_EL2,
        MISCREG_ICH_LR6_EL2,
        MISCREG_ICH_LR7_EL2,
        MISCREG_ICH_LR8_EL2,
        MISCREG_ICH_LR9_EL2,
        MISCREG_ICH_LR10_EL2,
        MISCREG_ICH_LR11_EL2,
        MISCREG_ICH_LR12_EL2,
        MISCREG_ICH_LR13_EL2,
        MISCREG_ICH_LR14_EL2,
        MISCREG_ICH_LR15_EL2,
 
        MISCREG_ICV_PMR_EL1,
        MISCREG_ICV_IAR0_EL1,
        MISCREG_ICV_EOIR0_EL1,
        MISCREG_ICV_HPPIR0_EL1,
        MISCREG_ICV_BPR0_EL1,
        MISCREG_ICV_AP0R0_EL1,
        MISCREG_ICV_AP0R1_EL1,
        MISCREG_ICV_AP0R2_EL1,
        MISCREG_ICV_AP0R3_EL1,
        MISCREG_ICV_AP1R0_EL1,
        MISCREG_ICV_AP1R0_EL1_NS,
        MISCREG_ICV_AP1R0_EL1_S,
        MISCREG_ICV_AP1R1_EL1,
        MISCREG_ICV_AP1R1_EL1_NS,
        MISCREG_ICV_AP1R1_EL1_S,
        MISCREG_ICV_AP1R2_EL1,
        MISCREG_ICV_AP1R2_EL1_NS,
        MISCREG_ICV_AP1R2_EL1_S,
        MISCREG_ICV_AP1R3_EL1,
        MISCREG_ICV_AP1R3_EL1_NS,
        MISCREG_ICV_AP1R3_EL1_S,
        MISCREG_ICV_DIR_EL1,
        MISCREG_ICV_RPR_EL1,
        MISCREG_ICV_SGI1R_EL1,
        MISCREG_ICV_ASGI1R_EL1,
        MISCREG_ICV_SGI0R_EL1,
        MISCREG_ICV_IAR1_EL1,
        MISCREG_ICV_EOIR1_EL1,
        MISCREG_ICV_HPPIR1_EL1,
        MISCREG_ICV_BPR1_EL1,
        MISCREG_ICV_BPR1_EL1_NS,
        MISCREG_ICV_BPR1_EL1_S,
        MISCREG_ICV_CTLR_EL1,
        MISCREG_ICV_CTLR_EL1_NS,
        MISCREG_ICV_CTLR_EL1_S,
        MISCREG_ICV_SRE_EL1,
        MISCREG_ICV_SRE_EL1_NS,
        MISCREG_ICV_SRE_EL1_S,
        MISCREG_ICV_IGRPEN0_EL1,
        MISCREG_ICV_IGRPEN1_EL1,
        MISCREG_ICV_IGRPEN1_EL1_NS,
        MISCREG_ICV_IGRPEN1_EL1_S,
 
        MISCREG_ICC_AP0R0,
        MISCREG_ICC_AP0R1,
        MISCREG_ICC_AP0R2,
        MISCREG_ICC_AP0R3,
        MISCREG_ICC_AP1R0,
        MISCREG_ICC_AP1R0_NS,
        MISCREG_ICC_AP1R0_S,
        MISCREG_ICC_AP1R1,
        MISCREG_ICC_AP1R1_NS,
        MISCREG_ICC_AP1R1_S,
        MISCREG_ICC_AP1R2,
        MISCREG_ICC_AP1R2_NS,
        MISCREG_ICC_AP1R2_S,
        MISCREG_ICC_AP1R3,
        MISCREG_ICC_AP1R3_NS,
        MISCREG_ICC_AP1R3_S,
        MISCREG_ICC_ASGI1R,
        MISCREG_ICC_BPR0,
        MISCREG_ICC_BPR1,
        MISCREG_ICC_BPR1_NS,
        MISCREG_ICC_BPR1_S,
        MISCREG_ICC_CTLR,
        MISCREG_ICC_CTLR_NS,
        MISCREG_ICC_CTLR_S,
        MISCREG_ICC_DIR,
        MISCREG_ICC_EOIR0,
        MISCREG_ICC_EOIR1,
        MISCREG_ICC_HPPIR0,
        MISCREG_ICC_HPPIR1,
        MISCREG_ICC_HSRE,
        MISCREG_ICC_IAR0,
        MISCREG_ICC_IAR1,
        MISCREG_ICC_IGRPEN0,
        MISCREG_ICC_IGRPEN1,
        MISCREG_ICC_IGRPEN1_NS,
        MISCREG_ICC_IGRPEN1_S,
        MISCREG_ICC_MCTLR,
        MISCREG_ICC_MGRPEN1,
        MISCREG_ICC_MSRE,
        MISCREG_ICC_PMR,
        MISCREG_ICC_RPR,
        MISCREG_ICC_SGI0R,
        MISCREG_ICC_SGI1R,
        MISCREG_ICC_SRE,
        MISCREG_ICC_SRE_NS,
        MISCREG_ICC_SRE_S,
 
        MISCREG_ICH_AP0R0,
        MISCREG_ICH_AP0R1,
        MISCREG_ICH_AP0R2,
        MISCREG_ICH_AP0R3,
        MISCREG_ICH_AP1R0,
        MISCREG_ICH_AP1R1,
        MISCREG_ICH_AP1R2,
        MISCREG_ICH_AP1R3,
        MISCREG_ICH_HCR,
        MISCREG_ICH_VTR,
        MISCREG_ICH_MISR,
        MISCREG_ICH_EISR,
        MISCREG_ICH_ELRSR,
        MISCREG_ICH_VMCR,
        MISCREG_ICH_LR0,
        MISCREG_ICH_LR1,
        MISCREG_ICH_LR2,
        MISCREG_ICH_LR3,
        MISCREG_ICH_LR4,
        MISCREG_ICH_LR5,
        MISCREG_ICH_LR6,
        MISCREG_ICH_LR7,
        MISCREG_ICH_LR8,
        MISCREG_ICH_LR9,
        MISCREG_ICH_LR10,
        MISCREG_ICH_LR11,
        MISCREG_ICH_LR12,
        MISCREG_ICH_LR13,
        MISCREG_ICH_LR14,
        MISCREG_ICH_LR15,
        MISCREG_ICH_LRC0,
        MISCREG_ICH_LRC1,
        MISCREG_ICH_LRC2,
        MISCREG_ICH_LRC3,
        MISCREG_ICH_LRC4,
        MISCREG_ICH_LRC5,
        MISCREG_ICH_LRC6,
        MISCREG_ICH_LRC7,
        MISCREG_ICH_LRC8,
        MISCREG_ICH_LRC9,
        MISCREG_ICH_LRC10,
        MISCREG_ICH_LRC11,
        MISCREG_ICH_LRC12,
        MISCREG_ICH_LRC13,
        MISCREG_ICH_LRC14,
        MISCREG_ICH_LRC15,
 
        // SVE
        MISCREG_ID_AA64ZFR0_EL1,
        MISCREG_ZCR_EL3,
        MISCREG_ZCR_EL2,
        MISCREG_ZCR_EL12,
        MISCREG_ZCR_EL1,
 
        // NUM_PHYS_MISCREGS specifies the number of actual physical
        // registers, not considering the following pseudo-registers
        // (dummy registers), like MISCREG_UNKNOWN, MISCREG_IMPDEF_UNIMPL.
        // Checkpointing should use this physical index when
        // saving/restoring register values.
        NUM_PHYS_MISCREGS,
 
        // Dummy registers
        MISCREG_NOP,
        MISCREG_RAZ,
        MISCREG_UNKNOWN,
 
        // Implementation defined register: this represent
        // a pool of unimplemented registers whose access can throw
        // either UNDEFINED or hypervisor trap exception.
        MISCREG_IMPDEF_UNIMPL,
 
        // RAS extension (unimplemented)
        MISCREG_ERRIDR_EL1,
        MISCREG_ERRSELR_EL1,
        MISCREG_ERXFR_EL1,
        MISCREG_ERXCTLR_EL1,
        MISCREG_ERXSTATUS_EL1,
        MISCREG_ERXADDR_EL1,
        MISCREG_ERXMISC0_EL1,
        MISCREG_ERXMISC1_EL1,
        MISCREG_DISR_EL1,
        MISCREG_VSESR_EL2,
        MISCREG_VDISR_EL2,
 
        // PSTATE
        MISCREG_PAN,
        MISCREG_UAO,
 
        // Total number of Misc Registers: Physical + Dummy
        NUM_MISCREGS
    };
 
    enum MiscRegInfo
    {
        MISCREG_IMPLEMENTED,
        MISCREG_UNVERIFIABLE,   // Does the value change on every read (e.g. a
                                // arch generic counter)
        MISCREG_WARN_NOT_FAIL,  // If MISCREG_IMPLEMENTED is deasserted, it
                                // tells whether the instruction should raise a
                                // warning or fail
        MISCREG_MUTEX,  // True if the register corresponds to a pair of
                        // mutually exclusive registers
        MISCREG_BANKED,  // True if the register is banked between the two
                         // security states, and this is the parent node of the
                         // two banked registers
        MISCREG_BANKED64, // True if the register is banked between the two
                          // security states, and this is the parent node of
                          // the two banked registers. Used in AA64 only.
        MISCREG_BANKED_CHILD, // The entry is one of the child registers that
                              // forms a banked set of regs (along with the
                              // other child regs)
 
        // Access permissions
        // User mode
        MISCREG_USR_NS_RD,
        MISCREG_USR_NS_WR,
        MISCREG_USR_S_RD,
        MISCREG_USR_S_WR,
        // Privileged modes other than hypervisor or monitor
        MISCREG_PRI_NS_RD,
        MISCREG_PRI_NS_WR,
        MISCREG_PRI_S_RD,
        MISCREG_PRI_S_WR,
        // Hypervisor mode
        MISCREG_HYP_NS_RD,
        MISCREG_HYP_NS_WR,
        MISCREG_HYP_S_RD,
        MISCREG_HYP_S_WR,
        // Hypervisor mode, HCR_EL2.E2H == 1
        MISCREG_HYP_E2H_NS_RD,
        MISCREG_HYP_E2H_NS_WR,
        MISCREG_HYP_E2H_S_RD,
        MISCREG_HYP_E2H_S_WR,
        // Monitor mode, SCR.NS == 0
        MISCREG_MON_NS0_RD,
        MISCREG_MON_NS0_WR,
        // Monitor mode, SCR.NS == 1
        MISCREG_MON_NS1_RD,
        MISCREG_MON_NS1_WR,
        // Monitor mode, HCR_EL2.E2H == 1
        MISCREG_MON_E2H_RD,
        MISCREG_MON_E2H_WR,
 
        NUM_MISCREG_INFOS
    };
 
    extern std::bitset<NUM_MISCREG_INFOS> miscRegInfo[NUM_MISCREGS];
 
    struct MiscRegNum32
    {
        MiscRegNum32(unsigned _coproc, unsigned _opc1,
                     unsigned _crn, unsigned _crm,
                     unsigned _opc2)
          : reg64(0), coproc(_coproc), opc1(_opc1), crn(_crn),
            crm(_crm), opc2(_opc2)
        {
            // MCR/MRC CP14 or CP15 register
            assert(coproc == 0b1110 || coproc == 0b1111);
            assert(opc1 < 8 && crn < 16 && crm < 16 && opc2 < 8);
        }
 
        MiscRegNum32(unsigned _coproc, unsigned _opc1,
                     unsigned _crm)
          : reg64(1), coproc(_coproc), opc1(_opc1), crn(0),
            crm(_crm), opc2(0)
        {
            // MCRR/MRRC CP14 or CP15 register
            assert(coproc == 0b1110 || coproc == 0b1111);
            assert(opc1 < 16 && crm < 16);
        }
 
        MiscRegNum32(const MiscRegNum32& rhs) = default;
 
        bool
        operator==(const MiscRegNum32 &other) const
        {
            return reg64 == other.reg64 &&
                coproc == other.coproc &&
                opc1 == other.opc1 &&
                crn == other.crn &&
                crm == other.crm &&
                opc2 == other.opc2;
        }
 
        uint32_t
        packed() const
        {
            return reg64 << 19  |
                   coproc << 15 |
                   opc1 << 11   |
                   crn << 7     |
                   crm << 3     |
                   opc2;
        }
 
        // 1 if the register is 64bit wide (accessed through MCRR/MRCC)
        // 0 otherwise. We need this when generating the hash as there
        // might be collisions between 32 and 64 bit registers
        const unsigned reg64;
 
        unsigned coproc;
        unsigned opc1;
        unsigned crn;
        unsigned crm;
        unsigned opc2;
    };
 
    struct MiscRegNum64
    {
        MiscRegNum64(unsigned _op0, unsigned _op1,
                     unsigned _crn, unsigned _crm,
                     unsigned _op2)
          : op0(_op0), op1(_op1), crn(_crn),
            crm(_crm), op2(_op2)
        {
            assert(op0 < 4 && op1 < 8 && crn < 16 && crm < 16 && op2 < 8);
        }
 
        MiscRegNum64(const MiscRegNum64& rhs) = default;
 
        bool
        operator==(const MiscRegNum64 &other) const
        {
            return op0 == other.op0 &&
                op1 == other.op1 &&
                crn == other.crn &&
                crm == other.crm &&
                op2 == other.op2;
        }
 
        uint32_t
        packed() const
        {
            return op0 << 14 |
                   op1 << 11 |
                   crn << 7  |
                   crm << 3  |
                   op2;
        }
 
        unsigned op0;
        unsigned op1;
        unsigned crn;
        unsigned crm;
        unsigned op2;
    };
 
    // Decodes 32-bit CP14 registers accessible through MCR/MRC instructions
    MiscRegIndex decodeCP14Reg(unsigned crn, unsigned opc1,
                               unsigned crm, unsigned opc2);
    MiscRegIndex decodeAArch64SysReg(unsigned op0, unsigned op1,
                                     unsigned crn, unsigned crm,
                                     unsigned op2);
    MiscRegNum64 encodeAArch64SysReg(MiscRegIndex misc_reg);
 
    // Whether a particular AArch64 system register is -always- read only.
    bool aarch64SysRegReadOnly(MiscRegIndex miscReg);
 
    // Decodes 32-bit CP15 registers accessible through MCR/MRC instructions
    MiscRegIndex decodeCP15Reg(unsigned crn, unsigned opc1,
                               unsigned crm, unsigned opc2);
 
    // Decodes 64-bit CP15 registers accessible through MCRR/MRRC instructions
    MiscRegIndex decodeCP15Reg64(unsigned crm, unsigned opc1);
 
 
    const char * const miscRegName[] = {
        "cpsr",
        "spsr",
        "spsr_fiq",
        "spsr_irq",
        "spsr_svc",
        "spsr_mon",
        "spsr_abt",
        "spsr_hyp",
        "spsr_und",
        "elr_hyp",
        "fpsid",
        "fpscr",
        "mvfr1",
        "mvfr0",
        "fpexc",
 
        // Helper registers
        "cpsr_mode",
        "cpsr_q",
        "fpscr_exc",
        "fpscr_qc",
        "lockaddr",
        "lockflag",
        "prrr_mair0",
        "prrr_mair0_ns",
        "prrr_mair0_s",
        "nmrr_mair1",
        "nmrr_mair1_ns",
        "nmrr_mair1_s",
        "pmxevtyper_pmccfiltr",
        "sctlr_rst",
        "sev_mailbox",
        "tlbi_needsync",
 
        // AArch32 CP14 registers
        "dbgdidr",
        "dbgdscrint",
        "dbgdccint",
        "dbgdtrtxint",
        "dbgdtrrxint",
        "dbgwfar",
        "dbgvcr",
        "dbgdtrrxext",
        "dbgdscrext",
        "dbgdtrtxext",
        "dbgoseccr",
        "dbgbvr0",
        "dbgbvr1",
        "dbgbvr2",
        "dbgbvr3",
        "dbgbvr4",
        "dbgbvr5",
        "dbgbvr6",
        "dbgbvr7",
        "dbgbvr8",
        "dbgbvr9",
        "dbgbvr10",
        "dbgbvr11",
        "dbgbvr12",
        "dbgbvr13",
        "dbgbvr14",
        "dbgbvr15",
        "dbgbcr0",
        "dbgbcr1",
        "dbgbcr2",
        "dbgbcr3",
        "dbgbcr4",
        "dbgbcr5",
        "dbgbcr6",
        "dbgbcr7",
        "dbgbcr8",
        "dbgbcr9",
        "dbgbcr10",
        "dbgbcr11",
        "dbgbcr12",
        "dbgbcr13",
        "dbgbcr14",
        "dbgbcr15",
        "dbgwvr0",
        "dbgwvr1",
        "dbgwvr2",
        "dbgwvr3",
        "dbgwvr4",
        "dbgwvr5",
        "dbgwvr6",
        "dbgwvr7",
        "dbgwvr8",
        "dbgwvr9",
        "dbgwvr10",
        "dbgwvr11",
        "dbgwvr12",
        "dbgwvr13",
        "dbgwvr14",
        "dbgwvr15",
        "dbgwcr0",
        "dbgwcr1",
        "dbgwcr2",
        "dbgwcr3",
        "dbgwcr4",
        "dbgwcr5",
        "dbgwcr6",
        "dbgwcr7",
        "dbgwcr8",
        "dbgwcr9",
        "dbgwcr10",
        "dbgwcr11",
        "dbgwcr12",
        "dbgwcr13",
        "dbgwcr14",
        "dbgwcr15",
        "dbgdrar",
        "dbgbxvr0",
        "dbgbxvr1",
        "dbgbxvr2",
        "dbgbxvr3",
        "dbgbxvr4",
        "dbgbxvr5",
        "dbgbxvr6",
        "dbgbxvr7",
        "dbgbxvr8",
        "dbgbxvr9",
        "dbgbxvr10",
        "dbgbxvr11",
        "dbgbxvr12",
        "dbgbxvr13",
        "dbgbxvr14",
        "dbgbxvr15",
        "dbgoslar",
        "dbgoslsr",
        "dbgosdlr",
        "dbgprcr",
        "dbgdsar",
        "dbgclaimset",
        "dbgclaimclr",
        "dbgauthstatus",
        "dbgdevid2",
        "dbgdevid1",
        "dbgdevid0",
        "teecr",
        "jidr",
        "teehbr",
        "joscr",
        "jmcr",
 
        // AArch32 CP15 registers
        "midr",
        "ctr",
        "tcmtr",
        "tlbtr",
        "mpidr",
        "revidr",
        "id_pfr0",
        "id_pfr1",
        "id_dfr0",
        "id_afr0",
        "id_mmfr0",
        "id_mmfr1",
        "id_mmfr2",
        "id_mmfr3",
        "id_mmfr4",
        "id_isar0",
        "id_isar1",
        "id_isar2",
        "id_isar3",
        "id_isar4",
        "id_isar5",
        "id_isar6",
        "ccsidr",
        "clidr",
        "aidr",
        "csselr",
        "csselr_ns",
        "csselr_s",
        "vpidr",
        "vmpidr",
        "sctlr",
        "sctlr_ns",
        "sctlr_s",
        "actlr",
        "actlr_ns",
        "actlr_s",
        "cpacr",
        "sdcr",
        "scr",
        "sder",
        "nsacr",
        "hsctlr",
        "hactlr",
        "hcr",
        "hcr2",
        "hdcr",
        "hcptr",
        "hstr",
        "hacr",
        "ttbr0",
        "ttbr0_ns",
        "ttbr0_s",
        "ttbr1",
        "ttbr1_ns",
        "ttbr1_s",
        "ttbcr",
        "ttbcr_ns",
        "ttbcr_s",
        "htcr",
        "vtcr",
        "dacr",
        "dacr_ns",
        "dacr_s",
        "dfsr",
        "dfsr_ns",
        "dfsr_s",
        "ifsr",
        "ifsr_ns",
        "ifsr_s",
        "adfsr",
        "adfsr_ns",
        "adfsr_s",
        "aifsr",
        "aifsr_ns",
        "aifsr_s",
        "hadfsr",
        "haifsr",
        "hsr",
        "dfar",
        "dfar_ns",
        "dfar_s",
        "ifar",
        "ifar_ns",
        "ifar_s",
        "hdfar",
        "hifar",
        "hpfar",
        "icialluis",
        "bpiallis",
        "par",
        "par_ns",
        "par_s",
        "iciallu",
        "icimvau",
        "cp15isb",
        "bpiall",
        "bpimva",
        "dcimvac",
        "dcisw",
        "ats1cpr",
        "ats1cpw",
        "ats1cur",
        "ats1cuw",
        "ats12nsopr",
        "ats12nsopw",
        "ats12nsour",
        "ats12nsouw",
        "dccmvac",
        "dccsw",
        "cp15dsb",
        "cp15dmb",
        "dccmvau",
        "dccimvac",
        "dccisw",
        "ats1hr",
        "ats1hw",
        "tlbiallis",
        "tlbimvais",
        "tlbiasidis",
        "tlbimvaais",
        "tlbimvalis",
        "tlbimvaalis",
        "itlbiall",
        "itlbimva",
        "itlbiasid",
        "dtlbiall",
        "dtlbimva",
        "dtlbiasid",
        "tlbiall",
        "tlbimva",
        "tlbiasid",
        "tlbimvaa",
        "tlbimval",
        "tlbimvaal",
        "tlbiipas2is",
        "tlbiipas2lis",
        "tlbiallhis",
        "tlbimvahis",
        "tlbiallnsnhis",
        "tlbimvalhis",
        "tlbiipas2",
        "tlbiipas2l",
        "tlbiallh",
        "tlbimvah",
        "tlbiallnsnh",
        "tlbimvalh",
        "pmcr",
        "pmcntenset",
        "pmcntenclr",
        "pmovsr",
        "pmswinc",
        "pmselr",
        "pmceid0",
        "pmceid1",
        "pmccntr",
        "pmxevtyper",
        "pmccfiltr",
        "pmxevcntr",
        "pmuserenr",
        "pmintenset",
        "pmintenclr",
        "pmovsset",
        "l2ctlr",
        "l2ectlr",
        "prrr",
        "prrr_ns",
        "prrr_s",
        "mair0",
        "mair0_ns",
        "mair0_s",
        "nmrr",
        "nmrr_ns",
        "nmrr_s",
        "mair1",
        "mair1_ns",
        "mair1_s",
        "amair0",
        "amair0_ns",
        "amair0_s",
        "amair1",
        "amair1_ns",
        "amair1_s",
        "hmair0",
        "hmair1",
        "hamair0",
        "hamair1",
        "vbar",
        "vbar_ns",
        "vbar_s",
        "mvbar",
        "rmr",
        "isr",
        "hvbar",
        "fcseidr",
        "contextidr",
        "contextidr_ns",
        "contextidr_s",
        "tpidrurw",
        "tpidrurw_ns",
        "tpidrurw_s",
        "tpidruro",
        "tpidruro_ns",
        "tpidruro_s",
        "tpidrprw",
        "tpidrprw_ns",
        "tpidrprw_s",
        "htpidr",
        "cntfrq",
        "cntpct",
        "cntvct",
        "cntp_ctl",
        "cntp_ctl_ns",
        "cntp_ctl_s",
        "cntp_cval",
        "cntp_cval_ns",
        "cntp_cval_s",
        "cntp_tval",
        "cntp_tval_ns",
        "cntp_tval_s",
        "cntv_ctl",
        "cntv_cval",
        "cntv_tval",
        "cntkctl",
        "cnthctl",
        "cnthp_ctl",
        "cnthp_cval",
        "cnthp_tval",
        "cntvoff",
        "il1data0",
        "il1data1",
        "il1data2",
        "il1data3",
        "dl1data0",
        "dl1data1",
        "dl1data2",
        "dl1data3",
        "dl1data4",
        "ramindex",
        "l2actlr",
        "cbar",
        "httbr",
        "vttbr",
        "cpumerrsr",
        "l2merrsr",
 
        // AArch64 registers (Op0=2)
        "mdccint_el1",
        "osdtrrx_el1",
        "mdscr_el1",
        "osdtrtx_el1",
        "oseccr_el1",
        "dbgbvr0_el1",
        "dbgbvr1_el1",
        "dbgbvr2_el1",
        "dbgbvr3_el1",
        "dbgbvr4_el1",
        "dbgbvr5_el1",
        "dbgbvr6_el1",
        "dbgbvr7_el1",
        "dbgbvr8_el1",
        "dbgbvr9_el1",
        "dbgbvr10_el1",
        "dbgbvr11_el1",
        "dbgbvr12_el1",
        "dbgbvr13_el1",
        "dbgbvr14_el1",
        "dbgbvr15_el1",
        "dbgbcr0_el1",
        "dbgbcr1_el1",
        "dbgbcr2_el1",
        "dbgbcr3_el1",
        "dbgbcr4_el1",
        "dbgbcr5_el1",
        "dbgbcr6_el1",
        "dbgbcr7_el1",
        "dbgbcr8_el1",
        "dbgbcr9_el1",
        "dbgbcr10_el1",
        "dbgbcr11_el1",
        "dbgbcr12_el1",
        "dbgbcr13_el1",
        "dbgbcr14_el1",
        "dbgbcr15_el1",
        "dbgwvr0_el1",
        "dbgwvr1_el1",
        "dbgwvr2_el1",
        "dbgwvr3_el1",
        "dbgwvr4_el1",
        "dbgwvr5_el1",
        "dbgwvr6_el1",
        "dbgwvr7_el1",
        "dbgwvr8_el1",
        "dbgwvr9_el1",
        "dbgwvr10_el1",
        "dbgwvr11_el1",
        "dbgwvr12_el1",
        "dbgwvr13_el1",
        "dbgwvr14_el1",
        "dbgwvr15_el1",
        "dbgwcr0_el1",
        "dbgwcr1_el1",
        "dbgwcr2_el1",
        "dbgwcr3_el1",
        "dbgwcr4_el1",
        "dbgwcr5_el1",
        "dbgwcr6_el1",
        "dbgwcr7_el1",
        "dbgwcr8_el1",
        "dbgwcr9_el1",
        "dbgwcr10_el1",
        "dbgwcr11_el1",
        "dbgwcr12_el1",
        "dbgwcr13_el1",
        "dbgwcr14_el1",
        "dbgwcr15_el1",
        "mdccsr_el0",
        "mddtr_el0",
        "mddtrtx_el0",
        "mddtrrx_el0",
        "dbgvcr32_el2",
        "mdrar_el1",
        "oslar_el1",
        "oslsr_el1",
        "osdlr_el1",
        "dbgprcr_el1",
        "dbgclaimset_el1",
        "dbgclaimclr_el1",
        "dbgauthstatus_el1",
        "teecr32_el1",
        "teehbr32_el1",
 
        // AArch64 registers (Op0=1,3)
        "midr_el1",
        "mpidr_el1",
        "revidr_el1",
        "id_pfr0_el1",
        "id_pfr1_el1",
        "id_dfr0_el1",
        "id_afr0_el1",
        "id_mmfr0_el1",
        "id_mmfr1_el1",
        "id_mmfr2_el1",
        "id_mmfr3_el1",
        "id_mmfr4_el1",
        "id_isar0_el1",
        "id_isar1_el1",
        "id_isar2_el1",
        "id_isar3_el1",
        "id_isar4_el1",
        "id_isar5_el1",
        "id_isar6_el1",
        "mvfr0_el1",
        "mvfr1_el1",
        "mvfr2_el1",
        "id_aa64pfr0_el1",
        "id_aa64pfr1_el1",
        "id_aa64dfr0_el1",
        "id_aa64dfr1_el1",
        "id_aa64afr0_el1",
        "id_aa64afr1_el1",
        "id_aa64isar0_el1",
        "id_aa64isar1_el1",
        "id_aa64mmfr0_el1",
        "id_aa64mmfr1_el1",
        "ccsidr_el1",
        "clidr_el1",
        "aidr_el1",
        "csselr_el1",
        "ctr_el0",
        "dczid_el0",
        "vpidr_el2",
        "vmpidr_el2",
        "sctlr_el1",
        "sctlr_el12",
        "actlr_el1",
        "cpacr_el1",
        "cpacr_el12",
        "sctlr_el2",
        "actlr_el2",
        "hcr_el2",
        "mdcr_el2",
        "cptr_el2",
        "hstr_el2",
        "hacr_el2",
        "sctlr_el3",
        "actlr_el3",
        "scr_el3",
        "sder32_el3",
        "cptr_el3",
        "mdcr_el3",
        "ttbr0_el1",
        "ttbr0_el12",
        "ttbr1_el1",
        "ttbr1_el12",
        "tcr_el1",
        "tcr_el12",
        "ttbr0_el2",
        "tcr_el2",
        "vttbr_el2",
        "vtcr_el2",
        "vsttbr_el2",
        "vstcr_el2",
        "ttbr0_el3",
        "tcr_el3",
        "dacr32_el2",
        "spsr_el1",
        "spsr_el12",
        "elr_el1",
        "elr_el12",
        "sp_el0",
        "spsel",
        "currentel",
        "nzcv",
        "daif",
        "fpcr",
        "fpsr",
        "dspsr_el0",
        "dlr_el0",
        "spsr_el2",
        "elr_el2",
        "sp_el1",
        "spsr_irq_aa64",
        "spsr_abt_aa64",
        "spsr_und_aa64",
        "spsr_fiq_aa64",
        "spsr_el3",
        "elr_el3",
        "sp_el2",
        "afsr0_el1",
        "afsr0_el12",
        "afsr1_el1",
        "afsr1_el12",
        "esr_el1",
        "esr_el12",
        "ifsr32_el2",
        "afsr0_el2",
        "afsr1_el2",
        "esr_el2",
        "fpexc32_el2",
        "afsr0_el3",
        "afsr1_el3",
        "esr_el3",
        "far_el1",
        "far_el12",
        "far_el2",
        "hpfar_el2",
        "far_el3",
        "ic_ialluis",
        "par_el1",
        "ic_iallu",
        "dc_ivac_xt",
        "dc_isw_xt",
        "at_s1e1r_xt",
        "at_s1e1w_xt",
        "at_s1e0r_xt",
        "at_s1e0w_xt",
        "dc_csw_xt",
        "dc_cisw_xt",
        "dc_zva_xt",
        "ic_ivau_xt",
        "dc_cvac_xt",
        "dc_cvau_xt",
        "dc_civac_xt",
        "at_s1e2r_xt",
        "at_s1e2w_xt",
        "at_s12e1r_xt",
        "at_s12e1w_xt",
        "at_s12e0r_xt",
        "at_s12e0w_xt",
        "at_s1e3r_xt",
        "at_s1e3w_xt",
        "tlbi_vmalle1is",
        "tlbi_vae1is_xt",
        "tlbi_aside1is_xt",
        "tlbi_vaae1is_xt",
        "tlbi_vale1is_xt",
        "tlbi_vaale1is_xt",
        "tlbi_vmalle1",
        "tlbi_vae1_xt",
        "tlbi_aside1_xt",
        "tlbi_vaae1_xt",
        "tlbi_vale1_xt",
        "tlbi_vaale1_xt",
        "tlbi_ipas2e1is_xt",
        "tlbi_ipas2le1is_xt",
        "tlbi_alle2is",
        "tlbi_vae2is_xt",
        "tlbi_alle1is",
        "tlbi_vale2is_xt",
        "tlbi_vmalls12e1is",
        "tlbi_ipas2e1_xt",
        "tlbi_ipas2le1_xt",
        "tlbi_alle2",
        "tlbi_vae2_xt",
        "tlbi_alle1",
        "tlbi_vale2_xt",
        "tlbi_vmalls12e1",
        "tlbi_alle3is",
        "tlbi_vae3is_xt",
        "tlbi_vale3is_xt",
        "tlbi_alle3",
        "tlbi_vae3_xt",
        "tlbi_vale3_xt",
        "pmintenset_el1",
        "pmintenclr_el1",
        "pmcr_el0",
        "pmcntenset_el0",
        "pmcntenclr_el0",
        "pmovsclr_el0",
        "pmswinc_el0",
        "pmselr_el0",
        "pmceid0_el0",
        "pmceid1_el0",
        "pmccntr_el0",
        "pmxevtyper_el0",
        "pmccfiltr_el0",
        "pmxevcntr_el0",
        "pmuserenr_el0",
        "pmovsset_el0",
        "mair_el1",
        "mair_el12",
        "amair_el1",
        "amair_el12",
        "mair_el2",
        "amair_el2",
        "mair_el3",
        "amair_el3",
        "l2ctlr_el1",
        "l2ectlr_el1",
        "vbar_el1",
        "vbar_el12",
        "rvbar_el1",
        "isr_el1",
        "vbar_el2",
        "rvbar_el2",
        "vbar_el3",
        "rvbar_el3",
        "rmr_el3",
        "contextidr_el1",
        "contextidr_el12",
        "tpidr_el1",
        "tpidr_el0",
        "tpidrro_el0",
        "tpidr_el2",
        "tpidr_el3",
        "cntfrq_el0",
        "cntpct_el0",
        "cntvct_el0",
        "cntp_ctl_el0",
        "cntp_cval_el0",
        "cntp_tval_el0",
        "cntv_ctl_el0",
        "cntv_cval_el0",
        "cntv_tval_el0",
        "cntp_ctl_el02",
        "cntp_cval_el02",
        "cntp_tval_el02",
        "cntv_ctl_el02",
        "cntv_cval_el02",
        "cntv_tval_el02",
        "cntkctl_el1",
        "cntkctl_el12",
        "cntps_ctl_el1",
        "cntps_cval_el1",
        "cntps_tval_el1",
        "cnthctl_el2",
        "cnthp_ctl_el2",
        "cnthp_cval_el2",
        "cnthp_tval_el2",
        "cnthps_ctl_el2",
        "cnthps_cval_el2",
        "cnthps_tval_el2",
        "cnthv_ctl_el2",
        "cnthv_cval_el2",
        "cnthv_tval_el2",
        "cnthvs_ctl_el2",
        "cnthvs_cval_el2",
        "cnthvs_tval_el2",
        "cntvoff_el2",
        "pmevcntr0_el0",
        "pmevcntr1_el0",
        "pmevcntr2_el0",
        "pmevcntr3_el0",
        "pmevcntr4_el0",
        "pmevcntr5_el0",
        "pmevtyper0_el0",
        "pmevtyper1_el0",
        "pmevtyper2_el0",
        "pmevtyper3_el0",
        "pmevtyper4_el0",
        "pmevtyper5_el0",
        "il1data0_el1",
        "il1data1_el1",
        "il1data2_el1",
        "il1data3_el1",
        "dl1data0_el1",
        "dl1data1_el1",
        "dl1data2_el1",
        "dl1data3_el1",
        "dl1data4_el1",
        "l2actlr_el1",
        "cpuactlr_el1",
        "cpuectlr_el1",
        "cpumerrsr_el1",
        "l2merrsr_el1",
        "cbar_el1",
        "contextidr_el2",
 
        "ttbr1_el2",
        "id_aa64mmfr2_el1",
 
        "apdakeyhi_el1",
        "apdakeylo_el1",
        "apdbkeyhi_el1",
        "apdbkeylo_el1",
        "apgakeyhi_el1",
        "apgakeylo_el1",
        "apiakeyhi_el1",
        "apiakeylo_el1",
        "apibkeyhi_el1",
        "apibkeylo_el1",
        // GICv3, CPU interface
        "icc_pmr_el1",
        "icc_iar0_el1",
        "icc_eoir0_el1",
        "icc_hppir0_el1",
        "icc_bpr0_el1",
        "icc_ap0r0_el1",
        "icc_ap0r1_el1",
        "icc_ap0r2_el1",
        "icc_ap0r3_el1",
        "icc_ap1r0_el1",
        "icc_ap1r0_el1_ns",
        "icc_ap1r0_el1_s",
        "icc_ap1r1_el1",
        "icc_ap1r1_el1_ns",
        "icc_ap1r1_el1_s",
        "icc_ap1r2_el1",
        "icc_ap1r2_el1_ns",
        "icc_ap1r2_el1_s",
        "icc_ap1r3_el1",
        "icc_ap1r3_el1_ns",
        "icc_ap1r3_el1_s",
        "icc_dir_el1",
        "icc_rpr_el1",
        "icc_sgi1r_el1",
        "icc_asgi1r_el1",
        "icc_sgi0r_el1",
        "icc_iar1_el1",
        "icc_eoir1_el1",
        "icc_hppir1_el1",
        "icc_bpr1_el1",
        "icc_bpr1_el1_ns",
        "icc_bpr1_el1_s",
        "icc_ctlr_el1",
        "icc_ctlr_el1_ns",
        "icc_ctlr_el1_s",
        "icc_sre_el1",
        "icc_sre_el1_ns",
        "icc_sre_el1_s",
        "icc_igrpen0_el1",
        "icc_igrpen1_el1",
        "icc_igrpen1_el1_ns",
        "icc_igrpen1_el1_s",
        "icc_sre_el2",
        "icc_ctlr_el3",
        "icc_sre_el3",
        "icc_igrpen1_el3",
 
        // GICv3, CPU interface, virtualization
        "ich_ap0r0_el2",
        "ich_ap0r1_el2",
        "ich_ap0r2_el2",
        "ich_ap0r3_el2",
        "ich_ap1r0_el2",
        "ich_ap1r1_el2",
        "ich_ap1r2_el2",
        "ich_ap1r3_el2",
        "ich_hcr_el2",
        "ich_vtr_el2",
        "ich_misr_el2",
        "ich_eisr_el2",
        "ich_elrsr_el2",
        "ich_vmcr_el2",
        "ich_lr0_el2",
        "ich_lr1_el2",
        "ich_lr2_el2",
        "ich_lr3_el2",
        "ich_lr4_el2",
        "ich_lr5_el2",
        "ich_lr6_el2",
        "ich_lr7_el2",
        "ich_lr8_el2",
        "ich_lr9_el2",
        "ich_lr10_el2",
        "ich_lr11_el2",
        "ich_lr12_el2",
        "ich_lr13_el2",
        "ich_lr14_el2",
        "ich_lr15_el2",
 
        "icv_pmr_el1",
        "icv_iar0_el1",
        "icv_eoir0_el1",
        "icv_hppir0_el1",
        "icv_bpr0_el1",
        "icv_ap0r0_el1",
        "icv_ap0r1_el1",
        "icv_ap0r2_el1",
        "icv_ap0r3_el1",
        "icv_ap1r0_el1",
        "icv_ap1r0_el1_ns",
        "icv_ap1r0_el1_s",
        "icv_ap1r1_el1",
        "icv_ap1r1_el1_ns",
        "icv_ap1r1_el1_s",
        "icv_ap1r2_el1",
        "icv_ap1r2_el1_ns",
        "icv_ap1r2_el1_s",
        "icv_ap1r3_el1",
        "icv_ap1r3_el1_ns",
        "icv_ap1r3_el1_s",
        "icv_dir_el1",
        "icv_rpr_el1",
        "icv_sgi1r_el1",
        "icv_asgi1r_el1",
        "icv_sgi0r_el1",
        "icv_iar1_el1",
        "icv_eoir1_el1",
        "icv_hppir1_el1",
        "icv_bpr1_el1",
        "icv_bpr1_el1_ns",
        "icv_bpr1_el1_s",
        "icv_ctlr_el1",
        "icv_ctlr_el1_ns",
        "icv_ctlr_el1_s",
        "icv_sre_el1",
        "icv_sre_el1_ns",
        "icv_sre_el1_s",
        "icv_igrpen0_el1",
        "icv_igrpen1_el1",
        "icv_igrpen1_el1_ns",
        "icv_igrpen1_el1_s",
 
        "icc_ap0r0",
        "icc_ap0r1",
        "icc_ap0r2",
        "icc_ap0r3",
        "icc_ap1r0",
        "icc_ap1r0_ns",
        "icc_ap1r0_s",
        "icc_ap1r1",
        "icc_ap1r1_ns",
        "icc_ap1r1_s",
        "icc_ap1r2",
        "icc_ap1r2_ns",
        "icc_ap1r2_s",
        "icc_ap1r3",
        "icc_ap1r3_ns",
        "icc_ap1r3_s",
        "icc_asgi1r",
        "icc_bpr0",
        "icc_bpr1",
        "icc_bpr1_ns",
        "icc_bpr1_s",
        "icc_ctlr",
        "icc_ctlr_ns",
        "icc_ctlr_s",
        "icc_dir",
        "icc_eoir0",
        "icc_eoir1",
        "icc_hppir0",
        "icc_hppir1",
        "icc_hsre",
        "icc_iar0",
        "icc_iar1",
        "icc_igrpen0",
        "icc_igrpen1",
        "icc_igrpen1_ns",
        "icc_igrpen1_s",
        "icc_mctlr",
        "icc_mgrpen1",
        "icc_msre",
        "icc_pmr",
        "icc_rpr",
        "icc_sgi0r",
        "icc_sgi1r",
        "icc_sre",
        "icc_sre_ns",
        "icc_sre_s",
 
        "ich_ap0r0",
        "ich_ap0r1",
        "ich_ap0r2",
        "ich_ap0r3",
        "ich_ap1r0",
        "ich_ap1r1",
        "ich_ap1r2",
        "ich_ap1r3",
        "ich_hcr",
        "ich_vtr",
        "ich_misr",
        "ich_eisr",
        "ich_elrsr",
        "ich_vmcr",
        "ich_lr0",
        "ich_lr1",
        "ich_lr2",
        "ich_lr3",
        "ich_lr4",
        "ich_lr5",
        "ich_lr6",
        "ich_lr7",
        "ich_lr8",
        "ich_lr9",
        "ich_lr10",
        "ich_lr11",
        "ich_lr12",
        "ich_lr13",
        "ich_lr14",
        "ich_lr15",
        "ich_lrc0",
        "ich_lrc1",
        "ich_lrc2",
        "ich_lrc3",
        "ich_lrc4",
        "ich_lrc5",
        "ich_lrc6",
        "ich_lrc7",
        "ich_lrc8",
        "ich_lrc9",
        "ich_lrc10",
        "ich_lrc11",
        "ich_lrc12",
        "ich_lrc13",
        "ich_lrc14",
        "ich_lrc15",
 
        "id_aa64zfr0_el1",
        "zcr_el3",
        "zcr_el2",
        "zcr_el12",
        "zcr_el1",
 
        "num_phys_regs",
 
        // Dummy registers
        "nop",
        "raz",
        "unknown",
        "impl_defined",
        "erridr_el1",
        "errselr_el1",
        "erxfr_el1",
        "erxctlr_el1",
        "erxstatus_el1",
        "erxaddr_el1",
        "erxmisc0_el1",
        "erxmisc1_el1",
        "disr_el1",
        "vsesr_el2",
        "vdisr_el2",
 
        // PSTATE
        "pan",
        "uao",
    };
 
    static_assert(sizeof(miscRegName) / sizeof(*miscRegName) == NUM_MISCREGS,
                  "The miscRegName array and NUM_MISCREGS are inconsistent.");
 
    // This mask selects bits of the CPSR that actually go in the CondCodes
    // integer register to allow renaming.
    static const uint32_t CondCodesMask   = 0xF00F0000;
    static const uint32_t CpsrMaskQ       = 0x08000000;
 
    // APSR (Application Program Status Register Mask). It is the user level
    // alias for the CPSR. The APSR is a subset of the CPSR. Although
    // bits[15:0] are UNKNOWN on reads, it is permitted that, on a read of
    // APSR:
    // Bit[9] returns the value of CPSR.E.
    // Bits[8:6] return the value of CPSR.{A,I, F}, the mask bits.
    static const uint32_t ApsrMask = CpsrMaskQ | CondCodesMask | 0x000001D0;
 
    // CPSR (Current Program Status Register Mask).
    static const uint32_t CpsrMask = ApsrMask | 0x00F003DF;
 
    // This mask selects bits of the FPSCR that actually go in the FpCondCodes
    // integer register to allow renaming.
    static const uint32_t FpCondCodesMask = 0xF0000000;
    // This mask selects the cumulative saturation flag of the FPSCR.
    static const uint32_t FpscrQcMask = 0x08000000;
    // This mask selects the AHP bit of the FPSCR.
    static const uint32_t FpscrAhpMask = 0x04000000;
    // This mask selects the cumulative FP exception flags of the FPSCR.
    static const uint32_t FpscrExcMask = 0x0000009F;
 
    std::tuple<bool, bool> canReadCoprocReg(MiscRegIndex reg, SCR scr,
                                            CPSR cpsr, ThreadContext *tc);
 
    std::tuple<bool, bool> canWriteCoprocReg(MiscRegIndex reg, SCR scr,
                                             CPSR cpsr, ThreadContext *tc);
 
    // Checks for UNDEFINED behaviours when accessing AArch32
    // Generic Timer system registers
    bool AArch32isUndefinedGenericTimer(MiscRegIndex reg, ThreadContext *tc);
 
    // Checks read access permissions to AArch64 system registers
    bool canReadAArch64SysReg(MiscRegIndex reg, HCR hcr, SCR scr, CPSR cpsr,
                              ThreadContext *tc);
 
    // Checks write access permissions to AArch64 system registers
    bool canWriteAArch64SysReg(MiscRegIndex reg, HCR hcr, SCR scr, CPSR cpsr,
                               ThreadContext *tc);
 
    // Uses just the scr.ns bit to pre flatten the misc regs. This is useful
    // for MCR/MRC instructions
    int
    snsBankedIndex(MiscRegIndex reg, ThreadContext *tc);
 
    // Flattens a misc reg index using the specified security state. This is
    // used for opperations (eg address translations) where the security
    // state of the register access may differ from the current state of the
    // processor
    int
    snsBankedIndex(MiscRegIndex reg, ThreadContext *tc, bool ns);
 
    int
    snsBankedIndex64(MiscRegIndex reg, ThreadContext *tc);
 
    // Takes a misc reg index and returns the root reg if its one of a set of
    // banked registers
    void
    preUnflattenMiscReg();
 
    int
    unflattenMiscReg(int reg);
 
} // namespace ArmISA
} // namespace gem5
 
namespace std
{
template<>
struct hash<gem5::ArmISA::MiscRegNum32>
{
    size_t
    operator()(const gem5::ArmISA::MiscRegNum32& reg) const
    {
        return reg.packed();
    }
};
 
template<>
struct hash<gem5::ArmISA::MiscRegNum64>
{
    size_t
    operator()(const gem5::ArmISA::MiscRegNum64& reg) const
    {
        return reg.packed();
    }
};
} // namespace std
 
#endif // __ARCH_ARM_REGS_MISC_HH__