public Args(string peFilePath, string pdbFilePathOpt, string outPdbFilePath, PdbConversionOptions options, bool extract, bool verbose)
{
PEFilePath = peFilePath;
PdbFilePathOpt = pdbFilePathOpt;
OutPdbFilePath = outPdbFilePath;
Options = options;
Extract = extract;
Verbose = verbose;
}
internal void Convert(PEReader peReader, MetadataReader pdbReader, PdbWriter <TDocumentWriter> pdbWriter, PdbConversionOptions options)
{
if (!SymReaderHelpers.TryReadPdbId(peReader, out var pePdbId, out int peAge))
{
throw new InvalidDataException(ConverterResources.SpecifiedPEFileHasNoAssociatedPdb);
}
if (!new BlobContentId(pdbReader.DebugMetadataHeader.Id).Equals(pePdbId))
{
throw new InvalidDataException(ConverterResources.PdbNotMatchingDebugDirectory);
}
string vbDefaultNamespace = MetadataUtilities.GetVisualBasicDefaultNamespace(pdbReader);
bool vbSemantics = vbDefaultNamespace != null;
string vbDefaultNamespaceImportString = string.IsNullOrEmpty(vbDefaultNamespace) ? null : "*" + vbDefaultNamespace;
var metadataReader = peReader.GetMetadataReader();
var metadataModel = new MetadataModel(metadataReader, vbSemantics);
var documentWriters = new ArrayBuilder <TDocumentWriter>(pdbReader.Documents.Count);
var documentNames = new ArrayBuilder <string>(pdbReader.Documents.Count);
var symSequencePointBuilder = new SequencePointsBuilder(capacity: 64);
var declaredExternAliases = new HashSet <string>();
var importStringsBuilder = new List <string>();
var importGroups = new List <int>();
var cdiBuilder = new BlobBuilder();
var dynamicLocals = new List <(string LocalName, byte[] Flags, int Count, int SlotIndex)>();
var tupleLocals = new List <(string LocalName, int SlotIndex, int ScopeStart, int ScopeEnd, ImmutableArray <string> Names)>();
var openScopeEndOffsets = new Stack <int>();
// state for calculating import string forwarding:
var lastImportScopeHandle = default(ImportScopeHandle);
var vbLastImportScopeNamespace = default(string);
var lastImportScopeMethodDefHandle = default(MethodDefinitionHandle);
var importStringsMap = new Dictionary <ImmutableArray <string>, MethodDefinitionHandle>(SequenceComparer <string> .Instance);
var aliasedAssemblyRefs = GetAliasedAssemblyRefs(pdbReader);
foreach (var documentHandle in pdbReader.Documents)
{
var document = pdbReader.GetDocument(documentHandle);
var languageGuid = pdbReader.GetGuid(document.Language);
var name = pdbReader.GetString(document.Name);
documentNames.Add(name);
documentWriters.Add(pdbWriter.DefineDocument(
name: name,
language: languageGuid,
type: s_documentTypeText,
vendor: GetLanguageVendorGuid(languageGuid),
algorithmId: pdbReader.GetGuid(document.HashAlgorithm),
checksum: pdbReader.GetBlobBytes(document.Hash)));
}
var localScopeEnumerator = pdbReader.LocalScopes.GetEnumerator();
LocalScope?currentLocalScope = NextLocalScope();
LocalScope?NextLocalScope() =>
localScopeEnumerator.MoveNext() ? pdbReader.GetLocalScope(localScopeEnumerator.Current) : default(LocalScope?);
// Handle of the method that is gonna contain list of AssemblyRef aliases.
// Other methods will forward to it.
var methodDefHandleWithAssemblyRefAliases = default(MethodDefinitionHandle);
foreach (var methodDebugInfoHandle in pdbReader.MethodDebugInformation)
{
var methodDebugInfo = pdbReader.GetMethodDebugInformation(methodDebugInfoHandle);
var methodDefHandle = methodDebugInfoHandle.ToDefinitionHandle();
int methodToken = MetadataTokens.GetToken(methodDefHandle);
var methodDef = metadataReader.GetMethodDefinition(methodDefHandle);
#if DEBUG
var declaringTypeDef = metadataReader.GetTypeDefinition(methodDef.GetDeclaringType());
var typeName = metadataReader.GetString(declaringTypeDef.Name);
var methodName = metadataReader.GetString(methodDef.Name);
#endif
bool methodOpened = false;
var methodBodyOpt = (methodDef.RelativeVirtualAddress != 0 && (methodDef.ImplAttributes & MethodImplAttributes.CodeTypeMask) == MethodImplAttributes.Managed) ?
peReader.GetMethodBody(methodDef.RelativeVirtualAddress) : null;
var vbCurrentMethodNamespace = vbSemantics ? GetMethodNamespace(metadataReader, methodDef) : null;
var moveNextHandle = metadataModel.FindStateMachineMoveNextMethod(methodDefHandle, vbSemantics);
bool isKickOffMethod = !moveNextHandle.IsNil;
var forwardImportScopesToMethodDef = default(MethodDefinitionHandle);
Debug.Assert(dynamicLocals.Count == 0);
Debug.Assert(tupleLocals.Count == 0);
Debug.Assert(openScopeEndOffsets.Count == 0);
void LazyOpenMethod()
{
if (!methodOpened)
{
#if DEBUG
Debug.WriteLine($"Open Method '{typeName}::{methodName}' {methodToken:X8}");
#endif
pdbWriter.OpenMethod(methodToken);
methodOpened = true;
}
}
void CloseOpenScopes(int currentScopeStartOffset)
{
// close all open scopes that end before this scope starts:
while (openScopeEndOffsets.Count > 0 && currentScopeStartOffset >= openScopeEndOffsets.Peek())
{
int scopeEnd = openScopeEndOffsets.Pop();
Debug.WriteLine($"Close Scope [.., {scopeEnd})");
// Note that the root scope end is not end-inclusive in VB:
pdbWriter.CloseScope(AdjustEndScopeOffset(scopeEnd, isEndInclusive: vbSemantics && openScopeEndOffsets.Count > 0));
}
}
bool isFirstMethodScope = true;
while (currentLocalScope.HasValue && currentLocalScope.Value.Method == methodDefHandle)
{
// kickoff methods don't have any scopes emitted to Windows PDBs
if (methodBodyOpt == null)
{
ReportDiagnostic(PdbDiagnosticId.MethodAssociatedWithLocalScopeHasNoBody, MetadataTokens.GetToken(localScopeEnumerator.Current));
}
else if (!isKickOffMethod)
{
LazyOpenMethod();
var localScope = currentLocalScope.Value;
CloseOpenScopes(localScope.StartOffset);
Debug.WriteLine($"Open Scope [{localScope.StartOffset}, {localScope.EndOffset})");
pdbWriter.OpenScope(localScope.StartOffset);
openScopeEndOffsets.Push(localScope.EndOffset);
if (isFirstMethodScope)
{
if (lastImportScopeHandle == localScope.ImportScope && vbLastImportScopeNamespace == vbCurrentMethodNamespace)
{
// forward to a method that has the same imports:
forwardImportScopesToMethodDef = lastImportScopeMethodDefHandle;
}
else
{
Debug.Assert(importStringsBuilder.Count == 0);
Debug.Assert(declaredExternAliases.Count == 0);
Debug.Assert(importGroups.Count == 0);
AddImportStrings(importStringsBuilder, importGroups, declaredExternAliases, pdbReader, metadataModel, localScope.ImportScope, aliasedAssemblyRefs, vbDefaultNamespaceImportString, vbCurrentMethodNamespace, vbSemantics);
var importStrings = importStringsBuilder.ToImmutableArray();
importStringsBuilder.Clear();
if (importStringsMap.TryGetValue(importStrings, out forwardImportScopesToMethodDef))
{
// forward to a method that has the same imports:
lastImportScopeMethodDefHandle = forwardImportScopesToMethodDef;
}
else
{
// attach import strings to the current method:
WriteImports(pdbWriter, importStrings);
lastImportScopeMethodDefHandle = methodDefHandle;
importStringsMap[importStrings] = methodDefHandle;
}
lastImportScopeHandle = localScope.ImportScope;
vbLastImportScopeNamespace = vbCurrentMethodNamespace;
}
if (vbSemantics && !forwardImportScopesToMethodDef.IsNil)
{
pdbWriter.UsingNamespace("@" + MetadataTokens.GetToken(forwardImportScopesToMethodDef));
}
// This is the method that's gonna have AssemblyRef aliases attached:
if (methodDefHandleWithAssemblyRefAliases.IsNil)
{
foreach (var(assemblyRefHandle, alias) in aliasedAssemblyRefs)
{
var assemblyRef = metadataReader.GetAssemblyReference(assemblyRefHandle);
pdbWriter.UsingNamespace("Z" + alias + " " + AssemblyDisplayNameBuilder.GetAssemblyDisplayName(metadataReader, assemblyRef));
}
}
}
foreach (var localVariableHandle in localScope.GetLocalVariables())
{
var variable = pdbReader.GetLocalVariable(localVariableHandle);
string name = pdbReader.GetString(variable.Name);
if (name.Length > MaxEntityNameLength)
{
ReportDiagnostic(PdbDiagnosticId.LocalConstantNameTooLong, MetadataTokens.GetToken(localVariableHandle));
continue;
}
if (methodBodyOpt.LocalSignature.IsNil)
{
ReportDiagnostic(PdbDiagnosticId.MethodContainingLocalVariablesHasNoLocalSignature, methodToken);
continue;
}
// TODO: translate hoisted variable scopes to dummy VB hoisted state machine locals (https://github.com/dotnet/roslyn/issues/8473)
pdbWriter.DefineLocalVariable(variable.Index, name, variable.Attributes, MetadataTokens.GetToken(methodBodyOpt.LocalSignature));
var dynamicFlags = MetadataUtilities.ReadDynamicCustomDebugInformation(pdbReader, localVariableHandle);
if (TryGetDynamicLocal(name, variable.Index, dynamicFlags, out var dynamicLocal))
{
dynamicLocals.Add(dynamicLocal);
}
var tupleElementNames = MetadataUtilities.ReadTupleCustomDebugInformation(pdbReader, localVariableHandle);
if (!tupleElementNames.IsDefaultOrEmpty)
{
tupleLocals.Add((name, SlotIndex: variable.Index, ScopeStart: 0, ScopeEnd: 0, Names: tupleElementNames));
}
}
foreach (var localConstantHandle in localScope.GetLocalConstants())
{
var constant = pdbReader.GetLocalConstant(localConstantHandle);
string name = pdbReader.GetString(constant.Name);
if (name.Length > MaxEntityNameLength)
{
ReportDiagnostic(PdbDiagnosticId.LocalConstantNameTooLong, MetadataTokens.GetToken(localConstantHandle));
continue;
}
var(value, signature) = PortableConstantSignature.GetConstantValueAndSignature(pdbReader, localConstantHandle, metadataReader.GetQualifiedTypeName);
if (!metadataModel.TryGetStandaloneSignatureHandle(signature, out var constantSignatureHandle))
{
// Signature will be unspecified. At least we store the name and the value.
constantSignatureHandle = default(StandaloneSignatureHandle);
}
pdbWriter.DefineLocalConstant(name, value, MetadataTokens.GetToken(constantSignatureHandle));
var dynamicFlags = MetadataUtilities.ReadDynamicCustomDebugInformation(pdbReader, localConstantHandle);
if (TryGetDynamicLocal(name, 0, dynamicFlags, out var dynamicLocal))
{
dynamicLocals.Add(dynamicLocal);
}
var tupleElementNames = MetadataUtilities.ReadTupleCustomDebugInformation(pdbReader, localConstantHandle);
if (!tupleElementNames.IsDefaultOrEmpty)
{
// Note that the end offset of tuple locals is always end-exclusive, regardless of whether the PDB uses VB semantics or not.
tupleLocals.Add((name, SlotIndex: -1, ScopeStart: localScope.StartOffset, ScopeEnd: localScope.EndOffset, Names: tupleElementNames));
}
}
}
currentLocalScope = NextLocalScope();
isFirstMethodScope = false;
}
bool hasAnyScopes = !isFirstMethodScope;
CloseOpenScopes(int.MaxValue);
if (openScopeEndOffsets.Count > 0)
{
ReportDiagnostic(PdbDiagnosticId.LocalScopeRangesNestingIsInvalid, methodToken);
openScopeEndOffsets.Clear();
}
if (!methodDebugInfo.SequencePointsBlob.IsNil)
{
LazyOpenMethod();
WriteSequencePoints(pdbWriter, documentWriters, symSequencePointBuilder, methodDebugInfo.GetSequencePoints(), methodToken);
}
// async method data:
var asyncData = MetadataUtilities.ReadAsyncMethodData(pdbReader, methodDebugInfoHandle);
if (!asyncData.IsNone)
{
LazyOpenMethod();
pdbWriter.SetAsyncInfo(
moveNextMethodToken: methodToken,
kickoffMethodToken: MetadataTokens.GetToken(asyncData.KickoffMethod),
catchHandlerOffset: asyncData.CatchHandlerOffset,
yieldOffsets: asyncData.YieldOffsets.ToArray(),
resumeOffsets: asyncData.ResumeOffsets.ToArray());
}
// custom debug information:
var cdiEncoder = new CustomDebugInfoEncoder(cdiBuilder);
if (isKickOffMethod)
{
cdiEncoder.AddStateMachineTypeName(GetIteratorTypeName(metadataReader, moveNextHandle));
}
else
{
if (!vbSemantics && hasAnyScopes)
{
if (forwardImportScopesToMethodDef.IsNil)
{
// record the number of import strings in each scope:
cdiEncoder.AddUsingGroups(importGroups);
if (!methodDefHandleWithAssemblyRefAliases.IsNil)
{
// forward assembly ref aliases to the first method:
cdiEncoder.AddForwardModuleInfo(methodDefHandleWithAssemblyRefAliases);
}
}
else
{
// forward all imports to another method:
cdiEncoder.AddForwardMethodInfo(forwardImportScopesToMethodDef);
}
}
var hoistedLocalScopes = GetStateMachineHoistedLocalScopes(pdbReader, methodDefHandle);
if (!hoistedLocalScopes.IsDefault)
{
cdiEncoder.AddStateMachineHoistedLocalScopes(hoistedLocalScopes);
}
if (dynamicLocals.Count > 0)
{
cdiEncoder.AddDynamicLocals(dynamicLocals);
dynamicLocals.Clear();
}
if (tupleLocals.Count > 0)
{
cdiEncoder.AddTupleElementNames(tupleLocals);
tupleLocals.Clear();
}
}
importGroups.Clear();
// the following blobs map 1:1
CopyCustomDebugInfoRecord(ref cdiEncoder, pdbReader, methodDefHandle, PortableCustomDebugInfoKinds.EncLocalSlotMap, CustomDebugInfoKind.EditAndContinueLocalSlotMap);
CopyCustomDebugInfoRecord(ref cdiEncoder, pdbReader, methodDefHandle, PortableCustomDebugInfoKinds.EncLambdaAndClosureMap, CustomDebugInfoKind.EditAndContinueLambdaMap);
if (cdiEncoder.RecordCount > 0)
{
LazyOpenMethod();
pdbWriter.DefineCustomMetadata(cdiEncoder.ToArray());
}
cdiBuilder.Clear();
if (methodOpened && aliasedAssemblyRefs.Length > 0 && !isKickOffMethod && methodDefHandleWithAssemblyRefAliases.IsNil)
{
methodDefHandleWithAssemblyRefAliases = methodDefHandle;
}
if (methodOpened)
{
Debug.WriteLine($"Close Method {methodToken:X8}");
pdbWriter.CloseMethod();
}
}
if (!pdbReader.DebugMetadataHeader.EntryPoint.IsNil)
{
pdbWriter.SetEntryPoint(MetadataTokens.GetToken(pdbReader.DebugMetadataHeader.EntryPoint));
}
var sourceLinkHandle = pdbReader.GetCustomDebugInformation(EntityHandle.ModuleDefinition, PortableCustomDebugInfoKinds.SourceLink);
if (!sourceLinkHandle.IsNil)
{
if ((options & PdbConversionOptions.SuppressSourceLinkConversion) == 0)
{
ConvertSourceServerData(pdbReader.GetStringUTF8(sourceLinkHandle), pdbWriter, documentNames);
}
else
{
pdbWriter.SetSourceLinkData(pdbReader.GetBlobBytes(sourceLinkHandle));
}
}
SymReaderHelpers.GetWindowsPdbSignature(pdbReader.DebugMetadataHeader.Id, out var guid, out var stamp, out var age);
pdbWriter.UpdateSignature(guid, stamp, age);
}
private void ConvertPortableToWindows(
ITaskItem file,
PdbConverter converter,
PdbConversionOptions parsedConversionOptions)
{
string pdbPath = file.GetMetadata(PdbPathMetadata);
if (string.IsNullOrEmpty(pdbPath))
{
Log.LogError($"No '{PdbPathMetadata}' metadata found for '{file}'.");
return;
}
string targetPath = file.GetMetadata(TargetPathMetadata);
if (string.IsNullOrEmpty(targetPath))
{
Log.LogError($"No '{TargetPathMetadata}' metadata found for '{file}'.");
return;
}
using (var sourcePdbStream = new FileStream(pdbPath, FileMode.Open, FileAccess.Read))
{
if (PdbConverter.IsPortable(sourcePdbStream))
{
Log.LogMessage(
MessageImportance.Low,
$"Converting portable PDB '{file.ItemSpec}'...");
Directory.CreateDirectory(Path.GetDirectoryName(targetPath));
using (var peStream = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read))
using (var peReader = new PEReader(peStream, PEStreamOptions.LeaveOpen))
{
if (peReader.ReadDebugDirectory().Length > 0)
{
using (var outPdbStream = new FileStream(targetPath, FileMode.Create, FileAccess.Write))
{
converter.ConvertPortableToWindows(
peReader,
sourcePdbStream,
outPdbStream,
parsedConversionOptions);
}
Log.LogMessage(
MessageImportance.Normal,
$"Portable PDB '{file.ItemSpec}' -> '{targetPath}'");
}
else
{
Log.LogWarning($"'{file.ItemSpec}' {NoDebugDirectoryEntriesMessage}");
}
}
}
else
{
Log.LogMessage(
MessageImportance.Normal,
$"PDB is not portable, skipping: '{file.ItemSpec}'");
}
}
}
/// <summary>
/// Converts Portable PDB stream to Windows PDB.
/// </summary>
/// <param name="peReader">PE reader.</param>
/// <param name="pdbReader">Portable PDB reader.</param>
/// <param name="pdbWriter">PDB writer.</param>
/// <param name="options">Conversion options.</param>
/// <exception cref="ArgumentNullException"><paramref name="peReader"/>, <paramref name="pdbReader"/>, or <paramref name="pdbWriter"/> is null.</exception>
/// <exception cref="BadImageFormatException">The format of the PE image or the source PDB image is invalid.</exception>
/// <exception cref="InvalidDataException">The PDB doesn't match the CodeView Debug Directory record in the PE image.</exception>
/// <exception cref="IOException">IO error while reading from or writing to a stream.</exception>
public void ConvertPortableToWindows <TDocumentWriter>(PEReader peReader, MetadataReader pdbReader, PdbWriter <TDocumentWriter> pdbWriter, PdbConversionOptions options)
{
new PdbConverterPortableToWindows <TDocumentWriter>(_diagnosticReporterOpt).Convert(
peReader ?? throw new ArgumentNullException(nameof(peReader)),
pdbReader ?? throw new ArgumentNullException(nameof(pdbReader)),
pdbWriter ?? throw new ArgumentNullException(nameof(pdbWriter)),
options);
}
/// <summary>
/// Converts Portable PDB to Windows PDB.
/// </summary>
/// <param name="peReader">PE reader.</param>
/// <param name="pdbReader">Portable PDB reader.</param>
/// <param name="targetPdbStream">Target stream of Windows PDB data. Must be writable.</param>
/// <param name="options">Conversion options.</param>
/// <exception cref="ArgumentNullException"><paramref name="peReader"/>, <paramref name="pdbReader"/>, or <paramref name="targetPdbStream"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="targetPdbStream"/> does not support writing.</exception>
/// <exception cref="BadImageFormatException">The format of the PE image or the source PDB image is invalid.</exception>
/// <exception cref="InvalidDataException">The PDB doesn't match the CodeView Debug Directory record in the PE image.</exception>
/// <exception cref="IOException">IO error while reading from or writing to a stream.</exception>
/// <exception cref="ObjectDisposedException">Stream has been disposed while reading/writing.</exception>
public void ConvertPortableToWindows(PEReader peReader, MetadataReader pdbReader, Stream targetPdbStream, PdbConversionOptions options = default(PdbConversionOptions))
{
if (pdbReader == null)
{
throw new ArgumentNullException(nameof(pdbReader));
}
StreamUtilities.ValidateStream(targetPdbStream, nameof(targetPdbStream), writeRequired: true);
using (var pdbWriter = new SymUnmanagedWriter(peReader.GetMetadataReader()))
{
ConvertPortableToWindows(peReader, pdbReader, pdbWriter, options);
pdbWriter.WriteTo(targetPdbStream);
}
}
/// <summary>
/// Converts Portable PDB stream to Windows PDB.
/// </summary>
/// <param name="peReader">PE reader.</param>
/// <param name="sourcePdbStream">Source stream of Portable PDB data. Must be readable.</param>
/// <param name="targetPdbStream">Target stream of Windows PDB data. Must be writable.</param>
/// <param name="options">Conversion options.</param>
/// <exception cref="ArgumentNullException"><paramref name="peReader"/>, <paramref name="sourcePdbStream"/>, or <paramref name="targetPdbStream"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="sourcePdbStream"/> does not support reading.</exception>
/// <exception cref="ArgumentException"><paramref name="targetPdbStream"/> does not support writing.</exception>
/// <exception cref="BadImageFormatException">The format of the PE image or the source PDB image is invalid.</exception>
/// <exception cref="InvalidDataException">The PDB doesn't match the CodeView Debug Directory record in the PE image.</exception>
/// <exception cref="IOException">IO error while reading from or writing to a stream.</exception>
/// <exception cref="ObjectDisposedException">Stream has been disposed while reading/writing.</exception>
public void ConvertPortableToWindows(PEReader peReader, Stream sourcePdbStream, Stream targetPdbStream, PdbConversionOptions options = default(PdbConversionOptions))
{
StreamUtilities.ValidateStream(sourcePdbStream, nameof(sourcePdbStream), readRequired: true);
using (var pdbReaderProvider = MetadataReaderProvider.FromPortablePdbStream(sourcePdbStream, MetadataStreamOptions.LeaveOpen))
{
ConvertPortableToWindows(peReader, pdbReaderProvider.GetMetadataReader(), targetPdbStream, options);
}
}
/// <summary>
/// Converts Portable PDB stream to Windows PDB.
/// </summary>
/// <param name="peStream">PE image stream (.dll or .exe)</param>
/// <param name="sourcePdbStream">Source stream of Portable PDB data. Must be readable.</param>
/// <param name="targetPdbStream">Target stream of Windows PDB data. Must be writable.</param>
/// <param name="options">Conversion options.</param>
/// <exception cref="ArgumentNullException"><paramref name="peStream"/>, <paramref name="sourcePdbStream"/>, or <paramref name="targetPdbStream"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="peStream"/> does not support read and seek operations.</exception>
/// <exception cref="ArgumentException"><paramref name="sourcePdbStream"/> does not support reading.</exception>
/// <exception cref="ArgumentException"><paramref name="targetPdbStream"/> does not support writing.</exception>
/// <exception cref="BadImageFormatException">The format of the PE image or the source PDB image is invalid.</exception>
/// <exception cref="InvalidDataException">The PDB doesn't match the CodeView Debug Directory record in the PE image.</exception>
/// <exception cref="IOException">IO error while reading from or writing to a stream.</exception>
/// <exception cref="ObjectDisposedException">Stream has been disposed while reading/writing.</exception>
public void ConvertPortableToWindows(Stream peStream, Stream sourcePdbStream, Stream targetPdbStream, PdbConversionOptions options = default(PdbConversionOptions))
{
StreamUtilities.ValidateStream(peStream, nameof(peStream), readRequired: true, seekRequired: true);
using (var peReader = new PEReader(peStream, PEStreamOptions.LeaveOpen))
{
ConvertPortableToWindows(peReader, sourcePdbStream, targetPdbStream, options);
}
}
