public DbiModuleInfo(BitAccess bits, bool readStrings) { bits.ReadInt32(out opened); section = new DbiSecCon(bits); bits.ReadUInt16(out flags); bits.ReadInt16(out stream); bits.ReadInt32(out cbSyms); bits.ReadInt32(out cbOldLines); bits.ReadInt32(out cbLines); bits.ReadInt16(out files); bits.ReadInt16(out pad1); bits.ReadUInt32(out offsets); bits.ReadInt32(out niSource); bits.ReadInt32(out niCompiler); if (readStrings) { bits.ReadCString(out moduleName); bits.ReadCString(out objectName); } else { bits.SkipCString(out moduleName); bits.SkipCString(out objectName); } bits.Align(4); if (opened != 0 || pad1 != 0) { throw new PdbException("Invalid DBI module. "+ "(opened={0}, pad={1})", opened, pad1); } }
public DbiModuleInfo(BitAccess bits, bool readStrings) { bits.ReadInt32(out opened); section = new DbiSecCon(bits); bits.ReadUInt16(out flags); bits.ReadInt16(out stream); bits.ReadInt32(out cbSyms); bits.ReadInt32(out cbOldLines); bits.ReadInt32(out cbLines); bits.ReadInt16(out files); bits.ReadInt16(out pad1); bits.ReadUInt32(out offsets); bits.ReadInt32(out niSource); bits.ReadInt32(out niCompiler); if (readStrings) { bits.ReadCString(out moduleName); bits.ReadCString(out objectName); } else { bits.SkipCString(out moduleName); bits.SkipCString(out objectName); } bits.Align(4); if (opened != 0 || pad1 != 0) { throw new PdbException("Invalid DBI module. " + "(opened={0}, pad={1})", opened, pad1); } }
public DbiSecCon(BitAccess bits) { bits.ReadInt16(out section); bits.ReadInt16(out pad1); bits.ReadInt32(out offset); bits.ReadInt32(out size); bits.ReadUInt32(out flags); bits.ReadInt16(out module); bits.ReadInt16(out pad2); bits.ReadUInt32(out dataCrc); bits.ReadUInt32(out relocCrc); if (pad1 != 0 || pad2 != 0) { throw new PdbException("Invalid DBI section. "+ "(pad1={0}, pad2={1})", pad1, pad2); } }
public DbiSecCon(BitAccess bits) { bits.ReadInt16(out section); bits.ReadInt16(out pad1); bits.ReadInt32(out offset); bits.ReadInt32(out size); bits.ReadUInt32(out flags); bits.ReadInt16(out module); bits.ReadInt16(out pad2); bits.ReadUInt32(out dataCrc); bits.ReadUInt32(out relocCrc); if (pad1 != 0 || pad2 != 0) { throw new PdbException("Invalid DBI section. " + "(pad1={0}, pad2={1})", pad1, pad2); } }
internal PdbSlot(BitAccess bits, out uint typind) { AttrSlotSym slot; bits.ReadUInt32(out slot.index); bits.ReadUInt32(out slot.typind); bits.ReadUInt32(out slot.offCod); bits.ReadUInt16(out slot.segCod); bits.ReadUInt16(out slot.flags); bits.ReadCString(out slot.name); this.slot = slot.index; this.name = slot.name; this.flags = slot.flags; this.segment = slot.segCod; this.address = slot.offCod; typind = slot.typind; }
static void DumpNameStream(BitAccess bits) { uint sig; int ver; bits.ReadUInt32(out sig); // 0..3 Signature bits.ReadInt32(out ver); // 4..7 Version // Read (or skip) string buffer. int buf; bits.ReadInt32(out buf); // 8..11 Bytes of Strings Console.Write(" ** NAM sig={0:x8} ver={1,4} cb={2,4}", sig, ver, buf); if (sig != 0xeffeeffe || ver != 1) { throw new PdbDebugException("Unknown Name Stream version. "+ "(sig={0:x8}, ver={1})", sig, ver); } #if true int beg = bits.Position; int nxt = bits.Position + buf; bits.Position = nxt; // Read hash table. int siz; bits.ReadInt32(out siz); // n+0..3 Number of hash buckets. nxt = bits.Position; Console.WriteLine(" siz={0,4}", siz); for (int i = 0; i < siz; i++) { int ni; string name; bits.ReadInt32(out ni); if (ni != 0) { int saved = bits.Position; bits.Position = beg + ni; bits.ReadCString(out name); bits.Position = saved; if (name.Length > 60) { Console.WriteLine(" {0,6}: [{1}]+", ni, name.Substring(0,60)); } else { Console.WriteLine(" {0,6}: [{1}]", ni, name); } } } bits.Position = nxt; // Read maxni. int maxni; bits.ReadInt32(out maxni); Console.WriteLine(" maxni={0}", maxni); #endif }
internal static PdbFunction[] LoadManagedFunctions(string module, BitAccess bits, uint limit, bool readStrings) { string mod = StripNamespace(module); int begin = bits.Position; int count = 0; while (bits.Position < limit) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; bits.Position = star; bits.ReadUInt16(out rec); switch ((SYM)rec) { case SYM.S_GMANPROC: case SYM.S_LMANPROC: ManProcSym proc; bits.ReadUInt32(out proc.parent); bits.ReadUInt32(out proc.end); bits.Position = (int)proc.end; count++; break; case SYM.S_END: bits.Position = stop; break; default: Console.WriteLine("{0,6}: {1:x2} {2}", bits.Position, rec, (SYM)rec); bits.Position = stop; break; } } if (count == 0) { return null; } bits.Position = begin; PdbFunction[] funcs = new PdbFunction[count]; int func = 0; while (bits.Position < limit) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; bits.ReadUInt16(out rec); switch ((SYM)rec) { case SYM.S_GMANPROC: case SYM.S_LMANPROC: ManProcSym proc; int offset = bits.Position; bits.ReadUInt32(out proc.parent); bits.ReadUInt32(out proc.end); bits.ReadUInt32(out proc.next); bits.ReadUInt32(out proc.len); bits.ReadUInt32(out proc.dbgStart); bits.ReadUInt32(out proc.dbgEnd); bits.ReadUInt32(out proc.token); bits.ReadUInt32(out proc.off); bits.ReadUInt16(out proc.seg); bits.ReadUInt8(out proc.flags); bits.ReadUInt16(out proc.retReg); if (readStrings) { bits.ReadCString(out proc.name); } else { bits.SkipCString(out proc.name); } //Console.WriteLine("token={0:X8} [{1}::{2}]", proc.token, module, proc.name); bits.Position = stop; funcs[func++] = new PdbFunction(module, proc, bits); break; default: { throw new PdbDebugException("Unknown SYMREC {0}", (SYM)rec); // bits.Position = stop; } } } return funcs; }
internal PdbFunction(string module, ManProcSym proc, BitAccess bits) { this.token = proc.token; this.module = module; this.name = proc.name; this.flags = proc.flags; this.segment = proc.seg; this.address = proc.off; this.length = proc.len; this.slotToken = 0; if (proc.seg != 1) { throw new PdbDebugException("Segment is {0}, not 1.", proc.seg); } if (proc.parent != 0 || proc.next != 0) { throw new PdbDebugException("Warning parent={0}, next={1}", proc.parent, proc.next); } if (proc.dbgStart != 0 || proc.dbgEnd != 0) { throw new PdbDebugException("Warning DBG start={0}, end={1}", proc.dbgStart, proc.dbgEnd); } int scopeCount; int slotCount; CountScopesAndSlots(bits, proc.end, out scopeCount, out slotCount); scopes = new PdbScope[scopeCount]; int scope = 0; while (bits.Position < proc.end) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; bits.Position = star; bits.ReadUInt16(out rec); switch ((SYM)rec) { case SYM.S_OEM: { // 0x0404 OemSymbol oem; bits.ReadGuid(out oem.idOem); bits.ReadUInt32(out oem.typind); // public byte[] rgl; // user data, force 4-byte alignment if (oem.idOem == msilMetaData) { metadata = new byte[stop - bits.Position]; bits.ReadBytes(metadata); bits.Position = stop; break; } else { throw new PdbDebugException("OEM section: guid={0} ti={1}", oem.idOem, oem.typind); // bits.Position = stop; } } case SYM.S_BLOCK32: { BlockSym32 block = new BlockSym32(); bits.ReadUInt32(out block.parent); bits.ReadUInt32(out block.end); bits.ReadUInt32(out block.len); bits.ReadUInt32(out block.off); bits.ReadUInt16(out block.seg); bits.SkipCString(out block.name); bits.Position = stop; scopes[scope] = new PdbScope(block, bits, out slotToken); bits.Position = (int)block.end; break; } case SYM.S_UNAMESPACE: bits.Position = stop; break; case SYM.S_END: bits.Position = stop; break; default: { throw new PdbDebugException("Unknown SYM: {0}", (SYM)rec); // bits.Position = stop; } } } if (bits.Position != proc.end) { throw new PdbDebugException("Not at S_END"); } ushort esiz; ushort erec; bits.ReadUInt16(out esiz); bits.ReadUInt16(out erec); if (erec != (ushort)SYM.S_END) { throw new PdbDebugException("Missing S_END"); } }
internal static void CountScopesAndSlots(BitAccess bits, uint limit, out int scopes, out int slots) { int pos = bits.Position; BlockSym32 block; slots = 0; scopes = 0; while (bits.Position < limit) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; bits.Position = star; bits.ReadUInt16(out rec); switch ((SYM)rec) { case SYM.S_BLOCK32: { bits.ReadUInt32(out block.parent); bits.ReadUInt32(out block.end); scopes++; bits.Position = (int)block.end; break; } case SYM.S_MANSLOT: slots++; bits.Position = stop; break; default: bits.Position = stop; break; } } bits.Position = pos; }
public BitSet(BitAccess bits) { bits.ReadInt32(out size); // 0..3 : Number of words words = new uint[size]; bits.ReadUInt32(words); }
internal PdbScope(BlockSym32 block, BitAccess bits, out uint typind) { this.segment = block.seg; this.address = block.off; this.length = block.len; typind = 0; int scopeCount; int slotCount; PdbFunction.CountScopesAndSlots(bits, block.end, out scopeCount, out slotCount); scopes = new PdbScope[scopeCount]; slots = new PdbSlot[slotCount]; int scope = 0; int slot = 0; while (bits.Position < block.end) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; bits.Position = star; bits.ReadUInt16(out rec); switch ((SYM)rec) { case SYM.S_BLOCK32: { BlockSym32 sub = new BlockSym32(); bits.ReadUInt32(out sub.parent); bits.ReadUInt32(out sub.end); bits.ReadUInt32(out sub.len); bits.ReadUInt32(out sub.off); bits.ReadUInt16(out sub.seg); bits.SkipCString(out sub.name); bits.Position = stop; scopes[scope++] = new PdbScope(sub, bits, out typind); break; } case SYM.S_MANSLOT: slots[slot++] = new PdbSlot(bits, out typind); bits.Position = stop; break; case SYM.S_END: case SYM.S_UNAMESPACE: case SYM.S_MANCONSTANT: bits.Position = stop; break; default: throw new PdbException("Unknown SYM in scope {0}", (SYM)rec); // bits.Position = stop; } } if (bits.Position != block.end) { throw new Exception("Not at S_END"); } ushort esiz; ushort erec; bits.ReadUInt16(out esiz); bits.ReadUInt16(out erec); if (erec != (ushort)SYM.S_END) { throw new Exception("Missing S_END"); } }
static IntHashTable LoadNameStream(BitAccess bits) { IntHashTable ht = new IntHashTable(); uint sig; int ver; bits.ReadUInt32(out sig); // 0..3 Signature bits.ReadInt32(out ver); // 4..7 Version // Read (or skip) string buffer. int buf; bits.ReadInt32(out buf); // 8..11 Bytes of Strings if (sig != 0xeffeeffe || ver != 1) { throw new PdbDebugException("Unsupported Name Stream version. "+ "(sig={0:x8}, ver={1})", sig, ver); } int beg = bits.Position; int nxt = bits.Position + buf; bits.Position = nxt; // Read hash table. int siz; bits.ReadInt32(out siz); // n+0..3 Number of hash buckets. nxt = bits.Position; for (int i = 0; i < siz; i++) { int ni; string name; bits.ReadInt32(out ni); if (ni != 0) { int saved = bits.Position; bits.Position = beg + ni; bits.ReadCString(out name); bits.Position = saved; ht.Add(ni, name); } } bits.Position = nxt; return ht; }
public static PdbFunction[] LoadFunctions(Stream read, BitAccess bits, bool readAllStrings) { PdbFileHeader head = new PdbFileHeader(read, bits); PdbReader reader = new PdbReader(read, head.pageSize); MsfDirectory dir = new MsfDirectory(reader, head, bits); DbiModuleInfo[] modules = null; DbiDbgHdr header; dir.streams[1].Read(reader, bits); int nameStream = LoadPdbStream(bits); if (nameStream <= 0) { throw new PdbException("No `name' stream"); } dir.streams[nameStream].Read(reader, bits); IntHashTable names = LoadNameStream(bits); dir.streams[3].Read(reader, bits); LoadDbiStream(bits, out modules, out header, readAllStrings); ArrayList funcList = new ArrayList(); if (modules != null) { for (int m = 0; m < modules.Length; m++) { if (modules[m].stream > 0) { dir.streams[modules[m].stream].Read(reader, bits); LoadFuncsFromDbiModule(bits, modules[m], names, funcList, readAllStrings); } } } PdbFunction[] funcs = (PdbFunction[])funcList.ToArray(typeof(PdbFunction)); // After reading the functions, apply the token remapping table if it exists. if (header.snTokenRidMap != 0 && header.snTokenRidMap != 0xffff) { dir.streams[header.snTokenRidMap].Read(reader, bits); uint[] ridMap = new uint [dir.streams[header.snTokenRidMap].Length / 4]; bits.ReadUInt32(ridMap); foreach (PdbFunction func in funcs) { func.token = 0x06000000 | ridMap[func.token & 0xffffff]; } } // Array.Sort(funcs, PdbFunction.byAddress); //Array.Sort(funcs, PdbFunction.byToken); return funcs; }
static void LoadManagedLines(PdbFunction[] funcs, IntHashTable names, BitAccess bits, uint limit) { Array.Sort(funcs, PdbFunction.byAddress); checks.Clear(); // Read the files first int begin = bits.Position; while (bits.Position < limit) { int sig; int siz; bits.ReadInt32(out sig); bits.ReadInt32(out siz); int place = bits.Position; int endSym = bits.Position + siz; switch ((DEBUG_S_SUBSECTION)sig) { case DEBUG_S_SUBSECTION.FILECHKSMS: while (bits.Position < endSym) { CV_FileCheckSum chk; int ni = bits.Position - place; bits.ReadUInt32(out chk.name); bits.ReadUInt8(out chk.len); bits.ReadUInt8(out chk.type); string name = (string)names[(int)chk.name]; PdbSource src = new PdbSource((uint)ni, name); checks.Add(ni, src); bits.Position += chk.len; bits.Align(4); } bits.Position = endSym; break; default: bits.Position = endSym; break; } } // Read the lines next. bits.Position = begin; while (bits.Position < limit) { int sig; int siz; bits.ReadInt32(out sig); bits.ReadInt32(out siz); int endSym = bits.Position + siz; switch ((DEBUG_S_SUBSECTION)sig) { case DEBUG_S_SUBSECTION.LINES: { CV_LineSection sec; bits.ReadUInt32(out sec.off); bits.ReadUInt16(out sec.sec); bits.ReadUInt16(out sec.flags); bits.ReadUInt32(out sec.cod); PdbFunction func = FindFunction(funcs, sec.sec, sec.off); // Count the line blocks. int begSym = bits.Position; int blocks = 0; while (bits.Position < endSym) { CV_SourceFile file; bits.ReadUInt32(out file.index); bits.ReadUInt32(out file.count); bits.ReadUInt32(out file.linsiz); // Size of payload. int linsiz = (int)file.count * (8 + ((sec.flags & 1) != 0 ? 4 : 0)); bits.Position += linsiz; blocks++; } func.lines = new PdbLines[blocks]; int block = 0; bits.Position = begSym; while (bits.Position < endSym) { CV_SourceFile file; bits.ReadUInt32(out file.index); bits.ReadUInt32(out file.count); bits.ReadUInt32(out file.linsiz); // Size of payload. PdbSource src = (PdbSource)checks[(int)file.index]; PdbLines tmp = new PdbLines(src, file.count); func.lines[block++] = tmp; PdbLine[] lines = tmp.lines; int plin = bits.Position; int pcol = bits.Position + 8 * (int)file.count; for (int i = 0; i < file.count; i++) { CV_Line line; CV_Column column = new CV_Column(); bits.Position = plin + 8 * i; bits.ReadUInt32(out line.offset); bits.ReadUInt32(out line.flags); uint delta = (line.flags & 0x7f000000) >> 24; bool statement = ((line.flags & 0x80000000) == 0); if ((sec.flags & 1) != 0) { bits.Position = pcol + 4 * i; bits.ReadUInt16(out column.offColumnStart); bits.ReadUInt16(out column.offColumnEnd); } lines[i] = new PdbLine(line.offset, line.flags & 0xffffff, column.offColumnStart, column.offColumnEnd); } } break; } } bits.Position = endSym; } }
static void DumpCvInfo(BitAccess bits, int begin, int limit) { int indent = 0; string pad = ""; while (bits.Position < limit) { ushort siz; ushort rec; bits.ReadUInt16(out siz); int star = bits.Position; int stop = bits.Position + siz; #if false Dump(bits.GetBuffer(), star, stop); bits.Position = star; #endif bits.ReadUInt16(out rec); SYM cv = (SYM)rec; if (rec < 0x1000) { if (cv != SYM.S_END && cv != SYM.S_OEM) { throw new Exception("CV is unknown: " + rec); } } switch (cv) { case SYM.S_OEM: { // 0x0404 OemSymbol oem; bits.ReadGuid(out oem.idOem); bits.ReadUInt32(out oem.typind); // public byte[] rgl; // user data, force 4-byte alignment if (oem.idOem == PdbFunction.msilMetaData) { Console.WriteLine(" {0}META: ", pad); Dump(bits.Buffer, star + 22, stop); break; } else { Console.WriteLine(" {0}OEMS: guid={1} ti={2}", pad, oem.idOem, oem.typind); Dump(bits.Buffer, star + 22, stop); } break; } case SYM.S_OBJNAME: { // 0x1101 ObjNameSym obj; bits.ReadUInt32(out obj.signature); bits.ReadCString(out obj.name); Console.WriteLine(" {0}OBJN: sig={1:x8} [{2}]", pad, obj.signature, obj.name); break; } case SYM.S_FRAMEPROC: { // 0x1012 FrameProcSym frame; bits.ReadUInt32(out frame.cbFrame); bits.ReadUInt32(out frame.cbPad); bits.ReadUInt32(out frame.offPad); bits.ReadUInt32(out frame.cbSaveRegs); bits.ReadUInt32(out frame.offExHdlr); bits.ReadUInt16(out frame.secExHdlr); bits.ReadUInt32(out frame.flags); Console.WriteLine(" {0}FRAM: size={1}, pad={2}+{3}, exc={4:x4}:{5:x8}, flags={6:x3}", pad, frame.cbFrame, frame.cbPad, frame.offPad, frame.offExHdlr, frame.secExHdlr, frame.flags); break; } case SYM.S_BLOCK32: { // 0x1103 BlockSym32 block; bits.ReadUInt32(out block.parent); bits.ReadUInt32(out block.end); bits.ReadUInt32(out block.len); bits.ReadUInt32(out block.off); bits.ReadUInt16(out block.seg); bits.ReadCString(out block.name); Console.WriteLine(" {0}BLCK: par={1}, addr={2:x4}:{3:x8} len={4:x4} [{5}], end={6}", pad, block.parent, block.seg, block.off, block.len, block.name, block.end); indent++; pad = new String('.', indent); break; } case SYM.S_COMPILE2: { // 0x1116 CompileSym com; bits.ReadUInt32(out com.flags); bits.ReadUInt16(out com.machine); bits.ReadUInt16(out com.verFEMajor); bits.ReadUInt16(out com.verFEMinor); bits.ReadUInt16(out com.verFEBuild); bits.ReadUInt16(out com.verMajor); bits.ReadUInt16(out com.verMinor); bits.ReadUInt16(out com.verBuild); bits.ReadCString(out com.verSt); Console.WriteLine(" {0}COMP: flg={1:x4} mach={2:x2} [{3}] {4}.{5}.{6}.{7}.{8}.{9}", pad, com.flags, com.machine, com.verSt, com.verFEMajor, com.verFEMinor, com.verFEBuild, com.verMajor, com.verMinor, com.verBuild); break; } case SYM.S_BPREL32: { // 0x110b BpRelSym32 bp; bits.ReadInt32(out bp.off); bits.ReadUInt32(out bp.typind); bits.ReadCString(out bp.name); Console.WriteLine(" {0}BPRL: ti={1:x8} [{2}] off={3,6}", pad, bp.typind, bp.name, bp.off); break; } case SYM.S_LPROC32: // 0x110f case SYM.S_GPROC32: { // 0x1110 ProcSym32 proc; bits.ReadUInt32(out proc.parent); bits.ReadUInt32(out proc.end); bits.ReadUInt32(out proc.next); bits.ReadUInt32(out proc.len); bits.ReadUInt32(out proc.dbgStart); bits.ReadUInt32(out proc.dbgEnd); bits.ReadUInt32(out proc.typind); bits.ReadUInt32(out proc.off); bits.ReadUInt16(out proc.seg); bits.ReadUInt8(out proc.flags); bits.ReadCString(out proc.name); Console.WriteLine(" {0}PROC: ti={1,5} [{2}] addr={3:x4}:{4:x8} len={5} f={6:x4}, end={7}", pad, proc.typind, proc.name, proc.seg, proc.off, proc.len, proc.flags, proc.end); if (proc.parent != 0 || proc.next != 0) { Console.WriteLine(" !!! Warning parent={0}, next={1}", proc.parent, proc.next); } indent++; pad = new String('.', indent); break; } case SYM.S_MANSLOT: { // 0x1120 AttrSlotSym slot; bits.ReadUInt32(out slot.index); bits.ReadUInt32(out slot.typind); bits.ReadUInt32(out slot.offCod); bits.ReadUInt16(out slot.segCod); bits.ReadUInt16(out slot.flags); bits.ReadCString(out slot.name); Console.WriteLine(" {0}SLOT: ti={1:x8} [{2}] slot={3} flg={4:x4}", pad, slot.typind, slot.name, slot.index, slot.flags); if (slot.segCod != 0 || slot.offCod != 0) { Console.WriteLine(" !!! Warning: addr={0:x4}:{1:x8}", slot.segCod, slot.offCod); } break; } case SYM.S_UNAMESPACE: { // 0x1124 UnamespaceSym ns; bits.ReadCString(out ns.name); Console.WriteLine(" {0}NAME: using [{1}]", pad, ns.name); break; } case SYM.S_GMANPROC: // 0x112a case SYM.S_LMANPROC: { // 0x112b ManProcSym proc; int offset = bits.Position; bits.ReadUInt32(out proc.parent); bits.ReadUInt32(out proc.end); bits.ReadUInt32(out proc.next); bits.ReadUInt32(out proc.len); bits.ReadUInt32(out proc.dbgStart); bits.ReadUInt32(out proc.dbgEnd); bits.ReadUInt32(out proc.token); bits.ReadUInt32(out proc.off); bits.ReadUInt16(out proc.seg); bits.ReadUInt8(out proc.flags); bits.ReadUInt16(out proc.retReg); bits.ReadCString(out proc.name); Console.WriteLine(" {0}PROC: token={1:x8} [{2}] addr={3:x4}:{4:x8} len={5:x4} f={6:x4}, end={7}", pad, proc.token, proc.name, proc.seg, proc.off, proc.len, proc.flags, proc.end); if (proc.parent != 0 || proc.next != 0) { Console.WriteLine(" !!! Warning par={0}, pnext={1}", proc.parent, proc.next); } if (proc.dbgStart != 0 || proc.dbgEnd != 0) { Console.WriteLine(" !!! Warning DBG start={0}, end={1}", proc.dbgStart, proc.dbgEnd); } indent++; pad = new String('.', indent); break; } case SYM.S_END: { // 0x0006 indent--; pad = new String('.', indent); Console.WriteLine(" {0}END {1}", pad, bits.Position - 4); break; } case SYM.S_SECTION: { // 0x1136 SectionSym sect; bits.ReadUInt16(out sect.isec); bits.ReadUInt8(out sect.align); bits.ReadUInt8(out sect.bReserved); bits.ReadUInt32(out sect.rva); bits.ReadUInt32(out sect.cb); bits.ReadUInt32(out sect.characteristics); bits.ReadCString(out sect.name); Console.WriteLine(" {0}SECT: sec={1,4} align={2}, flags={3:x8} [{4}]", pad, sect.isec, sect.align, sect.characteristics, sect.name); break; } case SYM.S_COFFGROUP: { // 0x1137 CoffGroupSym group; bits.ReadUInt32(out group.cb); bits.ReadUInt32(out group.characteristics); bits.ReadUInt32(out group.off); bits.ReadUInt16(out group.seg); bits.ReadCString(out group.name); Console.WriteLine(" {0}CGRP: flags={1:x8} [{2}] addr={3:x4}:{4:x8}", pad, group.characteristics, group.name, group.seg, group.off); break; } case SYM.S_THUNK32: { // 0x1102 ThunkSym32 thunk; bits.ReadUInt32(out thunk.parent); bits.ReadUInt32(out thunk.end); bits.ReadUInt32(out thunk.next); bits.ReadUInt32(out thunk.off); bits.ReadUInt16(out thunk.seg); bits.ReadUInt16(out thunk.len); bits.ReadUInt8(out thunk.ord); bits.ReadCString(out thunk.name); Console.WriteLine(" {0}THNK: addr={1:x4}:{2:x8} [{3}], end={4}", pad, thunk.seg, thunk.off, thunk.name, thunk.end); indent++; pad = new String('.', indent); break; } default: { Console.WriteLine(" {0}{1}:", pad, cv); Dump(bits.Buffer, star + 2, stop); break; } } bits.Position = stop; } if (indent != 0) { throw new Exception("indent isn't 0."); } }
static void DumpLines(BitAccess bits, int begin, int limit) { uint lastAddr = 0; // Read the files first Console.WriteLine(" Lines:"); bits.Position = begin; while (bits.Position < limit) { int sig; int siz; bits.ReadInt32(out sig); bits.ReadInt32(out siz); int place = bits.Position; int endSym = bits.Position + siz; switch ((DEBUG_S_SUBSECTION)sig) { case DEBUG_S_SUBSECTION.FILECHKSMS: int beg = bits.Position; while (bits.Position < endSym) { CV_FileCheckSum chk; int nif = bits.Position - beg; bits.ReadUInt32(out chk.name); bits.ReadUInt8(out chk.len); bits.ReadUInt8(out chk.type); int where = bits.Position; bits.Position += chk.len; bits.Align(4); Console.WriteLine(" nif={0,4}, ni={1,5}, type={2:x2}, len={3}", nif, chk.name, chk.type, chk.len); Dump(bits.Buffer, where, where + chk.len); } bits.Position = endSym; break; case DEBUG_S_SUBSECTION.LINES: bits.Position = endSym; break; default: Console.WriteLine(" ??? {0}", (DEBUG_S_SUBSECTION)sig); Dump(bits.Buffer, bits.Position, bits.Position + siz); bits.Position = endSym; break; } } // Read the lines next. bits.Position = begin; while (bits.Position < limit) { int sig; int siz; bits.ReadInt32(out sig); bits.ReadInt32(out siz); int endSym = bits.Position + siz; switch ((DEBUG_S_SUBSECTION)sig) { case DEBUG_S_SUBSECTION.LINES: { CV_LineSection sec; bits.ReadUInt32(out sec.off); bits.ReadUInt16(out sec.sec); bits.ReadUInt16(out sec.flags); bits.ReadUInt32(out sec.cod); Console.WriteLine(" addr={0:x4}:{1:x8}, flg={2:x4}, cod={3,8}", sec.sec, sec.off, sec.flags, sec.cod); if (sec.off < lastAddr) { throw new PdbDebugException("address {0} follows {1}", sec.off, lastAddr); } else if (sec.off > lastAddr) { lastAddr = sec.off; } while (bits.Position < endSym) { CV_SourceFile file; bits.ReadUInt32(out file.index); bits.ReadUInt32(out file.count); bits.ReadUInt32(out file.linsiz); // Size of payload. Console.WriteLine(" nif={0,4}, cnt={1,4}", file.index, file.count); int plin = bits.Position; int pcol = bits.Position + 8 * (int)file.count; //Dump(bits.Buffer, bits.Position, bits.Position + file.linsiz); for (int i = 0; i < file.count; i++) { CV_Line line; CV_Column column = new CV_Column(); bits.Position = plin + 8 * i; bits.ReadUInt32(out line.offset); bits.ReadUInt32(out line.flags); uint delta = (line.flags & 0x7f000000) >> 24; bool statement = ((line.flags & 0x80000000) == 0); if ((sec.flags & 1) != 0) { bits.Position = pcol + 4 * i; bits.ReadUInt16(out column.offColumnStart); bits.ReadUInt16(out column.offColumnEnd); } Console.WriteLine(" pc={0:x8} # {1,8}.{2,2}.{3,2}", line.offset, line.flags & 0xffffff, column.offColumnStart, column.offColumnEnd); } } break; } } bits.Position = endSym; } }
public BitSet(BitAccess bits) { bits.ReadInt32(out size); // 0..3 : Number of words words = new uint[size]; bits.ReadUInt32(words); }