1 /* Support routines for building symbol tables in GDB's internal format. 2 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 3 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 4 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>. */ 20 21 /* This module provides subroutines used for creating and adding to 22 the symbol table. These routines are called from various symbol- 23 file-reading routines. 24 25 Routines to support specific debugging information formats (stabs, 26 DWARF, etc) belong somewhere else. */ 27 28 #include "defs.h" 29 #include "bfd.h" 30 #include "gdb_obstack.h" 31 #include "symtab.h" 32 #include "symfile.h" 33 #include "objfiles.h" 34 #include "gdbtypes.h" 35 #include "gdb_assert.h" 36 #include "complaints.h" 37 #include "gdb_string.h" 38 #include "expression.h" /* For "enum exp_opcode" used by... */ 39 #include "bcache.h" 40 #include "filenames.h" /* For DOSish file names. */ 41 #include "macrotab.h" 42 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ 43 #include "block.h" 44 #include "cp-support.h" 45 #include "dictionary.h" 46 #include "addrmap.h" 47 48 /* Ask buildsym.h to define the vars it normally declares `extern'. */ 49 #define EXTERN 50 /**/ 51 #include "buildsym.h" /* Our own declarations. */ 52 #undef EXTERN 53 54 /* For cleanup_undefined_types and finish_global_stabs (somewhat 55 questionable--see comment where we call them). */ 56 57 #include "stabsread.h" 58 59 /* List of subfiles. */ 60 61 static struct subfile *subfiles; 62 63 /* List of free `struct pending' structures for reuse. */ 64 65 static struct pending *free_pendings; 66 67 /* Non-zero if symtab has line number info. This prevents an 68 otherwise empty symtab from being tossed. */ 69 70 static int have_line_numbers; 71 72 /* The mutable address map for the compilation unit whose symbols 73 we're currently reading. The symtabs' shared blockvector will 74 point to a fixed copy of this. */ 75 static struct addrmap *pending_addrmap; 76 77 /* The obstack on which we allocate pending_addrmap. 78 If pending_addrmap is NULL, this is uninitialized; otherwise, it is 79 initialized (and holds pending_addrmap). */ 80 static struct obstack pending_addrmap_obstack; 81 82 /* Non-zero if we recorded any ranges in the addrmap that are 83 different from those in the blockvector already. We set this to 84 zero when we start processing a symfile, and if it's still zero at 85 the end, then we just toss the addrmap. */ 86 static int pending_addrmap_interesting; 87 88 89 static int compare_line_numbers (const void *ln1p, const void *ln2p); 90 91 92 /* Initial sizes of data structures. These are realloc'd larger if 93 needed, and realloc'd down to the size actually used, when 94 completed. */ 95 96 #define INITIAL_CONTEXT_STACK_SIZE 10 97 #define INITIAL_LINE_VECTOR_LENGTH 1000 98 99 100 /* Maintain the lists of symbols and blocks. */ 101 102 /* Add a pending list to free_pendings. */ 103 void 104 add_free_pendings (struct pending *list) 105 { 106 struct pending *link = list; 107 108 if (list) 109 { 110 while (link->next) link = link->next; 111 link->next = free_pendings; 112 free_pendings = list; 113 } 114 } 115 116 /* Add a symbol to one of the lists of symbols. While we're at it, if 117 we're in the C++ case and don't have full namespace debugging info, 118 check to see if it references an anonymous namespace; if so, add an 119 appropriate using directive. */ 120 121 void 122 add_symbol_to_list (struct symbol *symbol, struct pending **listhead) 123 { 124 struct pending *link; 125 126 /* If this is an alias for another symbol, don't add it. */ 127 if (symbol->ginfo.name && symbol->ginfo.name[0] == '#') 128 return; 129 130 /* We keep PENDINGSIZE symbols in each link of the list. If we 131 don't have a link with room in it, add a new link. */ 132 if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE) 133 { 134 if (free_pendings) 135 { 136 link = free_pendings; 137 free_pendings = link->next; 138 } 139 else 140 { 141 link = (struct pending *) xmalloc (sizeof (struct pending)); 142 } 143 144 link->next = *listhead; 145 *listhead = link; 146 link->nsyms = 0; 147 } 148 149 (*listhead)->symbol[(*listhead)->nsyms++] = symbol; 150 } 151 152 /* Find a symbol named NAME on a LIST. NAME need not be 153 '\0'-terminated; LENGTH is the length of the name. */ 154 155 struct symbol * 156 find_symbol_in_list (struct pending *list, char *name, int length) 157 { 158 int j; 159 char *pp; 160 161 while (list != NULL) 162 { 163 for (j = list->nsyms; --j >= 0;) 164 { 165 pp = SYMBOL_LINKAGE_NAME (list->symbol[j]); 166 if (*pp == *name && strncmp (pp, name, length) == 0 167 && pp[length] == '\0') 168 { 169 return (list->symbol[j]); 170 } 171 } 172 list = list->next; 173 } 174 return (NULL); 175 } 176 177 /* At end of reading syms, or in case of quit, really free as many 178 `struct pending's as we can easily find. */ 179 180 void 181 really_free_pendings (void *dummy) 182 { 183 struct pending *next, *next1; 184 185 for (next = free_pendings; next; next = next1) 186 { 187 next1 = next->next; 188 xfree ((void *) next); 189 } 190 free_pendings = NULL; 191 192 free_pending_blocks (); 193 194 for (next = file_symbols; next != NULL; next = next1) 195 { 196 next1 = next->next; 197 xfree ((void *) next); 198 } 199 file_symbols = NULL; 200 201 for (next = global_symbols; next != NULL; next = next1) 202 { 203 next1 = next->next; 204 xfree ((void *) next); 205 } 206 global_symbols = NULL; 207 208 if (pending_macros) 209 free_macro_table (pending_macros); 210 211 if (pending_addrmap) 212 { 213 obstack_free (&pending_addrmap_obstack, NULL); 214 pending_addrmap = NULL; 215 } 216 } 217 218 /* This function is called to discard any pending blocks. */ 219 220 void 221 free_pending_blocks (void) 222 { 223 /* The links are made in the objfile_obstack, so we only need to 224 reset PENDING_BLOCKS. */ 225 pending_blocks = NULL; 226 } 227 228 /* Take one of the lists of symbols and make a block from it. Keep 229 the order the symbols have in the list (reversed from the input 230 file). Put the block on the list of pending blocks. */ 231 232 struct block * 233 finish_block (struct symbol *symbol, struct pending **listhead, 234 struct pending_block *old_blocks, 235 CORE_ADDR start, CORE_ADDR end, 236 struct objfile *objfile) 237 { 238 struct gdbarch *gdbarch = get_objfile_arch (objfile); 239 struct pending *next, *next1; 240 struct block *block; 241 struct pending_block *pblock; 242 struct pending_block *opblock; 243 244 block = allocate_block (&objfile->objfile_obstack); 245 246 if (symbol) 247 { 248 BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack, 249 *listhead); 250 } 251 else 252 { 253 BLOCK_DICT (block) = dict_create_hashed (&objfile->objfile_obstack, 254 *listhead); 255 } 256 257 BLOCK_START (block) = start; 258 BLOCK_END (block) = end; 259 /* Superblock filled in when containing block is made. */ 260 BLOCK_SUPERBLOCK (block) = NULL; 261 BLOCK_NAMESPACE (block) = NULL; 262 263 /* Put the block in as the value of the symbol that names it. */ 264 265 if (symbol) 266 { 267 struct type *ftype = SYMBOL_TYPE (symbol); 268 struct dict_iterator iter; 269 SYMBOL_BLOCK_VALUE (symbol) = block; 270 BLOCK_FUNCTION (block) = symbol; 271 272 if (TYPE_NFIELDS (ftype) <= 0) 273 { 274 /* No parameter type information is recorded with the 275 function's type. Set that from the type of the 276 parameter symbols. */ 277 int nparams = 0, iparams; 278 struct symbol *sym; 279 ALL_BLOCK_SYMBOLS (block, iter, sym) 280 { 281 if (SYMBOL_IS_ARGUMENT (sym)) 282 nparams++; 283 } 284 if (nparams > 0) 285 { 286 TYPE_NFIELDS (ftype) = nparams; 287 TYPE_FIELDS (ftype) = (struct field *) 288 TYPE_ALLOC (ftype, nparams * sizeof (struct field)); 289 290 iparams = 0; 291 ALL_BLOCK_SYMBOLS (block, iter, sym) 292 { 293 if (iparams == nparams) 294 break; 295 296 if (SYMBOL_IS_ARGUMENT (sym)) 297 { 298 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); 299 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; 300 iparams++; 301 } 302 } 303 } 304 } 305 } 306 else 307 { 308 BLOCK_FUNCTION (block) = NULL; 309 } 310 311 /* Now "free" the links of the list, and empty the list. */ 312 313 for (next = *listhead; next; next = next1) 314 { 315 next1 = next->next; 316 next->next = free_pendings; 317 free_pendings = next; 318 } 319 *listhead = NULL; 320 321 /* Check to be sure that the blocks have an end address that is 322 greater than starting address. */ 323 324 if (BLOCK_END (block) < BLOCK_START (block)) 325 { 326 if (symbol) 327 { 328 complaint (&symfile_complaints, 329 _("block end address less than block " 330 "start address in %s (patched it)"), 331 SYMBOL_PRINT_NAME (symbol)); 332 } 333 else 334 { 335 complaint (&symfile_complaints, 336 _("block end address %s less than block " 337 "start address %s (patched it)"), 338 paddress (gdbarch, BLOCK_END (block)), 339 paddress (gdbarch, BLOCK_START (block))); 340 } 341 /* Better than nothing. */ 342 BLOCK_END (block) = BLOCK_START (block); 343 } 344 345 /* Install this block as the superblock of all blocks made since the 346 start of this scope that don't have superblocks yet. */ 347 348 opblock = NULL; 349 for (pblock = pending_blocks; 350 pblock && pblock != old_blocks; 351 pblock = pblock->next) 352 { 353 if (BLOCK_SUPERBLOCK (pblock->block) == NULL) 354 { 355 /* Check to be sure the blocks are nested as we receive 356 them. If the compiler/assembler/linker work, this just 357 burns a small amount of time. 358 359 Skip blocks which correspond to a function; they're not 360 physically nested inside this other blocks, only 361 lexically nested. */ 362 if (BLOCK_FUNCTION (pblock->block) == NULL 363 && (BLOCK_START (pblock->block) < BLOCK_START (block) 364 || BLOCK_END (pblock->block) > BLOCK_END (block))) 365 { 366 if (symbol) 367 { 368 complaint (&symfile_complaints, 369 _("inner block not inside outer block in %s"), 370 SYMBOL_PRINT_NAME (symbol)); 371 } 372 else 373 { 374 complaint (&symfile_complaints, 375 _("inner block (%s-%s) not " 376 "inside outer block (%s-%s)"), 377 paddress (gdbarch, BLOCK_START (pblock->block)), 378 paddress (gdbarch, BLOCK_END (pblock->block)), 379 paddress (gdbarch, BLOCK_START (block)), 380 paddress (gdbarch, BLOCK_END (block))); 381 } 382 if (BLOCK_START (pblock->block) < BLOCK_START (block)) 383 BLOCK_START (pblock->block) = BLOCK_START (block); 384 if (BLOCK_END (pblock->block) > BLOCK_END (block)) 385 BLOCK_END (pblock->block) = BLOCK_END (block); 386 } 387 BLOCK_SUPERBLOCK (pblock->block) = block; 388 } 389 opblock = pblock; 390 } 391 392 block_set_using (block, using_directives, &objfile->objfile_obstack); 393 using_directives = NULL; 394 395 record_pending_block (objfile, block, opblock); 396 397 return block; 398 } 399 400 401 /* Record BLOCK on the list of all blocks in the file. Put it after 402 OPBLOCK, or at the beginning if opblock is NULL. This puts the 403 block in the list after all its subblocks. 404 405 Allocate the pending block struct in the objfile_obstack to save 406 time. This wastes a little space. FIXME: Is it worth it? */ 407 408 void 409 record_pending_block (struct objfile *objfile, struct block *block, 410 struct pending_block *opblock) 411 { 412 struct pending_block *pblock; 413 414 pblock = (struct pending_block *) 415 obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block)); 416 pblock->block = block; 417 if (opblock) 418 { 419 pblock->next = opblock->next; 420 opblock->next = pblock; 421 } 422 else 423 { 424 pblock->next = pending_blocks; 425 pending_blocks = pblock; 426 } 427 } 428 429 430 /* Record that the range of addresses from START to END_INCLUSIVE 431 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end 432 addresses must be set already. You must apply this function to all 433 BLOCK's children before applying it to BLOCK. 434 435 If a call to this function complicates the picture beyond that 436 already provided by BLOCK_START and BLOCK_END, then we create an 437 address map for the block. */ 438 void 439 record_block_range (struct block *block, 440 CORE_ADDR start, CORE_ADDR end_inclusive) 441 { 442 /* If this is any different from the range recorded in the block's 443 own BLOCK_START and BLOCK_END, then note that the address map has 444 become interesting. Note that even if this block doesn't have 445 any "interesting" ranges, some later block might, so we still 446 need to record this block in the addrmap. */ 447 if (start != BLOCK_START (block) 448 || end_inclusive + 1 != BLOCK_END (block)) 449 pending_addrmap_interesting = 1; 450 451 if (! pending_addrmap) 452 { 453 obstack_init (&pending_addrmap_obstack); 454 pending_addrmap = addrmap_create_mutable (&pending_addrmap_obstack); 455 } 456 457 addrmap_set_empty (pending_addrmap, start, end_inclusive, block); 458 } 459 460 461 static struct blockvector * 462 make_blockvector (struct objfile *objfile) 463 { 464 struct pending_block *next; 465 struct blockvector *blockvector; 466 int i; 467 468 /* Count the length of the list of blocks. */ 469 470 for (next = pending_blocks, i = 0; next; next = next->next, i++) 471 {; 472 } 473 474 blockvector = (struct blockvector *) 475 obstack_alloc (&objfile->objfile_obstack, 476 (sizeof (struct blockvector) 477 + (i - 1) * sizeof (struct block *))); 478 479 /* Copy the blocks into the blockvector. This is done in reverse 480 order, which happens to put the blocks into the proper order 481 (ascending starting address). finish_block has hair to insert 482 each block into the list after its subblocks in order to make 483 sure this is true. */ 484 485 BLOCKVECTOR_NBLOCKS (blockvector) = i; 486 for (next = pending_blocks; next; next = next->next) 487 { 488 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block; 489 } 490 491 free_pending_blocks (); 492 493 /* If we needed an address map for this symtab, record it in the 494 blockvector. */ 495 if (pending_addrmap && pending_addrmap_interesting) 496 BLOCKVECTOR_MAP (blockvector) 497 = addrmap_create_fixed (pending_addrmap, &objfile->objfile_obstack); 498 else 499 BLOCKVECTOR_MAP (blockvector) = 0; 500 501 /* Some compilers output blocks in the wrong order, but we depend on 502 their being in the right order so we can binary search. Check the 503 order and moan about it. */ 504 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1) 505 { 506 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) 507 { 508 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1)) 509 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))) 510 { 511 CORE_ADDR start 512 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)); 513 514 complaint (&symfile_complaints, _("block at %s out of order"), 515 hex_string ((LONGEST) start)); 516 } 517 } 518 } 519 520 return (blockvector); 521 } 522 523 /* Start recording information about source code that came from an 524 included (or otherwise merged-in) source file with a different 525 name. NAME is the name of the file (cannot be NULL), DIRNAME is 526 the directory in which the file was compiled (or NULL if not 527 known). */ 528 529 void 530 start_subfile (const char *name, const char *dirname) 531 { 532 struct subfile *subfile; 533 534 /* See if this subfile is already known as a subfile of the current 535 main source file. */ 536 537 for (subfile = subfiles; subfile; subfile = subfile->next) 538 { 539 char *subfile_name; 540 541 /* If NAME is an absolute path, and this subfile is not, then 542 attempt to create an absolute path to compare. */ 543 if (IS_ABSOLUTE_PATH (name) 544 && !IS_ABSOLUTE_PATH (subfile->name) 545 && subfile->dirname != NULL) 546 subfile_name = concat (subfile->dirname, SLASH_STRING, 547 subfile->name, (char *) NULL); 548 else 549 subfile_name = subfile->name; 550 551 if (FILENAME_CMP (subfile_name, name) == 0) 552 { 553 current_subfile = subfile; 554 if (subfile_name != subfile->name) 555 xfree (subfile_name); 556 return; 557 } 558 if (subfile_name != subfile->name) 559 xfree (subfile_name); 560 } 561 562 /* This subfile is not known. Add an entry for it. Make an entry 563 for this subfile in the list of all subfiles of the current main 564 source file. */ 565 566 subfile = (struct subfile *) xmalloc (sizeof (struct subfile)); 567 memset ((char *) subfile, 0, sizeof (struct subfile)); 568 subfile->next = subfiles; 569 subfiles = subfile; 570 current_subfile = subfile; 571 572 /* Save its name and compilation directory name. */ 573 subfile->name = (name == NULL) ? NULL : xstrdup (name); 574 subfile->dirname = (dirname == NULL) ? NULL : xstrdup (dirname); 575 576 /* Initialize line-number recording for this subfile. */ 577 subfile->line_vector = NULL; 578 579 /* Default the source language to whatever can be deduced from the 580 filename. If nothing can be deduced (such as for a C/C++ include 581 file with a ".h" extension), then inherit whatever language the 582 previous subfile had. This kludgery is necessary because there 583 is no standard way in some object formats to record the source 584 language. Also, when symtabs are allocated we try to deduce a 585 language then as well, but it is too late for us to use that 586 information while reading symbols, since symtabs aren't allocated 587 until after all the symbols have been processed for a given 588 source file. */ 589 590 subfile->language = deduce_language_from_filename (subfile->name); 591 if (subfile->language == language_unknown 592 && subfile->next != NULL) 593 { 594 subfile->language = subfile->next->language; 595 } 596 597 /* Initialize the debug format string to NULL. We may supply it 598 later via a call to record_debugformat. */ 599 subfile->debugformat = NULL; 600 601 /* Similarly for the producer. */ 602 subfile->producer = NULL; 603 604 /* If the filename of this subfile ends in .C, then change the 605 language of any pending subfiles from C to C++. We also accept 606 any other C++ suffixes accepted by deduce_language_from_filename. */ 607 /* Likewise for f2c. */ 608 609 if (subfile->name) 610 { 611 struct subfile *s; 612 enum language sublang = deduce_language_from_filename (subfile->name); 613 614 if (sublang == language_cplus || sublang == language_fortran) 615 for (s = subfiles; s != NULL; s = s->next) 616 if (s->language == language_c) 617 s->language = sublang; 618 } 619 620 /* And patch up this file if necessary. */ 621 if (subfile->language == language_c 622 && subfile->next != NULL 623 && (subfile->next->language == language_cplus 624 || subfile->next->language == language_fortran)) 625 { 626 subfile->language = subfile->next->language; 627 } 628 } 629 630 /* For stabs readers, the first N_SO symbol is assumed to be the 631 source file name, and the subfile struct is initialized using that 632 assumption. If another N_SO symbol is later seen, immediately 633 following the first one, then the first one is assumed to be the 634 directory name and the second one is really the source file name. 635 636 So we have to patch up the subfile struct by moving the old name 637 value to dirname and remembering the new name. Some sanity 638 checking is performed to ensure that the state of the subfile 639 struct is reasonable and that the old name we are assuming to be a 640 directory name actually is (by checking for a trailing '/'). */ 641 642 void 643 patch_subfile_names (struct subfile *subfile, char *name) 644 { 645 if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL 646 && IS_DIR_SEPARATOR (subfile->name[strlen (subfile->name) - 1])) 647 { 648 subfile->dirname = subfile->name; 649 subfile->name = xstrdup (name); 650 last_source_file = name; 651 652 /* Default the source language to whatever can be deduced from 653 the filename. If nothing can be deduced (such as for a C/C++ 654 include file with a ".h" extension), then inherit whatever 655 language the previous subfile had. This kludgery is 656 necessary because there is no standard way in some object 657 formats to record the source language. Also, when symtabs 658 are allocated we try to deduce a language then as well, but 659 it is too late for us to use that information while reading 660 symbols, since symtabs aren't allocated until after all the 661 symbols have been processed for a given source file. */ 662 663 subfile->language = deduce_language_from_filename (subfile->name); 664 if (subfile->language == language_unknown 665 && subfile->next != NULL) 666 { 667 subfile->language = subfile->next->language; 668 } 669 } 670 } 671 672 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for 673 switching source files (different subfiles, as we call them) within 674 one object file, but using a stack rather than in an arbitrary 675 order. */ 676 677 void 678 push_subfile (void) 679 { 680 struct subfile_stack *tem 681 = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack)); 682 683 tem->next = subfile_stack; 684 subfile_stack = tem; 685 if (current_subfile == NULL || current_subfile->name == NULL) 686 { 687 internal_error (__FILE__, __LINE__, 688 _("failed internal consistency check")); 689 } 690 tem->name = current_subfile->name; 691 } 692 693 char * 694 pop_subfile (void) 695 { 696 char *name; 697 struct subfile_stack *link = subfile_stack; 698 699 if (link == NULL) 700 { 701 internal_error (__FILE__, __LINE__, 702 _("failed internal consistency check")); 703 } 704 name = link->name; 705 subfile_stack = link->next; 706 xfree ((void *) link); 707 return (name); 708 } 709 710 /* Add a linetable entry for line number LINE and address PC to the 711 line vector for SUBFILE. */ 712 713 void 714 record_line (struct subfile *subfile, int line, CORE_ADDR pc) 715 { 716 struct linetable_entry *e; 717 718 /* Ignore the dummy line number in libg.o */ 719 if (line == 0xffff) 720 { 721 return; 722 } 723 724 /* Make sure line vector exists and is big enough. */ 725 if (!subfile->line_vector) 726 { 727 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH; 728 subfile->line_vector = (struct linetable *) 729 xmalloc (sizeof (struct linetable) 730 + subfile->line_vector_length * sizeof (struct linetable_entry)); 731 subfile->line_vector->nitems = 0; 732 have_line_numbers = 1; 733 } 734 735 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length) 736 { 737 subfile->line_vector_length *= 2; 738 subfile->line_vector = (struct linetable *) 739 xrealloc ((char *) subfile->line_vector, 740 (sizeof (struct linetable) 741 + (subfile->line_vector_length 742 * sizeof (struct linetable_entry)))); 743 } 744 745 /* Normally, we treat lines as unsorted. But the end of sequence 746 marker is special. We sort line markers at the same PC by line 747 number, so end of sequence markers (which have line == 0) appear 748 first. This is right if the marker ends the previous function, 749 and there is no padding before the next function. But it is 750 wrong if the previous line was empty and we are now marking a 751 switch to a different subfile. We must leave the end of sequence 752 marker at the end of this group of lines, not sort the empty line 753 to after the marker. The easiest way to accomplish this is to 754 delete any empty lines from our table, if they are followed by 755 end of sequence markers. All we lose is the ability to set 756 breakpoints at some lines which contain no instructions 757 anyway. */ 758 if (line == 0 && subfile->line_vector->nitems > 0) 759 { 760 e = subfile->line_vector->item + subfile->line_vector->nitems - 1; 761 while (subfile->line_vector->nitems > 0 && e->pc == pc) 762 { 763 e--; 764 subfile->line_vector->nitems--; 765 } 766 } 767 768 e = subfile->line_vector->item + subfile->line_vector->nitems++; 769 e->line = line; 770 e->pc = pc; 771 } 772 773 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */ 774 775 static int 776 compare_line_numbers (const void *ln1p, const void *ln2p) 777 { 778 struct linetable_entry *ln1 = (struct linetable_entry *) ln1p; 779 struct linetable_entry *ln2 = (struct linetable_entry *) ln2p; 780 781 /* Note: this code does not assume that CORE_ADDRs can fit in ints. 782 Please keep it that way. */ 783 if (ln1->pc < ln2->pc) 784 return -1; 785 786 if (ln1->pc > ln2->pc) 787 return 1; 788 789 /* If pc equal, sort by line. I'm not sure whether this is optimum 790 behavior (see comment at struct linetable in symtab.h). */ 791 return ln1->line - ln2->line; 792 } 793 794 /* Start a new symtab for a new source file. Called, for example, 795 when a stabs symbol of type N_SO is seen, or when a DWARF 796 TAG_compile_unit DIE is seen. It indicates the start of data for 797 one original source file. 798 799 NAME is the name of the file (cannot be NULL). DIRNAME is the directory in 800 which the file was compiled (or NULL if not known). START_ADDR is the 801 lowest address of objects in the file (or 0 if not known). */ 802 803 void 804 start_symtab (char *name, char *dirname, CORE_ADDR start_addr) 805 { 806 last_source_file = name; 807 last_source_start_addr = start_addr; 808 file_symbols = NULL; 809 global_symbols = NULL; 810 within_function = 0; 811 have_line_numbers = 0; 812 813 /* Context stack is initially empty. Allocate first one with room 814 for 10 levels; reuse it forever afterward. */ 815 if (context_stack == NULL) 816 { 817 context_stack_size = INITIAL_CONTEXT_STACK_SIZE; 818 context_stack = (struct context_stack *) 819 xmalloc (context_stack_size * sizeof (struct context_stack)); 820 } 821 context_stack_depth = 0; 822 823 /* We shouldn't have any address map at this point. */ 824 gdb_assert (! pending_addrmap); 825 826 /* Initialize the list of sub source files with one entry for this 827 file (the top-level source file). */ 828 829 subfiles = NULL; 830 current_subfile = NULL; 831 start_subfile (name, dirname); 832 } 833 834 /* Subroutine of end_symtab to simplify it. Look for a subfile that 835 matches the main source file's basename. If there is only one, and 836 if the main source file doesn't have any symbol or line number 837 information, then copy this file's symtab and line_vector to the 838 main source file's subfile and discard the other subfile. This can 839 happen because of a compiler bug or from the user playing games 840 with #line or from things like a distributed build system that 841 manipulates the debug info. */ 842 843 static void 844 watch_main_source_file_lossage (void) 845 { 846 struct subfile *mainsub, *subfile; 847 848 /* Find the main source file. 849 This loop could be eliminated if start_symtab saved it for us. */ 850 mainsub = NULL; 851 for (subfile = subfiles; subfile; subfile = subfile->next) 852 { 853 /* The main subfile is guaranteed to be the last one. */ 854 if (subfile->next == NULL) 855 mainsub = subfile; 856 } 857 858 /* If the main source file doesn't have any line number or symbol 859 info, look for an alias in another subfile. 860 861 We have to watch for mainsub == NULL here. It's a quirk of 862 end_symtab, it can return NULL so there may not be a main 863 subfile. */ 864 865 if (mainsub 866 && mainsub->line_vector == NULL 867 && mainsub->symtab == NULL) 868 { 869 const char *mainbase = lbasename (mainsub->name); 870 int nr_matches = 0; 871 struct subfile *prevsub; 872 struct subfile *mainsub_alias = NULL; 873 struct subfile *prev_mainsub_alias = NULL; 874 875 prevsub = NULL; 876 for (subfile = subfiles; 877 /* Stop before we get to the last one. */ 878 subfile->next; 879 subfile = subfile->next) 880 { 881 if (filename_cmp (lbasename (subfile->name), mainbase) == 0) 882 { 883 ++nr_matches; 884 mainsub_alias = subfile; 885 prev_mainsub_alias = prevsub; 886 } 887 prevsub = subfile; 888 } 889 890 if (nr_matches == 1) 891 { 892 gdb_assert (mainsub_alias != NULL && mainsub_alias != mainsub); 893 894 /* Found a match for the main source file. 895 Copy its line_vector and symtab to the main subfile 896 and then discard it. */ 897 898 mainsub->line_vector = mainsub_alias->line_vector; 899 mainsub->line_vector_length = mainsub_alias->line_vector_length; 900 mainsub->symtab = mainsub_alias->symtab; 901 902 if (prev_mainsub_alias == NULL) 903 subfiles = mainsub_alias->next; 904 else 905 prev_mainsub_alias->next = mainsub_alias->next; 906 xfree (mainsub_alias); 907 } 908 } 909 } 910 911 /* Helper function for qsort. Parametes are `struct block *' pointers, 912 function sorts them in descending order by their BLOCK_START. */ 913 914 static int 915 block_compar (const void *ap, const void *bp) 916 { 917 const struct block *a = *(const struct block **) ap; 918 const struct block *b = *(const struct block **) bp; 919 920 return ((BLOCK_START (b) > BLOCK_START (a)) 921 - (BLOCK_START (b) < BLOCK_START (a))); 922 } 923 924 /* Finish the symbol definitions for one main source file, close off 925 all the lexical contexts for that file (creating struct block's for 926 them), then make the struct symtab for that file and put it in the 927 list of all such. 928 929 END_ADDR is the address of the end of the file's text. SECTION is 930 the section number (in objfile->section_offsets) of the blockvector 931 and linetable. 932 933 Note that it is possible for end_symtab() to return NULL. In 934 particular, for the DWARF case at least, it will return NULL when 935 it finds a compilation unit that has exactly one DIE, a 936 TAG_compile_unit DIE. This can happen when we link in an object 937 file that was compiled from an empty source file. Returning NULL 938 is probably not the correct thing to do, because then gdb will 939 never know about this empty file (FIXME). */ 940 941 struct symtab * 942 end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section) 943 { 944 struct symtab *symtab = NULL; 945 struct blockvector *blockvector; 946 struct subfile *subfile; 947 struct context_stack *cstk; 948 struct subfile *nextsub; 949 950 /* Finish the lexical context of the last function in the file; pop 951 the context stack. */ 952 953 if (context_stack_depth > 0) 954 { 955 cstk = pop_context (); 956 /* Make a block for the local symbols within. */ 957 finish_block (cstk->name, &local_symbols, cstk->old_blocks, 958 cstk->start_addr, end_addr, objfile); 959 960 if (context_stack_depth > 0) 961 { 962 /* This is said to happen with SCO. The old coffread.c 963 code simply emptied the context stack, so we do the 964 same. FIXME: Find out why it is happening. This is not 965 believed to happen in most cases (even for coffread.c); 966 it used to be an abort(). */ 967 complaint (&symfile_complaints, 968 _("Context stack not empty in end_symtab")); 969 context_stack_depth = 0; 970 } 971 } 972 973 /* Reordered executables may have out of order pending blocks; if 974 OBJF_REORDERED is true, then sort the pending blocks. */ 975 if ((objfile->flags & OBJF_REORDERED) && pending_blocks) 976 { 977 unsigned count = 0; 978 struct pending_block *pb; 979 struct block **barray, **bp; 980 struct cleanup *back_to; 981 982 for (pb = pending_blocks; pb != NULL; pb = pb->next) 983 count++; 984 985 barray = xmalloc (sizeof (*barray) * count); 986 back_to = make_cleanup (xfree, barray); 987 988 bp = barray; 989 for (pb = pending_blocks; pb != NULL; pb = pb->next) 990 *bp++ = pb->block; 991 992 qsort (barray, count, sizeof (*barray), block_compar); 993 994 bp = barray; 995 for (pb = pending_blocks; pb != NULL; pb = pb->next) 996 pb->block = *bp++; 997 998 do_cleanups (back_to); 999 } 1000 1001 /* Cleanup any undefined types that have been left hanging around 1002 (this needs to be done before the finish_blocks so that 1003 file_symbols is still good). 1004 1005 Both cleanup_undefined_types and finish_global_stabs are stabs 1006 specific, but harmless for other symbol readers, since on gdb 1007 startup or when finished reading stabs, the state is set so these 1008 are no-ops. FIXME: Is this handled right in case of QUIT? Can 1009 we make this cleaner? */ 1010 1011 cleanup_undefined_types (objfile); 1012 finish_global_stabs (objfile); 1013 1014 if (pending_blocks == NULL 1015 && file_symbols == NULL 1016 && global_symbols == NULL 1017 && have_line_numbers == 0 1018 && pending_macros == NULL) 1019 { 1020 /* Ignore symtabs that have no functions with real debugging 1021 info. */ 1022 blockvector = NULL; 1023 } 1024 else 1025 { 1026 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the 1027 blockvector. */ 1028 finish_block (0, &file_symbols, 0, last_source_start_addr, 1029 end_addr, objfile); 1030 finish_block (0, &global_symbols, 0, last_source_start_addr, 1031 end_addr, objfile); 1032 blockvector = make_blockvector (objfile); 1033 } 1034 1035 /* Read the line table if it has to be read separately. */ 1036 if (objfile->sf->sym_read_linetable != NULL) 1037 objfile->sf->sym_read_linetable (); 1038 1039 /* Handle the case where the debug info specifies a different path 1040 for the main source file. It can cause us to lose track of its 1041 line number information. */ 1042 watch_main_source_file_lossage (); 1043 1044 /* Now create the symtab objects proper, one for each subfile. */ 1045 /* (The main file is the last one on the chain.) */ 1046 1047 for (subfile = subfiles; subfile; subfile = nextsub) 1048 { 1049 int linetablesize = 0; 1050 symtab = NULL; 1051 1052 /* If we have blocks of symbols, make a symtab. Otherwise, just 1053 ignore this file and any line number info in it. */ 1054 if (blockvector) 1055 { 1056 if (subfile->line_vector) 1057 { 1058 linetablesize = sizeof (struct linetable) + 1059 subfile->line_vector->nitems * sizeof (struct linetable_entry); 1060 1061 /* Like the pending blocks, the line table may be 1062 scrambled in reordered executables. Sort it if 1063 OBJF_REORDERED is true. */ 1064 if (objfile->flags & OBJF_REORDERED) 1065 qsort (subfile->line_vector->item, 1066 subfile->line_vector->nitems, 1067 sizeof (struct linetable_entry), compare_line_numbers); 1068 } 1069 1070 /* Now, allocate a symbol table. */ 1071 if (subfile->symtab == NULL) 1072 symtab = allocate_symtab (subfile->name, objfile); 1073 else 1074 symtab = subfile->symtab; 1075 1076 /* Fill in its components. */ 1077 symtab->blockvector = blockvector; 1078 symtab->macro_table = pending_macros; 1079 if (subfile->line_vector) 1080 { 1081 /* Reallocate the line table on the symbol obstack. */ 1082 symtab->linetable = (struct linetable *) 1083 obstack_alloc (&objfile->objfile_obstack, linetablesize); 1084 memcpy (symtab->linetable, subfile->line_vector, linetablesize); 1085 } 1086 else 1087 { 1088 symtab->linetable = NULL; 1089 } 1090 symtab->block_line_section = section; 1091 if (subfile->dirname) 1092 { 1093 /* Reallocate the dirname on the symbol obstack. */ 1094 symtab->dirname = (char *) 1095 obstack_alloc (&objfile->objfile_obstack, 1096 strlen (subfile->dirname) + 1); 1097 strcpy (symtab->dirname, subfile->dirname); 1098 } 1099 else 1100 { 1101 symtab->dirname = NULL; 1102 } 1103 symtab->free_code = free_linetable; 1104 symtab->free_func = NULL; 1105 1106 /* Use whatever language we have been using for this 1107 subfile, not the one that was deduced in allocate_symtab 1108 from the filename. We already did our own deducing when 1109 we created the subfile, and we may have altered our 1110 opinion of what language it is from things we found in 1111 the symbols. */ 1112 symtab->language = subfile->language; 1113 1114 /* Save the debug format string (if any) in the symtab. */ 1115 if (subfile->debugformat != NULL) 1116 { 1117 symtab->debugformat = obsavestring (subfile->debugformat, 1118 strlen (subfile->debugformat), 1119 &objfile->objfile_obstack); 1120 } 1121 1122 /* Similarly for the producer. */ 1123 if (subfile->producer != NULL) 1124 symtab->producer = obsavestring (subfile->producer, 1125 strlen (subfile->producer), 1126 &objfile->objfile_obstack); 1127 1128 /* All symtabs for the main file and the subfiles share a 1129 blockvector, so we need to clear primary for everything 1130 but the main file. */ 1131 1132 symtab->primary = 0; 1133 } 1134 else 1135 { 1136 if (subfile->symtab) 1137 { 1138 /* Since we are ignoring that subfile, we also need 1139 to unlink the associated empty symtab that we created. 1140 Otherwise, we can into trouble because various parts 1141 such as the block-vector are uninitialized whereas 1142 the rest of the code assumes that they are. 1143 1144 We can only unlink the symtab because it was allocated 1145 on the objfile obstack. */ 1146 struct symtab *s; 1147 1148 if (objfile->symtabs == subfile->symtab) 1149 objfile->symtabs = objfile->symtabs->next; 1150 else 1151 ALL_OBJFILE_SYMTABS (objfile, s) 1152 if (s->next == subfile->symtab) 1153 { 1154 s->next = s->next->next; 1155 break; 1156 } 1157 subfile->symtab = NULL; 1158 } 1159 } 1160 if (subfile->name != NULL) 1161 { 1162 xfree ((void *) subfile->name); 1163 } 1164 if (subfile->dirname != NULL) 1165 { 1166 xfree ((void *) subfile->dirname); 1167 } 1168 if (subfile->line_vector != NULL) 1169 { 1170 xfree ((void *) subfile->line_vector); 1171 } 1172 if (subfile->debugformat != NULL) 1173 { 1174 xfree ((void *) subfile->debugformat); 1175 } 1176 if (subfile->producer != NULL) 1177 xfree (subfile->producer); 1178 1179 nextsub = subfile->next; 1180 xfree ((void *) subfile); 1181 } 1182 1183 /* Set this for the main source file. */ 1184 if (symtab) 1185 { 1186 symtab->primary = 1; 1187 } 1188 1189 /* Default any symbols without a specified symtab to the primary 1190 symtab. */ 1191 if (blockvector) 1192 { 1193 int block_i; 1194 1195 for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++) 1196 { 1197 struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i); 1198 struct symbol *sym; 1199 struct dict_iterator iter; 1200 1201 /* Inlined functions may have symbols not in the global or 1202 static symbol lists. */ 1203 if (BLOCK_FUNCTION (block) != NULL) 1204 if (SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) == NULL) 1205 SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) = symtab; 1206 1207 for (sym = dict_iterator_first (BLOCK_DICT (block), &iter); 1208 sym != NULL; 1209 sym = dict_iterator_next (&iter)) 1210 if (SYMBOL_SYMTAB (sym) == NULL) 1211 SYMBOL_SYMTAB (sym) = symtab; 1212 } 1213 } 1214 1215 last_source_file = NULL; 1216 current_subfile = NULL; 1217 pending_macros = NULL; 1218 if (pending_addrmap) 1219 { 1220 obstack_free (&pending_addrmap_obstack, NULL); 1221 pending_addrmap = NULL; 1222 } 1223 1224 return symtab; 1225 } 1226 1227 /* Push a context block. Args are an identifying nesting level 1228 (checkable when you pop it), and the starting PC address of this 1229 context. */ 1230 1231 struct context_stack * 1232 push_context (int desc, CORE_ADDR valu) 1233 { 1234 struct context_stack *new; 1235 1236 if (context_stack_depth == context_stack_size) 1237 { 1238 context_stack_size *= 2; 1239 context_stack = (struct context_stack *) 1240 xrealloc ((char *) context_stack, 1241 (context_stack_size * sizeof (struct context_stack))); 1242 } 1243 1244 new = &context_stack[context_stack_depth++]; 1245 new->depth = desc; 1246 new->locals = local_symbols; 1247 new->params = param_symbols; 1248 new->old_blocks = pending_blocks; 1249 new->start_addr = valu; 1250 new->using_directives = using_directives; 1251 new->name = NULL; 1252 1253 local_symbols = NULL; 1254 param_symbols = NULL; 1255 using_directives = NULL; 1256 1257 return new; 1258 } 1259 1260 /* Pop a context block. Returns the address of the context block just 1261 popped. */ 1262 1263 struct context_stack * 1264 pop_context (void) 1265 { 1266 gdb_assert (context_stack_depth > 0); 1267 return (&context_stack[--context_stack_depth]); 1268 } 1269 1270 1271 1272 /* Compute a small integer hash code for the given name. */ 1273 1274 int 1275 hashname (char *name) 1276 { 1277 return (hash(name,strlen(name)) % HASHSIZE); 1278 } 1279 1280 1281 void 1282 record_debugformat (char *format) 1283 { 1284 current_subfile->debugformat = xstrdup (format); 1285 } 1286 1287 void 1288 record_producer (const char *producer) 1289 { 1290 /* The producer is not always provided in the debugging info. 1291 Do nothing if PRODUCER is NULL. */ 1292 if (producer == NULL) 1293 return; 1294 1295 current_subfile->producer = xstrdup (producer); 1296 } 1297 1298 /* Merge the first symbol list SRCLIST into the second symbol list 1299 TARGETLIST by repeated calls to add_symbol_to_list(). This 1300 procedure "frees" each link of SRCLIST by adding it to the 1301 free_pendings list. Caller must set SRCLIST to a null list after 1302 calling this function. 1303 1304 Void return. */ 1305 1306 void 1307 merge_symbol_lists (struct pending **srclist, struct pending **targetlist) 1308 { 1309 int i; 1310 1311 if (!srclist || !*srclist) 1312 return; 1313 1314 /* Merge in elements from current link. */ 1315 for (i = 0; i < (*srclist)->nsyms; i++) 1316 add_symbol_to_list ((*srclist)->symbol[i], targetlist); 1317 1318 /* Recurse on next. */ 1319 merge_symbol_lists (&(*srclist)->next, targetlist); 1320 1321 /* "Free" the current link. */ 1322 (*srclist)->next = free_pendings; 1323 free_pendings = (*srclist); 1324 } 1325 1326 /* Initialize anything that needs initializing when starting to read a 1327 fresh piece of a symbol file, e.g. reading in the stuff 1328 corresponding to a psymtab. */ 1329 1330 void 1331 buildsym_init (void) 1332 { 1333 free_pendings = NULL; 1334 file_symbols = NULL; 1335 global_symbols = NULL; 1336 pending_blocks = NULL; 1337 pending_macros = NULL; 1338 1339 /* We shouldn't have any address map at this point. */ 1340 gdb_assert (! pending_addrmap); 1341 pending_addrmap_interesting = 0; 1342 } 1343 1344 /* Initialize anything that needs initializing when a completely new 1345 symbol file is specified (not just adding some symbols from another 1346 file, e.g. a shared library). */ 1347 1348 void 1349 buildsym_new_init (void) 1350 { 1351 buildsym_init (); 1352 } 1353