1 /* Read a symbol table in ECOFF format (Third-Eye). 2 3 Copyright (C) 1986-2013 Free Software Foundation, Inc. 4 5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at 6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor 7 at Cygnus Support. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 23 24 /* This module provides the function mdebug_build_psymtabs. It reads 25 ECOFF debugging information into partial symbol tables. The 26 debugging information is read from two structures. A struct 27 ecoff_debug_swap includes the sizes of each ECOFF structure and 28 swapping routines; these are fixed for a particular target. A 29 struct ecoff_debug_info points to the debugging information for a 30 particular object file. 31 32 ECOFF symbol tables are mostly written in the byte order of the 33 target machine. However, one section of the table (the auxiliary 34 symbol information) is written in the host byte order. There is a 35 bit in the other symbol info which describes which host byte order 36 was used. ECOFF thereby takes the trophy from Intel `b.out' for 37 the most brain-dead adaptation of a file format to byte order. 38 39 This module can read all four of the known byte-order combinations, 40 on any type of host. */ 41 42 #include "defs.h" 43 #include "symtab.h" 44 #include "gdbtypes.h" 45 #include "gdbcore.h" 46 #include "filenames.h" 47 #include "objfiles.h" 48 #include "gdb_obstack.h" 49 #include "buildsym.h" 50 #include "stabsread.h" 51 #include "complaints.h" 52 #include "demangle.h" 53 #include "gdb-demangle.h" 54 #include "gdb_assert.h" 55 #include "block.h" 56 #include "dictionary.h" 57 #include "mdebugread.h" 58 #include "gdb_stat.h" 59 #include "gdb_string.h" 60 #include "psympriv.h" 61 #include "source.h" 62 63 #include "bfd.h" 64 65 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */ 66 67 #include "libaout.h" /* Private BFD a.out information. */ 68 #include "aout/aout64.h" 69 #include "aout/stab_gnu.h" /* STABS information. */ 70 71 #include "expression.h" 72 73 extern void _initialize_mdebugread (void); 74 75 /* Provide a way to test if we have both ECOFF and ELF symbol tables. 76 We use this define in order to know whether we should override a 77 symbol's ECOFF section with its ELF section. This is necessary in 78 case the symbol's ELF section could not be represented in ECOFF. */ 79 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 80 && bfd_get_section_by_name (bfd, ".mdebug") != NULL) 81 82 /* The objfile we are currently reading. */ 83 84 static struct objfile *mdebugread_objfile; 85 86 87 88 /* We put a pointer to this structure in the read_symtab_private field 89 of the psymtab. */ 90 91 struct symloc 92 { 93 /* Index of the FDR that this psymtab represents. */ 94 int fdr_idx; 95 /* The BFD that the psymtab was created from. */ 96 bfd *cur_bfd; 97 const struct ecoff_debug_swap *debug_swap; 98 struct ecoff_debug_info *debug_info; 99 struct mdebug_pending **pending_list; 100 /* Pointer to external symbols for this file. */ 101 EXTR *extern_tab; 102 /* Size of extern_tab. */ 103 int extern_count; 104 enum language pst_language; 105 }; 106 107 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private) 108 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx) 109 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd) 110 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap) 111 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info) 112 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list) 113 114 #define SC_IS_TEXT(sc) ((sc) == scText \ 115 || (sc) == scRConst \ 116 || (sc) == scInit \ 117 || (sc) == scFini) 118 #define SC_IS_DATA(sc) ((sc) == scData \ 119 || (sc) == scSData \ 120 || (sc) == scRData \ 121 || (sc) == scPData \ 122 || (sc) == scXData) 123 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon) 124 #define SC_IS_BSS(sc) ((sc) == scBss) 125 #define SC_IS_SBSS(sc) ((sc) == scSBss) 126 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined) 127 128 /* Various complaints about symbol reading that don't abort the process. */ 129 static void 130 index_complaint (const char *arg1) 131 { 132 complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1); 133 } 134 135 static void 136 unknown_ext_complaint (const char *arg1) 137 { 138 complaint (&symfile_complaints, _("unknown external symbol %s"), arg1); 139 } 140 141 static void 142 basic_type_complaint (int arg1, const char *arg2) 143 { 144 complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"), 145 arg1, arg2); 146 } 147 148 static void 149 bad_tag_guess_complaint (const char *arg1) 150 { 151 complaint (&symfile_complaints, 152 _("guessed tag type of %s incorrectly"), arg1); 153 } 154 155 static void 156 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3) 157 { 158 complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"), 159 arg1, arg2, arg3); 160 } 161 162 static void 163 unexpected_type_code_complaint (const char *arg1) 164 { 165 complaint (&symfile_complaints, _("unexpected type code for %s"), arg1); 166 } 167 168 /* Macros and extra defs. */ 169 170 /* Puns: hard to find whether -g was used and how. */ 171 172 #define MIN_GLEVEL GLEVEL_0 173 #define compare_glevel(a,b) \ 174 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \ 175 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a))) 176 177 /* Things that really are local to this module. */ 178 179 /* Remember what we deduced to be the source language of this psymtab. */ 180 181 static enum language psymtab_language = language_unknown; 182 183 /* Current BFD. */ 184 185 static bfd *cur_bfd; 186 187 /* How to parse debugging information for CUR_BFD. */ 188 189 static const struct ecoff_debug_swap *debug_swap; 190 191 /* Pointers to debugging information for CUR_BFD. */ 192 193 static struct ecoff_debug_info *debug_info; 194 195 /* Pointer to current file decriptor record, and its index. */ 196 197 static FDR *cur_fdr; 198 static int cur_fd; 199 200 /* Index of current symbol. */ 201 202 static int cur_sdx; 203 204 /* Note how much "debuggable" this image is. We would like 205 to see at least one FDR with full symbols. */ 206 207 static int max_gdbinfo; 208 static int max_glevel; 209 210 /* When examining .o files, report on undefined symbols. */ 211 212 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs; 213 214 /* Pseudo symbol to use when putting stabs into the symbol table. */ 215 216 static char stabs_symbol[] = STABS_SYMBOL; 217 218 /* Nonzero if we have seen ecoff debugging info for a file. */ 219 220 static int found_ecoff_debugging_info; 221 222 /* Forward declarations. */ 223 224 static int upgrade_type (int, struct type **, int, union aux_ext *, 225 int, char *); 226 227 static void parse_partial_symbols (struct objfile *); 228 229 static int has_opaque_xref (FDR *, SYMR *); 230 231 static int cross_ref (int, union aux_ext *, struct type **, enum type_code, 232 char **, int, char *); 233 234 static struct symbol *new_symbol (char *); 235 236 static struct type *new_type (char *); 237 238 enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK }; 239 240 static struct block *new_block (enum block_type); 241 242 static struct symtab *new_symtab (const char *, int, struct objfile *); 243 244 static struct linetable *new_linetable (int); 245 246 static struct blockvector *new_bvect (int); 247 248 static struct type *parse_type (int, union aux_ext *, unsigned int, int *, 249 int, char *); 250 251 static struct symbol *mylookup_symbol (char *, struct block *, domain_enum, 252 enum address_class); 253 254 static void sort_blocks (struct symtab *); 255 256 static struct partial_symtab *new_psymtab (char *, struct objfile *); 257 258 static void psymtab_to_symtab_1 (struct objfile *objfile, 259 struct partial_symtab *, const char *); 260 261 static void add_block (struct block *, struct symtab *); 262 263 static void add_symbol (struct symbol *, struct symtab *, struct block *); 264 265 static int add_line (struct linetable *, int, CORE_ADDR, int); 266 267 static struct linetable *shrink_linetable (struct linetable *); 268 269 static void handle_psymbol_enumerators (struct objfile *, FDR *, int, 270 CORE_ADDR); 271 272 static char *mdebug_next_symbol_text (struct objfile *); 273 274 /* Exported procedure: Builds a symtab from the partial symtab SELF. 275 Restores the environment in effect when SELF was created, delegates 276 most of the work to an ancillary procedure, and sorts 277 and reorders the symtab list at the end. SELF is not NULL. */ 278 279 static void 280 mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile) 281 { 282 if (info_verbose) 283 { 284 printf_filtered (_("Reading in symbols for %s..."), self->filename); 285 gdb_flush (gdb_stdout); 286 } 287 288 next_symbol_text_func = mdebug_next_symbol_text; 289 290 psymtab_to_symtab_1 (objfile, self, self->filename); 291 292 /* Match with global symbols. This only needs to be done once, 293 after all of the symtabs and dependencies have been read in. */ 294 scan_file_globals (objfile); 295 296 if (info_verbose) 297 printf_filtered (_("done.\n")); 298 } 299 300 /* File-level interface functions. */ 301 302 /* Find a file descriptor given its index RF relative to a file CF. */ 303 304 static FDR * 305 get_rfd (int cf, int rf) 306 { 307 FDR *fdrs; 308 FDR *f; 309 RFDT rfd; 310 311 fdrs = debug_info->fdr; 312 f = fdrs + cf; 313 /* Object files do not have the RFD table, all refs are absolute. */ 314 if (f->rfdBase == 0) 315 return fdrs + rf; 316 (*debug_swap->swap_rfd_in) (cur_bfd, 317 ((char *) debug_info->external_rfd 318 + ((f->rfdBase + rf) 319 * debug_swap->external_rfd_size)), 320 &rfd); 321 return fdrs + rfd; 322 } 323 324 /* Return a safer print NAME for a file descriptor. */ 325 326 static char * 327 fdr_name (FDR *f) 328 { 329 if (f->rss == -1) 330 return "<stripped file>"; 331 if (f->rss == 0) 332 return "<NFY>"; 333 return debug_info->ss + f->issBase + f->rss; 334 } 335 336 337 /* Read in and parse the symtab of the file OBJFILE. Symbols from 338 different sections are relocated via the SECTION_OFFSETS. */ 339 340 void 341 mdebug_build_psymtabs (struct objfile *objfile, 342 const struct ecoff_debug_swap *swap, 343 struct ecoff_debug_info *info) 344 { 345 cur_bfd = objfile->obfd; 346 debug_swap = swap; 347 debug_info = info; 348 349 stabsread_new_init (); 350 buildsym_new_init (); 351 free_header_files (); 352 init_header_files (); 353 354 /* Make sure all the FDR information is swapped in. */ 355 if (info->fdr == (FDR *) NULL) 356 { 357 char *fdr_src; 358 char *fdr_end; 359 FDR *fdr_ptr; 360 361 info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack, 362 (info->symbolic_header.ifdMax 363 * sizeof (FDR))); 364 fdr_src = info->external_fdr; 365 fdr_end = (fdr_src 366 + info->symbolic_header.ifdMax * swap->external_fdr_size); 367 fdr_ptr = info->fdr; 368 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++) 369 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr); 370 } 371 372 parse_partial_symbols (objfile); 373 374 #if 0 375 /* Check to make sure file was compiled with -g. If not, warn the 376 user of this limitation. */ 377 if (compare_glevel (max_glevel, GLEVEL_2) < 0) 378 { 379 if (max_gdbinfo == 0) 380 printf_unfiltered (_("\n%s not compiled with -g, " 381 "debugging support is limited.\n"), 382 objfile->name); 383 printf_unfiltered (_("You should compile with -g2 or " 384 "-g3 for best debugging support.\n")); 385 gdb_flush (gdb_stdout); 386 } 387 #endif 388 } 389 390 /* Local utilities */ 391 392 /* Map of FDR indexes to partial symtabs. */ 393 394 struct pst_map 395 { 396 struct partial_symtab *pst; /* the psymtab proper */ 397 long n_globals; /* exported globals (external symbols) */ 398 long globals_offset; /* cumulative */ 399 }; 400 401 402 /* Utility stack, used to nest procedures and blocks properly. 403 It is a doubly linked list, to avoid too many alloc/free. 404 Since we might need it quite a few times it is NOT deallocated 405 after use. */ 406 407 static struct parse_stack 408 { 409 struct parse_stack *next, *prev; 410 struct symtab *cur_st; /* Current symtab. */ 411 struct block *cur_block; /* Block in it. */ 412 413 /* What are we parsing. stFile, or stBlock are for files and 414 blocks. stProc or stStaticProc means we have seen the start of a 415 procedure, but not the start of the block within in. When we see 416 the start of that block, we change it to stNil, without pushing a 417 new block, i.e. stNil means both a procedure and a block. */ 418 419 int blocktype; 420 421 struct type *cur_type; /* Type we parse fields for. */ 422 int cur_field; /* Field number in cur_type. */ 423 CORE_ADDR procadr; /* Start addres of this procedure. */ 424 int numargs; /* Its argument count. */ 425 } 426 427 *top_stack; /* Top stack ptr */ 428 429 430 /* Enter a new lexical context. */ 431 432 static void 433 push_parse_stack (void) 434 { 435 struct parse_stack *new; 436 437 /* Reuse frames if possible. */ 438 if (top_stack && top_stack->prev) 439 new = top_stack->prev; 440 else 441 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack)); 442 /* Initialize new frame with previous content. */ 443 if (top_stack) 444 { 445 struct parse_stack *prev = new->prev; 446 447 *new = *top_stack; 448 top_stack->prev = new; 449 new->prev = prev; 450 new->next = top_stack; 451 } 452 top_stack = new; 453 } 454 455 /* Exit a lexical context. */ 456 457 static void 458 pop_parse_stack (void) 459 { 460 if (!top_stack) 461 return; 462 if (top_stack->next) 463 top_stack = top_stack->next; 464 } 465 466 467 /* Cross-references might be to things we haven't looked at 468 yet, e.g. type references. To avoid too many type 469 duplications we keep a quick fixup table, an array 470 of lists of references indexed by file descriptor. */ 471 472 struct mdebug_pending 473 { 474 struct mdebug_pending *next; /* link */ 475 char *s; /* the unswapped symbol */ 476 struct type *t; /* its partial type descriptor */ 477 }; 478 479 480 /* The pending information is kept for an entire object file. We 481 allocate the pending information table when we create the partial 482 symbols, and we store a pointer to the single table in each 483 psymtab. */ 484 485 static struct mdebug_pending **pending_list; 486 487 /* Check whether we already saw symbol SH in file FH. */ 488 489 static struct mdebug_pending * 490 is_pending_symbol (FDR *fh, char *sh) 491 { 492 int f_idx = fh - debug_info->fdr; 493 struct mdebug_pending *p; 494 495 /* Linear search is ok, list is typically no more than 10 deep. */ 496 for (p = pending_list[f_idx]; p; p = p->next) 497 if (p->s == sh) 498 break; 499 return p; 500 } 501 502 /* Add a new symbol SH of type T. */ 503 504 static void 505 add_pending (FDR *fh, char *sh, struct type *t) 506 { 507 int f_idx = fh - debug_info->fdr; 508 struct mdebug_pending *p = is_pending_symbol (fh, sh); 509 510 /* Make sure we do not make duplicates. */ 511 if (!p) 512 { 513 p = ((struct mdebug_pending *) 514 obstack_alloc (&mdebugread_objfile->objfile_obstack, 515 sizeof (struct mdebug_pending))); 516 p->s = sh; 517 p->t = t; 518 p->next = pending_list[f_idx]; 519 pending_list[f_idx] = p; 520 } 521 } 522 523 524 /* Parsing Routines proper. */ 525 526 /* Parse a single symbol. Mostly just make up a GDB symbol for it. 527 For blocks, procedures and types we open a new lexical context. 528 This is basically just a big switch on the symbol's type. Argument 529 AX is the base pointer of aux symbols for this file (fh->iauxBase). 530 EXT_SH points to the unswapped symbol, which is needed for struct, 531 union, etc., types; it is NULL for an EXTR. BIGEND says whether 532 aux symbols are big-endian or little-endian. Return count of 533 SYMR's handled (normally one). */ 534 535 static int 536 mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) 537 { 538 return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); 539 } 540 541 static const struct symbol_register_ops mdebug_register_funcs = { 542 mdebug_reg_to_regnum 543 }; 544 545 static int 546 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, 547 struct section_offsets *section_offsets, struct objfile *objfile) 548 { 549 struct gdbarch *gdbarch = get_objfile_arch (objfile); 550 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 551 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 552 char *name; 553 struct symbol *s; 554 struct block *b; 555 struct mdebug_pending *pend; 556 struct type *t; 557 struct field *f; 558 int count = 1; 559 enum address_class class; 560 TIR tir; 561 long svalue = sh->value; 562 int bitsize; 563 564 if (ext_sh == (char *) NULL) 565 name = debug_info->ssext + sh->iss; 566 else 567 name = debug_info->ss + cur_fdr->issBase + sh->iss; 568 569 switch (sh->sc) 570 { 571 case scText: 572 case scRConst: 573 /* Do not relocate relative values. 574 The value of a stEnd symbol is the displacement from the 575 corresponding start symbol value. 576 The value of a stBlock symbol is the displacement from the 577 procedure address. */ 578 if (sh->st != stEnd && sh->st != stBlock) 579 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 580 break; 581 case scData: 582 case scSData: 583 case scRData: 584 case scPData: 585 case scXData: 586 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); 587 break; 588 case scBss: 589 case scSBss: 590 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile)); 591 break; 592 } 593 594 switch (sh->st) 595 { 596 case stNil: 597 break; 598 599 case stGlobal: /* External symbol, goes into global block. */ 600 class = LOC_STATIC; 601 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), 602 GLOBAL_BLOCK); 603 s = new_symbol (name); 604 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 605 goto data; 606 607 case stStatic: /* Static data, goes into current block. */ 608 class = LOC_STATIC; 609 b = top_stack->cur_block; 610 s = new_symbol (name); 611 if (SC_IS_COMMON (sh->sc)) 612 { 613 /* It is a FORTRAN common block. At least for SGI Fortran the 614 address is not in the symbol; we need to fix it later in 615 scan_file_globals. */ 616 int bucket = hashname (SYMBOL_LINKAGE_NAME (s)); 617 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket]; 618 global_sym_chain[bucket] = s; 619 } 620 else 621 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 622 goto data; 623 624 case stLocal: /* Local variable, goes into current block. */ 625 b = top_stack->cur_block; 626 s = new_symbol (name); 627 SYMBOL_VALUE (s) = svalue; 628 if (sh->sc == scRegister) 629 { 630 class = LOC_REGISTER; 631 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 632 } 633 else 634 class = LOC_LOCAL; 635 636 data: /* Common code for symbols describing data. */ 637 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 638 SYMBOL_CLASS (s) = class; 639 add_symbol (s, top_stack->cur_st, b); 640 641 /* Type could be missing if file is compiled without debugging info. */ 642 if (SC_IS_UNDEF (sh->sc) 643 || sh->sc == scNil || sh->index == indexNil) 644 SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol; 645 else 646 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); 647 /* Value of a data symbol is its memory address. */ 648 break; 649 650 case stParam: /* Arg to procedure, goes into current 651 block. */ 652 max_gdbinfo++; 653 found_ecoff_debugging_info = 1; 654 top_stack->numargs++; 655 656 /* Special GNU C++ name. */ 657 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0) 658 name = "this"; /* FIXME, not alloc'd in obstack. */ 659 s = new_symbol (name); 660 661 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 662 SYMBOL_IS_ARGUMENT (s) = 1; 663 switch (sh->sc) 664 { 665 case scRegister: 666 /* Pass by value in register. */ 667 SYMBOL_CLASS (s) = LOC_REGISTER; 668 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 669 break; 670 case scVar: 671 /* Pass by reference on stack. */ 672 SYMBOL_CLASS (s) = LOC_REF_ARG; 673 break; 674 case scVarRegister: 675 /* Pass by reference in register. */ 676 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR; 677 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 678 break; 679 default: 680 /* Pass by value on stack. */ 681 SYMBOL_CLASS (s) = LOC_ARG; 682 break; 683 } 684 SYMBOL_VALUE (s) = svalue; 685 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); 686 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 687 break; 688 689 case stLabel: /* label, goes into current block. */ 690 s = new_symbol (name); 691 SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */ 692 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused. */ 693 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 694 SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int; 695 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 696 break; 697 698 case stProc: /* Procedure, usually goes into global block. */ 699 case stStaticProc: /* Static procedure, goes into current block. */ 700 /* For stProc symbol records, we need to check the storage class 701 as well, as only (stProc, scText) entries represent "real" 702 procedures - See the Compaq document titled "Object File / 703 Symbol Table Format Specification" for more information. 704 If the storage class is not scText, we discard the whole block 705 of symbol records for this stProc. */ 706 if (sh->st == stProc && sh->sc != scText) 707 { 708 char *ext_tsym = ext_sh; 709 int keep_counting = 1; 710 SYMR tsym; 711 712 while (keep_counting) 713 { 714 ext_tsym += external_sym_size; 715 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 716 count++; 717 switch (tsym.st) 718 { 719 case stParam: 720 break; 721 case stEnd: 722 keep_counting = 0; 723 break; 724 default: 725 complaint (&symfile_complaints, 726 _("unknown symbol type 0x%x"), sh->st); 727 break; 728 } 729 } 730 break; 731 } 732 s = new_symbol (name); 733 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 734 SYMBOL_CLASS (s) = LOC_BLOCK; 735 /* Type of the return value. */ 736 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) 737 t = objfile_type (objfile)->builtin_int; 738 else 739 { 740 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name); 741 if (strcmp (name, "malloc") == 0 742 && TYPE_CODE (t) == TYPE_CODE_VOID) 743 { 744 /* I don't know why, but, at least under Alpha GNU/Linux, 745 when linking against a malloc without debugging 746 symbols, its read as a function returning void---this 747 is bad because it means we cannot call functions with 748 string arguments interactively; i.e., "call 749 printf("howdy\n")" would fail with the error message 750 "program has no memory available". To avoid this, we 751 patch up the type and make it void* 752 instead. (davidm@azstarnet.com). */ 753 t = make_pointer_type (t, NULL); 754 } 755 } 756 b = top_stack->cur_block; 757 if (sh->st == stProc) 758 { 759 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); 760 761 /* The next test should normally be true, but provides a 762 hook for nested functions (which we don't want to make 763 global). */ 764 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) 765 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 766 /* Irix 5 sometimes has duplicate names for the same 767 function. We want to add such names up at the global 768 level, not as a nested function. */ 769 else if (sh->value == top_stack->procadr) 770 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 771 } 772 add_symbol (s, top_stack->cur_st, b); 773 774 /* Make a type for the procedure itself. */ 775 SYMBOL_TYPE (s) = lookup_function_type (t); 776 777 /* All functions in C++ have prototypes. For C we don't have enough 778 information in the debug info. */ 779 if (SYMBOL_LANGUAGE (s) == language_cplus) 780 TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1; 781 782 /* Create and enter a new lexical context. */ 783 b = new_block (FUNCTION_BLOCK); 784 SYMBOL_BLOCK_VALUE (s) = b; 785 BLOCK_FUNCTION (b) = s; 786 BLOCK_START (b) = BLOCK_END (b) = sh->value; 787 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 788 add_block (b, top_stack->cur_st); 789 790 /* Not if we only have partial info. */ 791 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) 792 break; 793 794 push_parse_stack (); 795 top_stack->cur_block = b; 796 top_stack->blocktype = sh->st; 797 top_stack->cur_type = SYMBOL_TYPE (s); 798 top_stack->cur_field = -1; 799 top_stack->procadr = sh->value; 800 top_stack->numargs = 0; 801 break; 802 803 /* Beginning of code for structure, union, and enum definitions. 804 They all share a common set of local variables, defined here. */ 805 { 806 enum type_code type_code; 807 char *ext_tsym; 808 int nfields; 809 long max_value; 810 struct field *f; 811 812 case stStruct: /* Start a block defining a struct type. */ 813 type_code = TYPE_CODE_STRUCT; 814 goto structured_common; 815 816 case stUnion: /* Start a block defining a union type. */ 817 type_code = TYPE_CODE_UNION; 818 goto structured_common; 819 820 case stEnum: /* Start a block defining an enum type. */ 821 type_code = TYPE_CODE_ENUM; 822 goto structured_common; 823 824 case stBlock: /* Either a lexical block, or some type. */ 825 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc)) 826 goto case_stBlock_code; /* Lexical block */ 827 828 type_code = TYPE_CODE_UNDEF; /* We have a type. */ 829 830 /* Common code for handling struct, union, enum, and/or as-yet- 831 unknown-type blocks of info about structured data. `type_code' 832 has been set to the proper TYPE_CODE, if we know it. */ 833 structured_common: 834 found_ecoff_debugging_info = 1; 835 push_parse_stack (); 836 top_stack->blocktype = stBlock; 837 838 /* First count the number of fields and the highest value. */ 839 nfields = 0; 840 max_value = 0; 841 for (ext_tsym = ext_sh + external_sym_size; 842 ; 843 ext_tsym += external_sym_size) 844 { 845 SYMR tsym; 846 847 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 848 849 switch (tsym.st) 850 { 851 case stEnd: 852 /* C++ encodes class types as structures where there the 853 methods are encoded as stProc. The scope of stProc 854 symbols also ends with stEnd, thus creating a risk of 855 taking the wrong stEnd symbol record as the end of 856 the current struct, which would cause GDB to undercount 857 the real number of fields in this struct. To make sure 858 we really reached the right stEnd symbol record, we 859 check the associated name, and match it against the 860 struct name. Since method names are mangled while 861 the class name is not, there is no risk of having a 862 method whose name is identical to the class name 863 (in particular constructor method names are different 864 from the class name). There is therefore no risk that 865 this check stops the count on the StEnd of a method. 866 867 Also, assume that we're really at the end when tsym.iss 868 is 0 (issNull). */ 869 if (tsym.iss == issNull 870 || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss, 871 name) == 0) 872 goto end_of_fields; 873 break; 874 875 case stMember: 876 if (nfields == 0 && type_code == TYPE_CODE_UNDEF) 877 { 878 /* If the type of the member is Nil (or Void), 879 without qualifiers, assume the tag is an 880 enumeration. 881 Alpha cc -migrate enums are recognized by a zero 882 index and a zero symbol value. 883 DU 4.0 cc enums are recognized by a member type of 884 btEnum without qualifiers and a zero symbol value. */ 885 if (tsym.index == indexNil 886 || (tsym.index == 0 && sh->value == 0)) 887 type_code = TYPE_CODE_ENUM; 888 else 889 { 890 (*debug_swap->swap_tir_in) (bigend, 891 &ax[tsym.index].a_ti, 892 &tir); 893 if ((tir.bt == btNil || tir.bt == btVoid 894 || (tir.bt == btEnum && sh->value == 0)) 895 && tir.tq0 == tqNil) 896 type_code = TYPE_CODE_ENUM; 897 } 898 } 899 nfields++; 900 if (tsym.value > max_value) 901 max_value = tsym.value; 902 break; 903 904 case stBlock: 905 case stUnion: 906 case stEnum: 907 case stStruct: 908 { 909 #if 0 910 /* This is a no-op; is it trying to tell us something 911 we should be checking? */ 912 if (tsym.sc == scVariant); /*UNIMPLEMENTED */ 913 #endif 914 if (tsym.index != 0) 915 { 916 /* This is something like a struct within a 917 struct. Skip over the fields of the inner 918 struct. The -1 is because the for loop will 919 increment ext_tsym. */ 920 ext_tsym = ((char *) debug_info->external_sym 921 + ((cur_fdr->isymBase + tsym.index - 1) 922 * external_sym_size)); 923 } 924 } 925 break; 926 927 case stTypedef: 928 /* mips cc puts out a typedef for struct x if it is not yet 929 defined when it encounters 930 struct y { struct x *xp; }; 931 Just ignore it. */ 932 break; 933 934 case stIndirect: 935 /* Irix5 cc puts out a stIndirect for struct x if it is not 936 yet defined when it encounters 937 struct y { struct x *xp; }; 938 Just ignore it. */ 939 break; 940 941 default: 942 complaint (&symfile_complaints, 943 _("declaration block contains " 944 "unhandled symbol type %d"), 945 tsym.st); 946 } 947 } 948 end_of_fields: 949 950 /* In an stBlock, there is no way to distinguish structs, 951 unions, and enums at this point. This is a bug in the 952 original design (that has been fixed with the recent 953 addition of the stStruct, stUnion, and stEnum symbol 954 types.) The way you can tell is if/when you see a variable 955 or field of that type. In that case the variable's type 956 (in the AUX table) says if the type is struct, union, or 957 enum, and points back to the stBlock here. So you can 958 patch the tag kind up later - but only if there actually is 959 a variable or field of that type. 960 961 So until we know for sure, we will guess at this point. 962 The heuristic is: 963 If the first member has index==indexNil or a void type, 964 assume we have an enumeration. 965 Otherwise, if there is more than one member, and all 966 the members have offset 0, assume we have a union. 967 Otherwise, assume we have a struct. 968 969 The heuristic could guess wrong in the case of of an 970 enumeration with no members or a union with one (or zero) 971 members, or when all except the last field of a struct have 972 width zero. These are uncommon and/or illegal situations, 973 and in any case guessing wrong probably doesn't matter 974 much. 975 976 But if we later do find out we were wrong, we fixup the tag 977 kind. Members of an enumeration must be handled 978 differently from struct/union fields, and that is harder to 979 patch up, but luckily we shouldn't need to. (If there are 980 any enumeration members, we can tell for sure it's an enum 981 here.) */ 982 983 if (type_code == TYPE_CODE_UNDEF) 984 { 985 if (nfields > 1 && max_value == 0) 986 type_code = TYPE_CODE_UNION; 987 else 988 type_code = TYPE_CODE_STRUCT; 989 } 990 991 /* Create a new type or use the pending type. */ 992 pend = is_pending_symbol (cur_fdr, ext_sh); 993 if (pend == (struct mdebug_pending *) NULL) 994 { 995 t = new_type (NULL); 996 add_pending (cur_fdr, ext_sh, t); 997 } 998 else 999 t = pend->t; 1000 1001 /* Do not set the tag name if it is a compiler generated tag name 1002 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. 1003 Alpha cc puts out an sh->iss of zero for those. */ 1004 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0') 1005 TYPE_TAG_NAME (t) = NULL; 1006 else 1007 TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack, 1008 name, (char *) NULL); 1009 1010 TYPE_CODE (t) = type_code; 1011 TYPE_LENGTH (t) = sh->value; 1012 TYPE_NFIELDS (t) = nfields; 1013 TYPE_FIELDS (t) = f = ((struct field *) 1014 TYPE_ALLOC (t, 1015 nfields * sizeof (struct field))); 1016 1017 if (type_code == TYPE_CODE_ENUM) 1018 { 1019 int unsigned_enum = 1; 1020 1021 /* This is a non-empty enum. */ 1022 1023 /* DEC c89 has the number of enumerators in the sh.value field, 1024 not the type length, so we have to compensate for that 1025 incompatibility quirk. 1026 This might do the wrong thing for an enum with one or two 1027 enumerators and gcc -gcoff -fshort-enums, but these cases 1028 are hopefully rare enough. 1029 Alpha cc -migrate has a sh.value field of zero, we adjust 1030 that too. */ 1031 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t) 1032 || TYPE_LENGTH (t) == 0) 1033 TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT; 1034 for (ext_tsym = ext_sh + external_sym_size; 1035 ; 1036 ext_tsym += external_sym_size) 1037 { 1038 SYMR tsym; 1039 struct symbol *enum_sym; 1040 1041 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 1042 1043 if (tsym.st != stMember) 1044 break; 1045 1046 SET_FIELD_ENUMVAL (*f, tsym.value); 1047 FIELD_TYPE (*f) = t; 1048 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss; 1049 FIELD_BITSIZE (*f) = 0; 1050 1051 enum_sym = ((struct symbol *) 1052 obstack_alloc (&mdebugread_objfile->objfile_obstack, 1053 sizeof (struct symbol))); 1054 memset (enum_sym, 0, sizeof (struct symbol)); 1055 SYMBOL_SET_LINKAGE_NAME 1056 (enum_sym, 1057 obstack_copy0 (&mdebugread_objfile->objfile_obstack, 1058 f->name, strlen (f->name))); 1059 SYMBOL_CLASS (enum_sym) = LOC_CONST; 1060 SYMBOL_TYPE (enum_sym) = t; 1061 SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN; 1062 SYMBOL_VALUE (enum_sym) = tsym.value; 1063 if (SYMBOL_VALUE (enum_sym) < 0) 1064 unsigned_enum = 0; 1065 add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block); 1066 1067 /* Skip the stMembers that we've handled. */ 1068 count++; 1069 f++; 1070 } 1071 if (unsigned_enum) 1072 TYPE_UNSIGNED (t) = 1; 1073 } 1074 /* Make this the current type. */ 1075 top_stack->cur_type = t; 1076 top_stack->cur_field = 0; 1077 1078 /* Do not create a symbol for alpha cc unnamed structs. */ 1079 if (sh->iss == 0) 1080 break; 1081 1082 /* gcc puts out an empty struct for an opaque struct definitions, 1083 do not create a symbol for it either. */ 1084 if (TYPE_NFIELDS (t) == 0) 1085 { 1086 TYPE_STUB (t) = 1; 1087 break; 1088 } 1089 1090 s = new_symbol (name); 1091 SYMBOL_DOMAIN (s) = STRUCT_DOMAIN; 1092 SYMBOL_CLASS (s) = LOC_TYPEDEF; 1093 SYMBOL_VALUE (s) = 0; 1094 SYMBOL_TYPE (s) = t; 1095 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1096 break; 1097 1098 /* End of local variables shared by struct, union, enum, and 1099 block (as yet unknown struct/union/enum) processing. */ 1100 } 1101 1102 case_stBlock_code: 1103 found_ecoff_debugging_info = 1; 1104 /* Beginnning of (code) block. Value of symbol 1105 is the displacement from procedure start. */ 1106 push_parse_stack (); 1107 1108 /* Do not start a new block if this is the outermost block of a 1109 procedure. This allows the LOC_BLOCK symbol to point to the 1110 block with the local variables, so funcname::var works. */ 1111 if (top_stack->blocktype == stProc 1112 || top_stack->blocktype == stStaticProc) 1113 { 1114 top_stack->blocktype = stNil; 1115 break; 1116 } 1117 1118 top_stack->blocktype = stBlock; 1119 b = new_block (NON_FUNCTION_BLOCK); 1120 BLOCK_START (b) = sh->value + top_stack->procadr; 1121 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 1122 top_stack->cur_block = b; 1123 add_block (b, top_stack->cur_st); 1124 break; 1125 1126 case stEnd: /* end (of anything) */ 1127 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc)) 1128 { 1129 /* Finished with type */ 1130 top_stack->cur_type = 0; 1131 } 1132 else if (sh->sc == scText && 1133 (top_stack->blocktype == stProc || 1134 top_stack->blocktype == stStaticProc)) 1135 { 1136 /* Finished with procedure */ 1137 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); 1138 struct mdebug_extra_func_info *e; 1139 struct block *b = top_stack->cur_block; 1140 struct type *ftype = top_stack->cur_type; 1141 int i; 1142 1143 BLOCK_END (top_stack->cur_block) += sh->value; /* size */ 1144 1145 /* Make up special symbol to contain procedure specific info. */ 1146 s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); 1147 SYMBOL_DOMAIN (s) = LABEL_DOMAIN; 1148 SYMBOL_CLASS (s) = LOC_CONST; 1149 SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void; 1150 e = ((struct mdebug_extra_func_info *) 1151 obstack_alloc (&mdebugread_objfile->objfile_obstack, 1152 sizeof (struct mdebug_extra_func_info))); 1153 memset (e, 0, sizeof (struct mdebug_extra_func_info)); 1154 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; 1155 e->numargs = top_stack->numargs; 1156 e->pdr.framereg = -1; 1157 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1158 1159 /* f77 emits proc-level with address bounds==[0,0], 1160 So look for such child blocks, and patch them. */ 1161 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) 1162 { 1163 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i); 1164 1165 if (BLOCK_SUPERBLOCK (b_bad) == b 1166 && BLOCK_START (b_bad) == top_stack->procadr 1167 && BLOCK_END (b_bad) == top_stack->procadr) 1168 { 1169 BLOCK_START (b_bad) = BLOCK_START (b); 1170 BLOCK_END (b_bad) = BLOCK_END (b); 1171 } 1172 } 1173 1174 if (TYPE_NFIELDS (ftype) <= 0) 1175 { 1176 /* No parameter type information is recorded with the function's 1177 type. Set that from the type of the parameter symbols. */ 1178 int nparams = top_stack->numargs; 1179 int iparams; 1180 struct symbol *sym; 1181 1182 if (nparams > 0) 1183 { 1184 struct block_iterator iter; 1185 1186 TYPE_NFIELDS (ftype) = nparams; 1187 TYPE_FIELDS (ftype) = (struct field *) 1188 TYPE_ALLOC (ftype, nparams * sizeof (struct field)); 1189 1190 iparams = 0; 1191 ALL_BLOCK_SYMBOLS (b, iter, sym) 1192 { 1193 if (iparams == nparams) 1194 break; 1195 1196 if (SYMBOL_IS_ARGUMENT (sym)) 1197 { 1198 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); 1199 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; 1200 iparams++; 1201 } 1202 } 1203 } 1204 } 1205 } 1206 else if (sh->sc == scText && top_stack->blocktype == stBlock) 1207 { 1208 /* End of (code) block. The value of the symbol is the 1209 displacement from the procedure`s start address of the 1210 end of this block. */ 1211 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr; 1212 } 1213 else if (sh->sc == scText && top_stack->blocktype == stNil) 1214 { 1215 /* End of outermost block. Pop parse stack and ignore. The 1216 following stEnd of stProc will take care of the block. */ 1217 ; 1218 } 1219 else if (sh->sc == scText && top_stack->blocktype == stFile) 1220 { 1221 /* End of file. Pop parse stack and ignore. Higher 1222 level code deals with this. */ 1223 ; 1224 } 1225 else 1226 complaint (&symfile_complaints, 1227 _("stEnd with storage class %d not handled"), sh->sc); 1228 1229 pop_parse_stack (); /* Restore previous lexical context. */ 1230 break; 1231 1232 case stMember: /* member of struct or union */ 1233 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++]; 1234 FIELD_NAME (*f) = name; 1235 SET_FIELD_BITPOS (*f, sh->value); 1236 bitsize = 0; 1237 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, 1238 &bitsize, bigend, name); 1239 FIELD_BITSIZE (*f) = bitsize; 1240 break; 1241 1242 case stIndirect: /* forward declaration on Irix5 */ 1243 /* Forward declarations from Irix5 cc are handled by cross_ref, 1244 skip them. */ 1245 break; 1246 1247 case stTypedef: /* type definition */ 1248 found_ecoff_debugging_info = 1; 1249 1250 /* Typedefs for forward declarations and opaque structs from alpha cc 1251 are handled by cross_ref, skip them. */ 1252 if (sh->iss == 0) 1253 break; 1254 1255 /* Parse the type or use the pending type. */ 1256 pend = is_pending_symbol (cur_fdr, ext_sh); 1257 if (pend == (struct mdebug_pending *) NULL) 1258 { 1259 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name); 1260 add_pending (cur_fdr, ext_sh, t); 1261 } 1262 else 1263 t = pend->t; 1264 1265 /* Mips cc puts out a typedef with the name of the struct for forward 1266 declarations. These should not go into the symbol table and 1267 TYPE_NAME should not be set for them. 1268 They can't be distinguished from an intentional typedef to 1269 the same name however: 1270 x.h: 1271 struct x { int ix; int jx; }; 1272 struct xx; 1273 x.c: 1274 typedef struct x x; 1275 struct xx {int ixx; int jxx; }; 1276 generates a cross referencing stTypedef for x and xx. 1277 The user visible effect of this is that the type of a pointer 1278 to struct foo sometimes is given as `foo *' instead of `struct foo *'. 1279 The problem is fixed with alpha cc and Irix5 cc. */ 1280 1281 /* However if the typedef cross references to an opaque aggregate, it 1282 is safe to omit it from the symbol table. */ 1283 1284 if (has_opaque_xref (cur_fdr, sh)) 1285 break; 1286 s = new_symbol (name); 1287 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 1288 SYMBOL_CLASS (s) = LOC_TYPEDEF; 1289 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block; 1290 SYMBOL_TYPE (s) = t; 1291 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1292 1293 /* Incomplete definitions of structs should not get a name. */ 1294 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL 1295 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0 1296 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT 1297 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION))) 1298 { 1299 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR 1300 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC) 1301 { 1302 /* If we are giving a name to a type such as "pointer to 1303 foo" or "function returning foo", we better not set 1304 the TYPE_NAME. If the program contains "typedef char 1305 *caddr_t;", we don't want all variables of type char 1306 * to print as caddr_t. This is not just a 1307 consequence of GDB's type management; CC and GCC (at 1308 least through version 2.4) both output variables of 1309 either type char * or caddr_t with the type 1310 refering to the stTypedef symbol for caddr_t. If a future 1311 compiler cleans this up it GDB is not ready for it 1312 yet, but if it becomes ready we somehow need to 1313 disable this check (without breaking the PCC/GCC2.4 1314 case). 1315 1316 Sigh. 1317 1318 Fortunately, this check seems not to be necessary 1319 for anything except pointers or functions. */ 1320 } 1321 else 1322 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s); 1323 } 1324 break; 1325 1326 case stFile: /* file name */ 1327 push_parse_stack (); 1328 top_stack->blocktype = sh->st; 1329 break; 1330 1331 /* I`ve never seen these for C */ 1332 case stRegReloc: 1333 break; /* register relocation */ 1334 case stForward: 1335 break; /* forwarding address */ 1336 case stConstant: 1337 break; /* constant */ 1338 default: 1339 complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st); 1340 break; 1341 } 1342 1343 return count; 1344 } 1345 1346 /* Basic types. */ 1347 1348 static const struct objfile_data *basic_type_data; 1349 1350 static struct type * 1351 basic_type (int bt, struct objfile *objfile) 1352 { 1353 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1354 struct type **map_bt = objfile_data (objfile, basic_type_data); 1355 struct type *tp; 1356 1357 if (bt >= btMax) 1358 return NULL; 1359 1360 if (!map_bt) 1361 { 1362 map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack, 1363 btMax, struct type *); 1364 set_objfile_data (objfile, basic_type_data, map_bt); 1365 } 1366 1367 if (map_bt[bt]) 1368 return map_bt[bt]; 1369 1370 switch (bt) 1371 { 1372 case btNil: 1373 tp = objfile_type (objfile)->builtin_void; 1374 break; 1375 1376 case btAdr: 1377 tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED, 1378 "adr_32", objfile); 1379 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; 1380 break; 1381 1382 case btChar: 1383 tp = init_type (TYPE_CODE_INT, 1, 0, 1384 "char", objfile); 1385 break; 1386 1387 case btUChar: 1388 tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, 1389 "unsigned char", objfile); 1390 break; 1391 1392 case btShort: 1393 tp = init_type (TYPE_CODE_INT, 2, 0, 1394 "short", objfile); 1395 break; 1396 1397 case btUShort: 1398 tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, 1399 "unsigned short", objfile); 1400 break; 1401 1402 case btInt: 1403 tp = init_type (TYPE_CODE_INT, 4, 0, 1404 "int", objfile); 1405 break; 1406 1407 case btUInt: 1408 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 1409 "unsigned int", objfile); 1410 break; 1411 1412 case btLong: 1413 tp = init_type (TYPE_CODE_INT, 4, 0, 1414 "long", objfile); 1415 break; 1416 1417 case btULong: 1418 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 1419 "unsigned long", objfile); 1420 break; 1421 1422 case btFloat: 1423 tp = init_type (TYPE_CODE_FLT, 1424 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1425 "float", objfile); 1426 break; 1427 1428 case btDouble: 1429 tp = init_type (TYPE_CODE_FLT, 1430 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1431 "double", objfile); 1432 break; 1433 1434 case btComplex: 1435 tp = init_type (TYPE_CODE_COMPLEX, 1436 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1437 "complex", objfile); 1438 TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile); 1439 break; 1440 1441 case btDComplex: 1442 tp = init_type (TYPE_CODE_COMPLEX, 1443 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1444 "double complex", objfile); 1445 TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile); 1446 break; 1447 1448 case btFixedDec: 1449 /* We use TYPE_CODE_INT to print these as integers. Does this do any 1450 good? Would we be better off with TYPE_CODE_ERROR? Should 1451 TYPE_CODE_ERROR print things in hex if it knows the size? */ 1452 tp = init_type (TYPE_CODE_INT, 1453 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1454 "fixed decimal", objfile); 1455 break; 1456 1457 case btFloatDec: 1458 tp = init_type (TYPE_CODE_ERROR, 1459 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1460 "floating decimal", objfile); 1461 break; 1462 1463 case btString: 1464 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING? 1465 FIXME. */ 1466 tp = init_type (TYPE_CODE_STRING, 1, 0, 1467 "string", objfile); 1468 break; 1469 1470 case btVoid: 1471 tp = objfile_type (objfile)->builtin_void; 1472 break; 1473 1474 case btLong64: 1475 tp = init_type (TYPE_CODE_INT, 8, 0, 1476 "long", objfile); 1477 break; 1478 1479 case btULong64: 1480 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1481 "unsigned long", objfile); 1482 break; 1483 1484 case btLongLong64: 1485 tp = init_type (TYPE_CODE_INT, 8, 0, 1486 "long long", objfile); 1487 break; 1488 1489 case btULongLong64: 1490 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1491 "unsigned long long", objfile); 1492 break; 1493 1494 case btAdr64: 1495 tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED, 1496 "adr_64", objfile); 1497 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; 1498 break; 1499 1500 case btInt64: 1501 tp = init_type (TYPE_CODE_INT, 8, 0, 1502 "int", objfile); 1503 break; 1504 1505 case btUInt64: 1506 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1507 "unsigned int", objfile); 1508 break; 1509 1510 default: 1511 tp = NULL; 1512 break; 1513 } 1514 1515 map_bt[bt] = tp; 1516 return tp; 1517 } 1518 1519 /* Parse the type information provided in the raw AX entries for 1520 the symbol SH. Return the bitfield size in BS, in case. 1521 We must byte-swap the AX entries before we use them; BIGEND says whether 1522 they are big-endian or little-endian (from fh->fBigendian). */ 1523 1524 static struct type * 1525 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, 1526 int bigend, char *sym_name) 1527 { 1528 TIR t[1]; 1529 struct type *tp = 0; 1530 enum type_code type_code = TYPE_CODE_UNDEF; 1531 1532 /* Handle undefined types, they have indexNil. */ 1533 if (aux_index == indexNil) 1534 return basic_type (btInt, mdebugread_objfile); 1535 1536 /* Handle corrupt aux indices. */ 1537 if (aux_index >= (debug_info->fdr + fd)->caux) 1538 { 1539 index_complaint (sym_name); 1540 return basic_type (btInt, mdebugread_objfile); 1541 } 1542 ax += aux_index; 1543 1544 /* Use aux as a type information record, map its basic type. */ 1545 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); 1546 tp = basic_type (t->bt, mdebugread_objfile); 1547 if (tp == NULL) 1548 { 1549 /* Cannot use builtin types -- build our own. */ 1550 switch (t->bt) 1551 { 1552 case btStruct: 1553 type_code = TYPE_CODE_STRUCT; 1554 break; 1555 case btUnion: 1556 type_code = TYPE_CODE_UNION; 1557 break; 1558 case btEnum: 1559 type_code = TYPE_CODE_ENUM; 1560 break; 1561 case btRange: 1562 type_code = TYPE_CODE_RANGE; 1563 break; 1564 case btSet: 1565 type_code = TYPE_CODE_SET; 1566 break; 1567 case btIndirect: 1568 /* alpha cc -migrate uses this for typedefs. The true type will 1569 be obtained by crossreferencing below. */ 1570 type_code = TYPE_CODE_ERROR; 1571 break; 1572 case btTypedef: 1573 /* alpha cc uses this for typedefs. The true type will be 1574 obtained by crossreferencing below. */ 1575 type_code = TYPE_CODE_ERROR; 1576 break; 1577 default: 1578 basic_type_complaint (t->bt, sym_name); 1579 return basic_type (btInt, mdebugread_objfile); 1580 } 1581 } 1582 1583 /* Move on to next aux. */ 1584 ax++; 1585 1586 if (t->fBitfield) 1587 { 1588 int width = AUX_GET_WIDTH (bigend, ax); 1589 1590 /* Inhibit core dumps if TIR is corrupted. */ 1591 if (bs == (int *) NULL) 1592 { 1593 /* Alpha cc -migrate encodes char and unsigned char types 1594 as short and unsigned short types with a field width of 8. 1595 Enum types also have a field width which we ignore for now. */ 1596 if (t->bt == btShort && width == 8) 1597 tp = basic_type (btChar, mdebugread_objfile); 1598 else if (t->bt == btUShort && width == 8) 1599 tp = basic_type (btUChar, mdebugread_objfile); 1600 else if (t->bt == btEnum) 1601 ; 1602 else 1603 complaint (&symfile_complaints, 1604 _("can't handle TIR fBitfield for %s"), 1605 sym_name); 1606 } 1607 else 1608 *bs = width; 1609 ax++; 1610 } 1611 1612 /* A btIndirect entry cross references to an aux entry containing 1613 the type. */ 1614 if (t->bt == btIndirect) 1615 { 1616 RNDXR rn[1]; 1617 int rf; 1618 FDR *xref_fh; 1619 int xref_fd; 1620 1621 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn); 1622 ax++; 1623 if (rn->rfd == 0xfff) 1624 { 1625 rf = AUX_GET_ISYM (bigend, ax); 1626 ax++; 1627 } 1628 else 1629 rf = rn->rfd; 1630 1631 if (rf == -1) 1632 { 1633 complaint (&symfile_complaints, 1634 _("unable to cross ref btIndirect for %s"), sym_name); 1635 return basic_type (btInt, mdebugread_objfile); 1636 } 1637 xref_fh = get_rfd (fd, rf); 1638 xref_fd = xref_fh - debug_info->fdr; 1639 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase, 1640 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name); 1641 } 1642 1643 /* All these types really point to some (common) MIPS type 1644 definition, and only the type-qualifiers fully identify 1645 them. We'll make the same effort at sharing. */ 1646 if (t->bt == btStruct || 1647 t->bt == btUnion || 1648 t->bt == btEnum || 1649 1650 /* btSet (I think) implies that the name is a tag name, not a typedef 1651 name. This apparently is a MIPS extension for C sets. */ 1652 t->bt == btSet) 1653 { 1654 char *name; 1655 1656 /* Try to cross reference this type, build new type on failure. */ 1657 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1658 if (tp == (struct type *) NULL) 1659 tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile); 1660 1661 /* DEC c89 produces cross references to qualified aggregate types, 1662 dereference them. */ 1663 while (TYPE_CODE (tp) == TYPE_CODE_PTR 1664 || TYPE_CODE (tp) == TYPE_CODE_ARRAY) 1665 tp = TYPE_TARGET_TYPE (tp); 1666 1667 /* Make sure that TYPE_CODE(tp) has an expected type code. 1668 Any type may be returned from cross_ref if file indirect entries 1669 are corrupted. */ 1670 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT 1671 && TYPE_CODE (tp) != TYPE_CODE_UNION 1672 && TYPE_CODE (tp) != TYPE_CODE_ENUM) 1673 { 1674 unexpected_type_code_complaint (sym_name); 1675 } 1676 else 1677 { 1678 /* Usually, TYPE_CODE(tp) is already type_code. The main 1679 exception is if we guessed wrong re struct/union/enum. 1680 But for struct vs. union a wrong guess is harmless, so 1681 don't complain(). */ 1682 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM 1683 && type_code != TYPE_CODE_ENUM) 1684 || (TYPE_CODE (tp) != TYPE_CODE_ENUM 1685 && type_code == TYPE_CODE_ENUM)) 1686 { 1687 bad_tag_guess_complaint (sym_name); 1688 } 1689 1690 if (TYPE_CODE (tp) != type_code) 1691 { 1692 TYPE_CODE (tp) = type_code; 1693 } 1694 1695 /* Do not set the tag name if it is a compiler generated tag name 1696 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */ 1697 if (name[0] == '.' || name[0] == '\0') 1698 TYPE_TAG_NAME (tp) = NULL; 1699 else if (TYPE_TAG_NAME (tp) == NULL 1700 || strcmp (TYPE_TAG_NAME (tp), name) != 0) 1701 TYPE_TAG_NAME (tp) 1702 = obstack_copy0 (&mdebugread_objfile->objfile_obstack, 1703 name, strlen (name)); 1704 } 1705 } 1706 1707 /* All these types really point to some (common) MIPS type 1708 definition, and only the type-qualifiers fully identify 1709 them. We'll make the same effort at sharing. 1710 FIXME: We are not doing any guessing on range types. */ 1711 if (t->bt == btRange) 1712 { 1713 char *name; 1714 1715 /* Try to cross reference this type, build new type on failure. */ 1716 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1717 if (tp == (struct type *) NULL) 1718 tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile); 1719 1720 /* Make sure that TYPE_CODE(tp) has an expected type code. 1721 Any type may be returned from cross_ref if file indirect entries 1722 are corrupted. */ 1723 if (TYPE_CODE (tp) != TYPE_CODE_RANGE) 1724 { 1725 unexpected_type_code_complaint (sym_name); 1726 } 1727 else 1728 { 1729 /* Usually, TYPE_CODE(tp) is already type_code. The main 1730 exception is if we guessed wrong re struct/union/enum. */ 1731 if (TYPE_CODE (tp) != type_code) 1732 { 1733 bad_tag_guess_complaint (sym_name); 1734 TYPE_CODE (tp) = type_code; 1735 } 1736 if (TYPE_NAME (tp) == NULL 1737 || strcmp (TYPE_NAME (tp), name) != 0) 1738 TYPE_NAME (tp) 1739 = obstack_copy0 (&mdebugread_objfile->objfile_obstack, 1740 name, strlen (name)); 1741 } 1742 } 1743 if (t->bt == btTypedef) 1744 { 1745 char *name; 1746 1747 /* Try to cross reference this type, it should succeed. */ 1748 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1749 if (tp == (struct type *) NULL) 1750 { 1751 complaint (&symfile_complaints, 1752 _("unable to cross ref btTypedef for %s"), sym_name); 1753 tp = basic_type (btInt, mdebugread_objfile); 1754 } 1755 } 1756 1757 /* Deal with range types. */ 1758 if (t->bt == btRange) 1759 { 1760 TYPE_NFIELDS (tp) = 0; 1761 TYPE_RANGE_DATA (tp) = ((struct range_bounds *) 1762 TYPE_ZALLOC (tp, sizeof (struct range_bounds))); 1763 TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax); 1764 ax++; 1765 TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); 1766 ax++; 1767 } 1768 1769 /* Parse all the type qualifiers now. If there are more 1770 than 6 the game will continue in the next aux. */ 1771 1772 while (1) 1773 { 1774 #define PARSE_TQ(tq) \ 1775 if (t->tq != tqNil) \ 1776 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \ 1777 else \ 1778 break; 1779 1780 PARSE_TQ (tq0); 1781 PARSE_TQ (tq1); 1782 PARSE_TQ (tq2); 1783 PARSE_TQ (tq3); 1784 PARSE_TQ (tq4); 1785 PARSE_TQ (tq5); 1786 #undef PARSE_TQ 1787 1788 /* mips cc 2.x and gcc never put out continued aux entries. */ 1789 if (!t->continued) 1790 break; 1791 1792 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); 1793 ax++; 1794 } 1795 1796 /* Complain for illegal continuations due to corrupt aux entries. */ 1797 if (t->continued) 1798 complaint (&symfile_complaints, 1799 _("illegal TIR continued for %s"), sym_name); 1800 1801 return tp; 1802 } 1803 1804 /* Make up a complex type from a basic one. Type is passed by 1805 reference in TPP and side-effected as necessary. The type 1806 qualifier TQ says how to handle the aux symbols at AX for 1807 the symbol SX we are currently analyzing. BIGEND says whether 1808 aux symbols are big-endian or little-endian. 1809 Returns the number of aux symbols we parsed. */ 1810 1811 static int 1812 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, 1813 char *sym_name) 1814 { 1815 int off; 1816 struct type *t; 1817 1818 /* Used in array processing. */ 1819 int rf, id; 1820 FDR *fh; 1821 struct type *range; 1822 struct type *indx; 1823 int lower, upper; 1824 RNDXR rndx; 1825 1826 switch (tq) 1827 { 1828 case tqPtr: 1829 t = lookup_pointer_type (*tpp); 1830 *tpp = t; 1831 return 0; 1832 1833 case tqProc: 1834 t = lookup_function_type (*tpp); 1835 *tpp = t; 1836 return 0; 1837 1838 case tqArray: 1839 off = 0; 1840 1841 /* Determine and record the domain type (type of index). */ 1842 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx); 1843 id = rndx.index; 1844 rf = rndx.rfd; 1845 if (rf == 0xfff) 1846 { 1847 ax++; 1848 rf = AUX_GET_ISYM (bigend, ax); 1849 off++; 1850 } 1851 fh = get_rfd (fd, rf); 1852 1853 indx = parse_type (fh - debug_info->fdr, 1854 debug_info->external_aux + fh->iauxBase, 1855 id, (int *) NULL, bigend, sym_name); 1856 1857 /* The bounds type should be an integer type, but might be anything 1858 else due to corrupt aux entries. */ 1859 if (TYPE_CODE (indx) != TYPE_CODE_INT) 1860 { 1861 complaint (&symfile_complaints, 1862 _("illegal array index type for %s, assuming int"), 1863 sym_name); 1864 indx = objfile_type (mdebugread_objfile)->builtin_int; 1865 } 1866 1867 /* Get the bounds, and create the array type. */ 1868 ax++; 1869 lower = AUX_GET_DNLOW (bigend, ax); 1870 ax++; 1871 upper = AUX_GET_DNHIGH (bigend, ax); 1872 ax++; 1873 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */ 1874 1875 range = create_range_type ((struct type *) NULL, indx, 1876 lower, upper); 1877 1878 t = create_array_type ((struct type *) NULL, *tpp, range); 1879 1880 /* We used to fill in the supplied array element bitsize 1881 here if the TYPE_LENGTH of the target type was zero. 1882 This happens for a `pointer to an array of anonymous structs', 1883 but in this case the array element bitsize is also zero, 1884 so nothing is gained. 1885 And we used to check the TYPE_LENGTH of the target type against 1886 the supplied array element bitsize. 1887 gcc causes a mismatch for `pointer to array of object', 1888 since the sdb directives it uses do not have a way of 1889 specifying the bitsize, but it does no harm (the 1890 TYPE_LENGTH should be correct) and we should be able to 1891 ignore the erroneous bitsize from the auxiliary entry safely. 1892 dbx seems to ignore it too. */ 1893 1894 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */ 1895 if (TYPE_LENGTH (*tpp) == 0) 1896 TYPE_TARGET_STUB (t) = 1; 1897 1898 *tpp = t; 1899 return 4 + off; 1900 1901 case tqVol: 1902 /* Volatile -- currently ignored */ 1903 return 0; 1904 1905 case tqConst: 1906 /* Const -- currently ignored */ 1907 return 0; 1908 1909 default: 1910 complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq); 1911 return 0; 1912 } 1913 } 1914 1915 1916 /* Parse a procedure descriptor record PR. Note that the procedure is 1917 parsed _after_ the local symbols, now we just insert the extra 1918 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has 1919 already been placed in the procedure's main block. Note also that 1920 images that have been partially stripped (ld -x) have been deprived 1921 of local symbols, and we have to cope with them here. FIRST_OFF is 1922 the offset of the first procedure for this FDR; we adjust the 1923 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab 1924 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol 1925 in question, or NULL to use top_stack->cur_block. */ 1926 1927 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *); 1928 1929 static void 1930 parse_procedure (PDR *pr, struct symtab *search_symtab, 1931 struct partial_symtab *pst) 1932 { 1933 struct symbol *s, *i; 1934 struct block *b; 1935 char *sh_name; 1936 1937 /* Simple rule to find files linked "-x". */ 1938 if (cur_fdr->rss == -1) 1939 { 1940 if (pr->isym == -1) 1941 { 1942 /* Static procedure at address pr->adr. Sigh. */ 1943 /* FIXME-32x64. assuming pr->adr fits in long. */ 1944 complaint (&symfile_complaints, 1945 _("can't handle PDR for static proc at 0x%lx"), 1946 (unsigned long) pr->adr); 1947 return; 1948 } 1949 else 1950 { 1951 /* external */ 1952 EXTR she; 1953 1954 (*debug_swap->swap_ext_in) (cur_bfd, 1955 ((char *) debug_info->external_ext 1956 + (pr->isym 1957 * debug_swap->external_ext_size)), 1958 &she); 1959 sh_name = debug_info->ssext + she.asym.iss; 1960 } 1961 } 1962 else 1963 { 1964 /* Full symbols */ 1965 SYMR sh; 1966 1967 (*debug_swap->swap_sym_in) (cur_bfd, 1968 ((char *) debug_info->external_sym 1969 + ((cur_fdr->isymBase + pr->isym) 1970 * debug_swap->external_sym_size)), 1971 &sh); 1972 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss; 1973 } 1974 1975 if (search_symtab != NULL) 1976 { 1977 #if 0 1978 /* This loses both in the case mentioned (want a static, find a global), 1979 but also if we are looking up a non-mangled name which happens to 1980 match the name of a mangled function. */ 1981 /* We have to save the cur_fdr across the call to lookup_symbol. 1982 If the pdr is for a static function and if a global function with 1983 the same name exists, lookup_symbol will eventually read in the symtab 1984 for the global function and clobber cur_fdr. */ 1985 FDR *save_cur_fdr = cur_fdr; 1986 1987 s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0); 1988 cur_fdr = save_cur_fdr; 1989 #else 1990 s = mylookup_symbol 1991 (sh_name, 1992 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK), 1993 VAR_DOMAIN, 1994 LOC_BLOCK); 1995 #endif 1996 } 1997 else 1998 s = mylookup_symbol (sh_name, top_stack->cur_block, 1999 VAR_DOMAIN, LOC_BLOCK); 2000 2001 if (s != 0) 2002 { 2003 b = SYMBOL_BLOCK_VALUE (s); 2004 } 2005 else 2006 { 2007 complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name); 2008 #if 1 2009 return; 2010 #else 2011 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */ 2012 s = new_symbol (sh_name); 2013 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 2014 SYMBOL_CLASS (s) = LOC_BLOCK; 2015 /* Donno its type, hope int is ok. */ 2016 SYMBOL_TYPE (s) 2017 = lookup_function_type (objfile_type (pst->objfile)->builtin_int); 2018 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 2019 /* Won't have symbols for this one. */ 2020 b = new_block (2); 2021 SYMBOL_BLOCK_VALUE (s) = b; 2022 BLOCK_FUNCTION (b) = s; 2023 BLOCK_START (b) = pr->adr; 2024 /* BOUND used to be the end of procedure's text, but the 2025 argument is no longer passed in. */ 2026 BLOCK_END (b) = bound; 2027 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 2028 add_block (b, top_stack->cur_st); 2029 #endif 2030 } 2031 2032 i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST); 2033 2034 if (i) 2035 { 2036 struct mdebug_extra_func_info *e; 2037 2038 e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i); 2039 e->pdr = *pr; 2040 2041 /* GDB expects the absolute function start address for the 2042 procedure descriptor in e->pdr.adr. 2043 As the address in the procedure descriptor is usually relative, 2044 we would have to relocate e->pdr.adr with cur_fdr->adr and 2045 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)). 2046 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute 2047 in shared libraries on some systems, and on other systems 2048 e->pdr.adr is sometimes offset by a bogus value. 2049 To work around these problems, we replace e->pdr.adr with 2050 the start address of the function. */ 2051 e->pdr.adr = BLOCK_START (b); 2052 } 2053 2054 /* It would be reasonable that functions that have been compiled 2055 without debugging info have a btNil type for their return value, 2056 and functions that are void and are compiled with debugging info 2057 have btVoid. 2058 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped 2059 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info' 2060 case right. 2061 The glevel field in cur_fdr could be used to determine the presence 2062 of debugging info, but GCC doesn't always pass the -g switch settings 2063 to the assembler and GAS doesn't set the glevel field from the -g switch 2064 settings. 2065 To work around these problems, the return value type of a TYPE_CODE_VOID 2066 function is adjusted accordingly if no debugging info was found in the 2067 compilation unit. */ 2068 2069 if (processing_gcc_compilation == 0 2070 && found_ecoff_debugging_info == 0 2071 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID) 2072 SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol; 2073 } 2074 2075 /* Parse the external symbol ES. Just call parse_symbol() after 2076 making sure we know where the aux are for it. 2077 BIGEND says whether aux entries are big-endian or little-endian. 2078 2079 This routine clobbers top_stack->cur_block and ->cur_st. */ 2080 2081 static void parse_external (EXTR *, int, struct section_offsets *, 2082 struct objfile *); 2083 2084 static void 2085 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets, 2086 struct objfile *objfile) 2087 { 2088 union aux_ext *ax; 2089 2090 if (es->ifd != ifdNil) 2091 { 2092 cur_fd = es->ifd; 2093 cur_fdr = debug_info->fdr + cur_fd; 2094 ax = debug_info->external_aux + cur_fdr->iauxBase; 2095 } 2096 else 2097 { 2098 cur_fdr = debug_info->fdr; 2099 ax = 0; 2100 } 2101 2102 /* Reading .o files */ 2103 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil) 2104 { 2105 char *what; 2106 switch (es->asym.st) 2107 { 2108 case stNil: 2109 /* These are generated for static symbols in .o files, 2110 ignore them. */ 2111 return; 2112 case stStaticProc: 2113 case stProc: 2114 what = "procedure"; 2115 n_undef_procs++; 2116 break; 2117 case stGlobal: 2118 what = "variable"; 2119 n_undef_vars++; 2120 break; 2121 case stLabel: 2122 what = "label"; 2123 n_undef_labels++; 2124 break; 2125 default: 2126 what = "symbol"; 2127 break; 2128 } 2129 n_undef_symbols++; 2130 /* FIXME: Turn this into a complaint? */ 2131 if (info_verbose) 2132 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"), 2133 what, debug_info->ssext + es->asym.iss, 2134 fdr_name (cur_fdr)); 2135 return; 2136 } 2137 2138 switch (es->asym.st) 2139 { 2140 case stProc: 2141 case stStaticProc: 2142 /* There is no need to parse the external procedure symbols. 2143 If they are from objects compiled without -g, their index will 2144 be indexNil, and the symbol definition from the minimal symbol 2145 is preferrable (yielding a function returning int instead of int). 2146 If the index points to a local procedure symbol, the local 2147 symbol already provides the correct type. 2148 Note that the index of the external procedure symbol points 2149 to the local procedure symbol in the local symbol table, and 2150 _not_ to the auxiliary symbol info. */ 2151 break; 2152 case stGlobal: 2153 case stLabel: 2154 /* Global common symbols are resolved by the runtime loader, 2155 ignore them. */ 2156 if (SC_IS_COMMON (es->asym.sc)) 2157 break; 2158 2159 /* Note that the case of a symbol with indexNil must be handled 2160 anyways by parse_symbol(). */ 2161 parse_symbol (&es->asym, ax, (char *) NULL, 2162 bigend, section_offsets, objfile); 2163 break; 2164 default: 2165 break; 2166 } 2167 } 2168 2169 /* Parse the line number info for file descriptor FH into 2170 GDB's linetable LT. MIPS' encoding requires a little bit 2171 of magic to get things out. Note also that MIPS' line 2172 numbers can go back and forth, apparently we can live 2173 with that and do not need to reorder our linetables. */ 2174 2175 static void parse_lines (FDR *, PDR *, struct linetable *, int, 2176 struct partial_symtab *, CORE_ADDR); 2177 2178 static void 2179 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines, 2180 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr) 2181 { 2182 unsigned char *base; 2183 int j, k; 2184 int delta, count, lineno = 0; 2185 2186 if (fh->cbLine == 0) 2187 return; 2188 2189 /* Scan by procedure descriptors. */ 2190 k = 0; 2191 for (j = 0; j < fh->cpd; j++, pr++) 2192 { 2193 CORE_ADDR l; 2194 CORE_ADDR adr; 2195 unsigned char *halt; 2196 2197 /* No code for this one. */ 2198 if (pr->iline == ilineNil || 2199 pr->lnLow == -1 || pr->lnHigh == -1) 2200 continue; 2201 2202 /* Determine start and end address of compressed line bytes for 2203 this procedure. */ 2204 base = debug_info->line + fh->cbLineOffset; 2205 if (j != (fh->cpd - 1)) 2206 halt = base + pr[1].cbLineOffset; 2207 else 2208 halt = base + fh->cbLine; 2209 base += pr->cbLineOffset; 2210 2211 adr = pst->textlow + pr->adr - lowest_pdr_addr; 2212 2213 l = adr >> 2; /* in words */ 2214 for (lineno = pr->lnLow; base < halt;) 2215 { 2216 count = *base & 0x0f; 2217 delta = *base++ >> 4; 2218 if (delta >= 8) 2219 delta -= 16; 2220 if (delta == -8) 2221 { 2222 delta = (base[0] << 8) | base[1]; 2223 if (delta >= 0x8000) 2224 delta -= 0x10000; 2225 base += 2; 2226 } 2227 lineno += delta; /* first delta is 0 */ 2228 2229 /* Complain if the line table overflows. Could happen 2230 with corrupt binaries. */ 2231 if (lt->nitems >= maxlines) 2232 { 2233 complaint (&symfile_complaints, 2234 _("guessed size of linetable for %s incorrectly"), 2235 fdr_name (fh)); 2236 break; 2237 } 2238 k = add_line (lt, lineno, l, k); 2239 l += count + 1; 2240 } 2241 } 2242 } 2243 2244 static void 2245 function_outside_compilation_unit_complaint (const char *arg1) 2246 { 2247 complaint (&symfile_complaints, 2248 _("function `%s' appears to be defined " 2249 "outside of all compilation units"), 2250 arg1); 2251 } 2252 2253 /* Use the STORAGE_CLASS to compute which section the given symbol 2254 belongs to, and then records this new minimal symbol. */ 2255 2256 static void 2257 record_minimal_symbol (const char *name, const CORE_ADDR address, 2258 enum minimal_symbol_type ms_type, int storage_class, 2259 struct objfile *objfile) 2260 { 2261 int section; 2262 asection *bfd_section; 2263 2264 switch (storage_class) 2265 { 2266 case scText: 2267 section = SECT_OFF_TEXT (objfile); 2268 bfd_section = bfd_get_section_by_name (cur_bfd, ".text"); 2269 break; 2270 case scData: 2271 section = SECT_OFF_DATA (objfile); 2272 bfd_section = bfd_get_section_by_name (cur_bfd, ".data"); 2273 break; 2274 case scBss: 2275 section = SECT_OFF_BSS (objfile); 2276 bfd_section = bfd_get_section_by_name (cur_bfd, ".bss"); 2277 break; 2278 case scSData: 2279 section = get_section_index (objfile, ".sdata"); 2280 bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata"); 2281 break; 2282 case scSBss: 2283 section = get_section_index (objfile, ".sbss"); 2284 bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss"); 2285 break; 2286 case scRData: 2287 section = get_section_index (objfile, ".rdata"); 2288 bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata"); 2289 break; 2290 case scInit: 2291 section = get_section_index (objfile, ".init"); 2292 bfd_section = bfd_get_section_by_name (cur_bfd, ".init"); 2293 break; 2294 case scXData: 2295 section = get_section_index (objfile, ".xdata"); 2296 bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata"); 2297 break; 2298 case scPData: 2299 section = get_section_index (objfile, ".pdata"); 2300 bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata"); 2301 break; 2302 case scFini: 2303 section = get_section_index (objfile, ".fini"); 2304 bfd_section = bfd_get_section_by_name (cur_bfd, ".fini"); 2305 break; 2306 case scRConst: 2307 section = get_section_index (objfile, ".rconst"); 2308 bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst"); 2309 break; 2310 #ifdef scTlsData 2311 case scTlsData: 2312 section = get_section_index (objfile, ".tlsdata"); 2313 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata"); 2314 break; 2315 #endif 2316 #ifdef scTlsBss 2317 case scTlsBss: 2318 section = get_section_index (objfile, ".tlsbss"); 2319 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss"); 2320 break; 2321 #endif 2322 default: 2323 /* This kind of symbol is not associated to a section. */ 2324 section = -1; 2325 bfd_section = NULL; 2326 } 2327 2328 prim_record_minimal_symbol_and_info (name, address, ms_type, 2329 section, bfd_section, objfile); 2330 } 2331 2332 /* Master parsing procedure for first-pass reading of file symbols 2333 into a partial_symtab. */ 2334 2335 static void 2336 parse_partial_symbols (struct objfile *objfile) 2337 { 2338 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2339 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 2340 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size; 2341 const bfd_size_type external_ext_size = debug_swap->external_ext_size; 2342 void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in; 2343 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 2344 void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in; 2345 int f_idx, s_idx; 2346 HDRR *hdr = &debug_info->symbolic_header; 2347 /* Running pointers */ 2348 FDR *fh; 2349 char *ext_out; 2350 char *ext_out_end; 2351 EXTR *ext_block; 2352 EXTR *ext_in; 2353 EXTR *ext_in_end; 2354 SYMR sh; 2355 struct partial_symtab *pst; 2356 int textlow_not_set = 1; 2357 int past_first_source_file = 0; 2358 2359 /* List of current psymtab's include files. */ 2360 const char **psymtab_include_list; 2361 int includes_allocated; 2362 int includes_used; 2363 EXTR *extern_tab; 2364 struct pst_map *fdr_to_pst; 2365 /* Index within current psymtab dependency list. */ 2366 struct partial_symtab **dependency_list; 2367 int dependencies_used, dependencies_allocated; 2368 struct cleanup *old_chain; 2369 char *name; 2370 enum language prev_language; 2371 asection *text_sect; 2372 int relocatable = 0; 2373 2374 /* Irix 5.2 shared libraries have a fh->adr field of zero, but 2375 the shared libraries are prelinked at a high memory address. 2376 We have to adjust the start address of the object file for this case, 2377 by setting it to the start address of the first procedure in the file. 2378 But we should do no adjustments if we are debugging a .o file, where 2379 the text section (and fh->adr) really starts at zero. */ 2380 text_sect = bfd_get_section_by_name (cur_bfd, ".text"); 2381 if (text_sect != NULL 2382 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC)) 2383 relocatable = 1; 2384 2385 extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack, 2386 sizeof (EXTR) * hdr->iextMax); 2387 2388 includes_allocated = 30; 2389 includes_used = 0; 2390 psymtab_include_list = (const char **) alloca (includes_allocated * 2391 sizeof (const char *)); 2392 next_symbol_text_func = mdebug_next_symbol_text; 2393 2394 dependencies_allocated = 30; 2395 dependencies_used = 0; 2396 dependency_list = 2397 (struct partial_symtab **) alloca (dependencies_allocated * 2398 sizeof (struct partial_symtab *)); 2399 2400 set_last_source_file (NULL); 2401 2402 /* 2403 * Big plan: 2404 * 2405 * Only parse the Local and External symbols, and the Relative FDR. 2406 * Fixup enough of the loader symtab to be able to use it. 2407 * Allocate space only for the file's portions we need to 2408 * look at. (XXX) 2409 */ 2410 2411 max_gdbinfo = 0; 2412 max_glevel = MIN_GLEVEL; 2413 2414 /* Allocate the map FDR -> PST. 2415 Minor hack: -O3 images might claim some global data belongs 2416 to FDR -1. We`ll go along with that. */ 2417 fdr_to_pst = (struct pst_map *) 2418 xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst); 2419 old_chain = make_cleanup (xfree, fdr_to_pst); 2420 fdr_to_pst++; 2421 { 2422 struct partial_symtab *pst = new_psymtab ("", objfile); 2423 2424 fdr_to_pst[-1].pst = pst; 2425 FDR_IDX (pst) = -1; 2426 } 2427 2428 /* Allocate the global pending list. */ 2429 pending_list = 2430 ((struct mdebug_pending **) 2431 obstack_alloc (&objfile->objfile_obstack, 2432 hdr->ifdMax * sizeof (struct mdebug_pending *))); 2433 memset (pending_list, 0, 2434 hdr->ifdMax * sizeof (struct mdebug_pending *)); 2435 2436 /* Pass 0 over external syms: swap them in. */ 2437 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR)); 2438 make_cleanup (xfree, ext_block); 2439 2440 ext_out = (char *) debug_info->external_ext; 2441 ext_out_end = ext_out + hdr->iextMax * external_ext_size; 2442 ext_in = ext_block; 2443 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++) 2444 (*swap_ext_in) (cur_bfd, ext_out, ext_in); 2445 2446 /* Pass 1 over external syms: Presize and partition the list. */ 2447 ext_in = ext_block; 2448 ext_in_end = ext_in + hdr->iextMax; 2449 for (; ext_in < ext_in_end; ext_in++) 2450 { 2451 /* See calls to complain below. */ 2452 if (ext_in->ifd >= -1 2453 && ext_in->ifd < hdr->ifdMax 2454 && ext_in->asym.iss >= 0 2455 && ext_in->asym.iss < hdr->issExtMax) 2456 fdr_to_pst[ext_in->ifd].n_globals++; 2457 } 2458 2459 /* Pass 1.5 over files: partition out global symbol space. */ 2460 s_idx = 0; 2461 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++) 2462 { 2463 fdr_to_pst[f_idx].globals_offset = s_idx; 2464 s_idx += fdr_to_pst[f_idx].n_globals; 2465 fdr_to_pst[f_idx].n_globals = 0; 2466 } 2467 2468 /* ECOFF in ELF: 2469 2470 For ECOFF in ELF, we skip the creation of the minimal symbols. 2471 The ECOFF symbols should be a subset of the Elf symbols, and the 2472 section information of the elf symbols will be more accurate. 2473 FIXME! What about Irix 5's native linker? 2474 2475 By default, Elf sections which don't exist in ECOFF 2476 get put in ECOFF's absolute section by the gnu linker. 2477 Since absolute sections don't get relocated, we 2478 end up calculating an address different from that of 2479 the symbol's minimal symbol (created earlier from the 2480 Elf symtab). 2481 2482 To fix this, either : 2483 1) don't create the duplicate symbol 2484 (assumes ECOFF symtab is a subset of the ELF symtab; 2485 assumes no side-effects result from ignoring ECOFF symbol) 2486 2) create it, only if lookup for existing symbol in ELF's minimal 2487 symbols fails 2488 (inefficient; 2489 assumes no side-effects result from ignoring ECOFF symbol) 2490 3) create it, but lookup ELF's minimal symbol and use it's section 2491 during relocation, then modify "uniqify" phase to merge and 2492 eliminate the duplicate symbol 2493 (highly inefficient) 2494 2495 I've implemented #1 here... 2496 Skip the creation of the minimal symbols based on the ECOFF 2497 symbol table. */ 2498 2499 /* Pass 2 over external syms: fill in external symbols. */ 2500 ext_in = ext_block; 2501 ext_in_end = ext_in + hdr->iextMax; 2502 for (; ext_in < ext_in_end; ext_in++) 2503 { 2504 enum minimal_symbol_type ms_type = mst_text; 2505 CORE_ADDR svalue = ext_in->asym.value; 2506 2507 /* The Irix 5 native tools seem to sometimes generate bogus 2508 external symbols. */ 2509 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax) 2510 { 2511 complaint (&symfile_complaints, 2512 _("bad ifd for external symbol: %d (max %ld)"), 2513 ext_in->ifd, hdr->ifdMax); 2514 continue; 2515 } 2516 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax) 2517 { 2518 complaint (&symfile_complaints, 2519 _("bad iss for external symbol: %ld (max %ld)"), 2520 ext_in->asym.iss, hdr->issExtMax); 2521 continue; 2522 } 2523 2524 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset 2525 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in; 2526 2527 2528 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil) 2529 continue; 2530 2531 2532 /* Pass 3 over files, over local syms: fill in static symbols. */ 2533 name = debug_info->ssext + ext_in->asym.iss; 2534 2535 /* Process ECOFF Symbol Types and Storage Classes. */ 2536 switch (ext_in->asym.st) 2537 { 2538 case stProc: 2539 /* Beginnning of Procedure */ 2540 svalue += ANOFFSET (objfile->section_offsets, 2541 SECT_OFF_TEXT (objfile)); 2542 break; 2543 case stStaticProc: 2544 /* Load time only static procs */ 2545 ms_type = mst_file_text; 2546 svalue += ANOFFSET (objfile->section_offsets, 2547 SECT_OFF_TEXT (objfile)); 2548 break; 2549 case stGlobal: 2550 /* External symbol */ 2551 if (SC_IS_COMMON (ext_in->asym.sc)) 2552 { 2553 /* The value of a common symbol is its size, not its address. 2554 Ignore it. */ 2555 continue; 2556 } 2557 else if (SC_IS_DATA (ext_in->asym.sc)) 2558 { 2559 ms_type = mst_data; 2560 svalue += ANOFFSET (objfile->section_offsets, 2561 SECT_OFF_DATA (objfile)); 2562 } 2563 else if (SC_IS_BSS (ext_in->asym.sc)) 2564 { 2565 ms_type = mst_bss; 2566 svalue += ANOFFSET (objfile->section_offsets, 2567 SECT_OFF_BSS (objfile)); 2568 } 2569 else if (SC_IS_SBSS (ext_in->asym.sc)) 2570 { 2571 ms_type = mst_bss; 2572 svalue += ANOFFSET (objfile->section_offsets, 2573 get_section_index (objfile, ".sbss")); 2574 } 2575 else 2576 ms_type = mst_abs; 2577 break; 2578 case stLabel: 2579 /* Label */ 2580 2581 /* On certain platforms, some extra label symbols can be 2582 generated by the linker. One possible usage for this kind 2583 of symbols is to represent the address of the begining of a 2584 given section. For instance, on Tru64 5.1, the address of 2585 the _ftext label is the start address of the .text section. 2586 2587 The storage class of these symbols is usually directly 2588 related to the section to which the symbol refers. For 2589 instance, on Tru64 5.1, the storage class for the _fdata 2590 label is scData, refering to the .data section. 2591 2592 It is actually possible that the section associated to the 2593 storage class of the label does not exist. On True64 5.1 2594 for instance, the libm.so shared library does not contain 2595 any .data section, although it contains a _fpdata label 2596 which storage class is scData... Since these symbols are 2597 usually useless for the debugger user anyway, we just 2598 discard these symbols. */ 2599 2600 if (SC_IS_TEXT (ext_in->asym.sc)) 2601 { 2602 if (objfile->sect_index_text == -1) 2603 continue; 2604 2605 ms_type = mst_file_text; 2606 svalue += ANOFFSET (objfile->section_offsets, 2607 SECT_OFF_TEXT (objfile)); 2608 } 2609 else if (SC_IS_DATA (ext_in->asym.sc)) 2610 { 2611 if (objfile->sect_index_data == -1) 2612 continue; 2613 2614 ms_type = mst_file_data; 2615 svalue += ANOFFSET (objfile->section_offsets, 2616 SECT_OFF_DATA (objfile)); 2617 } 2618 else if (SC_IS_BSS (ext_in->asym.sc)) 2619 { 2620 if (objfile->sect_index_bss == -1) 2621 continue; 2622 2623 ms_type = mst_file_bss; 2624 svalue += ANOFFSET (objfile->section_offsets, 2625 SECT_OFF_BSS (objfile)); 2626 } 2627 else if (SC_IS_SBSS (ext_in->asym.sc)) 2628 { 2629 const int sbss_sect_index = get_section_index (objfile, ".sbss"); 2630 2631 if (sbss_sect_index == -1) 2632 continue; 2633 2634 ms_type = mst_file_bss; 2635 svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index); 2636 } 2637 else 2638 ms_type = mst_abs; 2639 break; 2640 case stLocal: 2641 case stNil: 2642 /* The alpha has the section start addresses in stLocal symbols 2643 whose name starts with a `.'. Skip those but complain for all 2644 other stLocal symbols. 2645 Irix6 puts the section start addresses in stNil symbols, skip 2646 those too. */ 2647 if (name[0] == '.') 2648 continue; 2649 /* Fall through. */ 2650 default: 2651 ms_type = mst_unknown; 2652 unknown_ext_complaint (name); 2653 } 2654 if (!ECOFF_IN_ELF (cur_bfd)) 2655 record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc, 2656 objfile); 2657 } 2658 2659 /* Pass 3 over files, over local syms: fill in static symbols. */ 2660 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) 2661 { 2662 struct partial_symtab *save_pst; 2663 EXTR *ext_ptr; 2664 CORE_ADDR textlow; 2665 2666 cur_fdr = fh = debug_info->fdr + f_idx; 2667 2668 if (fh->csym == 0) 2669 { 2670 fdr_to_pst[f_idx].pst = NULL; 2671 continue; 2672 } 2673 2674 /* Determine the start address for this object file from the 2675 file header and relocate it, except for Irix 5.2 zero fh->adr. */ 2676 if (fh->cpd) 2677 { 2678 textlow = fh->adr; 2679 if (relocatable || textlow != 0) 2680 textlow += ANOFFSET (objfile->section_offsets, 2681 SECT_OFF_TEXT (objfile)); 2682 } 2683 else 2684 textlow = 0; 2685 pst = start_psymtab_common (objfile, objfile->section_offsets, 2686 fdr_name (fh), 2687 textlow, 2688 objfile->global_psymbols.next, 2689 objfile->static_psymbols.next); 2690 pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, 2691 sizeof (struct symloc)); 2692 memset (pst->read_symtab_private, 0, sizeof (struct symloc)); 2693 2694 save_pst = pst; 2695 FDR_IDX (pst) = f_idx; 2696 CUR_BFD (pst) = cur_bfd; 2697 DEBUG_SWAP (pst) = debug_swap; 2698 DEBUG_INFO (pst) = debug_info; 2699 PENDING_LIST (pst) = pending_list; 2700 2701 /* The way to turn this into a symtab is to call... */ 2702 pst->read_symtab = mdebug_read_symtab; 2703 2704 /* Set up language for the pst. 2705 The language from the FDR is used if it is unambigious (e.g. cfront 2706 with native cc and g++ will set the language to C). 2707 Otherwise we have to deduce the language from the filename. 2708 Native ecoff has every header file in a separate FDR, so 2709 deduce_language_from_filename will return language_unknown for 2710 a header file, which is not what we want. 2711 But the FDRs for the header files are after the FDR for the source 2712 file, so we can assign the language of the source file to the 2713 following header files. Then we save the language in the private 2714 pst data so that we can reuse it when building symtabs. */ 2715 prev_language = psymtab_language; 2716 2717 switch (fh->lang) 2718 { 2719 case langCplusplusV2: 2720 psymtab_language = language_cplus; 2721 break; 2722 default: 2723 psymtab_language = deduce_language_from_filename (fdr_name (fh)); 2724 break; 2725 } 2726 if (psymtab_language == language_unknown) 2727 psymtab_language = prev_language; 2728 PST_PRIVATE (pst)->pst_language = psymtab_language; 2729 2730 pst->texthigh = pst->textlow; 2731 2732 /* For stabs-in-ecoff files, the second symbol must be @stab. 2733 This symbol is emitted by mips-tfile to signal that the 2734 current object file uses encapsulated stabs instead of mips 2735 ecoff for local symbols. (It is the second symbol because 2736 the first symbol is the stFile used to signal the start of a 2737 file). */ 2738 processing_gcc_compilation = 0; 2739 if (fh->csym >= 2) 2740 { 2741 (*swap_sym_in) (cur_bfd, 2742 ((char *) debug_info->external_sym 2743 + (fh->isymBase + 1) * external_sym_size), 2744 &sh); 2745 if (strcmp (debug_info->ss + fh->issBase + sh.iss, 2746 stabs_symbol) == 0) 2747 processing_gcc_compilation = 2; 2748 } 2749 2750 if (processing_gcc_compilation != 0) 2751 { 2752 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++) 2753 { 2754 int type_code; 2755 const char *namestring; 2756 2757 (*swap_sym_in) (cur_bfd, 2758 (((char *) debug_info->external_sym) 2759 + (fh->isymBase + cur_sdx) * external_sym_size), 2760 &sh); 2761 type_code = ECOFF_UNMARK_STAB (sh.index); 2762 if (!ECOFF_IS_STAB (&sh)) 2763 { 2764 if (sh.st == stProc || sh.st == stStaticProc) 2765 { 2766 CORE_ADDR procaddr; 2767 long isym; 2768 2769 sh.value += ANOFFSET (objfile->section_offsets, 2770 SECT_OFF_TEXT (objfile)); 2771 if (sh.st == stStaticProc) 2772 { 2773 namestring = debug_info->ss + fh->issBase + sh.iss; 2774 record_minimal_symbol (namestring, sh.value, 2775 mst_file_text, sh.sc, 2776 objfile); 2777 } 2778 procaddr = sh.value; 2779 2780 isym = AUX_GET_ISYM (fh->fBigendian, 2781 (debug_info->external_aux 2782 + fh->iauxBase 2783 + sh.index)); 2784 (*swap_sym_in) (cur_bfd, 2785 ((char *) debug_info->external_sym 2786 + ((fh->isymBase + isym - 1) 2787 * external_sym_size)), 2788 &sh); 2789 if (sh.st == stEnd) 2790 { 2791 CORE_ADDR high = procaddr + sh.value; 2792 2793 /* Kludge for Irix 5.2 zero fh->adr. */ 2794 if (!relocatable 2795 && (pst->textlow == 0 || procaddr < pst->textlow)) 2796 pst->textlow = procaddr; 2797 if (high > pst->texthigh) 2798 pst->texthigh = high; 2799 } 2800 } 2801 else if (sh.st == stStatic) 2802 { 2803 switch (sh.sc) 2804 { 2805 case scUndefined: 2806 case scSUndefined: 2807 case scNil: 2808 case scAbs: 2809 break; 2810 2811 case scData: 2812 case scSData: 2813 case scRData: 2814 case scPData: 2815 case scXData: 2816 namestring = debug_info->ss + fh->issBase + sh.iss; 2817 sh.value += ANOFFSET (objfile->section_offsets, 2818 SECT_OFF_DATA (objfile)); 2819 record_minimal_symbol (namestring, sh.value, 2820 mst_file_data, sh.sc, 2821 objfile); 2822 break; 2823 2824 default: 2825 /* FIXME! Shouldn't this use cases for bss, 2826 then have the default be abs? */ 2827 namestring = debug_info->ss + fh->issBase + sh.iss; 2828 sh.value += ANOFFSET (objfile->section_offsets, 2829 SECT_OFF_BSS (objfile)); 2830 record_minimal_symbol (namestring, sh.value, 2831 mst_file_bss, sh.sc, 2832 objfile); 2833 break; 2834 } 2835 } 2836 continue; 2837 } 2838 /* Handle stabs continuation. */ 2839 { 2840 char *stabstring = debug_info->ss + fh->issBase + sh.iss; 2841 int len = strlen (stabstring); 2842 2843 while (stabstring[len - 1] == '\\') 2844 { 2845 SYMR sh2; 2846 char *stabstring1 = stabstring; 2847 char *stabstring2; 2848 int len2; 2849 2850 /* Ignore continuation char from 1st string. */ 2851 len--; 2852 2853 /* Read next stabstring. */ 2854 cur_sdx++; 2855 (*swap_sym_in) (cur_bfd, 2856 (((char *) debug_info->external_sym) 2857 + (fh->isymBase + cur_sdx) 2858 * external_sym_size), 2859 &sh2); 2860 stabstring2 = debug_info->ss + fh->issBase + sh2.iss; 2861 len2 = strlen (stabstring2); 2862 2863 /* Concatinate stabstring2 with stabstring1. */ 2864 if (stabstring 2865 && stabstring != debug_info->ss + fh->issBase + sh.iss) 2866 stabstring = xrealloc (stabstring, len + len2 + 1); 2867 else 2868 { 2869 stabstring = xmalloc (len + len2 + 1); 2870 strcpy (stabstring, stabstring1); 2871 } 2872 strcpy (stabstring + len, stabstring2); 2873 len += len2; 2874 } 2875 2876 switch (type_code) 2877 { 2878 char *p; 2879 2880 /* Standard, external, non-debugger, symbols. */ 2881 2882 case N_TEXT | N_EXT: 2883 case N_NBTEXT | N_EXT: 2884 sh.value += ANOFFSET (objfile->section_offsets, 2885 SECT_OFF_TEXT (objfile)); 2886 goto record_it; 2887 2888 case N_DATA | N_EXT: 2889 case N_NBDATA | N_EXT: 2890 sh.value += ANOFFSET (objfile->section_offsets, 2891 SECT_OFF_DATA (objfile)); 2892 goto record_it; 2893 2894 case N_BSS: 2895 case N_BSS | N_EXT: 2896 case N_NBBSS | N_EXT: 2897 case N_SETV | N_EXT: /* FIXME, is this in BSS? */ 2898 sh.value += ANOFFSET (objfile->section_offsets, 2899 SECT_OFF_BSS (objfile)); 2900 goto record_it; 2901 2902 case N_ABS | N_EXT: 2903 record_it: 2904 continue; 2905 2906 /* Standard, local, non-debugger, symbols. */ 2907 2908 case N_NBTEXT: 2909 2910 /* We need to be able to deal with both N_FN or 2911 N_TEXT, because we have no way of knowing 2912 whether the sys-supplied ld or GNU ld was used 2913 to make the executable. Sequents throw in 2914 another wrinkle -- they renumbered N_FN. */ 2915 2916 case N_FN: 2917 case N_FN_SEQ: 2918 case N_TEXT: 2919 continue; 2920 2921 case N_DATA: 2922 sh.value += ANOFFSET (objfile->section_offsets, 2923 SECT_OFF_DATA (objfile)); 2924 goto record_it; 2925 2926 case N_UNDF | N_EXT: 2927 continue; /* Just undefined, not COMMON. */ 2928 2929 case N_UNDF: 2930 continue; 2931 2932 /* Lots of symbol types we can just ignore. */ 2933 2934 case N_ABS: 2935 case N_NBDATA: 2936 case N_NBBSS: 2937 continue; 2938 2939 /* Keep going . . . */ 2940 2941 /* 2942 * Special symbol types for GNU 2943 */ 2944 case N_INDR: 2945 case N_INDR | N_EXT: 2946 case N_SETA: 2947 case N_SETA | N_EXT: 2948 case N_SETT: 2949 case N_SETT | N_EXT: 2950 case N_SETD: 2951 case N_SETD | N_EXT: 2952 case N_SETB: 2953 case N_SETB | N_EXT: 2954 case N_SETV: 2955 continue; 2956 2957 /* 2958 * Debugger symbols 2959 */ 2960 2961 case N_SO: 2962 { 2963 CORE_ADDR valu; 2964 static int prev_so_symnum = -10; 2965 static int first_so_symnum; 2966 const char *p; 2967 int prev_textlow_not_set; 2968 2969 valu = sh.value + ANOFFSET (objfile->section_offsets, 2970 SECT_OFF_TEXT (objfile)); 2971 2972 prev_textlow_not_set = textlow_not_set; 2973 2974 /* A zero value is probably an indication for the 2975 SunPRO 3.0 compiler. end_psymtab explicitly tests 2976 for zero, so don't relocate it. */ 2977 2978 if (sh.value == 0 2979 && gdbarch_sofun_address_maybe_missing (gdbarch)) 2980 { 2981 textlow_not_set = 1; 2982 valu = 0; 2983 } 2984 else 2985 textlow_not_set = 0; 2986 2987 past_first_source_file = 1; 2988 2989 if (prev_so_symnum != symnum - 1) 2990 { /* Here if prev stab wasn't N_SO. */ 2991 first_so_symnum = symnum; 2992 2993 if (pst) 2994 { 2995 pst = (struct partial_symtab *) 0; 2996 includes_used = 0; 2997 dependencies_used = 0; 2998 } 2999 } 3000 3001 prev_so_symnum = symnum; 3002 3003 /* End the current partial symtab and start a 3004 new one. */ 3005 3006 /* SET_NAMESTRING ();*/ 3007 namestring = stabstring; 3008 3009 /* Null name means end of .o file. Don't start a new 3010 one. */ 3011 if (*namestring == '\000') 3012 continue; 3013 3014 /* Some compilers (including gcc) emit a pair of 3015 initial N_SOs. The first one is a directory name; 3016 the second the file name. If pst exists, is 3017 empty, and has a filename ending in '/', we assume 3018 the previous N_SO was a directory name. */ 3019 p = lbasename (namestring); 3020 if (p != namestring && *p == '\000') 3021 continue; /* Simply ignore directory 3022 name SOs. */ 3023 3024 /* Some other compilers (C++ ones in particular) emit 3025 useless SOs for non-existant .c files. We ignore 3026 all subsequent SOs that immediately follow the 3027 first. */ 3028 3029 if (!pst) 3030 pst = save_pst; 3031 continue; 3032 } 3033 3034 case N_BINCL: 3035 continue; 3036 3037 case N_SOL: 3038 { 3039 enum language tmp_language; 3040 3041 /* Mark down an include file in the current psymtab. */ 3042 3043 /* SET_NAMESTRING (); */ 3044 namestring = stabstring; 3045 3046 tmp_language 3047 = deduce_language_from_filename (namestring); 3048 3049 /* Only change the psymtab's language if we've 3050 learned something useful (eg. tmp_language is not 3051 language_unknown). In addition, to match what 3052 start_subfile does, never change from C++ to 3053 C. */ 3054 if (tmp_language != language_unknown 3055 && (tmp_language != language_c 3056 || psymtab_language != language_cplus)) 3057 psymtab_language = tmp_language; 3058 3059 /* In C++, one may expect the same filename to come 3060 round many times, when code is coming alternately 3061 from the main file and from inline functions in 3062 other files. So I check to see if this is a file 3063 we've seen before -- either the main source file, 3064 or a previously included file. 3065 3066 This seems to be a lot of time to be spending on 3067 N_SOL, but things like "break c-exp.y:435" need to 3068 work (I suppose the psymtab_include_list could be 3069 hashed or put in a binary tree, if profiling shows 3070 this is a major hog). */ 3071 if (pst && filename_cmp (namestring, pst->filename) == 0) 3072 continue; 3073 3074 { 3075 int i; 3076 3077 for (i = 0; i < includes_used; i++) 3078 if (filename_cmp (namestring, 3079 psymtab_include_list[i]) == 0) 3080 { 3081 i = -1; 3082 break; 3083 } 3084 if (i == -1) 3085 continue; 3086 } 3087 3088 psymtab_include_list[includes_used++] = namestring; 3089 if (includes_used >= includes_allocated) 3090 { 3091 const char **orig = psymtab_include_list; 3092 3093 psymtab_include_list = (const char **) 3094 alloca ((includes_allocated *= 2) * 3095 sizeof (const char *)); 3096 memcpy (psymtab_include_list, orig, 3097 includes_used * sizeof (const char *)); 3098 } 3099 continue; 3100 } 3101 case N_LSYM: /* Typedef or automatic variable. */ 3102 case N_STSYM: /* Data seg var -- static */ 3103 case N_LCSYM: /* BSS " */ 3104 case N_ROSYM: /* Read-only data seg var -- static. */ 3105 case N_NBSTS: /* Gould nobase. */ 3106 case N_NBLCS: /* symbols. */ 3107 case N_FUN: 3108 case N_GSYM: /* Global (extern) variable; can be 3109 data or bss (sigh FIXME). */ 3110 3111 /* Following may probably be ignored; I'll leave them here 3112 for now (until I do Pascal and Modula 2 extensions). */ 3113 3114 case N_PC: /* I may or may not need this; I 3115 suspect not. */ 3116 case N_M2C: /* I suspect that I can ignore this 3117 here. */ 3118 case N_SCOPE: /* Same. */ 3119 3120 /* SET_NAMESTRING (); */ 3121 namestring = stabstring; 3122 p = (char *) strchr (namestring, ':'); 3123 if (!p) 3124 continue; /* Not a debugging symbol. */ 3125 3126 3127 3128 /* Main processing section for debugging symbols which 3129 the initial read through the symbol tables needs to 3130 worry about. If we reach this point, the symbol 3131 which we are considering is definitely one we are 3132 interested in. p must also contain the (valid) 3133 index into the namestring which indicates the 3134 debugging type symbol. */ 3135 3136 switch (p[1]) 3137 { 3138 case 'S': 3139 sh.value += ANOFFSET (objfile->section_offsets, 3140 SECT_OFF_DATA (objfile)); 3141 3142 if (gdbarch_static_transform_name_p (gdbarch)) 3143 namestring = gdbarch_static_transform_name 3144 (gdbarch, namestring); 3145 3146 add_psymbol_to_list (namestring, p - namestring, 1, 3147 VAR_DOMAIN, LOC_STATIC, 3148 &objfile->static_psymbols, 3149 0, sh.value, 3150 psymtab_language, objfile); 3151 continue; 3152 case 'G': 3153 sh.value += ANOFFSET (objfile->section_offsets, 3154 SECT_OFF_DATA (objfile)); 3155 /* The addresses in these entries are reported 3156 to be wrong. See the code that reads 'G's 3157 for symtabs. */ 3158 add_psymbol_to_list (namestring, p - namestring, 1, 3159 VAR_DOMAIN, LOC_STATIC, 3160 &objfile->global_psymbols, 3161 0, sh.value, 3162 psymtab_language, objfile); 3163 continue; 3164 3165 case 'T': 3166 /* When a 'T' entry is defining an anonymous enum, it 3167 may have a name which is the empty string, or a 3168 single space. Since they're not really defining a 3169 symbol, those shouldn't go in the partial symbol 3170 table. We do pick up the elements of such enums at 3171 'check_enum:', below. */ 3172 if (p >= namestring + 2 3173 || (p == namestring + 1 3174 && namestring[0] != ' ')) 3175 { 3176 add_psymbol_to_list (namestring, p - namestring, 1, 3177 STRUCT_DOMAIN, LOC_TYPEDEF, 3178 &objfile->static_psymbols, 3179 sh.value, 0, 3180 psymtab_language, objfile); 3181 if (p[2] == 't') 3182 { 3183 /* Also a typedef with the same name. */ 3184 add_psymbol_to_list (namestring, 3185 p - namestring, 1, 3186 VAR_DOMAIN, LOC_TYPEDEF, 3187 &objfile->static_psymbols, 3188 sh.value, 0, 3189 psymtab_language, 3190 objfile); 3191 p += 1; 3192 } 3193 } 3194 goto check_enum; 3195 case 't': 3196 if (p != namestring) /* a name is there, not 3197 just :T... */ 3198 { 3199 add_psymbol_to_list (namestring, p - namestring, 1, 3200 VAR_DOMAIN, LOC_TYPEDEF, 3201 &objfile->static_psymbols, 3202 sh.value, 0, 3203 psymtab_language, objfile); 3204 } 3205 check_enum: 3206 /* If this is an enumerated type, we need to add 3207 all the enum constants to the partial symbol 3208 table. This does not cover enums without names, 3209 e.g. "enum {a, b} c;" in C, but fortunately 3210 those are rare. There is no way for GDB to find 3211 those from the enum type without spending too 3212 much time on it. Thus to solve this problem, 3213 the compiler needs to put out the enum in a 3214 nameless type. GCC2 does this. */ 3215 3216 /* We are looking for something of the form 3217 <name> ":" ("t" | "T") [<number> "="] "e" 3218 {<constant> ":" <value> ","} ";". */ 3219 3220 /* Skip over the colon and the 't' or 'T'. */ 3221 p += 2; 3222 /* This type may be given a number. Also, numbers 3223 can come in pairs like (0,26). Skip over it. */ 3224 while ((*p >= '0' && *p <= '9') 3225 || *p == '(' || *p == ',' || *p == ')' 3226 || *p == '=') 3227 p++; 3228 3229 if (*p++ == 'e') 3230 { 3231 /* The aix4 compiler emits extra crud before 3232 the members. */ 3233 if (*p == '-') 3234 { 3235 /* Skip over the type (?). */ 3236 while (*p != ':') 3237 p++; 3238 3239 /* Skip over the colon. */ 3240 p++; 3241 } 3242 3243 /* We have found an enumerated type. */ 3244 /* According to comments in read_enum_type 3245 a comma could end it instead of a semicolon. 3246 I don't know where that happens. 3247 Accept either. */ 3248 while (*p && *p != ';' && *p != ',') 3249 { 3250 char *q; 3251 3252 /* Check for and handle cretinous dbx 3253 symbol name continuation! */ 3254 if (*p == '\\' || (*p == '?' && p[1] == '\0')) 3255 p = next_symbol_text (objfile); 3256 3257 /* Point to the character after the name 3258 of the enum constant. */ 3259 for (q = p; *q && *q != ':'; q++) 3260 ; 3261 /* Note that the value doesn't matter for 3262 enum constants in psymtabs, just in 3263 symtabs. */ 3264 add_psymbol_to_list (p, q - p, 1, 3265 VAR_DOMAIN, LOC_CONST, 3266 &objfile->static_psymbols, 3267 0, 0, psymtab_language, 3268 objfile); 3269 /* Point past the name. */ 3270 p = q; 3271 /* Skip over the value. */ 3272 while (*p && *p != ',') 3273 p++; 3274 /* Advance past the comma. */ 3275 if (*p) 3276 p++; 3277 } 3278 } 3279 continue; 3280 case 'c': 3281 /* Constant, e.g. from "const" in Pascal. */ 3282 add_psymbol_to_list (namestring, p - namestring, 1, 3283 VAR_DOMAIN, LOC_CONST, 3284 &objfile->static_psymbols, 3285 sh.value, 0, psymtab_language, 3286 objfile); 3287 continue; 3288 3289 case 'f': 3290 if (! pst) 3291 { 3292 int name_len = p - namestring; 3293 char *name = xmalloc (name_len + 1); 3294 3295 memcpy (name, namestring, name_len); 3296 name[name_len] = '\0'; 3297 function_outside_compilation_unit_complaint (name); 3298 xfree (name); 3299 } 3300 sh.value += ANOFFSET (objfile->section_offsets, 3301 SECT_OFF_TEXT (objfile)); 3302 add_psymbol_to_list (namestring, p - namestring, 1, 3303 VAR_DOMAIN, LOC_BLOCK, 3304 &objfile->static_psymbols, 3305 0, sh.value, 3306 psymtab_language, objfile); 3307 continue; 3308 3309 /* Global functions were ignored here, but now they 3310 are put into the global psymtab like one would 3311 expect. They're also in the minimal symbol 3312 table. */ 3313 case 'F': 3314 if (! pst) 3315 { 3316 int name_len = p - namestring; 3317 char *name = xmalloc (name_len + 1); 3318 3319 memcpy (name, namestring, name_len); 3320 name[name_len] = '\0'; 3321 function_outside_compilation_unit_complaint (name); 3322 xfree (name); 3323 } 3324 sh.value += ANOFFSET (objfile->section_offsets, 3325 SECT_OFF_TEXT (objfile)); 3326 add_psymbol_to_list (namestring, p - namestring, 1, 3327 VAR_DOMAIN, LOC_BLOCK, 3328 &objfile->global_psymbols, 3329 0, sh.value, 3330 psymtab_language, objfile); 3331 continue; 3332 3333 /* Two things show up here (hopefully); static 3334 symbols of local scope (static used inside 3335 braces) or extensions of structure symbols. We 3336 can ignore both. */ 3337 case 'V': 3338 case '(': 3339 case '0': 3340 case '1': 3341 case '2': 3342 case '3': 3343 case '4': 3344 case '5': 3345 case '6': 3346 case '7': 3347 case '8': 3348 case '9': 3349 case '-': 3350 case '#': /* For symbol identification (used 3351 in live ranges). */ 3352 continue; 3353 3354 case ':': 3355 /* It is a C++ nested symbol. We don't need to 3356 record it (I don't think); if we try to look up 3357 foo::bar::baz, then symbols for the symtab 3358 containing foo should get read in, I think. */ 3359 /* Someone says sun cc puts out symbols like 3360 /foo/baz/maclib::/usr/local/bin/maclib, 3361 which would get here with a symbol type of ':'. */ 3362 continue; 3363 3364 default: 3365 /* Unexpected symbol descriptor. The second and 3366 subsequent stabs of a continued stab can show up 3367 here. The question is whether they ever can 3368 mimic a normal stab--it would be nice if not, 3369 since we certainly don't want to spend the time 3370 searching to the end of every string looking for 3371 a backslash. */ 3372 3373 complaint (&symfile_complaints, 3374 _("unknown symbol descriptor `%c'"), p[1]); 3375 3376 /* Ignore it; perhaps it is an extension that we don't 3377 know about. */ 3378 continue; 3379 } 3380 3381 case N_EXCL: 3382 continue; 3383 3384 case N_ENDM: 3385 /* Solaris 2 end of module, finish current partial 3386 symbol table. END_PSYMTAB will set 3387 pst->texthigh to the proper value, which is 3388 necessary if a module compiled without 3389 debugging info follows this module. */ 3390 if (pst 3391 && gdbarch_sofun_address_maybe_missing (gdbarch)) 3392 { 3393 pst = (struct partial_symtab *) 0; 3394 includes_used = 0; 3395 dependencies_used = 0; 3396 } 3397 continue; 3398 3399 case N_RBRAC: 3400 if (sh.value > save_pst->texthigh) 3401 save_pst->texthigh = sh.value; 3402 continue; 3403 case N_EINCL: 3404 case N_DSLINE: 3405 case N_BSLINE: 3406 case N_SSYM: /* Claim: Structure or union 3407 element. Hopefully, I can 3408 ignore this. */ 3409 case N_ENTRY: /* Alternate entry point; can 3410 ignore. */ 3411 case N_MAIN: /* Can definitely ignore this. */ 3412 case N_CATCH: /* These are GNU C++ extensions. */ 3413 case N_EHDECL: /* that can safely be ignored here. */ 3414 case N_LENG: 3415 case N_BCOMM: 3416 case N_ECOMM: 3417 case N_ECOML: 3418 case N_FNAME: 3419 case N_SLINE: 3420 case N_RSYM: 3421 case N_PSYM: 3422 case N_LBRAC: 3423 case N_NSYMS: /* Ultrix 4.0: symbol count */ 3424 case N_DEFD: /* GNU Modula-2 */ 3425 case N_ALIAS: /* SunPro F77: alias name, ignore 3426 for now. */ 3427 3428 case N_OBJ: /* Useless types from Solaris. */ 3429 case N_OPT: 3430 /* These symbols aren't interesting; don't worry about 3431 them. */ 3432 3433 continue; 3434 3435 default: 3436 /* If we haven't found it yet, ignore it. It's 3437 probably some new type we don't know about yet. */ 3438 complaint (&symfile_complaints, 3439 _("unknown symbol type %s"), 3440 hex_string (type_code)); /* CUR_SYMBOL_TYPE */ 3441 continue; 3442 } 3443 if (stabstring 3444 && stabstring != debug_info->ss + fh->issBase + sh.iss) 3445 xfree (stabstring); 3446 } 3447 /* end - Handle continuation */ 3448 } 3449 } 3450 else 3451 { 3452 for (cur_sdx = 0; cur_sdx < fh->csym;) 3453 { 3454 char *name; 3455 enum address_class class; 3456 3457 (*swap_sym_in) (cur_bfd, 3458 ((char *) debug_info->external_sym 3459 + ((fh->isymBase + cur_sdx) 3460 * external_sym_size)), 3461 &sh); 3462 3463 if (ECOFF_IS_STAB (&sh)) 3464 { 3465 cur_sdx++; 3466 continue; 3467 } 3468 3469 /* Non absolute static symbols go into the minimal table. */ 3470 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil 3471 || (sh.index == indexNil 3472 && (sh.st != stStatic || sh.sc == scAbs))) 3473 { 3474 /* FIXME, premature? */ 3475 cur_sdx++; 3476 continue; 3477 } 3478 3479 name = debug_info->ss + fh->issBase + sh.iss; 3480 3481 switch (sh.sc) 3482 { 3483 case scText: 3484 case scRConst: 3485 /* The value of a stEnd symbol is the displacement from the 3486 corresponding start symbol value, do not relocate it. */ 3487 if (sh.st != stEnd) 3488 sh.value += ANOFFSET (objfile->section_offsets, 3489 SECT_OFF_TEXT (objfile)); 3490 break; 3491 case scData: 3492 case scSData: 3493 case scRData: 3494 case scPData: 3495 case scXData: 3496 sh.value += ANOFFSET (objfile->section_offsets, 3497 SECT_OFF_DATA (objfile)); 3498 break; 3499 case scBss: 3500 case scSBss: 3501 sh.value += ANOFFSET (objfile->section_offsets, 3502 SECT_OFF_BSS (objfile)); 3503 break; 3504 } 3505 3506 switch (sh.st) 3507 { 3508 CORE_ADDR high; 3509 CORE_ADDR procaddr; 3510 int new_sdx; 3511 3512 case stStaticProc: 3513 prim_record_minimal_symbol_and_info (name, sh.value, 3514 mst_file_text, 3515 SECT_OFF_TEXT (objfile), 3516 NULL, objfile); 3517 3518 /* FALLTHROUGH */ 3519 3520 case stProc: 3521 /* Ignore all parameter symbol records. */ 3522 if (sh.index >= hdr->iauxMax) 3523 { 3524 /* Should not happen, but does when cross-compiling 3525 with the MIPS compiler. FIXME -- pull later. */ 3526 index_complaint (name); 3527 new_sdx = cur_sdx + 1; /* Don't skip at all. */ 3528 } 3529 else 3530 new_sdx = AUX_GET_ISYM (fh->fBigendian, 3531 (debug_info->external_aux 3532 + fh->iauxBase 3533 + sh.index)); 3534 3535 if (new_sdx <= cur_sdx) 3536 { 3537 /* This should not happen either... FIXME. */ 3538 complaint (&symfile_complaints, 3539 _("bad proc end in aux found from symbol %s"), 3540 name); 3541 new_sdx = cur_sdx + 1; /* Don't skip backward. */ 3542 } 3543 3544 /* For stProc symbol records, we need to check the 3545 storage class as well, as only (stProc, scText) 3546 entries represent "real" procedures - See the 3547 Compaq document titled "Object File / Symbol Table 3548 Format Specification" for more information. If the 3549 storage class is not scText, we discard the whole 3550 block of symbol records for this stProc. */ 3551 if (sh.st == stProc && sh.sc != scText) 3552 goto skip; 3553 3554 /* Usually there is a local and a global stProc symbol 3555 for a function. This means that the function name 3556 has already been entered into the mimimal symbol table 3557 while processing the global symbols in pass 2 above. 3558 One notable exception is the PROGRAM name from 3559 f77 compiled executables, it is only put out as 3560 local stProc symbol, and a global MAIN__ stProc symbol 3561 points to it. It doesn't matter though, as gdb is 3562 still able to find the PROGRAM name via the partial 3563 symbol table, and the MAIN__ symbol via the minimal 3564 symbol table. */ 3565 if (sh.st == stProc) 3566 add_psymbol_to_list (name, strlen (name), 1, 3567 VAR_DOMAIN, LOC_BLOCK, 3568 &objfile->global_psymbols, 3569 0, sh.value, psymtab_language, objfile); 3570 else 3571 add_psymbol_to_list (name, strlen (name), 1, 3572 VAR_DOMAIN, LOC_BLOCK, 3573 &objfile->static_psymbols, 3574 0, sh.value, psymtab_language, objfile); 3575 3576 procaddr = sh.value; 3577 3578 cur_sdx = new_sdx; 3579 (*swap_sym_in) (cur_bfd, 3580 ((char *) debug_info->external_sym 3581 + ((fh->isymBase + cur_sdx - 1) 3582 * external_sym_size)), 3583 &sh); 3584 if (sh.st != stEnd) 3585 continue; 3586 3587 /* Kludge for Irix 5.2 zero fh->adr. */ 3588 if (!relocatable 3589 && (pst->textlow == 0 || procaddr < pst->textlow)) 3590 pst->textlow = procaddr; 3591 3592 high = procaddr + sh.value; 3593 if (high > pst->texthigh) 3594 pst->texthigh = high; 3595 continue; 3596 3597 case stStatic: /* Variable */ 3598 if (SC_IS_DATA (sh.sc)) 3599 prim_record_minimal_symbol_and_info (name, sh.value, 3600 mst_file_data, 3601 SECT_OFF_DATA (objfile), 3602 NULL, 3603 objfile); 3604 else 3605 prim_record_minimal_symbol_and_info (name, sh.value, 3606 mst_file_bss, 3607 SECT_OFF_BSS (objfile), 3608 NULL, 3609 objfile); 3610 class = LOC_STATIC; 3611 break; 3612 3613 case stIndirect: /* Irix5 forward declaration */ 3614 /* Skip forward declarations from Irix5 cc. */ 3615 goto skip; 3616 3617 case stTypedef: /* Typedef */ 3618 /* Skip typedefs for forward declarations and opaque 3619 structs from alpha and mips cc. */ 3620 if (sh.iss == 0 || has_opaque_xref (fh, &sh)) 3621 goto skip; 3622 class = LOC_TYPEDEF; 3623 break; 3624 3625 case stConstant: /* Constant decl */ 3626 class = LOC_CONST; 3627 break; 3628 3629 case stUnion: 3630 case stStruct: 3631 case stEnum: 3632 case stBlock: /* { }, str, un, enum */ 3633 /* Do not create a partial symbol for cc unnamed aggregates 3634 and gcc empty aggregates. */ 3635 if ((sh.sc == scInfo 3636 || SC_IS_COMMON (sh.sc)) 3637 && sh.iss != 0 3638 && sh.index != cur_sdx + 2) 3639 { 3640 add_psymbol_to_list (name, strlen (name), 1, 3641 STRUCT_DOMAIN, LOC_TYPEDEF, 3642 &objfile->static_psymbols, 3643 0, (CORE_ADDR) 0, 3644 psymtab_language, objfile); 3645 } 3646 handle_psymbol_enumerators (objfile, fh, sh.st, sh.value); 3647 3648 /* Skip over the block. */ 3649 new_sdx = sh.index; 3650 if (new_sdx <= cur_sdx) 3651 { 3652 /* This happens with the Ultrix kernel. */ 3653 complaint (&symfile_complaints, 3654 _("bad aux index at block symbol %s"), name); 3655 new_sdx = cur_sdx + 1; /* Don't skip backward. */ 3656 } 3657 cur_sdx = new_sdx; 3658 continue; 3659 3660 case stFile: /* File headers */ 3661 case stLabel: /* Labels */ 3662 case stEnd: /* Ends of files */ 3663 goto skip; 3664 3665 case stLocal: /* Local variables */ 3666 /* Normally these are skipped because we skip over 3667 all blocks we see. However, these can occur 3668 as visible symbols in a .h file that contains code. */ 3669 goto skip; 3670 3671 default: 3672 /* Both complaints are valid: one gives symbol name, 3673 the other the offending symbol type. */ 3674 complaint (&symfile_complaints, _("unknown local symbol %s"), 3675 name); 3676 complaint (&symfile_complaints, _("with type %d"), sh.st); 3677 cur_sdx++; 3678 continue; 3679 } 3680 /* Use this gdb symbol. */ 3681 add_psymbol_to_list (name, strlen (name), 1, 3682 VAR_DOMAIN, class, 3683 &objfile->static_psymbols, 3684 0, sh.value, psymtab_language, objfile); 3685 skip: 3686 cur_sdx++; /* Go to next file symbol. */ 3687 } 3688 3689 /* Now do enter the external symbols. */ 3690 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset]; 3691 cur_sdx = fdr_to_pst[f_idx].n_globals; 3692 PST_PRIVATE (save_pst)->extern_count = cur_sdx; 3693 PST_PRIVATE (save_pst)->extern_tab = ext_ptr; 3694 for (; --cur_sdx >= 0; ext_ptr++) 3695 { 3696 enum address_class class; 3697 SYMR *psh; 3698 char *name; 3699 CORE_ADDR svalue; 3700 3701 if (ext_ptr->ifd != f_idx) 3702 internal_error (__FILE__, __LINE__, 3703 _("failed internal consistency check")); 3704 psh = &ext_ptr->asym; 3705 3706 /* Do not add undefined symbols to the partial symbol table. */ 3707 if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil) 3708 continue; 3709 3710 svalue = psh->value; 3711 switch (psh->sc) 3712 { 3713 case scText: 3714 case scRConst: 3715 svalue += ANOFFSET (objfile->section_offsets, 3716 SECT_OFF_TEXT (objfile)); 3717 break; 3718 case scData: 3719 case scSData: 3720 case scRData: 3721 case scPData: 3722 case scXData: 3723 svalue += ANOFFSET (objfile->section_offsets, 3724 SECT_OFF_DATA (objfile)); 3725 break; 3726 case scBss: 3727 case scSBss: 3728 svalue += ANOFFSET (objfile->section_offsets, 3729 SECT_OFF_BSS (objfile)); 3730 break; 3731 } 3732 3733 switch (psh->st) 3734 { 3735 case stNil: 3736 /* These are generated for static symbols in .o files, 3737 ignore them. */ 3738 continue; 3739 case stProc: 3740 case stStaticProc: 3741 /* External procedure symbols have been entered 3742 into the minimal symbol table in pass 2 above. 3743 Ignore them, as parse_external will ignore them too. */ 3744 continue; 3745 case stLabel: 3746 class = LOC_LABEL; 3747 break; 3748 default: 3749 unknown_ext_complaint (debug_info->ssext + psh->iss); 3750 /* Fall through, pretend it's global. */ 3751 case stGlobal: 3752 /* Global common symbols are resolved by the runtime loader, 3753 ignore them. */ 3754 if (SC_IS_COMMON (psh->sc)) 3755 continue; 3756 3757 class = LOC_STATIC; 3758 break; 3759 } 3760 name = debug_info->ssext + psh->iss; 3761 add_psymbol_to_list (name, strlen (name), 1, 3762 VAR_DOMAIN, class, 3763 &objfile->global_psymbols, 3764 0, svalue, 3765 psymtab_language, objfile); 3766 } 3767 } 3768 3769 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was 3770 empty and put on the free list. */ 3771 fdr_to_pst[f_idx].pst = end_psymtab (objfile, save_pst, 3772 psymtab_include_list, includes_used, 3773 -1, save_pst->texthigh, 3774 dependency_list, dependencies_used, textlow_not_set); 3775 includes_used = 0; 3776 dependencies_used = 0; 3777 3778 /* The objfile has its functions reordered if this partial symbol 3779 table overlaps any other partial symbol table. 3780 We cannot assume a reordered objfile if a partial symbol table 3781 is contained within another partial symbol table, as partial symbol 3782 tables for include files with executable code are contained 3783 within the partial symbol table for the including source file, 3784 and we do not want to flag the objfile reordered for these cases. 3785 3786 This strategy works well for Irix-5.2 shared libraries, but we 3787 might have to use a more elaborate (and slower) algorithm for 3788 other cases. */ 3789 save_pst = fdr_to_pst[f_idx].pst; 3790 if (save_pst != NULL 3791 && save_pst->textlow != 0 3792 && !(objfile->flags & OBJF_REORDERED)) 3793 { 3794 ALL_OBJFILE_PSYMTABS (objfile, pst) 3795 { 3796 if (save_pst != pst 3797 && save_pst->textlow >= pst->textlow 3798 && save_pst->textlow < pst->texthigh 3799 && save_pst->texthigh > pst->texthigh) 3800 { 3801 objfile->flags |= OBJF_REORDERED; 3802 break; 3803 } 3804 } 3805 } 3806 } 3807 3808 /* Now scan the FDRs for dependencies. */ 3809 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) 3810 { 3811 fh = f_idx + debug_info->fdr; 3812 pst = fdr_to_pst[f_idx].pst; 3813 3814 if (pst == (struct partial_symtab *) NULL) 3815 continue; 3816 3817 /* This should catch stabs-in-ecoff. */ 3818 if (fh->crfd <= 1) 3819 continue; 3820 3821 /* Skip the first file indirect entry as it is a self dependency for 3822 source files or a reverse .h -> .c dependency for header files. */ 3823 pst->number_of_dependencies = 0; 3824 pst->dependencies = 3825 ((struct partial_symtab **) 3826 obstack_alloc (&objfile->objfile_obstack, 3827 ((fh->crfd - 1) 3828 * sizeof (struct partial_symtab *)))); 3829 for (s_idx = 1; s_idx < fh->crfd; s_idx++) 3830 { 3831 RFDT rh; 3832 3833 (*swap_rfd_in) (cur_bfd, 3834 ((char *) debug_info->external_rfd 3835 + (fh->rfdBase + s_idx) * external_rfd_size), 3836 &rh); 3837 if (rh < 0 || rh >= hdr->ifdMax) 3838 { 3839 complaint (&symfile_complaints, _("bad file number %ld"), rh); 3840 continue; 3841 } 3842 3843 /* Skip self dependencies of header files. */ 3844 if (rh == f_idx) 3845 continue; 3846 3847 /* Do not add to dependeny list if psymtab was empty. */ 3848 if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL) 3849 continue; 3850 pst->dependencies[pst->number_of_dependencies++] 3851 = fdr_to_pst[rh].pst; 3852 } 3853 } 3854 3855 /* Remove the dummy psymtab created for -O3 images above, if it is 3856 still empty, to enable the detection of stripped executables. */ 3857 if (objfile->psymtabs->next == NULL 3858 && objfile->psymtabs->number_of_dependencies == 0 3859 && objfile->psymtabs->n_global_syms == 0 3860 && objfile->psymtabs->n_static_syms == 0) 3861 objfile->psymtabs = NULL; 3862 do_cleanups (old_chain); 3863 } 3864 3865 /* If the current psymbol has an enumerated type, we need to add 3866 all the enum constants to the partial symbol table. */ 3867 3868 static void 3869 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, 3870 CORE_ADDR svalue) 3871 { 3872 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 3873 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 3874 char *ext_sym = ((char *) debug_info->external_sym 3875 + ((fh->isymBase + cur_sdx + 1) * external_sym_size)); 3876 SYMR sh; 3877 TIR tir; 3878 3879 switch (stype) 3880 { 3881 case stEnum: 3882 break; 3883 3884 case stBlock: 3885 /* It is an enumerated type if the next symbol entry is a stMember 3886 and its auxiliary index is indexNil or its auxiliary entry 3887 is a plain btNil or btVoid. 3888 Alpha cc -migrate enums are recognized by a zero index and 3889 a zero symbol value. 3890 DU 4.0 cc enums are recognized by a member type of btEnum without 3891 qualifiers and a zero symbol value. */ 3892 (*swap_sym_in) (cur_bfd, ext_sym, &sh); 3893 if (sh.st != stMember) 3894 return; 3895 3896 if (sh.index == indexNil 3897 || (sh.index == 0 && svalue == 0)) 3898 break; 3899 (*debug_swap->swap_tir_in) (fh->fBigendian, 3900 &(debug_info->external_aux 3901 + fh->iauxBase + sh.index)->a_ti, 3902 &tir); 3903 if ((tir.bt != btNil 3904 && tir.bt != btVoid 3905 && (tir.bt != btEnum || svalue != 0)) 3906 || tir.tq0 != tqNil) 3907 return; 3908 break; 3909 3910 default: 3911 return; 3912 } 3913 3914 for (;;) 3915 { 3916 char *name; 3917 3918 (*swap_sym_in) (cur_bfd, ext_sym, &sh); 3919 if (sh.st != stMember) 3920 break; 3921 name = debug_info->ss + cur_fdr->issBase + sh.iss; 3922 3923 /* Note that the value doesn't matter for enum constants 3924 in psymtabs, just in symtabs. */ 3925 add_psymbol_to_list (name, strlen (name), 1, 3926 VAR_DOMAIN, LOC_CONST, 3927 &objfile->static_psymbols, 0, 3928 (CORE_ADDR) 0, psymtab_language, objfile); 3929 ext_sym += external_sym_size; 3930 } 3931 } 3932 3933 /* Get the next symbol. OBJFILE is unused. */ 3934 3935 static char * 3936 mdebug_next_symbol_text (struct objfile *objfile) 3937 { 3938 SYMR sh; 3939 3940 cur_sdx++; 3941 (*debug_swap->swap_sym_in) (cur_bfd, 3942 ((char *) debug_info->external_sym 3943 + ((cur_fdr->isymBase + cur_sdx) 3944 * debug_swap->external_sym_size)), 3945 &sh); 3946 return debug_info->ss + cur_fdr->issBase + sh.iss; 3947 } 3948 3949 /* Ancillary function to psymtab_to_symtab(). Does all the work 3950 for turning the partial symtab PST into a symtab, recurring 3951 first on all dependent psymtabs. The argument FILENAME is 3952 only passed so we can see in debug stack traces what file 3953 is being read. 3954 3955 This function has a split personality, based on whether the 3956 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff. 3957 The flow of control and even the memory allocation differs. FIXME. */ 3958 3959 static void 3960 psymtab_to_symtab_1 (struct objfile *objfile, 3961 struct partial_symtab *pst, const char *filename) 3962 { 3963 bfd_size_type external_sym_size; 3964 bfd_size_type external_pdr_size; 3965 void (*swap_sym_in) (bfd *, void *, SYMR *); 3966 void (*swap_pdr_in) (bfd *, void *, PDR *); 3967 int i; 3968 struct symtab *st = NULL; 3969 FDR *fh; 3970 struct linetable *lines; 3971 CORE_ADDR lowest_pdr_addr = 0; 3972 int last_symtab_ended = 0; 3973 3974 if (pst->readin) 3975 return; 3976 pst->readin = 1; 3977 3978 /* Read in all partial symbtabs on which this one is dependent. 3979 NOTE that we do have circular dependencies, sigh. We solved 3980 that by setting pst->readin before this point. */ 3981 3982 for (i = 0; i < pst->number_of_dependencies; i++) 3983 if (!pst->dependencies[i]->readin) 3984 { 3985 /* Inform about additional files to be read in. */ 3986 if (info_verbose) 3987 { 3988 fputs_filtered (" ", gdb_stdout); 3989 wrap_here (""); 3990 fputs_filtered ("and ", gdb_stdout); 3991 wrap_here (""); 3992 printf_filtered ("%s...", 3993 pst->dependencies[i]->filename); 3994 wrap_here (""); /* Flush output */ 3995 gdb_flush (gdb_stdout); 3996 } 3997 /* We only pass the filename for debug purposes. */ 3998 psymtab_to_symtab_1 (objfile, pst->dependencies[i], 3999 pst->dependencies[i]->filename); 4000 } 4001 4002 /* Do nothing if this is a dummy psymtab. */ 4003 4004 if (pst->n_global_syms == 0 && pst->n_static_syms == 0 4005 && pst->textlow == 0 && pst->texthigh == 0) 4006 return; 4007 4008 /* Now read the symbols for this symtab. */ 4009 4010 cur_bfd = CUR_BFD (pst); 4011 debug_swap = DEBUG_SWAP (pst); 4012 debug_info = DEBUG_INFO (pst); 4013 pending_list = PENDING_LIST (pst); 4014 external_sym_size = debug_swap->external_sym_size; 4015 external_pdr_size = debug_swap->external_pdr_size; 4016 swap_sym_in = debug_swap->swap_sym_in; 4017 swap_pdr_in = debug_swap->swap_pdr_in; 4018 mdebugread_objfile = objfile; 4019 cur_fd = FDR_IDX (pst); 4020 fh = ((cur_fd == -1) 4021 ? (FDR *) NULL 4022 : debug_info->fdr + cur_fd); 4023 cur_fdr = fh; 4024 4025 /* See comment in parse_partial_symbols about the @stabs sentinel. */ 4026 processing_gcc_compilation = 0; 4027 if (fh != (FDR *) NULL && fh->csym >= 2) 4028 { 4029 SYMR sh; 4030 4031 (*swap_sym_in) (cur_bfd, 4032 ((char *) debug_info->external_sym 4033 + (fh->isymBase + 1) * external_sym_size), 4034 &sh); 4035 if (strcmp (debug_info->ss + fh->issBase + sh.iss, 4036 stabs_symbol) == 0) 4037 { 4038 /* We indicate that this is a GCC compilation so that certain 4039 features will be enabled in stabsread/dbxread. */ 4040 processing_gcc_compilation = 2; 4041 } 4042 } 4043 4044 if (processing_gcc_compilation != 0) 4045 { 4046 struct gdbarch *gdbarch = get_objfile_arch (objfile); 4047 4048 /* This symbol table contains stabs-in-ecoff entries. */ 4049 4050 /* Parse local symbols first. */ 4051 4052 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr. */ 4053 { 4054 mdebugread_objfile = NULL; 4055 return; 4056 } 4057 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++) 4058 { 4059 SYMR sh; 4060 char *name; 4061 CORE_ADDR valu; 4062 4063 (*swap_sym_in) (cur_bfd, 4064 (((char *) debug_info->external_sym) 4065 + (fh->isymBase + cur_sdx) * external_sym_size), 4066 &sh); 4067 name = debug_info->ss + fh->issBase + sh.iss; 4068 valu = sh.value; 4069 /* XXX This is a hack. It will go away! */ 4070 if (ECOFF_IS_STAB (&sh) || (name[0] == '#')) 4071 { 4072 int type_code = ECOFF_UNMARK_STAB (sh.index); 4073 4074 /* We should never get non N_STAB symbols here, but they 4075 should be harmless, so keep process_one_symbol from 4076 complaining about them. */ 4077 if (type_code & N_STAB) 4078 { 4079 /* If we found a trailing N_SO with no name, process 4080 it here instead of in process_one_symbol, so we 4081 can keep a handle to its symtab. The symtab 4082 would otherwise be ended twice, once in 4083 process_one_symbol, and once after this loop. */ 4084 if (type_code == N_SO 4085 && get_last_source_file () 4086 && previous_stab_code != (unsigned char) N_SO 4087 && *name == '\000') 4088 { 4089 valu += ANOFFSET (pst->section_offsets, 4090 SECT_OFF_TEXT (objfile)); 4091 previous_stab_code = N_SO; 4092 st = end_symtab (valu, objfile, 4093 SECT_OFF_TEXT (objfile)); 4094 end_stabs (); 4095 last_symtab_ended = 1; 4096 } 4097 else 4098 { 4099 last_symtab_ended = 0; 4100 process_one_symbol (type_code, 0, valu, name, 4101 pst->section_offsets, objfile); 4102 } 4103 } 4104 /* Similarly a hack. */ 4105 else if (name[0] == '#') 4106 { 4107 process_one_symbol (N_SLINE, 0, valu, name, 4108 pst->section_offsets, objfile); 4109 } 4110 if (type_code == N_FUN) 4111 { 4112 /* Make up special symbol to contain 4113 procedure specific info. */ 4114 struct mdebug_extra_func_info *e = 4115 ((struct mdebug_extra_func_info *) 4116 obstack_alloc (&mdebugread_objfile->objfile_obstack, 4117 sizeof (struct mdebug_extra_func_info))); 4118 struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); 4119 4120 memset (e, 0, sizeof (struct mdebug_extra_func_info)); 4121 SYMBOL_DOMAIN (s) = LABEL_DOMAIN; 4122 SYMBOL_CLASS (s) = LOC_CONST; 4123 SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void; 4124 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; 4125 e->pdr.framereg = -1; 4126 add_symbol_to_list (s, &local_symbols); 4127 } 4128 } 4129 else if (sh.st == stLabel) 4130 { 4131 if (sh.index == indexNil) 4132 { 4133 /* This is what the gcc2_compiled and __gnu_compiled_* 4134 show up as. So don't complain. */ 4135 ; 4136 } 4137 else 4138 { 4139 /* Handle encoded stab line number. */ 4140 valu += ANOFFSET (pst->section_offsets, 4141 SECT_OFF_TEXT (objfile)); 4142 record_line (current_subfile, sh.index, 4143 gdbarch_addr_bits_remove (gdbarch, valu)); 4144 } 4145 } 4146 else if (sh.st == stProc || sh.st == stStaticProc 4147 || sh.st == stStatic || sh.st == stEnd) 4148 /* These are generated by gcc-2.x, do not complain. */ 4149 ; 4150 else 4151 complaint (&symfile_complaints, 4152 _("unknown stabs symbol %s"), name); 4153 } 4154 4155 if (! last_symtab_ended) 4156 { 4157 st = end_symtab (pst->texthigh, objfile, 4158 SECT_OFF_TEXT (objfile)); 4159 end_stabs (); 4160 } 4161 4162 /* There used to be a call to sort_blocks here, but this should not 4163 be necessary for stabs symtabs. And as sort_blocks modifies the 4164 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, 4165 it did the wrong thing if the first procedure in a file was 4166 generated via asm statements. */ 4167 4168 /* Fill in procedure info next. */ 4169 if (fh->cpd > 0) 4170 { 4171 PDR *pr_block; 4172 struct cleanup *old_chain; 4173 char *pdr_ptr; 4174 char *pdr_end; 4175 PDR *pdr_in; 4176 PDR *pdr_in_end; 4177 4178 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); 4179 old_chain = make_cleanup (xfree, pr_block); 4180 4181 pdr_ptr = ((char *) debug_info->external_pdr 4182 + fh->ipdFirst * external_pdr_size); 4183 pdr_end = pdr_ptr + fh->cpd * external_pdr_size; 4184 pdr_in = pr_block; 4185 for (; 4186 pdr_ptr < pdr_end; 4187 pdr_ptr += external_pdr_size, pdr_in++) 4188 { 4189 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); 4190 4191 /* Determine lowest PDR address, the PDRs are not always 4192 sorted. */ 4193 if (pdr_in == pr_block) 4194 lowest_pdr_addr = pdr_in->adr; 4195 else if (pdr_in->adr < lowest_pdr_addr) 4196 lowest_pdr_addr = pdr_in->adr; 4197 } 4198 4199 pdr_in = pr_block; 4200 pdr_in_end = pdr_in + fh->cpd; 4201 for (; pdr_in < pdr_in_end; pdr_in++) 4202 parse_procedure (pdr_in, st, pst); 4203 4204 do_cleanups (old_chain); 4205 } 4206 } 4207 else 4208 { 4209 /* This symbol table contains ordinary ecoff entries. */ 4210 4211 int maxlines, size; 4212 EXTR *ext_ptr; 4213 4214 if (fh == 0) 4215 { 4216 maxlines = 0; 4217 st = new_symtab ("unknown", 0, objfile); 4218 } 4219 else 4220 { 4221 maxlines = 2 * fh->cline; 4222 st = new_symtab (pst->filename, maxlines, objfile); 4223 4224 /* The proper language was already determined when building 4225 the psymtab, use it. */ 4226 st->language = PST_PRIVATE (pst)->pst_language; 4227 } 4228 4229 psymtab_language = st->language; 4230 4231 lines = LINETABLE (st); 4232 4233 /* Get a new lexical context. */ 4234 4235 push_parse_stack (); 4236 top_stack->cur_st = st; 4237 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st), 4238 STATIC_BLOCK); 4239 BLOCK_START (top_stack->cur_block) = pst->textlow; 4240 BLOCK_END (top_stack->cur_block) = 0; 4241 top_stack->blocktype = stFile; 4242 top_stack->cur_type = 0; 4243 top_stack->procadr = 0; 4244 top_stack->numargs = 0; 4245 found_ecoff_debugging_info = 0; 4246 4247 if (fh) 4248 { 4249 char *sym_ptr; 4250 char *sym_end; 4251 4252 /* Parse local symbols first. */ 4253 sym_ptr = ((char *) debug_info->external_sym 4254 + fh->isymBase * external_sym_size); 4255 sym_end = sym_ptr + fh->csym * external_sym_size; 4256 while (sym_ptr < sym_end) 4257 { 4258 SYMR sh; 4259 int c; 4260 4261 (*swap_sym_in) (cur_bfd, sym_ptr, &sh); 4262 c = parse_symbol (&sh, 4263 debug_info->external_aux + fh->iauxBase, 4264 sym_ptr, fh->fBigendian, 4265 pst->section_offsets, objfile); 4266 sym_ptr += c * external_sym_size; 4267 } 4268 4269 /* Linenumbers. At the end, check if we can save memory. 4270 parse_lines has to look ahead an arbitrary number of PDR 4271 structures, so we swap them all first. */ 4272 if (fh->cpd > 0) 4273 { 4274 PDR *pr_block; 4275 struct cleanup *old_chain; 4276 char *pdr_ptr; 4277 char *pdr_end; 4278 PDR *pdr_in; 4279 PDR *pdr_in_end; 4280 4281 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); 4282 4283 old_chain = make_cleanup (xfree, pr_block); 4284 4285 pdr_ptr = ((char *) debug_info->external_pdr 4286 + fh->ipdFirst * external_pdr_size); 4287 pdr_end = pdr_ptr + fh->cpd * external_pdr_size; 4288 pdr_in = pr_block; 4289 for (; 4290 pdr_ptr < pdr_end; 4291 pdr_ptr += external_pdr_size, pdr_in++) 4292 { 4293 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); 4294 4295 /* Determine lowest PDR address, the PDRs are not always 4296 sorted. */ 4297 if (pdr_in == pr_block) 4298 lowest_pdr_addr = pdr_in->adr; 4299 else if (pdr_in->adr < lowest_pdr_addr) 4300 lowest_pdr_addr = pdr_in->adr; 4301 } 4302 4303 parse_lines (fh, pr_block, lines, maxlines, 4304 pst, lowest_pdr_addr); 4305 if (lines->nitems < fh->cline) 4306 lines = shrink_linetable (lines); 4307 4308 /* Fill in procedure info next. */ 4309 pdr_in = pr_block; 4310 pdr_in_end = pdr_in + fh->cpd; 4311 for (; pdr_in < pdr_in_end; pdr_in++) 4312 parse_procedure (pdr_in, 0, pst); 4313 4314 do_cleanups (old_chain); 4315 } 4316 } 4317 4318 size = lines->nitems; 4319 if (size > 1) 4320 --size; 4321 LINETABLE (st) = obstack_copy (&mdebugread_objfile->objfile_obstack, 4322 lines, 4323 (sizeof (struct linetable) 4324 + size * sizeof (lines->item))); 4325 xfree (lines); 4326 4327 /* .. and our share of externals. 4328 XXX use the global list to speed up things here. How? 4329 FIXME, Maybe quit once we have found the right number of ext's? */ 4330 top_stack->cur_st = st; 4331 top_stack->cur_block 4332 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), 4333 GLOBAL_BLOCK); 4334 top_stack->blocktype = stFile; 4335 4336 ext_ptr = PST_PRIVATE (pst)->extern_tab; 4337 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++) 4338 parse_external (ext_ptr, fh->fBigendian, 4339 pst->section_offsets, objfile); 4340 4341 /* If there are undefined symbols, tell the user. 4342 The alpha has an undefined symbol for every symbol that is 4343 from a shared library, so tell the user only if verbose is on. */ 4344 if (info_verbose && n_undef_symbols) 4345 { 4346 printf_filtered (_("File %s contains %d unresolved references:"), 4347 symtab_to_filename_for_display (st), 4348 n_undef_symbols); 4349 printf_filtered ("\n\t%4d variables\n\t%4d " 4350 "procedures\n\t%4d labels\n", 4351 n_undef_vars, n_undef_procs, n_undef_labels); 4352 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0; 4353 4354 } 4355 pop_parse_stack (); 4356 4357 st->primary = 1; 4358 4359 sort_blocks (st); 4360 } 4361 4362 /* Now link the psymtab and the symtab. */ 4363 pst->symtab = st; 4364 4365 mdebugread_objfile = NULL; 4366 } 4367 4368 /* Ancillary parsing procedures. */ 4369 4370 /* Return 1 if the symbol pointed to by SH has a cross reference 4371 to an opaque aggregate type, else 0. */ 4372 4373 static int 4374 has_opaque_xref (FDR *fh, SYMR *sh) 4375 { 4376 TIR tir; 4377 union aux_ext *ax; 4378 RNDXR rn[1]; 4379 unsigned int rf; 4380 4381 if (sh->index == indexNil) 4382 return 0; 4383 4384 ax = debug_info->external_aux + fh->iauxBase + sh->index; 4385 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir); 4386 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum) 4387 return 0; 4388 4389 ax++; 4390 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn); 4391 if (rn->rfd == 0xfff) 4392 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1); 4393 else 4394 rf = rn->rfd; 4395 if (rf != -1) 4396 return 0; 4397 return 1; 4398 } 4399 4400 /* Lookup the type at relative index RN. Return it in TPP 4401 if found and in any event come up with its name PNAME. 4402 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian). 4403 Return value says how many aux symbols we ate. */ 4404 4405 static int 4406 cross_ref (int fd, union aux_ext *ax, struct type **tpp, 4407 enum type_code type_code, 4408 /* Use to alloc new type if none is found. */ 4409 char **pname, int bigend, char *sym_name) 4410 { 4411 RNDXR rn[1]; 4412 unsigned int rf; 4413 int result = 1; 4414 FDR *fh; 4415 char *esh; 4416 SYMR sh; 4417 int xref_fd; 4418 struct mdebug_pending *pend; 4419 4420 *tpp = (struct type *) NULL; 4421 4422 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn); 4423 4424 /* Escape index means 'the next one'. */ 4425 if (rn->rfd == 0xfff) 4426 { 4427 result++; 4428 rf = AUX_GET_ISYM (bigend, ax + 1); 4429 } 4430 else 4431 { 4432 rf = rn->rfd; 4433 } 4434 4435 /* mips cc uses a rf of -1 for opaque struct definitions. 4436 Set TYPE_FLAG_STUB for these types so that check_typedef will 4437 resolve them if the struct gets defined in another compilation unit. */ 4438 if (rf == -1) 4439 { 4440 *pname = "<undefined>"; 4441 *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, 4442 (char *) NULL, mdebugread_objfile); 4443 return result; 4444 } 4445 4446 /* mips cc uses an escaped rn->index of 0 for struct return types 4447 of procedures that were compiled without -g. These will always remain 4448 undefined. */ 4449 if (rn->rfd == 0xfff && rn->index == 0) 4450 { 4451 *pname = "<undefined>"; 4452 return result; 4453 } 4454 4455 /* Find the relative file descriptor and the symbol in it. */ 4456 fh = get_rfd (fd, rf); 4457 xref_fd = fh - debug_info->fdr; 4458 4459 if (rn->index >= fh->csym) 4460 { 4461 /* File indirect entry is corrupt. */ 4462 *pname = "<illegal>"; 4463 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); 4464 return result; 4465 } 4466 4467 /* If we have processed this symbol then we left a forwarding 4468 pointer to the type in the pending list. If not, we`ll put 4469 it in a list of pending types, to be processed later when 4470 the file will be. In any event, we collect the name for the 4471 type here. */ 4472 4473 esh = ((char *) debug_info->external_sym 4474 + ((fh->isymBase + rn->index) 4475 * debug_swap->external_sym_size)); 4476 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh); 4477 4478 /* Make sure that this type of cross reference can be handled. */ 4479 if ((sh.sc != scInfo 4480 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect 4481 && sh.st != stStruct && sh.st != stUnion 4482 && sh.st != stEnum)) 4483 && (sh.st != stBlock || !SC_IS_COMMON (sh.sc))) 4484 { 4485 /* File indirect entry is corrupt. */ 4486 *pname = "<illegal>"; 4487 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); 4488 return result; 4489 } 4490 4491 *pname = debug_info->ss + fh->issBase + sh.iss; 4492 4493 pend = is_pending_symbol (fh, esh); 4494 if (pend) 4495 *tpp = pend->t; 4496 else 4497 { 4498 /* We have not yet seen this type. */ 4499 4500 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect) 4501 { 4502 TIR tir; 4503 4504 /* alpha cc puts out a stTypedef with a sh.iss of zero for 4505 two cases: 4506 a) forward declarations of structs/unions/enums which are not 4507 defined in this compilation unit. 4508 For these the type will be void. This is a bad design decision 4509 as cross referencing across compilation units is impossible 4510 due to the missing name. 4511 b) forward declarations of structs/unions/enums/typedefs which 4512 are defined later in this file or in another file in the same 4513 compilation unit. Irix5 cc uses a stIndirect symbol for this. 4514 Simply cross reference those again to get the true type. 4515 The forward references are not entered in the pending list and 4516 in the symbol table. */ 4517 4518 (*debug_swap->swap_tir_in) (bigend, 4519 &(debug_info->external_aux 4520 + fh->iauxBase + sh.index)->a_ti, 4521 &tir); 4522 if (tir.tq0 != tqNil) 4523 complaint (&symfile_complaints, 4524 _("illegal tq0 in forward typedef for %s"), sym_name); 4525 switch (tir.bt) 4526 { 4527 case btVoid: 4528 *tpp = init_type (type_code, 0, 0, (char *) NULL, 4529 mdebugread_objfile); 4530 *pname = "<undefined>"; 4531 break; 4532 4533 case btStruct: 4534 case btUnion: 4535 case btEnum: 4536 cross_ref (xref_fd, 4537 (debug_info->external_aux 4538 + fh->iauxBase + sh.index + 1), 4539 tpp, type_code, pname, 4540 fh->fBigendian, sym_name); 4541 break; 4542 4543 case btTypedef: 4544 /* Follow a forward typedef. This might recursively 4545 call cross_ref till we get a non typedef'ed type. 4546 FIXME: This is not correct behaviour, but gdb currently 4547 cannot handle typedefs without type copying. Type 4548 copying is impossible as we might have mutual forward 4549 references between two files and the copied type would not 4550 get filled in when we later parse its definition. */ 4551 *tpp = parse_type (xref_fd, 4552 debug_info->external_aux + fh->iauxBase, 4553 sh.index, 4554 (int *) NULL, 4555 fh->fBigendian, 4556 debug_info->ss + fh->issBase + sh.iss); 4557 add_pending (fh, esh, *tpp); 4558 break; 4559 4560 default: 4561 complaint (&symfile_complaints, 4562 _("illegal bt %d in forward typedef for %s"), tir.bt, 4563 sym_name); 4564 *tpp = init_type (type_code, 0, 0, (char *) NULL, 4565 mdebugread_objfile); 4566 break; 4567 } 4568 return result; 4569 } 4570 else if (sh.st == stTypedef) 4571 { 4572 /* Parse the type for a normal typedef. This might recursively call 4573 cross_ref till we get a non typedef'ed type. 4574 FIXME: This is not correct behaviour, but gdb currently 4575 cannot handle typedefs without type copying. But type copying is 4576 impossible as we might have mutual forward references between 4577 two files and the copied type would not get filled in when 4578 we later parse its definition. */ 4579 *tpp = parse_type (xref_fd, 4580 debug_info->external_aux + fh->iauxBase, 4581 sh.index, 4582 (int *) NULL, 4583 fh->fBigendian, 4584 debug_info->ss + fh->issBase + sh.iss); 4585 } 4586 else 4587 { 4588 /* Cross reference to a struct/union/enum which is defined 4589 in another file in the same compilation unit but that file 4590 has not been parsed yet. 4591 Initialize the type only, it will be filled in when 4592 it's definition is parsed. */ 4593 *tpp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile); 4594 } 4595 add_pending (fh, esh, *tpp); 4596 } 4597 4598 /* We used one auxent normally, two if we got a "next one" rf. */ 4599 return result; 4600 } 4601 4602 4603 /* Quick&dirty lookup procedure, to avoid the MI ones that require 4604 keeping the symtab sorted. */ 4605 4606 static struct symbol * 4607 mylookup_symbol (char *name, struct block *block, 4608 domain_enum domain, enum address_class class) 4609 { 4610 struct block_iterator iter; 4611 int inc; 4612 struct symbol *sym; 4613 4614 inc = name[0]; 4615 ALL_BLOCK_SYMBOLS (block, iter, sym) 4616 { 4617 if (SYMBOL_LINKAGE_NAME (sym)[0] == inc 4618 && SYMBOL_DOMAIN (sym) == domain 4619 && SYMBOL_CLASS (sym) == class 4620 && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0) 4621 return sym; 4622 } 4623 4624 block = BLOCK_SUPERBLOCK (block); 4625 if (block) 4626 return mylookup_symbol (name, block, domain, class); 4627 return 0; 4628 } 4629 4630 4631 /* Add a new symbol S to a block B. */ 4632 4633 static void 4634 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b) 4635 { 4636 SYMBOL_SYMTAB (s) = symtab; 4637 dict_add_symbol (BLOCK_DICT (b), s); 4638 } 4639 4640 /* Add a new block B to a symtab S. */ 4641 4642 static void 4643 add_block (struct block *b, struct symtab *s) 4644 { 4645 struct blockvector *bv = BLOCKVECTOR (s); 4646 4647 bv = (struct blockvector *) xrealloc ((void *) bv, 4648 (sizeof (struct blockvector) 4649 + BLOCKVECTOR_NBLOCKS (bv) 4650 * sizeof (bv->block))); 4651 if (bv != BLOCKVECTOR (s)) 4652 BLOCKVECTOR (s) = bv; 4653 4654 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b; 4655 } 4656 4657 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT. 4658 MIPS' linenumber encoding might need more than one byte 4659 to describe it, LAST is used to detect these continuation lines. 4660 4661 Combining lines with the same line number seems like a bad idea. 4662 E.g: There could be a line number entry with the same line number after the 4663 prologue and GDB should not ignore it (this is a better way to find 4664 a prologue than mips_skip_prologue). 4665 But due to the compressed line table format there are line number entries 4666 for the same line which are needed to bridge the gap to the next 4667 line number entry. These entries have a bogus address info with them 4668 and we are unable to tell them from intended duplicate line number 4669 entries. 4670 This is another reason why -ggdb debugging format is preferable. */ 4671 4672 static int 4673 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last) 4674 { 4675 /* DEC c89 sometimes produces zero linenos which confuse gdb. 4676 Change them to something sensible. */ 4677 if (lineno == 0) 4678 lineno = 1; 4679 if (last == 0) 4680 last = -2; /* Make sure we record first line. */ 4681 4682 if (last == lineno) /* Skip continuation lines. */ 4683 return lineno; 4684 4685 lt->item[lt->nitems].line = lineno; 4686 lt->item[lt->nitems++].pc = adr << 2; 4687 return lineno; 4688 } 4689 4690 /* Sorting and reordering procedures. */ 4691 4692 /* Blocks with a smaller low bound should come first. */ 4693 4694 static int 4695 compare_blocks (const void *arg1, const void *arg2) 4696 { 4697 LONGEST addr_diff; 4698 struct block **b1 = (struct block **) arg1; 4699 struct block **b2 = (struct block **) arg2; 4700 4701 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2))); 4702 if (addr_diff == 0) 4703 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1))); 4704 return addr_diff; 4705 } 4706 4707 /* Sort the blocks of a symtab S. 4708 Reorder the blocks in the blockvector by code-address, 4709 as required by some MI search routines. */ 4710 4711 static void 4712 sort_blocks (struct symtab *s) 4713 { 4714 struct blockvector *bv = BLOCKVECTOR (s); 4715 4716 if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_BLOCK) 4717 { 4718 /* Cosmetic */ 4719 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0) 4720 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0; 4721 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0) 4722 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0; 4723 return; 4724 } 4725 /* 4726 * This is very unfortunate: normally all functions are compiled in 4727 * the order they are found, but if the file is compiled -O3 things 4728 * are very different. It would be nice to find a reliable test 4729 * to detect -O3 images in advance. 4730 */ 4731 if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1) 4732 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK), 4733 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK, 4734 sizeof (struct block *), 4735 compare_blocks); 4736 4737 { 4738 CORE_ADDR high = 0; 4739 int i, j = BLOCKVECTOR_NBLOCKS (bv); 4740 4741 for (i = FIRST_LOCAL_BLOCK; i < j; i++) 4742 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i))) 4743 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)); 4744 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high; 4745 } 4746 4747 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 4748 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK)); 4749 4750 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 4751 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 4752 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 4753 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 4754 } 4755 4756 4757 /* Constructor/restructor/destructor procedures. */ 4758 4759 /* Allocate a new symtab for NAME. Needs an estimate of how many 4760 linenumbers MAXLINES we'll put in it. */ 4761 4762 static struct symtab * 4763 new_symtab (const char *name, int maxlines, struct objfile *objfile) 4764 { 4765 struct symtab *s = allocate_symtab (name, objfile); 4766 4767 LINETABLE (s) = new_linetable (maxlines); 4768 4769 /* All symtabs must have at least two blocks. */ 4770 BLOCKVECTOR (s) = new_bvect (2); 4771 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) 4772 = new_block (NON_FUNCTION_BLOCK); 4773 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) 4774 = new_block (NON_FUNCTION_BLOCK); 4775 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) = 4776 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); 4777 4778 s->debugformat = "ECOFF"; 4779 return (s); 4780 } 4781 4782 /* Allocate a new partial_symtab NAME. */ 4783 4784 static struct partial_symtab * 4785 new_psymtab (char *name, struct objfile *objfile) 4786 { 4787 struct partial_symtab *psymtab; 4788 4789 psymtab = allocate_psymtab (name, objfile); 4790 psymtab->section_offsets = objfile->section_offsets; 4791 4792 /* Keep a backpointer to the file's symbols. */ 4793 4794 psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack, 4795 sizeof (struct symloc)); 4796 memset (psymtab->read_symtab_private, 0, sizeof (struct symloc)); 4797 CUR_BFD (psymtab) = cur_bfd; 4798 DEBUG_SWAP (psymtab) = debug_swap; 4799 DEBUG_INFO (psymtab) = debug_info; 4800 PENDING_LIST (psymtab) = pending_list; 4801 4802 /* The way to turn this into a symtab is to call... */ 4803 psymtab->read_symtab = mdebug_read_symtab; 4804 return (psymtab); 4805 } 4806 4807 4808 /* Allocate a linetable array of the given SIZE. Since the struct 4809 already includes one item, we subtract one when calculating the 4810 proper size to allocate. */ 4811 4812 static struct linetable * 4813 new_linetable (int size) 4814 { 4815 struct linetable *l; 4816 4817 if (size > 1) 4818 --size; 4819 size = size * sizeof (l->item) + sizeof (struct linetable); 4820 l = (struct linetable *) xmalloc (size); 4821 l->nitems = 0; 4822 return l; 4823 } 4824 4825 /* Oops, too big. Shrink it. This was important with the 2.4 linetables, 4826 I am not so sure about the 3.4 ones. 4827 4828 Since the struct linetable already includes one item, we subtract one when 4829 calculating the proper size to allocate. */ 4830 4831 static struct linetable * 4832 shrink_linetable (struct linetable *lt) 4833 { 4834 return (struct linetable *) xrealloc ((void *) lt, 4835 (sizeof (struct linetable) 4836 + ((lt->nitems - 1) 4837 * sizeof (lt->item)))); 4838 } 4839 4840 /* Allocate and zero a new blockvector of NBLOCKS blocks. */ 4841 4842 static struct blockvector * 4843 new_bvect (int nblocks) 4844 { 4845 struct blockvector *bv; 4846 int size; 4847 4848 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *); 4849 bv = (struct blockvector *) xzalloc (size); 4850 4851 BLOCKVECTOR_NBLOCKS (bv) = nblocks; 4852 4853 return bv; 4854 } 4855 4856 /* Allocate and zero a new block, and set its BLOCK_DICT. If function 4857 is non-zero, assume the block is associated to a function, and make 4858 sure that the symbols are stored linearly; otherwise, store them 4859 hashed. */ 4860 4861 static struct block * 4862 new_block (enum block_type type) 4863 { 4864 /* FIXME: carlton/2003-09-11: This should use allocate_block to 4865 allocate the block. Which, in turn, suggests that the block 4866 should be allocated on an obstack. */ 4867 struct block *retval = xzalloc (sizeof (struct block)); 4868 4869 if (type == FUNCTION_BLOCK) 4870 BLOCK_DICT (retval) = dict_create_linear_expandable (); 4871 else 4872 BLOCK_DICT (retval) = dict_create_hashed_expandable (); 4873 4874 return retval; 4875 } 4876 4877 /* Create a new symbol with printname NAME. */ 4878 4879 static struct symbol * 4880 new_symbol (char *name) 4881 { 4882 struct symbol *s = ((struct symbol *) 4883 obstack_alloc (&mdebugread_objfile->objfile_obstack, 4884 sizeof (struct symbol))); 4885 4886 memset (s, 0, sizeof (*s)); 4887 SYMBOL_SET_LANGUAGE (s, psymtab_language); 4888 SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile); 4889 return s; 4890 } 4891 4892 /* Create a new type with printname NAME. */ 4893 4894 static struct type * 4895 new_type (char *name) 4896 { 4897 struct type *t; 4898 4899 t = alloc_type (mdebugread_objfile); 4900 TYPE_NAME (t) = name; 4901 INIT_CPLUS_SPECIFIC (t); 4902 return t; 4903 } 4904 4905 /* Read ECOFF debugging information from a BFD section. This is 4906 called from elfread.c. It parses the section into a 4907 ecoff_debug_info struct, and then lets the rest of the file handle 4908 it as normal. */ 4909 4910 void 4911 elfmdebug_build_psymtabs (struct objfile *objfile, 4912 const struct ecoff_debug_swap *swap, asection *sec) 4913 { 4914 bfd *abfd = objfile->obfd; 4915 struct ecoff_debug_info *info; 4916 struct cleanup *back_to; 4917 4918 /* FIXME: It's not clear whether we should be getting minimal symbol 4919 information from .mdebug in an ELF file, or whether we will. 4920 Re-initialize the minimal symbol reader in case we do. */ 4921 4922 init_minimal_symbol_collection (); 4923 back_to = make_cleanup_discard_minimal_symbols (); 4924 4925 info = ((struct ecoff_debug_info *) 4926 obstack_alloc (&objfile->objfile_obstack, 4927 sizeof (struct ecoff_debug_info))); 4928 4929 if (!(*swap->read_debug_info) (abfd, sec, info)) 4930 error (_("Error reading ECOFF debugging information: %s"), 4931 bfd_errmsg (bfd_get_error ())); 4932 4933 mdebug_build_psymtabs (objfile, swap, info); 4934 4935 install_minimal_symbols (objfile); 4936 do_cleanups (back_to); 4937 } 4938 4939 void 4940 _initialize_mdebugread (void) 4941 { 4942 basic_type_data = register_objfile_data (); 4943 } 4944