/// <summary> /// Matches the specified other. /// </summary> /// <param name="other">The other signature type.</param> /// <returns>True, if the signature type matches.</returns> public override bool Matches(SigType other) { RefSigType refOther = other as RefSigType; // FIXME: Do we need to consider custom mods here? return (refOther != null && refOther.elementType.Matches(this.ElementType) == true); }
private IInstruction GetMoveInstruction(SigType sigType) { IInstruction moveInstruction; if (this.RequiresSseOperation(sigType) == false) { if (MustSignExtendOnLoad(sigType.Type) == true) { moveInstruction = Instruction.MovsxInstruction; } else if (MustZeroExtendOnLoad(sigType.Type) == true) { moveInstruction = Instruction.MovzxInstruction; } else { moveInstruction = Instruction.MovInstruction; } } else if (sigType.Type == CilElementType.R8) { moveInstruction = Instruction.MovsdInstruction; } else { moveInstruction = Instruction.MovssInstruction; } return moveInstruction; }
/// <summary> /// Initializes a new instance of the <see cref="GenericInstSigType"/> class. /// </summary> /// <param name="baseType">Type of the base.</param> /// <param name="genericArguments">The generic args.</param> public GenericInstSigType(TypeSigType baseType, SigType[] genericArguments) : base(CilElementType.GenericInst) { this.baseType = baseType; this.genericArguments = genericArguments; this.containsGenericParameters = CheckContainsOpenGenericParameters(); }
/// <summary> /// Retrieves a constant operand to represent the null-value. /// </summary> /// <returns>A new instance of <see cref="ConstantOperand"/>, that represents the null value.</returns> public static ConstantOperand GetNull() { if (_sObject == null) _sObject = BuiltInSigType.Object; return new ConstantOperand(_sObject, null); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> public override bool Equals(SigType other) { RefSigType rst = other as RefSigType; if (null == rst) return false; return (base.Equals(other) && this.elementType.Matches(rst.elementType) == true); }
/// <summary> /// Initializes a new instance of the <see cref="LocalVariableSignature"/> class. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <param name="genericArguments">The generic arguments.</param> public LocalVariableSignature(LocalVariableSignature signature, SigType[] genericArguments) : base(signature.Token) { locals = new VariableSignature[signature.locals.Length]; for (int i = 0; i < signature.locals.Length; i++) locals[i] = new VariableSignature(signature.locals[i], genericArguments); }
/// <summary> /// Initializes a new instance of the <see cref="MemberOperand"/> class. /// </summary> /// <param name="member">The member to reference.</param> /// <param name="type">The type of data held in the operand.</param> /// <param name="offset">The offset from the base register or absolute address to retrieve.</param> public MemberOperand(RuntimeMember member, SigType type, IntPtr offset) : base(null, type, offset) { if (member == null) throw new ArgumentNullException(@"member"); this.member = member; }
/// <summary> /// Initializes a new <see cref="RegisterOperand"/>. /// </summary> /// <param name="type">The signature type of the value the register holds.</param> /// <param name="register">The machine specific register used.</param> public RegisterOperand(SigType type, Register register) : base(type) { if (register == null) throw new ArgumentNullException(@"register"); this.register = register; }
/// <summary> /// Allocates the virtual register. /// </summary> /// <param name="type">The type.</param> /// <returns></returns> public Operand AllocateVirtualRegister(SigType type) { Operand virtualRegister = Operand.CreateVirtualRegister(type, virtualRegisters.Count + 1); virtualRegisters.Add(virtualRegister); return virtualRegister; }
/// <summary> /// Initializes a new instance of the <see cref="RefSigType"/> class. /// </summary> /// <param name="type">The referenced type.</param> public RefSigType(SigType type) : base(CilElementType.ByRef) { if (null == type) throw new ArgumentNullException(@"type"); ElementType = type; }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> public override bool Equals(SigType other) { SZArraySigType szast = other as SZArraySigType; if (szast == null) return false; return (base.Equals(other) == true && _elementType.Equals(szast._elementType) && CustomMod.Equals(_customMods, szast._customMods)); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false. /// </returns> public override bool Equals(SigType other) { ClassSigType cst = other as ClassSigType; if (null == cst) return false; return (base.Equals(other) == true && this.Token == cst.Token); }
/// <summary> /// Initializes a new instance of the <see cref="PtrSigType"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="customMods">The custom mods.</param> public PtrSigType(SigType type, CustomMod[] customMods) : base(CilElementType.Ptr) { if (type == null) throw new ArgumentNullException(@"type"); this.customMods = customMods; this.elementType = type; }
/// <summary> /// Initializes a new instance of the <see cref="LdobjInstruction"/> class. /// </summary> /// <param name="opcode">The opcode.</param> public LdobjInstruction(OpCode opcode) : base(opcode, 1) { switch (opcode) { case OpCode.Ldind_i1: typeRef = BuiltInSigType.SByte; break; case OpCode.Ldind_i2: typeRef = BuiltInSigType.Int16; break; case OpCode.Ldind_i4: typeRef = BuiltInSigType.Int32; break; case OpCode.Ldind_i8: typeRef = BuiltInSigType.Int64; break; case OpCode.Ldind_u1: typeRef = BuiltInSigType.Byte; break; case OpCode.Ldind_u2: typeRef = BuiltInSigType.UInt16; break; case OpCode.Ldind_u4: typeRef = BuiltInSigType.UInt32; break; case OpCode.Ldind_i: typeRef = BuiltInSigType.IntPtr; break; case OpCode.Ldind_r4: typeRef = BuiltInSigType.Single; break; case OpCode.Ldind_r8: typeRef = BuiltInSigType.Double; break; case OpCode.Ldind_ref: // FIXME: Really object? typeRef = BuiltInSigType.Object; break; case OpCode.Ldobj: // FIXME typeRef = null; // BuiltInSigType.Object; break; default: throw new NotImplementedException(); } }
/// <summary> /// Initializes a new instance of the <see cref="PtrSigType"/> class. /// </summary> /// <param name="type">The type.</param> public PtrSigType(SigType type) : base(CilElementType.Ptr) { if (null == type) throw new ArgumentNullException(@"type"); this.customMods = null; this.elementType = type; }
/// <summary> /// Allocates the virtual register. /// </summary> /// <param name="type">The type.</param> /// <returns></returns> public VirtualRegisterOperand AllocateVirtualRegister(SigType type) { int index = virtualRegisters.Count + 1; VirtualRegisterOperand virtualRegister = new VirtualRegisterOperand(type, index); virtualRegisters.Add(virtualRegister); return virtualRegister; }
private Operand InsertLoadBeforeInstruction(Context context, string symbolName, SigType type) { Context before = context.InsertBefore(); Operand result = this.methodCompiler.CreateTemporary(type); Operand op = new SymbolOperand(type, symbolName); before.SetInstruction(Instruction.Get(OpCode.Ldc_i4), result, op); return result; }
private Operand InsertLoadBeforeInstruction(Context context, string symbolName, SigType type) { Context before = context.InsertBefore(); Operand result = methodCompiler.CreateVirtualRegister(type); Operand op = Operand.CreateSymbol(type, symbolName); before.SetInstruction(CILInstruction.Get(OpCode.Ldc_i4), result, op); return result; }
private Operand AllocateRegister(SigType sigType) { if (RequiresSseOperation(sigType)) { return Operand.CreateCPURegister(sigType, SSE2Register.XMM6); } else { return Operand.CreateCPURegister(sigType, GeneralPurposeRegister.EAX); } }
public static SigType[] Resolve(SigType[] sigTypes, SigType[] genericArguments) { SigType[] newSigTypes = new SigType[sigTypes.Length]; for (int i = 0; i < sigTypes.Length; i++) { newSigTypes[i] = Resolve(sigTypes[i], genericArguments); } return newSigTypes; }
/// <summary> /// Initializes a new instance of LiteralInstruction. /// </summary> /// <param name="label">The label used to identify the literal in code.</param> /// <param name="type">The signature type of the literal data.</param> /// <param name="data">The data to embed along with the code stream.</param> public LiteralData(int label, SigType type, object data) { if (null == type) throw new ArgumentNullException(@"type"); if (null == data) throw new ArgumentNullException(@"data"); _label = label; _type = type; _data = data; }
public static Operand CreateResultOperand(IInstructionDecoder decoder, StackTypeCode operandType, SigType operandSigType) { if (operandType == StackTypeCode.O || operandType == StackTypeCode.Ptr || operandType == StackTypeCode.F) { return decoder.Compiler.CreateVirtualRegister(operandSigType); } else { return decoder.Compiler.CreateVirtualRegister(Operand.SigTypeFromStackType(operandType)); } }
/// <summary> /// Initializes a new instance of the <see cref="ArraySigType"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="rank">The rank.</param> /// <param name="sizes">The sizes.</param> /// <param name="lowBounds">The low bounds.</param> public ArraySigType(SigType type, int rank, int[] sizes, int[] lowBounds) : base(CilElementType.Array) { if (type == null) throw new ArgumentNullException(@"type"); ElementType = type; Rank = rank; Sizes = sizes; LowBounds = lowBounds; }
/// <summary> /// Initializes a new instance of the <see cref="ArraySigType"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="rank">The rank.</param> /// <param name="sizes">The sizes.</param> /// <param name="lowBounds">The low bounds.</param> public ArraySigType(SigType type, int rank, int[] sizes, int[] lowBounds) : base(CilElementType.Array) { if (null == type) throw new ArgumentNullException(@"type"); _type = type; _rank = rank; _sizes = sizes; _lowbounds = lowBounds; }
/// <summary> /// Initializes a new instance of the <see cref="LdelemInstruction"/> class. /// </summary> /// <param name="opcode">The opcode.</param> public LdelemInstruction(OpCode opcode) : base(opcode, 1) { switch (opcode) { case OpCode.Ldelem_i1: elementType = BuiltInSigType.SByte; break; case OpCode.Ldelem_i2: elementType = BuiltInSigType.Int16; break; case OpCode.Ldelem_i4: elementType = BuiltInSigType.Int32; break; case OpCode.Ldelem_i8: elementType = BuiltInSigType.Int64; break; case OpCode.Ldelem_u1: elementType = BuiltInSigType.Byte; break; case OpCode.Ldelem_u2: elementType = BuiltInSigType.UInt16; break; case OpCode.Ldelem_u4: elementType = BuiltInSigType.UInt32; break; case OpCode.Ldelem_i: elementType = BuiltInSigType.IntPtr; break; case OpCode.Ldelem_r4: elementType = BuiltInSigType.Single; break; case OpCode.Ldelem_r8: elementType = BuiltInSigType.Double; break; case OpCode.Ldelem_ref: // FIXME: Really object? elementType = BuiltInSigType.Object; break; default: throw new NotImplementedException(); } }
private RegisterOperand AllocateRegister(SigType sigType) { RegisterOperand result; if (RequiresSseOperation(sigType)) { result = new RegisterOperand(sigType, SSE2Register.XMM6); } else { result = new RegisterOperand(sigType, GeneralPurposeRegister.EAX); } return result; }
public static Operand CreateResultOperand(IInstructionDecoder decoder, StackTypeCode operandType, SigType operandSigType) { Operand result; if (operandType == StackTypeCode.O || operandType == StackTypeCode.Ptr || operandType == StackTypeCode.F) { result = decoder.Compiler.CreateTemporary(operandSigType); } else { result = decoder.Compiler.CreateTemporary(Operand.SigTypeFromStackType(operandType)); } return result; }
/// <summary> /// Initializes a new instance of the <see cref="StelemInstruction"/> class. /// </summary> /// <param name="opcode">The opcode.</param> public StelemInstruction(OpCode opcode) : base(opcode, 3) { switch (opcode) { case OpCode.Stelem_i1: typeRef = BuiltInSigType.SByte; break; case OpCode.Stelem_i2: typeRef = BuiltInSigType.Int16; break; case OpCode.Stelem_i4: typeRef = BuiltInSigType.Int32; break; case OpCode.Stelem_i8: typeRef = BuiltInSigType.Int64; break; case OpCode.Stelem_i: typeRef = BuiltInSigType.IntPtr; break; case OpCode.Stelem_r4: typeRef = BuiltInSigType.Single; break; case OpCode.Stelem_r8: typeRef = BuiltInSigType.Double; break; case OpCode.Stelem_ref: // FIXME: Really object? typeRef = BuiltInSigType.Object; break; case OpCode.Stelem: typeRef = null; break; default: throw new NotImplementedException("Not implemented: " + opcode); } }
/// <summary> /// Initializes a new instance of the <see cref="StobjInstruction"/> class. /// </summary> /// <param name="opcode">The opcode.</param> public StobjInstruction(OpCode opcode) : base(opcode) { switch (opcode) { case OpCode.Stind_i1: valueType = BuiltInSigType.SByte; break; case OpCode.Stind_i2: valueType = BuiltInSigType.Int16; break; case OpCode.Stind_i4: valueType = BuiltInSigType.Int32; break; case OpCode.Stind_i8: valueType = BuiltInSigType.Int64; break; case OpCode.Stind_r4: valueType = BuiltInSigType.Single; break; case OpCode.Stind_r8: valueType = BuiltInSigType.Double; break; case OpCode.Stind_i: valueType = BuiltInSigType.IntPtr; break; case OpCode.Stind_ref: // FIXME: Really object? valueType = BuiltInSigType.Object; break; case OpCode.Stobj: // FIXME valueType = null; break; default: throw new NotImplementedException(); } }
public static SigType Resolve(SigType sigType, SigType[] genericArguments) { if (genericArguments == null) return sigType; if (sigType is VarSigType) { if ((sigType as VarSigType).Index < genericArguments.Length) return genericArguments[(sigType as VarSigType).Index]; } else if (sigType is GenericInstSigType) { var genericInstSigType = sigType as GenericInstSigType; for (var i = 0; i < genericInstSigType.GenericArguments.Length; ++i) { if (genericInstSigType.GenericArguments[i] is VarSigType) return genericArguments[(genericInstSigType.GenericArguments[i] as VarSigType).Index]; } } return sigType; }
/// <summary> /// Parses the array signature. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseArraySignature(SignatureReader reader) { SigType elementType = ParseTypeSignature(reader); int rank, count; int[] sizes, lowerBounds; rank = reader.ReadCompressedInt32(); count = reader.ReadCompressedInt32(); sizes = new int[count]; for (int i = 0; i < count; i++) { sizes[i] = reader.ReadCompressedInt32(); } count = reader.ReadCompressedInt32(); lowerBounds = new int[count]; for (int i = 0; i < count; i++) { lowerBounds[i] = reader.ReadCompressedInt32(); } return(new ArraySigType(elementType, rank, sizes, lowerBounds)); }
/// <summary> /// Initializes a new instance of the <see cref="SZArraySigType"/> class. /// </summary> /// <param name="customMods">The custom mods.</param> /// <param name="type">The type.</param> public SZArraySigType(CustomMod[] customMods, SigType type) : base(CilElementType.SZArray) { CustomMods = customMods; ElementType = type; }
/// <summary> /// Parses the reference. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseReference(SignatureReader reader) { SigType type = ParseTypeSignature(reader); return(new RefSigType(type)); }
protected override void ParseSignature(SignatureReader reader) { ParseModifier(reader); CustomMods = CustomMod.ParseCustomMods(reader); Type = SigType.ParseTypeSignature(reader); }