?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedump: Added support for dumping FPO streams.
[wine/multimedia.git] / tools / winedump / pdb.c
blob89146d50c3972e1dc3d7159076eca65b252ab36b
1 /*
2 * PDB dumping utility
3 *
4 * Copyright 2006 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #include <time.h>
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34 #ifdef HAVE_SYS_STAT_H
35 # include <sys/stat.h>
36 #endif
37 #ifdef HAVE_SYS_MMAN_H
38 #include <sys/mman.h>
39 #endif
40 #include <fcntl.h>
41
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
44 #include "windef.h"
45 #include "winbase.h"
46 #include "winedump.h"
47 #include "wine/mscvpdb.h"
48
49 struct pdb_reader
50 {
51 union
52 {
53 struct
54 {
55 const struct PDB_JG_HEADER* header;
56 const struct PDB_JG_TOC* toc;
57 } jg;
58 struct
59 {
60 const struct PDB_DS_HEADER* header;
61 const struct PDB_DS_TOC* toc;
62 } ds;
63 } u;
64 void* (*read_file)(struct pdb_reader*, DWORD);
65 DWORD file_used[1024];
66 };
67
68 static void* pdb_jg_read(const struct PDB_JG_HEADER* pdb, const WORD* block_list, int size)
69 {
70 int i, nBlocks;
71 BYTE* buffer;
72
73 if (!size) return NULL;
74
75 nBlocks = (size + pdb->block_size - 1) / pdb->block_size;
76 buffer = malloc(nBlocks * pdb->block_size);
77
78 for (i = 0; i < nBlocks; i++)
79 memcpy(buffer + i * pdb->block_size,
80 (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size);
81
82 return buffer;
83 }
84
85 static void* pdb_jg_read_file(struct pdb_reader* reader, DWORD file_nr)
86 {
87 const WORD* block_list;
88 DWORD i;
89
90 if (!reader->u.jg.toc || file_nr >= reader->u.jg.toc->num_files) return NULL;
91
92 reader->file_used[file_nr / 32] |= 1 << (file_nr % 32);
93 if (reader->u.jg.toc->file[file_nr].size == 0 ||
94 reader->u.jg.toc->file[file_nr].size == 0xFFFFFFFF)
95 return NULL;
96 block_list = (const WORD*) &reader->u.jg.toc->file[reader->u.jg.toc->num_files];
97 for (i = 0; i < file_nr; i++)
98 block_list += (reader->u.jg.toc->file[i].size +
99 reader->u.jg.header->block_size - 1) / reader->u.jg.header->block_size;
100
101 return pdb_jg_read(reader->u.jg.header, block_list,
102 reader->u.jg.toc->file[file_nr].size);
103 }
104
105 static void pdb_jg_init(struct pdb_reader* reader)
106 {
107 reader->u.jg.header = PRD(0, sizeof(struct PDB_JG_HEADER));
108 reader->read_file = pdb_jg_read_file;
109 reader->u.jg.toc = pdb_jg_read(reader->u.jg.header,
110 reader->u.jg.header->toc_block,
111 reader->u.jg.header->toc.size);
112 memset(reader->file_used, 0, sizeof(reader->file_used));
113 }
114
115 static DWORD pdb_get_num_files(const struct pdb_reader* reader)
116 {
117 if (reader->read_file == pdb_jg_read_file)
118 return reader->u.jg.toc->num_files;
119 else
120 return reader->u.ds.toc->num_files;
121 }
122
123 static DWORD pdb_get_file_size(const struct pdb_reader* reader, unsigned idx)
124 {
125 if (reader->read_file == pdb_jg_read_file)
126 return reader->u.jg.toc->file[idx].size;
127 else
128 return reader->u.ds.toc->file_size[idx];
129 }
130
131 static void pdb_exit(struct pdb_reader* reader)
132 {
133 #if 1
134 unsigned i;
135 unsigned char* file;
136 DWORD size;
137
138 for (i = 0; i < pdb_get_num_files(reader); i++)
139 {
140 if (reader->file_used[i / 32] & (1 << (i % 32))) continue;
141
142 file = reader->read_file(reader, i);
143 if (!file) continue;
144
145 size = pdb_get_file_size(reader, i);
146
147 printf("File --unused-- #%d (%x)\n", i, size);
148 dump_data(file, size, " ");
149 free(file);
150 }
151 #endif
152 if (reader->read_file == pdb_jg_read_file)
153 free((char*)reader->u.jg.toc);
154 else
155 free((char*)reader->u.ds.toc);
156 }
157
158 static void pdb_dump_symbols(struct pdb_reader* reader)
159 {
160 PDB_SYMBOLS* symbols;
161 unsigned char* modimage;
162 const char* file;
163 char* filesimage;
164 DWORD filessize = 0;
165
166 symbols = reader->read_file(reader, 3);
167
168 if (!symbols) return;
169
170 switch (symbols->version)
171 {
172 case 0: /* VC 4.0 */
173 case 19960307: /* VC 5.0 */
174 case 19970606: /* VC 6.0 */
175 case 19990903: /* VC 7.0 */
176 break;
177 default:
178 printf("-Unknown symbol info version %d\n", symbols->version);
179 }
180 printf("Symbols:\n"
181 "\tsignature: %08x\n"
182 "\tversion: %u\n"
183 "\tunknown: %08x\n"
184 "\thash1_file: %08x\n"
185 "\thash2_file: %08x\n"
186 "\tgsym_file: %04x\n"
187 "\tunknown1: %04x\n"
188 "\tmodule_size: %08x\n"
189 "\toffset_size: %08x\n"
190 "\thash_size: %08x\n"
191 "\tsrc_module_size %08x\n"
192 "\tpdbimport_size %08x\n"
193 "\tresvd[0] %08x\n"
194 "\tresvd[1] %08x\n"
195 "\tresvd[2] %08x\n"
196 "\tresvd[3] %08x\n"
197 "\tresvd[4] %08x\n",
198 symbols->signature,
199 symbols->version,
200 symbols->unknown,
201 symbols->hash1_file,
202 symbols->hash2_file,
203 symbols->gsym_file,
204 symbols->unknown1,
205 symbols->module_size,
206 symbols->offset_size,
207 symbols->hash_size,
208 symbols->srcmodule_size,
209 symbols->pdbimport_size,
210 symbols->resvd[0],
211 symbols->resvd[1],
212 symbols->resvd[2],
213 symbols->resvd[3],
214 symbols->resvd[4]);
215
216 if (symbols->offset_size)
217 {
218 const BYTE* src;
219
220 printf("\t----------offsets------------\n");
221 src = (const BYTE*)((const char*)symbols + sizeof(PDB_SYMBOLS) + symbols->module_size);
222 dump_data(src, symbols->offset_size, " ");
223 }
224
225 filesimage = reader->read_file(reader, 12); /* FIXME: really fixed ??? */
226 if (filesimage)
227 {
228 if (*(const DWORD*)filesimage == 0xeffeeffe)
229 {
230 filessize = *(const DWORD*)(filesimage + 8);
231 }
232 else
233 {
234 printf("wrong header %x expecting 0xeffeeffe\n", *(const DWORD*)filesimage);
235 free(filesimage);
236 filesimage = NULL;
237 }
238 }
239
240 if (symbols->srcmodule_size)
241 {
242 const PDB_SYMBOL_SOURCE*src;
243 int i, j, cfile;
244 const WORD* indx;
245 const DWORD* offset;
246 const char* start_cstr;
247 const char* cstr;
248
249 printf("\t----------src module------------\n");
250 src = (const PDB_SYMBOL_SOURCE*)((const char*)symbols + sizeof(PDB_SYMBOLS) +
251 symbols->module_size + symbols->offset_size + symbols->hash_size);
252 printf("\tSource Modules\n"
253 "\t\tnModules: %u\n"
254 "\t\tnSrcFiles: %u\n",
255 src->nModules, src->nSrcFiles);
256
257 /* usage of table seems to be as follows:
258 * two arrays of WORD (src->nModules as size)
259 * - first array contains index into files for "module" compilation
260 * (module = compilation unit ??)
261 * - second array contains the number of source files in module
262 * an array of DWORD (src->nSrcFiles as size)
263 * - contains offset (in following string table) of the source file name
264 * a string table
265 * - each string is a pascal string (ie. with its length as first BYTE) or
266 * 0-terminated string (depending on version)
267 */
268 indx = &src->table[src->nModules];
269 offset = (const DWORD*)&src->table[2 * src->nModules];
270 cstr = (const char*)&src->table[2 * (src->nModules + src->nSrcFiles)];
271 start_cstr = cstr;
272
273 for (i = cfile = 0; i < src->nModules; i++)
274 {
275 printf("\t\tModule[%2d]:\n", i);
276 for (j = 0; j < indx[i]; j++, cfile++)
277 {
278 /* FIXME: in some cases, it's a p_string but WHEN ? */
279 if (src->table[cfile] < src->nSrcFiles &&
280 cstr + offset[src->table[cfile]] >= (const char*)start_cstr /* wrap around */ &&
281 cstr + offset[src->table[cfile]] < (const char*)src + symbols->srcmodule_size)
282 printf("\t\t\tSource file: %s\n", cstr + offset[src->table[cfile]]);
283 else
284 printf("\t\t\tSource file: <<out of bounds>>\n");
285 }
286 }
287 }
288 if (symbols->pdbimport_size)
289 {
290 const PDB_SYMBOL_IMPORT* imp;
291 const char* first;
292 const char* last;
293 const char* ptr;
294
295 printf("\t------------import--------------\n");
296 imp = (const PDB_SYMBOL_IMPORT*)((const char*)symbols + sizeof(PDB_SYMBOLS) +
297 symbols->module_size + symbols->offset_size +
298 symbols->hash_size + symbols->srcmodule_size);
299 first = (const char*)imp;
300 last = (const char*)imp + symbols->pdbimport_size;
301 while (imp < (const PDB_SYMBOL_IMPORT*)last)
302 {
303 ptr = (const char*)imp + sizeof(*imp) + strlen(imp->filename);
304 printf("\tImport: %lx\n"
305 "\t\tUnknown1: %08x\n"
306 "\t\tUnknown2: %08x\n"
307 "\t\tTimeDateStamp: %08x\n"
308 "\t\tAge: %08u\n"
309 "\t\tfile1: %s\n"
310 "\t\tfile2: %s\n",
311 (ULONG_PTR)((const char*)imp - (const char*)first),
312 imp->unknown1,
313 imp->unknown2,
314 imp->TimeDateStamp,
315 imp->Age,
316 imp->filename,
317 ptr);
318 imp = (const PDB_SYMBOL_IMPORT*)(first + ((ptr - first + strlen(ptr) + 1 + 3) & ~3));
319 }
320 }
321
322 /* Read global symbol table */
323 modimage = reader->read_file(reader, symbols->gsym_file);
324 if (modimage)
325 {
326 printf("\t------------globals-------------\n");
327 codeview_dump_symbols(modimage, pdb_get_file_size(reader, symbols->gsym_file));
328 free(modimage);
329 }
330
331 /* Read per-module symbol / linenumber tables */
332 file = (const char*)symbols + sizeof(PDB_SYMBOLS);
333 while (file - (const char*)symbols < sizeof(PDB_SYMBOLS) + symbols->module_size)
334 {
335 int file_nr, symbol_size, lineno_size;
336 const char* file_name;
337
338 if (symbols->version < 19970000)
339 {
340 const PDB_SYMBOL_FILE* sym_file = (const PDB_SYMBOL_FILE*) file;
341 file_nr = sym_file->file;
342 file_name = sym_file->filename;
343 symbol_size = sym_file->symbol_size;
344 lineno_size = sym_file->lineno_size;
345 printf("\t--------symbol file----------- %s\n", file_name);
346 printf("\tgot symbol_file\n"
347 "\t\tunknown1: %08x\n"
348 "\t\trange\n"
349 "\t\t\tsegment: %04x\n"
350 "\t\t\tpad1: %04x\n"
351 "\t\t\toffset: %08x\n"
352 "\t\t\tsize: %08x\n"
353 "\t\t\tcharacteristics: %08x\n"
354 "\t\t\tindex: %04x\n"
355 "\t\t\tpad2: %04x\n"
356 "\t\tflag: %04x\n"
357 "\t\tfile: %04x\n"
358 "\t\tsymb size: %08x\n"
359 "\t\tline size: %08x\n"
360 "\t\tunknown2: %08x\n"
361 "\t\tnSrcFiles: %08x\n"
362 "\t\tattribute: %08x\n",
363 sym_file->unknown1,
364 sym_file->range.segment,
365 sym_file->range.pad1,
366 sym_file->range.offset,
367 sym_file->range.size,
368 sym_file->range.characteristics,
369 sym_file->range.index,
370 sym_file->range.pad2,
371 sym_file->flag,
372 sym_file->file,
373 sym_file->symbol_size,
374 sym_file->lineno_size,
375 sym_file->unknown2,
376 sym_file->nSrcFiles,
377 sym_file->attribute);
378 }
379 else
380 {
381 const PDB_SYMBOL_FILE_EX* sym_file = (const PDB_SYMBOL_FILE_EX*) file;
382 file_nr = sym_file->file;
383 file_name = sym_file->filename;
384 symbol_size = sym_file->symbol_size;
385 lineno_size = sym_file->lineno_size;
386 printf("\t--------symbol file----------- %s\n", file_name);
387 printf("\t\tunknown1: %08x\n"
388 "\t\trange\n"
389 "\t\t\tsegment: %04x\n"
390 "\t\t\tpad1: %04x\n"
391 "\t\t\toffset: %08x\n"
392 "\t\t\tsize: %08x\n"
393 "\t\t\tcharacteristics: %08x\n"
394 "\t\t\tindex: %04x\n"
395 "\t\t\tpad2: %04x\n"
396 "\t\t\ttimestamp: %08x\n"
397 "\t\t\tunknown: %08x\n"
398 "\t\tflag: %04x\n"
399 "\t\tfile: %04x\n"
400 "\t\tsymb size: %08x\n"
401 "\t\tline size: %08x\n"
402 "\t\tunknown2: %08x\n"
403 "\t\tnSrcFiles: %08x\n"
404 "\t\tattribute: %08x\n"
405 "\t\treserved/0: %08x\n"
406 "\t\treserved/1: %08x\n",
407 sym_file->unknown1,
408 sym_file->range.segment,
409 sym_file->range.pad1,
410 sym_file->range.offset,
411 sym_file->range.size,
412 sym_file->range.characteristics,
413 sym_file->range.index,
414 sym_file->range.pad2,
415 sym_file->range.timestamp,
416 sym_file->range.unknown,
417 sym_file->flag,
418 sym_file->file,
419 sym_file->symbol_size,
420 sym_file->lineno_size,
421 sym_file->unknown2,
422 sym_file->nSrcFiles,
423 sym_file->attribute,
424 sym_file->reserved[0],
425 sym_file->reserved[1]);
426 }
427 modimage = reader->read_file(reader, file_nr);
428 if (modimage)
429 {
430 int total_size = pdb_get_file_size(reader, file_nr);
431
432 if (symbol_size)
433 codeview_dump_symbols((const char*)modimage + sizeof(DWORD), symbol_size);
434
435 /* line number info */
436 if (lineno_size)
437 codeview_dump_linetab((const char*)modimage + symbol_size, lineno_size, TRUE, " ");
438 /* anyway, lineno_size doesn't see to really be the size of the line number information, and
439 * it's not clear yet when to call for linetab2...
440 */
441 codeview_dump_linetab2((const char*)modimage + symbol_size + lineno_size,
442 total_size - (symbol_size + lineno_size),
443 filesimage + 12, filessize, " ");
444 /* what's that part ??? */
445 if (0)
446 dump_data(modimage + symbol_size + lineno_size, total_size - (symbol_size + lineno_size), " ");
447 free(modimage);
448 }
449
450 file_name += strlen(file_name) + 1;
451 file = (char*)((DWORD_PTR)(file_name + strlen(file_name) + 1 + 3) & ~3);
452 }
453 free(symbols);
454 free(filesimage);
455 }
456
457 static void pdb_dump_types(struct pdb_reader* reader)
458 {
459 PDB_TYPES* types = NULL;
460
461 types = reader->read_file(reader, 2);
462
463 switch (types->version)
464 {
465 case 19950410: /* VC 4.0 */
466 case 19951122:
467 case 19961031: /* VC 5.0 / 6.0 */
468 case 19990903: /* VC 7.0 */
469 case 20040203: /* VC 8.0 */
470 break;
471 default:
472 printf("-Unknown type info version %d\n", types->version);
473 }
474
475 /* Read type table */
476 printf("Types:\n"
477 "\tversion: %u\n"
478 "\ttype_offset: %08x\n"
479 "\tfirst_index: %x\n"
480 "\tlast_index: %x\n"
481 "\ttype_size: %x\n"
482 "\tfile: %x\n"
483 "\tpad: %x\n"
484 "\thash_size: %x\n"
485 "\thash_base: %x\n"
486 "\thash_offset: %x\n"
487 "\thash_len: %x\n"
488 "\tsearch_offset: %x\n"
489 "\tsearch_len: %x\n"
490 "\tunknown_offset: %x\n"
491 "\tunknown_len: %x\n",
492 types->version,
493 types->type_offset,
494 types->first_index,
495 types->last_index,
496 types->type_size,
497 types->file,
498 types->pad,
499 types->hash_size,
500 types->hash_base,
501 types->hash_offset,
502 types->hash_len,
503 types->search_offset,
504 types->search_len,
505 types->unknown_offset,
506 types->unknown_len);
507 codeview_dump_types_from_block((const char*)types + types->type_offset, types->type_size);
508 free(types);
509 }
510
511 static void pdb_dump_fpo(struct pdb_reader* reader)
512 {
513 FPO_DATA* fpo;
514 PDB_FPO_DATA* fpoext;
515 unsigned i, size, strsize;
516 char* strbase;
517 const char* frame_type[4] = {"Fpo", "Trap", "Tss", "NonFpo"};
518
519 fpo = reader->read_file(reader, 5);
520 size = pdb_get_file_size(reader, 5);
521 if (fpo && (size % sizeof(*fpo)) == 0)
522 {
523 size /= sizeof(*fpo);
524 printf("FPO data:\n\t Start Length #loc #pmt #prolog #reg frame SEH /BP\n");
525 for (i = 0; i < size; i++)
526 {
527 printf("\t%08x %08x %4d %4d %7d %4d %6s %c %c\n",
528 fpo[i].ulOffStart, fpo[i].cbProcSize, fpo[i].cdwLocals, fpo[i].cdwParams,
529 fpo[i].cbProlog, fpo[i].cbRegs, frame_type[fpo[i].cbFrame],
530 fpo[i].fHasSEH ? 'Y' : 'N', fpo[i].fUseBP ? 'Y' : 'N');
531 }
532 }
533 free(fpo);
534
535 strbase = reader->read_file(reader, 12); /* FIXME: really fixed ??? */
536 if (!strbase) return;
537
538 if (*(const DWORD*)strbase != 0xeffeeffe)
539 {
540 printf("wrong header %x expecting 0xeffeeffe\n", *(const DWORD*)strbase);
541 free(strbase);
542 return;
543 }
544 strsize = *(const DWORD*)(strbase + 8);
545 fpoext = reader->read_file(reader, 10);
546 size = pdb_get_file_size(reader, 10);
547 if (fpoext && (size % sizeof(*fpoext)) == 0)
548 {
549 size /= sizeof(*fpoext);
550 printf("FPO data (extended):\n"
551 "\t Start Length Locals Params MaxStack Prolog #SavedRegs Flags Command\n");
552 for (i = 0; i < size; i++)
553 {
554 printf("\t%08x %08x %8x %8x %8x %6x %8x %08x %s\n",
555 fpoext[i].start, fpoext[i].func_size, fpoext[i].locals_size, fpoext[i].params_size,
556 fpoext[i].maxstack_size, fpoext[i].prolog_size, fpoext[i].savedregs_size, fpoext[i].flags,
557 fpoext[i].str_offset < strsize ? strbase + 12 + fpoext[i].str_offset : "<out of bounds>");
558 }
559 }
560 free(fpoext);
561 free(strbase);
562 }
563
564 static const char pdb2[] = "Microsoft C/C++ program database 2.00";
565
566 static void pdb_jg_dump(void)
567 {
568 struct pdb_reader reader;
569 struct PDB_JG_ROOT* root = NULL;
570
571 /*
572 * Read in TOC and well-known files
573 */
574 pdb_jg_init(&reader);
575 printf("Header (JG):\n"
576 "\tident: %.*s\n"
577 "\tsignature: %08x\n"
578 "\tblock_size: %08x\n"
579 "\tfree_list: %04x\n"
580 "\ttotal_alloc:%04x\n",
581 (int)sizeof(pdb2) - 1, reader.u.jg.header->ident,
582 reader.u.jg.header->signature,
583 reader.u.jg.header->block_size,
584 reader.u.jg.header->free_list,
585 reader.u.jg.header->total_alloc);
586
587 root = reader.read_file(&reader, 1);
588
589 if (root)
590 {
591 printf("Root:\n"
592 "\tVersion: %u\n"
593 "\tTimeDateStamp: %08x\n"
594 "\tAge: %08x\n"
595 "\tnames: %.*s\n",
596 root->Version,
597 root->TimeDateStamp,
598 root->Age,
599 (unsigned)root->cbNames,
600 root->names);
601
602 /* Check for unknown versions */
603 switch (root->Version)
604 {
605 case 19950623: /* VC 4.0 */
606 case 19950814:
607 case 19960307: /* VC 5.0 */
608 case 19970604: /* VC 6.0 */
609 break;
610 default:
611 printf("-Unknown root block version %d\n", root->Version);
612 }
613 free(root);
614 }
615 else printf("-Unable to get root\n");
616
617 pdb_dump_types(&reader);
618 #if 0
619 /* segments info, index is unknown */
620 {
621 const void* segs = pdb_read_file(pdb, toc, 8); /* FIXME which index ??? */
622 const void* ptr = segs;
623
624 if (segs) while (ptr < segs + toc->file[8].size)
625 {
626 printf("Segment %s\n", (const char*)ptr);
627 ptr += (strlen(ptr) + 1 + 3) & ~3;
628 printf("\tdword[0]: %08lx\n", *(DWORD*)ptr); ptr += 4;
629 printf("\tdword[1]: %08lx\n", *(DWORD*)ptr); ptr += 4;
630 printf("\tdword[2]: %08lx\n", *(DWORD*)ptr); ptr += 4;
631 printf("\tdword[3]: %08lx\n", *(DWORD*)ptr); ptr += 4;
632 printf("\tdword[4]: %08lx\n", *(DWORD*)ptr); ptr += 4;
633 printf("\tdword[5]: %08lx\n", *(DWORD*)ptr); ptr += 4;
634 printf("\tdword[6]: %08lx\n", *(DWORD*)ptr); ptr += 4;
635 printf("\tdword[7]: %08lx\n", *(DWORD*)ptr); ptr += 4;
636 }
637 free(segs);
638 }
639 #endif
640
641 pdb_dump_symbols(&reader);
642 pdb_exit(&reader);
643 }
644
645 static void* pdb_ds_read(const struct PDB_DS_HEADER* header, const DWORD* block_list, int size)
646 {
647 int i, nBlocks;
648 BYTE* buffer;
649
650 if (!size) return NULL;
651
652 nBlocks = (size + header->block_size - 1) / header->block_size;
653 buffer = malloc(nBlocks * header->block_size);
654
655 for (i = 0; i < nBlocks; i++)
656 memcpy(buffer + i * header->block_size,
657 (const char*)header + block_list[i] * header->block_size, header->block_size);
658
659 return buffer;
660 }
661
662 static void* pdb_ds_read_file(struct pdb_reader* reader, DWORD file_number)
663 {
664 const DWORD* block_list;
665 DWORD i;
666
667 if (!reader->u.ds.toc || file_number >= reader->u.ds.toc->num_files) return NULL;
668
669 reader->file_used[file_number / 32] |= 1 << (file_number % 32);
670 if (reader->u.ds.toc->file_size[file_number] == 0 ||
671 reader->u.ds.toc->file_size[file_number] == 0xFFFFFFFF)
672 return NULL;
673 block_list = reader->u.ds.toc->file_size + reader->u.ds.toc->num_files;
674 for (i = 0; i < file_number; i++)
675 block_list += (reader->u.ds.toc->file_size[i] + reader->u.ds.header->block_size - 1) /
676 reader->u.ds.header->block_size;
677
678 return pdb_ds_read(reader->u.ds.header, block_list, reader->u.ds.toc->file_size[file_number]);
679 }
680
681 static BOOL pdb_ds_init(struct pdb_reader* reader)
682 {
683 reader->u.ds.header = PRD(0, sizeof(*reader->u.ds.header));
684 if (!reader->u.ds.header) return FALSE;
685 reader->read_file = pdb_ds_read_file;
686 reader->u.ds.toc = pdb_ds_read(reader->u.ds.header,
687 (const DWORD*)((const char*)reader->u.ds.header + reader->u.ds.header->toc_page * reader->u.ds.header->block_size),
688 reader->u.ds.header->toc_size);
689 memset(reader->file_used, 0, sizeof(reader->file_used));
690 return TRUE;
691 }
692
693 static const char pdb7[] = "Microsoft C/C++ MSF 7.00";
694
695 static void pdb_ds_dump(void)
696 {
697 struct pdb_reader reader;
698 struct PDB_DS_ROOT* root;
699
700 pdb_ds_init(&reader);
701 printf("Header (DS)\n"
702 "\tsignature: %.*s\n"
703 "\tblock_size: %08x\n"
704 "\tunknown1: %08x\n"
705 "\tnum_pages: %08x\n"
706 "\ttoc_size: %08x\n"
707 "\tunknown2: %08x\n"
708 "\ttoc_page: %08x\n",
709 (int)sizeof(pdb7) - 1, reader.u.ds.header->signature,
710 reader.u.ds.header->block_size,
711 reader.u.ds.header->unknown1,
712 reader.u.ds.header->num_pages,
713 reader.u.ds.header->toc_size,
714 reader.u.ds.header->unknown2,
715 reader.u.ds.header->toc_page);
716
717 /* files:
718 * 0: JG says old toc pages, I'd say free pages (tbc, low prio)
719 * 1: root structure
720 * 2: types
721 * 3: modules
722 * 5: FPO data
723 * 8: segments
724 * 10: extended FPO data
725 * 12: string table (FPO unwinder, files for linetab2...)
726 */
727 root = reader.read_file(&reader, 1);
728 if (root)
729 {
730 const char* ptr;
731
732 printf("Root:\n"
733 "\tVersion: %u\n"
734 "\tTimeDateStamp: %08x\n"
735 "\tAge: %08x\n"
736 "\tguid %s\n"
737 "\tcbNames: %08x\n",
738 root->Version,
739 root->TimeDateStamp,
740 root->Age,
741 get_guid_str(&root->guid),
742 root->cbNames);
743 for (ptr = &root->names[0]; ptr < &root->names[0] + root->cbNames; ptr += strlen(ptr) + 1)
744 printf("\tString: %s\n", ptr);
745 /* follows an unknown list of DWORDs */
746 free(root);
747 }
748 else printf("-Unable to get root\n");
749
750 pdb_dump_types(&reader);
751 pdb_dump_symbols(&reader);
752 pdb_dump_fpo(&reader);
753
754 pdb_exit(&reader);
755 }
756
757 enum FileSig get_kind_pdb(void)
758 {
759 const char* head;
760
761 head = PRD(0, sizeof(pdb2) - 1);
762 if (head && !memcmp(head, pdb2, sizeof(pdb2) - 1))
763 return SIG_PDB;
764 head = PRD(0, sizeof(pdb7) - 1);
765 if (head && !memcmp(head, pdb7, sizeof(pdb7) - 1))
766 return SIG_PDB;
767 return SIG_UNKNOWN;
768 }
769
770 void pdb_dump(void)
771 {
772 const char* head;
773
774 /* init_types(); */
775 head = PRD(0, sizeof(pdb2) - 1);
776 if (head && !memcmp(head, pdb2, sizeof(pdb2) - 1))
777 {
778 pdb_jg_dump();
779 return;
780 }
781 head = PRD(0, sizeof(pdb7) - 1);
782 if (head && !memcmp(head, pdb7, sizeof(pdb7) - 1))
783 {
784 pdb_ds_dump();
785 return;
786 }
787 printf("Unrecognized header %s\n", head);
788 }
Maarten's multimedia branch