2 * File stabs.c - read stabs information from the modules
4 * Copyright (C) 1996, Eric Youngdale.
5 * 1999-2005, Eric Pouech
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.
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.
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
22 * Maintenance Information
23 * -----------------------
25 * For documentation on the stabs format see for example
26 * The "stabs" debug format
27 * by Julia Menapace, Jim Kingdon, David Mackenzie
29 * available (hopefully) from http://sources.redhat.com/gdb/onlinedocs
32 #include <sys/types.h>
45 #include "dbghelp_private.h"
46 #include "image_private.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_stabs
);
52 /* Masks for n_type field */
58 /* Values for (n_type & N_TYPE) */
85 static BOOL
stab_strcpy(char* dest
, int sz
, const char* source
)
89 * A strcpy routine that stops when we hit the ':' character.
90 * Faster than copying the whole thing, and then nuking the
92 * Takes also care of (valid) a::b constructs
94 while (*source
!= '\0')
96 if (source
[0] != ':' && sz
-- > 0) *ptr
++ = *source
++;
97 else if (source
[1] == ':' && (sz
-= 2) > 0)
105 /* GCC emits, in some cases, a .<digit>+ suffix.
106 * This is used for static variable inside functions, so
107 * that we can have several such variables with same name in
108 * the same compilation unit
109 * We simply ignore that suffix when present (we also get rid
110 * of it in ELF symtab parsing)
112 if (ptr
>= dest
&& isdigit(*ptr
))
114 while (ptr
> dest
&& isdigit(*ptr
)) ptr
--;
115 if (*ptr
== '.') *ptr
= '\0';
124 struct symt
** vector
;
128 #define MAX_INCLUDES 5120
130 static include_def
* include_defs
= NULL
;
131 static int num_include_def
= 0;
132 static int num_alloc_include_def
= 0;
133 static int cu_include_stack
[MAX_INCLUDES
];
134 static int cu_include_stk_idx
= 0;
135 static struct symt
** cu_vector
= NULL
;
136 static int cu_nrofentries
= 0;
137 static struct symt_basic
* stabs_basic
[36];
139 static int stabs_new_include(const char* file
, ULONG_PTR val
)
141 if (num_include_def
== num_alloc_include_def
)
145 num_alloc_include_def
= 256;
146 include_defs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
147 sizeof(include_defs
[0]) * num_alloc_include_def
);
151 num_alloc_include_def
*= 2;
152 include_defs
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, include_defs
,
153 sizeof(include_defs
[0]) * num_alloc_include_def
);
156 include_defs
[num_include_def
].name
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(file
) + 1), file
);
157 include_defs
[num_include_def
].value
= val
;
158 include_defs
[num_include_def
].vector
= NULL
;
159 include_defs
[num_include_def
].nrofentries
= 0;
161 return num_include_def
++;
164 static int stabs_find_include(const char* file
, ULONG_PTR val
)
168 for (i
= 0; i
< num_include_def
; i
++)
170 if (val
== include_defs
[i
].value
&&
171 strcmp(file
, include_defs
[i
].name
) == 0)
177 static int stabs_add_include(int idx
)
179 if (idx
< 0) return -1;
180 cu_include_stk_idx
++;
182 /* if this happens, just bump MAX_INCLUDES */
183 /* we could also handle this as another dynarray */
184 assert(cu_include_stk_idx
< MAX_INCLUDES
);
185 cu_include_stack
[cu_include_stk_idx
] = idx
;
186 return cu_include_stk_idx
;
189 static void stabs_reset_includes(void)
192 * The struct symt:s that we would need to use are reset when
193 * we start a new file. (at least the ones in filenr == 0)
195 cu_include_stk_idx
= 0;/* keep 0 as index for the .c file itself */
196 memset(cu_vector
, 0, sizeof(cu_vector
[0]) * cu_nrofentries
);
199 static void stabs_free_includes(void)
203 stabs_reset_includes();
204 for (i
= 0; i
< num_include_def
; i
++)
206 HeapFree(GetProcessHeap(), 0, include_defs
[i
].name
);
207 HeapFree(GetProcessHeap(), 0, include_defs
[i
].vector
);
209 HeapFree(GetProcessHeap(), 0, include_defs
);
212 num_alloc_include_def
= 0;
213 HeapFree(GetProcessHeap(), 0, cu_vector
);
218 static struct symt
** stabs_find_ref(LONG_PTR filenr
, LONG_PTR subnr
)
222 /* FIXME: I could perhaps create a dummy include_def for each compilation
223 * unit which would allow not to handle those two cases separately
227 if (cu_nrofentries
<= subnr
)
229 cu_nrofentries
= max( cu_nrofentries
* 2, subnr
+ 1 );
231 cu_vector
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
232 sizeof(cu_vector
[0]) * cu_nrofentries
);
234 cu_vector
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
235 cu_vector
, sizeof(cu_vector
[0]) * cu_nrofentries
);
237 ret
= &cu_vector
[subnr
];
243 assert(filenr
<= cu_include_stk_idx
);
244 idef
= &include_defs
[cu_include_stack
[filenr
]];
246 if (idef
->nrofentries
<= subnr
)
248 idef
->nrofentries
= max( idef
->nrofentries
* 2, subnr
+ 1 );
250 idef
->vector
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
251 sizeof(idef
->vector
[0]) * idef
->nrofentries
);
253 idef
->vector
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
254 idef
->vector
, sizeof(idef
->vector
[0]) * idef
->nrofentries
);
256 ret
= &idef
->vector
[subnr
];
258 TRACE("(%Id,%Id) => %p (%p)\n", filenr
, subnr
, ret
, *ret
);
262 static struct symt
** stabs_read_type_enum(const char** x
)
264 LONG_PTR filenr
, subnr
;
272 filenr
= strtol(iter
, &end
, 10); /* <int> */
273 iter
= ++end
; /* ',' */
274 subnr
= strtol(iter
, &end
, 10); /* <int> */
275 iter
= ++end
; /* ')' */
280 subnr
= strtol(iter
, &end
, 10); /* <int> */
284 return stabs_find_ref(filenr
, subnr
);
288 struct ParseTypedefData
293 struct module
* module
;
305 static void stabs_pts_push(struct ParseTypedefData
* ptd
, unsigned line
)
307 assert(ptd
->err_idx
< ARRAY_SIZE(ptd
->errors
));
308 ptd
->errors
[ptd
->err_idx
].line
= line
;
309 ptd
->errors
[ptd
->err_idx
].ptr
= ptd
->ptr
;
312 #define PTS_ABORTIF(ptd, t) do { if (t) { stabs_pts_push((ptd), __LINE__); return -1;} } while (0)
314 #define PTS_ABORTIF(ptd, t) do { if (t) return -1; } while (0)
317 static int stabs_get_basic(struct ParseTypedefData
* ptd
, unsigned basic
, struct symt
** symt
)
319 PTS_ABORTIF(ptd
, basic
>= ARRAY_SIZE(stabs_basic
));
321 if (!stabs_basic
[basic
])
325 case 1: stabs_basic
[basic
] = symt_get_basic(btInt
, 4); break; /* int */
326 case 2: stabs_basic
[basic
] = symt_get_basic(btChar
, 1); break; /* char */
327 case 3: stabs_basic
[basic
] = symt_get_basic(btInt
, 2); break; /* short int */
328 case 4: stabs_basic
[basic
] = symt_get_basic(btInt
, 4); break; /* long int */
329 case 5: stabs_basic
[basic
] = symt_get_basic(btUInt
, 1); break; /* unsigned char */
330 case 6: stabs_basic
[basic
] = symt_get_basic(btInt
, 1); break; /* signed char */
331 case 7: stabs_basic
[basic
] = symt_get_basic(btUInt
, 2); break; /* unsigned short int */
332 case 8: stabs_basic
[basic
] = symt_get_basic(btUInt
, 4); break; /* unsigned int */
333 case 9: stabs_basic
[basic
] = symt_get_basic(btUInt
, 2); break; /* unsigned */
334 case 10: stabs_basic
[basic
] = symt_get_basic(btUInt
, 2); break; /* unsigned long int */
335 case 11: stabs_basic
[basic
] = symt_get_basic(btVoid
, 0); break; /* void */
336 case 12: stabs_basic
[basic
] = symt_get_basic(btFloat
, 4); break; /* float */
337 case 13: stabs_basic
[basic
] = symt_get_basic(btFloat
, 8); break; /* double */
338 case 14: stabs_basic
[basic
] = symt_get_basic(btFloat
, 2); break; /* long double", */
339 case 15: stabs_basic
[basic
] = symt_get_basic(btInt
, 4); break; /* integer */
340 case 16: stabs_basic
[basic
] = symt_get_basic(btBool
, 1); break; /* bool */
341 /* case 17: short real */
343 case 25: stabs_basic
[basic
] = symt_get_basic(btComplex
, 8); break; /* float complex */
344 case 26: stabs_basic
[basic
] = symt_get_basic(btComplex
, 6); break; /* double complex", */
345 case 30: stabs_basic
[basic
] = symt_get_basic(btWChar
, 2); break; /* wchar_t */
346 case 31: stabs_basic
[basic
] = symt_get_basic(btInt
, 8); break; /* long long int */
347 case 32: stabs_basic
[basic
] = symt_get_basic(btUInt
, 8); break; /* long long unsigned */
348 /* starting at 35 are wine extensions (especially for R implementation) */
349 case 35: stabs_basic
[basic
] = symt_get_basic(btComplex
, 4); break; /* long double complex", */
350 default: PTS_ABORTIF(ptd
, 1);
353 *symt
= &stabs_basic
[basic
]->symt
;
357 static int stabs_pts_read_type_def(struct ParseTypedefData
* ptd
,
358 const char* typename
, struct symt
** dt
);
360 static int stabs_pts_read_id(struct ParseTypedefData
* ptd
)
362 const char* first
= ptd
->ptr
;
363 unsigned int template = 0;
366 while ((ch
= *ptd
->ptr
++) != '\0')
373 unsigned int len
= ptd
->ptr
- first
- 1;
374 PTS_ABORTIF(ptd
, len
>= sizeof(ptd
->buf
) - ptd
->idx
);
375 memcpy(ptd
->buf
+ ptd
->idx
, first
, len
);
376 ptd
->buf
[ptd
->idx
+ len
] = '\0';
381 case '<': template++; break;
382 case '>': PTS_ABORTIF(ptd
, template == 0); template--; break;
388 static int stabs_pts_read_number(struct ParseTypedefData
* ptd
, LONG_PTR
* v
)
392 *v
= strtol(ptd
->ptr
, &last
, 10);
393 PTS_ABORTIF(ptd
, last
== ptd
->ptr
);
398 static int stabs_pts_read_type_reference(struct ParseTypedefData
* ptd
,
399 LONG_PTR
* filenr
, LONG_PTR
* subnr
)
401 if (*ptd
->ptr
== '(')
403 /* '(' <int> ',' <int> ')' */
405 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, filenr
) == -1);
406 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
407 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, subnr
) == -1);
408 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ')');
413 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, subnr
) == -1);
418 struct pts_range_value
424 static int stabs_pts_read_range_value(struct ParseTypedefData
* ptd
, struct pts_range_value
* prv
)
431 while (*ptd
->ptr
== '0') ptd
->ptr
++;
432 if (*ptd
->ptr
>= '1' && *ptd
->ptr
<= '7')
437 PTS_ABORTIF(ptd
, ptd
->ptr
[0] != '1');
440 while (isdigit(*ptd
->ptr
)) prv
->val
= (prv
->val
<< 3) + *ptd
->ptr
++ - '0';
445 while (isdigit(*ptd
->ptr
)) prv
->val
= (prv
->val
<< 3) + *ptd
->ptr
++ - '0';
447 default: PTS_ABORTIF(ptd
, 1); break;
449 } else prv
->sign
= 0;
453 prv
->val
= strtoull(++ptd
->ptr
, &last
, 10);
459 prv
->val
= strtoull(ptd
->ptr
, &last
, 10);
466 static int stabs_pts_read_range(struct ParseTypedefData
* ptd
, const char* typename
,
470 struct pts_range_value lo
;
471 struct pts_range_value hi
;
477 /* type ';' <int> ';' <int> ';' */
478 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &ref
) == -1);
479 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
480 PTS_ABORTIF(ptd
, stabs_pts_read_range_value(ptd
, &lo
) == -1);
481 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
482 PTS_ABORTIF(ptd
, stabs_pts_read_range_value(ptd
, &hi
) == -1);
483 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
485 /* basically, we don't use ref... in some cases, for example, float is declared
486 * as a derived type of int... which won't help us... so we guess the types
487 * from the various formats
489 if (lo
.sign
== 0 && hi
.sign
< 0)
494 else if (lo
.sign
< 0 && hi
.sign
== 0)
499 else if (lo
.sign
> 0 && hi
.sign
== 0)
504 else if (lo
.sign
< 0 && hi
.sign
> 0)
507 for (i
= 7; i
< 64; i
+= 8)
509 if (lo
.val
== v
&& hi
.val
== v
- 1)
517 PTS_ABORTIF(ptd
, i
>= 64);
519 else if (lo
.sign
== 0 && hi
.sign
> 0)
521 if (hi
.val
== 127) /* specific case for char... */
529 for (i
= 8; i
<= 64; i
+= 8)
539 PTS_ABORTIF(ptd
, i
> 64);
542 else PTS_ABORTIF(ptd
, 1);
544 *dt
= &symt_get_basic(bt
, size
)->symt
;
548 static inline int stabs_pts_read_method_info(struct ParseTypedefData
* ptd
)
556 /* get type of return value */
557 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
558 if (*ptd
->ptr
== ';') ptd
->ptr
++;
560 /* get types of parameters */
561 if (*ptd
->ptr
== ':')
563 PTS_ABORTIF(ptd
, !(tmp
= strchr(ptd
->ptr
+ 1, ';')));
566 PTS_ABORTIF(ptd
, !(*ptd
->ptr
>= '0' && *ptd
->ptr
<= '9'));
568 PTS_ABORTIF(ptd
, !(ptd
->ptr
[0] >= 'A' && *ptd
->ptr
<= 'D'));
570 PTS_ABORTIF(ptd
, mthd
!= '.' && mthd
!= '?' && mthd
!= '*');
576 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &ofs
) == -1);
577 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
578 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
579 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
581 } while (*ptd
->ptr
!= ';');
587 static inline int stabs_pts_read_aggregate(struct ParseTypedefData
* ptd
,
588 struct symt_udt
* sdt
)
592 struct symt
* dt
= NULL
;
596 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &sz
) == -1);
598 doadd
= symt_set_udt_size(ptd
->module
, sdt
, sz
);
599 if (*ptd
->ptr
== '!') /* C++ inheritance */
601 LONG_PTR num_classes
;
604 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &num_classes
) == -1);
605 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
606 while (--num_classes
>= 0)
608 ptd
->ptr
+= 2; /* skip visibility and inheritance */
609 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &ofs
) == -1);
610 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
612 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &adt
) == -1);
618 strcpy(tmp
, "__inherited_class_");
619 strcat(tmp
, symt_get_name(adt
));
621 symt_add_udt_element(ptd
->module
, sdt
, tmp
, adt
, ofs
, 0, 0);
623 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
627 /* if the structure has already been filled, just redo the parsing
628 * but don't store results into the struct
629 * FIXME: there's a quite ugly memory leak in there...
632 /* Now parse the individual elements of the structure/union. */
633 while (*ptd
->ptr
!= ';')
635 /* agg_name : type ',' <int:offset> ',' <int:size> */
638 if (ptd
->ptr
[0] == '$' && ptd
->ptr
[1] == 'v')
642 if (ptd
->ptr
[2] == 'f')
644 /* C++ virtual method table */
646 stabs_read_type_enum(&ptd
->ptr
);
647 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ':');
648 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
649 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
650 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &x
) == -1);
651 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
655 else if (ptd
->ptr
[2] == 'b')
658 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
659 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ':');
660 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
661 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
662 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &x
) == -1);
663 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
669 PTS_ABORTIF(ptd
, stabs_pts_read_id(ptd
) == -1);
670 /* Ref. TSDF R2.130 Section 7.4. When the field name is a method name
671 * it is followed by two colons rather than one.
673 if (*ptd
->ptr
== ':')
676 stabs_pts_read_method_info(ptd
);
682 /* skip C++ member protection /0 /1 or /2 */
683 if (*ptd
->ptr
== '/') ptd
->ptr
+= 2;
685 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &adt
) == -1);
690 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &ofs
) == -1);
691 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
692 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &sz
) == -1);
693 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
695 if (doadd
) symt_add_udt_element(ptd
->module
, sdt
, ptd
->buf
+ idx
, adt
, ofs
, 0, 0);
700 /* method parameters... terminated by ';' */
701 PTS_ABORTIF(ptd
, !(tmp
= strchr(ptd
->ptr
, ';')));
706 PTS_ABORTIF(ptd
, TRUE
);
710 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
711 if (*ptd
->ptr
== '~')
714 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != '%');
715 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &dt
) == -1);
716 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
721 static inline int stabs_pts_read_enum(struct ParseTypedefData
* ptd
,
722 struct symt_enum
* edt
)
727 while (*ptd
->ptr
!= ';')
730 PTS_ABORTIF(ptd
, stabs_pts_read_id(ptd
) == -1);
731 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &value
) == -1);
732 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
733 symt_add_enum_element(ptd
->module
, edt
, ptd
->buf
+ idx
, value
);
740 static inline int stabs_pts_read_array(struct ParseTypedefData
* ptd
,
744 struct symt
* range_dt
;
745 struct symt
* base_dt
;
747 /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo> */
749 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != 'r');
751 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &range_dt
) == -1);
752 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
753 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &lo
) == -1);
754 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
755 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &hi
) == -1);
756 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
758 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &base_dt
) == -1);
760 *adt
= &symt_new_array(ptd
->module
, lo
, hi
- lo
+ 1, base_dt
, range_dt
)->symt
;
764 static int stabs_pts_read_type_def(struct ParseTypedefData
* ptd
, const char* typename
,
765 struct symt
** ret_dt
)
769 struct symt
* new_dt
= NULL
; /* newly created data type */
770 struct symt
* ref_dt
; /* referenced data type (pointer...) */
771 LONG_PTR filenr1
, subnr1
, tmp
;
773 /* things are a bit complicated because of the way the typedefs are stored inside
774 * the file, because addresses can change when realloc is done, so we must call
775 * over and over stabs_find_ref() to keep the correct values around
777 PTS_ABORTIF(ptd
, stabs_pts_read_type_reference(ptd
, &filenr1
, &subnr1
) == -1);
779 while (*ptd
->ptr
== '=')
782 PTS_ABORTIF(ptd
, new_dt
!= NULL
);
784 /* first handle attribute if any */
788 if (*++ptd
->ptr
== 's')
791 if (stabs_pts_read_number(ptd
, &sz
) == -1)
793 ERR("Not an attribute... NIY\n");
797 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
801 /* then the real definitions */
806 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &ref_dt
) == -1);
807 new_dt
= &symt_new_pointer(ptd
->module
, ref_dt
, ptd
->module
->cpu
->word_size
)->symt
;
809 case 'k': /* 'const' modifier */
810 case 'B': /* 'volatile' modifier */
811 /* just kinda ignore the modifier, I guess -gmt */
812 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, typename
, &new_dt
) == -1);
816 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, typename
, &new_dt
) == -1);
819 PTS_ABORTIF(ptd
, stabs_pts_read_array(ptd
, &new_dt
) == -1);
822 PTS_ABORTIF(ptd
, stabs_pts_read_range(ptd
, typename
, &new_dt
) == -1);
823 assert(!*stabs_find_ref(filenr1
, subnr1
));
824 *stabs_find_ref(filenr1
, subnr1
) = new_dt
;
827 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &ref_dt
) == -1);
828 new_dt
= &symt_new_function_signature(ptd
->module
, ref_dt
, -1)->symt
;
831 stabs_get_basic(ptd
, 1 /* int */, &ref_dt
);
832 new_dt
= &symt_new_enum(ptd
->module
, typename
, ref_dt
)->symt
;
833 PTS_ABORTIF(ptd
, stabs_pts_read_enum(ptd
, (struct symt_enum
*)new_dt
) == -1);
838 struct symt_udt
* udt
;
839 enum UdtKind kind
= (ptd
->ptr
[-1] == 's') ? UdtStruct
: UdtUnion
;
840 /* udt can have been already defined in a forward definition */
841 udt
= (struct symt_udt
*)*stabs_find_ref(filenr1
, subnr1
);
844 udt
= symt_new_udt(ptd
->module
, typename
, 0, kind
);
845 /* we need to set it here, because a struct can hold a pointer
848 new_dt
= *stabs_find_ref(filenr1
, subnr1
) = &udt
->symt
;
853 if (udt
->symt
.tag
!= SymTagUDT
)
855 ERR("Forward declaration (%p/%s) is not an aggregate (%u)\n",
856 udt
, symt_get_name(&udt
->symt
), udt
->symt
.tag
);
859 /* FIXME: we currently don't correctly construct nested C++
860 * classes names. Therefore, we could be here with either:
861 * - typename and udt->hash_elt.name being the same string
862 * (non embedded case)
863 * - typename being foo::bar while udt->hash_elt.name being
865 * So, we twist the comparison to test both occurrences. When
866 * we have proper C++ types in this file, this twist has to be
869 l1
= strlen(udt
->hash_elt
.name
);
870 l2
= strlen(typename
);
871 if (l1
> l2
|| strcmp(udt
->hash_elt
.name
, typename
+ l2
- l1
))
872 ERR("Forward declaration name mismatch %s <> %s\n",
873 udt
->hash_elt
.name
, typename
);
876 PTS_ABORTIF(ptd
, stabs_pts_read_aggregate(ptd
, udt
) == -1);
882 PTS_ABORTIF(ptd
, stabs_pts_read_id(ptd
) == -1);
886 stabs_get_basic(ptd
, 1 /* int */, &ref_dt
);
887 new_dt
= &symt_new_enum(ptd
->module
, ptd
->buf
+ idx
, ref_dt
)->symt
;
890 new_dt
= &symt_new_udt(ptd
->module
, ptd
->buf
+ idx
, 0, UdtStruct
)->symt
;
893 new_dt
= &symt_new_udt(ptd
->module
, ptd
->buf
+ idx
, 0, UdtUnion
)->symt
;
902 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &tmp
) == -1);
903 PTS_ABORTIF(ptd
, stabs_get_basic(ptd
, tmp
, &new_dt
) == -1);
904 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';');
908 if (*ptd
->ptr
== '#')
911 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &ref_dt
) == -1);
912 new_dt
= &symt_new_function_signature(ptd
->module
, ref_dt
, -1)->symt
;
919 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &cls_dt
) == -1);
920 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ',');
921 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &ref_dt
) == -1);
922 new_dt
= &symt_new_function_signature(ptd
->module
, ref_dt
, -1)->symt
;
923 while (*ptd
->ptr
== ',')
926 PTS_ABORTIF(ptd
, stabs_pts_read_type_def(ptd
, NULL
, &pmt_dt
) == -1);
932 LONG_PTR type
, len
, unk
;
935 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &type
) == -1);
936 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
937 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &len
) == -1);
938 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
939 PTS_ABORTIF(ptd
, stabs_pts_read_number(ptd
, &unk
) == -1);
940 PTS_ABORTIF(ptd
, *ptd
->ptr
++ != ';'); /* ';' */
942 switch (type
) /* see stabs_get_basic for the details */
944 case 1: basic
= 12; break;
945 case 2: basic
= 13; break;
946 case 3: basic
= 25; break;
947 case 4: basic
= 26; break;
948 case 5: basic
= 35; break;
949 case 6: basic
= 14; break;
950 default: PTS_ABORTIF(ptd
, 1);
952 PTS_ABORTIF(ptd
, stabs_get_basic(ptd
, basic
, &new_dt
) == -1);
956 ERR("Unknown type '%c'\n", ptd
->ptr
[-1]);
963 /* is it a forward declaration that has been filled ? */
964 new_dt
= *stabs_find_ref(filenr1
, subnr1
);
965 /* if not, this should be void (which is defined as a ref to itself, but we
966 * don't correctly catch it)
968 if (!new_dt
&& typename
)
970 new_dt
= &symt_get_basic(btVoid
, 0)->symt
;
971 PTS_ABORTIF(ptd
, strcmp(typename
, "void"));
975 *stabs_find_ref(filenr1
, subnr1
) = *ret_dt
= new_dt
;
977 TRACE("Adding (%Id,%Id) %s\n", filenr1
, subnr1
, debugstr_a(typename
));
982 static int stabs_parse_typedef(struct module
* module
, const char* ptr
,
983 const char* typename
)
985 struct ParseTypedefData ptd
;
989 /* check for already existing definition */
991 TRACE("%s => %s\n", typename
, debugstr_a(ptr
));
997 for (ptd
.ptr
= ptr
- 1; ;)
999 ptd
.ptr
= strchr(ptd
.ptr
+ 1, ':');
1000 if (ptd
.ptr
== NULL
|| *++ptd
.ptr
!= ':') break;
1004 if (*ptd
.ptr
!= '(') ptd
.ptr
++;
1005 /* most of type definitions take one char, except Tt */
1006 if (*ptd
.ptr
!= '(') ptd
.ptr
++;
1007 ret
= stabs_pts_read_type_def(&ptd
, typename
, &dt
);
1010 if (ret
== -1 || *ptd
.ptr
)
1014 TRACE("Failure on %s\n", debugstr_a(ptr
));
1017 for (i
= 0; i
< ptd
.err_idx
; i
++)
1019 TRACE("[%d]: line %d => %s\n",
1020 i
, ptd
.errors
[i
].line
, debugstr_a(ptd
.errors
[i
].ptr
));
1024 TRACE("[0]: => %s\n", debugstr_a(ptd
.ptr
));
1027 ERR("Failure on %s at %s\n", debugstr_a(ptr
), debugstr_a(ptd
.ptr
));
1035 static struct symt
* stabs_parse_type(const char* stab
)
1037 const char* c
= stab
- 1;
1040 * Look through the stab definition, and figure out what struct symt
1041 * this represents. If we have something we know about, assign the
1043 * According to "The \"stabs\" debug format" (Rev 2.130) the name may be
1044 * a C++ name and contain double colons e.g. foo::bar::baz:t5=*6.
1048 if ((c
= strchr(c
+ 1, ':')) == NULL
) return NULL
;
1049 } while (*++c
== ':');
1052 * The next characters say more about the type (i.e. data, function, etc)
1053 * of symbol. Skip them. (C++ for example may have Tt).
1054 * Actually this is a very weak description; I think Tt is the only
1055 * multiple combination we should see.
1057 while (*c
&& *c
!= '(' && !isdigit(*c
))
1060 * The next is either an integer or a (integer,integer).
1061 * The stabs_read_type_enum() takes care that stab_types is large enough.
1063 return *stabs_read_type_enum(&c
);
1066 enum pending_obj_kind
1072 struct pending_loc_var
1077 struct location loc
;
1085 ULONG_PTR load_offset
;
1088 struct pending_object
1090 enum pending_obj_kind tag
;
1092 struct pending_loc_var var
;
1093 struct pending_line line
;
1099 struct pending_object
* objs
;
1104 static inline void pending_make_room(struct pending_list
* pending
)
1106 if (pending
->num
== pending
->allocated
)
1110 pending
->allocated
= 8;
1111 pending
->objs
= HeapAlloc(GetProcessHeap(), 0,
1112 pending
->allocated
* sizeof(pending
->objs
[0]));
1116 pending
->allocated
*= 2;
1117 pending
->objs
= HeapReAlloc(GetProcessHeap(), 0, pending
->objs
,
1118 pending
->allocated
* sizeof(pending
->objs
[0]));
1123 static inline void pending_add_var(struct pending_list
* pending
, const char* name
,
1124 enum DataKind dt
, const struct location
* loc
)
1126 pending_make_room(pending
);
1127 pending
->objs
[pending
->num
].tag
= PENDING_VAR
;
1128 if (!stab_strcpy(pending
->objs
[pending
->num
].u
.var
.name
,
1129 sizeof(pending
->objs
[pending
->num
].u
.var
.name
), name
))
1131 ERR("symbol too long %s\n", debugstr_a(name
));
1134 pending
->objs
[pending
->num
].u
.var
.type
= stabs_parse_type(name
);
1135 pending
->objs
[pending
->num
].u
.var
.kind
= dt
;
1136 pending
->objs
[pending
->num
].u
.var
.loc
= *loc
;
1140 static inline void pending_add_line(struct pending_list
* pending
, int source_idx
,
1141 int line_num
, ULONG_PTR offset
,
1142 ULONG_PTR load_offset
)
1144 pending_make_room(pending
);
1145 pending
->objs
[pending
->num
].tag
= PENDING_LINE
;
1146 pending
->objs
[pending
->num
].u
.line
.source_idx
= source_idx
;
1147 pending
->objs
[pending
->num
].u
.line
.line_num
= line_num
;
1148 pending
->objs
[pending
->num
].u
.line
.offset
= offset
;
1149 pending
->objs
[pending
->num
].u
.line
.load_offset
= load_offset
;
1153 static void pending_flush(struct pending_list
* pending
, struct module
* module
,
1154 struct symt_function
* func
, struct symt_block
* block
)
1158 for (i
= 0; i
< pending
->num
; i
++)
1160 switch (pending
->objs
[i
].tag
)
1163 symt_add_func_local(module
, func
,
1164 pending
->objs
[i
].u
.var
.kind
, &pending
->objs
[i
].u
.var
.loc
,
1165 block
, pending
->objs
[i
].u
.var
.type
, pending
->objs
[i
].u
.var
.name
);
1168 if (module
->type
== DMT_MACHO
)
1169 pending
->objs
[i
].u
.line
.offset
-= func
->ranges
[0].low
- pending
->objs
[i
].u
.line
.load_offset
;
1170 symt_add_func_line(module
, func
, pending
->objs
[i
].u
.line
.source_idx
,
1171 pending
->objs
[i
].u
.line
.line_num
, func
->ranges
[0].low
+ pending
->objs
[i
].u
.line
.offset
);
1174 ERR("Unknown pending object tag %u\n", (unsigned)pending
->objs
[i
].tag
);
1181 /******************************************************************
1182 * stabs_finalize_function
1184 * Ends function creation: mainly:
1185 * - cleans up line number information
1186 * - tries to set up a debug-start tag (FIXME: heuristic to be enhanced)
1187 * - for stabs which have absolute address in them, initializes the size of the
1188 * function (assuming that current function ends where next function starts)
1190 static void stabs_finalize_function(struct module
* module
, struct symt_function
* func
,
1194 struct location loc
;
1198 /* To define the debug-start of the function, we use the second line number.
1199 * Not 100% bullet proof, but better than nothing
1201 il
.SizeOfStruct
= sizeof(il
);
1202 if (SymGetLineFromAddr64(module
->process
->handle
, func
->ranges
[0].low
, &disp
, &il
) &&
1203 SymGetLineNext64(module
->process
->handle
, &il
))
1205 loc
.kind
= loc_absolute
;
1206 loc
.offset
= il
.Address
- func
->ranges
[0].low
;
1207 symt_add_function_point(module
, func
, SymTagFuncDebugStart
,
1210 if (size
) func
->ranges
[0].high
= func
->ranges
[0].low
+ size
;
1213 static inline void stabbuf_append(char **buf
, unsigned *buf_size
, const char *str
)
1215 unsigned str_len
, buf_len
;
1217 str_len
= strlen(str
);
1218 buf_len
= strlen(*buf
);
1220 if(str_len
+buf_len
>= *buf_size
) {
1221 *buf_size
+= buf_len
+ str_len
;
1222 *buf
= HeapReAlloc(GetProcessHeap(), 0, *buf
, *buf_size
);
1225 strcpy(*buf
+buf_len
, str
);
1228 BOOL
stabs_parse(struct module
* module
, ULONG_PTR load_offset
,
1229 const char* pv_stab_ptr
, size_t nstab
, size_t stabsize
,
1230 const char* strs
, int strtablen
,
1231 stabs_def_cb callback
, void* user
)
1233 struct symt_function
* curr_func
= NULL
;
1234 struct symt_block
* block
= NULL
;
1235 struct symt_compiland
* compiland
= NULL
;
1236 char* srcpath
= NULL
;
1240 unsigned int stabbufflen
;
1241 const struct stab_nlist
* stab_ptr
;
1242 const char* strs_end
;
1247 int source_idx
= -1;
1248 struct pending_list pending_block
;
1249 struct pending_list pending_func
;
1251 struct location loc
;
1255 strs_end
= strs
+ strtablen
;
1257 memset(stabs_basic
, 0, sizeof(stabs_basic
));
1258 memset(&pending_block
, 0, sizeof(pending_block
));
1259 memset(&pending_func
, 0, sizeof(pending_func
));
1262 * Allocate a buffer into which we can build stab strings for cases
1263 * where the stab is continued over multiple lines.
1265 stabbufflen
= 65536;
1266 stabbuff
= HeapAlloc(GetProcessHeap(), 0, stabbufflen
);
1270 for (i
= 0; i
< nstab
; i
++)
1272 stab_ptr
= (struct stab_nlist
*)(pv_stab_ptr
+ i
* stabsize
);
1273 n_value
= stabsize
== sizeof(struct macho64_nlist
) ? ((struct macho64_nlist
*)stab_ptr
)->n_value
: stab_ptr
->n_value
;
1274 ptr
= strs
+ stab_ptr
->n_strx
;
1275 if ((ptr
> strs_end
) || (ptr
+ strlen(ptr
) > strs_end
))
1277 WARN("Bad stabs string %p\n", ptr
);
1280 if (*ptr
!= '\0' && (ptr
[strlen(ptr
) - 1] == '\\'))
1283 * Indicates continuation. Append this to the buffer, and go onto the
1284 * next record. Repeat the process until we find a stab without the
1285 * '/' character, as this indicates we have the whole thing.
1287 stabbuf_append(&stabbuff
, &stabbufflen
, ptr
);
1290 else if (stabbuff
[0] != '\0')
1292 stabbuf_append(&stabbuff
, &stabbufflen
, ptr
);
1296 if (stab_ptr
->n_type
& N_STAB
)
1297 type
= stab_ptr
->n_type
;
1300 type
= (stab_ptr
->n_type
& N_TYPE
);
1301 if (module
->type
== DMT_MACHO
) type
&= ~N_PEXT
;
1304 /* only symbol entries contain a typedef */
1314 if (strchr(ptr
, '=') != NULL
)
1317 * The stabs aren't in writable memory, so copy it over so we are
1318 * sure we can scribble on it.
1320 if (ptr
!= stabbuff
)
1323 stabbuf_append(&stabbuff
, &stabbufflen
, ptr
);
1326 if (!stab_strcpy(symname
, sizeof(symname
), ptr
) ||
1327 !stabs_parse_typedef(module
, ptr
, symname
))
1329 /* skip this definition */
1340 * These are useless with ELF. They have no value, and you have to
1341 * read the normal symbol table to get the address. Thus we
1342 * ignore them, and when we process the normal symbol table
1343 * we should do the right thing.
1345 * With a.out or mingw, they actually do make some amount of sense.
1347 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1349 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1353 loc
.kind
= loc_absolute
;
1355 loc
.offset
= load_offset
+ n_value
;
1356 symt_new_global_variable(module
, compiland
, symname
, TRUE
/* FIXME */,
1357 loc
, 0, stabs_parse_type(ptr
));
1361 /* These are static symbols and BSS symbols. */
1362 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1364 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1368 loc
.kind
= loc_absolute
;
1370 loc
.offset
= load_offset
+ n_value
;
1371 symt_new_global_variable(module
, compiland
, symname
, TRUE
/* FIXME */,
1372 loc
, 0, stabs_parse_type(ptr
));
1377 block
= symt_open_func_block(module
, curr_func
, block
, 1);
1378 block
->ranges
[0].low
= curr_func
->ranges
[0].low
+ n_value
;
1379 block
->ranges
[0].high
= 0; /* will be set by N_RBRAC */
1380 pending_flush(&pending_block
, module
, curr_func
, block
);
1386 block
->ranges
[0].high
= curr_func
->ranges
[0].low
+ n_value
;
1387 block
= symt_close_func_block(module
, curr_func
, block
);
1391 /* These are function parameters. */
1392 if (curr_func
!= NULL
)
1394 struct symt
* param_type
= stabs_parse_type(ptr
);
1395 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1397 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1401 loc
.kind
= loc_regrel
;
1402 loc
.reg
= module
->cpu
->frame_regno
;
1403 loc
.offset
= n_value
;
1404 symt_add_func_local(module
, curr_func
,
1405 (int)n_value
>= 0 ? DataIsParam
: DataIsLocal
,
1406 &loc
, NULL
, param_type
, symname
);
1407 symt_add_function_signature_parameter(module
,
1408 (struct symt_function_signature
*)curr_func
->type
,
1413 /* These are registers (as local variables) */
1414 if (curr_func
!= NULL
)
1416 loc
.kind
= loc_register
;
1421 case 0: loc
.reg
= CV_REG_EAX
; break;
1422 case 1: loc
.reg
= CV_REG_ECX
; break;
1423 case 2: loc
.reg
= CV_REG_EDX
; break;
1424 case 3: loc
.reg
= CV_REG_EBX
; break;
1425 case 4: loc
.reg
= CV_REG_ESP
; break;
1426 case 5: loc
.reg
= CV_REG_EBP
; break;
1427 case 6: loc
.reg
= CV_REG_ESI
; break;
1428 case 7: loc
.reg
= CV_REG_EDI
; break;
1437 case 19: loc
.reg
= CV_REG_ST0
+ n_value
- 12; break;
1445 case 28: loc
.reg
= CV_REG_XMM0
+ n_value
- 21; break;
1453 case 36: loc
.reg
= CV_REG_MM0
+ n_value
- 29; break;
1455 FIXME("Unknown register value (%Iu)\n", (ULONG_PTR
)n_value
);
1456 loc
.reg
= CV_REG_NONE
;
1459 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1461 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1465 if (ptr
[strlen(symname
) + 1] == 'P')
1467 struct symt
* param_type
= stabs_parse_type(ptr
);
1468 stab_strcpy(symname
, sizeof(symname
), ptr
);
1469 symt_add_func_local(module
, curr_func
, DataIsParam
, &loc
,
1470 NULL
, param_type
, symname
);
1471 symt_add_function_signature_parameter(module
,
1472 (struct symt_function_signature
*)curr_func
->type
,
1476 pending_add_var(&pending_block
, ptr
, DataIsLocal
, &loc
);
1480 /* These are local variables */
1481 loc
.kind
= loc_regrel
;
1482 loc
.reg
= module
->cpu
->frame_regno
;
1483 loc
.offset
= n_value
;
1484 if (curr_func
!= NULL
) pending_add_var(&pending_block
, ptr
, DataIsLocal
, &loc
);
1488 * This is a line number. These are always relative to the start
1489 * of the function (N_FUN), and this makes the lookup easier.
1491 assert(source_idx
>= 0);
1492 if (curr_func
!= NULL
)
1494 ULONG_PTR offset
= n_value
;
1495 if (module
->type
== DMT_MACHO
)
1496 offset
-= curr_func
->ranges
[0].low
- load_offset
;
1497 symt_add_func_line(module
, curr_func
, source_idx
,
1498 stab_ptr
->n_desc
, curr_func
->ranges
[0].low
+ offset
);
1500 else pending_add_line(&pending_func
, source_idx
, stab_ptr
->n_desc
,
1501 n_value
, load_offset
);
1505 * For now, just declare the various functions. Later
1506 * on, we will add the line number information and the
1510 * Copy the string to a temp buffer so we
1511 * can kill everything after the ':'. We do
1512 * it this way because otherwise we end up dirtying
1513 * all of the pages related to the stabs, and that
1514 * sucks up swap space like crazy.
1516 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1518 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1524 struct symt_function_signature
* func_type
;
1528 /* First, clean up the previous function we were working on.
1529 * Assume size of the func is the delta between current offset
1530 * and offset of last function
1532 stabs_finalize_function(module
, curr_func
,
1534 (load_offset
+ n_value
- curr_func
->ranges
[0].low
) : 0);
1536 func_type
= symt_new_function_signature(module
,
1537 stabs_parse_type(ptr
), -1);
1538 curr_func
= symt_new_function(module
, compiland
, symname
,
1539 load_offset
+ n_value
, 0,
1541 pending_flush(&pending_func
, module
, curr_func
, NULL
);
1545 /* some versions of GCC to use a N_FUN "" to mark the end of a function
1546 * and n_value contains the size of the func
1548 stabs_finalize_function(module
, curr_func
, n_value
);
1554 * This indicates a new source file. Append the records
1555 * together, to build the correct path name.
1557 if (*ptr
== '\0') /* end of N_SO file */
1559 /* Nuke old path. */
1560 HeapFree(GetProcessHeap(), 0, srcpath
);
1562 stabs_finalize_function(module
, curr_func
, 0);
1566 assert(block
== NULL
);
1571 int len
= strlen(ptr
);
1572 if (ptr
[len
-1] != '/')
1574 stabs_reset_includes();
1575 source_idx
= source_new(module
, srcpath
, ptr
);
1576 compiland
= symt_new_compiland(module
, source_idx
);
1580 srcpath
= HeapAlloc(GetProcessHeap(), 0, len
+ 1);
1581 strcpy(srcpath
, ptr
);
1586 source_idx
= source_new(module
, srcpath
, ptr
);
1590 strtabinc
= n_value
;
1591 /* I'm not sure this is needed, so trace it before we obsolete it */
1594 FIXME("UNDF: curr_func %s\n", curr_func
->hash_elt
.name
);
1595 stabs_finalize_function(module
, curr_func
, 0); /* FIXME */
1600 /* Ignore this. We don't care what it points to. */
1603 stabs_add_include(stabs_new_include(ptr
, n_value
));
1604 assert(incl_stk
< (int) ARRAY_SIZE(incl
) - 1);
1605 incl
[++incl_stk
] = source_idx
;
1606 source_idx
= source_new(module
, NULL
, ptr
);
1609 assert(incl_stk
>= 0);
1610 source_idx
= incl
[incl_stk
--];
1613 if (stabs_add_include(stabs_find_include(ptr
, n_value
)) < 0)
1615 ERR("Excluded header not found (%s,%Id)\n", ptr
, (ULONG_PTR
)n_value
);
1616 module_reset_debug_info(module
);
1622 /* Always ignore these. GCC doesn't even generate them. */
1628 /* Always ignore these, they seem to be used only on Darwin. */
1632 /* FIXME: Other definition types (N_TEXT, N_DATA, N_BSS, ...)? */
1635 BOOL is_public
= (stab_ptr
->n_type
& N_EXT
);
1636 BOOL is_global
= is_public
;
1638 /* "private extern"; shared among compilation units in a shared
1639 * library, but not accessible from outside the library. */
1640 if (stab_ptr
->n_type
& N_PEXT
)
1646 if (*ptr
== '_') ptr
++;
1647 if (!stab_strcpy(symname
, sizeof(symname
), ptr
))
1649 ERR("symbol too long: %s\n", debugstr_a(ptr
));
1654 callback(module
, load_offset
, symname
, n_value
,
1655 is_public
, is_global
, stab_ptr
->n_other
, compiland
, user
);
1659 ERR("Unknown stab type 0x%02x\n", type
);
1663 TRACE("0x%02x %Ix %s\n",
1664 stab_ptr
->n_type
, (ULONG_PTR
)n_value
, debugstr_a(strs
+ stab_ptr
->n_strx
));
1666 module
->module
.SymType
= SymDia
;
1667 module
->module
.CVSig
= 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24);
1668 /* FIXME: we could have a finer grain here */
1669 module
->module
.LineNumbers
= TRUE
;
1670 module
->module
.GlobalSymbols
= TRUE
;
1671 module
->module
.TypeInfo
= TRUE
;
1672 module
->module
.SourceIndexed
= TRUE
;
1673 module
->module
.Publics
= TRUE
;
1675 HeapFree(GetProcessHeap(), 0, stabbuff
);
1676 stabs_free_includes();
1677 HeapFree(GetProcessHeap(), 0, pending_block
.objs
);
1678 HeapFree(GetProcessHeap(), 0, pending_func
.objs
);
1679 HeapFree(GetProcessHeap(), 0, srcpath
);