X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Frddbg.c;h=eb8ffcbc0257c4cad7e87adcbbf9c0ced1cba621;hb=9b30da15e72bd4e8265169bfd511272aa3875738;hp=b2602af4c6e98dd30e8a08367d77da47deb3d24c;hpb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;p=deliverable%2Fbinutils-gdb.git

diff --git a/binutils/rddbg.c b/binutils/rddbg.c
index b2602af4c6..eb8ffcbc02 100644
--- a/binutils/rddbg.c
+++ b/binutils/rddbg.c
@@ -1,12 +1,12 @@
 /* rddbg.c -- Read debugging information into a generic form.
-   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1995-2019 Free Software Foundation, Inc.
    Written by Ian Lance Taylor <ian@cygnus.com>.
 
    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,
@@ -16,39 +16,37 @@
 
    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.  */
+
 
 /* This file reads debugging information into a generic form.  This
    file knows how to dig the debugging information out of an object
    file.  */
 
+#include "sysdep.h"
 #include "bfd.h"
-#include "bucomm.h"
 #include "libiberty.h"
+#include "bucomm.h"
 #include "debug.h"
 #include "budbg.h"
 
-static boolean read_section_stabs_debugging_info
-  PARAMS ((bfd *, asymbol **, long, PTR, boolean *));
-static boolean read_symbol_stabs_debugging_info
-  PARAMS ((bfd *, asymbol **, long, PTR, boolean *));
-static boolean read_ieee_debugging_info PARAMS ((bfd *, PTR, boolean *));
-static void save_stab PARAMS ((int, int, bfd_vma, const char *));
-static void stab_context PARAMS ((void));
-static void free_saved_stabs PARAMS ((void));
+static bfd_boolean read_section_stabs_debugging_info
+  (bfd *, asymbol **, long, void *, bfd_boolean *);
+static bfd_boolean read_symbol_stabs_debugging_info
+  (bfd *, asymbol **, long, void *, bfd_boolean *);
+static void save_stab (int, int, bfd_vma, const char *);
+static void stab_context (void);
+static void free_saved_stabs (void);
 
 /* Read debugging information from a BFD.  Returns a generic debugging
    pointer.  */
 
-PTR
-read_debugging_info (abfd, syms, symcount)
-     bfd *abfd;
-     asymbol **syms;
-     long symcount;
+void *
+read_debugging_info (bfd *abfd, asymbol **syms, long symcount, bfd_boolean no_messages)
 {
-  PTR dhandle;
-  boolean found;
+  void *dhandle;
+  bfd_boolean found;
 
   dhandle = debug_init ();
   if (dhandle == NULL)
@@ -65,12 +63,6 @@ read_debugging_info (abfd, syms, symcount)
 	return NULL;
     }
 
-  if (bfd_get_flavour (abfd) == bfd_target_ieee_flavour)
-    {
-      if (! read_ieee_debugging_info (abfd, dhandle, &found))
-	return NULL;
-    }
-
   /* Try reading the COFF symbols if we didn't find any stabs in COFF
      sections.  */
   if (! found
@@ -79,13 +71,14 @@ read_debugging_info (abfd, syms, symcount)
     {
       if (! parse_coff (abfd, syms, symcount, dhandle))
 	return NULL;
-      found = true;
+      found = TRUE;
     }
 
   if (! found)
     {
-      fprintf (stderr, "%s: no recognized debugging information\n",
-	       bfd_get_filename (abfd));
+      if (! no_messages)
+	non_fatal (_("%s: no recognized debugging information"),
+		   bfd_get_filename (abfd));
       return NULL;
     }
 
@@ -94,23 +87,25 @@ read_debugging_info (abfd, syms, symcount)
 
 /* Read stabs in sections debugging information from a BFD.  */
 
-static boolean
-read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
-     bfd *abfd;
-     asymbol **syms;
-     long symcount;
-     PTR dhandle;
-     boolean *pfound;
+static bfd_boolean
+read_section_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
+				   void *dhandle, bfd_boolean *pfound)
 {
   static struct
     {
       const char *secname;
       const char *strsecname;
-    } names[] = { { ".stab", ".stabstr" } };
+    }
+  names[] =
+    {
+      { ".stab", ".stabstr" },
+      { "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr" },
+      { "$GDB_SYMBOLS$", "$GDB_STRINGS$" }
+    };
   unsigned int i;
-  PTR shandle;
+  void *shandle;
 
-  *pfound = false;
+  *pfound = FALSE;
   shandle = NULL;
 
   for (i = 0; i < sizeof names / sizeof names[0]; i++)
@@ -126,42 +121,53 @@ read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 	  bfd_byte *stab;
 	  bfd_size_type stroff, next_stroff;
 
-	  stabsize = bfd_section_size (abfd, sec);
+	  stabsize = bfd_section_size (sec);
 	  stabs = (bfd_byte *) xmalloc (stabsize);
 	  if (! bfd_get_section_contents (abfd, sec, stabs, 0, stabsize))
 	    {
 	      fprintf (stderr, "%s: %s: %s\n",
 		       bfd_get_filename (abfd), names[i].secname,
 		       bfd_errmsg (bfd_get_error ()));
-	      return false;
+	      free (shandle);
+	      free (stabs);
+	      return FALSE;
 	    }
 
-	  strsize = bfd_section_size (abfd, strsec);
-	  strings = (bfd_byte *) xmalloc (strsize);
+	  strsize = bfd_section_size (strsec);
+	  strings = (bfd_byte *) xmalloc (strsize + 1);
 	  if (! bfd_get_section_contents (abfd, strsec, strings, 0, strsize))
 	    {
 	      fprintf (stderr, "%s: %s: %s\n",
 		       bfd_get_filename (abfd), names[i].strsecname,
 		       bfd_errmsg (bfd_get_error ()));
-	      return false;
+	      free (shandle);
+	      free (strings);
+	      free (stabs);
+	      return FALSE;
 	    }
-
+	  /* Zero terminate the strings table, just in case.  */
+	  strings [strsize] = 0;
 	  if (shandle == NULL)
 	    {
-	      shandle = start_stab (dhandle, abfd, true, syms, symcount);
+	      shandle = start_stab (dhandle, abfd, TRUE, syms, symcount);
 	      if (shandle == NULL)
-		return false;
+		{
+		  free (strings);
+		  free (stabs);
+		  return FALSE;
+		}
 	    }
 
-	  *pfound = true;
+	  *pfound = TRUE;
 
 	  stroff = 0;
 	  next_stroff = 0;
-	  for (stab = stabs; stab < stabs + stabsize; stab += 12)
+	  /* PR 17512: file: 078-60391-0.001:0.1.  */
+	  for (stab = stabs; stab <= (stabs + stabsize) - 12; stab += 12)
 	    {
-	      bfd_size_type strx;
+	      unsigned int strx;
 	      int type;
-	      int other;
+	      int other ATTRIBUTE_UNUSED;
 	      int desc;
 	      bfd_vma value;
 
@@ -176,28 +182,56 @@ read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 	      if (type == 0)
 		{
 		  /* Special type 0 stabs indicate the offset to the
-                     next string table.  */
+		     next string table.  */
 		  stroff = next_stroff;
 		  next_stroff += value;
 		}
 	      else
 		{
+		  size_t len;
 		  char *f, *s;
 
-		  f = NULL;
+		  if (stroff + strx >= strsize)
+		    {
+		      fprintf (stderr, _("%s: %s: stab entry %ld is corrupt, strx = 0x%x, type = %d\n"),
+			       bfd_get_filename (abfd), names[i].secname,
+			       (long) (stab - stabs) / 12, strx, type);
+		      continue;
+		    }
+
 		  s = (char *) strings + stroff + strx;
-		  while (s[strlen (s) - 1] == '\\'
+		  f = NULL;
+
+		  /* PR 17512: file: 002-87578-0.001:0.1.
+		     It is possible to craft a file where, without the 'strlen (s) > 0',
+		     an attempt to read the byte before 'strings' would occur.  */
+		  while ((len = strlen (s)) > 0
+			 && s[len  - 1] == '\\'
 			 && stab + 12 < stabs + stabsize)
 		    {
+		      char *p;
+
 		      stab += 12;
-		      s[strlen (s) - 1] = '\0';
-		      s = concat (s,
-				  ((char *) strings
-				   + stroff
-				   + bfd_get_32 (abfd, stab)),
+		      p = s + len - 1;
+		      *p = '\0';
+		      strx = stroff + bfd_get_32 (abfd, stab);
+		      if (strx >= strsize)
+			{
+			  fprintf (stderr, _("%s: %s: stab entry %ld is corrupt\n"),
+				   bfd_get_filename (abfd), names[i].secname,
+				   (long) (stab - stabs) / 12);
+			  break;
+			}
+
+		      s = concat (s, (char *) strings + strx,
 				  (const char *) NULL);
-		      if (f != NULL)
-			free (f);
+
+		      /* We have to restore the backslash, because, if
+			 the linker is hashing stabs strings, we may
+			 see the same string more than once.  */
+		      *p = '\\';
+
+		      free (f);
 		      f = s;
 		    }
 
@@ -207,12 +241,16 @@ read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 		    {
 		      stab_context ();
 		      free_saved_stabs ();
-		      return false;
+		      free (f);
+		      free (shandle);
+		      free (stabs);
+		      free (strings);
+		      return FALSE;
 		    }
 
 		  /* Don't free f, since I think the stabs code
-                     expects strings to hang around.  This should be
-                     straightened out.  FIXME.  */
+		     expects strings to hang around.  This should be
+		     straightened out.  FIXME.  */
 		}
 	    }
 
@@ -220,31 +258,27 @@ read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 	  free (stabs);
 
 	  /* Don't free strings, since I think the stabs code expects
-             the strings to hang around.  This should be straightened
-             out.  FIXME.  */
+	     the strings to hang around.  This should be straightened
+	     out.  FIXME.  */
 	}
     }
 
   if (shandle != NULL)
     {
       if (! finish_stab (dhandle, shandle))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Read stabs in the symbol table.  */
 
-static boolean
-read_symbol_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
-     bfd *abfd;
-     asymbol **syms;
-     long symcount;
-     PTR dhandle;
-     boolean *pfound;
+static bfd_boolean
+read_symbol_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
+				  void *dhandle, bfd_boolean *pfound)
 {
-  PTR shandle;
+  void *shandle;
   asymbol **ps, **symend;
 
   shandle = NULL;
@@ -262,15 +296,20 @@ read_symbol_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 
 	  if (shandle == NULL)
 	    {
-	      shandle = start_stab (dhandle, abfd, false, syms, symcount);
+	      shandle = start_stab (dhandle, abfd, FALSE, syms, symcount);
 	      if (shandle == NULL)
-		return false;
+		return FALSE;
 	    }
 
-	  *pfound = true;
+	  *pfound = TRUE;
 
 	  s = i.name;
-	  while (s[strlen (s) - 1] == '\\'
+	  if (s == NULL || strlen (s) < 1)
+	    return FALSE;
+	  f = NULL;
+
+	  while (strlen (s) > 0
+		 && s[strlen (s) - 1] == '\\'
 		 && ps + 1 < symend)
 	    {
 	      char *sc, *n;
@@ -293,58 +332,24 @@ read_symbol_stabs_debugging_info (abfd, syms, symcount, dhandle, pfound)
 	    {
 	      stab_context ();
 	      free_saved_stabs ();
-	      return false;
+	      return FALSE;
 	    }
 
-	  free_saved_stabs ();
-
 	  /* Don't free f, since I think the stabs code expects
 	     strings to hang around.  This should be straightened out.
 	     FIXME.  */
 	}
     }
 
+  free_saved_stabs ();
+
   if (shandle != NULL)
     {
       if (! finish_stab (dhandle, shandle))
-	return false;
+	return FALSE;
     }
 
-  return true;
-}
-
-/* Read IEEE debugging information.  */
-
-static boolean
-read_ieee_debugging_info (abfd, dhandle, pfound)
-     bfd *abfd;
-     PTR dhandle;
-     boolean *pfound;
-{
-  asection *dsec;
-  bfd_size_type size;
-  bfd_byte *contents;
-
-  /* The BFD backend puts the debugging information into a section
-     named .debug.  */
-
-  dsec = bfd_get_section_by_name (abfd, ".debug");
-  if (dsec == NULL)
-    return true;
-
-  size = bfd_section_size (abfd, dsec);
-  contents = (bfd_byte *) xmalloc (size);
-  if (! bfd_get_section_contents (abfd, dsec, contents, 0, size))
-    return false;
-
-  if (! parse_ieee (dhandle, abfd, contents, size))
-    return false;
-
-  free (contents);
-
-  *pfound = true;
-
-  return true;
+  return TRUE;
 }
 
 /* Record stabs strings, so that we can give some context for errors.  */
@@ -365,11 +370,7 @@ static int saved_stabs_index;
 /* Save a stabs string.  */
 
 static void
-save_stab (type, desc, value, string)
-     int type;
-     int desc;
-     bfd_vma value;
-     const char *string;
+save_stab (int type, int desc, bfd_vma value, const char *string)
 {
   if (saved_stabs[saved_stabs_index].string != NULL)
     free (saved_stabs[saved_stabs_index].string);
@@ -383,11 +384,11 @@ save_stab (type, desc, value, string)
 /* Provide context for an error.  */
 
 static void
-stab_context ()
+stab_context (void)
 {
   int i;
 
-  fprintf (stderr, "Last stabs entries before error:\n");
+  fprintf (stderr, _("Last stabs entries before error:\n"));
   fprintf (stderr, "n_type n_desc n_value  string\n");
 
   i = saved_stabs_index;
@@ -421,12 +422,18 @@ stab_context ()
 /* Free the saved stab strings.  */
 
 static void
-free_saved_stabs ()
+free_saved_stabs (void)
 {
   int i;
 
   for (i = 0; i < SAVE_STABS_COUNT; i++)
-    if (saved_stabs[i].string != NULL)
-      free (saved_stabs[i].string);
+    {
+      if (saved_stabs[i].string != NULL)
+	{
+	  free (saved_stabs[i].string);
+	  saved_stabs[i].string = NULL;
+	}
+    }
+
   saved_stabs_index = 0;
 }