1/* Support routines for building symbol tables in GDB's internal format. 2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 3 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23/* This module provides subroutines used for creating and adding to 24 the symbol table. These routines are called from various symbol- 25 file-reading routines. 26 27 Routines to support specific debugging information formats (stabs, 28 DWARF, etc) belong somewhere else. */ 29 30#include "defs.h" 31#include "bfd.h" 32#include "gdb_obstack.h" 33#include "symtab.h" 34#include "symfile.h" 35#include "objfiles.h" 36#include "gdbtypes.h" 37#include "gdb_assert.h" 38#include "complaints.h" 39#include "gdb_string.h" 40#include "expression.h" /* For "enum exp_opcode" used by... */ 41#include "language.h" /* For "local_hex_string" */ 42#include "bcache.h" 43#include "filenames.h" /* For DOSish file names */ 44#include "macrotab.h" 45#include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ 46#include "block.h" 47#include "cp-support.h" 48#include "dictionary.h" 49 50/* Ask buildsym.h to define the vars it normally declares `extern'. */ 51#define EXTERN 52/**/ 53#include "buildsym.h" /* Our own declarations */ 54#undef EXTERN 55 56/* For cleanup_undefined_types and finish_global_stabs (somewhat 57 questionable--see comment where we call them). */ 58 59#include "stabsread.h" 60 61/* List of free `struct pending' structures for reuse. */ 62 63static struct pending *free_pendings; 64 65/* Non-zero if symtab has line number info. This prevents an 66 otherwise empty symtab from being tossed. */ 67 68static int have_line_numbers; 69 70static int compare_line_numbers (const void *ln1p, const void *ln2p); 71 72 73/* Initial sizes of data structures. These are realloc'd larger if 74 needed, and realloc'd down to the size actually used, when 75 completed. */ 76 77#define INITIAL_CONTEXT_STACK_SIZE 10 78#define INITIAL_LINE_VECTOR_LENGTH 1000 79 80 81/* maintain the lists of symbols and blocks */ 82 83/* Add a pending list to free_pendings. */ 84void 85add_free_pendings (struct pending *list) 86{ 87 struct pending *link = list; 88 89 if (list) 90 { 91 while (link->next) link = link->next; 92 link->next = free_pendings; 93 free_pendings = list; 94 } 95} 96 97/* Add a symbol to one of the lists of symbols. While we're at it, if 98 we're in the C++ case and don't have full namespace debugging info, 99 check to see if it references an anonymous namespace; if so, add an 100 appropriate using directive. */ 101 102void 103add_symbol_to_list (struct symbol *symbol, struct pending **listhead) 104{ 105 struct pending *link; 106 107 /* If this is an alias for another symbol, don't add it. */ 108 if (symbol->ginfo.name && symbol->ginfo.name[0] == '#') 109 return; 110 111 /* We keep PENDINGSIZE symbols in each link of the list. If we 112 don't have a link with room in it, add a new link. */ 113 if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE) 114 { 115 if (free_pendings) 116 { 117 link = free_pendings; 118 free_pendings = link->next; 119 } 120 else 121 { 122 link = (struct pending *) xmalloc (sizeof (struct pending)); 123 } 124 125 link->next = *listhead; 126 *listhead = link; 127 link->nsyms = 0; 128 } 129 130 (*listhead)->symbol[(*listhead)->nsyms++] = symbol; 131 132 /* Check to see if we might need to look for a mention of anonymous 133 namespaces. */ 134 135 if (SYMBOL_LANGUAGE (symbol) == language_cplus) 136 cp_scan_for_anonymous_namespaces (symbol); 137} 138 139/* Find a symbol named NAME on a LIST. NAME need not be 140 '\0'-terminated; LENGTH is the length of the name. */ 141 142struct symbol * 143find_symbol_in_list (struct pending *list, char *name, int length) 144{ 145 int j; 146 char *pp; 147 148 while (list != NULL) 149 { 150 for (j = list->nsyms; --j >= 0;) 151 { 152 pp = DEPRECATED_SYMBOL_NAME (list->symbol[j]); 153 if (*pp == *name && strncmp (pp, name, length) == 0 && 154 pp[length] == '\0') 155 { 156 return (list->symbol[j]); 157 } 158 } 159 list = list->next; 160 } 161 return (NULL); 162} 163 164/* At end of reading syms, or in case of quit, really free as many 165 `struct pending's as we can easily find. */ 166 167void 168really_free_pendings (void *dummy) 169{ 170 struct pending *next, *next1; 171 172 for (next = free_pendings; next; next = next1) 173 { 174 next1 = next->next; 175 xfree ((void *) next); 176 } 177 free_pendings = NULL; 178 179 free_pending_blocks (); 180 181 for (next = file_symbols; next != NULL; next = next1) 182 { 183 next1 = next->next; 184 xfree ((void *) next); 185 } 186 file_symbols = NULL; 187 188 for (next = global_symbols; next != NULL; next = next1) 189 { 190 next1 = next->next; 191 xfree ((void *) next); 192 } 193 global_symbols = NULL; 194 195 if (pending_macros) 196 free_macro_table (pending_macros); 197} 198 199/* This function is called to discard any pending blocks. */ 200 201void 202free_pending_blocks (void) 203{ 204#if 0 /* Now we make the links in the 205 objfile_obstack, so don't free 206 them. */ 207 struct pending_block *bnext, *bnext1; 208 209 for (bnext = pending_blocks; bnext; bnext = bnext1) 210 { 211 bnext1 = bnext->next; 212 xfree ((void *) bnext); 213 } 214#endif 215 pending_blocks = NULL; 216} 217 218/* Take one of the lists of symbols and make a block from it. Keep 219 the order the symbols have in the list (reversed from the input 220 file). Put the block on the list of pending blocks. */ 221 222void 223finish_block (struct symbol *symbol, struct pending **listhead, 224 struct pending_block *old_blocks, 225 CORE_ADDR start, CORE_ADDR end, 226 struct objfile *objfile) 227{ 228 struct pending *next, *next1; 229 struct block *block; 230 struct pending_block *pblock; 231 struct pending_block *opblock; 232 233 block = allocate_block (&objfile->objfile_obstack); 234 235 if (symbol) 236 { 237 BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack, 238 *listhead); 239 } 240 else 241 { 242 BLOCK_DICT (block) = dict_create_hashed (&objfile->objfile_obstack, 243 *listhead); 244 } 245 246 BLOCK_START (block) = start; 247 BLOCK_END (block) = end; 248 /* Superblock filled in when containing block is made */ 249 BLOCK_SUPERBLOCK (block) = NULL; 250 BLOCK_NAMESPACE (block) = NULL; 251 252 BLOCK_GCC_COMPILED (block) = processing_gcc_compilation; 253 254 /* Put the block in as the value of the symbol that names it. */ 255 256 if (symbol) 257 { 258 struct type *ftype = SYMBOL_TYPE (symbol); 259 struct dict_iterator iter; 260 SYMBOL_BLOCK_VALUE (symbol) = block; 261 BLOCK_FUNCTION (block) = symbol; 262 263 if (TYPE_NFIELDS (ftype) <= 0) 264 { 265 /* No parameter type information is recorded with the 266 function's type. Set that from the type of the 267 parameter symbols. */ 268 int nparams = 0, iparams; 269 struct symbol *sym; 270 ALL_BLOCK_SYMBOLS (block, iter, sym) 271 { 272 switch (SYMBOL_CLASS (sym)) 273 { 274 case LOC_ARG: 275 case LOC_REF_ARG: 276 case LOC_REGPARM: 277 case LOC_REGPARM_ADDR: 278 case LOC_BASEREG_ARG: 279 case LOC_LOCAL_ARG: 280 case LOC_COMPUTED_ARG: 281 nparams++; 282 break; 283 case LOC_UNDEF: 284 case LOC_CONST: 285 case LOC_STATIC: 286 case LOC_INDIRECT: 287 case LOC_REGISTER: 288 case LOC_LOCAL: 289 case LOC_TYPEDEF: 290 case LOC_LABEL: 291 case LOC_BLOCK: 292 case LOC_CONST_BYTES: 293 case LOC_BASEREG: 294 case LOC_UNRESOLVED: 295 case LOC_OPTIMIZED_OUT: 296 case LOC_COMPUTED: 297 default: 298 break; 299 } 300 } 301 if (nparams > 0) 302 { 303 TYPE_NFIELDS (ftype) = nparams; 304 TYPE_FIELDS (ftype) = (struct field *) 305 TYPE_ALLOC (ftype, nparams * sizeof (struct field)); 306 307 iparams = 0; 308 ALL_BLOCK_SYMBOLS (block, iter, sym) 309 { 310 if (iparams == nparams) 311 break; 312 313 switch (SYMBOL_CLASS (sym)) 314 { 315 case LOC_ARG: 316 case LOC_REF_ARG: 317 case LOC_REGPARM: 318 case LOC_REGPARM_ADDR: 319 case LOC_BASEREG_ARG: 320 case LOC_LOCAL_ARG: 321 case LOC_COMPUTED_ARG: 322 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); 323 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; 324 iparams++; 325 break; 326 case LOC_UNDEF: 327 case LOC_CONST: 328 case LOC_STATIC: 329 case LOC_INDIRECT: 330 case LOC_REGISTER: 331 case LOC_LOCAL: 332 case LOC_TYPEDEF: 333 case LOC_LABEL: 334 case LOC_BLOCK: 335 case LOC_CONST_BYTES: 336 case LOC_BASEREG: 337 case LOC_UNRESOLVED: 338 case LOC_OPTIMIZED_OUT: 339 case LOC_COMPUTED: 340 default: 341 break; 342 } 343 } 344 } 345 } 346 347 /* If we're in the C++ case, set the block's scope. */ 348 if (SYMBOL_LANGUAGE (symbol) == language_cplus) 349 { 350 cp_set_block_scope (symbol, block, &objfile->objfile_obstack); 351 } 352 } 353 else 354 { 355 BLOCK_FUNCTION (block) = NULL; 356 } 357 358 /* Now "free" the links of the list, and empty the list. */ 359 360 for (next = *listhead; next; next = next1) 361 { 362 next1 = next->next; 363 next->next = free_pendings; 364 free_pendings = next; 365 } 366 *listhead = NULL; 367 368#if 1 369 /* Check to be sure that the blocks have an end address that is 370 greater than starting address */ 371 372 if (BLOCK_END (block) < BLOCK_START (block)) 373 { 374 if (symbol) 375 { 376 complaint (&symfile_complaints, 377 "block end address less than block start address in %s (patched it)", 378 SYMBOL_PRINT_NAME (symbol)); 379 } 380 else 381 { 382 complaint (&symfile_complaints, 383 "block end address 0x%s less than block start address 0x%s (patched it)", 384 paddr_nz (BLOCK_END (block)), paddr_nz (BLOCK_START (block))); 385 } 386 /* Better than nothing */ 387 BLOCK_END (block) = BLOCK_START (block); 388 } 389#endif 390 391 /* Install this block as the superblock of all blocks made since the 392 start of this scope that don't have superblocks yet. */ 393 394 opblock = NULL; 395 for (pblock = pending_blocks; 396 pblock && pblock != old_blocks; 397 pblock = pblock->next) 398 { 399 if (BLOCK_SUPERBLOCK (pblock->block) == NULL) 400 { 401#if 1 402 /* Check to be sure the blocks are nested as we receive 403 them. If the compiler/assembler/linker work, this just 404 burns a small amount of time. */ 405 if (BLOCK_START (pblock->block) < BLOCK_START (block) || 406 BLOCK_END (pblock->block) > BLOCK_END (block)) 407 { 408 if (symbol) 409 { 410 complaint (&symfile_complaints, 411 "inner block not inside outer block in %s", 412 SYMBOL_PRINT_NAME (symbol)); 413 } 414 else 415 { 416 complaint (&symfile_complaints, 417 "inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)", 418 paddr_nz (BLOCK_START (pblock->block)), 419 paddr_nz (BLOCK_END (pblock->block)), 420 paddr_nz (BLOCK_START (block)), 421 paddr_nz (BLOCK_END (block))); 422 } 423 if (BLOCK_START (pblock->block) < BLOCK_START (block)) 424 BLOCK_START (pblock->block) = BLOCK_START (block); 425 if (BLOCK_END (pblock->block) > BLOCK_END (block)) 426 BLOCK_END (pblock->block) = BLOCK_END (block); 427 } 428#endif 429 BLOCK_SUPERBLOCK (pblock->block) = block; 430 } 431 opblock = pblock; 432 } 433 434 record_pending_block (objfile, block, opblock); 435} 436 437 438/* Record BLOCK on the list of all blocks in the file. Put it after 439 OPBLOCK, or at the beginning if opblock is NULL. This puts the 440 block in the list after all its subblocks. 441 442 Allocate the pending block struct in the objfile_obstack to save 443 time. This wastes a little space. FIXME: Is it worth it? */ 444 445void 446record_pending_block (struct objfile *objfile, struct block *block, 447 struct pending_block *opblock) 448{ 449 struct pending_block *pblock; 450 451 pblock = (struct pending_block *) 452 obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block)); 453 pblock->block = block; 454 if (opblock) 455 { 456 pblock->next = opblock->next; 457 opblock->next = pblock; 458 } 459 else 460 { 461 pblock->next = pending_blocks; 462 pending_blocks = pblock; 463 } 464} 465 466static struct blockvector * 467make_blockvector (struct objfile *objfile) 468{ 469 struct pending_block *next; 470 struct blockvector *blockvector; 471 int i; 472 473 /* Count the length of the list of blocks. */ 474 475 for (next = pending_blocks, i = 0; next; next = next->next, i++) 476 {; 477 } 478 479 blockvector = (struct blockvector *) 480 obstack_alloc (&objfile->objfile_obstack, 481 (sizeof (struct blockvector) 482 + (i - 1) * sizeof (struct block *))); 483 484 /* Copy the blocks into the blockvector. This is done in reverse 485 order, which happens to put the blocks into the proper order 486 (ascending starting address). finish_block has hair to insert 487 each block into the list after its subblocks in order to make 488 sure this is true. */ 489 490 BLOCKVECTOR_NBLOCKS (blockvector) = i; 491 for (next = pending_blocks; next; next = next->next) 492 { 493 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block; 494 } 495 496#if 0 /* Now we make the links in the 497 obstack, so don't free them. */ 498 /* Now free the links of the list, and empty the list. */ 499 500 for (next = pending_blocks; next; next = next1) 501 { 502 next1 = next->next; 503 xfree (next); 504 } 505#endif 506 pending_blocks = NULL; 507 508#if 1 /* FIXME, shut this off after a while 509 to speed up symbol reading. */ 510 /* Some compilers output blocks in the wrong order, but we depend on 511 their being in the right order so we can binary search. Check the 512 order and moan about it. FIXME. */ 513 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1) 514 { 515 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) 516 { 517 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1)) 518 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))) 519 { 520 CORE_ADDR start 521 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)); 522 523 complaint (&symfile_complaints, "block at %s out of order", 524 local_hex_string ((LONGEST) start)); 525 } 526 } 527 } 528#endif 529 530 return (blockvector); 531} 532 533/* Start recording information about source code that came from an 534 included (or otherwise merged-in) source file with a different 535 name. NAME is the name of the file (cannot be NULL), DIRNAME is 536 the directory in which it resides (or NULL if not known). */ 537 538void 539start_subfile (char *name, char *dirname) 540{ 541 struct subfile *subfile; 542 543 /* See if this subfile is already known as a subfile of the current 544 main source file. */ 545 546 for (subfile = subfiles; subfile; subfile = subfile->next) 547 { 548 if (FILENAME_CMP (subfile->name, name) == 0) 549 { 550 current_subfile = subfile; 551 return; 552 } 553 } 554 555 /* This subfile is not known. Add an entry for it. Make an entry 556 for this subfile in the list of all subfiles of the current main 557 source file. */ 558 559 subfile = (struct subfile *) xmalloc (sizeof (struct subfile)); 560 memset ((char *) subfile, 0, sizeof (struct subfile)); 561 subfile->next = subfiles; 562 subfiles = subfile; 563 current_subfile = subfile; 564 565 /* Save its name and compilation directory name */ 566 subfile->name = (name == NULL) ? NULL : savestring (name, strlen (name)); 567 subfile->dirname = 568 (dirname == NULL) ? NULL : savestring (dirname, strlen (dirname)); 569 570 /* Initialize line-number recording for this subfile. */ 571 subfile->line_vector = NULL; 572 573 /* Default the source language to whatever can be deduced from the 574 filename. If nothing can be deduced (such as for a C/C++ include 575 file with a ".h" extension), then inherit whatever language the 576 previous subfile had. This kludgery is necessary because there 577 is no standard way in some object formats to record the source 578 language. Also, when symtabs are allocated we try to deduce a 579 language then as well, but it is too late for us to use that 580 information while reading symbols, since symtabs aren't allocated 581 until after all the symbols have been processed for a given 582 source file. */ 583 584 subfile->language = deduce_language_from_filename (subfile->name); 585 if (subfile->language == language_unknown && 586 subfile->next != NULL) 587 { 588 subfile->language = subfile->next->language; 589 } 590 591 /* Initialize the debug format string to NULL. We may supply it 592 later via a call to record_debugformat. */ 593 subfile->debugformat = NULL; 594 595 /* If the filename of this subfile ends in .C, then change the 596 language of any pending subfiles from C to C++. We also accept 597 any other C++ suffixes accepted by deduce_language_from_filename. */ 598 /* Likewise for f2c. */ 599 600 if (subfile->name) 601 { 602 struct subfile *s; 603 enum language sublang = deduce_language_from_filename (subfile->name); 604 605 if (sublang == language_cplus || sublang == language_fortran) 606 for (s = subfiles; s != NULL; s = s->next) 607 if (s->language == language_c) 608 s->language = sublang; 609 } 610 611 /* And patch up this file if necessary. */ 612 if (subfile->language == language_c 613 && subfile->next != NULL 614 && (subfile->next->language == language_cplus 615 || subfile->next->language == language_fortran)) 616 { 617 subfile->language = subfile->next->language; 618 } 619} 620 621/* For stabs readers, the first N_SO symbol is assumed to be the 622 source file name, and the subfile struct is initialized using that 623 assumption. If another N_SO symbol is later seen, immediately 624 following the first one, then the first one is assumed to be the 625 directory name and the second one is really the source file name. 626 627 So we have to patch up the subfile struct by moving the old name 628 value to dirname and remembering the new name. Some sanity 629 checking is performed to ensure that the state of the subfile 630 struct is reasonable and that the old name we are assuming to be a 631 directory name actually is (by checking for a trailing '/'). */ 632 633void 634patch_subfile_names (struct subfile *subfile, char *name) 635{ 636 if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL 637 && subfile->name[strlen (subfile->name) - 1] == '/') 638 { 639 subfile->dirname = subfile->name; 640 subfile->name = savestring (name, strlen (name)); 641 last_source_file = name; 642 643 /* Default the source language to whatever can be deduced from 644 the filename. If nothing can be deduced (such as for a C/C++ 645 include file with a ".h" extension), then inherit whatever 646 language the previous subfile had. This kludgery is 647 necessary because there is no standard way in some object 648 formats to record the source language. Also, when symtabs 649 are allocated we try to deduce a language then as well, but 650 it is too late for us to use that information while reading 651 symbols, since symtabs aren't allocated until after all the 652 symbols have been processed for a given source file. */ 653 654 subfile->language = deduce_language_from_filename (subfile->name); 655 if (subfile->language == language_unknown && 656 subfile->next != NULL) 657 { 658 subfile->language = subfile->next->language; 659 } 660 } 661} 662 663/* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for 664 switching source files (different subfiles, as we call them) within 665 one object file, but using a stack rather than in an arbitrary 666 order. */ 667 668void 669push_subfile (void) 670{ 671 struct subfile_stack *tem 672 = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack)); 673 674 tem->next = subfile_stack; 675 subfile_stack = tem; 676 if (current_subfile == NULL || current_subfile->name == NULL) 677 { 678 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 679 } 680 tem->name = current_subfile->name; 681} 682 683char * 684pop_subfile (void) 685{ 686 char *name; 687 struct subfile_stack *link = subfile_stack; 688 689 if (link == NULL) 690 { 691 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 692 } 693 name = link->name; 694 subfile_stack = link->next; 695 xfree ((void *) link); 696 return (name); 697} 698 699/* Add a linetable entry for line number LINE and address PC to the 700 line vector for SUBFILE. */ 701 702void 703record_line (struct subfile *subfile, int line, CORE_ADDR pc) 704{ 705 struct linetable_entry *e; 706 /* Ignore the dummy line number in libg.o */ 707 708 if (line == 0xffff) 709 { 710 return; 711 } 712 713 /* Make sure line vector exists and is big enough. */ 714 if (!subfile->line_vector) 715 { 716 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH; 717 subfile->line_vector = (struct linetable *) 718 xmalloc (sizeof (struct linetable) 719 + subfile->line_vector_length * sizeof (struct linetable_entry)); 720 subfile->line_vector->nitems = 0; 721 have_line_numbers = 1; 722 } 723 724 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length) 725 { 726 subfile->line_vector_length *= 2; 727 subfile->line_vector = (struct linetable *) 728 xrealloc ((char *) subfile->line_vector, 729 (sizeof (struct linetable) 730 + (subfile->line_vector_length 731 * sizeof (struct linetable_entry)))); 732 } 733 734 e = subfile->line_vector->item + subfile->line_vector->nitems++; 735 e->line = line; 736 e->pc = ADDR_BITS_REMOVE(pc); 737} 738 739/* Needed in order to sort line tables from IBM xcoff files. Sigh! */ 740 741static int 742compare_line_numbers (const void *ln1p, const void *ln2p) 743{ 744 struct linetable_entry *ln1 = (struct linetable_entry *) ln1p; 745 struct linetable_entry *ln2 = (struct linetable_entry *) ln2p; 746 747 /* Note: this code does not assume that CORE_ADDRs can fit in ints. 748 Please keep it that way. */ 749 if (ln1->pc < ln2->pc) 750 return -1; 751 752 if (ln1->pc > ln2->pc) 753 return 1; 754 755 /* If pc equal, sort by line. I'm not sure whether this is optimum 756 behavior (see comment at struct linetable in symtab.h). */ 757 return ln1->line - ln2->line; 758} 759 760/* Start a new symtab for a new source file. Called, for example, 761 when a stabs symbol of type N_SO is seen, or when a DWARF 762 TAG_compile_unit DIE is seen. It indicates the start of data for 763 one original source file. */ 764 765void 766start_symtab (char *name, char *dirname, CORE_ADDR start_addr) 767{ 768 769 last_source_file = name; 770 last_source_start_addr = start_addr; 771 file_symbols = NULL; 772 global_symbols = NULL; 773 within_function = 0; 774 have_line_numbers = 0; 775 776 /* Context stack is initially empty. Allocate first one with room 777 for 10 levels; reuse it forever afterward. */ 778 if (context_stack == NULL) 779 { 780 context_stack_size = INITIAL_CONTEXT_STACK_SIZE; 781 context_stack = (struct context_stack *) 782 xmalloc (context_stack_size * sizeof (struct context_stack)); 783 } 784 context_stack_depth = 0; 785 786 /* Set up support for C++ namespace support, in case we need it. */ 787 788 cp_initialize_namespace (); 789 790 /* Initialize the list of sub source files with one entry for this 791 file (the top-level source file). */ 792 793 subfiles = NULL; 794 current_subfile = NULL; 795 start_subfile (name, dirname); 796} 797 798/* Finish the symbol definitions for one main source file, close off 799 all the lexical contexts for that file (creating struct block's for 800 them), then make the struct symtab for that file and put it in the 801 list of all such. 802 803 END_ADDR is the address of the end of the file's text. SECTION is 804 the section number (in objfile->section_offsets) of the blockvector 805 and linetable. 806 807 Note that it is possible for end_symtab() to return NULL. In 808 particular, for the DWARF case at least, it will return NULL when 809 it finds a compilation unit that has exactly one DIE, a 810 TAG_compile_unit DIE. This can happen when we link in an object 811 file that was compiled from an empty source file. Returning NULL 812 is probably not the correct thing to do, because then gdb will 813 never know about this empty file (FIXME). */ 814 815struct symtab * 816end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section) 817{ 818 struct symtab *symtab = NULL; 819 struct blockvector *blockvector; 820 struct subfile *subfile; 821 struct context_stack *cstk; 822 struct subfile *nextsub; 823 824 /* Finish the lexical context of the last function in the file; pop 825 the context stack. */ 826 827 if (context_stack_depth > 0) 828 { 829 cstk = pop_context (); 830 /* Make a block for the local symbols within. */ 831 finish_block (cstk->name, &local_symbols, cstk->old_blocks, 832 cstk->start_addr, end_addr, objfile); 833 834 if (context_stack_depth > 0) 835 { 836 /* This is said to happen with SCO. The old coffread.c 837 code simply emptied the context stack, so we do the 838 same. FIXME: Find out why it is happening. This is not 839 believed to happen in most cases (even for coffread.c); 840 it used to be an abort(). */ 841 complaint (&symfile_complaints, 842 "Context stack not empty in end_symtab"); 843 context_stack_depth = 0; 844 } 845 } 846 847 /* Reordered executables may have out of order pending blocks; if 848 OBJF_REORDERED is true, then sort the pending blocks. */ 849 if ((objfile->flags & OBJF_REORDERED) && pending_blocks) 850 { 851 /* FIXME! Remove this horrid bubble sort and use merge sort!!! */ 852 int swapped; 853 do 854 { 855 struct pending_block *pb, *pbnext; 856 857 pb = pending_blocks; 858 pbnext = pb->next; 859 swapped = 0; 860 861 while (pbnext) 862 { 863 /* swap blocks if unordered! */ 864 865 if (BLOCK_START (pb->block) < BLOCK_START (pbnext->block)) 866 { 867 struct block *tmp = pb->block; 868 pb->block = pbnext->block; 869 pbnext->block = tmp; 870 swapped = 1; 871 } 872 pb = pbnext; 873 pbnext = pbnext->next; 874 } 875 } 876 while (swapped); 877 } 878 879 /* Cleanup any undefined types that have been left hanging around 880 (this needs to be done before the finish_blocks so that 881 file_symbols is still good). 882 883 Both cleanup_undefined_types and finish_global_stabs are stabs 884 specific, but harmless for other symbol readers, since on gdb 885 startup or when finished reading stabs, the state is set so these 886 are no-ops. FIXME: Is this handled right in case of QUIT? Can 887 we make this cleaner? */ 888 889 cleanup_undefined_types (); 890 finish_global_stabs (objfile); 891 892 if (pending_blocks == NULL 893 && file_symbols == NULL 894 && global_symbols == NULL 895 && have_line_numbers == 0 896 && pending_macros == NULL) 897 { 898 /* Ignore symtabs that have no functions with real debugging 899 info. */ 900 blockvector = NULL; 901 } 902 else 903 { 904 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the 905 blockvector. */ 906 finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, 907 objfile); 908 finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, 909 objfile); 910 blockvector = make_blockvector (objfile); 911 cp_finalize_namespace (BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK), 912 &objfile->objfile_obstack); 913 } 914 915#ifndef PROCESS_LINENUMBER_HOOK 916#define PROCESS_LINENUMBER_HOOK() 917#endif 918 PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */ 919 920 /* Now create the symtab objects proper, one for each subfile. */ 921 /* (The main file is the last one on the chain.) */ 922 923 for (subfile = subfiles; subfile; subfile = nextsub) 924 { 925 int linetablesize = 0; 926 symtab = NULL; 927 928 /* If we have blocks of symbols, make a symtab. Otherwise, just 929 ignore this file and any line number info in it. */ 930 if (blockvector) 931 { 932 if (subfile->line_vector) 933 { 934 linetablesize = sizeof (struct linetable) + 935 subfile->line_vector->nitems * sizeof (struct linetable_entry); 936#if 0 937 /* I think this is artifact from before it went on the 938 obstack. I doubt we'll need the memory between now 939 and when we free it later in this function. */ 940 /* First, shrink the linetable to make more memory. */ 941 subfile->line_vector = (struct linetable *) 942 xrealloc ((char *) subfile->line_vector, linetablesize); 943#endif 944 945 /* Like the pending blocks, the line table may be 946 scrambled in reordered executables. Sort it if 947 OBJF_REORDERED is true. */ 948 if (objfile->flags & OBJF_REORDERED) 949 qsort (subfile->line_vector->item, 950 subfile->line_vector->nitems, 951 sizeof (struct linetable_entry), compare_line_numbers); 952 } 953 954 /* Now, allocate a symbol table. */ 955 symtab = allocate_symtab (subfile->name, objfile); 956 957 /* Fill in its components. */ 958 symtab->blockvector = blockvector; 959 symtab->macro_table = pending_macros; 960 if (subfile->line_vector) 961 { 962 /* Reallocate the line table on the symbol obstack */ 963 symtab->linetable = (struct linetable *) 964 obstack_alloc (&objfile->objfile_obstack, linetablesize); 965 memcpy (symtab->linetable, subfile->line_vector, linetablesize); 966 } 967 else 968 { 969 symtab->linetable = NULL; 970 } 971 symtab->block_line_section = section; 972 if (subfile->dirname) 973 { 974 /* Reallocate the dirname on the symbol obstack */ 975 symtab->dirname = (char *) 976 obstack_alloc (&objfile->objfile_obstack, 977 strlen (subfile->dirname) + 1); 978 strcpy (symtab->dirname, subfile->dirname); 979 } 980 else 981 { 982 symtab->dirname = NULL; 983 } 984 symtab->free_code = free_linetable; 985 symtab->free_func = NULL; 986 987 /* Use whatever language we have been using for this 988 subfile, not the one that was deduced in allocate_symtab 989 from the filename. We already did our own deducing when 990 we created the subfile, and we may have altered our 991 opinion of what language it is from things we found in 992 the symbols. */ 993 symtab->language = subfile->language; 994 995 /* Save the debug format string (if any) in the symtab */ 996 if (subfile->debugformat != NULL) 997 { 998 symtab->debugformat = obsavestring (subfile->debugformat, 999 strlen (subfile->debugformat), 1000 &objfile->objfile_obstack); 1001 } 1002 1003 /* All symtabs for the main file and the subfiles share a 1004 blockvector, so we need to clear primary for everything 1005 but the main file. */ 1006 1007 symtab->primary = 0; 1008 } 1009 if (subfile->name != NULL) 1010 { 1011 xfree ((void *) subfile->name); 1012 } 1013 if (subfile->dirname != NULL) 1014 { 1015 xfree ((void *) subfile->dirname); 1016 } 1017 if (subfile->line_vector != NULL) 1018 { 1019 xfree ((void *) subfile->line_vector); 1020 } 1021 if (subfile->debugformat != NULL) 1022 { 1023 xfree ((void *) subfile->debugformat); 1024 } 1025 1026 nextsub = subfile->next; 1027 xfree ((void *) subfile); 1028 } 1029 1030 /* Set this for the main source file. */ 1031 if (symtab) 1032 { 1033 symtab->primary = 1; 1034 } 1035 1036 last_source_file = NULL; 1037 current_subfile = NULL; 1038 pending_macros = NULL; 1039 1040 return symtab; 1041} 1042 1043/* Push a context block. Args are an identifying nesting level 1044 (checkable when you pop it), and the starting PC address of this 1045 context. */ 1046 1047struct context_stack * 1048push_context (int desc, CORE_ADDR valu) 1049{ 1050 struct context_stack *new; 1051 1052 if (context_stack_depth == context_stack_size) 1053 { 1054 context_stack_size *= 2; 1055 context_stack = (struct context_stack *) 1056 xrealloc ((char *) context_stack, 1057 (context_stack_size * sizeof (struct context_stack))); 1058 } 1059 1060 new = &context_stack[context_stack_depth++]; 1061 new->depth = desc; 1062 new->locals = local_symbols; 1063 new->params = param_symbols; 1064 new->old_blocks = pending_blocks; 1065 new->start_addr = valu; 1066 new->name = NULL; 1067 1068 local_symbols = NULL; 1069 param_symbols = NULL; 1070 1071 return new; 1072} 1073 1074/* Pop a context block. Returns the address of the context block just 1075 popped. */ 1076 1077struct context_stack * 1078pop_context (void) 1079{ 1080 gdb_assert (context_stack_depth > 0); 1081 return (&context_stack[--context_stack_depth]); 1082} 1083 1084 1085 1086/* Compute a small integer hash code for the given name. */ 1087 1088int 1089hashname (char *name) 1090{ 1091 return (hash(name,strlen(name)) % HASHSIZE); 1092} 1093 1094 1095void 1096record_debugformat (char *format) 1097{ 1098 current_subfile->debugformat = savestring (format, strlen (format)); 1099} 1100 1101/* Merge the first symbol list SRCLIST into the second symbol list 1102 TARGETLIST by repeated calls to add_symbol_to_list(). This 1103 procedure "frees" each link of SRCLIST by adding it to the 1104 free_pendings list. Caller must set SRCLIST to a null list after 1105 calling this function. 1106 1107 Void return. */ 1108 1109void 1110merge_symbol_lists (struct pending **srclist, struct pending **targetlist) 1111{ 1112 int i; 1113 1114 if (!srclist || !*srclist) 1115 return; 1116 1117 /* Merge in elements from current link. */ 1118 for (i = 0; i < (*srclist)->nsyms; i++) 1119 add_symbol_to_list ((*srclist)->symbol[i], targetlist); 1120 1121 /* Recurse on next. */ 1122 merge_symbol_lists (&(*srclist)->next, targetlist); 1123 1124 /* "Free" the current link. */ 1125 (*srclist)->next = free_pendings; 1126 free_pendings = (*srclist); 1127} 1128 1129/* Initialize anything that needs initializing when starting to read a 1130 fresh piece of a symbol file, e.g. reading in the stuff 1131 corresponding to a psymtab. */ 1132 1133void 1134buildsym_init (void) 1135{ 1136 free_pendings = NULL; 1137 file_symbols = NULL; 1138 global_symbols = NULL; 1139 pending_blocks = NULL; 1140 pending_macros = NULL; 1141} 1142 1143/* Initialize anything that needs initializing when a completely new 1144 symbol file is specified (not just adding some symbols from another 1145 file, e.g. a shared library). */ 1146 1147void 1148buildsym_new_init (void) 1149{ 1150 buildsym_init (); 1151} 1152