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))); }