/*
* uint Magic = 0x53445352;
* Guid Signature;
* uint Age;
* string FileName;
*/
public bool ProcessDebugHeader(ImageDebugHeader header)
{
if (!header.HasEntries)
{
return(false);
}
using (pdb_file) {
var info = PdbFile.LoadFunctions(pdb_file.value);
foreach (var entry in header.Entries)
{
if (!IsMatchingEntry(info, entry))
{
continue;
}
foreach (var function in info.Functions)
{
functions.Add(function.token, function);
}
return(true);
}
}
return(false);
}
public static byte[] GetBytes(this ImageDebugHeader header)
{
using (var ms = new MemoryStream()) {
Write(new BinaryWriter(ms), header);
return(ms.ToArray());
}
}
/// <summary>Process a debug header in the symbol file.</summary>
/// <param name="header">The debug header.</param>
public bool ProcessDebugHeader(ImageDebugHeader header)
{
try
{
return(this.Reader.ProcessDebugHeader(header));
}
catch
{
this.Reader.Dispose();
this.Reader = new PortablePdbReaderProvider().GetSymbolReader(this.Module, this.Stream);
return(this.Reader.ProcessDebugHeader(header));
}
}
private void GetDebugHeader()
{
ISymbolWriter symbol_writer = metadata.symbol_writer;
if (symbol_writer != null)
{
debug_header = symbol_writer.GetDebugHeader();
}
if (module.HasDebugHeader && module.GetDebugHeader().GetDeterministicEntry() != null)
{
debug_header = debug_header.AddDeterministicEntry();
}
}
public static void Write(BinaryWriter writer, ImageDebugHeader header)
{
writer.Write((byte)header.Entries.Length);
foreach (var entry in header.Entries)
{
var directory = entry.Directory;
writer.Write(directory.Characteristics);
writer.Write(directory.TimeDateStamp);
writer.Write(directory.MajorVersion);
writer.Write(directory.MinorVersion);
writer.Write((int)directory.Type);
writer.Write(directory.SizeOfData);
writer.Write(entry.Data);
}
}
/*
* uint Magic = 0x53445352;
* Guid Signature;
* uint Age;
* string FileName;
*/
public bool ProcessDebugHeader(ImageDebugHeader header)
{
if (!header.HasEntries)
{
return(false);
}
var entry = header.GetCodeViewEntry();
if (entry == null)
{
return(false);
}
var directory = entry.Directory;
if (directory.Type != ImageDebugType.CodeView)
{
return(false);
}
if (directory.MajorVersion != 0 || directory.MinorVersion != 0)
{
return(false);
}
var data = entry.Data;
if (data.Length < 24)
{
return(false);
}
var magic = ReadInt32(data, 0);
if (magic != 0x53445352)
{
return(false);
}
var guid_bytes = new byte [16];
Buffer.BlockCopy(data, 4, guid_bytes, 0, 16);
this.guid = new Guid(guid_bytes);
this.age = ReadInt32(data, 20);
return(PopulateFunctions());
}
public static ImageDebugHeader AddDeterministicEntry(this ImageDebugHeader header)
{
var entry = new ImageDebugHeaderEntry(new ImageDebugDirectory {
Type = ImageDebugType.Deterministic
}, Empty <byte> .Array);
if (header == null)
{
return(new ImageDebugHeader(entry));
}
var entries = new ImageDebugHeaderEntry [header.Entries.Length + 1];
Array.Copy(header.Entries, entries, header.Entries.Length);
entries [entries.Length - 1] = entry;
return(new ImageDebugHeader(entries));
}
private void GetEmbeddedPdb(ImageDebugHeader debugHeader, out byte [] embeddedPdb)
{
var entry = Mixin.GetEmbeddedPortablePdbEntry(debugHeader);
Assert.IsNotNull(entry);
var compressed_stream = new MemoryStream(entry.Data);
var reader = new BinaryStreamReader(compressed_stream);
Assert.AreEqual(0x4244504D, reader.ReadInt32());
var length = reader.ReadInt32();
var decompressed_stream = new MemoryStream(length);
using (var deflate = new DeflateStream(compressed_stream, CompressionMode.Decompress, leaveOpen: true))
deflate.CopyTo(decompressed_stream);
embeddedPdb = decompressed_stream.ToArray();
}
private static ImageDebugHeaderEntry GetEntry(this ImageDebugHeader header, ImageDebugType type)
{
if (!header.HasEntries)
{
return(null);
}
for (var i = 0; i < header.Entries.Length; i++)
{
var entry = header.Entries [i];
if (entry.Directory.Type == type)
{
return(entry);
}
}
return(null);
}
void GetDebugHeader()
{
var symbol_writer = metadata.symbol_writer;
if (symbol_writer != null)
{
debug_header = symbol_writer.GetDebugHeader();
}
if (module.HasDebugHeader)
{
var header = module.GetDebugHeader();
var deterministic = header.GetDeterministicEntry();
if (deterministic == null)
{
return;
}
debug_header = debug_header.AddDeterministicEntry();
}
}
private void GetPdbChecksumData(ImageDebugHeader debugHeader, out string algorithmName, out byte [] checksum)
{
var entry = Mixin.GetPdbChecksumEntry(debugHeader);
Assert.IsNotNull(entry);
var length = Array.IndexOf(entry.Data, (byte)0, 0);
var bytes = new byte [length];
Buffer.BlockCopy(entry.Data, 0, bytes, 0, length);
algorithmName = Encoding.UTF8.GetString(bytes);
int checksumSize = 0;
switch (algorithmName)
{
case "SHA256": checksumSize = 32; break;
case "SHA384": checksumSize = 48; break;
case "SHA512": checksumSize = 64; break;
}
checksum = new byte [checksumSize];
Buffer.BlockCopy(entry.Data, length + 1, checksum, 0, checksumSize);
}
async Task <MethodInfo> LoadSymbolsOnDemand(AssemblyInfo asm, uint method_token, SessionId sessionId, CancellationToken token)
{
var context = GetContext(sessionId);
if (asm.TriedToLoadSymbolsOnDemand)
{
return(null);
}
asm.TriedToLoadSymbolsOnDemand = true;
ImageDebugHeader header = asm.Image.GetDebugHeader();
for (var i = 0; i < header.Entries.Length; i++)
{
var entry = header.Entries[i];
if (entry.Directory.Type != ImageDebugType.CodeView)
{
continue;
}
var data = entry.Data;
if (data.Length < 24)
{
return(null);
}
var pdbSignature = (data[0]
| (data[1] << 8)
| (data[2] << 16)
| (data[3] << 24));
if (pdbSignature != 0x53445352) // "SDSR" mono/metadata/debug-mono-ppdb.c#L101
{
return(null);
}
var buffer = new byte[16];
Buffer.BlockCopy(data, 4, buffer, 0, 16);
var pdbAge = (data[20]
| (data[21] << 8)
| (data[22] << 16)
| (data[23] << 24));
var pdbGuid = new Guid(buffer);
var buffer2 = new byte[(data.Length - 24) - 1];
Buffer.BlockCopy(data, 24, buffer2, 0, (data.Length - 24) - 1);
var pdbName = System.Text.Encoding.UTF8.GetString(buffer2, 0, buffer2.Length);
pdbName = Path.GetFileName(pdbName);
foreach (var urlSymbolServer in urlSymbolServerList)
{
var downloadURL = $"{urlSymbolServer}/{pdbName}/{pdbGuid.ToString("N").ToUpper() + pdbAge}/{pdbName}";
try
{
using HttpResponseMessage response = await client.GetAsync(downloadURL);
using Stream streamToReadFrom = await response.Content.ReadAsStreamAsync();
var portablePdbReaderProvider = new PdbReaderProvider();
var symbolReader = portablePdbReaderProvider.GetSymbolReader(asm.Image, streamToReadFrom);
asm.ClearDebugInfo(); //workaround while cecil PR #686 is not merged
asm.Image.ReadSymbols(symbolReader);
asm.Populate();
foreach (var source in asm.Sources)
{
var scriptSource = JObject.FromObject(source.ToScriptSource(context.Id, context.AuxData));
SendEvent(sessionId, "Debugger.scriptParsed", scriptSource, token);
}
return(asm.GetMethodByToken(method_token));
}
catch (Exception e)
{
Log("info", $"Unable to load symbols on demand exception: {e.ToString()} url:{downloadURL} assembly: {asm.Name}");
}
}
break;
}
Log("info", "Unable to load symbols on demand assembly: {asm.Name}");
return(null);
}
public bool ProcessDebugHeader(ImageDebugHeader header)
{
return(symbol_file.Guid == module.Mvid);
}
public static ImageDebugHeaderEntry GetEmbeddedPortablePdbEntry(this ImageDebugHeader header)
{
return(GetEntry(header, ImageDebugType.EmbeddedPortablePdb));
}
public static ImageDebugHeaderEntry GetPdbChecksumEntry(this ImageDebugHeader header)
{
return(GetEntry(header, ImageDebugType.PdbChecksum));
}
public static ImageDebugHeaderEntry GetDeterministicEntry(this ImageDebugHeader header)
{
return(GetEntry(header, ImageDebugType.Deterministic));
}
public static ImageDebugHeaderEntry GetCodeViewEntry(this ImageDebugHeader header)
{
return(GetEntry(header, ImageDebugType.CodeView));
}
