private static void ReadCSharpNativeCustomDebugInfo(
ISymUnmanagedReader reader,
int methodToken,
int methodVersion,
IEnumerable <ISymUnmanagedScope> scopes,
out ImmutableArray <HoistedLocalScopeRecord> hoistedLocalScopeRecords,
out ImmutableDictionary <int, ImmutableArray <bool> > dynamicLocalMap,
out ImmutableDictionary <string, ImmutableArray <bool> > dynamicLocalConstantMap)
{
hoistedLocalScopeRecords = ImmutableArray <HoistedLocalScopeRecord> .Empty;
dynamicLocalMap = ImmutableDictionary <int, ImmutableArray <bool> > .Empty;
dynamicLocalConstantMap = ImmutableDictionary <string, ImmutableArray <bool> > .Empty;
byte[] customDebugInfoBytes = reader.GetCustomDebugInfoBytes(methodToken, methodVersion);
if (customDebugInfoBytes == null)
{
return;
}
var customDebugInfoRecord = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(customDebugInfoBytes, CustomDebugInfoKind.StateMachineHoistedLocalScopes);
if (!customDebugInfoRecord.IsDefault)
{
hoistedLocalScopeRecords = CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(customDebugInfoRecord)
.SelectAsArray(s => new HoistedLocalScopeRecord(s.StartOffset, s.EndOffset - s.StartOffset + 1));
}
CustomDebugInfoReader.GetCSharpDynamicLocalInfo(
customDebugInfoBytes,
methodToken,
methodVersion,
scopes,
out dynamicLocalMap,
out dynamicLocalConstantMap);
}
public unsafe static MethodDebugInfo <TTypeSymbol, TLocalSymbol> ReadMethodDebugInfo(
ISymUnmanagedReader3 symReader,
EESymbolProvider <TTypeSymbol, TLocalSymbol> symbolProviderOpt, // TODO: only null in DTEE case where we looking for default namesapace
int methodToken,
int methodVersion,
int ilOffset,
bool isVisualBasicMethod)
{
// no symbols
if (symReader == null)
{
return(None);
}
if (symReader is ISymUnmanagedReader5 symReader5)
{
int hr = symReader5.GetPortableDebugMetadataByVersion(methodVersion, out byte *metadata, out int size);
ThrowExceptionForHR(hr);
if (hr == S_OK)
{
var mdReader = new MetadataReader(metadata, size);
try
{
return(ReadFromPortable(mdReader, methodToken, ilOffset, symbolProviderOpt, isVisualBasicMethod));
}
catch (BadImageFormatException)
{
// bad CDI, ignore
return(None);
}
}
}
var allScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance();
var containingScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance();
try
{
var symMethod = symReader.GetMethodByVersion(methodToken, methodVersion);
if (symMethod != null)
{
symMethod.GetAllScopes(allScopes, containingScopes, ilOffset, isScopeEndInclusive: isVisualBasicMethod);
}
ImmutableArray <ImmutableArray <ImportRecord> > importRecordGroups;
ImmutableArray <ExternAliasRecord> externAliasRecords;
string defaultNamespaceName;
if (isVisualBasicMethod)
{
ReadVisualBasicImportsDebugInfo(
symReader,
methodToken,
methodVersion,
out importRecordGroups,
out defaultNamespaceName);
externAliasRecords = ImmutableArray <ExternAliasRecord> .Empty;
}
else
{
Debug.Assert(symbolProviderOpt != null);
ReadCSharpNativeImportsInfo(
symReader,
symbolProviderOpt,
methodToken,
methodVersion,
out importRecordGroups,
out externAliasRecords);
defaultNamespaceName = "";
}
// VB should read hoisted scope information from local variables:
var hoistedLocalScopeRecords = isVisualBasicMethod ?
default(ImmutableArray <HoistedLocalScopeRecord>) :
ImmutableArray <HoistedLocalScopeRecord> .Empty;
ImmutableDictionary <int, ImmutableArray <bool> > dynamicLocalMap = null;
ImmutableDictionary <string, ImmutableArray <bool> > dynamicLocalConstantMap = null;
ImmutableDictionary <int, ImmutableArray <string> > tupleLocalMap = null;
ImmutableDictionary <LocalNameAndScope, ImmutableArray <string> > tupleLocalConstantMap = null;
byte[] customDebugInfo = GetCustomDebugInfoBytes(symReader, methodToken, methodVersion);
if (customDebugInfo != null)
{
if (!isVisualBasicMethod)
{
var customDebugInfoRecord = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(customDebugInfo, CustomDebugInfoKind.StateMachineHoistedLocalScopes);
if (!customDebugInfoRecord.IsDefault)
{
hoistedLocalScopeRecords = CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(customDebugInfoRecord)
.SelectAsArray(s => new HoistedLocalScopeRecord(s.StartOffset, s.Length));
}
GetCSharpDynamicLocalInfo(
customDebugInfo,
allScopes,
out dynamicLocalMap,
out dynamicLocalConstantMap);
}
GetTupleElementNamesLocalInfo(
customDebugInfo,
out tupleLocalMap,
out tupleLocalConstantMap);
}
var constantsBuilder = ArrayBuilder <TLocalSymbol> .GetInstance();
if (symbolProviderOpt != null) // TODO
{
GetConstants(constantsBuilder, symbolProviderOpt, containingScopes, dynamicLocalConstantMap, tupleLocalConstantMap);
}
var reuseSpan = GetReuseSpan(allScopes, ilOffset, isVisualBasicMethod);
return(new MethodDebugInfo <TTypeSymbol, TLocalSymbol>(
hoistedLocalScopeRecords,
importRecordGroups,
externAliasRecords,
dynamicLocalMap,
tupleLocalMap,
defaultNamespaceName,
containingScopes.GetLocalNames(),
constantsBuilder.ToImmutableAndFree(),
reuseSpan));
}
catch (InvalidOperationException)
{
// bad CDI, ignore
return(None);
}
finally
{
allScopes.Free();
containingScopes.Free();
}
}
public static void Convert(Stream peStream, Stream sourcePdbStream, Stream targetPdbStream)
{
var metadataBuilder = new MetadataBuilder();
ImmutableArray <int> typeSystemRowCounts;
var debugEntryPointToken = default(MethodDefinitionHandle);
var pdbId = default(BlobContentId);
try
{
using (var peReader = new PEReader(peStream))
{
pdbId = ReadPdbId(peReader);
var symReader = SymReaderFactory.CreateWindowsPdbReader(sourcePdbStream, peReader);
var metadataReader = peReader.GetMetadataReader();
var metadataModel = new MetadataModel(metadataReader);
typeSystemRowCounts = metadataModel.GetRowCounts();
debugEntryPointToken = ReadEntryPointHandle(symReader);
// documents:
var documentIndex = new Dictionary <string, DocumentHandle>(StringComparer.Ordinal);
var documents = symReader.GetDocuments();
metadataBuilder.SetCapacity(TableIndex.Document, documents.Length);
bool vbSemantics = false;
foreach (var document in documents)
{
string name = document.GetName();
Guid language = document.GetLanguage();
// TODO:
// won't work for IL-merged assmemblies
vbSemantics |= language == SymReaderHelpers.VisualBasicLanguageGuid;
var rid = metadataBuilder.AddDocument(
name: metadataBuilder.GetOrAddDocumentName(name),
hashAlgorithm: metadataBuilder.GetOrAddGuid(document.GetHashAlgorithm()),
hash: metadataBuilder.GetOrAddBlob(document.GetChecksum()),
language: metadataBuilder.GetOrAddGuid(language));
documentIndex.Add(name, rid);
}
var lastLocalVariableHandle = default(LocalVariableHandle);
var lastLocalConstantHandle = default(LocalConstantHandle);
var importStringsByMethod = new Dictionary <int, ImmutableArray <string> >();
var importScopesByMethod = new Dictionary <int, ImportScopeHandle>();
// Maps import scope content to import scope handles
var importScopeIndex = new Dictionary <ImportScopeInfo, ImportScopeHandle>();
var importScopes = new List <ImportScopeInfo>();
// reserve slot for module import scope:
importScopes.Add(default(ImportScopeInfo));
var externAliasImports = new List <ImportInfo>();
var externAliasStringSet = new HashSet <string>(StringComparer.Ordinal);
string vbDefaultNamespace = null;
var vbProjectLevelImports = new List <ImportInfo>();
// first pass:
foreach (var methodHandle in metadataReader.MethodDefinitions)
{
int methodToken = MetadataTokens.GetToken(methodHandle);
ImmutableArray <ImmutableArray <ImportInfo> > importGroups;
if (vbSemantics)
{
var importStrings = CustomDebugInfoReader.GetVisualBasicImportStrings(
methodToken,
symReader,
getMethodImportStrings: (token, sr) => GetImportStrings(token, importStringsByMethod, sr));
if (importStrings.IsEmpty)
{
// no debug info
continue;
}
var vbFileLevelImports = ArrayBuilder <ImportInfo> .GetInstance();
foreach (var importString in importStrings)
{
if (TryParseImportString(importString, out var import, vbSemantics: true))
{
if (import.Kind == ImportTargetKind.DefaultNamespace)
{
vbDefaultNamespace = import.Target;
}
else if (import.Scope == VBImportScopeKind.Project)
{
vbProjectLevelImports.Add(import);
}
else
{
vbFileLevelImports.Add(import);
}
}
}
importGroups = ImmutableArray.Create(vbFileLevelImports.ToImmutableAndFree());
}
else
{
var importStringGroups = CustomDebugInfoReader.GetCSharpGroupedImportStrings(
methodToken,
symReader,
getMethodCustomDebugInfo: (token, sr) => sr.GetCustomDebugInfo(token, methodVersion: 1),
getMethodImportStrings: (token, sr) => GetImportStrings(token, importStringsByMethod, sr),
externAliasStrings: out var localExternAliasStrings);
if (importStringGroups.IsDefault)
{
// no debug info
continue;
}
if (!localExternAliasStrings.IsDefault)
{
foreach (var externAlias in localExternAliasStrings)
{
if (externAliasStringSet.Add(externAlias) &&
TryParseImportString(externAlias, out var import, vbSemantics: false))
{
externAliasImports.Add(import);
}
}
}
importGroups = ImmutableArray.CreateRange(importStringGroups.Select(g => ParseImportStrings(g, vbSemantics: false)));
}
var importScopeHandle = DefineImportScope(importGroups, importScopeIndex, importScopes);
importScopesByMethod.Add(methodToken, importScopeHandle);
}
// import scopes:
metadataBuilder.AddImportScope(
parentScope: default(ImportScopeHandle),
imports: SerializeModuleImportScope(metadataBuilder, externAliasImports, vbProjectLevelImports, vbDefaultNamespace, metadataModel));
for (int i = 1; i < importScopes.Count; i++)
{
metadataBuilder.AddImportScope(
parentScope: importScopes[i].Parent,
imports: SerializeImportsBlob(metadataBuilder, importScopes[i].Imports, metadataModel));
}
var dynamicNames = new Dictionary <string, DynamicLocalInfo>();
var dynamicSlots = new Dictionary <int, DynamicLocalInfo>();
// methods:
metadataBuilder.SetCapacity(TableIndex.MethodDebugInformation, metadataReader.MethodDefinitions.Count);
foreach (var methodHandle in metadataReader.MethodDefinitions)
{
var methodDef = metadataReader.GetMethodDefinition(methodHandle);
int methodToken = MetadataTokens.GetToken(methodHandle);
var symMethod = symReader.GetMethod(methodToken);
if (symMethod == null)
{
metadataBuilder.AddMethodDebugInformation(default(DocumentHandle), sequencePoints: default(BlobHandle));
continue;
}
// method debug info:
int localSignatureRowId;
if (methodDef.RelativeVirtualAddress != 0)
{
var methodBody = peReader.GetMethodBody(methodDef.RelativeVirtualAddress);
localSignatureRowId = methodBody.LocalSignature.IsNil ? 0 : MetadataTokens.GetRowNumber(methodBody.LocalSignature);
}
else
{
localSignatureRowId = 0;
}
var symSequencePoints = symMethod.GetSequencePoints().ToImmutableArray();
DocumentHandle singleDocumentHandle;
BlobHandle sequencePointsBlob = SerializeSequencePoints(metadataBuilder, localSignatureRowId, symSequencePoints, documentIndex, out singleDocumentHandle);
metadataBuilder.AddMethodDebugInformation(
document: singleDocumentHandle,
sequencePoints: sequencePointsBlob);
// state machine and async info:
var symAsyncMethod = symMethod.AsAsyncMethod();
if (symAsyncMethod != null)
{
var kickoffToken = MetadataTokens.Handle(symAsyncMethod.GetKickoffMethod());
metadataBuilder.AddStateMachineMethod(
moveNextMethod: methodHandle,
kickoffMethod: (MethodDefinitionHandle)kickoffToken);
metadataBuilder.AddCustomDebugInformation(
parent: methodHandle,
kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.AsyncMethodSteppingInformationBlob),
value: SerializeAsyncMethodSteppingInfo(metadataBuilder, symAsyncMethod, MetadataTokens.GetRowNumber(methodHandle)));
}
// custom debug information:
var dynamicLocals = default(ImmutableArray <DynamicLocalInfo>);
byte[] customDebugInfoBytes = symReader.GetCustomDebugInfo(methodToken, methodVersion: 1);
if (customDebugInfoBytes != null)
{
foreach (var record in CustomDebugInfoReader.GetCustomDebugInfoRecords(customDebugInfoBytes))
{
switch (record.Kind)
{
case CustomDebugInfoKind.DynamicLocals:
dynamicLocals = CustomDebugInfoReader.DecodeDynamicLocalsRecord(record.Data);
break;
case CustomDebugInfoKind.StateMachineHoistedLocalScopes:
metadataBuilder.AddCustomDebugInformation(
parent: methodHandle,
kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLocalSlotMap),
value: SerializeStateMachineHoistedLocalsBlob(metadataBuilder, CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(record.Data)));
break;
case CustomDebugInfoKind.EditAndContinueLocalSlotMap:
metadataBuilder.AddCustomDebugInformation(
parent: methodHandle,
kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLocalSlotMap),
value: metadataBuilder.GetOrAddBlob(record.Data));
break;
case CustomDebugInfoKind.EditAndContinueLambdaMap:
metadataBuilder.AddCustomDebugInformation(
parent: methodHandle,
kind: metadataBuilder.GetOrAddGuid(PortableCustomDebugInfoKinds.EncLambdaAndClosureMap),
value: metadataBuilder.GetOrAddBlob(record.Data));
break;
}
}
}
var rootScope = symMethod.GetRootScope();
if (rootScope.GetNamespaces().Length == 0 || rootScope.GetLocals().Length == 0 || rootScope.GetConstants().Length == 0)
{
dynamicNames.Clear();
dynamicSlots.Clear();
foreach (var dynamicLocal in dynamicLocals)
{
if (dynamicLocal.SlotId == 0)
{
// All dynamic constants have slot id == 0,
// but a variable can also have slot id == 0
if (!dynamicNames.ContainsKey(dynamicLocal.LocalName))
{
dynamicNames.Add(dynamicLocal.LocalName, dynamicLocal);
}
else
{
// TODO: warning
}
}
else if (!dynamicSlots.ContainsKey(dynamicLocal.SlotId))
{
dynamicSlots.Add(dynamicLocal.SlotId, dynamicLocal);
}
else
{
// TODO: warning
}
}
foreach (ISymUnmanagedScope scope in rootScope.GetChildren())
{
SerializeScope(
metadataBuilder,
metadataModel,
methodHandle,
importScopesByMethod[methodToken],
scope,
dynamicSlots,
dynamicNames,
vbSemantics,
ref lastLocalVariableHandle,
ref lastLocalConstantHandle);
}
}
else
{
// TODO: warning:
// "Root scope must be empty (method 0x{0:x8})", MetadataTokens.GetToken(methodHandle))
}
}
}
}
catch (COMException e)
{
// TODO: loc
throw new BadImageFormatException("Invalid PDB format: " + e.Message, e);
}
var serializer = new PortablePdbBuilder(metadataBuilder, typeSystemRowCounts, debugEntryPointToken, idProvider: _ => pdbId);
BlobBuilder blobBuilder = new BlobBuilder();
serializer.Serialize(blobBuilder);
blobBuilder.WriteContentTo(targetPdbStream);
}
public static MethodDebugInfo GetMethodDebugInfo(
this ISymUnmanagedReader reader,
int methodToken,
int methodVersion,
ArrayBuilder <ISymUnmanagedScope> scopes)
{
ImmutableArray <string> externAliasStrings;
var importStringGroups = reader.GetCSharpGroupedImportStrings(methodToken, methodVersion, out externAliasStrings);
Debug.Assert(importStringGroups.IsDefault == externAliasStrings.IsDefault);
ArrayBuilder <ImmutableArray <ImportRecord> > importRecordGroupBuilder = null;
ArrayBuilder <ExternAliasRecord> externAliasRecordBuilder = null;
if (!importStringGroups.IsDefault)
{
importRecordGroupBuilder = ArrayBuilder <ImmutableArray <ImportRecord> > .GetInstance(importStringGroups.Length);
foreach (var importStringGroup in importStringGroups)
{
var groupBuilder = ArrayBuilder <ImportRecord> .GetInstance(importStringGroup.Length);
foreach (var importString in importStringGroup)
{
ImportRecord record;
if (NativeImportRecord.TryCreateFromCSharpImportString(importString, out record))
{
groupBuilder.Add(record);
}
else
{
Debug.WriteLine($"Failed to parse import string {importString}");
}
}
importRecordGroupBuilder.Add(groupBuilder.ToImmutableAndFree());
}
if (!externAliasStrings.IsDefault)
{
externAliasRecordBuilder = ArrayBuilder <ExternAliasRecord> .GetInstance(externAliasStrings.Length);
foreach (string externAliasString in externAliasStrings)
{
string alias;
string externAlias;
string target;
ImportTargetKind kind;
if (!CustomDebugInfoReader.TryParseCSharpImportString(externAliasString, out alias, out externAlias, out target, out kind))
{
Debug.WriteLine($"Unable to parse extern alias '{externAliasString}'");
continue;
}
Debug.Assert(kind == ImportTargetKind.Assembly, "Programmer error: How did a non-assembly get in the extern alias list?");
Debug.Assert(alias != null); // Name of the extern alias.
Debug.Assert(externAlias == null); // Not used.
Debug.Assert(target != null); // Name of the target assembly.
AssemblyIdentity targetIdentity;
if (!AssemblyIdentity.TryParseDisplayName(target, out targetIdentity))
{
Debug.WriteLine($"Unable to parse target of extern alias '{externAliasString}'");
continue;
}
externAliasRecordBuilder.Add(new NativeExternAliasRecord <AssemblySymbol>(alias, targetIdentity));
}
}
}
var hoistedLocalScopeRecords = ImmutableArray <HoistedLocalScopeRecord> .Empty;
var dynamicLocalMap = ImmutableDictionary <int, ImmutableArray <bool> > .Empty;
var dynamicLocalConstantMap = ImmutableDictionary <string, ImmutableArray <bool> > .Empty;
byte[] customDebugInfoBytes = reader.GetCustomDebugInfoBytes(methodToken, methodVersion);
if (customDebugInfoBytes != null)
{
var customDebugInfoRecord = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(customDebugInfoBytes, CustomDebugInfoKind.StateMachineHoistedLocalScopes);
if (!customDebugInfoRecord.IsDefault)
{
hoistedLocalScopeRecords = CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(customDebugInfoRecord)
.SelectAsArray(s => HoistedLocalScopeRecord.FromNative(s.StartOffset, s.EndOffset));
}
CustomDebugInfoReader.GetCSharpDynamicLocalInfo(
customDebugInfoBytes,
methodToken,
methodVersion,
scopes,
out dynamicLocalMap,
out dynamicLocalConstantMap);
}
return(new MethodDebugInfo(
hoistedLocalScopeRecords,
importRecordGroupBuilder?.ToImmutableAndFree() ?? ImmutableArray <ImmutableArray <ImportRecord> > .Empty,
externAliasRecordBuilder?.ToImmutableAndFree() ?? ImmutableArray <ExternAliasRecord> .Empty,
dynamicLocalMap,
dynamicLocalConstantMap,
defaultNamespaceName: "")); // Unused in C#.
}