1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
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.
25 Routines to support specific debugging information formats (stabs,
26 DWARF, etc) belong somewhere else. */
32 #include "symfile.h" /* Needed for "struct complaint" */
36 /* Ask buildsym.h to define the vars it normally declares `extern'. */
38 #include "buildsym.h" /* Our own declarations */
42 compare_line_numbers PARAMS ((const void *, const void *));
44 static struct blockvector *
45 make_blockvector PARAMS ((struct objfile *));
48 /* Initial sizes of data structures. These are realloc'd larger if needed,
49 and realloc'd down to the size actually used, when completed. */
51 #define INITIAL_CONTEXT_STACK_SIZE 10
52 #define INITIAL_LINE_VECTOR_LENGTH 1000
55 /* Complaints about the symbols we have encountered. */
57 struct complaint innerblock_complaint =
58 {"inner block not inside outer block in %s", 0, 0};
60 struct complaint innerblock_anon_complaint =
61 {"inner block not inside outer block", 0, 0};
63 struct complaint blockvector_complaint =
64 {"block at 0x%x out of order", 0, 0};
67 /* maintain the lists of symbols and blocks */
69 /* Add a symbol to one of the lists of symbols. */
72 add_symbol_to_list (symbol, listhead)
73 struct symbol *symbol;
74 struct pending **listhead;
76 register struct pending *link;
78 /* We keep PENDINGSIZE symbols in each link of the list.
79 If we don't have a link with room in it, add a new link. */
80 if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE)
85 free_pendings = link->next;
89 link = (struct pending *) xmalloc (sizeof (struct pending));
92 link->next = *listhead;
97 (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
100 /* Find a symbol on a pending list. */
103 find_symbol_in_list (list, name, length)
104 struct pending *list;
113 for (j = list->nsyms; --j >= 0; )
115 pp = SYMBOL_NAME (list->symbol[j]);
116 if (*pp == *name && strncmp (pp, name, length) == 0 &&
119 return (list->symbol[j]);
127 /* At end of reading syms, or in case of quit,
128 really free as many `struct pending's as we can easily find. */
132 really_free_pendings (foo)
135 struct pending *next, *next1;
137 struct pending_block *bnext, *bnext1;
140 for (next = free_pendings; next; next = next1)
145 free_pendings = NULL;
147 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
148 for (bnext = pending_blocks; bnext; bnext = bnext1)
150 bnext1 = bnext->next;
154 pending_blocks = NULL;
156 for (next = file_symbols; next != NULL; next = next1)
163 for (next = global_symbols; next != NULL; next = next1)
168 global_symbols = NULL;
171 /* Take one of the lists of symbols and make a block from it.
172 Keep the order the symbols have in the list (reversed from the input file).
173 Put the block on the list of pending blocks. */
176 finish_block (symbol, listhead, old_blocks, start, end, objfile)
177 struct symbol *symbol;
178 struct pending **listhead;
179 struct pending_block *old_blocks;
180 CORE_ADDR start, end;
181 struct objfile *objfile;
183 register struct pending *next, *next1;
184 register struct block *block;
185 register struct pending_block *pblock;
186 struct pending_block *opblock;
190 /* Count the length of the list of symbols. */
192 for (next = *listhead, i = 0;
194 i += next->nsyms, next = next->next)
199 block = (struct block *) obstack_alloc (&objfile -> symbol_obstack,
200 (sizeof (struct block) + ((i - 1) * sizeof (struct symbol *))));
202 /* Copy the symbols into the block. */
204 BLOCK_NSYMS (block) = i;
205 for (next = *listhead; next; next = next->next)
207 for (j = next->nsyms - 1; j >= 0; j--)
209 BLOCK_SYM (block, --i) = next->symbol[j];
213 BLOCK_START (block) = start;
214 BLOCK_END (block) = end;
215 /* Superblock filled in when containing block is made */
216 BLOCK_SUPERBLOCK (block) = NULL;
217 BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
219 /* Put the block in as the value of the symbol that names it. */
223 SYMBOL_BLOCK_VALUE (symbol) = block;
224 BLOCK_FUNCTION (block) = symbol;
228 BLOCK_FUNCTION (block) = NULL;
231 /* Now "free" the links of the list, and empty the list. */
233 for (next = *listhead; next; next = next1)
236 next->next = free_pendings;
237 free_pendings = next;
241 /* Install this block as the superblock
242 of all blocks made since the start of this scope
243 that don't have superblocks yet. */
246 for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
248 if (BLOCK_SUPERBLOCK (pblock->block) == NULL)
251 /* Check to be sure the blocks are nested as we receive them.
252 If the compiler/assembler/linker work, this just burns a small
254 if (BLOCK_START (pblock->block) < BLOCK_START (block) ||
255 BLOCK_END (pblock->block) > BLOCK_END (block))
259 complain (&innerblock_complaint, SYMBOL_NAME (symbol));
263 complain (&innerblock_anon_complaint, 0);
265 BLOCK_START (pblock->block) = BLOCK_START (block);
266 BLOCK_END (pblock->block) = BLOCK_END (block);
269 BLOCK_SUPERBLOCK (pblock->block) = block;
274 /* Record this block on the list of all blocks in the file.
275 Put it after opblock, or at the beginning if opblock is 0.
276 This puts the block in the list after all its subblocks. */
278 /* Allocate in the symbol_obstack to save time.
279 It wastes a little space. */
280 pblock = (struct pending_block *)
281 obstack_alloc (&objfile -> symbol_obstack,
282 sizeof (struct pending_block));
283 pblock->block = block;
286 pblock->next = opblock->next;
287 opblock->next = pblock;
291 pblock->next = pending_blocks;
292 pending_blocks = pblock;
296 static struct blockvector *
297 make_blockvector (objfile)
298 struct objfile *objfile;
300 register struct pending_block *next;
301 register struct blockvector *blockvector;
304 /* Count the length of the list of blocks. */
306 for (next = pending_blocks, i = 0; next; next = next->next, i++) {;}
308 blockvector = (struct blockvector *)
309 obstack_alloc (&objfile -> symbol_obstack,
310 (sizeof (struct blockvector)
311 + (i - 1) * sizeof (struct block *)));
313 /* Copy the blocks into the blockvector.
314 This is done in reverse order, which happens to put
315 the blocks into the proper order (ascending starting address).
316 finish_block has hair to insert each block into the list
317 after its subblocks in order to make sure this is true. */
319 BLOCKVECTOR_NBLOCKS (blockvector) = i;
320 for (next = pending_blocks; next; next = next->next)
322 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
325 #if 0 /* Now we make the links in the obstack, so don't free them. */
326 /* Now free the links of the list, and empty the list. */
328 for (next = pending_blocks; next; next = next1)
334 pending_blocks = NULL;
336 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
337 /* Some compilers output blocks in the wrong order, but we depend
338 on their being in the right order so we can binary search.
339 Check the order and moan about it. FIXME. */
340 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
342 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++)
344 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
345 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)))
347 complain (&blockvector_complaint,
348 (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
354 return (blockvector);
358 /* Start recording information about source code that came from an included
359 (or otherwise merged-in) source file with a different name. */
362 start_subfile (name, dirname)
366 register struct subfile *subfile;
368 /* See if this subfile is already known as a subfile of the
369 current main source file. */
371 for (subfile = subfiles; subfile; subfile = subfile->next)
373 if (!strcmp (subfile->name, name))
375 current_subfile = subfile;
380 /* This subfile is not known. Add an entry for it.
381 Make an entry for this subfile in the list of all subfiles
382 of the current main source file. */
384 subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
385 subfile->next = subfiles;
387 current_subfile = subfile;
389 /* Save its name and compilation directory name */
390 subfile->name = strdup (name);
393 subfile->dirname = NULL;
397 subfile->dirname = strdup (dirname);
400 /* Initialize line-number recording for this subfile. */
401 subfile->line_vector = NULL;
405 /* Handle the N_BINCL and N_EINCL symbol types
406 that act like N_SOL for switching source files
407 (different subfiles, as we call them) within one object file,
408 but using a stack rather than in an arbitrary order. */
413 register struct subfile_stack *tem
414 = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
416 tem->next = subfile_stack;
418 if (current_subfile == NULL || current_subfile->name == NULL)
422 tem->name = current_subfile->name;
429 register struct subfile_stack *link = subfile_stack;
436 subfile_stack = link->next;
442 /* Manage the vector of line numbers for each subfile. */
445 record_line (subfile, line, pc)
446 register struct subfile *subfile;
450 struct linetable_entry *e;
451 /* Ignore the dummy line number in libg.o */
458 /* Make sure line vector exists and is big enough. */
459 if (!subfile->line_vector)
461 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH;
462 subfile->line_vector = (struct linetable *)
463 xmalloc (sizeof (struct linetable)
464 + subfile->line_vector_length * sizeof (struct linetable_entry));
465 subfile->line_vector->nitems = 0;
468 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
470 subfile->line_vector_length *= 2;
471 subfile->line_vector = (struct linetable *)
472 xrealloc ((char *) subfile->line_vector, (sizeof (struct linetable)
473 + subfile->line_vector_length * sizeof (struct linetable_entry)));
476 e = subfile->line_vector->item + subfile->line_vector->nitems++;
477 e->line = line; e->pc = pc;
481 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
484 compare_line_numbers (ln1p, ln2p)
488 return (((struct linetable_entry *) ln1p) -> line -
489 ((struct linetable_entry *) ln2p) -> line);
493 /* Start a new symtab for a new source file.
494 Called, for example, when a stabs symbol of type N_SO is seen, or when
495 a DWARF TAG_compile_unit DIE is seen.
496 It indicates the start of data for one original source file. */
499 start_symtab (name, dirname, start_addr)
502 CORE_ADDR start_addr;
505 last_source_file = name;
506 last_source_start_addr = start_addr;
508 global_symbols = NULL;
511 /* Context stack is initially empty. Allocate first one with room for
512 10 levels; reuse it forever afterward. */
513 if (context_stack == NULL)
515 context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
516 context_stack = (struct context_stack *)
517 xmalloc (context_stack_size * sizeof (struct context_stack));
519 context_stack_depth = 0;
521 /* Initialize the list of sub source files with one entry
522 for this file (the top-level source file). */
525 current_subfile = NULL;
526 start_subfile (name, dirname);
529 /* Finish the symbol definitions for one main source file,
530 close off all the lexical contexts for that file
531 (creating struct block's for them), then make the struct symtab
532 for that file and put it in the list of all such.
534 END_ADDR is the address of the end of the file's text. */
537 end_symtab (end_addr, sort_pending, sort_linevec, objfile)
541 struct objfile *objfile;
543 register struct symtab *symtab;
544 register struct blockvector *blockvector;
545 register struct subfile *subfile;
546 register struct context_stack *cstk;
547 struct subfile *nextsub;
549 /* Finish the lexical context of the last function in the file;
550 pop the context stack. */
552 if (context_stack_depth > 0)
554 context_stack_depth--;
555 cstk = &context_stack[context_stack_depth];
556 /* Make a block for the local symbols within. */
557 finish_block (cstk->name, &local_symbols, cstk->old_blocks,
558 cstk->start_addr, end_addr, objfile);
560 /* Debug: if context stack still has something in it,
561 we are in trouble. */
562 if (context_stack_depth > 0)
568 /* It is unfortunate that in aixcoff, pending blocks might not be ordered
569 in this stage. Especially, blocks for static functions will show up at
570 the end. We need to sort them, so tools like `find_pc_function' and
571 `find_pc_block' can work reliably. */
573 if (sort_pending && pending_blocks)
575 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
579 struct pending_block *pb, *pbnext;
587 /* swap blocks if unordered! */
589 if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block))
591 struct block *tmp = pb->block;
592 pb->block = pbnext->block;
597 pbnext = pbnext->next;
602 /* Cleanup any undefined types that have been left hanging around
603 (this needs to be done before the finish_blocks so that
604 file_symbols is still good).
605 FIXME: Stabs specific. */
606 cleanup_undefined_types ();
607 finish_global_stabs (objfile);
609 if (pending_blocks == NULL
610 && file_symbols == NULL
611 && global_symbols == NULL)
613 /* Ignore symtabs that have no functions with real debugging info */
618 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */
619 finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr,
621 finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr,
623 blockvector = make_blockvector (objfile);
626 #ifdef PROCESS_LINENUMBER_HOOK
627 PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
630 /* Now create the symtab objects proper, one for each subfile. */
631 /* (The main file is the last one on the chain.) */
633 for (subfile = subfiles; subfile; subfile = nextsub)
636 /* If we have blocks of symbols, make a symtab.
637 Otherwise, just ignore this file and any line number info in it. */
641 if (subfile->line_vector)
643 /* First, shrink the linetable to make more memory. */
644 linetablesize = sizeof (struct linetable) +
645 subfile->line_vector->nitems * sizeof (struct linetable_entry);
646 subfile->line_vector = (struct linetable *)
647 xrealloc ((char *) subfile->line_vector, linetablesize);
650 qsort (subfile->line_vector->item,
651 subfile->line_vector->nitems,
652 sizeof (struct linetable_entry), compare_line_numbers);
655 /* Now, allocate a symbol table. */
656 symtab = allocate_symtab (subfile->name, objfile);
658 /* Fill in its components. */
659 symtab->blockvector = blockvector;
660 if (subfile->line_vector)
662 /* Reallocate the line table on the symbol obstack */
663 symtab->linetable = (struct linetable *)
664 obstack_alloc (&objfile -> symbol_obstack, linetablesize);
665 memcpy (symtab->linetable, subfile->line_vector, linetablesize);
669 symtab->linetable = NULL;
671 if (subfile->dirname)
673 /* Reallocate the dirname on the symbol obstack */
674 symtab->dirname = (char *)
675 obstack_alloc (&objfile -> symbol_obstack,
676 strlen (subfile -> dirname) + 1);
677 strcpy (symtab->dirname, subfile->dirname);
681 symtab->dirname = NULL;
683 symtab->free_code = free_linetable;
684 symtab->free_ptr = NULL;
686 #ifdef IBM6000_TARGET
687 /* In case we need to duplicate symbol tables (to represent include
688 files), and in case our system needs relocation, we want to
689 relocate the main symbol table node only (for the main file,
690 not for the include files). */
692 symtab->nonreloc = TRUE;
695 if (subfile->line_vector)
697 free ((PTR)subfile->line_vector);
700 nextsub = subfile->next;
704 #ifdef IBM6000_TARGET
705 /* all include symbol tables are non-relocatable, except the main source
709 symtab->nonreloc = FALSE;
713 last_source_file = NULL;
714 current_subfile = NULL;
720 /* Push a context block. Args are an identifying nesting level (checkable
721 when you pop it), and the starting PC address of this context. */
723 struct context_stack *
724 push_context (desc, valu)
728 register struct context_stack *new;
730 if (context_stack_depth == context_stack_size)
732 context_stack_size *= 2;
733 context_stack = (struct context_stack *)
734 xrealloc ((char *) context_stack,
735 (context_stack_size * sizeof (struct context_stack)));
738 new = &context_stack[context_stack_depth++];
740 new->locals = local_symbols;
741 new->old_blocks = pending_blocks;
742 new->start_addr = valu;
745 local_symbols = NULL;
751 /* Initialize anything that needs initializing when starting to read
752 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
758 free_pendings = NULL;
760 global_symbols = NULL;
761 pending_blocks = NULL;
764 /* Initialize anything that needs initializing when a completely new
765 symbol file is specified (not just adding some symbols from another
766 file, e.g. a shared library). */
774 /* Initializer for this module */
777 _initialize_buildsym ()