/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // Simple result is the same type as the unary argument ctx.Result = compiler.CreateTemporary(ctx.Operand1.Type); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = StackTypeCode.Unknown; switch (_opcode) { case OpCode.Add_ovf_un: result = _addovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; case OpCode.Sub_ovf_un: result = _subovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; default: result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; } if (StackTypeCode.Unknown == result) { throw new InvalidOperationException("Invalid operand types passed to " + _opcode); } ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); Mosa.Runtime.Metadata.Signatures.ArraySigType a = ctx.Operand1.Type as Mosa.Runtime.Metadata.Signatures.ArraySigType; if (null == a || 1 != a.Rank) throw new InvalidProgramException(@"Operand to ldlen is not a vector."); ctx.Result = compiler.CreateTemporary(new SigType(CilElementType.I)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = StackTypeCode.Unknown; switch (_opcode) { case OpCode.Add: result = _addTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; case OpCode.Sub: result = _subTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; default: result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; } if (StackTypeCode.Unknown == result) { throw new InvalidOperationException("Invalid operand types passed to " + _opcode); } SigType resultType; if (result != StackTypeCode.Ptr) { resultType = Operand.SigTypeFromStackType(result); } else { // Copy the pointer element type PtrSigType op0 = ctx.Operand1.Type as PtrSigType; PtrSigType op1 = ctx.Operand2.Type as PtrSigType; if (op0 != null) { resultType = new PtrSigType(op0.CustomMods, op0.ElementType); } else if (op1 != null) { resultType = new PtrSigType(op1.CustomMods, op1.ElementType); } else { throw new InvalidOperationException(); } } ctx.Result = compiler.CreateTemporary(resultType); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = _opTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; if (result == StackTypeCode.Unknown) throw new InvalidOperationException(@"Invalid stack result of instruction."); ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); SZArraySigType arrayType = ctx.Operand1.Type as SZArraySigType; if (arrayType == null) throw new InvalidProgramException(@"Operand to ldlen is not a vector."); ctx.Result = compiler.CreateTemporary(BuiltInSigType.IntPtr); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); Mosa.Runtime.Metadata.Signatures.ArraySigType a = ctx.Operand1.Type as Mosa.Runtime.Metadata.Signatures.ArraySigType; if (null == a || 1 != a.Rank) { throw new InvalidProgramException(@"Operand to ldlen is not a vector."); } ctx.Result = compiler.CreateTemporary(new SigType(CilElementType.I)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx"></param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // Validate the operand StackTypeCode result = _opTable[(int)ctx.Operand1.StackType]; if (StackTypeCode.Unknown == result) throw new InvalidOperationException(@"Invalid operand to Not instruction."); ctx.Result = compiler.CreateTemporary(ctx.Operand1.Type); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; Debug.Assert(StackTypeCode.Unknown != result, @"Can't shift with the given stack operands."); if (StackTypeCode.Unknown == result) throw new InvalidOperationException(@"Invalid stack state for pairing (" + ctx.Operand1.StackType + ", " + ctx.Operand2.StackType + ")"); ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = _opTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; if (result == StackTypeCode.Unknown) { throw new ExecutionEngineException("Invalid stack result of instruction."); } ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx"></param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // Validate the operand StackTypeCode result = _typeCodes[(int)ctx.Operand1.StackType]; if (StackTypeCode.Unknown == result) { throw new InvalidOperationException(@"Invalid operand to Neg instruction."); } ctx.Result = compiler.CreateTemporary(ctx.Operand1.Type); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; Debug.Assert(StackTypeCode.Unknown != result, @"Can't shift with the given stack operands."); if (StackTypeCode.Unknown == result) { throw new ExecutionEngineException(@"Invalid stack state."); } ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // If we're ldind.i8, fix an IL deficiency that the result may be U8 if (opcode == OpCode.Ldind_i8 && this.typeRef.Type == CilElementType.I8) { SigType opType = ctx.Operand1.Type; RefSigType rst = opType as RefSigType; PtrSigType ptr = opType as PtrSigType; if (rst != null && rst.ElementType.Type == CilElementType.U8 || ptr != null && ptr.ElementType.Type == CilElementType.U8) { ctx.Result = compiler.CreateTemporary(BuiltInSigType.UInt64); } } }
/// <summary> /// Sets the invoke target. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> /// <param name="method">The method.</param> private static void SetInvokeTarget(Context ctx, IMethodCompiler compiler, RuntimeMethod method) { if (method == null) { throw new ArgumentNullException(@"method"); } // Signature of the call target // Number of parameters required for the call ctx.InvokeTarget = method; // Retrieve the target signature MethodSignature signature = ctx.InvokeTarget.Signature; // Fix the parameter list byte paramCount = (byte)signature.Parameters.Length; if (signature.HasThis && !signature.HasExplicitThis) { paramCount++; } // Setup operands for parameters and the return value if (signature.ReturnType.Type != CilElementType.Void) { ctx.ResultCount = 1; ctx.Result = compiler.CreateTemporary(signature.ReturnType); } else { ctx.ResultCount = 0; } ctx.OperandCount = paramCount; }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // If we're ldind.i8, fix an IL deficiency that the result may be U8 if (_opcode == OpCode.Ldind_i8 && this.typeRef.Type == CilElementType.I8) { SigType opType = ctx.Operand1.Type; RefSigType rst = opType as RefSigType; PtrSigType ptr = opType as PtrSigType; if (rst != null && rst.ElementType.Type == CilElementType.U8 || ptr != null && ptr.ElementType.Type == CilElementType.U8) { ctx.Result = compiler.CreateTemporary(BuiltInSigType.UInt64); } } }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx"></param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // Validate the typecode & determine the resulting stack type SigType resultType; switch (_opcode) { case OpCode.Conv_u: goto case OpCode.Conv_i; case OpCode.Conv_i: resultType = compiler.Architecture.NativeType; break; case OpCode.Conv_i1: resultType = new SigType(CilElementType.I1); break; case OpCode.Conv_i2: resultType = new SigType(CilElementType.I2); break; case OpCode.Conv_i4: resultType = new SigType(CilElementType.I4); break; case OpCode.Conv_i8: resultType = new SigType(CilElementType.I8); break; case OpCode.Conv_r4: resultType = new SigType(CilElementType.R4); break; case OpCode.Conv_r8: resultType = new SigType(CilElementType.R8); break; case OpCode.Conv_u1: resultType = new SigType(CilElementType.U1); break; case OpCode.Conv_u2: resultType = new SigType(CilElementType.U2); break; case OpCode.Conv_u4: resultType = new SigType(CilElementType.U4); break; case OpCode.Conv_u8: resultType = new SigType(CilElementType.U8); break; default: throw new NotSupportedException(@"Overflow checking conversions not supported."); } ctx.Result = compiler.CreateTemporary(resultType); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); StackTypeCode result = StackTypeCode.Unknown; switch (_opcode) { case OpCode.Add_ovf_un: result = _addovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; case OpCode.Sub_ovf_un: result = _subovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; default: result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; } if (StackTypeCode.Unknown == result) throw new InvalidOperationException(@"Invalid operand types passed to " + _opcode); ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); var stackTypeForOperand1 = ctx.Operand1.StackType; var stackTypeForOperand2 = ctx.Operand2.StackType; if (ctx.Operand1.Type is ValueTypeSigType) { var op1Type = compiler.Method.Module.GetType ((ctx.Operand1.Type as ValueTypeSigType).Token); if (op1Type.BaseType.FullName == "System.Enum") stackTypeForOperand1 = this.FromSigType (op1Type.Fields[0].SignatureType.Type); } if (ctx.Operand2.Type is ValueTypeSigType) { var op2Type = compiler.Method.Module.GetType ((ctx.Operand2.Type as ValueTypeSigType).Token); if (op2Type.BaseType.FullName == "System.Enum") stackTypeForOperand2 = this.FromSigType (op2Type.Fields[0].SignatureType.Type); } var result = _opTable[(int)stackTypeForOperand1][(int)stackTypeForOperand2]; if (result == StackTypeCode.Unknown) throw new InvalidOperationException (@"Invalid stack result of instruction: " + result.ToString () + " (" + ctx.Operand1.ToString () + ")"); ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result)); }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx"></param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate(ctx, compiler); // Validate the typecode & determine the resulting stack type SigType resultType; switch (opcode) { case OpCode.Conv_u: goto case OpCode.Conv_i; case OpCode.Conv_i: resultType = compiler.Architecture.NativeType; break; case OpCode.Conv_i1: resultType = BuiltInSigType.SByte; break; case OpCode.Conv_i2: resultType = BuiltInSigType.Int16; break; case OpCode.Conv_i4: resultType = BuiltInSigType.Int32; break; case OpCode.Conv_i8: resultType = BuiltInSigType.Int64; break; case OpCode.Conv_r4: resultType = BuiltInSigType.Single; break; case OpCode.Conv_r8: resultType = BuiltInSigType.Double; break; case OpCode.Conv_u1: resultType = BuiltInSigType.Byte; break; case OpCode.Conv_u2: resultType = BuiltInSigType.UInt16; break; case OpCode.Conv_u4: resultType = BuiltInSigType.UInt32; break; case OpCode.Conv_u8: resultType = BuiltInSigType.UInt64; break; case OpCode.Conv_ovf_i: goto case OpCode.Conv_i; case OpCode.Conv_ovf_u: goto case OpCode.Conv_i; case OpCode.Conv_ovf_i_un: goto case OpCode.Conv_i; case OpCode.Conv_ovf_u_un: goto case OpCode.Conv_i; default: throw new NotSupportedException(@"Overflow checking conversions not supported."); } ctx.Result = compiler.CreateTemporary(resultType); }
/// <summary> /// Sets the invoke target. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> /// <param name="method">The method.</param> private static void SetInvokeTarget(Context ctx, IMethodCompiler compiler, RuntimeMethod method) { if (method == null) throw new ArgumentNullException(@"method"); // Signature of the call target // Number of parameters required for the call ctx.InvokeTarget = method; // Retrieve the target signature MethodSignature signature = ctx.InvokeTarget.Signature; // Fix the parameter list byte paramCount = (byte)signature.Parameters.Length; if (signature.HasThis && !signature.HasExplicitThis) paramCount++; // Setup operands for parameters and the return value if (signature.ReturnType.Type != CilElementType.Void) { ctx.ResultCount = 1; ctx.Result = compiler.CreateTemporary(signature.ReturnType); } else ctx.ResultCount = 0; ctx.OperandCount = paramCount; }
/// <summary> /// Validates the instruction operands and creates a matching variable for the result. /// </summary> /// <param name="ctx">The context.</param> /// <param name="compiler">The compiler.</param> public override void Validate(Context ctx, IMethodCompiler compiler) { base.Validate (ctx, compiler); StackTypeCode result = StackTypeCode.Unknown; switch (_opcode) { case OpCode.Add: result = _addTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; case OpCode.Sub: result = _subTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; default: result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType]; break; } if (StackTypeCode.Unknown == result) throw new InvalidOperationException ("Invalid operand types passed to " + _opcode); SigType resultType; if (result != StackTypeCode.Ptr) { resultType = Operand.SigTypeFromStackType (result); } else { // Copy the pointer element type PtrSigType op0 = ctx.Operand1.Type as PtrSigType; PtrSigType op1 = ctx.Operand2.Type as PtrSigType; if (op0 != null) resultType = new PtrSigType (op0.CustomMods, op0.ElementType); else if (op1 != null) { resultType = new PtrSigType (op1.CustomMods, op1.ElementType); } else throw new InvalidOperationException (); } ctx.Result = compiler.CreateTemporary (resultType); }