public FullPeWriter(
EmitContext context,
CommonMessageProvider messageProvider,
PdbWriter pdbWriter,
bool allowMissingMethodBodies,
bool deterministic,
CancellationToken cancellationToken)
: base(context, messageProvider, pdbWriter, allowMissingMethodBodies, deterministic, cancellationToken)
{
// EDMAURER make some intelligent guesses for the initial sizes of these things.
int numMethods = this.module.HintNumberOfMethodDefinitions;
int numTypeDefsGuess = numMethods / 6;
int numFieldDefsGuess = numTypeDefsGuess * 4;
int numPropertyDefsGuess = numMethods / 4;
this.typeDefs = new DefinitionIndex <ITypeDefinition>(numTypeDefsGuess);
this.eventDefs = new DefinitionIndex <IEventDefinition>(0);
this.fieldDefs = new DefinitionIndex <IFieldDefinition>(numFieldDefsGuess);
this.methodDefs = new DefinitionIndex <IMethodDefinition>(numMethods);
this.propertyDefs = new DefinitionIndex <IPropertyDefinition>(numPropertyDefsGuess);
this.parameterDefs = new DefinitionIndex <IParameterDefinition>(numMethods);
this.genericParameters = new DefinitionIndex <IGenericParameter>(0);
this.fieldDefIndex = new Dictionary <ITypeDefinition, uint>(numTypeDefsGuess);
this.methodDefIndex = new Dictionary <ITypeDefinition, uint>(numTypeDefsGuess);
this.parameterListIndex = new Dictionary <IMethodDefinition, uint>(numMethods);
this.assemblyRefIndex = new HeapOrReferenceIndex <IAssemblyReference>(this, AssemblyReferenceComparer.Instance);
this.moduleRefIndex = new HeapOrReferenceIndex <string>(this);
this.memberRefIndex = new InstanceAndStructuralReferenceIndex <ITypeMemberReference>(this, new MemberRefComparer(this));
this.methodSpecIndex = new InstanceAndStructuralReferenceIndex <IGenericMethodInstanceReference>(this, new MethodSpecComparer(this));
this.typeRefIndex = new HeapOrReferenceIndex <ITypeReference>(this);
this.typeSpecIndex = new InstanceAndStructuralReferenceIndex <ITypeReference>(this, new TypeSpecComparer(this));
this.standAloneSignatureIndex = new HeapOrReferenceIndex <uint>(this);
}
public static bool WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Func<Stream> getPeStream,
PdbWriter nativePdbWriterOpt,
string pdbPathOpt,
bool allowMissingMethodBodies,
bool deterministic,
CancellationToken cancellationToken)
{
// If PDB writer is given, we have to have PDB path.
Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null);
var peWriter = new PeWriter(context.Module, pdbPathOpt, deterministic);
var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken);
return peWriter.WritePeToStream(mdWriter, getPeStream, nativePdbWriterOpt);
}
public static void WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Stream peStream,
PdbWriter nativePdbWriterOpt,
bool allowMissingMethodBodies,
bool deterministic,
CancellationToken cancellationToken)
{
var peWriter = new PeWriter(context.Module, nativePdbWriterOpt, deterministic);
var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken);
if (nativePdbWriterOpt != null)
{
nativePdbWriterOpt.SetMetadataEmitter(mdWriter);
}
uint entryPointToken;
peWriter.WritePeToStream(mdWriter, peStream, nativePdbWriterOpt, out entryPointToken);
if (nativePdbWriterOpt != null)
{
if (entryPointToken != 0)
{
nativePdbWriterOpt.SetEntryPoint(entryPointToken);
}
var assembly = context.Module.AsAssembly;
if (assembly != null && assembly.Kind == ModuleKind.WindowsRuntimeMetadata)
{
// Dev12: If compiling to winmdobj, we need to add to PDB source spans of
// all types and members for better error reporting by WinMDExp.
nativePdbWriterOpt.WriteDefinitionLocations(context.Module.GetSymbolToLocationMap());
}
}
}
public IEnumerable <IEventDefinition> GetEvents(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <IEventDefinition>());
}
ITypeDefinition ITypeReference.AsTypeDefinition(EmitContext context)
{
return(this);
}
ITypeDefinition ITypeReference.GetResolvedType(EmitContext context)
{
return(this);
}
public static bool WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Func <Stream> getPeStream,
Func <Stream> getPortablePdbStreamOpt,
PdbWriter nativePdbWriterOpt,
string pdbPathOpt,
bool allowMissingMethodBodies,
bool isDeterministic,
CancellationToken cancellationToken)
{
// If PDB writer is given, we have to have PDB path.
Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null);
var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken);
var properties = context.Module.Properties;
nativePdbWriterOpt?.SetMetadataEmitter(mdWriter);
// Since we are producing a full assembly, we should not have a module version ID
// imposed ahead-of time. Instead we will compute a deterministic module version ID
// based on the contents of the generated stream.
Debug.Assert(properties.PersistentIdentifier == default(Guid));
var ilBuilder = new BlobBuilder(32 * 1024);
var mappedFieldDataBuilder = new BlobBuilder();
var managedResourceBuilder = new BlobBuilder(1024);
Blob mvidFixup;
mdWriter.BuildMetadataAndIL(
nativePdbWriterOpt,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
out mvidFixup);
MethodDefinitionHandle entryPointHandle;
MethodDefinitionHandle debugEntryPointHandle;
mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle);
if (!debugEntryPointHandle.IsNil)
{
nativePdbWriterOpt?.SetEntryPoint((uint)MetadataTokens.GetToken(debugEntryPointHandle));
}
if (nativePdbWriterOpt != null)
{
var assembly = mdWriter.Module.AsAssembly;
if (assembly != null && assembly.Kind == OutputKind.WindowsRuntimeMetadata)
{
// Dev12: If compiling to winmdobj, we need to add to PDB source spans of
// all types and members for better error reporting by WinMDExp.
nativePdbWriterOpt.WriteDefinitionLocations(mdWriter.Module.GetSymbolToLocationMap());
}
else
{
#if DEBUG
// validate that all definitions are writable
// if same scenario would happen in an winmdobj project
nativePdbWriterOpt.AssertAllDefinitionsHaveTokens(mdWriter.Module.GetSymbolToLocationMap());
#endif
}
}
Stream peStream = getPeStream();
if (peStream == null)
{
return(false);
}
BlobContentId pdbContentId = nativePdbWriterOpt?.GetContentId() ?? default(BlobContentId);
// the writer shall not be used after this point for writing:
nativePdbWriterOpt = null;
ushort portablePdbVersion = 0;
var metadataSerializer = mdWriter.GetTypeSystemMetadataSerializer();
var peHeaderBuilder = new PEHeaderBuilder(
machine: properties.Machine,
sectionAlignment: properties.SectionAlignment,
fileAlignment: properties.FileAlignment,
imageBase: properties.BaseAddress,
majorLinkerVersion: properties.LinkerMajorVersion,
minorLinkerVersion: properties.LinkerMinorVersion,
majorOperatingSystemVersion: 4,
minorOperatingSystemVersion: 0,
majorImageVersion: 0,
minorImageVersion: 0,
majorSubsystemVersion: properties.MajorSubsystemVersion,
minorSubsystemVersion: properties.MinorSubsystemVersion,
subsystem: properties.Subsystem,
dllCharacteristics: properties.DllCharacteristics,
imageCharacteristics: properties.ImageCharacteristics,
sizeOfStackReserve: properties.SizeOfStackReserve,
sizeOfStackCommit: properties.SizeOfStackCommit,
sizeOfHeapReserve: properties.SizeOfHeapReserve,
sizeOfHeapCommit: properties.SizeOfHeapCommit);
var deterministicIdProvider = isDeterministic ?
new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeSha1(content))) :
null;
if (mdWriter.EmitStandaloneDebugMetadata)
{
Debug.Assert(getPortablePdbStreamOpt != null);
var debugMetadataBuilder = new BlobBuilder();
var debugMetadataSerializer = mdWriter.GetStandaloneDebugMetadataSerializer(metadataSerializer.MetadataSizes, debugEntryPointHandle, deterministicIdProvider);
debugMetadataSerializer.SerializeMetadata(debugMetadataBuilder, out pdbContentId);
portablePdbVersion = debugMetadataSerializer.FormatVersion;
// write to Portable PDB stream:
Stream portablePdbStream = getPortablePdbStreamOpt();
if (portablePdbStream != null)
{
debugMetadataBuilder.WriteContentTo(portablePdbStream);
}
}
DebugDirectoryBuilder debugDirectoryBuilder;
if (pdbPathOpt != null || isDeterministic)
{
debugDirectoryBuilder = new DebugDirectoryBuilder();
if (pdbPathOpt != null)
{
string paddedPath = isDeterministic ? pdbPathOpt : PadPdbPath(pdbPathOpt);
debugDirectoryBuilder.AddCodeViewEntry(paddedPath, pdbContentId, portablePdbVersion);
}
if (isDeterministic)
{
debugDirectoryBuilder.AddReproducibleEntry();
}
}
else
{
debugDirectoryBuilder = null;
}
var peBuilder = new ManagedPEBuilder(
peHeaderBuilder,
metadataSerializer,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
CreateNativeResourceSectionSerializer(context.Module),
debugDirectoryBuilder,
CalculateStrongNameSignatureSize(context.Module),
entryPointHandle,
properties.CorFlags,
deterministicIdProvider);
var peBlob = new BlobBuilder();
BlobContentId peContentId;
peBuilder.Serialize(peBlob, out peContentId);
// Patch MVID
if (!mvidFixup.IsDefault)
{
var writer = new BlobWriter(mvidFixup);
writer.WriteGuid(peContentId.Guid);
Debug.Assert(writer.RemainingBytes == 0);
}
try
{
peBlob.WriteContentTo(peStream);
}
catch (Exception e) when(!(e is OperationCanceledException))
{
throw new PeWritingException(e);
}
return(true);
}
public Cci.IDefinition AsDefinition(EmitContext context)
{
return(null);
}
public abstract Cci.ITypeReference GetType(EmitContext context);
public virtual Cci.ITypeReference GetType(EmitContext context)
=> context.Module.GetPlatformType(Cci.PlatformType.SystemInt32, context);
public override Cci.ITypeReference GetType(EmitContext context)
=> context.Module.GetPlatformType(Cci.PlatformType.SystemVoid, context);
public Cci.IDefinition AsDefinition(EmitContext context)
{
return null;
}
IEnumerable<ICustomAttribute> IReference.GetAttributes(EmitContext context)
{
return SpecializedCollections.EmptyEnumerable<ICustomAttribute>();
}
PrimitiveTypeCode ITypeReference.TypeCode(EmitContext context)
{
return PrimitiveTypeCode.NotPrimitive;
}
ITypeDefinition ITypeReference.GetResolvedType(EmitContext context)
{
throw ExceptionUtilities.Unreachable;
}
public IMetadataConstant GetDefaultValue(EmitContext context)
{
return(null);
}
public virtual Cci.ITypeReference GetType(EmitContext context)
{
return(context.Module.GetPlatformType(Cci.PlatformType.SystemInt32, context));
}
public override Cci.ITypeReference GetType(EmitContext context)
=> _arrayType.GetElementType(context);
public Cci.IMethodDefinition GetResolvedMethod(EmitContext context)
{
return(null);
}
public abstract Cci.ITypeReference GetType(EmitContext context);
INamespaceTypeDefinition ITypeReference.AsNamespaceTypeDefinition(EmitContext context)
{
return(null);
}
public ImmutableArray<Cci.IParameterTypeInformation> GetParameters(EmitContext context)
=> StaticCast<Cci.IParameterTypeInformation>.From(_parameters);
public IEnumerable <INestedTypeDefinition> GetNestedTypes(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <INestedTypeDefinition>());
}
public Cci.IMethodDefinition GetResolvedMethod(EmitContext context) => null;
INestedTypeDefinition?ITypeReference.AsNestedTypeDefinition(EmitContext context)
{
return(null);
}
public Cci.ITypeReference GetContainingType(EmitContext context)
{
// We are not translating arrayType.
// It is an array type and it is never generic or contained in a generic.
return this.arrayType;
}
public IEnumerable <ICustomAttribute> GetAttributes(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <ICustomAttribute>());
}
public IEnumerable<Cci.ICustomAttribute> GetAttributes(EmitContext context)
=> SpecializedCollections.EmptyEnumerable<Cci.ICustomAttribute>();
public IEnumerable <IFieldDefinition> GetFields(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <IFieldDefinition>());
}
public Cci.IDefinition AsDefinition(EmitContext context)
=> null;
public IEnumerable <ICustomAttribute> GetAttributes(EmitContext context)
{
return(_containingMethod.ReturnValueAttributes);
}
public ITypeReference GetType(EmitContext context)
{
return this.containingMethod.GetType(context);
}
public override Cci.ITypeReference GetType(EmitContext context)
{
return(context.Module.GetPlatformType(Cci.PlatformType.SystemVoid, context));
}
public IEnumerable<ICustomAttribute> GetAttributes(EmitContext context)
{
return this.containingMethod.ReturnValueAttributes;
}
public override Cci.ITypeReference GetType(EmitContext context)
{
return(_arrayType.GetElementType(context));
}
public IMetadataConstant GetDefaultValue(EmitContext context)
{
return null;
}
public ImmutableArray <Cci.IParameterTypeInformation> GetParameters(EmitContext context)
{
return(StaticCast <Cci.IParameterTypeInformation> .From(_parameters));
}
public INamespaceTypeDefinition AsNamespaceTypeDefinition(EmitContext context)
{
return this as INamespaceTypeDefinition;
}
public Cci.ITypeReference GetContainingType(EmitContext context)
{
// We are not translating arrayType.
// It is an array type and it is never generic or contained in a generic.
return(this.arrayType);
}
public INestedTypeDefinition AsNestedTypeDefinition(EmitContext context)
{
return this as INestedTypeDefinition;
}
IDefinition?IReference.AsDefinition(EmitContext context)
{
return(null);
}
public ITypeDefinition AsTypeDefinition(EmitContext context)
{
return this as ITypeDefinition;
}
ITypeDefinition ITypeReference.GetResolvedType(EmitContext context)
{
throw ExceptionUtilities.Unreachable;
}
public IDefinition AsDefinition(EmitContext context)
{
return this as IDefinition;
}
/// <summary>
/// Returns a reference to the unit that defines the given referenced type. If the referenced type is a structural type, such as a pointer or a generic type instance,
/// then the result is null.
/// </summary>
public static IUnitReference/*?*/ GetDefiningUnitReference(ITypeReference typeReference, EmitContext context)
{
INestedTypeReference/*?*/ nestedTypeReference = typeReference.AsNestedTypeReference;
while (nestedTypeReference != null)
{
if (nestedTypeReference.AsGenericTypeInstanceReference != null)
{
return null;
}
typeReference = nestedTypeReference.GetContainingType(context);
nestedTypeReference = typeReference.AsNestedTypeReference;
}
INamespaceTypeReference/*?*/ namespaceTypeReference = typeReference.AsNamespaceTypeReference;
if (namespaceTypeReference == null)
{
return null;
}
Debug.Assert(namespaceTypeReference.AsGenericTypeInstanceReference == null);
return namespaceTypeReference.GetUnit(context);
}
public IEnumerable<ICustomAttribute> GetAttributes(EmitContext context)
{
return this.parentParameter.GetAttributes(context);
}
public IEnumerable <IPropertyDefinition> GetProperties(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <IPropertyDefinition>());
}
public ITypeDefinition GetResolvedType(EmitContext context)
{
throw ExceptionUtilities.Unreachable;
}
IUnitReference INamespaceTypeReference.GetUnit(EmitContext context)
{
throw ExceptionUtilities.Unreachable;
}
public PrimitiveTypeCode TypeCode(EmitContext context)
{
return PrimitiveTypeCode.NotPrimitive;
}
public IEnumerable <IMethodDefinition> GetMethods(EmitContext context)
{
return(_methods ??= SpecializedCollections.EmptyReadOnlyList <IMethodDefinition>());
}
public IEnumerable<ITypeReference> GetConstraints(EmitContext context)
{
return this.parentParameter.GetConstraints(context);
}
IDefinition IReference.AsDefinition(EmitContext context)
{
return(this);
}
public static bool WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Func<Stream> getPeStream,
Func<Stream> getPortablePdbStreamOpt,
PdbWriter nativePdbWriterOpt,
string pdbPathOpt,
bool allowMissingMethodBodies,
bool isDeterministic,
CancellationToken cancellationToken)
{
// If PDB writer is given, we have to have PDB path.
Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null);
var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken);
var properties = context.Module.Properties;
nativePdbWriterOpt?.SetMetadataEmitter(mdWriter);
// Since we are producing a full assembly, we should not have a module version ID
// imposed ahead-of time. Instead we will compute a deterministic module version ID
// based on the contents of the generated stream.
Debug.Assert(properties.PersistentIdentifier == default(Guid));
var ilBuilder = new BlobBuilder(32 * 1024);
var mappedFieldDataBuilder = new BlobBuilder();
var managedResourceBuilder = new BlobBuilder(1024);
Blob mvidFixup;
mdWriter.BuildMetadataAndIL(
nativePdbWriterOpt,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
out mvidFixup);
MethodDefinitionHandle entryPointHandle;
MethodDefinitionHandle debugEntryPointHandle;
mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle);
if (!debugEntryPointHandle.IsNil)
{
nativePdbWriterOpt?.SetEntryPoint((uint)MetadataTokens.GetToken(debugEntryPointHandle));
}
if (nativePdbWriterOpt != null)
{
var assembly = mdWriter.Module.AsAssembly;
if (assembly != null && assembly.Kind == OutputKind.WindowsRuntimeMetadata)
{
// Dev12: If compiling to winmdobj, we need to add to PDB source spans of
// all types and members for better error reporting by WinMDExp.
nativePdbWriterOpt.WriteDefinitionLocations(mdWriter.Module.GetSymbolToLocationMap());
}
else
{
#if DEBUG
// validate that all definitions are writable
// if same scenario would happen in an winmdobj project
nativePdbWriterOpt.AssertAllDefinitionsHaveTokens(mdWriter.Module.GetSymbolToLocationMap());
#endif
}
}
Stream peStream = getPeStream();
if (peStream == null)
{
return false;
}
ContentId nativePdbContentId = nativePdbWriterOpt?.GetContentId() ?? default(ContentId);
// the writer shall not be used after this point for writing:
nativePdbWriterOpt = null;
var metadataSerializer = mdWriter.GetTypeSystemMetadataSerializer();
var peBuilder = new PEBuilder(
machine: properties.Machine,
sectionAlignment: properties.SectionAlignment,
fileAlignment: properties.FileAlignment,
imageBase: properties.BaseAddress,
majorLinkerVersion: properties.LinkerMajorVersion,
minorLinkerVersion: properties.LinkerMinorVersion,
majorOperatingSystemVersion: 4,
minorOperatingSystemVersion: 0,
majorImageVersion: 0,
minorImageVersion: 0,
majorSubsystemVersion: properties.MajorSubsystemVersion,
minorSubsystemVersion: properties.MinorSubsystemVersion,
subsystem: properties.Subsystem,
dllCharacteristics: properties.DllCharacteristics,
imageCharacteristics: properties.ImageCharacteristics,
sizeOfStackReserve: properties.SizeOfStackReserve,
sizeOfStackCommit: properties.SizeOfStackCommit,
sizeOfHeapReserve: properties.SizeOfHeapReserve,
sizeOfHeapCommit: properties.SizeOfHeapCommit,
deterministicIdProvider: isDeterministic ? new Func<BlobBuilder, ContentId>(content => ContentId.FromHash(CryptographicHashProvider.ComputeSha1(content))) : null);
ContentId portablePdbContentId;
if (mdWriter.EmitStandaloneDebugMetadata)
{
Debug.Assert(getPortablePdbStreamOpt != null);
var debugMetadataBuilder = new BlobBuilder();
var debugMetadataSerializer = mdWriter.GetStandaloneDebugMetadataSerializer(metadataSerializer.MetadataSizes, debugEntryPointHandle);
debugMetadataSerializer.SerializeMetadata(debugMetadataBuilder, peBuilder.IdProvider, out portablePdbContentId);
// write to Portable PDB stream:
Stream portablePdbStream = getPortablePdbStreamOpt();
if (portablePdbStream != null)
{
debugMetadataBuilder.WriteContentTo(portablePdbStream);
}
}
else
{
portablePdbContentId = default(ContentId);
}
var peDirectoriesBuilder = new PEDirectoriesBuilder();
peBuilder.AddManagedSections(
peDirectoriesBuilder,
metadataSerializer,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
CreateNativeResourceSectionSerializer(context.Module),
CalculateStrongNameSignatureSize(context.Module),
entryPointHandle,
pdbPathOpt,
nativePdbContentId,
portablePdbContentId,
properties.CorFlags);
var peBlob = new BlobBuilder();
ContentId peContentId;
peBuilder.Serialize(peBlob, peDirectoriesBuilder, out peContentId);
// Patch MVID
if (!mvidFixup.IsDefault)
{
var mvidWriter = new BlobWriter(mvidFixup);
mvidWriter.WriteBytes(peContentId.Guid);
Debug.Assert(mvidWriter.RemainingBytes == 0);
}
try
{
peBlob.WriteContentTo(peStream);
}
catch (Exception e) when (!(e is OperationCanceledException))
{
throw new PeWritingException(e);
}
return true;
}
public ITypeReference?GetBaseClass(EmitContext context)
{
return(null);
}
internal ReferenceIndexerBase(EmitContext context)
: base(context)
{
}
public IEnumerable <MethodImplementation> GetExplicitImplementationOverrides(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <MethodImplementation>());
}
internal NoPiaReferenceIndexer(EmitContext context)
: base(context)
{
this.module = context.Module;
}
public IEnumerable <Cci.TypeReferenceWithAttributes> Interfaces(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <Cci.TypeReferenceWithAttributes>());
}
public IDefinition AsDefinition(EmitContext context)
{
return(this as IDefinition);
}
