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