public static bool WritePeToStream(
EmitContext context,
CommonMessageProvider messageProvider,
Func <Stream> getPeStream,
PdbWriter nativePdbWriterOpt,
string pdbPathOpt,
bool metadataOnly,
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, 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 (mdWriter.Module.OutputKind == 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
* }
*
* 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);
}
public static DiagnosticDescriptor GetDescriptor(int errorCode, CommonMessageProvider messageProvider)
{
var defaultSeverity = messageProvider.GetSeverity(errorCode);
return(GetOrCreateDescriptor(errorCode, defaultSeverity, messageProvider));
}
private static DiagnosticDescriptor GetOrCreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider)
{
DiagnosticDescriptor result;
if (!s_errorCodeToDescriptorMap.TryGetValue(errorCode, out result))
{
result = CreateDescriptor(errorCode, defaultSeverity, messageProvider);
s_errorCodeToDescriptorMap.Add(errorCode, result);
}
return(result);
}
public DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode, params object[] arguments)
: this(messageProvider, errorCode)
{
_arguments = arguments;
}
private static DiagnosticDescriptor CreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider)
{
var id = messageProvider.GetIdForErrorCode(errorCode);
var title = messageProvider.GetTitle(errorCode);
var description = messageProvider.GetDescription(errorCode);
var messageFormat = messageProvider.GetMessageFormat(errorCode);
var helpLink = messageProvider.GetHelpLink(errorCode);
var category = messageProvider.GetCategory(errorCode);
var customTags = GetCustomTags(defaultSeverity);
return(new DiagnosticDescriptor(id, title, messageFormat, category, defaultSeverity,
isEnabledByDefault: true, description: description, helpLinkUri: helpLink, customTags: customTags));
}
public void ValidateOptions(List <Diagnostic> builder, CommonMessageProvider messageProvider)
{
}
public static Diagnostic Create(CommonMessageProvider messageProvider, int errorCode, params object[] arguments)
{
return(Create(new DiagnosticInfo(messageProvider, errorCode, arguments)));
}
public static Diagnostic Create(CommonMessageProvider messageProvider, int errorCode)
{
return(Create(new DiagnosticInfo(messageProvider, errorCode)));
}
