3 Copyright 1999-2013 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "search_list.h"
30 #include "safe-ctype.h"
33 static int core_num_syms
;
34 static asymbol
**core_syms
;
35 asection
*core_text_sect
;
36 void * core_text_space
;
38 static int min_insn_size
;
41 /* For mapping symbols to specific .o files during file ordering. */
42 struct function_map
* symbol_map
;
43 unsigned int symbol_map_count
;
45 static void read_function_mappings (const char *);
46 static int core_sym_class (asymbol
*);
47 static bfd_boolean get_src_info
48 (bfd_vma
, const char **, const char **, int *);
50 extern void i386_find_call (Sym
*, bfd_vma
, bfd_vma
);
51 extern void alpha_find_call (Sym
*, bfd_vma
, bfd_vma
);
52 extern void vax_find_call (Sym
*, bfd_vma
, bfd_vma
);
53 extern void tahoe_find_call (Sym
*, bfd_vma
, bfd_vma
);
54 extern void sparc_find_call (Sym
*, bfd_vma
, bfd_vma
);
55 extern void mips_find_call (Sym
*, bfd_vma
, bfd_vma
);
56 extern void aarch64_find_call (Sym
*, bfd_vma
, bfd_vma
);
59 parse_error (const char *filename
)
61 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
65 /* Compare two function_map structs based on function name.
66 We want to sort in ascending order. */
69 cmp_symbol_map (const void * l
, const void * r
)
71 return strcmp (((struct function_map
*) l
)->function_name
,
72 ((struct function_map
*) r
)->function_name
);
76 read_function_mappings (const char *filename
)
78 FILE * file
= fopen (filename
, "r");
85 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
89 /* First parse the mapping file so we know how big we need to
90 make our tables. We also do some sanity checks at this
96 matches
= fscanf (file
, "%[^\n:]", dummy
);
98 parse_error (filename
);
100 /* Just skip messages about files with no symbols. */
101 if (!strncmp (dummy
, "No symbols in ", 14))
103 matches
= fscanf (file
, "\n");
105 parse_error (filename
);
109 /* Don't care what else is on this line at this point. */
110 matches
= fscanf (file
, "%[^\n]\n", dummy
);
112 parse_error (filename
);
116 /* Now we know how big we need to make our table. */
117 symbol_map
= ((struct function_map
*)
118 xmalloc (count
* sizeof (struct function_map
)));
120 /* Rewind the input file so we can read it again. */
123 /* Read each entry and put it into the table. */
130 matches
= fscanf (file
, "%[^\n:]", dummy
);
132 parse_error (filename
);
134 /* Just skip messages about files with no symbols. */
135 if (!strncmp (dummy
, "No symbols in ", 14))
137 matches
= fscanf (file
, "\n");
139 parse_error (filename
);
143 /* dummy has the filename, go ahead and copy it. */
144 symbol_map
[count
].file_name
= (char *) xmalloc (strlen (dummy
) + 1);
145 strcpy (symbol_map
[count
].file_name
, dummy
);
147 /* Now we need the function name. */
148 matches
= fscanf (file
, "%[^\n]\n", dummy
);
150 parse_error (filename
);
151 tmp
= strrchr (dummy
, ' ') + 1;
152 symbol_map
[count
].function_name
= (char *) xmalloc (strlen (tmp
) + 1);
153 strcpy (symbol_map
[count
].function_name
, tmp
);
157 /* Record the size of the map table for future reference. */
158 symbol_map_count
= count
;
160 for (i
= 0; i
< symbol_map_count
; ++i
)
162 || filename_cmp (symbol_map
[i
].file_name
, symbol_map
[i
- 1].file_name
))
163 symbol_map
[i
].is_first
= 1;
165 qsort (symbol_map
, symbol_map_count
, sizeof (struct function_map
), cmp_symbol_map
);
171 core_init (const char * aout_name
)
177 core_bfd
= bfd_openr (aout_name
, 0);
185 if (!bfd_check_format (core_bfd
, bfd_object
))
187 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
191 /* Get core's text section. */
192 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
195 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
198 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
204 /* Read core's symbol table. */
206 /* This will probably give us more than we need, but that's ok. */
207 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
208 if (core_sym_bytes
< 0)
210 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
211 bfd_errmsg (bfd_get_error ()));
215 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
216 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
218 if (core_num_syms
< 0)
220 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
221 bfd_errmsg (bfd_get_error ()));
225 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
226 0, NULL
, &synthsyms
);
233 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
234 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
235 symp
= core_syms
+ core_num_syms
;
236 core_num_syms
+= synth_count
;
237 for (i
= 0; i
< synth_count
; i
++)
238 *symp
++ = synthsyms
+ i
;
245 switch (bfd_get_arch (core_bfd
))
260 if (function_mapping_file
)
261 read_function_mappings (function_mapping_file
);
264 /* Read in the text space of an a.out file. */
267 core_get_text_space (bfd
*cbfd
)
269 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
271 if (!core_text_space
)
273 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
274 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
278 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
279 0, bfd_get_section_size (core_text_sect
)))
281 bfd_perror ("bfd_get_section_contents");
282 free (core_text_space
);
286 if (!core_text_space
)
287 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
292 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
294 if (core_text_space
== 0)
297 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
299 switch (bfd_get_arch (core_bfd
))
302 i386_find_call (parent
, p_lowpc
, p_highpc
);
306 alpha_find_call (parent
, p_lowpc
, p_highpc
);
310 vax_find_call (parent
, p_lowpc
, p_highpc
);
314 sparc_find_call (parent
, p_lowpc
, p_highpc
);
318 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
322 mips_find_call (parent
, p_lowpc
, p_highpc
);
325 case bfd_arch_aarch64
:
326 aarch64_find_call (parent
, p_lowpc
, p_highpc
);
330 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
331 whoami
, bfd_printable_name(core_bfd
));
333 /* Don't give the error more than once. */
334 ignore_direct_calls
= FALSE
;
338 /* Return class of symbol SYM. The returned class can be any of:
339 0 -> symbol is not interesting to us
340 'T' -> symbol is a global name
341 't' -> symbol is a local (static) name. */
344 core_sym_class (asymbol
*sym
)
351 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
354 /* Must be a text symbol, and static text symbols
355 don't qualify if ignore_static_funcs set. */
356 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
358 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
363 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
367 return i
; /* It's a global symbol. */
370 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
371 also be a data symbol. */
376 /* Not a static text symbol. */
377 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
382 /* Do some more filtering on static function-names. */
383 if (ignore_static_funcs
)
386 /* Can't zero-length name or funny characters in name, where
387 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
388 if (!sym
->name
|| sym
->name
[0] == '\0')
391 for (name
= sym
->name
; *name
; ++name
)
398 /* Allow both nested subprograms (which end with ".NNN", where N is
399 a digit) and GCC cloned functions (which contain ".clone").
400 Allow for multiple iterations of both - apparently GCC can clone
401 clones and subprograms. */
403 #define CLONE_NAME ".clone."
404 #define CLONE_NAME_LEN strlen (CLONE_NAME)
405 #define CONSTPROP_NAME ".constprop."
406 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
408 if (strlen (name
) > CLONE_NAME_LEN
409 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
410 name
+= CLONE_NAME_LEN
- 1;
412 else if (strlen (name
) > CONSTPROP_NAME_LEN
413 && strncmp (name
, CONSTPROP_NAME
, CONSTPROP_NAME_LEN
) == 0)
414 name
+= CONSTPROP_NAME_LEN
- 1;
416 for (name
++; *name
; name
++)
417 if (digit_seen
&& *name
== '.')
419 else if (ISDIGIT (*name
))
426 /* On systems where the C compiler adds an underscore to all
427 names, static names without underscores seem usually to be
428 labels in hand written assembler in the library. We don't want
429 these names. This is certainly necessary on a Sparc running
430 SunOS 4.1 (try profiling a program that does a lot of
431 division). I don't know whether it has harmful side effects on
432 other systems. Perhaps it should be made configurable. */
433 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
435 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
436 /* GCC may add special symbols to help gdb figure out the file
437 language. We want to ignore these, since sometimes they mask
438 the real function. (dj@ctron) */
439 || !strncmp (sym
->name
, "__gnu_compiled", 14)
440 || !strncmp (sym
->name
, "___gnu_compiled", 15))
445 /* If the object file supports marking of function symbols, then
446 we can zap anything that doesn't have BSF_FUNCTION set. */
447 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
450 return 't'; /* It's a static text symbol. */
453 /* Get whatever source info we can get regarding address ADDR. */
456 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
458 const char *fname
= 0, *func_name
= 0;
461 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
462 addr
- core_text_sect
->vma
,
463 &fname
, &func_name
, (unsigned int *) &l
)
464 && fname
&& func_name
&& l
)
466 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
467 (unsigned long) addr
, fname
, l
, func_name
));
475 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
476 (unsigned long) addr
,
477 fname
? fname
: "<unknown>", l
,
478 func_name
? func_name
: "<unknown>"));
483 /* Return number of symbols in a symbol-table file. */
486 num_of_syms_in (FILE * f
)
488 const int BUFSIZE
= 1024;
489 char * buf
= (char *) xmalloc (BUFSIZE
);
490 char * address
= (char *) xmalloc (BUFSIZE
);
492 char * name
= (char *) xmalloc (BUFSIZE
);
495 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
497 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
498 if (type
== 't' || type
== 'T')
509 /* Read symbol table from a file. */
512 core_create_syms_from (const char * sym_table_file
)
514 const int BUFSIZE
= 1024;
515 char * buf
= (char *) xmalloc (BUFSIZE
);
516 char * address
= (char *) xmalloc (BUFSIZE
);
518 char * name
= (char *) xmalloc (BUFSIZE
);
519 bfd_vma min_vma
= ~(bfd_vma
) 0;
523 f
= fopen (sym_table_file
, "r");
526 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
530 /* Pass 1 - determine upper bound on number of function names. */
531 symtab
.len
= num_of_syms_in (f
);
535 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
539 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
541 /* Pass 2 - create symbols. */
542 symtab
.limit
= symtab
.base
;
544 if (fseek (f
, 0, SEEK_SET
) != 0)
546 perror (sym_table_file
);
550 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
552 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
553 if (type
!= 't' && type
!= 'T')
556 sym_init (symtab
.limit
);
558 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
560 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
561 strcpy ((char *) symtab
.limit
->name
, name
);
562 symtab
.limit
->mapped
= 0;
563 symtab
.limit
->is_func
= TRUE
;
564 symtab
.limit
->is_bb_head
= TRUE
;
565 symtab
.limit
->is_static
= (type
== 't');
566 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
567 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
573 symtab
.len
= symtab
.limit
- symtab
.base
;
574 symtab_finalize (&symtab
);
582 search_mapped_symbol (const void * l
, const void * r
)
584 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
587 /* Read in symbol table from core.
588 One symbol per function is entered. */
591 core_create_function_syms (void)
593 bfd_vma min_vma
= ~ (bfd_vma
) 0;
597 struct function_map
* found
= NULL
;
598 int core_has_func_syms
= 0;
600 switch (core_bfd
->xvec
->flavour
)
604 case bfd_target_coff_flavour
:
605 case bfd_target_ecoff_flavour
:
606 case bfd_target_xcoff_flavour
:
607 case bfd_target_elf_flavour
:
608 case bfd_target_nlm_flavour
:
609 case bfd_target_som_flavour
:
610 core_has_func_syms
= 1;
613 /* Pass 1 - determine upper bound on number of function names. */
616 for (i
= 0; i
< core_num_syms
; ++i
)
618 if (!core_sym_class (core_syms
[i
]))
621 /* Don't create a symtab entry for a function that has
622 a mapping to a file, unless it's the first function
624 if (symbol_map_count
!= 0)
626 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
628 found
= (struct function_map
*) bsearch
629 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
630 sizeof (struct function_map
), search_mapped_symbol
);
632 if (found
== NULL
|| found
->is_first
)
638 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
642 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
644 /* Pass 2 - create symbols. */
645 symtab
.limit
= symtab
.base
;
647 for (i
= 0; i
< core_num_syms
; ++i
)
651 cxxclass
= core_sym_class (core_syms
[i
]);
656 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
657 (unsigned long) core_syms
[i
]->value
,
658 core_syms
[i
]->name
));
662 if (symbol_map_count
!= 0)
664 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
666 found
= (struct function_map
*) bsearch
667 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
668 sizeof (struct function_map
), search_mapped_symbol
);
670 if (found
&& ! found
->is_first
)
673 sym_init (symtab
.limit
);
675 /* Symbol offsets are always section-relative. */
676 sym_sec
= core_syms
[i
]->section
;
677 symtab
.limit
->addr
= core_syms
[i
]->value
;
679 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
683 symtab
.limit
->name
= found
->file_name
;
684 symtab
.limit
->mapped
= 1;
688 symtab
.limit
->name
= core_syms
[i
]->name
;
689 symtab
.limit
->mapped
= 0;
692 /* Lookup filename and line number, if we can. */
694 const char * filename
;
695 const char * func_name
;
697 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
698 & symtab
.limit
->line_num
))
700 symtab
.limit
->file
= source_file_lookup_path (filename
);
702 /* FIXME: Checking __osf__ here does not work with a cross
705 /* Suppress symbols that are not function names. This is
706 useful to suppress code-labels and aliases.
708 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
709 labels do not appear in the symbol table info, so this isn't
712 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
714 /* The symbol's address maps to a different name, so
715 it can't be a function-entry point. This happens
716 for labels, for example. */
718 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
719 symtab
.limit
->name
, func_name
));
726 symtab
.limit
->is_func
= (!core_has_func_syms
727 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
728 symtab
.limit
->is_bb_head
= TRUE
;
731 symtab
.limit
->is_static
= TRUE
;
733 /* Keep track of the minimum and maximum vma addresses used by all
734 symbols. When computing the max_vma, use the ending address of the
735 section containing the symbol, if available. */
736 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
738 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
739 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
742 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
744 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
745 (long) (symtab
.limit
- symtab
.base
),
747 (unsigned long) symtab
.limit
->addr
));
751 symtab
.len
= symtab
.limit
- symtab
.base
;
752 symtab_finalize (&symtab
);
755 /* Read in symbol table from core.
756 One symbol per line of source code is entered. */
759 core_create_line_syms (void)
761 char *prev_name
, *prev_filename
;
762 unsigned int prev_name_len
, prev_filename_len
;
763 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
764 Sym
*prev
, dummy
, *sym
;
765 const char *filename
;
770 /* Create symbols for functions as usual. This is necessary in
771 cases where parts of a program were not compiled with -g. For
772 those parts we still want to get info at the function level. */
773 core_create_function_syms ();
775 /* Pass 1: count the number of symbols. */
777 /* To find all line information, walk through all possible
778 text-space addresses (one by one!) and get the debugging
779 info for each address. When the debugging info changes,
780 it is time to create a new symbol.
782 Of course, this is rather slow and it would be better if
783 BFD would provide an iterator for enumerating all line infos. */
784 prev_name_len
= PATH_MAX
;
785 prev_filename_len
= PATH_MAX
;
786 prev_name
= (char *) xmalloc (prev_name_len
);
787 prev_filename
= (char *) xmalloc (prev_filename_len
);
791 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
792 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
796 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
797 || (prev_line_num
== dummy
.line_num
799 && strcmp (prev_name
, dummy
.name
) == 0
800 && filename_cmp (prev_filename
, filename
) == 0))
804 prev_line_num
= dummy
.line_num
;
806 len
= strlen (dummy
.name
);
807 if (len
>= prev_name_len
)
809 prev_name_len
= len
+ 1024;
811 prev_name
= (char *) xmalloc (prev_name_len
);
814 strcpy (prev_name
, dummy
.name
);
815 len
= strlen (filename
);
817 if (len
>= prev_filename_len
)
819 prev_filename_len
= len
+ 1024;
820 free (prev_filename
);
821 prev_filename
= (char *) xmalloc (prev_filename_len
);
824 strcpy (prev_filename
, filename
);
826 min_vma
= MIN (vma
, min_vma
);
827 max_vma
= MAX (vma
, max_vma
);
831 free (prev_filename
);
833 /* Make room for function symbols, too. */
834 ltab
.len
+= symtab
.len
;
835 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
836 ltab
.limit
= ltab
.base
;
838 /* Pass 2 - create symbols. */
840 /* We now set is_static as we go along, rather than by running
841 through the symbol table at the end.
843 The old way called symtab_finalize before the is_static pass,
844 causing a problem since symtab_finalize uses is_static as part of
845 its address conflict resolution algorithm. Since global symbols
846 were prefered over static symbols, and all line symbols were
847 global at that point, static function names that conflicted with
848 their own line numbers (static, but labeled as global) were
849 rejected in favor of the line num.
851 This was not the desired functionality. We always want to keep
852 our function symbols and discard any conflicting line symbols.
853 Perhaps symtab_finalize should be modified to make this
854 distinction as well, but the current fix works and the code is a
858 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
860 sym_init (ltab
.limit
);
862 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
863 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
864 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
865 && filename_cmp (prev
->file
->name
, filename
) == 0))
868 /* Make name pointer a malloc'ed string. */
869 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
870 ltab
.limit
->file
= source_file_lookup_path (filename
);
872 ltab
.limit
->addr
= vma
;
874 /* Set is_static based on the enclosing function, using either:
875 1) the previous symbol, if it's from the same function, or
876 2) a symtab lookup. */
877 if (prev
&& ltab
.limit
->file
== prev
->file
&&
878 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
880 ltab
.limit
->is_static
= prev
->is_static
;
884 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
886 ltab
.limit
->is_static
= sym
->is_static
;
891 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
892 (unsigned long) (ltab
.limit
- ltab
.base
),
894 (unsigned long) ltab
.limit
->addr
));
898 /* Copy in function symbols. */
899 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
900 ltab
.limit
+= symtab
.len
;
902 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
905 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
906 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
910 /* Finalize ltab and make it symbol table. */
911 symtab_finalize (<ab
);
This page took 0.051397 seconds and 4 git commands to generate.