private static void WritePEImage( Stream peStream, MetadataBuilder metadataBuilder, BlobBuilder ilBuilder, MethodDefinitionHandle entryPointHandle, Blob mvidFixup = default(Blob), byte[] privateKeyOpt = null) { var peBuilder = new ManagedPEBuilder( entryPointHandle.IsNil ? PEHeaderBuilder.CreateLibraryHeader() : PEHeaderBuilder.CreateExecutableHeader(), new MetadataRootBuilder(metadataBuilder), ilBuilder, entryPoint: entryPointHandle, flags: CorFlags.ILOnly | (privateKeyOpt != null ? CorFlags.StrongNameSigned : 0), deterministicIdProvider: content => s_contentId); var peBlob = new BlobBuilder(); var contentId = peBuilder.Serialize(peBlob); if (!mvidFixup.IsDefault) { new BlobWriter(mvidFixup).WriteGuid(contentId.Guid); } if (privateKeyOpt != null) { peBuilder.Sign(peBlob, content => SigningUtilities.CalculateRsaSignature(content, privateKeyOpt)); } peBlob.WriteContentTo(peStream); }
internal static PEMethodSymbol GetMethod(this CSharpCompilation compilation, Guid moduleVersionId, MethodDefinitionHandle methodHandle) { var module = compilation.GetModule(moduleVersionId); var reader = module.Module.MetadataReader; var typeHandle = reader.GetMethodDefinition(methodHandle).GetDeclaringType(); var type = GetType(module, typeHandle); var method = (PEMethodSymbol)new MetadataDecoder(module, type).GetMethodSymbolForMethodDefOrMemberRef(methodHandle, type); return method; }
public StandaloneDebugMetadataSerializer( MetadataBuilder builder, ImmutableArray<int> typeSystemRowCounts, MethodDefinitionHandle entryPoint, bool isMinimalDelta) : base(builder, CreateSizes(builder, typeSystemRowCounts, isMinimalDelta, isStandaloneDebugMetadata: true), DebugMetadataVersionString) { _entryPoint = entryPoint; }
TypeDesc[] _genericParameters; // TODO: Optional field? internal EcmaMethod(EcmaType type, MethodDefinitionHandle handle) { _type = type; _handle = handle; #if DEBUG // Initialize name eagerly in debug builds for convenience this.ToString(); #endif }
public static EditAndContinueMethodDebugInformation GetEncMethodDebugInfo(this ISymUnmanagedReader3 symReader, MethodDefinitionHandle handle) { var cdi = CustomDebugInfoUtilities.GetCustomDebugInfoBytes(symReader, handle, methodVersion: 1); if (cdi == null) { return default(EditAndContinueMethodDebugInformation); } return GetEncMethodDebugInfo(cdi); }
public static EditAndContinueMethodDebugInformation GetEncMethodDebugInfo(this ISymUnmanagedReader symReader, MethodDefinitionHandle handle) { var cdi = symReader.GetCustomDebugInfo(MetadataTokens.GetToken(handle), methodVersion: 0); if (cdi == null) { return default(EditAndContinueMethodDebugInformation); } return GetEncMethodDebugInfo(cdi); }
/// <summary> /// Returns true if the method should be imported. Returns false for private methods that are not /// explicit interface implementations. For other methods, visibility and the value of /// <paramref name="importOptions"/> are considered. /// </summary> public static bool ShouldImportMethod(this PEModule module, MethodDefinitionHandle methodDef, MetadataImportOptions importOptions) { try { var flags = module.GetMethodDefFlagsOrThrow(methodDef); // If the method is virtual, it must be accessible, although // it may be an explicit (private) interface implementation. // Otherwise, we need to check the accessibility. if ((flags & MethodAttributes.Virtual) == 0) { switch (flags & MethodAttributes.MemberAccessMask) { case MethodAttributes.Private: case MethodAttributes.PrivateScope: if (importOptions != MetadataImportOptions.All) { return false; } break; case MethodAttributes.Assembly: if (importOptions == MetadataImportOptions.Public) { return false; } break; } } } catch (BadImageFormatException) { } try { // As in the native C# compiler (see IMPORTER::ImportMethod), drop any method prefixed // with "_VtblGap". They should be impossible to call/implement/etc. // BREAK: The native VB compiler does not drop such methods, but it produces unverfiable // code when they are called, so the break is acceptable. // TODO: Keep some record of vtable gaps (DevDiv #17472). var name = module.GetMethodDefNameOrThrow(methodDef); return !name.StartsWith(VTableGapMethodNamePrefix, StringComparison.Ordinal); } catch (BadImageFormatException) { return true; } }
private static void WritePEImage(Stream peStream, MetadataBuilder metadataBuilder, BlobBuilder ilBuilder, MethodDefinitionHandle entryPointHandle) { var mappedFieldDataBuilder = new BlobBuilder(); var managedResourceDataBuilder = new BlobBuilder(); var peBuilder = new PEBuilder( machine: 0, sectionAlignment: 0x2000, fileAlignment: 0x200, imageBase: 0x00400000, majorLinkerVersion: 0x30, // (what is ref.emit using?) minorLinkerVersion: 0, majorOperatingSystemVersion: 4, minorOperatingSystemVersion: 0, majorImageVersion: 0, minorImageVersion: 0, majorSubsystemVersion: 4, minorSubsystemVersion: 0, subsystem: Subsystem.WindowsCui, dllCharacteristics: DllCharacteristics.DynamicBase | DllCharacteristics.NxCompatible | DllCharacteristics.NoSeh | DllCharacteristics.TerminalServerAware, imageCharacteristics: entryPointHandle.IsNil ? Characteristics.Dll : Characteristics.ExecutableImage, sizeOfStackReserve: 0x00100000, sizeOfStackCommit: 0x1000, sizeOfHeapReserve: 0x00100000, sizeOfHeapCommit: 0x1000); var peDirectoriesBuilder = new PEDirectoriesBuilder(); peBuilder.AddManagedSections( peDirectoriesBuilder, new TypeSystemMetadataSerializer(metadataBuilder, "v4.0.30319", isMinimalDelta: false), ilBuilder, mappedFieldDataBuilder, managedResourceDataBuilder, nativeResourceSectionSerializer: null, strongNameSignatureSize: 0, entryPoint: entryPointHandle, pdbPathOpt: null, nativePdbContentId: default(ContentId), portablePdbContentId: default(ContentId), corFlags: CorFlags.ILOnly); var peBlob = new BlobBuilder(); ContentId peContentId; peBuilder.Serialize(peBlob, peDirectoriesBuilder, out peContentId); peBlob.WriteContentTo(peStream); }
public ManagedPEBuilder( PEHeaderBuilder header, MetadataRootBuilder metadataRootBuilder, BlobBuilder ilStream, BlobBuilder mappedFieldData = null, BlobBuilder managedResources = null, ResourceSectionBuilder nativeResources = null, DebugDirectoryBuilder debugDirectoryBuilder = null, int strongNameSignatureSize = DefaultStrongNameSignatureSize, MethodDefinitionHandle entryPoint = default(MethodDefinitionHandle), CorFlags flags = CorFlags.ILOnly, Func<IEnumerable<Blob>, BlobContentId> deterministicIdProvider = null) : base(header, deterministicIdProvider) { if (header == null) { Throw.ArgumentNull(nameof(header)); } if (metadataRootBuilder == null) { Throw.ArgumentNull(nameof(metadataRootBuilder)); } if (ilStream == null) { Throw.ArgumentNull(nameof(ilStream)); } if (strongNameSignatureSize < 0) { Throw.ArgumentOutOfRange(nameof(strongNameSignatureSize)); } _metadataRootBuilder = metadataRootBuilder; _ilStream = ilStream; _mappedFieldDataOpt = mappedFieldData; _managedResourcesOpt = managedResources; _nativeResourcesOpt = nativeResources; _strongNameSignatureSize = strongNameSignatureSize; _entryPointOpt = entryPoint; _debugDirectoryBuilderOpt = debugDirectoryBuilder ?? CreateDefaultDebugDirectoryBuilder(); _corFlags = flags; _peDirectoriesBuilder = new PEDirectoriesBuilder(); }
public AsyncMethodData( MethodDefinitionHandle kickoffMethod, int catchHandlerOffset, ImmutableArray<int> yieldOffsets, ImmutableArray<int> resumeOffsets, ImmutableArray<int> resumeMethods) { Debug.Assert(!kickoffMethod.IsNil); Debug.Assert(catchHandlerOffset >= -1); Debug.Assert(yieldOffsets.Length == resumeOffsets.Length); Debug.Assert(yieldOffsets.Length == resumeMethods.Length); KickoffMethod = kickoffMethod; CatchHandlerOffset = catchHandlerOffset; YieldOffsets = yieldOffsets; ResumeOffsets = resumeOffsets; ResumeMethods = resumeMethods; }
public void VerifyIL( string qualifiedMethodName, string expectedIL, Func<Cci.ILocalDefinition, ILVisualizer.LocalInfo> mapLocal = null, MethodDefinitionHandle methodToken = default(MethodDefinitionHandle), [CallerFilePath]string callerPath = null, [CallerLineNumber]int callerLine = 0) { var ilBuilder = TestData.GetMethodData(qualifiedMethodName).ILBuilder; Dictionary<int, string> sequencePointMarkers = null; if (!methodToken.IsNil) { string actualPdb = PdbToXmlConverter.DeltaPdbToXml(PdbDelta, new[] { MetadataTokens.GetToken(methodToken) }); sequencePointMarkers = TestBase.GetMarkers(actualPdb); } string actualIL = ILBuilderVisualizer.ILBuilderToString(ilBuilder, mapLocal ?? ToLocalInfo, sequencePointMarkers); AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine); }
/// <summary> /// Creates a builder of a Portable PDB image. /// </summary> /// <param name="tablesAndHeaps"> /// Builder populated with debug metadata entities stored in tables and values stored in heaps. /// The entities and values will be enumerated when serializing the Portable PDB image. /// </param> /// <param name="typeSystemRowCounts"> /// Row counts of all tables that the associated type-system metadata contain. /// Each slot in the array corresponds to a table (<see cref="TableIndex"/>). /// The length of the array must be equal to <see cref="MetadataTokens.TableCount"/>. /// </param> /// <param name="entryPoint"> /// Entry point method definition handle. /// </param> /// <param name="idProvider"> /// Function calculating id of content represented as a sequence of blobs. /// If not specified a default function that ignores the content and returns current time-based content id is used /// (<see cref="BlobContentId.GetTimeBasedProvider()"/>). /// You must specify a deterministic function to produce a deterministic Portable PDB image. /// </param> /// <exception cref="ArgumentNullException"><paramref name="tablesAndHeaps"/> or <paramref name="typeSystemRowCounts"/> is null.</exception> public PortablePdbBuilder( MetadataBuilder tablesAndHeaps, ImmutableArray<int> typeSystemRowCounts, MethodDefinitionHandle entryPoint, Func<IEnumerable<Blob>, BlobContentId> idProvider = null) { if (tablesAndHeaps == null) { Throw.ArgumentNull(nameof(tablesAndHeaps)); } ValidateTypeSystemRowCounts(typeSystemRowCounts); _builder = tablesAndHeaps; _entryPoint = entryPoint; Debug.Assert(BlobUtilities.GetUTF8ByteCount(MetadataVersion) == MetadataVersion.Length); _serializedMetadata = tablesAndHeaps.GetSerializedMetadata(typeSystemRowCounts, MetadataVersion.Length, isStandaloneDebugMetadata: true); IdProvider = idProvider ?? BlobContentId.GetTimeBasedProvider(); }
public GenericContext(MethodDefinitionHandle method, PEFile module) { this.metadata = module.Metadata; this.method = method; this.declaringType = module.Metadata.GetMethodDefinition(method).GetDeclaringType(); }
public MethodDebugInformation GetMethodDebugInformation(MethodDefinitionHandle handle) { return new MethodDebugInformation(this, MethodDebugInformationHandle.FromRowId(handle.RowId)); }
public GenericContext(MethodDefinitionHandle method, MetadataReader metadata) { this.metadata = metadata; this.method = method; this.declaringType = metadata.GetMethodDefinition(method).GetDeclaringType(); }
public static void WriteVariableReference(ITextOutput writer, MetadataReader metadata, MethodDefinitionHandle handle, int index) { writer.WriteLocalReference(index.ToString(), "loc_" + index); }
protected override IEntityHandleObject CreateValueFromKey(EntityHandle handle) { object item; switch (handle.Kind) { case HandleKind.TypeDefinition: item = new EcmaType(_module, (TypeDefinitionHandle)handle); break; case HandleKind.MethodDefinition: { MethodDefinitionHandle methodDefinitionHandle = (MethodDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetMethodDefinition(methodDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle, NotFoundBehavior.Throw); item = new EcmaMethod(type, methodDefinitionHandle); } break; case HandleKind.FieldDefinition: { FieldDefinitionHandle fieldDefinitionHandle = (FieldDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetFieldDefinition(fieldDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle, NotFoundBehavior.Throw); item = new EcmaField(type, fieldDefinitionHandle); } break; case HandleKind.TypeReference: item = _module.ResolveTypeReference((TypeReferenceHandle)handle); break; case HandleKind.MemberReference: item = _module.ResolveMemberReference((MemberReferenceHandle)handle); break; case HandleKind.AssemblyReference: item = _module.ResolveAssemblyReference((AssemblyReferenceHandle)handle); break; case HandleKind.TypeSpecification: item = _module.ResolveTypeSpecification((TypeSpecificationHandle)handle); break; case HandleKind.MethodSpecification: item = _module.ResolveMethodSpecification((MethodSpecificationHandle)handle); break; case HandleKind.ExportedType: item = _module.ResolveExportedType((ExportedTypeHandle)handle); break; case HandleKind.StandaloneSignature: item = _module.ResolveStandaloneSignature((StandaloneSignatureHandle)handle); break; case HandleKind.ModuleDefinition: // ECMA-335 Partition 2 II.22.38 1d: This should not occur in a CLI ("compressed metadata") module, // but resolves to "current module". item = _module; break; case HandleKind.ModuleReference: item = _module.ResolveModuleReference((ModuleReferenceHandle)handle); break; default: ThrowHelper.ThrowBadImageFormatException("unknown metadata token type: " + handle.Kind); item = null; break; } switch (handle.Kind) { case HandleKind.TypeDefinition: case HandleKind.MethodDefinition: case HandleKind.FieldDefinition: // type/method/field definitions directly correspond to their target item. return((IEntityHandleObject)item); default: // Everything else is some form of reference which cannot be self-describing return(new EcmaObjectLookupWrapper(handle, item)); } }
public QMethodDefinition(MetadataReader reader, MethodDefinitionHandle handle) { _reader = reader; _handle = MetadataTokens.GetToken(handle); }
public MethodDefinition GetMethodDefinition(MethodDefinitionHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. return new MethodDefinition(this, GetMethodDefTreatmentAndRowId(handle)); }
public void IsNil() { Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil); Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil); Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil); Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil); Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil); Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil); Assert.False(ExportedTypeHandle.FromRowId(1).IsNil); Assert.False(TypeReferenceHandle.FromRowId(1).IsNil); Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(ParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil); Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil); Assert.False(CustomAttributeHandle.FromRowId(1).IsNil); Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(ConstantHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(AssemblyFileHandle.FromRowId(1).IsNil); Assert.False(MethodImplementationHandle.FromRowId(1).IsNil); Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil); Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil); Assert.False(StringHandle.FromOffset(1).IsNil); Assert.False(BlobHandle.FromOffset(1).IsNil); Assert.False(UserStringHandle.FromOffset(1).IsNil); Assert.False(GuidHandle.FromIndex(1).IsNil); Assert.False(DocumentNameBlobHandle.FromOffset(1).IsNil); Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil); Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil); Assert.False(((BlobHandle)DocumentNameBlobHandle.FromOffset(1)).IsNil); Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil); Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil); Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil); Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil); Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil); Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil); Assert.True(ExportedTypeHandle.FromRowId(0).IsNil); Assert.True(TypeReferenceHandle.FromRowId(0).IsNil); Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(ParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil); Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil); Assert.True(CustomAttributeHandle.FromRowId(0).IsNil); Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(ConstantHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(AssemblyFileHandle.FromRowId(0).IsNil); Assert.True(MethodImplementationHandle.FromRowId(0).IsNil); Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil); Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil); // heaps: Assert.True(StringHandle.FromOffset(0).IsNil); Assert.True(BlobHandle.FromOffset(0).IsNil); Assert.True(UserStringHandle.FromOffset(0).IsNil); Assert.True(GuidHandle.FromIndex(0).IsNil); Assert.True(DocumentNameBlobHandle.FromOffset(0).IsNil); Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil); Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil); Assert.True(((BlobHandle)DocumentNameBlobHandle.FromOffset(0)).IsNil); // virtual: Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil); Assert.False(StringHandle.FromVirtualIndex(0).IsNil); Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil); Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil); }
public static byte[] GetCustomDebugInfoBytes(ISymUnmanagedReader3 reader, MethodDefinitionHandle handle, int methodVersion) { return(reader.GetCustomDebugInfo(MetadataTokens.GetToken(handle), methodVersion)); }
internal abstract bool TryGetMethodHandle(Cci.IMethodDefinition def, out MethodDefinitionHandle handle);
public abstract StandaloneSignatureHandle GetLocalSignature(MethodDefinitionHandle methodHandle);
public abstract EditAndContinueMethodDebugInformation GetDebugInfo(MethodDefinitionHandle methodHandle);
private ImmutableArray <byte> GetCdiBytes(MethodDefinitionHandle methodHandle, Guid kind) => TryGetCustomDebugInformation(_pdbReader, methodHandle, kind, out var cdi) ? _pdbReader.GetBlobContent(cdi.Value) : default;
public override EditAndContinueMethodDebugInformation GetDebugInfo(MethodDefinitionHandle methodHandle) => EditAndContinueMethodDebugInformation.Create( compressedSlotMap: GetCdiBytes(methodHandle, PortableCustomDebugInfoKinds.EncLocalSlotMap), compressedLambdaMap: GetCdiBytes(methodHandle, PortableCustomDebugInfoKinds.EncLambdaAndClosureMap));
protected override IEntityHandleObject CreateValueFromKey(EntityHandle handle) { object item; switch (handle.Kind) { case HandleKind.TypeDefinition: item = new EcmaType(_module, (TypeDefinitionHandle)handle); break; case HandleKind.MethodDefinition: { MethodDefinitionHandle methodDefinitionHandle = (MethodDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetMethodDefinition(methodDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle); item = new EcmaMethod(type, methodDefinitionHandle); } break; case HandleKind.FieldDefinition: { FieldDefinitionHandle fieldDefinitionHandle = (FieldDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetFieldDefinition(fieldDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle); item = new EcmaField(type, fieldDefinitionHandle); } break; case HandleKind.TypeReference: item = _module.ResolveTypeReference((TypeReferenceHandle)handle); break; case HandleKind.MemberReference: item = _module.ResolveMemberReference((MemberReferenceHandle)handle); break; case HandleKind.AssemblyReference: item = _module.ResolveAssemblyReference((AssemblyReferenceHandle)handle); break; case HandleKind.TypeSpecification: item = _module.ResolveTypeSpecification((TypeSpecificationHandle)handle); break; case HandleKind.MethodSpecification: item = _module.ResolveMethodSpecification((MethodSpecificationHandle)handle); break; case HandleKind.ExportedType: item = _module.ResolveExportedType((ExportedTypeHandle)handle); break; case HandleKind.StandaloneSignature: item = _module.ResolveStandaloneSignature((StandaloneSignatureHandle)handle); break; // TODO: Resolve other tokens default: throw new BadImageFormatException("Unknown metadata token type: " + handle.Kind); } switch (handle.Kind) { case HandleKind.TypeDefinition: case HandleKind.MethodDefinition: case HandleKind.FieldDefinition: // type/method/field definitions directly correspond to their target item. return((IEntityHandleObject)item); default: // Everything else is some form of reference which cannot be self-describing return(new EcmaObjectLookupWrapper(handle, item)); } }
internal void GetParameterRange(MethodDefinitionHandle methodDef, out int firstParamRowId, out int lastParamRowId) { uint rid = methodDef.RowId; firstParamRowId = (int)this.MethodDefTable.GetParamStart(rid); if (firstParamRowId == 0) { firstParamRowId = 1; lastParamRowId = 0; } else if (rid == this.MethodDefTable.NumberOfRows) { lastParamRowId = (int)(this.UseParamPtrTable ? this.ParamPtrTable.NumberOfRows : this.ParamTable.NumberOfRows); } else { lastParamRowId = (int)this.MethodDefTable.GetParamStart(rid + 1) - 1; } }
private void SerializeAsyncMethodSteppingInfo(AsyncMethodBodyDebugInfo asyncInfo, MethodDefinitionHandle moveNextMethod) { Debug.Assert(asyncInfo.ResumeOffsets.Length == asyncInfo.YieldOffsets.Length); Debug.Assert(asyncInfo.CatchHandlerOffset >= -1); var writer = new BlobBuilder(); writer.WriteUInt32((uint)((long)asyncInfo.CatchHandlerOffset + 1)); for (int i = 0; i < asyncInfo.ResumeOffsets.Length; i++) { writer.WriteUInt32((uint)asyncInfo.YieldOffsets[i]); writer.WriteUInt32((uint)asyncInfo.ResumeOffsets[i]); writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(moveNextMethod)); } _debugMetadataOpt.AddCustomDebugInformation( parent: moveNextMethod, kind: _debugMetadataOpt.GetOrAddGuid(PortableCustomDebugInfoKinds.AsyncMethodSteppingInformationBlob), value: _debugMetadataOpt.GetOrAddBlob(writer)); }
public MethodImportRow(MethodImport import, MethodDefinitionHandle parent) { Import = import; Parent = parent; }
internal int GetLocalSignatureToken(MethodDefinitionHandle methodHandle) { if (!_includeLocalSignatures) { return 0; } using (var module = new PEModule(new PEReader(ImmutableArray.CreateRange(this.FullImage)), metadataOpt: IntPtr.Zero, metadataSizeOpt: 0)) { var reader = module.MetadataReader; var methodIL = module.GetMethodBodyOrThrow(methodHandle); var localSignatureHandle = methodIL.LocalSignature; return reader.GetToken(localSignatureHandle); } }
protected override MethodSymbol FindMethodSymbolInType(TypeSymbol typeSymbol, MethodDefinitionHandle targetMethodDef) { Debug.Assert(typeSymbol is PENamedTypeSymbol || typeSymbol is ErrorTypeSymbol); foreach (Symbol member in typeSymbol.GetMembersUnordered()) { PEMethodSymbol method = member as PEMethodSymbol; if ((object)method != null && method.Handle == targetMethodDef) { return(method); } } return(null); }
public void AddMethodSemantics(EntityHandle association, ushort semantics, MethodDefinitionHandle methodDefinition) { uint associationCodedIndex = (uint)CodedIndex.ToHasSemantics(association); // the table is required to be sorted by Association: _methodSemanticsTableNeedsSorting |= associationCodedIndex < _methodSemanticsTableLastAssociation; _methodSemanticsTableLastAssociation = associationCodedIndex; _methodSemanticsTable.Add(new MethodSemanticsRow { Association = associationCodedIndex, Method = (uint)MetadataTokens.GetRowNumber(methodDefinition), Semantic = semantics }); }
public static void WriteParameterReference(ITextOutput writer, MetadataReader metadata, MethodDefinitionHandle handle, int sequence) { var methodDefinition = metadata.GetMethodDefinition(handle); var signature = methodDefinition.DecodeSignature(new FullTypeNameSignatureDecoder(metadata), default); var parameters = methodDefinition.GetParameters().Select(p => metadata.GetParameter(p)).ToArray(); var signatureHeader = signature.Header; int index = sequence; if (signatureHeader.IsInstance && signature.ParameterTypes.Length == parameters.Length) { index--; } if (index < 0 || index >= parameters.Length) { writer.WriteLocalReference(sequence.ToString(), "param_" + index); } else { var param = parameters[index]; if (param.Name.IsNil) { writer.WriteLocalReference(sequence.ToString(), "param_" + index); } else { writer.WriteLocalReference(Escape(metadata.GetString(param.Name)), "param_" + index); } } }
public void AddStateMachineMethod(MethodDefinitionHandle moveNextMethod, MethodDefinitionHandle kickoffMethod) { _stateMachineMethodTable.Add(new StateMachineMethodRow { MoveNextMethod = (uint)MetadataTokens.GetRowNumber(moveNextMethod), KickoffMethod = (uint)MetadataTokens.GetRowNumber(kickoffMethod) }); }
public static byte[] GetCustomDebugInfoBytes(ISymUnmanagedReader3 reader, MethodDefinitionHandle handle, int methodVersion) { return reader.GetCustomDebugInfoBytes(MetadataTokens.GetToken(handle), methodVersion); }
private MethodDefTreatment GetMethodTreatmentFromCustomAttributes(MethodDefinitionHandle methodDef) { MethodDefTreatment treatment = 0; foreach (var caHandle in GetCustomAttributes(methodDef)) { StringHandle namespaceHandle, nameHandle; if (!GetAttributeTypeNameRaw(caHandle, out namespaceHandle, out nameHandle)) { continue; } Debug.Assert(!namespaceHandle.IsVirtual && !nameHandle.IsVirtual); if (StringStream.EqualsRaw(namespaceHandle, "Windows.UI.Xaml")) { if (StringStream.EqualsRaw(nameHandle, "TreatAsPublicMethodAttribute")) { treatment |= MethodDefTreatment.MarkPublicFlag; } if (StringStream.EqualsRaw(nameHandle, "TreatAsAbstractMethodAttribute")) { treatment |= MethodDefTreatment.MarkAbstractFlag; } } } return treatment; }
public LocalScopeHandleCollection GetLocalScopes(MethodDefinitionHandle handle) { return new LocalScopeHandleCollection(this, handle.RowId); }
/// <summary> /// Find a method given its metadata token. This method is used for debugging support. /// </summary> /// <param name="mdMethodToken">Method metadata token.</param> /// <returns></returns> public ImportedMethod GetMethod(int mdToken) { MethodDefinitionHandle methodHandle = (MethodDefinitionHandle)MetadataTokens.EntityHandle(mdToken); return(ResolveMethod(methodHandle)); }
protected override void WriteInstruction(ITextOutput output, MetadataReader metadata, MethodDefinitionHandle methodDefinition, ref BlobReader blob) { int index = sequencePoints.BinarySearch(blob.Offset, seq => seq.Offset); if (index >= 0) { var info = sequencePoints[index]; var highlightingOutput = output as ISmartTextOutput; if (!info.IsHidden) { for (int line = info.StartLine; line <= info.EndLine; line++) { if (highlightingOutput != null) { string text = codeLines[line - 1]; int startColumn = 1; int endColumn = text.Length + 1; if (line == info.StartLine) { startColumn = info.StartColumn; } if (line == info.EndLine) { endColumn = info.EndColumn; } WriteHighlightedCommentLine(highlightingOutput, text, startColumn - 1, endColumn - 1, info.StartLine == info.EndLine); } else { WriteCommentLine(output, codeLines[line - 1]); } } } else { output.Write("// "); highlightingOutput?.BeginSpan(gray); output.WriteLine("(no C# code)"); highlightingOutput?.EndSpan(); } } base.WriteInstruction(output, metadata, methodDefinition, ref blob); }
public override StandaloneSignatureHandle GetLocalSignature(MethodDefinitionHandle methodHandle) => _pdbReader.GetMethodDebugInformation(methodHandle.ToDebugInformationHandle()).LocalSignature;
internal static CilMethodDefinition Create(MethodDefinitionHandle methodHandle, ref CilReaders readers, CilTypeDefinition typeDefinition) { MethodDefinition method = readers.MdReader.GetMethodDefinition(methodHandle); int token = MetadataTokens.GetToken(methodHandle); return Create(method, token, ref readers, typeDefinition); }
public void MethodImplEntry() { var text = @" public class A { ~A() { } } "; CompileAndVerify( text, assemblyValidator: (assembly) => { var peFileReader = assembly.GetMetadataReader(); // Find the handle and row for A. var pairA = peFileReader.TypeDefinitions .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetTypeDefinition(handle) } ) .Single( pair => peFileReader.GetString(pair.row.Name) == "A" && string.IsNullOrEmpty(peFileReader.GetString(pair.row.Namespace)) ); TypeDefinitionHandle handleA = pairA.handle; TypeDefinition typeA = pairA.row; // Find the handle for A's destructor. MethodDefinitionHandle handleDestructorA = typeA .GetMethods() .AsEnumerable() .Single( handle => peFileReader.GetString( peFileReader.GetMethodDefinition(handle).Name ) == WellKnownMemberNames.DestructorName ); // Find the handle for System.Object. TypeReferenceHandle handleObject = peFileReader.TypeReferences .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetTypeReference(handle) } ) .Single( pair => peFileReader.GetString(pair.row.Name) == "Object" && peFileReader.GetString(pair.row.Namespace) == "System" ).handle; // Find the handle for System.Object's destructor. MemberReferenceHandle handleDestructorObject = peFileReader.MemberReferences .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetMemberReference(handle) } ) .Single( pair => pair.row.Parent == (EntityHandle)handleObject && peFileReader.GetString(pair.row.Name) == WellKnownMemberNames.DestructorName ).handle; // Find the MethodImpl row for A. MethodImplementation methodImpl = typeA .GetMethodImplementations() .AsEnumerable() .Select(handle => peFileReader.GetMethodImplementation(handle)) .Single(); // The Class column should point to A. Assert.Equal(handleA, methodImpl.Type); // The MethodDeclaration column should point to System.Object.Finalize. Assert.Equal( (EntityHandle)handleDestructorObject, methodImpl.MethodDeclaration ); // The MethodDeclarationColumn should point to A's destructor. Assert.Equal((EntityHandle)handleDestructorA, methodImpl.MethodBody); } ); }
public TypeDefinitionHandle AddTypeDefinition( TypeAttributes attributes, StringHandle @namespace, StringHandle name, EntityHandle baseType, FieldDefinitionHandle fieldList, MethodDefinitionHandle methodList) { Debug.Assert(@namespace != null); Debug.Assert(name != null); _typeDefTable.Add(new TypeDefRow { Flags = (uint)attributes, Name = name, Namespace = @namespace, Extends = baseType.IsNil ? 0 : (uint)CodedIndex.ToTypeDefOrRef(baseType), FieldList = (uint)MetadataTokens.GetRowNumber(fieldList), MethodList = (uint)MetadataTokens.GetRowNumber(methodList) }); return MetadataTokens.TypeDefinitionHandle(_typeDefTable.Count); }
private static void ReadLocalScopeInformation( MetadataReader reader, MethodDefinitionHandle methodHandle, int ilOffset, EESymbolProvider <TTypeSymbol, TLocalSymbol> symbolProvider, bool isVisualBasicMethod, out ImmutableArray <ImmutableArray <ImportRecord> > importGroups, out ImmutableArray <ExternAliasRecord> externAliases, out ImmutableArray <string> localVariableNames, out ImmutableDictionary <int, ImmutableArray <bool> > dynamicLocals, out ImmutableArray <TLocalSymbol> localConstants, out ILSpan reuseSpan) { var localVariableNamesBuilder = ArrayBuilder <string> .GetInstance(); var localConstantsBuilder = ArrayBuilder <TLocalSymbol> .GetInstance(); ImmutableDictionary <int, ImmutableArray <bool> > .Builder lazyDynamicLocalsBuilder = null; var innerMostImportScope = default(ImportScopeHandle); uint reuseSpanStart = 0; uint reuseSpanEnd = uint.MaxValue; try { foreach (var scopeHandle in reader.GetLocalScopes(methodHandle)) { try { var scope = reader.GetLocalScope(scopeHandle); if (ilOffset < scope.StartOffset) { // scopes are sorted by StartOffset, hence all scopes that follow can't contain ilOffset reuseSpanEnd = Math.Min(reuseSpanEnd, (uint)scope.StartOffset); break; } if (ilOffset >= scope.EndOffset) { // ilOffset is not in this scope, go to next one reuseSpanStart = Math.Max(reuseSpanStart, (uint)scope.EndOffset); continue; } // reuse span is a subspan of the inner-most scope containing the IL offset: reuseSpanStart = Math.Max(reuseSpanStart, (uint)scope.StartOffset); reuseSpanEnd = Math.Min(reuseSpanEnd, (uint)scope.EndOffset); // imports (use the inner-most): innerMostImportScope = scope.ImportScope; // locals (from all contained scopes): foreach (var variableHandle in scope.GetLocalVariables()) { var variable = reader.GetLocalVariable(variableHandle); if ((variable.Attributes & LocalVariableAttributes.DebuggerHidden) != 0) { continue; } localVariableNamesBuilder.SetItem(variable.Index, reader.GetString(variable.Name)); var dynamicFlags = ReadDynamicCustomDebugInformation(reader, variableHandle); if (!dynamicFlags.IsDefault) { lazyDynamicLocalsBuilder = lazyDynamicLocalsBuilder ?? ImmutableDictionary.CreateBuilder <int, ImmutableArray <bool> >(); lazyDynamicLocalsBuilder[variable.Index] = dynamicFlags; } } // constants (from all contained scopes): foreach (var constantHandle in scope.GetLocalConstants()) { var constant = reader.GetLocalConstant(constantHandle); TTypeSymbol typeSymbol; ConstantValue value; var sigReader = reader.GetBlobReader(constant.Signature); symbolProvider.DecodeLocalConstant(ref sigReader, out typeSymbol, out value); var dynamicFlags = ReadDynamicCustomDebugInformation(reader, constantHandle); localConstantsBuilder.Add(symbolProvider.GetLocalConstant(reader.GetString(constant.Name), typeSymbol, value, dynamicFlags)); } } catch (Exception e) when(e is UnsupportedSignatureContent || e is BadImageFormatException) { // ignore scopes with invalid data } } } finally { localVariableNames = localVariableNamesBuilder.ToImmutableAndFree(); localConstants = localConstantsBuilder.ToImmutableAndFree(); dynamicLocals = lazyDynamicLocalsBuilder?.ToImmutable(); reuseSpan = new ILSpan(reuseSpanStart, reuseSpanEnd); } var importGroupsBuilder = ArrayBuilder <ImmutableArray <ImportRecord> > .GetInstance(); var externAliasesBuilder = ArrayBuilder <ExternAliasRecord> .GetInstance(); try { if (!innerMostImportScope.IsNil) { PopulateImports(reader, innerMostImportScope, symbolProvider, isVisualBasicMethod, importGroupsBuilder, externAliasesBuilder); } } catch (Exception e) when(e is UnsupportedSignatureContent || e is BadImageFormatException) { // ignore invalid imports } importGroups = importGroupsBuilder.ToImmutableAndFree(); externAliases = externAliasesBuilder.ToImmutableAndFree(); }
public LocalScopeHandle AddLocalScope(MethodDefinitionHandle method, ImportScopeHandle importScope, LocalVariableHandle variableList, LocalConstantHandle constantList, int startOffset, int length) { _localScopeTable.Add(new LocalScopeRow { Method = (uint)MetadataTokens.GetRowNumber(method), ImportScope = (uint)MetadataTokens.GetRowNumber(importScope), VariableList = (uint)MetadataTokens.GetRowNumber(variableList), ConstantList = (uint)MetadataTokens.GetRowNumber(constantList), StartOffset = (uint)startOffset, Length = (uint)length }); return MetadataTokens.LocalScopeHandle(_localScopeTable.Count); }
internal static uint ConvertMethodDefToTag(MethodDefinitionHandle methodDef) { return((uint)methodDef.RowId << NumberOfBits | MethodDef); }
private uint CalculateMethodDefTreatmentAndRowId(MethodDefinitionHandle methodDef) { MethodDefTreatment treatment = MethodDefTreatment.Implementation; TypeDefinitionHandle parentTypeDef = GetDeclaringType(methodDef); TypeAttributes parentFlags = TypeDefTable.GetFlags(parentTypeDef); if ((parentFlags & TypeAttributes.WindowsRuntime) != 0) { if (IsClrImplementationType(parentTypeDef)) { treatment = MethodDefTreatment.Implementation; } else if (parentFlags.IsNested()) { treatment = MethodDefTreatment.Implementation; } else if ((parentFlags & TypeAttributes.Interface) != 0) { treatment = MethodDefTreatment.InterfaceMethod; } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && (parentFlags & TypeAttributes.Public) == 0) { treatment = MethodDefTreatment.Implementation; } else { treatment = MethodDefTreatment.Other; var parentBaseType = TypeDefTable.GetExtends(parentTypeDef); if (parentBaseType.Kind == HandleKind.TypeReference) { switch (GetSpecialTypeRefTreatment((TypeReferenceHandle)parentBaseType)) { case TypeRefTreatment.SystemAttribute: treatment = MethodDefTreatment.AttributeMethod; break; case TypeRefTreatment.SystemDelegate: treatment = MethodDefTreatment.DelegateMethod | MethodDefTreatment.MarkPublicFlag; break; } } } } if (treatment == MethodDefTreatment.Other) { // we want to hide the method if it implements // only redirected interfaces // We also want to check if the methodImpl is IClosable.Close, // so we can change the name bool seenRedirectedInterfaces = false; bool seenNonRedirectedInterfaces = false; bool isIClosableClose = false; foreach (var methodImplHandle in new MethodImplementationHandleCollection(this, parentTypeDef)) { MethodImplementation methodImpl = GetMethodImplementation(methodImplHandle); if (methodImpl.MethodBody == methodDef) { EntityHandle declaration = methodImpl.MethodDeclaration; // See if this MethodImpl implements a redirected interface // In WinMD, MethodImpl will always use MemberRef and TypeRefs to refer to redirected interfaces, // even if they are in the same module. if (declaration.Kind == HandleKind.MemberReference && ImplementsRedirectedInterface((MemberReferenceHandle)declaration, out isIClosableClose)) { seenRedirectedInterfaces = true; if (isIClosableClose) { // This method implements IClosable.Close // Let's rename to IDisposable later // Once we know this implements IClosable.Close, we are done // looking break; } } else { // Now we know this implements a non-redirected interface // But we need to keep looking, just in case we got a methodimpl that // implements the IClosable.Close method and needs to be renamed seenNonRedirectedInterfaces = true; } } } if (isIClosableClose) { treatment = MethodDefTreatment.DisposeMethod; } else if (seenRedirectedInterfaces && !seenNonRedirectedInterfaces) { // Only hide if all the interfaces implemented are redirected treatment = MethodDefTreatment.HiddenInterfaceImplementation; } } // If treatment is other, then this is a non-managed WinRT runtime class definition // Find out about various bits that we apply via attributes and name parsing if (treatment == MethodDefTreatment.Other) { treatment |= GetMethodTreatmentFromCustomAttributes(methodDef); } return TreatmentAndRowId((byte)treatment, methodDef.RowId); }
public static LocalScopeHandleCollection GetLocalScopes(this MethodDefinitionHandle handle, MetadataReader reader) => reader.GetLocalScopes(handle);
public static MethodDefinition GetMethodDefinition(this MethodDefinitionHandle handle, MetadataReader reader) => reader.GetMethodDefinition(handle);
public static int GetToken(this MethodDefinitionHandle handle) => MetadataTokens.GetToken(handle);
internal PEMethodSymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, MethodDefinitionHandle methodDef) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingType != null); Debug.Assert(!methodDef.IsNil); _handle = methodDef; _containingType = containingType; MethodAttributes localflags = 0; try { int rva; MethodImplAttributes implFlags; moduleSymbol.Module.GetMethodDefPropsOrThrow(methodDef, out _name, out implFlags, out localflags, out rva); Debug.Assert((uint)implFlags <= ushort.MaxValue); _implFlags = (ushort)implFlags; } catch (BadImageFormatException) { if ((object)_name == null) { _name = string.Empty; } InitializeUseSiteDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this)); } Debug.Assert((uint)localflags <= ushort.MaxValue); _flags = (ushort)localflags; }
public MethodBaseDefinitionMetadata ReserveMethodDefinition(MethodInfo method, MethodDefinitionHandle handle) { var metadata = new MethodBaseDefinitionMetadata(method, handle); _methodDefHandles.Add(method, metadata); return(metadata); }
internal DebugMetadataHeader(ImmutableArray<byte> id, MethodDefinitionHandle entryPoint) { Id = id; EntryPoint = entryPoint; }
public static EditAndContinueMethodDebugInformation GetEncMethodDebugInfo(this ISymUnmanagedReader symReader, MethodDefinitionHandle handle) { var cdi = symReader.GetCustomDebugInfoBytes(MetadataTokens.GetToken(handle), methodVersion: 0); if (cdi == null) { return(default(EditAndContinueMethodDebugInformation)); } return(GetEncMethodDebugInfo(cdi)); }
internal TypeDefinitionHandle GetDeclaringType(MethodDefinitionHandle methodDef) { uint methodRowId; if (UseMethodPtrTable) { methodRowId = MethodPtrTable.GetRowIdForMethodDefRow(methodDef.RowId); } else { methodRowId = methodDef.RowId; } return TypeDefTable.FindTypeContainingMethod(methodRowId, (int)MethodDefTable.NumberOfRows); }
/// <summary> /// Returns true if the namespace scope for this method should be forwarded to another method. /// Returns non-null <paramref name="forwardToMethod"/> if the forwarding should be done directly via UsingNamespace, /// null if the forwarding is done via custom debug info. /// </summary> public bool ShouldForwardNamespaceScopes(EmitContext context, IMethodBody methodBody, MethodDefinitionHandle methodHandle, out IMethodDefinition forwardToMethod) { if (ShouldForwardToPreviousMethodWithUsingInfo(context, methodBody)) { // SerializeNamespaceScopeMetadata will do the actual forwarding in case this is a CSharp method. // VB on the other hand adds a "@methodtoken" to the scopes instead. if (context.Module.GenerateVisualBasicStylePdb) { forwardToMethod = _previousMethodBodyWithUsingInfo.MethodDefinition; } else { forwardToMethod = null; } return(true); } _previousMethodBodyWithUsingInfo = methodBody; _previousMethodWithUsingInfo = methodHandle; forwardToMethod = null; return(false); }
private uint GetMethodDefTreatmentAndRowId(MethodDefinitionHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. if (this.metadataKind == MetadataKind.Ecma335) { return handle.RowId; } return CalculateMethodDefTreatmentAndRowId(handle); }
internal static PEMethodSymbol GetMethod(this CSharpCompilation compilation, Guid moduleVersionId, MethodDefinitionHandle methodHandle) { var module = compilation.GetModule(moduleVersionId); var reader = module.Module.MetadataReader; var typeHandle = reader.GetMethodDefinition(methodHandle).GetDeclaringType(); var type = GetType(module, typeHandle); var method = (PEMethodSymbol) new MetadataDecoder(module, type).GetMethodSymbolForMethodDefOrMemberRef(methodHandle, type); return(method); }