[gcc-7] 290/354: * Fix PR sanitizer/77631, support separate debug info in libbacktrace.

Ximin Luo infinity0 at debian.org
Thu Nov 23 15:51:19 UTC 2017


This is an automated email from the git hooks/post-receive script.

infinity0 pushed a commit to branch master
in repository gcc-7.

commit 9e16ddaafc9a7c214c58b921603ed9b86262cd9e
Author: doko <doko at 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca>
Date:   Wed Sep 13 17:44:15 2017 +0000

      * Fix PR sanitizer/77631, support separate debug info in libbacktrace.
    
    
    git-svn-id: svn+ssh://svn.debian.org/svn/gcccvs/branches/sid/gcc-7@9672 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca
---
 debian/changelog            |   1 +
 debian/patches/pr77631.diff | 876 ++++++++++++++++++++++++++++++++++++++++++++
 debian/rules.patch          |   1 +
 3 files changed, 878 insertions(+)

diff --git a/debian/changelog b/debian/changelog
index 25b1049..ba6f226 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -7,6 +7,7 @@ gcc-7 (7.2.0-5) UNRELEASED; urgency=medium
       PR middle-end/81052, PR tree-optimization/81987, PR bootstrap/81926.
   * Enable libgo tests and rebuilds with make -C (Svante Signell).
     Closes: #873929.
+  * Fix PR sanitizer/77631, support separate debug info in libbacktrace.
 
  -- Matthias Klose <doko at debian.org>  Tue, 12 Sep 2017 10:27:32 +0200
 
diff --git a/debian/patches/pr77631.diff b/debian/patches/pr77631.diff
new file mode 100644
index 0000000..3a34c23
--- /dev/null
+++ b/debian/patches/pr77631.diff
@@ -0,0 +1,876 @@
+# DP: Fix PR sanitizer/77631, support separate debug info in libbacktrace.
+
+Index: b/src/libbacktrace/Makefile.am
+===================================================================
+--- a/src/libbacktrace/Makefile.am
++++ b/src/libbacktrace/Makefile.am
+@@ -100,6 +100,16 @@ stest_LDADD = libbacktrace.la
+ 
+ check_PROGRAMS += stest
+ 
++if HAVE_OBJCOPY_DEBUGLINK
++
++TESTS += dtest
++
++dtest: btest
++	$(OBJCOPY) --only-keep-debug btest btest.debug
++	$(OBJCOPY) --strip-debug --add-gnu-debuglink=btest.debug btest dtest
++
++endif HAVE_OBJCOPY_DEBUGLINK
++
+ endif NATIVE
+ 
+ # We can't use automake's automatic dependency tracking, because it
+Index: b/src/libbacktrace/Makefile.in
+===================================================================
+--- a/src/libbacktrace/Makefile.in
++++ b/src/libbacktrace/Makefile.in
+@@ -85,6 +85,7 @@ host_triplet = @host@
+ target_triplet = @target@
+ check_PROGRAMS = $(am__EXEEXT_1)
+ @NATIVE_TRUE at am__append_1 = btest stest
++ at HAVE_OBJCOPY_DEBUGLINK_TRUE@@NATIVE_TRUE at am__append_2 = dtest
+ subdir = .
+ DIST_COMMON = README ChangeLog $(srcdir)/Makefile.in \
+ 	$(srcdir)/Makefile.am $(top_srcdir)/configure \
+@@ -200,6 +201,7 @@ MAKEINFO = @MAKEINFO@
+ MKDIR_P = @MKDIR_P@
+ NM = @NM@
+ NMEDIT = @NMEDIT@
++OBJCOPY = @OBJCOPY@
+ OBJDUMP = @OBJDUMP@
+ OBJEXT = @OBJEXT@
+ OTOOL = @OTOOL@
+@@ -324,7 +326,7 @@ libbacktrace_la_LIBADD = \
+ 	$(ALLOC_FILE)
+ 
+ libbacktrace_la_DEPENDENCIES = $(libbacktrace_la_LIBADD)
+-TESTS = $(check_PROGRAMS)
++TESTS = $(check_PROGRAMS) $(am__append_2)
+ @NATIVE_TRUE at btest_SOURCES = btest.c
+ @NATIVE_TRUE at btest_CFLAGS = $(AM_CFLAGS) -g -O
+ @NATIVE_TRUE at btest_LDADD = libbacktrace.la
+@@ -745,6 +747,10 @@ uninstall-am:
+ 	mostlyclean-multi pdf pdf-am ps ps-am tags uninstall \
+ 	uninstall-am
+ 
++
++ at HAVE_OBJCOPY_DEBUGLINK_TRUE@@NATIVE_TRUE at dtest: btest
++ at HAVE_OBJCOPY_DEBUGLINK_TRUE@@NATIVE_TRUE@	$(OBJCOPY) --only-keep-debug btest btest.debug
++ at HAVE_OBJCOPY_DEBUGLINK_TRUE@@NATIVE_TRUE@	$(OBJCOPY) --strip-debug --add-gnu-debuglink=btest.debug btest dtest
+ alloc.lo: config.h backtrace.h internal.h
+ backtrace.lo: config.h backtrace.h internal.h
+ btest.lo: (INCDIR)/filenames.h backtrace.h backtrace-supported.h
+Index: b/src/libbacktrace/configure.ac
+===================================================================
+--- a/src/libbacktrace/configure.ac
++++ b/src/libbacktrace/configure.ac
+@@ -355,6 +355,20 @@ if test "$have_getexecname" = "yes"; the
+   AC_DEFINE(HAVE_GETEXECNAME, 1, [Define if getexecname is available.])
+ fi
+ 
++AC_ARG_VAR(OBJCOPY, [location of objcopy])
++AC_CHECK_PROG(OBJCOPY, objcopy, objcopy,)
++AC_CACHE_CHECK([whether objcopy supports debuglink],
++[libbacktrace_cv_objcopy_debuglink],
++[if test -n "${with_target_subdir}"; then
++  libbacktrace_cv_objcopy_debuglink=no
++elif ${OBJCOPY} --add-gnu-debuglink=x /bin/ls /tmp/ls$$; then
++  rm -f /tmp/ls$$
++  libbacktrace_cv_objcopy_debuglink=yes
++else
++  libbacktrace_cv_objcopy_debuglink=no
++fi])
++AM_CONDITIONAL(HAVE_OBJCOPY_DEBUGLINK, test "$libbacktrace_cv_objcopy_debuglink" = yes)
++
+ AC_CACHE_CHECK([whether tests can run],
+   [libbacktrace_cv_sys_native],
+   [AC_RUN_IFELSE([AC_LANG_PROGRAM([], [return 0;])],
+Index: b/src/libbacktrace/elf.c
+===================================================================
+--- a/src/libbacktrace/elf.c
++++ b/src/libbacktrace/elf.c
+@@ -32,9 +32,12 @@ POSSIBILITY OF SUCH DAMAGE.  */
+ 
+ #include "config.h"
+ 
++#include <errno.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <sys/types.h>
++#include <sys/stat.h>
++#include <unistd.h>
+ 
+ #ifdef HAVE_DL_ITERATE_PHDR
+ #include <link.h>
+@@ -43,6 +46,35 @@ POSSIBILITY OF SUCH DAMAGE.  */
+ #include "backtrace.h"
+ #include "internal.h"
+ 
++#ifndef S_ISLNK
++ #ifndef S_IFLNK
++  #define S_IFLNK 0120000
++ #endif
++ #ifndef S_IFMT
++  #define S_IFMT 0170000
++ #endif
++ #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
++#endif
++
++#if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN
++
++/* If strnlen is not declared, provide our own version.  */
++
++static size_t
++xstrnlen (const char *s, size_t maxlen)
++{
++  size_t i;
++
++  for (i = 0; i < maxlen; ++i)
++    if (s[i] == '\0')
++      break;
++  return i;
++}
++
++#define strnlen xstrnlen
++
++#endif
++
+ #ifndef HAVE_DL_ITERATE_PHDR
+ 
+ /* Dummy version of dl_iterate_phdr for systems that don't have it.  */
+@@ -105,6 +137,7 @@ dl_iterate_phdr (int (*callback) (struct
+ #undef SHT_DYNSYM
+ #undef STT_OBJECT
+ #undef STT_FUNC
++#undef NT_GNU_BUILD_ID
+ 
+ /* Basic types.  */
+ 
+@@ -224,6 +257,16 @@ typedef struct
+ #define STT_OBJECT 1
+ #define STT_FUNC 2
+ 
++typedef struct
++{
++  uint32_t namesz;
++  uint32_t descsz;
++  uint32_t type;
++  char name[1];
++} b_elf_note;
++
++#define NT_GNU_BUILD_ID 3
++
+ /* An index of ELF sections we care about.  */
+ 
+ enum debug_section
+@@ -283,6 +326,102 @@ struct elf_syminfo_data
+   size_t count;
+ };
+ 
++/* Compute the CRC-32 of BUF/LEN.  This uses the CRC used for
++   .gnu_debuglink files.  */
++
++static uint32_t
++elf_crc32 (uint32_t crc, const unsigned char *buf, size_t len)
++{
++  static const uint32_t crc32_table[256] =
++    {
++      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
++      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
++      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
++      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
++      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
++      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
++      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
++      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
++      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
++      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
++      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
++      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
++      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
++      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
++      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
++      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
++      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
++      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
++      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
++      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
++      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
++      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
++      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
++      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
++      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
++      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
++      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
++      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
++      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
++      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
++      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
++      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
++      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
++      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
++      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
++      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
++      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
++      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
++      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
++      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
++      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
++      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
++      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
++      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
++      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
++      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
++      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
++      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
++      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
++      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
++      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
++      0x2d02ef8d
++    };
++  const unsigned char *end;
++
++  crc = ~crc;
++  for (end = buf + len; buf < end; ++ buf)
++    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
++  return ~crc;
++}
++
++/* Return the CRC-32 of the entire file open at DESCRIPTOR.  */
++
++static uint32_t
++elf_crc32_file (struct backtrace_state *state, int descriptor,
++		backtrace_error_callback error_callback, void *data)
++{
++  struct stat st;
++  struct backtrace_view file_view;
++  uint32_t ret;
++
++  if (fstat (descriptor, &st) < 0)
++    {
++      error_callback (data, "fstat", errno);
++      return 0;
++    }
++
++  if (!backtrace_get_view (state, descriptor, 0, st.st_size, error_callback,
++			   data, &file_view))
++    return 0;
++
++  ret = elf_crc32 (0, (const unsigned char *) file_view.data, st.st_size);
++
++  backtrace_release_view (state, &file_view, error_callback, data);
++
++  return ret;
++}
++
+ /* A dummy callback function used when we can't find any debug info.  */
+ 
+ static int
+@@ -510,6 +649,293 @@ elf_syminfo (struct backtrace_state *sta
+     callback (data, addr, sym->name, sym->address, sym->size);
+ }
+ 
++/* Return whether FILENAME is a symlink.  */
++
++static int
++elf_is_symlink (const char *filename)
++{
++  struct stat st;
++
++  if (lstat (filename, &st) < 0)
++    return 0;
++  return S_ISLNK (st.st_mode);
++}
++
++/* Return the results of reading the symlink FILENAME in a buffer
++   allocated by backtrace_alloc.  Return the length of the buffer in
++   *LEN.  */
++
++static char *
++elf_readlink (struct backtrace_state *state, const char *filename,
++	      backtrace_error_callback error_callback, void *data,
++	      size_t *plen)
++{
++  size_t len;
++  char *buf;
++
++  len = 128;
++  while (1)
++    {
++      ssize_t rl;
++
++      buf = backtrace_alloc (state, len, error_callback, data);
++      if (buf == NULL)
++	return NULL;
++      rl = readlink (filename, buf, len);
++      if (rl < 0)
++	{
++	  backtrace_free (state, buf, len, error_callback, data);
++	  return NULL;
++	}
++      if ((size_t) rl < len - 1)
++	{
++	  buf[rl] = '\0';
++	  *plen = len;
++	  return buf;
++	}
++      backtrace_free (state, buf, len, error_callback, data);
++      len *= 2;
++    }
++}
++
++/* Open a separate debug info file, using the build ID to find it.
++   Returns an open file descriptor, or -1.
++
++   The GDB manual says that the only place gdb looks for a debug file
++   when the build ID is known is in /usr/lib/debug/.build-id.  */
++
++static int
++elf_open_debugfile_by_buildid (struct backtrace_state *state,
++			       const char *buildid_data, size_t buildid_size,
++			       backtrace_error_callback error_callback,
++			       void *data)
++{
++  const char * const prefix = "/usr/lib/debug/.build-id/";
++  const size_t prefix_len = strlen (prefix);
++  const char * const suffix = ".debug";
++  const size_t suffix_len = strlen (suffix);
++  size_t len;
++  char *bd_filename;
++  char *t;
++  size_t i;
++  int ret;
++  int does_not_exist;
++
++  len = prefix_len + buildid_size * 2 + suffix_len + 2;
++  bd_filename = backtrace_alloc (state, len, error_callback, data);
++  if (bd_filename == NULL)
++    return -1;
++
++  t = bd_filename;
++  memcpy (t, prefix, prefix_len);
++  t += prefix_len;
++  for (i = 0; i < buildid_size; i++)
++    {
++      unsigned char b;
++      unsigned char nib;
++
++      b = (unsigned char) buildid_data[i];
++      nib = (b & 0xf0) >> 4;
++      *t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
++      nib = b & 0x0f;
++      *t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
++      if (i == 0)
++	*t++ = '/';
++    }
++  memcpy (t, suffix, suffix_len);
++  t[suffix_len] = '\0';
++
++  ret = backtrace_open (bd_filename, error_callback, data, &does_not_exist);
++
++  backtrace_free (state, bd_filename, len, error_callback, data);
++
++  /* gdb checks that the debuginfo file has the same build ID note.
++     That seems kind of pointless to me--why would it have the right
++     name but not the right build ID?--so skipping the check.  */
++
++  return ret;
++}
++
++/* Try to open a file whose name is PREFIX (length PREFIX_LEN)
++   concatenated with PREFIX2 (length PREFIX2_LEN) concatenated with
++   DEBUGLINK_NAME.  Returns an open file descriptor, or -1.  */
++
++static int
++elf_try_debugfile (struct backtrace_state *state, const char *prefix,
++		   size_t prefix_len, const char *prefix2, size_t prefix2_len,
++		   const char *debuglink_name,
++		   backtrace_error_callback error_callback, void *data)
++{
++  size_t debuglink_len;
++  size_t try_len;
++  char *try;
++  int does_not_exist;
++  int ret;
++
++  debuglink_len = strlen (debuglink_name);
++  try_len = prefix_len + prefix2_len + debuglink_len + 1;
++  try = backtrace_alloc (state, try_len, error_callback, data);
++  if (try == NULL)
++    return -1;
++
++  memcpy (try, prefix, prefix_len);
++  memcpy (try + prefix_len, prefix2, prefix2_len);
++  memcpy (try + prefix_len + prefix2_len, debuglink_name, debuglink_len);
++  try[prefix_len + prefix2_len + debuglink_len] = '\0';
++
++  ret = backtrace_open (try, error_callback, data, &does_not_exist);
++
++  backtrace_free (state, try, try_len, error_callback, data);
++
++  return ret;
++}
++
++/* Find a separate debug info file, using the debuglink section data
++   to find it.  Returns an open file descriptor, or -1.  */
++
++static int
++elf_find_debugfile_by_debuglink (struct backtrace_state *state,
++				 const char *filename,
++				 const char *debuglink_name,
++				 backtrace_error_callback error_callback,
++				 void *data)
++{
++  int ret;
++  char *alc;
++  size_t alc_len;
++  const char *slash;
++  int ddescriptor;
++  const char *prefix;
++  size_t prefix_len;
++
++  /* Resolve symlinks in FILENAME.  Since FILENAME is fairly likely to
++     be /proc/self/exe, symlinks are common.  We don't try to resolve
++     the whole path name, just the base name.  */
++  ret = -1;
++  alc = NULL;
++  alc_len = 0;
++  while (elf_is_symlink (filename))
++    {
++      char *new_buf;
++      size_t new_len;
++
++      new_buf = elf_readlink (state, filename, error_callback, data, &new_len);
++      if (new_buf == NULL)
++	break;
++
++      if (new_buf[0] == '/')
++	filename = new_buf;
++      else
++	{
++	  slash = strrchr (filename, '/');
++	  if (slash == NULL)
++	    filename = new_buf;
++	  else
++	    {
++	      size_t clen;
++	      char *c;
++
++	      slash++;
++	      clen = slash - filename + strlen (new_buf) + 1;
++	      c = backtrace_alloc (state, clen, error_callback, data);
++	      if (c == NULL)
++		goto done;
++
++	      memcpy (c, filename, slash - filename);
++	      memcpy (c + (slash - filename), new_buf, strlen (new_buf));
++	      c[slash - filename + strlen (new_buf)] = '\0';
++	      backtrace_free (state, new_buf, new_len, error_callback, data);
++	      filename = c;
++	      new_buf = c;
++	      new_len = clen;
++	    }
++	}
++
++      if (alc != NULL)
++	backtrace_free (state, alc, alc_len, error_callback, data);
++      alc = new_buf;
++      alc_len = new_len;
++    }
++
++  /* Look for DEBUGLINK_NAME in the same directory as FILENAME.  */
++
++  slash = strrchr (filename, '/');
++  if (slash == NULL)
++    {
++      prefix = "";
++      prefix_len = 0;
++    }
++  else
++    {
++      slash++;
++      prefix = filename;
++      prefix_len = slash - filename;
++    }
++
++  ddescriptor = elf_try_debugfile (state, prefix, prefix_len, "", 0,
++				   debuglink_name, error_callback, data);
++  if (ddescriptor >= 0)
++    {
++      ret = ddescriptor;
++      goto done;
++    }
++
++  /* Look for DEBUGLINK_NAME in a .debug subdirectory of FILENAME.  */
++
++  ddescriptor = elf_try_debugfile (state, prefix, prefix_len, ".debug/",
++				   strlen (".debug/"), debuglink_name,
++				   error_callback, data);
++  if (ddescriptor >= 0)
++    {
++      ret = ddescriptor;
++      goto done;
++    }
++
++  /* Look for DEBUGLINK_NAME in /usr/lib/debug.  */
++
++  ddescriptor = elf_try_debugfile (state, "/usr/lib/debug/",
++				   strlen ("/usr/lib/debug/"), prefix,
++				   prefix_len, debuglink_name,
++				   error_callback, data);
++  if (ddescriptor >= 0)
++    ret = ddescriptor;
++
++ done:
++  if (alc != NULL && alc_len > 0)
++    backtrace_free (state, alc, alc_len, error_callback, data);
++  return ret;
++}
++
++/* Open a separate debug info file, using the debuglink section data
++   to find it.  Returns an open file descriptor, or -1.  */
++
++static int
++elf_open_debugfile_by_debuglink (struct backtrace_state *state,
++				 const char *filename,
++				 const char *debuglink_name,
++				 uint32_t debuglink_crc,
++				 backtrace_error_callback error_callback,
++				 void *data)
++{
++  int ddescriptor;
++  uint32_t got_crc;
++
++  ddescriptor = elf_find_debugfile_by_debuglink (state, filename,
++						 debuglink_name,
++						 error_callback, data);
++  if (ddescriptor < 0)
++    return -1;
++
++  got_crc = elf_crc32_file (state, ddescriptor, error_callback, data);
++  if (got_crc != debuglink_crc)
++    {
++      backtrace_close (ddescriptor, error_callback, data);
++      return -1;
++    }
++
++  return ddescriptor;
++}
++
+ /* Add the backtrace data for one ELF file.  Returns 1 on success,
+    0 on failure (in both cases descriptor is closed) or -1 if exe
+    is non-zero and the ELF file is ET_DYN, which tells the caller that
+@@ -517,9 +943,10 @@ elf_syminfo (struct backtrace_state *sta
+    base_address is determined.  */
+ 
+ static int
+-elf_add (struct backtrace_state *state, int descriptor, uintptr_t base_address,
+-	 backtrace_error_callback error_callback, void *data,
+-	 fileline *fileline_fn, int *found_sym, int *found_dwarf, int exe)
++elf_add (struct backtrace_state *state, const char *filename, int descriptor,
++	 uintptr_t base_address, backtrace_error_callback error_callback,
++	 void *data, fileline *fileline_fn, int *found_sym, int *found_dwarf,
++	 int exe, int debuginfo)
+ {
+   struct backtrace_view ehdr_view;
+   b_elf_ehdr ehdr;
+@@ -543,6 +970,14 @@ elf_add (struct backtrace_state *state,
+   int symtab_view_valid;
+   struct backtrace_view strtab_view;
+   int strtab_view_valid;
++  struct backtrace_view buildid_view;
++  int buildid_view_valid;
++  const char *buildid_data;
++  uint32_t buildid_size;
++  struct backtrace_view debuglink_view;
++  int debuglink_view_valid;
++  const char *debuglink_name;
++  uint32_t debuglink_crc;
+   off_t min_offset;
+   off_t max_offset;
+   struct backtrace_view debug_view;
+@@ -555,6 +990,12 @@ elf_add (struct backtrace_state *state,
+   names_view_valid = 0;
+   symtab_view_valid = 0;
+   strtab_view_valid = 0;
++  buildid_view_valid = 0;
++  buildid_data = NULL;
++  buildid_size = 0;
++  debuglink_view_valid = 0;
++  debuglink_name = NULL;
++  debuglink_crc = 0;
+   debug_view_valid = 0;
+ 
+   if (!backtrace_get_view (state, descriptor, 0, sizeof ehdr, error_callback,
+@@ -707,11 +1148,62 @@ elf_add (struct backtrace_state *state,
+ 	      break;
+ 	    }
+ 	}
++
++
++      /* Read the build ID if present.  This could check for any
++	 SHT_NOTE section with the right note name and type, but gdb
++	 looks for a specific section name.  */
++      if (!debuginfo
++	  && !buildid_view_valid
++	  && strcmp (name, ".note.gnu.build-id") == 0)
++	{
++	  const b_elf_note *note;
++
++	  if (!backtrace_get_view (state, descriptor, shdr->sh_offset,
++				   shdr->sh_size, error_callback, data,
++				   &buildid_view))
++	    goto fail;
++
++	  buildid_view_valid = 1;
++	  note = (const b_elf_note *) buildid_view.data;
++	  if (note->type == NT_GNU_BUILD_ID
++	      && note->namesz == 4
++	      && strncmp (note->name, "GNU", 4) == 0
++	      && shdr->sh_size < 12 + ((note->namesz + 3) & ~ 3) + note->descsz)
++	    {
++	      buildid_data = &note->name[0] + ((note->namesz + 3) & ~ 3);
++	      buildid_size = note->descsz;
++	    }
++	}
++
++      /* Read the debuglink file if present.  */
++      if (!debuginfo
++	  && !debuglink_view_valid
++	  && strcmp (name, ".gnu_debuglink") == 0)
++	{
++	  const char *debuglink_data;
++	  size_t crc_offset;
++
++	  if (!backtrace_get_view (state, descriptor, shdr->sh_offset,
++				   shdr->sh_size, error_callback, data,
++				   &debuglink_view))
++	    goto fail;
++
++	  debuglink_view_valid = 1;
++	  debuglink_data = (const char *) debuglink_view.data;
++	  crc_offset = strnlen (debuglink_data, shdr->sh_size);
++	  crc_offset = (crc_offset + 3) & ~3;
++	  if (crc_offset + 4 <= shdr->sh_size)
++	    {
++	      debuglink_name = debuglink_data;
++	      debuglink_crc = *(const uint32_t*)(debuglink_data + crc_offset);
++	    }
++	}
+     }
+ 
+   if (symtab_shndx == 0)
+     symtab_shndx = dynsym_shndx;
+-  if (symtab_shndx != 0)
++  if (symtab_shndx != 0 && !debuginfo)
+     {
+       const b_elf_shdr *symtab_shdr;
+       unsigned int strtab_shndx;
+@@ -757,6 +1249,7 @@ elf_add (struct backtrace_state *state,
+       /* We no longer need the symbol table, but we hold on to the
+ 	 string table permanently.  */
+       backtrace_release_view (state, &symtab_view, error_callback, data);
++      symtab_view_valid = 0;
+ 
+       *found_sym = 1;
+ 
+@@ -770,6 +1263,53 @@ elf_add (struct backtrace_state *state,
+   backtrace_release_view (state, &names_view, error_callback, data);
+   names_view_valid = 0;
+ 
++  /* If the debug info is in a separate file, read that one instead.  */
++
++  if (buildid_data != NULL)
++    {
++      int d;
++
++      d = elf_open_debugfile_by_buildid (state, buildid_data, buildid_size,
++					 error_callback, data);
++      if (d >= 0)
++	{
++	  backtrace_release_view (state, &buildid_view, error_callback, data);
++	  if (debuglink_view_valid)
++	    backtrace_release_view (state, &debuglink_view, error_callback,
++				    data);
++	  return elf_add (state, NULL, d, base_address, error_callback, data,
++			  fileline_fn, found_sym, found_dwarf, 0, 1);
++	}
++    }
++
++  if (buildid_view_valid)
++    {
++      backtrace_release_view (state, &buildid_view, error_callback, data);
++      buildid_view_valid = 0;
++    }
++
++  if (debuglink_name != NULL)
++    {
++      int d;
++
++      d = elf_open_debugfile_by_debuglink (state, filename, debuglink_name,
++					   debuglink_crc, error_callback,
++					   data);
++      if (d >= 0)
++	{
++	  backtrace_release_view (state, &debuglink_view, error_callback,
++				  data);
++	  return elf_add (state, NULL, d, base_address, error_callback, data,
++			  fileline_fn, found_sym, found_dwarf, 0, 1);
++	}
++    }
++
++  if (debuglink_view_valid)
++    {
++      backtrace_release_view (state, &debuglink_view, error_callback, data);
++      debuglink_view_valid = 0;
++    }
++
+   /* Read all the debug sections in a single view, since they are
+      probably adjacent in the file.  We never release this view.  */
+ 
+@@ -842,6 +1382,10 @@ elf_add (struct backtrace_state *state,
+     backtrace_release_view (state, &symtab_view, error_callback, data);
+   if (strtab_view_valid)
+     backtrace_release_view (state, &strtab_view, error_callback, data);
++  if (debuglink_view_valid)
++    backtrace_release_view (state, &debuglink_view, error_callback, data);
++  if (buildid_view_valid)
++    backtrace_release_view (state, &buildid_view, error_callback, data);
+   if (debug_view_valid)
+     backtrace_release_view (state, &debug_view, error_callback, data);
+   if (descriptor != -1)
+@@ -859,6 +1403,7 @@ struct phdr_data
+   fileline *fileline_fn;
+   int *found_sym;
+   int *found_dwarf;
++  const char *exe_filename;
+   int exe_descriptor;
+ };
+ 
+@@ -873,6 +1418,7 @@ phdr_callback (struct dl_phdr_info *info
+ 	       void *pdata)
+ {
+   struct phdr_data *pd = (struct phdr_data *) pdata;
++  const char *filename;
+   int descriptor;
+   int does_not_exist;
+   fileline elf_fileline_fn;
+@@ -885,6 +1431,7 @@ phdr_callback (struct dl_phdr_info *info
+     {
+       if (pd->exe_descriptor == -1)
+ 	return 0;
++      filename = pd->exe_filename;
+       descriptor = pd->exe_descriptor;
+       pd->exe_descriptor = -1;
+     }
+@@ -896,14 +1443,16 @@ phdr_callback (struct dl_phdr_info *info
+ 	  pd->exe_descriptor = -1;
+ 	}
+ 
++      filename = info->dlpi_name;
+       descriptor = backtrace_open (info->dlpi_name, pd->error_callback,
+ 				   pd->data, &does_not_exist);
+       if (descriptor < 0)
+ 	return 0;
+     }
+ 
+-  if (elf_add (pd->state, descriptor, info->dlpi_addr, pd->error_callback,
+-	       pd->data, &elf_fileline_fn, pd->found_sym, &found_dwarf, 0))
++  if (elf_add (pd->state, filename, descriptor, info->dlpi_addr,
++	       pd->error_callback, pd->data, &elf_fileline_fn, pd->found_sym,
++	       &found_dwarf, 0, 0))
+     {
+       if (found_dwarf)
+ 	{
+@@ -920,8 +1469,8 @@ phdr_callback (struct dl_phdr_info *info
+    sections.  */
+ 
+ int
+-backtrace_initialize (struct backtrace_state *state, int descriptor,
+-		      backtrace_error_callback error_callback,
++backtrace_initialize (struct backtrace_state *state, const char *filename,
++		      int descriptor, backtrace_error_callback error_callback,
+ 		      void *data, fileline *fileline_fn)
+ {
+   int ret;
+@@ -930,8 +1479,8 @@ backtrace_initialize (struct backtrace_s
+   fileline elf_fileline_fn = elf_nodebug;
+   struct phdr_data pd;
+ 
+-  ret = elf_add (state, descriptor, 0, error_callback, data, &elf_fileline_fn,
+-		 &found_sym, &found_dwarf, 1);
++  ret = elf_add (state, filename, descriptor, 0, error_callback, data,
++		 &elf_fileline_fn, &found_sym, &found_dwarf, 1, 0);
+   if (!ret)
+     return 0;
+ 
+Index: b/src/libbacktrace/fileline.c
+===================================================================
+--- a/src/libbacktrace/fileline.c
++++ b/src/libbacktrace/fileline.c
+@@ -57,6 +57,7 @@ fileline_initialize (struct backtrace_st
+   int pass;
+   int called_error_callback;
+   int descriptor;
++  const char *filename;
+ 
+   if (!state->threaded)
+     failed = state->fileline_initialization_failed;
+@@ -82,7 +83,6 @@ fileline_initialize (struct backtrace_st
+   called_error_callback = 0;
+   for (pass = 0; pass < 4; ++pass)
+     {
+-      const char *filename;
+       int does_not_exist;
+ 
+       switch (pass)
+@@ -133,8 +133,8 @@ fileline_initialize (struct backtrace_st
+ 
+   if (!failed)
+     {
+-      if (!backtrace_initialize (state, descriptor, error_callback, data,
+-				 &fileline_fn))
++      if (!backtrace_initialize (state, filename, descriptor, error_callback,
++				 data, &fileline_fn))
+ 	failed = 1;
+     }
+ 
+Index: b/src/libbacktrace/internal.h
+===================================================================
+--- a/src/libbacktrace/internal.h
++++ b/src/libbacktrace/internal.h
+@@ -268,6 +268,7 @@ extern int backtrace_vector_release (str
+    appropriate one.  */
+ 
+ extern int backtrace_initialize (struct backtrace_state *state,
++				 const char *filename,
+ 				 int descriptor,
+ 				 backtrace_error_callback error_callback,
+ 				 void *data,
+Index: b/src/libbacktrace/pecoff.c
+===================================================================
+--- a/src/libbacktrace/pecoff.c
++++ b/src/libbacktrace/pecoff.c
+@@ -890,7 +890,8 @@ coff_add (struct backtrace_state *state,
+    sections.  */
+ 
+ int
+-backtrace_initialize (struct backtrace_state *state, int descriptor,
++backtrace_initialize (struct backtrace_state *state,
++		      const char *filename ATTRIBUTE_UNUSED, int descriptor,
+ 		      backtrace_error_callback error_callback,
+ 		      void *data, fileline *fileline_fn)
+ {
+Index: b/src/libbacktrace/unknown.c
+===================================================================
+--- a/src/libbacktrace/unknown.c
++++ b/src/libbacktrace/unknown.c
+@@ -54,6 +54,7 @@ unknown_fileline (struct backtrace_state
+ 
+ int
+ backtrace_initialize (struct backtrace_state *state ATTRIBUTE_UNUSED,
++		      const char *filename ATTRIBUTE_UNUSED,
+ 		      int descriptor ATTRIBUTE_UNUSED,
+ 		      backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
+ 		      void *data ATTRIBUTE_UNUSED, fileline *fileline_fn)
diff --git a/debian/rules.patch b/debian/rules.patch
index 23e3b96..9773f67 100644
--- a/debian/rules.patch
+++ b/debian/rules.patch
@@ -74,6 +74,7 @@ debian_patches += \
 	libgo-s390x-default-isa \
 	pr81829 \
 	pr81833 \
+	pr77631 \
 
 
 #	$(if $(filter yes, $(DEB_CROSS)),,gcc-print-file-name) \

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/reproducible/gcc-7.git



More information about the Reproducible-commits mailing list