/* corefile.c    Copyright (C) 1999-2026 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 3 of the License, or   (at your option) any later version.    This program is distributed in the hope that it will be useful,   but WITHOUT ANY WARRANTY; without even the implied warranty of   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   GNU General Public License for more details.    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., 51 Franklin Street - Fifth Floor, Boston, MA   02110-1301, USA.  */ #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 "gmon_io.h"#include "safe-ctype.h"#include <limits.h>    /* For UINT_MAX.  */ bfd *core_bfd;static int core_num_syms;static asymbol **core_syms;asection *core_text_sect;void * core_text_space; /* Greatest common divisor of instruction sizes and alignments.  */static int insn_boundary;int offset_to_code; /* For mapping symbols to specific .o files during file ordering.  */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 voidparse_error (const char *filename){  fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);  done (1);} /* Compare two function_map structs based on function name.   We want to sort in ascending order.  */ static intcmp_symbol_map (const void * l, const void * r){  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 voidread_function_mappings (const char *filename){  FILE * file = fopen (filename, "r");  char dummy[BUFSIZE];  int count = 0;  unsigned int i;   if (!file)    {      fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);      done (1);    }   /* First parse the mapping file so we know how big we need to     make our tables.  We also do some sanity checks at this     time.  */  while (!feof (file))    {      int matches;       matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);      if (!matches)	parse_error (filename);       /* Just skip messages about files with no symbols.  */      if (!strncmp (dummy, "No symbols in ", 14))	{	  matches = fscanf (file, "\n");	  if (matches == EOF)	    parse_error (filename);	  continue;	}       /* Don't care what else is on this line at this point.  */      matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);      if (!matches)	parse_error (filename);      count++;    }   /* Now we know how big we need to make our table.  */  symbol_map = ((struct function_map *)		xmalloc (count * sizeof (struct function_map)));   /* Rewind the input file so we can read it again.  */  rewind (file);   /* Read each entry and put it into the table.  */  count = 0;  while (!feof (file))    {      int matches;      char *tmp;       matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);      if (!matches)	parse_error (filename);       /* Just skip messages about files with no symbols.  */      if (!strncmp (dummy, "No symbols in ", 14))	{	  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 = (char *) xmalloc (strlen (dummy) + 1);      strcpy (symbol_map[count].file_name, dummy);       /* Now we need the function name.  */      matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);      if (!matches)	parse_error (filename);      tmp = strrchr (dummy, ' ') + 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);} voidcore_init (const char * aout_name){  int core_sym_bytes;  asymbol *synthsyms;  long synth_count;   core_bfd = bfd_openr (aout_name, 0);   if (!core_bfd)    {      perror (aout_name);      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);      done (1);    }   /* Get core's text section.  */  core_text_sect = bfd_get_section_by_name (core_bfd, ".text");  if (!core_text_sect)    {      core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");      if (!core_text_sect)	{	  fprintf (stderr, _("%s: can't find .text section in %s\n"),		   whoami, aout_name);	  done (1);	}    }   /* Read core's symbol table.  */   /* This will probably give us more than we need, but that's ok.  */  core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);  if (core_sym_bytes < 0)    {      fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,	       bfd_errmsg (bfd_get_error ()));      done (1);    }   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, 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;    }   insn_boundary = 1;  offset_to_code = 0;   switch (bfd_get_arch (core_bfd))    {    case bfd_arch_vax:      offset_to_code = 2;      break;     case bfd_arch_mips:/* and microMIPS */    case bfd_arch_powerpc:/* and VLE */    case bfd_arch_riscv:/* and RVC */    case bfd_arch_sh:      insn_boundary = 2;      break;     case bfd_arch_alpha:      insn_boundary = 4;      break;     default:      break;    }   if (function_mapping_file)    read_function_mappings (function_mapping_file);} /* Read in the text space of an a.out file.  */ voidcore_get_text_space (bfd *cbfd){  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_section_size (core_text_sect));      done (1);    }   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);      core_text_space = 0;    }   if (!core_text_space)    fprintf (stderr, _("%s: can't do -c\n"), whoami);}  voidfind_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:      i386_find_call (parent, p_lowpc, p_highpc);      break;     case bfd_arch_alpha:      alpha_find_call (parent, p_lowpc, p_highpc);      break;     case bfd_arch_vax:      vax_find_call (parent, p_lowpc, p_highpc);      break;     case bfd_arch_sparc:      sparc_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;    }} /* Return class of symbol SYM.  The returned class can be any of:	0   -> symbol is not interesting to us	'T' -> symbol is a global name	't' -> symbol is a local (static) name.  */ static intcore_sym_class (asymbol *sym){  symbol_info syminfo;  const char *name;  char sym_prefix;  int i;   if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)    return 0;   /* Must be a text symbol, and static text symbols     don't qualify if ignore_static_funcs set.   */  if (ignore_static_funcs && (sym->flags & BSF_LOCAL))    {      DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",			      sym->name));      return 0;    }   bfd_get_symbol_info (core_bfd, sym, &syminfo);  i = syminfo.type;   if (i == 'T')    return i;			/* It's a global symbol.  */   if (i == 'W')    /* Treat weak symbols as text symbols.  FIXME: a weak symbol may       also be a data symbol.  */    return 'T';   if (i != 't')    {      /* Not a static text symbol.  */      DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",			      sym->name, i));      return 0;    }   /* Do some more filtering on static function-names.  */  if (ignore_static_funcs)    return 0;   /* Can't zero-length name or funny characters in name, where     `funny' includes: `.' (.o file names) and `$' (Pascal labels).  */  if (!sym->name || sym->name[0] == '\0')    return 0;   for (name = sym->name; *name; ++name)    {      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     names, static names without underscores seem usually to be     labels in hand written assembler in the library.  We don't want     these names.  This is certainly necessary on a Sparc running     SunOS 4.1 (try profiling a program that does a lot of     division). I don't know whether it has harmful side effects on     other systems.  Perhaps it should be made configurable.  */  sym_prefix = bfd_get_symbol_leading_char (core_bfd);   if ((sym_prefix && sym_prefix != sym->name[0])      /* GCC may add special symbols to help gdb figure out the file	language.  We want to ignore these, since sometimes they mask	the real function.  (dj@ctron)  */      || !strncmp (sym->name, "__gnu_compiled", 14)      || !strncmp (sym->name, "___gnu_compiled", 15))    {      return 0;    }   /* If the object file supports marking of function symbols, then     we can zap anything that doesn't have BSF_FUNCTION set.  */  if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)    return 0;   return 't';			/* It's a static text symbol.  */} /* Get whatever source info we can get regarding address ADDR.  */ static boolget_src_info (bfd_vma addr, const char **filename, const char **name,	      int *line_num){  const char *fname = 0, *func_name = 0;  int l = 0;   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,			     addr - core_text_sect->vma,			     &fname, &func_name, (unsigned int *) &l)      && fname && func_name && l)    {      DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",			      (unsigned long) addr, fname, l, func_name));      *filename = fname;      *name = func_name;      *line_num = l;      return true;    }  else    {      DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",			      (unsigned long) addr,			      fname ? fname : "<unknown>", l,			      func_name ? func_name : "<unknown>"));      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

Lines 1–500 of 922. Load more