Commit | Line | Data |
---|---|---|
7e258d18 PB |
1 | /* Shared code to pre-read a stab (dbx-style), when building a psymtab. |
2 | Copyright (C) 1986-1991 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
20 | /* The following need to be defined: | |
21 | SET_NAMESTRING() --Set namestring to name of symbol. | |
22 | CUR_SYMBOL_TYPE --Type code of current symbol. | |
23 | CUR_SYMBOL_VALUE --Value field of current symbol. May be adjusted here. | |
24 | */ | |
25 | ||
7e258d18 PB |
26 | /* End of macro definitions, now let's handle them symbols! */ |
27 | ||
28 | switch (CUR_SYMBOL_TYPE) | |
29 | { | |
30 | char *p; | |
31 | /* | |
32 | * Standard, external, non-debugger, symbols | |
33 | */ | |
34 | ||
7e258d18 PB |
35 | case N_TEXT | N_EXT: |
36 | case N_NBTEXT | N_EXT: | |
37 | case N_NBDATA | N_EXT: | |
38 | case N_NBBSS | N_EXT: | |
39 | case N_SETV | N_EXT: | |
40 | case N_ABS | N_EXT: | |
41 | case N_DATA | N_EXT: | |
42 | case N_BSS | N_EXT: | |
aab77d5f | 43 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
44 | |
45 | CUR_SYMBOL_VALUE += addr; /* Relocate */ | |
46 | ||
47 | SET_NAMESTRING(); | |
48 | ||
49 | bss_ext_symbol: | |
50 | record_misc_function (namestring, CUR_SYMBOL_VALUE, | |
51 | CUR_SYMBOL_TYPE); /* Always */ | |
aab77d5f | 52 | #endif /* DBXREAD_ONLY */ |
7e258d18 PB |
53 | continue; |
54 | ||
55 | /* Standard, local, non-debugger, symbols */ | |
56 | ||
57 | case N_NBTEXT: | |
58 | ||
59 | /* We need to be able to deal with both N_FN or N_TEXT, | |
60 | because we have no way of knowing whether the sys-supplied ld | |
61 | or GNU ld was used to make the executable. Sequents throw | |
62 | in another wrinkle -- they renumbered N_FN. */ | |
63 | ||
64 | case N_FN: | |
65 | case N_FN_SEQ: | |
66 | case N_TEXT: | |
aab77d5f | 67 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
68 | CUR_SYMBOL_VALUE += addr; /* Relocate */ |
69 | SET_NAMESTRING(); | |
70 | if ((namestring[0] == '-' && namestring[1] == 'l') | |
71 | || (namestring [(nsl = strlen (namestring)) - 1] == 'o' | |
72 | && namestring [nsl - 2] == '.')) | |
73 | { | |
74 | if (entry_point < CUR_SYMBOL_VALUE | |
75 | && entry_point >= last_o_file_start | |
76 | && addr == 0) /* FIXME nogood nomore */ | |
77 | { | |
78 | startup_file_start = last_o_file_start; | |
79 | startup_file_end = CUR_SYMBOL_VALUE; | |
80 | } | |
81 | if (past_first_source_file && pst | |
82 | /* The gould NP1 uses low values for .o and -l symbols | |
83 | which are not the address. */ | |
84 | && CUR_SYMBOL_VALUE > pst->textlow) | |
85 | { | |
86 | END_PSYMTAB (pst, psymtab_include_list, includes_used, | |
87 | symnum * symbol_size, CUR_SYMBOL_VALUE, | |
88 | dependency_list, dependencies_used); | |
89 | pst = (struct partial_symtab *) 0; | |
90 | includes_used = 0; | |
91 | dependencies_used = 0; | |
92 | } | |
93 | else | |
94 | past_first_source_file = 1; | |
95 | last_o_file_start = CUR_SYMBOL_VALUE; | |
96 | } | |
aab77d5f | 97 | #endif /* DBXREAD_ONLY */ |
7e258d18 PB |
98 | continue; |
99 | ||
100 | case N_DATA: | |
aab77d5f | 101 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
102 | CUR_SYMBOL_VALUE += addr; /* Relocate */ |
103 | SET_NAMESTRING (); | |
104 | /* Check for __DYNAMIC, which is used by Sun shared libraries. | |
105 | Record it even if it's local, not global, so we can find it. | |
106 | Same with virtual function tables, both global and static. */ | |
107 | if ((namestring[8] == 'C' && (strcmp ("__DYNAMIC", namestring) == 0)) | |
108 | || VTBL_PREFIX_P ((namestring+HASH_OFFSET))) | |
109 | { | |
110 | /* Not really a function here, but... */ | |
111 | record_misc_function (namestring, CUR_SYMBOL_VALUE, | |
112 | CUR_SYMBOL_TYPE); /* Always */ | |
113 | } | |
aab77d5f | 114 | #endif /* DBXREAD_ONLY */ |
7e258d18 PB |
115 | continue; |
116 | ||
117 | case N_UNDF | N_EXT: | |
aab77d5f | 118 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
119 | if (CUR_SYMBOL_VALUE != 0) { |
120 | /* This is a "Fortran COMMON" symbol. See if the target | |
121 | environment knows where it has been relocated to. */ | |
122 | ||
123 | CORE_ADDR reladdr; | |
124 | ||
125 | SET_NAMESTRING(); | |
126 | if (target_lookup_symbol (namestring, &reladdr)) { | |
127 | continue; /* Error in lookup; ignore symbol for now. */ | |
128 | } | |
129 | CUR_SYMBOL_TYPE ^= (N_BSS^N_UNDF); /* Define it as a bss-symbol */ | |
130 | CUR_SYMBOL_VALUE = reladdr; | |
131 | goto bss_ext_symbol; | |
132 | } | |
aab77d5f | 133 | #endif /* DBXREAD_ONLY */ |
7e258d18 | 134 | continue; /* Just undefined, not COMMON */ |
7e258d18 PB |
135 | |
136 | /* Lots of symbol types we can just ignore. */ | |
137 | ||
138 | case N_UNDF: | |
139 | case N_ABS: | |
140 | case N_BSS: | |
141 | case N_NBDATA: | |
142 | case N_NBBSS: | |
143 | continue; | |
144 | ||
145 | /* Keep going . . .*/ | |
146 | ||
147 | /* | |
148 | * Special symbol types for GNU | |
149 | */ | |
150 | case N_INDR: | |
151 | case N_INDR | N_EXT: | |
152 | case N_SETA: | |
153 | case N_SETA | N_EXT: | |
154 | case N_SETT: | |
155 | case N_SETT | N_EXT: | |
156 | case N_SETD: | |
157 | case N_SETD | N_EXT: | |
158 | case N_SETB: | |
159 | case N_SETB | N_EXT: | |
160 | case N_SETV: | |
161 | continue; | |
162 | ||
163 | /* | |
164 | * Debugger symbols | |
165 | */ | |
166 | ||
167 | case N_SO: { | |
168 | unsigned long valu = CUR_SYMBOL_VALUE; | |
169 | /* Symbol number of the first symbol of this file (i.e. the N_SO | |
170 | if there is just one, or the first if we have a pair). */ | |
171 | int first_symnum = symnum; | |
172 | ||
173 | /* End the current partial symtab and start a new one */ | |
174 | ||
175 | SET_NAMESTRING(); | |
176 | ||
7e258d18 PB |
177 | valu += addr; /* Relocate */ |
178 | ||
179 | if (pst && past_first_source_file) | |
180 | { | |
aab77d5f PB |
181 | /* Some compilers (including gcc) emit a pair of initial N_SOs. |
182 | The first one is a directory name; the second the file name. | |
183 | If pst exists, is empty, and has a filename ending in '/', | |
184 | we assume the previous N_SO was a directory name. */ | |
185 | if (global_psymbols.next | |
186 | == (global_psymbols.list + pst->globals_offset) | |
187 | && static_psymbols.next | |
188 | == (static_psymbols.list + pst->statics_offset) | |
189 | && pst->filename && pst->filename[0] | |
190 | && pst->filename[strlen(pst->filename)-1] == '/') { | |
191 | /* Just replace the directory name with the real filename. */ | |
192 | pst->filename = | |
193 | (char *) obstack_alloc (psymbol_obstack, | |
194 | strlen (namestring) + 1); | |
195 | strcpy (pst->filename, namestring); | |
196 | continue; | |
197 | } | |
7e258d18 PB |
198 | END_PSYMTAB (pst, psymtab_include_list, includes_used, |
199 | first_symnum * symbol_size, valu, | |
200 | dependency_list, dependencies_used); | |
201 | pst = (struct partial_symtab *) 0; | |
202 | includes_used = 0; | |
203 | dependencies_used = 0; | |
204 | } | |
205 | else | |
206 | past_first_source_file = 1; | |
207 | ||
208 | pst = START_PSYMTAB (objfile, addr, | |
209 | namestring, valu, | |
210 | first_symnum * symbol_size, | |
211 | global_psymbols.next, static_psymbols.next); | |
212 | continue; | |
213 | } | |
214 | ||
7e258d18 | 215 | case N_BINCL: |
aab77d5f | 216 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
217 | /* Add this bincl to the bincl_list for future EXCLs. No |
218 | need to save the string; it'll be around until | |
219 | read_dbx_symtab function returns */ | |
220 | ||
221 | SET_NAMESTRING(); | |
222 | ||
223 | add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE); | |
224 | ||
225 | /* Mark down an include file in the current psymtab */ | |
226 | ||
227 | psymtab_include_list[includes_used++] = namestring; | |
228 | if (includes_used >= includes_allocated) | |
229 | { | |
230 | char **orig = psymtab_include_list; | |
231 | ||
232 | psymtab_include_list = (char **) | |
233 | alloca ((includes_allocated *= 2) * | |
234 | sizeof (char *)); | |
235 | bcopy (orig, psymtab_include_list, | |
236 | includes_used * sizeof (char *)); | |
237 | } | |
238 | ||
aab77d5f | 239 | #endif /* DBXREAD_ONLY */ |
7e258d18 | 240 | continue; |
7e258d18 PB |
241 | |
242 | case N_SOL: | |
243 | /* Mark down an include file in the current psymtab */ | |
244 | ||
245 | SET_NAMESTRING(); | |
246 | ||
247 | /* In C++, one may expect the same filename to come round many | |
248 | times, when code is coming alternately from the main file | |
249 | and from inline functions in other files. So I check to see | |
250 | if this is a file we've seen before -- either the main | |
251 | source file, or a previously included file. | |
252 | ||
253 | This seems to be a lot of time to be spending on N_SOL, but | |
254 | things like "break c-exp.y:435" need to work (I | |
255 | suppose the psymtab_include_list could be hashed or put | |
256 | in a binary tree, if profiling shows this is a major hog). */ | |
257 | if (pst && !strcmp (namestring, pst->filename)) | |
258 | continue; | |
259 | { | |
260 | register int i; | |
261 | for (i = 0; i < includes_used; i++) | |
262 | if (!strcmp (namestring, psymtab_include_list[i])) | |
263 | { | |
264 | i = -1; | |
265 | break; | |
266 | } | |
267 | if (i == -1) | |
268 | continue; | |
269 | } | |
270 | ||
271 | psymtab_include_list[includes_used++] = namestring; | |
272 | if (includes_used >= includes_allocated) | |
273 | { | |
274 | char **orig = psymtab_include_list; | |
275 | ||
276 | psymtab_include_list = (char **) | |
277 | alloca ((includes_allocated *= 2) * | |
278 | sizeof (char *)); | |
279 | bcopy (orig, psymtab_include_list, | |
280 | includes_used * sizeof (char *)); | |
281 | } | |
282 | continue; | |
aab77d5f | 283 | |
7e258d18 PB |
284 | case N_LSYM: /* Typedef or automatic variable. */ |
285 | case N_STSYM: /* Data seg var -- static */ | |
286 | case N_LCSYM: /* BSS " */ | |
287 | case N_NBSTS: /* Gould nobase. */ | |
288 | case N_NBLCS: /* symbols. */ | |
289 | ||
290 | SET_NAMESTRING(); | |
291 | ||
292 | p = (char *) strchr (namestring, ':'); | |
293 | ||
294 | /* Skip if there is no :. */ | |
295 | if (!p) continue; | |
296 | ||
297 | switch (p[1]) | |
298 | { | |
299 | case 'T': | |
300 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
301 | STRUCT_NAMESPACE, LOC_TYPEDEF, | |
302 | static_psymbols, CUR_SYMBOL_VALUE); | |
303 | if (p[2] == 't') | |
304 | { | |
305 | /* Also a typedef with the same name. */ | |
306 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
307 | VAR_NAMESPACE, LOC_TYPEDEF, | |
308 | static_psymbols, CUR_SYMBOL_VALUE); | |
309 | p += 1; | |
310 | } | |
311 | goto check_enum; | |
312 | case 't': | |
313 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
314 | VAR_NAMESPACE, LOC_TYPEDEF, | |
315 | static_psymbols, CUR_SYMBOL_VALUE); | |
316 | check_enum: | |
7e258d18 PB |
317 | /* If this is an enumerated type, we need to |
318 | add all the enum constants to the partial symbol | |
319 | table. This does not cover enums without names, e.g. | |
320 | "enum {a, b} c;" in C, but fortunately those are | |
321 | rare. There is no way for GDB to find those from the | |
322 | enum type without spending too much time on it. Thus | |
323 | to solve this problem, the compiler needs to put out separate | |
324 | constant symbols ('c' N_LSYMS) for enum constants in | |
325 | enums without names, or put out a dummy type. */ | |
326 | ||
327 | /* We are looking for something of the form | |
328 | <name> ":" ("t" | "T") [<number> "="] "e" | |
329 | {<constant> ":" <value> ","} ";". */ | |
330 | ||
331 | /* Skip over the colon and the 't' or 'T'. */ | |
332 | p += 2; | |
333 | /* This type may be given a number. Also, numbers can come | |
334 | in pairs like (0,26). Skip over it. */ | |
335 | while ((*p >= '0' && *p <= '9') | |
336 | || *p == '(' || *p == ',' || *p == ')' | |
337 | || *p == '=') | |
338 | p++; | |
339 | ||
340 | if (*p++ == 'e') | |
341 | { | |
342 | /* We have found an enumerated type. */ | |
343 | /* According to comments in read_enum_type | |
344 | a comma could end it instead of a semicolon. | |
345 | I don't know where that happens. | |
346 | Accept either. */ | |
347 | while (*p && *p != ';' && *p != ',') | |
348 | { | |
349 | char *q; | |
350 | ||
351 | /* Check for and handle cretinous dbx symbol name | |
352 | continuation! */ | |
353 | if (*p == '\\') | |
354 | p = next_symbol_text (); | |
355 | ||
356 | /* Point to the character after the name | |
357 | of the enum constant. */ | |
358 | for (q = p; *q && *q != ':'; q++) | |
359 | ; | |
360 | /* Note that the value doesn't matter for | |
361 | enum constants in psymtabs, just in symtabs. */ | |
362 | ADD_PSYMBOL_TO_LIST (p, q - p, | |
363 | VAR_NAMESPACE, LOC_CONST, | |
364 | static_psymbols, 0); | |
365 | /* Point past the name. */ | |
366 | p = q; | |
367 | /* Skip over the value. */ | |
368 | while (*p && *p != ',') | |
369 | p++; | |
370 | /* Advance past the comma. */ | |
371 | if (*p) | |
372 | p++; | |
373 | } | |
374 | } | |
7e258d18 PB |
375 | continue; |
376 | case 'c': | |
377 | /* Constant, e.g. from "const" in Pascal. */ | |
378 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
379 | VAR_NAMESPACE, LOC_CONST, | |
380 | static_psymbols, CUR_SYMBOL_VALUE); | |
381 | continue; | |
382 | default: | |
383 | /* Skip if the thing following the : is | |
384 | not a letter (which indicates declaration of a local | |
385 | variable, which we aren't interested in). */ | |
386 | continue; | |
387 | } | |
388 | ||
389 | case N_FUN: | |
390 | case N_GSYM: /* Global (extern) variable; can be | |
391 | data or bss (sigh). */ | |
392 | ||
393 | /* Following may probably be ignored; I'll leave them here | |
394 | for now (until I do Pascal and Modula 2 extensions). */ | |
395 | ||
396 | case N_PC: /* I may or may not need this; I | |
397 | suspect not. */ | |
398 | case N_M2C: /* I suspect that I can ignore this here. */ | |
399 | case N_SCOPE: /* Same. */ | |
400 | ||
401 | SET_NAMESTRING(); | |
402 | ||
403 | p = (char *) strchr (namestring, ':'); | |
404 | if (!p) | |
405 | continue; /* Not a debugging symbol. */ | |
406 | ||
407 | ||
408 | ||
409 | /* Main processing section for debugging symbols which | |
410 | the initial read through the symbol tables needs to worry | |
411 | about. If we reach this point, the symbol which we are | |
412 | considering is definitely one we are interested in. | |
413 | p must also contain the (valid) index into the namestring | |
414 | which indicates the debugging type symbol. */ | |
415 | ||
416 | switch (p[1]) | |
417 | { | |
418 | case 'c': | |
419 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
420 | VAR_NAMESPACE, LOC_CONST, | |
421 | static_psymbols, CUR_SYMBOL_VALUE); | |
422 | continue; | |
423 | case 'S': | |
424 | CUR_SYMBOL_VALUE += addr; /* Relocate */ | |
425 | ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring, | |
426 | VAR_NAMESPACE, LOC_STATIC, | |
427 | static_psymbols, CUR_SYMBOL_VALUE); | |
428 | continue; | |
429 | case 'G': | |
430 | CUR_SYMBOL_VALUE += addr; /* Relocate */ | |
431 | /* The addresses in these entries are reported to be | |
432 | wrong. See the code that reads 'G's for symtabs. */ | |
433 | ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring, | |
434 | VAR_NAMESPACE, LOC_STATIC, | |
435 | global_psymbols, CUR_SYMBOL_VALUE); | |
436 | continue; | |
437 | ||
438 | case 't': | |
439 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
440 | VAR_NAMESPACE, LOC_TYPEDEF, | |
441 | static_psymbols, CUR_SYMBOL_VALUE); | |
442 | continue; | |
443 | ||
444 | case 'f': | |
445 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
446 | VAR_NAMESPACE, LOC_BLOCK, | |
447 | static_psymbols, CUR_SYMBOL_VALUE); | |
448 | continue; | |
449 | ||
450 | /* Global functions were ignored here, but now they | |
451 | are put into the global psymtab like one would expect. | |
452 | They're also in the misc fn vector... | |
453 | FIXME, why did it used to ignore these? That broke | |
454 | "i fun" on these functions. */ | |
455 | case 'F': | |
456 | ADD_PSYMBOL_TO_LIST (namestring, p - namestring, | |
457 | VAR_NAMESPACE, LOC_BLOCK, | |
458 | global_psymbols, CUR_SYMBOL_VALUE); | |
459 | continue; | |
460 | ||
461 | /* Two things show up here (hopefully); static symbols of | |
462 | local scope (static used inside braces) or extensions | |
463 | of structure symbols. We can ignore both. */ | |
464 | case 'V': | |
465 | case '(': | |
466 | case '0': | |
467 | case '1': | |
468 | case '2': | |
469 | case '3': | |
470 | case '4': | |
471 | case '5': | |
472 | case '6': | |
473 | case '7': | |
474 | case '8': | |
475 | case '9': | |
476 | continue; | |
477 | ||
478 | default: | |
479 | /* Unexpected symbol. Ignore it; perhaps it is an extension | |
480 | that we don't know about. | |
481 | ||
482 | Someone says sun cc puts out symbols like | |
483 | /foo/baz/maclib::/usr/local/bin/maclib, | |
484 | which would get here with a symbol type of ':'. */ | |
485 | continue; | |
486 | } | |
487 | ||
7e258d18 | 488 | case N_EXCL: |
aab77d5f | 489 | #ifdef DBXREAD_ONLY |
7e258d18 PB |
490 | |
491 | SET_NAMESTRING(); | |
492 | ||
493 | /* Find the corresponding bincl and mark that psymtab on the | |
494 | psymtab dependency list */ | |
495 | { | |
496 | struct partial_symtab *needed_pst = | |
497 | find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE); | |
498 | ||
499 | /* If this include file was defined earlier in this file, | |
500 | leave it alone. */ | |
501 | if (needed_pst == pst) continue; | |
502 | ||
503 | if (needed_pst) | |
504 | { | |
505 | int i; | |
506 | int found = 0; | |
507 | ||
508 | for (i = 0; i < dependencies_used; i++) | |
509 | if (dependency_list[i] == needed_pst) | |
510 | { | |
511 | found = 1; | |
512 | break; | |
513 | } | |
514 | ||
515 | /* If it's already in the list, skip the rest. */ | |
516 | if (found) continue; | |
517 | ||
518 | dependency_list[dependencies_used++] = needed_pst; | |
519 | if (dependencies_used >= dependencies_allocated) | |
520 | { | |
521 | struct partial_symtab **orig = dependency_list; | |
522 | dependency_list = | |
523 | (struct partial_symtab **) | |
524 | alloca ((dependencies_allocated *= 2) | |
525 | * sizeof (struct partial_symtab *)); | |
526 | bcopy (orig, dependency_list, | |
527 | (dependencies_used | |
528 | * sizeof (struct partial_symtab *))); | |
529 | #ifdef DEBUG_INFO | |
530 | fprintf (stderr, "Had to reallocate dependency list.\n"); | |
531 | fprintf (stderr, "New dependencies allocated: %d\n", | |
532 | dependencies_allocated); | |
533 | #endif | |
534 | } | |
535 | } | |
536 | else | |
537 | error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.", | |
538 | symnum); | |
539 | } | |
aab77d5f | 540 | #endif /* DBXREAD_ONLY */ |
7e258d18 | 541 | continue; |
7e258d18 PB |
542 | |
543 | case N_RBRAC: | |
544 | #ifdef HANDLE_RBRAC | |
545 | HANDLE_RBRAC(CUR_SYMBOL_VALUE); | |
aab77d5f | 546 | continue; |
7e258d18 PB |
547 | #endif |
548 | case N_EINCL: | |
549 | case N_DSLINE: | |
550 | case N_BSLINE: | |
551 | case N_SSYM: /* Claim: Structure or union element. | |
552 | Hopefully, I can ignore this. */ | |
553 | case N_ENTRY: /* Alternate entry point; can ignore. */ | |
554 | case N_MAIN: /* Can definitely ignore this. */ | |
555 | case N_CATCH: /* These are GNU C++ extensions */ | |
556 | case N_EHDECL: /* that can safely be ignored here. */ | |
557 | case N_LENG: | |
558 | case N_BCOMM: | |
559 | case N_ECOMM: | |
560 | case N_ECOML: | |
561 | case N_FNAME: | |
562 | case N_SLINE: | |
563 | case N_RSYM: | |
564 | case N_PSYM: | |
565 | case N_LBRAC: | |
566 | case N_NSYMS: /* Ultrix 4.0: symbol count */ | |
567 | case N_DEFD: /* GNU Modula-2 */ | |
568 | /* These symbols aren't interesting; don't worry about them */ | |
569 | ||
570 | continue; | |
571 | ||
572 | default: | |
7e258d18 PB |
573 | /* If we haven't found it yet, ignore it. It's probably some |
574 | new type we don't know about yet. */ | |
575 | complain (&unknown_symtype_complaint, local_hex_string(CUR_SYMBOL_TYPE)); | |
7e258d18 PB |
576 | continue; |
577 | } |