From 9f1112653610d4bd4179bec2d324e094df10a4fa Mon Sep 17 00:00:00 2001 From: roland Date: Jul 16 2007 07:15:30 +0000 Subject: ld --build-id support --- diff --git a/binutils-2.17.50.0.17-build-id.patch b/binutils-2.17.50.0.17-build-id.patch new file mode 100644 index 0000000..cbc3e5f --- /dev/null +++ b/binutils-2.17.50.0.17-build-id.patch @@ -0,0 +1,1098 @@ +Index: include/elf/common.h +=================================================================== +RCS file: /cvs/src/src/include/elf/common.h,v +retrieving revision 1.85 +retrieving revision 1.86 +diff -b -u -r1.85 -r1.86 +--- include/elf/common.h 29 Jun 2007 16:29:16 -0000 1.85 ++++ include/elf/common.h 9 Jul 2007 21:17:42 -0000 1.86 +@@ -413,9 +413,13 @@ + #define NT_VERSION 1 /* Contains a version string. */ + #define NT_ARCH 2 /* Contains an architecture string. */ + +-/* Values for GNU .note.ABI-tag notes. Note name is "GNU". */ ++/* Values for notes in non-core files using name "GNU". */ + + #define NT_GNU_ABI_TAG 1 ++#define NT_GNU_HWCAP 2 /* Used by ld.so and kernel vDSO. */ ++#define NT_GNU_BUILD_ID 3 /* Generated by ld --build-id. */ ++ ++/* Values used in GNU .note.ABI-tag notes (NT_GNU_ABI_TAG). */ + #define GNU_ABI_TAG_LINUX 0 + #define GNU_ABI_TAG_HURD 1 + #define GNU_ABI_TAG_SOLARIS 2 +Index: binutils/readelf.c +=================================================================== +RCS file: /cvs/src/src/binutils/readelf.c,v +retrieving revision 1.369 +retrieving revision 1.370 +diff -b -u -r1.369 -r1.370 +--- binutils/readelf.c 5 Jul 2007 16:54:45 -0000 1.369 ++++ binutils/readelf.c 9 Jul 2007 21:19:51 -0000 1.370 +@@ -9128,6 +9128,27 @@ + } + + static const char * ++get_gnu_elf_note_type (unsigned e_type) ++{ ++ static char buff[64]; ++ ++ switch (e_type) ++ { ++ case NT_GNU_ABI_TAG: ++ return _("NT_GNU_ABI_TAG (ABI version tag)"); ++ case NT_GNU_HWCAP: ++ return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)"); ++ case NT_GNU_BUILD_ID: ++ return _("NT_GNU_BUILD_ID (unique build ID bitstring)"); ++ default: ++ break; ++ } ++ ++ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type); ++ return buff; ++} ++ ++static const char * + get_netbsd_elfcore_note_type (unsigned e_type) + { + static char buff[64]; +@@ -9204,6 +9225,10 @@ + note type strings. */ + nt = get_note_type (pnote->type); + ++ else if (const_strneq (pnote->namedata, "GNU")) ++ /* GNU-specific object file notes. */ ++ nt = get_gnu_elf_note_type (pnote->type); ++ + else if (const_strneq (pnote->namedata, "NetBSD-CORE")) + /* NetBSD-specific core file notes. */ + nt = get_netbsd_elfcore_note_type (pnote->type); +Index: include/bfdlink.h +=================================================================== +RCS file: /cvs/src/src/include/bfdlink.h,v +retrieving revision 1.69 +retrieving revision 1.70 +diff -b -u -r1.69 -r1.70 +--- include/bfdlink.h 6 Jul 2007 11:13:56 -0000 1.69 ++++ include/bfdlink.h 9 Jul 2007 21:21:42 -0000 1.70 +@@ -348,6 +348,9 @@ + --dynamic-list command line options. */ + unsigned int dynamic: 1; + ++ /* Non-NULL if .note.gnu.build-id section should be created. */ ++ char *emit_note_gnu_build_id; ++ + /* What to do with unresolved symbols in an object file. + When producing executables the default is GENERATE_ERROR. + When producing shared libraries the default is IGNORE. The +Index: bfd/elf-bfd.h +=================================================================== +RCS file: /cvs/src/src/bfd/elf-bfd.h,v +retrieving revision 1.235 +retrieving revision 1.237 +diff -b -u -r1.235 -r1.237 +--- bfd/elf-bfd.h 3 Jul 2007 14:26:40 -0000 1.235 ++++ bfd/elf-bfd.h 13 Jul 2007 10:44:12 -0000 1.237 +@@ -447,6 +447,8 @@ struct elf_size_info { + (bfd *, const Elf_Internal_Phdr *, unsigned int); + bfd_boolean + (*write_shdrs_and_ehdr) (bfd *); ++ bfd_boolean (*checksum_contents) ++ (bfd * , void (*) (const void *, size_t, void *), void *); + void (*write_relocs) + (bfd *, asection *, void *); + bfd_boolean (*swap_symbol_in) +@@ -1406,6 +1408,10 @@ struct elf_obj_tdata + + /* Symbol buffer. */ + void *symbuf; ++ ++ /* Called at the end of _bfd_elf_write_object_contents if not NULL. */ ++ bfd_boolean (*after_write_object_contents) (bfd *); ++ void *after_write_object_contents_info; + }; + + #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data) +@@ -1803,6 +1809,8 @@ extern bfd_boolean bfd_elf32_write_shdrs + (bfd *); + extern int bfd_elf32_write_out_phdrs + (bfd *, const Elf_Internal_Phdr *, unsigned int); ++extern bfd_boolean bfd_elf32_checksum_contents ++ (bfd * , void (*) (const void *, size_t, void *), void *); + extern void bfd_elf32_write_relocs + (bfd *, asection *, void *); + extern bfd_boolean bfd_elf32_slurp_reloc_table +@@ -1845,6 +1853,8 @@ extern bfd_boolean bfd_elf64_write_shdrs + (bfd *); + extern int bfd_elf64_write_out_phdrs + (bfd *, const Elf_Internal_Phdr *, unsigned int); ++extern bfd_boolean bfd_elf64_checksum_contents ++ (bfd * , void (*) (const void *, size_t, void *), void *); + extern void bfd_elf64_write_relocs + (bfd *, asection *, void *); + extern bfd_boolean bfd_elf64_slurp_reloc_table +Index: bfd/elf.c +=================================================================== +RCS file: /cvs/src/src/bfd/elf.c,v +retrieving revision 1.396 +retrieving revision 1.398 +diff -b -u -r1.396 -r1.398 +--- bfd/elf.c 3 Jul 2007 14:26:40 -0000 1.396 ++++ bfd/elf.c 13 Jul 2007 10:44:12 -0000 1.398 +@@ -5124,7 +5125,14 @@ + (*bed->elf_backend_final_write_processing) (abfd, + elf_tdata (abfd)->linker); + +- return bed->s->write_shdrs_and_ehdr (abfd); ++ if (!bed->s->write_shdrs_and_ehdr (abfd)) ++ return FALSE; ++ ++ /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */ ++ if (elf_tdata (abfd)->after_write_object_contents) ++ return (*elf_tdata (abfd)->after_write_object_contents) (abfd); ++ ++ return TRUE; + } + + bfd_boolean +Index: bfd/elfcode.h +=================================================================== +RCS file: /cvs/src/src/bfd/elfcode.h,v +retrieving revision 1.83 +retrieving revision 1.84 +diff -b -u -r1.83 -r1.84 +--- bfd/elfcode.h 3 Jul 2007 14:26:42 -0000 1.83 ++++ bfd/elfcode.h 9 Jul 2007 21:23:37 -0000 1.84 +@@ -122,6 +122,7 @@ + #define elf_find_section NAME(bfd_elf,find_section) + #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr) + #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs) ++#define elf_checksum_contents NAME(bfd_elf,checksum_contents) + #define elf_write_relocs NAME(bfd_elf,write_relocs) + #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table) + +@@ -1105,6 +1106,53 @@ + return TRUE; + } + ++bfd_boolean ++elf_checksum_contents (bfd *abfd, ++ void (*process) (const void *, size_t, void *), ++ void *arg) ++{ ++ Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); ++ Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd); ++ Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr; ++ unsigned int count, num; ++ ++ { ++ Elf_External_Ehdr x_ehdr; ++ Elf_Internal_Ehdr i_ehdr; ++ ++ i_ehdr = *i_ehdrp; ++ i_ehdr.e_phoff = i_ehdr.e_shoff = 0; ++ elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr); ++ (*process) (&x_ehdr, sizeof x_ehdr, arg); ++ } ++ ++ num = i_ehdrp->e_phnum; ++ for (count = 0; count < num; count++) ++ { ++ Elf_External_Phdr x_phdr; ++ elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr); ++ (*process) (&x_phdr, sizeof x_phdr, arg); ++ } ++ ++ num = elf_numsections (abfd); ++ for (count = 0; count < num; count++) ++ { ++ Elf_Internal_Shdr i_shdr; ++ Elf_External_Shdr x_shdr; ++ ++ i_shdr = *i_shdrp[count]; ++ i_shdr.sh_offset = 0; ++ ++ elf_swap_shdr_out (abfd, &i_shdr, &x_shdr); ++ (*process) (&x_shdr, sizeof x_shdr, arg); ++ ++ if (i_shdr.contents) ++ (*process) (i_shdr.contents, i_shdr.sh_size, arg); ++ } ++ ++ return TRUE; ++} ++ + long + elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic) + { +@@ -1803,6 +1851,7 @@ + ELFCLASS, EV_CURRENT, + elf_write_out_phdrs, + elf_write_shdrs_and_ehdr, ++ elf_checksum_contents, + elf_write_relocs, + elf_swap_symbol_in, + elf_swap_symbol_out, +Index: ld/Makefile.in +=================================================================== +RCS file: /cvs/src/src/ld/Makefile.in,v +retrieving revision 1.259 +retrieving revision 1.260 +diff -b -u -r1.259 -r1.260 +--- ld/Makefile.in 2 Jul 2007 07:12:52 -0000 1.259 ++++ ld/Makefile.in 13 Jul 2007 10:44:28 -0000 1.260 +@@ -75,7 +75,7 @@ + ldlang.$(OBJEXT) mri.$(OBJEXT) ldctor.$(OBJEXT) \ + ldmain.$(OBJEXT) ldwrite.$(OBJEXT) ldexp.$(OBJEXT) \ + ldemul.$(OBJEXT) ldver.$(OBJEXT) ldmisc.$(OBJEXT) \ +- ldfile.$(OBJEXT) ldcref.$(OBJEXT) ++ ldfile.$(OBJEXT) ldcref.$(OBJEXT) sha1.$(OBJEXT) + ld_new_OBJECTS = $(am_ld_new_OBJECTS) + am__DEPENDENCIES_1 = + am__DEPENDENCIES_2 = ../bfd/libbfd.la +@@ -675,17 +675,17 @@ + + CFILES = ldctor.c ldemul.c ldexp.c ldfile.c ldlang.c \ + ldmain.c ldmisc.c ldver.c ldwrite.c lexsup.c \ +- mri.c ldcref.c pe-dll.c pep-dll.c ++ mri.c ldcref.c pe-dll.c pep-dll.c sha1.c + + HFILES = ld.h ldctor.h ldemul.h ldexp.h ldfile.h \ + ldlang.h ldlex.h ldmain.h ldmisc.h ldver.h \ +- ldwrite.h mri.h deffile.h pe-dll.h pep-dll.h elf-hints-local.h ++ ldwrite.h mri.h deffile.h pe-dll.h pep-dll.h elf-hints-local.h sha1.h + + GENERATED_CFILES = ldgram.c ldlex.c deffilep.c + GENERATED_HFILES = ldgram.h ldemul-list.h deffilep.h + OFILES = ldgram.o ldlex.o lexsup.o ldlang.o mri.o ldctor.o ldmain.o \ + ldwrite.o ldexp.o ldemul.o ldver.o ldmisc.o \ +- ldfile.o ldcref.o ${EMULATION_OFILES} ${EMUL_EXTRA_OFILES} ++ ldfile.o ldcref.o sha1.o ${EMULATION_OFILES} ${EMUL_EXTRA_OFILES} + + STAGESTUFF = *.o ldscripts/* e*.c + +@@ -703,7 +703,7 @@ + # We need this for automake to use YLWRAP. + EXTRA_ld_new_SOURCES = deffilep.y + ld_new_SOURCES = ldgram.y ldlex.l lexsup.c ldlang.c mri.c ldctor.c ldmain.c \ +- ldwrite.c ldexp.c ldemul.c ldver.c ldmisc.c ldfile.c ldcref.c ++ ldwrite.c ldexp.c ldemul.c ldver.c ldmisc.c ldfile.c ldcref.c sha1.c + + ld_new_DEPENDENCIES = $(EMULATION_OFILES) $(EMUL_EXTRA_OFILES) $(BFDLIB) $(LIBIBERTY) $(LIBINTL_DEP) + ld_new_LDADD = $(EMULATION_OFILES) $(EMUL_EXTRA_OFILES) $(BFDLIB) $(LIBIBERTY) $(LIBINTL) +@@ -2834,6 +2834,7 @@ + $(INCDIR)/libiberty.h $(INCDIR)/ansidecl.h $(INCDIR)/safe-ctype.h \ + ../bfd/bfd.h $(INCDIR)/ansidecl.h $(INCDIR)/symcat.h \ + ld.h ldmisc.h deffile.h ++sha1.o: sha1.c config.h sha1.h + # IF YOU PUT ANYTHING HERE IT WILL GO AWAY + # Tell versions [3.59,3.63) of GNU make to not export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. +Index: ld/emultempl/elf32.em +=================================================================== +RCS file: /cvs/src/src/ld/emultempl/elf32.em,v +retrieving revision 1.179 +retrieving revision 1.181 +diff -b -u -r1.179 -r1.181 +--- ld/emultempl/elf32.em 6 Jul 2007 14:09:42 -0000 1.179 ++++ ld/emultempl/elf32.em 13 Jul 2007 10:44:26 -0000 1.181 +@@ -41,6 +41,9 @@ + #include "libiberty.h" + #include "safe-ctype.h" + #include "getopt.h" ++#include "md5.h" ++#include "sha1.h" ++#include + + #include "bfdlink.h" + +@@ -859,6 +862,169 @@ + if test x"$LDEMUL_AFTER_OPEN" != xgld"$EMULATION_NAME"_after_open; then + cat >>e${EMULATION_NAME}.c <emit_note_gnu_build_id; ++ bfd_size_type size; ++ ++ abfd = abfd; ++ ++ size = offsetof (Elf_External_Note, name[sizeof "GNU"]); ++ size = (size + 3) & -(bfd_size_type) 4; ++ ++ if (!strcmp (style, "md5") || !strcmp (style, "uuid")) ++ size += 128 / 8; ++ else if (!strcmp (style, "sha1")) ++ size += 160 / 8; ++ else if (!strncmp (style, "0x", 2)) ++ { ++ /* ID is in string form (hex). Convert to bits. */ ++ const char *id = style + 2; ++ do ++ { ++ if (ISXDIGIT (id[0]) && ISXDIGIT (id[1])) ++ { ++ ++size; ++ id += 2; ++ } ++ else if (*id == '-' || *id == ':') ++ ++id; ++ else ++ { ++ size = 0; ++ break; ++ } ++ } while (*id != '\0'); ++ } ++ else ++ size = 0; ++ ++ return size; ++} ++ ++static unsigned char ++read_hex (const char xdigit) ++{ ++ if (ISDIGIT (xdigit)) ++ return xdigit - '0'; ++ if (ISUPPER (xdigit)) ++ return xdigit - 'A' + 0xa; ++ if (ISLOWER (xdigit)) ++ return xdigit - 'a' + 0xa; ++ abort (); ++ return 0; ++} ++ ++struct build_id_info ++{ ++ const char *style; ++ asection *sec; ++}; ++ ++static bfd_boolean ++gld${EMULATION_NAME}_write_build_id_section (bfd *abfd) ++{ ++ const struct elf_backend_data *bed = get_elf_backend_data (abfd); ++ struct build_id_info *info = ++ elf_tdata (abfd)->after_write_object_contents_info; ++ asection *asec; ++ Elf_Internal_Shdr *i_shdr; ++ unsigned char *contents, *id_bits; ++ bfd_size_type size; ++ Elf_External_Note *e_note; ++ ++ asec = info->sec; ++ if (asec->output_section == NULL) ++ { ++ einfo (_("%P: .note.gnu.build-id section missing")); ++ return FALSE; ++ } ++ i_shdr = &elf_section_data (asec->output_section)->this_hdr; ++ ++ if (i_shdr->contents == NULL) ++ { ++ ASSERT (asec->output_offset == 0); ++ i_shdr->contents = xcalloc (i_shdr->sh_size, 1); ++ if (i_shdr->contents == NULL) ++ return FALSE; ++ } ++ contents = i_shdr->contents + asec->output_offset; ++ ++ e_note = (void *) contents; ++ size = offsetof (Elf_External_Note, name[sizeof "GNU"]); ++ size = (size + 3) & -(bfd_size_type) 4; ++ id_bits = contents + size; ++ size = asec->size - size; ++ ++ bfd_h_put_32 (abfd, sizeof "GNU", &e_note->namesz); ++ bfd_h_put_32 (abfd, size, &e_note->descsz); ++ bfd_h_put_32 (abfd, NT_GNU_BUILD_ID, &e_note->type); ++ memcpy (e_note->name, "GNU", sizeof "GNU"); ++ ++ if (!strcmp (info->style, "md5")) ++ { ++ struct md5_ctx ctx; ++ md5_init_ctx (&ctx); ++ if (bed->s->checksum_contents (abfd, ++ (void (*) (const void *, size_t, void *)) ++ &md5_process_bytes, ++ &ctx)) ++ md5_finish_ctx (&ctx, id_bits); ++ else ++ return FALSE; ++ } ++ else if (!strcmp (info->style, "sha1")) ++ { ++ struct sha1_ctx ctx; ++ sha1_init_ctx (&ctx); ++ if (bed->s->checksum_contents (abfd, ++ (void (*) (const void *, size_t, void *)) ++ &sha1_process_bytes, ++ &ctx)) ++ sha1_finish_ctx (&ctx, id_bits); ++ else ++ return FALSE; ++ } ++ else if (!strcmp (info->style, "uuid")) ++ { ++ int n; ++ int fd = open ("/dev/urandom", O_RDONLY); ++ if (fd < 0) ++ return FALSE; ++ n = read (fd, id_bits, size); ++ close (fd); ++ if (n < (int) size) ++ return FALSE; ++ } ++ else if (!strncmp (info->style, "0x", 2)) ++ { ++ /* ID is in string form (hex). Convert to bits. */ ++ const char *id = info->style + 2; ++ size_t n = 0; ++ do ++ { ++ if (ISXDIGIT (id[0]) && ISXDIGIT (id[1])) ++ { ++ id_bits[n] = read_hex (*id++) << 4; ++ id_bits[n++] |= read_hex (*id++); ++ } ++ else if (*id == '-' || *id == ':') ++ ++id; ++ else ++ abort (); /* Should have been validated earlier. */ ++ } while (*id != '\0'); ++ } ++ else ++ abort (); /* Should have been validated earlier. */ ++ ++ size = i_shdr->sh_size; ++ return (bfd_seek (abfd, i_shdr->sh_offset, SEEK_SET) == 0 ++ && bfd_bwrite (i_shdr->contents, size, abfd) == size); ++} ++ ++ + /* This is called after all the input files have been opened. */ + + static void +@@ -866,6 +1032,49 @@ + { + struct bfd_link_needed_list *needed, *l; + ++ if (link_info.emit_note_gnu_build_id) ++ { ++ bfd *abfd; ++ asection *s; ++ bfd_size_type size; ++ ++ abfd = link_info.input_bfds; ++ ++ size = gld${EMULATION_NAME}_id_note_section_size (abfd, &link_info); ++ if (size == 0) ++ { ++ einfo ("%P: warning: unrecognized --build-id style ignored.\n"); ++ free (link_info.emit_note_gnu_build_id); ++ link_info.emit_note_gnu_build_id = NULL; ++ } ++ else ++ { ++ s = bfd_make_section_with_flags (abfd, ".note.gnu.build-id", ++ SEC_ALLOC | SEC_LOAD ++ | SEC_IN_MEMORY | SEC_LINKER_CREATED ++ | SEC_READONLY | SEC_DATA); ++ if (s != NULL && bfd_set_section_alignment (abfd, s, 2)) ++ { ++ struct elf_obj_tdata *t = elf_tdata (output_bfd); ++ struct build_id_info *b = xmalloc (sizeof *b); ++ b->style = link_info.emit_note_gnu_build_id; ++ b->sec = s; ++ elf_section_type (s) = SHT_NOTE; ++ s->size = size; ++ t->after_write_object_contents ++ = &gld${EMULATION_NAME}_write_build_id_section; ++ t->after_write_object_contents_info = b; ++ } ++ else ++ { ++ einfo ("%P: warning: Cannot create .note.gnu.build-id section," ++ " --build-id ignored.\n"); ++ free (link_info.emit_note_gnu_build_id); ++ link_info.emit_note_gnu_build_id = NULL; ++ } ++ } ++ } ++ + if (link_info.eh_frame_hdr + && ! link_info.traditional_format + && ! link_info.relocatable) +@@ -1760,6 +1969,7 @@ + #define OPTION_EH_FRAME_HDR (OPTION_GROUP + 1) + #define OPTION_EXCLUDE_LIBS (OPTION_EH_FRAME_HDR + 1) + #define OPTION_HASH_STYLE (OPTION_EXCLUDE_LIBS + 1) ++#define OPTION_BUILD_ID (OPTION_HASH_STYLE + 1) + + static void + gld${EMULATION_NAME}_add_options +@@ -1768,6 +1978,7 @@ + { + static const char xtra_short[] = "${PARSE_AND_LIST_SHORTOPTS}z:"; + static const struct option xtra_long[] = { ++ {"build-id", optional_argument, NULL, OPTION_BUILD_ID}, + EOF + + if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then +@@ -1798,6 +2009,8 @@ + memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long)); + } + ++#define DEFAULT_BUILD_ID_STYLE "sha1" ++ + static bfd_boolean + gld${EMULATION_NAME}_handle_option (int optc) + { +@@ -1806,6 +2019,18 @@ + default: + return FALSE; + ++ case OPTION_BUILD_ID: ++ if (link_info.emit_note_gnu_build_id != NULL) ++ { ++ free (link_info.emit_note_gnu_build_id); ++ link_info.emit_note_gnu_build_id = NULL; ++ } ++ if (optarg == NULL) ++ optarg = DEFAULT_BUILD_ID_STYLE; ++ if (strcmp (optarg, "none")) ++ link_info.emit_note_gnu_build_id = xstrdup (optarg); ++ break; ++ + EOF + + if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then +@@ -1959,6 +2184,7 @@ + static void + gld${EMULATION_NAME}_list_options (FILE * file) + { ++ fprintf (file, _(" --build-id[=STYLE]\tGenerate build ID note\n")); + EOF + + if test x"$GENERATE_SHLIB_SCRIPT" = xyes; then +Index: ld/sha1.c +=================================================================== +RCS file: ld/sha1.c +diff -N ld/sha1.c +--- /dev/null 1 Jan 1970 00:00:00 -0000 ++++ ld/sha1.c 13 Jul 2007 10:44:28 -0000 1.1 +@@ -0,0 +1,416 @@ ++/* sha1.c - Functions to compute SHA1 message digest of files or ++ memory blocks according to the NIST specification FIPS-180-1. ++ ++ Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006 Free Software ++ Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by the ++ Free Software Foundation; either version 2, or (at your option) any ++ later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++/* Written by Scott G. Miller ++ Credits: ++ Robert Klep -- Expansion function fix ++*/ ++ ++#include ++ ++#include "sha1.h" ++ ++#include ++#include ++ ++#if USE_UNLOCKED_IO ++# include "unlocked-io.h" ++#endif ++ ++#ifdef WORDS_BIGENDIAN ++# define SWAP(n) (n) ++#else ++# define SWAP(n) \ ++ (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) ++#endif ++ ++#define BLOCKSIZE 4096 ++#if BLOCKSIZE % 64 != 0 ++# error "invalid BLOCKSIZE" ++#endif ++ ++/* This array contains the bytes used to pad the buffer to the next ++ 64-byte boundary. (RFC 1321, 3.1: Step 1) */ ++static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; ++ ++ ++/* Take a pointer to a 160 bit block of data (five 32 bit ints) and ++ initialize it to the start constants of the SHA1 algorithm. This ++ must be called before using hash in the call to sha1_hash. */ ++void ++sha1_init_ctx (struct sha1_ctx *ctx) ++{ ++ ctx->A = 0x67452301; ++ ctx->B = 0xefcdab89; ++ ctx->C = 0x98badcfe; ++ ctx->D = 0x10325476; ++ ctx->E = 0xc3d2e1f0; ++ ++ ctx->total[0] = ctx->total[1] = 0; ++ ctx->buflen = 0; ++} ++ ++/* Put result from CTX in first 20 bytes following RESBUF. The result ++ must be in little endian byte order. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32-bit value. */ ++void * ++sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf) ++{ ++ ((uint32_t *) resbuf)[0] = SWAP (ctx->A); ++ ((uint32_t *) resbuf)[1] = SWAP (ctx->B); ++ ((uint32_t *) resbuf)[2] = SWAP (ctx->C); ++ ((uint32_t *) resbuf)[3] = SWAP (ctx->D); ++ ((uint32_t *) resbuf)[4] = SWAP (ctx->E); ++ ++ return resbuf; ++} ++ ++/* Process the remaining bytes in the internal buffer and the usual ++ prolog according to the standard and write the result to RESBUF. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32-bit value. */ ++void * ++sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf) ++{ ++ /* Take yet unprocessed bytes into account. */ ++ uint32_t bytes = ctx->buflen; ++ size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4; ++ ++ /* Now count remaining bytes. */ ++ ctx->total[0] += bytes; ++ if (ctx->total[0] < bytes) ++ ++ctx->total[1]; ++ ++ /* Put the 64-bit file length in *bits* at the end of the buffer. */ ++ ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29)); ++ ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3); ++ ++ memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes); ++ ++ /* Process last bytes. */ ++ sha1_process_block (ctx->buffer, size * 4, ctx); ++ ++ return sha1_read_ctx (ctx, resbuf); ++} ++ ++/* Compute SHA1 message digest for bytes read from STREAM. The ++ resulting message digest number will be written into the 16 bytes ++ beginning at RESBLOCK. */ ++int ++sha1_stream (FILE *stream, void *resblock) ++{ ++ struct sha1_ctx ctx; ++ char buffer[BLOCKSIZE + 72]; ++ size_t sum; ++ ++ /* Initialize the computation context. */ ++ sha1_init_ctx (&ctx); ++ ++ /* Iterate over full file contents. */ ++ while (1) ++ { ++ /* We read the file in blocks of BLOCKSIZE bytes. One call of the ++ computation function processes the whole buffer so that with the ++ next round of the loop another block can be read. */ ++ size_t n; ++ sum = 0; ++ ++ /* Read block. Take care for partial reads. */ ++ while (1) ++ { ++ n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream); ++ ++ sum += n; ++ ++ if (sum == BLOCKSIZE) ++ break; ++ ++ if (n == 0) ++ { ++ /* Check for the error flag IFF N == 0, so that we don't ++ exit the loop after a partial read due to e.g., EAGAIN ++ or EWOULDBLOCK. */ ++ if (ferror (stream)) ++ return 1; ++ goto process_partial_block; ++ } ++ ++ /* We've read at least one byte, so ignore errors. But always ++ check for EOF, since feof may be true even though N > 0. ++ Otherwise, we could end up calling fread after EOF. */ ++ if (feof (stream)) ++ goto process_partial_block; ++ } ++ ++ /* Process buffer with BLOCKSIZE bytes. Note that ++ BLOCKSIZE % 64 == 0 ++ */ ++ sha1_process_block (buffer, BLOCKSIZE, &ctx); ++ } ++ ++ process_partial_block:; ++ ++ /* Process any remaining bytes. */ ++ if (sum > 0) ++ sha1_process_bytes (buffer, sum, &ctx); ++ ++ /* Construct result in desired memory. */ ++ sha1_finish_ctx (&ctx, resblock); ++ return 0; ++} ++ ++/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The ++ result is always in little endian byte order, so that a byte-wise ++ output yields to the wanted ASCII representation of the message ++ digest. */ ++void * ++sha1_buffer (const char *buffer, size_t len, void *resblock) ++{ ++ struct sha1_ctx ctx; ++ ++ /* Initialize the computation context. */ ++ sha1_init_ctx (&ctx); ++ ++ /* Process whole buffer but last len % 64 bytes. */ ++ sha1_process_bytes (buffer, len, &ctx); ++ ++ /* Put result in desired memory area. */ ++ return sha1_finish_ctx (&ctx, resblock); ++} ++ ++void ++sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx) ++{ ++ /* When we already have some bits in our internal buffer concatenate ++ both inputs first. */ ++ if (ctx->buflen != 0) ++ { ++ size_t left_over = ctx->buflen; ++ size_t add = 128 - left_over > len ? len : 128 - left_over; ++ ++ memcpy (&((char *) ctx->buffer)[left_over], buffer, add); ++ ctx->buflen += add; ++ ++ if (ctx->buflen > 64) ++ { ++ sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx); ++ ++ ctx->buflen &= 63; ++ /* The regions in the following copy operation cannot overlap. */ ++ memcpy (ctx->buffer, ++ &((char *) ctx->buffer)[(left_over + add) & ~63], ++ ctx->buflen); ++ } ++ ++ buffer = (const char *) buffer + add; ++ len -= add; ++ } ++ ++ /* Process available complete blocks. */ ++ if (len >= 64) ++ { ++#if !_STRING_ARCH_unaligned ++# define alignof(type) offsetof (struct { char c; type x; }, x) ++# define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0) ++ if (UNALIGNED_P (buffer)) ++ while (len > 64) ++ { ++ sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx); ++ buffer = (const char *) buffer + 64; ++ len -= 64; ++ } ++ else ++#endif ++ { ++ sha1_process_block (buffer, len & ~63, ctx); ++ buffer = (const char *) buffer + (len & ~63); ++ len &= 63; ++ } ++ } ++ ++ /* Move remaining bytes in internal buffer. */ ++ if (len > 0) ++ { ++ size_t left_over = ctx->buflen; ++ ++ memcpy (&((char *) ctx->buffer)[left_over], buffer, len); ++ left_over += len; ++ if (left_over >= 64) ++ { ++ sha1_process_block (ctx->buffer, 64, ctx); ++ left_over -= 64; ++ memcpy (ctx->buffer, &ctx->buffer[16], left_over); ++ } ++ ctx->buflen = left_over; ++ } ++} ++ ++/* --- Code below is the primary difference between md5.c and sha1.c --- */ ++ ++/* SHA1 round constants */ ++#define K1 0x5a827999 ++#define K2 0x6ed9eba1 ++#define K3 0x8f1bbcdc ++#define K4 0xca62c1d6 ++ ++/* Round functions. Note that F2 is the same as F4. */ ++#define F1(B,C,D) ( D ^ ( B & ( C ^ D ) ) ) ++#define F2(B,C,D) (B ^ C ^ D) ++#define F3(B,C,D) ( ( B & C ) | ( D & ( B | C ) ) ) ++#define F4(B,C,D) (B ^ C ^ D) ++ ++/* Process LEN bytes of BUFFER, accumulating context into CTX. ++ It is assumed that LEN % 64 == 0. ++ Most of this code comes from GnuPG's cipher/sha1.c. */ ++ ++void ++sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx) ++{ ++ const uint32_t *words = buffer; ++ size_t nwords = len / sizeof (uint32_t); ++ const uint32_t *endp = words + nwords; ++ uint32_t x[16]; ++ uint32_t a = ctx->A; ++ uint32_t b = ctx->B; ++ uint32_t c = ctx->C; ++ uint32_t d = ctx->D; ++ uint32_t e = ctx->E; ++ ++ /* First increment the byte count. RFC 1321 specifies the possible ++ length of the file up to 2^64 bits. Here we only compute the ++ number of bytes. Do a double word increment. */ ++ ctx->total[0] += len; ++ if (ctx->total[0] < len) ++ ++ctx->total[1]; ++ ++#define rol(x, n) (((x) << (n)) | ((uint32_t) (x) >> (32 - (n)))) ++ ++#define M(I) ( tm = x[I&0x0f] ^ x[(I-14)&0x0f] \ ++ ^ x[(I-8)&0x0f] ^ x[(I-3)&0x0f] \ ++ , (x[I&0x0f] = rol(tm, 1)) ) ++ ++#define R(A,B,C,D,E,F,K,M) do { E += rol( A, 5 ) \ ++ + F( B, C, D ) \ ++ + K \ ++ + M; \ ++ B = rol( B, 30 ); \ ++ } while(0) ++ ++ while (words < endp) ++ { ++ uint32_t tm; ++ int t; ++ for (t = 0; t < 16; t++) ++ { ++ x[t] = SWAP (*words); ++ words++; ++ } ++ ++ R( a, b, c, d, e, F1, K1, x[ 0] ); ++ R( e, a, b, c, d, F1, K1, x[ 1] ); ++ R( d, e, a, b, c, F1, K1, x[ 2] ); ++ R( c, d, e, a, b, F1, K1, x[ 3] ); ++ R( b, c, d, e, a, F1, K1, x[ 4] ); ++ R( a, b, c, d, e, F1, K1, x[ 5] ); ++ R( e, a, b, c, d, F1, K1, x[ 6] ); ++ R( d, e, a, b, c, F1, K1, x[ 7] ); ++ R( c, d, e, a, b, F1, K1, x[ 8] ); ++ R( b, c, d, e, a, F1, K1, x[ 9] ); ++ R( a, b, c, d, e, F1, K1, x[10] ); ++ R( e, a, b, c, d, F1, K1, x[11] ); ++ R( d, e, a, b, c, F1, K1, x[12] ); ++ R( c, d, e, a, b, F1, K1, x[13] ); ++ R( b, c, d, e, a, F1, K1, x[14] ); ++ R( a, b, c, d, e, F1, K1, x[15] ); ++ R( e, a, b, c, d, F1, K1, M(16) ); ++ R( d, e, a, b, c, F1, K1, M(17) ); ++ R( c, d, e, a, b, F1, K1, M(18) ); ++ R( b, c, d, e, a, F1, K1, M(19) ); ++ R( a, b, c, d, e, F2, K2, M(20) ); ++ R( e, a, b, c, d, F2, K2, M(21) ); ++ R( d, e, a, b, c, F2, K2, M(22) ); ++ R( c, d, e, a, b, F2, K2, M(23) ); ++ R( b, c, d, e, a, F2, K2, M(24) ); ++ R( a, b, c, d, e, F2, K2, M(25) ); ++ R( e, a, b, c, d, F2, K2, M(26) ); ++ R( d, e, a, b, c, F2, K2, M(27) ); ++ R( c, d, e, a, b, F2, K2, M(28) ); ++ R( b, c, d, e, a, F2, K2, M(29) ); ++ R( a, b, c, d, e, F2, K2, M(30) ); ++ R( e, a, b, c, d, F2, K2, M(31) ); ++ R( d, e, a, b, c, F2, K2, M(32) ); ++ R( c, d, e, a, b, F2, K2, M(33) ); ++ R( b, c, d, e, a, F2, K2, M(34) ); ++ R( a, b, c, d, e, F2, K2, M(35) ); ++ R( e, a, b, c, d, F2, K2, M(36) ); ++ R( d, e, a, b, c, F2, K2, M(37) ); ++ R( c, d, e, a, b, F2, K2, M(38) ); ++ R( b, c, d, e, a, F2, K2, M(39) ); ++ R( a, b, c, d, e, F3, K3, M(40) ); ++ R( e, a, b, c, d, F3, K3, M(41) ); ++ R( d, e, a, b, c, F3, K3, M(42) ); ++ R( c, d, e, a, b, F3, K3, M(43) ); ++ R( b, c, d, e, a, F3, K3, M(44) ); ++ R( a, b, c, d, e, F3, K3, M(45) ); ++ R( e, a, b, c, d, F3, K3, M(46) ); ++ R( d, e, a, b, c, F3, K3, M(47) ); ++ R( c, d, e, a, b, F3, K3, M(48) ); ++ R( b, c, d, e, a, F3, K3, M(49) ); ++ R( a, b, c, d, e, F3, K3, M(50) ); ++ R( e, a, b, c, d, F3, K3, M(51) ); ++ R( d, e, a, b, c, F3, K3, M(52) ); ++ R( c, d, e, a, b, F3, K3, M(53) ); ++ R( b, c, d, e, a, F3, K3, M(54) ); ++ R( a, b, c, d, e, F3, K3, M(55) ); ++ R( e, a, b, c, d, F3, K3, M(56) ); ++ R( d, e, a, b, c, F3, K3, M(57) ); ++ R( c, d, e, a, b, F3, K3, M(58) ); ++ R( b, c, d, e, a, F3, K3, M(59) ); ++ R( a, b, c, d, e, F4, K4, M(60) ); ++ R( e, a, b, c, d, F4, K4, M(61) ); ++ R( d, e, a, b, c, F4, K4, M(62) ); ++ R( c, d, e, a, b, F4, K4, M(63) ); ++ R( b, c, d, e, a, F4, K4, M(64) ); ++ R( a, b, c, d, e, F4, K4, M(65) ); ++ R( e, a, b, c, d, F4, K4, M(66) ); ++ R( d, e, a, b, c, F4, K4, M(67) ); ++ R( c, d, e, a, b, F4, K4, M(68) ); ++ R( b, c, d, e, a, F4, K4, M(69) ); ++ R( a, b, c, d, e, F4, K4, M(70) ); ++ R( e, a, b, c, d, F4, K4, M(71) ); ++ R( d, e, a, b, c, F4, K4, M(72) ); ++ R( c, d, e, a, b, F4, K4, M(73) ); ++ R( b, c, d, e, a, F4, K4, M(74) ); ++ R( a, b, c, d, e, F4, K4, M(75) ); ++ R( e, a, b, c, d, F4, K4, M(76) ); ++ R( d, e, a, b, c, F4, K4, M(77) ); ++ R( c, d, e, a, b, F4, K4, M(78) ); ++ R( b, c, d, e, a, F4, K4, M(79) ); ++ ++ a = ctx->A += a; ++ b = ctx->B += b; ++ c = ctx->C += c; ++ d = ctx->D += d; ++ e = ctx->E += e; ++ } ++} +Index: ld/sha1.h +=================================================================== +RCS file: ld/sha1.h +diff -N ld/sha1.h +--- /dev/null 1 Jan 1970 00:00:00 -0000 ++++ ld/sha1.h 13 Jul 2007 10:44:28 -0000 1.1 +@@ -0,0 +1,87 @@ ++/* Declarations of functions and data types used for SHA1 sum ++ library functions. ++ Copyright (C) 2000, 2001, 2003, 2005, 2006 Free Software Foundation, Inc. ++ ++ This program is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by the ++ Free Software Foundation; either version 2, or (at your option) any ++ later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ ++ ++#ifndef SHA1_H ++# define SHA1_H 1 ++ ++# include ++# include ++ ++/* Structure to save state of computation between the single steps. */ ++struct sha1_ctx ++{ ++ uint32_t A; ++ uint32_t B; ++ uint32_t C; ++ uint32_t D; ++ uint32_t E; ++ ++ uint32_t total[2]; ++ uint32_t buflen; ++ uint32_t buffer[32]; ++}; ++ ++ ++/* Initialize structure containing state of computation. */ ++extern void sha1_init_ctx (struct sha1_ctx *ctx); ++ ++/* Starting with the result of former calls of this function (or the ++ initialization function update the context for the next LEN bytes ++ starting at BUFFER. ++ It is necessary that LEN is a multiple of 64!!! */ ++extern void sha1_process_block (const void *buffer, size_t len, ++ struct sha1_ctx *ctx); ++ ++/* Starting with the result of former calls of this function (or the ++ initialization function update the context for the next LEN bytes ++ starting at BUFFER. ++ It is NOT required that LEN is a multiple of 64. */ ++extern void sha1_process_bytes (const void *buffer, size_t len, ++ struct sha1_ctx *ctx); ++ ++/* Process the remaining bytes in the buffer and put result from CTX ++ in first 20 bytes following RESBUF. The result is always in little ++ endian byte order, so that a byte-wise output yields to the wanted ++ ASCII representation of the message digest. ++ ++ IMPORTANT: On some systems it is required that RESBUF be correctly ++ aligned for a 32 bits value. */ ++extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf); ++ ++ ++/* Put result from CTX in first 20 bytes following RESBUF. The result is ++ always in little endian byte order, so that a byte-wise output yields ++ to the wanted ASCII representation of the message digest. ++ ++ IMPORTANT: On some systems it is required that RESBUF is correctly ++ aligned for a 32 bits value. */ ++extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf); ++ ++ ++/* Compute SHA1 message digest for bytes read from STREAM. The ++ resulting message digest number will be written into the 20 bytes ++ beginning at RESBLOCK. */ ++extern int sha1_stream (FILE *stream, void *resblock); ++ ++/* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The ++ result is always in little endian byte order, so that a byte-wise ++ output yields to the wanted ASCII representation of the message ++ digest. */ ++extern void *sha1_buffer (const char *buffer, size_t len, void *resblock); ++ ++#endif diff --git a/binutils.spec b/binutils.spec index 037e9f5..883c335 100644 --- a/binutils.spec +++ b/binutils.spec @@ -1,7 +1,7 @@ Summary: A GNU collection of binary utilities. Name: binutils Version: 2.17.50.0.17 -Release: 1 +Release: 2 License: GPL Group: Development/Tools URL: http://sources.redhat.com/binutils @@ -14,6 +14,7 @@ Patch5: binutils-2.17.50.0.17-standards.patch Patch6: binutils-2.17.50.0.17-build-fixes.patch Patch7: binutils-2.17.50.0.17-symbolic-envvar-revert.patch Patch8: binutils-2.17.50.0.17-version.patch +Patch9: binutils-2.17.50.0.17-build-id.patch Buildroot: %{_tmppath}/binutils-root BuildRequires: texinfo >= 4.0, dejagnu, gettext, flex, bison @@ -63,6 +64,7 @@ to consider using libelf instead of BFD. %patch6 -p0 -b .build-fixes~ %patch7 -p0 -b .symbolic-envvar-revert~ %patch8 -p0 -b .version~ +%patch9 -p0 -b .build-id~ # On ppc64 we might use 64K pages sed -i -e '/#define.*ELF_COMMONPAGESIZE/s/0x1000$/0x10000/' bfd/elf*ppc.c @@ -213,6 +215,9 @@ fi %{_infodir}/bfd*info* %changelog +* Sun Jul 15 2007 Roland McGrath - 2.17.50.0.17-2 +- ld --build-id support + * Wed Jun 27 2007 Jakub Jelinek 2.17.50.0.17-1 - update to 2.17.50.0.17