3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010, 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "search_list.h"
31 #include "safe-ctype.h"
34 static int core_num_syms
;
35 static asymbol
**core_syms
;
36 asection
*core_text_sect
;
37 void * core_text_space
;
39 static int min_insn_size
;
42 /* For mapping symbols to specific .o files during file ordering. */
43 struct function_map
* symbol_map
;
44 unsigned int symbol_map_count
;
46 static void read_function_mappings (const char *);
47 static int core_sym_class (asymbol
*);
48 static bfd_boolean get_src_info
49 (bfd_vma
, const char **, const char **, int *);
51 extern void i386_find_call (Sym
*, bfd_vma
, bfd_vma
);
52 extern void alpha_find_call (Sym
*, bfd_vma
, bfd_vma
);
53 extern void vax_find_call (Sym
*, bfd_vma
, bfd_vma
);
54 extern void tahoe_find_call (Sym
*, bfd_vma
, bfd_vma
);
55 extern void sparc_find_call (Sym
*, bfd_vma
, bfd_vma
);
56 extern void mips_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
);
169 core_init (const char * aout_name
)
175 core_bfd
= bfd_openr (aout_name
, 0);
183 if (!bfd_check_format (core_bfd
, bfd_object
))
185 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
189 /* Get core's text section. */
190 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
193 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
196 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
202 /* Read core's symbol table. */
204 /* This will probably give us more than we need, but that's ok. */
205 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
206 if (core_sym_bytes
< 0)
208 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
209 bfd_errmsg (bfd_get_error ()));
213 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
214 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
216 if (core_num_syms
< 0)
218 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
219 bfd_errmsg (bfd_get_error ()));
223 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
224 0, NULL
, &synthsyms
);
231 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
232 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
233 symp
= core_syms
+ core_num_syms
;
234 core_num_syms
+= synth_count
;
235 for (i
= 0; i
< synth_count
; i
++)
236 *symp
++ = synthsyms
+ i
;
243 switch (bfd_get_arch (core_bfd
))
258 if (function_mapping_file
)
259 read_function_mappings (function_mapping_file
);
262 /* Read in the text space of an a.out file. */
265 core_get_text_space (bfd
*cbfd
)
267 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
269 if (!core_text_space
)
271 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
272 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
276 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
277 0, bfd_get_section_size (core_text_sect
)))
279 bfd_perror ("bfd_get_section_contents");
280 free (core_text_space
);
284 if (!core_text_space
)
285 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
290 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
292 if (core_text_space
== 0)
295 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
297 switch (bfd_get_arch (core_bfd
))
300 i386_find_call (parent
, p_lowpc
, p_highpc
);
304 alpha_find_call (parent
, p_lowpc
, p_highpc
);
308 vax_find_call (parent
, p_lowpc
, p_highpc
);
312 sparc_find_call (parent
, p_lowpc
, p_highpc
);
316 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
320 mips_find_call (parent
, p_lowpc
, p_highpc
);
324 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
325 whoami
, bfd_printable_name(core_bfd
));
327 /* Don't give the error more than once. */
328 ignore_direct_calls
= FALSE
;
332 /* Return class of symbol SYM. The returned class can be any of:
333 0 -> symbol is not interesting to us
334 'T' -> symbol is a global name
335 't' -> symbol is a local (static) name. */
338 core_sym_class (asymbol
*sym
)
345 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
348 /* Must be a text symbol, and static text symbols
349 don't qualify if ignore_static_funcs set. */
350 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
352 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
357 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
361 return i
; /* It's a global symbol. */
364 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
365 also be a data symbol. */
370 /* Not a static text symbol. */
371 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
376 /* Do some more filtering on static function-names. */
377 if (ignore_static_funcs
)
380 /* Can't zero-length name or funny characters in name, where
381 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
382 if (!sym
->name
|| sym
->name
[0] == '\0')
385 for (name
= sym
->name
; *name
; ++name
)
392 /* Allow both nested subprograms (which end with ".NNN", where N is
393 a digit) and GCC cloned functions (which contain ".clone").
394 Allow for multiple iterations of both - apparently GCC can clone
395 clones and subprograms. */
397 #define CLONE_NAME ".clone."
398 #define CLONE_NAME_LEN strlen (CLONE_NAME)
399 #define CONSTPROP_NAME ".constprop."
400 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
402 if (strlen (name
) > CLONE_NAME_LEN
403 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
404 name
+= CLONE_NAME_LEN
- 1;
406 else if (strlen (name
) > CONSTPROP_NAME_LEN
407 && strncmp (name
, CONSTPROP_NAME
, CONSTPROP_NAME_LEN
) == 0)
408 name
+= CONSTPROP_NAME_LEN
- 1;
410 for (name
++; *name
; name
++)
411 if (digit_seen
&& *name
== '.')
413 else if (ISDIGIT (*name
))
420 /* On systems where the C compiler adds an underscore to all
421 names, static names without underscores seem usually to be
422 labels in hand written assembler in the library. We don't want
423 these names. This is certainly necessary on a Sparc running
424 SunOS 4.1 (try profiling a program that does a lot of
425 division). I don't know whether it has harmful side effects on
426 other systems. Perhaps it should be made configurable. */
427 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
429 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
430 /* GCC may add special symbols to help gdb figure out the file
431 language. We want to ignore these, since sometimes they mask
432 the real function. (dj@ctron) */
433 || !strncmp (sym
->name
, "__gnu_compiled", 14)
434 || !strncmp (sym
->name
, "___gnu_compiled", 15))
439 /* If the object file supports marking of function symbols, then
440 we can zap anything that doesn't have BSF_FUNCTION set. */
441 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
444 return 't'; /* It's a static text symbol. */
447 /* Get whatever source info we can get regarding address ADDR. */
450 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
452 const char *fname
= 0, *func_name
= 0;
455 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
456 addr
- core_text_sect
->vma
,
457 &fname
, &func_name
, (unsigned int *) &l
)
458 && fname
&& func_name
&& l
)
460 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
461 (unsigned long) addr
, fname
, l
, func_name
));
469 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
470 (unsigned long) addr
,
471 fname
? fname
: "<unknown>", l
,
472 func_name
? func_name
: "<unknown>"));
477 /* Return number of symbols in a symbol-table file. */
480 num_of_syms_in (FILE * f
)
482 const int BUFSIZE
= 1024;
483 char * buf
= (char *) xmalloc (BUFSIZE
);
484 char * address
= (char *) xmalloc (BUFSIZE
);
486 char * name
= (char *) xmalloc (BUFSIZE
);
489 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
491 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
492 if (type
== 't' || type
== 'T')
503 /* Read symbol table from a file. */
506 core_create_syms_from (const char * sym_table_file
)
508 const int BUFSIZE
= 1024;
509 char * buf
= (char *) xmalloc (BUFSIZE
);
510 char * address
= (char *) xmalloc (BUFSIZE
);
512 char * name
= (char *) xmalloc (BUFSIZE
);
513 bfd_vma min_vma
= ~(bfd_vma
) 0;
517 f
= fopen (sym_table_file
, "r");
520 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
524 /* Pass 1 - determine upper bound on number of function names. */
525 symtab
.len
= num_of_syms_in (f
);
529 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
533 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
535 /* Pass 2 - create symbols. */
536 symtab
.limit
= symtab
.base
;
538 if (fseek (f
, 0, SEEK_SET
) != 0)
540 perror (sym_table_file
);
544 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
546 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
547 if (type
!= 't' && type
!= 'T')
550 sym_init (symtab
.limit
);
552 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
554 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
555 strcpy ((char *) symtab
.limit
->name
, name
);
556 symtab
.limit
->mapped
= 0;
557 symtab
.limit
->is_func
= TRUE
;
558 symtab
.limit
->is_bb_head
= TRUE
;
559 symtab
.limit
->is_static
= (type
== 't');
560 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
561 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
567 symtab
.len
= symtab
.limit
- symtab
.base
;
568 symtab_finalize (&symtab
);
576 search_mapped_symbol (const void * l
, const void * r
)
578 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
581 /* Read in symbol table from core.
582 One symbol per function is entered. */
585 core_create_function_syms (void)
587 bfd_vma min_vma
= ~ (bfd_vma
) 0;
591 struct function_map
* found
= NULL
;
592 int core_has_func_syms
= 0;
594 switch (core_bfd
->xvec
->flavour
)
598 case bfd_target_coff_flavour
:
599 case bfd_target_ecoff_flavour
:
600 case bfd_target_xcoff_flavour
:
601 case bfd_target_elf_flavour
:
602 case bfd_target_nlm_flavour
:
603 case bfd_target_som_flavour
:
604 core_has_func_syms
= 1;
607 /* Pass 1 - determine upper bound on number of function names. */
610 for (i
= 0; i
< core_num_syms
; ++i
)
612 if (!core_sym_class (core_syms
[i
]))
615 /* Don't create a symtab entry for a function that has
616 a mapping to a file, unless it's the first function
618 if (symbol_map_count
!= 0)
620 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
622 found
= (struct function_map
*) bsearch
623 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
624 sizeof (struct function_map
), search_mapped_symbol
);
626 if (found
== NULL
|| found
->is_first
)
632 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
636 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
638 /* Pass 2 - create symbols. */
639 symtab
.limit
= symtab
.base
;
641 for (i
= 0; i
< core_num_syms
; ++i
)
645 cxxclass
= core_sym_class (core_syms
[i
]);
650 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
651 (unsigned long) core_syms
[i
]->value
,
652 core_syms
[i
]->name
));
656 if (symbol_map_count
!= 0)
658 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
660 found
= (struct function_map
*) bsearch
661 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
662 sizeof (struct function_map
), search_mapped_symbol
);
664 if (found
&& ! found
->is_first
)
667 sym_init (symtab
.limit
);
669 /* Symbol offsets are always section-relative. */
670 sym_sec
= core_syms
[i
]->section
;
671 symtab
.limit
->addr
= core_syms
[i
]->value
;
673 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
677 symtab
.limit
->name
= found
->file_name
;
678 symtab
.limit
->mapped
= 1;
682 symtab
.limit
->name
= core_syms
[i
]->name
;
683 symtab
.limit
->mapped
= 0;
686 /* Lookup filename and line number, if we can. */
688 const char * filename
;
689 const char * func_name
;
691 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
692 & symtab
.limit
->line_num
))
694 symtab
.limit
->file
= source_file_lookup_path (filename
);
696 /* FIXME: Checking __osf__ here does not work with a cross
699 /* Suppress symbols that are not function names. This is
700 useful to suppress code-labels and aliases.
702 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
703 labels do not appear in the symbol table info, so this isn't
706 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
708 /* The symbol's address maps to a different name, so
709 it can't be a function-entry point. This happens
710 for labels, for example. */
712 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
713 symtab
.limit
->name
, func_name
));
720 symtab
.limit
->is_func
= (!core_has_func_syms
721 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
722 symtab
.limit
->is_bb_head
= TRUE
;
725 symtab
.limit
->is_static
= TRUE
;
727 /* Keep track of the minimum and maximum vma addresses used by all
728 symbols. When computing the max_vma, use the ending address of the
729 section containing the symbol, if available. */
730 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
732 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
733 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
736 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
738 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
739 (long) (symtab
.limit
- symtab
.base
),
741 (unsigned long) symtab
.limit
->addr
));
745 symtab
.len
= symtab
.limit
- symtab
.base
;
746 symtab_finalize (&symtab
);
749 /* Read in symbol table from core.
750 One symbol per line of source code is entered. */
753 core_create_line_syms (void)
755 char *prev_name
, *prev_filename
;
756 unsigned int prev_name_len
, prev_filename_len
;
757 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
758 Sym
*prev
, dummy
, *sym
;
759 const char *filename
;
764 /* Create symbols for functions as usual. This is necessary in
765 cases where parts of a program were not compiled with -g. For
766 those parts we still want to get info at the function level. */
767 core_create_function_syms ();
769 /* Pass 1: count the number of symbols. */
771 /* To find all line information, walk through all possible
772 text-space addresses (one by one!) and get the debugging
773 info for each address. When the debugging info changes,
774 it is time to create a new symbol.
776 Of course, this is rather slow and it would be better if
777 BFD would provide an iterator for enumerating all line infos. */
778 prev_name_len
= PATH_MAX
;
779 prev_filename_len
= PATH_MAX
;
780 prev_name
= (char *) xmalloc (prev_name_len
);
781 prev_filename
= (char *) xmalloc (prev_filename_len
);
785 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
786 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
790 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
791 || (prev_line_num
== dummy
.line_num
793 && strcmp (prev_name
, dummy
.name
) == 0
794 && filename_cmp (prev_filename
, filename
) == 0))
798 prev_line_num
= dummy
.line_num
;
800 len
= strlen (dummy
.name
);
801 if (len
>= prev_name_len
)
803 prev_name_len
= len
+ 1024;
805 prev_name
= (char *) xmalloc (prev_name_len
);
808 strcpy (prev_name
, dummy
.name
);
809 len
= strlen (filename
);
811 if (len
>= prev_filename_len
)
813 prev_filename_len
= len
+ 1024;
814 free (prev_filename
);
815 prev_filename
= (char *) xmalloc (prev_filename_len
);
818 strcpy (prev_filename
, filename
);
820 min_vma
= MIN (vma
, min_vma
);
821 max_vma
= MAX (vma
, max_vma
);
825 free (prev_filename
);
827 /* Make room for function symbols, too. */
828 ltab
.len
+= symtab
.len
;
829 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
830 ltab
.limit
= ltab
.base
;
832 /* Pass 2 - create symbols. */
834 /* We now set is_static as we go along, rather than by running
835 through the symbol table at the end.
837 The old way called symtab_finalize before the is_static pass,
838 causing a problem since symtab_finalize uses is_static as part of
839 its address conflict resolution algorithm. Since global symbols
840 were prefered over static symbols, and all line symbols were
841 global at that point, static function names that conflicted with
842 their own line numbers (static, but labeled as global) were
843 rejected in favor of the line num.
845 This was not the desired functionality. We always want to keep
846 our function symbols and discard any conflicting line symbols.
847 Perhaps symtab_finalize should be modified to make this
848 distinction as well, but the current fix works and the code is a
852 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
854 sym_init (ltab
.limit
);
856 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
857 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
858 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
859 && filename_cmp (prev
->file
->name
, filename
) == 0))
862 /* Make name pointer a malloc'ed string. */
863 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
864 ltab
.limit
->file
= source_file_lookup_path (filename
);
866 ltab
.limit
->addr
= vma
;
868 /* Set is_static based on the enclosing function, using either:
869 1) the previous symbol, if it's from the same function, or
870 2) a symtab lookup. */
871 if (prev
&& ltab
.limit
->file
== prev
->file
&&
872 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
874 ltab
.limit
->is_static
= prev
->is_static
;
878 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
880 ltab
.limit
->is_static
= sym
->is_static
;
885 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
886 (unsigned long) (ltab
.limit
- ltab
.base
),
888 (unsigned long) ltab
.limit
->addr
));
892 /* Copy in function symbols. */
893 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
894 ltab
.limit
+= symtab
.len
;
896 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
899 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
900 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
904 /* Finalize ltab and make it symbol table. */
905 symtab_finalize (<ab
);
This page took 0.047206 seconds and 4 git commands to generate.