1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This module provides subroutines used for creating and adding to
24 the symbol table. These routines are called from various symbol-
25 file-reading routines.
27 Routines to support specific debugging information formats (stabs,
28 DWARF, etc) belong somewhere else. */
32 #include "gdb_obstack.h"
37 #include "gdb_assert.h"
38 #include "complaints.h"
39 #include "gdb_string.h"
40 #include "expression.h" /* For "enum exp_opcode" used by... */
41 #include "language.h" /* For "local_hex_string" */
43 #include "filenames.h" /* For DOSish file names */
45 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
47 #include "cp-support.h"
49 /* Ask buildsym.h to define the vars it normally declares `extern'. */
52 #include "buildsym.h" /* Our own declarations */
55 /* For cleanup_undefined_types and finish_global_stabs (somewhat
56 questionable--see comment where we call them). */
58 #include "stabsread.h"
60 /* List of free `struct pending' structures for reuse. */
62 static struct pending
*free_pendings
;
64 /* Non-zero if symtab has line number info. This prevents an
65 otherwise empty symtab from being tossed. */
67 static int have_line_numbers
;
69 static int compare_line_numbers (const void *ln1p
, const void *ln2p
);
72 /* Initial sizes of data structures. These are realloc'd larger if
73 needed, and realloc'd down to the size actually used, when
76 #define INITIAL_CONTEXT_STACK_SIZE 10
77 #define INITIAL_LINE_VECTOR_LENGTH 1000
80 /* maintain the lists of symbols and blocks */
82 /* Add a pending list to free_pendings. */
84 add_free_pendings (struct pending
*list
)
86 register struct pending
*link
= list
;
90 while (link
->next
) link
= link
->next
;
91 link
->next
= free_pendings
;
96 /* Add a symbol to one of the lists of symbols. While we're at it, if
97 we're in the C++ case and don't have full namespace debugging info,
98 check to see if it references an anonymous namespace; if so, add an
99 appropriate using directive. */
102 add_symbol_to_list (struct symbol
*symbol
, struct pending
**listhead
)
104 register struct pending
*link
;
106 /* If this is an alias for another symbol, don't add it. */
107 if (symbol
->ginfo
.name
&& symbol
->ginfo
.name
[0] == '#')
110 /* We keep PENDINGSIZE symbols in each link of the list. If we
111 don't have a link with room in it, add a new link. */
112 if (*listhead
== NULL
|| (*listhead
)->nsyms
== PENDINGSIZE
)
116 link
= free_pendings
;
117 free_pendings
= link
->next
;
121 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
124 link
->next
= *listhead
;
129 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
131 /* Check to see if we might need to look for a mention of anonymous
134 if (SYMBOL_LANGUAGE (symbol
) == language_cplus
)
135 cp_scan_for_anonymous_namespaces (symbol
);
138 /* Find a symbol named NAME on a LIST. NAME need not be
139 '\0'-terminated; LENGTH is the length of the name. */
142 find_symbol_in_list (struct pending
*list
, char *name
, int length
)
149 for (j
= list
->nsyms
; --j
>= 0;)
151 pp
= DEPRECATED_SYMBOL_NAME (list
->symbol
[j
]);
152 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0 &&
155 return (list
->symbol
[j
]);
163 /* At end of reading syms, or in case of quit, really free as many
164 `struct pending's as we can easily find. */
168 really_free_pendings (void *dummy
)
170 struct pending
*next
, *next1
;
172 for (next
= free_pendings
; next
; next
= next1
)
175 xfree ((void *) next
);
177 free_pendings
= NULL
;
179 free_pending_blocks ();
181 for (next
= file_symbols
; next
!= NULL
; next
= next1
)
184 xfree ((void *) next
);
188 for (next
= global_symbols
; next
!= NULL
; next
= next1
)
191 xfree ((void *) next
);
193 global_symbols
= NULL
;
196 free_macro_table (pending_macros
);
199 /* This function is called to discard any pending blocks. */
202 free_pending_blocks (void)
204 #if 0 /* Now we make the links in the
205 symbol_obstack, so don't free
207 struct pending_block
*bnext
, *bnext1
;
209 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
211 bnext1
= bnext
->next
;
212 xfree ((void *) bnext
);
215 pending_blocks
= NULL
;
218 /* Take one of the lists of symbols and make a block from it. Keep
219 the order the symbols have in the list (reversed from the input
220 file). Put the block on the list of pending blocks. */
223 finish_block (struct symbol
*symbol
, struct pending
**listhead
,
224 struct pending_block
*old_blocks
,
225 CORE_ADDR start
, CORE_ADDR end
,
226 struct objfile
*objfile
)
228 register struct pending
*next
, *next1
;
229 register struct block
*block
;
230 register struct pending_block
*pblock
;
231 struct pending_block
*opblock
;
235 /* Count the length of the list of symbols. */
237 for (next
= *listhead
, i
= 0;
239 i
+= next
->nsyms
, next
= next
->next
)
244 /* Copy the symbols into the block. */
248 block
= (struct block
*)
249 obstack_alloc (&objfile
->symbol_obstack
,
250 (sizeof (struct block
) +
251 ((i
- 1) * sizeof (struct symbol
*))));
252 BLOCK_NSYMS (block
) = i
;
253 for (next
= *listhead
; next
; next
= next
->next
)
254 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
256 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
261 int htab_size
= BLOCK_HASHTABLE_SIZE (i
);
263 block
= (struct block
*)
264 obstack_alloc (&objfile
->symbol_obstack
,
265 (sizeof (struct block
) +
266 ((htab_size
- 1) * sizeof (struct symbol
*))));
267 for (j
= 0; j
< htab_size
; j
++)
269 BLOCK_BUCKET (block
, j
) = 0;
271 BLOCK_BUCKETS (block
) = htab_size
;
272 for (next
= *listhead
; next
; next
= next
->next
)
274 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
277 unsigned int hash_index
;
278 const char *name
= SYMBOL_DEMANGLED_NAME (next
->symbol
[j
]);
280 name
= DEPRECATED_SYMBOL_NAME (next
->symbol
[j
]);
281 hash_index
= msymbol_hash_iw (name
);
282 hash_index
= hash_index
% BLOCK_BUCKETS (block
);
283 sym
= BLOCK_BUCKET (block
, hash_index
);
284 BLOCK_BUCKET (block
, hash_index
) = next
->symbol
[j
];
285 next
->symbol
[j
]->hash_next
= sym
;
290 BLOCK_START (block
) = start
;
291 BLOCK_END (block
) = end
;
292 /* Superblock filled in when containing block is made */
293 BLOCK_SUPERBLOCK (block
) = NULL
;
294 BLOCK_NAMESPACE (block
) = NULL
;
296 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
298 /* Put the block in as the value of the symbol that names it. */
302 struct type
*ftype
= SYMBOL_TYPE (symbol
);
303 SYMBOL_BLOCK_VALUE (symbol
) = block
;
304 BLOCK_FUNCTION (block
) = symbol
;
305 BLOCK_HASHTABLE (block
) = 0;
307 if (TYPE_NFIELDS (ftype
) <= 0)
309 /* No parameter type information is recorded with the
310 function's type. Set that from the type of the
311 parameter symbols. */
312 int nparams
= 0, iparams
;
314 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
316 switch (SYMBOL_CLASS (sym
))
321 case LOC_REGPARM_ADDR
:
322 case LOC_BASEREG_ARG
:
324 case LOC_COMPUTED_ARG
:
336 case LOC_CONST_BYTES
:
339 case LOC_OPTIMIZED_OUT
:
347 TYPE_NFIELDS (ftype
) = nparams
;
348 TYPE_FIELDS (ftype
) = (struct field
*)
349 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
351 for (i
= iparams
= 0; iparams
< nparams
; i
++)
353 sym
= BLOCK_SYM (block
, i
);
354 switch (SYMBOL_CLASS (sym
))
359 case LOC_REGPARM_ADDR
:
360 case LOC_BASEREG_ARG
:
362 case LOC_COMPUTED_ARG
:
363 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
364 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
376 case LOC_CONST_BYTES
:
379 case LOC_OPTIMIZED_OUT
:
388 /* If we're in the C++ case, set the block's scope. */
389 if (SYMBOL_LANGUAGE (symbol
) == language_cplus
)
391 cp_set_block_scope (symbol
, block
, &objfile
->symbol_obstack
);
396 BLOCK_FUNCTION (block
) = NULL
;
397 BLOCK_HASHTABLE (block
) = 1;
400 /* Now "free" the links of the list, and empty the list. */
402 for (next
= *listhead
; next
; next
= next1
)
405 next
->next
= free_pendings
;
406 free_pendings
= next
;
411 /* Check to be sure that the blocks have an end address that is
412 greater than starting address */
414 if (BLOCK_END (block
) < BLOCK_START (block
))
418 complaint (&symfile_complaints
,
419 "block end address less than block start address in %s (patched it)",
420 SYMBOL_PRINT_NAME (symbol
));
424 complaint (&symfile_complaints
,
425 "block end address 0x%s less than block start address 0x%s (patched it)",
426 paddr_nz (BLOCK_END (block
)), paddr_nz (BLOCK_START (block
)));
428 /* Better than nothing */
429 BLOCK_END (block
) = BLOCK_START (block
);
433 /* Install this block as the superblock of all blocks made since the
434 start of this scope that don't have superblocks yet. */
437 for (pblock
= pending_blocks
;
438 pblock
&& pblock
!= old_blocks
;
439 pblock
= pblock
->next
)
441 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
444 /* Check to be sure the blocks are nested as we receive
445 them. If the compiler/assembler/linker work, this just
446 burns a small amount of time. */
447 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
) ||
448 BLOCK_END (pblock
->block
) > BLOCK_END (block
))
452 complaint (&symfile_complaints
,
453 "inner block not inside outer block in %s",
454 SYMBOL_PRINT_NAME (symbol
));
458 complaint (&symfile_complaints
,
459 "inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)",
460 paddr_nz (BLOCK_START (pblock
->block
)),
461 paddr_nz (BLOCK_END (pblock
->block
)),
462 paddr_nz (BLOCK_START (block
)),
463 paddr_nz (BLOCK_END (block
)));
465 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
))
466 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
467 if (BLOCK_END (pblock
->block
) > BLOCK_END (block
))
468 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
471 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
476 record_pending_block (objfile
, block
, opblock
);
479 /* Record BLOCK on the list of all blocks in the file. Put it after
480 OPBLOCK, or at the beginning if opblock is NULL. This puts the
481 block in the list after all its subblocks.
483 Allocate the pending block struct in the symbol_obstack to save
484 time. This wastes a little space. FIXME: Is it worth it? */
487 record_pending_block (struct objfile
*objfile
, struct block
*block
,
488 struct pending_block
*opblock
)
490 register struct pending_block
*pblock
;
492 pblock
= (struct pending_block
*)
493 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct pending_block
));
494 pblock
->block
= block
;
497 pblock
->next
= opblock
->next
;
498 opblock
->next
= pblock
;
502 pblock
->next
= pending_blocks
;
503 pending_blocks
= pblock
;
507 static struct blockvector
*
508 make_blockvector (struct objfile
*objfile
)
510 register struct pending_block
*next
;
511 register struct blockvector
*blockvector
;
514 /* Count the length of the list of blocks. */
516 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++)
520 blockvector
= (struct blockvector
*)
521 obstack_alloc (&objfile
->symbol_obstack
,
522 (sizeof (struct blockvector
)
523 + (i
- 1) * sizeof (struct block
*)));
525 /* Copy the blocks into the blockvector. This is done in reverse
526 order, which happens to put the blocks into the proper order
527 (ascending starting address). finish_block has hair to insert
528 each block into the list after its subblocks in order to make
529 sure this is true. */
531 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
532 for (next
= pending_blocks
; next
; next
= next
->next
)
534 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
537 #if 0 /* Now we make the links in the
538 obstack, so don't free them. */
539 /* Now free the links of the list, and empty the list. */
541 for (next
= pending_blocks
; next
; next
= next1
)
547 pending_blocks
= NULL
;
549 #if 1 /* FIXME, shut this off after a while
550 to speed up symbol reading. */
551 /* Some compilers output blocks in the wrong order, but we depend on
552 their being in the right order so we can binary search. Check the
553 order and moan about it. FIXME. */
554 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
556 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
558 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
- 1))
559 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
)))
562 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
));
564 complaint (&symfile_complaints
, "block at %s out of order",
565 local_hex_string ((LONGEST
) start
));
571 return (blockvector
);
574 /* Start recording information about source code that came from an
575 included (or otherwise merged-in) source file with a different
576 name. NAME is the name of the file (cannot be NULL), DIRNAME is
577 the directory in which it resides (or NULL if not known). */
580 start_subfile (char *name
, char *dirname
)
582 register struct subfile
*subfile
;
584 /* See if this subfile is already known as a subfile of the current
587 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
589 if (FILENAME_CMP (subfile
->name
, name
) == 0)
591 current_subfile
= subfile
;
596 /* This subfile is not known. Add an entry for it. Make an entry
597 for this subfile in the list of all subfiles of the current main
600 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
601 memset ((char *) subfile
, 0, sizeof (struct subfile
));
602 subfile
->next
= subfiles
;
604 current_subfile
= subfile
;
606 /* Save its name and compilation directory name */
607 subfile
->name
= (name
== NULL
) ? NULL
: savestring (name
, strlen (name
));
609 (dirname
== NULL
) ? NULL
: savestring (dirname
, strlen (dirname
));
611 /* Initialize line-number recording for this subfile. */
612 subfile
->line_vector
= NULL
;
614 /* Default the source language to whatever can be deduced from the
615 filename. If nothing can be deduced (such as for a C/C++ include
616 file with a ".h" extension), then inherit whatever language the
617 previous subfile had. This kludgery is necessary because there
618 is no standard way in some object formats to record the source
619 language. Also, when symtabs are allocated we try to deduce a
620 language then as well, but it is too late for us to use that
621 information while reading symbols, since symtabs aren't allocated
622 until after all the symbols have been processed for a given
625 subfile
->language
= deduce_language_from_filename (subfile
->name
);
626 if (subfile
->language
== language_unknown
&&
627 subfile
->next
!= NULL
)
629 subfile
->language
= subfile
->next
->language
;
632 /* Initialize the debug format string to NULL. We may supply it
633 later via a call to record_debugformat. */
634 subfile
->debugformat
= NULL
;
636 #if 0 /* OBSOLETE CFront */
637 // OBSOLETE /* cfront output is a C program, so in most ways it looks like a C
638 // OBSOLETE program. But to demangle we need to set the language to C++. We
639 // OBSOLETE can distinguish cfront code by the fact that it has #line
640 // OBSOLETE directives which specify a file name ending in .C. */
641 #endif /* OBSOLETE CFront */
643 /* If the filename of this subfile ends in .C, then change the
644 language of any pending subfiles from C to C++. We also accept
645 any other C++ suffixes accepted by deduce_language_from_filename. */
646 /* OBSOLETE (in particular, some people use .cxx with cfront). */
647 /* Likewise for f2c. */
652 enum language sublang
= deduce_language_from_filename (subfile
->name
);
654 if (sublang
== language_cplus
|| sublang
== language_fortran
)
655 for (s
= subfiles
; s
!= NULL
; s
= s
->next
)
656 if (s
->language
== language_c
)
657 s
->language
= sublang
;
660 /* And patch up this file if necessary. */
661 if (subfile
->language
== language_c
662 && subfile
->next
!= NULL
663 && (subfile
->next
->language
== language_cplus
664 || subfile
->next
->language
== language_fortran
))
666 subfile
->language
= subfile
->next
->language
;
670 /* For stabs readers, the first N_SO symbol is assumed to be the
671 source file name, and the subfile struct is initialized using that
672 assumption. If another N_SO symbol is later seen, immediately
673 following the first one, then the first one is assumed to be the
674 directory name and the second one is really the source file name.
676 So we have to patch up the subfile struct by moving the old name
677 value to dirname and remembering the new name. Some sanity
678 checking is performed to ensure that the state of the subfile
679 struct is reasonable and that the old name we are assuming to be a
680 directory name actually is (by checking for a trailing '/'). */
683 patch_subfile_names (struct subfile
*subfile
, char *name
)
685 if (subfile
!= NULL
&& subfile
->dirname
== NULL
&& subfile
->name
!= NULL
686 && subfile
->name
[strlen (subfile
->name
) - 1] == '/')
688 subfile
->dirname
= subfile
->name
;
689 subfile
->name
= savestring (name
, strlen (name
));
690 last_source_file
= name
;
692 /* Default the source language to whatever can be deduced from
693 the filename. If nothing can be deduced (such as for a C/C++
694 include file with a ".h" extension), then inherit whatever
695 language the previous subfile had. This kludgery is
696 necessary because there is no standard way in some object
697 formats to record the source language. Also, when symtabs
698 are allocated we try to deduce a language then as well, but
699 it is too late for us to use that information while reading
700 symbols, since symtabs aren't allocated until after all the
701 symbols have been processed for a given source file. */
703 subfile
->language
= deduce_language_from_filename (subfile
->name
);
704 if (subfile
->language
== language_unknown
&&
705 subfile
->next
!= NULL
)
707 subfile
->language
= subfile
->next
->language
;
712 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
713 switching source files (different subfiles, as we call them) within
714 one object file, but using a stack rather than in an arbitrary
720 register struct subfile_stack
*tem
721 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
723 tem
->next
= subfile_stack
;
725 if (current_subfile
== NULL
|| current_subfile
->name
== NULL
)
727 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
729 tem
->name
= current_subfile
->name
;
736 register struct subfile_stack
*link
= subfile_stack
;
740 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
743 subfile_stack
= link
->next
;
744 xfree ((void *) link
);
748 /* Add a linetable entry for line number LINE and address PC to the
749 line vector for SUBFILE. */
752 record_line (register struct subfile
*subfile
, int line
, CORE_ADDR pc
)
754 struct linetable_entry
*e
;
755 /* Ignore the dummy line number in libg.o */
762 /* Make sure line vector exists and is big enough. */
763 if (!subfile
->line_vector
)
765 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
766 subfile
->line_vector
= (struct linetable
*)
767 xmalloc (sizeof (struct linetable
)
768 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
769 subfile
->line_vector
->nitems
= 0;
770 have_line_numbers
= 1;
773 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
775 subfile
->line_vector_length
*= 2;
776 subfile
->line_vector
= (struct linetable
*)
777 xrealloc ((char *) subfile
->line_vector
,
778 (sizeof (struct linetable
)
779 + (subfile
->line_vector_length
780 * sizeof (struct linetable_entry
))));
783 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
785 e
->pc
= ADDR_BITS_REMOVE(pc
);
788 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
791 compare_line_numbers (const void *ln1p
, const void *ln2p
)
793 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
794 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
796 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
797 Please keep it that way. */
798 if (ln1
->pc
< ln2
->pc
)
801 if (ln1
->pc
> ln2
->pc
)
804 /* If pc equal, sort by line. I'm not sure whether this is optimum
805 behavior (see comment at struct linetable in symtab.h). */
806 return ln1
->line
- ln2
->line
;
809 /* Start a new symtab for a new source file. Called, for example,
810 when a stabs symbol of type N_SO is seen, or when a DWARF
811 TAG_compile_unit DIE is seen. It indicates the start of data for
812 one original source file. */
815 start_symtab (char *name
, char *dirname
, CORE_ADDR start_addr
)
818 last_source_file
= name
;
819 last_source_start_addr
= start_addr
;
821 global_symbols
= NULL
;
823 have_line_numbers
= 0;
825 /* Context stack is initially empty. Allocate first one with room
826 for 10 levels; reuse it forever afterward. */
827 if (context_stack
== NULL
)
829 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
830 context_stack
= (struct context_stack
*)
831 xmalloc (context_stack_size
* sizeof (struct context_stack
));
833 context_stack_depth
= 0;
835 /* Set up support for C++ namespace support, in case we need it. */
837 cp_initialize_namespace ();
839 /* Initialize the list of sub source files with one entry for this
840 file (the top-level source file). */
843 current_subfile
= NULL
;
844 start_subfile (name
, dirname
);
847 /* Finish the symbol definitions for one main source file, close off
848 all the lexical contexts for that file (creating struct block's for
849 them), then make the struct symtab for that file and put it in the
852 END_ADDR is the address of the end of the file's text. SECTION is
853 the section number (in objfile->section_offsets) of the blockvector
856 Note that it is possible for end_symtab() to return NULL. In
857 particular, for the DWARF case at least, it will return NULL when
858 it finds a compilation unit that has exactly one DIE, a
859 TAG_compile_unit DIE. This can happen when we link in an object
860 file that was compiled from an empty source file. Returning NULL
861 is probably not the correct thing to do, because then gdb will
862 never know about this empty file (FIXME). */
865 end_symtab (CORE_ADDR end_addr
, struct objfile
*objfile
, int section
)
867 register struct symtab
*symtab
= NULL
;
868 register struct blockvector
*blockvector
;
869 register struct subfile
*subfile
;
870 register struct context_stack
*cstk
;
871 struct subfile
*nextsub
;
873 /* Finish the lexical context of the last function in the file; pop
874 the context stack. */
876 if (context_stack_depth
> 0)
878 cstk
= pop_context ();
879 /* Make a block for the local symbols within. */
880 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
881 cstk
->start_addr
, end_addr
, objfile
);
883 if (context_stack_depth
> 0)
885 /* This is said to happen with SCO. The old coffread.c
886 code simply emptied the context stack, so we do the
887 same. FIXME: Find out why it is happening. This is not
888 believed to happen in most cases (even for coffread.c);
889 it used to be an abort(). */
890 complaint (&symfile_complaints
,
891 "Context stack not empty in end_symtab");
892 context_stack_depth
= 0;
896 /* Reordered executables may have out of order pending blocks; if
897 OBJF_REORDERED is true, then sort the pending blocks. */
898 if ((objfile
->flags
& OBJF_REORDERED
) && pending_blocks
)
900 /* FIXME! Remove this horrid bubble sort and use merge sort!!! */
904 struct pending_block
*pb
, *pbnext
;
912 /* swap blocks if unordered! */
914 if (BLOCK_START (pb
->block
) < BLOCK_START (pbnext
->block
))
916 struct block
*tmp
= pb
->block
;
917 pb
->block
= pbnext
->block
;
922 pbnext
= pbnext
->next
;
928 /* Cleanup any undefined types that have been left hanging around
929 (this needs to be done before the finish_blocks so that
930 file_symbols is still good).
932 Both cleanup_undefined_types and finish_global_stabs are stabs
933 specific, but harmless for other symbol readers, since on gdb
934 startup or when finished reading stabs, the state is set so these
935 are no-ops. FIXME: Is this handled right in case of QUIT? Can
936 we make this cleaner? */
938 cleanup_undefined_types ();
939 finish_global_stabs (objfile
);
941 if (pending_blocks
== NULL
942 && file_symbols
== NULL
943 && global_symbols
== NULL
944 && have_line_numbers
== 0
945 && pending_macros
== NULL
)
947 /* Ignore symtabs that have no functions with real debugging
953 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the
955 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
,
957 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
,
959 blockvector
= make_blockvector (objfile
);
960 cp_finalize_namespace (BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
),
961 &objfile
->symbol_obstack
);
964 #ifndef PROCESS_LINENUMBER_HOOK
965 #define PROCESS_LINENUMBER_HOOK()
967 PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */
969 /* Now create the symtab objects proper, one for each subfile. */
970 /* (The main file is the last one on the chain.) */
972 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
974 int linetablesize
= 0;
977 /* If we have blocks of symbols, make a symtab. Otherwise, just
978 ignore this file and any line number info in it. */
981 if (subfile
->line_vector
)
983 linetablesize
= sizeof (struct linetable
) +
984 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
986 /* I think this is artifact from before it went on the
987 obstack. I doubt we'll need the memory between now
988 and when we free it later in this function. */
989 /* First, shrink the linetable to make more memory. */
990 subfile
->line_vector
= (struct linetable
*)
991 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
994 /* Like the pending blocks, the line table may be
995 scrambled in reordered executables. Sort it if
996 OBJF_REORDERED is true. */
997 if (objfile
->flags
& OBJF_REORDERED
)
998 qsort (subfile
->line_vector
->item
,
999 subfile
->line_vector
->nitems
,
1000 sizeof (struct linetable_entry
), compare_line_numbers
);
1003 /* Now, allocate a symbol table. */
1004 symtab
= allocate_symtab (subfile
->name
, objfile
);
1006 /* Fill in its components. */
1007 symtab
->blockvector
= blockvector
;
1008 symtab
->macro_table
= pending_macros
;
1009 if (subfile
->line_vector
)
1011 /* Reallocate the line table on the symbol obstack */
1012 symtab
->linetable
= (struct linetable
*)
1013 obstack_alloc (&objfile
->symbol_obstack
, linetablesize
);
1014 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
1018 symtab
->linetable
= NULL
;
1020 symtab
->block_line_section
= section
;
1021 if (subfile
->dirname
)
1023 /* Reallocate the dirname on the symbol obstack */
1024 symtab
->dirname
= (char *)
1025 obstack_alloc (&objfile
->symbol_obstack
,
1026 strlen (subfile
->dirname
) + 1);
1027 strcpy (symtab
->dirname
, subfile
->dirname
);
1031 symtab
->dirname
= NULL
;
1033 symtab
->free_code
= free_linetable
;
1034 symtab
->free_ptr
= NULL
;
1036 /* Use whatever language we have been using for this
1037 subfile, not the one that was deduced in allocate_symtab
1038 from the filename. We already did our own deducing when
1039 we created the subfile, and we may have altered our
1040 opinion of what language it is from things we found in
1042 symtab
->language
= subfile
->language
;
1044 /* Save the debug format string (if any) in the symtab */
1045 if (subfile
->debugformat
!= NULL
)
1047 symtab
->debugformat
= obsavestring (subfile
->debugformat
,
1048 strlen (subfile
->debugformat
),
1049 &objfile
->symbol_obstack
);
1052 /* All symtabs for the main file and the subfiles share a
1053 blockvector, so we need to clear primary for everything
1054 but the main file. */
1056 symtab
->primary
= 0;
1058 if (subfile
->name
!= NULL
)
1060 xfree ((void *) subfile
->name
);
1062 if (subfile
->dirname
!= NULL
)
1064 xfree ((void *) subfile
->dirname
);
1066 if (subfile
->line_vector
!= NULL
)
1068 xfree ((void *) subfile
->line_vector
);
1070 if (subfile
->debugformat
!= NULL
)
1072 xfree ((void *) subfile
->debugformat
);
1075 nextsub
= subfile
->next
;
1076 xfree ((void *) subfile
);
1079 /* Set this for the main source file. */
1082 symtab
->primary
= 1;
1085 last_source_file
= NULL
;
1086 current_subfile
= NULL
;
1087 pending_macros
= NULL
;
1092 /* Push a context block. Args are an identifying nesting level
1093 (checkable when you pop it), and the starting PC address of this
1096 struct context_stack
*
1097 push_context (int desc
, CORE_ADDR valu
)
1099 register struct context_stack
*new;
1101 if (context_stack_depth
== context_stack_size
)
1103 context_stack_size
*= 2;
1104 context_stack
= (struct context_stack
*)
1105 xrealloc ((char *) context_stack
,
1106 (context_stack_size
* sizeof (struct context_stack
)));
1109 new = &context_stack
[context_stack_depth
++];
1111 new->locals
= local_symbols
;
1112 new->params
= param_symbols
;
1113 new->old_blocks
= pending_blocks
;
1114 new->start_addr
= valu
;
1117 local_symbols
= NULL
;
1118 param_symbols
= NULL
;
1123 /* Pop a context block. Returns the address of the context block just
1126 struct context_stack
*
1129 gdb_assert (context_stack_depth
> 0);
1130 return (&context_stack
[--context_stack_depth
]);
1135 /* Compute a small integer hash code for the given name. */
1138 hashname (char *name
)
1140 return (hash(name
,strlen(name
)) % HASHSIZE
);
1145 record_debugformat (char *format
)
1147 current_subfile
->debugformat
= savestring (format
, strlen (format
));
1150 /* Merge the first symbol list SRCLIST into the second symbol list
1151 TARGETLIST by repeated calls to add_symbol_to_list(). This
1152 procedure "frees" each link of SRCLIST by adding it to the
1153 free_pendings list. Caller must set SRCLIST to a null list after
1154 calling this function.
1159 merge_symbol_lists (struct pending
**srclist
, struct pending
**targetlist
)
1163 if (!srclist
|| !*srclist
)
1166 /* Merge in elements from current link. */
1167 for (i
= 0; i
< (*srclist
)->nsyms
; i
++)
1168 add_symbol_to_list ((*srclist
)->symbol
[i
], targetlist
);
1170 /* Recurse on next. */
1171 merge_symbol_lists (&(*srclist
)->next
, targetlist
);
1173 /* "Free" the current link. */
1174 (*srclist
)->next
= free_pendings
;
1175 free_pendings
= (*srclist
);
1178 /* Initialize anything that needs initializing when starting to read a
1179 fresh piece of a symbol file, e.g. reading in the stuff
1180 corresponding to a psymtab. */
1183 buildsym_init (void)
1185 free_pendings
= NULL
;
1186 file_symbols
= NULL
;
1187 global_symbols
= NULL
;
1188 pending_blocks
= NULL
;
1189 pending_macros
= NULL
;
1192 /* Initialize anything that needs initializing when a completely new
1193 symbol file is specified (not just adding some symbols from another
1194 file, e.g. a shared library). */
1197 buildsym_new_init (void)