Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Shared code to pre-read a stab (dbx-style), when building a psymtab. |
b6ba6518 KB |
2 | Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, |
3 | 1996, 1997, 1998, 1999, 2000, 2001 | |
c906108c SS |
4 | Free Software Foundation, Inc. |
5 | ||
c5aa993b | 6 | This file is part of GDB. |
c906108c | 7 | |
c5aa993b JM |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
c906108c | 12 | |
c5aa993b JM |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
c906108c | 17 | |
c5aa993b JM |
18 | You should have received a copy of the GNU General Public License |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 59 Temple Place - Suite 330, | |
21 | Boston, MA 02111-1307, USA. */ | |
c906108c SS |
22 | |
23 | /* The following need to be defined: | |
24 | SET_NAMESTRING() --Set namestring to name of symbol. | |
25 | CUR_SYMBOL_TYPE --Type code of current symbol. | |
26 | CUR_SYMBOL_VALUE --Value field of current symbol. May be adjusted here. | |
27 | namestring - variable pointing to the name of the stab. | |
c906108c SS |
28 | pst - the partial symbol table being built. |
29 | ||
30 | psymtab_include_list, includes_used, includes_allocated - list of include | |
c5aa993b | 31 | file names (N_SOL) seen so far. |
c906108c | 32 | dependency_list, dependencies_used, dependencies_allocated - list of |
c5aa993b | 33 | N_EXCL stabs seen so far. |
c906108c SS |
34 | |
35 | END_PSYMTAB -- end a partial symbol table. | |
36 | START_PSYMTAB -- start a partial symbol table. | |
37 | */ | |
38 | ||
39 | /* End of macro definitions, now let's handle them symbols! */ | |
40 | ||
c5aa993b JM |
41 | switch (CUR_SYMBOL_TYPE) |
42 | { | |
531017df JB |
43 | static struct complaint function_outside_compilation_unit = { |
44 | "function `%s' appears to be defined outside of all compilation units", 0, 0 | |
45 | }; | |
c5aa993b JM |
46 | char *p; |
47 | /* | |
48 | * Standard, external, non-debugger, symbols | |
49 | */ | |
50 | ||
51 | case N_TEXT | N_EXT: | |
52 | case N_NBTEXT | N_EXT: | |
b8fbeb18 | 53 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c5aa993b JM |
54 | goto record_it; |
55 | ||
56 | case N_DATA | N_EXT: | |
57 | case N_NBDATA | N_EXT: | |
b8fbeb18 | 58 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); |
c5aa993b JM |
59 | goto record_it; |
60 | ||
61 | case N_BSS: | |
62 | case N_BSS | N_EXT: | |
63 | case N_NBBSS | N_EXT: | |
64 | case N_SETV | N_EXT: /* FIXME, is this in BSS? */ | |
b8fbeb18 | 65 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); |
c5aa993b JM |
66 | goto record_it; |
67 | ||
68 | case N_ABS | N_EXT: | |
69 | record_it: | |
c906108c | 70 | #ifdef DBXREAD_ONLY |
c5aa993b | 71 | SET_NAMESTRING (); |
c906108c | 72 | |
c5aa993b JM |
73 | bss_ext_symbol: |
74 | record_minimal_symbol (namestring, CUR_SYMBOL_VALUE, | |
75 | CUR_SYMBOL_TYPE, objfile); /* Always */ | |
c906108c | 76 | #endif /* DBXREAD_ONLY */ |
c5aa993b | 77 | continue; |
c906108c | 78 | |
c5aa993b | 79 | /* Standard, local, non-debugger, symbols */ |
c906108c | 80 | |
c5aa993b | 81 | case N_NBTEXT: |
c906108c | 82 | |
c5aa993b JM |
83 | /* We need to be able to deal with both N_FN or N_TEXT, |
84 | because we have no way of knowing whether the sys-supplied ld | |
85 | or GNU ld was used to make the executable. Sequents throw | |
86 | in another wrinkle -- they renumbered N_FN. */ | |
c906108c | 87 | |
c5aa993b JM |
88 | case N_FN: |
89 | case N_FN_SEQ: | |
90 | case N_TEXT: | |
c906108c | 91 | #ifdef DBXREAD_ONLY |
b8fbeb18 | 92 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c5aa993b JM |
93 | SET_NAMESTRING (); |
94 | if ((namestring[0] == '-' && namestring[1] == 'l') | |
95 | || (namestring[(nsl = strlen (namestring)) - 1] == 'o' | |
96 | && namestring[nsl - 2] == '.')) | |
97 | { | |
98 | if (objfile->ei.entry_point < CUR_SYMBOL_VALUE && | |
99 | objfile->ei.entry_point >= last_o_file_start) | |
100 | { | |
101 | objfile->ei.entry_file_lowpc = last_o_file_start; | |
102 | objfile->ei.entry_file_highpc = CUR_SYMBOL_VALUE; | |
103 | } | |
104 | if (past_first_source_file && pst | |
105 | /* The gould NP1 uses low values for .o and -l symbols | |
106 | which are not the address. */ | |
3973eadd | 107 | && CUR_SYMBOL_VALUE >= TEXTLOW (pst)) |
c5aa993b JM |
108 | { |
109 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
110 | symnum * symbol_size, | |
3973eadd JB |
111 | CUR_SYMBOL_VALUE > TEXTHIGH (pst) |
112 | ? CUR_SYMBOL_VALUE : TEXTHIGH (pst), | |
c5aa993b JM |
113 | dependency_list, dependencies_used, textlow_not_set); |
114 | pst = (struct partial_symtab *) 0; | |
115 | includes_used = 0; | |
116 | dependencies_used = 0; | |
117 | } | |
118 | else | |
119 | past_first_source_file = 1; | |
120 | last_o_file_start = CUR_SYMBOL_VALUE; | |
121 | } | |
122 | else | |
123 | goto record_it; | |
c906108c | 124 | #endif /* DBXREAD_ONLY */ |
c5aa993b | 125 | continue; |
c906108c | 126 | |
c5aa993b | 127 | case N_DATA: |
b8fbeb18 | 128 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); |
c5aa993b | 129 | goto record_it; |
c906108c | 130 | |
c5aa993b | 131 | case N_UNDF | N_EXT: |
c906108c | 132 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
133 | if (CUR_SYMBOL_VALUE != 0) |
134 | { | |
135 | /* This is a "Fortran COMMON" symbol. See if the target | |
136 | environment knows where it has been relocated to. */ | |
c906108c | 137 | |
c5aa993b | 138 | CORE_ADDR reladdr; |
c906108c | 139 | |
c5aa993b JM |
140 | SET_NAMESTRING (); |
141 | if (target_lookup_symbol (namestring, &reladdr)) | |
142 | { | |
143 | continue; /* Error in lookup; ignore symbol for now. */ | |
c906108c | 144 | } |
c5aa993b JM |
145 | CUR_SYMBOL_TYPE ^= (N_BSS ^ N_UNDF); /* Define it as a bss-symbol */ |
146 | CUR_SYMBOL_VALUE = reladdr; | |
147 | goto bss_ext_symbol; | |
148 | } | |
c906108c | 149 | #endif /* DBXREAD_ONLY */ |
c5aa993b | 150 | continue; /* Just undefined, not COMMON */ |
c906108c | 151 | |
c5aa993b | 152 | case N_UNDF: |
c906108c | 153 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
154 | if (processing_acc_compilation && CUR_SYMBOL_STRX == 1) |
155 | { | |
156 | /* Deal with relative offsets in the string table | |
157 | used in ELF+STAB under Solaris. If we want to use the | |
158 | n_strx field, which contains the name of the file, | |
159 | we must adjust file_string_table_offset *before* calling | |
160 | SET_NAMESTRING(). */ | |
161 | past_first_source_file = 1; | |
162 | file_string_table_offset = next_file_string_table_offset; | |
163 | next_file_string_table_offset = | |
164 | file_string_table_offset + CUR_SYMBOL_VALUE; | |
165 | if (next_file_string_table_offset < file_string_table_offset) | |
166 | error ("string table offset backs up at %d", symnum); | |
167 | /* FIXME -- replace error() with complaint. */ | |
168 | continue; | |
169 | } | |
c906108c | 170 | #endif /* DBXREAD_ONLY */ |
c5aa993b JM |
171 | continue; |
172 | ||
173 | /* Lots of symbol types we can just ignore. */ | |
174 | ||
175 | case N_ABS: | |
176 | case N_NBDATA: | |
177 | case N_NBBSS: | |
178 | continue; | |
179 | ||
180 | /* Keep going . . . */ | |
181 | ||
182 | /* | |
183 | * Special symbol types for GNU | |
184 | */ | |
185 | case N_INDR: | |
186 | case N_INDR | N_EXT: | |
187 | case N_SETA: | |
188 | case N_SETA | N_EXT: | |
189 | case N_SETT: | |
190 | case N_SETT | N_EXT: | |
191 | case N_SETD: | |
192 | case N_SETD | N_EXT: | |
193 | case N_SETB: | |
194 | case N_SETB | N_EXT: | |
195 | case N_SETV: | |
196 | continue; | |
197 | ||
198 | /* | |
199 | * Debugger symbols | |
200 | */ | |
201 | ||
202 | case N_SO: | |
203 | { | |
40b3352b | 204 | CORE_ADDR valu; |
c5aa993b JM |
205 | static int prev_so_symnum = -10; |
206 | static int first_so_symnum; | |
207 | char *p; | |
208 | int prev_textlow_not_set; | |
209 | ||
b8fbeb18 | 210 | valu = CUR_SYMBOL_VALUE + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c5aa993b JM |
211 | |
212 | prev_textlow_not_set = textlow_not_set; | |
c906108c SS |
213 | |
214 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING | |
c5aa993b JM |
215 | /* A zero value is probably an indication for the SunPRO 3.0 |
216 | compiler. end_psymtab explicitly tests for zero, so | |
217 | don't relocate it. */ | |
c906108c | 218 | |
c5aa993b JM |
219 | if (CUR_SYMBOL_VALUE == 0) |
220 | { | |
221 | textlow_not_set = 1; | |
222 | valu = 0; | |
223 | } | |
224 | else | |
225 | textlow_not_set = 0; | |
c906108c | 226 | #else |
c5aa993b | 227 | textlow_not_set = 0; |
c906108c | 228 | #endif |
c5aa993b | 229 | past_first_source_file = 1; |
c906108c | 230 | |
c5aa993b JM |
231 | if (prev_so_symnum != symnum - 1) |
232 | { /* Here if prev stab wasn't N_SO */ | |
233 | first_so_symnum = symnum; | |
234 | ||
235 | if (pst) | |
236 | { | |
237 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
238 | symnum * symbol_size, | |
3973eadd | 239 | valu > TEXTHIGH (pst) ? valu : TEXTHIGH (pst), |
c5aa993b JM |
240 | dependency_list, dependencies_used, |
241 | prev_textlow_not_set); | |
242 | pst = (struct partial_symtab *) 0; | |
243 | includes_used = 0; | |
244 | dependencies_used = 0; | |
c906108c | 245 | } |
c5aa993b | 246 | } |
c906108c | 247 | |
c5aa993b | 248 | prev_so_symnum = symnum; |
c906108c | 249 | |
c5aa993b | 250 | /* End the current partial symtab and start a new one */ |
c906108c | 251 | |
c5aa993b | 252 | SET_NAMESTRING (); |
c906108c | 253 | |
c5aa993b JM |
254 | /* Null name means end of .o file. Don't start a new one. */ |
255 | if (*namestring == '\000') | |
256 | continue; | |
c906108c | 257 | |
c5aa993b JM |
258 | /* Some compilers (including gcc) emit a pair of initial N_SOs. |
259 | The first one is a directory name; the second the file name. | |
260 | If pst exists, is empty, and has a filename ending in '/', | |
261 | we assume the previous N_SO was a directory name. */ | |
c906108c | 262 | |
c5aa993b JM |
263 | p = strrchr (namestring, '/'); |
264 | if (p && *(p + 1) == '\000') | |
265 | continue; /* Simply ignore directory name SOs */ | |
266 | ||
267 | /* Some other compilers (C++ ones in particular) emit useless | |
268 | SOs for non-existant .c files. We ignore all subsequent SOs that | |
269 | immediately follow the first. */ | |
270 | ||
271 | if (!pst) | |
d4f3574e | 272 | pst = START_PSYMTAB (objfile, |
c5aa993b JM |
273 | namestring, valu, |
274 | first_so_symnum * symbol_size, | |
275 | objfile->global_psymbols.next, | |
276 | objfile->static_psymbols.next); | |
277 | continue; | |
278 | } | |
279 | ||
280 | case N_BINCL: | |
281 | { | |
c906108c | 282 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
283 | enum language tmp_language; |
284 | /* Add this bincl to the bincl_list for future EXCLs. No | |
285 | need to save the string; it'll be around until | |
286 | read_dbx_symtab function returns */ | |
c906108c | 287 | |
c5aa993b | 288 | SET_NAMESTRING (); |
c906108c | 289 | |
c5aa993b | 290 | tmp_language = deduce_language_from_filename (namestring); |
c906108c | 291 | |
c5aa993b JM |
292 | /* Only change the psymtab's language if we've learned |
293 | something useful (eg. tmp_language is not language_unknown). | |
294 | In addition, to match what start_subfile does, never change | |
295 | from C++ to C. */ | |
296 | if (tmp_language != language_unknown | |
297 | && (tmp_language != language_c | |
298 | || psymtab_language != language_cplus)) | |
299 | psymtab_language = tmp_language; | |
c906108c | 300 | |
c5aa993b JM |
301 | if (pst == NULL) |
302 | { | |
303 | /* FIXME: we should not get here without a PST to work on. | |
304 | Attempt to recover. */ | |
305 | complain (&unclaimed_bincl_complaint, namestring, symnum); | |
306 | continue; | |
307 | } | |
308 | add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE); | |
c906108c | 309 | |
c5aa993b | 310 | /* Mark down an include file in the current psymtab */ |
c906108c | 311 | |
c5aa993b | 312 | goto record_include_file; |
c906108c SS |
313 | |
314 | #else /* DBXREAD_ONLY */ | |
c5aa993b | 315 | continue; |
c906108c | 316 | #endif |
c5aa993b JM |
317 | } |
318 | ||
319 | case N_SOL: | |
320 | { | |
321 | enum language tmp_language; | |
322 | /* Mark down an include file in the current psymtab */ | |
323 | ||
324 | SET_NAMESTRING (); | |
325 | ||
326 | tmp_language = deduce_language_from_filename (namestring); | |
327 | ||
328 | /* Only change the psymtab's language if we've learned | |
329 | something useful (eg. tmp_language is not language_unknown). | |
330 | In addition, to match what start_subfile does, never change | |
331 | from C++ to C. */ | |
332 | if (tmp_language != language_unknown | |
333 | && (tmp_language != language_c | |
334 | || psymtab_language != language_cplus)) | |
335 | psymtab_language = tmp_language; | |
336 | ||
337 | /* In C++, one may expect the same filename to come round many | |
338 | times, when code is coming alternately from the main file | |
339 | and from inline functions in other files. So I check to see | |
340 | if this is a file we've seen before -- either the main | |
341 | source file, or a previously included file. | |
342 | ||
343 | This seems to be a lot of time to be spending on N_SOL, but | |
344 | things like "break c-exp.y:435" need to work (I | |
345 | suppose the psymtab_include_list could be hashed or put | |
346 | in a binary tree, if profiling shows this is a major hog). */ | |
347 | if (pst && STREQ (namestring, pst->filename)) | |
348 | continue; | |
349 | { | |
350 | register int i; | |
351 | for (i = 0; i < includes_used; i++) | |
352 | if (STREQ (namestring, psymtab_include_list[i])) | |
c906108c | 353 | { |
c5aa993b JM |
354 | i = -1; |
355 | break; | |
c906108c | 356 | } |
c5aa993b JM |
357 | if (i == -1) |
358 | continue; | |
359 | } | |
360 | ||
c906108c | 361 | #ifdef DBXREAD_ONLY |
c5aa993b | 362 | record_include_file: |
c906108c | 363 | #endif |
c5aa993b JM |
364 | |
365 | psymtab_include_list[includes_used++] = namestring; | |
366 | if (includes_used >= includes_allocated) | |
367 | { | |
368 | char **orig = psymtab_include_list; | |
369 | ||
370 | psymtab_include_list = (char **) | |
371 | alloca ((includes_allocated *= 2) * | |
372 | sizeof (char *)); | |
373 | memcpy ((PTR) psymtab_include_list, (PTR) orig, | |
374 | includes_used * sizeof (char *)); | |
375 | } | |
376 | continue; | |
377 | } | |
378 | case N_LSYM: /* Typedef or automatic variable. */ | |
379 | case N_STSYM: /* Data seg var -- static */ | |
380 | case N_LCSYM: /* BSS " */ | |
381 | case N_ROSYM: /* Read-only data seg var -- static. */ | |
382 | case N_NBSTS: /* Gould nobase. */ | |
383 | case N_NBLCS: /* symbols. */ | |
384 | case N_FUN: | |
385 | case N_GSYM: /* Global (extern) variable; can be | |
c906108c SS |
386 | data or bss (sigh FIXME). */ |
387 | ||
c5aa993b JM |
388 | /* Following may probably be ignored; I'll leave them here |
389 | for now (until I do Pascal and Modula 2 extensions). */ | |
c906108c | 390 | |
c5aa993b | 391 | case N_PC: /* I may or may not need this; I |
c906108c | 392 | suspect not. */ |
c5aa993b JM |
393 | case N_M2C: /* I suspect that I can ignore this here. */ |
394 | case N_SCOPE: /* Same. */ | |
c906108c | 395 | |
c5aa993b | 396 | SET_NAMESTRING (); |
c906108c SS |
397 | |
398 | #ifdef DBXREAD_ONLY | |
c5aa993b | 399 | /* See if this is an end of function stab. */ |
7d88144c | 400 | if (pst && CUR_SYMBOL_TYPE == N_FUN && *namestring == '\000') |
c5aa993b | 401 | { |
40b3352b | 402 | CORE_ADDR valu; |
c5aa993b JM |
403 | |
404 | /* It's value is the size (in bytes) of the function for | |
405 | function relative stabs, or the address of the function's | |
406 | end for old style stabs. */ | |
407 | valu = CUR_SYMBOL_VALUE + last_function_start; | |
3973eadd JB |
408 | if (TEXTHIGH (pst) == 0 || valu > TEXTHIGH (pst)) |
409 | TEXTHIGH (pst) = valu; | |
c5aa993b JM |
410 | break; |
411 | } | |
c906108c SS |
412 | #endif |
413 | ||
c5aa993b JM |
414 | p = (char *) strchr (namestring, ':'); |
415 | if (!p) | |
416 | continue; /* Not a debugging symbol. */ | |
c906108c SS |
417 | |
418 | ||
419 | ||
c5aa993b JM |
420 | /* Main processing section for debugging symbols which |
421 | the initial read through the symbol tables needs to worry | |
422 | about. If we reach this point, the symbol which we are | |
423 | considering is definitely one we are interested in. | |
424 | p must also contain the (valid) index into the namestring | |
425 | which indicates the debugging type symbol. */ | |
c906108c | 426 | |
c5aa993b JM |
427 | switch (p[1]) |
428 | { | |
429 | case 'S': | |
b8fbeb18 | 430 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); |
c906108c | 431 | #ifdef STATIC_TRANSFORM_NAME |
c5aa993b | 432 | namestring = STATIC_TRANSFORM_NAME (namestring); |
c906108c | 433 | #endif |
c5aa993b JM |
434 | add_psymbol_to_list (namestring, p - namestring, |
435 | VAR_NAMESPACE, LOC_STATIC, | |
436 | &objfile->static_psymbols, | |
437 | 0, CUR_SYMBOL_VALUE, | |
438 | psymtab_language, objfile); | |
439 | continue; | |
440 | case 'G': | |
b8fbeb18 | 441 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); |
c5aa993b JM |
442 | /* The addresses in these entries are reported to be |
443 | wrong. See the code that reads 'G's for symtabs. */ | |
444 | add_psymbol_to_list (namestring, p - namestring, | |
445 | VAR_NAMESPACE, LOC_STATIC, | |
446 | &objfile->global_psymbols, | |
447 | 0, CUR_SYMBOL_VALUE, | |
448 | psymtab_language, objfile); | |
449 | continue; | |
450 | ||
451 | case 'T': | |
452 | /* When a 'T' entry is defining an anonymous enum, it | |
453 | may have a name which is the empty string, or a | |
454 | single space. Since they're not really defining a | |
455 | symbol, those shouldn't go in the partial symbol | |
456 | table. We do pick up the elements of such enums at | |
457 | 'check_enum:', below. */ | |
458 | if (p >= namestring + 2 | |
459 | || (p == namestring + 1 | |
460 | && namestring[0] != ' ')) | |
461 | { | |
462 | add_psymbol_to_list (namestring, p - namestring, | |
463 | STRUCT_NAMESPACE, LOC_TYPEDEF, | |
464 | &objfile->static_psymbols, | |
465 | CUR_SYMBOL_VALUE, 0, | |
466 | psymtab_language, objfile); | |
467 | if (p[2] == 't') | |
468 | { | |
469 | /* Also a typedef with the same name. */ | |
470 | add_psymbol_to_list (namestring, p - namestring, | |
471 | VAR_NAMESPACE, LOC_TYPEDEF, | |
472 | &objfile->static_psymbols, | |
473 | CUR_SYMBOL_VALUE, 0, | |
474 | psymtab_language, objfile); | |
475 | p += 1; | |
476 | } | |
477 | /* The semantics of C++ state that "struct foo { ... }" | |
478 | also defines a typedef for "foo". Unfortuantely, cfront | |
479 | never makes the typedef when translating from C++ to C. | |
480 | We make the typedef here so that "ptype foo" works as | |
481 | expected for cfront translated code. */ | |
482 | else if (psymtab_language == language_cplus) | |
483 | { | |
484 | /* Also a typedef with the same name. */ | |
485 | add_psymbol_to_list (namestring, p - namestring, | |
486 | VAR_NAMESPACE, LOC_TYPEDEF, | |
487 | &objfile->static_psymbols, | |
488 | CUR_SYMBOL_VALUE, 0, | |
489 | psymtab_language, objfile); | |
490 | } | |
491 | } | |
492 | goto check_enum; | |
493 | case 't': | |
494 | if (p != namestring) /* a name is there, not just :T... */ | |
495 | { | |
496 | add_psymbol_to_list (namestring, p - namestring, | |
497 | VAR_NAMESPACE, LOC_TYPEDEF, | |
498 | &objfile->static_psymbols, | |
499 | CUR_SYMBOL_VALUE, 0, | |
500 | psymtab_language, objfile); | |
501 | } | |
502 | check_enum: | |
503 | /* If this is an enumerated type, we need to | |
504 | add all the enum constants to the partial symbol | |
505 | table. This does not cover enums without names, e.g. | |
506 | "enum {a, b} c;" in C, but fortunately those are | |
507 | rare. There is no way for GDB to find those from the | |
508 | enum type without spending too much time on it. Thus | |
509 | to solve this problem, the compiler needs to put out the | |
510 | enum in a nameless type. GCC2 does this. */ | |
511 | ||
512 | /* We are looking for something of the form | |
513 | <name> ":" ("t" | "T") [<number> "="] "e" | |
514 | {<constant> ":" <value> ","} ";". */ | |
515 | ||
516 | /* Skip over the colon and the 't' or 'T'. */ | |
517 | p += 2; | |
518 | /* This type may be given a number. Also, numbers can come | |
519 | in pairs like (0,26). Skip over it. */ | |
520 | while ((*p >= '0' && *p <= '9') | |
521 | || *p == '(' || *p == ',' || *p == ')' | |
522 | || *p == '=') | |
523 | p++; | |
524 | ||
525 | if (*p++ == 'e') | |
526 | { | |
527 | /* The aix4 compiler emits extra crud before the members. */ | |
528 | if (*p == '-') | |
529 | { | |
530 | /* Skip over the type (?). */ | |
531 | while (*p != ':') | |
532 | p++; | |
533 | ||
534 | /* Skip over the colon. */ | |
c906108c | 535 | p++; |
c5aa993b | 536 | } |
c906108c | 537 | |
c5aa993b JM |
538 | /* We have found an enumerated type. */ |
539 | /* According to comments in read_enum_type | |
540 | a comma could end it instead of a semicolon. | |
541 | I don't know where that happens. | |
542 | Accept either. */ | |
543 | while (*p && *p != ';' && *p != ',') | |
544 | { | |
545 | char *q; | |
546 | ||
547 | /* Check for and handle cretinous dbx symbol name | |
548 | continuation! */ | |
549 | if (*p == '\\' || (*p == '?' && p[1] == '\0')) | |
550 | p = next_symbol_text (objfile); | |
551 | ||
552 | /* Point to the character after the name | |
553 | of the enum constant. */ | |
554 | for (q = p; *q && *q != ':'; q++) | |
555 | ; | |
556 | /* Note that the value doesn't matter for | |
557 | enum constants in psymtabs, just in symtabs. */ | |
558 | add_psymbol_to_list (p, q - p, | |
559 | VAR_NAMESPACE, LOC_CONST, | |
560 | &objfile->static_psymbols, 0, | |
561 | 0, psymtab_language, objfile); | |
562 | /* Point past the name. */ | |
563 | p = q; | |
564 | /* Skip over the value. */ | |
565 | while (*p && *p != ',') | |
566 | p++; | |
567 | /* Advance past the comma. */ | |
568 | if (*p) | |
569 | p++; | |
570 | } | |
571 | } | |
572 | continue; | |
573 | case 'c': | |
574 | /* Constant, e.g. from "const" in Pascal. */ | |
575 | add_psymbol_to_list (namestring, p - namestring, | |
576 | VAR_NAMESPACE, LOC_CONST, | |
577 | &objfile->static_psymbols, CUR_SYMBOL_VALUE, | |
578 | 0, psymtab_language, objfile); | |
579 | continue; | |
580 | ||
581 | case 'f': | |
531017df JB |
582 | if (! pst) |
583 | { | |
584 | int name_len = p - namestring; | |
585 | char *name = xmalloc (name_len + 1); | |
586 | memcpy (name, namestring, name_len); | |
587 | name[name_len] = '\0'; | |
588 | complain (&function_outside_compilation_unit, name); | |
d0bbfec7 | 589 | xfree (name); |
531017df | 590 | } |
b8fbeb18 | 591 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c906108c | 592 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
593 | /* Kludges for ELF/STABS with Sun ACC */ |
594 | last_function_name = namestring; | |
c906108c | 595 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b JM |
596 | /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit |
597 | value for the bottom of the text seg in those cases. */ | |
9a058a09 KB |
598 | if (CUR_SYMBOL_VALUE == ANOFFSET (objfile->section_offsets, |
599 | SECT_OFF_TEXT (objfile))) | |
c5aa993b | 600 | { |
9a058a09 | 601 | CORE_ADDR minsym_valu = |
c2c6d25f | 602 | find_stab_function_addr (namestring, pst->filename, objfile); |
9a058a09 KB |
603 | /* find_stab_function_addr will return 0 if the minimal |
604 | symbol wasn't found. (Unfortunately, this might also | |
605 | be a valid address.) Anyway, if it *does* return 0, | |
606 | it is likely that the value was set correctly to begin | |
607 | with... */ | |
608 | if (minsym_valu != 0) | |
609 | CUR_SYMBOL_VALUE = minsym_valu; | |
610 | } | |
611 | if (pst && textlow_not_set) | |
612 | { | |
3973eadd | 613 | TEXTLOW (pst) = CUR_SYMBOL_VALUE; |
c5aa993b JM |
614 | textlow_not_set = 0; |
615 | } | |
c906108c | 616 | #endif |
c5aa993b JM |
617 | /* End kludge. */ |
618 | ||
c2c6d25f JM |
619 | /* Keep track of the start of the last function so we |
620 | can handle end of function symbols. */ | |
621 | last_function_start = CUR_SYMBOL_VALUE; | |
622 | ||
c5aa993b JM |
623 | /* In reordered executables this function may lie outside |
624 | the bounds created by N_SO symbols. If that's the case | |
625 | use the address of this function as the low bound for | |
626 | the partial symbol table. */ | |
531017df JB |
627 | if (pst |
628 | && (textlow_not_set | |
3973eadd | 629 | || (CUR_SYMBOL_VALUE < TEXTLOW (pst) |
531017df JB |
630 | && (CUR_SYMBOL_VALUE |
631 | != ANOFFSET (objfile->section_offsets, | |
632 | SECT_OFF_TEXT (objfile)))))) | |
c5aa993b | 633 | { |
3973eadd | 634 | TEXTLOW (pst) = CUR_SYMBOL_VALUE; |
c5aa993b JM |
635 | textlow_not_set = 0; |
636 | } | |
c906108c | 637 | #endif /* DBXREAD_ONLY */ |
c5aa993b JM |
638 | add_psymbol_to_list (namestring, p - namestring, |
639 | VAR_NAMESPACE, LOC_BLOCK, | |
640 | &objfile->static_psymbols, | |
641 | 0, CUR_SYMBOL_VALUE, | |
642 | psymtab_language, objfile); | |
643 | continue; | |
644 | ||
645 | /* Global functions were ignored here, but now they | |
646 | are put into the global psymtab like one would expect. | |
647 | They're also in the minimal symbol table. */ | |
648 | case 'F': | |
531017df JB |
649 | if (! pst) |
650 | { | |
651 | int name_len = p - namestring; | |
652 | char *name = xmalloc (name_len + 1); | |
653 | memcpy (name, namestring, name_len); | |
654 | name[name_len] = '\0'; | |
655 | complain (&function_outside_compilation_unit, name); | |
d0bbfec7 | 656 | xfree (name); |
531017df | 657 | } |
b8fbeb18 | 658 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c906108c | 659 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
660 | /* Kludges for ELF/STABS with Sun ACC */ |
661 | last_function_name = namestring; | |
c906108c | 662 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b JM |
663 | /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit |
664 | value for the bottom of the text seg in those cases. */ | |
c2c6d25f | 665 | if (CUR_SYMBOL_VALUE == ANOFFSET (objfile->section_offsets, |
b8fbeb18 | 666 | SECT_OFF_TEXT (objfile))) |
9a058a09 KB |
667 | { |
668 | CORE_ADDR minsym_valu = | |
669 | find_stab_function_addr (namestring, pst->filename, objfile); | |
670 | /* find_stab_function_addr will return 0 if the minimal | |
671 | symbol wasn't found. (Unfortunately, this might also | |
672 | be a valid address.) Anyway, if it *does* return 0, | |
673 | it is likely that the value was set correctly to begin | |
674 | with... */ | |
675 | if (minsym_valu != 0) | |
676 | CUR_SYMBOL_VALUE = minsym_valu; | |
677 | } | |
c5aa993b JM |
678 | if (pst && textlow_not_set) |
679 | { | |
3973eadd | 680 | TEXTLOW (pst) = CUR_SYMBOL_VALUE; |
c5aa993b JM |
681 | textlow_not_set = 0; |
682 | } | |
c906108c | 683 | #endif |
c5aa993b | 684 | /* End kludge. */ |
c2c6d25f JM |
685 | |
686 | /* Keep track of the start of the last function so we | |
687 | can handle end of function symbols. */ | |
688 | last_function_start = CUR_SYMBOL_VALUE; | |
689 | ||
c5aa993b JM |
690 | /* In reordered executables this function may lie outside |
691 | the bounds created by N_SO symbols. If that's the case | |
692 | use the address of this function as the low bound for | |
693 | the partial symbol table. */ | |
531017df JB |
694 | if (pst |
695 | && (textlow_not_set | |
3973eadd | 696 | || (CUR_SYMBOL_VALUE < TEXTLOW (pst) |
531017df JB |
697 | && (CUR_SYMBOL_VALUE |
698 | != ANOFFSET (objfile->section_offsets, | |
699 | SECT_OFF_TEXT (objfile)))))) | |
c5aa993b | 700 | { |
3973eadd | 701 | TEXTLOW (pst) = CUR_SYMBOL_VALUE; |
c5aa993b JM |
702 | textlow_not_set = 0; |
703 | } | |
c906108c | 704 | #endif /* DBXREAD_ONLY */ |
c5aa993b JM |
705 | add_psymbol_to_list (namestring, p - namestring, |
706 | VAR_NAMESPACE, LOC_BLOCK, | |
707 | &objfile->global_psymbols, | |
708 | 0, CUR_SYMBOL_VALUE, | |
709 | psymtab_language, objfile); | |
710 | continue; | |
711 | ||
712 | /* Two things show up here (hopefully); static symbols of | |
713 | local scope (static used inside braces) or extensions | |
714 | of structure symbols. We can ignore both. */ | |
715 | case 'V': | |
716 | case '(': | |
717 | case '0': | |
718 | case '1': | |
719 | case '2': | |
720 | case '3': | |
721 | case '4': | |
722 | case '5': | |
723 | case '6': | |
724 | case '7': | |
725 | case '8': | |
726 | case '9': | |
727 | case '-': | |
728 | case '#': /* for symbol identification (used in live ranges) */ | |
729 | /* added to support cfront stabs strings */ | |
730 | case 'Z': /* for definition continuations */ | |
731 | case 'P': /* for prototypes */ | |
732 | continue; | |
733 | ||
734 | case ':': | |
735 | /* It is a C++ nested symbol. We don't need to record it | |
736 | (I don't think); if we try to look up foo::bar::baz, | |
737 | then symbols for the symtab containing foo should get | |
738 | read in, I think. */ | |
739 | /* Someone says sun cc puts out symbols like | |
740 | /foo/baz/maclib::/usr/local/bin/maclib, | |
741 | which would get here with a symbol type of ':'. */ | |
742 | continue; | |
743 | ||
744 | default: | |
745 | /* Unexpected symbol descriptor. The second and subsequent stabs | |
746 | of a continued stab can show up here. The question is | |
747 | whether they ever can mimic a normal stab--it would be | |
748 | nice if not, since we certainly don't want to spend the | |
749 | time searching to the end of every string looking for | |
750 | a backslash. */ | |
751 | ||
752 | complain (&unknown_symchar_complaint, p[1]); | |
753 | ||
754 | /* Ignore it; perhaps it is an extension that we don't | |
755 | know about. */ | |
756 | continue; | |
757 | } | |
758 | ||
759 | case N_EXCL: | |
c906108c SS |
760 | #ifdef DBXREAD_ONLY |
761 | ||
c5aa993b | 762 | SET_NAMESTRING (); |
c906108c | 763 | |
c5aa993b JM |
764 | /* Find the corresponding bincl and mark that psymtab on the |
765 | psymtab dependency list */ | |
766 | { | |
767 | struct partial_symtab *needed_pst = | |
768 | find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE); | |
c906108c | 769 | |
c5aa993b JM |
770 | /* If this include file was defined earlier in this file, |
771 | leave it alone. */ | |
772 | if (needed_pst == pst) | |
773 | continue; | |
c906108c | 774 | |
c5aa993b JM |
775 | if (needed_pst) |
776 | { | |
777 | int i; | |
778 | int found = 0; | |
779 | ||
780 | for (i = 0; i < dependencies_used; i++) | |
781 | if (dependency_list[i] == needed_pst) | |
c906108c | 782 | { |
c5aa993b JM |
783 | found = 1; |
784 | break; | |
785 | } | |
786 | ||
787 | /* If it's already in the list, skip the rest. */ | |
788 | if (found) | |
789 | continue; | |
790 | ||
791 | dependency_list[dependencies_used++] = needed_pst; | |
792 | if (dependencies_used >= dependencies_allocated) | |
793 | { | |
794 | struct partial_symtab **orig = dependency_list; | |
795 | dependency_list = | |
796 | (struct partial_symtab **) | |
797 | alloca ((dependencies_allocated *= 2) | |
798 | * sizeof (struct partial_symtab *)); | |
799 | memcpy ((PTR) dependency_list, (PTR) orig, | |
800 | (dependencies_used | |
801 | * sizeof (struct partial_symtab *))); | |
c906108c | 802 | #ifdef DEBUG_INFO |
c5aa993b JM |
803 | fprintf_unfiltered (gdb_stderr, "Had to reallocate dependency list.\n"); |
804 | fprintf_unfiltered (gdb_stderr, "New dependencies allocated: %d\n", | |
805 | dependencies_allocated); | |
c906108c | 806 | #endif |
c5aa993b JM |
807 | } |
808 | } | |
809 | } | |
c906108c | 810 | #endif /* DBXREAD_ONLY */ |
c5aa993b | 811 | continue; |
c906108c | 812 | |
c5aa993b | 813 | case N_ENDM: |
c906108c | 814 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b | 815 | /* Solaris 2 end of module, finish current partial symbol table. |
3973eadd | 816 | END_PSYMTAB will set TEXTHIGH (pst) to the proper value, which |
c5aa993b JM |
817 | is necessary if a module compiled without debugging info |
818 | follows this module. */ | |
819 | if (pst) | |
820 | { | |
821 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
822 | symnum * symbol_size, | |
823 | (CORE_ADDR) 0, | |
824 | dependency_list, dependencies_used, textlow_not_set); | |
825 | pst = (struct partial_symtab *) 0; | |
826 | includes_used = 0; | |
827 | dependencies_used = 0; | |
828 | } | |
c906108c | 829 | #endif |
c5aa993b | 830 | continue; |
c906108c | 831 | |
c5aa993b | 832 | case N_RBRAC: |
c906108c | 833 | #ifdef HANDLE_RBRAC |
c5aa993b JM |
834 | HANDLE_RBRAC (CUR_SYMBOL_VALUE); |
835 | continue; | |
c906108c | 836 | #endif |
c5aa993b JM |
837 | case N_EINCL: |
838 | case N_DSLINE: | |
839 | case N_BSLINE: | |
840 | case N_SSYM: /* Claim: Structure or union element. | |
c906108c | 841 | Hopefully, I can ignore this. */ |
c5aa993b JM |
842 | case N_ENTRY: /* Alternate entry point; can ignore. */ |
843 | case N_MAIN: /* Can definitely ignore this. */ | |
844 | case N_CATCH: /* These are GNU C++ extensions */ | |
845 | case N_EHDECL: /* that can safely be ignored here. */ | |
846 | case N_LENG: | |
847 | case N_BCOMM: | |
848 | case N_ECOMM: | |
849 | case N_ECOML: | |
850 | case N_FNAME: | |
851 | case N_SLINE: | |
852 | case N_RSYM: | |
853 | case N_PSYM: | |
854 | case N_LBRAC: | |
855 | case N_NSYMS: /* Ultrix 4.0: symbol count */ | |
856 | case N_DEFD: /* GNU Modula-2 */ | |
857 | case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ | |
858 | ||
859 | case N_OBJ: /* useless types from Solaris */ | |
860 | case N_OPT: | |
861 | /* These symbols aren't interesting; don't worry about them */ | |
862 | ||
863 | continue; | |
864 | ||
865 | default: | |
866 | /* If we haven't found it yet, ignore it. It's probably some | |
867 | new type we don't know about yet. */ | |
868 | complain (&unknown_symtype_complaint, | |
869 | local_hex_string (CUR_SYMBOL_TYPE)); | |
870 | continue; | |
871 | } |