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; }