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