Assorted typo, spelling, wording and case fixes.
[wine] / dlls / dbghelp / stabs.c
1 /*
2  * File stabs.c - read stabs information from the modules
3  *
4  * Copyright (C) 1996,      Eric Youngdale.
5  *               1999-2005, Eric Pouech
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  *
21  *
22  * Maintenance Information
23  * -----------------------
24  *
25  * For documentation on the stabs format see for example
26  *   The "stabs" debug format
27  *     by Julia Menapace, Jim Kingdon, David Mackenzie
28  *     of Cygnus Support
29  *     available (hopefully) from http://sources.redhat.com/gdb/onlinedocs
30  */
31
32 #include "config.h"
33 #include "wine/port.h"
34
35 #include <sys/types.h>
36 #include <fcntl.h>
37 #ifdef HAVE_SYS_STAT_H
38 # include <sys/stat.h>
39 #endif
40 #ifdef HAVE_SYS_MMAN_H
41 #include <sys/mman.h>
42 #endif
43 #include <limits.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #ifdef HAVE_UNISTD_H
47 # include <unistd.h>
48 #endif
49 #include <stdio.h>
50 #include <assert.h>
51 #include <stdarg.h>
52
53 #ifdef HAVE_MACH_O_NLIST_H
54 # include <mach-o/nlist.h>
55 #endif
56
57 #include "windef.h"
58 #include "winbase.h"
59 #include "winnls.h"
60
61 #include "dbghelp_private.h"
62
63 #include "wine/debug.h"
64
65 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_stabs);
66
67 /* Masks for n_type field */
68 #ifndef N_STAB
69 #define N_STAB          0xe0
70 #endif
71 #ifndef N_TYPE
72 #define N_TYPE          0x1e
73 #endif
74 #ifndef N_EXT
75 #define N_EXT           0x01
76 #endif
77
78 /* Values for (n_type & N_TYPE) */
79 #ifndef N_UNDF
80 #define N_UNDF          0x00
81 #endif
82 #ifndef N_ABS
83 #define N_ABS           0x02
84 #endif
85
86 #define N_GSYM          0x20
87 #define N_FUN           0x24
88 #define N_STSYM         0x26
89 #define N_LCSYM         0x28
90 #define N_MAIN          0x2a
91 #define N_ROSYM         0x2c
92 #define N_BNSYM         0x2e
93 #define N_OPT           0x3c
94 #define N_RSYM          0x40
95 #define N_SLINE         0x44
96 #define N_ENSYM         0x4e
97 #define N_SO            0x64
98 #define N_OSO           0x66
99 #define N_LSYM          0x80
100 #define N_BINCL         0x82
101 #define N_SOL           0x84
102 #define N_PSYM          0xa0
103 #define N_EINCL         0xa2
104 #define N_LBRAC         0xc0
105 #define N_EXCL          0xc2
106 #define N_RBRAC         0xe0
107
108 struct stab_nlist
109 {
110     unsigned            n_strx;
111     unsigned char       n_type;
112     char                n_other;
113     short               n_desc;
114     unsigned            n_value;
115 };
116
117 static void stab_strcpy(char* dest, int sz, const char* source)
118 {
119     char*       ptr = dest;
120     /*
121      * A strcpy routine that stops when we hit the ':' character.
122      * Faster than copying the whole thing, and then nuking the
123      * ':'.
124      * Takes also care of (valid) a::b constructs
125      */
126     while (*source != '\0')
127     {
128         if (source[0] != ':' && sz-- > 0) *ptr++ = *source++;
129         else if (source[1] == ':' && (sz -= 2) > 0)
130         {
131             *ptr++ = *source++;
132             *ptr++ = *source++;
133         }
134         else break;
135     }
136     *ptr-- = '\0';
137     /* GCC emits, in some cases, a .<digit>+ suffix.
138      * This is used for static variable inside functions, so
139      * that we can have several such variables with same name in
140      * the same compilation unit
141      * We simply ignore that suffix when present (we also get rid
142      * of it in ELF symtab parsing)
143      */
144     if (ptr >= dest && isdigit(*ptr))
145     {
146         while (ptr > dest && isdigit(*ptr)) ptr--;
147         if (*ptr == '.') *ptr = '\0';
148     }
149     assert(sz > 0);
150 }
151
152 typedef struct
153 {
154    char*                name;
155    unsigned long        value;
156    struct symt**        vector;
157    int                  nrofentries;
158 } include_def;
159
160 #define MAX_INCLUDES    5120
161
162 static include_def*             include_defs = NULL;
163 static int                      num_include_def = 0;
164 static int                      num_alloc_include_def = 0;
165 static int                      cu_include_stack[MAX_INCLUDES];
166 static int                      cu_include_stk_idx = 0;
167 static struct symt**            cu_vector = NULL;
168 static int                      cu_nrofentries = 0;
169 static struct symt_basic*       stabs_basic[36];
170
171 static int stabs_new_include(const char* file, unsigned long val)
172 {
173     if (num_include_def == num_alloc_include_def)
174     {
175         if (!include_defs)
176         {
177             num_alloc_include_def = 256;
178             include_defs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
179                                      sizeof(include_defs[0]) * num_alloc_include_def);
180         }
181         else
182         {
183             num_alloc_include_def *= 2;
184             include_defs = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, include_defs,
185                                        sizeof(include_defs[0]) * num_alloc_include_def);
186         }
187     }
188     include_defs[num_include_def].name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(file) + 1), file);
189     include_defs[num_include_def].value = val;
190     include_defs[num_include_def].vector = NULL;
191     include_defs[num_include_def].nrofentries = 0;
192
193     return num_include_def++;
194 }
195
196 static int stabs_find_include(const char* file, unsigned long val)
197 {
198     int         i;
199
200     for (i = 0; i < num_include_def; i++)
201     {
202         if (val == include_defs[i].value &&
203             strcmp(file, include_defs[i].name) == 0)
204             return i;
205     }
206     return -1;
207 }
208
209 static int stabs_add_include(int idx)
210 {
211     if (idx < 0) return -1;
212     cu_include_stk_idx++;
213
214     /* if this happens, just bump MAX_INCLUDES */
215     /* we could also handle this as another dynarray */
216     assert(cu_include_stk_idx < MAX_INCLUDES);
217     cu_include_stack[cu_include_stk_idx] = idx;
218     return cu_include_stk_idx;
219 }
220
221 static void stabs_reset_includes(void)
222 {
223     /*
224      * The struct symt:s that we would need to use are reset when
225      * we start a new file. (at least the ones in filenr == 0)
226      */
227     cu_include_stk_idx = 0;/* keep 0 as index for the .c file itself */
228     memset(cu_vector, 0, sizeof(cu_vector[0]) * cu_nrofentries);
229 }
230
231 static void stabs_free_includes(void)
232 {
233     int i;
234
235     stabs_reset_includes();
236     for (i = 0; i < num_include_def; i++)
237     {
238         HeapFree(GetProcessHeap(), 0, include_defs[i].name);
239         HeapFree(GetProcessHeap(), 0, include_defs[i].vector);
240     }
241     HeapFree(GetProcessHeap(), 0, include_defs);
242     include_defs = NULL;
243     num_include_def = 0;
244     num_alloc_include_def = 0;
245     HeapFree(GetProcessHeap(), 0, cu_vector);
246     cu_vector = NULL;
247     cu_nrofentries = 0;
248 }
249
250 static struct symt** stabs_find_ref(long filenr, long subnr)
251 {
252     struct symt**       ret;
253
254     /* FIXME: I could perhaps create a dummy include_def for each compilation
255      * unit which would allow not to handle those two cases separately
256      */
257     if (filenr == 0)
258     {
259         if (cu_nrofentries <= subnr)
260         {
261             cu_nrofentries = max( cu_nrofentries * 2, subnr + 1 );
262             if (!cu_vector)
263                 cu_vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
264                                       sizeof(cu_vector[0]) * cu_nrofentries);
265             else
266                 cu_vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
267                                         cu_vector, sizeof(cu_vector[0]) * cu_nrofentries);
268         }
269         ret = &cu_vector[subnr];
270     }
271     else
272     {
273         include_def*    idef;
274
275         assert(filenr <= cu_include_stk_idx);
276         idef = &include_defs[cu_include_stack[filenr]];
277
278         if (idef->nrofentries <= subnr)
279         {
280             idef->nrofentries = max( idef->nrofentries * 2, subnr + 1 );
281             if (!idef->vector)
282                 idef->vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
283                                          sizeof(idef->vector[0]) * idef->nrofentries);
284             else
285                 idef->vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
286                                            idef->vector, sizeof(idef->vector[0]) * idef->nrofentries);
287         }
288         ret = &idef->vector[subnr];
289     }
290     TRACE("(%ld,%ld) => %p (%p)\n", filenr, subnr, ret, *ret);
291     return ret;
292 }
293
294 static struct symt** stabs_read_type_enum(const char** x)
295 {
296     long        filenr, subnr;
297     const char* iter;
298     char*       end;
299
300     iter = *x;
301     if (*iter == '(')
302     {
303         ++iter;                             /* '('   */
304         filenr = strtol(iter, &end, 10);    /* <int> */
305         iter = ++end;                       /* ','   */
306         subnr = strtol(iter, &end, 10);     /* <int> */
307         iter = ++end;                       /* ')'   */
308     }
309     else
310     {
311         filenr = 0;
312         subnr = strtol(iter, &end, 10);     /* <int> */
313         iter = end;
314     }
315     *x = iter;
316     return stabs_find_ref(filenr, subnr);
317 }
318
319 #define PTS_DEBUG
320 struct ParseTypedefData
321 {
322     const char*         ptr;
323     char                buf[1024];
324     int                 idx;
325     struct module*      module;
326 #ifdef PTS_DEBUG
327     struct PTS_Error 
328     {
329         const char*         ptr;
330         unsigned            line;
331     } errors[16];
332     int                 err_idx;
333 #endif
334 };
335
336 #ifdef PTS_DEBUG
337 static void stabs_pts_push(struct ParseTypedefData* ptd, unsigned line)
338 {
339     assert(ptd->err_idx < sizeof(ptd->errors) / sizeof(ptd->errors[0]));
340     ptd->errors[ptd->err_idx].line = line;
341     ptd->errors[ptd->err_idx].ptr = ptd->ptr;
342     ptd->err_idx++;
343 }
344 #define PTS_ABORTIF(ptd, t) do { if (t) { stabs_pts_push((ptd), __LINE__); return -1;} } while (0)
345 #else
346 #define PTS_ABORTIF(ptd, t) do { if (t) return -1; } while (0)
347 #endif
348
349 static int stabs_get_basic(struct ParseTypedefData* ptd, unsigned basic, struct symt** symt)
350 {
351     PTS_ABORTIF(ptd, basic >= sizeof(stabs_basic) / sizeof(stabs_basic[0]));
352
353     if (!stabs_basic[basic])
354     {
355         switch (basic)
356         {
357         case  1: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "int", 4); break;
358         case  2: stabs_basic[basic] = symt_new_basic(ptd->module, btChar,    "char", 1); break;
359         case  3: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "short int", 2); break;
360         case  4: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "long int", 4); break;
361         case  5: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned char", 1); break;
362         case  6: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "signed char", 1); break;
363         case  7: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned short int", 2); break;
364         case  8: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned int", 4); break;
365         case  9: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned", 2); break;
366         case 10: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned long int", 2); break;
367         case 11: stabs_basic[basic] = symt_new_basic(ptd->module, btVoid,    "void", 0); break;
368         case 12: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "float", 4); break;
369         case 13: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "double", 8); break;
370         case 14: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "long double", 12); break;
371         case 15: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "integer", 4); break;
372         case 16: stabs_basic[basic] = symt_new_basic(ptd->module, btBool,    "bool", 1); break;
373         /*    case 17: short real */
374         /*    case 18: real */
375         case 25: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "float complex", 8); break;
376         case 26: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "double complex", 16); break;
377         case 30: stabs_basic[basic] = symt_new_basic(ptd->module, btWChar,   "wchar_t", 2); break;
378         case 31: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "long long int", 8); break;
379         case 32: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "long long unsigned", 8); break;
380             /* starting at 35 are wine extensions (especially for R implementation) */
381         case 35: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "long double complex", 24); break;
382         default: PTS_ABORTIF(ptd, 1);
383         }
384     }   
385     *symt = &stabs_basic[basic]->symt;
386     return 0;
387 }
388
389 static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, 
390                                    const char* typename, struct symt** dt);
391
392 static int stabs_pts_read_id(struct ParseTypedefData* ptd)
393 {
394     const char*         first = ptd->ptr;
395     unsigned int        template = 0;
396     char                ch;
397
398     while ((ch = *ptd->ptr++) != '\0')
399     {
400         switch (ch)
401         {
402         case ':':
403             if (template == 0)
404             {
405                 unsigned int len = ptd->ptr - first - 1;
406                 PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx);
407                 memcpy(ptd->buf + ptd->idx, first, len);
408                 ptd->buf[ptd->idx + len] = '\0';
409                 ptd->idx += len + 1;
410                 return 0;
411             }
412             break;
413         case '<': template++; break;
414         case '>': PTS_ABORTIF(ptd, template == 0); template--; break;
415         }
416     }
417     return -1;
418 }
419
420 static int stabs_pts_read_number(struct ParseTypedefData* ptd, long* v)
421 {
422     char*       last;
423
424     *v = strtol(ptd->ptr, &last, 10);
425     PTS_ABORTIF(ptd, last == ptd->ptr);
426     ptd->ptr = last;
427     return 0;
428 }
429
430 static int stabs_pts_read_type_reference(struct ParseTypedefData* ptd,
431                                          long* filenr, long* subnr)
432 {
433     if (*ptd->ptr == '(')
434     {
435         /* '(' <int> ',' <int> ')' */
436         ptd->ptr++;
437         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, filenr) == -1);
438         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
439         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, subnr) == -1);
440         PTS_ABORTIF(ptd, *ptd->ptr++ != ')');
441     }
442     else
443     {
444         *filenr = 0;
445         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, subnr) == -1);
446     }
447     return 0;
448 }
449
450 struct pts_range_value
451 {
452     ULONGLONG           val;
453     int                 sign;
454 };
455
456 static int stabs_pts_read_range_value(struct ParseTypedefData* ptd, struct pts_range_value* prv)
457 {
458     char*       last;
459
460     switch (*ptd->ptr)
461     {
462     case '0':
463         while (*ptd->ptr == '0') ptd->ptr++;
464         if (*ptd->ptr >= '1' && *ptd->ptr <= '7')
465         {
466             switch (ptd->ptr[1])
467             {
468             case '0': 
469                 PTS_ABORTIF(ptd, ptd->ptr[0] != '1');
470                 prv->sign = -1;
471                 prv->val = 0;
472                 while (isdigit(*ptd->ptr)) prv->val = (prv->val << 3) + *ptd->ptr++ - '0';
473                 break;
474             case '7':
475                 prv->sign = 1;
476                 prv->val = 0;
477                 while (isdigit(*ptd->ptr)) prv->val = (prv->val << 3) + *ptd->ptr++ - '0';
478                 break;
479             default: PTS_ABORTIF(ptd, 1); break;
480             }
481         } else prv->sign = 0;
482         break;
483     case '-':
484         prv->sign = -1;
485         prv->val = strtoull(++ptd->ptr, &last, 10);
486         ptd->ptr = last;
487         break;
488     case '+':
489     default:    
490         prv->sign = 1;
491         prv->val = strtoull(ptd->ptr, &last, 10);
492         ptd->ptr = last;
493         break;
494     }
495     return 0;
496 }
497
498 static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typename,
499                                 struct symt** dt)
500 {
501     struct symt*                ref;
502     struct pts_range_value      lo;
503     struct pts_range_value      hi;
504     unsigned                    size;
505     enum BasicType              bt;
506     int                         i;
507     ULONGLONG                   v;
508
509     /* type ';' <int> ';' <int> ';' */
510     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref) == -1);
511     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
512     PTS_ABORTIF(ptd, stabs_pts_read_range_value(ptd, &lo) == -1);
513     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
514     PTS_ABORTIF(ptd, stabs_pts_read_range_value(ptd, &hi) == -1);
515     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
516
517     /* basically, we don't use ref... in some cases, for example, float is declared
518      * as a derived type of int... which won't help us... so we guess the types
519      * from the various formats
520      */
521     if (lo.sign == 0 && hi.sign < 0)
522     {
523         bt = btUInt;
524         size = hi.val;
525     }
526     else if (lo.sign < 0 && hi.sign == 0)
527     {
528         bt = btUInt;
529         size = lo.val;
530     }
531     else if (lo.sign > 0 && hi.sign == 0)
532     {
533         bt = btFloat;
534         size = lo.val;
535     }
536     else if (lo.sign < 0 && hi.sign > 0)
537     {
538         v = 1 << 7;
539         for (i = 7; i < 64; i += 8)
540         {
541             if (lo.val == v && hi.val == v - 1)
542             {
543                 bt = btInt;
544                 size = (i + 1) / 8;
545                 break;
546             }
547             v <<= 8;
548         }
549         PTS_ABORTIF(ptd, i >= 64);
550     }
551     else if (lo.sign == 0 && hi.sign > 0)
552     {
553         if (hi.val == 127) /* specific case for char... */
554         {
555             bt = btChar;
556             size = 1;
557         }
558         else
559         {
560             v = 1;
561             for (i = 8; i <= 64; i += 8)
562             {
563                 v <<= 8;
564                 if (hi.val + 1 == v)
565                 {
566                     bt = btUInt;
567                     size = (i + 1) / 8;
568                     break;
569                 }
570             }
571             PTS_ABORTIF(ptd, i > 64);
572         }
573     }
574     else PTS_ABORTIF(ptd, 1);
575
576     *dt = &symt_new_basic(ptd->module, bt, typename, size)->symt;
577     return 0;
578 }
579
580 static inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd)
581 {
582     struct symt*        dt;
583     const char*         tmp;
584     char                mthd;
585
586     do
587     {
588         /* get type of return value */
589         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
590         if (*ptd->ptr == ';') ptd->ptr++;
591
592         /* get types of parameters */
593         if (*ptd->ptr == ':')
594         {
595             PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr + 1, ';')));
596             ptd->ptr = tmp + 1;
597         }
598         PTS_ABORTIF(ptd, !(*ptd->ptr >= '0' && *ptd->ptr <= '9'));
599         ptd->ptr++;
600         PTS_ABORTIF(ptd, !(ptd->ptr[0] >= 'A' && *ptd->ptr <= 'D'));
601         mthd = *++ptd->ptr;
602         PTS_ABORTIF(ptd, mthd != '.' && mthd != '?' && mthd != '*');
603         ptd->ptr++;
604         if (mthd == '*')
605         {
606             long int            ofs;
607
608             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
609             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
610             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
611             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
612         }
613     } while (*ptd->ptr != ';');
614     ptd->ptr++;
615
616     return 0;
617 }
618
619 static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, 
620                                            struct symt_udt* sdt)
621 {
622     long                sz, ofs;
623     struct symt*        adt;
624     struct symt*        dt = NULL;
625     int                 idx;
626     int                 doadd;
627
628     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &sz) == -1);
629
630     doadd = symt_set_udt_size(ptd->module, sdt, sz);
631     if (*ptd->ptr == '!') /* C++ inheritance */
632     {
633         long     num_classes;
634
635         ptd->ptr++;
636         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &num_classes) == -1);
637         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
638         while (--num_classes >= 0)
639         {
640             ptd->ptr += 2; /* skip visibility and inheritance */
641             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
642             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
643
644             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &adt) == -1);
645
646             if (doadd && adt)
647             {
648                 char    tmp[256];
649                 DWORD64 size;
650
651                 strcpy(tmp, "__inherited_class_");
652                 strcat(tmp, symt_get_name(adt));
653
654                 /* FIXME: TI_GET_LENGTH will not always work, especially when adt
655                  * has just been seen as a forward definition and not the real stuff
656                  * yet.
657                  * As we don't use much the size of members in structs, this may not
658                  * be much of a problem
659                  */
660                 symt_get_info(ptd->module, adt, TI_GET_LENGTH, &size);
661                 symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, (DWORD)size * 8);
662             }
663             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
664         }
665         
666     }
667     /* if the structure has already been filled, just redo the parsing
668      * but don't store results into the struct
669      * FIXME: there's a quite ugly memory leak in there...
670      */
671
672     /* Now parse the individual elements of the structure/union. */
673     while (*ptd->ptr != ';') 
674     {
675         /* agg_name : type ',' <int:offset> ',' <int:size> */
676         idx = ptd->idx;
677
678         if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v')
679         {
680             long        x;
681
682             if (ptd->ptr[2] == 'f')
683             {
684                 /* C++ virtual method table */
685                 ptd->ptr += 3;
686                 stabs_read_type_enum(&ptd->ptr);
687                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
688                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
689                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
690                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &x) == -1);
691                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
692                 ptd->idx = idx;
693                 continue;
694             }
695             else if (ptd->ptr[2] == 'b')
696             {
697                 ptd->ptr += 3;
698                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
699                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
700                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
701                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
702                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &x) == -1);
703                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
704                 ptd->idx = idx;
705                 continue;
706             }
707         }
708
709         PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
710         /* Ref. TSDF R2.130 Section 7.4.  When the field name is a method name
711          * it is followed by two colons rather than one.
712          */
713         if (*ptd->ptr == ':')
714         {
715             ptd->ptr++; 
716             stabs_pts_read_method_info(ptd);
717             ptd->idx = idx;
718             continue;
719         }
720         else
721         {
722             /* skip C++ member protection /0 /1 or /2 */
723             if (*ptd->ptr == '/') ptd->ptr += 2;
724         }
725         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &adt) == -1);
726
727         switch (*ptd->ptr++)
728         {
729         case ',':
730             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
731             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
732             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &sz) == -1);
733             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
734
735             if (doadd) symt_add_udt_element(ptd->module, sdt, ptd->buf + idx, adt, ofs, sz);
736             break;
737         case ':':
738             {
739                 const char* tmp;
740                 /* method parameters... terminated by ';' */
741                 PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr, ';')));
742                 ptd->ptr = tmp + 1;
743             }
744             break;
745         default:
746             PTS_ABORTIF(ptd, TRUE);
747         }
748         ptd->idx = idx;
749     }
750     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
751     if (*ptd->ptr == '~')
752     {
753         ptd->ptr++;
754         PTS_ABORTIF(ptd, *ptd->ptr++ != '%');
755         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
756         PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
757     }
758     return 0;
759 }
760
761 static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd, 
762                                       struct symt_enum* edt)
763 {
764     long        value;
765     int         idx;
766
767     while (*ptd->ptr != ';')
768     {
769         idx = ptd->idx;
770         PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
771         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &value) == -1);
772         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
773         symt_add_enum_element(ptd->module, edt, ptd->buf + idx, value);
774         ptd->idx = idx;
775     }
776     ptd->ptr++;
777     return 0;
778 }
779
780 static inline int stabs_pts_read_array(struct ParseTypedefData* ptd,
781                                        struct symt** adt)
782 {
783     long                lo, hi;
784     struct symt*        range_dt;
785     struct symt*        base_dt;
786
787     /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo> */
788
789     PTS_ABORTIF(ptd, *ptd->ptr++ != 'r');
790
791     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &range_dt) == -1);
792     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
793     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &lo) == -1);
794     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
795     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &hi) == -1);
796     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
797
798     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &base_dt) == -1);
799
800     *adt = &symt_new_array(ptd->module, lo, hi, base_dt, range_dt)->symt;
801     return 0;
802 }
803
804 static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typename,
805                                    struct symt** ret_dt)
806 {
807     int                 idx;
808     long                sz = -1;
809     struct symt*        new_dt = NULL;     /* newly created data type */
810     struct symt*        ref_dt;            /* referenced data type (pointer...) */
811     long                filenr1, subnr1, tmp;
812
813     /* things are a bit complicated because of the way the typedefs are stored inside
814      * the file, because addresses can change when realloc is done, so we must call
815      * over and over stabs_find_ref() to keep the correct values around
816      */
817     PTS_ABORTIF(ptd, stabs_pts_read_type_reference(ptd, &filenr1, &subnr1) == -1);
818
819     while (*ptd->ptr == '=')
820     {
821         ptd->ptr++;
822         PTS_ABORTIF(ptd, new_dt != NULL);
823
824         /* first handle attribute if any */
825         switch (*ptd->ptr)      
826         {
827         case '@':
828             if (*++ptd->ptr == 's')
829             {
830                 ptd->ptr++;
831                 if (stabs_pts_read_number(ptd, &sz) == -1)
832                 {
833                     ERR("Not an attribute... NIY\n");
834                     ptd->ptr -= 2;
835                     return -1;
836                 }
837                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
838             }
839             break;
840         }
841         /* then the real definitions */
842         switch (*ptd->ptr++)
843         {
844         case '*':
845         case '&':
846             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
847             new_dt = &symt_new_pointer(ptd->module, ref_dt, sizeof(void*))->symt;
848            break;
849         case 'k': /* 'const' modifier */
850         case 'B': /* 'volatile' modifier */
851             /* just kinda ignore the modifier, I guess -gmt */
852             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, typename, &new_dt) == -1);
853             break;
854         case '(':
855             ptd->ptr--;
856             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, typename, &new_dt) == -1);
857             break;
858         case 'a':
859             PTS_ABORTIF(ptd, stabs_pts_read_array(ptd, &new_dt) == -1);
860             break;
861         case 'r':
862             PTS_ABORTIF(ptd, stabs_pts_read_range(ptd, typename, &new_dt) == -1);
863             assert(!*stabs_find_ref(filenr1, subnr1));
864             *stabs_find_ref(filenr1, subnr1) = new_dt;
865             break;
866         case 'f':
867             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
868             new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt;
869             break;
870         case 'e':
871             stabs_get_basic(ptd, 1 /* int */, &ref_dt);
872             new_dt = &symt_new_enum(ptd->module, typename, ref_dt)->symt;
873             PTS_ABORTIF(ptd, stabs_pts_read_enum(ptd, (struct symt_enum*)new_dt) == -1);
874             break;
875         case 's':
876         case 'u':
877             {
878                 struct symt_udt*    udt;
879                 enum UdtKind kind = (ptd->ptr[-1] == 's') ? UdtStruct : UdtUnion;
880                 /* udt can have been already defined in a forward definition */
881                 udt = (struct symt_udt*)*stabs_find_ref(filenr1, subnr1);
882                 if (!udt)
883                 {
884                     udt = symt_new_udt(ptd->module, typename, 0, kind);
885                     /* we need to set it here, because a struct can hold a pointer
886                      * to itself
887                      */
888                     new_dt = *stabs_find_ref(filenr1, subnr1) = &udt->symt;
889                 }
890                 else
891                 {
892                     unsigned l1, l2;
893                     if (udt->symt.tag != SymTagUDT)
894                     {
895                         ERR("Forward declaration (%p/%s) is not an aggregate (%u)\n",
896                             udt, symt_get_name(&udt->symt), udt->symt.tag);
897                         return -1;
898                     }
899                     /* FIXME: we currently don't correctly construct nested C++
900                      * classes names. Therefore, we could be here with either:
901                      * - typename and udt->hash_elt.name being the same string
902                      *   (non embedded case)
903                      * - typename being foo::bar while udt->hash_elt.name being 
904                      *   just bar
905                      * So, we twist the comparison to test both occurrences. When
906                      * we have proper C++ types in this file, this twist has to be
907                      * removed
908                      */
909                     l1 = strlen(udt->hash_elt.name);
910                     l2 = strlen(typename);
911                     if (l1 > l2 || strcmp(udt->hash_elt.name, typename + l2 - l1))
912                         ERR("Forward declaration name mismatch %s <> %s\n",
913                             udt->hash_elt.name, typename);
914                     new_dt = &udt->symt;
915                 }
916                 PTS_ABORTIF(ptd, stabs_pts_read_aggregate(ptd, udt) == -1);
917             }
918             break;
919         case 'x':
920             idx = ptd->idx;
921             tmp = *ptd->ptr++;
922             PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
923             switch (tmp)
924             {
925             case 'e':
926                 stabs_get_basic(ptd, 1 /* int */, &ref_dt);
927                 new_dt = &symt_new_enum(ptd->module, ptd->buf + idx, ref_dt)->symt;
928                 break;
929             case 's':
930                 new_dt = &symt_new_udt(ptd->module, ptd->buf + idx, 0, UdtStruct)->symt;
931                 break;
932             case 'u':
933                 new_dt = &symt_new_udt(ptd->module, ptd->buf + idx, 0, UdtUnion)->symt;
934                 break;
935             default:
936                 return -1;
937             }
938             ptd->idx = idx;
939             break;
940         case '-':
941             {
942                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &tmp) == -1);
943                 PTS_ABORTIF(ptd, stabs_get_basic(ptd, tmp, &new_dt) == -1);
944                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
945             }
946             break;
947         case '#':
948             if (*ptd->ptr == '#')
949             {
950                 ptd->ptr++;
951                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
952                 new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt;
953             }
954             else
955             {
956                 struct symt*    cls_dt;
957                 struct symt*    pmt_dt;
958
959                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &cls_dt) == -1);
960                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
961                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
962                 new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt;
963                 while (*ptd->ptr == ',')
964                 {
965                     ptd->ptr++;
966                     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &pmt_dt) == -1);
967                 }
968             }
969             break;
970         case 'R':
971             {
972                 long    type, len, unk;
973                 int     basic;
974                 
975                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &type) == -1);
976                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
977                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &len) == -1);
978                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
979                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &unk) == -1);
980                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
981
982                 switch (type) /* see stabs_get_basic for the details */
983                 {
984                 case 1: basic = 12; break;
985                 case 2: basic = 13; break;
986                 case 3: basic = 25; break;
987                 case 4: basic = 26; break;
988                 case 5: basic = 35; break;
989                 case 6: basic = 14; break;
990                 default: PTS_ABORTIF(ptd, 1);
991                 }
992                 PTS_ABORTIF(ptd, stabs_get_basic(ptd, basic, &new_dt) == -1);
993             }
994             break;
995         default:
996             ERR("Unknown type '%c'\n", ptd->ptr[-1]);
997             return -1;
998         }
999     }
1000
1001     if (!new_dt)
1002     {
1003         /* is it a forward declaration that has been filled ? */
1004         new_dt = *stabs_find_ref(filenr1, subnr1);
1005         /* if not, this should be void (which is defined as a ref to itself, but we
1006          * don't correctly catch it)
1007          */
1008         if (!new_dt && typename)
1009         {
1010             new_dt = &symt_new_basic(ptd->module, btVoid, typename, 0)->symt;
1011             PTS_ABORTIF(ptd, strcmp(typename, "void"));
1012         }
1013     }            
1014
1015     *stabs_find_ref(filenr1, subnr1) = *ret_dt = new_dt;
1016
1017     TRACE("Adding (%ld,%ld) %s\n", filenr1, subnr1, debugstr_a(typename));
1018
1019     return 0;
1020 }
1021
1022 static int stabs_parse_typedef(struct module* module, const char* ptr, 
1023                                const char* typename)
1024 {
1025     struct ParseTypedefData     ptd;
1026     struct symt*                dt;
1027     int                         ret = -1;
1028
1029     /* check for already existing definition */
1030
1031     TRACE("%s => %s\n", typename, debugstr_a(ptr));
1032     ptd.module = module;
1033     ptd.idx = 0;
1034 #ifdef PTS_DEBUG
1035     ptd.err_idx = 0;
1036 #endif
1037     for (ptd.ptr = ptr - 1; ;)
1038     {
1039         ptd.ptr = strchr(ptd.ptr + 1, ':');
1040         if (ptd.ptr == NULL || *++ptd.ptr != ':') break;
1041     }
1042     if (ptd.ptr)
1043     {
1044         if (*ptd.ptr != '(') ptd.ptr++;
1045         /* most of type definitions take one char, except Tt */
1046         if (*ptd.ptr != '(') ptd.ptr++;
1047         ret = stabs_pts_read_type_def(&ptd, typename, &dt);
1048     }
1049
1050     if (ret == -1 || *ptd.ptr) 
1051     {
1052 #ifdef PTS_DEBUG
1053         int     i;
1054         TRACE("Failure on %s\n", debugstr_a(ptr));
1055         if (ret == -1)
1056         {
1057             for (i = 0; i < ptd.err_idx; i++)
1058             {
1059                 TRACE("[%d]: line %d => %s\n", 
1060                       i, ptd.errors[i].line, debugstr_a(ptd.errors[i].ptr));
1061             }
1062         }
1063         else
1064             TRACE("[0]: => %s\n", debugstr_a(ptd.ptr));
1065             
1066 #else
1067         ERR("Failure on %s at %s\n", debugstr_a(ptr), debugstr_a(ptd.ptr));
1068 #endif
1069         return FALSE;
1070     }
1071
1072     return TRUE;
1073 }
1074
1075 static struct symt* stabs_parse_type(const char* stab)
1076 {
1077     const char* c = stab - 1;
1078
1079     /*
1080      * Look through the stab definition, and figure out what struct symt
1081      * this represents.  If we have something we know about, assign the
1082      * type.
1083      * According to "The \"stabs\" debug format" (Rev 2.130) the name may be
1084      * a C++ name and contain double colons e.g. foo::bar::baz:t5=*6.
1085      */
1086     do
1087     {
1088         if ((c = strchr(c + 1, ':')) == NULL) return NULL;
1089     } while (*++c == ':');
1090
1091     /*
1092      * The next characters say more about the type (i.e. data, function, etc)
1093      * of symbol.  Skip them.  (C++ for example may have Tt).
1094      * Actually this is a very weak description; I think Tt is the only
1095      * multiple combination we should see.
1096      */
1097     while (*c && *c != '(' && !isdigit(*c))
1098         c++;
1099     /*
1100      * The next is either an integer or a (integer,integer).
1101      * The stabs_read_type_enum() takes care that stab_types is large enough.
1102      */
1103     return *stabs_read_type_enum(&c);
1104 }
1105
1106 enum pending_obj_kind
1107 {
1108     PENDING_VAR,
1109     PENDING_LINE,
1110 };
1111
1112 struct pending_loc_var
1113 {
1114     char                name[256];
1115     struct symt*        type;
1116     enum DataKind       kind;
1117     struct location     loc;
1118 };
1119
1120 struct pending_line
1121 {
1122     int                 source_idx;
1123     int                 line_num;
1124     unsigned long       offset;
1125     unsigned long       load_offset;
1126 };
1127
1128 struct pending_object
1129 {
1130     enum pending_obj_kind               tag;
1131     union {
1132         struct pending_loc_var  var;
1133         struct pending_line     line;
1134     }                                   u;
1135 };
1136
1137 struct pending_list
1138 {
1139     struct pending_object*      objs;
1140     unsigned                    num;
1141     unsigned                    allocated;
1142 };
1143
1144 static inline void pending_make_room(struct pending_list* pending)
1145 {
1146     if (pending->num == pending->allocated)
1147     {
1148         if (!pending->objs)
1149         {
1150             pending->allocated = 8;
1151             pending->objs = HeapAlloc(GetProcessHeap(), 0,
1152                                      pending->allocated * sizeof(pending->objs[0]));
1153         }
1154         else
1155         {
1156             pending->allocated *= 2;
1157             pending->objs = HeapReAlloc(GetProcessHeap(), 0, pending->objs,
1158                                        pending->allocated * sizeof(pending->objs[0]));
1159         }
1160     }
1161 }
1162
1163 static inline void pending_add_var(struct pending_list* pending, const char* name,
1164                                    enum DataKind dt, const struct location* loc)
1165 {
1166     pending_make_room(pending);
1167     pending->objs[pending->num].tag = PENDING_VAR;
1168     stab_strcpy(pending->objs[pending->num].u.var.name,
1169                 sizeof(pending->objs[pending->num].u.var.name), name);
1170     pending->objs[pending->num].u.var.type  = stabs_parse_type(name);
1171     pending->objs[pending->num].u.var.kind  = dt;
1172     pending->objs[pending->num].u.var.loc   = *loc;
1173     pending->num++;
1174 }
1175
1176 static inline void pending_add_line(struct pending_list* pending, int source_idx,
1177                                     int line_num, unsigned long offset,
1178                                     unsigned long load_offset)
1179 {
1180     pending_make_room(pending);
1181     pending->objs[pending->num].tag = PENDING_LINE;
1182     pending->objs[pending->num].u.line.source_idx   = source_idx;
1183     pending->objs[pending->num].u.line.line_num     = line_num;
1184     pending->objs[pending->num].u.line.offset       = offset;
1185     pending->objs[pending->num].u.line.load_offset  = load_offset;
1186     pending->num++;
1187 }
1188
1189 static void pending_flush(struct pending_list* pending, struct module* module,
1190                           struct symt_function* func, struct symt_block* block)
1191 {
1192     unsigned int i;
1193
1194     for (i = 0; i < pending->num; i++)
1195     {
1196         switch (pending->objs[i].tag)
1197         {
1198         case PENDING_VAR:
1199             symt_add_func_local(module, func,
1200                                 pending->objs[i].u.var.kind, &pending->objs[i].u.var.loc,
1201                                 block, pending->objs[i].u.var.type, pending->objs[i].u.var.name);
1202             break;
1203         case PENDING_LINE:
1204             if (module->type == DMT_MACHO)
1205                 pending->objs[i].u.line.offset -= func->address - pending->objs[i].u.line.load_offset;
1206             symt_add_func_line(module, func, pending->objs[i].u.line.source_idx,
1207                                pending->objs[i].u.line.line_num, pending->objs[i].u.line.offset);
1208             break;
1209         default:
1210             ERR("Unknown pending object tag %u\n", (unsigned)pending->objs[i].tag);
1211             break;
1212         }
1213     }
1214     pending->num = 0;
1215 }
1216
1217 /******************************************************************
1218  *              stabs_finalize_function
1219  *
1220  * Ends function creation: mainly:
1221  * - cleans up line number information
1222  * - tries to set up a debug-start tag (FIXME: heuristic to be enhanced)
1223  * - for stabs which have absolute address in them, initializes the size of the
1224  *   function (assuming that current function ends where next function starts)
1225  */
1226 static void stabs_finalize_function(struct module* module, struct symt_function* func,
1227                                     unsigned long size)
1228 {
1229     IMAGEHLP_LINE64     il;
1230     struct location     loc;
1231
1232     if (!func) return;
1233     symt_normalize_function(module, func);
1234     /* To define the debug-start of the function, we use the second line number.
1235      * Not 100% bullet proof, but better than nothing
1236      */
1237     if (symt_fill_func_line_info(module, func, func->address, &il) &&
1238         symt_get_func_line_next(module, &il))
1239     {
1240         loc.kind = loc_absolute;
1241         loc.offset = il.Address - func->address;
1242         symt_add_function_point(module, func, SymTagFuncDebugStart, 
1243                                 &loc, NULL);
1244     }
1245     if (size) func->size = size;
1246 }
1247
1248 static inline void stabbuf_append(char **buf, unsigned *buf_size, const char *str)
1249 {
1250     unsigned str_len, buf_len;
1251
1252     str_len = strlen(str);
1253     buf_len = strlen(*buf);
1254
1255     if(str_len+buf_len >= *buf_size) {
1256         *buf_size += buf_len + str_len;
1257         *buf = HeapReAlloc(GetProcessHeap(), 0, *buf, *buf_size);
1258     }
1259
1260     strcpy(*buf+buf_len, str);
1261 }
1262
1263 BOOL stabs_parse(struct module* module, unsigned long load_offset, 
1264                  const void* pv_stab_ptr, int stablen,
1265                  const char* strs, int strtablen,
1266                  stabs_def_cb callback, void* user)
1267 {
1268     struct symt_function*       curr_func = NULL;
1269     struct symt_block*          block = NULL;
1270     struct symt_compiland*      compiland = NULL;
1271     char*                       srcpath = NULL;
1272     int                         i;
1273     int                         nstab;
1274     const char*                 ptr;
1275     char*                       stabbuff;
1276     unsigned int                stabbufflen;
1277     const struct stab_nlist*    stab_ptr = pv_stab_ptr;
1278     const char*                 strs_end;
1279     int                         strtabinc;
1280     char                        symname[4096];
1281     unsigned                    incl[32];
1282     int                         incl_stk = -1;
1283     int                         source_idx = -1;
1284     struct pending_list         pending_block;
1285     struct pending_list         pending_func;
1286     BOOL                        ret = TRUE;
1287     struct location             loc;
1288     unsigned char               type;
1289
1290     nstab = stablen / sizeof(struct stab_nlist);
1291     strs_end = strs + strtablen;
1292
1293     memset(stabs_basic, 0, sizeof(stabs_basic));
1294     memset(&pending_block, 0, sizeof(pending_block));
1295     memset(&pending_func, 0, sizeof(pending_func));
1296
1297     /*
1298      * Allocate a buffer into which we can build stab strings for cases
1299      * where the stab is continued over multiple lines.
1300      */
1301     stabbufflen = 65536;
1302     stabbuff = HeapAlloc(GetProcessHeap(), 0, stabbufflen);
1303
1304     strtabinc = 0;
1305     stabbuff[0] = '\0';
1306     for (i = 0; i < nstab; i++, stab_ptr++)
1307     {
1308         ptr = strs + stab_ptr->n_strx;
1309         if ((ptr > strs_end) || (ptr + strlen(ptr) > strs_end))
1310         {
1311             WARN("Bad stabs string %p\n", ptr);
1312             continue;
1313         }
1314         if (*ptr != '\0' && (ptr[strlen(ptr) - 1] == '\\'))
1315         {
1316             /*
1317              * Indicates continuation.  Append this to the buffer, and go onto the
1318              * next record.  Repeat the process until we find a stab without the
1319              * '/' character, as this indicates we have the whole thing.
1320              */
1321             stabbuf_append(&stabbuff, &stabbufflen, ptr);
1322             continue;
1323         }
1324         else if (stabbuff[0] != '\0')
1325         {
1326             stabbuf_append(&stabbuff, &stabbufflen, ptr);
1327             ptr = stabbuff;
1328         }
1329
1330         if (stab_ptr->n_type & N_STAB)
1331             type = stab_ptr->n_type;
1332         else
1333             type = (stab_ptr->n_type & N_TYPE);
1334
1335         /* only symbol entries contain a typedef */
1336         switch (type)
1337         {
1338         case N_GSYM:
1339         case N_LCSYM:
1340         case N_STSYM:
1341         case N_RSYM:
1342         case N_LSYM:
1343         case N_ROSYM:
1344         case N_PSYM:
1345             if (strchr(ptr, '=') != NULL)
1346             {
1347                 /*
1348                  * The stabs aren't in writable memory, so copy it over so we are
1349                  * sure we can scribble on it.
1350                  */
1351                 if (ptr != stabbuff)
1352                 {
1353                     stabbuff[0] = 0;
1354                     stabbuf_append(&stabbuff, &stabbufflen, ptr);
1355                     ptr = stabbuff;
1356                 }
1357                 stab_strcpy(symname, sizeof(symname), ptr);
1358                 if (!stabs_parse_typedef(module, ptr, symname))
1359                 {
1360                     /* skip this definition */
1361                     stabbuff[0] = '\0';
1362                     continue;
1363                 }
1364             }
1365         }
1366
1367         switch (type)
1368         {
1369         case N_GSYM:
1370             /*
1371              * These are useless with ELF.  They have no value, and you have to
1372              * read the normal symbol table to get the address.  Thus we
1373              * ignore them, and when we process the normal symbol table
1374              * we should do the right thing.
1375              *
1376              * With a.out or mingw, they actually do make some amount of sense.
1377              */
1378             stab_strcpy(symname, sizeof(symname), ptr);
1379             loc.kind = loc_absolute;
1380             loc.reg = 0;
1381             loc.offset = load_offset + stab_ptr->n_value;
1382             symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
1383                                      loc, 0, stabs_parse_type(ptr));
1384             break;
1385         case N_LCSYM:
1386         case N_STSYM:
1387             /* These are static symbols and BSS symbols. */
1388             stab_strcpy(symname, sizeof(symname), ptr);
1389             loc.kind = loc_absolute;
1390             loc.reg = 0;
1391             loc.offset = load_offset + stab_ptr->n_value;
1392             symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
1393                                      loc, 0, stabs_parse_type(ptr));
1394             break;
1395         case N_LBRAC:
1396             if (curr_func)
1397             {
1398                 block = symt_open_func_block(module, curr_func, block,
1399                                              stab_ptr->n_value, 0);
1400                 pending_flush(&pending_block, module, curr_func, block);
1401             }
1402             break;
1403         case N_RBRAC:
1404             if (curr_func)
1405                 block = symt_close_func_block(module, curr_func, block,
1406                                               stab_ptr->n_value);
1407             break;
1408         case N_PSYM:
1409             /* These are function parameters. */
1410             if (curr_func != NULL)
1411             {
1412                 struct symt*    param_type = stabs_parse_type(ptr);
1413                 stab_strcpy(symname, sizeof(symname), ptr);
1414                 loc.kind = loc_regrel;
1415                 loc.reg = dbghelp_current_cpu->frame_regno;
1416                 loc.offset = stab_ptr->n_value;
1417                 symt_add_func_local(module, curr_func,
1418                                     (int)stab_ptr->n_value >= 0 ? DataIsParam : DataIsLocal,
1419                                     &loc, NULL, param_type, symname);
1420                 symt_add_function_signature_parameter(module, 
1421                                                       (struct symt_function_signature*)curr_func->type, 
1422                                                       param_type);
1423             }
1424             break;
1425         case N_RSYM:
1426             /* These are registers (as local variables) */
1427             if (curr_func != NULL)
1428             {
1429                 loc.kind = loc_register;
1430                 loc.offset = 0;
1431
1432                 switch (stab_ptr->n_value)
1433                 {
1434                 case  0: loc.reg = CV_REG_EAX; break;
1435                 case  1: loc.reg = CV_REG_ECX; break;
1436                 case  2: loc.reg = CV_REG_EDX; break;
1437                 case  3: loc.reg = CV_REG_EBX; break;
1438                 case  4: loc.reg = CV_REG_ESP; break;
1439                 case  5: loc.reg = CV_REG_EBP; break;
1440                 case  6: loc.reg = CV_REG_ESI; break;
1441                 case  7: loc.reg = CV_REG_EDI; break;
1442                 case 11:
1443                 case 12:
1444                 case 13:
1445                 case 14:
1446                 case 15:
1447                 case 16:
1448                 case 17:
1449                 case 18:
1450                 case 19: loc.reg = CV_REG_ST0 + stab_ptr->n_value - 12; break;
1451                 case 21:
1452                 case 22:
1453                 case 23:
1454                 case 24:
1455                 case 25:
1456                 case 26:
1457                 case 27:
1458                 case 28: loc.reg = CV_REG_XMM0 + stab_ptr->n_value - 21; break;
1459                 case 29:
1460                 case 30:
1461                 case 31:
1462                 case 32:
1463                 case 33:
1464                 case 34:
1465                 case 35:
1466                 case 36: loc.reg = CV_REG_MM0 + stab_ptr->n_value - 29; break;
1467                 default:
1468                     FIXME("Unknown register value (%u)\n", stab_ptr->n_value);
1469                     loc.reg = CV_REG_NONE;
1470                     break;
1471                 }
1472                 stab_strcpy(symname, sizeof(symname), ptr);
1473                 if (ptr[strlen(symname) + 1] == 'P')
1474                 {
1475                     struct symt*    param_type = stabs_parse_type(ptr);
1476                     stab_strcpy(symname, sizeof(symname), ptr);
1477                     symt_add_func_local(module, curr_func, DataIsParam, &loc,
1478                                         NULL, param_type, symname);
1479                     symt_add_function_signature_parameter(module, 
1480                                                           (struct symt_function_signature*)curr_func->type, 
1481                                                           param_type);
1482                 }
1483                 else
1484                     pending_add_var(&pending_block, ptr, DataIsLocal, &loc);
1485             }
1486             break;
1487         case N_LSYM:
1488             /* These are local variables */
1489             loc.kind = loc_regrel;
1490             loc.reg = dbghelp_current_cpu->frame_regno;
1491             loc.offset = stab_ptr->n_value;
1492             if (curr_func != NULL) pending_add_var(&pending_block, ptr, DataIsLocal, &loc);
1493             break;
1494         case N_SLINE:
1495             /*
1496              * This is a line number.  These are always relative to the start
1497              * of the function (N_FUN), and this makes the lookup easier.
1498              */
1499             assert(source_idx >= 0);
1500             if (curr_func != NULL)
1501             {
1502                 unsigned long offset = stab_ptr->n_value;
1503                 if (module->type == DMT_MACHO)
1504                     offset -= curr_func->address - load_offset;
1505                 symt_add_func_line(module, curr_func, source_idx, 
1506                                    stab_ptr->n_desc, offset);
1507             }
1508             else pending_add_line(&pending_func, source_idx, stab_ptr->n_desc,
1509                                   stab_ptr->n_value, load_offset);
1510             break;
1511         case N_FUN:
1512             /*
1513              * For now, just declare the various functions.  Later
1514              * on, we will add the line number information and the
1515              * local symbols.
1516              */
1517             /*
1518              * Copy the string to a temp buffer so we
1519              * can kill everything after the ':'.  We do
1520              * it this way because otherwise we end up dirtying
1521              * all of the pages related to the stabs, and that
1522              * sucks up swap space like crazy.
1523              */
1524             stab_strcpy(symname, sizeof(symname), ptr);
1525             if (*symname)
1526             {
1527                 struct symt_function_signature* func_type;
1528
1529                 if (curr_func)
1530                 {
1531                     /* First, clean up the previous function we were working on.
1532                      * Assume size of the func is the delta between current offset
1533                      * and offset of last function
1534                      */
1535                     stabs_finalize_function(module, curr_func, 
1536                                             stab_ptr->n_value ?
1537                                                 (load_offset + stab_ptr->n_value - curr_func->address) : 0);
1538                 }
1539                 func_type = symt_new_function_signature(module, 
1540                                                         stabs_parse_type(ptr), -1);
1541                 curr_func = symt_new_function(module, compiland, symname, 
1542                                               load_offset + stab_ptr->n_value, 0,
1543                                               &func_type->symt);
1544                 pending_flush(&pending_func, module, curr_func, NULL);
1545             }
1546             else
1547             {
1548                 /* some versions of GCC to use a N_FUN "" to mark the end of a function
1549                  * and n_value contains the size of the func
1550                  */
1551                 stabs_finalize_function(module, curr_func, stab_ptr->n_value);
1552                 curr_func = NULL;
1553             }
1554             break;
1555         case N_SO:
1556             /*
1557              * This indicates a new source file.  Append the records
1558              * together, to build the correct path name.
1559              */
1560             if (*ptr == '\0') /* end of N_SO file */
1561             {
1562                 /* Nuke old path. */
1563                 HeapFree(GetProcessHeap(), 0, srcpath);
1564                 srcpath = NULL;
1565                 stabs_finalize_function(module, curr_func, 0);
1566                 curr_func = NULL;
1567                 source_idx = -1;
1568                 incl_stk = -1;
1569                 assert(block == NULL);
1570                 compiland = NULL;
1571             }
1572             else
1573             {
1574                 int len = strlen(ptr);
1575                 if (ptr[len-1] != '/')
1576                 {
1577                     stabs_reset_includes();
1578                     source_idx = source_new(module, srcpath, ptr);
1579                     compiland = symt_new_compiland(module, 0 /* FIXME */, source_idx);
1580                 }
1581                 else
1582                 {
1583                     srcpath = HeapAlloc(GetProcessHeap(), 0, len + 1);
1584                     strcpy(srcpath, ptr);
1585                 }
1586             }
1587             break;
1588         case N_SOL:
1589             source_idx = source_new(module, srcpath, ptr);
1590             break;
1591         case N_UNDF:
1592             strs += strtabinc;
1593             strtabinc = stab_ptr->n_value;
1594             /* I'm not sure this is needed, so trace it before we obsolete it */
1595             if (curr_func)
1596             {
1597                 FIXME("UNDF: curr_func %s\n", curr_func->hash_elt.name);
1598                 stabs_finalize_function(module, curr_func, 0); /* FIXME */
1599                 curr_func = NULL;
1600             }
1601             break;
1602         case N_OPT:
1603             /* Ignore this. We don't care what it points to. */
1604             break;
1605         case N_BINCL:
1606             stabs_add_include(stabs_new_include(ptr, stab_ptr->n_value));
1607             assert(incl_stk < (int)(sizeof(incl) / sizeof(incl[0])) - 1);
1608             incl[++incl_stk] = source_idx;
1609             source_idx = source_new(module, NULL, ptr);
1610             break;
1611         case N_EINCL:
1612             assert(incl_stk >= 0);
1613             source_idx = incl[incl_stk--];
1614             break;
1615         case N_EXCL:
1616             if (stabs_add_include(stabs_find_include(ptr, stab_ptr->n_value)) < 0)
1617             {
1618                 ERR("Excluded header not found (%s,%d)\n", ptr, stab_ptr->n_value);
1619                 module_reset_debug_info(module);
1620                 ret = FALSE;
1621                 goto done;
1622             }
1623             break;
1624         case N_MAIN:
1625             /* Always ignore these. GCC doesn't even generate them. */
1626             break;
1627         case N_BNSYM:
1628         case N_ENSYM:
1629         case N_OSO:
1630             /* Always ignore these, they seem to be used only on Darwin. */
1631             break;
1632         case N_ABS:
1633 #ifdef N_SECT
1634         case N_SECT:
1635 #endif
1636             /* FIXME: Other definition types (N_TEXT, N_DATA, N_BSS, ...)? */
1637             if (callback)
1638             {
1639                 BOOL is_public = (stab_ptr->n_type & N_EXT);
1640                 BOOL is_global = is_public;
1641
1642 #ifdef N_PEXT
1643                 /* "private extern"; shared among compilation units in a shared
1644                  * library, but not accessible from outside the library. */
1645                 if (stab_ptr->n_type & N_PEXT)
1646                 {
1647                     is_public = FALSE;
1648                     is_global = TRUE;
1649                 }
1650 #endif
1651
1652                 if (*ptr == '_') ptr++;
1653                 stab_strcpy(symname, sizeof(symname), ptr);
1654
1655                 callback(module, load_offset, symname, stab_ptr->n_value,
1656                          is_public, is_global, stab_ptr->n_other, compiland, user);
1657             }
1658             break;
1659         default:
1660             ERR("Unknown stab type 0x%02x\n", type);
1661             break;
1662         }
1663         stabbuff[0] = '\0';
1664         TRACE("0x%02x %x %s\n",
1665               stab_ptr->n_type, stab_ptr->n_value, debugstr_a(strs + stab_ptr->n_strx));
1666     }
1667     module->module.SymType = SymDia;
1668     module->module.CVSig = 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24);
1669     /* FIXME: we could have a finer grain here */
1670     module->module.LineNumbers = TRUE;
1671     module->module.GlobalSymbols = TRUE;
1672     module->module.TypeInfo = TRUE;
1673     module->module.SourceIndexed = TRUE;
1674     module->module.Publics = TRUE;
1675 done:
1676     HeapFree(GetProcessHeap(), 0, stabbuff);
1677     stabs_free_includes();
1678     HeapFree(GetProcessHeap(), 0, pending_block.objs);
1679     HeapFree(GetProcessHeap(), 0, pending_func.objs);
1680
1681     return ret;
1682 }