3 Copyright (C) 1999-2018 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"
31 #include <limits.h> /* For UINT_MAX. */
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 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
);
75 #define BUFSIZE (1024)
76 /* This is BUFSIZE - 1 as a string. Suitable for use in fprintf/sscanf format strings. */
77 #define STR_BUFSIZE "1023"
80 read_function_mappings (const char *filename
)
82 FILE * file
= fopen (filename
, "r");
89 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
93 /* First parse the mapping file so we know how big we need to
94 make our tables. We also do some sanity checks at this
100 matches
= fscanf (file
, "%" STR_BUFSIZE
"[^\n:]", dummy
);
102 parse_error (filename
);
104 /* Just skip messages about files with no symbols. */
105 if (!strncmp (dummy
, "No symbols in ", 14))
107 matches
= fscanf (file
, "\n");
109 parse_error (filename
);
113 /* Don't care what else is on this line at this point. */
114 matches
= fscanf (file
, "%" STR_BUFSIZE
"[^\n]\n", dummy
);
116 parse_error (filename
);
120 /* Now we know how big we need to make our table. */
121 symbol_map
= ((struct function_map
*)
122 xmalloc (count
* sizeof (struct function_map
)));
124 /* Rewind the input file so we can read it again. */
127 /* Read each entry and put it into the table. */
134 matches
= fscanf (file
, "%" STR_BUFSIZE
"[^\n:]", dummy
);
136 parse_error (filename
);
138 /* Just skip messages about files with no symbols. */
139 if (!strncmp (dummy
, "No symbols in ", 14))
141 matches
= fscanf (file
, "\n");
143 parse_error (filename
);
147 /* dummy has the filename, go ahead and copy it. */
148 symbol_map
[count
].file_name
= (char *) xmalloc (strlen (dummy
) + 1);
149 strcpy (symbol_map
[count
].file_name
, dummy
);
151 /* Now we need the function name. */
152 matches
= fscanf (file
, "%" STR_BUFSIZE
"[^\n]\n", dummy
);
154 parse_error (filename
);
155 tmp
= strrchr (dummy
, ' ') + 1;
156 symbol_map
[count
].function_name
= (char *) xmalloc (strlen (tmp
) + 1);
157 strcpy (symbol_map
[count
].function_name
, tmp
);
161 /* Record the size of the map table for future reference. */
162 symbol_map_count
= count
;
164 for (i
= 0; i
< symbol_map_count
; ++i
)
166 || filename_cmp (symbol_map
[i
].file_name
, symbol_map
[i
- 1].file_name
))
167 symbol_map
[i
].is_first
= 1;
169 qsort (symbol_map
, symbol_map_count
, sizeof (struct function_map
), cmp_symbol_map
);
175 core_init (const char * aout_name
)
181 core_bfd
= bfd_openr (aout_name
, 0);
189 if (!bfd_check_format (core_bfd
, bfd_object
))
191 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
195 /* Get core's text section. */
196 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
199 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
202 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
208 /* Read core's symbol table. */
210 /* This will probably give us more than we need, but that's ok. */
211 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
212 if (core_sym_bytes
< 0)
214 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
215 bfd_errmsg (bfd_get_error ()));
219 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
220 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
222 if (core_num_syms
< 0)
224 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
225 bfd_errmsg (bfd_get_error ()));
229 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
230 0, NULL
, &synthsyms
);
237 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
238 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
239 symp
= core_syms
+ core_num_syms
;
240 core_num_syms
+= synth_count
;
241 for (i
= 0; i
< synth_count
; i
++)
242 *symp
++ = synthsyms
+ i
;
249 switch (bfd_get_arch (core_bfd
))
263 if (function_mapping_file
)
264 read_function_mappings (function_mapping_file
);
267 /* Read in the text space of an a.out file. */
270 core_get_text_space (bfd
*cbfd
)
272 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
274 if (!core_text_space
)
276 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
277 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
281 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
282 0, bfd_get_section_size (core_text_sect
)))
284 bfd_perror ("bfd_get_section_contents");
285 free (core_text_space
);
289 if (!core_text_space
)
290 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
295 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
297 if (core_text_space
== 0)
300 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
302 switch (bfd_get_arch (core_bfd
))
305 i386_find_call (parent
, p_lowpc
, p_highpc
);
309 alpha_find_call (parent
, p_lowpc
, p_highpc
);
313 vax_find_call (parent
, p_lowpc
, p_highpc
);
317 sparc_find_call (parent
, p_lowpc
, p_highpc
);
321 mips_find_call (parent
, p_lowpc
, p_highpc
);
324 case bfd_arch_aarch64
:
325 aarch64_find_call (parent
, p_lowpc
, p_highpc
);
329 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
330 whoami
, bfd_printable_name(core_bfd
));
332 /* Don't give the error more than once. */
333 ignore_direct_calls
= FALSE
;
337 /* Return class of symbol SYM. The returned class can be any of:
338 0 -> symbol is not interesting to us
339 'T' -> symbol is a global name
340 't' -> symbol is a local (static) name. */
343 core_sym_class (asymbol
*sym
)
350 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
353 /* Must be a text symbol, and static text symbols
354 don't qualify if ignore_static_funcs set. */
355 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
357 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
362 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
366 return i
; /* It's a global symbol. */
369 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
370 also be a data symbol. */
375 /* Not a static text symbol. */
376 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
381 /* Do some more filtering on static function-names. */
382 if (ignore_static_funcs
)
385 /* Can't zero-length name or funny characters in name, where
386 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
387 if (!sym
->name
|| sym
->name
[0] == '\0')
390 for (name
= sym
->name
; *name
; ++name
)
397 /* Allow both nested subprograms (which end with ".NNN", where N is
398 a digit) and GCC cloned functions (which contain ".clone").
399 Allow for multiple iterations of both - apparently GCC can clone
400 clones and subprograms. */
402 #define CLONE_NAME ".clone."
403 #define CLONE_NAME_LEN strlen (CLONE_NAME)
404 #define CONSTPROP_NAME ".constprop."
405 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
407 if (strlen (name
) > CLONE_NAME_LEN
408 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
409 name
+= CLONE_NAME_LEN
- 1;
411 else if (strlen (name
) > CONSTPROP_NAME_LEN
412 && strncmp (name
, CONSTPROP_NAME
, CONSTPROP_NAME_LEN
) == 0)
413 name
+= CONSTPROP_NAME_LEN
- 1;
415 for (name
++; *name
; name
++)
416 if (digit_seen
&& *name
== '.')
418 else if (ISDIGIT (*name
))
425 /* On systems where the C compiler adds an underscore to all
426 names, static names without underscores seem usually to be
427 labels in hand written assembler in the library. We don't want
428 these names. This is certainly necessary on a Sparc running
429 SunOS 4.1 (try profiling a program that does a lot of
430 division). I don't know whether it has harmful side effects on
431 other systems. Perhaps it should be made configurable. */
432 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
434 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
435 /* GCC may add special symbols to help gdb figure out the file
436 language. We want to ignore these, since sometimes they mask
437 the real function. (dj@ctron) */
438 || !strncmp (sym
->name
, "__gnu_compiled", 14)
439 || !strncmp (sym
->name
, "___gnu_compiled", 15))
444 /* If the object file supports marking of function symbols, then
445 we can zap anything that doesn't have BSF_FUNCTION set. */
446 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
449 return 't'; /* It's a static text symbol. */
452 /* Get whatever source info we can get regarding address ADDR. */
455 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
457 const char *fname
= 0, *func_name
= 0;
460 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
461 addr
- core_text_sect
->vma
,
462 &fname
, &func_name
, (unsigned int *) &l
)
463 && fname
&& func_name
&& l
)
465 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
466 (unsigned long) addr
, fname
, l
, func_name
));
474 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
475 (unsigned long) addr
,
476 fname
? fname
: "<unknown>", l
,
477 func_name
? func_name
: "<unknown>"));
482 static char buf
[BUFSIZE
];
483 static char address
[BUFSIZE
];
484 static char name
[BUFSIZE
];
486 /* Return number of symbols in a symbol-table file. */
489 num_of_syms_in (FILE * f
)
492 unsigned int num
= 0;
494 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
496 if (sscanf (buf
, "%" STR_BUFSIZE
"s %c %" STR_BUFSIZE
"s", address
, &type
, name
) == 3)
497 if (type
== 't' || type
== 'T')
499 /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
500 if (++num
>= UINT_MAX
/ sizeof (Sym
))
508 /* Read symbol table from a file. */
511 core_create_syms_from (const char * sym_table_file
)
514 bfd_vma min_vma
= ~(bfd_vma
) 0;
518 f
= fopen (sym_table_file
, "r");
521 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
525 /* Pass 1 - determine upper bound on number of function names. */
526 symtab
.len
= num_of_syms_in (f
);
530 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
533 else if (symtab
.len
== -1U)
535 fprintf (stderr
, _("%s: file `%s' has too many symbols\n"),
536 whoami
, sym_table_file
);
540 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
542 /* Pass 2 - create symbols. */
543 symtab
.limit
= symtab
.base
;
545 if (fseek (f
, 0, SEEK_SET
) != 0)
547 perror (sym_table_file
);
551 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
553 if (sscanf (buf
, "%" STR_BUFSIZE
"s %c %" STR_BUFSIZE
"s", address
, &type
, name
) != 3)
555 if (type
!= 't' && type
!= 'T')
558 sym_init (symtab
.limit
);
560 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
562 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
563 strcpy ((char *) symtab
.limit
->name
, name
);
564 symtab
.limit
->mapped
= 0;
565 symtab
.limit
->is_func
= TRUE
;
566 symtab
.limit
->is_bb_head
= TRUE
;
567 symtab
.limit
->is_static
= (type
== 't');
568 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
569 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
575 symtab
.len
= symtab
.limit
- symtab
.base
;
576 symtab_finalize (&symtab
);
580 search_mapped_symbol (const void * l
, const void * r
)
582 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
585 /* Read in symbol table from core.
586 One symbol per function is entered. */
589 core_create_function_syms (void)
591 bfd_vma min_vma
= ~ (bfd_vma
) 0;
595 struct function_map
* found
= NULL
;
596 int core_has_func_syms
= 0;
598 switch (core_bfd
->xvec
->flavour
)
602 case bfd_target_coff_flavour
:
603 case bfd_target_ecoff_flavour
:
604 case bfd_target_xcoff_flavour
:
605 case bfd_target_elf_flavour
:
606 case bfd_target_som_flavour
:
607 core_has_func_syms
= 1;
610 /* Pass 1 - determine upper bound on number of function names. */
613 for (i
= 0; i
< core_num_syms
; ++i
)
615 if (!core_sym_class (core_syms
[i
]))
618 /* Don't create a symtab entry for a function that has
619 a mapping to a file, unless it's the first function
621 if (symbol_map_count
!= 0)
623 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
625 found
= (struct function_map
*) bsearch
626 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
627 sizeof (struct function_map
), search_mapped_symbol
);
629 if (found
== NULL
|| found
->is_first
)
635 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
639 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
641 /* Pass 2 - create symbols. */
642 symtab
.limit
= symtab
.base
;
644 for (i
= 0; i
< core_num_syms
; ++i
)
648 cxxclass
= core_sym_class (core_syms
[i
]);
653 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
654 (unsigned long) core_syms
[i
]->value
,
655 core_syms
[i
]->name
));
659 if (symbol_map_count
!= 0)
661 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
663 found
= (struct function_map
*) bsearch
664 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
665 sizeof (struct function_map
), search_mapped_symbol
);
667 if (found
&& ! found
->is_first
)
670 sym_init (symtab
.limit
);
672 /* Symbol offsets are always section-relative. */
673 sym_sec
= core_syms
[i
]->section
;
674 symtab
.limit
->addr
= core_syms
[i
]->value
;
676 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
680 symtab
.limit
->name
= found
->file_name
;
681 symtab
.limit
->mapped
= 1;
685 symtab
.limit
->name
= core_syms
[i
]->name
;
686 symtab
.limit
->mapped
= 0;
689 /* Lookup filename and line number, if we can. */
691 const char * filename
;
692 const char * func_name
;
694 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
695 & symtab
.limit
->line_num
))
697 symtab
.limit
->file
= source_file_lookup_path (filename
);
699 /* FIXME: Checking __osf__ here does not work with a cross
702 /* Suppress symbols that are not function names. This is
703 useful to suppress code-labels and aliases.
705 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
706 labels do not appear in the symbol table info, so this isn't
709 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
711 /* The symbol's address maps to a different name, so
712 it can't be a function-entry point. This happens
713 for labels, for example. */
715 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
716 symtab
.limit
->name
, func_name
));
723 symtab
.limit
->is_func
= (!core_has_func_syms
724 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
725 symtab
.limit
->is_bb_head
= TRUE
;
728 symtab
.limit
->is_static
= TRUE
;
730 /* Keep track of the minimum and maximum vma addresses used by all
731 symbols. When computing the max_vma, use the ending address of the
732 section containing the symbol, if available. */
733 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
735 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
736 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
739 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
741 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
742 (long) (symtab
.limit
- symtab
.base
),
744 (unsigned long) symtab
.limit
->addr
));
748 symtab
.len
= symtab
.limit
- symtab
.base
;
749 symtab_finalize (&symtab
);
752 /* Read in symbol table from core.
753 One symbol per line of source code is entered. */
756 core_create_line_syms (void)
758 char *prev_name
, *prev_filename
;
759 unsigned int prev_name_len
, prev_filename_len
;
760 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
761 Sym
*prev
, dummy
, *sym
;
762 const char *filename
;
767 /* Create symbols for functions as usual. This is necessary in
768 cases where parts of a program were not compiled with -g. For
769 those parts we still want to get info at the function level. */
770 core_create_function_syms ();
772 /* Pass 1: count the number of symbols. */
774 /* To find all line information, walk through all possible
775 text-space addresses (one by one!) and get the debugging
776 info for each address. When the debugging info changes,
777 it is time to create a new symbol.
779 Of course, this is rather slow and it would be better if
780 BFD would provide an iterator for enumerating all line infos. */
781 prev_name_len
= PATH_MAX
;
782 prev_filename_len
= PATH_MAX
;
783 prev_name
= (char *) xmalloc (prev_name_len
);
784 prev_filename
= (char *) xmalloc (prev_filename_len
);
788 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
789 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
793 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
794 || (prev_line_num
== dummy
.line_num
796 && strcmp (prev_name
, dummy
.name
) == 0
797 && filename_cmp (prev_filename
, filename
) == 0))
801 prev_line_num
= dummy
.line_num
;
803 len
= strlen (dummy
.name
);
804 if (len
>= prev_name_len
)
806 prev_name_len
= len
+ 1024;
808 prev_name
= (char *) xmalloc (prev_name_len
);
811 strcpy (prev_name
, dummy
.name
);
812 len
= strlen (filename
);
814 if (len
>= prev_filename_len
)
816 prev_filename_len
= len
+ 1024;
817 free (prev_filename
);
818 prev_filename
= (char *) xmalloc (prev_filename_len
);
821 strcpy (prev_filename
, filename
);
823 min_vma
= MIN (vma
, min_vma
);
824 max_vma
= MAX (vma
, max_vma
);
828 free (prev_filename
);
830 /* Make room for function symbols, too. */
831 ltab
.len
+= symtab
.len
;
832 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
833 ltab
.limit
= ltab
.base
;
835 /* Pass 2 - create symbols. */
837 /* We now set is_static as we go along, rather than by running
838 through the symbol table at the end.
840 The old way called symtab_finalize before the is_static pass,
841 causing a problem since symtab_finalize uses is_static as part of
842 its address conflict resolution algorithm. Since global symbols
843 were preferred over static symbols, and all line symbols were
844 global at that point, static function names that conflicted with
845 their own line numbers (static, but labeled as global) were
846 rejected in favor of the line num.
848 This was not the desired functionality. We always want to keep
849 our function symbols and discard any conflicting line symbols.
850 Perhaps symtab_finalize should be modified to make this
851 distinction as well, but the current fix works and the code is a
855 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
857 sym_init (ltab
.limit
);
859 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
860 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
861 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
862 && filename_cmp (prev
->file
->name
, filename
) == 0))
865 /* Make name pointer a malloc'ed string. */
866 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
867 ltab
.limit
->file
= source_file_lookup_path (filename
);
869 ltab
.limit
->addr
= vma
;
871 /* Set is_static based on the enclosing function, using either:
872 1) the previous symbol, if it's from the same function, or
873 2) a symtab lookup. */
874 if (prev
&& ltab
.limit
->file
== prev
->file
&&
875 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
877 ltab
.limit
->is_static
= prev
->is_static
;
881 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
883 ltab
.limit
->is_static
= sym
->is_static
;
888 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
889 (unsigned long) (ltab
.limit
- ltab
.base
),
891 (unsigned long) ltab
.limit
->addr
));
895 /* Copy in function symbols. */
896 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
897 ltab
.limit
+= symtab
.len
;
899 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
902 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
903 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
907 /* Finalize ltab and make it symbol table. */
908 symtab_finalize (<ab
);
This page took 0.049531 seconds and 4 git commands to generate.