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 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 start address in %s (patched it)"), 330 SYMBOL_PRINT_NAME (symbol)); 331 } 332 else 333 { 334 complaint (&symfile_complaints, 335 _("block end address %s less than block start address %s (patched it)"), 336 paddress (gdbarch, BLOCK_END (block)), 337 paddress (gdbarch, BLOCK_START (block))); 338 } 339 /* Better than nothing */ 340 BLOCK_END (block) = BLOCK_START (block); 341 } 342 343 /* Install this block as the superblock of all blocks made since the 344 start of this scope that don't have superblocks yet. */ 345 346 opblock = NULL; 347 for (pblock = pending_blocks; 348 pblock && pblock != old_blocks; 349 pblock = pblock->next) 350 { 351 if (BLOCK_SUPERBLOCK (pblock->block) == NULL) 352 { 353 /* Check to be sure the blocks are nested as we receive 354 them. If the compiler/assembler/linker work, this just 355 burns a small amount of time. 356 357 Skip blocks which correspond to a function; they're not 358 physically nested inside this other blocks, only 359 lexically nested. */ 360 if (BLOCK_FUNCTION (pblock->block) == NULL 361 && (BLOCK_START (pblock->block) < BLOCK_START (block) 362 || BLOCK_END (pblock->block) > BLOCK_END (block))) 363 { 364 if (symbol) 365 { 366 complaint (&symfile_complaints, 367 _("inner block not inside outer block in %s"), 368 SYMBOL_PRINT_NAME (symbol)); 369 } 370 else 371 { 372 complaint (&symfile_complaints, 373 _("inner block (%s-%s) not inside outer block (%s-%s)"), 374 paddress (gdbarch, BLOCK_START (pblock->block)), 375 paddress (gdbarch, BLOCK_END (pblock->block)), 376 paddress (gdbarch, BLOCK_START (block)), 377 paddress (gdbarch, BLOCK_END (block))); 378 } 379 if (BLOCK_START (pblock->block) < BLOCK_START (block)) 380 BLOCK_START (pblock->block) = BLOCK_START (block); 381 if (BLOCK_END (pblock->block) > BLOCK_END (block)) 382 BLOCK_END (pblock->block) = BLOCK_END (block); 383 } 384 BLOCK_SUPERBLOCK (pblock->block) = block; 385 } 386 opblock = pblock; 387 } 388 389 block_set_using (block, using_directives, &objfile->objfile_obstack); 390 391 record_pending_block (objfile, block, opblock); 392 393 return block; 394 } 395 396 397 /* Record BLOCK on the list of all blocks in the file. Put it after 398 OPBLOCK, or at the beginning if opblock is NULL. This puts the 399 block in the list after all its subblocks. 400 401 Allocate the pending block struct in the objfile_obstack to save 402 time. This wastes a little space. FIXME: Is it worth it? */ 403 404 void 405 record_pending_block (struct objfile *objfile, struct block *block, 406 struct pending_block *opblock) 407 { 408 struct pending_block *pblock; 409 410 pblock = (struct pending_block *) 411 obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block)); 412 pblock->block = block; 413 if (opblock) 414 { 415 pblock->next = opblock->next; 416 opblock->next = pblock; 417 } 418 else 419 { 420 pblock->next = pending_blocks; 421 pending_blocks = pblock; 422 } 423 } 424 425 426 /* Record that the range of addresses from START to END_INCLUSIVE 427 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end 428 addresses must be set already. You must apply this function to all 429 BLOCK's children before applying it to BLOCK. 430 431 If a call to this function complicates the picture beyond that 432 already provided by BLOCK_START and BLOCK_END, then we create an 433 address map for the block. */ 434 void 435 record_block_range (struct block *block, 436 CORE_ADDR start, CORE_ADDR end_inclusive) 437 { 438 /* If this is any different from the range recorded in the block's 439 own BLOCK_START and BLOCK_END, then note that the address map has 440 become interesting. Note that even if this block doesn't have 441 any "interesting" ranges, some later block might, so we still 442 need to record this block in the addrmap. */ 443 if (start != BLOCK_START (block) 444 || end_inclusive + 1 != BLOCK_END (block)) 445 pending_addrmap_interesting = 1; 446 447 if (! pending_addrmap) 448 { 449 obstack_init (&pending_addrmap_obstack); 450 pending_addrmap = addrmap_create_mutable (&pending_addrmap_obstack); 451 } 452 453 addrmap_set_empty (pending_addrmap, start, end_inclusive, block); 454 } 455 456 457 static struct blockvector * 458 make_blockvector (struct objfile *objfile) 459 { 460 struct pending_block *next; 461 struct blockvector *blockvector; 462 int i; 463 464 /* Count the length of the list of blocks. */ 465 466 for (next = pending_blocks, i = 0; next; next = next->next, i++) 467 {; 468 } 469 470 blockvector = (struct blockvector *) 471 obstack_alloc (&objfile->objfile_obstack, 472 (sizeof (struct blockvector) 473 + (i - 1) * sizeof (struct block *))); 474 475 /* Copy the blocks into the blockvector. This is done in reverse 476 order, which happens to put the blocks into the proper order 477 (ascending starting address). finish_block has hair to insert 478 each block into the list after its subblocks in order to make 479 sure this is true. */ 480 481 BLOCKVECTOR_NBLOCKS (blockvector) = i; 482 for (next = pending_blocks; next; next = next->next) 483 { 484 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block; 485 } 486 487 free_pending_blocks (); 488 489 /* If we needed an address map for this symtab, record it in the 490 blockvector. */ 491 if (pending_addrmap && pending_addrmap_interesting) 492 BLOCKVECTOR_MAP (blockvector) 493 = addrmap_create_fixed (pending_addrmap, &objfile->objfile_obstack); 494 else 495 BLOCKVECTOR_MAP (blockvector) = 0; 496 497 /* Some compilers output blocks in the wrong order, but we depend on 498 their being in the right order so we can binary search. Check the 499 order and moan about it. */ 500 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1) 501 { 502 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) 503 { 504 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1)) 505 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))) 506 { 507 CORE_ADDR start 508 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)); 509 510 complaint (&symfile_complaints, _("block at %s out of order"), 511 hex_string ((LONGEST) start)); 512 } 513 } 514 } 515 516 return (blockvector); 517 } 518 519 /* Start recording information about source code that came from an 520 included (or otherwise merged-in) source file with a different 521 name. NAME is the name of the file (cannot be NULL), DIRNAME is 522 the directory in which the file was compiled (or NULL if not known). */ 523 524 void 525 start_subfile (char *name, 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 && 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__, _("failed internal consistency check")); 683 } 684 tem->name = current_subfile->name; 685 } 686 687 char * 688 pop_subfile (void) 689 { 690 char *name; 691 struct subfile_stack *link = subfile_stack; 692 693 if (link == NULL) 694 { 695 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 696 } 697 name = link->name; 698 subfile_stack = link->next; 699 xfree ((void *) link); 700 return (name); 701 } 702 703 /* Add a linetable entry for line number LINE and address PC to the 704 line vector for SUBFILE. */ 705 706 void 707 record_line (struct subfile *subfile, int line, CORE_ADDR pc) 708 { 709 struct linetable_entry *e; 710 /* Ignore the dummy line number in libg.o */ 711 712 if (line == 0xffff) 713 { 714 return; 715 } 716 717 /* Make sure line vector exists and is big enough. */ 718 if (!subfile->line_vector) 719 { 720 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH; 721 subfile->line_vector = (struct linetable *) 722 xmalloc (sizeof (struct linetable) 723 + subfile->line_vector_length * sizeof (struct linetable_entry)); 724 subfile->line_vector->nitems = 0; 725 have_line_numbers = 1; 726 } 727 728 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length) 729 { 730 subfile->line_vector_length *= 2; 731 subfile->line_vector = (struct linetable *) 732 xrealloc ((char *) subfile->line_vector, 733 (sizeof (struct linetable) 734 + (subfile->line_vector_length 735 * sizeof (struct linetable_entry)))); 736 } 737 738 /* Normally, we treat lines as unsorted. But the end of sequence 739 marker is special. We sort line markers at the same PC by line 740 number, so end of sequence markers (which have line == 0) appear 741 first. This is right if the marker ends the previous function, 742 and there is no padding before the next function. But it is 743 wrong if the previous line was empty and we are now marking a 744 switch to a different subfile. We must leave the end of sequence 745 marker at the end of this group of lines, not sort the empty line 746 to after the marker. The easiest way to accomplish this is to 747 delete any empty lines from our table, if they are followed by 748 end of sequence markers. All we lose is the ability to set 749 breakpoints at some lines which contain no instructions 750 anyway. */ 751 if (line == 0 && subfile->line_vector->nitems > 0) 752 { 753 e = subfile->line_vector->item + subfile->line_vector->nitems - 1; 754 while (subfile->line_vector->nitems > 0 && e->pc == pc) 755 { 756 e--; 757 subfile->line_vector->nitems--; 758 } 759 } 760 761 e = subfile->line_vector->item + subfile->line_vector->nitems++; 762 e->line = line; 763 e->pc = pc; 764 } 765 766 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */ 767 768 static int 769 compare_line_numbers (const void *ln1p, const void *ln2p) 770 { 771 struct linetable_entry *ln1 = (struct linetable_entry *) ln1p; 772 struct linetable_entry *ln2 = (struct linetable_entry *) ln2p; 773 774 /* Note: this code does not assume that CORE_ADDRs can fit in ints. 775 Please keep it that way. */ 776 if (ln1->pc < ln2->pc) 777 return -1; 778 779 if (ln1->pc > ln2->pc) 780 return 1; 781 782 /* If pc equal, sort by line. I'm not sure whether this is optimum 783 behavior (see comment at struct linetable in symtab.h). */ 784 return ln1->line - ln2->line; 785 } 786 787 /* Start a new symtab for a new source file. Called, for example, 788 when a stabs symbol of type N_SO is seen, or when a DWARF 789 TAG_compile_unit DIE is seen. It indicates the start of data for 790 one original source file. 791 792 NAME is the name of the file (cannot be NULL). DIRNAME is the directory in 793 which the file was compiled (or NULL if not known). START_ADDR is the 794 lowest address of objects in the file (or 0 if not known). */ 795 796 void 797 start_symtab (char *name, char *dirname, CORE_ADDR start_addr) 798 { 799 last_source_file = name; 800 last_source_start_addr = start_addr; 801 file_symbols = NULL; 802 global_symbols = NULL; 803 within_function = 0; 804 have_line_numbers = 0; 805 806 /* Context stack is initially empty. Allocate first one with room 807 for 10 levels; reuse it forever afterward. */ 808 if (context_stack == NULL) 809 { 810 context_stack_size = INITIAL_CONTEXT_STACK_SIZE; 811 context_stack = (struct context_stack *) 812 xmalloc (context_stack_size * sizeof (struct context_stack)); 813 } 814 context_stack_depth = 0; 815 816 /* We shouldn't have any address map at this point. */ 817 gdb_assert (! pending_addrmap); 818 819 /* Initialize the list of sub source files with one entry for this 820 file (the top-level source file). */ 821 822 subfiles = NULL; 823 current_subfile = NULL; 824 start_subfile (name, dirname); 825 } 826 827 /* Subroutine of end_symtab to simplify it. 828 Look for a subfile that matches the main source file's basename. 829 If there is only one, and if the main source file doesn't have any 830 symbol or line number information, then copy this file's symtab and 831 line_vector to the main source file's subfile and discard the other subfile. 832 This can happen because of a compiler bug or from the user playing games 833 with #line or from things like a distributed build system that manipulates 834 the debug info. */ 835 836 static void 837 watch_main_source_file_lossage (void) 838 { 839 struct subfile *mainsub, *subfile; 840 841 /* Find the main source file. 842 This loop could be eliminated if start_symtab saved it for us. */ 843 mainsub = NULL; 844 for (subfile = subfiles; subfile; subfile = subfile->next) 845 { 846 /* The main subfile is guaranteed to be the last one. */ 847 if (subfile->next == NULL) 848 mainsub = subfile; 849 } 850 851 /* If the main source file doesn't have any line number or symbol info, 852 look for an alias in another subfile. 853 We have to watch for mainsub == NULL here. It's a quirk of end_symtab, 854 it can return NULL so there may not be a main subfile. */ 855 856 if (mainsub 857 && mainsub->line_vector == NULL 858 && mainsub->symtab == NULL) 859 { 860 const char *mainbase = lbasename (mainsub->name); 861 int nr_matches = 0; 862 struct subfile *prevsub; 863 struct subfile *mainsub_alias = NULL; 864 struct subfile *prev_mainsub_alias = NULL; 865 866 prevsub = NULL; 867 for (subfile = subfiles; 868 /* Stop before we get to the last one. */ 869 subfile->next; 870 subfile = subfile->next) 871 { 872 if (strcmp (lbasename (subfile->name), mainbase) == 0) 873 { 874 ++nr_matches; 875 mainsub_alias = subfile; 876 prev_mainsub_alias = prevsub; 877 } 878 prevsub = subfile; 879 } 880 881 if (nr_matches == 1) 882 { 883 gdb_assert (mainsub_alias != NULL && mainsub_alias != mainsub); 884 885 /* Found a match for the main source file. 886 Copy its line_vector and symtab to the main subfile 887 and then discard it. */ 888 889 mainsub->line_vector = mainsub_alias->line_vector; 890 mainsub->line_vector_length = mainsub_alias->line_vector_length; 891 mainsub->symtab = mainsub_alias->symtab; 892 893 if (prev_mainsub_alias == NULL) 894 subfiles = mainsub_alias->next; 895 else 896 prev_mainsub_alias->next = mainsub_alias->next; 897 xfree (mainsub_alias); 898 } 899 } 900 } 901 902 /* Helper function for qsort. Parametes are `struct block *' pointers, 903 function sorts them in descending order by their BLOCK_START. */ 904 905 static int 906 block_compar (const void *ap, const void *bp) 907 { 908 const struct block *a = *(const struct block **) ap; 909 const struct block *b = *(const struct block **) bp; 910 911 return ((BLOCK_START (b) > BLOCK_START (a)) 912 - (BLOCK_START (b) < BLOCK_START (a))); 913 } 914 915 /* Finish the symbol definitions for one main source file, close off 916 all the lexical contexts for that file (creating struct block's for 917 them), then make the struct symtab for that file and put it in the 918 list of all such. 919 920 END_ADDR is the address of the end of the file's text. SECTION is 921 the section number (in objfile->section_offsets) of the blockvector 922 and linetable. 923 924 Note that it is possible for end_symtab() to return NULL. In 925 particular, for the DWARF case at least, it will return NULL when 926 it finds a compilation unit that has exactly one DIE, a 927 TAG_compile_unit DIE. This can happen when we link in an object 928 file that was compiled from an empty source file. Returning NULL 929 is probably not the correct thing to do, because then gdb will 930 never know about this empty file (FIXME). */ 931 932 struct symtab * 933 end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section) 934 { 935 struct symtab *symtab = NULL; 936 struct blockvector *blockvector; 937 struct subfile *subfile; 938 struct context_stack *cstk; 939 struct subfile *nextsub; 940 941 /* Finish the lexical context of the last function in the file; pop 942 the context stack. */ 943 944 if (context_stack_depth > 0) 945 { 946 cstk = pop_context (); 947 /* Make a block for the local symbols within. */ 948 finish_block (cstk->name, &local_symbols, cstk->old_blocks, 949 cstk->start_addr, end_addr, objfile); 950 951 if (context_stack_depth > 0) 952 { 953 /* This is said to happen with SCO. The old coffread.c 954 code simply emptied the context stack, so we do the 955 same. FIXME: Find out why it is happening. This is not 956 believed to happen in most cases (even for coffread.c); 957 it used to be an abort(). */ 958 complaint (&symfile_complaints, 959 _("Context stack not empty in end_symtab")); 960 context_stack_depth = 0; 961 } 962 } 963 964 /* Reordered executables may have out of order pending blocks; if 965 OBJF_REORDERED is true, then sort the pending blocks. */ 966 if ((objfile->flags & OBJF_REORDERED) && pending_blocks) 967 { 968 unsigned count = 0; 969 struct pending_block *pb; 970 struct block **barray, **bp; 971 struct cleanup *back_to; 972 973 for (pb = pending_blocks; pb != NULL; pb = pb->next) 974 count++; 975 976 barray = xmalloc (sizeof (*barray) * count); 977 back_to = make_cleanup (xfree, barray); 978 979 bp = barray; 980 for (pb = pending_blocks; pb != NULL; pb = pb->next) 981 *bp++ = pb->block; 982 983 qsort (barray, count, sizeof (*barray), block_compar); 984 985 bp = barray; 986 for (pb = pending_blocks; pb != NULL; pb = pb->next) 987 pb->block = *bp++; 988 989 do_cleanups (back_to); 990 } 991 992 /* Cleanup any undefined types that have been left hanging around 993 (this needs to be done before the finish_blocks so that 994 file_symbols is still good). 995 996 Both cleanup_undefined_types and finish_global_stabs are stabs 997 specific, but harmless for other symbol readers, since on gdb 998 startup or when finished reading stabs, the state is set so these 999 are no-ops. FIXME: Is this handled right in case of QUIT? Can 1000 we make this cleaner? */ 1001 1002 cleanup_undefined_types (objfile); 1003 finish_global_stabs (objfile); 1004 1005 if (pending_blocks == NULL 1006 && file_symbols == NULL 1007 && global_symbols == NULL 1008 && have_line_numbers == 0 1009 && pending_macros == NULL) 1010 { 1011 /* Ignore symtabs that have no functions with real debugging 1012 info. */ 1013 blockvector = NULL; 1014 } 1015 else 1016 { 1017 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the 1018 blockvector. */ 1019 finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, 1020 objfile); 1021 finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, 1022 objfile); 1023 blockvector = make_blockvector (objfile); 1024 } 1025 1026 /* Read the line table if it has to be read separately. */ 1027 if (objfile->sf->sym_read_linetable != NULL) 1028 objfile->sf->sym_read_linetable (); 1029 1030 /* Handle the case where the debug info specifies a different path 1031 for the main source file. It can cause us to lose track of its 1032 line number information. */ 1033 watch_main_source_file_lossage (); 1034 1035 /* Now create the symtab objects proper, one for each subfile. */ 1036 /* (The main file is the last one on the chain.) */ 1037 1038 for (subfile = subfiles; subfile; subfile = nextsub) 1039 { 1040 int linetablesize = 0; 1041 symtab = NULL; 1042 1043 /* If we have blocks of symbols, make a symtab. Otherwise, just 1044 ignore this file and any line number info in it. */ 1045 if (blockvector) 1046 { 1047 if (subfile->line_vector) 1048 { 1049 linetablesize = sizeof (struct linetable) + 1050 subfile->line_vector->nitems * sizeof (struct linetable_entry); 1051 1052 /* Like the pending blocks, the line table may be 1053 scrambled in reordered executables. Sort it if 1054 OBJF_REORDERED is true. */ 1055 if (objfile->flags & OBJF_REORDERED) 1056 qsort (subfile->line_vector->item, 1057 subfile->line_vector->nitems, 1058 sizeof (struct linetable_entry), compare_line_numbers); 1059 } 1060 1061 /* Now, allocate a symbol table. */ 1062 if (subfile->symtab == NULL) 1063 symtab = allocate_symtab (subfile->name, objfile); 1064 else 1065 symtab = subfile->symtab; 1066 1067 /* Fill in its components. */ 1068 symtab->blockvector = blockvector; 1069 symtab->macro_table = pending_macros; 1070 if (subfile->line_vector) 1071 { 1072 /* Reallocate the line table on the symbol obstack */ 1073 symtab->linetable = (struct linetable *) 1074 obstack_alloc (&objfile->objfile_obstack, linetablesize); 1075 memcpy (symtab->linetable, subfile->line_vector, linetablesize); 1076 } 1077 else 1078 { 1079 symtab->linetable = NULL; 1080 } 1081 symtab->block_line_section = section; 1082 if (subfile->dirname) 1083 { 1084 /* Reallocate the dirname on the symbol obstack */ 1085 symtab->dirname = (char *) 1086 obstack_alloc (&objfile->objfile_obstack, 1087 strlen (subfile->dirname) + 1); 1088 strcpy (symtab->dirname, subfile->dirname); 1089 } 1090 else 1091 { 1092 symtab->dirname = NULL; 1093 } 1094 symtab->free_code = free_linetable; 1095 symtab->free_func = NULL; 1096 1097 /* Use whatever language we have been using for this 1098 subfile, not the one that was deduced in allocate_symtab 1099 from the filename. We already did our own deducing when 1100 we created the subfile, and we may have altered our 1101 opinion of what language it is from things we found in 1102 the symbols. */ 1103 symtab->language = subfile->language; 1104 1105 /* Save the debug format string (if any) in the symtab */ 1106 if (subfile->debugformat != NULL) 1107 { 1108 symtab->debugformat = obsavestring (subfile->debugformat, 1109 strlen (subfile->debugformat), 1110 &objfile->objfile_obstack); 1111 } 1112 1113 /* Similarly for the producer. */ 1114 if (subfile->producer != NULL) 1115 symtab->producer = obsavestring (subfile->producer, 1116 strlen (subfile->producer), 1117 &objfile->objfile_obstack); 1118 1119 /* All symtabs for the main file and the subfiles share a 1120 blockvector, so we need to clear primary for everything 1121 but the main file. */ 1122 1123 symtab->primary = 0; 1124 } 1125 else 1126 { 1127 if (subfile->symtab) 1128 { 1129 /* Since we are ignoring that subfile, we also need 1130 to unlink the associated empty symtab that we created. 1131 Otherwise, we can into trouble because various parts 1132 such as the block-vector are uninitialized whereas 1133 the rest of the code assumes that they are. 1134 1135 We can only unlink the symtab because it was allocated 1136 on the objfile obstack. */ 1137 struct symtab *s; 1138 1139 if (objfile->symtabs == subfile->symtab) 1140 objfile->symtabs = objfile->symtabs->next; 1141 else 1142 ALL_OBJFILE_SYMTABS (objfile, s) 1143 if (s->next == subfile->symtab) 1144 { 1145 s->next = s->next->next; 1146 break; 1147 } 1148 subfile->symtab = NULL; 1149 } 1150 } 1151 if (subfile->name != NULL) 1152 { 1153 xfree ((void *) subfile->name); 1154 } 1155 if (subfile->dirname != NULL) 1156 { 1157 xfree ((void *) subfile->dirname); 1158 } 1159 if (subfile->line_vector != NULL) 1160 { 1161 xfree ((void *) subfile->line_vector); 1162 } 1163 if (subfile->debugformat != NULL) 1164 { 1165 xfree ((void *) subfile->debugformat); 1166 } 1167 if (subfile->producer != NULL) 1168 xfree (subfile->producer); 1169 1170 nextsub = subfile->next; 1171 xfree ((void *) subfile); 1172 } 1173 1174 /* Set this for the main source file. */ 1175 if (symtab) 1176 { 1177 symtab->primary = 1; 1178 } 1179 1180 /* Default any symbols without a specified symtab to the primary 1181 symtab. */ 1182 if (blockvector) 1183 { 1184 int block_i; 1185 1186 for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++) 1187 { 1188 struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i); 1189 struct symbol *sym; 1190 struct dict_iterator iter; 1191 1192 /* Inlined functions may have symbols not in the global or static 1193 symbol lists. */ 1194 if (BLOCK_FUNCTION (block) != NULL) 1195 if (SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) == NULL) 1196 SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) = symtab; 1197 1198 for (sym = dict_iterator_first (BLOCK_DICT (block), &iter); 1199 sym != NULL; 1200 sym = dict_iterator_next (&iter)) 1201 if (SYMBOL_SYMTAB (sym) == NULL) 1202 SYMBOL_SYMTAB (sym) = symtab; 1203 } 1204 } 1205 1206 last_source_file = NULL; 1207 current_subfile = NULL; 1208 pending_macros = NULL; 1209 if (pending_addrmap) 1210 { 1211 obstack_free (&pending_addrmap_obstack, NULL); 1212 pending_addrmap = NULL; 1213 } 1214 1215 return symtab; 1216 } 1217 1218 /* Push a context block. Args are an identifying nesting level 1219 (checkable when you pop it), and the starting PC address of this 1220 context. */ 1221 1222 struct context_stack * 1223 push_context (int desc, CORE_ADDR valu) 1224 { 1225 struct context_stack *new; 1226 1227 if (context_stack_depth == context_stack_size) 1228 { 1229 context_stack_size *= 2; 1230 context_stack = (struct context_stack *) 1231 xrealloc ((char *) context_stack, 1232 (context_stack_size * sizeof (struct context_stack))); 1233 } 1234 1235 new = &context_stack[context_stack_depth++]; 1236 new->depth = desc; 1237 new->locals = local_symbols; 1238 new->params = param_symbols; 1239 new->old_blocks = pending_blocks; 1240 new->start_addr = valu; 1241 new->using_directives = using_directives; 1242 new->name = NULL; 1243 1244 local_symbols = NULL; 1245 param_symbols = NULL; 1246 using_directives = NULL; 1247 1248 return new; 1249 } 1250 1251 /* Pop a context block. Returns the address of the context block just 1252 popped. */ 1253 1254 struct context_stack * 1255 pop_context (void) 1256 { 1257 gdb_assert (context_stack_depth > 0); 1258 return (&context_stack[--context_stack_depth]); 1259 } 1260 1261 1262 1263 /* Compute a small integer hash code for the given name. */ 1264 1265 int 1266 hashname (char *name) 1267 { 1268 return (hash(name,strlen(name)) % HASHSIZE); 1269 } 1270 1271 1272 void 1273 record_debugformat (char *format) 1274 { 1275 current_subfile->debugformat = xstrdup (format); 1276 } 1277 1278 void 1279 record_producer (const char *producer) 1280 { 1281 /* The producer is not always provided in the debugging info. 1282 Do nothing if PRODUCER is NULL. */ 1283 if (producer == NULL) 1284 return; 1285 1286 current_subfile->producer = xstrdup (producer); 1287 } 1288 1289 /* Merge the first symbol list SRCLIST into the second symbol list 1290 TARGETLIST by repeated calls to add_symbol_to_list(). This 1291 procedure "frees" each link of SRCLIST by adding it to the 1292 free_pendings list. Caller must set SRCLIST to a null list after 1293 calling this function. 1294 1295 Void return. */ 1296 1297 void 1298 merge_symbol_lists (struct pending **srclist, struct pending **targetlist) 1299 { 1300 int i; 1301 1302 if (!srclist || !*srclist) 1303 return; 1304 1305 /* Merge in elements from current link. */ 1306 for (i = 0; i < (*srclist)->nsyms; i++) 1307 add_symbol_to_list ((*srclist)->symbol[i], targetlist); 1308 1309 /* Recurse on next. */ 1310 merge_symbol_lists (&(*srclist)->next, targetlist); 1311 1312 /* "Free" the current link. */ 1313 (*srclist)->next = free_pendings; 1314 free_pendings = (*srclist); 1315 } 1316 1317 /* Initialize anything that needs initializing when starting to read a 1318 fresh piece of a symbol file, e.g. reading in the stuff 1319 corresponding to a psymtab. */ 1320 1321 void 1322 buildsym_init (void) 1323 { 1324 free_pendings = NULL; 1325 file_symbols = NULL; 1326 global_symbols = NULL; 1327 pending_blocks = NULL; 1328 pending_macros = NULL; 1329 1330 /* We shouldn't have any address map at this point. */ 1331 gdb_assert (! pending_addrmap); 1332 pending_addrmap_interesting = 0; 1333 } 1334 1335 /* Initialize anything that needs initializing when a completely new 1336 symbol file is specified (not just adding some symbols from another 1337 file, e.g. a shared library). */ 1338 1339 void 1340 buildsym_new_init (void) 1341 { 1342 buildsym_init (); 1343 } 1344