protected override void InitializeRegisters()
{
indexValueMapR = new Dictionary <int, ArmRegisters>
{
{ 0, ArmRegisters.R0 },
{ 1, ArmRegisters.R1 },
{ 2, ArmRegisters.R2 },
{ 3, ArmRegisters.R3 },
{ 4, ArmRegisters.R4 },
{ 5, ArmRegisters.R5 },
{ 6, ArmRegisters.R6 },
{ 7, ArmRegisters.R7 },
{ 8, ArmRegisters.R8 },
{ 9, ArmRegisters.R9 },
{ 10, ArmRegisters.R10 },
{ 11, ArmRegisters.R11 },
{ 12, ArmRegisters.R12 },
{ 13, ArmRegisters.R13 },
{ 14, ArmRegisters.R14 },
{ 15, ArmRegisters.R15 },
};
R = new RegistersGroup <UInt32>(
indexValueMapR.Keys,
i => GetRegisterValue32((int)indexValueMapR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapR[i], v));
}
protected override void InitializeRegisters()
{
var indexValueMapR = new Dictionary <int, PowerPc64Registers>
{
{ 0, PowerPc64Registers.R0 },
{ 1, PowerPc64Registers.R1 },
{ 2, PowerPc64Registers.R2 },
{ 3, PowerPc64Registers.R3 },
{ 4, PowerPc64Registers.R4 },
{ 5, PowerPc64Registers.R5 },
{ 6, PowerPc64Registers.R6 },
{ 7, PowerPc64Registers.R7 },
{ 8, PowerPc64Registers.R8 },
{ 9, PowerPc64Registers.R9 },
{ 10, PowerPc64Registers.R10 },
{ 11, PowerPc64Registers.R11 },
{ 12, PowerPc64Registers.R12 },
{ 13, PowerPc64Registers.R13 },
{ 14, PowerPc64Registers.R14 },
{ 15, PowerPc64Registers.R15 },
{ 16, PowerPc64Registers.R16 },
{ 17, PowerPc64Registers.R17 },
{ 18, PowerPc64Registers.R18 },
{ 19, PowerPc64Registers.R19 },
{ 20, PowerPc64Registers.R20 },
{ 21, PowerPc64Registers.R21 },
{ 22, PowerPc64Registers.R22 },
{ 23, PowerPc64Registers.R23 },
{ 24, PowerPc64Registers.R24 },
{ 25, PowerPc64Registers.R25 },
{ 26, PowerPc64Registers.R26 },
{ 27, PowerPc64Registers.R27 },
{ 28, PowerPc64Registers.R28 },
{ 29, PowerPc64Registers.R29 },
{ 30, PowerPc64Registers.R30 },
{ 31, PowerPc64Registers.R31 },
};
R = new RegistersGroup(
indexValueMapR.Keys,
i => GetRegisterUnsafe((int)indexValueMapR[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapR[i], v));
}
protected override void InitializeRegisters()
{
indexValueMapX = new Dictionary <int, RiscVRegisters>
{
{ 0, RiscVRegisters.X0 },
{ 1, RiscVRegisters.X1 },
{ 2, RiscVRegisters.X2 },
{ 3, RiscVRegisters.X3 },
{ 4, RiscVRegisters.X4 },
{ 5, RiscVRegisters.X5 },
{ 6, RiscVRegisters.X6 },
{ 7, RiscVRegisters.X7 },
{ 8, RiscVRegisters.X8 },
{ 9, RiscVRegisters.X9 },
{ 10, RiscVRegisters.X10 },
{ 11, RiscVRegisters.X11 },
{ 12, RiscVRegisters.X12 },
{ 13, RiscVRegisters.X13 },
{ 14, RiscVRegisters.X14 },
{ 15, RiscVRegisters.X15 },
{ 16, RiscVRegisters.X16 },
{ 17, RiscVRegisters.X17 },
{ 18, RiscVRegisters.X18 },
{ 19, RiscVRegisters.X19 },
{ 20, RiscVRegisters.X20 },
{ 21, RiscVRegisters.X21 },
{ 22, RiscVRegisters.X22 },
{ 23, RiscVRegisters.X23 },
{ 24, RiscVRegisters.X24 },
{ 25, RiscVRegisters.X25 },
{ 26, RiscVRegisters.X26 },
{ 27, RiscVRegisters.X27 },
{ 28, RiscVRegisters.X28 },
{ 29, RiscVRegisters.X29 },
{ 30, RiscVRegisters.X30 },
{ 31, RiscVRegisters.X31 },
};
X = new RegistersGroup <UInt32>(
indexValueMapX.Keys,
i => GetRegisterValue32((int)indexValueMapX[i]),
(i, v) => SetRegisterValue32((int)indexValueMapX[i], v));
}
protected override void InitializeRegisters()
{
var indexValueMapX = new Dictionary <int, RiscV32Registers>
{
{ 0, RiscV32Registers.X0 },
{ 1, RiscV32Registers.X1 },
{ 2, RiscV32Registers.X2 },
{ 3, RiscV32Registers.X3 },
{ 4, RiscV32Registers.X4 },
{ 5, RiscV32Registers.X5 },
{ 6, RiscV32Registers.X6 },
{ 7, RiscV32Registers.X7 },
{ 8, RiscV32Registers.X8 },
{ 9, RiscV32Registers.X9 },
{ 10, RiscV32Registers.X10 },
{ 11, RiscV32Registers.X11 },
{ 12, RiscV32Registers.X12 },
{ 13, RiscV32Registers.X13 },
{ 14, RiscV32Registers.X14 },
{ 15, RiscV32Registers.X15 },
{ 16, RiscV32Registers.X16 },
{ 17, RiscV32Registers.X17 },
{ 18, RiscV32Registers.X18 },
{ 19, RiscV32Registers.X19 },
{ 20, RiscV32Registers.X20 },
{ 21, RiscV32Registers.X21 },
{ 22, RiscV32Registers.X22 },
{ 23, RiscV32Registers.X23 },
{ 24, RiscV32Registers.X24 },
{ 25, RiscV32Registers.X25 },
{ 26, RiscV32Registers.X26 },
{ 27, RiscV32Registers.X27 },
{ 28, RiscV32Registers.X28 },
{ 29, RiscV32Registers.X29 },
{ 30, RiscV32Registers.X30 },
{ 31, RiscV32Registers.X31 },
};
X = new RegistersGroup(
indexValueMapX.Keys,
i => GetRegisterUnsafe((int)indexValueMapX[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapX[i], v));
var indexValueMapT = new Dictionary <int, RiscV32Registers>
{
{ 0, RiscV32Registers.T0 },
{ 1, RiscV32Registers.T1 },
{ 2, RiscV32Registers.T2 },
{ 3, RiscV32Registers.T3 },
{ 4, RiscV32Registers.T4 },
{ 5, RiscV32Registers.T5 },
{ 6, RiscV32Registers.T6 },
};
T = new RegistersGroup(
indexValueMapT.Keys,
i => GetRegisterUnsafe((int)indexValueMapT[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapT[i], v));
var indexValueMapS = new Dictionary <int, RiscV32Registers>
{
{ 0, RiscV32Registers.S0 },
{ 1, RiscV32Registers.S1 },
{ 2, RiscV32Registers.S2 },
{ 3, RiscV32Registers.S3 },
{ 4, RiscV32Registers.S4 },
{ 5, RiscV32Registers.S5 },
{ 6, RiscV32Registers.S6 },
{ 7, RiscV32Registers.S7 },
{ 8, RiscV32Registers.S8 },
{ 9, RiscV32Registers.S9 },
{ 10, RiscV32Registers.S10 },
{ 11, RiscV32Registers.S11 },
};
S = new RegistersGroup(
indexValueMapS.Keys,
i => GetRegisterUnsafe((int)indexValueMapS[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapS[i], v));
var indexValueMapA = new Dictionary <int, RiscV32Registers>
{
{ 0, RiscV32Registers.A0 },
{ 1, RiscV32Registers.A1 },
{ 2, RiscV32Registers.A2 },
{ 3, RiscV32Registers.A3 },
{ 4, RiscV32Registers.A4 },
{ 5, RiscV32Registers.A5 },
{ 6, RiscV32Registers.A6 },
{ 7, RiscV32Registers.A7 },
};
A = new RegistersGroup(
indexValueMapA.Keys,
i => GetRegisterUnsafe((int)indexValueMapA[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapA[i], v));
var indexValueMapF = new Dictionary <int, RiscV32Registers>
{
{ 0, RiscV32Registers.F0 },
{ 1, RiscV32Registers.F1 },
{ 2, RiscV32Registers.F2 },
{ 3, RiscV32Registers.F3 },
{ 4, RiscV32Registers.F4 },
{ 5, RiscV32Registers.F5 },
{ 6, RiscV32Registers.F6 },
{ 7, RiscV32Registers.F7 },
{ 8, RiscV32Registers.F8 },
{ 9, RiscV32Registers.F9 },
{ 10, RiscV32Registers.F10 },
{ 11, RiscV32Registers.F11 },
{ 12, RiscV32Registers.F12 },
{ 13, RiscV32Registers.F13 },
{ 14, RiscV32Registers.F14 },
{ 15, RiscV32Registers.F15 },
{ 16, RiscV32Registers.F16 },
{ 17, RiscV32Registers.F17 },
{ 18, RiscV32Registers.F18 },
{ 19, RiscV32Registers.F19 },
{ 20, RiscV32Registers.F20 },
{ 21, RiscV32Registers.F21 },
{ 22, RiscV32Registers.F22 },
{ 23, RiscV32Registers.F23 },
{ 24, RiscV32Registers.F24 },
{ 25, RiscV32Registers.F25 },
{ 26, RiscV32Registers.F26 },
{ 27, RiscV32Registers.F27 },
{ 28, RiscV32Registers.F28 },
{ 29, RiscV32Registers.F29 },
{ 30, RiscV32Registers.F30 },
{ 31, RiscV32Registers.F31 },
};
F = new RegistersGroup(
indexValueMapF.Keys,
i => GetRegisterUnsafe((int)indexValueMapF[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapF[i], v));
}
protected override void InitializeRegisters()
{
indexValueMapR = new Dictionary<int, SparcRegisters>
{
{ 0, SparcRegisters.R0 },
{ 1, SparcRegisters.R1 },
{ 2, SparcRegisters.R2 },
{ 3, SparcRegisters.R3 },
{ 4, SparcRegisters.R4 },
{ 5, SparcRegisters.R5 },
{ 6, SparcRegisters.R6 },
{ 7, SparcRegisters.R7 },
{ 8, SparcRegisters.R8 },
{ 9, SparcRegisters.R9 },
{ 10, SparcRegisters.R10 },
{ 11, SparcRegisters.R11 },
{ 12, SparcRegisters.R12 },
{ 13, SparcRegisters.R13 },
{ 14, SparcRegisters.R14 },
{ 15, SparcRegisters.R15 },
{ 16, SparcRegisters.R16 },
{ 17, SparcRegisters.R17 },
{ 18, SparcRegisters.R18 },
{ 19, SparcRegisters.R19 },
{ 20, SparcRegisters.R20 },
{ 21, SparcRegisters.R21 },
{ 22, SparcRegisters.R22 },
{ 23, SparcRegisters.R23 },
{ 24, SparcRegisters.R24 },
{ 25, SparcRegisters.R25 },
{ 26, SparcRegisters.R26 },
{ 27, SparcRegisters.R27 },
{ 28, SparcRegisters.R28 },
{ 29, SparcRegisters.R29 },
{ 30, SparcRegisters.R30 },
{ 31, SparcRegisters.R31 },
};
R = new RegistersGroup<UInt32>(
indexValueMapR.Keys,
i => GetRegisterValue32((int)indexValueMapR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapR[i], v));
indexValueMapASR = new Dictionary<int, SparcRegisters>
{
{ 16, SparcRegisters.ASR16 },
{ 17, SparcRegisters.ASR17 },
{ 18, SparcRegisters.ASR18 },
{ 19, SparcRegisters.ASR19 },
{ 20, SparcRegisters.ASR20 },
{ 21, SparcRegisters.ASR21 },
{ 22, SparcRegisters.ASR22 },
{ 23, SparcRegisters.ASR23 },
{ 24, SparcRegisters.ASR24 },
{ 25, SparcRegisters.ASR25 },
{ 26, SparcRegisters.ASR26 },
{ 27, SparcRegisters.ASR27 },
{ 28, SparcRegisters.ASR28 },
{ 29, SparcRegisters.ASR29 },
{ 30, SparcRegisters.ASR30 },
{ 31, SparcRegisters.ASR31 },
};
ASR = new RegistersGroup<UInt32>(
indexValueMapASR.Keys,
i => GetRegisterValue32((int)indexValueMapASR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapASR[i], v));
}
protected override void InitializeRegisters()
{
var indexValueMapAR = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.AR0 },
{ 1, XtensaRegisters.AR1 },
{ 2, XtensaRegisters.AR2 },
{ 3, XtensaRegisters.AR3 },
{ 4, XtensaRegisters.AR4 },
{ 5, XtensaRegisters.AR5 },
{ 6, XtensaRegisters.AR6 },
{ 7, XtensaRegisters.AR7 },
{ 8, XtensaRegisters.AR8 },
{ 9, XtensaRegisters.AR9 },
{ 10, XtensaRegisters.AR10 },
{ 11, XtensaRegisters.AR11 },
{ 12, XtensaRegisters.AR12 },
{ 13, XtensaRegisters.AR13 },
{ 14, XtensaRegisters.AR14 },
{ 15, XtensaRegisters.AR15 },
{ 16, XtensaRegisters.AR16 },
{ 17, XtensaRegisters.AR17 },
{ 18, XtensaRegisters.AR18 },
{ 19, XtensaRegisters.AR19 },
{ 20, XtensaRegisters.AR20 },
{ 21, XtensaRegisters.AR21 },
{ 22, XtensaRegisters.AR22 },
{ 23, XtensaRegisters.AR23 },
{ 24, XtensaRegisters.AR24 },
{ 25, XtensaRegisters.AR25 },
{ 26, XtensaRegisters.AR26 },
{ 27, XtensaRegisters.AR27 },
{ 28, XtensaRegisters.AR28 },
{ 29, XtensaRegisters.AR29 },
{ 30, XtensaRegisters.AR30 },
{ 31, XtensaRegisters.AR31 },
};
AR = new RegistersGroup(
indexValueMapAR.Keys,
i => GetRegisterUnsafe((int)indexValueMapAR[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapAR[i], v));
var indexValueMapCONFIGID = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.CONFIGID0 },
{ 1, XtensaRegisters.CONFIGID1 },
};
CONFIGID = new RegistersGroup(
indexValueMapCONFIGID.Keys,
i => GetRegisterUnsafe((int)indexValueMapCONFIGID[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapCONFIGID[i], v));
var indexValueMapSCOMPARE = new Dictionary <int, XtensaRegisters>
{
{ 1, XtensaRegisters.SCOMPARE1 },
};
SCOMPARE = new RegistersGroup(
indexValueMapSCOMPARE.Keys,
i => GetRegisterUnsafe((int)indexValueMapSCOMPARE[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapSCOMPARE[i], v));
var indexValueMapIBREAKA = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.IBREAKA0 },
{ 1, XtensaRegisters.IBREAKA1 },
};
IBREAKA = new RegistersGroup(
indexValueMapIBREAKA.Keys,
i => GetRegisterUnsafe((int)indexValueMapIBREAKA[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapIBREAKA[i], v));
var indexValueMapDBREAKA = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.DBREAKA0 },
{ 1, XtensaRegisters.DBREAKA1 },
};
DBREAKA = new RegistersGroup(
indexValueMapDBREAKA.Keys,
i => GetRegisterUnsafe((int)indexValueMapDBREAKA[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapDBREAKA[i], v));
var indexValueMapDBREAKC = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.DBREAKC0 },
{ 1, XtensaRegisters.DBREAKC1 },
};
DBREAKC = new RegistersGroup(
indexValueMapDBREAKC.Keys,
i => GetRegisterUnsafe((int)indexValueMapDBREAKC[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapDBREAKC[i], v));
var indexValueMapEPC = new Dictionary <int, XtensaRegisters>
{
{ 1, XtensaRegisters.EPC1 },
{ 2, XtensaRegisters.EPC2 },
{ 3, XtensaRegisters.EPC3 },
{ 4, XtensaRegisters.EPC4 },
{ 5, XtensaRegisters.EPC5 },
{ 6, XtensaRegisters.EPC6 },
{ 7, XtensaRegisters.EPC7 },
};
EPC = new RegistersGroup(
indexValueMapEPC.Keys,
i => GetRegisterUnsafe((int)indexValueMapEPC[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapEPC[i], v));
var indexValueMapEPS = new Dictionary <int, XtensaRegisters>
{
{ 2, XtensaRegisters.EPS2 },
{ 3, XtensaRegisters.EPS3 },
{ 4, XtensaRegisters.EPS4 },
{ 5, XtensaRegisters.EPS5 },
{ 6, XtensaRegisters.EPS6 },
{ 7, XtensaRegisters.EPS7 },
};
EPS = new RegistersGroup(
indexValueMapEPS.Keys,
i => GetRegisterUnsafe((int)indexValueMapEPS[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapEPS[i], v));
var indexValueMapEXCSAVE = new Dictionary <int, XtensaRegisters>
{
{ 1, XtensaRegisters.EXCSAVE1 },
{ 2, XtensaRegisters.EXCSAVE2 },
{ 3, XtensaRegisters.EXCSAVE3 },
{ 4, XtensaRegisters.EXCSAVE4 },
{ 5, XtensaRegisters.EXCSAVE5 },
{ 6, XtensaRegisters.EXCSAVE6 },
{ 7, XtensaRegisters.EXCSAVE7 },
};
EXCSAVE = new RegistersGroup(
indexValueMapEXCSAVE.Keys,
i => GetRegisterUnsafe((int)indexValueMapEXCSAVE[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapEXCSAVE[i], v));
var indexValueMapCCOMPARE = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.CCOMPARE0 },
{ 1, XtensaRegisters.CCOMPARE1 },
{ 2, XtensaRegisters.CCOMPARE2 },
};
CCOMPARE = new RegistersGroup(
indexValueMapCCOMPARE.Keys,
i => GetRegisterUnsafe((int)indexValueMapCCOMPARE[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapCCOMPARE[i], v));
var indexValueMapMISC = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.MISC0 },
{ 1, XtensaRegisters.MISC1 },
};
MISC = new RegistersGroup(
indexValueMapMISC.Keys,
i => GetRegisterUnsafe((int)indexValueMapMISC[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapMISC[i], v));
var indexValueMapA = new Dictionary <int, XtensaRegisters>
{
{ 0, XtensaRegisters.A0 },
{ 1, XtensaRegisters.A1 },
{ 2, XtensaRegisters.A2 },
{ 3, XtensaRegisters.A3 },
{ 4, XtensaRegisters.A4 },
{ 5, XtensaRegisters.A5 },
{ 6, XtensaRegisters.A6 },
{ 7, XtensaRegisters.A7 },
{ 8, XtensaRegisters.A8 },
{ 9, XtensaRegisters.A9 },
{ 10, XtensaRegisters.A10 },
{ 11, XtensaRegisters.A11 },
{ 12, XtensaRegisters.A12 },
{ 13, XtensaRegisters.A13 },
{ 14, XtensaRegisters.A14 },
{ 15, XtensaRegisters.A15 },
};
A = new RegistersGroup(
indexValueMapA.Keys,
i => GetRegisterUnsafe((int)indexValueMapA[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapA[i], v));
}
protected override void InitializeRegisters()
{
indexValueMapR = new Dictionary <int, SparcRegisters>
{
{ 0, SparcRegisters.R0 },
{ 1, SparcRegisters.R1 },
{ 2, SparcRegisters.R2 },
{ 3, SparcRegisters.R3 },
{ 4, SparcRegisters.R4 },
{ 5, SparcRegisters.R5 },
{ 6, SparcRegisters.R6 },
{ 7, SparcRegisters.R7 },
{ 8, SparcRegisters.R8 },
{ 9, SparcRegisters.R9 },
{ 10, SparcRegisters.R10 },
{ 11, SparcRegisters.R11 },
{ 12, SparcRegisters.R12 },
{ 13, SparcRegisters.R13 },
{ 14, SparcRegisters.R14 },
{ 15, SparcRegisters.R15 },
{ 16, SparcRegisters.R16 },
{ 17, SparcRegisters.R17 },
{ 18, SparcRegisters.R18 },
{ 19, SparcRegisters.R19 },
{ 20, SparcRegisters.R20 },
{ 21, SparcRegisters.R21 },
{ 22, SparcRegisters.R22 },
{ 23, SparcRegisters.R23 },
{ 24, SparcRegisters.R24 },
{ 25, SparcRegisters.R25 },
{ 26, SparcRegisters.R26 },
{ 27, SparcRegisters.R27 },
{ 28, SparcRegisters.R28 },
{ 29, SparcRegisters.R29 },
{ 30, SparcRegisters.R30 },
{ 31, SparcRegisters.R31 },
};
R = new RegistersGroup <UInt32>(
indexValueMapR.Keys,
i => GetRegisterValue32((int)indexValueMapR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapR[i], v));
indexValueMapASR = new Dictionary <int, SparcRegisters>
{
{ 16, SparcRegisters.ASR16 },
{ 17, SparcRegisters.ASR17 },
{ 18, SparcRegisters.ASR18 },
{ 19, SparcRegisters.ASR19 },
{ 20, SparcRegisters.ASR20 },
{ 21, SparcRegisters.ASR21 },
{ 22, SparcRegisters.ASR22 },
{ 23, SparcRegisters.ASR23 },
{ 24, SparcRegisters.ASR24 },
{ 25, SparcRegisters.ASR25 },
{ 26, SparcRegisters.ASR26 },
{ 27, SparcRegisters.ASR27 },
{ 28, SparcRegisters.ASR28 },
{ 29, SparcRegisters.ASR29 },
{ 30, SparcRegisters.ASR30 },
{ 31, SparcRegisters.ASR31 },
};
ASR = new RegistersGroup <UInt32>(
indexValueMapASR.Keys,
i => GetRegisterValue32((int)indexValueMapASR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapASR[i], v));
}
protected override void InitializeRegisters()
{
indexValueMapR = new Dictionary<int, ArmRegisters>
{
{ 0, ArmRegisters.R0 },
{ 1, ArmRegisters.R1 },
{ 2, ArmRegisters.R2 },
{ 3, ArmRegisters.R3 },
{ 4, ArmRegisters.R4 },
{ 5, ArmRegisters.R5 },
{ 6, ArmRegisters.R6 },
{ 7, ArmRegisters.R7 },
{ 8, ArmRegisters.R8 },
{ 9, ArmRegisters.R9 },
{ 10, ArmRegisters.R10 },
{ 11, ArmRegisters.R11 },
{ 12, ArmRegisters.R12 },
{ 13, ArmRegisters.R13 },
{ 14, ArmRegisters.R14 },
{ 15, ArmRegisters.R15 },
};
R = new RegistersGroup<UInt32>(
indexValueMapR.Keys,
i => GetRegisterValue32((int)indexValueMapR[i]),
(i, v) => SetRegisterValue32((int)indexValueMapR[i], v));
}
protected override void InitializeRegisters()
{
var indexValueMapX = new Dictionary <int, RiscV64Registers>
{
{ 0, RiscV64Registers.X0 },
{ 1, RiscV64Registers.X1 },
{ 2, RiscV64Registers.X2 },
{ 3, RiscV64Registers.X3 },
{ 4, RiscV64Registers.X4 },
{ 5, RiscV64Registers.X5 },
{ 6, RiscV64Registers.X6 },
{ 7, RiscV64Registers.X7 },
{ 8, RiscV64Registers.X8 },
{ 9, RiscV64Registers.X9 },
{ 10, RiscV64Registers.X10 },
{ 11, RiscV64Registers.X11 },
{ 12, RiscV64Registers.X12 },
{ 13, RiscV64Registers.X13 },
{ 14, RiscV64Registers.X14 },
{ 15, RiscV64Registers.X15 },
{ 16, RiscV64Registers.X16 },
{ 17, RiscV64Registers.X17 },
{ 18, RiscV64Registers.X18 },
{ 19, RiscV64Registers.X19 },
{ 20, RiscV64Registers.X20 },
{ 21, RiscV64Registers.X21 },
{ 22, RiscV64Registers.X22 },
{ 23, RiscV64Registers.X23 },
{ 24, RiscV64Registers.X24 },
{ 25, RiscV64Registers.X25 },
{ 26, RiscV64Registers.X26 },
{ 27, RiscV64Registers.X27 },
{ 28, RiscV64Registers.X28 },
{ 29, RiscV64Registers.X29 },
{ 30, RiscV64Registers.X30 },
{ 31, RiscV64Registers.X31 },
};
X = new RegistersGroup(
indexValueMapX.Keys,
i => GetRegisterUnsafe((int)indexValueMapX[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapX[i], v));
var indexValueMapF = new Dictionary <int, RiscV64Registers>
{
{ 0, RiscV64Registers.F0 },
{ 1, RiscV64Registers.F1 },
{ 2, RiscV64Registers.F2 },
{ 3, RiscV64Registers.F3 },
{ 4, RiscV64Registers.F4 },
{ 5, RiscV64Registers.F5 },
{ 6, RiscV64Registers.F6 },
{ 7, RiscV64Registers.F7 },
{ 8, RiscV64Registers.F8 },
{ 9, RiscV64Registers.F9 },
{ 10, RiscV64Registers.F10 },
{ 11, RiscV64Registers.F11 },
{ 12, RiscV64Registers.F12 },
{ 13, RiscV64Registers.F13 },
{ 14, RiscV64Registers.F14 },
{ 15, RiscV64Registers.F15 },
{ 16, RiscV64Registers.F16 },
{ 17, RiscV64Registers.F17 },
{ 18, RiscV64Registers.F18 },
{ 19, RiscV64Registers.F19 },
{ 20, RiscV64Registers.F20 },
{ 21, RiscV64Registers.F21 },
{ 22, RiscV64Registers.F22 },
{ 23, RiscV64Registers.F23 },
{ 24, RiscV64Registers.F24 },
{ 25, RiscV64Registers.F25 },
{ 26, RiscV64Registers.F26 },
{ 27, RiscV64Registers.F27 },
{ 28, RiscV64Registers.F28 },
{ 29, RiscV64Registers.F29 },
{ 30, RiscV64Registers.F30 },
{ 31, RiscV64Registers.F31 },
};
F = new RegistersGroup(
indexValueMapF.Keys,
i => GetRegisterUnsafe((int)indexValueMapF[i]),
(i, v) => SetRegisterUnsafe((int)indexValueMapF[i], v));
}
