diff options
Diffstat (limited to 'binutils-2.23.2-dwz-alt-debuginfo.patch')
| -rw-r--r-- | binutils-2.23.2-dwz-alt-debuginfo.patch | 610 |
1 files changed, 610 insertions, 0 deletions
diff --git a/binutils-2.23.2-dwz-alt-debuginfo.patch b/binutils-2.23.2-dwz-alt-debuginfo.patch new file mode 100644 index 0000000..18605a6 --- /dev/null +++ b/binutils-2.23.2-dwz-alt-debuginfo.patch @@ -0,0 +1,610 @@ +diff -rcp ../binutils-2.23.2.orig/bfd/bfd-in2.h bfd/bfd-in2.h +*** ../binutils-2.23.2.orig/bfd/bfd-in2.h 2013-05-29 15:56:00.512051112 +0100 +--- bfd/bfd-in2.h 2013-05-29 15:58:54.994055949 +0100 +*************** void *bfd_zalloc (bfd *abfd, bfd_size_ty +*** 1042,1049 **** +--- 1042,1053 ---- + unsigned long bfd_calc_gnu_debuglink_crc32 + (unsigned long crc, const unsigned char *buf, bfd_size_type len); + ++ char *bfd_get_alt_debug_link_info (bfd *abfd, unsigned long *crc32_out); ++ + char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); + ++ char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir); ++ + struct bfd_section *bfd_create_gnu_debuglink_section + (bfd *abfd, const char *filename); + +diff -rcp ../binutils-2.23.2.orig/bfd/dwarf2.c bfd/dwarf2.c +*** ../binutils-2.23.2.orig/bfd/dwarf2.c 2013-05-29 15:56:00.296051106 +0100 +--- bfd/dwarf2.c 2013-05-29 16:00:03.490057848 +0100 +*************** struct dwarf2_debug +*** 108,113 **** +--- 108,123 ---- + asection *sec; + bfd_byte *sec_info_ptr; + ++ /* Support for alternate debug info sections created by the DWZ utility: ++ This includes a pointer to an alternate bfd which contains *extra*, ++ possibly duplicate debug sections, and pointers to the loaded ++ .debug_str and .debug_info sections from this bfd. */ ++ bfd * alt_bfd_ptr; ++ bfd_byte * alt_dwarf_str_buffer; ++ bfd_size_type alt_dwarf_str_size; ++ bfd_byte * alt_dwarf_info_buffer; ++ bfd_size_type alt_dwarf_info_size; ++ + /* A pointer to the memory block allocated for info_ptr. Neither + info_ptr nor sec_info_ptr are guaranteed to stay pointing to the + beginning of the malloc block. This is used only to free the +*************** const struct dwarf_debug_section dwarf_d +*** 287,292 **** +--- 297,303 ---- + { ".debug_aranges", ".zdebug_aranges" }, + { ".debug_frame", ".zdebug_frame" }, + { ".debug_info", ".zdebug_info" }, ++ { ".debug_info", ".zdebug_info" }, + { ".debug_line", ".zdebug_line" }, + { ".debug_loc", ".zdebug_loc" }, + { ".debug_macinfo", ".zdebug_macinfo" }, +*************** const struct dwarf_debug_section dwarf_d +*** 297,302 **** +--- 308,314 ---- + { ".debug_static_func", ".zdebug_static_func" }, + { ".debug_static_vars", ".zdebug_static_vars" }, + { ".debug_str", ".zdebug_str", }, ++ { ".debug_str", ".zdebug_str", }, + { ".debug_types", ".zdebug_types" }, + /* GNU DWARF 1 extensions */ + { ".debug_sfnames", ".zdebug_sfnames" }, +*************** const struct dwarf_debug_section dwarf_d +*** 309,320 **** +--- 321,335 ---- + { NULL, NULL }, + }; + ++ /* NB/ Numbers in this enum must match up with indicies ++ into the dwarf_debug_sections[] array above. */ + enum dwarf_debug_section_enum + { + debug_abbrev = 0, + debug_aranges, + debug_frame, + debug_info, ++ debug_info_alt, + debug_line, + debug_loc, + debug_macinfo, +*************** enum dwarf_debug_section_enum +*** 325,330 **** +--- 340,346 ---- + debug_static_func, + debug_static_vars, + debug_str, ++ debug_str_alt, + debug_types, + debug_sfnames, + debug_srcinfo, +*************** read_section (bfd * abfd, +*** 481,488 **** + asection *msec; + const char *section_name = sec->uncompressed_name; + +! /* read_section is a noop if the section has already been read. */ +! if (!*section_buffer) + { + msec = bfd_get_section_by_name (abfd, section_name); + if (! msec) +--- 497,504 ---- + asection *msec; + const char *section_name = sec->uncompressed_name; + +! /* The section may have already been read. */ +! if (*section_buffer == NULL) + { + msec = bfd_get_section_by_name (abfd, section_name); + if (! msec) +*************** read_indirect_string (struct comp_unit * +*** 623,628 **** +--- 639,742 ---- + return str; + } + ++ /* Like read_indirect_string but uses a .debug_str located in ++ an alternate filepointed to by the .gnu_debuglink section. ++ Used to impement DW_FORM_GNU_strp_alt. */ ++ ++ static char * ++ read_alt_indirect_string (struct comp_unit * unit, ++ bfd_byte * buf, ++ unsigned int * bytes_read_ptr) ++ { ++ bfd_uint64_t offset; ++ struct dwarf2_debug *stash = unit->stash; ++ char *str; ++ ++ if (unit->offset_size == 4) ++ offset = read_4_bytes (unit->abfd, buf); ++ else ++ offset = read_8_bytes (unit->abfd, buf); ++ ++ *bytes_read_ptr = unit->offset_size; ++ ++ if (stash->alt_bfd_ptr == NULL) ++ { ++ bfd * debug_bfd; ++ char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR); ++ ++ if (debug_filename == NULL) ++ return NULL; ++ ++ if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL ++ || ! bfd_check_format (debug_bfd, bfd_object)) ++ { ++ if (debug_bfd) ++ bfd_close (debug_bfd); ++ ++ /* FIXME: Should we report our failure to follow the debuglink ? */ ++ free (debug_filename); ++ return NULL; ++ } ++ stash->alt_bfd_ptr = debug_bfd; ++ } ++ ++ if (! read_section (unit->stash->alt_bfd_ptr, ++ stash->debug_sections + debug_str_alt, ++ NULL, /* FIXME: Do we need to load alternate symbols ? */ ++ offset, ++ &stash->alt_dwarf_str_buffer, ++ &stash->alt_dwarf_str_size)) ++ return NULL; ++ ++ str = (char *) stash->alt_dwarf_str_buffer + offset; ++ if (*str == '\0') ++ return NULL; ++ ++ return str; ++ } ++ ++ /* Resolve an alternate reference from UNIT at OFFSET. ++ Returns a pointer into the loaded alternate CU upon success ++ or NULL upon failure. */ ++ ++ static bfd_byte * ++ read_alt_indirect_ref (struct comp_unit * unit, ++ bfd_uint64_t offset) ++ { ++ struct dwarf2_debug *stash = unit->stash; ++ ++ if (stash->alt_bfd_ptr == NULL) ++ { ++ bfd * debug_bfd; ++ char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR); ++ ++ if (debug_filename == NULL) ++ return FALSE; ++ ++ if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL ++ || ! bfd_check_format (debug_bfd, bfd_object)) ++ { ++ if (debug_bfd) ++ bfd_close (debug_bfd); ++ ++ /* FIXME: Should we report our failure to follow the debuglink ? */ ++ free (debug_filename); ++ return NULL; ++ } ++ stash->alt_bfd_ptr = debug_bfd; ++ } ++ ++ if (! read_section (unit->stash->alt_bfd_ptr, ++ stash->debug_sections + debug_info_alt, ++ NULL, /* FIXME: Do we need to load alternate symbols ? */ ++ offset, ++ &stash->alt_dwarf_info_buffer, ++ &stash->alt_dwarf_info_size)) ++ return NULL; ++ ++ return stash->alt_dwarf_info_buffer + offset; ++ } ++ + static bfd_uint64_t + read_address (struct comp_unit *unit, bfd_byte *buf) + { +*************** read_attribute_value (struct attribute * +*** 826,831 **** +--- 940,946 ---- + attr->u.val = read_address (unit, info_ptr); + info_ptr += unit->addr_size; + break; ++ case DW_FORM_GNU_ref_alt: + case DW_FORM_sec_offset: + if (unit->offset_size == 4) + attr->u.val = read_4_bytes (unit->abfd, info_ptr); +*************** read_attribute_value (struct attribute * +*** 875,880 **** +--- 990,999 ---- + attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read); + info_ptr += bytes_read; + break; ++ case DW_FORM_GNU_strp_alt: ++ attr->u.str = read_alt_indirect_string (unit, info_ptr, &bytes_read); ++ info_ptr += bytes_read; ++ break; + case DW_FORM_exprloc: + case DW_FORM_block: + amt = sizeof (struct dwarf_block); +*************** find_abstract_instance_name (struct comp +*** 2006,2011 **** +--- 2125,2141 ---- + + info_ptr = unit->sec_info_ptr + die_ref; + } ++ else if (attr_ptr->form == DW_FORM_GNU_ref_alt) ++ { ++ info_ptr = read_alt_indirect_ref (unit, die_ref); ++ if (info_ptr == NULL) ++ { ++ (*_bfd_error_handler) ++ (_("Dwarf Error: Unable to read alt ref %u."), die_ref); ++ bfd_set_error (bfd_error_bad_value); ++ return name; ++ } ++ } + else + info_ptr = unit->info_ptr_unit + die_ref; + abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); +*************** _bfd_dwarf2_cleanup_debug_info (bfd *abf +*** 3720,3723 **** +--- 3850,3859 ---- + free (stash->dwarf_ranges_buffer); + if (stash->info_ptr_memory) + free (stash->info_ptr_memory); ++ if (stash->alt_dwarf_str_buffer) ++ free (stash->alt_dwarf_str_buffer); ++ if (stash->alt_dwarf_info_buffer) ++ free (stash->alt_dwarf_info_buffer); ++ if (stash->alt_bfd_ptr) ++ bfd_close (stash->alt_bfd_ptr); + } +diff -rcp ../binutils-2.23.2.orig/bfd/opncls.c bfd/opncls.c +*** ../binutils-2.23.2.orig/bfd/opncls.c 2013-05-29 15:55:59.990051098 +0100 +--- bfd/opncls.c 2013-05-29 16:01:00.052059415 +0100 +*************** bfd_release (bfd *abfd, void *block) +*** 1056,1065 **** + + This facilitates "optional" provision of debugging information, without + having to provide two complete copies of every binary object (with and +! without debug symbols). +! */ + +- #define GNU_DEBUGLINK ".gnu_debuglink" + /* + FUNCTION + bfd_calc_gnu_debuglink_crc32 +--- 1056,1066 ---- + + This facilitates "optional" provision of debugging information, without + having to provide two complete copies of every binary object (with and +! without debug symbols). */ +! +! #define GNU_DEBUGLINK ".gnu_debuglink" +! #define GNU_DEBUGALTLINK ".gnu_debugaltlink" + + /* + FUNCTION + bfd_calc_gnu_debuglink_crc32 +*************** get_debug_link_info (bfd *abfd, unsigned +*** 1195,1200 **** +--- 1196,1249 ---- + } + + /* ++ FUNCTION ++ bfd_get_alt_debug_link_info ++ ++ SYNOPSIS ++ char *bfd_get_alt_debug_link_info (bfd *abfd, unsigned long *crc32_out); ++ ++ DESCRIPTION ++ Fetch the filename and BuildID value for any alternate debuginfo ++ associated with @var{abfd}. Return NULL if no such info found, ++ otherwise return filename and update @var{buildid_out}. The ++ returned filename is allocated with @code{malloc}; freeing it ++ is the responsibility of the caller. ++ */ ++ ++ char * ++ bfd_get_alt_debug_link_info (bfd * abfd, unsigned long * buildid_out) ++ { ++ asection *sect; ++ bfd_byte *contents; ++ int buildid_offset; ++ char *name; ++ ++ BFD_ASSERT (abfd); ++ BFD_ASSERT (buildid_out); ++ ++ sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK); ++ ++ if (sect == NULL) ++ return NULL; ++ ++ if (!bfd_malloc_and_get_section (abfd, sect, & contents)) ++ { ++ if (contents != NULL) ++ free (contents); ++ return NULL; ++ } ++ ++ /* BuildID value is stored after the filename, aligned up to 4 bytes. */ ++ name = (char *) contents; ++ buildid_offset = strlen (name) + 1; ++ buildid_offset = (buildid_offset + 3) & ~3; ++ ++ * buildid_out = bfd_get_32 (abfd, contents + buildid_offset); ++ ++ return name; ++ } ++ ++ /* + INTERNAL_FUNCTION + separate_debug_file_exists + +*************** separate_debug_file_exists (const char * +*** 1229,1234 **** +--- 1278,1314 ---- + return crc == file_crc; + } + ++ /* ++ INTERNAL_FUNCTION ++ separate_alt_debug_file_exists ++ ++ SYNOPSIS ++ bfd_boolean separate_alt_debug_file_exists ++ (char *name, unsigned long crc32); ++ ++ DESCRIPTION ++ Checks to see if @var{name} is a file and if its BuildID ++ matches @var{buildid}. ++ */ ++ ++ static bfd_boolean ++ separate_alt_debug_file_exists (const char *name, ++ const unsigned long buildid ATTRIBUTE_UNUSED) ++ { ++ FILE *f; ++ ++ BFD_ASSERT (name); ++ ++ f = real_fopen (name, FOPEN_RB); ++ if (f == NULL) ++ return FALSE; ++ ++ /* FIXME: Add code to check buildid. */ ++ ++ fclose (f); ++ ++ return TRUE; ++ } + + /* + INTERNAL_FUNCTION +*************** SYNOPSIS +*** 1238,1253 **** + char *find_separate_debug_file (bfd *abfd); + + DESCRIPTION +! Searches @var{abfd} for a reference to separate debugging +! information, scans various locations in the filesystem, including +! the file tree rooted at @var{debug_file_directory}, and returns a +! filename of such debugging information if the file is found and has +! matching CRC32. Returns NULL if no reference to debugging file +! exists, or file cannot be found. + */ + + static char * +! find_separate_debug_file (bfd *abfd, const char *debug_file_directory) + { + char *base; + char *dir; +--- 1318,1341 ---- + char *find_separate_debug_file (bfd *abfd); + + DESCRIPTION +! Searches @var{abfd} for a section called @var{section_name} which +! is expected to contain a reference to a file containing separate +! debugging information. The function scans various locations in +! the filesystem, including the file tree rooted at +! @var{debug_file_directory}, and returns the first matching +! filename that it finds. If @var{check_crc} is TRUE then the +! contents of the file must also match the CRC value contained in +! @var{section_name}. Returns NULL if no valid file could be found. + */ + ++ typedef char * (* get_func_type) (bfd *, unsigned long *); ++ typedef bfd_boolean (* check_func_type) (const char *, const unsigned long); ++ + static char * +! find_separate_debug_file (bfd * abfd, +! const char * debug_file_directory, +! get_func_type get_func, +! check_func_type check_func) + { + char *base; + char *dir; +*************** find_separate_debug_file (bfd *abfd, con +*** 1268,1274 **** + return NULL; + } + +! base = get_debug_link_info (abfd, & crc32); + if (base == NULL) + return NULL; + +--- 1356,1362 ---- + return NULL; + } + +! base = get_func (abfd, & crc32); + if (base == NULL) + return NULL; + +*************** find_separate_debug_file (bfd *abfd, con +*** 1309,1345 **** + + strlen (base) + + 1); + if (debugfile == NULL) +! { +! free (base); +! free (dir); +! free (canon_dir); +! return NULL; +! } + + /* First try in the same directory as the original file: */ + strcpy (debugfile, dir); + strcat (debugfile, base); + +! if (separate_debug_file_exists (debugfile, crc32)) +! { +! free (base); +! free (dir); +! free (canon_dir); +! return debugfile; +! } + + /* Then try in a subdirectory called .debug. */ + strcpy (debugfile, dir); + strcat (debugfile, ".debug/"); + strcat (debugfile, base); + +! if (separate_debug_file_exists (debugfile, crc32)) +! { +! free (base); +! free (dir); +! free (canon_dir); +! return debugfile; +! } + + /* Then try in the global debug dir for Fedora libraries. */ + sprintf (debugfile, "%s%s%s", FEDORA_LIB_DEBUG_DIR, dir, base); +--- 1397,1418 ---- + + strlen (base) + + 1); + if (debugfile == NULL) +! goto found; /* Actually this returns NULL. */ + + /* First try in the same directory as the original file: */ + strcpy (debugfile, dir); + strcat (debugfile, base); + +! if (check_func (debugfile, crc32)) +! goto found; + + /* Then try in a subdirectory called .debug. */ + strcpy (debugfile, dir); + strcat (debugfile, ".debug/"); + strcat (debugfile, base); + +! if (check_func (debugfile, crc32)) +! goto found; + + /* Then try in the global debug dir for Fedora libraries. */ + sprintf (debugfile, "%s%s%s", FEDORA_LIB_DEBUG_DIR, dir, base); +*************** find_separate_debug_file (bfd *abfd, con +*** 1371,1389 **** + strcat (debugfile, canon_dir); + strcat (debugfile, base); + +! if (separate_debug_file_exists (debugfile, crc32)) +! { +! free (base); +! free (dir); +! free (canon_dir); +! return debugfile; +! } + + free (debugfile); + free (base); + free (dir); + free (canon_dir); +! return NULL; + } + + +--- 1444,1461 ---- + strcat (debugfile, canon_dir); + strcat (debugfile, base); + +! if (check_func (debugfile, crc32)) +! goto found; + ++ /* Failed to find the file. */ + free (debugfile); ++ debugfile = NULL; ++ ++ found: + free (base); + free (dir); + free (canon_dir); +! return debugfile; + } + + +*************** RETURNS +*** 1416,1422 **** + char * + bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) + { +! return find_separate_debug_file (abfd, dir); + } + + /* +--- 1488,1530 ---- + char * + bfd_follow_gnu_debuglink (bfd *abfd, const char *dir) + { +! return find_separate_debug_file (abfd, dir, +! get_debug_link_info, +! separate_debug_file_exists); +! } +! +! /* +! FUNCTION +! bfd_follow_gnu_debugaltlink +! +! SYNOPSIS +! char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir); +! +! DESCRIPTION +! +! Takes a BFD and searches it for a .gnu_debugaltlink section. If this +! section is found, it examines the section for the name of a file +! containing auxiliary debugging information. It then searches the +! filesystem for this file in a set of standard locations, including +! the directory tree rooted at @var{dir}, and if found returns the +! full filename. +! +! If @var{dir} is NULL, it will search a default path configured into +! libbfd at build time. [FIXME: This feature is not currently +! implemented]. +! +! RETURNS +! <<NULL>> on any errors or failure to locate the debug file, +! otherwise a pointer to a heap-allocated string containing the +! filename. The caller is responsible for freeing this string. +! */ +! +! char * +! bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir) +! { +! return find_separate_debug_file (abfd, dir, +! bfd_get_alt_debug_link_info, +! separate_alt_debug_file_exists); + } + + /* + |