48#include "params/ArmISA.hh"
60std::unordered_map<MiscRegNum32, MiscRegIndex> miscRegNum32ToIdx{
538 auto it = miscRegNum32ToIdx.find(cop_reg);
539 if (it != miscRegNum32ToIdx.end()) {
542 warn(
"CP14 unimplemented crn[%d], opc1[%d], crm[%d], opc2[%d]",
543 crn, opc1, crm,
opc2);
552 auto it = miscRegNum32ToIdx.find(cop_reg);
553 if (it != miscRegNum32ToIdx.end()) {
557 (crn == 9 && (crm <= 2 || crm >= 5)) ||
558 (crn == 10 && opc1 == 0 && crm <= 1) ||
559 (crn == 11 && opc1 <= 7 && (crm <= 8 || crm ==15))) {
571 auto it = miscRegNum32ToIdx.find(cop_reg);
572 if (it != miscRegNum32ToIdx.end()) {
579std::tuple<bool, bool>
582 bool secure = !scr.ns;
583 bool can_read =
false;
584 bool undefined =
false;
623 return std::make_tuple(can_read, undefined);
626std::tuple<bool, bool>
629 bool secure = !scr.ns;
630 bool can_write =
false;
631 bool undefined =
false;
670 return std::make_tuple(can_write, undefined);
679 if (trap_cond && (!
EL2Enabled(tc) || !hcr.tge))
695 int reg_as_int =
static_cast<int>(
reg);
708 return isa->snsBankedIndex64(
reg, scr.ns);
755std::unordered_map<MiscRegIndex, MiscRegNum64> idxToMiscRegNum;
759std::unordered_map<MiscRegNum64, MiscRegIndex> miscRegNumToIdx{
770 { MiscRegNum64(1, 0, 8, 1, 0), MISCREG_TLBI_VMALLE1OS },
771 { MiscRegNum64(1, 0, 8, 1, 1), MISCREG_TLBI_VAE1OS },
772 { MiscRegNum64(1, 0, 8, 1, 2), MISCREG_TLBI_ASIDE1OS },
773 { MiscRegNum64(1, 0, 8, 1, 3), MISCREG_TLBI_VAAE1OS },
774 { MiscRegNum64(1, 0, 8, 1, 5), MISCREG_TLBI_VALE1OS },
775 { MiscRegNum64(1, 0, 8, 1, 7), MISCREG_TLBI_VAALE1OS },
776 { MiscRegNum64(1, 0, 8, 2, 1), MISCREG_TLBI_RVAE1IS },
777 { MiscRegNum64(1, 0, 8, 2, 3), MISCREG_TLBI_RVAAE1IS },
778 { MiscRegNum64(1, 0, 8, 2, 5), MISCREG_TLBI_RVALE1IS },
779 { MiscRegNum64(1, 0, 8, 2, 7), MISCREG_TLBI_RVAALE1IS },
780 { MiscRegNum64(1, 0, 8, 3, 0), MISCREG_TLBI_VMALLE1IS },
781 { MiscRegNum64(1, 0, 8, 3, 1), MISCREG_TLBI_VAE1IS },
782 { MiscRegNum64(1, 0, 8, 3, 2), MISCREG_TLBI_ASIDE1IS },
783 { MiscRegNum64(1, 0, 8, 3, 3), MISCREG_TLBI_VAAE1IS },
784 { MiscRegNum64(1, 0, 8, 3, 5), MISCREG_TLBI_VALE1IS },
785 { MiscRegNum64(1, 0, 8, 3, 7), MISCREG_TLBI_VAALE1IS },
786 { MiscRegNum64(1, 0, 8, 5, 1), MISCREG_TLBI_RVAE1OS },
787 { MiscRegNum64(1, 0, 8, 5, 3), MISCREG_TLBI_RVAAE1OS },
788 { MiscRegNum64(1, 0, 8, 5, 5), MISCREG_TLBI_RVALE1OS },
789 { MiscRegNum64(1, 0, 8, 5, 7), MISCREG_TLBI_RVAALE1OS },
790 { MiscRegNum64(1, 0, 8, 6, 1), MISCREG_TLBI_RVAE1 },
791 { MiscRegNum64(1, 0, 8, 6, 3), MISCREG_TLBI_RVAAE1 },
792 { MiscRegNum64(1, 0, 8, 6, 5), MISCREG_TLBI_RVALE1 },
793 { MiscRegNum64(1, 0, 8, 6, 7), MISCREG_TLBI_RVAALE1 },
794 { MiscRegNum64(1, 0, 8, 7, 0), MISCREG_TLBI_VMALLE1 },
795 { MiscRegNum64(1, 0, 8, 7, 1), MISCREG_TLBI_VAE1 },
796 { MiscRegNum64(1, 0, 8, 7, 2), MISCREG_TLBI_ASIDE1 },
797 { MiscRegNum64(1, 0, 8, 7, 3), MISCREG_TLBI_VAAE1 },
798 { MiscRegNum64(1, 0, 8, 7, 5), MISCREG_TLBI_VALE1 },
799 { MiscRegNum64(1, 0, 8, 7, 7), MISCREG_TLBI_VAALE1 },
800 { MiscRegNum64(1, 0, 9, 1, 0), MISCREG_TLBI_VMALLE1OSNXS },
801 { MiscRegNum64(1, 0, 9, 1, 1), MISCREG_TLBI_VAE1OSNXS },
802 { MiscRegNum64(1, 0, 9, 1, 2), MISCREG_TLBI_ASIDE1OSNXS },
803 { MiscRegNum64(1, 0, 9, 1, 3), MISCREG_TLBI_VAAE1OSNXS },
804 { MiscRegNum64(1, 0, 9, 1, 5), MISCREG_TLBI_VALE1OSNXS },
805 { MiscRegNum64(1, 0, 9, 1, 7), MISCREG_TLBI_VAALE1OSNXS },
806 { MiscRegNum64(1, 0, 9, 2, 1), MISCREG_TLBI_RVAE1ISNXS },
807 { MiscRegNum64(1, 0, 9, 2, 3), MISCREG_TLBI_RVAAE1ISNXS },
808 { MiscRegNum64(1, 0, 9, 2, 5), MISCREG_TLBI_RVALE1ISNXS },
809 { MiscRegNum64(1, 0, 9, 2, 7), MISCREG_TLBI_RVAALE1ISNXS },
810 { MiscRegNum64(1, 0, 9, 3, 0), MISCREG_TLBI_VMALLE1ISNXS },
811 { MiscRegNum64(1, 0, 9, 3, 1), MISCREG_TLBI_VAE1ISNXS },
812 { MiscRegNum64(1, 0, 9, 3, 2), MISCREG_TLBI_ASIDE1ISNXS },
813 { MiscRegNum64(1, 0, 9, 3, 3), MISCREG_TLBI_VAAE1ISNXS },
814 { MiscRegNum64(1, 0, 9, 3, 5), MISCREG_TLBI_VALE1ISNXS },
815 { MiscRegNum64(1, 0, 9, 3, 7), MISCREG_TLBI_VAALE1ISNXS },
816 { MiscRegNum64(1, 0, 9, 5, 1), MISCREG_TLBI_RVAE1OSNXS },
817 { MiscRegNum64(1, 0, 9, 5, 3), MISCREG_TLBI_RVAAE1OSNXS },
818 { MiscRegNum64(1, 0, 9, 5, 5), MISCREG_TLBI_RVALE1OSNXS },
819 { MiscRegNum64(1, 0, 9, 5, 7), MISCREG_TLBI_RVAALE1OSNXS },
820 { MiscRegNum64(1, 0, 9, 6, 1), MISCREG_TLBI_RVAE1NXS },
821 { MiscRegNum64(1, 0, 9, 6, 3), MISCREG_TLBI_RVAAE1NXS },
822 { MiscRegNum64(1, 0, 9, 6, 5), MISCREG_TLBI_RVALE1NXS },
823 { MiscRegNum64(1, 0, 9, 6, 7), MISCREG_TLBI_RVAALE1NXS },
824 { MiscRegNum64(1, 0, 9, 7, 0), MISCREG_TLBI_VMALLE1NXS },
825 { MiscRegNum64(1, 0, 9, 7, 1), MISCREG_TLBI_VAE1NXS },
826 { MiscRegNum64(1, 0, 9, 7, 2), MISCREG_TLBI_ASIDE1NXS },
827 { MiscRegNum64(1, 0, 9, 7, 3), MISCREG_TLBI_VAAE1NXS },
828 { MiscRegNum64(1, 0, 9, 7, 5), MISCREG_TLBI_VALE1NXS },
829 { MiscRegNum64(1, 0, 9, 7, 7), MISCREG_TLBI_VAALE1NXS },
841 { MiscRegNum64(1, 4, 8, 0, 1), MISCREG_TLBI_IPAS2E1IS },
842 { MiscRegNum64(1, 4, 8, 0, 2), MISCREG_TLBI_RIPAS2E1IS },
843 { MiscRegNum64(1, 4, 8, 0, 5), MISCREG_TLBI_IPAS2LE1IS },
844 { MiscRegNum64(1, 4, 8, 1, 0), MISCREG_TLBI_ALLE2OS },
845 { MiscRegNum64(1, 4, 8, 1, 1), MISCREG_TLBI_VAE2OS },
846 { MiscRegNum64(1, 4, 8, 1, 4), MISCREG_TLBI_ALLE1OS },
847 { MiscRegNum64(1, 4, 8, 1, 5), MISCREG_TLBI_VALE2OS },
848 { MiscRegNum64(1, 4, 8, 1, 6), MISCREG_TLBI_VMALLS12E1OS },
849 { MiscRegNum64(1, 4, 8, 0, 6), MISCREG_TLBI_RIPAS2LE1IS },
850 { MiscRegNum64(1, 4, 8, 2, 1), MISCREG_TLBI_RVAE2IS },
851 { MiscRegNum64(1, 4, 8, 2, 5), MISCREG_TLBI_RVALE2IS },
852 { MiscRegNum64(1, 4, 8, 3, 0), MISCREG_TLBI_ALLE2IS },
853 { MiscRegNum64(1, 4, 8, 3, 1), MISCREG_TLBI_VAE2IS },
854 { MiscRegNum64(1, 4, 8, 3, 4), MISCREG_TLBI_ALLE1IS },
855 { MiscRegNum64(1, 4, 8, 3, 5), MISCREG_TLBI_VALE2IS },
856 { MiscRegNum64(1, 4, 8, 3, 6), MISCREG_TLBI_VMALLS12E1IS },
857 { MiscRegNum64(1, 4, 8, 4, 0), MISCREG_TLBI_IPAS2E1OS },
858 { MiscRegNum64(1, 4, 8, 4, 1), MISCREG_TLBI_IPAS2E1 },
859 { MiscRegNum64(1, 4, 8, 4, 2), MISCREG_TLBI_RIPAS2E1 },
860 { MiscRegNum64(1, 4, 8, 4, 3), MISCREG_TLBI_RIPAS2E1OS },
861 { MiscRegNum64(1, 4, 8, 4, 4), MISCREG_TLBI_IPAS2LE1OS },
862 { MiscRegNum64(1, 4, 8, 4, 5), MISCREG_TLBI_IPAS2LE1 },
863 { MiscRegNum64(1, 4, 8, 4, 6), MISCREG_TLBI_RIPAS2LE1 },
864 { MiscRegNum64(1, 4, 8, 4, 7), MISCREG_TLBI_RIPAS2LE1OS },
865 { MiscRegNum64(1, 4, 8, 5, 1), MISCREG_TLBI_RVAE2OS },
866 { MiscRegNum64(1, 4, 8, 5, 5), MISCREG_TLBI_RVALE2OS },
867 { MiscRegNum64(1, 4, 8, 6, 1), MISCREG_TLBI_RVAE2 },
868 { MiscRegNum64(1, 4, 8, 6, 5), MISCREG_TLBI_RVALE2 },
869 { MiscRegNum64(1, 4, 8, 7, 0), MISCREG_TLBI_ALLE2 },
870 { MiscRegNum64(1, 4, 8, 7, 1), MISCREG_TLBI_VAE2 },
871 { MiscRegNum64(1, 4, 8, 7, 4), MISCREG_TLBI_ALLE1 },
872 { MiscRegNum64(1, 4, 8, 7, 5), MISCREG_TLBI_VALE2 },
873 { MiscRegNum64(1, 4, 8, 7, 6), MISCREG_TLBI_VMALLS12E1 },
874 { MiscRegNum64(1, 4, 9, 0, 1), MISCREG_TLBI_IPAS2E1ISNXS },
875 { MiscRegNum64(1, 4, 9, 0, 2), MISCREG_TLBI_RIPAS2E1ISNXS },
876 { MiscRegNum64(1, 4, 9, 0, 5), MISCREG_TLBI_IPAS2LE1ISNXS },
877 { MiscRegNum64(1, 4, 9, 1, 0), MISCREG_TLBI_ALLE2OSNXS },
878 { MiscRegNum64(1, 4, 9, 1, 1), MISCREG_TLBI_VAE2OSNXS },
879 { MiscRegNum64(1, 4, 9, 1, 4), MISCREG_TLBI_ALLE1OSNXS },
880 { MiscRegNum64(1, 4, 9, 1, 5), MISCREG_TLBI_VALE2OSNXS },
881 { MiscRegNum64(1, 4, 9, 1, 6), MISCREG_TLBI_VMALLS12E1OSNXS },
882 { MiscRegNum64(1, 4, 9, 0, 6), MISCREG_TLBI_RIPAS2LE1ISNXS },
883 { MiscRegNum64(1, 4, 9, 2, 1), MISCREG_TLBI_RVAE2ISNXS },
884 { MiscRegNum64(1, 4, 9, 2, 5), MISCREG_TLBI_RVALE2ISNXS },
885 { MiscRegNum64(1, 4, 9, 3, 0), MISCREG_TLBI_ALLE2ISNXS },
886 { MiscRegNum64(1, 4, 9, 3, 1), MISCREG_TLBI_VAE2ISNXS },
887 { MiscRegNum64(1, 4, 9, 3, 4), MISCREG_TLBI_ALLE1ISNXS },
888 { MiscRegNum64(1, 4, 9, 3, 5), MISCREG_TLBI_VALE2ISNXS },
889 { MiscRegNum64(1, 4, 9, 3, 6), MISCREG_TLBI_VMALLS12E1ISNXS },
890 { MiscRegNum64(1, 4, 9, 4, 0), MISCREG_TLBI_IPAS2E1OSNXS },
891 { MiscRegNum64(1, 4, 9, 4, 1), MISCREG_TLBI_IPAS2E1NXS },
892 { MiscRegNum64(1, 4, 9, 4, 2), MISCREG_TLBI_RIPAS2E1NXS },
893 { MiscRegNum64(1, 4, 9, 4, 3), MISCREG_TLBI_RIPAS2E1OSNXS },
894 { MiscRegNum64(1, 4, 9, 4, 4), MISCREG_TLBI_IPAS2LE1OSNXS },
895 { MiscRegNum64(1, 4, 9, 4, 5), MISCREG_TLBI_IPAS2LE1NXS },
896 { MiscRegNum64(1, 4, 9, 4, 6), MISCREG_TLBI_RIPAS2LE1NXS },
897 { MiscRegNum64(1, 4, 9, 4, 7), MISCREG_TLBI_RIPAS2LE1OSNXS },
898 { MiscRegNum64(1, 4, 9, 5, 1), MISCREG_TLBI_RVAE2OSNXS },
899 { MiscRegNum64(1, 4, 9, 5, 5), MISCREG_TLBI_RVALE2OSNXS },
900 { MiscRegNum64(1, 4, 9, 6, 1), MISCREG_TLBI_RVAE2NXS },
901 { MiscRegNum64(1, 4, 9, 6, 5), MISCREG_TLBI_RVALE2NXS },
902 { MiscRegNum64(1, 4, 9, 7, 0), MISCREG_TLBI_ALLE2NXS },
903 { MiscRegNum64(1, 4, 9, 7, 1), MISCREG_TLBI_VAE2NXS },
904 { MiscRegNum64(1, 4, 9, 7, 4), MISCREG_TLBI_ALLE1NXS },
905 { MiscRegNum64(1, 4, 9, 7, 5), MISCREG_TLBI_VALE2NXS },
906 { MiscRegNum64(1, 4, 9, 7, 6), MISCREG_TLBI_VMALLS12E1NXS },
909 { MiscRegNum64(1, 6, 8, 1, 0), MISCREG_TLBI_ALLE3OS },
910 { MiscRegNum64(1, 6, 8, 1, 1), MISCREG_TLBI_VAE3OS },
911 { MiscRegNum64(1, 6, 8, 1, 5), MISCREG_TLBI_VALE3OS },
912 { MiscRegNum64(1, 6, 8, 2, 1), MISCREG_TLBI_RVAE3IS },
913 { MiscRegNum64(1, 6, 8, 2, 5), MISCREG_TLBI_RVALE3IS },
914 { MiscRegNum64(1, 6, 8, 3, 0), MISCREG_TLBI_ALLE3IS },
915 { MiscRegNum64(1, 6, 8, 3, 1), MISCREG_TLBI_VAE3IS },
916 { MiscRegNum64(1, 6, 8, 3, 5), MISCREG_TLBI_VALE3IS },
917 { MiscRegNum64(1, 6, 8, 5, 1), MISCREG_TLBI_RVAE3OS },
918 { MiscRegNum64(1, 6, 8, 5, 5), MISCREG_TLBI_RVALE3OS },
919 { MiscRegNum64(1, 6, 8, 6, 1), MISCREG_TLBI_RVAE3 },
920 { MiscRegNum64(1, 6, 8, 6, 5), MISCREG_TLBI_RVALE3 },
921 { MiscRegNum64(1, 6, 8, 7, 0), MISCREG_TLBI_ALLE3 },
922 { MiscRegNum64(1, 6, 8, 7, 1), MISCREG_TLBI_VAE3 },
923 { MiscRegNum64(1, 6, 8, 7, 5), MISCREG_TLBI_VALE3 },
924 { MiscRegNum64(1, 6, 9, 1, 0), MISCREG_TLBI_ALLE3OSNXS },
925 { MiscRegNum64(1, 6, 9, 1, 1), MISCREG_TLBI_VAE3OSNXS },
926 { MiscRegNum64(1, 6, 9, 1, 5), MISCREG_TLBI_VALE3OSNXS },
927 { MiscRegNum64(1, 6, 9, 2, 1), MISCREG_TLBI_RVAE3ISNXS },
928 { MiscRegNum64(1, 6, 9, 2, 5), MISCREG_TLBI_RVALE3ISNXS },
929 { MiscRegNum64(1, 6, 9, 3, 0), MISCREG_TLBI_ALLE3ISNXS },
930 { MiscRegNum64(1, 6, 9, 3, 1), MISCREG_TLBI_VAE3ISNXS },
931 { MiscRegNum64(1, 6, 9, 3, 5), MISCREG_TLBI_VALE3ISNXS },
932 { MiscRegNum64(1, 6, 9, 5, 1), MISCREG_TLBI_RVAE3OSNXS },
933 { MiscRegNum64(1, 6, 9, 5, 5), MISCREG_TLBI_RVALE3OSNXS },
934 { MiscRegNum64(1, 6, 9, 6, 1), MISCREG_TLBI_RVAE3NXS },
935 { MiscRegNum64(1, 6, 9, 6, 5), MISCREG_TLBI_RVALE3NXS },
936 { MiscRegNum64(1, 6, 9, 7, 0), MISCREG_TLBI_ALLE3NXS },
937 { MiscRegNum64(1, 6, 9, 7, 1), MISCREG_TLBI_VAE3NXS },
938 { MiscRegNum64(1, 6, 9, 7, 5), MISCREG_TLBI_VALE3NXS },
1403fgtRegister(ThreadContext *tc)
1405 if constexpr (read) {
1414fgtDebugRegister(ThreadContext *tc)
1416 if constexpr (read) {
1429template<
bool read, auto r_bitfield>
1431faultFgtEL0(
const MiscRegLUTEntry &entry,
1432 ThreadContext *tc,
const MiscRegOp64 &inst)
1435 const bool in_host =
EL2Enabled(tc) && hcr.e2h && hcr.tge;
1437 fgtRegister<read>(tc).*r_bitfield) {
1438 return inst.generateTrap(
EL2);
1450template<
bool read, auto r_bitfield>
1452faultFgtEL1(
const MiscRegLUTEntry &entry,
1453 ThreadContext *tc,
const MiscRegOp64 &inst)
1455 if (
fgtEnabled(tc) && fgtRegister<read>(tc).*r_bitfield) {
1456 return inst.generateTrap(
EL2);
1467template<auto r_bitfield>
1469faultFgtInstEL1(
const MiscRegLUTEntry &entry,
1470 ThreadContext *tc,
const MiscRegOp64 &inst)
1474 return inst.generateTrap(
EL2);
1486template<auto r_bitfield>
1488faultFgtTlbiNxsEL1(
const MiscRegLUTEntry &entry,
1489 ThreadContext *tc,
const MiscRegOp64 &inst)
1491 if (
HaveExt(tc, ArmExtension::FEAT_HCX)) {
1493 if (
auto fault = faultFgtInstEL1<r_bitfield>(entry, tc, inst);
1510template<
bool read, auto r_bitfield>
1512faultFgtDebugEL1(
const MiscRegLUTEntry &entry,
1513 ThreadContext *tc,
const MiscRegOp64 &inst)
1515 if (
fgtEnabled(tc) && fgtDebugRegister<read>(tc).*r_bitfield) {
1516 return inst.generateTrap(
EL2);
1527template <auto g_bitfield>
1529faultHcrEL1(
const MiscRegLUTEntry &entry,
1530 ThreadContext *tc,
const MiscRegOp64 &inst)
1534 return inst.generateTrap(
EL2);
1547template<
bool read, auto g_bitfield, auto r_bitfield>
1549faultHcrFgtEL0(
const MiscRegLUTEntry &entry,
1550 ThreadContext *tc,
const MiscRegOp64 &inst)
1553 const bool in_host =
EL2Enabled(tc) && hcr.e2h && hcr.tge;
1555 if (
EL2Enabled(tc) && !in_host && hcr.*g_bitfield) {
1556 return inst.generateTrap(
EL2);
1557 }
else if (
auto fault = faultFgtEL0<read, r_bitfield>(entry, tc, inst);
1572template<
bool read, auto g_bitfield, auto r_bitfield>
1574faultHcrFgtEL1(
const MiscRegLUTEntry &entry,
1575 ThreadContext *tc,
const MiscRegOp64 &inst)
1580 return inst.generateTrap(
EL2);
1581 }
else if (
auto fault = faultFgtEL1<read, r_bitfield>(entry, tc, inst);
1595template<auto g_bitfield, auto r_bitfield>
1597faultHcrFgtInstEL1(
const MiscRegLUTEntry &entry,
1598 ThreadContext *tc,
const MiscRegOp64 &inst)
1603 return inst.generateTrap(
EL2);
1604 }
else if (
auto fault = faultFgtInstEL1<r_bitfield>(entry, tc, inst);
1619template<auto g_bitfield, auto r_bitfield>
1621faultTlbiNxsEL1(
const MiscRegLUTEntry &entry,
1622 ThreadContext *tc,
const MiscRegOp64 &inst)
1627 return inst.generateTrap(
EL2);
1628 }
else if (
auto fault = faultFgtTlbiNxsEL1<r_bitfield>(entry, tc, inst);
1637faultSpEL0(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1638 const MiscRegOp64 &inst)
1641 return inst.undefined();
1647faultDaif(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1648 const MiscRegOp64 &inst)
1653 if ((el2_enabled && hcr.e2h && hcr.tge) || sctlr.uma == 0) {
1654 if (el2_enabled && hcr.tge) {
1655 return inst.generateTrap(
EL2);
1657 return inst.generateTrap(
EL1);
1665faultDczvaEL0(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1666 const MiscRegOp64 &inst)
1676 const bool in_host = hcr.e2h && hcr.tge;
1677 if (!(el2_enabled && in_host) && !sctlr.dze) {
1678 if (el2_enabled && hcr.tge) {
1679 return inst.generateTrap(
EL2);
1681 return inst.generateTrap(
EL1);
1683 }
else if (el2_enabled && !in_host && hcr.tdz) {
1684 return inst.generateTrap(
EL2);
1685 }
else if (el2_enabled && in_host && !sctlr2.dze) {
1686 return inst.generateTrap(
EL2);
1693faultCvacEL0(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1694 const MiscRegOp64 &inst)
1701 const bool in_host = hcr.e2h && hcr.tge;
1702 if (!(el2_enabled && in_host) && !sctlr.uci) {
1703 if (el2_enabled && hcr.tge) {
1704 return inst.generateTrap(
EL2);
1706 return inst.generateTrap(
EL1);
1708 }
else if (el2_enabled && !in_host && hcr.tpc) {
1709 return inst.generateTrap(
EL2);
1710 }
else if (el2_enabled && in_host && !sctlr2.uci) {
1711 return inst.generateTrap(
EL2);
1718faultFpcrEL0(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1719 const MiscRegOp64 &inst)
1727 const bool in_host = hcr.e2h && hcr.tge;
1728 if (!(el2_enabled && in_host) && cpacr.fpen != 0b11) {
1729 if (el2_enabled && hcr.tge) {
1732 return inst.generateTrap(
EL1,
1735 }
else if (el2_enabled && in_host && cptr_el2.fpen != 0b11) {
1736 return inst.generateTrap(
EL2,
1738 }
else if (el2_enabled && hcr.e2h && ((cptr_el2.fpen & 0b1) == 0b0)) {
1739 return inst.generateTrap(
EL2,
1741 }
else if (el2_enabled && !hcr.e2h && cptr_el2.tfp) {
1742 return inst.generateTrap(
EL2,
1745 return inst.generateTrap(
EL3,
1753faultFpcrEL1(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1754 const MiscRegOp64 &inst)
1762 if ((cpacr.fpen & 0b1) == 0b0) {
1763 return inst.generateTrap(
EL1,
1765 }
else if (el2_enabled && !hcr.e2h && cptr_el2.tfp) {
1766 return inst.generateTrap(
EL2,
1768 }
else if (el2_enabled && hcr.e2h && ((cptr_el2.fpen & 0b1) == 0b0)) {
1769 return inst.generateTrap(
EL2,
1772 return inst.generateTrap(
EL3,
1780faultFpcrEL2(
const MiscRegLUTEntry &entry, ThreadContext *tc,
1781 const MiscRegOp64 &inst)
1787 if (!hcr.e2h && cptr_el2.tfp) {
1788 return inst.generateTrap(
EL2,
1790 }
else if (hcr.e2h && ((cptr_el2.fpen & 0b1) == 0b0)) {
1791 return inst.generateTrap(
EL2,
1794 return inst.generateTrap(
EL3,
1802faultFpcrEL3(
const MiscRegLUTEntry &entry,
1803 ThreadContext *tc,
const MiscRegOp64 &inst)
1807 return inst.generateTrap(
EL3,
1815faultPouEL0(
const MiscRegLUTEntry &entry,
1816 ThreadContext *tc,
const MiscRegOp64 &inst)
1823 const bool in_host = hcr.e2h && hcr.tge;
1824 if (!(el2_enabled && in_host) && !sctlr.uci) {
1825 if (el2_enabled && hcr.tge) {
1826 return inst.generateTrap(
EL2);
1828 return inst.generateTrap(
EL1);
1830 }
else if (el2_enabled && !in_host && hcr.tpu) {
1831 return inst.generateTrap(
EL2);
1832 }
else if (el2_enabled && !in_host &&
1833 HaveExt(tc, ArmExtension::FEAT_EVT) && hcr.tocu) {
1834 return inst.generateTrap(
EL2);
1835 }
else if (el2_enabled && in_host && !sctlr2.uci) {
1836 return inst.generateTrap(
EL2);
1842template <auto bitfield>
1844faultPouEL1(
const MiscRegLUTEntry &entry,
1845 ThreadContext *tc,
const MiscRegOp64 &inst)
1849 if (el2_enabled && hcr.tpu) {
1850 return inst.generateTrap(
EL2);
1851 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
1853 return inst.generateTrap(
EL2);
1854 }
else if (
auto fault = faultFgtInstEL1<bitfield>(entry, tc, inst);
1862template <auto bitfield>
1864faultPouIsEL1(
const MiscRegLUTEntry &entry,
1865 ThreadContext *tc,
const MiscRegOp64 &inst)
1869 if (el2_enabled && hcr.tpu) {
1870 return inst.generateTrap(
EL2);
1871 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
1873 return inst.generateTrap(
EL2);
1874 }
else if (
auto fault = faultFgtInstEL1<bitfield>(entry, tc, inst);
1883faultCtrEL0(
const MiscRegLUTEntry &entry,
1884 ThreadContext *tc,
const MiscRegOp64 &inst)
1891 const bool in_host = hcr.e2h && hcr.tge;
1892 if (!(el2_enabled && in_host) && !sctlr.uct) {
1893 if (el2_enabled && hcr.tge) {
1894 return inst.generateTrap(
EL2);
1896 return inst.generateTrap(
EL1);
1898 }
else if (
auto fault = faultHcrFgtEL0<
1899 true, &HCR::tid2, &HFGTR::ctrEL0>(entry, tc, inst);
1902 }
else if (el2_enabled && in_host && !sctlr2.uct) {
1903 return inst.generateTrap(
EL2);
1910faultMdccsrEL0(
const MiscRegLUTEntry &entry,
1911 ThreadContext *tc,
const MiscRegOp64 &inst)
1920 if (el2_enabled && hcr.tge) {
1921 return inst.generateTrap(
EL2);
1923 return inst.generateTrap(
EL1);
1925 }
else if (el2_enabled && mdcr_el2.tdcc) {
1926 return inst.generateTrap(
EL2);
1927 }
else if (el2_enabled && (hcr.tge || (mdcr_el2.tde || mdcr_el2.tda))) {
1928 return inst.generateTrap(
EL2);
1930 return inst.generateTrap(
EL3);
1937faultMdccsrEL1(
const MiscRegLUTEntry &entry,
1938 ThreadContext *tc,
const MiscRegOp64 &inst)
1944 if (el2_enabled && mdcr_el2.tdcc) {
1945 return inst.generateTrap(
EL2);
1946 }
else if (el2_enabled && (mdcr_el2.tde || mdcr_el2.tda)) {
1947 return inst.generateTrap(
EL2);
1949 return inst.generateTrap(
EL3);
1956faultMdccsrEL2(
const MiscRegLUTEntry &entry,
1957 ThreadContext *tc,
const MiscRegOp64 &inst)
1961 return inst.generateTrap(
EL3);
1968faultDebugEL1(
const MiscRegLUTEntry &entry,
1969 ThreadContext *tc,
const MiscRegOp64 &inst)
1975 if (el2_enabled && (mdcr_el2.tde || mdcr_el2.tda)) {
1976 return inst.generateTrap(
EL2);
1978 return inst.generateTrap(
EL3);
1985faultDebugEL2(
const MiscRegLUTEntry &entry,
1986 ThreadContext *tc,
const MiscRegOp64 &inst)
1990 return inst.generateTrap(
EL3);
1996template<
bool read, auto r_bitfield>
1998faultDebugWithFgtEL1(
const MiscRegLUTEntry &entry,
1999 ThreadContext *tc,
const MiscRegOp64 &inst)
2001 if (
auto fault = faultFgtDebugEL1<read, r_bitfield>(entry, tc, inst);
2005 return faultDebugEL1(entry, tc, inst);
2009template<
bool read, auto r_bitfield>
2011faultDebugOsEL1(
const MiscRegLUTEntry &entry,
2012 ThreadContext *tc,
const MiscRegOp64 &inst)
2017 if (
auto fault = faultFgtDebugEL1<read, r_bitfield>(entry, tc, inst);
2020 }
else if (
EL2Enabled(tc) && (mdcr_el2.tde || mdcr_el2.tdosa)) {
2021 return inst.generateTrap(
EL2);
2023 return inst.generateTrap(
EL3);
2030faultDebugOsEL2(
const MiscRegLUTEntry &entry,
2031 ThreadContext *tc,
const MiscRegOp64 &inst)
2035 return inst.generateTrap(
EL3);
2042faultHcrxEL2(
const MiscRegLUTEntry &entry,
2043 ThreadContext *tc,
const MiscRegOp64 &inst)
2047 return inst.generateTrap(
EL3);
2054faultZcrEL1(
const MiscRegLUTEntry &entry,
2055 ThreadContext *tc,
const MiscRegOp64 &inst)
2063 if (!(cpacr_el1.zen & 0x1)) {
2065 }
else if (el2_enabled && !hcr.e2h && cptr_el2.tz) {
2067 }
else if (el2_enabled && hcr.e2h && !(cptr_el2.zen & 0x1)) {
2077faultZcrEL2(
const MiscRegLUTEntry &entry,
2078 ThreadContext *tc,
const MiscRegOp64 &inst)
2084 if (!hcr.e2h && cptr_el2.tz) {
2086 }
else if (hcr.e2h && !(cptr_el2.zen & 0x1)) {
2096faultZcrEL3(
const MiscRegLUTEntry &entry,
2097 ThreadContext *tc,
const MiscRegOp64 &inst)
2108faultGicv3(
const MiscRegLUTEntry &entry,
2109 ThreadContext *tc,
const MiscRegOp64 &inst)
2111 auto gic =
static_cast<ArmSystem*
>(tc->getSystemPtr())->getGIC();
2113 return inst.undefined();
2120faultIccSgiEL1(
const MiscRegLUTEntry &entry,
2121 ThreadContext *tc,
const MiscRegOp64 &inst)
2123 if (
auto fault = faultGicv3(entry, tc, inst); fault !=
NoFault) {
2127 const Gicv3CPUInterface::ICH_HCR_EL2 ich_hcr =
2131 if (
EL2Enabled(tc) && (hcr.fmo || hcr.imo || ich_hcr.TC)) {
2132 return inst.generateTrap(
EL2);
2134 return inst.generateTrap(
EL3);
2141faultIccSgiEL2(
const MiscRegLUTEntry &entry,
2142 ThreadContext *tc,
const MiscRegOp64 &inst)
2144 if (
auto fault = faultGicv3(entry, tc, inst); fault !=
NoFault) {
2150 return inst.generateTrap(
EL3);
2156template<
bool read, auto g_bitfield>
2158faultSctlr2EL1(
const MiscRegLUTEntry &entry,
2159 ThreadContext *tc,
const MiscRegOp64 &inst)
2161 if (
HaveExt(tc, ArmExtension::FEAT_SCTLR2)) {
2165 auto fault = faultHcrFgtEL1<read, g_bitfield, &HFGTR::sctlrEL1>
2177 return inst.generateTrap(
EL2);
2179 return inst.generateTrap(
EL3);
2184 return inst.undefined();
2189faultSctlr2EL2(
const MiscRegLUTEntry &entry,
2190 ThreadContext *tc,
const MiscRegOp64 &inst)
2192 if (
HaveExt(tc, ArmExtension::FEAT_SCTLR2)) {
2195 return inst.generateTrap(
EL3);
2200 return inst.undefined();
2205faultSctlr2VheEL2(
const MiscRegLUTEntry &entry,
2206 ThreadContext *tc,
const MiscRegOp64 &inst)
2208 if (
HaveExt(tc, ArmExtension::FEAT_SCTLR2)) {
2213 return inst.generateTrap(
EL3);
2218 return inst.undefined();
2221 return inst.undefined();
2225template<
bool read, auto g_bitfield>
2227faultTcr2EL1(
const MiscRegLUTEntry &entry,
2228 ThreadContext *tc,
const MiscRegOp64 &inst)
2230 if (
HaveExt(tc, ArmExtension::FEAT_TCR2)) {
2234 auto fault = faultHcrFgtEL1<read, g_bitfield, &HFGTR::sctlrEL1>
2244 return inst.generateTrap(
EL2);
2246 return inst.generateTrap(
EL3);
2251 return inst.undefined();
2256faultTcr2EL2(
const MiscRegLUTEntry &entry,
2257 ThreadContext *tc,
const MiscRegOp64 &inst)
2259 if (
HaveExt(tc, ArmExtension::FEAT_TCR2)) {
2262 return inst.generateTrap(
EL3);
2267 return inst.undefined();
2272faultTcr2VheEL2(
const MiscRegLUTEntry &entry,
2273 ThreadContext *tc,
const MiscRegOp64 &inst)
2275 if (
HaveExt(tc, ArmExtension::FEAT_TCR2)) {
2280 return inst.generateTrap(
EL3);
2285 return inst.undefined();
2288 return inst.undefined();
2293faultTcr2VheEL3(
const MiscRegLUTEntry &entry,
2294 ThreadContext *tc,
const MiscRegOp64 &inst)
2296 if (
HaveExt(tc, ArmExtension::FEAT_TCR2)) {
2298 const bool el2_host =
EL2Enabled(tc) && hcr.e2h;
2302 return inst.undefined();
2305 return inst.undefined();
2309template<
bool read, auto r_bitfield>
2311faultCpacrEL1(
const MiscRegLUTEntry &entry,
2312 ThreadContext *tc,
const MiscRegOp64 &inst)
2318 if (el2_enabled && cptr_el2.tcpac) {
2319 return inst.generateTrap(
EL2);
2320 }
else if (
auto fault = faultFgtEL1<read, r_bitfield>(entry, tc, inst);
2324 return inst.generateTrap(
EL3);
2331faultCpacrEL2(
const MiscRegLUTEntry &entry,
2332 ThreadContext *tc,
const MiscRegOp64 &inst)
2336 return inst.generateTrap(
EL3);
2343faultCpacrVheEL2(
const MiscRegLUTEntry &entry,
2344 ThreadContext *tc,
const MiscRegOp64 &inst)
2348 return faultCpacrEL2(entry, tc, inst);
2350 return inst.undefined();
2354template <auto bitfield>
2356faultTlbiOsEL1(
const MiscRegLUTEntry &entry,
2357 ThreadContext *tc,
const MiscRegOp64 &inst)
2361 if (el2_enabled && hcr.ttlb) {
2362 return inst.generateTrap(
EL2);
2363 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
2365 return inst.generateTrap(
EL2);
2366 }
else if (
auto fault = faultFgtInstEL1<bitfield>(entry, tc, inst);
2374template <auto bitfield>
2376faultTlbiOsNxsEL1(
const MiscRegLUTEntry &entry,
2377 ThreadContext *tc,
const MiscRegOp64 &inst)
2381 if (el2_enabled && hcr.ttlb) {
2382 return inst.generateTrap(
EL2);
2383 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
2385 return inst.generateTrap(
EL2);
2386 }
else if (
auto fault = faultFgtTlbiNxsEL1<bitfield>(entry, tc, inst);
2394template <auto bitfield>
2396faultTlbiIsEL1(
const MiscRegLUTEntry &entry,
2397 ThreadContext *tc,
const MiscRegOp64 &inst)
2401 if (el2_enabled && hcr.ttlb) {
2402 return inst.generateTrap(
EL2);
2403 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
2405 return inst.generateTrap(
EL2);
2406 }
else if (
auto fault = faultFgtInstEL1<bitfield>(entry, tc, inst);
2414template <auto bitfield>
2416faultTlbiIsNxsEL1(
const MiscRegLUTEntry &entry,
2417 ThreadContext *tc,
const MiscRegOp64 &inst)
2421 if (el2_enabled && hcr.ttlb) {
2422 return inst.generateTrap(
EL2);
2423 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
2425 return inst.generateTrap(
EL2);
2426 }
else if (
auto fault = faultFgtTlbiNxsEL1<bitfield>(entry, tc, inst);
2434template <
bool read, auto r_bitfield>
2436faultCacheEL1(
const MiscRegLUTEntry &entry,
2437 ThreadContext *tc,
const MiscRegOp64 &inst)
2441 if (el2_enabled && hcr.tid2) {
2442 return inst.generateTrap(
EL2);
2443 }
else if (el2_enabled &&
HaveExt(tc, ArmExtension::FEAT_EVT) &&
2445 return inst.generateTrap(
EL2);
2446 }
else if (
auto fault = faultFgtEL1<read, r_bitfield>(entry, tc, inst);
2454template <
bool read, auto r_bitfield>
2456faultPauthEL1(
const MiscRegLUTEntry &entry,
2457 ThreadContext *tc,
const MiscRegOp64 &inst)
2463 if (el2_enabled && !hcr.apk) {
2464 return inst.generateTrap(
EL2);
2465 }
else if (
auto fault = faultFgtEL1<read, r_bitfield>(entry, tc, inst);
2469 return inst.generateTrap(
EL3);
2476faultPauthEL2(
const MiscRegLUTEntry &entry,
2477 ThreadContext *tc,
const MiscRegOp64 &inst)
2481 return inst.generateTrap(
EL3);
2488faultGenericTimerEL0(
const MiscRegLUTEntry &entry,
2489 ThreadContext *tc,
const MiscRegOp64 &inst)
2493 const bool in_host = el2_enabled && hcr.e2h && hcr.tge;
2496 if (!(in_host) && !cntkctl_el1.el0pcten && !cntkctl_el1.el0vcten) {
2497 if (el2_enabled && hcr.tge)
2498 return inst.generateTrap(
EL2);
2500 return inst.generateTrap(
EL1);
2501 }
else if (in_host && !cnthctl_el2.el0pcten && !cnthctl_el2.el0vcten) {
2502 return inst.generateTrap(
EL2);
2509faultCntpctEL0(
const MiscRegLUTEntry &entry,
2510 ThreadContext *tc,
const MiscRegOp64 &inst)
2514 const bool in_host = el2_enabled && hcr.e2h && hcr.tge;
2517 if (!(in_host) && !cntkctl_el1.el0pcten) {
2518 if (el2_enabled && hcr.tge)
2519 return inst.generateTrap(
EL2);
2521 return inst.generateTrap(
EL1);
2522 }
else if (el2_enabled && !hcr.e2h &&
2523 !
static_cast<CNTHCTL
>(cnthctl_el2).el1pcten) {
2524 return inst.generateTrap(
EL2);
2525 }
else if (el2_enabled && hcr.e2h && !hcr.tge &&
2526 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).el1pcten) {
2527 return inst.generateTrap(
EL2);
2528 }
else if (in_host &&
2529 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).
el0pcten) {
2530 return inst.generateTrap(
EL2);
2537faultCntpctEL1(
const MiscRegLUTEntry &entry,
2538 ThreadContext *tc,
const MiscRegOp64 &inst)
2543 if (el2_enabled && hcr.e2h &&
2544 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).el1pcten) {
2545 return inst.generateTrap(
EL2);
2546 }
else if (el2_enabled && !hcr.e2h &&
2547 !
static_cast<CNTHCTL
>(cnthctl_el2).el1pcten) {
2548 return inst.generateTrap(
EL2);
2555faultCntvctEL0(
const MiscRegLUTEntry &entry,
2556 ThreadContext *tc,
const MiscRegOp64 &inst)
2560 const bool in_host = el2_enabled && hcr.e2h && hcr.tge;
2563 if (!(in_host) && !cntkctl_el1.el0vcten) {
2564 if (el2_enabled && hcr.tge)
2565 return inst.generateTrap(
EL2);
2567 return inst.generateTrap(
EL1);
2568 }
else if (in_host && !cnthctl_el2.el0vcten) {
2569 return inst.generateTrap(
EL2);
2570 }
else if (el2_enabled && !(hcr.e2h && hcr.tge) && cnthctl_el2.el1tvct) {
2571 return inst.generateTrap(
EL2);
2578faultCntvctEL1(
const MiscRegLUTEntry &entry,
2579 ThreadContext *tc,
const MiscRegOp64 &inst)
2583 return inst.generateTrap(
EL2);
2591faultCntpCtlEL0(
const MiscRegLUTEntry &entry,
2592 ThreadContext *tc,
const MiscRegOp64 &inst)
2596 const bool in_host = el2_enabled && hcr.e2h && hcr.tge;
2599 if (!(in_host) && !cntkctl_el1.el0pten) {
2600 if (el2_enabled && hcr.tge)
2601 return inst.generateTrap(
EL2);
2603 return inst.generateTrap(
EL1);
2604 }
else if (el2_enabled && !hcr.e2h &&
2605 !
static_cast<CNTHCTL
>(cnthctl_el2).el1pcen) {
2606 return inst.generateTrap(
EL2);
2607 }
else if (el2_enabled && hcr.e2h && !hcr.tge &&
2608 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).el1pten) {
2609 return inst.generateTrap(
EL2);
2610 }
else if (in_host &&
2611 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).
el0pten) {
2612 return inst.generateTrap(
EL2);
2619faultCntpCtlEL1(
const MiscRegLUTEntry &entry,
2620 ThreadContext *tc,
const MiscRegOp64 &inst)
2625 if (el2_enabled && !hcr.e2h &&
2626 !
static_cast<CNTHCTL
>(cnthctl_el2).el1pcen) {
2627 return inst.generateTrap(
EL2);
2628 }
else if (el2_enabled && hcr.e2h &&
2629 !
static_cast<CNTHCTL_E2H
>(cnthctl_el2).el1pten) {
2630 return inst.generateTrap(
EL2);
2638faultCntvCtlEL0(
const MiscRegLUTEntry &entry,
2639 ThreadContext *tc,
const MiscRegOp64 &inst)
2643 const bool in_host = el2_enabled && hcr.e2h && hcr.tge;
2646 if (!(in_host) && !cntkctl_el1.el0vten) {
2647 if (el2_enabled && hcr.tge)
2648 return inst.generateTrap(
EL2);
2650 return inst.generateTrap(
EL1);
2651 }
else if (in_host && !cnthctl_el2.el0vten) {
2652 return inst.generateTrap(
EL2);
2653 }
else if (el2_enabled && !(hcr.e2h && hcr.tge) && cnthctl_el2.el1tvt) {
2654 return inst.generateTrap(
EL2);
2661faultCntvCtlEL1(
const MiscRegLUTEntry &entry,
2662 ThreadContext *tc,
const MiscRegOp64 &inst)
2666 return inst.generateTrap(
EL2);
2673faultCntpsCtlEL1(
const MiscRegLUTEntry &entry,
2674 ThreadContext *tc,
const MiscRegOp64 &inst)
2679 return inst.undefined();
2681 return inst.generateTrap(
EL3);
2685 return inst.undefined();
2690faultUnimplemented(
const MiscRegLUTEntry &entry,
2691 ThreadContext *tc,
const MiscRegOp64 &inst)
2696 return inst.undefined();
2701faultImpdefUnimplEL1(
const MiscRegLUTEntry &entry,
2702 ThreadContext *tc,
const MiscRegOp64 &inst)
2706 return inst.generateTrap(
EL2);
2708 return faultUnimplemented(entry, tc, inst);
2713faultEsm(
const MiscRegLUTEntry &entry,
2714 ThreadContext *tc,
const MiscRegOp64 &inst)
2725faultTsmSmen(
const MiscRegLUTEntry &entry,
2726 ThreadContext *tc,
const MiscRegOp64 &inst)
2731 if (el2_enabled && !hcr_el2.e2h && cptr_el2.tsm) {
2733 }
else if (el2_enabled && hcr_el2.e2h && !(cptr_el2.smen & 0b1)) {
2736 return faultEsm(entry, tc, inst);
2741faultSmenEL1(
const MiscRegLUTEntry &entry,
2742 ThreadContext *tc,
const MiscRegOp64 &inst)
2745 if (!(cpacr.smen & 0b1)) {
2748 return faultTsmSmen(entry, tc, inst);
2753faultSmenEL0(
const MiscRegLUTEntry &entry,
2754 ThreadContext *tc,
const MiscRegOp64 &inst)
2758 const bool in_host = hcr.e2h && hcr.tge;
2762 if (!(el2_enabled && in_host) && cpacr.smen != 0b11) {
2763 if (el2_enabled && hcr.tge)
2767 }
else if (el2_enabled && in_host && cptr_el2.smen != 0b11) {
2770 return faultTsmSmen(entry, tc, inst);
2775faultRng(
const MiscRegLUTEntry &entry,
2776 ThreadContext *tc,
const MiscRegOp64 &inst)
2779 if (
HaveExt(tc, ArmExtension::FEAT_RNG_TRAP) && scr.trndr) {
2780 return inst.generateTrap(
EL3);
2781 }
else if (!
HaveExt(tc, ArmExtension::FEAT_RNG)) {
2782 return inst.undefined();
2789faultFgtCtrlRegs(
const MiscRegLUTEntry &entry,
2790 ThreadContext *tc,
const MiscRegOp64 &inst)
2792 if (
HaveExt(tc, ArmExtension::FEAT_FGT)) {
2795 return inst.generateTrap(
EL3);
2800 return inst.undefined();
2805faultIdst(
const MiscRegLUTEntry &entry,
2806 ThreadContext *tc,
const MiscRegOp64 &inst)
2808 if (
HaveExt(tc, ArmExtension::FEAT_IDST)) {
2811 return inst.generateTrap(
EL2);
2813 return inst.generateTrap(
EL1);
2816 return inst.undefined();
2821faultMpamIdrEL1(
const MiscRegLUTEntry &entry,
2822 ThreadContext *tc,
const MiscRegOp64 &inst)
2824 if (
HaveExt(tc, ArmExtension::FEAT_MPAM)) {
2830 return inst.generateTrap(
EL3);
2831 }
else if (
EL2Enabled(tc) && mpamidr.hasHcr && mpamhcr.trapMpamIdrEL1) {
2832 return inst.generateTrap(
EL2);
2833 }
else if (
EL2Enabled(tc) && mpamidr.hasTidr && mpam2.el2.tidr) {
2834 return inst.generateTrap(
EL2);
2839 return inst.undefined();
2844faultMpam0EL1(
const MiscRegLUTEntry &entry,
2845 ThreadContext *tc,
const MiscRegOp64 &inst)
2847 if (
HaveExt(tc, ArmExtension::FEAT_MPAM)) {
2851 return inst.generateTrap(
EL3);
2852 }
else if (
EL2Enabled(tc) && mpam2.el2.trapMpam0EL1) {
2853 return inst.generateTrap(
EL2);
2858 return inst.undefined();
2863faultMpam1EL1(
const MiscRegLUTEntry &entry,
2864 ThreadContext *tc,
const MiscRegOp64 &inst)
2866 if (
HaveExt(tc, ArmExtension::FEAT_MPAM)) {
2870 return inst.generateTrap(
EL3);
2871 }
else if (
EL2Enabled(tc) && mpam2.el2.trapMpam1EL1) {
2872 return inst.generateTrap(
EL2);
2877 return inst.undefined();
2882faultMpamEL2(
const MiscRegLUTEntry &entry,
2883 ThreadContext *tc,
const MiscRegOp64 &inst)
2885 if (
HaveExt(tc, ArmExtension::FEAT_MPAM)) {
2888 return inst.generateTrap(
EL3);
2893 return inst.undefined();
2898faultMpam12EL2(
const MiscRegLUTEntry &entry,
2899 ThreadContext *tc,
const MiscRegOp64 &inst)
2902 return faultMpamEL2(entry, tc, inst);
2904 return inst.undefined();
2909faultMpamsmEL1(
const MiscRegLUTEntry &entry,
2910 ThreadContext *tc,
const MiscRegOp64 &inst)
2912 if (
HaveExt(tc, ArmExtension::FEAT_MPAM)) {
2916 return inst.generateTrap(
EL3);
2917 }
else if (
EL2Enabled(tc) && mpam2.el2.enMpamSm) {
2918 return inst.generateTrap(
EL2);
2923 return inst.undefined();
2931 unsigned crn,
unsigned crm,
2941 auto it = miscRegNumToIdx.find(sys_reg);
2942 if (it != miscRegNumToIdx.end()) {
2946 if ((sys_reg.
op0 == 1 || sys_reg.
op0 == 3) &&
2947 (sys_reg.
crn == 11 || sys_reg.
crn == 15)) {
2955std::optional<MiscRegNum64>
2958 if (
auto it = idxToMiscRegNum.find(misc_reg);
2959 it != idxToMiscRegNum.end()) {
2962 return std::nullopt;
2974template <MiscRegInfo Sec, MiscRegInfo NonSec>
3003 const bool el2_host =
EL2Enabled(tc) && hcr.e2h;
3030 switch (
system->highestEL()) {
3044 panic(
"Invalid highest implemented exception level");
3061 static bool completed =
false;
3079 bool LSMAOE =
false;
3082 bool nTLSMD =
false;
3090 const bool vhe_implemented =
release->
has(ArmExtension::FEAT_VHE);
3091 const bool sel2_implemented =
release->
has(ArmExtension::FEAT_SEL2);
3148 mvfr1.flushToZero = 1;
3149 mvfr1.defaultNaN = 1;
3150 mvfr1.advSimdLoadStore = 1;
3151 mvfr1.advSimdInteger = 1;
3152 mvfr1.advSimdSinglePrecision = 1;
3153 mvfr1.advSimdHalfPrecision = 1;
3154 mvfr1.vfpHalfPrecision = 1;
3161 mvfr0.advSimdRegisters = 2;
3162 mvfr0.singlePrecision = 2;
3163 mvfr0.doublePrecision = 2;
3164 mvfr0.vfpExceptionTrapping = 0;
3166 mvfr0.squareRoot = 1;
3167 mvfr0.shortVectors = 1;
3168 mvfr0.roundingModes = 1;
3466 unsigned line_size_words =
3467 system->cacheLineSize() / 4;
3468 unsigned log2_line_size_words = 0;
3470 while (line_size_words >>= 1) {
3471 ++log2_line_size_words;
3476 ctr.iCacheLineSize = log2_line_size_words;
3478 ctr.l1IndexPolicy = 0x3;
3480 ctr.dCacheLineSize = log2_line_size_words;
3482 ctr.erg = log2_line_size_words;
3484 ctr.cwg = log2_line_size_words;
3511 bool have_timer = (
system &&
system->getGenericTimer() !=
nullptr);
3513 (release->has(ArmExtension::SECURITY) ?
3515 (release->has(ArmExtension::VIRTUALIZATION) ?
3517 (have_timer ? 0x00010000 : 0x0);
3522 .
reset(
p.pmu ? 0x03000000 : 0)
3523 .allPrivileges().exceptUserMode().writes(0);
3527 .
reset([
p,release=release](){
3529 if (release->has(ArmExtension::LPAE))
3530 mmfr0 = (mmfr0 & ~0xf) | 0x5;
3562 .
reset([
p,release=release] () {
3563 ISAR5 isar5 =
p.id_isar5;
3564 isar5.crc32 = release->has(ArmExtension::FEAT_CRC32) ? 0x1 : 0x0;
3565 isar5.sha2 = release->has(ArmExtension::FEAT_SHA256) ? 0x1 : 0x0;
3566 isar5.sha1 = release->has(ArmExtension::FEAT_SHA1) ? 0x1 : 0x0;
3567 isar5.aes = release->has(ArmExtension::FEAT_PMULL) ?
3568 0x2 : release->has(ArmExtension::FEAT_AES) ?
3570 isar5.rdm = release->has(ArmExtension::FEAT_RDM) ? 0x1 : 0x0;
3571 isar5.vcma = release->has(ArmExtension::FEAT_FCMA) ? 0x1 : 0x0;
3576 .
reset([
p,release=release] () {
3577 ISAR6 isar6 =
p.id_isar6;
3578 isar6.jscvt = release->has(ArmExtension::FEAT_JSCVT) ? 0x1 : 0x0;
3609 .
res1(0x00400800 | (SPAN ? 0 : 0x800000)
3610 | (LSMAOE ? 0 : 0x10)
3611 | (nTLSMD ? 0 : 0x8));
3613 auto sctlr_reset = [
aarch64=highestELIs64] ()
3659 .
reset(release->has(ArmExtension::SECURITY) ? 0 : 1)
3660 .mon().secure().exceptUserMode()
3670 .
res0(0x0512c7c0 | (EnDB ? 0 : 0x2000)
3671 | (IESB ? 0 : 0x200000)
3672 | (EnDA ? 0 : 0x8000000)
3673 | (EnIB ? 0 : 0x40000000)
3674 | (EnIA ? 0 : 0x80000000))
3680 .
res0(release->has(ArmExtension::VIRTUALIZATION) ?
3681 0x90000000 :
mask(31, 0));
3684 .
res0(release->has(ArmExtension::VIRTUALIZATION) ?
3685 0xffa9ff8c :
mask(31, 0));
4089 .
res0(release->has(ArmExtension::LPAE) ? 0 :
mask(31, 0))
4099 .
res0(release->has(ArmExtension::LPAE) ? 0 :
mask(31, 0))
4324 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::mdscrEL1>)
4325 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::mdscrEL1>)
4333 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::oseccrEL1>)
4334 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::oseccrEL1>)
4339 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4340 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4345 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4346 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4351 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4352 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4357 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4358 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4363 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4364 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4369 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4370 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4375 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4376 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4381 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4382 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4387 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4388 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4393 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4394 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4399 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4400 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4405 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4406 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4411 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4412 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4417 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4418 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4423 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4424 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4429 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbvrnEL1>)
4430 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbvrnEL1>)
4435 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4436 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4441 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4442 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4447 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4448 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4453 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4454 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4459 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4460 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4465 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4466 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4471 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4472 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4477 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4478 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4483 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4484 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4489 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4490 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4495 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4496 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4501 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4502 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4507 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4508 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4513 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4514 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4519 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4520 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4525 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgbcrnEL1>)
4526 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgbcrnEL1>)
4531 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4532 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4537 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4538 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4543 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4544 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4549 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4550 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4555 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4556 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4561 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4562 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4567 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4568 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4573 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4574 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4579 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4580 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4585 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4586 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4591 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4592 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4597 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4598 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4603 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4604 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4609 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4610 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4615 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4616 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4621 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwvrnEL1>)
4622 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwvrnEL1>)
4627 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4628 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4633 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4634 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4639 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4640 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4645 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4646 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4651 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4652 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4657 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4658 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4663 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4664 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4669 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4670 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4675 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4676 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4681 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4682 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4687 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4688 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4693 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4694 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4699 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4700 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4705 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4706 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4711 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4712 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4717 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgwcrnEL1>)
4718 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgwcrnEL1>)
4749 .
faultRead(
EL1, faultDebugOsEL1<true, &HDFGTR::oslsrEL1>)
4754 .
faultRead(
EL1, faultDebugOsEL1<true, &HDFGTR::osdlrEL1>)
4760 .
faultRead(
EL1, faultDebugOsEL1<true, &HDFGTR::dbgprcrEL1>)
4761 .
faultWrite(
EL1, faultDebugOsEL1<false, &HDFGTR::dbgprcrEL1>)
4766 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgclaim>)
4767 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgclaim>)
4772 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgclaim>)
4773 .
faultWrite(
EL1, faultDebugWithFgtEL1<false, &HDFGTR::dbgclaim>)
4778 .
faultRead(
EL1, faultDebugWithFgtEL1<true, &HDFGTR::dbgauthstatusEL1>)
4786 .allPrivileges().exceptUserMode().writes(0)
4787 .faultRead(
EL0, faultIdst)
4788 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::midrEL1>)
4791 .allPrivileges().exceptUserMode().writes(0)
4792 .faultRead(
EL0, faultIdst)
4793 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::mpidrEL1>)
4796 .faultRead(
EL0, faultIdst)
4797 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::tid1, &HFGTR::revidrEL1>)
4798 .allPrivileges().exceptUserMode().writes(0);
4800 .allPrivileges().exceptUserMode().writes(0)
4801 .faultRead(
EL0, faultIdst)
4802 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4805 .allPrivileges().exceptUserMode().writes(0)
4806 .faultRead(
EL0, faultIdst)
4807 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4810 .allPrivileges().exceptUserMode().writes(0)
4811 .faultRead(
EL0, faultIdst)
4812 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4815 .allPrivileges().exceptUserMode().writes(0)
4816 .faultRead(
EL0, faultIdst)
4817 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4820 .allPrivileges().exceptUserMode().writes(0)
4821 .faultRead(
EL0, faultIdst)
4822 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4825 .allPrivileges().exceptUserMode().writes(0)
4826 .faultRead(
EL0, faultIdst)
4827 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4830 .allPrivileges().exceptUserMode().writes(0)
4831 .faultRead(
EL0, faultIdst)
4832 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4835 .allPrivileges().exceptUserMode().writes(0)
4836 .faultRead(
EL0, faultIdst)
4837 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4840 .allPrivileges().exceptUserMode().writes(0)
4841 .faultRead(
EL0, faultIdst)
4842 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4845 .allPrivileges().exceptUserMode().writes(0)
4846 .faultRead(
EL0, faultIdst)
4847 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4850 .allPrivileges().exceptUserMode().writes(0)
4851 .faultRead(
EL0, faultIdst)
4852 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4855 .allPrivileges().exceptUserMode().writes(0)
4856 .faultRead(
EL0, faultIdst)
4857 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4860 .allPrivileges().exceptUserMode().writes(0)
4861 .faultRead(
EL0, faultIdst)
4862 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4865 .allPrivileges().exceptUserMode().writes(0)
4866 .faultRead(
EL0, faultIdst)
4867 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4870 .allPrivileges().exceptUserMode().writes(0)
4871 .faultRead(
EL0, faultIdst)
4872 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4875 .allPrivileges().exceptUserMode().writes(0)
4876 .faultRead(
EL0, faultIdst)
4877 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4880 .faultRead(
EL0, faultIdst)
4881 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4882 .allPrivileges().exceptUserMode().writes(0)
4885 .faultRead(
EL0, faultIdst)
4886 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4887 .allPrivileges().exceptUserMode().writes(0)
4890 .faultRead(
EL0, faultIdst)
4891 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4892 .allPrivileges().exceptUserMode().writes(0);
4894 .reset([
this,release=release,tc=tc](){
4895 AA64PFR0 pfr0_el1 = 0;
4898 pfr0_el1.el2 = release->has(ArmExtension::VIRTUALIZATION)
4900 pfr0_el1.el3 = release->has(ArmExtension::SECURITY) ? 0x2 : 0x0;
4901 pfr0_el1.sve = release->has(ArmExtension::FEAT_SVE) ? 0x1 : 0x0;
4902 pfr0_el1.sel2 = release->has(ArmExtension::FEAT_SEL2) ? 0x1 : 0x0;
4905 pfr0_el1.mpam = 0x0;
4906 pfr0_el1.gic =
FullSystem && getGICv3CPUInterface(tc) ? 0x1 : 0;
4910 .faultRead(
EL0, faultIdst)
4911 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4912 .allPrivileges().writes(0);
4914 .reset([release=release](){
4915 AA64PFR1 pfr1_el1 = 0;
4916 pfr1_el1.sme = release->has(ArmExtension::FEAT_SME) ? 0x1 : 0x0;
4917 pfr1_el1.mpamFrac = release->has(ArmExtension::FEAT_MPAM) ?
4922 .faultRead(
EL0, faultIdst)
4923 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4924 .allPrivileges().writes(0);
4927 AA64DFR0 dfr0_el1 =
p.id_aa64dfr0_el1;
4928 dfr0_el1.pmuver =
p.pmu ? 1 : 0;
4931 .faultRead(
EL0, faultIdst)
4932 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4933 .allPrivileges().writes(0);
4935 .reset(
p.id_aa64dfr1_el1)
4936 .faultRead(
EL0, faultIdst)
4937 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4938 .allPrivileges().writes(0);
4940 .reset(
p.id_aa64afr0_el1)
4941 .faultRead(
EL0, faultIdst)
4942 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4943 .allPrivileges().writes(0);
4945 .reset(
p.id_aa64afr1_el1)
4946 .faultRead(
EL0, faultIdst)
4947 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4948 .allPrivileges().writes(0);
4950 .reset([
p,release=release](){
4951 AA64ISAR0 isar0_el1 =
p.id_aa64isar0_el1;
4952 isar0_el1.crc32 = release->has(ArmExtension::FEAT_CRC32) ? 0x1 : 0x0;
4953 isar0_el1.sha2 = release->has(ArmExtension::FEAT_SHA256) ? 0x1 : 0x0;
4954 isar0_el1.sha1 = release->has(ArmExtension::FEAT_SHA1) ? 0x1 : 0x0;
4955 isar0_el1.aes = release->has(ArmExtension::FEAT_PMULL) ?
4956 0x2 : release->has(ArmExtension::FEAT_AES) ?
4958 isar0_el1.dp = release->has(ArmExtension::FEAT_DOTPROD) ? 0x1 : 0x0;
4959 isar0_el1.atomic = release->has(ArmExtension::FEAT_LSE) ? 0x2 : 0x0;
4960 isar0_el1.rdm = release->has(ArmExtension::FEAT_RDM) ? 0x1 : 0x0;
4961 isar0_el1.tme = release->has(ArmExtension::TME) ? 0x1 : 0x0;
4962 isar0_el1.tlb = release->has(ArmExtension::FEAT_TLBIRANGE) ?
4963 0x2 : release->has(ArmExtension::FEAT_TLBIOS) ?
4965 isar0_el1.ts = release->has(ArmExtension::FEAT_FLAGM2) ?
4966 0x2 : release->has(ArmExtension::FEAT_FLAGM) ?
4968 isar0_el1.rndr = release->has(ArmExtension::FEAT_RNG) ? 0x1 : 0x0;
4971 .faultRead(
EL0, faultIdst)
4972 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4973 .allPrivileges().writes(0);
4975 .reset([
p,release=release](){
4976 AA64ISAR1 isar1_el1 =
p.id_aa64isar1_el1;
4977 isar1_el1.xs = release->has(ArmExtension::FEAT_XS) ? 0x1 : 0x0;
4978 isar1_el1.i8mm = release->has(ArmExtension::FEAT_I8MM) ? 0x1 : 0x0;
4979 isar1_el1.apa = release->has(ArmExtension::FEAT_PAuth) ? 0x1 : 0x0;
4980 isar1_el1.jscvt = release->has(ArmExtension::FEAT_JSCVT) ? 0x1 : 0x0;
4981 isar1_el1.fcma = release->has(ArmExtension::FEAT_FCMA) ? 0x1 : 0x0;
4982 isar1_el1.gpa = release->has(ArmExtension::FEAT_PAuth) ? 0x1 : 0x0;
4985 .faultRead(
EL0, faultIdst)
4986 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4987 .allPrivileges().writes(0);
4990 AA64MMFR0 mmfr0_el1 =
p.id_aa64mmfr0_el1;
4991 mmfr0_el1.asidbits =
asidbits ? 0x2 : 0x0;
4995 .faultRead(
EL0, faultIdst)
4996 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
4997 .allPrivileges().writes(0);
4999 .reset([
p,release=release](){
5000 AA64MMFR1 mmfr1_el1 =
p.id_aa64mmfr1_el1;
5001 mmfr1_el1.vmidbits =
5002 release->has(ArmExtension::FEAT_VMID16) ? 0x2 : 0x0;
5003 mmfr1_el1.vh = release->has(ArmExtension::FEAT_VHE) ? 0x1 : 0x0;
5004 mmfr1_el1.hpds = release->has(ArmExtension::FEAT_HPDS) ? 0x1 : 0x0;
5005 mmfr1_el1.pan = release->has(ArmExtension::FEAT_PAN) ? 0x1 : 0x0;
5006 mmfr1_el1.hcx = release->has(ArmExtension::FEAT_HCX) ? 0x1 : 0x0;
5009 .faultRead(
EL0, faultIdst)
5010 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
5011 .allPrivileges().writes(0);
5013 .reset([
p,release=release](){
5014 AA64MMFR2 mmfr2_el1 =
p.id_aa64mmfr2_el1;
5015 mmfr2_el1.uao = release->has(ArmExtension::FEAT_UAO) ? 0x1 : 0x0;
5016 mmfr2_el1.varange = release->has(ArmExtension::FEAT_LVA) ? 0x1 : 0x0;
5017 mmfr2_el1.st = release->has(ArmExtension::FEAT_TTST) ? 0x1 : 0x0;
5018 mmfr2_el1.ids = release->has(ArmExtension::FEAT_IDST) ? 0x1 : 0x0;
5019 mmfr2_el1.evt = release->has(ArmExtension::FEAT_EVT) ? 0x2 : 0x0;
5022 .faultRead(
EL0, faultIdst)
5023 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
5024 .allPrivileges().writes(0);
5026 .reset([
p,release=release](){
5027 AA64MMFR3 mmfr3_el1 = 0;
5029 release->has(ArmExtension::FEAT_SCTLR2) ? 0x1 : 0x0;
5030 mmfr3_el1.tcrx = release->has(ArmExtension::FEAT_TCR2) ? 0x1 : 0x0;
5033 .faultRead(
EL0, faultIdst)
5034 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
5035 .allPrivileges().writes(0);
5038 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apdaKey>)
5039 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apdaKey>)
5040 .fault(
EL2, faultPauthEL2)
5041 .allPrivileges().exceptUserMode();
5043 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apdaKey>)
5044 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apdaKey>)
5045 .fault(
EL2, faultPauthEL2)
5046 .allPrivileges().exceptUserMode();
5048 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apdbKey>)
5049 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apdbKey>)
5050 .fault(
EL2, faultPauthEL2)
5051 .allPrivileges().exceptUserMode();
5053 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apdbKey>)
5054 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apdbKey>)
5055 .fault(
EL2, faultPauthEL2)
5056 .allPrivileges().exceptUserMode();
5058 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apgaKey>)
5059 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apgaKey>)
5060 .fault(
EL2, faultPauthEL2)
5061 .allPrivileges().exceptUserMode();
5063 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apgaKey>)
5064 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apgaKey>)
5065 .fault(
EL2, faultPauthEL2)
5066 .allPrivileges().exceptUserMode();
5068 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apiaKey>)
5069 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apiaKey>)
5070 .fault(
EL2, faultPauthEL2)
5071 .allPrivileges().exceptUserMode();
5073 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apiaKey>)
5074 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apiaKey>)
5075 .fault(
EL2, faultPauthEL2)
5076 .allPrivileges().exceptUserMode();
5078 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apibKey>)
5079 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apibKey>)
5080 .fault(
EL2, faultPauthEL2)
5081 .allPrivileges().exceptUserMode();
5083 .faultRead(
EL1, faultPauthEL1<true, &HFGTR::apibKey>)
5084 .faultWrite(
EL1, faultPauthEL1<false, &HFGTR::apibKey>)
5085 .fault(
EL2, faultPauthEL2)
5086 .allPrivileges().exceptUserMode();
5089 .faultRead(
EL0, faultIdst)
5090 .faultRead(
EL1, faultCacheEL1<true, &HFGTR::ccsidrEL1>)
5091 .allPrivileges().writes(0);
5093 .faultRead(
EL0, faultIdst)
5094 .faultRead(
EL1, faultCacheEL1<true, &HFGTR::clidrEL1>)
5095 .allPrivileges().writes(0);
5097 .faultRead(
EL0, faultIdst)
5098 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::tid1, &HFGTR::aidrEL1>)
5099 .allPrivileges().writes(0);
5101 .allPrivileges().exceptUserMode()
5102 .faultRead(
EL1, faultCacheEL1<true, &HFGTR::csselrEL1>)
5103 .faultWrite(
EL1, faultCacheEL1<false, &HFGTR::csselrEL1>)
5106 .faultRead(
EL0, faultCtrEL0)
5107 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::tid2, &HFGTR::ctrEL0>)
5112 .faultRead(
EL0, faultFgtEL0<true, &HFGTR::dczidEL0>)
5113 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::dczidEL0>)
5124 .allPrivileges().exceptUserMode()
5125 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::sctlrEL1>)
5126 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::sctlrEL1>)
5127 .res0( 0x20440 | (EnDB ? 0 : 0x2000)
5128 | (IESB ? 0 : 0x200000)
5129 | (EnDA ? 0 : 0x8000000)
5130 | (EnIB ? 0 : 0x40000000)
5131 | (EnIA ? 0 : 0x80000000))
5132 .res1(0x500800 | (SPAN ? 0 : 0x800000)
5133 | (nTLSMD ? 0 : 0x8000000)
5134 | (LSMAOE ? 0 : 0x10000000))
5139 .res0( 0x20440 | (EnDB ? 0 : 0x2000)
5140 | (IESB ? 0 : 0x200000)
5141 | (EnDA ? 0 : 0x8000000)
5142 | (EnIB ? 0 : 0x40000000)
5143 | (EnIA ? 0 : 0x80000000))
5144 .res1(0x500800 | (SPAN ? 0 : 0x800000)
5145 | (nTLSMD ? 0 : 0x8000000)
5146 | (LSMAOE ? 0 : 0x10000000))
5149 .allPrivileges().exceptUserMode()
5150 .faultRead(
EL1, faultSctlr2EL1<true, &HCR::trvm>)
5151 .faultWrite(
EL1, faultSctlr2EL1<false, &HCR::tvm>)
5152 .fault(
EL2,faultSctlr2EL2);
5154 .fault(
EL2, faultSctlr2VheEL2)
5158 .allPrivileges().exceptUserMode()
5159 .fault(
EL1, faultHcrEL1<&HCR::tacr>)
5162 .allPrivileges().exceptUserMode()
5163 .faultRead(
EL1, faultCpacrEL1<true, &HFGTR::cpacrEL1>)
5164 .faultWrite(
EL1, faultCpacrEL1<false, &HFGTR::cpacrEL1>)
5165 .fault(
EL2, faultCpacrEL2)
5168 .fault(
EL2, faultCpacrVheEL2)
5173 .res0(0x0512c7c0 | (EnDB ? 0 : 0x2000)
5174 | (IESB ? 0 : 0x200000)
5175 | (EnDA ? 0 : 0x8000000)
5176 | (EnIB ? 0 : 0x40000000)
5177 | (EnIA ? 0 : 0x80000000))
5182 .fault(
EL2, faultSctlr2EL2);
5191 .fault(
EL2, faultHcrxEL2);
5194 .fault(
EL2, faultDebugEL2)
5198 .fault(
EL2, faultCpacrEL2)
5209 .res0(0x0512c7c0 | (EnDB ? 0 : 0x2000)
5210 | (IESB ? 0 : 0x200000)
5211 | (EnDA ? 0 : 0x8000000)
5212 | (EnIB ? 0 : 0x40000000)
5213 | (EnIA ? 0 : 0x80000000))
5231 .allPrivileges().exceptUserMode()
5232 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::ttbr0EL1>)
5233 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::ttbr0EL1>)
5240 .allPrivileges().exceptUserMode()
5241 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::ttbr1EL1>)
5242 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::ttbr1EL1>)
5249 .allPrivileges().exceptUserMode()
5250 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::tcrEL1>)
5251 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::tcrEL1>)
5258 .allPrivileges().exceptUserMode()
5259 .faultRead(
EL1, faultTcr2EL1<true, &HCR::trvm>)
5260 .faultWrite(
EL1, faultTcr2EL1<false, &HCR::tvm>)
5261 .fault(
EL2, faultTcr2EL2);
5263 .fault(
EL2, faultTcr2VheEL2)
5264 .fault(
EL3, faultTcr2VheEL3)
5276 .fault(
EL2, faultTcr2EL2);
5295 .allPrivileges().exceptUserMode()
5302 .allPrivileges().exceptUserMode();
5308 .allPrivileges().exceptUserMode()
5309 .fault(
EL1, faultSpEL0)
5310 .fault(
EL2, faultSpEL0)
5311 .fault(
EL3, faultSpEL0);
5313 .allPrivileges().exceptUserMode();
5315 .allPrivileges().exceptUserMode().writes(0);
5317 .allPrivileges(release->has(ArmExtension::FEAT_PAN))
5320 .allPrivileges().exceptUserMode();
5325 .fault(
EL0, faultDaif);
5328 .fault(
EL0, faultFpcrEL0)
5329 .fault(
EL1, faultFpcrEL1)
5330 .fault(
EL2, faultFpcrEL2)
5331 .fault(
EL3, faultFpcrEL3);
5334 .fault(
EL0, faultFpcrEL0)
5335 .fault(
EL1, faultFpcrEL1)
5336 .fault(
EL2, faultFpcrEL2)
5337 .fault(
EL3, faultFpcrEL3);
5365 .allPrivileges().exceptUserMode()
5366 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::afsr0EL1>)
5367 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::afsr0EL1>)
5374 .allPrivileges().exceptUserMode()
5375 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::afsr1EL1>)
5376 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::afsr1EL1>)
5383 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::esrEL1>)
5384 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::esrEL1>)
5385 .allPrivileges().exceptUserMode();
5403 .fault(
EL2, faultFpcrEL2)
5404 .fault(
EL3, faultFpcrEL3)
5413 .allPrivileges().exceptUserMode()
5414 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::farEL1>)
5415 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::farEL1>)
5431 .faultWrite(
EL1, faultPouIsEL1<&HFGITR::icialluis>)
5432 .writes(1).exceptUserMode();
5434 .allPrivileges().exceptUserMode()
5438 .faultWrite(
EL1, faultPouEL1<&HFGITR::iciallu>)
5439 .writes(1).exceptUserMode();
5441 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tpc, &HFGITR::dcivac>)
5442 .writes(1).exceptUserMode();
5445 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tsw, &HFGITR::dcisw>)
5446 .writes(1).exceptUserMode();
5448 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::at, &HFGITR::ats1e1r>)
5449 .writes(1).exceptUserMode();
5451 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::at, &HFGITR::ats1e1w>)
5452 .writes(1).exceptUserMode();
5454 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::at, &HFGITR::ats1e0r>)
5455 .writes(1).exceptUserMode();
5457 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::at, &HFGITR::ats1e0w>)
5458 .writes(1).exceptUserMode();
5461 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tsw, &HFGITR::dccsw>)
5462 .writes(1).exceptUserMode();
5465 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tsw, &HFGITR::dccisw>)
5466 .writes(1).exceptUserMode();
5469 .faultWrite(
EL0, faultDczvaEL0)
5470 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tdz, &HFGITR::dczva>);
5472 .faultWrite(
EL0, faultPouEL0)
5473 .faultWrite(
EL1, faultPouEL1<&HFGITR::icivau>)
5476 .faultWrite(
EL0, faultCvacEL0)
5477 .faultWrite(
EL1, faultHcrEL1<&HCR::tpc>)
5480 .faultWrite(
EL0, faultPouEL0)
5481 .faultWrite(
EL1, faultPouEL1<&HFGITR::dccvau>)
5484 .faultWrite(
EL0, faultCvacEL0)
5485 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::tpc, &HFGITR::dccivac>)
5488 .monWrite().hypWrite();
5490 .monWrite().hypWrite();
5492 .hypWrite().monSecureWrite().monNonSecureWrite();
5494 .hypWrite().monSecureWrite().monNonSecureWrite();
5496 .hypWrite().monSecureWrite().monNonSecureWrite();
5498 .hypWrite().monSecureWrite().monNonSecureWrite();
5500 .monSecureWrite().monNonSecureWrite();
5502 .monSecureWrite().monNonSecureWrite();
5503 InitReg(MISCREG_TLBI_VMALLE1OS)
5504 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbivmalle1os>)
5505 .writes(1).exceptUserMode();
5506 InitReg(MISCREG_TLBI_VAE1OS)
5507 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbivae1os>)
5508 .writes(1).exceptUserMode();
5509 InitReg(MISCREG_TLBI_ASIDE1OS)
5510 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbiaside1os>)
5511 .writes(1).exceptUserMode();
5512 InitReg(MISCREG_TLBI_VAAE1OS)
5513 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbivaae1os>)
5514 .writes(1).exceptUserMode();
5515 InitReg(MISCREG_TLBI_VALE1OS)
5516 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbivale1os>)
5517 .writes(1).exceptUserMode();
5518 InitReg(MISCREG_TLBI_VAALE1OS)
5519 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbivaale1os>)
5520 .writes(1).exceptUserMode();
5521 InitReg(MISCREG_TLBI_VMALLE1IS)
5522 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbivmalle1is>)
5523 .writes(1).exceptUserMode();
5524 InitReg(MISCREG_TLBI_VAE1IS)
5525 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbivae1is>)
5526 .writes(1).exceptUserMode();
5527 InitReg(MISCREG_TLBI_ASIDE1IS)
5528 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbiaside1is>)
5529 .writes(1).exceptUserMode();
5530 InitReg(MISCREG_TLBI_VAAE1IS)
5531 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbivaae1is>)
5532 .writes(1).exceptUserMode();
5533 InitReg(MISCREG_TLBI_VALE1IS)
5534 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbivale1is>)
5535 .writes(1).exceptUserMode();
5536 InitReg(MISCREG_TLBI_VAALE1IS)
5537 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbivaale1is>)
5538 .writes(1).exceptUserMode();
5539 InitReg(MISCREG_TLBI_VMALLE1)
5540 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbivmalle1>)
5541 .writes(1).exceptUserMode();
5542 InitReg(MISCREG_TLBI_VAE1)
5543 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbivae1>)
5544 .writes(1).exceptUserMode();
5545 InitReg(MISCREG_TLBI_ASIDE1)
5546 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbiaside1>)
5547 .writes(1).exceptUserMode();
5548 InitReg(MISCREG_TLBI_VAAE1)
5549 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbivaae1>)
5550 .writes(1).exceptUserMode();
5551 InitReg(MISCREG_TLBI_VALE1)
5552 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbivale1>)
5553 .writes(1).exceptUserMode();
5554 InitReg(MISCREG_TLBI_VAALE1)
5555 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbivaale1>)
5556 .writes(1).exceptUserMode();
5557 InitReg(MISCREG_TLBI_IPAS2E1OS)
5558 .monWrite().hypWrite();
5559 InitReg(MISCREG_TLBI_IPAS2LE1OS)
5560 .monWrite().hypWrite();
5561 InitReg(MISCREG_TLBI_ALLE2OS)
5562 .monWrite().hypWrite();
5563 InitReg(MISCREG_TLBI_VAE2OS)
5564 .monWrite().hypWrite();
5565 InitReg(MISCREG_TLBI_ALLE1OS)
5566 .monWrite().hypWrite();
5567 InitReg(MISCREG_TLBI_VALE2OS)
5568 .monWrite().hypWrite();
5569 InitReg(MISCREG_TLBI_VMALLS12E1OS)
5570 .monWrite().hypWrite();
5571 InitReg(MISCREG_TLBI_IPAS2E1IS)
5572 .monWrite().hypWrite();
5573 InitReg(MISCREG_TLBI_IPAS2LE1IS)
5574 .monWrite().hypWrite();
5575 InitReg(MISCREG_TLBI_ALLE2IS)
5576 .monWrite().hypWrite();
5577 InitReg(MISCREG_TLBI_VAE2IS)
5578 .monWrite().hypWrite();
5579 InitReg(MISCREG_TLBI_ALLE1IS)
5580 .monWrite().hypWrite();
5581 InitReg(MISCREG_TLBI_VALE2IS)
5582 .monWrite().hypWrite();
5583 InitReg(MISCREG_TLBI_VMALLS12E1IS)
5584 .monWrite().hypWrite();
5585 InitReg(MISCREG_TLBI_IPAS2E1)
5586 .monWrite().hypWrite();
5587 InitReg(MISCREG_TLBI_IPAS2LE1)
5588 .monWrite().hypWrite();
5589 InitReg(MISCREG_TLBI_ALLE2)
5590 .monWrite().hypWrite();
5591 InitReg(MISCREG_TLBI_VAE2)
5592 .monWrite().hypWrite();
5593 InitReg(MISCREG_TLBI_ALLE1)
5594 .monWrite().hypWrite();
5595 InitReg(MISCREG_TLBI_VALE2)
5596 .monWrite().hypWrite();
5597 InitReg(MISCREG_TLBI_VMALLS12E1)
5598 .monWrite().hypWrite();
5599 InitReg(MISCREG_TLBI_ALLE3OS)
5600 .monSecureWrite().monNonSecureWrite();
5601 InitReg(MISCREG_TLBI_VAE3OS)
5602 .monSecureWrite().monNonSecureWrite();
5603 InitReg(MISCREG_TLBI_VALE3OS)
5604 .monSecureWrite().monNonSecureWrite();
5605 InitReg(MISCREG_TLBI_ALLE3IS)
5606 .monSecureWrite().monNonSecureWrite();
5607 InitReg(MISCREG_TLBI_VAE3IS)
5608 .monSecureWrite().monNonSecureWrite();
5609 InitReg(MISCREG_TLBI_VALE3IS)
5610 .monSecureWrite().monNonSecureWrite();
5611 InitReg(MISCREG_TLBI_ALLE3)
5612 .monSecureWrite().monNonSecureWrite();
5613 InitReg(MISCREG_TLBI_VAE3)
5614 .monSecureWrite().monNonSecureWrite();
5615 InitReg(MISCREG_TLBI_VALE3)
5616 .monSecureWrite().monNonSecureWrite();
5618 InitReg(MISCREG_TLBI_RVAE1)
5619 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvae1>)
5620 .writes(1).exceptUserMode();
5621 InitReg(MISCREG_TLBI_RVAAE1)
5622 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvaae1>)
5623 .writes(1).exceptUserMode();
5624 InitReg(MISCREG_TLBI_RVALE1)
5625 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvale1>)
5626 .writes(1).exceptUserMode();
5627 InitReg(MISCREG_TLBI_RVAALE1)
5628 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvaale1>)
5629 .writes(1).exceptUserMode();
5630 InitReg(MISCREG_TLBI_RIPAS2E1)
5631 .hypWrite().monWrite();
5632 InitReg(MISCREG_TLBI_RIPAS2LE1)
5633 .hypWrite().monWrite();
5634 InitReg(MISCREG_TLBI_RVAE2)
5635 .hypWrite().monWrite();
5636 InitReg(MISCREG_TLBI_RVALE2)
5637 .hypWrite().monWrite();
5638 InitReg(MISCREG_TLBI_RVAE3)
5640 InitReg(MISCREG_TLBI_RVALE3)
5642 InitReg(MISCREG_TLBI_RVAE1IS)
5643 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbirvae1is>)
5644 .writes(1).exceptUserMode();
5645 InitReg(MISCREG_TLBI_RVAAE1IS)
5646 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbirvaae1is>)
5647 .writes(1).exceptUserMode();
5648 InitReg(MISCREG_TLBI_RVALE1IS)
5649 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbirvale1is>)
5650 .writes(1).exceptUserMode();
5651 InitReg(MISCREG_TLBI_RVAALE1IS)
5652 .faultWrite(
EL1, faultTlbiIsEL1<&HFGITR::tlbirvaale1is>)
5653 .writes(1).exceptUserMode();
5654 InitReg(MISCREG_TLBI_RIPAS2E1IS)
5655 .hypWrite().monWrite();
5656 InitReg(MISCREG_TLBI_RIPAS2LE1IS)
5657 .hypWrite().monWrite();
5658 InitReg(MISCREG_TLBI_RVAE2IS)
5659 .hypWrite().monWrite();
5660 InitReg(MISCREG_TLBI_RVALE2IS)
5661 .hypWrite().monWrite();
5662 InitReg(MISCREG_TLBI_RVAE3IS)
5664 InitReg(MISCREG_TLBI_RVALE3IS)
5666 InitReg(MISCREG_TLBI_RVAE1OS)
5667 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbirvae1os>)
5668 .writes(1).exceptUserMode();
5669 InitReg(MISCREG_TLBI_RVAAE1OS)
5670 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbirvaae1os>)
5671 .writes(1).exceptUserMode();
5672 InitReg(MISCREG_TLBI_RVALE1OS)
5673 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbirvale1os>)
5674 .writes(1).exceptUserMode();
5675 InitReg(MISCREG_TLBI_RVAALE1OS)
5676 .faultWrite(
EL1, faultTlbiOsEL1<&HFGITR::tlbirvaale1os>)
5677 .writes(1).exceptUserMode();
5678 InitReg(MISCREG_TLBI_RIPAS2E1OS)
5679 .hypWrite().monWrite();
5680 InitReg(MISCREG_TLBI_RIPAS2LE1OS)
5681 .hypWrite().monWrite();
5682 InitReg(MISCREG_TLBI_RVAE2OS)
5683 .hypWrite().monWrite();
5684 InitReg(MISCREG_TLBI_RVALE2OS)
5685 .hypWrite().monWrite();
5686 InitReg(MISCREG_TLBI_RVAE3OS)
5688 InitReg(MISCREG_TLBI_RVALE3OS)
5690 InitReg(MISCREG_TLBI_VMALLE1OSNXS)
5691 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbivmalle1os>)
5692 .writes(1).exceptUserMode();
5693 InitReg(MISCREG_TLBI_VAE1OSNXS)
5694 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbivae1os>)
5695 .writes(1).exceptUserMode();
5696 InitReg(MISCREG_TLBI_ASIDE1OSNXS)
5697 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbiaside1os>)
5698 .writes(1).exceptUserMode();
5699 InitReg(MISCREG_TLBI_VAAE1OSNXS)
5700 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbivaae1os>)
5701 .writes(1).exceptUserMode();
5702 InitReg(MISCREG_TLBI_VALE1OSNXS)
5703 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbivale1os>)
5704 .writes(1).exceptUserMode();
5705 InitReg(MISCREG_TLBI_VAALE1OSNXS)
5706 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbivaale1os>)
5707 .writes(1).exceptUserMode();
5708 InitReg(MISCREG_TLBI_VMALLE1ISNXS)
5709 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbivmalle1is>)
5710 .writes(1).exceptUserMode();
5711 InitReg(MISCREG_TLBI_VAE1ISNXS)
5712 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbivae1is>)
5713 .writes(1).exceptUserMode();
5714 InitReg(MISCREG_TLBI_ASIDE1ISNXS)
5715 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbiaside1is>)
5716 .writes(1).exceptUserMode();
5717 InitReg(MISCREG_TLBI_VAAE1ISNXS)
5718 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbivaae1is>)
5719 .writes(1).exceptUserMode();
5720 InitReg(MISCREG_TLBI_VALE1ISNXS)
5721 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbivale1is>)
5722 .writes(1).exceptUserMode();
5723 InitReg(MISCREG_TLBI_VAALE1ISNXS)
5724 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbivaale1is>)
5725 .writes(1).exceptUserMode();
5726 InitReg(MISCREG_TLBI_VMALLE1NXS)
5727 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbivmalle1>)
5728 .writes(1).exceptUserMode();
5729 InitReg(MISCREG_TLBI_VAE1NXS)
5730 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbivae1>)
5731 .writes(1).exceptUserMode();
5732 InitReg(MISCREG_TLBI_ASIDE1NXS)
5733 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbiaside1>)
5734 .writes(1).exceptUserMode();
5735 InitReg(MISCREG_TLBI_VAAE1NXS)
5736 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbivaae1>)
5737 .writes(1).exceptUserMode();
5738 InitReg(MISCREG_TLBI_VALE1NXS)
5739 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbivale1>)
5740 .writes(1).exceptUserMode();
5741 InitReg(MISCREG_TLBI_VAALE1NXS)
5742 .faultWrite(
EL1, faultTlbiNxsEL1<&HCR::ttlb, &HFGITR::tlbivaale1>)
5743 .writes(1).exceptUserMode();
5744 InitReg(MISCREG_TLBI_IPAS2E1OSNXS)
5745 .hypWrite().monWrite();
5746 InitReg(MISCREG_TLBI_IPAS2LE1OSNXS)
5747 .hypWrite().monWrite();
5748 InitReg(MISCREG_TLBI_ALLE2OSNXS)
5749 .hypWrite().monWrite();
5750 InitReg(MISCREG_TLBI_VAE2OSNXS)
5751 .hypWrite().monWrite();
5752 InitReg(MISCREG_TLBI_ALLE1OSNXS)
5753 .hypWrite().monWrite();
5754 InitReg(MISCREG_TLBI_VALE2OSNXS)
5755 .hypWrite().monWrite();
5756 InitReg(MISCREG_TLBI_VMALLS12E1OSNXS)
5757 .hypWrite().monWrite();
5758 InitReg(MISCREG_TLBI_IPAS2E1ISNXS)
5759 .hypWrite().monWrite();
5760 InitReg(MISCREG_TLBI_IPAS2LE1ISNXS)
5761 .hypWrite().monWrite();
5762 InitReg(MISCREG_TLBI_ALLE2ISNXS)
5763 .hypWrite().monWrite();
5764 InitReg(MISCREG_TLBI_VAE2ISNXS)
5765 .hypWrite().monWrite();
5766 InitReg(MISCREG_TLBI_ALLE1ISNXS)
5767 .hypWrite().monWrite();
5768 InitReg(MISCREG_TLBI_VALE2ISNXS)
5769 .hypWrite().monWrite();
5770 InitReg(MISCREG_TLBI_VMALLS12E1ISNXS)
5771 .hypWrite().monWrite();
5772 InitReg(MISCREG_TLBI_IPAS2E1NXS)
5773 .hypWrite().monWrite();
5774 InitReg(MISCREG_TLBI_IPAS2LE1NXS)
5775 .hypWrite().monWrite();
5776 InitReg(MISCREG_TLBI_ALLE2NXS)
5777 .hypWrite().monWrite();
5778 InitReg(MISCREG_TLBI_VAE2NXS)
5779 .hypWrite().monWrite();
5780 InitReg(MISCREG_TLBI_ALLE1NXS)
5781 .hypWrite().monWrite();
5782 InitReg(MISCREG_TLBI_VALE2NXS)
5783 .hypWrite().monWrite();
5784 InitReg(MISCREG_TLBI_VMALLS12E1NXS)
5785 .hypWrite().monWrite();
5786 InitReg(MISCREG_TLBI_ALLE3OSNXS)
5788 InitReg(MISCREG_TLBI_VAE3OSNXS)
5790 InitReg(MISCREG_TLBI_VALE3OSNXS)
5792 InitReg(MISCREG_TLBI_ALLE3ISNXS)
5794 InitReg(MISCREG_TLBI_VAE3ISNXS)
5796 InitReg(MISCREG_TLBI_VALE3ISNXS)
5798 InitReg(MISCREG_TLBI_ALLE3NXS)
5800 InitReg(MISCREG_TLBI_VAE3NXS)
5802 InitReg(MISCREG_TLBI_VALE3NXS)
5805 InitReg(MISCREG_TLBI_RVAE1NXS)
5806 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvae1>)
5807 .writes(1).exceptUserMode();
5808 InitReg(MISCREG_TLBI_RVAAE1NXS)
5809 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvaae1>)
5810 .writes(1).exceptUserMode();
5811 InitReg(MISCREG_TLBI_RVALE1NXS)
5812 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvale1>)
5813 .writes(1).exceptUserMode();
5814 InitReg(MISCREG_TLBI_RVAALE1NXS)
5815 .faultWrite(
EL1, faultHcrFgtInstEL1<&HCR::ttlb, &HFGITR::tlbirvaale1>)
5816 .writes(1).exceptUserMode();
5817 InitReg(MISCREG_TLBI_RIPAS2E1NXS)
5818 .hypWrite().monWrite();
5819 InitReg(MISCREG_TLBI_RIPAS2LE1NXS)
5820 .hypWrite().monWrite();
5821 InitReg(MISCREG_TLBI_RVAE2NXS)
5822 .hypWrite().monWrite();
5823 InitReg(MISCREG_TLBI_RVALE2NXS)
5824 .hypWrite().monWrite();
5825 InitReg(MISCREG_TLBI_RVAE3NXS)
5827 InitReg(MISCREG_TLBI_RVALE3NXS)
5829 InitReg(MISCREG_TLBI_RVAE1ISNXS)
5830 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbirvae1is>)
5831 .writes(1).exceptUserMode();
5832 InitReg(MISCREG_TLBI_RVAAE1ISNXS)
5833 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbirvaae1is>)
5834 .writes(1).exceptUserMode();
5835 InitReg(MISCREG_TLBI_RVALE1ISNXS)
5836 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbirvale1is>)
5837 .writes(1).exceptUserMode();
5838 InitReg(MISCREG_TLBI_RVAALE1ISNXS)
5839 .faultWrite(
EL1, faultTlbiIsNxsEL1<&HFGITR::tlbirvaale1is>)
5840 .writes(1).exceptUserMode();
5841 InitReg(MISCREG_TLBI_RIPAS2E1ISNXS)
5842 .hypWrite().monWrite();
5843 InitReg(MISCREG_TLBI_RIPAS2LE1ISNXS)
5844 .hypWrite().monWrite();
5845 InitReg(MISCREG_TLBI_RVAE2ISNXS)
5846 .hypWrite().monWrite();
5847 InitReg(MISCREG_TLBI_RVALE2ISNXS)
5848 .hypWrite().monWrite();
5849 InitReg(MISCREG_TLBI_RVAE3ISNXS)
5851 InitReg(MISCREG_TLBI_RVALE3ISNXS)
5853 InitReg(MISCREG_TLBI_RVAE1OSNXS)
5854 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbirvae1os>)
5855 .writes(1).exceptUserMode();
5856 InitReg(MISCREG_TLBI_RVAAE1OSNXS)
5857 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbirvaae1os>)
5858 .writes(1).exceptUserMode();
5859 InitReg(MISCREG_TLBI_RVALE1OSNXS)
5860 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbirvale1os>)
5861 .writes(1).exceptUserMode();
5862 InitReg(MISCREG_TLBI_RVAALE1OSNXS)
5863 .faultWrite(
EL1, faultTlbiOsNxsEL1<&HFGITR::tlbirvaale1os>)
5864 .writes(1).exceptUserMode();
5865 InitReg(MISCREG_TLBI_RIPAS2E1OSNXS)
5866 .hypWrite().monWrite();
5867 InitReg(MISCREG_TLBI_RIPAS2LE1OSNXS)
5868 .hypWrite().monWrite();
5869 InitReg(MISCREG_TLBI_RVAE2OSNXS)
5870 .hypWrite().monWrite();
5871 InitReg(MISCREG_TLBI_RVALE2OSNXS)
5872 .hypWrite().monWrite();
5873 InitReg(MISCREG_TLBI_RVAE3OSNXS)
5875 InitReg(MISCREG_TLBI_RVALE3OSNXS)
5878 .allPrivileges().exceptUserMode()
5881 .allPrivileges().exceptUserMode()
5919 .allPrivileges().userNonSecureWrite(0).userSecureWrite(0)
5925 .allPrivileges().exceptUserMode()
5926 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::mairEL1>)
5927 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::mairEL1>)
5934 .allPrivileges().exceptUserMode()
5935 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::amairEL1>)
5936 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::amairEL1>)
5953 .allPrivileges().exceptUserMode();
5955 .allPrivileges().exceptUserMode();
5957 .allPrivileges().exceptUserMode()
5958 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::vbarEL1>)
5959 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::vbarEL1>)
5970 .allPrivileges().exceptUserMode().writes(0);
5988 .allPrivileges().exceptUserMode()
5989 .faultRead(
EL1, faultHcrFgtEL1<true, &HCR::trvm, &HFGTR::contextidrEL1>)
5990 .faultWrite(
EL1, faultHcrFgtEL1<false, &HCR::tvm, &HFGTR::contextidrEL1>)
5997 .allPrivileges().exceptUserMode()
5998 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::tpidrEL1>)
5999 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::tpidrEL1>)
6003 .faultRead(
EL0, faultFgtEL0<true, &HFGTR::tpidrEL0>)
6004 .faultWrite(
EL0, faultFgtEL0<false, &HFGTR::tpidrEL0>)
6005 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::tpidrEL0>)
6006 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::tpidrEL0>)
6009 .allPrivileges().userNonSecureWrite(0).userSecureWrite(0)
6010 .faultRead(
EL0, faultFgtEL0<true, &HFGTR::tpidrroEL0>)
6011 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::tpidrroEL0>)
6012 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::tpidrroEL0>)
6022 .faultRead(
EL0, faultGenericTimerEL0)
6024 .privSecureWrite(aarch32EL3)
6028 .faultRead(
EL0, faultCntpctEL0)
6029 .faultRead(
EL1, faultCntpctEL1)
6034 .faultRead(
EL0, faultCntvctEL0)
6035 .faultRead(
EL1, faultCntvctEL1)
6040 .fault(
EL0, faultCntpCtlEL0)
6041 .fault(
EL1, faultCntpCtlEL1)
6042 .res0(0xfffffffffffffff8)
6046 .fault(
EL0, faultCntpCtlEL0)
6047 .fault(
EL1, faultCntpCtlEL1)
6051 .fault(
EL0, faultCntpCtlEL0)
6052 .fault(
EL1, faultCntpCtlEL1)
6053 .res0(0xffffffff00000000)
6057 .fault(
EL0, faultCntvCtlEL0)
6058 .fault(
EL1, faultCntvCtlEL1)
6059 .res0(0xfffffffffffffff8)
6063 .fault(
EL0, faultCntvCtlEL0)
6064 .fault(
EL1, faultCntvCtlEL1)
6068 .fault(
EL0, faultCntvCtlEL0)
6069 .fault(
EL1, faultCntvCtlEL1)
6070 .res0(0xffffffff00000000)
6075 .res0(0xfffffffffffffff8)
6084 .res0(0xffffffff00000000)
6089 .res0(0xfffffffffffffff8)
6098 .res0(0xffffffff00000000)
6103 .res0(0xfffffffffffdfc00)
6108 .res0(0xfffffffffffdfc00)
6113 .fault(
EL1, faultCntpsCtlEL1)
6114 .res0(0xfffffffffffffff8);
6118 .fault(
EL1, faultCntpsCtlEL1);
6122 .fault(
EL1, faultCntpsCtlEL1)
6123 .res0(0xffffffff00000000);
6127 .res0(0xfffffffffffc0000)
6132 .res0(0xfffffffffffffff8)
6141 .res0(0xffffffff00000000)
6144 .mon(sel2_implemented)
6145 .hypSecure(sel2_implemented)
6146 .res0(0xfffffffffffffff8);
6148 .mon(sel2_implemented)
6149 .hypSecure(sel2_implemented);
6151 .mon(sel2_implemented)
6152 .hypSecure(sel2_implemented)
6153 .res0(0xffffffff00000000);
6155 .mon(vhe_implemented)
6157 .res0(0xfffffffffffffff8);
6159 .mon(vhe_implemented)
6160 .hyp(vhe_implemented);
6162 .mon(vhe_implemented)
6163 .hyp(vhe_implemented)
6164 .res0(0xffffffff00000000);
6166 .mon(vhe_implemented && sel2_implemented)
6167 .hypSecure(vhe_implemented && sel2_implemented)
6168 .res0(0xfffffffffffffff8);
6170 .mon(vhe_implemented && sel2_implemented)
6171 .hypSecure(vhe_implemented && sel2_implemented);
6173 .mon(vhe_implemented && sel2_implemented)
6174 .hypSecure(vhe_implemented && sel2_implemented)
6175 .res0(0xffffffff00000000);
6219 .allPrivileges().exceptUserMode();
6221 .allPrivileges().exceptUserMode();
6223 .allPrivileges().exceptUserMode();
6225 .allPrivileges().exceptUserMode();
6227 .allPrivileges().exceptUserMode();
6229 .allPrivileges().exceptUserMode();
6231 .allPrivileges().exceptUserMode();
6233 .allPrivileges().exceptUserMode();
6235 .allPrivileges().exceptUserMode();
6237 .allPrivileges().exceptUserMode();
6239 .allPrivileges().exceptUserMode();
6241 .allPrivileges().exceptUserMode();
6243 .allPrivileges().exceptUserMode();
6246 .fault(faultUnimplemented);
6248 .allPrivileges().exceptUserMode().writes(0);
6255 .allPrivileges().exceptUserMode()
6258 .allPrivileges().exceptUserMode().writes(0)
6261 .allPrivileges().exceptUserMode().reads(0)
6264 .allPrivileges().exceptUserMode().writes(0)
6268 .allPrivileges().exceptUserMode()
6271 .allPrivileges().exceptUserMode()
6274 .allPrivileges().exceptUserMode()
6277 .allPrivileges().exceptUserMode()
6280 .allPrivileges().exceptUserMode()
6287 .allPrivileges().exceptUserMode()
6291 .allPrivileges().exceptUserMode()
6298 .allPrivileges().exceptUserMode()
6302 .allPrivileges().exceptUserMode()
6309 .allPrivileges().exceptUserMode()
6313 .allPrivileges().exceptUserMode()
6320 .allPrivileges().exceptUserMode()
6324 .allPrivileges().exceptUserMode()
6328 .allPrivileges().exceptUserMode().reads(0)
6331 .allPrivileges().exceptUserMode().writes(0)
6334 .allPrivileges().exceptUserMode().reads(0)
6335 .faultWrite(
EL1, faultIccSgiEL1)
6336 .faultWrite(
EL2, faultIccSgiEL2)
6339 .allPrivileges().exceptUserMode().reads(0)
6340 .faultWrite(
EL1, faultIccSgiEL1)
6341 .faultWrite(
EL2, faultIccSgiEL2)
6344 .allPrivileges().exceptUserMode().reads(0)
6345 .faultWrite(
EL1, faultIccSgiEL1)
6346 .faultWrite(
EL2, faultIccSgiEL2)
6349 .allPrivileges().exceptUserMode().writes(0)
6353 .allPrivileges().exceptUserMode().reads(0)
6356 .allPrivileges().exceptUserMode().writes(0)
6364 .allPrivileges().exceptUserMode()
6369 .secure().exceptUserMode()
6377 .allPrivileges().exceptUserMode()
6382 .secure().exceptUserMode()
6390 .allPrivileges().exceptUserMode()
6395 .secure().exceptUserMode()
6399 .allPrivileges().exceptUserMode()
6400 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::iccIgrpEnEL1>)
6401 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::iccIgrpEnEL1>)
6405 .faultRead(
EL1, faultFgtEL1<true, &HFGTR::iccIgrpEnEL1>)
6406 .faultWrite(
EL1, faultFgtEL1<false, &HFGTR::iccIgrpEnEL1>)
6411 .allPrivileges().exceptUserMode()
6416 .secure().exceptUserMode()
6459 .hyp().mon().writes(0)
6462 .hyp().mon().writes(0)
6465 .hyp().mon().writes(0)
6468 .hyp().mon().writes(0)
6524 .allPrivileges().exceptUserMode();
6526 .allPrivileges().exceptUserMode();
6528 .allPrivileges().exceptUserMode();
6530 .allPrivileges().exceptUserMode();
6532 .allPrivileges().exceptUserMode();
6534 .allPrivileges().exceptUserMode();
6536 .allPrivileges().exceptUserMode();
6538 .allPrivileges().exceptUserMode();
6540 .allPrivileges().exceptUserMode();
6542 .allPrivileges().exceptUserMode();
6544 .allPrivileges().exceptUserMode();
6546 .allPrivileges().exceptUserMode();
6548 .allPrivileges().exceptUserMode();
6550 .allPrivileges().exceptUserMode();
6552 .allPrivileges().exceptUserMode();
6554 .allPrivileges().exceptUserMode();
6556 .allPrivileges().exceptUserMode().reads(0);
6558 .allPrivileges().exceptUserMode();
6560 .allPrivileges().exceptUserMode();
6562 .allPrivileges().exceptUserMode();
6564 .allPrivileges().exceptUserMode();
6566 .allPrivileges().exceptUserMode();
6568 .allPrivileges().exceptUserMode();
6570 .allPrivileges().exceptUserMode();
6572 .allPrivileges().exceptUserMode().reads(0);
6574 .allPrivileges().exceptUserMode().reads(0);
6576 .allPrivileges().exceptUserMode().reads(0);
6578 .allPrivileges().exceptUserMode().writes(0);
6580 .allPrivileges().exceptUserMode().writes(0);
6584 .allPrivileges().exceptUserMode().writes(0);
6586 .allPrivileges().exceptUserMode().writes(0);
6588 .allPrivileges().exceptUserMode();
6590 .allPrivileges().exceptUserMode();
6592 .allPrivileges().exceptUserMode();
6594 .allPrivileges().exceptUserMode();
6602 .allPrivileges().exceptUserMode();
6604 .allPrivileges().exceptUserMode().writes(0);
6606 .allPrivileges().exceptUserMode().reads(0);
6608 .allPrivileges().exceptUserMode().reads(0);
6610 .allPrivileges().exceptUserMode();
6612 .allPrivileges().exceptUserMode();
6614 .allPrivileges().exceptUserMode();
6635 .hyp().mon().writes(0);
6637 .hyp().mon().writes(0);
6639 .hyp().mon().writes(0);
6641 .hyp().mon().writes(0);
6712 AA64ZFR0 zfr0_el1 = 0;
6713 zfr0_el1.f32mm = release->has(ArmExtension::FEAT_F32MM) ? 1 : 0;
6714 zfr0_el1.f64mm = release->has(ArmExtension::FEAT_F64MM) ? 1 : 0;
6715 zfr0_el1.i8mm = release->has(ArmExtension::FEAT_I8MM) ? 1 : 0;
6718 .faultRead(
EL0, faultIdst)
6719 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
6720 .allPrivileges().exceptUserMode().writes(0);
6723 .fault(
EL3, faultZcrEL3)
6727 .fault(
EL2, faultZcrEL2)
6728 .fault(
EL3, faultZcrEL3)
6736 .fault(
EL1, faultZcrEL1)
6737 .fault(
EL2, faultZcrEL2)
6738 .fault(
EL3, faultZcrEL3)
6739 .allPrivileges().exceptUserMode();
6744 AA64SMFR0 smfr0_el1 = 0;
6745 smfr0_el1.f32f32 = 0x1;
6749 smfr0_el1.b16f32 = 0x1;
6750 smfr0_el1.f16f32 = 0x1;
6751 smfr0_el1.i8i32 = 0xF;
6752 smfr0_el1.f64f64 = 0x1;
6753 smfr0_el1.i16i64 = 0xF;
6754 smfr0_el1.smEver = 0;
6755 smfr0_el1.fa64 = 0x1;
6758 .faultRead(
EL0, faultIdst)
6759 .faultRead(
EL1, faultHcrEL1<&HCR::tid3>)
6760 .allPrivileges().writes(0);
6768 .fault(
EL0, faultSmenEL0)
6769 .fault(
EL1, faultSmenEL1)
6770 .fault(
EL2, faultTsmSmen)
6771 .fault(
EL3, faultEsm)
6775 SMIDR smidr_el1 = 0;
6776 smidr_el1.affinity = 0;
6778 smidr_el1.implementer = 0x41;
6781 .faultRead(
EL0, faultIdst)
6782 .faultRead(
EL1, faultHcrEL1<&HCR::tid1>)
6783 .allPrivileges().writes(0);
6786 .fault(
EL1, faultEsm)
6787 .fault(
EL2, faultEsm)
6788 .fault(
EL3, faultEsm)
6789 .allPrivileges().exceptUserMode();
6791 .fault(
EL2, faultEsm)
6792 .fault(
EL3, faultEsm)
6803 smcr_el3.len = smeVL - 1;
6806 .fault(
EL3, faultEsm)
6817 smcr_el2.len = smeVL - 1;
6820 .fault(
EL2, faultTsmSmen)
6821 .fault(
EL3, faultEsm)
6824 .allPrivileges().exceptUserMode();
6834 smcr_el1.len = smeVL - 1;
6837 .fault(
EL1, faultSmenEL1)
6838 .fault(
EL2, faultTsmSmen)
6839 .fault(
EL3, faultEsm)
6840 .allPrivileges().exceptUserMode();
6845 .faultRead(
EL0, faultRng)
6846 .faultRead(
EL1, faultRng)
6847 .faultRead(
EL2, faultRng)
6848 .faultRead(
EL3, faultRng)
6850 .allPrivileges().writes(0);
6852 .faultRead(
EL0, faultRng)
6853 .faultRead(
EL1, faultRng)
6854 .faultRead(
EL2, faultRng)
6855 .faultRead(
EL3, faultRng)
6857 .allPrivileges().writes(0);
6861 .fault(
EL2, faultFgtCtrlRegs)
6862 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6864 .fault(
EL2, faultFgtCtrlRegs)
6865 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6867 .fault(
EL2, faultFgtCtrlRegs)
6868 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6870 .fault(
EL2, faultFgtCtrlRegs)
6871 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6873 .fault(
EL2, faultFgtCtrlRegs)
6874 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6876 .fault(
EL2, faultFgtCtrlRegs)
6877 .hyp().mon(release->has(ArmExtension::FEAT_FGT));
6883 .allPrivileges().exceptUserMode().writes(0);
6886 .fault(
EL1, faultImpdefUnimplEL1)
6887 .fault(
EL2, faultUnimplemented)
6888 .fault(
EL3, faultUnimplemented)
6889 .warnNotFail(impdefAsNop);
6894 .fault(faultUnimplemented);
6897 .fault(faultUnimplemented);
6900 .fault(faultUnimplemented);
6903 .fault(faultUnimplemented);
6906 .fault(faultUnimplemented);
6909 .fault(faultUnimplemented);
6912 .fault(faultUnimplemented);
6915 .fault(faultUnimplemented);
6918 .fault(faultUnimplemented);
6921 .fault(faultUnimplemented);
6924 .fault(faultUnimplemented);
6928 .reset(
p.mpamidr_el1)
6930 .faultRead(
EL1, faultMpamIdrEL1)
6931 .faultRead(
EL2, faultMpamEL2)
6932 .allPrivileges().exceptUserMode().writes(0);
6935 .fault(
EL1, faultMpam0EL1)
6936 .fault(
EL2, faultMpamEL2)
6937 .priv().hyp().mon();
6940 .fault(
EL1, faultMpam1EL1)
6941 .fault(
EL2, faultMpamEL2)
6942 .priv().hyp().mon();
6945 .fault(
EL2, faultMpam12EL2)
6950 .fault(
EL2, faultMpamEL2)
6954 .fault(
EL2, faultMpamEL2)
6957 .fault(
EL2, faultMpamEL2)
6960 .fault(
EL2, faultMpamEL2)
6963 .fault(
EL2, faultMpamEL2)
6966 .fault(
EL2, faultMpamEL2)
6969 .fault(
EL2, faultMpamEL2)
6972 .fault(
EL2, faultMpamEL2)
6975 .fault(
EL2, faultMpamEL2)
6978 .fault(
EL2, faultMpamEL2)
6982 .fault(
EL2, faultMpamEL2)
6989 .fault(
EL1, faultMpamsmEL1)
6990 .fault(
EL2, faultMpamEL2)
6991 .allPrivileges().exceptUserMode();
7003 assert(idxToMiscRegNum.empty());
7004 for (
const auto& [key,
val] : miscRegNumToIdx) {
7005 idxToMiscRegNum.insert({
val, key});
Fault undefined(bool disabled=false) const
const MiscRegLUTEntryInitializer InitReg(uint32_t reg)
void initializeMiscRegMetadata()
const ArmRelease * release
This could be either a FS or a SE release.
Metadata table accessible via the value of the register.
chain userNonSecureWrite(bool v=true) const
chain userSecureWrite(bool v=true) const
chain exceptUserMode() const
chain warnNotFail(bool v=true) const
chain mapsTo(uint32_t l, uint32_t u=0) const
chain fault(ExceptionLevel el, MiscRegLUTEntry::FaultCB cb) const
chain userSecureRead(bool v=true) const
chain reads(bool v) const
chain highest(ArmSystem *const sys) const
chain secure(bool v=true) const
chain mutex(bool v=true) const
chain raz(uint64_t mask=(uint64_t) -1) const
chain monSecure(bool v=true) const
chain privSecure(bool v=true) const
chain nonSecure(bool v=true) const
chain monNonSecureWrite(bool v=true) const
chain reset(uint64_t res_val) const
chain monNonSecureRead(bool v=true) const
chain unverifiable(bool v=true) const
chain banked(bool v=true) const
chain res0(uint64_t mask) const
chain bankedChild(bool v=true) const
chain hypWrite(bool v=true) const
chain writes(bool v) const
chain allPrivileges(bool v=true) const
chain monSecureRead(bool v=true) const
chain privSecureWrite(bool v=true) const
chain res1(uint64_t mask) const
chain faultRead(ExceptionLevel el, MiscRegLUTEntry::FaultCB cb) const
chain monNonSecure(bool v=true) const
chain monSecureWrite(bool v=true) const
chain mon(bool v=true) const
chain unimplemented() const
chain privNonSecureWrite(bool v=true) const
chain unserialize(bool v=true) const
chain faultWrite(ExceptionLevel el, MiscRegLUTEntry::FaultCB cb) const
chain hyp(bool v=true) const
bool has(ArmExtension ext) const
bool highestELIs64() const
Returns true if the register width of the highest implemented exception level is 64 bits (ARMv8)
ArmISA::ExceptionLevel highestEL() const
Returns the highest implemented exception level.
static bool haveEL(ThreadContext *tc, ArmISA::ExceptionLevel el)
Return true if the system implements a specific exception level.
This class is implementing the Base class for a generic AArch64 instruction which is making use of sy...
ThreadContext is the external interface to all thread state for anything outside of the CPU.
virtual RegVal readMiscReg(RegIndex misc_reg)=0
virtual BaseISA * getIsaPtr() const =0
virtual RegVal readMiscRegNoEffect(RegIndex misc_reg) const =0
#define panic(...)
This implements a cprintf based panic() function.
const Params & params() const
bool ELIs32(ThreadContext *tc, ExceptionLevel el)
static CPSR resetCPSR(ArmSystem *system)
int unflattenResultMiscReg[NUM_MISCREGS]
If the reg is a child reg of a banked set, then the parent is the last banked one in the list.
Bitfield< 7, 4 > asidbits
bool AArch32isUndefinedGenericTimer(MiscRegIndex reg, ThreadContext *tc)
uint8_t encodePhysAddrRange64(int pa_size)
Returns the encoding corresponding to the specified n.
bool ELIsInHost(ThreadContext *tc, ExceptionLevel el)
Returns true if the current exception level el is executing a Host OS or an application of a Host OS ...
ExceptionLevel currEL(const ThreadContext *tc)
Returns the current Exception Level (EL) of the provided ThreadContext.
MiscRegIndex decodeAArch64SysReg(unsigned op0, unsigned op1, unsigned crn, unsigned crm, unsigned op2)
MiscRegIndex decodeCP15Reg(unsigned crn, unsigned opc1, unsigned crm, unsigned opc2)
Fault checkFaultAccessAArch64SysReg(MiscRegIndex reg, CPSR cpsr, ThreadContext *tc, const MiscRegOp64 &inst)
bool isSecureBelowEL3(ThreadContext *tc)
bool fgtEnabled(ThreadContext *tc)
bool EL2Enabled(ThreadContext *tc)
void preUnflattenMiscReg()
bool isHcrxEL2Enabled(ThreadContext *tc)
@ MISCREG_ID_AA64PFR0_EL1
@ MISCREG_ICC_BPR1_EL1_NS
@ MISCREG_ICC_IGRPEN1_EL1_NS
@ MISCREG_ICC_IGRPEN1_EL3
@ MISCREG_ID_AA64ZFR0_EL1
@ MISCREG_ICC_IGRPEN1_EL1_S
@ MISCREG_ID_AA64DFR0_EL1
@ MISCREG_ICC_AP1R3_EL1_NS
@ MISCREG_ICC_AP1R0_EL1_S
@ MISCREG_ICC_AP1R1_EL1_S
@ MISCREG_ID_AA64DFR1_EL1
@ MISCREG_ID_AA64ISAR1_EL1
@ MISCREG_ID_AA64MMFR1_EL1
@ MISCREG_ICC_AP1R3_EL1_S
@ MISCREG_ID_AA64MMFR3_EL1
@ MISCREG_CNTHPS_CVAL_EL2
@ MISCREG_CNTHPS_TVAL_EL2
@ MISCREG_ICC_AP1R1_EL1_NS
@ MISCREG_ID_AA64MMFR0_EL1
@ MISCREG_ICC_CTLR_EL1_NS
@ MISCREG_CNTHVS_TVAL_EL2
@ MISCREG_CNTHVS_CVAL_EL2
@ MISCREG_ID_AA64MMFR2_EL1
@ MISCREG_DBGCLAIMSET_EL1
@ MISCREG_ICC_AP1R0_EL1_NS
@ MISCREG_ICC_AP1R2_EL1_S
@ MISCREG_ICC_IGRPEN0_EL1
@ MISCREG_ICC_AP1R2_EL1_NS
@ MISCREG_DBGCLAIMCLR_EL1
@ MISCREG_ID_AA64AFR1_EL1
@ MISCREG_ICC_IGRPEN1_EL1
@ MISCREG_ID_AA64AFR0_EL1
@ MISCREG_ID_AA64ISAR0_EL1
@ MISCREG_ID_AA64SMFR0_EL1
@ MISCREG_CONTEXTIDR_EL12
@ MISCREG_DBGAUTHSTATUS_EL1
@ MISCREG_PMXEVTYPER_PMCCFILTR
@ MISCREG_ID_AA64PFR1_EL1
std::optional< MiscRegNum64 > encodeAArch64SysReg(MiscRegIndex misc_reg)
MiscRegIndex decodeCP14Reg(unsigned crn, unsigned opc1, unsigned crm, unsigned opc2)
bool condGenericTimerSystemAccessTrapEL1(const MiscRegIndex misc_reg, ThreadContext *tc)
int unflattenMiscReg(int reg)
int snsBankedIndex(MiscRegIndex reg, ThreadContext *tc)
std::tuple< bool, bool > canWriteCoprocReg(MiscRegIndex reg, SCR scr, CPSR cpsr, ThreadContext *tc)
Check for permission to write coprocessor registers.
bool HaveExt(ThreadContext *tc, ArmExtension ext)
Returns true if the provided ThreadContext supports the ArmExtension passed as a second argument.
int snsBankedIndex64(MiscRegIndex reg, ThreadContext *tc)
MiscRegIndex decodeCP15Reg64(unsigned crm, unsigned opc1)
std::vector< struct MiscRegLUTEntry > lookUpMiscReg(NUM_MISCREGS)
static Fault defaultFaultE2H_EL2(const MiscRegLUTEntry &entry, ThreadContext *tc, const MiscRegOp64 &inst)
std::tuple< bool, bool > canReadCoprocReg(MiscRegIndex reg, SCR scr, CPSR cpsr, ThreadContext *tc)
Check for permission to read coprocessor registers.
static Fault defaultFaultE2H_EL3(const MiscRegLUTEntry &entry, ThreadContext *tc, const MiscRegOp64 &inst)
Copyright (c) 2024 Arm Limited All rights reserved.
std::shared_ptr< FaultBase > Fault
bool FullSystem
The FullSystem variable can be used to determine the current mode of simulation.
constexpr decltype(nullptr) NoFault
static Fault defaultFault(const MiscRegLUTEntry &entry, ThreadContext *tc, const MiscRegOp64 &inst)
std::array< FaultCB, EL3+1 > faultRead
std::bitset< NUM_MISCREG_INFOS > info
std::array< FaultCB, EL3+1 > faultWrite
Fault checkFault(ThreadContext *tc, const MiscRegOp64 &inst, ExceptionLevel el)