/* corefile.c
- Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1999-2021 Free Software Foundation, Inc.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
\f
-#include "libiberty.h"
#include "gprof.h"
+#include "libiberty.h"
+#include "filenames.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
+#include "hist.h"
#include "corefile.h"
+#include "safe-ctype.h"
+#include <limits.h> /* For UINT_MAX. */
bfd *core_bfd;
-int core_num_syms;
-asymbol **core_syms;
+static int core_num_syms;
+static asymbol **core_syms;
asection *core_text_sect;
-PTR core_text_space;
+void * core_text_space;
-int min_insn_size;
+static int min_insn_size;
int offset_to_code;
/* For mapping symbols to specific .o files during file ordering. */
-struct function_map
+struct function_map * symbol_map;
+unsigned int symbol_map_count;
+
+static void read_function_mappings (const char *);
+static int core_sym_class (asymbol *);
+static bool get_src_info
+ (bfd_vma, const char **, const char **, int *);
+
+extern void i386_find_call (Sym *, bfd_vma, bfd_vma);
+extern void alpha_find_call (Sym *, bfd_vma, bfd_vma);
+extern void vax_find_call (Sym *, bfd_vma, bfd_vma);
+extern void sparc_find_call (Sym *, bfd_vma, bfd_vma);
+extern void mips_find_call (Sym *, bfd_vma, bfd_vma);
+extern void aarch64_find_call (Sym *, bfd_vma, bfd_vma);
+
+static void
+parse_error (const char *filename)
{
- char *function_name;
- char *file_name;
-};
+ fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
+ done (1);
+}
-struct function_map *symbol_map;
-unsigned int symbol_map_count;
+/* Compare two function_map structs based on function name.
+ We want to sort in ascending order. */
+
+static int
+cmp_symbol_map (const void * l, const void * r)
+{
+ return strcmp (((struct function_map *) l)->function_name,
+ ((struct function_map *) r)->function_name);
+}
-extern void i386_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
-extern void alpha_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
-extern void vax_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
-extern void tahoe_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
-extern void sparc_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
-extern void mips_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
+#define BUFSIZE (1024)
+/* This is BUFSIZE - 1 as a string. Suitable for use in fprintf/sscanf format strings. */
+#define STR_BUFSIZE "1023"
static void
-DEFUN (read_function_mappings, (filename), const char *filename)
+read_function_mappings (const char *filename)
{
- FILE *file = fopen (filename, "r");
- char dummy[1024];
+ FILE * file = fopen (filename, "r");
+ char dummy[BUFSIZE];
int count = 0;
+ unsigned int i;
if (!file)
{
{
int matches;
- matches = fscanf (file, "%[^\n:]", dummy);
+ matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
if (!matches)
- {
- fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
- whoami, filename);
- done (1);
- }
+ parse_error (filename);
/* Just skip messages about files with no symbols. */
if (!strncmp (dummy, "No symbols in ", 14))
{
- fscanf (file, "\n");
+ matches = fscanf (file, "\n");
+ if (matches == EOF)
+ parse_error (filename);
continue;
}
/* Don't care what else is on this line at this point. */
- fscanf (file, "%[^\n]\n", dummy);
+ matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
+ if (!matches)
+ parse_error (filename);
count++;
}
int matches;
char *tmp;
- matches = fscanf (file, "%[^\n:]", dummy);
+ matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
if (!matches)
- {
- fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
- whoami, filename);
- done (1);
- }
+ parse_error (filename);
/* Just skip messages about files with no symbols. */
if (!strncmp (dummy, "No symbols in ", 14))
{
- fscanf (file, "\n");
+ matches = fscanf (file, "\n");
+ if (matches == EOF)
+ parse_error (filename);
continue;
}
/* dummy has the filename, go ahead and copy it. */
- symbol_map[count].file_name = xmalloc (strlen (dummy) + 1);
+ symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
strcpy (symbol_map[count].file_name, dummy);
/* Now we need the function name. */
- fscanf (file, "%[^\n]\n", dummy);
+ matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
+ if (!matches)
+ parse_error (filename);
tmp = strrchr (dummy, ' ') + 1;
- symbol_map[count].function_name = xmalloc (strlen (tmp) + 1);
+ symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
strcpy (symbol_map[count].function_name, tmp);
count++;
}
/* Record the size of the map table for future reference. */
symbol_map_count = count;
-}
+ for (i = 0; i < symbol_map_count; ++i)
+ if (i == 0
+ || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
+ symbol_map[i].is_first = 1;
+
+ qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
+
+ fclose (file);
+}
void
-DEFUN (core_init, (a_out_name), const char *a_out_name)
+core_init (const char * aout_name)
{
- core_bfd = bfd_openr (a_out_name, 0);
+ int core_sym_bytes;
+ asymbol *synthsyms;
+ long synth_count;
+
+ core_bfd = bfd_openr (aout_name, 0);
if (!core_bfd)
{
- perror (a_out_name);
+ perror (aout_name);
done (1);
}
+ core_bfd->flags |= BFD_DECOMPRESS;
+
if (!bfd_check_format (core_bfd, bfd_object))
{
- fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, a_out_name);
+ fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
done (1);
}
if (!core_text_sect)
{
fprintf (stderr, _("%s: can't find .text section in %s\n"),
- whoami, a_out_name);
+ whoami, aout_name);
done (1);
}
}
/* Read core's symbol table. */
/* This will probably give us more than we need, but that's ok. */
- core_num_syms = bfd_get_symtab_upper_bound (core_bfd);
- if (core_num_syms < 0)
+ core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
+ if (core_sym_bytes < 0)
{
- fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
+ fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
bfd_errmsg (bfd_get_error ()));
done (1);
}
- core_syms = (asymbol **) xmalloc (core_num_syms);
+ core_syms = (asymbol **) xmalloc (core_sym_bytes);
core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
if (core_num_syms < 0)
{
- fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
+ fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
bfd_errmsg (bfd_get_error ()));
done (1);
}
+ synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
+ 0, NULL, &synthsyms);
+ if (synth_count > 0)
+ {
+ asymbol **symp;
+ long new_size;
+ long i;
+
+ new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
+ core_syms = (asymbol **) xrealloc (core_syms, new_size);
+ symp = core_syms + core_num_syms;
+ core_num_syms += synth_count;
+ for (i = 0; i < synth_count; i++)
+ *symp++ = synthsyms + i;
+ *symp = 0;
+ }
+
min_insn_size = 1;
offset_to_code = 0;
switch (bfd_get_arch (core_bfd))
{
case bfd_arch_vax:
- case bfd_arch_tahoe:
offset_to_code = 2;
break;
/* Read in the text space of an a.out file. */
void
-DEFUN (core_get_text_space, (core_bfd), bfd * core_bfd)
+core_get_text_space (bfd *cbfd)
{
- core_text_space = (PTR) malloc (core_text_sect->_raw_size);
+ core_text_space = malloc (bfd_section_size (core_text_sect));
if (!core_text_space)
{
fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
- whoami, (unsigned long) core_text_sect->_raw_size);
+ whoami, (unsigned long) bfd_section_size (core_text_sect));
done (1);
}
- if (!bfd_get_section_contents (core_bfd, core_text_sect, core_text_space,
- 0, core_text_sect->_raw_size))
+ if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
+ 0, bfd_section_size (core_text_sect)))
{
bfd_perror ("bfd_get_section_contents");
free (core_text_space);
void
-DEFUN (find_call, (parent, p_lowpc, p_highpc),
- Sym * parent AND bfd_vma p_lowpc AND bfd_vma p_highpc)
+find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
{
+ if (core_text_space == 0)
+ return;
+
+ hist_clip_symbol_address (&p_lowpc, &p_highpc);
+
switch (bfd_get_arch (core_bfd))
{
case bfd_arch_i386:
sparc_find_call (parent, p_lowpc, p_highpc);
break;
- case bfd_arch_tahoe:
- tahoe_find_call (parent, p_lowpc, p_highpc);
- break;
-
case bfd_arch_mips:
mips_find_call (parent, p_lowpc, p_highpc);
break;
+ case bfd_arch_aarch64:
+ aarch64_find_call (parent, p_lowpc, p_highpc);
+ break;
+
default:
fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
whoami, bfd_printable_name(core_bfd));
/* Don't give the error more than once. */
- ignore_direct_calls = FALSE;
+ ignore_direct_calls = false;
}
}
't' -> symbol is a local (static) name. */
static int
-DEFUN (core_sym_class, (sym), asymbol * sym)
+core_sym_class (asymbol *sym)
{
symbol_info syminfo;
const char *name;
for (name = sym->name; *name; ++name)
{
- if (*name == '.' || *name == '$')
- return 0;
+ if (*name == '$')
+ return 0;
+
+ while (*name == '.')
+ {
+ /* Allow both nested subprograms (which end with ".NNN", where N is
+ a digit) and GCC cloned functions (which contain ".clone").
+ Allow for multiple iterations of both - apparently GCC can clone
+ clones and subprograms. */
+ int digit_seen = 0;
+#define CLONE_NAME ".clone."
+#define CLONE_NAME_LEN strlen (CLONE_NAME)
+#define CONSTPROP_NAME ".constprop."
+#define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
+
+ if (strlen (name) > CLONE_NAME_LEN
+ && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
+ name += CLONE_NAME_LEN - 1;
+
+ else if (strlen (name) > CONSTPROP_NAME_LEN
+ && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
+ name += CONSTPROP_NAME_LEN - 1;
+
+ for (name++; *name; name++)
+ if (digit_seen && *name == '.')
+ break;
+ else if (ISDIGIT (*name))
+ digit_seen = 1;
+ else
+ return 0;
+ }
}
/* On systems where the C compiler adds an underscore to all
/* Get whatever source info we can get regarding address ADDR. */
static bool
-DEFUN (get_src_info, (addr, filename, name, line_num),
- bfd_vma addr AND const char **filename AND const char **name
- AND int *line_num)
+get_src_info (bfd_vma addr, const char **filename, const char **name,
+ int *line_num)
{
const char *fname = 0, *func_name = 0;
int l = 0;
*filename = fname;
*name = func_name;
*line_num = l;
- return TRUE;
+ return true;
}
else
{
DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
- (long) addr, fname ? fname : "<unknown>", l,
+ (unsigned long) addr,
+ fname ? fname : "<unknown>", l,
func_name ? func_name : "<unknown>"));
- return FALSE;
+ return false;
+ }
+}
+
+static char buf[BUFSIZE];
+static char address[BUFSIZE];
+static char name[BUFSIZE];
+
+/* Return number of symbols in a symbol-table file. */
+
+static unsigned int
+num_of_syms_in (FILE * f)
+{
+ char type;
+ unsigned int num = 0;
+
+ while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
+ {
+ if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
+ if (type == 't' || type == 'T')
+ {
+ /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
+ if (++num >= UINT_MAX / sizeof (Sym))
+ return -1U;
+ }
+ }
+
+ return num;
+}
+
+/* Read symbol table from a file. */
+
+void
+core_create_syms_from (const char * sym_table_file)
+{
+ char type;
+ bfd_vma min_vma = ~(bfd_vma) 0;
+ bfd_vma max_vma = 0;
+ FILE * f;
+
+ f = fopen (sym_table_file, "r");
+ if (!f)
+ {
+ fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
+ done (1);
+ }
+
+ /* Pass 1 - determine upper bound on number of function names. */
+ symtab.len = num_of_syms_in (f);
+
+ if (symtab.len == 0)
+ {
+ fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
+ done (1);
+ }
+ else if (symtab.len == -1U)
+ {
+ fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
+ whoami, sym_table_file);
+ done (1);
+ }
+
+ symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
+
+ /* Pass 2 - create symbols. */
+ symtab.limit = symtab.base;
+
+ if (fseek (f, 0, SEEK_SET) != 0)
+ {
+ perror (sym_table_file);
+ done (1);
+ }
+
+ while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
+ {
+ if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) != 3)
+ continue;
+ if (type != 't' && type != 'T')
+ continue;
+
+ sym_init (symtab.limit);
+
+ sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
+
+ symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
+ strcpy ((char *) symtab.limit->name, name);
+ symtab.limit->mapped = 0;
+ symtab.limit->is_func = true;
+ symtab.limit->is_bb_head = true;
+ symtab.limit->is_static = (type == 't');
+ min_vma = MIN (symtab.limit->addr, min_vma);
+ max_vma = MAX (symtab.limit->addr, max_vma);
+
+ ++symtab.limit;
}
+ fclose (f);
+
+ symtab.len = symtab.limit - symtab.base;
+ symtab_finalize (&symtab);
+}
+
+static int
+search_mapped_symbol (const void * l, const void * r)
+{
+ return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
}
/* Read in symbol table from core.
One symbol per function is entered. */
void
-core_create_function_syms (core_bfd)
- bfd *core_bfd ATTRIBUTE_UNUSED;
+core_create_function_syms (void)
{
- bfd_vma min_vma = ~0, max_vma = 0;
- int class;
- long i, found, skip;
- unsigned int j;
+ bfd_vma min_vma = ~ (bfd_vma) 0;
+ bfd_vma max_vma = 0;
+ int cxxclass;
+ long i;
+ struct function_map * found = NULL;
+ int core_has_func_syms = 0;
+
+ switch (core_bfd->xvec->flavour)
+ {
+ default:
+ break;
+ case bfd_target_coff_flavour:
+ case bfd_target_ecoff_flavour:
+ case bfd_target_xcoff_flavour:
+ case bfd_target_elf_flavour:
+ case bfd_target_som_flavour:
+ core_has_func_syms = 1;
+ }
/* Pass 1 - determine upper bound on number of function names. */
symtab.len = 0;
if (!core_sym_class (core_syms[i]))
continue;
- /* This should be replaced with a binary search or hashed
- search. Gross.
-
- Don't create a symtab entry for a function that has
+ /* Don't create a symtab entry for a function that has
a mapping to a file, unless it's the first function
in the file. */
- skip = 0;
- for (j = 0; j < symbol_map_count; j++)
- if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
- {
- if (j > 0 && ! strcmp (symbol_map [j].file_name,
- symbol_map [j - 1].file_name))
- skip = 1;
- break;
- }
-
- if (!skip)
+ if (symbol_map_count != 0)
+ {
+ /* Note: some systems (SunOS 5.8) crash if bsearch base argument
+ is NULL. */
+ found = (struct function_map *) bsearch
+ (core_syms[i]->name, symbol_map, symbol_map_count,
+ sizeof (struct function_map), search_mapped_symbol);
+ }
+ if (found == NULL || found->is_first)
++symtab.len;
}
done (1);
}
- /* The "+ 2" is for the sentinels. */
- symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
+ symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
/* Pass 2 - create symbols. */
symtab.limit = symtab.base;
for (i = 0; i < core_num_syms; ++i)
{
- class = core_sym_class (core_syms[i]);
+ asection *sym_sec;
+
+ cxxclass = core_sym_class (core_syms[i]);
- if (!class)
+ if (!cxxclass)
{
DBG (AOUTDEBUG,
printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
continue;
}
- /* This should be replaced with a binary search or hashed
- search. Gross. */
- skip = 0;
- found = 0;
-
- for (j = 0; j < symbol_map_count; j++)
- if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
- {
- if (j > 0 && ! strcmp (symbol_map [j].file_name,
- symbol_map [j - 1].file_name))
- skip = 1;
- else
- found = j;
- break;
- }
-
- if (skip)
+ if (symbol_map_count != 0)
+ {
+ /* Note: some systems (SunOS 5.8) crash if bsearch base argument
+ is NULL. */
+ found = (struct function_map *) bsearch
+ (core_syms[i]->name, symbol_map, symbol_map_count,
+ sizeof (struct function_map), search_mapped_symbol);
+ }
+ if (found && ! found->is_first)
continue;
sym_init (symtab.limit);
/* Symbol offsets are always section-relative. */
- symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
+ sym_sec = core_syms[i]->section;
+ symtab.limit->addr = core_syms[i]->value;
+ if (sym_sec)
+ symtab.limit->addr += bfd_section_vma (sym_sec);
- if (symbol_map_count
- && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
+ if (found)
{
- symtab.limit->name = symbol_map[found].file_name;
+ symtab.limit->name = found->file_name;
symtab.limit->mapped = 1;
}
else
/* Lookup filename and line number, if we can. */
{
- const char *filename, *func_name;
+ const char * filename;
+ const char * func_name;
- if (get_src_info (symtab.limit->addr, &filename, &func_name,
- &symtab.limit->line_num))
+ if (get_src_info (symtab.limit->addr, & filename, & func_name,
+ & symtab.limit->line_num))
{
symtab.limit->file = source_file_lookup_path (filename);
}
}
- symtab.limit->is_func = TRUE;
- symtab.limit->is_bb_head = TRUE;
+ symtab.limit->is_func = (!core_has_func_syms
+ || (core_syms[i]->flags & BSF_FUNCTION) != 0);
+ symtab.limit->is_bb_head = true;
- if (class == 't')
- symtab.limit->is_static = TRUE;
+ if (cxxclass == 't')
+ symtab.limit->is_static = true;
+ /* Keep track of the minimum and maximum vma addresses used by all
+ symbols. When computing the max_vma, use the ending address of the
+ section containing the symbol, if available. */
min_vma = MIN (symtab.limit->addr, min_vma);
- max_vma = MAX (symtab.limit->addr, max_vma);
-
- /* If we see "main" without an initial '_', we assume names
- are *not* prefixed by '_'. */
- if (symtab.limit->name[0] == 'm' && discard_underscores
- && strcmp (symtab.limit->name, "main") == 0)
- discard_underscores = 0;
+ if (sym_sec)
+ max_vma = MAX (bfd_section_vma (sym_sec)
+ + bfd_section_size (sym_sec) - 1,
+ max_vma);
+ else
+ max_vma = MAX (symtab.limit->addr, max_vma);
DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
(long) (symtab.limit - symtab.base),
++symtab.limit;
}
- /* Create sentinels. */
- sym_init (symtab.limit);
- symtab.limit->name = "<locore>";
- symtab.limit->addr = 0;
- symtab.limit->end_addr = min_vma - 1;
- ++symtab.limit;
-
- sym_init (symtab.limit);
- symtab.limit->name = "<hicore>";
- symtab.limit->addr = max_vma + 1;
- symtab.limit->end_addr = ~0;
- ++symtab.limit;
-
symtab.len = symtab.limit - symtab.base;
symtab_finalize (&symtab);
}
One symbol per line of source code is entered. */
void
-DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
+core_create_line_syms (void)
{
char *prev_name, *prev_filename;
- int prev_name_len, prev_filename_len;
- bfd_vma vma, min_vma = ~0, max_vma = 0;
- bfd_vma offset;
- Sym *prev, dummy, *sentinel, *sym;
+ unsigned int prev_name_len, prev_filename_len;
+ bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
+ Sym *prev, dummy, *sym;
const char *filename;
int prev_line_num;
Sym_Table ltab;
+ bfd_vma vma_high;
/* Create symbols for functions as usual. This is necessary in
cases where parts of a program were not compiled with -g. For
those parts we still want to get info at the function level. */
- core_create_function_syms (core_bfd);
+ core_create_function_syms ();
- /* Pass 1 - counter number of symbols. */
+ /* Pass 1: count the number of symbols. */
/* To find all line information, walk through all possible
text-space addresses (one by one!) and get the debugging
it is time to create a new symbol.
Of course, this is rather slow and it would be better if
- bfd would provide an iterator for enumerating all line infos. */
- prev_name_len = PATH_MAX;
- prev_filename_len = PATH_MAX;
- prev_name = xmalloc (prev_name_len);
- prev_filename = xmalloc (prev_filename_len);
+ BFD would provide an iterator for enumerating all line infos. */
+ prev_name_len = 1024;
+ prev_filename_len = 1024;
+ prev_name = (char *) xmalloc (prev_name_len);
+ prev_filename = (char *) xmalloc (prev_filename_len);
ltab.len = 0;
prev_line_num = 0;
- for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
+ vma_high = core_text_sect->vma + bfd_section_size (core_text_sect);
+ for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
{
- int len;
-
- vma = core_text_sect->vma + offset;
+ unsigned int len;
if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
|| (prev_line_num == dummy.line_num
&& prev_name != NULL
&& strcmp (prev_name, dummy.name) == 0
- && strcmp (prev_filename, filename) == 0))
+ && filename_cmp (prev_filename, filename) == 0))
continue;
++ltab.len;
{
prev_name_len = len + 1024;
free (prev_name);
- prev_name = xmalloc (prev_name_len);
+ prev_name = (char *) xmalloc (prev_name_len);
}
strcpy (prev_name, dummy.name);
{
prev_filename_len = len + 1024;
free (prev_filename);
- prev_filename = xmalloc (prev_filename_len);
+ prev_filename = (char *) xmalloc (prev_filename_len);
}
strcpy (prev_filename, filename);
The old way called symtab_finalize before the is_static pass,
causing a problem since symtab_finalize uses is_static as part of
its address conflict resolution algorithm. Since global symbols
- were prefered over static symbols, and all line symbols were
+ were preferred over static symbols, and all line symbols were
global at that point, static function names that conflicted with
their own line numbers (static, but labeled as global) were
rejected in favor of the line num.
lot cleaner now. */
prev = 0;
- for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
+ for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
{
sym_init (ltab.limit);
- if (!get_src_info (core_text_sect->vma + offset, &filename,
- <ab.limit->name, <ab.limit->line_num)
+ if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
|| (prev && prev->line_num == ltab.limit->line_num
&& strcmp (prev->name, ltab.limit->name) == 0
- && strcmp (prev->file->name, filename) == 0))
+ && filename_cmp (prev->file->name, filename) == 0))
continue;
/* Make name pointer a malloc'ed string. */
ltab.limit->name = xstrdup (ltab.limit->name);
ltab.limit->file = source_file_lookup_path (filename);
- ltab.limit->addr = core_text_sect->vma + offset;
+ ltab.limit->addr = vma;
/* Set is_static based on the enclosing function, using either:
1) the previous symbol, if it's from the same function, or
else
{
sym = sym_lookup(&symtab, ltab.limit->addr);
- ltab.limit->is_static = sym->is_static;
+ if (sym)
+ ltab.limit->is_static = sym->is_static;
}
prev = ltab.limit;
- /* If we see "main" without an initial '_', we assume names
- are *not* prefixed by '_'. */
- if (ltab.limit->name[0] == 'm' && discard_underscores
- && strcmp (ltab.limit->name, "main") == 0)
- discard_underscores = 0;
-
DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
(unsigned long) (ltab.limit - ltab.base),
ltab.limit->name,
++ltab.limit;
}
- /* Update sentinels. */
- sentinel = sym_lookup (&symtab, 0);
-
- if (strcmp (sentinel->name, "<locore>") == 0
- && min_vma <= sentinel->end_addr)
- sentinel->end_addr = min_vma - 1;
-
- sentinel = sym_lookup (&symtab, ~0);
-
- if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
- sentinel->addr = max_vma + 1;
-
/* Copy in function symbols. */
memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
ltab.limit += symtab.len;
projects / deliverable / binutils-gdb.git / blobdiff