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