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));
internal abstract bool TryGetMethodHandle(Cci.IMethodDefinition def, out MethodDefinitionHandle handle);
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);
}
