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 /* Manage the vector of line numbers for each subfile. */
535 record_line (subfile
, line
, pc
)
536 register struct subfile
*subfile
;
540 struct linetable_entry
*e
;
541 /* Ignore the dummy line number in libg.o */
548 /* Make sure line vector exists and is big enough. */
549 if (!subfile
->line_vector
)
551 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
552 subfile
->line_vector
= (struct linetable
*)
553 xmalloc (sizeof (struct linetable
)
554 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
555 subfile
->line_vector
->nitems
= 0;
558 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
560 subfile
->line_vector_length
*= 2;
561 subfile
->line_vector
= (struct linetable
*)
562 xrealloc ((char *) subfile
->line_vector
, (sizeof (struct linetable
)
563 + subfile
->line_vector_length
* sizeof (struct linetable_entry
)));
566 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
567 e
->line
= line
; e
->pc
= pc
;
571 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
574 compare_line_numbers (ln1p
, ln2p
)
578 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
579 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
581 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
582 Please keep it that way. */
583 if (ln1
->pc
< ln2
->pc
)
586 if (ln1
->pc
> ln2
->pc
)
589 /* If pc equal, sort by line. I'm not sure whether this is optimum
590 behavior (see comment at struct linetable in symtab.h). */
591 return ln1
->line
- ln2
->line
;
595 /* Start a new symtab for a new source file.
596 Called, for example, when a stabs symbol of type N_SO is seen, or when
597 a DWARF TAG_compile_unit DIE is seen.
598 It indicates the start of data for one original source file. */
601 start_symtab (name
, dirname
, start_addr
)
604 CORE_ADDR start_addr
;
607 last_source_file
= name
;
608 last_source_start_addr
= start_addr
;
610 global_symbols
= NULL
;
613 /* Context stack is initially empty. Allocate first one with room for
614 10 levels; reuse it forever afterward. */
615 if (context_stack
== NULL
)
617 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
618 context_stack
= (struct context_stack
*)
619 xmalloc (context_stack_size
* sizeof (struct context_stack
));
621 context_stack_depth
= 0;
623 /* Initialize the list of sub source files with one entry
624 for this file (the top-level source file). */
627 current_subfile
= NULL
;
628 start_subfile (name
, dirname
);
631 /* Finish the symbol definitions for one main source file,
632 close off all the lexical contexts for that file
633 (creating struct block's for them), then make the struct symtab
634 for that file and put it in the list of all such.
636 END_ADDR is the address of the end of the file's text.
637 SECTION is the section number (in objfile->section_offsets) of
638 the blockvector and linetable.
640 Note that it is possible for end_symtab() to return NULL. In particular,
641 for the DWARF case at least, it will return NULL when it finds a
642 compilation unit that has exactly one DIE, a TAG_compile_unit DIE. This
643 can happen when we link in an object file that was compiled from an empty
644 source file. Returning NULL is probably not the correct thing to do,
645 because then gdb will never know about this empty file (FIXME). */
648 end_symtab (end_addr
, sort_pending
, sort_linevec
, objfile
, section
)
652 struct objfile
*objfile
;
655 register struct symtab
*symtab
;
656 register struct blockvector
*blockvector
;
657 register struct subfile
*subfile
;
658 register struct context_stack
*cstk
;
659 struct subfile
*nextsub
;
661 /* Finish the lexical context of the last function in the file;
662 pop the context stack. */
664 if (context_stack_depth
> 0)
666 context_stack_depth
--;
667 cstk
= &context_stack
[context_stack_depth
];
668 /* Make a block for the local symbols within. */
669 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
670 cstk
->start_addr
, end_addr
, objfile
);
672 /* Debug: if context stack still has something in it,
673 we are in trouble. */
674 if (context_stack_depth
> 0)
680 /* It is unfortunate that in xcoff, pending blocks might not be ordered
681 in this stage. Especially, blocks for static functions will show up at
682 the end. We need to sort them, so tools like `find_pc_function' and
683 `find_pc_block' can work reliably. */
685 if (sort_pending
&& pending_blocks
)
687 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
691 struct pending_block
*pb
, *pbnext
;
699 /* swap blocks if unordered! */
701 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
))
703 struct block
*tmp
= pb
->block
;
704 pb
->block
= pbnext
->block
;
709 pbnext
= pbnext
->next
;
714 /* Cleanup any undefined types that have been left hanging around
715 (this needs to be done before the finish_blocks so that
716 file_symbols is still good).
718 Both cleanup_undefined_types and finish_global_stabs are stabs
719 specific, but harmless for other symbol readers, since on gdb
720 startup or when finished reading stabs, the state is set so these
721 are no-ops. FIXME: Is this handled right in case of QUIT? Can
722 we make this cleaner? */
724 cleanup_undefined_types ();
725 finish_global_stabs (objfile
);
727 if (pending_blocks
== NULL
728 && file_symbols
== NULL
729 && global_symbols
== NULL
)
731 /* Ignore symtabs that have no functions with real debugging info */
736 /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */
737 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
,
739 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
,
741 blockvector
= make_blockvector (objfile
);
744 #ifdef PROCESS_LINENUMBER_HOOK
745 PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */
748 /* Now create the symtab objects proper, one for each subfile. */
749 /* (The main file is the last one on the chain.) */
751 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
754 /* If we have blocks of symbols, make a symtab.
755 Otherwise, just ignore this file and any line number info in it. */
759 if (subfile
->line_vector
)
761 linetablesize
= sizeof (struct linetable
) +
762 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
764 /* I think this is artifact from before it went on the obstack.
765 I doubt we'll need the memory between now and when we
766 free it later in this function. */
767 /* First, shrink the linetable to make more memory. */
768 subfile
->line_vector
= (struct linetable
*)
769 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
771 /* If sort_linevec is false, we might want just check to make
772 sure they are sorted and complain() if not, as a way of
773 tracking down compilers/symbol readers which don't get
774 them sorted right. */
777 qsort (subfile
->line_vector
->item
,
778 subfile
->line_vector
->nitems
,
779 sizeof (struct linetable_entry
), compare_line_numbers
);
782 /* Now, allocate a symbol table. */
783 symtab
= allocate_symtab (subfile
->name
, objfile
);
785 /* Fill in its components. */
786 symtab
->blockvector
= blockvector
;
787 if (subfile
->line_vector
)
789 /* Reallocate the line table on the symbol obstack */
790 symtab
->linetable
= (struct linetable
*)
791 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
792 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
796 symtab
->linetable
= NULL
;
798 symtab
->block_line_section
= section
;
799 if (subfile
->dirname
)
801 /* Reallocate the dirname on the symbol obstack */
802 symtab
->dirname
= (char *)
803 obstack_alloc (&objfile
-> symbol_obstack
,
804 strlen (subfile
-> dirname
) + 1);
805 strcpy (symtab
->dirname
, subfile
->dirname
);
809 symtab
->dirname
= NULL
;
811 symtab
->free_code
= free_linetable
;
812 symtab
->free_ptr
= NULL
;
814 /* Use whatever language we have been using for this subfile,
815 not the one that was deduced in allocate_symtab from the
816 filename. We already did our own deducing when we created
817 the subfile, and we may have altered our opinion of what
818 language it is from things we found in the symbols. */
819 symtab
->language
= subfile
->language
;
821 /* All symtabs for the main file and the subfiles share a
822 blockvector, so we need to clear primary for everything but
827 if (subfile
->name
!= NULL
)
829 free ((PTR
) subfile
->name
);
831 if (subfile
->dirname
!= NULL
)
833 free ((PTR
) subfile
->dirname
);
835 if (subfile
->line_vector
!= NULL
)
837 free ((PTR
) subfile
->line_vector
);
840 nextsub
= subfile
->next
;
844 /* Set this for the main source file. */
850 last_source_file
= NULL
;
851 current_subfile
= NULL
;
857 /* Push a context block. Args are an identifying nesting level (checkable
858 when you pop it), and the starting PC address of this context. */
860 struct context_stack
*
861 push_context (desc
, valu
)
865 register struct context_stack
*new;
867 if (context_stack_depth
== context_stack_size
)
869 context_stack_size
*= 2;
870 context_stack
= (struct context_stack
*)
871 xrealloc ((char *) context_stack
,
872 (context_stack_size
* sizeof (struct context_stack
)));
875 new = &context_stack
[context_stack_depth
++];
877 new->locals
= local_symbols
;
878 new->old_blocks
= pending_blocks
;
879 new->start_addr
= valu
;
882 local_symbols
= NULL
;
888 /* Compute a small integer hash code for the given name. */
894 register char *p
= name
;
895 register int total
= p
[0];
910 /* Ensure result is positive. */
913 total
+= (1000 << 6);
915 return (total
% HASHSIZE
);
919 /* Initialize anything that needs initializing when starting to read
920 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
926 free_pendings
= NULL
;
928 global_symbols
= NULL
;
929 pending_blocks
= NULL
;
932 /* Initialize anything that needs initializing when a completely new
933 symbol file is specified (not just adding some symbols from another
934 file, e.g. a shared library). */
942 /* Initializer for this module */
945 _initialize_buildsym ()