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 ! <> 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); } /*