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. */ | |
107 | && CUR_SYMBOL_VALUE >= pst->textlow) | |
108 | { | |
109 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
110 | symnum * symbol_size, | |
111 | CUR_SYMBOL_VALUE > pst->texthigh | |
112 | ? CUR_SYMBOL_VALUE : pst->texthigh, | |
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 | { | |
204 | unsigned long valu; | |
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, | |
239 | valu > pst->texthigh ? valu : pst->texthigh, | |
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 JM |
401 | { |
402 | unsigned long valu; | |
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; | |
c5f231f7 | 408 | if (pst->texthigh == 0 || valu > pst->texthigh) |
c5aa993b JM |
409 | pst->texthigh = valu; |
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); | |
589 | } | |
b8fbeb18 | 590 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c906108c | 591 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
592 | /* Kludges for ELF/STABS with Sun ACC */ |
593 | last_function_name = namestring; | |
c906108c | 594 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b JM |
595 | /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit |
596 | value for the bottom of the text seg in those cases. */ | |
597 | if (pst && textlow_not_set) | |
598 | { | |
599 | pst->textlow = | |
c2c6d25f | 600 | find_stab_function_addr (namestring, pst->filename, objfile); |
c5aa993b JM |
601 | textlow_not_set = 0; |
602 | } | |
c906108c | 603 | #endif |
c5aa993b JM |
604 | /* End kludge. */ |
605 | ||
c2c6d25f JM |
606 | /* Keep track of the start of the last function so we |
607 | can handle end of function symbols. */ | |
608 | last_function_start = CUR_SYMBOL_VALUE; | |
609 | ||
c5aa993b JM |
610 | /* In reordered executables this function may lie outside |
611 | the bounds created by N_SO symbols. If that's the case | |
612 | use the address of this function as the low bound for | |
613 | the partial symbol table. */ | |
531017df JB |
614 | if (pst |
615 | && (textlow_not_set | |
616 | || (CUR_SYMBOL_VALUE < pst->textlow | |
617 | && (CUR_SYMBOL_VALUE | |
618 | != ANOFFSET (objfile->section_offsets, | |
619 | SECT_OFF_TEXT (objfile)))))) | |
c5aa993b JM |
620 | { |
621 | pst->textlow = CUR_SYMBOL_VALUE; | |
622 | textlow_not_set = 0; | |
623 | } | |
c906108c | 624 | #endif /* DBXREAD_ONLY */ |
c5aa993b JM |
625 | add_psymbol_to_list (namestring, p - namestring, |
626 | VAR_NAMESPACE, LOC_BLOCK, | |
627 | &objfile->static_psymbols, | |
628 | 0, CUR_SYMBOL_VALUE, | |
629 | psymtab_language, objfile); | |
630 | continue; | |
631 | ||
632 | /* Global functions were ignored here, but now they | |
633 | are put into the global psymtab like one would expect. | |
634 | They're also in the minimal symbol table. */ | |
635 | case 'F': | |
531017df JB |
636 | if (! pst) |
637 | { | |
638 | int name_len = p - namestring; | |
639 | char *name = xmalloc (name_len + 1); | |
640 | memcpy (name, namestring, name_len); | |
641 | name[name_len] = '\0'; | |
642 | complain (&function_outside_compilation_unit, name); | |
643 | } | |
b8fbeb18 | 644 | CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); |
c906108c | 645 | #ifdef DBXREAD_ONLY |
c5aa993b JM |
646 | /* Kludges for ELF/STABS with Sun ACC */ |
647 | last_function_name = namestring; | |
c906108c | 648 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b JM |
649 | /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit |
650 | value for the bottom of the text seg in those cases. */ | |
c2c6d25f | 651 | if (CUR_SYMBOL_VALUE == ANOFFSET (objfile->section_offsets, |
b8fbeb18 | 652 | SECT_OFF_TEXT (objfile))) |
c2c6d25f JM |
653 | CUR_SYMBOL_VALUE = |
654 | find_stab_function_addr (namestring, pst->filename, objfile); | |
c5aa993b JM |
655 | if (pst && textlow_not_set) |
656 | { | |
c2c6d25f | 657 | pst->textlow = CUR_SYMBOL_VALUE; |
c5aa993b JM |
658 | textlow_not_set = 0; |
659 | } | |
c906108c | 660 | #endif |
c5aa993b | 661 | /* End kludge. */ |
c2c6d25f JM |
662 | |
663 | /* Keep track of the start of the last function so we | |
664 | can handle end of function symbols. */ | |
665 | last_function_start = CUR_SYMBOL_VALUE; | |
666 | ||
c5aa993b JM |
667 | /* In reordered executables this function may lie outside |
668 | the bounds created by N_SO symbols. If that's the case | |
669 | use the address of this function as the low bound for | |
670 | the partial symbol table. */ | |
531017df JB |
671 | if (pst |
672 | && (textlow_not_set | |
673 | || (CUR_SYMBOL_VALUE < pst->textlow | |
674 | && (CUR_SYMBOL_VALUE | |
675 | != ANOFFSET (objfile->section_offsets, | |
676 | SECT_OFF_TEXT (objfile)))))) | |
c5aa993b JM |
677 | { |
678 | pst->textlow = CUR_SYMBOL_VALUE; | |
679 | textlow_not_set = 0; | |
680 | } | |
c906108c | 681 | #endif /* DBXREAD_ONLY */ |
c5aa993b JM |
682 | add_psymbol_to_list (namestring, p - namestring, |
683 | VAR_NAMESPACE, LOC_BLOCK, | |
684 | &objfile->global_psymbols, | |
685 | 0, CUR_SYMBOL_VALUE, | |
686 | psymtab_language, objfile); | |
687 | continue; | |
688 | ||
689 | /* Two things show up here (hopefully); static symbols of | |
690 | local scope (static used inside braces) or extensions | |
691 | of structure symbols. We can ignore both. */ | |
692 | case 'V': | |
693 | case '(': | |
694 | case '0': | |
695 | case '1': | |
696 | case '2': | |
697 | case '3': | |
698 | case '4': | |
699 | case '5': | |
700 | case '6': | |
701 | case '7': | |
702 | case '8': | |
703 | case '9': | |
704 | case '-': | |
705 | case '#': /* for symbol identification (used in live ranges) */ | |
706 | /* added to support cfront stabs strings */ | |
707 | case 'Z': /* for definition continuations */ | |
708 | case 'P': /* for prototypes */ | |
709 | continue; | |
710 | ||
711 | case ':': | |
712 | /* It is a C++ nested symbol. We don't need to record it | |
713 | (I don't think); if we try to look up foo::bar::baz, | |
714 | then symbols for the symtab containing foo should get | |
715 | read in, I think. */ | |
716 | /* Someone says sun cc puts out symbols like | |
717 | /foo/baz/maclib::/usr/local/bin/maclib, | |
718 | which would get here with a symbol type of ':'. */ | |
719 | continue; | |
720 | ||
721 | default: | |
722 | /* Unexpected symbol descriptor. The second and subsequent stabs | |
723 | of a continued stab can show up here. The question is | |
724 | whether they ever can mimic a normal stab--it would be | |
725 | nice if not, since we certainly don't want to spend the | |
726 | time searching to the end of every string looking for | |
727 | a backslash. */ | |
728 | ||
729 | complain (&unknown_symchar_complaint, p[1]); | |
730 | ||
731 | /* Ignore it; perhaps it is an extension that we don't | |
732 | know about. */ | |
733 | continue; | |
734 | } | |
735 | ||
736 | case N_EXCL: | |
c906108c SS |
737 | #ifdef DBXREAD_ONLY |
738 | ||
c5aa993b | 739 | SET_NAMESTRING (); |
c906108c | 740 | |
c5aa993b JM |
741 | /* Find the corresponding bincl and mark that psymtab on the |
742 | psymtab dependency list */ | |
743 | { | |
744 | struct partial_symtab *needed_pst = | |
745 | find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE); | |
c906108c | 746 | |
c5aa993b JM |
747 | /* If this include file was defined earlier in this file, |
748 | leave it alone. */ | |
749 | if (needed_pst == pst) | |
750 | continue; | |
c906108c | 751 | |
c5aa993b JM |
752 | if (needed_pst) |
753 | { | |
754 | int i; | |
755 | int found = 0; | |
756 | ||
757 | for (i = 0; i < dependencies_used; i++) | |
758 | if (dependency_list[i] == needed_pst) | |
c906108c | 759 | { |
c5aa993b JM |
760 | found = 1; |
761 | break; | |
762 | } | |
763 | ||
764 | /* If it's already in the list, skip the rest. */ | |
765 | if (found) | |
766 | continue; | |
767 | ||
768 | dependency_list[dependencies_used++] = needed_pst; | |
769 | if (dependencies_used >= dependencies_allocated) | |
770 | { | |
771 | struct partial_symtab **orig = dependency_list; | |
772 | dependency_list = | |
773 | (struct partial_symtab **) | |
774 | alloca ((dependencies_allocated *= 2) | |
775 | * sizeof (struct partial_symtab *)); | |
776 | memcpy ((PTR) dependency_list, (PTR) orig, | |
777 | (dependencies_used | |
778 | * sizeof (struct partial_symtab *))); | |
c906108c | 779 | #ifdef DEBUG_INFO |
c5aa993b JM |
780 | fprintf_unfiltered (gdb_stderr, "Had to reallocate dependency list.\n"); |
781 | fprintf_unfiltered (gdb_stderr, "New dependencies allocated: %d\n", | |
782 | dependencies_allocated); | |
c906108c | 783 | #endif |
c5aa993b JM |
784 | } |
785 | } | |
786 | } | |
c906108c | 787 | #endif /* DBXREAD_ONLY */ |
c5aa993b | 788 | continue; |
c906108c | 789 | |
c5aa993b | 790 | case N_ENDM: |
c906108c | 791 | #ifdef SOFUN_ADDRESS_MAYBE_MISSING |
c5aa993b JM |
792 | /* Solaris 2 end of module, finish current partial symbol table. |
793 | END_PSYMTAB will set pst->texthigh to the proper value, which | |
794 | is necessary if a module compiled without debugging info | |
795 | follows this module. */ | |
796 | if (pst) | |
797 | { | |
798 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
799 | symnum * symbol_size, | |
800 | (CORE_ADDR) 0, | |
801 | dependency_list, dependencies_used, textlow_not_set); | |
802 | pst = (struct partial_symtab *) 0; | |
803 | includes_used = 0; | |
804 | dependencies_used = 0; | |
805 | } | |
c906108c | 806 | #endif |
c5aa993b | 807 | continue; |
c906108c | 808 | |
c5aa993b | 809 | case N_RBRAC: |
c906108c | 810 | #ifdef HANDLE_RBRAC |
c5aa993b JM |
811 | HANDLE_RBRAC (CUR_SYMBOL_VALUE); |
812 | continue; | |
c906108c | 813 | #endif |
c5aa993b JM |
814 | case N_EINCL: |
815 | case N_DSLINE: | |
816 | case N_BSLINE: | |
817 | case N_SSYM: /* Claim: Structure or union element. | |
c906108c | 818 | Hopefully, I can ignore this. */ |
c5aa993b JM |
819 | case N_ENTRY: /* Alternate entry point; can ignore. */ |
820 | case N_MAIN: /* Can definitely ignore this. */ | |
821 | case N_CATCH: /* These are GNU C++ extensions */ | |
822 | case N_EHDECL: /* that can safely be ignored here. */ | |
823 | case N_LENG: | |
824 | case N_BCOMM: | |
825 | case N_ECOMM: | |
826 | case N_ECOML: | |
827 | case N_FNAME: | |
828 | case N_SLINE: | |
829 | case N_RSYM: | |
830 | case N_PSYM: | |
831 | case N_LBRAC: | |
832 | case N_NSYMS: /* Ultrix 4.0: symbol count */ | |
833 | case N_DEFD: /* GNU Modula-2 */ | |
834 | case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ | |
835 | ||
836 | case N_OBJ: /* useless types from Solaris */ | |
837 | case N_OPT: | |
838 | /* These symbols aren't interesting; don't worry about them */ | |
839 | ||
840 | continue; | |
841 | ||
842 | default: | |
843 | /* If we haven't found it yet, ignore it. It's probably some | |
844 | new type we don't know about yet. */ | |
845 | complain (&unknown_symtype_complaint, | |
846 | local_hex_string (CUR_SYMBOL_TYPE)); | |
847 | continue; | |
848 | } |