public static MetadataWriter Create(
EmitContext context,
CommonMessageProvider messageProvider,
bool metadataOnly,
bool deterministic,
bool emitTestCoverageData,
bool hasPdbStream,
CancellationToken cancellationToken)
{
var builder = new MetadataBuilder();
MetadataBuilder debugBuilderOpt;
switch (context.Module.DebugInformationFormat)
{
case DebugInformationFormat.PortablePdb:
debugBuilderOpt = hasPdbStream ? new MetadataBuilder() : null;
break;
case DebugInformationFormat.Embedded:
debugBuilderOpt = metadataOnly ? null : new MetadataBuilder();
break;
default:
debugBuilderOpt = null;
break;
}
var dynamicAnalysisDataWriterOpt = emitTestCoverageData ?
new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) :
null;
return(new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, metadataOnly, deterministic,
emitTestCoverageData, cancellationToken));
}
/// <summary>
/// When emitting ref assemblies, some members will not be included.
/// </summary>
public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext context)
{
if (context.IncludePrivateMembers)
{
return(true);
}
var method = member as IMethodDefinition;
if (method != null && method.IsVirtual)
{
return(true);
}
switch (member.Visibility)
{
case TypeMemberVisibility.Private:
return(context.IncludePrivateMembers);
case TypeMemberVisibility.Assembly:
case TypeMemberVisibility.FamilyAndAssembly:
return(context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true);
}
return(true);
}
private FullMetadataWriter(
EmitContext context,
MetadataBuilder builder,
MetadataBuilder debugBuilderOpt,
DynamicAnalysisDataWriter dynamicAnalysisDataWriterOpt,
CommonMessageProvider messageProvider,
bool metadataOnly,
bool deterministic,
bool emitTestCoverageData,
CancellationToken cancellationToken)
: base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, metadataOnly, deterministic,
emitTestCoverageData, 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;
_typeDefs = new DefinitionIndex <ITypeDefinition>(numTypeDefsGuess);
_eventDefs = new DefinitionIndex <IEventDefinition>(0);
_fieldDefs = new DefinitionIndex <IFieldDefinition>(numFieldDefsGuess);
_methodDefs = new DefinitionIndex <IMethodDefinition>(numMethods);
_propertyDefs = new DefinitionIndex <IPropertyDefinition>(numPropertyDefsGuess);
_parameterDefs = new DefinitionIndex <IParameterDefinition>(numMethods);
_genericParameters = new DefinitionIndex <IGenericParameter>(0);
_fieldDefIndex = new Dictionary <ITypeDefinition, int>(numTypeDefsGuess);
_methodDefIndex = new Dictionary <ITypeDefinition, int>(numTypeDefsGuess);
_parameterListIndex = new Dictionary <IMethodDefinition, int>(numMethods);
_assemblyRefIndex = new HeapOrReferenceIndex <AssemblyIdentity>(this);
_moduleRefIndex = new HeapOrReferenceIndex <string>(this);
_memberRefIndex = new InstanceAndStructuralReferenceIndex <ITypeMemberReference>(this, new MemberRefComparer(this));
_methodSpecIndex = new InstanceAndStructuralReferenceIndex <IGenericMethodInstanceReference>(this, new MethodSpecComparer(this));
_typeRefIndex = new HeapOrReferenceIndex <ITypeReference>(this);
_typeSpecIndex = new InstanceAndStructuralReferenceIndex <ITypeReference>(this, new TypeSpecComparer(this));
_standAloneSignatureIndex = new HeapOrReferenceIndex <BlobHandle>(this);
}
internal TypeReferenceIndexer(EmitContext context)
: base(context)
{
}
internal ReferenceIndexerBase(EmitContext context)
: base(context)
{
}
internal static bool WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Func <Stream> getPeStream,
Func <Stream> getPortablePdbStreamOpt,
PdbWriter nativePdbWriterOpt,
string pdbPathOpt,
bool metadataOnly,
bool isDeterministic,
bool emitTestCoverageData,
RSAParameters?privateKeyOpt,
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, metadataOnly, isDeterministic,
emitTestCoverageData, getPortablePdbStreamOpt != null, cancellationToken);
var properties = context.Module.SerializationProperties;
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, mvidStringFixup;
mdWriter.BuildMetadataAndIL(
nativePdbWriterOpt,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
out mvidFixup,
out mvidStringFixup);
MethodDefinitionHandle entryPointHandle;
MethodDefinitionHandle debugEntryPointHandle;
mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle);
if (!debugEntryPointHandle.IsNil)
{
nativePdbWriterOpt?.SetEntryPoint(MetadataTokens.GetToken(debugEntryPointHandle));
}
if (nativePdbWriterOpt != null)
{
if (context.Module.SourceLinkStreamOpt != null)
{
nativePdbWriterOpt.EmbedSourceLink(context.Module.SourceLinkStreamOpt);
}
#if DEBUG
// validate that all definitions are writable
// if same scenario would happen in an winmdobj project
nativePdbWriterOpt.AssertAllDefinitionsHaveTokens(mdWriter.Module.GetSymbolToLocationMap());
#endif
nativePdbWriterOpt.WriteRemainingEmbeddedDocuments(mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments);
}
Stream peStream = getPeStream();
if (peStream == null)
{
return(false);
}
BlobContentId pdbContentId = nativePdbWriterOpt?.GetContentId() ?? default;
// the writer shall not be used after this point for writing:
nativePdbWriterOpt = null;
ushort portablePdbVersion = 0;
var metadataRootBuilder = mdWriter.GetRootBuilder();
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);
// TODO: replace SHA1 with non-crypto alg: https://github.com/dotnet/roslyn/issues/24737
var peIdProvider = isDeterministic ?
new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeHash(HashAlgorithmName.SHA1, content))) :
null;
// We need to calculate the PDB checksum, so we may as well use the calculated hash for PDB ID regardless of whether deterministic build is requested.
var portablePdbContentHash = default(ImmutableArray <byte>);
BlobBuilder portablePdbToEmbed = null;
if (mdWriter.EmitPortableDebugMetadata)
{
mdWriter.AddRemainingEmbeddedDocuments(mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments);
// The algorithm must be specified for deterministic builds (checked earlier).
Debug.Assert(!isDeterministic || context.Module.PdbChecksumAlgorithm.Name != null);
var portablePdbIdProvider = (context.Module.PdbChecksumAlgorithm.Name != null) ?
new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(portablePdbContentHash = CryptographicHashProvider.ComputeHash(context.Module.PdbChecksumAlgorithm, content))) :
null;
var portablePdbBlob = new BlobBuilder();
var portablePdbBuilder = mdWriter.GetPortablePdbBuilder(metadataRootBuilder.Sizes.RowCounts, debugEntryPointHandle, portablePdbIdProvider);
pdbContentId = portablePdbBuilder.Serialize(portablePdbBlob);
portablePdbVersion = portablePdbBuilder.FormatVersion;
if (getPortablePdbStreamOpt == null)
{
// embed to debug directory:
portablePdbToEmbed = portablePdbBlob;
}
else
{
// write to Portable PDB stream:
Stream portablePdbStream = getPortablePdbStreamOpt();
if (portablePdbStream != null)
{
try
{
portablePdbBlob.WriteContentTo(portablePdbStream);
}
catch (Exception e) when(!(e is OperationCanceledException))
{
throw new SymUnmanagedWriterException(e.Message, e);
}
}
}
}
DebugDirectoryBuilder debugDirectoryBuilder;
if (pdbPathOpt != null || isDeterministic || portablePdbToEmbed != null)
{
debugDirectoryBuilder = new DebugDirectoryBuilder();
if (pdbPathOpt != null)
{
string paddedPath = isDeterministic ? pdbPathOpt : PadPdbPath(pdbPathOpt);
debugDirectoryBuilder.AddCodeViewEntry(paddedPath, pdbContentId, portablePdbVersion);
if (!portablePdbContentHash.IsDefault)
{
// Emit PDB Checksum entry for Portable and Embedded PDBs. The checksum is not as useful when the PDB is embedded,
// however it allows the client to efficiently validate a standalone Portable PDB that
// has been extracted from Embedded PDB and placed next to the PE file.
debugDirectoryBuilder.AddPdbChecksumEntry(context.Module.PdbChecksumAlgorithm.Name, portablePdbContentHash);
}
}
if (isDeterministic)
{
debugDirectoryBuilder.AddReproducibleEntry();
}
if (portablePdbToEmbed != null)
{
debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(portablePdbToEmbed, portablePdbVersion);
}
}
else
{
debugDirectoryBuilder = null;
}
var strongNameProvider = context.Module.CommonCompilation.Options.StrongNameProvider;
var corFlags = properties.CorFlags;
var peBuilder = new ExtendedPEBuilder(
peHeaderBuilder,
metadataRootBuilder,
ilBuilder,
mappedFieldDataBuilder,
managedResourceBuilder,
CreateNativeResourceSectionSerializer(context.Module),
debugDirectoryBuilder,
CalculateStrongNameSignatureSize(context.Module, privateKeyOpt),
entryPointHandle,
corFlags,
peIdProvider,
metadataOnly && !context.IncludePrivateMembers);
var peBlob = new BlobBuilder();
var peContentId = peBuilder.Serialize(peBlob, out Blob mvidSectionFixup);
PatchModuleVersionIds(mvidFixup, mvidSectionFixup, mvidStringFixup, peContentId.Guid);
if (privateKeyOpt != null && corFlags.HasFlag(CorFlags.StrongNameSigned))
{
strongNameProvider.SignBuilder(peBuilder, peBlob, privateKeyOpt.Value);
}
try
{
peBlob.WriteContentTo(peStream);
}
catch (Exception e) when(!(e is OperationCanceledException))
{
throw new PeWritingException(e);
}
return(true);
}
