/* corefile.c
- Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
- 2010 Free Software Foundation, Inc.
+ Copyright (C) 1999-2021 Free Software Foundation, Inc.
This file is part of GNU Binutils.
\f
#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;
static int core_num_syms;
static void read_function_mappings (const char *);
static int core_sym_class (asymbol *);
-static bfd_boolean get_src_info
+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 tahoe_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)
static int
cmp_symbol_map (const void * l, const void * r)
{
- return strcmp (((struct function_map *) l)->function_name,
+ return strcmp (((struct function_map *) l)->function_name,
((struct function_map *) r)->function_name);
}
+#define BUFSIZE (1024)
+/* This is BUFSIZE - 1 as a string. Suitable for use in fprintf/sscanf format strings. */
+#define STR_BUFSIZE "1023"
+
static void
read_function_mappings (const char *filename)
{
FILE * file = fopen (filename, "r");
- char dummy[1024];
+ char dummy[BUFSIZE];
int count = 0;
unsigned int i;
{
int matches;
- matches = fscanf (file, "%[^\n:]", dummy);
+ matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
if (!matches)
parse_error (filename);
}
/* Don't care what else is on this line at this point. */
- matches = 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)
parse_error (filename);
strcpy (symbol_map[count].file_name, dummy);
/* Now we need the function name. */
- matches = 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 = count;
for (i = 0; i < symbol_map_count; ++i)
- if (i == 0 || strcmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
+ 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
done (1);
}
+ core_bfd->flags |= BFD_DECOMPRESS;
+
if (!bfd_check_format (core_bfd, bfd_object))
{
fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
switch (bfd_get_arch (core_bfd))
{
case bfd_arch_vax:
- case bfd_arch_tahoe:
offset_to_code = 2;
break;
void
core_get_text_space (bfd *cbfd)
{
- core_text_space = malloc (bfd_get_section_size (core_text_sect));
+ 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) bfd_get_section_size (core_text_sect));
+ whoami, (unsigned long) bfd_section_size (core_text_sect));
done (1);
}
if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
- 0, bfd_get_section_size (core_text_sect)))
+ 0, bfd_section_size (core_text_sect)))
{
bfd_perror ("bfd_get_section_contents");
free (core_text_space);
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;
}
}
if (*name == '$')
return 0;
- /* Do not discard nested subprograms (those
- which end with .NNN, where N are digits). */
- if (*name == '.')
- for (name++; *name; name++)
- if (! ISDIGIT (*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 bfd_boolean
-get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
+static bool
+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
{
(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 int
+static unsigned int
num_of_syms_in (FILE * f)
{
- const int BUFSIZE = 1024;
- char * buf = (char *) xmalloc (BUFSIZE);
- char * address = (char *) xmalloc (BUFSIZE);
char type;
- char * name = (char *) xmalloc (BUFSIZE);
- int num = 0;
-
+ unsigned int num = 0;
+
while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
{
- if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
+ if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
if (type == 't' || type == 'T')
- ++num;
+ {
+ /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
+ if (++num >= UINT_MAX / sizeof (Sym))
+ return -1U;
+ }
}
- free (buf);
- free (address);
- free (name);
-
return num;
}
void
core_create_syms_from (const char * sym_table_file)
{
- const int BUFSIZE = 1024;
- char * buf = (char *) xmalloc (BUFSIZE);
- char * address = (char *) xmalloc (BUFSIZE);
char type;
- char * name = (char *) xmalloc (BUFSIZE);
bfd_vma min_vma = ~(bfd_vma) 0;
bfd_vma max_vma = 0;
FILE * f;
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));
while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
{
- if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
- if (type != 't' && type != 'T')
- continue;
+ 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);
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_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.len = symtab.limit - symtab.base;
symtab_finalize (&symtab);
-
- free (buf);
- free (address);
- free (name);
}
static int
bfd_vma max_vma = 0;
int cxxclass;
long i;
- struct function_map * found;
+ 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;
/* 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. */
- found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
- symbol_map_count,
- sizeof (struct function_map),
- search_mapped_symbol);
+ 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;
}
continue;
}
- found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
- symbol_map_count,
- sizeof (struct function_map), search_mapped_symbol);
+ 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_sec = core_syms[i]->section;
symtab.limit->addr = core_syms[i]->value;
if (sym_sec)
- symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
+ symtab.limit->addr += bfd_section_vma (sym_sec);
if (found)
{
}
}
- symtab.limit->is_func = (core_syms[i]->flags & BSF_FUNCTION) != 0;
- 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 (cxxclass == 't')
- symtab.limit->is_static = TRUE;
+ 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);
if (sym_sec)
- max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
- + bfd_section_size (sym_sec->owner, sym_sec) - 1,
+ 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);
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_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;
- vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
+ 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)
{
unsigned int len;
|| (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;
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.
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. */
projects / deliverable / binutils-gdb.git / blobdiff