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" */
34 #include "complaints.h"
37 /* Ask buildsym.h to define the vars it normally declares `extern'. */
39 #include "buildsym.h" /* Our own declarations */
43 compare_line_numbers
PARAMS ((const void *, const void *));
45 static struct blockvector
*
46 make_blockvector
PARAMS ((struct objfile
*));
49 /* Initial sizes of data structures. These are realloc'd larger if needed,
50 and realloc'd down to the size actually used, when completed. */
52 #define INITIAL_CONTEXT_STACK_SIZE 10
53 #define INITIAL_LINE_VECTOR_LENGTH 1000
56 /* Complaints about the symbols we have encountered. */
58 struct complaint innerblock_complaint
=
59 {"inner block not inside outer block in %s", 0, 0};
61 struct complaint innerblock_anon_complaint
=
62 {"inner block not inside outer block", 0, 0};
64 struct complaint blockvector_complaint
=
65 {"block at 0x%x out of order", 0, 0};
68 /* maintain the lists of symbols and blocks */
70 /* Add a symbol to one of the lists of symbols. */
73 add_symbol_to_list (symbol
, listhead
)
74 struct symbol
*symbol
;
75 struct pending
**listhead
;
77 register struct pending
*link
;
79 /* We keep PENDINGSIZE symbols in each link of the list.
80 If we don't have a link with room in it, add a new link. */
81 if (*listhead
== NULL
|| (*listhead
)->nsyms
== PENDINGSIZE
)
86 free_pendings
= link
->next
;
90 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
93 link
->next
= *listhead
;
98 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
101 /* Find a symbol named NAME on a LIST. NAME need not be '\0'-terminated;
102 LENGTH is the length of the name. */
105 find_symbol_in_list (list
, name
, length
)
106 struct pending
*list
;
115 for (j
= list
->nsyms
; --j
>= 0; )
117 pp
= SYMBOL_NAME (list
->symbol
[j
]);
118 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0 &&
121 return (list
->symbol
[j
]);
129 /* At end of reading syms, or in case of quit,
130 really free as many `struct pending's as we can easily find. */
134 really_free_pendings (foo
)
137 struct pending
*next
, *next1
;
139 struct pending_block
*bnext
, *bnext1
;
142 for (next
= free_pendings
; next
; next
= next1
)
147 free_pendings
= NULL
;
149 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
150 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
152 bnext1
= bnext
->next
;
156 pending_blocks
= NULL
;
158 for (next
= file_symbols
; next
!= NULL
; next
= next1
)
165 for (next
= global_symbols
; next
!= NULL
; next
= next1
)
170 global_symbols
= NULL
;
173 /* Take one of the lists of symbols and make a block from it.
174 Keep the order the symbols have in the list (reversed from the input file).
175 Put the block on the list of pending blocks. */
178 finish_block (symbol
, listhead
, old_blocks
, start
, end
, objfile
)
179 struct symbol
*symbol
;
180 struct pending
**listhead
;
181 struct pending_block
*old_blocks
;
182 CORE_ADDR start
, end
;
183 struct objfile
*objfile
;
185 register struct pending
*next
, *next1
;
186 register struct block
*block
;
187 register struct pending_block
*pblock
;
188 struct pending_block
*opblock
;
192 /* Count the length of the list of symbols. */
194 for (next
= *listhead
, i
= 0;
196 i
+= next
->nsyms
, next
= next
->next
)
201 block
= (struct block
*) obstack_alloc (&objfile
-> symbol_obstack
,
202 (sizeof (struct block
) + ((i
- 1) * sizeof (struct symbol
*))));
204 /* Copy the symbols into the block. */
206 BLOCK_NSYMS (block
) = i
;
207 for (next
= *listhead
; next
; next
= next
->next
)
209 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
211 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
215 BLOCK_START (block
) = start
;
216 BLOCK_END (block
) = end
;
217 /* Superblock filled in when containing block is made */
218 BLOCK_SUPERBLOCK (block
) = NULL
;
219 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
221 /* Put the block in as the value of the symbol that names it. */
225 SYMBOL_BLOCK_VALUE (symbol
) = block
;
226 BLOCK_FUNCTION (block
) = symbol
;
230 BLOCK_FUNCTION (block
) = NULL
;
233 /* Now "free" the links of the list, and empty the list. */
235 for (next
= *listhead
; next
; next
= next1
)
238 next
->next
= free_pendings
;
239 free_pendings
= next
;
243 /* Install this block as the superblock
244 of all blocks made since the start of this scope
245 that don't have superblocks yet. */
248 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
250 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
253 /* Check to be sure the blocks are nested as we receive them.
254 If the compiler/assembler/linker work, this just burns a small
256 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
) ||
257 BLOCK_END (pblock
->block
) > BLOCK_END (block
))
261 complain (&innerblock_complaint
,
262 SYMBOL_SOURCE_NAME (symbol
));
266 complain (&innerblock_anon_complaint
);
268 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
269 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
272 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
277 /* Record this block on the list of all blocks in the file.
278 Put it after opblock, or at the beginning if opblock is 0.
279 This puts the block in the list after all its subblocks. */
281 /* Allocate in the symbol_obstack to save time.
282 It wastes a little space. */
283 pblock
= (struct pending_block
*)
284 obstack_alloc (&objfile
-> symbol_obstack
,
285 sizeof (struct pending_block
));
286 pblock
->block
= block
;
289 pblock
->next
= opblock
->next
;
290 opblock
->next
= pblock
;
294 pblock
->next
= pending_blocks
;
295 pending_blocks
= pblock
;
299 static struct blockvector
*
300 make_blockvector (objfile
)
301 struct objfile
*objfile
;
303 register struct pending_block
*next
;
304 register struct blockvector
*blockvector
;
307 /* Count the length of the list of blocks. */
309 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++) {;}
311 blockvector
= (struct blockvector
*)
312 obstack_alloc (&objfile
-> symbol_obstack
,
313 (sizeof (struct blockvector
)
314 + (i
- 1) * sizeof (struct block
*)));
316 /* Copy the blocks into the blockvector.
317 This is done in reverse order, which happens to put
318 the blocks into the proper order (ascending starting address).
319 finish_block has hair to insert each block into the list
320 after its subblocks in order to make sure this is true. */
322 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
323 for (next
= pending_blocks
; next
; next
= next
->next
)
325 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
328 #if 0 /* Now we make the links in the obstack, so don't free them. */
329 /* Now free the links of the list, and empty the list. */
331 for (next
= pending_blocks
; next
; next
= next1
)
337 pending_blocks
= NULL
;
339 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
340 /* Some compilers output blocks in the wrong order, but we depend
341 on their being in the right order so we can binary search.
342 Check the order and moan about it. FIXME. */
343 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
345 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
347 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
348 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)))
350 complain (&blockvector_complaint
,
351 BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
357 return (blockvector
);
361 /* Start recording information about source code that came from an included
362 (or otherwise merged-in) source file with a different name. NAME is
363 the name of the file (cannot be NULL), DIRNAME is the directory in which
364 it resides (or NULL if not known). */
367 start_subfile (name
, dirname
)
371 register struct subfile
*subfile
;
373 /* See if this subfile is already known as a subfile of the
374 current main source file. */
376 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
378 if (STREQ (subfile
->name
, name
))
380 current_subfile
= subfile
;
385 /* This subfile is not known. Add an entry for it.
386 Make an entry for this subfile in the list of all subfiles
387 of the current main source file. */
389 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
390 subfile
->next
= subfiles
;
392 current_subfile
= subfile
;
394 /* Save its name and compilation directory name */
395 subfile
->name
= (name
== NULL
)? NULL
: strdup (name
);
396 subfile
->dirname
= (dirname
== NULL
) ? NULL
: strdup (dirname
);
398 /* Initialize line-number recording for this subfile. */
399 subfile
->line_vector
= NULL
;
401 /* Default the source language to whatever can be deduced from
402 the filename. If nothing can be deduced (such as for a C/C++
403 include file with a ".h" extension), then inherit whatever
404 language the previous subfile had. This kludgery is necessary
405 because there is no standard way in some object formats to
406 record the source language. Also, when symtabs are allocated
407 we try to deduce a language then as well, but it is too late
408 for us to use that information while reading symbols, since
409 symtabs aren't allocated until after all the symbols have
410 been processed for a given source file. */
412 subfile
->language
= deduce_language_from_filename (subfile
->name
);
413 if (subfile
->language
== language_unknown
&&
414 subfile
->next
!= NULL
)
416 subfile
->language
= subfile
->next
->language
;
419 /* cfront output is a C program, so in most ways it looks like a C
420 program. But to demangle we need to set the language to C++. We
421 can distinguish cfront code by the fact that it has #line
422 directives which specify a file name ending in .C.
424 So if the filename of this subfile ends in .C, then change the language
425 of any pending subfiles from C to C++. .cc is also accepted, even
426 though I don't think cfront allows it. */
433 p
= strrchr (subfile
->name
, '.');
435 && ((p
[1] == 'C' && p
[2] == '\0')
436 || (p
[1] == 'c' && p
[2] == 'c' && p
[3] == '\0')))
437 for (s
= subfiles
; s
!= NULL
; s
= s
->next
)
438 if (s
->language
== language_c
)
439 s
->language
= language_cplus
;
442 /* And patch up this file if necessary. */
443 if (subfile
->language
== language_c
444 && subfile
->next
!= NULL
445 && subfile
->next
->language
== language_cplus
)
447 subfile
->language
= language_cplus
;
451 /* For stabs readers, the first N_SO symbol is assumed to be the source
452 file name, and the subfile struct is initialized using that assumption.
453 If another N_SO symbol is later seen, immediately following the first
454 one, then the first one is assumed to be the directory name and the
455 second one is really the source file name.
457 So we have to patch up the subfile struct by moving the old name value to
458 dirname and remembering the new name. Some sanity checking is performed
459 to ensure that the state of the subfile struct is reasonable and that the
460 old name we are assuming to be a directory name actually is (by checking
461 for a trailing '/'). */
464 patch_subfile_names (subfile
, name
)
465 struct subfile
*subfile
;
468 if (subfile
!= NULL
&& subfile
->dirname
== NULL
&& subfile
->name
!= NULL
469 && subfile
->name
[strlen(subfile
->name
)-1] == '/')
471 subfile
->dirname
= subfile
->name
;
472 subfile
->name
= strdup (name
);
474 /* Default the source language to whatever can be deduced from
475 the filename. If nothing can be deduced (such as for a C/C++
476 include file with a ".h" extension), then inherit whatever
477 language the previous subfile had. This kludgery is necessary
478 because there is no standard way in some object formats to
479 record the source language. Also, when symtabs are allocated
480 we try to deduce a language then as well, but it is too late
481 for us to use that information while reading symbols, since
482 symtabs aren't allocated until after all the symbols have
483 been processed for a given source file. */
485 subfile
->language
= deduce_language_from_filename (subfile
->name
);
486 if (subfile
->language
== language_unknown
&&
487 subfile
->next
!= NULL
)
489 subfile
->language
= subfile
->next
->language
;
495 /* Handle the N_BINCL and N_EINCL symbol types
496 that act like N_SOL for switching source files
497 (different subfiles, as we call them) within one object file,
498 but using a stack rather than in an arbitrary order. */
503 register struct subfile_stack
*tem
504 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
506 tem
->next
= subfile_stack
;
508 if (current_subfile
== NULL
|| current_subfile
->name
== NULL
)
512 tem
->name
= current_subfile
->name
;
519 register struct subfile_stack
*link
= subfile_stack
;
526 subfile_stack
= link
->next
;
532 /* Add a linetable entry for line number LINE and address PC to the line
533 vector for SUBFILE. */
536 record_line (subfile
, line
, pc
)
537 register struct subfile
*subfile
;
541 struct linetable_entry
*e
;
542 /* Ignore the dummy line number in libg.o */
549 /* Make sure line vector exists and is big enough. */
550 if (!subfile
->line_vector
)
552 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
553 subfile
->line_vector
= (struct linetable
*)
554 xmalloc (sizeof (struct linetable
)
555 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
556 subfile
->line_vector
->nitems
= 0;
559 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
561 subfile
->line_vector_length
*= 2;
562 subfile
->line_vector
= (struct linetable
*)
563 xrealloc ((char *) subfile
->line_vector
, (sizeof (struct linetable
)
564 + subfile
->line_vector_length
* sizeof (struct linetable_entry
)));
567 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
568 e
->line
= line
; e
->pc
= pc
;
572 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
575 compare_line_numbers (ln1p
, ln2p
)
579 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
580 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
582 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
583 Please keep it that way. */
584 if (ln1
->pc
< ln2
->pc
)
587 if (ln1
->pc
> ln2
->pc
)
590 /* If pc equal, sort by line. I'm not sure whether this is optimum
591 behavior (see comment at struct linetable in symtab.h). */
592 return ln1
->line
- ln2
->line
;
596 /* Start a new symtab for a new source file.
597 Called, for example, when a stabs symbol of type N_SO is seen, or when
598 a DWARF TAG_compile_unit DIE is seen.
599 It indicates the start of data for one original source file. */
602 start_symtab (name
, dirname
, start_addr
)
605 CORE_ADDR start_addr
;
608 last_source_file
= name
;
609 last_source_start_addr
= start_addr
;
611 global_symbols
= NULL
;
614 /* Context stack is initially empty. Allocate first one with room for
615 10 levels; reuse it forever afterward. */
616 if (context_stack
== NULL
)
618 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
619 context_stack
= (struct context_stack
*)
620 xmalloc (context_stack_size
* sizeof (struct context_stack
));
622 context_stack_depth
= 0;
624 /* Initialize the list of sub source files with one entry
625 for this file (the top-level source file). */
628 current_subfile
= NULL
;
629 start_subfile (name
, dirname
);
632 /* Finish the symbol definitions for one main source file,
633 close off all the lexical contexts for that file
634 (creating struct block's for them), then make the struct symtab
635 for that file and put it in the list of all such.
637 END_ADDR is the address of the end of the file's text.
638 SECTION is the section number (in objfile->section_offsets) of
639 the blockvector and linetable.
641 Note that it is possible for end_symtab() to return NULL. In particular,
642 for the DWARF case at least, it will return NULL when it finds a
643 compilation unit that has exactly one DIE, a TAG_compile_unit DIE. This
644 can happen when we link in an object file that was compiled from an empty
645 source file. Returning NULL is probably not the correct thing to do,
646 because then gdb will never know about this empty file (FIXME). */
649 end_symtab (end_addr
, sort_pending
, sort_linevec
, objfile
, section
)
653 struct objfile
*objfile
;
656 register struct symtab
*symtab
;
657 register struct blockvector
*blockvector
;
658 register struct subfile
*subfile
;
659 register struct context_stack
*cstk
;
660 struct subfile
*nextsub
;
662 /* Finish the lexical context of the last function in the file;
663 pop the context stack. */
665 if (context_stack_depth
> 0)
667 context_stack_depth
--;
668 cstk
= &context_stack
[context_stack_depth
];
669 /* Make a block for the local symbols within. */
670 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
671 cstk
->start_addr
, end_addr
, objfile
);
673 /* Debug: if context stack still has something in it,
674 we are in trouble. */
675 if (context_stack_depth
> 0)
681 /* It is unfortunate that in xcoff, pending blocks might not be ordered
682 in this stage. Especially, blocks for static functions will show up at
683 the end. We need to sort them, so tools like `find_pc_function' and
684 `find_pc_block' can work reliably. */
686 if (sort_pending
&& pending_blocks
)
688 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
692 struct pending_block
*pb
, *pbnext
;
700 /* swap blocks if unordered! */
702 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
))
704 struct block
*tmp
= pb
->block
;
705 pb
->block
= pbnext
->block
;
710 pbnext
= pbnext
->next
;
715 /* Cleanup any undefined types that have been left hanging around
716 (this needs to be done before the finish_blocks so that
717 file_symbols is still good).
719 Both cleanup_undefined_types and finish_global_stabs are stabs
720 specific, but harmless for other symbol readers, since on gdb
721 startup or when finished reading stabs, the state is set so these
722 are no-ops. FIXME: Is this handled right in case of QUIT? Can
723 we make this cleaner? */
725 cleanup_undefined_types ();
726 finish_global_stabs (objfile
);
728 if (pending_blocks
== NULL
729 && file_symbols
== NULL
730 && global_symbols
== NULL
)
732 /* Ignore symtabs that have no functions with real debugging info */
737 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */
738 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
,
740 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
,
742 blockvector
= make_blockvector (objfile
);
745 #ifdef PROCESS_LINENUMBER_HOOK
746 PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */
749 /* Now create the symtab objects proper, one for each subfile. */
750 /* (The main file is the last one on the chain.) */
752 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
755 /* If we have blocks of symbols, make a symtab.
756 Otherwise, just ignore this file and any line number info in it. */
760 if (subfile
->line_vector
)
762 linetablesize
= sizeof (struct linetable
) +
763 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
765 /* I think this is artifact from before it went on the obstack.
766 I doubt we'll need the memory between now and when we
767 free it later in this function. */
768 /* First, shrink the linetable to make more memory. */
769 subfile
->line_vector
= (struct linetable
*)
770 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
772 /* If sort_linevec is false, we might want just check to make
773 sure they are sorted and complain() if not, as a way of
774 tracking down compilers/symbol readers which don't get
775 them sorted right. */
778 qsort (subfile
->line_vector
->item
,
779 subfile
->line_vector
->nitems
,
780 sizeof (struct linetable_entry
), compare_line_numbers
);
783 /* Now, allocate a symbol table. */
784 symtab
= allocate_symtab (subfile
->name
, objfile
);
786 /* Fill in its components. */
787 symtab
->blockvector
= blockvector
;
788 if (subfile
->line_vector
)
790 /* Reallocate the line table on the symbol obstack */
791 symtab
->linetable
= (struct linetable
*)
792 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
793 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
797 symtab
->linetable
= NULL
;
799 symtab
->block_line_section
= section
;
800 if (subfile
->dirname
)
802 /* Reallocate the dirname on the symbol obstack */
803 symtab
->dirname
= (char *)
804 obstack_alloc (&objfile
-> symbol_obstack
,
805 strlen (subfile
-> dirname
) + 1);
806 strcpy (symtab
->dirname
, subfile
->dirname
);
810 symtab
->dirname
= NULL
;
812 symtab
->free_code
= free_linetable
;
813 symtab
->free_ptr
= NULL
;
815 /* Use whatever language we have been using for this subfile,
816 not the one that was deduced in allocate_symtab from the
817 filename. We already did our own deducing when we created
818 the subfile, and we may have altered our opinion of what
819 language it is from things we found in the symbols. */
820 symtab
->language
= subfile
->language
;
822 /* All symtabs for the main file and the subfiles share a
823 blockvector, so we need to clear primary for everything but
828 if (subfile
->name
!= NULL
)
830 free ((PTR
) subfile
->name
);
832 if (subfile
->dirname
!= NULL
)
834 free ((PTR
) subfile
->dirname
);
836 if (subfile
->line_vector
!= NULL
)
838 free ((PTR
) subfile
->line_vector
);
841 nextsub
= subfile
->next
;
845 /* Set this for the main source file. */
851 last_source_file
= NULL
;
852 current_subfile
= NULL
;
858 /* Push a context block. Args are an identifying nesting level (checkable
859 when you pop it), and the starting PC address of this context. */
861 struct context_stack
*
862 push_context (desc
, valu
)
866 register struct context_stack
*new;
868 if (context_stack_depth
== context_stack_size
)
870 context_stack_size
*= 2;
871 context_stack
= (struct context_stack
*)
872 xrealloc ((char *) context_stack
,
873 (context_stack_size
* sizeof (struct context_stack
)));
876 new = &context_stack
[context_stack_depth
++];
878 new->locals
= local_symbols
;
879 new->old_blocks
= pending_blocks
;
880 new->start_addr
= valu
;
883 local_symbols
= NULL
;
889 /* Compute a small integer hash code for the given name. */
895 register char *p
= name
;
896 register int total
= p
[0];
911 /* Ensure result is positive. */
914 total
+= (1000 << 6);
916 return (total
% HASHSIZE
);
920 /* Initialize anything that needs initializing when starting to read
921 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
927 free_pendings
= NULL
;
929 global_symbols
= NULL
;
930 pending_blocks
= NULL
;
933 /* Initialize anything that needs initializing when a completely new
934 symbol file is specified (not just adding some symbols from another
935 file, e.g. a shared library). */
943 /* Initializer for this module */
946 _initialize_buildsym ()