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
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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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... */
42 #include "filenames.h" /* For DOSish file names */
44 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
46 #include "cp-support.h"
47 #include "dictionary.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 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 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. */
167 really_free_pendings (void *dummy
)
169 struct pending
*next
, *next1
;
171 for (next
= free_pendings
; next
; next
= next1
)
174 xfree ((void *) next
);
176 free_pendings
= NULL
;
178 free_pending_blocks ();
180 for (next
= file_symbols
; next
!= NULL
; next
= next1
)
183 xfree ((void *) next
);
187 for (next
= global_symbols
; next
!= NULL
; next
= next1
)
190 xfree ((void *) next
);
192 global_symbols
= NULL
;
195 free_macro_table (pending_macros
);
198 /* This function is called to discard any pending blocks. */
201 free_pending_blocks (void)
203 #if 0 /* Now we make the links in the
204 objfile_obstack, so don't free
206 struct pending_block
*bnext
, *bnext1
;
208 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
210 bnext1
= bnext
->next
;
211 xfree ((void *) bnext
);
214 pending_blocks
= NULL
;
217 /* Take one of the lists of symbols and make a block from it. Keep
218 the order the symbols have in the list (reversed from the input
219 file). Put the block on the list of pending blocks. */
222 finish_block (struct symbol
*symbol
, struct pending
**listhead
,
223 struct pending_block
*old_blocks
,
224 CORE_ADDR start
, CORE_ADDR end
,
225 struct objfile
*objfile
)
227 struct pending
*next
, *next1
;
229 struct pending_block
*pblock
;
230 struct pending_block
*opblock
;
232 block
= allocate_block (&objfile
->objfile_obstack
);
236 BLOCK_DICT (block
) = dict_create_linear (&objfile
->objfile_obstack
,
241 BLOCK_DICT (block
) = dict_create_hashed (&objfile
->objfile_obstack
,
245 BLOCK_START (block
) = start
;
246 BLOCK_END (block
) = end
;
247 /* Superblock filled in when containing block is made */
248 BLOCK_SUPERBLOCK (block
) = NULL
;
249 BLOCK_NAMESPACE (block
) = NULL
;
251 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
253 /* Put the block in as the value of the symbol that names it. */
257 struct type
*ftype
= SYMBOL_TYPE (symbol
);
258 struct dict_iterator iter
;
259 SYMBOL_BLOCK_VALUE (symbol
) = block
;
260 BLOCK_FUNCTION (block
) = symbol
;
262 if (TYPE_NFIELDS (ftype
) <= 0)
264 /* No parameter type information is recorded with the
265 function's type. Set that from the type of the
266 parameter symbols. */
267 int nparams
= 0, iparams
;
269 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
271 switch (SYMBOL_CLASS (sym
))
276 case LOC_REGPARM_ADDR
:
277 case LOC_BASEREG_ARG
:
279 case LOC_COMPUTED_ARG
:
291 case LOC_CONST_BYTES
:
294 case LOC_OPTIMIZED_OUT
:
302 TYPE_NFIELDS (ftype
) = nparams
;
303 TYPE_FIELDS (ftype
) = (struct field
*)
304 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
307 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
309 if (iparams
== nparams
)
312 switch (SYMBOL_CLASS (sym
))
317 case LOC_REGPARM_ADDR
:
318 case LOC_BASEREG_ARG
:
320 case LOC_COMPUTED_ARG
:
321 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
322 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
334 case LOC_CONST_BYTES
:
337 case LOC_OPTIMIZED_OUT
:
346 /* If we're in the C++ case, set the block's scope. */
347 if (SYMBOL_LANGUAGE (symbol
) == language_cplus
)
349 cp_set_block_scope (symbol
, block
, &objfile
->objfile_obstack
);
354 BLOCK_FUNCTION (block
) = NULL
;
357 /* Now "free" the links of the list, and empty the list. */
359 for (next
= *listhead
; next
; next
= next1
)
362 next
->next
= free_pendings
;
363 free_pendings
= next
;
368 /* Check to be sure that the blocks have an end address that is
369 greater than starting address */
371 if (BLOCK_END (block
) < BLOCK_START (block
))
375 complaint (&symfile_complaints
,
376 _("block end address less than block start address in %s (patched it)"),
377 SYMBOL_PRINT_NAME (symbol
));
381 complaint (&symfile_complaints
,
382 _("block end address 0x%s less than block start address 0x%s (patched it)"),
383 paddr_nz (BLOCK_END (block
)), paddr_nz (BLOCK_START (block
)));
385 /* Better than nothing */
386 BLOCK_END (block
) = BLOCK_START (block
);
390 /* Install this block as the superblock of all blocks made since the
391 start of this scope that don't have superblocks yet. */
394 for (pblock
= pending_blocks
;
395 pblock
&& pblock
!= old_blocks
;
396 pblock
= pblock
->next
)
398 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
401 /* Check to be sure the blocks are nested as we receive
402 them. If the compiler/assembler/linker work, this just
403 burns a small amount of time.
405 Skip blocks which correspond to a function; they're not
406 physically nested inside this other blocks, only
408 if (BLOCK_FUNCTION (pblock
->block
) == NULL
409 && (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
410 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)))
414 complaint (&symfile_complaints
,
415 _("inner block not inside outer block in %s"),
416 SYMBOL_PRINT_NAME (symbol
));
420 complaint (&symfile_complaints
,
421 _("inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)"),
422 paddr_nz (BLOCK_START (pblock
->block
)),
423 paddr_nz (BLOCK_END (pblock
->block
)),
424 paddr_nz (BLOCK_START (block
)),
425 paddr_nz (BLOCK_END (block
)));
427 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
))
428 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
429 if (BLOCK_END (pblock
->block
) > BLOCK_END (block
))
430 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
433 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
438 record_pending_block (objfile
, block
, opblock
);
442 /* Record BLOCK on the list of all blocks in the file. Put it after
443 OPBLOCK, or at the beginning if opblock is NULL. This puts the
444 block in the list after all its subblocks.
446 Allocate the pending block struct in the objfile_obstack to save
447 time. This wastes a little space. FIXME: Is it worth it? */
450 record_pending_block (struct objfile
*objfile
, struct block
*block
,
451 struct pending_block
*opblock
)
453 struct pending_block
*pblock
;
455 pblock
= (struct pending_block
*)
456 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct pending_block
));
457 pblock
->block
= block
;
460 pblock
->next
= opblock
->next
;
461 opblock
->next
= pblock
;
465 pblock
->next
= pending_blocks
;
466 pending_blocks
= pblock
;
470 static struct blockvector
*
471 make_blockvector (struct objfile
*objfile
)
473 struct pending_block
*next
;
474 struct blockvector
*blockvector
;
477 /* Count the length of the list of blocks. */
479 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++)
483 blockvector
= (struct blockvector
*)
484 obstack_alloc (&objfile
->objfile_obstack
,
485 (sizeof (struct blockvector
)
486 + (i
- 1) * sizeof (struct block
*)));
488 /* Copy the blocks into the blockvector. This is done in reverse
489 order, which happens to put the blocks into the proper order
490 (ascending starting address). finish_block has hair to insert
491 each block into the list after its subblocks in order to make
492 sure this is true. */
494 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
495 for (next
= pending_blocks
; next
; next
= next
->next
)
497 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
500 #if 0 /* Now we make the links in the
501 obstack, so don't free them. */
502 /* Now free the links of the list, and empty the list. */
504 for (next
= pending_blocks
; next
; next
= next1
)
510 pending_blocks
= NULL
;
512 #if 1 /* FIXME, shut this off after a while
513 to speed up symbol reading. */
514 /* Some compilers output blocks in the wrong order, but we depend on
515 their being in the right order so we can binary search. Check the
516 order and moan about it. FIXME. */
517 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
519 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
521 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
- 1))
522 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
)))
525 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
));
527 complaint (&symfile_complaints
, _("block at %s out of order"),
528 hex_string ((LONGEST
) start
));
534 return (blockvector
);
537 /* Start recording information about source code that came from an
538 included (or otherwise merged-in) source file with a different
539 name. NAME is the name of the file (cannot be NULL), DIRNAME is
540 the directory in which it resides (or NULL if not known). */
543 start_subfile (char *name
, char *dirname
)
545 struct subfile
*subfile
;
547 /* See if this subfile is already known as a subfile of the current
550 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
552 if (FILENAME_CMP (subfile
->name
, name
) == 0)
554 current_subfile
= subfile
;
559 /* This subfile is not known. Add an entry for it. Make an entry
560 for this subfile in the list of all subfiles of the current main
563 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
564 memset ((char *) subfile
, 0, sizeof (struct subfile
));
565 subfile
->next
= subfiles
;
567 current_subfile
= subfile
;
569 /* Save its name and compilation directory name */
570 subfile
->name
= (name
== NULL
) ? NULL
: savestring (name
, strlen (name
));
572 (dirname
== NULL
) ? NULL
: savestring (dirname
, strlen (dirname
));
574 /* Initialize line-number recording for this subfile. */
575 subfile
->line_vector
= NULL
;
577 /* Default the source language to whatever can be deduced from the
578 filename. If nothing can be deduced (such as for a C/C++ include
579 file with a ".h" extension), then inherit whatever language the
580 previous subfile had. This kludgery is necessary because there
581 is no standard way in some object formats to record the source
582 language. Also, when symtabs are allocated we try to deduce a
583 language then as well, but it is too late for us to use that
584 information while reading symbols, since symtabs aren't allocated
585 until after all the symbols have been processed for a given
588 subfile
->language
= deduce_language_from_filename (subfile
->name
);
589 if (subfile
->language
== language_unknown
&&
590 subfile
->next
!= NULL
)
592 subfile
->language
= subfile
->next
->language
;
595 /* Initialize the debug format string to NULL. We may supply it
596 later via a call to record_debugformat. */
597 subfile
->debugformat
= NULL
;
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. */
607 enum language sublang
= deduce_language_from_filename (subfile
->name
);
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
;
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
))
621 subfile
->language
= subfile
->next
->language
;
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.
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 '/'). */
638 patch_subfile_names (struct subfile
*subfile
, char *name
)
640 if (subfile
!= NULL
&& subfile
->dirname
== NULL
&& subfile
->name
!= NULL
641 && subfile
->name
[strlen (subfile
->name
) - 1] == '/')
643 subfile
->dirname
= subfile
->name
;
644 subfile
->name
= savestring (name
, strlen (name
));
645 last_source_file
= name
;
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. */
658 subfile
->language
= deduce_language_from_filename (subfile
->name
);
659 if (subfile
->language
== language_unknown
&&
660 subfile
->next
!= NULL
)
662 subfile
->language
= subfile
->next
->language
;
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
675 struct subfile_stack
*tem
676 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
678 tem
->next
= subfile_stack
;
680 if (current_subfile
== NULL
|| current_subfile
->name
== NULL
)
682 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
684 tem
->name
= current_subfile
->name
;
691 struct subfile_stack
*link
= subfile_stack
;
695 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
698 subfile_stack
= link
->next
;
699 xfree ((void *) link
);
703 /* Add a linetable entry for line number LINE and address PC to the
704 line vector for SUBFILE. */
707 record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
709 struct linetable_entry
*e
;
710 /* Ignore the dummy line number in libg.o */
717 /* Make sure line vector exists and is big enough. */
718 if (!subfile
->line_vector
)
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;
728 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
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
))));
738 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
740 e
->pc
= ADDR_BITS_REMOVE(pc
);
743 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
746 compare_line_numbers (const void *ln1p
, const void *ln2p
)
748 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
749 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
751 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
752 Please keep it that way. */
753 if (ln1
->pc
< ln2
->pc
)
756 if (ln1
->pc
> ln2
->pc
)
759 /* If pc equal, sort by line. I'm not sure whether this is optimum
760 behavior (see comment at struct linetable in symtab.h). */
761 return ln1
->line
- ln2
->line
;
764 /* Start a new symtab for a new source file. Called, for example,
765 when a stabs symbol of type N_SO is seen, or when a DWARF
766 TAG_compile_unit DIE is seen. It indicates the start of data for
767 one original source file. */
770 start_symtab (char *name
, char *dirname
, CORE_ADDR start_addr
)
773 last_source_file
= name
;
774 last_source_start_addr
= start_addr
;
776 global_symbols
= NULL
;
778 have_line_numbers
= 0;
780 /* Context stack is initially empty. Allocate first one with room
781 for 10 levels; reuse it forever afterward. */
782 if (context_stack
== NULL
)
784 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
785 context_stack
= (struct context_stack
*)
786 xmalloc (context_stack_size
* sizeof (struct context_stack
));
788 context_stack_depth
= 0;
790 /* Set up support for C++ namespace support, in case we need it. */
792 cp_initialize_namespace ();
794 /* Initialize the list of sub source files with one entry for this
795 file (the top-level source file). */
798 current_subfile
= NULL
;
799 start_subfile (name
, dirname
);
802 /* Finish the symbol definitions for one main source file, close off
803 all the lexical contexts for that file (creating struct block's for
804 them), then make the struct symtab for that file and put it in the
807 END_ADDR is the address of the end of the file's text. SECTION is
808 the section number (in objfile->section_offsets) of the blockvector
811 Note that it is possible for end_symtab() to return NULL. In
812 particular, for the DWARF case at least, it will return NULL when
813 it finds a compilation unit that has exactly one DIE, a
814 TAG_compile_unit DIE. This can happen when we link in an object
815 file that was compiled from an empty source file. Returning NULL
816 is probably not the correct thing to do, because then gdb will
817 never know about this empty file (FIXME). */
820 end_symtab (CORE_ADDR end_addr
, struct objfile
*objfile
, int section
)
822 struct symtab
*symtab
= NULL
;
823 struct blockvector
*blockvector
;
824 struct subfile
*subfile
;
825 struct context_stack
*cstk
;
826 struct subfile
*nextsub
;
828 /* Finish the lexical context of the last function in the file; pop
829 the context stack. */
831 if (context_stack_depth
> 0)
833 cstk
= pop_context ();
834 /* Make a block for the local symbols within. */
835 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
836 cstk
->start_addr
, end_addr
, objfile
);
838 if (context_stack_depth
> 0)
840 /* This is said to happen with SCO. The old coffread.c
841 code simply emptied the context stack, so we do the
842 same. FIXME: Find out why it is happening. This is not
843 believed to happen in most cases (even for coffread.c);
844 it used to be an abort(). */
845 complaint (&symfile_complaints
,
846 _("Context stack not empty in end_symtab"));
847 context_stack_depth
= 0;
851 /* Reordered executables may have out of order pending blocks; if
852 OBJF_REORDERED is true, then sort the pending blocks. */
853 if ((objfile
->flags
& OBJF_REORDERED
) && pending_blocks
)
855 /* FIXME! Remove this horrid bubble sort and use merge sort!!! */
859 struct pending_block
*pb
, *pbnext
;
867 /* swap blocks if unordered! */
869 if (BLOCK_START (pb
->block
) < BLOCK_START (pbnext
->block
))
871 struct block
*tmp
= pb
->block
;
872 pb
->block
= pbnext
->block
;
877 pbnext
= pbnext
->next
;
883 /* Cleanup any undefined types that have been left hanging around
884 (this needs to be done before the finish_blocks so that
885 file_symbols is still good).
887 Both cleanup_undefined_types and finish_global_stabs are stabs
888 specific, but harmless for other symbol readers, since on gdb
889 startup or when finished reading stabs, the state is set so these
890 are no-ops. FIXME: Is this handled right in case of QUIT? Can
891 we make this cleaner? */
893 cleanup_undefined_types ();
894 finish_global_stabs (objfile
);
896 if (pending_blocks
== NULL
897 && file_symbols
== NULL
898 && global_symbols
== NULL
899 && have_line_numbers
== 0
900 && pending_macros
== NULL
)
902 /* Ignore symtabs that have no functions with real debugging
908 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the
910 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
,
912 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
,
914 blockvector
= make_blockvector (objfile
);
915 cp_finalize_namespace (BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
),
916 &objfile
->objfile_obstack
);
919 #ifndef PROCESS_LINENUMBER_HOOK
920 #define PROCESS_LINENUMBER_HOOK()
922 PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */
924 /* Now create the symtab objects proper, one for each subfile. */
925 /* (The main file is the last one on the chain.) */
927 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
929 int linetablesize
= 0;
932 /* If we have blocks of symbols, make a symtab. Otherwise, just
933 ignore this file and any line number info in it. */
936 if (subfile
->line_vector
)
938 linetablesize
= sizeof (struct linetable
) +
939 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
941 /* I think this is artifact from before it went on the
942 obstack. I doubt we'll need the memory between now
943 and when we free it later in this function. */
944 /* First, shrink the linetable to make more memory. */
945 subfile
->line_vector
= (struct linetable
*)
946 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
949 /* Like the pending blocks, the line table may be
950 scrambled in reordered executables. Sort it if
951 OBJF_REORDERED is true. */
952 if (objfile
->flags
& OBJF_REORDERED
)
953 qsort (subfile
->line_vector
->item
,
954 subfile
->line_vector
->nitems
,
955 sizeof (struct linetable_entry
), compare_line_numbers
);
958 /* Now, allocate a symbol table. */
959 symtab
= allocate_symtab (subfile
->name
, objfile
);
961 /* Fill in its components. */
962 symtab
->blockvector
= blockvector
;
963 symtab
->macro_table
= pending_macros
;
964 if (subfile
->line_vector
)
966 /* Reallocate the line table on the symbol obstack */
967 symtab
->linetable
= (struct linetable
*)
968 obstack_alloc (&objfile
->objfile_obstack
, linetablesize
);
969 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
973 symtab
->linetable
= NULL
;
975 symtab
->block_line_section
= section
;
976 if (subfile
->dirname
)
978 /* Reallocate the dirname on the symbol obstack */
979 symtab
->dirname
= (char *)
980 obstack_alloc (&objfile
->objfile_obstack
,
981 strlen (subfile
->dirname
) + 1);
982 strcpy (symtab
->dirname
, subfile
->dirname
);
986 symtab
->dirname
= NULL
;
988 symtab
->free_code
= free_linetable
;
989 symtab
->free_func
= NULL
;
991 /* Use whatever language we have been using for this
992 subfile, not the one that was deduced in allocate_symtab
993 from the filename. We already did our own deducing when
994 we created the subfile, and we may have altered our
995 opinion of what language it is from things we found in
997 symtab
->language
= subfile
->language
;
999 /* Save the debug format string (if any) in the symtab */
1000 if (subfile
->debugformat
!= NULL
)
1002 symtab
->debugformat
= obsavestring (subfile
->debugformat
,
1003 strlen (subfile
->debugformat
),
1004 &objfile
->objfile_obstack
);
1007 /* All symtabs for the main file and the subfiles share a
1008 blockvector, so we need to clear primary for everything
1009 but the main file. */
1011 symtab
->primary
= 0;
1013 if (subfile
->name
!= NULL
)
1015 xfree ((void *) subfile
->name
);
1017 if (subfile
->dirname
!= NULL
)
1019 xfree ((void *) subfile
->dirname
);
1021 if (subfile
->line_vector
!= NULL
)
1023 xfree ((void *) subfile
->line_vector
);
1025 if (subfile
->debugformat
!= NULL
)
1027 xfree ((void *) subfile
->debugformat
);
1030 nextsub
= subfile
->next
;
1031 xfree ((void *) subfile
);
1034 /* Set this for the main source file. */
1037 symtab
->primary
= 1;
1040 last_source_file
= NULL
;
1041 current_subfile
= NULL
;
1042 pending_macros
= NULL
;
1047 /* Push a context block. Args are an identifying nesting level
1048 (checkable when you pop it), and the starting PC address of this
1051 struct context_stack
*
1052 push_context (int desc
, CORE_ADDR valu
)
1054 struct context_stack
*new;
1056 if (context_stack_depth
== context_stack_size
)
1058 context_stack_size
*= 2;
1059 context_stack
= (struct context_stack
*)
1060 xrealloc ((char *) context_stack
,
1061 (context_stack_size
* sizeof (struct context_stack
)));
1064 new = &context_stack
[context_stack_depth
++];
1066 new->locals
= local_symbols
;
1067 new->params
= param_symbols
;
1068 new->old_blocks
= pending_blocks
;
1069 new->start_addr
= valu
;
1072 local_symbols
= NULL
;
1073 param_symbols
= NULL
;
1078 /* Pop a context block. Returns the address of the context block just
1081 struct context_stack
*
1084 gdb_assert (context_stack_depth
> 0);
1085 return (&context_stack
[--context_stack_depth
]);
1090 /* Compute a small integer hash code for the given name. */
1093 hashname (char *name
)
1095 return (hash(name
,strlen(name
)) % HASHSIZE
);
1100 record_debugformat (char *format
)
1102 current_subfile
->debugformat
= savestring (format
, strlen (format
));
1105 /* Merge the first symbol list SRCLIST into the second symbol list
1106 TARGETLIST by repeated calls to add_symbol_to_list(). This
1107 procedure "frees" each link of SRCLIST by adding it to the
1108 free_pendings list. Caller must set SRCLIST to a null list after
1109 calling this function.
1114 merge_symbol_lists (struct pending
**srclist
, struct pending
**targetlist
)
1118 if (!srclist
|| !*srclist
)
1121 /* Merge in elements from current link. */
1122 for (i
= 0; i
< (*srclist
)->nsyms
; i
++)
1123 add_symbol_to_list ((*srclist
)->symbol
[i
], targetlist
);
1125 /* Recurse on next. */
1126 merge_symbol_lists (&(*srclist
)->next
, targetlist
);
1128 /* "Free" the current link. */
1129 (*srclist
)->next
= free_pendings
;
1130 free_pendings
= (*srclist
);
1133 /* Initialize anything that needs initializing when starting to read a
1134 fresh piece of a symbol file, e.g. reading in the stuff
1135 corresponding to a psymtab. */
1138 buildsym_init (void)
1140 free_pendings
= NULL
;
1141 file_symbols
= NULL
;
1142 global_symbols
= NULL
;
1143 pending_blocks
= NULL
;
1144 pending_macros
= NULL
;
1147 /* Initialize anything that needs initializing when a completely new
1148 symbol file is specified (not just adding some symbols from another
1149 file, e.g. a shared library). */
1152 buildsym_new_init (void)