public Jump(ECondition conditions, EJump jump, ERegister rm)
{
Condition = conditions;
JumpType = jump;
Rm = rm;
Linked = true;
}
//============================================================
private static UIntPtr TransferKeyName(ERegister type)
{
switch (type)
{
case ERegister.ClassesRoot:
return(HKEY_CLASSES_ROOT);
case ERegister.CurrentConfig:
break;
case ERegister.CurrentUser:
return(HKEY_CURRENT_USER);
case ERegister.DynData:
break;
case ERegister.LocalMachine:
return(HKEY_LOCAL_MACHINE);
case ERegister.PerformanceData:
break;
case ERegister.Users:
return(HKEY_USERS);
default:
break;
}
return(HKEY_CLASSES_ROOT);
}
private EOperand2 ParseOperand2([NotNull] string operand2, [CanBeNull] string shiftValue)
{
// User wants to use an immediate value
if (operand2.StartsWith("#", StringComparison.Ordinal))
{
var value = Parser.ParseImmediate <uint>(operand2);
Immediate = (byte)value;
ShiftCount = 0;
// If its higher than 255 try to fix it by rotating left
if (value >= 256)
{
// User added custom shift value so we cannot rotate
if (!string.IsNullOrEmpty(shiftValue))
{
throw new ArgumentOutOfRangeException();
}
for (var i = 2; i < 32; i += 2)
{
var tryValue = (value << i) | (value >> (32 - i)); // rotate left and check if it fits into 8 bit
if (tryValue >= 256)
{
continue;
}
Immediate = (byte)tryValue;
Rotate = (byte)(i / 2); // divided by 2 because there are only 4 bits rotate value
return(EOperand2.RotateImmediate);
}
// Value cannot be rotatet
throw new ArgumentOutOfRangeException();
}
if (string.IsNullOrEmpty(shiftValue))
{
return(EOperand2.RotateImmediate);
}
// parse custom rotate value
Rotate = Parser.ParseImmediate <byte>(shiftValue);
if (Rotate >= 16)
{
throw new ArgumentOutOfRangeException();
}
return(EOperand2.RotateImmediate);
}
Rm = Parser.ParseRegister(operand2); // use register
if (!string.IsNullOrEmpty(shiftValue) && Parser.ParseShiftInstruction(shiftValue, ref ShiftInst, ref ShiftCount, ref Rs))
{
return(EOperand2.RsShiftRm);
}
return(EOperand2.ImmediateShiftRm);
}
public Blocktransfer(ECondition condition, bool load, bool writeBack, ERegister rn, short regList)
{
Condition = condition;
Load = load;
WriteBack = writeBack;
Rn = rn;
RegisterList = regList;
Decoded = true;
}
public Multiply(ECondition condition, bool setConditionFlags, ERegister rd, ERegister rs, ERegister rm)
{
Condition = condition;
Multiplication = EMultiplication.Mul;
SetConditionFlags = setConditionFlags;
Rd = rd;
Rs = rs;
Rm = rm;
Decoded = true;
}
public void Parse([NotNull] string parameterString)
{
if (Decoded)
{
throw new InvalidOperationException();
}
var parameters = Parser.ParseParameters(parameterString, new[] { ',' });
switch (Multiplication)
{
case EMultiplication.Mul:
if (parameters.Length != 3)
{
throw new TargetParameterCountException();
}
Rd = Parser.ParseRegister(parameters[0]);
Rm = Parser.ParseRegister(parameters[1]);
Rs = Parser.ParseRegister(parameters[2]);
break;
case EMultiplication.Mla:
if (parameters.Length != 4)
{
throw new TargetParameterCountException();
}
Rd = Parser.ParseRegister(parameters[0]);
Rm = Parser.ParseRegister(parameters[1]);
Rs = Parser.ParseRegister(parameters[2]);
Rn = Parser.ParseRegister(parameters[3]);
break;
case EMultiplication.Smlal:
case EMultiplication.Smull:
case EMultiplication.Umlal:
case EMultiplication.UMull:
if (parameters.Length != 4)
{
throw new TargetParameterCountException();
}
RdLo = Parser.ParseRegister(parameters[0]);
RdHi = Parser.ParseRegister(parameters[1]);
Rm = Parser.ParseRegister(parameters[2]);
Rs = Parser.ParseRegister(parameters[3]);
break;
default:
throw new ArgumentOutOfRangeException();
}
Decoded = true;
}
public Multiply(ECondition condition, EMultiplication multiplication, bool setConditionFlags, ERegister rdhi, ERegister rdlo, ERegister rs, ERegister rm)
{
Condition = condition;
Multiplication = multiplication;
SetConditionFlags = setConditionFlags;
RdHi = rdhi;
RdLo = rdlo;
Rs = rs;
Rm = rm;
Decoded = true;
}
public Arithmetic(ECondition condition, EOpcode opcode, bool setConditionFlags, ERegister rn, ERegister rd, byte rotate, byte immediate)
{
Operand2 = EOperand2.RotateImmediate;
Condition = condition;
Opcode = opcode;
SetConditionFlags = setConditionFlags;
Rn = rn;
Rd = rd;
Rotate = rotate;
Immediate = immediate;
Decoded = true;
}
public Arithmetic(ECondition condition, EOpcode opcode, bool setConditionFlags, ERegister rn, ERegister rd, ERegister rs, EShiftInstruction shiftInst, ERegister rm)
{
Operand2 = EOperand2.RsShiftRm;
Condition = condition;
Opcode = opcode;
SetConditionFlags = setConditionFlags;
Rn = rn;
Rd = rd;
Rs = rs;
ShiftInst = shiftInst;
Rm = rm;
Decoded = true;
}
public Arithmetic(ECondition condition, EOpcode opcode, bool setConditionFlags, ERegister rn, ERegister rd, byte shiftCount, EShiftInstruction shiftInst, ERegister rm)
{
Operand2 = EOperand2.ImmediateShiftRm;
Condition = condition;
Opcode = opcode;
SetConditionFlags = setConditionFlags;
Rn = rn;
Rd = rd;
ShiftCount = shiftCount;
ShiftInst = shiftInst;
Rm = rm;
Decoded = true;
}
public DataAccess(ECondition condition, bool load, bool preIndex, bool unsigned, bool writeBack, EDataSize dataSize, ERegister rn, ERegister rd, short immediate)
{
Offset = EOffset.Immediate;
Condition = condition;
Load = load;
PreIndex = preIndex;
Up = unsigned;
WriteBack = writeBack;
DataSize = dataSize;
Rn = rn;
Rd = rd;
Immediate = immediate;
Decoded = true;
Linked = true;
}
private void ParseLabelAccess([NotNull] string parameterString)
{
// Load value at label
var parameters = Parser.ParseParameters(parameterString, new[] { ',' });
if (parameters.Length != 2)
{
throw new TargetParameterCountException();
}
Rd = Parser.ParseRegister(parameters[0]);
Rn = ERegister.Pc;
Label = parameters[1];
Decoded = true;
Linked = false;
}
private static void RegisterEvents()
{
var EventRegister = new ERegister();
var EventAuth = new EAuth();
var EventTeamGroup = new ETeam();
var EventTemUser = new ETeamUser();
var EventProject = new EProject();
var EventTeamProject = new ETeamProject();
var EventWebRequestItem = new EWebRequestItem();
var EventWebRequestDir = new EWebRequestDir();
var EventWebRequestParamsItem = new EWebRequestParamsItem();
var EventWebRequestHistory = new EWebRequestHistory();
var EventChat = new EChat();
var EventUserAccess = new EUserAccess();
var EventUsers = new EUsers();
var EventTramAccess = new ETeamAccess();
}
public DataAccess(ECondition condition, bool load, bool preIndex, bool unsigned, bool writeBack, EDataSize dataSize, ERegister rn, ERegister rd, byte shiftCount, EShiftInstruction shiftInst, ERegister rm)
{
Offset = EOffset.ImmediateShiftRm;
Condition = condition;
Load = load;
PreIndex = preIndex;
Up = unsigned;
WriteBack = writeBack;
DataSize = dataSize;
Rn = rn;
Rd = rd;
ShiftCount = shiftCount;
ShiftInst = shiftInst;
Rm = rm;
Decoded = true;
Linked = true;
}
// Preindex!
private void ParseSource([NotNull] string sourceString)
{
var source = sourceString.Split(',');
if (source.Length > 3)
{
throw new TargetParameterCountException();
}
Rn = Parser.ParseRegister(source[0]);
if (source.Length == 1)
{
return;
}
// User wants to use an immediate offset
if (source[1].StartsWith("#", StringComparison.Ordinal))
{
Immediate = Parser.ParseImmediate <short>(source[1]);
if (Immediate < 0)
{
Up = false;
Immediate *= -1;
}
if (Immediate > 4096)
{
throw new ArgumentOutOfRangeException();
}
Offset = EOffset.Immediate;
}
// User wants to use a register value offset
else
{
Rm = Parser.ParseRegister(source[1]);
if (source.Length > 2)
{
Parser.ParseShiftInstruction(source[2], ref ShiftInst, ref ShiftCount);
}
Offset = EOffset.ImmediateShiftRm;
}
}
//============================================================
// <T>强转注册表信息操作64系统<T>
//
// @param type 类型
// @param sunKeyName 首节点
//============================================================
public static FRegisterPath Sync(ERegister type, string path)
{
// 构建对象
FRegisterPath registerPath = new FRegisterPath();
if (IsRunningOn64Bit)
{
RegistryKey localMachineKey = Registry.LocalMachine;
RegistryKey pathKey = localMachineKey.CreateSubKey(path);
registerPath.RootNode = pathKey;
return(registerPath);
}
// 存储路径
registerPath.Path = path;
int KEY_QUERY_VALUE = (0x0001);
int KEY_WOW64_64KEY = (0x0100);
int KEY_ALL_WOW64 = (KEY_QUERY_VALUE | KEY_WOW64_64KEY);
// 将Windows注册表主键名转化成为不带正负号的整形句柄（与平台是32或者64位有关）
UIntPtr hKey = TransferKeyName(type);
// 声明将要获取Key值的句柄
IntPtr pHKey = IntPtr.Zero;
// 关闭文件系统转向
IntPtr oldWOW64State = new IntPtr();
if (Wow64DisableWow64FsRedirection(ref oldWOW64State))
{
// 获得操作Key值的句柄
RegOpenKeyEx(hKey, path, 0, KEY_ALL_WOW64, out pHKey);
Microsoft.Win32.SafeHandles.SafeRegistryHandle safeHandle = new Microsoft.Win32.SafeHandles.SafeRegistryHandle(pHKey, true);
RegistryKey key = RegistryKey.FromHandle(safeHandle);
registerPath.RootNode = key;
// 关闭注册表转向（禁止特定项的注册表反射）
RegDisableReflectionKey(pHKey);
// 打开注册表转向（开启特定项的注册表反射）
RegEnableReflectionKey(pHKey);
}
// 打开文件系统转向
Wow64RevertWow64FsRedirection(oldWOW64State);
return(registerPath);
}
public static bool ParseShiftInstruction(string parameter, ref EShiftInstruction shiftInst, ref byte shiftCount, ref ERegister rs)
{
if (parameter.Length < 4)
{
throw new ArgumentException("Invalid Shiftinstruction");
}
if (!Enum.TryParse(parameter.Substring(0, 3), true, out shiftInst))
{
throw new ArgumentException("Invalid Shiftinstruction");
}
parameter = parameter.Substring(3, parameter.Length - 3);
if (Enum.TryParse(parameter, true, out rs))
{
return(true);
}
shiftCount = ParseImmediate <byte>(parameter);
if (shiftCount > 64)
{
throw new ArgumentOutOfRangeException();
}
return(false);
}
public void SetRegValue(ERegister reg, int value)
{
RegisterList[(int)reg].Value = value;
OnPropertyChanged(nameof(RegisterList));
}
public DecodeStage(DRegister input, ERegister output, RegisterFile regFile)
{
InputRegisters = input;
OutputRegisters = output;
registerFile = regFile;
}
public void Parse([NotNull] string parameterString)
{
// Check if a label might be accessed
if ((parameterString.IndexOf("[", StringComparison.Ordinal) == -1) && (parameterString.IndexOf("]", StringComparison.Ordinal) == -1))
{
ParseLabelAccess(parameterString);
return;
}
var parameters = Parser.ParseParameters(parameterString, new[] { '[', ']' });
if ((parameters.Length != 2) && (parameters.Length != 3))
{
throw new TargetParameterCountException();
}
if (!parameters[0].EndsWith(",", StringComparison.Ordinal))
{
throw new ArgumentException();
}
Rd = Parser.ParseRegister(parameters[0].Substring(0, parameters[0].Length - 1));
// Parse second parameter (source)
ParseSource(parameters[1]);
// Parse third parameter (writeback, postindex)
if (parameters.Length == 3)
{
if (parameters[2].Equals("!")) // Writeback
{
WriteBack = true;
}
else if (parameters[2].StartsWith(",", StringComparison.Ordinal)) // PostIndex
{
parameters[2] = parameters[2].Substring(1);
if (parameters[2].StartsWith("#", StringComparison.Ordinal))
{
Immediate = Parser.ParseImmediate <short>(parameters[2]);
if (Immediate < 0)
{
Up = false;
Immediate *= -1;
}
if (Immediate >= 4096)
{
throw new ArgumentOutOfRangeException();
}
}
else
{
Rm = Parser.ParseRegister(parameters[2]);
}
WriteBack = true;
PreIndex = false;
}
else
{
throw new ArgumentException();
}
}
Decoded = true;
Linked = true;
}
public void Parse([NotNull] string parameterString)
{
if (Decoded)
{
throw new InvalidOperationException();
}
var parameters = Parser.ParseParameters(parameterString, new[] { ',' });
switch (Opcode)
{
case EOpcode.Add:
case EOpcode.Sub:
case EOpcode.Rsb:
case EOpcode.And:
case EOpcode.Eor:
case EOpcode.Orr:
case EOpcode.Bic:
if ((parameters.Length != 3) && (parameters.Length != 4))
{
throw new TargetParameterCountException();
}
// Parse Rd, Rn
Rd = Parser.ParseRegister(parameters[0]);
Rn = Parser.ParseRegister(parameters[1]);
Operand2 = ParseOperand2(parameters[2], parameters.Length == 4 ? parameters[3] : null);
break;
case EOpcode.Mov:
case EOpcode.Mvn:
// Check for valid parameter count
if ((parameters.Length != 2) && (parameters.Length != 3))
{
throw new TargetParameterCountException();
}
// Parse Rd
Rd = Parser.ParseRegister(parameters[0]);
Operand2 = ParseOperand2(parameters[1], parameters.Length == 3 ? parameters[2] : null);
break;
case EOpcode.Tst:
case EOpcode.Teq:
case EOpcode.Cmp:
case EOpcode.Cmn:
// Check for valid parameter count
if ((parameters.Length != 2) && (parameters.Length != 3))
{
throw new TargetParameterCountException();
}
// Parse Rn
Rn = Parser.ParseRegister(parameters[0]);
Operand2 = ParseOperand2(parameters[1], parameters.Length == 3 ? parameters[2] : null);
break;
}
Decoded = true;
}
public void Parse([NotNull] string parameterString)
{
if (Decoded)
{
throw new InvalidOperationException();
}
// split parameters
var parameters = Parser.ParseParameters(parameterString, new[] { '{', '}' });
if (parameters.Length != 2)
{
throw new TargetParameterCountException();
}
if (!parameters[0].EndsWith(",", StringComparison.Ordinal))
{
throw new ArgumentException();
}
// clear the ,
parameters[0] = parameters[0].Substring(0, parameters[0].Length - 1);
if (parameters[0].EndsWith("!", StringComparison.Ordinal))
{
parameters[0] = parameters[0].Substring(0, parameters[0].Length - 1);
WriteBack = true;
}
Rn = Parser.ParseRegister(parameters[0]);
// Parse Register List
var regList = parameters[1].Split(',');
foreach (var regRange in regList.Select(reg => reg.Split('-')))
{
switch (regRange.Length)
{
case 1: // use single register e.g. r1
var register = Parser.ParseRegister(regRange[0]);
RegisterList |= 1 << (int)register;
break;
case 2: // use register range e.g. r1-r3
var startReg = Parser.ParseRegister(regRange[0]);
var endReg = Parser.ParseRegister(regRange[1]);
if (endReg < startReg)
{
throw new ArgumentException();
}
for (var i = startReg; i <= endReg; i++)
{
RegisterList |= 1 << (int)i;
}
break;
default:
throw new ArgumentException();
}
}
Decoded = true;
}
public ObservableRegister(ERegister register, int value)
{
Register = register;
Value = value;
}
public RegisterParam(ERegister register)
{
Register = register;
}
