4 * Copyright 2006 Eric Pouech
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.
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.
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
22 #include "wine/port.h"
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
34 #ifdef HAVE_SYS_STAT_H
35 # include <sys/stat.h>
37 #ifdef HAVE_SYS_MMAN_H
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
47 #include "wine/mscvpdb.h"
55 const struct PDB_JG_HEADER
* header
;
56 const struct PDB_JG_TOC
* toc
;
60 const struct PDB_DS_HEADER
* header
;
61 const struct PDB_DS_TOC
* toc
;
64 void* (*read_file
)(struct pdb_reader
*, DWORD
);
65 DWORD file_used
[1024];
68 static void* pdb_jg_read(const struct PDB_JG_HEADER
* pdb
, const WORD
* block_list
, int size
)
73 if (!size
) return NULL
;
75 nBlocks
= (size
+ pdb
->block_size
- 1) / pdb
->block_size
;
76 buffer
= malloc(nBlocks
* pdb
->block_size
);
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
);
85 static void* pdb_jg_read_file(struct pdb_reader
* reader
, DWORD file_nr
)
87 const WORD
* block_list
;
90 if (!reader
->u
.jg
.toc
|| file_nr
>= reader
->u
.jg
.toc
->num_files
) return NULL
;
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)
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
;
101 return pdb_jg_read(reader
->u
.jg
.header
, block_list
,
102 reader
->u
.jg
.toc
->file
[file_nr
].size
);
105 static void pdb_jg_init(struct pdb_reader
* reader
)
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
));
115 static DWORD
pdb_get_num_files(const struct pdb_reader
* reader
)
117 if (reader
->read_file
== pdb_jg_read_file
)
118 return reader
->u
.jg
.toc
->num_files
;
120 return reader
->u
.ds
.toc
->num_files
;
123 static DWORD
pdb_get_file_size(const struct pdb_reader
* reader
, unsigned idx
)
125 if (reader
->read_file
== pdb_jg_read_file
)
126 return reader
->u
.jg
.toc
->file
[idx
].size
;
128 return reader
->u
.ds
.toc
->file_size
[idx
];
131 static void pdb_exit(struct pdb_reader
* reader
)
138 for (i
= 0; i
< pdb_get_num_files(reader
); i
++)
140 if (reader
->file_used
[i
/ 32] & (1 << (i
% 32))) continue;
142 file
= reader
->read_file(reader
, i
);
145 size
= pdb_get_file_size(reader
, i
);
147 printf("File --unused-- #%d (%x)\n", i
, size
);
148 dump_data(file
, size
, " ");
152 if (reader
->read_file
== pdb_jg_read_file
)
153 free((char*)reader
->u
.jg
.toc
);
155 free((char*)reader
->u
.ds
.toc
);
158 static void pdb_dump_symbols(struct pdb_reader
* reader
)
160 PDB_SYMBOLS
* symbols
;
161 unsigned char* modimage
;
164 symbols
= reader
->read_file(reader
, 3);
166 if (!symbols
) return;
168 switch (symbols
->version
)
171 case 19960307: /* VC 5.0 */
172 case 19970606: /* VC 6.0 */
175 printf("-Unknown symbol info version %d\n", symbols
->version
);
178 "\tsignature: %08x\n"
181 "\thash1_file: %08x\n"
182 "\thash2_file: %08x\n"
183 "\tgsym_file: %08x\n"
184 "\tmodule_size: %08x\n"
185 "\toffset_size: %08x\n"
186 "\thash_size: %08x\n"
187 "\tsrc_module_size %08x\n"
188 "\tpdbimport_size %08x\n",
195 symbols
->module_size
,
196 symbols
->offset_size
,
198 symbols
->srcmodule_size
,
199 symbols
->pdbimport_size
);
201 if (symbols
->offset_size
)
205 printf("\t----------offsets------------\n");
206 src
= (const BYTE
*)((const char*)symbols
+ sizeof(PDB_SYMBOLS
) + symbols
->module_size
);
207 dump_data(src
, symbols
->offset_size
, " ");
210 if (symbols
->srcmodule_size
)
212 const PDB_SYMBOL_SOURCE
*src
;
216 const char* start_cstr
;
219 printf("\t----------src module------------\n");
220 src
= (const PDB_SYMBOL_SOURCE
*)((const char*)symbols
+ sizeof(PDB_SYMBOLS
) +
221 symbols
->module_size
+ symbols
->offset_size
+ symbols
->hash_size
);
222 printf("\tSource Modules\n"
224 "\t\tnSrcFiles: %u\n",
225 src
->nModules
, src
->nSrcFiles
);
227 /* usage of table seems to be as follows:
228 * two arrays of WORD (src->nModules as size)
229 * - first array contains index into files for "module" compilation
230 * (module = compilation unit ??)
231 * - second array contains the number of source files in module
232 * an array of DWORD (src->nSrcFiles as size)
233 * - contains offset (in following string table) of the source file name
235 * - each string is a pascal string (ie. with its length as first BYTE) or
236 * 0-terminated string (depending on version)
238 indx
= &src
->table
[src
->nModules
];
239 offset
= (const DWORD
*)&src
->table
[2 * src
->nModules
];
240 cstr
= (const char*)&src
->table
[2 * (src
->nModules
+ src
->nSrcFiles
)];
243 for (i
= cfile
= 0; i
< src
->nModules
; i
++)
245 printf("\t\tModule[%2d]:\n", i
);
246 for (j
= 0; j
< indx
[i
]; j
++, cfile
++)
248 /* FIXME: in some cases, it's a p_string but WHEN ? */
249 if (src
->table
[cfile
] < src
->nSrcFiles
&&
250 cstr
+ offset
[src
->table
[cfile
]] >= (const char*)start_cstr
/* wrap around */ &&
251 cstr
+ offset
[src
->table
[cfile
]] < (const char*)src
+ symbols
->srcmodule_size
)
252 printf("\t\t\tSource file: %s\n", cstr
+ offset
[src
->table
[cfile
]]);
254 printf("\t\t\tSource file: <<out of bounds>>\n");
258 if (symbols
->pdbimport_size
)
260 const PDB_SYMBOL_IMPORT
* imp
;
265 printf("\t------------import--------------\n");
266 imp
= (const PDB_SYMBOL_IMPORT
*)((const char*)symbols
+ sizeof(PDB_SYMBOLS
) +
267 symbols
->module_size
+ symbols
->offset_size
+
268 symbols
->hash_size
+ symbols
->srcmodule_size
);
269 first
= (const char*)imp
;
270 last
= (const char*)imp
+ symbols
->pdbimport_size
;
271 while (imp
< (const PDB_SYMBOL_IMPORT
*)last
)
273 ptr
= (const char*)imp
+ sizeof(*imp
) + strlen(imp
->filename
);
274 printf("\tImport: %lx\n"
275 "\t\tUnknown1: %08x\n"
276 "\t\tUnknown2: %08x\n"
277 "\t\tTimeDateStamp: %08x\n"
281 (ULONG_PTR
)((const char*)imp
- (const char*)first
),
288 imp
= (const PDB_SYMBOL_IMPORT
*)(first
+ ((ptr
- first
+ strlen(ptr
) + 1 + 3) & ~3));
292 /* Read global symbol table */
293 modimage
= reader
->read_file(reader
, symbols
->gsym_file
);
296 printf("\t------------globals-------------\n");
297 codeview_dump_symbols(modimage
, pdb_get_file_size(reader
, symbols
->gsym_file
));
301 /* Read per-module symbol / linenumber tables */
302 file
= (const char*)symbols
+ sizeof(PDB_SYMBOLS
);
303 while (file
- (const char*)symbols
< sizeof(PDB_SYMBOLS
) + symbols
->module_size
)
305 int file_nr
, symbol_size
, lineno_size
;
306 const char* file_name
;
308 if (symbols
->version
< 19970000)
310 const PDB_SYMBOL_FILE
* sym_file
= (const PDB_SYMBOL_FILE
*) file
;
311 file_nr
= sym_file
->file
;
312 file_name
= sym_file
->filename
;
313 symbol_size
= sym_file
->symbol_size
;
314 lineno_size
= sym_file
->lineno_size
;
315 printf("\t--------symbol file----------- %s\n", file_name
);
316 printf("\tgot symbol_file\n"
317 "\t\tunknown1: %08x \n"
319 "\t\t\tsegment: %04x\n"
321 "\t\t\toffset: %08x\n"
323 "\t\t\tcharacteristics: %08x\n"
324 "\t\t\tindex: %04x\n"
328 "\t\tsymb size: %08x\n"
329 "\t\tline size: %08x\n"
330 "\t\tunknown2: %08x\n"
331 "\t\tnSrcFiles: %08x\n"
332 "\t\tattribute: %08x\n",
334 sym_file
->range
.segment
,
335 sym_file
->range
.pad1
,
336 sym_file
->range
.offset
,
337 sym_file
->range
.size
,
338 sym_file
->range
.characteristics
,
339 sym_file
->range
.index
,
340 sym_file
->range
.pad2
,
343 sym_file
->symbol_size
,
344 sym_file
->lineno_size
,
347 sym_file
->attribute
);
351 const PDB_SYMBOL_FILE_EX
* sym_file
= (const PDB_SYMBOL_FILE_EX
*) file
;
352 file_nr
= sym_file
->file
;
353 file_name
= sym_file
->filename
;
354 symbol_size
= sym_file
->symbol_size
;
355 lineno_size
= sym_file
->lineno_size
;
356 printf("\t--------symbol file----------- %s\n", file_name
);
357 printf("\t\tunknown1: %08x \n"
359 "\t\t\tsegment: %04x\n"
361 "\t\t\toffset: %08x\n"
363 "\t\t\tcharacteristics: %08x\n"
364 "\t\t\tindex: %04x\n"
366 "\t\t\ttimestamp: %08x\n"
367 "\t\t\tunknown: %08x\n"
370 "\t\tsymb size: %08x\n"
371 "\t\tline size: %08x\n"
372 "\t\tunknown2: %08x\n"
373 "\t\tnSrcFiles: %08x\n"
374 "\t\tattribute: %08x\n"
375 "\t\treserved/0: %08x\n"
376 "\t\treserved/1: %08x\n",
378 sym_file
->range
.segment
,
379 sym_file
->range
.pad1
,
380 sym_file
->range
.offset
,
381 sym_file
->range
.size
,
382 sym_file
->range
.characteristics
,
383 sym_file
->range
.index
,
384 sym_file
->range
.pad2
,
385 sym_file
->range
.timestamp
,
386 sym_file
->range
.unknown
,
389 sym_file
->symbol_size
,
390 sym_file
->lineno_size
,
394 sym_file
->reserved
[0],
395 sym_file
->reserved
[1]);
397 modimage
= reader
->read_file(reader
, file_nr
);
400 int total_size
= pdb_get_file_size(reader
, file_nr
);
403 codeview_dump_symbols((const char*)modimage
+ sizeof(DWORD
), symbol_size
);
405 /* what's that part ??? */
407 dump_data(modimage
+ symbol_size
+ lineno_size
, total_size
- (symbol_size
+ lineno_size
), " ");
411 file_name
+= strlen(file_name
) + 1;
412 file
= (char*)((DWORD_PTR
)(file_name
+ strlen(file_name
) + 1 + 3) & ~3);
417 static void pdb_dump_types(struct pdb_reader
* reader
)
419 PDB_TYPES
* types
= NULL
;
421 types
= reader
->read_file(reader
, 2);
423 switch (types
->version
)
425 case 19950410: /* VC 4.0 */
427 case 19961031: /* VC 5.0 / 6.0 */
428 case 19990903: /* VC 7.0 */
431 printf("-Unknown type info version %d\n", types
->version
);
434 /* Read type table */
437 "\ttype_offset: %08x\n"
438 "\tfirst_index: %x\n"
445 "\thash_offset: %x\n"
447 "\tsearch_offset: %x\n"
449 "\tunknown_offset: %x\n"
450 "\tunknown_len: %x\n",
462 types
->search_offset
,
464 types
->unknown_offset
,
466 codeview_dump_types_from_block((const char*)types
+ types
->type_offset
, types
->type_size
);
470 static const char pdb2
[] = "Microsoft C/C++ program database 2.00";
472 static void pdb_jg_dump(void)
474 struct pdb_reader reader
;
475 struct PDB_JG_ROOT
* root
= NULL
;
478 * Read in TOC and well-known files
480 pdb_jg_init(&reader
);
481 printf("Header (JG):\n"
483 "\tsignature: %08x\n"
484 "\tblock_size: %08x\n"
485 "\tfree_list: %04x\n"
486 "\ttotal_alloc:%04x\n",
487 (int)sizeof(pdb2
) - 1, reader
.u
.jg
.header
->ident
,
488 reader
.u
.jg
.header
->signature
,
489 reader
.u
.jg
.header
->block_size
,
490 reader
.u
.jg
.header
->free_list
,
491 reader
.u
.jg
.header
->total_alloc
);
493 root
= reader
.read_file(&reader
, 1);
499 "\tTimeDateStamp: %08x\n"
505 (unsigned)root
->cbNames
,
508 /* Check for unknown versions */
509 switch (root
->Version
)
511 case 19950623: /* VC 4.0 */
513 case 19960307: /* VC 5.0 */
514 case 19970604: /* VC 6.0 */
517 printf("-Unknown root block version %d\n", root
->Version
);
521 else printf("-Unable to get root\n");
523 pdb_dump_types(&reader
);
525 /* segments info, index is unknown */
527 const void* segs
= pdb_read_file(pdb
, toc
, 8); /* FIXME which index ??? */
528 const void* ptr
= segs
;
530 if (segs
) while (ptr
< segs
+ toc
->file
[8].size
)
532 printf("Segment %s\n", (const char*)ptr
);
533 ptr
+= (strlen(ptr
) + 1 + 3) & ~3;
534 printf("\tdword[0]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
535 printf("\tdword[1]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
536 printf("\tdword[2]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
537 printf("\tdword[3]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
538 printf("\tdword[4]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
539 printf("\tdword[5]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
540 printf("\tdword[6]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
541 printf("\tdword[7]: %08lx\n", *(DWORD
*)ptr
); ptr
+= 4;
547 pdb_dump_symbols(&reader
);
551 static void* pdb_ds_read(const struct PDB_DS_HEADER
* header
, const DWORD
* block_list
, int size
)
556 if (!size
) return NULL
;
558 nBlocks
= (size
+ header
->block_size
- 1) / header
->block_size
;
559 buffer
= malloc(nBlocks
* header
->block_size
);
561 for (i
= 0; i
< nBlocks
; i
++)
562 memcpy(buffer
+ i
* header
->block_size
,
563 (const char*)header
+ block_list
[i
] * header
->block_size
, header
->block_size
);
568 static void* pdb_ds_read_file(struct pdb_reader
* reader
, DWORD file_number
)
570 const DWORD
* block_list
;
573 if (!reader
->u
.ds
.toc
|| file_number
>= reader
->u
.ds
.toc
->num_files
) return NULL
;
575 reader
->file_used
[file_number
/ 32] |= 1 << (file_number
% 32);
576 if (reader
->u
.ds
.toc
->file_size
[file_number
] == 0 ||
577 reader
->u
.ds
.toc
->file_size
[file_number
] == 0xFFFFFFFF)
579 block_list
= reader
->u
.ds
.toc
->file_size
+ reader
->u
.ds
.toc
->num_files
;
580 for (i
= 0; i
< file_number
; i
++)
581 block_list
+= (reader
->u
.ds
.toc
->file_size
[i
] + reader
->u
.ds
.header
->block_size
- 1) /
582 reader
->u
.ds
.header
->block_size
;
584 return pdb_ds_read(reader
->u
.ds
.header
, block_list
, reader
->u
.ds
.toc
->file_size
[file_number
]);
587 static BOOL
pdb_ds_init(struct pdb_reader
* reader
)
589 reader
->u
.ds
.header
= PRD(0, sizeof(*reader
->u
.ds
.header
));
590 if (!reader
->u
.ds
.header
) return FALSE
;
591 reader
->read_file
= pdb_ds_read_file
;
592 reader
->u
.ds
.toc
= pdb_ds_read(reader
->u
.ds
.header
,
593 (const DWORD
*)((const char*)reader
->u
.ds
.header
+ reader
->u
.ds
.header
->toc_page
* reader
->u
.ds
.header
->block_size
),
594 reader
->u
.ds
.header
->toc_size
);
595 memset(reader
->file_used
, 0, sizeof(reader
->file_used
));
599 static const char pdb7
[] = "Microsoft C/C++ MSF 7.00";
601 static void pdb_ds_dump(void)
603 struct pdb_reader reader
;
604 struct PDB_DS_ROOT
* root
;
606 pdb_ds_init(&reader
);
607 printf("Header (DS)\n"
608 "\tsignature: %.*s\n"
609 "\tblock_size: %08x\n"
611 "\tnum_pages: %08x\n"
614 "\ttoc_page: %08x\n",
615 (int)sizeof(pdb7
) - 1, reader
.u
.ds
.header
->signature
,
616 reader
.u
.ds
.header
->block_size
,
617 reader
.u
.ds
.header
->unknown1
,
618 reader
.u
.ds
.header
->num_pages
,
619 reader
.u
.ds
.header
->toc_size
,
620 reader
.u
.ds
.header
->unknown2
,
621 reader
.u
.ds
.header
->toc_page
);
624 * 0: JG says old toc pages, I'd say free pages (tbc, low prio)
629 root
= reader
.read_file(&reader
, 1);
636 "\tTimeDateStamp: %08x\n"
643 get_guid_str(&root
->guid
),
645 for (ptr
= &root
->names
[0]; ptr
< &root
->names
[0] + root
->cbNames
; ptr
+= strlen(ptr
) + 1)
646 printf("\tString: %s\n", ptr
);
647 /* follows an unknown list of DWORDs */
650 else printf("-Unable to get root\n");
652 pdb_dump_types(&reader
);
653 pdb_dump_symbols(&reader
);
658 enum FileSig
get_kind_pdb(void)
662 head
= PRD(0, sizeof(pdb2
) - 1);
663 if (head
&& !memcmp(head
, pdb2
, sizeof(pdb2
) - 1))
665 head
= PRD(0, sizeof(pdb7
) - 1);
666 if (head
&& !memcmp(head
, pdb7
, sizeof(pdb7
) - 1))
676 head
= PRD(0, sizeof(pdb2
) - 1);
677 if (head
&& !memcmp(head
, pdb2
, sizeof(pdb2
) - 1))
682 head
= PRD(0, sizeof(pdb7
) - 1);
683 if (head
&& !memcmp(head
, pdb7
, sizeof(pdb7
) - 1))
688 printf("Unrecognized header %s\n", head
);