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; next
; i
+= next
->nsyms
, next
= next
->next
)
197 block
= (struct block
*) obstack_alloc (&objfile
-> symbol_obstack
,
198 (sizeof (struct block
) + ((i
- 1) * sizeof (struct symbol
*))));
200 /* Copy the symbols into the block. */
202 BLOCK_NSYMS (block
) = i
;
203 for (next
= *listhead
; next
; next
= next
->next
)
205 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
207 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
211 BLOCK_START (block
) = start
;
212 BLOCK_END (block
) = end
;
213 /* Superblock filled in when containing block is made */
214 BLOCK_SUPERBLOCK (block
) = NULL
;
215 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
217 /* Put the block in as the value of the symbol that names it. */
221 SYMBOL_BLOCK_VALUE (symbol
) = block
;
222 BLOCK_FUNCTION (block
) = symbol
;
226 BLOCK_FUNCTION (block
) = NULL
;
229 /* Now "free" the links of the list, and empty the list. */
231 for (next
= *listhead
; next
; next
= next1
)
234 next
->next
= free_pendings
;
235 free_pendings
= next
;
239 /* Install this block as the superblock
240 of all blocks made since the start of this scope
241 that don't have superblocks yet. */
244 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
246 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
249 /* Check to be sure the blocks are nested as we receive them.
250 If the compiler/assembler/linker work, this just burns a small
252 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
) ||
253 BLOCK_END (pblock
->block
) > BLOCK_END (block
))
257 complain (&innerblock_complaint
, SYMBOL_NAME (symbol
));
261 complain (&innerblock_anon_complaint
, 0);
263 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
264 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
267 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
272 /* Record this block on the list of all blocks in the file.
273 Put it after opblock, or at the beginning if opblock is 0.
274 This puts the block in the list after all its subblocks. */
276 /* Allocate in the symbol_obstack to save time.
277 It wastes a little space. */
278 pblock
= (struct pending_block
*)
279 obstack_alloc (&objfile
-> symbol_obstack
,
280 sizeof (struct pending_block
));
281 pblock
->block
= block
;
284 pblock
->next
= opblock
->next
;
285 opblock
->next
= pblock
;
289 pblock
->next
= pending_blocks
;
290 pending_blocks
= pblock
;
294 static struct blockvector
*
295 make_blockvector (objfile
)
296 struct objfile
*objfile
;
298 register struct pending_block
*next
;
299 register struct blockvector
*blockvector
;
302 /* Count the length of the list of blocks. */
304 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++) {;}
306 blockvector
= (struct blockvector
*)
307 obstack_alloc (&objfile
-> symbol_obstack
,
308 (sizeof (struct blockvector
)
309 + (i
- 1) * sizeof (struct block
*)));
311 /* Copy the blocks into the blockvector.
312 This is done in reverse order, which happens to put
313 the blocks into the proper order (ascending starting address).
314 finish_block has hair to insert each block into the list
315 after its subblocks in order to make sure this is true. */
317 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
318 for (next
= pending_blocks
; next
; next
= next
->next
)
320 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
323 #if 0 /* Now we make the links in the obstack, so don't free them. */
324 /* Now free the links of the list, and empty the list. */
326 for (next
= pending_blocks
; next
; next
= next1
)
332 pending_blocks
= NULL
;
334 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
335 /* Some compilers output blocks in the wrong order, but we depend
336 on their being in the right order so we can binary search.
337 Check the order and moan about it. FIXME. */
338 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
340 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
342 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
343 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)))
345 complain (&blockvector_complaint
,
346 (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
352 return (blockvector
);
356 /* Start recording information about source code that came from an included
357 (or otherwise merged-in) source file with a different name. */
360 start_subfile (name
, dirname
)
364 register struct subfile
*subfile
;
366 /* See if this subfile is already known as a subfile of the
367 current main source file. */
369 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
371 if (!strcmp (subfile
->name
, name
))
373 current_subfile
= subfile
;
378 /* This subfile is not known. Add an entry for it.
379 Make an entry for this subfile in the list of all subfiles
380 of the current main source file. */
382 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
383 subfile
->next
= subfiles
;
385 current_subfile
= subfile
;
387 /* Save its name and compilation directory name */
388 subfile
->name
= strdup (name
);
391 subfile
->dirname
= NULL
;
395 subfile
->dirname
= strdup (dirname
);
398 /* Initialize line-number recording for this subfile. */
399 subfile
->line_vector
= NULL
;
403 /* Handle the N_BINCL and N_EINCL symbol types
404 that act like N_SOL for switching source files
405 (different subfiles, as we call them) within one object file,
406 but using a stack rather than in an arbitrary order. */
411 register struct subfile_stack
*tem
412 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
414 tem
->next
= subfile_stack
;
416 if (current_subfile
== NULL
|| current_subfile
->name
== NULL
)
420 tem
->name
= current_subfile
->name
;
427 register struct subfile_stack
*link
= subfile_stack
;
434 subfile_stack
= link
->next
;
440 /* Manage the vector of line numbers for each subfile. */
443 record_line (subfile
, line
, pc
)
444 register struct subfile
*subfile
;
448 struct linetable_entry
*e
;
449 /* Ignore the dummy line number in libg.o */
456 /* Make sure line vector exists and is big enough. */
457 if (!subfile
->line_vector
)
459 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
460 subfile
->line_vector
= (struct linetable
*)
461 xmalloc (sizeof (struct linetable
)
462 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
463 subfile
->line_vector
->nitems
= 0;
466 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
468 subfile
->line_vector_length
*= 2;
469 subfile
->line_vector
= (struct linetable
*)
470 xrealloc ((char *) subfile
->line_vector
, (sizeof (struct linetable
)
471 + subfile
->line_vector_length
* sizeof (struct linetable_entry
)));
474 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
475 e
->line
= line
; e
->pc
= pc
;
479 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
482 compare_line_numbers (ln1p
, ln2p
)
486 return (((struct linetable_entry
*) ln1p
) -> line
-
487 ((struct linetable_entry
*) ln2p
) -> line
);
491 /* Start a new symtab for a new source file.
492 Called, for example, when a stabs symbol of type N_SO is seen, or when
493 a DWARF TAG_compile_unit DIE is seen.
494 It indicates the start of data for one original source file. */
497 start_symtab (name
, dirname
, start_addr
)
500 CORE_ADDR start_addr
;
503 last_source_file
= name
;
504 last_source_start_addr
= start_addr
;
506 global_symbols
= NULL
;
509 /* Context stack is initially empty. Allocate first one with room for
510 10 levels; reuse it forever afterward. */
511 if (context_stack
== NULL
)
513 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
514 context_stack
= (struct context_stack
*)
515 xmalloc (context_stack_size
* sizeof (struct context_stack
));
517 context_stack_depth
= 0;
519 /* Initialize the list of sub source files with one entry
520 for this file (the top-level source file). */
523 current_subfile
= NULL
;
524 start_subfile (name
, dirname
);
527 /* Finish the symbol definitions for one main source file,
528 close off all the lexical contexts for that file
529 (creating struct block's for them), then make the struct symtab
530 for that file and put it in the list of all such.
532 END_ADDR is the address of the end of the file's text. */
535 end_symtab (end_addr
, sort_pending
, sort_linevec
, objfile
)
539 struct objfile
*objfile
;
541 register struct symtab
*symtab
;
542 register struct blockvector
*blockvector
;
543 register struct subfile
*subfile
;
544 register struct context_stack
*cstk
;
545 struct subfile
*nextsub
;
547 /* Finish the lexical context of the last function in the file;
548 pop the context stack. */
550 if (context_stack_depth
> 0)
552 context_stack_depth
--;
553 cstk
= &context_stack
[context_stack_depth
];
554 /* Make a block for the local symbols within. */
555 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
556 cstk
->start_addr
, end_addr
, objfile
);
558 /* Debug: if context stack still has something in it,
559 we are in trouble. */
560 if (context_stack_depth
> 0)
566 /* It is unfortunate that in aixcoff, pending blocks might not be ordered
567 in this stage. Especially, blocks for static functions will show up at
568 the end. We need to sort them, so tools like `find_pc_function' and
569 `find_pc_block' can work reliably. */
571 if (sort_pending
&& pending_blocks
)
573 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
577 struct pending_block
*pb
, *pbnext
;
585 /* swap blocks if unordered! */
587 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
))
589 struct block
*tmp
= pb
->block
;
590 pb
->block
= pbnext
->block
;
595 pbnext
= pbnext
->next
;
600 /* Cleanup any undefined types that have been left hanging around
601 (this needs to be done before the finish_blocks so that
602 file_symbols is still good).
603 FIXME: Stabs specific. */
604 cleanup_undefined_types ();
605 finish_global_stabs (objfile
);
607 if (pending_blocks
== NULL
608 && file_symbols
== NULL
609 && global_symbols
== NULL
)
611 /* Ignore symtabs that have no functions with real debugging info */
616 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */
617 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
,
619 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
,
621 blockvector
= make_blockvector (objfile
);
624 #ifdef PROCESS_LINENUMBER_HOOK
625 PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
628 /* Now create the symtab objects proper, one for each subfile. */
629 /* (The main file is the last one on the chain.) */
631 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
634 /* If we have blocks of symbols, make a symtab.
635 Otherwise, just ignore this file and any line number info in it. */
639 if (subfile
->line_vector
)
641 /* First, shrink the linetable to make more memory. */
642 linetablesize
= sizeof (struct linetable
) +
643 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
644 subfile
->line_vector
= (struct linetable
*)
645 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
648 qsort (subfile
->line_vector
->item
,
649 subfile
->line_vector
->nitems
,
650 sizeof (struct linetable_entry
), compare_line_numbers
);
653 /* Now, allocate a symbol table. */
654 symtab
= allocate_symtab (subfile
->name
, objfile
);
656 /* Fill in its components. */
657 symtab
->blockvector
= blockvector
;
658 if (subfile
->line_vector
)
660 /* Reallocate the line table on the symbol obstack */
661 symtab
->linetable
= (struct linetable
*)
662 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
663 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
667 symtab
->linetable
= NULL
;
669 symtab
->dirname
= subfile
->dirname
;
670 symtab
->free_code
= free_linetable
;
671 symtab
->free_ptr
= NULL
;
673 #ifdef IBM6000_TARGET
674 /* In case we need to duplicate symbol tables (to represent include
675 files), and in case our system needs relocation, we want to
676 relocate the main symbol table node only (for the main file,
677 not for the include files). */
679 symtab
->nonreloc
= TRUE
;
682 if (subfile
->line_vector
)
684 free ((PTR
)subfile
->line_vector
);
687 nextsub
= subfile
->next
;
691 #ifdef IBM6000_TARGET
692 /* all include symbol tables are non-relocatable, except the main source
696 symtab
->nonreloc
= FALSE
;
700 last_source_file
= NULL
;
701 current_subfile
= NULL
;
707 /* Push a context block. Args are an identifying nesting level (checkable
708 when you pop it), and the starting PC address of this context. */
710 struct context_stack
*
711 push_context (desc
, valu
)
715 register struct context_stack
*new;
717 if (context_stack_depth
== context_stack_size
)
719 context_stack_size
*= 2;
720 context_stack
= (struct context_stack
*)
721 xrealloc ((char *) context_stack
,
722 (context_stack_size
* sizeof (struct context_stack
)));
725 new = &context_stack
[context_stack_depth
++];
727 new->locals
= local_symbols
;
728 new->old_blocks
= pending_blocks
;
729 new->start_addr
= valu
;
732 local_symbols
= NULL
;
738 /* Initialize anything that needs initializing when starting to read
739 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
745 free_pendings
= NULL
;
747 global_symbols
= NULL
;
748 pending_blocks
= NULL
;
751 /* Initialize anything that needs initializing when a completely new
752 symbol file is specified (not just adding some symbols from another
753 file, e.g. a shared library). */
761 /* Initializer for this module */
764 _initialize_buildsym ()