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