public TypeNode AddDependency(ILeafContainer type)
{
TypeNode node = new TypeNode(type);
TypeDependencies.Add(node);
return(node);
}
private TypeNode AddDependency(ILeafContainer leaf)
{
TypeNode node = new TypeNode(leaf);
TypeDependencies.Add(node);
return(node);
}
private void WriteType(ILeafContainer leafc)
{
switch (leafc.Type)
{
case LeafType.SPECIAL_BUILTIN:
BuiltinTypeLeaf builtin = leafc.Data as BuiltinTypeLeaf;
itw.Write(SpecialTypeMaps[builtin.SpecialType]);
if (builtin.TypeMode != SpecialTypeMode.Direct)
{
itw.Write('*');
}
break;
case LeafType.LF_ARGLIST:
LF_ARGLIST lfArgList = leafc.Data as LF_ARGLIST;
itw.Write('(');
for (int i = 0; i < lfArgList.NumberOfArguments; i++)
{
WriteType(lfArgList.ArgumentTypes[i]);
if (lfArgList.ArgumentTypes[i].Data is BuiltinTypeLeaf bt &&
i + 1 == lfArgList.NumberOfArguments &&
bt.SpecialType == SpecialType.None &&
bt.TypeMode == SpecialTypeMode.Direct
)
{
itw.Write("...");
}
public override void Read()
{
TypeDataReader r = CreateReader();
NumElements = r.ReadUInt16();
Bases = r.ReadIndexedType16Lazy();
}
//$TODO(work in progress): fix the NI -> TI mapping
private void BuildTypeMap()
{
uint minTi = Tpi.Header.MinTypeIndex;
uint maxTi = minTi + Tpi.Header.MaxTypeIndex - 1;
for (uint ti = minTi; ti <= maxTi; ti++)
{
ILeafContainer leafC = resolver.GetTypeByIndex(ti);
if (leafC == null || !(leafC.Data is LeafBase leaf))
{
continue;
}
if (!leaf.IsDefnUdt)
{
continue;
}
string typeName = leaf.UdtName;
if (leaf.IsLocalDefnUdtWithUniqueName)
{
throw new NotImplementedException();
}
if (!GetIndex(typeName, out uint nameIndex))
{
//$TODO: how do i handle this?
continue;
}
NameIndex_TypeIndex.Add(nameIndex, ti);
}
}
public override void Read()
{
TypeDataReader r = CreateReader();
r.ReadUInt16(); //padding
PointerType = r.ReadIndexedTypeLazy();
}
public override void Read()
{
TypeDataReader r = CreateReader();
Attributes = r.ReadFlagsEnum <CVModifier>();
ModifiedType = r.ReadIndexedType16Lazy();
}
/// <summary>
/// Read a varying ILeaf which can be either a ILeaf type or a raw data marker
/// </summary>
/// <param name="dataSize"></param>
/// <param name="leafType"></param>
/// <returns>true if we found a ILeaf, false if we found raw data marker</returns>
public ILeafContainer ReadVaryingType(out uint dataSize)
{
UInt16 leafValue = ReadUInt16();
if (leafValue < (ushort)LeafType.LF_NUMERIC)
{
// $TODO: ILeafValue is not a ILeaf marker, but it's still a valid ushort
// do we need to save this?
dataSize = 0;
return(null);
}
if (!Enum.IsDefined(typeof(LeafType), leafValue))
{
throw new InvalidDataException($"Unknown ILeaf type {leafValue} while computing ILeaf data size");
}
LeafType leafType = (LeafType)leafValue;
dataSize = PrimitiveDataSizes[leafType];
Seek(-2, SeekOrigin.Current);
TypeDataReader rdr = new TypeDataReader(ctx, this);
ILeafContainer leaf = rdr.ReadTypeDirect(hasSize: false);
//ILeafContainer leaf = new TypeDataReader(ctx, this).ReadTypeDirect(hasSize: false);
// add leaf size
this.Position += rdr.Position;
return(leaf);
}
public override void Read()
{
TypeDataReader r = CreateReader();
Attributes = new FieldAttributes(r.ReadUInt16());
Value = r.ReadVaryingType(out uint ILeafSize);
FieldName = r.ReadCString();
}
public override void Read()
{
TypeDataReader r = CreateReader();
Attributes = new FieldAttributes(r.ReadUInt16());
BaseClassType = r.ReadIndexedType32Lazy();
Offset = r.ReadVaryingType(out uint dataSize);
}
public void WriteVaryingType(ILeafContainer leaf)
{
if ((ushort)leaf.Type < (ushort)LeafType.LF_NUMERIC)
{
throw new NotImplementedException();
}
leaf.Data.Write();
}
public override void Read()
{
var r = CreateReader();
Offset = r.ReadUInt32();
SectionIndex = r.ReadUInt16();
r.ReadUInt16(); //padding
Type = r.ReadIndexedTypeLazy();
}
public override void Read()
{
var r = CreateReader();
InlinerParentOffset = r.ReadUInt32();
Inliner = r.ReadSymbol(Module, InlinerParentOffset);
End = r.ReadUInt32();
Inlinee = r.ReadIndexedTypeLazy();
BinaryAnnotations = r.ReadRemaining();
}
public override void Read()
{
TypeDataReader r = CreateReader();
ReturnValueType = r.ReadIndexedType32Lazy();
CallingConvention = r.ReadEnum <CallingConvention>();
r.ReadByte(); //reserved
NumberOfParameters = r.ReadUInt16();
ArgumentListType = r.ReadIndexedType32Lazy();
}
public override void Read()
{
var r = CreateReader();
CallSiteOffset = r.ReadUInt32();
SectionIndex = r.ReadUInt16();
HeapAllocationInstructionSize = r.ReadUInt16();
FunctionSignature = r.ReadIndexedType32Lazy();
}
public override void Read()
{
TypeDataReader r = CreateReader();
Attributes = new FieldAttributes(r.ReadUInt16());
VirtualBaseClassType = r.ReadIndexedTypeLazy();
VirtualBasePointerType = r.ReadIndexedTypeLazy();
//virtual base pointer offset from address point
OffsetFromAddress = r.ReadVaryingType(out uint dynSize1);
//virtual base offset from vbtable
OffsetFromTable = r.ReadVaryingType(out uint dynSize2);
}
private ILeafContainer ReadTypeOld(out long dataSize)
{
uint hash = ReadUInt32();
// we have no length, so we just pass all memory (after the hash)
SpanStream memStream = new SpanStream(Memory.Slice((int)Position));
TypeDataReader rdr = new TypeDataReader(ctx, memStream);
// without a length, and with a small amount of data, we can just read this directly
ILeafContainer leaf = rdr.ReadTypeDirect(false);
// hash + type data
dataSize = Position + rdr.Position;
Position += rdr.Position;
return(leaf);
}
public override void Read()
{
var r = CreateReader();
ParentOffset = r.ReadUInt32();
ParentSymbol = r.ReadSymbol(Module, ParentOffset);
End = r.ReadUInt32();
NextOffset = r.ReadUInt32();
NextSymbol = r.ReadSymbol(Module, NextOffset);
Length = r.ReadUInt32();
DebugStartOffset = r.ReadUInt32();
DebugEndOffset = r.ReadUInt32();
Type = r.ReadIndexedType32Lazy();
Offset = r.ReadUInt32();
Segment = r.ReadUInt16();
Flags = r.ReadFlagsEnum <CV_PROCFLAGS>();
Name = r.ReadSymbolString();
}
public static long LeafDecimalValue(this ILeafContainer leaf)
{
switch (leaf.Data)
{
case LF_CHAR lfChar:
return(lfChar.Value);
case LF_SHORT lfShort:
return(lfShort.Value);
case LF_USHORT lfUShort:
return(lfUShort.Value);
case LF_LONG lfLong:
return(lfLong.Value);
case LF_ULONG lfULong:
return(lfULong.Value);
default:
throw new NotSupportedException($"Cannot get numeric decimal value for leaf {leaf.Type}");
}
}
public override void Read()
{
var r = CreateReader();
ItemID = r.ReadIndexedTypeLazy();
}
public TypeNode(ILeafContainer leaf)
{
this.Type = leaf;
this.HandleType();
}
static void Main(string[] args)
{
ParseArguments(args);
if (PdbFilePath == null)
{
Console.Error.WriteLine(@"PDBSharp.Dumper
Usage: PDBSharp.Dumper <options> <file.pdb>
[-dump] Save individual PDB Streams to files
[-dump-modules] Verbose output for DBI Modules
[-dump-leaves] Verbose output for TPI Leaves
[-dump-syms] Verbose output for DBI Symbols
[-print] Extract and print type definitions");
Environment.Exit(1);
}
#if PERF
Console.WriteLine("Starting...");
Stopwatch sw = new Stopwatch();
sw.Start();
#endif
PDBFile pdb = PDBFile.Open(PdbFilePath);
IServiceContainer sc = pdb.Services;
DBIReader dbi = sc.GetService <DBIReader>();
TPIReader tpi = sc.GetService <TPIReader>();
StreamTableReader streamTable = sc.GetService <StreamTableReader>();
if (OptPrintDecls)
{
var tree = new GraphBuilder(sc).Build();
CodeWriter cw = new CodeWriter(tree);
#if !PERF
cw.Write(Console.Out);
#endif
}
if (OptDumpLeaves)
{
pdb.OnTpiInit += Pdb_OnTpiInit;
}
if (OptDumpModules || OptDumpSymbols)
{
pdb.OnDbiInit += Pdb_OnDbiInit;
}
if (OptDumpStreams)
{
DirectoryInfo dumpDir = Directory.CreateDirectory(Path.GetFileNameWithoutExtension(PdbFilePath));
for (int i = 1; i < streamTable.NumStreams; i++)
{
string dumpPath = Path.Combine(dumpDir.ToString(), $"stream{i}.bin");
byte[] stream = streamTable.GetStream(i);
File.WriteAllBytes(dumpPath, stream);
}
}
/*
* foreach(var type in ctx.TpiReader.Types) {
* //Console.WriteLine(type);
* }*/
TPIHashReader tpiHash = sc.GetService <TPIHashReader>();
UdtNameTableReader udtNameTable = sc.GetService <UdtNameTableReader>();
TypeResolver resolver = sc.GetService <TypeResolver>();
if (tpiHash != null && udtNameTable != null)
{
foreach (var pair in tpiHash.NameIndexToTypeIndex)
{
string name = udtNameTable.GetString(pair.Key);
ILeafContainer leaf = resolver.GetTypeByIndex(pair.Value);
#if !PERF
Console.WriteLine($"=> {name} [NI={pair.Key}] [TI={pair.Value}]");
Console.WriteLine(leaf.Data.GetType().Name);
#endif
}
}
foreach (var contrib in dbi.SectionContribs.SectionContribs)
{
#if !PERF
ObjectDumper.Dump(contrib);
#endif
}
DebugReader debug = dbi.DebugInfo;
if (debug != null && debug.FPO != null)
{
foreach (var frame in debug.FPO.Frames)
{
#if !PERF
ObjectDumper.Dump(frame);
#endif
}
}
foreach (var container in dbi.Modules)
{
#if !PERF
Console.WriteLine($"[MODULE => {container.Info.ModuleName}]");
Console.WriteLine($"[OBJECT => {container.Info.ObjectFileName}]");
Console.WriteLine($"[SRC => {container.Info.SourceFileName}]");
if (container.Module != null)
{
Console.WriteLine($"[TYPE => {container.Module.GetType().Name}");
}
Console.WriteLine();
#endif
IModule mod = container.Module;
if (mod != null)
{
foreach (var sym in mod.Symbols)
{
#if !PERF
Console.WriteLine(sym);
#endif
}
}
}
foreach (var type in tpi.Types)
{
#if !PERF
Console.WriteLine(type);
#endif
}
#if !PERF
Console.WriteLine("Press Enter to continue...");
Console.ReadLine();
#else
sw.Stop();
Console.WriteLine($"Finished in {sw.Elapsed.TotalSeconds} seconds");
#endif
}
public override void Read()
{
TypeDataReader r = CreateReader();
Referenced = r.ReadIndexedTypeLazy();
}
public void WriteIndexedType16(ILeafContainer leaf)
{
WriteUInt16((ushort)leaf.TypeIndex);
leaf.Data.Write();
}
public void WriteIndexedType(ILeafContainer leaf)
{
WriteUInt32(leaf.TypeIndex);
leaf.Data.Write();
}
