[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 = ¬e->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