3 Copyright (C) 1999-2016 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
);
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
))
264 if (function_mapping_file
)
265 read_function_mappings (function_mapping_file
);
268 /* Read in the text space of an a.out file. */
271 core_get_text_space (bfd
*cbfd
)
273 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
275 if (!core_text_space
)
277 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
278 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
282 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
283 0, bfd_get_section_size (core_text_sect
)))
285 bfd_perror ("bfd_get_section_contents");
286 free (core_text_space
);
290 if (!core_text_space
)
291 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
296 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
298 if (core_text_space
== 0)
301 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
303 switch (bfd_get_arch (core_bfd
))
306 i386_find_call (parent
, p_lowpc
, p_highpc
);
310 alpha_find_call (parent
, p_lowpc
, p_highpc
);
314 vax_find_call (parent
, p_lowpc
, p_highpc
);
318 sparc_find_call (parent
, p_lowpc
, p_highpc
);
322 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
326 mips_find_call (parent
, p_lowpc
, p_highpc
);
329 case bfd_arch_aarch64
:
330 aarch64_find_call (parent
, p_lowpc
, p_highpc
);
334 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
335 whoami
, bfd_printable_name(core_bfd
));
337 /* Don't give the error more than once. */
338 ignore_direct_calls
= FALSE
;
342 /* Return class of symbol SYM. The returned class can be any of:
343 0 -> symbol is not interesting to us
344 'T' -> symbol is a global name
345 't' -> symbol is a local (static) name. */
348 core_sym_class (asymbol
*sym
)
355 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
358 /* Must be a text symbol, and static text symbols
359 don't qualify if ignore_static_funcs set. */
360 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
362 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
367 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
371 return i
; /* It's a global symbol. */
374 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
375 also be a data symbol. */
380 /* Not a static text symbol. */
381 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
386 /* Do some more filtering on static function-names. */
387 if (ignore_static_funcs
)
390 /* Can't zero-length name or funny characters in name, where
391 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
392 if (!sym
->name
|| sym
->name
[0] == '\0')
395 for (name
= sym
->name
; *name
; ++name
)
402 /* Allow both nested subprograms (which end with ".NNN", where N is
403 a digit) and GCC cloned functions (which contain ".clone").
404 Allow for multiple iterations of both - apparently GCC can clone
405 clones and subprograms. */
407 #define CLONE_NAME ".clone."
408 #define CLONE_NAME_LEN strlen (CLONE_NAME)
409 #define CONSTPROP_NAME ".constprop."
410 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
412 if (strlen (name
) > CLONE_NAME_LEN
413 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
414 name
+= CLONE_NAME_LEN
- 1;
416 else if (strlen (name
) > CONSTPROP_NAME_LEN
417 && strncmp (name
, CONSTPROP_NAME
, CONSTPROP_NAME_LEN
) == 0)
418 name
+= CONSTPROP_NAME_LEN
- 1;
420 for (name
++; *name
; name
++)
421 if (digit_seen
&& *name
== '.')
423 else if (ISDIGIT (*name
))
430 /* On systems where the C compiler adds an underscore to all
431 names, static names without underscores seem usually to be
432 labels in hand written assembler in the library. We don't want
433 these names. This is certainly necessary on a Sparc running
434 SunOS 4.1 (try profiling a program that does a lot of
435 division). I don't know whether it has harmful side effects on
436 other systems. Perhaps it should be made configurable. */
437 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
439 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
440 /* GCC may add special symbols to help gdb figure out the file
441 language. We want to ignore these, since sometimes they mask
442 the real function. (dj@ctron) */
443 || !strncmp (sym
->name
, "__gnu_compiled", 14)
444 || !strncmp (sym
->name
, "___gnu_compiled", 15))
449 /* If the object file supports marking of function symbols, then
450 we can zap anything that doesn't have BSF_FUNCTION set. */
451 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
454 return 't'; /* It's a static text symbol. */
457 /* Get whatever source info we can get regarding address ADDR. */
460 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
462 const char *fname
= 0, *func_name
= 0;
465 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
466 addr
- core_text_sect
->vma
,
467 &fname
, &func_name
, (unsigned int *) &l
)
468 && fname
&& func_name
&& l
)
470 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
471 (unsigned long) addr
, fname
, l
, func_name
));
479 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
480 (unsigned long) addr
,
481 fname
? fname
: "<unknown>", l
,
482 func_name
? func_name
: "<unknown>"));
487 static char buf
[BUFSIZE
];
488 static char address
[BUFSIZE
];
489 static char name
[BUFSIZE
];
491 /* Return number of symbols in a symbol-table file. */
494 num_of_syms_in (FILE * f
)
497 unsigned int num
= 0;
499 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
501 if (sscanf (buf
, "%" STR_BUFSIZE
"s %c %" STR_BUFSIZE
"s", address
, &type
, name
) == 3)
502 if (type
== 't' || type
== 'T')
509 /* Read symbol table from a file. */
512 core_create_syms_from (const char * sym_table_file
)
515 bfd_vma min_vma
= ~(bfd_vma
) 0;
519 f
= fopen (sym_table_file
, "r");
522 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
526 /* Pass 1 - determine upper bound on number of function names. */
527 symtab
.len
= num_of_syms_in (f
);
531 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
534 /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
535 else if ((symtab
.len
* (unsigned) sizeof (Sym
)) < symtab
.len
)
537 fprintf (stderr
, _("%s: file `%s' has too many symbols: %u\n"),
538 whoami
, sym_table_file
, symtab
.len
);
542 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
544 /* Pass 2 - create symbols. */
545 symtab
.limit
= symtab
.base
;
547 if (fseek (f
, 0, SEEK_SET
) != 0)
549 perror (sym_table_file
);
553 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
555 if (sscanf (buf
, "%" STR_BUFSIZE
"s %c %" STR_BUFSIZE
"s", address
, &type
, name
) != 3)
557 if (type
!= 't' && type
!= 'T')
560 sym_init (symtab
.limit
);
562 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
564 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
565 strcpy ((char *) symtab
.limit
->name
, name
);
566 symtab
.limit
->mapped
= 0;
567 symtab
.limit
->is_func
= TRUE
;
568 symtab
.limit
->is_bb_head
= TRUE
;
569 symtab
.limit
->is_static
= (type
== 't');
570 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
571 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
574 /* PR 20499 - it is theoretically possible that there are so many
575 symbols in the file that the scan in num_of_syms_in() wrapped
576 around. So be paranoid here and exit the loop if we have
577 reached the end of our allocated table. */
578 if ((unsigned int)(symtab
.limit
- symtab
.base
) == symtab
.len
)
583 symtab
.len
= symtab
.limit
- symtab
.base
;
584 symtab_finalize (&symtab
);
588 search_mapped_symbol (const void * l
, const void * r
)
590 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
593 /* Read in symbol table from core.
594 One symbol per function is entered. */
597 core_create_function_syms (void)
599 bfd_vma min_vma
= ~ (bfd_vma
) 0;
603 struct function_map
* found
= NULL
;
604 int core_has_func_syms
= 0;
606 switch (core_bfd
->xvec
->flavour
)
610 case bfd_target_coff_flavour
:
611 case bfd_target_ecoff_flavour
:
612 case bfd_target_xcoff_flavour
:
613 case bfd_target_elf_flavour
:
614 case bfd_target_nlm_flavour
:
615 case bfd_target_som_flavour
:
616 core_has_func_syms
= 1;
619 /* Pass 1 - determine upper bound on number of function names. */
622 for (i
= 0; i
< core_num_syms
; ++i
)
624 if (!core_sym_class (core_syms
[i
]))
627 /* Don't create a symtab entry for a function that has
628 a mapping to a file, unless it's the first function
630 if (symbol_map_count
!= 0)
632 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
634 found
= (struct function_map
*) bsearch
635 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
636 sizeof (struct function_map
), search_mapped_symbol
);
638 if (found
== NULL
|| found
->is_first
)
644 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
648 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
650 /* Pass 2 - create symbols. */
651 symtab
.limit
= symtab
.base
;
653 for (i
= 0; i
< core_num_syms
; ++i
)
657 cxxclass
= core_sym_class (core_syms
[i
]);
662 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
663 (unsigned long) core_syms
[i
]->value
,
664 core_syms
[i
]->name
));
668 if (symbol_map_count
!= 0)
670 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
672 found
= (struct function_map
*) bsearch
673 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
674 sizeof (struct function_map
), search_mapped_symbol
);
676 if (found
&& ! found
->is_first
)
679 sym_init (symtab
.limit
);
681 /* Symbol offsets are always section-relative. */
682 sym_sec
= core_syms
[i
]->section
;
683 symtab
.limit
->addr
= core_syms
[i
]->value
;
685 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
689 symtab
.limit
->name
= found
->file_name
;
690 symtab
.limit
->mapped
= 1;
694 symtab
.limit
->name
= core_syms
[i
]->name
;
695 symtab
.limit
->mapped
= 0;
698 /* Lookup filename and line number, if we can. */
700 const char * filename
;
701 const char * func_name
;
703 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
704 & symtab
.limit
->line_num
))
706 symtab
.limit
->file
= source_file_lookup_path (filename
);
708 /* FIXME: Checking __osf__ here does not work with a cross
711 /* Suppress symbols that are not function names. This is
712 useful to suppress code-labels and aliases.
714 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
715 labels do not appear in the symbol table info, so this isn't
718 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
720 /* The symbol's address maps to a different name, so
721 it can't be a function-entry point. This happens
722 for labels, for example. */
724 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
725 symtab
.limit
->name
, func_name
));
732 symtab
.limit
->is_func
= (!core_has_func_syms
733 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
734 symtab
.limit
->is_bb_head
= TRUE
;
737 symtab
.limit
->is_static
= TRUE
;
739 /* Keep track of the minimum and maximum vma addresses used by all
740 symbols. When computing the max_vma, use the ending address of the
741 section containing the symbol, if available. */
742 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
744 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
745 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
748 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
750 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
751 (long) (symtab
.limit
- symtab
.base
),
753 (unsigned long) symtab
.limit
->addr
));
757 symtab
.len
= symtab
.limit
- symtab
.base
;
758 symtab_finalize (&symtab
);
761 /* Read in symbol table from core.
762 One symbol per line of source code is entered. */
765 core_create_line_syms (void)
767 char *prev_name
, *prev_filename
;
768 unsigned int prev_name_len
, prev_filename_len
;
769 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
770 Sym
*prev
, dummy
, *sym
;
771 const char *filename
;
776 /* Create symbols for functions as usual. This is necessary in
777 cases where parts of a program were not compiled with -g. For
778 those parts we still want to get info at the function level. */
779 core_create_function_syms ();
781 /* Pass 1: count the number of symbols. */
783 /* To find all line information, walk through all possible
784 text-space addresses (one by one!) and get the debugging
785 info for each address. When the debugging info changes,
786 it is time to create a new symbol.
788 Of course, this is rather slow and it would be better if
789 BFD would provide an iterator for enumerating all line infos. */
790 prev_name_len
= PATH_MAX
;
791 prev_filename_len
= PATH_MAX
;
792 prev_name
= (char *) xmalloc (prev_name_len
);
793 prev_filename
= (char *) xmalloc (prev_filename_len
);
797 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
798 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
802 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
803 || (prev_line_num
== dummy
.line_num
805 && strcmp (prev_name
, dummy
.name
) == 0
806 && filename_cmp (prev_filename
, filename
) == 0))
810 prev_line_num
= dummy
.line_num
;
812 len
= strlen (dummy
.name
);
813 if (len
>= prev_name_len
)
815 prev_name_len
= len
+ 1024;
817 prev_name
= (char *) xmalloc (prev_name_len
);
820 strcpy (prev_name
, dummy
.name
);
821 len
= strlen (filename
);
823 if (len
>= prev_filename_len
)
825 prev_filename_len
= len
+ 1024;
826 free (prev_filename
);
827 prev_filename
= (char *) xmalloc (prev_filename_len
);
830 strcpy (prev_filename
, filename
);
832 min_vma
= MIN (vma
, min_vma
);
833 max_vma
= MAX (vma
, max_vma
);
837 free (prev_filename
);
839 /* Make room for function symbols, too. */
840 ltab
.len
+= symtab
.len
;
841 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
842 ltab
.limit
= ltab
.base
;
844 /* Pass 2 - create symbols. */
846 /* We now set is_static as we go along, rather than by running
847 through the symbol table at the end.
849 The old way called symtab_finalize before the is_static pass,
850 causing a problem since symtab_finalize uses is_static as part of
851 its address conflict resolution algorithm. Since global symbols
852 were prefered over static symbols, and all line symbols were
853 global at that point, static function names that conflicted with
854 their own line numbers (static, but labeled as global) were
855 rejected in favor of the line num.
857 This was not the desired functionality. We always want to keep
858 our function symbols and discard any conflicting line symbols.
859 Perhaps symtab_finalize should be modified to make this
860 distinction as well, but the current fix works and the code is a
864 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
866 sym_init (ltab
.limit
);
868 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
869 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
870 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
871 && filename_cmp (prev
->file
->name
, filename
) == 0))
874 /* Make name pointer a malloc'ed string. */
875 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
876 ltab
.limit
->file
= source_file_lookup_path (filename
);
878 ltab
.limit
->addr
= vma
;
880 /* Set is_static based on the enclosing function, using either:
881 1) the previous symbol, if it's from the same function, or
882 2) a symtab lookup. */
883 if (prev
&& ltab
.limit
->file
== prev
->file
&&
884 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
886 ltab
.limit
->is_static
= prev
->is_static
;
890 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
892 ltab
.limit
->is_static
= sym
->is_static
;
897 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
898 (unsigned long) (ltab
.limit
- ltab
.base
),
900 (unsigned long) ltab
.limit
->addr
));
904 /* Copy in function symbols. */
905 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
906 ltab
.limit
+= symtab
.len
;
908 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
911 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
912 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
916 /* Finalize ltab and make it symbol table. */
917 symtab_finalize (<ab
);
This page took 0.058334 seconds and 5 git commands to generate.