public void FromHash()
{
var id1 = BlobContentId.FromHash(ImmutableArray.Create <byte>(
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20));
AssertEx.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x48, 0x89, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 }, id1.Guid.ToByteArray());
Assert.Equal(0x94131211u, id1.Stamp);
var id2 = BlobContentId.FromHash(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
AssertEx.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, id2.Guid.ToByteArray());
Assert.Equal(0x80000000u, id2.Stamp);
var id3 = BlobContentId.FromHash(new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff });
AssertEx.Equal(new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4f, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, id3.Guid.ToByteArray());
Assert.Equal(0xffffffffu, id3.Stamp);
Assert.Throws <ArgumentNullException>(() => BlobContentId.FromHash(default(ImmutableArray <byte>)));
Assert.Throws <ArgumentNullException>(() => BlobContentId.FromHash(null));
AssertExtensions.Throws <ArgumentException>("hashCode", () => BlobContentId.FromHash(new byte[0]));
AssertExtensions.Throws <ArgumentException>("hashCode", () => BlobContentId.FromHash(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }));
}
public void EmitPortableExecutable()
{
bool succeeded = false;
try
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
PEHeaderBuilder headerBuilder;
int? timeDateStamp;
ISymbolNode r2rHeaderExportSymbol;
Func <IEnumerable <Blob>, BlobContentId> peIdProvider = null;
if (_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode && _componentModule == null)
{
headerBuilder = PEHeaderProvider.Create(
imageCharacteristics: Characteristics.ExecutableImage | Characteristics.Dll,
dllCharacteristics: default(DllCharacteristics),
Subsystem.Unknown,
_nodeFactory.Target);
peIdProvider = new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeSourceHash(content)));
timeDateStamp = null;
r2rHeaderExportSymbol = _nodeFactory.Header;
}
else
{
PEReader inputPeReader = (_componentModule != null ? _componentModule.PEReader : _nodeFactory.CompilationModuleGroup.CompilationModuleSet.First().PEReader);
headerBuilder = PEHeaderProvider.Copy(inputPeReader.PEHeaders, _nodeFactory.Target);
timeDateStamp = inputPeReader.PEHeaders.CoffHeader.TimeDateStamp;
r2rHeaderExportSymbol = null;
}
Func <RuntimeFunctionsTableNode> getRuntimeFunctionsTable = null;
if (_componentModule == null)
{
getRuntimeFunctionsTable = GetRuntimeFunctionsTable;
}
R2RPEBuilder r2rPeBuilder = new R2RPEBuilder(
_nodeFactory.Target,
headerBuilder,
r2rHeaderExportSymbol,
Path.GetFileName(_objectFilePath),
getRuntimeFunctionsTable,
_customPESectionAlignment,
peIdProvider);
NativeDebugDirectoryEntryNode nativeDebugDirectoryEntryNode = null;
ISymbolDefinitionNode firstImportThunk = null;
ISymbolDefinitionNode lastImportThunk = null;
ObjectNode lastWrittenObjectNode = null;
int nodeIndex = -1;
foreach (var depNode in _nodes)
{
++nodeIndex;
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(_nodeFactory))
{
continue;
}
ObjectData nodeContents = node.GetData(_nodeFactory);
if (node is NativeDebugDirectoryEntryNode nddeNode)
{
// There should be only one NativeDebugDirectoryEntry.
Debug.Assert(nativeDebugDirectoryEntryNode == null);
nativeDebugDirectoryEntryNode = nddeNode;
}
if (node is ImportThunk importThunkNode)
{
Debug.Assert(firstImportThunk == null || lastWrittenObjectNode is ImportThunk,
"All the import thunks must be in single contiguous run");
if (firstImportThunk == null)
{
firstImportThunk = importThunkNode;
}
lastImportThunk = importThunkNode;
}
string name = null;
if (_mapFileBuilder != null)
{
name = depNode.GetType().ToString();
int firstGeneric = name.IndexOf('[');
if (firstGeneric < 0)
{
firstGeneric = name.Length;
}
int lastDot = name.LastIndexOf('.', firstGeneric - 1, firstGeneric);
if (lastDot > 0)
{
name = name.Substring(lastDot + 1);
}
}
EmitObjectData(r2rPeBuilder, nodeContents, nodeIndex, name, node.Section);
lastWrittenObjectNode = node;
if ((_generatePdbFile || _generatePerfMapFile) && node is MethodWithGCInfo methodNode)
{
_outputInfoBuilder.AddMethod(methodNode, nodeContents.DefinedSymbols[0]);
}
}
r2rPeBuilder.SetCorHeader(_nodeFactory.CopiedCorHeaderNode, _nodeFactory.CopiedCorHeaderNode.Size);
r2rPeBuilder.SetDebugDirectory(_nodeFactory.DebugDirectoryNode, _nodeFactory.DebugDirectoryNode.Size);
if (firstImportThunk != null)
{
r2rPeBuilder.AddSymbolForRange(_nodeFactory.DelayLoadMethodCallThunks, firstImportThunk, lastImportThunk);
}
if (_nodeFactory.Win32ResourcesNode != null)
{
Debug.Assert(_nodeFactory.Win32ResourcesNode.Size != 0);
r2rPeBuilder.SetWin32Resources(_nodeFactory.Win32ResourcesNode, _nodeFactory.Win32ResourcesNode.Size);
}
using (var peStream = File.Create(_objectFilePath))
{
r2rPeBuilder.Write(peStream, timeDateStamp);
if (_mapFileBuilder != null)
{
_mapFileBuilder.SetFileSize(peStream.Length);
}
// Compute MD5 hash of the output image and store that in the native DebugDirectory entry
using (var md5Hash = MD5.Create())
{
peStream.Seek(0, SeekOrigin.Begin);
byte[] hash = md5Hash.ComputeHash(peStream);
byte[] rsdsEntry = nativeDebugDirectoryEntryNode.GenerateRSDSEntryData(hash);
int offsetToUpdate = r2rPeBuilder.GetSymbolFilePosition(nativeDebugDirectoryEntryNode);
peStream.Seek(offsetToUpdate, SeekOrigin.Begin);
peStream.Write(rsdsEntry);
}
}
if (_outputInfoBuilder != null)
{
r2rPeBuilder.AddSections(_outputInfoBuilder);
if (_generateMapFile)
{
string mapFileName = Path.ChangeExtension(_objectFilePath, ".map");
_mapFileBuilder.SaveMap(mapFileName);
}
if (_generateMapCsvFile)
{
string nodeStatsCsvFileName = Path.ChangeExtension(_objectFilePath, ".nodestats.csv");
string mapCsvFileName = Path.ChangeExtension(_objectFilePath, ".map.csv");
_mapFileBuilder.SaveCsv(nodeStatsCsvFileName, mapCsvFileName);
}
if (_generatePdbFile)
{
string path = _pdbPath;
if (string.IsNullOrEmpty(path))
{
path = Path.GetDirectoryName(_objectFilePath);
}
_symbolFileBuilder.SavePdb(path, _objectFilePath);
}
if (_generatePerfMapFile)
{
string path = _perfMapPath;
if (string.IsNullOrEmpty(path))
{
path = Path.GetDirectoryName(_objectFilePath);
}
_symbolFileBuilder.SavePerfMap(path, _objectFilePath);
}
if (_profileFileBuilder != null)
{
string path = Path.ChangeExtension(_objectFilePath, ".profile");
_profileFileBuilder.SaveProfile(path);
}
}
succeeded = true;
}
finally
{
if (!succeeded)
{
// If there was an exception while generating the OBJ file, make sure we don't leave the unfinished
// object file around.
try
{
File.Delete(_objectFilePath);
}
catch
{
}
}
}
}
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 (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))
{
Debug.Assert(strongNameProvider.Capability == SigningCapability.SignsPeBuilder);
strongNameProvider.SignPeBuilder(peBuilder, peBlob, privateKeyOpt.Value);
}
try
{
peBlob.WriteContentTo(peStream);
}
catch (Exception e) when(!(e is OperationCanceledException))
{
throw new PeWritingException(e);
}
return(true);
}
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 static byte[] MakeRefasm(MetadataReader metaReader, PEReader peReader, LoggerBase logger, IImportFilter filter = null)
{
var metaBuilder = new MetadataBuilder();
var importer = new MetadataImporter(metaReader, metaBuilder, logger);
if (filter != null)
{
importer.Filter = filter;
logger.Info?.Invoke("Using custom entity filter");
}
else if (importer.IsInternalsVisible())
{
importer.Filter = new AllowPublicAndInternals();
logger.Info?.Invoke("InternalsVisibleTo attributes found, using AllowPublicAndInternals entity filter");
}
else
{
importer.Filter = new AllowPublic();
logger.Info?.Invoke("Using AllowPublic entity filter");
}
var mvidBlob = importer.Import();
logger.Debug?.Invoke($"Building reference assembly");
var metaRootBuilder = new MetadataRootBuilder(metaBuilder, metaReader.MetadataVersion, true);
var peHeaderBuilder = new PEHeaderBuilder(
peReader.PEHeaders.CoffHeader.Machine,
peReader.PEHeaders.PEHeader.SectionAlignment,
peReader.PEHeaders.PEHeader.FileAlignment,
peReader.PEHeaders.PEHeader.ImageBase,
peReader.PEHeaders.PEHeader.MajorLinkerVersion,
peReader.PEHeaders.PEHeader.MinorLinkerVersion,
peReader.PEHeaders.PEHeader.MajorOperatingSystemVersion,
peReader.PEHeaders.PEHeader.MinorOperatingSystemVersion,
peReader.PEHeaders.PEHeader.MajorImageVersion,
peReader.PEHeaders.PEHeader.MinorImageVersion,
peReader.PEHeaders.PEHeader.MajorSubsystemVersion,
peReader.PEHeaders.PEHeader.MinorSubsystemVersion,
peReader.PEHeaders.PEHeader.Subsystem,
peReader.PEHeaders.PEHeader.DllCharacteristics,
peReader.PEHeaders.CoffHeader.Characteristics,
peReader.PEHeaders.PEHeader.SizeOfStackReserve,
peReader.PEHeaders.PEHeader.SizeOfStackCommit,
peReader.PEHeaders.PEHeader.SizeOfHeapReserve,
peReader.PEHeaders.PEHeader.SizeOfHeapCommit
);
var ilStream = new BlobBuilder();
var peBuilder = new ManagedPEBuilder(peHeaderBuilder, metaRootBuilder, ilStream,
deterministicIdProvider: blobs =>
{
var hasher = IncrementalHash.CreateHash(HashAlgorithmName.SHA256) ?? throw new Exception("Cannot create hasher");
foreach (var segment in blobs.Select(b => b.GetBytes()))
{
hasher.AppendData(segment.Array, segment.Offset, segment.Count);
}
return(BlobContentId.FromHash(hasher.GetHashAndReset()));
});
var blobBuilder = new BlobBuilder();
var contentId = peBuilder.Serialize(blobBuilder);
mvidBlob.CreateWriter().WriteGuid(contentId.Guid);
return(blobBuilder.ToArray());
}