internal ConstantExpression( IModuleTypeReference typeReference, object/*?*/ value ) { this.TypeReference = typeReference; this.value = value; }
private bool PopulateExceptionInformation() { List <CilExceptionInformation> excepList = new List <CilExceptionInformation>(); SEHTableEntry[] /*?*/ sehTable = _methodIL.SEHTable; if (sehTable != null) { for (int i = 0; i < sehTable.Length; ++i) { SEHTableEntry sehTableEntry = sehTable[i]; int sehFlag = (int)sehTableEntry.SEHFlags; int handlerKindIndex = sehFlag >= ILReader.s_handlerKindMap.Length ? ILReader.s_handlerKindMap.Length - 1 : sehFlag; ITypeReference exceptionType = Dummy.TypeReference; uint filterDecisionStart = 0; HandlerKind handlerKind = ILReader.s_handlerKindMap[handlerKindIndex]; uint tryStart = sehTableEntry.TryOffset; uint tryEnd = sehTableEntry.TryOffset + sehTableEntry.TryLength; uint handlerStart = sehTableEntry.HandlerOffset; uint handlerEnd = sehTableEntry.HandlerOffset + sehTableEntry.HandlerLength; if (sehTableEntry.SEHFlags == SEHFlags.Catch) { IModuleTypeReference /*?*/ typeRef = this.PEFileToObjectModel.GetTypeReferenceForToken(this.MethodDefinition, sehTableEntry.ClassTokenOrFilterOffset); if (typeRef == null) { // Error return(false); } else { exceptionType = typeRef; } } else if (sehTableEntry.SEHFlags == SEHFlags.Filter) { exceptionType = this.PEFileToObjectModel.SystemObject; filterDecisionStart = sehTableEntry.ClassTokenOrFilterOffset; } excepList.Add( new CilExceptionInformation( handlerKind, exceptionType, tryStart, tryEnd, filterDecisionStart, handlerStart, handlerEnd ) ); } } this.MethodBody.SetExceptionInformation(new EnumerableArrayWrapper <CilExceptionInformation, IOperationExceptionInformation>(excepList.ToArray(), Dummy.OperationExceptionInformation)); return(true); }
//^ [NotDelayed] internal StandAloneMethodSignatureConverter( PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethodDef, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleMethodDef) { //^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray; this.RequiredParameters = TypeCache.EmptyParameterInfoArray; this.VarArgParameters = TypeCache.EmptyParameterInfoArray; //^ base; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. // TODO: Check minimum required size of the signature... this.FirstByte = this.SignatureMemoryReader.ReadByte(); int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32(); bool dummyPinned; this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned); byte retByte = this.SignatureMemoryReader.PeekByte(0); if (retByte == ElementType.Void) { this.ReturnTypeReference = peFileToObjectModel.SystemVoid; this.SignatureMemoryReader.SkipBytes(1); } else if (retByte == ElementType.TypedReference) { this.ReturnTypeReference = peFileToObjectModel.SystemTypedReference; this.SignatureMemoryReader.SkipBytes(1); } else { if (retByte == ElementType.ByReference) { this.IsReturnByReference = true; this.SignatureMemoryReader.SkipBytes(1); } this.ReturnTypeReference = this.GetTypeReference(); } if (paramCount > 0) { IModuleParameterTypeInformation[] reqModuleParamArr = this.GetModuleParameterTypeInformations(Dummy.Method, paramCount); if (reqModuleParamArr.Length > 0) { this.RequiredParameters = new EnumerableArrayWrapper <IModuleParameterTypeInformation, IParameterTypeInformation>(reqModuleParamArr, Dummy.ParameterTypeInformation); } IModuleParameterTypeInformation[] varArgModuleParamArr = this.GetModuleParameterTypeInformations(Dummy.Method, paramCount - reqModuleParamArr.Length); if (varArgModuleParamArr.Length > 0) { this.VarArgParameters = new EnumerableArrayWrapper <IModuleParameterTypeInformation, IParameterTypeInformation>(varArgModuleParamArr, Dummy.ParameterTypeInformation); } } }
private ITypeReference GetType( uint typeToken ) { IModuleTypeReference /*?*/ mtr = this.PEFileToObjectModel.GetTypeReferenceForToken(this.MethodDefinition, typeToken); if (mtr != null) { return(mtr); } // Error... return(Dummy.TypeReference); }
//^ [NotDelayed] internal FieldSignatureConverter( PEFileToObjectModel peFileToObjectModel, MetadataObject moduleField, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleField) { //^ base; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. this.FirstByte = this.SignatureMemoryReader.ReadByte(); if (!SignatureHeader.IsFieldSignature(this.FirstByte)) { // Error... } bool isPinned; this.ModuleCustomModifiers = this.GetCustomModifiers(out isPinned); this.TypeReference = this.GetTypeReference(); }
/// <summary> /// Resolves the serialized type name as if it belonged to the passed assembly. /// </summary> /// <param name="typeName">Serialized type name.</param> /// <param name="assembly">Assembly in which this needs to be resolved. If null then it is to be resolved in mscorlib.</param> /// <returns></returns> public ITypeDefinition ResolveSerializedTypeName(string typeName, IAssembly /*?*/ assembly) { if (assembly == null) { assembly = this.CoreAssembly; } Assembly /*?*/ internalAssembly = assembly as Assembly; if (internalAssembly == null) { return(Dummy.Type); } IModuleTypeReference /*?*/ moduleTypeRef = internalAssembly.PEFileToObjectModel.GetSerializedTypeNameAsTypeReference(typeName); if (moduleTypeRef == null) { return(Dummy.Type); } return(moduleTypeRef.ResolvedType); }
internal FieldOrPropertyNamedArgumentExpression( IName name, ITypeReference containingType, bool isField, IModuleTypeReference fieldOrPropTypeReference, ExpressionBase expressionValue ) { this.Name = name; this.ContainingType = containingType; if (isField) this.Flags |= FieldOrPropertyNamedArgumentExpression.IsFieldFlag; this.fieldOrPropTypeReference = fieldOrPropTypeReference; this.ExpressionValue = expressionValue; }
protected ExpressionBase ReadSerializedValue( IModuleTypeReference type ) { switch (type.SignatureTypeCode) { case ModuleSignatureTypeCode.SByte: case ModuleSignatureTypeCode.Int16: case ModuleSignatureTypeCode.Int32: case ModuleSignatureTypeCode.Int64: case ModuleSignatureTypeCode.Byte: case ModuleSignatureTypeCode.UInt16: case ModuleSignatureTypeCode.UInt32: case ModuleSignatureTypeCode.UInt64: case ModuleSignatureTypeCode.Single: case ModuleSignatureTypeCode.Double: case ModuleSignatureTypeCode.Boolean: case ModuleSignatureTypeCode.Char: return new ConstantExpression(type, this.GetPrimitiveValue(type)); case ModuleSignatureTypeCode.String: return new ConstantExpression(type, this.GetSerializedString()); case ModuleSignatureTypeCode.Object: { IModuleTypeReference/*?*/ underlyingType = this.GetFieldOrPropType(); if (underlyingType == null) return null; return this.ReadSerializedValue(underlyingType); } default: if (type == this.PEFileToObjectModel.SystemType) { string/*?*/ typeNameStr = this.GetSerializedString(); if (typeNameStr == null) { return new ConstantExpression(this.PEFileToObjectModel.SystemType, null); } return new TypeOfExpression(this.PEFileToObjectModel, this.PEFileToObjectModel.GetSerializedTypeNameAsTypeReference(typeNameStr)); } IModuleNominalType/*?*/ typeDef = type.ResolvedType as IModuleNominalType; if (typeDef != null && typeDef.IsEnum) return new ConstantExpression(type, this.GetPrimitiveValue(typeDef.EnumUnderlyingType)); VectorType/*?*/ vectorType = type as VectorType; if (vectorType != null) { IModuleTypeReference/*?*/ elementType = vectorType.ElementType; if (elementType == null) { this.decodeFailed = true; return null; } int size = this.SignatureMemoryReader.ReadInt32(); if (size == -1) { return new ConstantExpression(vectorType, null); } List<ExpressionBase> arrayElements = new List<ExpressionBase>(); for (int i = 0; i < size; ++i) { ExpressionBase/*?*/ expr = this.ReadSerializedValue(elementType); if (expr == null) { this.decodeFailed = true; return null; } arrayElements.Add(expr); } return new ArrayExpression(vectorType, new EnumerableArrayWrapper<ExpressionBase, IMetadataExpression>(arrayElements.ToArray(), Dummy.Expression)); } else { // If the metadata is correct, type must be a reference to an enum type. // Problem is, that without resolving this reference, it is not possible to know how many bytes to consume for the enum value // We'll let the host deal with this by guessing IModuleNominalType underlyingType; switch (this.PEFileToObjectModel.ModuleReader.metadataReaderHost.GuessUnderlyingTypeSizeOfUnresolvableReferenceToEnum(type)) { case 1: underlyingType = this.PEFileToObjectModel.SystemByte; break; case 2: underlyingType = this.PEFileToObjectModel.SystemInt16; break; case 4: underlyingType = this.PEFileToObjectModel.SystemInt32; break; case 8: underlyingType = this.PEFileToObjectModel.SystemInt64; break; default: this.decodeFailed = true; this.morePermutationsArePossible = false; return new ConstantExpression(type, 0); } return new ConstantExpression(type, this.GetPrimitiveValue(underlyingType)); } } }
internal TypeOfExpression( PEFileToObjectModel peFileToObjectModel, IModuleTypeReference/*?*/ typeExpression ) { this.PEFileToObjectModel = peFileToObjectModel; this.TypeExpression = typeExpression; }
/*?*/ protected object GetPrimitiveValue( IModuleTypeReference type ) { switch (type.SignatureTypeCode) { case ModuleSignatureTypeCode.SByte: if (this.SignatureMemoryReader.Offset+1 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (sbyte)0; } return this.SignatureMemoryReader.ReadSByte(); case ModuleSignatureTypeCode.Int16: if (this.SignatureMemoryReader.Offset+2 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (short)0; } return this.SignatureMemoryReader.ReadInt16(); case ModuleSignatureTypeCode.Int32: if (this.SignatureMemoryReader.Offset+4 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (int)0; } return this.SignatureMemoryReader.ReadInt32(); case ModuleSignatureTypeCode.Int64: if (this.SignatureMemoryReader.Offset+8 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (long)0; } return this.SignatureMemoryReader.ReadInt64(); case ModuleSignatureTypeCode.Byte: if (this.SignatureMemoryReader.Offset+1 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (byte)0; } return this.SignatureMemoryReader.ReadByte(); case ModuleSignatureTypeCode.UInt16: if (this.SignatureMemoryReader.Offset+2 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (ushort)0; } return this.SignatureMemoryReader.ReadUInt16(); case ModuleSignatureTypeCode.UInt32: if (this.SignatureMemoryReader.Offset+4 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (uint)0; } return this.SignatureMemoryReader.ReadUInt32(); case ModuleSignatureTypeCode.UInt64: if (this.SignatureMemoryReader.Offset+8 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (ulong)0; } return this.SignatureMemoryReader.ReadUInt64(); case ModuleSignatureTypeCode.Single: if (this.SignatureMemoryReader.Offset+4 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (float)0; } return this.SignatureMemoryReader.ReadSingle(); case ModuleSignatureTypeCode.Double: if (this.SignatureMemoryReader.Offset+8 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (double)0; } return this.SignatureMemoryReader.ReadDouble(); case ModuleSignatureTypeCode.Boolean: { if (this.SignatureMemoryReader.Offset+1 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return false; } byte val = this.SignatureMemoryReader.ReadByte(); return val == 1; } case ModuleSignatureTypeCode.Char: if (this.SignatureMemoryReader.Offset+2 > this.SignatureMemoryReader.Length) { this.decodeFailed = true; return (char)0; } return this.SignatureMemoryReader.ReadChar(); } this.decodeFailed = true; return null; }
//^ [NotDelayed] internal MethodRefSignatureConverter( PEFileToObjectModel peFileToObjectModel, MethodReference moduleMethodRef, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleMethodRef) { //^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray; this.RequiredParameters = TypeCache.EmptyParameterInfoArray; this.VarArgParameters = TypeCache.EmptyParameterInfoArray; //^ base; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. // TODO: Check minimum required size of the signature... byte firstByte = this.SignatureMemoryReader.ReadByte(); if (SignatureHeader.IsGeneric(firstByte)) { this.GenericParamCount = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32(); } int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32(); bool dummyPinned; this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned); byte retByte = this.SignatureMemoryReader.PeekByte(0); if (retByte == ElementType.Void) { this.ReturnTypeReference = peFileToObjectModel.SystemVoid; this.SignatureMemoryReader.SkipBytes(1); } else if (retByte == ElementType.TypedReference) { this.ReturnTypeReference = peFileToObjectModel.SystemTypedReference; this.SignatureMemoryReader.SkipBytes(1); } else { if (retByte == ElementType.ByReference) { this.IsReturnByReference = true; this.SignatureMemoryReader.SkipBytes(1); } this.ReturnTypeReference = this.GetTypeReference(); } if (paramCount > 0) { IModuleParameterTypeInformation[] reqModuleParamArr = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount); if (reqModuleParamArr.Length > 0) this.RequiredParameters = new EnumerableArrayWrapper<IModuleParameterTypeInformation, IParameterTypeInformation>(reqModuleParamArr, Dummy.ParameterTypeInformation); IModuleParameterTypeInformation[] varArgModuleParamArr = this.GetModuleParameterTypeInformations(moduleMethodRef, paramCount - reqModuleParamArr.Length); if (varArgModuleParamArr.Length > 0) this.VarArgParameters = new EnumerableArrayWrapper<IModuleParameterTypeInformation, IParameterTypeInformation>(varArgModuleParamArr, Dummy.ParameterTypeInformation); } }
//^ [NotDelayed] internal TypeSpecSignatureConverter( PEFileToObjectModel peFileToObjectModel, TypeSpecReference moduleTypeSpecReference, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleTypeSpecReference.TypeSpecOwner) { //^ base; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. byte firstByte = this.SignatureMemoryReader.ReadByte(); switch (firstByte) { case ElementType.GenericTypeInstance: this.TypeReference = this.GetModuleGenericTypeInstanceReference(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.ByReference: this.TypeReference = this.GetModuleManagedPointerType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.Pointer: this.TypeReference = this.GetModulePointerType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.Array: this.TypeReference = this.GetModuleMatrixType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.SzArray: this.TypeReference = this.GetModuleVectorType(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.FunctionPointer: this.TypeReference = this.GetModuleFuntionPointer(TokenTypeIds.TypeSpec | moduleTypeSpecReference.TypeSpecRowId); break; case ElementType.Class: case ElementType.ValueType: { uint typeEncoded = (uint)this.SignatureMemoryReader.ReadCompressedUInt32(); uint typeToken = TypeDefOrRefTag.ConvertToToken(typeEncoded); this.TypeReference = this.PEFileToObjectModel.GetTypeReferenceForToken(this.MetadataOwnerObject, typeToken, firstByte == ElementType.ValueType); } break; case ElementType.GenericTypeParameter: { ushort ordinal = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32(); if (this.ModuleGenericType == null) { // TODO: Error } else { this.TypeReference = this.ModuleGenericType.GetGenericTypeParameterFromOrdinal(ordinal); } break; } case ElementType.GenericMethodParameter: { ushort ordinal = (ushort)this.SignatureMemoryReader.ReadCompressedUInt32(); if (this.ModuleGenericMethod == null) { // TODO: Error } else { this.TypeReference = this.ModuleGenericMethod.GetGenericMethodParameterFromOrdinal(ordinal); } break; } case ElementType.RequiredModifier: case ElementType.OptionalModifier: { bool dummyPinned; this.SignatureMemoryReader.SkipBytes(-1); EnumerableArrayWrapper<CustomModifier, ICustomModifier> customModifiers = this.GetCustomModifiers(out dummyPinned); IModuleTypeReference/*?*/ typeReference = this.GetTypeReference(); if (typeReference == null) { // TODO: Error } else { this.TypeReference = new ModifiedTypeReference(this.PEFileToObjectModel, typeReference, customModifiers); } break; } case ElementType.Boolean: this.TypeReference = this.PEFileToObjectModel.SystemBoolean; break; case ElementType.Char: this.TypeReference = this.PEFileToObjectModel.SystemChar; break; case ElementType.Double: this.TypeReference = this.PEFileToObjectModel.SystemDouble; break; case ElementType.Int16: this.TypeReference = this.PEFileToObjectModel.SystemInt16; break; case ElementType.Int32: this.TypeReference = this.PEFileToObjectModel.SystemInt32; break; case ElementType.Int64: this.TypeReference = this.PEFileToObjectModel.SystemInt64; break; case ElementType.Int8: this.TypeReference = this.PEFileToObjectModel.SystemSByte; break; case ElementType.IntPtr: this.TypeReference = this.PEFileToObjectModel.SystemIntPtr; break; case ElementType.Object: this.TypeReference = this.PEFileToObjectModel.SystemObject; break; case ElementType.Single: this.TypeReference = this.PEFileToObjectModel.SystemSingle; break; case ElementType.String: this.TypeReference = this.PEFileToObjectModel.SystemString; break; case ElementType.UInt16: this.TypeReference = this.PEFileToObjectModel.SystemUInt16; break; case ElementType.UInt32: this.TypeReference = this.PEFileToObjectModel.SystemUInt32; break; case ElementType.UInt64: this.TypeReference = this.PEFileToObjectModel.SystemUInt64; break; case ElementType.UInt8: this.TypeReference = this.PEFileToObjectModel.SystemByte; break; case ElementType.UIntPtr: this.TypeReference = this.PEFileToObjectModel.SystemUIntPtr; break; case ElementType.Void: this.TypeReference = this.PEFileToObjectModel.SystemVoid; break; default: // Error... break; } }
//^ [NotDelayed] internal MethodDefSignatureConverter( PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethod, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleMethod) { //^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray; this.Parameters = TypeCache.EmptyParameterArray; //^ this.ReturnParameter = new ReturnParameter(peFileToObjectModel, ParamFlags.ByReference, 0); //^ this.ParamInfoArray = new ParamInfo[0]; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. //^ base; // TODO: Check minimum required size of the signature... this.FirstByte = this.SignatureMemoryReader.ReadByte(); if (SignatureHeader.IsGeneric(this.FirstByte)) { this.GenericParamCount = (uint)this.SignatureMemoryReader.ReadCompressedUInt32(); } int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32(); bool dummyPinned; this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned); byte retByte = this.SignatureMemoryReader.PeekByte(0); bool isReturnByReference = false; if (retByte == ElementType.Void) { this.ReturnTypeReference = peFileToObjectModel.SystemVoid; this.SignatureMemoryReader.SkipBytes(1); } else if (retByte == ElementType.TypedReference) { this.ReturnTypeReference = peFileToObjectModel.SystemTypedReference; this.SignatureMemoryReader.SkipBytes(1); } else { if (retByte == ElementType.ByReference) { isReturnByReference = true; this.SignatureMemoryReader.SkipBytes(1); } this.ReturnTypeReference = this.GetTypeReference(); } PEFileReader peFileReader = peFileToObjectModel.PEFileReader; uint paramRowCount; uint paramRowStart = peFileReader.GetParamInformation(moduleMethod.MethodDefRowId, out paramRowCount); uint paramRowEnd = paramRowStart + paramRowCount; ParamInfo[] paramInfoArray = new ParamInfo[paramRowCount]; if (peFileReader.UseParamPtrTable) { for (uint paramRowIter = paramRowStart; paramRowIter < paramRowEnd; ++paramRowIter) { uint paramRowId = peFileReader.ParamPtrTable.GetParamFor(paramRowIter); ParamRow paramRow = peFileReader.ParamTable[paramRowId]; // TODO: Error check if seqence is in proper range... paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags); } } else { for (uint paramRowId = paramRowStart; paramRowId < paramRowEnd; ++paramRowId) { ParamRow paramRow = peFileReader.ParamTable[paramRowId]; // TODO: Error check if seqence is in proper range... paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags); } } if (paramRowCount > 0 && paramInfoArray[0].ParamSequence == 0) { ParamFlags paramFlag = paramInfoArray[0].ParamFlags; if (isReturnByReference) { paramFlag |= ParamFlags.ByReference; } this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, paramFlag, paramInfoArray[0].ParamRowId); } else { this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, isReturnByReference ? ParamFlags.ByReference : 0, 0); } this.ParamInfoArray = paramInfoArray; if (paramCount > 0) { IModuleParameter[] moduleParamArr = this.GetModuleParameters(true, moduleMethod, paramCount); if (moduleParamArr.Length > 0) this.Parameters = new EnumerableArrayWrapper<IModuleParameter, IParameterDefinition>(moduleParamArr, Dummy.ParameterDefinition); } }
//^ [NotDelayed] internal PropertySignatureConverter( PEFileToObjectModel peFileToObjectModel, PropertyDefinition moduleProperty, MemoryReader signatureMemoryReader ) : base(peFileToObjectModel, signatureMemoryReader, moduleProperty) { //^ this.ReturnCustomModifiers = TypeCache.EmptyCustomModifierArray; this.Parameters = TypeCache.EmptyParameterArray; //^ base; //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary. // TODO: Check minimum required size of the signature... this.FirstByte = this.SignatureMemoryReader.ReadByte(); if (!SignatureHeader.IsPropertySignature(this.FirstByte)) { // Error... } int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32(); bool dummyPinned; this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned); if (this.SignatureMemoryReader.PeekByte(0) == ElementType.ByReference) { this.ReturnValueIsByReference = true; this.SignatureMemoryReader.SkipBytes(1); } this.ReturnTypeReference = this.GetTypeReference(); if (paramCount > 0) { IModuleParameter[] moduleParamArr = this.GetModuleParameters(false, moduleProperty, paramCount); if (moduleParamArr.Length > 0) this.Parameters = new EnumerableArrayWrapper<IModuleParameter, IParameterDefinition>(moduleParamArr, Dummy.ParameterDefinition); } }
private bool PopulateCilInstructions() { MethodBodyDocument document = new MethodBodyDocument(this.MethodDefinition); MemoryReader memReader = new MemoryReader(_methodIL.EncodedILMemoryBlock); List <CilInstruction> instrList = new List <CilInstruction>(); while (memReader.NotEndOfBytes) { object /*?*/ value = null; uint offset = (uint)memReader.Offset; OperationCode cilOpCode = memReader.ReadOpcode(); switch (cilOpCode) { case OperationCode.Nop: case OperationCode.Break: break; case OperationCode.Ldarg_0: case OperationCode.Ldarg_1: case OperationCode.Ldarg_2: case OperationCode.Ldarg_3: value = this.GetParameter((uint)(cilOpCode - OperationCode.Ldarg_0)); break; case OperationCode.Ldloc_0: case OperationCode.Ldloc_1: case OperationCode.Ldloc_2: case OperationCode.Ldloc_3: value = this.GetLocal((uint)(cilOpCode - OperationCode.Ldloc_0)); break; case OperationCode.Stloc_0: case OperationCode.Stloc_1: case OperationCode.Stloc_2: case OperationCode.Stloc_3: value = this.GetLocal((uint)(cilOpCode - OperationCode.Stloc_0)); break; case OperationCode.Ldarg_S: case OperationCode.Ldarga_S: case OperationCode.Starg_S: value = this.GetParameter(memReader.ReadByte()); break; case OperationCode.Ldloc_S: case OperationCode.Ldloca_S: case OperationCode.Stloc_S: value = this.GetLocal(memReader.ReadByte()); break; case OperationCode.Ldnull: case OperationCode.Ldc_I4_M1: case OperationCode.Ldc_I4_0: case OperationCode.Ldc_I4_1: case OperationCode.Ldc_I4_2: case OperationCode.Ldc_I4_3: case OperationCode.Ldc_I4_4: case OperationCode.Ldc_I4_5: case OperationCode.Ldc_I4_6: case OperationCode.Ldc_I4_7: case OperationCode.Ldc_I4_8: break; case OperationCode.Ldc_I4_S: value = (int)memReader.ReadSByte(); break; case OperationCode.Ldc_I4: value = memReader.ReadInt32(); break; case OperationCode.Ldc_I8: value = memReader.ReadInt64(); break; case OperationCode.Ldc_R4: value = memReader.ReadSingle(); break; case OperationCode.Ldc_R8: value = memReader.ReadDouble(); break; case OperationCode.Dup: case OperationCode.Pop: break; case OperationCode.Jmp: value = this.GetMethod(memReader.ReadUInt32()); break; case OperationCode.Call: { IMethodReference methodReference = this.GetMethod(memReader.ReadUInt32()); IArrayTypeReference /*?*/ arrayType = methodReference.ContainingType as IArrayTypeReference; if (arrayType != null) { if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.GetNameFor("Set").UniqueKey) { cilOpCode = OperationCode.Array_Set; } else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.Get.UniqueKey) { cilOpCode = OperationCode.Array_Get; } else if (methodReference.Name.UniqueKey == this.PEFileToObjectModel.NameTable.GetNameFor("Address").UniqueKey) { cilOpCode = OperationCode.Array_Addr; } value = arrayType; } else { value = methodReference; } } break; case OperationCode.Calli: value = this.GetFunctionPointerType(memReader.ReadUInt32()); break; case OperationCode.Ret: break; case OperationCode.Br_S: case OperationCode.Brfalse_S: case OperationCode.Brtrue_S: case OperationCode.Beq_S: case OperationCode.Bge_S: case OperationCode.Bgt_S: case OperationCode.Ble_S: case OperationCode.Blt_S: case OperationCode.Bne_Un_S: case OperationCode.Bge_Un_S: case OperationCode.Bgt_Un_S: case OperationCode.Ble_Un_S: case OperationCode.Blt_Un_S: { uint jumpOffset = (uint)(memReader.Offset + 1 + memReader.ReadSByte()); if (jumpOffset >= _endOfMethodOffset) { // Error... } value = jumpOffset; } break; case OperationCode.Br: case OperationCode.Brfalse: case OperationCode.Brtrue: case OperationCode.Beq: case OperationCode.Bge: case OperationCode.Bgt: case OperationCode.Ble: case OperationCode.Blt: case OperationCode.Bne_Un: case OperationCode.Bge_Un: case OperationCode.Bgt_Un: case OperationCode.Ble_Un: case OperationCode.Blt_Un: { uint jumpOffset = (uint)(memReader.Offset + 4 + memReader.ReadInt32()); if (jumpOffset >= _endOfMethodOffset) { // Error... } value = jumpOffset; } break; case OperationCode.Switch: { uint numTargets = memReader.ReadUInt32(); uint[] result = new uint[numTargets]; uint asOffset = memReader.Offset + numTargets * 4; for (int i = 0; i < numTargets; i++) { uint targetAddress = memReader.ReadUInt32() + asOffset; if (targetAddress >= _endOfMethodOffset) { // Error... } result[i] = targetAddress; } value = result; } break; case OperationCode.Ldind_I1: case OperationCode.Ldind_U1: case OperationCode.Ldind_I2: case OperationCode.Ldind_U2: case OperationCode.Ldind_I4: case OperationCode.Ldind_U4: case OperationCode.Ldind_I8: case OperationCode.Ldind_I: case OperationCode.Ldind_R4: case OperationCode.Ldind_R8: case OperationCode.Ldind_Ref: case OperationCode.Stind_Ref: case OperationCode.Stind_I1: case OperationCode.Stind_I2: case OperationCode.Stind_I4: case OperationCode.Stind_I8: case OperationCode.Stind_R4: case OperationCode.Stind_R8: case OperationCode.Add: case OperationCode.Sub: case OperationCode.Mul: case OperationCode.Div: case OperationCode.Div_Un: case OperationCode.Rem: case OperationCode.Rem_Un: case OperationCode.And: case OperationCode.Or: case OperationCode.Xor: case OperationCode.Shl: case OperationCode.Shr: case OperationCode.Shr_Un: case OperationCode.Neg: case OperationCode.Not: case OperationCode.Conv_I1: case OperationCode.Conv_I2: case OperationCode.Conv_I4: case OperationCode.Conv_I8: case OperationCode.Conv_R4: case OperationCode.Conv_R8: case OperationCode.Conv_U4: case OperationCode.Conv_U8: break; case OperationCode.Callvirt: value = this.GetMethod(memReader.ReadUInt32()); break; case OperationCode.Cpobj: case OperationCode.Ldobj: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Ldstr: value = this.GetUserStringForToken(memReader.ReadUInt32()); break; case OperationCode.Newobj: { IMethodReference methodReference = this.GetMethod(memReader.ReadUInt32()); IArrayTypeReference /*?*/ arrayType = methodReference.ContainingType as IArrayTypeReference; if (arrayType != null && !arrayType.IsVector) { uint numParam = IteratorHelper.EnumerableCount(methodReference.Parameters); if (numParam != arrayType.Rank) { cilOpCode = OperationCode.Array_Create_WithLowerBound; } else { cilOpCode = OperationCode.Array_Create; } value = arrayType; } else { value = methodReference; } } break; case OperationCode.Castclass: case OperationCode.Isinst: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Conv_R_Un: break; case OperationCode.Unbox: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Throw: break; case OperationCode.Ldfld: case OperationCode.Ldflda: case OperationCode.Stfld: case OperationCode.Ldsfld: case OperationCode.Ldsflda: case OperationCode.Stsfld: value = this.GetField(memReader.ReadUInt32()); break; case OperationCode.Stobj: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Conv_Ovf_I1_Un: case OperationCode.Conv_Ovf_I2_Un: case OperationCode.Conv_Ovf_I4_Un: case OperationCode.Conv_Ovf_I8_Un: case OperationCode.Conv_Ovf_U1_Un: case OperationCode.Conv_Ovf_U2_Un: case OperationCode.Conv_Ovf_U4_Un: case OperationCode.Conv_Ovf_U8_Un: case OperationCode.Conv_Ovf_I_Un: case OperationCode.Conv_Ovf_U_Un: break; case OperationCode.Box: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Newarr: { ITypeReference elementType = this.GetType(memReader.ReadUInt32()); IModuleTypeReference /*?*/ moduleTypeReference = elementType as IModuleTypeReference; if (moduleTypeReference != null) { value = new VectorType(this.PEFileToObjectModel, 0xFFFFFFFF, moduleTypeReference); } else { value = Dummy.ArrayType; } } break; case OperationCode.Ldlen: break; case OperationCode.Ldelema: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Ldelem_I1: case OperationCode.Ldelem_U1: case OperationCode.Ldelem_I2: case OperationCode.Ldelem_U2: case OperationCode.Ldelem_I4: case OperationCode.Ldelem_U4: case OperationCode.Ldelem_I8: case OperationCode.Ldelem_I: case OperationCode.Ldelem_R4: case OperationCode.Ldelem_R8: case OperationCode.Ldelem_Ref: case OperationCode.Stelem_I: case OperationCode.Stelem_I1: case OperationCode.Stelem_I2: case OperationCode.Stelem_I4: case OperationCode.Stelem_I8: case OperationCode.Stelem_R4: case OperationCode.Stelem_R8: case OperationCode.Stelem_Ref: break; case OperationCode.Ldelem: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Stelem: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Unbox_Any: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Conv_Ovf_I1: case OperationCode.Conv_Ovf_U1: case OperationCode.Conv_Ovf_I2: case OperationCode.Conv_Ovf_U2: case OperationCode.Conv_Ovf_I4: case OperationCode.Conv_Ovf_U4: case OperationCode.Conv_Ovf_I8: case OperationCode.Conv_Ovf_U8: break; case OperationCode.Refanyval: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Ckfinite: break; case OperationCode.Mkrefany: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Ldtoken: value = this.GetRuntimeHandleFromToken(memReader.ReadUInt32()); break; case OperationCode.Conv_U2: case OperationCode.Conv_U1: case OperationCode.Conv_I: case OperationCode.Conv_Ovf_I: case OperationCode.Conv_Ovf_U: case OperationCode.Add_Ovf: case OperationCode.Add_Ovf_Un: case OperationCode.Mul_Ovf: case OperationCode.Mul_Ovf_Un: case OperationCode.Sub_Ovf: case OperationCode.Sub_Ovf_Un: case OperationCode.Endfinally: break; case OperationCode.Leave: { uint leaveOffset = (uint)(memReader.Offset + 4 + memReader.ReadInt32()); if (leaveOffset >= _endOfMethodOffset) { // Error... } value = leaveOffset; } break; case OperationCode.Leave_S: { uint leaveOffset = (uint)(memReader.Offset + 1 + memReader.ReadSByte()); if (leaveOffset >= _endOfMethodOffset) { // Error... } value = leaveOffset; } break; case OperationCode.Stind_I: case OperationCode.Conv_U: case OperationCode.Arglist: case OperationCode.Ceq: case OperationCode.Cgt: case OperationCode.Cgt_Un: case OperationCode.Clt: case OperationCode.Clt_Un: break; case OperationCode.Ldftn: case OperationCode.Ldvirtftn: value = this.GetMethod(memReader.ReadUInt32()); break; case OperationCode.Ldarg: case OperationCode.Ldarga: case OperationCode.Starg: value = this.GetParameter(memReader.ReadUInt16()); break; case OperationCode.Ldloc: case OperationCode.Ldloca: case OperationCode.Stloc: value = this.GetLocal(memReader.ReadUInt16()); break; case OperationCode.Localloc: value = new PointerType(this.PEFileToObjectModel, 0xFFFFFFFF, this.PEFileToObjectModel.SystemVoid); break; case OperationCode.Endfilter: break; case OperationCode.Unaligned_: value = memReader.ReadByte(); break; case OperationCode.Volatile_: case OperationCode.Tail_: break; case OperationCode.Initobj: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Constrained_: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Cpblk: case OperationCode.Initblk: break; case OperationCode.No_: value = (OperationCheckFlags)memReader.ReadByte(); break; case OperationCode.Rethrow: break; case OperationCode.Sizeof: value = this.GetType(memReader.ReadUInt32()); break; case OperationCode.Refanytype: case OperationCode.Readonly_: break; default: this.PEFileToObjectModel.PEFileReader.ErrorContainer.AddILError(this.MethodDefinition, offset, MetadataReaderErrorKind.UnknownILInstruction); break; } MethodBodyLocation location = new MethodBodyLocation(document, offset); instrList.Add(new CilInstruction(cilOpCode, location, value)); } this.MethodBody.SetCilInstructions(new EnumerableArrayWrapper <CilInstruction, IOperation>(instrList.ToArray(), Dummy.Operation)); return(true); }