static private BinaryOp.ArithOp BinaryOpFromCode(InstructionCode code) { switch (code) { case InstructionCode.ADD: return(BinaryOp.ArithOp.ADD); case InstructionCode.AND: return(BinaryOp.ArithOp.AND); case InstructionCode.CEQ: return(BinaryOp.ArithOp.CEQ); case InstructionCode.CGT: return(BinaryOp.ArithOp.CGT); case InstructionCode.CLT: return(BinaryOp.ArithOp.CLT); case InstructionCode.DIV: return(BinaryOp.ArithOp.DIV); case InstructionCode.MUL: return(BinaryOp.ArithOp.MUL); case InstructionCode.OR: return(BinaryOp.ArithOp.OR); case InstructionCode.REM: return(BinaryOp.ArithOp.REM); case InstructionCode.SHL: return(BinaryOp.ArithOp.SHL); case InstructionCode.SHR: return(BinaryOp.ArithOp.SHR); case InstructionCode.SUB: return(BinaryOp.ArithOp.SUB); case InstructionCode.XOR: return(BinaryOp.ArithOp.XOR); } throw new ConvertionException(); }
private void WriteRCPPayload(BinaryWriter binaryWriter, object[] payload) { int count = (int)payload[0]; binaryWriter.Write(count); int payloadIndex = 1; for (int i = 0; i < count; i++) { InstructionCode code = (InstructionCode)payload[payloadIndex++]; binaryWriter.Write((byte)code); switch (code) { case InstructionCode.SPR: case InstructionCode.GPR: binaryWriter.Write((int)payload[payloadIndex++]); break; case InstructionCode.CSP: case InstructionCode.CGP: WriteObject(binaryWriter, payload[payloadIndex++]); break; case InstructionCode.DPR: case InstructionCode.CDP: WriteObject(binaryWriter, payload[payloadIndex++]); WriteObject(binaryWriter, payload[payloadIndex++]); break; } } }
private void Call(InstructionCode instruction, ReadOnlySpan <byte> program) { GetOpCodeArg(program, out int address); if ((uint)address >= (uint)program.Length) { throw new VmExecutionException($"Invalid method address '0x{address.ToString("X4")}'."); } _localsState.Save(_locals); _locals = new(); _argsState.Save(_args); _args = new(); for (int idx = 0; idx < program[address]; idx++) { _args.Add(program[address] - idx - 1, _stackFrame.Pop()); } // TODO (RH vNext): Use method table instead of arg count. _stackFrame.AddStack(); _stackFrame.Push(_pointer); _pointer = address + InstructionFacts.SizeOfMethodHeader; }
void IIntrinsicSupport.EmitInstruction(InstructionCode code, Operand operand0, Operand operand1) { Contract.Requires(operand0 != null); Contract.Requires(operand1 != null); throw new NotImplementedException(); }
private void Ret(InstructionCode instruction, ReadOnlySpan <byte> program) { switch (_stackFrame.StackSize) { case 1: { var retAddress = (int)_stackFrame.Pop(); _pointer = retAddress; _stackFrame.DropStack(); break; } case 2: { var retValue = _stackFrame.Pop(); var retAddress = (int)_stackFrame.Pop(); _pointer = retAddress; _stackFrame.DropStack(); _stackFrame.Push(retValue); break; } default: { Throw.InvalidStackSize(new IlAddress(_pointer), _stackFrame.StackSize); break; } } _args = _argsState.Restore(); _locals = _localsState.Restore(); }
void IIntrinsicSupport.EmitJcc(InstructionCode code, Label label, Hint hint) { Contract.Requires(label != null); Contract.Requires(hint == Hint.None || hint == Hint.NotTaken || hint == Hint.Taken); throw new NotImplementedException(); }
private void DecodeInterruptingDeviceInstruction() { // The interrupting device inserts an instruction code on the data bus InstructionCode candidateInstructionCode = Z80OpCodes.Tables[0, InternalDataBus]; // An opcode was recognized, decode it and prepare its execution if (candidateInstructionCode.FetchMoreBytes == 0 && candidateInstructionCode.SwitchToTableNumber == null) { InstructionCode instructionCode = candidateInstructionCode; // Register decoded instruction instructionOrigin = new InstructionOrigin(InstructionSource.InterruptingDevice, instructionCode, 0); currentInstruction = new Instruction(instructionCode.InstructionTypeIndex, instructionCode.InstructionTypeParamVariant); DecodeInstructionExecutionMethod(); // Correct the actual duration of the current opcode fetch cycle (depends on the instruction) currentMachineCycle = currentInstruction.ExecutionTimings.MachineCycles[machineCycleIndex]; // Decrease the half T state index to execute the decoded instruction as if it was fetched from memory halfTStateIndex = 4; } // We need to read more bytes to recognize a multi-byte opcode else { throw new NotSupportedException("Multi bytes opcodes are not supported in interrupt mode 0 by this simulator"); } if (TraceMicroInstructions) { TraceMicroInstruction(new MicroInstruction(Z80MicroInstructionTypes.CPUControlDecodeInterruptingDeviceInstruction)); } }
private void Add(InstructionCode instruction, ReadOnlySpan <byte> program) { if (_stackFrame.StackSize == 0) { Throw.StackUnderflowException(_pointer); } var op1 = _stackFrame.Pop(); if (_stackFrame.StackSize == 0) { Throw.StackUnderflowException(_pointer); } var op2 = _stackFrame.Pop(); if (op1 is not int num1) { Throw.OperationNotSupported(instruction, op1, op2); return; } if (op2 is not int num2) { Throw.OperationNotSupported(instruction, op1, op2); return; } var result = num1 + num2; _stackFrame.Push(result); }
public void InstructionRequiringDataWithInvalidTypeThrows(InstructionCode instructionCode, VmType vmType) { var instructions = new List <Instruction>(); switch (vmType) { case VmType.Integer: instructions.Add(new Instruction(instructionCode, 0L)); break; case VmType.Boolean: instructions.Add(new Instruction(instructionCode, true)); break; default: Assert.True(false); // error in test; break; } var functionDefinition = new FunctionDefinition(instructions, new List <VmType>(), new List <VmType>() { VmType.Boolean }, 0); var exception = Assert.Throws <InvalidSourceException>(() => new VirtualMachine(functionDefinition)); Assert.Equal(InvalidSourceDetail.InvalidInstructionData, exception.DetailCode); }
private void BrCondition(InstructionCode instruction, ReadOnlySpan <byte> program, bool expectedCondition) { GetOpCodeArg(program, out int target); if (target >= program.Length) { Throw.InvalidInstructionArgument(_pointer); return; } var obj = _stackFrame.Pop(); var isTrue = obj switch { bool value => value, int value => value != 0, decimal value => value != 0, string value => value is not null, null => false, // Object reference check _ => throw new VmExecutionException($"Instructuin not supports object type '{obj.GetType()}'.") }; if (isTrue == expectedCondition) { _pointer = target; } }
private object[] ReadRCPPayload(BinaryReader binaryReader) { List <object> payload = new List <object>(); int count = binaryReader.ReadInt32(); payload.Add(count); for (int i = 0; i < count; i++) { InstructionCode code = (InstructionCode)binaryReader.ReadByte(); payload.Add(code); switch (code) { case InstructionCode.SPR: case InstructionCode.GPR: payload.Add(binaryReader.ReadInt32()); break; case InstructionCode.CSP: case InstructionCode.CGP: payload.Add(ReadObject(binaryReader)); break; case InstructionCode.DPR: case InstructionCode.CDP: payload.Add(ReadObject(binaryReader)); payload.Add(ReadObject(binaryReader)); break; } } return(payload.ToArray()); }
private void Stloc(InstructionCode instruction, ReadOnlySpan <byte> program) { GetOpCodeArg(program, out int index); var value = _stackFrame.Pop(); _locals[index] = value; }
internal Instruction(InstructionCode code, object[] payload, int?sourcePosition, bool interruptable, InstructionExecutionBody <G> execute) { Code = code; Payload = payload; SourcePosition = sourcePosition; Interruptable = interruptable; ExecutionBody = execute; }
public static void GenerateProgramToExecuteAllInstructions() { StringBuilder program = new StringBuilder(); // 1. Execute all opcodes int nbTables = Z80OpCodes.Tables.GetLength(0); int nbOpCodesPerTable = Z80OpCodes.Tables.GetLength(1); int opCodesCount = 0; int programSize = 0; for (int tableIndex = 0; tableIndex < nbTables; tableIndex++) { for (int opCodeIndex = 0; opCodeIndex < nbOpCodesPerTable; opCodeIndex++) { InstructionCode instrCode = Z80OpCodes.Tables[tableIndex, opCodeIndex]; if (instrCode.FetchMoreBytes == 0 && instrCode.SwitchToTableNumber == null) { program.AppendLine(instrCode.InstructionText); opCodesCount++; programSize += instrCode.OpCodeByteCount + instrCode.OperandsByteCount; } } } // 2. Execute all internal instructions int nbInstructionTypes = Z80InstructionTypes.Table.Length; for (int instrTypeIndex = 1; instrTypeIndex < nbInstructionTypes; instrTypeIndex++) { InstructionType instructionType = Z80InstructionTypes.Table[instrTypeIndex]; if (instructionType.IsInternalZ80Operation) { switch (instructionType.OpCodeName) { case "NMI": break; case "INT 0": break; case "INT 1": break; case "INT 2": break; case "RESET": break; case "?": break; default: throw new NotImplementedException("No test implemented for internal instruction " + instructionType.OpCodeName); } } } }
private static bool Ignore(InstructionCode c) { switch (c) { case InstructionCode.Constrained: return(true); } return(false); }
private void AddReprocessInstruction(InstructionCode code, int location) { if (!_reprocessRequiredIndexes.TryGetValue(code, out List <int> locations)) { locations = new List <int>(); _reprocessRequiredIndexes.Add(code, locations); } locations.Add(location); }
public static void WriteMessage(InstructionCode instruction, NetworkStream outputStream, NetworkStream inputStream, string[] textItems, params InstructionCode[] okResponses) { MemoryStream buffer = new MemoryStream(); BinaryWriter writer = new BinaryWriter(buffer); WriteString(writer, textItems); writer.Close(); WriteMessage(instruction, outputStream, inputStream, buffer.ToArray(), okResponses); }
public static Instruction GetInstruction(InstructionCode code) { if (_list == null) { Load(); Debug.Assert(_list != null); } return(_list[(int)code].Clone()); }
private void Ceq(InstructionCode instruction, ReadOnlySpan <byte> program) { var op2 = _stackFrame.Pop(); var op1 = _stackFrame.Pop(); var result = Equals(op1, op2); _stackFrame.Push(result ? 1 : 0); }
static private UnaryOp.ArithOp UnaryOpFromCode(InstructionCode code) { switch (code) { case InstructionCode.NEG: return(UnaryOp.ArithOp.NEG); case InstructionCode.NOT: return(UnaryOp.ArithOp.NOT); } throw new ConvertionException(); }
static public void WriteInstruction(byte[] instructions, ushort startOffset, InstructionCode instructionCode, ushort argument1, ushort argument2, ushort argument3) { ushort offset = startOffset; offset = WriteBytesToArray(instructions, (ushort)instructionCode, offset); offset = WriteBytesToArray(instructions, argument1, offset); offset = WriteBytesToArray(instructions, argument2, offset); offset = WriteBytesToArray(instructions, argument3, offset); }
private void Ldarg(InstructionCode instruction, ReadOnlySpan <byte> program) { GetOpCodeArg(program, out int index); if (!_args.TryGetValue(index, out var value)) { Throw.LocalVariableNotSet(_pointer); } _stackFrame.Push(value); }
public void VariableOperationOutOfRangeThrows(InstructionCode instructionCode, long variableIndex) { var instructions = new List <Instruction>() { new Instruction(instructionCode, variableIndex), }; var exception = Assert.Throws <InvalidSourceException>(() => ExecuteIntegerFunction(instructions, varCount: 2)); Assert.Equal(InvalidSourceDetail.InvalidVariableIndex, exception.DetailCode); }
public void ConditionalBranchingWithIncorrectTypesOnStackThrows(VmType type, InstructionCode instructionCode) { var instructions = new List <Instruction>() { BuildConstantToStackInstruction(type), new Instruction(instructionCode, 0L) }; var exception = Assert.Throws <InvalidSourceException>(() => ExecuteBooleanFunction(instructions)); Assert.Equal(InvalidSourceDetail.IncorrectElementTypeOnStack, exception.DetailCode); }
internal static void UpdateCoverage(InstructionCode code) { LoadAllOpCodes(); UpdateCoverageCore((ushort)code); var eq = GetEquivalent(code); if (eq != null) { UpdateCoverageCore((ushort)eq.Value); } }
public static Exception GetErrorInfo(InstructionCode response, byte [] body) { if (body.Length < IntSize) { return(new SednaException(response, "General error")); } Array.Copy(int_array, 0, body, IntSize + 1, IntSize); int length = ReadInt(int_array, 0); return(new SednaException(response, System.Text.Encoding.ASCII.GetString(body, IntSize + IntSize + StringTypeSize, length - (IntSize + IntSize + StringTypeSize)).Replace("\n", Environment.NewLine))); }
private void Br(InstructionCode instruction, ReadOnlySpan <byte> program) { GetOpCodeArg(program, out int target); if (target >= program.Length) { Throw.InvalidInstructionArgument(_pointer); return; } _pointer = target; }
public void BranchingOutOfRangeThrows(InstructionCode instructionCode, long destinationLineNumber) { var instructions = new List <Instruction>() { new Instruction(IntegerConstantToStack, 1L), new Instruction(IntegerConstantToStack, 1L), new Instruction(instructionCode, destinationLineNumber), new Instruction(IntegerAdd), }; var exception = Assert.Throws <InvalidSourceException>(() => ExecuteIntegerFunction(instructions)); Assert.Equal(InvalidSourceDetail.InvalidBranchDestination, exception.DetailCode); }
private static byte[] EmitObject(object obj) { // TODO (RH -): add decimal type handling var code = obj switch { InstructionCode instruction => BinaryConvert.GetBytes(instruction), string text => BinaryConvert.GetBytes(text), int value => BinaryConvert.GetBytes(value), _ => throw new ArgumentOutOfRangeException(nameof(obj), obj.GetType().Name, null) }; return(code); } }
public void InstructionMissingRequiredDataThrows(InstructionCode instructionCode) { var instructions = new List <Instruction>() { new Instruction(instructionCode) }; var functionDefinition = new FunctionDefinition(instructions, new List <VmType>(), new List <VmType>() { VmType.Boolean }, 0); var exception = Assert.Throws <InvalidSourceException>(() => new VirtualMachine(functionDefinition)); Assert.Equal(InvalidSourceDetail.MissingInstructionData, exception.DetailCode); }
public void InstructionWithUnnecessaryDataThrows(InstructionCode instructionCode) { var instructions = new List <Instruction>() { new Instruction(instructionCode, 0L) }; var functionDefinition = new FunctionDefinition(instructions, new List <VmType>(), new List <VmType>() { VmType.Boolean }, 0); var exception = Assert.Throws <InvalidSourceException>(() => new VirtualMachine(functionDefinition)); Assert.Equal(InvalidSourceDetail.InstructionCodeDoesNotUseData, exception.DetailCode); }
private IlObject?ReadArguments(InstructionCode instruction, ReadOnlySpan <byte> program, ref int pointer) { var address = new IlAddress(pointer); switch (instruction) { case InstructionCode.Ldstr: { var arg = BinaryConvert.GetString(ref pointer, program); return(new IlObject(address, 0, arg)); } case InstructionCode.Ldloc: case InstructionCode.Stloc: case InstructionCode.Ldc_i4: case InstructionCode.Ldarg: case InstructionCode.Call: { var arg = BinaryConvert.GetInt32(ref pointer, program); return(new IlObject(address, 0, arg)); } case InstructionCode.Br: case InstructionCode.Brfalse: case InstructionCode.Brtrue: { var arg = BinaryConvert.GetInt32(ref pointer, program); _labelTargets.Add(new IlAddress(arg)); return(new IlObject(address, 0, arg)); } case InstructionCode.Ret: case InstructionCode.Add: case InstructionCode.Ceq: case InstructionCode.Pop: case InstructionCode.Nop: { return(null); } default: { Throw.NotSupportedInstruction(pointer, program[pointer - 1]); return(null); } } }
public CompilerJmpInstruction(Compiler compiler, InstructionCode code, Operand[] operands) : base(compiler, code, operands) { if (code < InstructionDescription.JumpBegin || code > InstructionDescription.JumpEnd) throw new ArgumentException("The specified instruction code is not a valid jump."); Contract.Requires(compiler != null); Contract.Requires(operands != null); Contract.EndContractBlock(); _jumpTarget = compiler.GetTarget(Operands[0].Id); _jumpTarget.JumpsCount++; _jumpNext = _jumpTarget.From; _jumpTarget.From = this; _isTaken = Code == InstructionCode.Jmp || (Operands.Length > 1 && Operands[1].IsImm && ((Imm)Operands[1]).Value == (IntPtr)Hint.Taken); }
static void Simplify(IInstruction i, InstructionCode op, object operand) { i.Code = op; i.Operand0 = operand; }
void IIntrinsicSupport.EmitInstruction(InstructionCode code) { throw new NotImplementedException(); }
static void AddSByteSimplifier(InstructionCode sByteIns, InstructionCode dest) { AddSimplifier((context, ins) => SimplifyFromSByte(ins, dest), sByteIns); }
/// <summary>Initializes a new instance of the <see cref="InstructionByte" /> class.</summary> /// <param name="code">The instruction code.</param> public InstructionByte(InstructionCode code) { _instruction = (byte) code; }
public InstructionByte(InstructionCode code) { this.ins = (byte)code; }
public static void WriteMessage(InstructionCode instruction, NetworkStream outputStream, NetworkStream inputStream, params InstructionCode[] okResponses) { WriteMessage(instruction, outputStream, inputStream, new byte[0], okResponses); }
public CompilerInstruction(Compiler compiler, InstructionCode code, Operand[] operands) : base(compiler) { Contract.Requires(compiler != null); Contract.Requires(operands != null); _code = code; _emitOptions = compiler.EmitOptions; // Each created instruction takes emit options and clears it. compiler.EmitOptions = EmitOptions.None; _operands = operands; _memoryOperand = null; _variables = null; for (int i = 0; i < operands.Length; i++) { if (operands[i].IsMem) { _memoryOperand = (Mem)operands[i]; break; } } InstructionDescription id = InstructionDescription.FromInstruction(_code); _isSpecial = id.IsSpecial; _isFPU = id.IsFPU; _isGPBHiUsed = false; _isGPBLoUsed = false; if (_isSpecial) { // ${SPECIAL_INSTRUCTION_HANDLING_BEGIN} switch (_code) { case InstructionCode.Cpuid: // Special... break; case InstructionCode.Cbw: case InstructionCode.Cdqe: case InstructionCode.Cwde: // Special... break; case InstructionCode.Cdq: case InstructionCode.Cqo: case InstructionCode.Cwd: // Special... break; case InstructionCode.Cmpxchg: case InstructionCode.Cmpxchg8b: case InstructionCode.Cmpxchg16b: // Special... if (_code == InstructionCode.Cmpxchg16b && !Util.IsX64) throw new NotSupportedException(string.Format("The '{0}' instruction is only supported on X64.", _code)); break; case InstructionCode.Daa: case InstructionCode.Das: // Special... if (!Util.IsX86) throw new NotSupportedException(string.Format("The '{0}' instruction is only supported on X86.", _code)); break; case InstructionCode.Imul: switch (operands.Length) { case 2: // IMUL dst, src is not special instruction. _isSpecial = false; break; case 3: if (!(_operands[0].IsVar && _operands[1].IsVar && _operands[2].IsVarMem)) { // Only IMUL dst_hi, dst_lo, reg/mem is special, all others don't. _isSpecial = false; } break; } break; case InstructionCode.Mul: case InstructionCode.Idiv: case InstructionCode.Div: // Special... break; case InstructionCode.MovPtr: // Special... break; case InstructionCode.Lahf: case InstructionCode.Sahf: // Special... break; case InstructionCode.Maskmovdqu: case InstructionCode.Maskmovq: // Special... break; case InstructionCode.Enter: case InstructionCode.Leave: // Special... break; case InstructionCode.Ret: // Special... break; case InstructionCode.Monitor: case InstructionCode.Mwait: // Special... break; case InstructionCode.Pop: case InstructionCode.Popad: case InstructionCode.Popfd: case InstructionCode.Popfq: // Special... break; case InstructionCode.Push: case InstructionCode.Pushad: case InstructionCode.Pushfd: case InstructionCode.Pushfq: // Special... break; case InstructionCode.Rcl: case InstructionCode.Rcr: case InstructionCode.Rol: case InstructionCode.Ror: case InstructionCode.Sal: case InstructionCode.Sar: case InstructionCode.Shl: case InstructionCode.Shr: // Rot instruction is special only if last operand is variable (register). _isSpecial = _operands[1].IsVar; break; case InstructionCode.Shld: case InstructionCode.Shrd: // Shld/Shrd instruction is special only if last operand is variable (register). _isSpecial = _operands[2].IsVar; break; case InstructionCode.Rdtsc: case InstructionCode.Rdtscp: // Special... break; case InstructionCode.RepLodsb: case InstructionCode.RepLodsd: case InstructionCode.RepLodsq: case InstructionCode.RepLodsw: case InstructionCode.RepMovsb: case InstructionCode.RepMovsd: case InstructionCode.RepMovsq: case InstructionCode.RepMovsw: case InstructionCode.RepStosb: case InstructionCode.RepStosd: case InstructionCode.RepStosq: case InstructionCode.RepStosw: case InstructionCode.RepeCmpsb: case InstructionCode.RepeCmpsd: case InstructionCode.RepeCmpsq: case InstructionCode.RepeCmpsw: case InstructionCode.RepeScasb: case InstructionCode.RepeScasd: case InstructionCode.RepeScasq: case InstructionCode.RepeScasw: case InstructionCode.RepneCmpsb: case InstructionCode.RepneCmpsd: case InstructionCode.RepneCmpsq: case InstructionCode.RepneCmpsw: case InstructionCode.RepneScasb: case InstructionCode.RepneScasd: case InstructionCode.RepneScasq: case InstructionCode.RepneScasw: // Special... break; default: throw new CompilerException("Instruction is marked as special but handling for it is not present."); } // ${SPECIAL_INSTRUCTION_HANDLING_END} } }
static void SimplifyFromSByte(IInstruction i, InstructionCode op) { i.Code = op; if (!(i.Operand0 is IInstruction)) i.Operand0 = ((sbyte)i.Operand0); }
public Info(InstructionCode code,bool ovf,bool un,string name, ParamType pType,InstructionTypeSuffix typeSuffix,AdditionalParamType apType) { this.code = code; this.ovf = ovf; this.un = un; this.name = name; this.pType = pType; this.typeSuffix = typeSuffix; this.apType = apType; }
private static bool IsFilterExit(InstructionCode code) { return(code == InstructionCode.ENDFILTER); }
static public bool IsFloatOperation(InstructionCode code, bool un, bool ovf) { switch(code) { case InstructionCode.SUB: case InstructionCode.ADD: return(! ovf); //ovf flag is only allowed in integer arithmetics case InstructionCode.XOR: case InstructionCode.OR: case InstructionCode.AND: return(false); case InstructionCode.MUL: case InstructionCode.DIV: case InstructionCode.REM: return(! un && ! ovf); //`div.un` is not a float operation, // though simply `div` is. //`rem` is a float operation according to documentation! default: throw new VerifierException(); //impossible case } }
public static void WriteMessage(InstructionCode instruction, NetworkStream outputStream, NetworkStream inputStream, byte[] body, params InstructionCode[] okResponses) { Message msg = new Message(); msg.Instruction = instruction; msg.Body = body; WriteMessage(msg, outputStream); ReadMessage(msg, inputStream); bool ok = false; foreach (InstructionCode response in okResponses) if (msg.Instruction==response) ok = true; if (!ok) throw GetErrorInfo(msg.Instruction, msg.Body); }
private InstructionDescription(InstructionCode code, string name, InstructionGroup group, InstructionFlags flags, OperandFlags[] operandFlags, int opReg, int opcode0, int opcode1) { Contract.Requires(operandFlags != null); _code = code; _name = name; _group = (byte)group; _flags = (byte)flags; _operandFlags = new ReadOnlyCollection<OperandFlags>((OperandFlags[])operandFlags.Clone()); _opcodeR = (short)opReg; _opcode0 = opcode0; _opcode1 = opcode1; }
private static bool IsCatchExit(InstructionCode code) { return(code == InstructionCode.LEAVE || code == InstructionCode.THROW || code == InstructionCode.RETHROW); }
internal void PreparePrologEpilog(CompilerContext cc) { Contract.Requires(cc != null); _pePushPop = false; _emitEMMS = false; _emitSFence = false; _emitLFence = false; _isAssumed16ByteAlignment = false; _isPerformed16ByteAlignment = false; uint accessibleMemoryBelowStack = 0; if (_functionPrototype.CallingConvention == CallingConvention.X64U) accessibleMemoryBelowStack = 128; if (_isCaller && (cc.MemBytesTotal > 0 || _isAssumed16ByteAlignment)) _isEspAdjusted = true; if (cc.MemBytesTotal > accessibleMemoryBelowStack) _isEspAdjusted = true; _isAssumed16ByteAlignment = (_hints & FunctionHints.Assume16ByteAlignment) != 0; _isPerformed16ByteAlignment = (_hints & FunctionHints.Perform16ByteAlignment) != 0; _isNaked = (_hints & FunctionHints.Naked) != 0; _pePushPop = (_hints & FunctionHints.PushPopSequence) != 0; _emitEMMS = (_hints & FunctionHints.Emms) != 0; _emitSFence = (_hints & FunctionHints.StoreFence) != 0; _emitLFence = (_hints & FunctionHints.LoadFence) != 0; // Updated to respect comment from issue #47, align also when using MMX code. if (!_isAssumed16ByteAlignment && !_isNaked && (cc.Mem16BlocksCount + cc.Mem8BlocksCount > 0)) { // Have to align stack to 16-bytes. _isPerformed16ByteAlignment = true; _isEspAdjusted = true; } _modifiedAndPreservedGP = cc.ModifiedGPRegisters & _functionPrototype.PreservedGP & ~RegisterMask.FromIndex(RegIndex.Esp); _modifiedAndPreservedMM = cc.ModifiedMMRegisters & _functionPrototype.PreservedMM; _modifiedAndPreservedXMM = cc.ModifiedXMMRegisters & _functionPrototype.PreservedXMM; _movDqInstruction = (IsAssumed16ByteAlignment || IsPerformed16ByteAlignment) ? InstructionCode.Movdqa : InstructionCode.Movdqu; // Prolog & Epilog stack size. { int memGpSize = _modifiedAndPreservedGP.RegisterCount * IntPtr.Size; int memMmSize = _modifiedAndPreservedMM.RegisterCount * 8; int memXmmSize = _modifiedAndPreservedXMM.RegisterCount * 16; if (_pePushPop) { _pePushPopStackSize = memGpSize; _peMovStackSize = memXmmSize + Util.AlignTo16(memMmSize); } else { _pePushPopStackSize = 0; _peMovStackSize = memXmmSize + Util.AlignTo16(memMmSize + memGpSize); } } if (IsPerformed16ByteAlignment) { _peAdjustStackSize += Util.DeltaTo16(_pePushPopStackSize); } else { int v = 16 - IntPtr.Size; if (!_isNaked) v -= IntPtr.Size; v -= _pePushPopStackSize & 15; if (v < 0) v += 16; _peAdjustStackSize = v; //_peAdjustStackSize += deltaTo16(_pePushPopStackSize + v); } // Memory stack size. _memStackSize = cc.MemBytesTotal; _memStackSize16 = Util.AlignTo16(_memStackSize); if (_isNaked) { cc.ArgumentsBaseReg = RegIndex.Esp; cc.ArgumentsBaseOffset = (_isEspAdjusted) ? (_functionCallStackSize + _memStackSize16 + _peMovStackSize + _pePushPopStackSize + _peAdjustStackSize) : (_pePushPopStackSize); } else { cc.ArgumentsBaseReg = RegIndex.Ebp; cc.ArgumentsBaseOffset = IntPtr.Size; } cc.VariablesBaseReg = RegIndex.Esp; cc.VariablesBaseOffset = _functionCallStackSize; if (!_isEspAdjusted) cc.VariablesBaseOffset = -_memStackSize16 - _peMovStackSize - _peAdjustStackSize; }
private static bool IsTryExit(InstructionCode code) { return(code == InstructionCode.LEAVE || code == InstructionCode.THROW); }
public static Exception GetErrorInfo(InstructionCode response, byte [] body) { if (body.Length < IntSize) return new SednaException(response, "General error"); Array.Copy(int_array, 0, body, IntSize + 1, IntSize); int length = ReadInt(int_array, 0); return new SednaException(response, System.Text.Encoding.ASCII.GetString(body, IntSize + IntSize + StringTypeSize, length - (IntSize + IntSize + StringTypeSize)).Replace("\n", Environment.NewLine)); }
private static InstructionDescription MAKE_INST(InstructionCode code, string name, InstructionGroup group, InstructionFlags flags, OperandFlags oflags0, OperandFlags oflags1, int opReg, uint opcode0, uint opcode1) { return new InstructionDescription(code, name, group, flags, new OperandFlags[] { oflags0, oflags1 }, opReg, (int)opcode0, (int)opcode1); }
public InstructionOrigin(InstructionSource source, InstructionCode opCode, ushort memoryAddress) { Source = source; OpCode = opCode; Address = memoryAddress; }
private static bool IsFinallyExit(InstructionCode code) { return(code == InstructionCode.ENDFINALLY); }
public static InstructionDescription FromInstruction(InstructionCode code) { InstructionDescription description = instructionDescriptions[(int)code]; if (description.Code != code) throw new InvalidOperationException(); return description; }
public SednaException(InstructionCode retCode, string message) : base(message) { ReturnCode = retCode; }
internal Instruction(ILMethodDecoder decoder) { stack = null; startOffset = decoder.GetOffset(); int code = decoder.ReadCode(); Info info = instructions[code]; if (info.code == InstructionCode.TAIL) { hasTail = true; code = decoder.ReadCode(); info = instructions[code]; } else hasTail = false; hasUnaligned = false; hasVolatile = false; unalignedParam = 0; while (info.code == InstructionCode.VOLATILE || info.code == InstructionCode.UNALIGNED) { if (info.code == InstructionCode.VOLATILE) hasVolatile = true; else { hasUnaligned = true; unalignedParam = (Int32)(decoder.ReadUint8()); } code = decoder.ReadCode(); info = instructions[code]; } instructionCode = info.code; ovfFlag = info.ovf; unFlag = info.un; typeSuffix = info.typeSuffix; name = info.name; paramIsOffset = false; switch (info.pType) { case ParamType.pNone: if (info.apType >= AdditionalParamType.apU0 && info.apType <= AdditionalParamType.apU3) param = (Int32)(info.apType-AdditionalParamType.apU0); if (info.apType >= AdditionalParamType.apIM1 && info.apType <= AdditionalParamType.apI8) param = (Int32)(info.apType-AdditionalParamType.apIM1-1); break; case ParamType.pInt8: param = (Int32)(decoder.ReadInt8()); if (info.apType == AdditionalParamType.apOfs) paramIsOffset = true; break; case ParamType.pInt32: param = decoder.ReadInt32(); if (info.apType == AdditionalParamType.apOfs) paramIsOffset = true; break; case ParamType.pInt64: param = decoder.ReadInt64(); break; case ParamType.pUint8: param = (Int32)(decoder.ReadUint8()); break; case ParamType.pUint16: param = (Int32)(decoder.ReadUint16()); break; case ParamType.pFloat32: param = (double)(decoder.ReadFloat32()); break; case ParamType.pFloat64: param = decoder.ReadFloat64(); break; case ParamType.pToken: param = decoder.ReadToken(); break; case ParamType.pSwitch: param = decoder.ReadSwitch(); paramIsOffset = true; break; } afterEndOffset = decoder.GetOffset(); }
public Apdu(byte cla, InstructionCode ins, byte p1, byte p2, byte? le = null) : this(cla, (byte)ins, p1, p2, le) { }
/// <summary>Initializes a new instance of the <see cref="InstructionByte" /> class.</summary> /// <param name="code">The instruction code.</param> public InstructionByte(InstructionCode code) { Value = (byte) code; }