?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Store print dlg structure in a property instead of DWL_USER.
[wine.git] / debugger / msc.c
blobf18933cbbf10ebbad7aea8cf9df72a4494eee51c
1 /*
2 * File msc.c - read VC++ debug information from COFF and eventually
3 * from PDB files.
4 *
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999, 2000, Ulrich Weigand.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * Note - this handles reading debug information for 32 bit applications
23 * that run under Windows-NT for example. I doubt that this would work well
24 * for 16 bit applications, but I don't think it really matters since the
25 * file format is different, and we should never get in here in such cases.
26 *
27 * TODO:
28 * Get 16 bit CV stuff working.
29 * Add symbol size to internal symbol table.
30 */
31
32 #include "config.h"
33 #include <stdlib.h>
34
35 #include <string.h>
36 #include <unistd.h>
37 #ifndef PATH_MAX
38 #define PATH_MAX MAX_PATH
39 #endif
40 #include "debugger.h"
41
42 #define MAX_PATHNAME_LEN 1024
43
44 typedef struct
45 {
46 DWORD from;
47 DWORD to;
48
49 } OMAP_DATA;
50
51 typedef struct tagMSC_DBG_INFO
52 {
53 int nsect;
54 PIMAGE_SECTION_HEADER sectp;
55
56 int nomap;
57 OMAP_DATA * omapp;
58
59 } MSC_DBG_INFO;
60
61 /*========================================================================
62 * Debug file access helper routines
63 */
64
65
66 /***********************************************************************
67 * DEBUG_LocateDebugInfoFile
68 *
69 * NOTE: dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
70 */
71 static void DEBUG_LocateDebugInfoFile(const char *filename, char *dbg_filename)
72 {
73 char *str1 = DBG_alloc(MAX_PATHNAME_LEN);
74 char *str2 = DBG_alloc(MAX_PATHNAME_LEN*10);
75 const char *file;
76 char *name_part;
77
78 file = strrchr(filename, '\\');
79 if( file == NULL ) file = filename; else file++;
80
81 if ((GetEnvironmentVariable("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
82 (SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
83 (GetEnvironmentVariable("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
84 (SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
85 (SearchPath(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part)))
86 lstrcpyn(dbg_filename, str2, MAX_PATHNAME_LEN);
87 else
88 lstrcpyn(dbg_filename, filename, MAX_PATHNAME_LEN);
89 DBG_free(str1);
90 DBG_free(str2);
91 }
92
93 /***********************************************************************
94 * DEBUG_MapDebugInfoFile
95 */
96 static void* DEBUG_MapDebugInfoFile(const char* name, DWORD offset, DWORD size,
97 HANDLE* hFile, HANDLE* hMap)
98 {
99 DWORD g_offset; /* offset aligned on map granuality */
100 DWORD g_size; /* size to map, with offset aligned */
101 char* ret;
102
103 *hMap = 0;
104
105 if (name != NULL) {
106 char filename[MAX_PATHNAME_LEN];
107
108 DEBUG_LocateDebugInfoFile(name, filename);
109 if ((*hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
110 return NULL;
111 }
112
113 if (!size) {
114 DWORD file_size = GetFileSize(*hFile, NULL);
115 if (file_size == (DWORD)-1) return NULL;
116 size = file_size - offset;
117 }
118
119 g_offset = offset & ~0xFFFF; /* FIXME: is granularity portable ? */
120 g_size = offset + size - g_offset;
121
122 if ((*hMap = CreateFileMapping(*hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == 0)
123 return NULL;
124
125 if ((ret = MapViewOfFile(*hMap, FILE_MAP_READ, 0, g_offset, g_size)) != NULL)
126 ret += offset - g_offset;
127
128 return ret;
129 }
130
131 /***********************************************************************
132 * DEBUG_UnmapDebugInfoFile
133 */
134 static void DEBUG_UnmapDebugInfoFile(HANDLE hFile, HANDLE hMap, void* addr)
135 {
136 if (addr) UnmapViewOfFile(addr);
137 if (hMap) CloseHandle(hMap);
138 if (hFile!=INVALID_HANDLE_VALUE) CloseHandle(hFile);
139 }
140
141
142
143 /*========================================================================
144 * Process COFF debug information.
145 */
146
147 struct CoffFile
148 {
149 unsigned int startaddr;
150 unsigned int endaddr;
151 const char *filename;
152 int linetab_offset;
153 int linecnt;
154 struct name_hash **entries;
155 int neps;
156 int neps_alloc;
157 };
158
159 struct CoffFileSet
160 {
161 struct CoffFile *files;
162 int nfiles;
163 int nfiles_alloc;
164 };
165
166 static const char* DEBUG_GetCoffName( PIMAGE_SYMBOL coff_sym, const char* coff_strtab )
167 {
168 static char namebuff[9];
169 const char* nampnt;
170
171 if( coff_sym->N.Name.Short )
172 {
173 memcpy(namebuff, coff_sym->N.ShortName, 8);
174 namebuff[8] = '\0';
175 nampnt = &namebuff[0];
176 }
177 else
178 {
179 nampnt = coff_strtab + coff_sym->N.Name.Long;
180 }
181
182 if( nampnt[0] == '_' )
183 nampnt++;
184 return nampnt;
185 }
186
187 static int DEBUG_AddCoffFile( struct CoffFileSet* coff_files, const char* filename )
188 {
189 struct CoffFile* file;
190
191 if( coff_files->nfiles + 1 >= coff_files->nfiles_alloc )
192 {
193 coff_files->nfiles_alloc += 10;
194 coff_files->files = (struct CoffFile *) DBG_realloc(coff_files->files,
195 coff_files->nfiles_alloc * sizeof(struct CoffFile));
196 }
197 file = coff_files->files + coff_files->nfiles;
198 file->startaddr = 0xffffffff;
199 file->endaddr = 0;
200 file->filename = filename;
201 file->linetab_offset = -1;
202 file->linecnt = 0;
203 file->entries = NULL;
204 file->neps = file->neps_alloc = 0;
205
206 return coff_files->nfiles++;
207 }
208
209 static void DEBUG_AddCoffSymbol( struct CoffFile* coff_file, struct name_hash* sym )
210 {
211 if( coff_file->neps + 1 >= coff_file->neps_alloc )
212 {
213 coff_file->neps_alloc += 10;
214 coff_file->entries = (struct name_hash **)
215 DBG_realloc(coff_file->entries,
216 coff_file->neps_alloc * sizeof(struct name_hash *));
217 }
218 coff_file->entries[coff_file->neps++] = sym;
219 }
220
221 static enum DbgInfoLoad DEBUG_ProcessCoff( DBG_MODULE *module, LPBYTE root )
222 {
223 PIMAGE_AUX_SYMBOL aux;
224 PIMAGE_COFF_SYMBOLS_HEADER coff;
225 PIMAGE_LINENUMBER coff_linetab;
226 PIMAGE_LINENUMBER linepnt;
227 char * coff_strtab;
228 PIMAGE_SYMBOL coff_sym;
229 PIMAGE_SYMBOL coff_symbols;
230 struct CoffFileSet coff_files;
231 int curr_file_idx = -1;
232 unsigned int i;
233 int j;
234 int k;
235 int l;
236 int linetab_indx;
237 const char * nampnt;
238 int naux;
239 DBG_VALUE new_value;
240 enum DbgInfoLoad dil = DIL_ERROR;
241
242 DEBUG_Printf(DBG_CHN_TRACE, "Processing COFF symbols...\n");
243
244 assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL);
245 assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER);
246
247 coff_files.files = NULL;
248 coff_files.nfiles = coff_files.nfiles_alloc = 0;
249
250 coff = (PIMAGE_COFF_SYMBOLS_HEADER) root;
251
252 coff_symbols = (PIMAGE_SYMBOL) ((unsigned int) coff + coff->LvaToFirstSymbol);
253 coff_linetab = (PIMAGE_LINENUMBER) ((unsigned int) coff + coff->LvaToFirstLinenumber);
254 coff_strtab = (char *) (coff_symbols + coff->NumberOfSymbols);
255
256 linetab_indx = 0;
257
258 new_value.cookie = DV_TARGET;
259 new_value.type = NULL;
260
261 for(i=0; i < coff->NumberOfSymbols; i++ )
262 {
263 coff_sym = coff_symbols + i;
264 naux = coff_sym->NumberOfAuxSymbols;
265
266 if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
267 {
268 curr_file_idx = DEBUG_AddCoffFile( &coff_files, (char *) (coff_sym + 1) );
269 DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", coff_files.files[curr_file_idx].filename);
270 i += naux;
271 continue;
272 }
273
274 if (curr_file_idx < 0) {
275 assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0);
276 curr_file_idx = DEBUG_AddCoffFile( &coff_files, "<none>" );
277 DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", coff_files.files[curr_file_idx].filename);
278 }
279
280 /*
281 * This guy marks the size and location of the text section
282 * for the current file. We need to keep track of this so
283 * we can figure out what file the different global functions
284 * go with.
285 */
286 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
287 && (naux != 0)
288 && (coff_sym->Type == 0)
289 && (coff_sym->SectionNumber == 1) )
290 {
291 aux = (PIMAGE_AUX_SYMBOL) (coff_sym + 1);
292
293 if( coff_files.files[curr_file_idx].linetab_offset != -1 )
294 {
295 /*
296 * Save this so we can still get the old name.
297 */
298 const char* fn = coff_files.files[curr_file_idx].filename;
299
300 #ifdef MORE_DBG
301 DEBUG_Printf(DBG_CHN_TRACE, "Duplicating sect from %s: %lx %x %x %d %d\n",
302 coff_files.files[curr_file_idx].filename,
303 aux->Section.Length,
304 aux->Section.NumberOfRelocations,
305 aux->Section.NumberOfLinenumbers,
306 aux->Section.Number,
307 aux->Section.Selection);
308 DEBUG_Printf(DBG_CHN_TRACE, "More sect %d %s %08lx %d %d %d\n",
309 coff_sym->SectionNumber,
310 DEBUG_GetCoffName( coff_sym, coff_strtab ),
311 coff_sym->Value,
312 coff_sym->Type,
313 coff_sym->StorageClass,
314 coff_sym->NumberOfAuxSymbols);
315 #endif
316
317 /*
318 * Duplicate the file entry. We have no way to describe
319 * multiple text sections in our current way of handling things.
320 */
321 DEBUG_AddCoffFile( &coff_files, fn );
322 }
323 #ifdef MORE_DBG
324 else
325 {
326 DEBUG_Printf(DBG_CHN_TRACE, "New text sect from %s: %lx %x %x %d %d\n",
327 coff_files.files[curr_file_idx].filename,
328 aux->Section.Length,
329 aux->Section.NumberOfRelocations,
330 aux->Section.NumberOfLinenumbers,
331 aux->Section.Number,
332 aux->Section.Selection);
333 }
334 #endif
335
336 if( coff_files.files[curr_file_idx].startaddr > coff_sym->Value )
337 {
338 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
339 }
340
341 if( coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length )
342 {
343 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
344 }
345
346 coff_files.files[curr_file_idx].linetab_offset = linetab_indx;
347 coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers;
348 linetab_indx += aux->Section.NumberOfLinenumbers;
349 i += naux;
350 continue;
351 }
352
353 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
354 && (naux == 0)
355 && (coff_sym->SectionNumber == 1) )
356 {
357 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
358 /*
359 * This is a normal static function when naux == 0.
360 * Just register it. The current file is the correct
361 * one in this instance.
362 */
363 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
364
365 new_value.addr.seg = 0;
366 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
367
368 #ifdef MORE_DBG
369 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding static symbol %s\n", nampnt);
370 #endif
371
372 /* FIXME: was adding symbol to this_file ??? */
373 DEBUG_AddCoffSymbol( &coff_files.files[curr_file_idx],
374 DEBUG_AddSymbol( nampnt, &new_value,
375 coff_files.files[curr_file_idx].filename,
376 SYM_WIN32 | SYM_FUNC ) );
377 i += naux;
378 continue;
379 }
380
381 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
382 && ISFCN(coff_sym->Type)
383 && (coff_sym->SectionNumber > 0) )
384 {
385 const char* this_file = NULL;
386 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
387 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
388
389 new_value.addr.seg = 0;
390 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
391
392 #ifdef MORE_DBG
393 DEBUG_Printf(DBG_CHN_TRACE, "%d: %lx %s\n", i, new_value.addr.off, nampnt);
394
395 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global symbol %s (sect=%s)\n",
396 nampnt, MSC_INFO(module)->sectp[coff_sym->SectionNumber - 1].Name);
397 #endif
398
399 /*
400 * Now we need to figure out which file this guy belongs to.
401 */
402 for(j=0; j < coff_files.nfiles; j++)
403 {
404 if( coff_files.files[j].startaddr <= base + coff_sym->Value
405 && coff_files.files[j].endaddr > base + coff_sym->Value )
406 {
407 this_file = coff_files.files[j].filename;
408 break;
409 }
410 }
411 if (j < coff_files.nfiles) {
412 DEBUG_AddCoffSymbol( &coff_files.files[j],
413 DEBUG_AddSymbol( nampnt, &new_value, this_file, SYM_WIN32 | SYM_FUNC ) );
414 } else {
415 DEBUG_AddSymbol( nampnt, &new_value, NULL, SYM_WIN32 | SYM_FUNC );
416 }
417 i += naux;
418 continue;
419 }
420
421 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
422 && (coff_sym->SectionNumber > 0) )
423 {
424 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
425 /*
426 * Similar to above, but for the case of data symbols.
427 * These aren't treated as entrypoints.
428 */
429 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
430
431 new_value.addr.seg = 0;
432 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
433
434 #ifdef MORE_DBG
435 DEBUG_Printf(DBG_CHN_TRACE, "%d: %lx %s\n", i, new_value.addr.off, nampnt);
436
437 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global data symbol %s\n", nampnt);
438 #endif
439
440 /*
441 * Now we need to figure out which file this guy belongs to.
442 */
443 DEBUG_AddSymbol( nampnt, &new_value, NULL, SYM_WIN32 | SYM_DATA );
444 i += naux;
445 continue;
446 }
447
448 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
449 && (naux == 0) )
450 {
451 /*
452 * Ignore these. They don't have anything to do with
453 * reality.
454 */
455 i += naux;
456 continue;
457 }
458
459 #ifdef MORE_DBG
460 DEBUG_Printf(DBG_CHN_TRACE,"Skipping unknown entry '%s' %d %d %d\n",
461 DEBUG_GetCoffName( coff_sym, coff_strtab ),
462 coff_sym->StorageClass, coff_sym->SectionNumber, naux);
463 #endif
464
465 /*
466 * For now, skip past the aux entries.
467 */
468 i += naux;
469
470 }
471
472 /*
473 * OK, we now should have a list of files, and we should have a list
474 * of entrypoints. We need to sort the entrypoints so that we are
475 * able to tie the line numbers with the given functions within the
476 * file.
477 */
478 if( coff_files.files != NULL )
479 {
480 for(j=0; j < coff_files.nfiles; j++)
481 {
482 if( coff_files.files[j].entries != NULL )
483 {
484 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
485 sizeof(struct name_hash *), DEBUG_cmp_sym);
486 }
487 }
488
489 /*
490 * Now pick apart the line number tables, and attach the entries
491 * to the given functions.
492 */
493 for(j=0; j < coff_files.nfiles; j++)
494 {
495 l = 0;
496 if( coff_files.files[j].neps != 0 )
497 for(k=0; k < coff_files.files[j].linecnt; k++)
498 {
499 linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
500 /*
501 * If we have spilled onto the next entrypoint, then
502 * bump the counter..
503 */
504 while(TRUE)
505 {
506 if (l+1 >= coff_files.files[j].neps) break;
507 DEBUG_GetSymbolAddr(coff_files.files[j].entries[l+1], &new_value.addr);
508 if( (((unsigned int)module->load_addr +
509 linepnt->Type.VirtualAddress) >= new_value.addr.off) )
510 {
511 l++;
512 } else break;
513 }
514
515 /*
516 * Add the line number. This is always relative to the
517 * start of the function, so we need to subtract that offset
518 * first.
519 */
520 DEBUG_GetSymbolAddr(coff_files.files[j].entries[l], &new_value.addr);
521 DEBUG_AddLineNumber(coff_files.files[j].entries[l],
522 linepnt->Linenumber,
523 (unsigned int) module->load_addr
524 + linepnt->Type.VirtualAddress
525 - new_value.addr.off);
526 }
527 }
528 }
529
530 dil = DIL_LOADED;
531
532 if( coff_files.files != NULL )
533 {
534 for(j=0; j < coff_files.nfiles; j++)
535 {
536 if( coff_files.files[j].entries != NULL )
537 {
538 DBG_free(coff_files.files[j].entries);
539 }
540 }
541 DBG_free(coff_files.files);
542 }
543
544 return dil;
545
546 }
547
548
549
550 /*========================================================================
551 * Process CodeView type information.
552 */
553
554 union codeview_type
555 {
556 struct
557 {
558 unsigned short int len;
559 short int id;
560 } generic;
561
562 struct
563 {
564 unsigned short int len;
565 short int id;
566 short int attribute;
567 short int datatype;
568 unsigned char variant[1];
569 } pointer;
570
571 struct
572 {
573 unsigned short int len;
574 short int id;
575 unsigned int datatype;
576 unsigned int attribute;
577 unsigned char variant[1];
578 } pointer32;
579
580 struct
581 {
582 unsigned short int len;
583 short int id;
584 unsigned char nbits;
585 unsigned char bitoff;
586 unsigned short type;
587 } bitfield;
588
589 struct
590 {
591 unsigned short int len;
592 short int id;
593 unsigned int type;
594 unsigned char nbits;
595 unsigned char bitoff;
596 } bitfield32;
597
598 struct
599 {
600 unsigned short int len;
601 short int id;
602 short int elemtype;
603 short int idxtype;
604 unsigned short int arrlen; /* numeric leaf */
605 #if 0
606 unsigned char name[1];
607 #endif
608 } array;
609
610 struct
611 {
612 unsigned short int len;
613 short int id;
614 unsigned int elemtype;
615 unsigned int idxtype;
616 unsigned short int arrlen; /* numeric leaf */
617 #if 0
618 unsigned char name[1];
619 #endif
620 } array32;
621
622 struct
623 {
624 unsigned short int len;
625 short int id;
626 short int n_element;
627 short int fieldlist;
628 short int property;
629 short int derived;
630 short int vshape;
631 unsigned short int structlen; /* numeric leaf */
632 #if 0
633 unsigned char name[1];
634 #endif
635 } structure;
636
637 struct
638 {
639 unsigned short int len;
640 short int id;
641 short int n_element;
642 short int property;
643 unsigned int fieldlist;
644 unsigned int derived;
645 unsigned int vshape;
646 unsigned short int structlen; /* numeric leaf */
647 #if 0
648 unsigned char name[1];
649 #endif
650 } structure32;
651
652 struct
653 {
654 unsigned short int len;
655 short int id;
656 short int count;
657 short int fieldlist;
658 short int property;
659 unsigned short int un_len; /* numeric leaf */
660 #if 0
661 unsigned char name[1];
662 #endif
663 } t_union;
664
665 struct
666 {
667 unsigned short int len;
668 short int id;
669 short int count;
670 short int property;
671 unsigned int fieldlist;
672 unsigned short int un_len; /* numeric leaf */
673 #if 0
674 unsigned char name[1];
675 #endif
676 } t_union32;
677
678 struct
679 {
680 unsigned short int len;
681 short int id;
682 short int count;
683 short int type;
684 short int field;
685 short int property;
686 unsigned char name[1];
687 } enumeration;
688
689 struct
690 {
691 unsigned short int len;
692 short int id;
693 short int count;
694 short int property;
695 unsigned int type;
696 unsigned int field;
697 unsigned char name[1];
698 } enumeration32;
699
700 struct
701 {
702 unsigned short int len;
703 short int id;
704 unsigned char list[1];
705 } fieldlist;
706 };
707
708 union codeview_fieldtype
709 {
710 struct
711 {
712 short int id;
713 } generic;
714
715 struct
716 {
717 short int id;
718 short int type;
719 short int attribute;
720 unsigned short int offset; /* numeric leaf */
721 } bclass;
722
723 struct
724 {
725 short int id;
726 short int attribute;
727 unsigned int type;
728 unsigned short int offset; /* numeric leaf */
729 } bclass32;
730
731 struct
732 {
733 short int id;
734 short int btype;
735 short int vbtype;
736 short int attribute;
737 unsigned short int vbpoff; /* numeric leaf */
738 #if 0
739 unsigned short int vboff; /* numeric leaf */
740 #endif
741 } vbclass;
742
743 struct
744 {
745 short int id;
746 short int attribute;
747 unsigned int btype;
748 unsigned int vbtype;
749 unsigned short int vbpoff; /* numeric leaf */
750 #if 0
751 unsigned short int vboff; /* numeric leaf */
752 #endif
753 } vbclass32;
754
755 struct
756 {
757 short int id;
758 short int attribute;
759 unsigned short int value; /* numeric leaf */
760 #if 0
761 unsigned char name[1];
762 #endif
763 } enumerate;
764
765 struct
766 {
767 short int id;
768 short int type;
769 unsigned char name[1];
770 } friendfcn;
771
772 struct
773 {
774 short int id;
775 short int _pad0;
776 unsigned int type;
777 unsigned char name[1];
778 } friendfcn32;
779
780 struct
781 {
782 short int id;
783 short int type;
784 short int attribute;
785 unsigned short int offset; /* numeric leaf */
786 #if 0
787 unsigned char name[1];
788 #endif
789 } member;
790
791 struct
792 {
793 short int id;
794 short int attribute;
795 unsigned int type;
796 unsigned short int offset; /* numeric leaf */
797 #if 0
798 unsigned char name[1];
799 #endif
800 } member32;
801
802 struct
803 {
804 short int id;
805 short int type;
806 short int attribute;
807 unsigned char name[1];
808 } stmember;
809
810 struct
811 {
812 short int id;
813 short int attribute;
814 unsigned int type;
815 unsigned char name[1];
816 } stmember32;
817
818 struct
819 {
820 short int id;
821 short int count;
822 short int mlist;
823 unsigned char name[1];
824 } method;
825
826 struct
827 {
828 short int id;
829 short int count;
830 unsigned int mlist;
831 unsigned char name[1];
832 } method32;
833
834 struct
835 {
836 short int id;
837 short int index;
838 unsigned char name[1];
839 } nesttype;
840
841 struct
842 {
843 short int id;
844 short int _pad0;
845 unsigned int index;
846 unsigned char name[1];
847 } nesttype32;
848
849 struct
850 {
851 short int id;
852 short int type;
853 } vfunctab;
854
855 struct
856 {
857 short int id;
858 short int _pad0;
859 unsigned int type;
860 } vfunctab32;
861
862 struct
863 {
864 short int id;
865 short int type;
866 } friendcls;
867
868 struct
869 {
870 short int id;
871 short int _pad0;
872 unsigned int type;
873 } friendcls32;
874
875
876 struct
877 {
878 short int id;
879 short int attribute;
880 short int type;
881 unsigned char name[1];
882 } onemethod;
883 struct
884 {
885 short int id;
886 short int attribute;
887 short int type;
888 unsigned int vtab_offset;
889 unsigned char name[1];
890 } onemethod_virt;
891
892 struct
893 {
894 short int id;
895 short int attribute;
896 unsigned int type;
897 unsigned char name[1];
898 } onemethod32;
899 struct
900 {
901 short int id;
902 short int attribute;
903 unsigned int type;
904 unsigned int vtab_offset;
905 unsigned char name[1];
906 } onemethod32_virt;
907
908 struct
909 {
910 short int id;
911 short int type;
912 unsigned int offset;
913 } vfuncoff;
914
915 struct
916 {
917 short int id;
918 short int _pad0;
919 unsigned int type;
920 unsigned int offset;
921 } vfuncoff32;
922
923 struct
924 {
925 short int id;
926 short int attribute;
927 short int index;
928 unsigned char name[1];
929 } nesttypeex;
930
931 struct
932 {
933 short int id;
934 short int attribute;
935 unsigned int index;
936 unsigned char name[1];
937 } nesttypeex32;
938
939 struct
940 {
941 short int id;
942 short int attribute;
943 unsigned int type;
944 unsigned char name[1];
945 } membermodify;
946 };
947
948
949 /*
950 * This covers the basic datatypes that VC++ seems to be using these days.
951 * 32 bit mode only. There are additional numbers for the pointers in 16
952 * bit mode. There are many other types listed in the documents, but these
953 * are apparently not used by the compiler, or represent pointer types
954 * that are not used.
955 */
956 #define T_NOTYPE 0x0000 /* Notype */
957 #define T_ABS 0x0001 /* Abs */
958 #define T_VOID 0x0003 /* Void */
959 #define T_CHAR 0x0010 /* signed char */
960 #define T_SHORT 0x0011 /* short */
961 #define T_LONG 0x0012 /* long */
962 #define T_QUAD 0x0013 /* long long */
963 #define T_UCHAR 0x0020 /* unsigned char */
964 #define T_USHORT 0x0021 /* unsigned short */
965 #define T_ULONG 0x0022 /* unsigned long */
966 #define T_UQUAD 0x0023 /* unsigned long long */
967 #define T_REAL32 0x0040 /* float */
968 #define T_REAL64 0x0041 /* double */
969 #define T_RCHAR 0x0070 /* real char */
970 #define T_WCHAR 0x0071 /* wide char */
971 #define T_INT4 0x0074 /* int */
972 #define T_UINT4 0x0075 /* unsigned int */
973
974 #define T_32PVOID 0x0403 /* 32 bit near pointer to void */
975 #define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */
976 #define T_32PSHORT 0x0411 /* 16:32 near pointer to short */
977 #define T_32PLONG 0x0412 /* 16:32 near pointer to int */
978 #define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */
979 #define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */
980 #define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */
981 #define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */
982 #define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */
983 #define T_32PREAL32 0x0440 /* 16:32 near pointer to float */
984 #define T_32PREAL64 0x0441 /* 16:32 near pointer to float */
985 #define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */
986 #define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */
987 #define T_32PINT4 0x0474 /* 16:32 near pointer to int */
988 #define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */
989
990
991 #define LF_MODIFIER 0x0001
992 #define LF_POINTER 0x0002
993 #define LF_ARRAY 0x0003
994 #define LF_CLASS 0x0004
995 #define LF_STRUCTURE 0x0005
996 #define LF_UNION 0x0006
997 #define LF_ENUM 0x0007
998 #define LF_PROCEDURE 0x0008
999 #define LF_MFUNCTION 0x0009
1000 #define LF_VTSHAPE 0x000a
1001 #define LF_COBOL0 0x000b
1002 #define LF_COBOL1 0x000c
1003 #define LF_BARRAY 0x000d
1004 #define LF_LABEL 0x000e
1005 #define LF_NULL 0x000f
1006 #define LF_NOTTRAN 0x0010
1007 #define LF_DIMARRAY 0x0011
1008 #define LF_VFTPATH 0x0012
1009 #define LF_PRECOMP 0x0013
1010 #define LF_ENDPRECOMP 0x0014
1011 #define LF_OEM 0x0015
1012 #define LF_TYPESERVER 0x0016
1013
1014 #define LF_MODIFIER_32 0x1001 /* variants with new 32-bit type indices */
1015 #define LF_POINTER_32 0x1002
1016 #define LF_ARRAY_32 0x1003
1017 #define LF_CLASS_32 0x1004
1018 #define LF_STRUCTURE_32 0x1005
1019 #define LF_UNION_32 0x1006
1020 #define LF_ENUM_32 0x1007
1021 #define LF_PROCEDURE_32 0x1008
1022 #define LF_MFUNCTION_32 0x1009
1023 #define LF_COBOL0_32 0x100a
1024 #define LF_BARRAY_32 0x100b
1025 #define LF_DIMARRAY_32 0x100c
1026 #define LF_VFTPATH_32 0x100d
1027 #define LF_PRECOMP_32 0x100e
1028 #define LF_OEM_32 0x100f
1029
1030 #define LF_SKIP 0x0200
1031 #define LF_ARGLIST 0x0201
1032 #define LF_DEFARG 0x0202
1033 #define LF_LIST 0x0203
1034 #define LF_FIELDLIST 0x0204
1035 #define LF_DERIVED 0x0205
1036 #define LF_BITFIELD 0x0206
1037 #define LF_METHODLIST 0x0207
1038 #define LF_DIMCONU 0x0208
1039 #define LF_DIMCONLU 0x0209
1040 #define LF_DIMVARU 0x020a
1041 #define LF_DIMVARLU 0x020b
1042 #define LF_REFSYM 0x020c
1043
1044 #define LF_SKIP_32 0x1200 /* variants with new 32-bit type indices */
1045 #define LF_ARGLIST_32 0x1201
1046 #define LF_DEFARG_32 0x1202
1047 #define LF_FIELDLIST_32 0x1203
1048 #define LF_DERIVED_32 0x1204
1049 #define LF_BITFIELD_32 0x1205
1050 #define LF_METHODLIST_32 0x1206
1051 #define LF_DIMCONU_32 0x1207
1052 #define LF_DIMCONLU_32 0x1208
1053 #define LF_DIMVARU_32 0x1209
1054 #define LF_DIMVARLU_32 0x120a
1055
1056 #define LF_BCLASS 0x0400
1057 #define LF_VBCLASS 0x0401
1058 #define LF_IVBCLASS 0x0402
1059 #define LF_ENUMERATE 0x0403
1060 #define LF_FRIENDFCN 0x0404
1061 #define LF_INDEX 0x0405
1062 #define LF_MEMBER 0x0406
1063 #define LF_STMEMBER 0x0407
1064 #define LF_METHOD 0x0408
1065 #define LF_NESTTYPE 0x0409
1066 #define LF_VFUNCTAB 0x040a
1067 #define LF_FRIENDCLS 0x040b
1068 #define LF_ONEMETHOD 0x040c
1069 #define LF_VFUNCOFF 0x040d
1070 #define LF_NESTTYPEEX 0x040e
1071 #define LF_MEMBERMODIFY 0x040f
1072
1073 #define LF_BCLASS_32 0x1400 /* variants with new 32-bit type indices */
1074 #define LF_VBCLASS_32 0x1401
1075 #define LF_IVBCLASS_32 0x1402
1076 #define LF_FRIENDFCN_32 0x1403
1077 #define LF_INDEX_32 0x1404
1078 #define LF_MEMBER_32 0x1405
1079 #define LF_STMEMBER_32 0x1406
1080 #define LF_METHOD_32 0x1407
1081 #define LF_NESTTYPE_32 0x1408
1082 #define LF_VFUNCTAB_32 0x1409
1083 #define LF_FRIENDCLS_32 0x140a
1084 #define LF_ONEMETHOD_32 0x140b
1085 #define LF_VFUNCOFF_32 0x140c
1086 #define LF_NESTTYPEEX_32 0x140d
1087
1088 #define LF_NUMERIC 0x8000 /* numeric leaf types */
1089 #define LF_CHAR 0x8000
1090 #define LF_SHORT 0x8001
1091 #define LF_USHORT 0x8002
1092 #define LF_LONG 0x8003
1093 #define LF_ULONG 0x8004
1094 #define LF_REAL32 0x8005
1095 #define LF_REAL64 0x8006
1096 #define LF_REAL80 0x8007
1097 #define LF_REAL128 0x8008
1098 #define LF_QUADWORD 0x8009
1099 #define LF_UQUADWORD 0x800a
1100 #define LF_REAL48 0x800b
1101 #define LF_COMPLEX32 0x800c
1102 #define LF_COMPLEX64 0x800d
1103 #define LF_COMPLEX80 0x800e
1104 #define LF_COMPLEX128 0x800f
1105 #define LF_VARSTRING 0x8010
1106
1107
1108
1109 #define MAX_BUILTIN_TYPES 0x480
1110 static struct datatype * cv_basic_types[MAX_BUILTIN_TYPES];
1111 static unsigned int num_cv_defined_types = 0;
1112 static struct datatype **cv_defined_types = NULL;
1113
1114 void
1115 DEBUG_InitCVDataTypes(void)
1116 {
1117 /*
1118 * These are the common builtin types that are used by VC++.
1119 */
1120 cv_basic_types[T_NOTYPE] = NULL;
1121 cv_basic_types[T_ABS] = NULL;
1122 cv_basic_types[T_VOID] = DEBUG_GetBasicType(DT_BASIC_VOID);
1123 cv_basic_types[T_CHAR] = DEBUG_GetBasicType(DT_BASIC_CHAR);
1124 cv_basic_types[T_SHORT] = DEBUG_GetBasicType(DT_BASIC_SHORTINT);
1125 cv_basic_types[T_LONG] = DEBUG_GetBasicType(DT_BASIC_LONGINT);
1126 cv_basic_types[T_QUAD] = DEBUG_GetBasicType(DT_BASIC_LONGLONGINT);
1127 cv_basic_types[T_UCHAR] = DEBUG_GetBasicType(DT_BASIC_UCHAR);
1128 cv_basic_types[T_USHORT] = DEBUG_GetBasicType(DT_BASIC_USHORTINT);
1129 cv_basic_types[T_ULONG] = DEBUG_GetBasicType(DT_BASIC_ULONGINT);
1130 cv_basic_types[T_UQUAD] = DEBUG_GetBasicType(DT_BASIC_ULONGLONGINT);
1131 cv_basic_types[T_REAL32] = DEBUG_GetBasicType(DT_BASIC_FLOAT);
1132 cv_basic_types[T_REAL64] = DEBUG_GetBasicType(DT_BASIC_DOUBLE);
1133 cv_basic_types[T_RCHAR] = DEBUG_GetBasicType(DT_BASIC_CHAR);
1134 cv_basic_types[T_WCHAR] = DEBUG_GetBasicType(DT_BASIC_SHORTINT);
1135 cv_basic_types[T_INT4] = DEBUG_GetBasicType(DT_BASIC_INT);
1136 cv_basic_types[T_UINT4] = DEBUG_GetBasicType(DT_BASIC_UINT);
1137
1138 cv_basic_types[T_32PVOID] = DEBUG_FindOrMakePointerType(cv_basic_types[T_VOID]);
1139 cv_basic_types[T_32PCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_CHAR]);
1140 cv_basic_types[T_32PSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_SHORT]);
1141 cv_basic_types[T_32PLONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_LONG]);
1142 cv_basic_types[T_32PQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_QUAD]);
1143 cv_basic_types[T_32PUCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UCHAR]);
1144 cv_basic_types[T_32PUSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_USHORT]);
1145 cv_basic_types[T_32PULONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_ULONG]);
1146 cv_basic_types[T_32PUQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UQUAD]);
1147 cv_basic_types[T_32PREAL32] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL32]);
1148 cv_basic_types[T_32PREAL64] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL64]);
1149 cv_basic_types[T_32PRCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_RCHAR]);
1150 cv_basic_types[T_32PWCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_WCHAR]);
1151 cv_basic_types[T_32PINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_INT4]);
1152 cv_basic_types[T_32PUINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UINT4]);
1153 }
1154
1155
1156 static int
1157 numeric_leaf( int *value, unsigned short int *leaf )
1158 {
1159 unsigned short int type = *leaf++;
1160 int length = 2;
1161
1162 if ( type < LF_NUMERIC )
1163 {
1164 *value = type;
1165 }
1166 else
1167 {
1168 switch ( type )
1169 {
1170 case LF_CHAR:
1171 length += 1;
1172 *value = *(char *)leaf;
1173 break;
1174
1175 case LF_SHORT:
1176 length += 2;
1177 *value = *(short *)leaf;
1178 break;
1179
1180 case LF_USHORT:
1181 length += 2;
1182 *value = *(unsigned short *)leaf;
1183 break;
1184
1185 case LF_LONG:
1186 length += 4;
1187 *value = *(int *)leaf;
1188 break;
1189
1190 case LF_ULONG:
1191 length += 4;
1192 *value = *(unsigned int *)leaf;
1193 break;
1194
1195 case LF_QUADWORD:
1196 case LF_UQUADWORD:
1197 length += 8;
1198 *value = 0; /* FIXME */
1199 break;
1200
1201 case LF_REAL32:
1202 length += 4;
1203 *value = 0; /* FIXME */
1204 break;
1205
1206 case LF_REAL48:
1207 length += 6;
1208 *value = 0; /* FIXME */
1209 break;
1210
1211 case LF_REAL64:
1212 length += 8;
1213 *value = 0; /* FIXME */
1214 break;
1215
1216 case LF_REAL80:
1217 length += 10;
1218 *value = 0; /* FIXME */
1219 break;
1220
1221 case LF_REAL128:
1222 length += 16;
1223 *value = 0; /* FIXME */
1224 break;
1225
1226 case LF_COMPLEX32:
1227 length += 4;
1228 *value = 0; /* FIXME */
1229 break;
1230
1231 case LF_COMPLEX64:
1232 length += 8;
1233 *value = 0; /* FIXME */
1234 break;
1235
1236 case LF_COMPLEX80:
1237 length += 10;
1238 *value = 0; /* FIXME */
1239 break;
1240
1241 case LF_COMPLEX128:
1242 length += 16;
1243 *value = 0; /* FIXME */
1244 break;
1245
1246 case LF_VARSTRING:
1247 length += 2 + *leaf;
1248 *value = 0; /* FIXME */
1249 break;
1250
1251 default:
1252 DEBUG_Printf( DBG_CHN_MESG, "Unknown numeric leaf type %04x\n", type );
1253 *value = 0;
1254 break;
1255 }
1256 }
1257
1258 return length;
1259 }
1260
1261 static char *
1262 terminate_string( unsigned char *name )
1263 {
1264 static char symname[256];
1265
1266 int namelen = name[0];
1267 assert( namelen >= 0 && namelen < 256 );
1268
1269 memcpy( symname, name+1, namelen );
1270 symname[namelen] = '\0';
1271
1272 if ( !*symname || strcmp( symname, "__unnamed" ) == 0 )
1273 return NULL;
1274 else
1275 return symname;
1276 }
1277
1278 static
1279 struct datatype * DEBUG_GetCVType(unsigned int typeno)
1280 {
1281 struct datatype * dt = NULL;
1282
1283 /*
1284 * Convert Codeview type numbers into something we can grok internally.
1285 * Numbers < 0x1000 are all fixed builtin types. Numbers from 0x1000 and
1286 * up are all user defined (structs, etc).
1287 */
1288 if ( typeno < 0x1000 )
1289 {
1290 if ( typeno < MAX_BUILTIN_TYPES )
1291 dt = cv_basic_types[typeno];
1292 }
1293 else
1294 {
1295 if ( typeno - 0x1000 < num_cv_defined_types )
1296 dt = cv_defined_types[typeno - 0x1000];
1297 }
1298
1299 return dt;
1300 }
1301
1302 static int
1303 DEBUG_AddCVType( unsigned int typeno, struct datatype *dt )
1304 {
1305 while ( typeno - 0x1000 >= num_cv_defined_types )
1306 {
1307 num_cv_defined_types += 0x100;
1308 cv_defined_types = (struct datatype **)
1309 DBG_realloc( cv_defined_types,
1310 num_cv_defined_types * sizeof(struct datatype *) );
1311
1312 memset( cv_defined_types + num_cv_defined_types - 0x100,
1313 0,
1314 0x100 * sizeof(struct datatype *) );
1315
1316 if ( cv_defined_types == NULL )
1317 return FALSE;
1318 }
1319
1320 cv_defined_types[ typeno - 0x1000 ] = dt;
1321 return TRUE;
1322 }
1323
1324 static void
1325 DEBUG_ClearTypeTable( void )
1326 {
1327 if ( cv_defined_types )
1328 DBG_free( cv_defined_types );
1329
1330 cv_defined_types = NULL;
1331 num_cv_defined_types = 0;
1332 }
1333
1334 static int
1335 DEBUG_AddCVType_Pointer( unsigned int typeno, unsigned int datatype )
1336 {
1337 struct datatype *dt =
1338 DEBUG_FindOrMakePointerType( DEBUG_GetCVType( datatype ) );
1339
1340 return DEBUG_AddCVType( typeno, dt );
1341 }
1342
1343 static int
1344 DEBUG_AddCVType_Array( unsigned int typeno, char *name,
1345 unsigned int elemtype, unsigned int arr_len )
1346 {
1347 struct datatype *dt = DEBUG_NewDataType( DT_ARRAY, name );
1348 struct datatype *elem = DEBUG_GetCVType( elemtype );
1349 unsigned int elem_size = elem? DEBUG_GetObjectSize( elem ) : 0;
1350 unsigned int arr_max = elem_size? arr_len / elem_size : 0;
1351
1352 DEBUG_SetArrayParams( dt, 0, arr_max, elem );
1353 return DEBUG_AddCVType( typeno, dt );
1354 }
1355
1356 static int
1357 DEBUG_AddCVType_Bitfield( unsigned int typeno,
1358 unsigned int bitoff, unsigned int nbits,
1359 unsigned int basetype )
1360 {
1361 struct datatype *dt = DEBUG_NewDataType( DT_BITFIELD, NULL );
1362 struct datatype *base = DEBUG_GetCVType( basetype );
1363
1364 DEBUG_SetBitfieldParams( dt, bitoff, nbits, base );
1365 return DEBUG_AddCVType( typeno, dt );
1366 }
1367
1368 static int
1369 DEBUG_AddCVType_EnumFieldList( unsigned int typeno, unsigned char *list, int len )
1370 {
1371 struct datatype *dt = DEBUG_NewDataType( DT_ENUM, NULL );
1372 unsigned char *ptr = list;
1373
1374 while ( ptr - list < len )
1375 {
1376 union codeview_fieldtype *type = (union codeview_fieldtype *)ptr;
1377
1378 if ( *ptr >= 0xf0 ) /* LF_PAD... */
1379 {
1380 ptr += *ptr & 0x0f;
1381 continue;
1382 }
1383
1384 switch ( type->generic.id )
1385 {
1386 case LF_ENUMERATE:
1387 {
1388 int value, vlen = numeric_leaf( &value, &type->enumerate.value );
1389 unsigned char *name = (unsigned char *)&type->enumerate.value + vlen;
1390
1391 DEBUG_AddStructElement( dt, terminate_string( name ),
1392 NULL, value, 0 );
1393
1394 ptr += 2 + 2 + vlen + (1 + name[0]);
1395 break;
1396 }
1397
1398 default:
1399 DEBUG_Printf( DBG_CHN_MESG, "Unhandled type %04x in ENUM field list\n",
1400 type->generic.id );
1401 return FALSE;
1402 }
1403 }
1404
1405 return DEBUG_AddCVType( typeno, dt );
1406 }
1407
1408 static int
1409 DEBUG_AddCVType_StructFieldList( unsigned int typeno, unsigned char *list, int len )
1410 {
1411 struct datatype *dt = DEBUG_NewDataType( DT_STRUCT, NULL );
1412 unsigned char *ptr = list;
1413
1414 while ( ptr - list < len )
1415 {
1416 union codeview_fieldtype *type = (union codeview_fieldtype *)ptr;
1417
1418 if ( *ptr >= 0xf0 ) /* LF_PAD... */
1419 {
1420 ptr += *ptr & 0x0f;
1421 continue;
1422 }
1423
1424 switch ( type->generic.id )
1425 {
1426 case LF_BCLASS:
1427 {
1428 int offset, olen = numeric_leaf( &offset, &type->bclass.offset );
1429
1430 /* FIXME: ignored for now */
1431
1432 ptr += 2 + 2 + 2 + olen;
1433 break;
1434 }
1435
1436 case LF_BCLASS_32:
1437 {
1438 int offset, olen = numeric_leaf( &offset, &type->bclass32.offset );
1439
1440 /* FIXME: ignored for now */
1441
1442 ptr += 2 + 2 + 4 + olen;
1443 break;
1444 }
1445
1446 case LF_VBCLASS:
1447 case LF_IVBCLASS:
1448 {
1449 int vbpoff, vbplen = numeric_leaf( &vbpoff, &type->vbclass.vbpoff );
1450 unsigned short int *p_vboff = (unsigned short int *)((char *)&type->vbclass.vbpoff + vbpoff);
1451 int vpoff, vplen = numeric_leaf( &vpoff, p_vboff );
1452
1453 /* FIXME: ignored for now */
1454
1455 ptr += 2 + 2 + 2 + 2 + vbplen + vplen;
1456 break;
1457 }
1458
1459 case LF_VBCLASS_32:
1460 case LF_IVBCLASS_32:
1461 {
1462 int vbpoff, vbplen = numeric_leaf( &vbpoff, &type->vbclass32.vbpoff );
1463 unsigned short int *p_vboff = (unsigned short int *)((char *)&type->vbclass32.vbpoff + vbpoff);
1464 int vpoff, vplen = numeric_leaf( &vpoff, p_vboff );
1465
1466 /* FIXME: ignored for now */
1467
1468 ptr += 2 + 2 + 4 + 4 + vbplen + vplen;
1469 break;
1470 }
1471
1472 case LF_MEMBER:
1473 {
1474 int offset, olen = numeric_leaf( &offset, &type->member.offset );
1475 unsigned char *name = (unsigned char *)&type->member.offset + olen;
1476
1477 struct datatype *subtype = DEBUG_GetCVType( type->member.type );
1478 int elem_size = subtype? DEBUG_GetObjectSize( subtype ) : 0;
1479
1480 DEBUG_AddStructElement( dt, terminate_string( name ),
1481 subtype, offset << 3, elem_size << 3 );
1482
1483 ptr += 2 + 2 + 2 + olen + (1 + name[0]);
1484 break;
1485 }
1486
1487 case LF_MEMBER_32:
1488 {
1489 int offset, olen = numeric_leaf( &offset, &type->member32.offset );
1490 unsigned char *name = (unsigned char *)&type->member32.offset + olen;
1491
1492 struct datatype *subtype = DEBUG_GetCVType( type->member32.type );
1493 int elem_size = subtype? DEBUG_GetObjectSize( subtype ) : 0;
1494
1495 DEBUG_AddStructElement( dt, terminate_string( name ),
1496 subtype, offset << 3, elem_size << 3 );
1497
1498 ptr += 2 + 2 + 4 + olen + (1 + name[0]);
1499 break;
1500 }
1501
1502 case LF_STMEMBER:
1503 /* FIXME: ignored for now */
1504 ptr += 2 + 2 + 2 + (1 + type->stmember.name[0]);
1505 break;
1506
1507 case LF_STMEMBER_32:
1508 /* FIXME: ignored for now */
1509 ptr += 2 + 4 + 2 + (1 + type->stmember32.name[0]);
1510 break;
1511
1512 case LF_METHOD:
1513 /* FIXME: ignored for now */
1514 ptr += 2 + 2 + 2 + (1 + type->method.name[0]);
1515 break;
1516
1517 case LF_METHOD_32:
1518 /* FIXME: ignored for now */
1519 ptr += 2 + 2 + 4 + (1 + type->method32.name[0]);
1520 break;
1521
1522 case LF_NESTTYPE:
1523 /* FIXME: ignored for now */
1524 ptr += 2 + 2 + (1 + type->nesttype.name[0]);
1525 break;
1526
1527 case LF_NESTTYPE_32:
1528 /* FIXME: ignored for now */
1529 ptr += 2 + 2 + 4 + (1 + type->nesttype32.name[0]);
1530 break;
1531
1532 case LF_VFUNCTAB:
1533 /* FIXME: ignored for now */
1534 ptr += 2 + 2;
1535 break;
1536
1537 case LF_VFUNCTAB_32:
1538 /* FIXME: ignored for now */
1539 ptr += 2 + 2 + 4;
1540 break;
1541
1542 case LF_ONEMETHOD:
1543 /* FIXME: ignored for now */
1544 switch ( (type->onemethod.attribute >> 2) & 7 )
1545 {
1546 case 4: case 6: /* (pure) introducing virtual method */
1547 ptr += 2 + 2 + 2 + 4 + (1 + type->onemethod_virt.name[0]);
1548 break;
1549
1550 default:
1551 ptr += 2 + 2 + 2 + (1 + type->onemethod.name[0]);
1552 break;
1553 }
1554 break;
1555
1556 case LF_ONEMETHOD_32:
1557 /* FIXME: ignored for now */
1558 switch ( (type->onemethod32.attribute >> 2) & 7 )
1559 {
1560 case 4: case 6: /* (pure) introducing virtual method */
1561 ptr += 2 + 2 + 4 + 4 + (1 + type->onemethod32_virt.name[0]);
1562 break;
1563
1564 default:
1565 ptr += 2 + 2 + 4 + (1 + type->onemethod32.name[0]);
1566 break;
1567 }
1568 break;
1569
1570 default:
1571 DEBUG_Printf( DBG_CHN_MESG, "Unhandled type %04x in STRUCT field list\n",
1572 type->generic.id );
1573 return FALSE;
1574 }
1575 }
1576
1577 return DEBUG_AddCVType( typeno, dt );
1578 }
1579
1580 static int
1581 DEBUG_AddCVType_Enum( unsigned int typeno, char *name, unsigned int fieldlist )
1582 {
1583 struct datatype *dt = DEBUG_NewDataType( DT_ENUM, name );
1584 struct datatype *list = DEBUG_GetCVType( fieldlist );
1585
1586 if ( list )
1587 if(DEBUG_CopyFieldlist( dt, list ) == FALSE)
1588 return FALSE;
1589
1590 return DEBUG_AddCVType( typeno, dt );
1591 }
1592
1593 static int
1594 DEBUG_AddCVType_Struct( unsigned int typeno, char *name, int structlen, unsigned int fieldlist )
1595 {
1596 struct datatype *dt = DEBUG_NewDataType( DT_STRUCT, name );
1597 struct datatype *list = DEBUG_GetCVType( fieldlist );
1598
1599 if ( list )
1600 {
1601 DEBUG_SetStructSize( dt, structlen );
1602 if(DEBUG_CopyFieldlist( dt, list ) == FALSE)
1603 return FALSE;
1604 }
1605
1606 return DEBUG_AddCVType( typeno, dt );
1607 }
1608
1609 static int
1610 DEBUG_ParseTypeTable( char *table, int len )
1611 {
1612 unsigned int curr_type = 0x1000;
1613 char *ptr = table;
1614
1615 while ( ptr - table < len )
1616 {
1617 union codeview_type *type = (union codeview_type *) ptr;
1618 int retv = TRUE;
1619
1620 switch ( type->generic.id )
1621 {
1622 case LF_POINTER:
1623 retv = DEBUG_AddCVType_Pointer( curr_type, type->pointer.datatype );
1624 break;
1625 case LF_POINTER_32:
1626 retv = DEBUG_AddCVType_Pointer( curr_type, type->pointer32.datatype );
1627 break;
1628
1629 case LF_ARRAY:
1630 {
1631 int arrlen, alen = numeric_leaf( &arrlen, &type->array.arrlen );
1632 unsigned char *name = (unsigned char *)&type->array.arrlen + alen;
1633
1634 retv = DEBUG_AddCVType_Array( curr_type, terminate_string( name ),
1635 type->array.elemtype, arrlen );
1636 break;
1637 }
1638 case LF_ARRAY_32:
1639 {
1640 int arrlen, alen = numeric_leaf( &arrlen, &type->array32.arrlen );
1641 unsigned char *name = (unsigned char *)&type->array32.arrlen + alen;
1642
1643 retv = DEBUG_AddCVType_Array( curr_type, terminate_string( name ),
1644 type->array32.elemtype, type->array32.arrlen );
1645 break;
1646 }
1647
1648 case LF_BITFIELD:
1649 retv = DEBUG_AddCVType_Bitfield( curr_type, type->bitfield.bitoff,
1650 type->bitfield.nbits,
1651 type->bitfield.type );
1652 break;
1653 case LF_BITFIELD_32:
1654 retv = DEBUG_AddCVType_Bitfield( curr_type, type->bitfield32.bitoff,
1655 type->bitfield32.nbits,
1656 type->bitfield32.type );
1657 break;
1658
1659 case LF_FIELDLIST:
1660 case LF_FIELDLIST_32:
1661 {
1662 /*
1663 * A 'field list' is a CodeView-specific data type which doesn't
1664 * directly correspond to any high-level data type. It is used
1665 * to hold the collection of members of a struct, class, union
1666 * or enum type. The actual definition of that type will follow
1667 * later, and refer to the field list definition record.
1668 *
1669 * As we don't have a field list type ourselves, we look ahead
1670 * in the field list to try to find out whether this field list
1671 * will be used for an enum or struct type, and create a dummy
1672 * type of the corresponding sort. Later on, the definition of
1673 * the 'real' type will copy the member / enumeration data.
1674 */
1675
1676 char *list = type->fieldlist.list;
1677 int len = (ptr + type->generic.len + 2) - list;
1678
1679 if ( ((union codeview_fieldtype *)list)->generic.id == LF_ENUMERATE )
1680 retv = DEBUG_AddCVType_EnumFieldList( curr_type, list, len );
1681 else
1682 retv = DEBUG_AddCVType_StructFieldList( curr_type, list, len );
1683 break;
1684 }
1685
1686 case LF_STRUCTURE:
1687 case LF_CLASS:
1688 {
1689 int structlen, slen = numeric_leaf( &structlen, &type->structure.structlen );
1690 unsigned char *name = (unsigned char *)&type->structure.structlen + slen;
1691
1692 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1693 structlen, type->structure.fieldlist );
1694 break;
1695 }
1696 case LF_STRUCTURE_32:
1697 case LF_CLASS_32:
1698 {
1699 int structlen, slen = numeric_leaf( &structlen, &type->structure32.structlen );
1700 unsigned char *name = (unsigned char *)&type->structure32.structlen + slen;
1701
1702 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1703 structlen, type->structure32.fieldlist );
1704 break;
1705 }
1706
1707 case LF_UNION:
1708 {
1709 int un_len, ulen = numeric_leaf( &un_len, &type->t_union.un_len );
1710 unsigned char *name = (unsigned char *)&type->t_union.un_len + ulen;
1711
1712 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1713 un_len, type->t_union.fieldlist );
1714 break;
1715 }
1716 case LF_UNION_32:
1717 {
1718 int un_len, ulen = numeric_leaf( &un_len, &type->t_union32.un_len );
1719 unsigned char *name = (unsigned char *)&type->t_union32.un_len + ulen;
1720
1721 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1722 un_len, type->t_union32.fieldlist );
1723 break;
1724 }
1725
1726 case LF_ENUM:
1727 retv = DEBUG_AddCVType_Enum( curr_type, terminate_string( type->enumeration.name ),
1728 type->enumeration.field );
1729 break;
1730 case LF_ENUM_32:
1731 retv = DEBUG_AddCVType_Enum( curr_type, terminate_string( type->enumeration32.name ),
1732 type->enumeration32.field );
1733 break;
1734
1735 default:
1736 break;
1737 }
1738
1739 if ( !retv )
1740 return FALSE;
1741
1742 curr_type++;
1743 ptr += type->generic.len + 2;
1744 }
1745
1746 return TRUE;
1747 }
1748
1749
1750 /*========================================================================
1751 * Process CodeView line number information.
1752 */
1753
1754 union any_size
1755 {
1756 char * c;
1757 short * s;
1758 int * i;
1759 unsigned int * ui;
1760 };
1761
1762 struct startend
1763 {
1764 unsigned int start;
1765 unsigned int end;
1766 };
1767
1768 struct codeview_linetab_hdr
1769 {
1770 unsigned int nline;
1771 unsigned int segno;
1772 unsigned int start;
1773 unsigned int end;
1774 char * sourcefile;
1775 unsigned short * linetab;
1776 unsigned int * offtab;
1777 };
1778
1779 static struct codeview_linetab_hdr *
1780 DEBUG_SnarfLinetab(char * linetab,
1781 int size)
1782 {
1783 int file_segcount;
1784 char filename[PATH_MAX];
1785 unsigned int * filetab;
1786 char * fn;
1787 int i;
1788 int k;
1789 struct codeview_linetab_hdr * lt_hdr;
1790 unsigned int * lt_ptr;
1791 int nfile;
1792 int nseg;
1793 union any_size pnt;
1794 union any_size pnt2;
1795 struct startend * start;
1796 int this_seg;
1797
1798 /*
1799 * Now get the important bits.
1800 */
1801 pnt.c = linetab;
1802 nfile = *pnt.s++;
1803 nseg = *pnt.s++;
1804
1805 filetab = (unsigned int *) pnt.c;
1806
1807 /*
1808 * Now count up the number of segments in the file.
1809 */
1810 nseg = 0;
1811 for(i=0; i<nfile; i++)
1812 {
1813 pnt2.c = linetab + filetab[i];
1814 nseg += *pnt2.s;
1815 }
1816
1817 /*
1818 * Next allocate the header we will be returning.
1819 * There is one header for each segment, so that we can reach in
1820 * and pull bits as required.
1821 */
1822 lt_hdr = (struct codeview_linetab_hdr *)
1823 DBG_alloc((nseg + 1) * sizeof(*lt_hdr));
1824 if( lt_hdr == NULL )
1825 {
1826 goto leave;
1827 }
1828
1829 memset(lt_hdr, 0, sizeof(*lt_hdr) * (nseg+1));
1830
1831 /*
1832 * Now fill the header we will be returning, one for each segment.
1833 * Note that this will basically just contain pointers into the existing
1834 * line table, and we do not actually copy any additional information
1835 * or allocate any additional memory.
1836 */
1837
1838 this_seg = 0;
1839 for(i=0; i<nfile; i++)
1840 {
1841 /*
1842 * Get the pointer into the segment information.
1843 */
1844 pnt2.c = linetab + filetab[i];
1845 file_segcount = *pnt2.s;
1846
1847 pnt2.ui++;
1848 lt_ptr = (unsigned int *) pnt2.c;
1849 start = (struct startend *) (lt_ptr + file_segcount);
1850
1851 /*
1852 * Now snarf the filename for all of the segments for this file.
1853 */
1854 fn = (unsigned char *) (start + file_segcount);
1855 memset(filename, 0, sizeof(filename));
1856 memcpy(filename, fn + 1, *fn);
1857 fn = DBG_strdup(filename);
1858
1859 for(k = 0; k < file_segcount; k++, this_seg++)
1860 {
1861 pnt2.c = linetab + lt_ptr[k];
1862 lt_hdr[this_seg].start = start[k].start;
1863 lt_hdr[this_seg].end = start[k].end;
1864 lt_hdr[this_seg].sourcefile = fn;
1865 lt_hdr[this_seg].segno = *pnt2.s++;
1866 lt_hdr[this_seg].nline = *pnt2.s++;
1867 lt_hdr[this_seg].offtab = pnt2.ui;
1868 lt_hdr[this_seg].linetab = (unsigned short *)
1869 (pnt2.ui + lt_hdr[this_seg].nline);
1870 }
1871 }
1872
1873 leave:
1874
1875 return lt_hdr;
1876
1877 }
1878
1879
1880 /*========================================================================
1881 * Process CodeView symbol information.
1882 */
1883
1884 union codeview_symbol
1885 {
1886 struct
1887 {
1888 short int len;
1889 short int id;
1890 } generic;
1891
1892 struct
1893 {
1894 short int len;
1895 short int id;
1896 unsigned int offset;
1897 unsigned short seg;
1898 unsigned short symtype;
1899 unsigned char namelen;
1900 unsigned char name[1];
1901 } data;
1902
1903 struct
1904 {
1905 short int len;
1906 short int id;
1907 unsigned int symtype;
1908 unsigned int offset;
1909 unsigned short seg;
1910 unsigned char namelen;
1911 unsigned char name[1];
1912 } data32;
1913
1914 struct
1915 {
1916 short int len;
1917 short int id;
1918 unsigned int pparent;
1919 unsigned int pend;
1920 unsigned int next;
1921 unsigned int offset;
1922 unsigned short segment;
1923 unsigned short thunk_len;
1924 unsigned char thtype;
1925 unsigned char namelen;
1926 unsigned char name[1];
1927 } thunk;
1928
1929 struct
1930 {
1931 short int len;
1932 short int id;
1933 unsigned int pparent;
1934 unsigned int pend;
1935 unsigned int next;
1936 unsigned int proc_len;
1937 unsigned int debug_start;
1938 unsigned int debug_end;
1939 unsigned int offset;
1940 unsigned short segment;
1941 unsigned short proctype;
1942 unsigned char flags;
1943 unsigned char namelen;
1944 unsigned char name[1];
1945 } proc;
1946
1947 struct
1948 {
1949 short int len;
1950 short int id;
1951 unsigned int pparent;
1952 unsigned int pend;
1953 unsigned int next;
1954 unsigned int proc_len;
1955 unsigned int debug_start;
1956 unsigned int debug_end;
1957 unsigned int proctype;
1958 unsigned int offset;
1959 unsigned short segment;
1960 unsigned char flags;
1961 unsigned char namelen;
1962 unsigned char name[1];
1963 } proc32;
1964
1965 struct
1966 {
1967 short int len; /* Total length of this entry */
1968 short int id; /* Always S_BPREL32 */
1969 unsigned int offset; /* Stack offset relative to BP */
1970 unsigned short symtype;
1971 unsigned char namelen;
1972 unsigned char name[1];
1973 } stack;
1974
1975 struct
1976 {
1977 short int len; /* Total length of this entry */
1978 short int id; /* Always S_BPREL32 */
1979 unsigned int offset; /* Stack offset relative to BP */
1980 unsigned int symtype;
1981 unsigned char namelen;
1982 unsigned char name[1];
1983 } stack32;
1984
1985 };
1986
1987 #define S_COMPILE 0x0001
1988 #define S_REGISTER 0x0002
1989 #define S_CONSTANT 0x0003
1990 #define S_UDT 0x0004
1991 #define S_SSEARCH 0x0005
1992 #define S_END 0x0006
1993 #define S_SKIP 0x0007
1994 #define S_CVRESERVE 0x0008
1995 #define S_OBJNAME 0x0009
1996 #define S_ENDARG 0x000a
1997 #define S_COBOLUDT 0x000b
1998 #define S_MANYREG 0x000c
1999 #define S_RETURN 0x000d
2000 #define S_ENTRYTHIS 0x000e
2001
2002 #define S_BPREL 0x0200
2003 #define S_LDATA 0x0201
2004 #define S_GDATA 0x0202
2005 #define S_PUB 0x0203
2006 #define S_LPROC 0x0204
2007 #define S_GPROC 0x0205
2008 #define S_THUNK 0x0206
2009 #define S_BLOCK 0x0207
2010 #define S_WITH 0x0208
2011 #define S_LABEL 0x0209
2012 #define S_CEXMODEL 0x020a
2013 #define S_VFTPATH 0x020b
2014 #define S_REGREL 0x020c
2015 #define S_LTHREAD 0x020d
2016 #define S_GTHREAD 0x020e
2017
2018 #define S_PROCREF 0x0400
2019 #define S_DATAREF 0x0401
2020 #define S_ALIGN 0x0402
2021 #define S_LPROCREF 0x0403
2022
2023 #define S_REGISTER_32 0x1001 /* Variants with new 32-bit type indices */
2024 #define S_CONSTANT_32 0x1002
2025 #define S_UDT_32 0x1003
2026 #define S_COBOLUDT_32 0x1004
2027 #define S_MANYREG_32 0x1005
2028
2029 #define S_BPREL_32 0x1006
2030 #define S_LDATA_32 0x1007
2031 #define S_GDATA_32 0x1008
2032 #define S_PUB_32 0x1009
2033 #define S_LPROC_32 0x100a
2034 #define S_GPROC_32 0x100b
2035 #define S_VFTTABLE_32 0x100c
2036 #define S_REGREL_32 0x100d
2037 #define S_LTHREAD_32 0x100e
2038 #define S_GTHREAD_32 0x100f
2039
2040
2041
2042 static unsigned int
2043 DEBUG_MapCVOffset( DBG_MODULE *module, unsigned int offset )
2044 {
2045 int nomap = module->msc_info->nomap;
2046 OMAP_DATA *omapp = module->msc_info->omapp;
2047 int i;
2048
2049 if ( !nomap || !omapp )
2050 return offset;
2051
2052 /* FIXME: use binary search */
2053 for ( i = 0; i < nomap-1; i++ )
2054 if ( omapp[i].from <= offset && omapp[i+1].from > offset )
2055 return !omapp[i].to? 0 : omapp[i].to + (offset - omapp[i].from);
2056
2057 return 0;
2058 }
2059
2060 static struct name_hash *
2061 DEBUG_AddCVSymbol( DBG_MODULE *module, char *name, int namelen,
2062 int type, unsigned int seg, unsigned int offset,
2063 int size, int cookie, int flags,
2064 struct codeview_linetab_hdr *linetab )
2065 {
2066 int nsect = module->msc_info->nsect;
2067 PIMAGE_SECTION_HEADER sectp = module->msc_info->sectp;
2068
2069 struct name_hash *symbol;
2070 char symname[PATH_MAX];
2071 DBG_VALUE value;
2072
2073 /*
2074 * Some sanity checks
2075 */
2076
2077 if ( !name || !namelen )
2078 return NULL;
2079
2080 if ( !seg || seg > nsect )
2081 return NULL;
2082
2083 /*
2084 * Convert type, address, and symbol name
2085 */
2086 value.type = type? DEBUG_GetCVType( type ) : NULL;
2087 value.cookie = cookie;
2088
2089 value.addr.seg = 0;
2090 value.addr.off = (unsigned int) module->load_addr +
2091 DEBUG_MapCVOffset( module, sectp[seg-1].VirtualAddress + offset );
2092
2093 memcpy( symname, name, namelen );
2094 symname[namelen] = '\0';
2095
2096
2097 /*
2098 * Check whether we have line number information
2099 */
2100 if ( linetab )
2101 {
2102 for ( ; linetab->linetab; linetab++ )
2103 if ( linetab->segno == seg
2104 && linetab->start <= offset
2105 && linetab->end > offset )
2106 break;
2107
2108 if ( !linetab->linetab )
2109 linetab = NULL;
2110 }
2111
2112
2113 /*
2114 * Create Wine symbol record
2115 */
2116 symbol = DEBUG_AddSymbol( symname, &value,
2117 linetab? linetab->sourcefile : NULL, flags );
2118
2119 if ( size )
2120 DEBUG_SetSymbolSize( symbol, size );
2121
2122
2123 /*
2124 * Add line numbers if found
2125 */
2126 if ( linetab )
2127 {
2128 unsigned int i;
2129 for ( i = 0; i < linetab->nline; i++ )
2130 if ( linetab->offtab[i] >= offset
2131 && linetab->offtab[i] < offset + size )
2132 {
2133 DEBUG_AddLineNumber( symbol, linetab->linetab[i],
2134 linetab->offtab[i] - offset );
2135 }
2136 }
2137
2138 return symbol;
2139 }
2140
2141 static struct wine_locals *
2142 DEBUG_AddCVLocal( struct name_hash *func, char *name, int namelen,
2143 int type, int offset )
2144 {
2145 struct wine_locals *local;
2146 char symname[PATH_MAX];
2147
2148 memcpy( symname, name, namelen );
2149 symname[namelen] = '\0';
2150
2151 local = DEBUG_AddLocal( func, 0, offset, 0, 0, symname );
2152 DEBUG_SetLocalSymbolType( local, DEBUG_GetCVType( type ) );
2153
2154 return local;
2155 }
2156
2157 static int
2158 DEBUG_SnarfCodeView( DBG_MODULE *module, LPBYTE root, int offset, int size,
2159 struct codeview_linetab_hdr *linetab )
2160 {
2161 struct name_hash *curr_func = NULL;
2162 int i, length;
2163
2164
2165 /*
2166 * Loop over the different types of records and whenever we
2167 * find something we are interested in, record it and move on.
2168 */
2169 for ( i = offset; i < size; i += length )
2170 {
2171 union codeview_symbol *sym = (union codeview_symbol *)(root + i);
2172 length = sym->generic.len + 2;
2173
2174 switch ( sym->generic.id )
2175 {
2176 /*
2177 * Global and local data symbols. We don't associate these
2178 * with any given source file.
2179 */
2180 case S_GDATA:
2181 case S_LDATA:
2182 case S_PUB:
2183 DEBUG_AddCVSymbol( module, sym->data.name, sym->data.namelen,
2184 sym->data.symtype, sym->data.seg,
2185 sym->data.offset, 0,
2186 DV_TARGET, SYM_WIN32 | SYM_DATA, NULL );
2187 break;
2188 case S_GDATA_32:
2189 case S_LDATA_32:
2190 case S_PUB_32:
2191 DEBUG_AddCVSymbol( module, sym->data32.name, sym->data32.namelen,
2192 sym->data32.symtype, sym->data32.seg,
2193 sym->data32.offset, 0,
2194 DV_TARGET, SYM_WIN32 | SYM_DATA, NULL );
2195 break;
2196
2197 /*
2198 * Sort of like a global function, but it just points
2199 * to a thunk, which is a stupid name for what amounts to
2200 * a PLT slot in the normal jargon that everyone else uses.
2201 */
2202 case S_THUNK:
2203 DEBUG_AddCVSymbol( module, sym->thunk.name, sym->thunk.namelen,
2204 0, sym->thunk.segment,
2205 sym->thunk.offset, sym->thunk.thunk_len,
2206 DV_TARGET, SYM_WIN32 | SYM_FUNC, NULL );
2207 break;
2208
2209 /*
2210 * Global and static functions.
2211 */
2212 case S_GPROC:
2213 case S_LPROC:
2214 DEBUG_Normalize( curr_func );
2215
2216 curr_func = DEBUG_AddCVSymbol( module, sym->proc.name, sym->proc.namelen,
2217 sym->proc.proctype, sym->proc.segment,
2218 sym->proc.offset, sym->proc.proc_len,
2219 DV_TARGET, SYM_WIN32 | SYM_FUNC, linetab );
2220
2221 DEBUG_SetSymbolBPOff( curr_func, sym->proc.debug_start );
2222 break;
2223 case S_GPROC_32:
2224 case S_LPROC_32:
2225 DEBUG_Normalize( curr_func );
2226
2227 curr_func = DEBUG_AddCVSymbol( module, sym->proc32.name, sym->proc32.namelen,
2228 sym->proc32.proctype, sym->proc32.segment,
2229 sym->proc32.offset, sym->proc32.proc_len,
2230 DV_TARGET, SYM_WIN32 | SYM_FUNC, linetab );
2231
2232 DEBUG_SetSymbolBPOff( curr_func, sym->proc32.debug_start );
2233 break;
2234
2235
2236 /*
2237 * Function parameters and stack variables.
2238 */
2239 case S_BPREL:
2240 DEBUG_AddCVLocal( curr_func, sym->stack.name, sym->stack.namelen,
2241 sym->stack.symtype, sym->stack.offset );
2242 break;
2243 case S_BPREL_32:
2244 DEBUG_AddCVLocal( curr_func, sym->stack32.name, sym->stack32.namelen,
2245 sym->stack32.symtype, sym->stack32.offset );
2246 break;
2247
2248
2249 /*
2250 * These are special, in that they are always followed by an
2251 * additional length-prefixed string which is *not* included
2252 * into the symbol length count. We need to skip it.
2253 */
2254 case S_PROCREF:
2255 case S_DATAREF:
2256 case S_LPROCREF:
2257 {
2258 LPBYTE name = (LPBYTE)sym + length;
2259 length += (*name + 1 + 3) & ~3;
2260 break;
2261 }
2262 }
2263 }
2264
2265 DEBUG_Normalize( curr_func );
2266
2267 if ( linetab ) DBG_free(linetab);
2268 return TRUE;
2269 }
2270
2271
2272
2273 /*========================================================================
2274 * Process PDB file.
2275 */
2276
2277 #pragma pack(1)
2278 typedef struct _PDB_FILE
2279 {
2280 DWORD size;
2281 DWORD unknown;
2282
2283 } PDB_FILE, *PPDB_FILE;
2284
2285 typedef struct _PDB_HEADER
2286 {
2287 CHAR ident[40];
2288 DWORD signature;
2289 DWORD blocksize;
2290 WORD freelist;
2291 WORD total_alloc;
2292 PDB_FILE toc;
2293 WORD toc_block[ 1 ];
2294
2295 } PDB_HEADER, *PPDB_HEADER;
2296
2297 typedef struct _PDB_TOC
2298 {
2299 DWORD nFiles;
2300 PDB_FILE file[ 1 ];
2301
2302 } PDB_TOC, *PPDB_TOC;
2303
2304 typedef struct _PDB_ROOT
2305 {
2306 DWORD version;
2307 DWORD TimeDateStamp;
2308 DWORD unknown;
2309 DWORD cbNames;
2310 CHAR names[ 1 ];
2311
2312 } PDB_ROOT, *PPDB_ROOT;
2313
2314 typedef struct _PDB_TYPES_OLD
2315 {
2316 DWORD version;
2317 WORD first_index;
2318 WORD last_index;
2319 DWORD type_size;
2320 WORD file;
2321 WORD pad;
2322
2323 } PDB_TYPES_OLD, *PPDB_TYPES_OLD;
2324
2325 typedef struct _PDB_TYPES
2326 {
2327 DWORD version;
2328 DWORD type_offset;
2329 DWORD first_index;
2330 DWORD last_index;
2331 DWORD type_size;
2332 WORD file;
2333 WORD pad;
2334 DWORD hash_size;
2335 DWORD hash_base;
2336 DWORD hash_offset;
2337 DWORD hash_len;
2338 DWORD search_offset;
2339 DWORD search_len;
2340 DWORD unknown_offset;
2341 DWORD unknown_len;
2342
2343 } PDB_TYPES, *PPDB_TYPES;
2344
2345 typedef struct _PDB_SYMBOL_RANGE
2346 {
2347 WORD segment;
2348 WORD pad1;
2349 DWORD offset;
2350 DWORD size;
2351 DWORD characteristics;
2352 WORD index;
2353 WORD pad2;
2354
2355 } PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE;
2356
2357 typedef struct _PDB_SYMBOL_RANGE_EX
2358 {
2359 WORD segment;
2360 WORD pad1;
2361 DWORD offset;
2362 DWORD size;
2363 DWORD characteristics;
2364 WORD index;
2365 WORD pad2;
2366 DWORD timestamp;
2367 DWORD unknown;
2368
2369 } PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX;
2370
2371 typedef struct _PDB_SYMBOL_FILE
2372 {
2373 DWORD unknown1;
2374 PDB_SYMBOL_RANGE range;
2375 WORD flag;
2376 WORD file;
2377 DWORD symbol_size;
2378 DWORD lineno_size;
2379 DWORD unknown2;
2380 DWORD nSrcFiles;
2381 DWORD attribute;
2382 CHAR filename[ 1 ];
2383
2384 } PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE;
2385
2386 typedef struct _PDB_SYMBOL_FILE_EX
2387 {
2388 DWORD unknown1;
2389 PDB_SYMBOL_RANGE_EX range;
2390 WORD flag;
2391 WORD file;
2392 DWORD symbol_size;
2393 DWORD lineno_size;
2394 DWORD unknown2;
2395 DWORD nSrcFiles;
2396 DWORD attribute;
2397 DWORD reserved[ 2 ];
2398 CHAR filename[ 1 ];
2399
2400 } PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX;
2401
2402 typedef struct _PDB_SYMBOL_SOURCE
2403 {
2404 WORD nModules;
2405 WORD nSrcFiles;
2406 WORD table[ 1 ];
2407
2408 } PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE;
2409
2410 typedef struct _PDB_SYMBOL_IMPORT
2411 {
2412 DWORD unknown1;
2413 DWORD unknown2;
2414 DWORD TimeDateStamp;
2415 DWORD nRequests;
2416 CHAR filename[ 1 ];
2417
2418 } PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT;
2419
2420 typedef struct _PDB_SYMBOLS_OLD
2421 {
2422 WORD hash1_file;
2423 WORD hash2_file;
2424 WORD gsym_file;
2425 WORD pad;
2426 DWORD module_size;
2427 DWORD offset_size;
2428 DWORD hash_size;
2429 DWORD srcmodule_size;
2430
2431 } PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD;
2432
2433 typedef struct _PDB_SYMBOLS
2434 {
2435 DWORD signature;
2436 DWORD version;
2437 DWORD unknown;
2438 DWORD hash1_file;
2439 DWORD hash2_file;
2440 DWORD gsym_file;
2441 DWORD module_size;
2442 DWORD offset_size;
2443 DWORD hash_size;
2444 DWORD srcmodule_size;
2445 DWORD pdbimport_size;
2446 DWORD resvd[ 5 ];
2447
2448 } PDB_SYMBOLS, *PPDB_SYMBOLS;
2449 #pragma pack()
2450
2451
2452 static void *pdb_read( LPBYTE image, WORD *block_list, int size )
2453 {
2454 PPDB_HEADER pdb = (PPDB_HEADER)image;
2455 int i, nBlocks;
2456 LPBYTE buffer;
2457
2458 if ( !size ) return NULL;
2459
2460 nBlocks = (size + pdb->blocksize-1) / pdb->blocksize;
2461 buffer = DBG_alloc( nBlocks * pdb->blocksize );
2462
2463 for ( i = 0; i < nBlocks; i++ )
2464 memcpy( buffer + i*pdb->blocksize,
2465 image + block_list[i]*pdb->blocksize, pdb->blocksize );
2466
2467 return buffer;
2468 }
2469
2470 static void *pdb_read_file( LPBYTE image, PPDB_TOC toc, DWORD fileNr )
2471 {
2472 PPDB_HEADER pdb = (PPDB_HEADER)image;
2473 WORD *block_list;
2474 DWORD i;
2475
2476 if ( !toc || fileNr >= toc->nFiles )
2477 return NULL;
2478
2479 block_list = (WORD *) &toc->file[ toc->nFiles ];
2480 for ( i = 0; i < fileNr; i++ )
2481 block_list += (toc->file[i].size + pdb->blocksize-1) / pdb->blocksize;
2482
2483 return pdb_read( image, block_list, toc->file[fileNr].size );
2484 }
2485
2486 static void pdb_free( void *buffer )
2487 {
2488 DBG_free( buffer );
2489 }
2490
2491 static void pdb_convert_types_header( PDB_TYPES *types, char *image )
2492 {
2493 memset( types, 0, sizeof(PDB_TYPES) );
2494 if ( !image ) return;
2495
2496 if ( *(DWORD *)image < 19960000 ) /* FIXME: correct version? */
2497 {
2498 /* Old version of the types record header */
2499 PDB_TYPES_OLD *old = (PDB_TYPES_OLD *)image;
2500 types->version = old->version;
2501 types->type_offset = sizeof(PDB_TYPES_OLD);
2502 types->type_size = old->type_size;
2503 types->first_index = old->first_index;
2504 types->last_index = old->last_index;
2505 types->file = old->file;
2506 }
2507 else
2508 {
2509 /* New version of the types record header */
2510 *types = *(PDB_TYPES *)image;
2511 }
2512 }
2513
2514 static void pdb_convert_symbols_header( PDB_SYMBOLS *symbols,
2515 int *header_size, char *image )
2516 {
2517 memset( symbols, 0, sizeof(PDB_SYMBOLS) );
2518 if ( !image ) return;
2519
2520 if ( *(DWORD *)image != 0xffffffff )
2521 {
2522 /* Old version of the symbols record header */
2523 PDB_SYMBOLS_OLD *old = (PDB_SYMBOLS_OLD *)image;
2524 symbols->version = 0;
2525 symbols->module_size = old->module_size;
2526 symbols->offset_size = old->offset_size;
2527 symbols->hash_size = old->hash_size;
2528 symbols->srcmodule_size = old->srcmodule_size;
2529 symbols->pdbimport_size = 0;
2530 symbols->hash1_file = old->hash1_file;
2531 symbols->hash2_file = old->hash2_file;
2532 symbols->gsym_file = old->gsym_file;
2533
2534 *header_size = sizeof(PDB_SYMBOLS_OLD);
2535 }
2536 else
2537 {
2538 /* New version of the symbols record header */
2539 *symbols = *(PDB_SYMBOLS *)image;
2540
2541 *header_size = sizeof(PDB_SYMBOLS);
2542 }
2543 }
2544
2545 static enum DbgInfoLoad DEBUG_ProcessPDBFile( DBG_MODULE *module,
2546 const char *filename, DWORD timestamp )
2547 {
2548 enum DbgInfoLoad dil = DIL_ERROR;
2549 HANDLE hFile, hMap;
2550 char *image = NULL;
2551 PDB_HEADER *pdb = NULL;
2552 PDB_TOC *toc = NULL;
2553 PDB_ROOT *root = NULL;
2554 char *types_image = NULL;
2555 char *symbols_image = NULL;
2556 PDB_TYPES types;
2557 PDB_SYMBOLS symbols;
2558 int header_size = 0;
2559 char *modimage, *file;
2560
2561 DEBUG_Printf( DBG_CHN_TRACE, "Processing PDB file %s\n", filename );
2562
2563 /*
2564 * Open and map() .PDB file
2565 */
2566 image = DEBUG_MapDebugInfoFile( filename, 0, 0, &hFile, &hMap );
2567 if ( !image )
2568 {
2569 DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .PDB file %s\n", filename );
2570 goto leave;
2571 }
2572
2573 /*
2574 * Read in TOC and well-known files
2575 */
2576
2577 pdb = (PPDB_HEADER)image;
2578 toc = pdb_read( image, pdb->toc_block, pdb->toc.size );
2579 root = pdb_read_file( image, toc, 1 );
2580 types_image = pdb_read_file( image, toc, 2 );
2581 symbols_image = pdb_read_file( image, toc, 3 );
2582
2583 pdb_convert_types_header( &types, types_image );
2584 pdb_convert_symbols_header( &symbols, &header_size, symbols_image );
2585
2586 /*
2587 * Check for unknown versions
2588 */
2589
2590 switch ( root->version )
2591 {
2592 case 19950623: /* VC 4.0 */
2593 case 19950814:
2594 case 19960307: /* VC 5.0 */
2595 case 19970604: /* VC 6.0 */
2596 break;
2597 default:
2598 DEBUG_Printf( DBG_CHN_ERR, "-Unknown root block version %ld\n", root->version );
2599 }
2600
2601 switch ( types.version )
2602 {
2603 case 19950410: /* VC 4.0 */
2604 case 19951122:
2605 case 19961031: /* VC 5.0 / 6.0 */
2606 break;
2607 default:
2608 DEBUG_Printf( DBG_CHN_ERR, "-Unknown type info version %ld\n", types.version );
2609 }
2610
2611 switch ( symbols.version )
2612 {
2613 case 0: /* VC 4.0 */
2614 case 19960307: /* VC 5.0 */
2615 case 19970606: /* VC 6.0 */
2616 break;
2617 default:
2618 DEBUG_Printf( DBG_CHN_ERR, "-Unknown symbol info version %ld\n", symbols.version );
2619 }
2620
2621
2622 /*
2623 * Check .PDB time stamp
2624 */
2625
2626 if ( root->TimeDateStamp != timestamp )
2627 {
2628 DEBUG_Printf( DBG_CHN_ERR, "-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n",
2629 filename, root->TimeDateStamp, timestamp );
2630 }
2631
2632 /*
2633 * Read type table
2634 */
2635
2636 DEBUG_ParseTypeTable( types_image + types.type_offset, types.type_size );
2637
2638 /*
2639 * Read type-server .PDB imports
2640 */
2641
2642 if ( symbols.pdbimport_size )
2643 {
2644 /* FIXME */
2645 DEBUG_Printf(DBG_CHN_ERR, "-Type server .PDB imports ignored!\n" );
2646 }
2647
2648 /*
2649 * Read global symbol table
2650 */
2651
2652 modimage = pdb_read_file( image, toc, symbols.gsym_file );
2653 if ( modimage )
2654 {
2655 DEBUG_SnarfCodeView( module, modimage, 0,
2656 toc->file[symbols.gsym_file].size, NULL );
2657 pdb_free( modimage );
2658 }
2659
2660 /*
2661 * Read per-module symbol / linenumber tables
2662 */
2663
2664 file = symbols_image + header_size;
2665 while ( file - symbols_image < header_size + symbols.module_size )
2666 {
2667 int file_nr, file_index, symbol_size, lineno_size;
2668 char *file_name;
2669
2670 if ( symbols.version < 19970000 )
2671 {
2672 PDB_SYMBOL_FILE *sym_file = (PDB_SYMBOL_FILE *) file;
2673 file_nr = sym_file->file;
2674 file_name = sym_file->filename;
2675 file_index = sym_file->range.index;
2676 symbol_size = sym_file->symbol_size;
2677 lineno_size = sym_file->lineno_size;
2678 }
2679 else
2680 {
2681 PDB_SYMBOL_FILE_EX *sym_file = (PDB_SYMBOL_FILE_EX *) file;
2682 file_nr = sym_file->file;
2683 file_name = sym_file->filename;
2684 file_index = sym_file->range.index;
2685 symbol_size = sym_file->symbol_size;
2686 lineno_size = sym_file->lineno_size;
2687 }
2688
2689 modimage = pdb_read_file( image, toc, file_nr );
2690 if ( modimage )
2691 {
2692 struct codeview_linetab_hdr *linetab = NULL;
2693
2694 if ( lineno_size )
2695 linetab = DEBUG_SnarfLinetab( modimage + symbol_size, lineno_size );
2696
2697 if ( symbol_size )
2698 DEBUG_SnarfCodeView( module, modimage, sizeof(DWORD),
2699 symbol_size, linetab );
2700
2701 pdb_free( modimage );
2702 }
2703
2704 file_name += strlen(file_name) + 1;
2705 file = (char *)( (DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3 );
2706 }
2707
2708 dil = DIL_LOADED;
2709
2710 leave:
2711
2712 /*
2713 * Cleanup
2714 */
2715
2716 DEBUG_ClearTypeTable();
2717
2718 if ( symbols_image ) pdb_free( symbols_image );
2719 if ( types_image ) pdb_free( types_image );
2720 if ( root ) pdb_free( root );
2721 if ( toc ) pdb_free( toc );
2722
2723 DEBUG_UnmapDebugInfoFile(hFile, hMap, image);
2724
2725 return dil;
2726 }
2727
2728
2729
2730
2731 /*========================================================================
2732 * Process CodeView debug information.
2733 */
2734
2735 #define CODEVIEW_NB09_SIG ( 'N' | ('B' << 8) | ('0' << 16) | ('9' << 24) )
2736 #define CODEVIEW_NB10_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('0' << 24) )
2737 #define CODEVIEW_NB11_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('1' << 24) )
2738
2739 typedef struct _CODEVIEW_HEADER
2740 {
2741 DWORD dwSignature;
2742 DWORD lfoDirectory;
2743
2744 } CODEVIEW_HEADER, *PCODEVIEW_HEADER;
2745
2746 typedef struct _CODEVIEW_PDB_DATA
2747 {
2748 DWORD timestamp;
2749 DWORD unknown;
2750 CHAR name[ 1 ];
2751
2752 } CODEVIEW_PDB_DATA, *PCODEVIEW_PDB_DATA;
2753
2754 typedef struct _CV_DIRECTORY_HEADER
2755 {
2756 WORD cbDirHeader;
2757 WORD cbDirEntry;
2758 DWORD cDir;
2759 DWORD lfoNextDir;
2760 DWORD flags;
2761
2762 } CV_DIRECTORY_HEADER, *PCV_DIRECTORY_HEADER;
2763
2764 typedef struct _CV_DIRECTORY_ENTRY
2765 {
2766 WORD subsection;
2767 WORD iMod;
2768 DWORD lfo;
2769 DWORD cb;
2770
2771 } CV_DIRECTORY_ENTRY, *PCV_DIRECTORY_ENTRY;
2772
2773
2774 #define sstAlignSym 0x125
2775 #define sstSrcModule 0x127
2776
2777
2778 static enum DbgInfoLoad DEBUG_ProcessCodeView( DBG_MODULE *module, LPBYTE root )
2779 {
2780 PCODEVIEW_HEADER cv = (PCODEVIEW_HEADER)root;
2781 enum DbgInfoLoad dil = DIL_ERROR;
2782
2783 switch ( cv->dwSignature )
2784 {
2785 case CODEVIEW_NB09_SIG:
2786 case CODEVIEW_NB11_SIG:
2787 {
2788 PCV_DIRECTORY_HEADER hdr = (PCV_DIRECTORY_HEADER)(root + cv->lfoDirectory);
2789 PCV_DIRECTORY_ENTRY ent, prev, next;
2790 unsigned int i;
2791
2792 ent = (PCV_DIRECTORY_ENTRY)((LPBYTE)hdr + hdr->cbDirHeader);
2793 for ( i = 0; i < hdr->cDir; i++, ent = next )
2794 {
2795 next = (i == hdr->cDir-1)? NULL :
2796 (PCV_DIRECTORY_ENTRY)((LPBYTE)ent + hdr->cbDirEntry);
2797 prev = (i == 0)? NULL :
2798 (PCV_DIRECTORY_ENTRY)((LPBYTE)ent - hdr->cbDirEntry);
2799
2800 if ( ent->subsection == sstAlignSym )
2801 {
2802 /*
2803 * Check the next and previous entry. If either is a
2804 * sstSrcModule, it contains the line number info for
2805 * this file.
2806 *
2807 * FIXME: This is not a general solution!
2808 */
2809 struct codeview_linetab_hdr *linetab = NULL;
2810
2811 if ( next && next->iMod == ent->iMod
2812 && next->subsection == sstSrcModule )
2813 linetab = DEBUG_SnarfLinetab( root + next->lfo, next->cb );
2814
2815 if ( prev && prev->iMod == ent->iMod
2816 && prev->subsection == sstSrcModule )
2817 linetab = DEBUG_SnarfLinetab( root + prev->lfo, prev->cb );
2818
2819
2820 DEBUG_SnarfCodeView( module, root + ent->lfo, sizeof(DWORD),
2821 ent->cb, linetab );
2822 }
2823 }
2824
2825 dil = DIL_LOADED;
2826 break;
2827 }
2828
2829 case CODEVIEW_NB10_SIG:
2830 {
2831 PCODEVIEW_PDB_DATA pdb = (PCODEVIEW_PDB_DATA)(cv + 1);
2832
2833 dil = DEBUG_ProcessPDBFile( module, pdb->name, pdb->timestamp );
2834 break;
2835 }
2836
2837 default:
2838 DEBUG_Printf( DBG_CHN_ERR, "Unknown CODEVIEW signature %08lX in module %s\n",
2839 cv->dwSignature, module->module_name );
2840 break;
2841 }
2842
2843 return dil;
2844 }
2845
2846
2847 /*========================================================================
2848 * Process debug directory.
2849 */
2850 static enum DbgInfoLoad DEBUG_ProcessDebugDirectory( DBG_MODULE *module,
2851 LPBYTE file_map,
2852 PIMAGE_DEBUG_DIRECTORY dbg,
2853 int nDbg )
2854 {
2855 enum DbgInfoLoad dil = DIL_ERROR;
2856 int i;
2857
2858 /* First, watch out for OMAP data */
2859 for ( i = 0; i < nDbg; i++ )
2860 {
2861 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_OMAP_FROM_SRC )
2862 {
2863 module->msc_info->nomap = dbg[i].SizeOfData / sizeof(OMAP_DATA);
2864 module->msc_info->omapp = (OMAP_DATA *)(file_map + dbg[i].PointerToRawData);
2865 break;
2866 }
2867 }
2868
2869 /* Now, try to parse CodeView debug info */
2870 for ( i = 0; dil != DIL_LOADED && i < nDbg; i++ )
2871 {
2872 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW )
2873 {
2874 dil = DEBUG_ProcessCodeView( module, file_map + dbg[i].PointerToRawData );
2875 }
2876 }
2877
2878 /* If not found, try to parse COFF debug info */
2879 for ( i = 0; dil != DIL_LOADED && i < nDbg; i++ )
2880 {
2881 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_COFF )
2882 dil = DEBUG_ProcessCoff( module, file_map + dbg[i].PointerToRawData );
2883 }
2884 #if 0
2885 /* FIXME: this should be supported... this is the debug information for
2886 * functions compiled without a frame pointer (FPO = frame pointer omission)
2887 * the associated data helps finding out the relevant information
2888 */
2889 for ( i = 0; i < nDbg; i++ )
2890 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_FPO )
2891 DEBUG_Printf(DBG_CHN_MESG, "This guy has FPO information\n");
2892
2893 #define FRAME_FPO 0
2894 #define FRAME_TRAP 1
2895 #define FRAME_TSS 2
2896
2897 typedef struct _FPO_DATA {
2898 DWORD ulOffStart; /* offset 1st byte of function code */
2899 DWORD cbProcSize; /* # bytes in function */
2900 DWORD cdwLocals; /* # bytes in locals/4 */
2901 WORD cdwParams; /* # bytes in params/4 */
2902
2903 WORD cbProlog : 8; /* # bytes in prolog */
2904 WORD cbRegs : 3; /* # regs saved */
2905 WORD fHasSEH : 1; /* TRUE if SEH in func */
2906 WORD fUseBP : 1; /* TRUE if EBP has been allocated */
2907 WORD reserved : 1; /* reserved for future use */
2908 WORD cbFrame : 2; /* frame type */
2909 } FPO_DATA;
2910 #endif
2911
2912 return dil;
2913 }
2914
2915
2916 /*========================================================================
2917 * Process DBG file.
2918 */
2919 static enum DbgInfoLoad DEBUG_ProcessDBGFile( DBG_MODULE *module,
2920 const char *filename, DWORD timestamp )
2921 {
2922 enum DbgInfoLoad dil = DIL_ERROR;
2923 HANDLE hFile = INVALID_HANDLE_VALUE, hMap = 0;
2924 LPBYTE file_map = NULL;
2925 PIMAGE_SEPARATE_DEBUG_HEADER hdr;
2926 PIMAGE_DEBUG_DIRECTORY dbg;
2927 int nDbg;
2928
2929
2930 DEBUG_Printf( DBG_CHN_TRACE, "Processing DBG file %s\n", filename );
2931
2932 file_map = DEBUG_MapDebugInfoFile( filename, 0, 0, &hFile, &hMap );
2933 if ( !file_map )
2934 {
2935 DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .DBG file %s\n", filename );
2936 goto leave;
2937 }
2938
2939 hdr = (PIMAGE_SEPARATE_DEBUG_HEADER) file_map;
2940
2941 if ( hdr->TimeDateStamp != timestamp )
2942 {
2943 DEBUG_Printf( DBG_CHN_ERR, "Warning - %s has incorrect internal timestamp\n",
2944 filename );
2945 /*
2946 * Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
2947 * files but nonetheless this check fails. Anyway, WINDBG (debugger for
2948 * Windows by Microsoft) loads debug symbols which have incorrect timestamps.
2949 */
2950 }
2951
2952
2953 dbg = (PIMAGE_DEBUG_DIRECTORY) ( file_map + sizeof(*hdr)
2954 + hdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
2955 + hdr->ExportedNamesSize );
2956
2957 nDbg = hdr->DebugDirectorySize / sizeof(*dbg);
2958
2959 dil = DEBUG_ProcessDebugDirectory( module, file_map, dbg, nDbg );
2960
2961
2962 leave:
2963 DEBUG_UnmapDebugInfoFile( hFile, hMap, file_map );
2964 return dil;
2965 }
2966
2967
2968 /*========================================================================
2969 * Process MSC debug information in PE file.
2970 */
2971 enum DbgInfoLoad DEBUG_RegisterMSCDebugInfo( DBG_MODULE *module, HANDLE hFile,
2972 void *_nth, unsigned long nth_ofs )
2973 {
2974 enum DbgInfoLoad dil = DIL_ERROR;
2975 PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
2976 PIMAGE_DATA_DIRECTORY dir = nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
2977 PIMAGE_DEBUG_DIRECTORY dbg = NULL;
2978 int nDbg;
2979 MSC_DBG_INFO extra_info = { 0, NULL, 0, NULL };
2980 HANDLE hMap = 0;
2981 LPBYTE file_map = NULL;
2982
2983
2984 /* Read in section data */
2985
2986 module->msc_info = &extra_info;
2987 extra_info.nsect = nth->FileHeader.NumberOfSections;
2988 extra_info.sectp = DBG_alloc( extra_info.nsect * sizeof(IMAGE_SECTION_HEADER) );
2989 if ( !extra_info.sectp )
2990 goto leave;
2991
2992 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module->load_addr +
2993 nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
2994 nth->FileHeader.SizeOfOptionalHeader,
2995 extra_info.sectp,
2996 extra_info.nsect * sizeof(IMAGE_SECTION_HEADER) ) )
2997 goto leave;
2998
2999 /* Read in debug directory */
3000
3001 nDbg = dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY);
3002 if ( !nDbg )
3003 goto leave;
3004
3005 dbg = (PIMAGE_DEBUG_DIRECTORY) DBG_alloc( nDbg * sizeof(IMAGE_DEBUG_DIRECTORY) );
3006 if ( !dbg )
3007 goto leave;
3008
3009 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module->load_addr + dir->VirtualAddress,
3010 dbg, nDbg * sizeof(IMAGE_DEBUG_DIRECTORY) ) )
3011 goto leave;
3012
3013
3014 /* Map in PE file */
3015 file_map = DEBUG_MapDebugInfoFile( NULL, 0, 0, &hFile, &hMap );
3016 if ( !file_map )
3017 goto leave;
3018
3019
3020 /* Parse debug directory */
3021
3022 if ( nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED )
3023 {
3024 /* Debug info is stripped to .DBG file */
3025
3026 PIMAGE_DEBUG_MISC misc = (PIMAGE_DEBUG_MISC)(file_map + dbg->PointerToRawData);
3027
3028 if ( nDbg != 1 || dbg->Type != IMAGE_DEBUG_TYPE_MISC
3029 || misc->DataType != IMAGE_DEBUG_MISC_EXENAME )
3030 {
3031 DEBUG_Printf( DBG_CHN_ERR, "-Debug info stripped, but no .DBG file in module %s\n",
3032 module->module_name );
3033 goto leave;
3034 }
3035
3036 dil = DEBUG_ProcessDBGFile( module, misc->Data, nth->FileHeader.TimeDateStamp );
3037 }
3038 else
3039 {
3040 /* Debug info is embedded into PE module */
3041 /* FIXME: the nDBG information we're manipulating comes from the debuggee
3042 * address space. However, the following code will be made against the
3043 * version mapped in the debugger address space. There are cases (for example
3044 * when the PE sections are compressed in the file and become decompressed
3045 * in the debuggee address space) where the two don't match.
3046 * Therefore, redo the DBG information lookup with the mapped data
3047 */
3048 PIMAGE_NT_HEADERS mpd_nth = (PIMAGE_NT_HEADERS)(file_map + nth_ofs);
3049 PIMAGE_DATA_DIRECTORY mpd_dir;
3050 PIMAGE_DEBUG_DIRECTORY mpd_dbg = NULL;
3051
3052 /* sanity checks */
3053 if ( mpd_nth->Signature != IMAGE_NT_SIGNATURE ||
3054 mpd_nth->FileHeader.NumberOfSections != nth->FileHeader.NumberOfSections ||
3055 !(mpd_nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED ))
3056 goto leave;
3057 mpd_dir = mpd_nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
3058
3059 if ((mpd_dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY)) != nDbg)
3060 goto leave;
3061
3062 mpd_dbg = (PIMAGE_DEBUG_DIRECTORY)(file_map + mpd_dir->VirtualAddress);
3063
3064 dil = DEBUG_ProcessDebugDirectory( module, file_map, mpd_dbg, nDbg );
3065 }
3066
3067
3068 leave:
3069 module->msc_info = NULL;
3070
3071 DEBUG_UnmapDebugInfoFile( 0, hMap, file_map );
3072 if ( extra_info.sectp ) DBG_free( extra_info.sectp );
3073 if ( dbg ) DBG_free( dbg );
3074 return dil;
3075 }
3076
3077
3078 /*========================================================================
3079 * look for stabs information in PE header (it's how mingw compiler provides its
3080 * debugging information), and also wine PE <-> ELF linking through .wsolnk sections
3081 */
3082 enum DbgInfoLoad DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile,
3083 void* _nth, unsigned long nth_ofs)
3084 {
3085 IMAGE_SECTION_HEADER pe_seg;
3086 unsigned long pe_seg_ofs;
3087 int i, stabsize = 0, stabstrsize = 0;
3088 unsigned int stabs = 0, stabstr = 0;
3089 PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
3090 enum DbgInfoLoad dil = DIL_ERROR;
3091
3092 pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
3093 nth->FileHeader.SizeOfOptionalHeader;
3094
3095 for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
3096 if (!DEBUG_READ_MEM_VERBOSE((void*)((char *)module->load_addr + pe_seg_ofs),
3097 &pe_seg, sizeof(pe_seg)))
3098 continue;
3099
3100 if (!strcasecmp(pe_seg.Name, ".stab")) {
3101 stabs = pe_seg.VirtualAddress;
3102 stabsize = pe_seg.SizeOfRawData;
3103 } else if (!strncasecmp(pe_seg.Name, ".stabstr", 8)) {
3104 stabstr = pe_seg.VirtualAddress;
3105 stabstrsize = pe_seg.SizeOfRawData;
3106 }
3107 }
3108
3109 if (stabstrsize && stabsize) {
3110 char* s1 = DBG_alloc(stabsize+stabstrsize);
3111
3112 if (s1) {
3113 if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabs, s1, stabsize) &&
3114 DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabstr,
3115 s1 + stabsize, stabstrsize)) {
3116 dil = DEBUG_ParseStabs(s1, 0, 0, stabsize, stabsize, stabstrsize);
3117 } else {
3118 DEBUG_Printf(DBG_CHN_MESG, "couldn't read data block\n");
3119 }
3120 DBG_free(s1);
3121 } else {
3122 DEBUG_Printf(DBG_CHN_MESG, "couldn't alloc %d bytes\n",
3123 stabsize + stabstrsize);
3124 }
3125 } else {
3126 dil = DIL_NOINFO;
3127 }
3128 return dil;
3129 }
3130
Windows API implementation