Пример #1
0
        public PDBFile(FileStream stream)
        {
            this.fs          = stream;
            this.StreamTable = Services.GetService <StreamTableReader>();

            this.mf       = MemoryMappedFile.CreateFromFile(stream, null, 0, MemoryMappedFileAccess.Read, HandleInheritability.Inheritable, true);
            this.FileType = DetectPdbType();

            Services.AddService <PDBFile>(this);

            //$TODO
            if (this.FileType == PDBType.Small)
            {
                throw new NotImplementedException($"Small/Old/JG PDBs not supported/tested yet");
            }


            MSFReader msf = new MSFReader(mf, stream.Length);

            Services.AddService <MSFReader>(msf);

            StreamTableReader streamTable;

            // init stream table
            {
                byte[] streamTableData = msf.StreamTable();
                streamTable = new StreamTableReader(Services, streamTableData);
            }
            Services.AddService <StreamTableReader>(streamTable);

            DBIReader dbi;

            // init DBI
            {
                byte[] dbiData = streamTable.GetStream(DefaultStreams.DBI);
                dbi = new DBIReader(Services, dbiData);
                OnDbiInit?.Invoke(dbi);
            }
            Services.AddService <DBIReader>(dbi);

            TPIReader tpi;

            // init TPI
            {
                byte[] tpiData = streamTable.GetStream(DefaultStreams.TPI);
                tpi = new TPIReader(Services, new SpanStream(tpiData));
                OnTpiInit?.Invoke(tpi);
            }
            Services.AddService <TPIReader>(tpi);

            TPIHashReader tpiHash = null;

            // init TPIHash
            if (tpi.Header.Hash.StreamNumber != -1)
            {
                byte[] tpiHashData = streamTable.GetStream(tpi.Header.Hash.StreamNumber);
                tpiHash = new TPIHashReader(Services, tpiHashData);
                Services.AddService <TPIHashReader>(tpiHash);
            }

            // init resolver
            TypeResolver resolver = new TypeResolver(Services);

            Services.AddService <TypeResolver>(resolver);


            // init Hasher
            HasherV2 hasher = new HasherV2(Services);

            Services.AddService <HasherV2>(hasher);

            PdbStreamReader nameMap;

            // init NameMap
            {
                byte[] nameMapData = streamTable.GetStream(DefaultStreams.PDB);
                nameMap = new PdbStreamReader(nameMapData);
            }
            Services.AddService <PdbStreamReader>(nameMap);

            NamedStreamTableReader namedStreamTable = new NamedStreamTableReader(Services);

            Services.AddService <NamedStreamTableReader>(namedStreamTable);

            UdtNameTableReader udtNameTable = null;
            // init UdtNameMap
            {
                byte[] namesData = namedStreamTable.GetStreamByName("/names");
                if (namesData != null)
                {
                    udtNameTable = new UdtNameTableReader(Services, namesData);
                    Services.AddService <UdtNameTableReader>(udtNameTable);
                }
            }
        }
Пример #2
0
        public PDBFile(FileStream stream)
        {
            this.fs      = stream;
            this.mf      = MemoryMappedFile.CreateFromFile(stream, null, 0, MemoryMappedFileAccess.Read, HandleInheritability.Inheritable, true);
            this.memSpan = new MemoryMappedSpan <byte>(mf, (int)fs.Length);

            this.StreamTable = Services.GetService <StreamTableReader>();
            Services.AddService <PDBFile>(this);

            this.Type = MSFReader.DetectPdbType(memSpan.GetSpan());

            MSFReader         msf         = null;
            StreamTableReader streamTable = null;

            if (Type != PDBType.Old)
            {
                switch (Type)
                {
                case PDBType.Big:
                    msf = new MSFReaderDS(memSpan.Memory);
                    break;

                case PDBType.Small:
                    msf = new MSFReaderJG(memSpan.Memory);
                    break;

                default:
                    throw new InvalidOperationException();
                }
                Services.AddService <MSFReader>(msf);

                // init stream table
                {
                    byte[] streamTableData = msf.StreamTable();
                    streamTable = new StreamTableReader(Services, streamTableData);
                }
                Services.AddService <StreamTableReader>(streamTable);

                DBIReader dbi;
                // init DBI
                {
                    byte[] dbiData = streamTable.GetStream(DefaultStreams.DBI);
                    dbi = new DBIReader(Services, dbiData);
                    OnDbiInit?.Invoke(dbi);
                }
                Services.AddService <DBIReader>(dbi);
            }

            TPIReader tpi;

            // init TPI
            {
                SpanStream tpiStream;
                if (Type != PDBType.Old)
                {
                    byte[] tpiData = streamTable.GetStream(DefaultStreams.TPI);
                    tpiStream = new SpanStream(tpiData);
                }
                else
                {
                    Span <byte> span   = memSpan.GetSpan();
                    JGHeaderOld header = span.Read <JGHeaderOld>(0);
                    // $TODO: the MSFReader interface should be abstracted into a more generic PDBHeader
                    Services.AddService <JGHeaderOld>(header);

                    tpiStream = new SpanStream(span.Slice(header.SIZE).ToArray());
                }
                tpi = new TPIReader(Services, tpiStream);
                OnTpiInit?.Invoke(tpi);
            }
            Services.AddService <TPIReader>(tpi);

            TPIHashReader tpiHash = null;

            // init TPIHash
            if (Type != PDBType.Old && tpi.Header.Hash.StreamNumber != -1)
            {
                byte[] tpiHashData = streamTable.GetStream(tpi.Header.Hash.StreamNumber);
                tpiHash = new TPIHashReader(Services, tpiHashData);
                Services.AddService <TPIHashReader>(tpiHash);
            }

            // init resolver
            TypeResolver resolver = new TypeResolver(Services);

            Services.AddService <TypeResolver>(resolver);


            // init Hasher
            HasherV2 hasher = new HasherV2(Services);

            Services.AddService <HasherV2>(hasher);

            if (Type != PDBType.Old)
            {
                {                 // init NameMap
                    byte[] nameMapData = streamTable.GetStream(DefaultStreams.PDB);

                    PdbStreamReader nameMap = new PdbStreamReader(nameMapData);
                    Services.AddService <PdbStreamReader>(nameMap);
                }

                NamedStreamTableReader namedStreamTable = new NamedStreamTableReader(Services);
                Services.AddService <NamedStreamTableReader>(namedStreamTable);

                {                 // init UdtNameMap
                    byte[] namesData = namedStreamTable.GetStreamByName("/names");
                    if (namesData != null)
                    {
                        UdtNameTableReader udtNameTable = new UdtNameTableReader(Services, namesData);
                        Services.AddService <UdtNameTableReader>(udtNameTable);
                    }
                }
            }
        }