summaryrefslogtreecommitdiff
path: root/elfutils/src
diff options
context:
space:
mode:
Diffstat (limited to 'elfutils/src')
-rw-r--r--elfutils/src/ChangeLog67
-rw-r--r--elfutils/src/Makefile.am24
-rw-r--r--elfutils/src/Makefile.in66
-rw-r--r--elfutils/src/addr2line.c4
-rw-r--r--elfutils/src/ar.c1521
-rw-r--r--elfutils/src/arlib.c272
-rw-r--r--elfutils/src/arlib.h95
-rw-r--r--elfutils/src/arlib2.c50
-rw-r--r--elfutils/src/elfcmp.c4
-rw-r--r--elfutils/src/elflint.c195
-rw-r--r--elfutils/src/findtextrel.c4
-rw-r--r--elfutils/src/ld.c4
-rw-r--r--elfutils/src/ldscript.c982
-rw-r--r--elfutils/src/ldscript.h38
-rw-r--r--elfutils/src/nm.c4
-rw-r--r--elfutils/src/objdump.c4
-rw-r--r--elfutils/src/ranlib.c320
-rw-r--r--elfutils/src/readelf.c4
-rw-r--r--elfutils/src/size.c4
-rw-r--r--elfutils/src/strings.c4
-rw-r--r--elfutils/src/strip.c8
21 files changed, 2925 insertions, 749 deletions
diff --git a/elfutils/src/ChangeLog b/elfutils/src/ChangeLog
index cbee068b..ce2c2ea7 100644
--- a/elfutils/src/ChangeLog
+++ b/elfutils/src/ChangeLog
@@ -1,3 +1,70 @@
+2007-02-05 Ulrich Drepper <drepper@redhat.com>
+
+ * ar.c: Add ugly hack to work around gcc complaining that we
+ ignore fchown's return value.
+ (do_oper_insert): Handle error when writing padding.
+ * ranlib.c: Add fchown complain work around.
+
+ * arlib.c: Make symtab a global variable. Change all users.
+ * arlib2.c: Likewise.
+ * ranlib.c: Likewise.
+ * ar.c: Likewise.
+ * arlib.h: Declare it.
+
+2007-01-11 Roland McGrath <roland@redhat.com>
+
+ * elflint.c (check_sections): Use ebl_machine_section_flag_check on
+ SHF_MASKPROC bits separately from generic sh_flags validation.
+
+2007-02-04 Ulrich Drepper <drepper@redhat.com>
+
+ * ar.c: New file.
+ * arlib.c: New file.
+ * arlib2.c: New file.
+ * arlib.h: New file.
+ * Makefile (noinst_LIBRARIES): Add libar.
+ (libar_a_SOURCES): Define.
+ (ar_LDADD): Define.
+ (CFLAGS_ar): Define.
+ * ranlib.c: Change to use arlib.
+
+ * elflint.c (check_symtab): Work around GNU ld bug which omits
+ sections but not symbols in those sections.
+
+2007-01-10 Ulrich Drepper <drepper@redhat.com>
+
+ * addr2line.c: Update copyright year.
+ * elfcmp.c: Likewise.
+ * elflint.c: Likewise.
+ * findtextrel.c: Likewise.
+ * ld.c: Likewise.
+ * nm.c: Likewise.
+ * objdump.c: Likewise.
+ * ranlib.c: Likewise.
+ * readelf.c: Likewise.
+ * size.c: Likewise.
+ * strings.c: Likewise.
+ * strip.c: Likewise.
+
+2006-12-09 Ulrich Drepper <drepper@redhat.com>
+
+ * elflint.c (compare_hash_gnu_hash): New function. Report if the
+ two hash tables have different content (module expected omission
+ of undefined symbols).
+
+2006-10-31 Roland McGrath <roland@redhat.com>
+
+ * elflint.c (check_program_header): Don't complain about
+ p_filesz > p_memsz if p_memsz is zero and p_type is PT_NOTE.
+
+2006-09-19 Jakub Jelinek <jakub@redhat.com>
+
+ * strip.c (process_file): Disallow -f on archives.
+
+2006-10-09 Roland McGrath <roland@redhat.com>
+
+ * Makefile.am (libld_elf_i386.so): Use $(LINK), not $(CC).
+
2006-08-29 Roland McGrath <roland@redhat.com>
* Makefile.am (MAINTAINERCLEANFILES): New variable.
diff --git a/elfutils/src/Makefile.am b/elfutils/src/Makefile.am
index 470a6b3a..230a8178 100644
--- a/elfutils/src/Makefile.am
+++ b/elfutils/src/Makefile.am
@@ -1,6 +1,6 @@
## Process this file with automake to create Makefile.in
##
-## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
## This file is part of Red Hat elfutils.
##
## Red Hat elfutils is free software; you can redistribute it and/or modify
@@ -34,7 +34,7 @@ endif
AM_CFLAGS += -Wall -Wshadow -std=gnu99 $(native_ld_cflags) \
$(if $($(*F)_no_Werror),,-Werror) \
$(if $($(*F)_no_Wunused),,-Wunused -Wextra) \
- $(if $($(*F)_no_Wformat),,-Wformat=2)
+ $(if $($(*F)_no_Wformat),,-Wformat=2) $(CFLAGS_$(*F))
INCLUDES = -I$(srcdir) -I$(srcdir)/../libelf -I$(srcdir)/../libebl \
-I$(srcdir)/../libdw -I$(srcdir)/../libdwfl \
@@ -52,15 +52,15 @@ native_ld = @native_ld@
base_cpu = @base_cpu@
bin_PROGRAMS = readelf nm size strip ld elflint findtextrel addr2line \
- elfcmp objdump ranlib strings
+ elfcmp objdump ranlib strings ar
ld_dsos = libld_elf_i386_pic.a
if NATIVE_LD
-noinst_LIBRARIES = libld_elf.a
+noinst_LIBRARIES = libld_elf.a libar.a
native_ld_cflags = -DBASE_ELF_NAME=elf_$(base_cpu)
else
-noinst_LIBRARIES = libld_elf.a $(ld_dsos)
+noinst_LIBRARIES = libld_elf.a libar.a $(ld_dsos)
noinst_PROGRAMS = $(ld_dsos:_pic.a=.so)
endif
if NEVER
@@ -76,10 +76,12 @@ textrel_check = if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
ld_SOURCES = ld.c ldgeneric.c ldlex.l ldscript.y symbolhash.c sectionhash.c \
versionhash.c
+libar_a_SOURCES = arlib.c arlib2.c
+
noinst_HEADERS = ld.h symbolhash.h sectionhash.h versionhash.h \
ldscript.h xelf.h unaligned.h
-EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules)
+EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules) arlib.h
ld_modules = i386_ld.c
if MUDFLAP
@@ -117,8 +119,10 @@ findtextrel_LDADD = $(libdw) $(libelf) $(libmudflap)
addr2line_LDADD = $(libdw) $(libmudflap)
elfcmp_LDADD = $(libebl) $(libelf) $(libmudflap) -ldl
objdump_LDADD = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
-ranlib_LDADD = $(libelf) $(libeu) $(libmudflap)
+ranlib_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
strings_LDADD = $(libelf) $(libeu) $(libmudflap)
+ar_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
+CFLAGS_ar = -DAR=\"$(shell echo ar|sed '$(transform)')\"
ldlex.o: ldscript.c
ldlex_no_Werror = yes
@@ -133,9 +137,9 @@ am_libld_elf_i386_pic_a_OBJECTS = i386_ld.os
libld_elf_i386_so_SOURCES =
libld_elf_i386.so: libld_elf_i386_pic.a libld_elf_i386.map
- $(CC) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
- $(libelf) $(libeu) \
- -Wl,--version-script,$(srcdir)/libld_elf_i386.map
+ $(LINK) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
+ $(libelf) $(libeu) \
+ -Wl,--version-script,$(srcdir)/libld_elf_i386.map
$(textrel_check)
endif
diff --git a/elfutils/src/Makefile.in b/elfutils/src/Makefile.in
index 5d41b670..8963dad4 100644
--- a/elfutils/src/Makefile.in
+++ b/elfutils/src/Makefile.in
@@ -41,7 +41,7 @@ host_triplet = @host@
bin_PROGRAMS = readelf$(EXEEXT) nm$(EXEEXT) size$(EXEEXT) \
strip$(EXEEXT) ld$(EXEEXT) elflint$(EXEEXT) \
findtextrel$(EXEEXT) addr2line$(EXEEXT) elfcmp$(EXEEXT) \
- objdump$(EXEEXT) ranlib$(EXEEXT) strings$(EXEEXT)
+ objdump$(EXEEXT) ranlib$(EXEEXT) strings$(EXEEXT) ar$(EXEEXT)
@NATIVE_LD_FALSE@noinst_PROGRAMS = $(am__EXEEXT_1)
# We never build this library but we need to get the dependency files
# of all the linker backends that might be used in a non-generic linker.
@@ -63,6 +63,10 @@ CONFIG_CLEAN_FILES =
LIBRARIES = $(noinst_LIBRARIES)
AR = ar
ARFLAGS = cru
+libar_a_AR = $(AR) $(ARFLAGS)
+libar_a_LIBADD =
+am_libar_a_OBJECTS = arlib.$(OBJEXT) arlib2.$(OBJEXT)
+libar_a_OBJECTS = $(am_libar_a_OBJECTS)
libdummy_a_AR = $(AR) $(ARFLAGS)
libdummy_a_LIBADD =
am__libdummy_a_SOURCES_DIST = i386_ld.c
@@ -90,13 +94,17 @@ am__DEPENDENCIES_2 = ../libebl/libebl.a
@BUILD_STATIC_TRUE@ $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)
am__DEPENDENCIES_4 =
addr2line_DEPENDENCIES = $(am__DEPENDENCIES_3) $(am__DEPENDENCIES_4)
+ar_SOURCES = ar.c
+ar_OBJECTS = ar.$(OBJEXT)
+am__DEPENDENCIES_5 = ../lib/libeu.a
+ar_DEPENDENCIES = libar.a $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_5) \
+ $(am__DEPENDENCIES_4)
elfcmp_SOURCES = elfcmp.c
elfcmp_OBJECTS = elfcmp.$(OBJEXT)
elfcmp_DEPENDENCIES = $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_4)
elflint_SOURCES = elflint.c
elflint_OBJECTS = elflint.$(OBJEXT)
-am__DEPENDENCIES_5 = ../lib/libeu.a
elflint_DEPENDENCIES = $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_5) $(am__DEPENDENCIES_4)
findtextrel_SOURCES = findtextrel.c
@@ -125,8 +133,8 @@ objdump_DEPENDENCIES = $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_5) $(am__DEPENDENCIES_4)
ranlib_SOURCES = ranlib.c
ranlib_OBJECTS = ranlib.$(OBJEXT)
-ranlib_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_5) \
- $(am__DEPENDENCIES_4)
+ranlib_DEPENDENCIES = libar.a $(am__DEPENDENCIES_1) \
+ $(am__DEPENDENCIES_5) $(am__DEPENDENCIES_4)
readelf_SOURCES = readelf.c
readelf_OBJECTS = readelf.$(OBJEXT)
readelf_DEPENDENCIES = $(am__DEPENDENCIES_3) $(am__DEPENDENCIES_2) \
@@ -153,15 +161,17 @@ CCLD = $(CC)
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
LEXCOMPILE = $(LEX) $(LFLAGS) $(AM_LFLAGS)
YACCCOMPILE = $(YACC) $(YFLAGS) $(AM_YFLAGS)
-SOURCES = $(libdummy_a_SOURCES) $(libld_elf_a_SOURCES) \
- $(libld_elf_i386_pic_a_SOURCES) addr2line.c elfcmp.c elflint.c \
- findtextrel.c $(ld_SOURCES) $(libld_elf_i386_so_SOURCES) nm.c \
- objdump.c ranlib.c readelf.c size.c strings.c strip.c
-DIST_SOURCES = $(am__libdummy_a_SOURCES_DIST) \
+SOURCES = $(libar_a_SOURCES) $(libdummy_a_SOURCES) \
+ $(libld_elf_a_SOURCES) $(libld_elf_i386_pic_a_SOURCES) \
+ addr2line.c ar.c elfcmp.c elflint.c findtextrel.c \
+ $(ld_SOURCES) $(libld_elf_i386_so_SOURCES) nm.c objdump.c \
+ ranlib.c readelf.c size.c strings.c strip.c
+DIST_SOURCES = $(libar_a_SOURCES) $(am__libdummy_a_SOURCES_DIST) \
$(am__libld_elf_a_SOURCES_DIST) \
- $(libld_elf_i386_pic_a_SOURCES) addr2line.c elfcmp.c elflint.c \
- findtextrel.c $(ld_SOURCES) $(libld_elf_i386_so_SOURCES) nm.c \
- objdump.c ranlib.c readelf.c size.c strings.c strip.c
+ $(libld_elf_i386_pic_a_SOURCES) addr2line.c ar.c elfcmp.c \
+ elflint.c findtextrel.c $(ld_SOURCES) \
+ $(libld_elf_i386_so_SOURCES) nm.c objdump.c ranlib.c readelf.c \
+ size.c strings.c strip.c
HEADERS = $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
@@ -287,12 +297,13 @@ target_alias = @target_alias@
@MUDFLAP_FALSE@ $(native_ld_cflags) $(if \
@MUDFLAP_FALSE@ $($(*F)_no_Werror),,-Werror) $(if \
@MUDFLAP_FALSE@ $($(*F)_no_Wunused),,-Wunused -Wextra) $(if \
-@MUDFLAP_FALSE@ $($(*F)_no_Wformat),,-Wformat=2)
+@MUDFLAP_FALSE@ $($(*F)_no_Wformat),,-Wformat=2) \
+@MUDFLAP_FALSE@ $(CFLAGS_$(*F))
@MUDFLAP_TRUE@AM_CFLAGS = -fmudflap -Wall -Wshadow -std=gnu99 \
@MUDFLAP_TRUE@ $(native_ld_cflags) $(if \
@MUDFLAP_TRUE@ $($(*F)_no_Werror),,-Werror) $(if \
@MUDFLAP_TRUE@ $($(*F)_no_Wunused),,-Wunused -Wextra) $(if \
-@MUDFLAP_TRUE@ $($(*F)_no_Wformat),,-Wformat=2)
+@MUDFLAP_TRUE@ $($(*F)_no_Wformat),,-Wformat=2) $(CFLAGS_$(*F))
INCLUDES = -I$(srcdir) -I$(srcdir)/../libelf -I$(srcdir)/../libebl \
-I$(srcdir)/../libdw -I$(srcdir)/../libdwfl \
-I$(srcdir)/../lib -I..
@@ -302,19 +313,20 @@ AM_YFLAGS = -pld
AM_LFLAGS = -Pld -olex.yy.c
native_ld = @native_ld@
ld_dsos = libld_elf_i386_pic.a
-@NATIVE_LD_FALSE@noinst_LIBRARIES = libld_elf.a $(ld_dsos) \
+@NATIVE_LD_FALSE@noinst_LIBRARIES = libld_elf.a libar.a $(ld_dsos) \
@NATIVE_LD_FALSE@ $(am__append_1)
-@NATIVE_LD_TRUE@noinst_LIBRARIES = libld_elf.a $(am__append_1)
+@NATIVE_LD_TRUE@noinst_LIBRARIES = libld_elf.a libar.a $(am__append_1)
@NATIVE_LD_TRUE@native_ld_cflags = -DBASE_ELF_NAME=elf_$(base_cpu)
@NEVER_TRUE@libdummy_a_SOURCES = i386_ld.c
textrel_check = if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
ld_SOURCES = ld.c ldgeneric.c ldlex.l ldscript.y symbolhash.c sectionhash.c \
versionhash.c
+libar_a_SOURCES = arlib.c arlib2.c
noinst_HEADERS = ld.h symbolhash.h sectionhash.h versionhash.h \
ldscript.h xelf.h unaligned.h
-EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules)
+EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules) arlib.h
ld_modules = i386_ld.c
@MUDFLAP_TRUE@libmudflap = -lmudflap
@BUILD_STATIC_FALSE@libdw = ../libdw/libdw.so
@@ -340,8 +352,10 @@ findtextrel_LDADD = $(libdw) $(libelf) $(libmudflap)
addr2line_LDADD = $(libdw) $(libmudflap)
elfcmp_LDADD = $(libebl) $(libelf) $(libmudflap) -ldl
objdump_LDADD = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
-ranlib_LDADD = $(libelf) $(libeu) $(libmudflap)
+ranlib_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
strings_LDADD = $(libelf) $(libeu) $(libmudflap)
+ar_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
+CFLAGS_ar = -DAR=\"$(shell echo ar|sed '$(transform)')\"
ldlex_no_Werror = yes
# Machine-specific linker code.
@@ -387,6 +401,10 @@ $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
clean-noinstLIBRARIES:
-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+libar.a: $(libar_a_OBJECTS) $(libar_a_DEPENDENCIES)
+ -rm -f libar.a
+ $(libar_a_AR) libar.a $(libar_a_OBJECTS) $(libar_a_LIBADD)
+ $(RANLIB) libar.a
libdummy.a: $(libdummy_a_OBJECTS) $(libdummy_a_DEPENDENCIES)
-rm -f libdummy.a
$(libdummy_a_AR) libdummy.a $(libdummy_a_OBJECTS) $(libdummy_a_LIBADD)
@@ -428,6 +446,9 @@ clean-noinstPROGRAMS:
addr2line$(EXEEXT): $(addr2line_OBJECTS) $(addr2line_DEPENDENCIES)
@rm -f addr2line$(EXEEXT)
$(LINK) $(addr2line_LDFLAGS) $(addr2line_OBJECTS) $(addr2line_LDADD) $(LIBS)
+ar$(EXEEXT): $(ar_OBJECTS) $(ar_DEPENDENCIES)
+ @rm -f ar$(EXEEXT)
+ $(LINK) $(ar_LDFLAGS) $(ar_OBJECTS) $(ar_LDADD) $(LIBS)
elfcmp$(EXEEXT): $(elfcmp_OBJECTS) $(elfcmp_DEPENDENCIES)
@rm -f elfcmp$(EXEEXT)
$(LINK) $(elfcmp_LDFLAGS) $(elfcmp_OBJECTS) $(elfcmp_LDADD) $(LIBS)
@@ -473,6 +494,9 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/$(base_cpu)_ld.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/addr2line.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ar.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arlib.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arlib2.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elfcmp.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elflint.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/findtextrel.Po@am__quote@
@@ -709,9 +733,9 @@ uninstall-am: uninstall-binPROGRAMS uninstall-info-am
ldlex.o: ldscript.c
ldscript.h: ldscript.c
@NATIVE_LD_FALSE@libld_elf_i386.so: libld_elf_i386_pic.a libld_elf_i386.map
-@NATIVE_LD_FALSE@ $(CC) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
-@NATIVE_LD_FALSE@ $(libelf) $(libeu) \
-@NATIVE_LD_FALSE@ -Wl,--version-script,$(srcdir)/libld_elf_i386.map
+@NATIVE_LD_FALSE@ $(LINK) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
+@NATIVE_LD_FALSE@ $(libelf) $(libeu) \
+@NATIVE_LD_FALSE@ -Wl,--version-script,$(srcdir)/libld_elf_i386.map
@NATIVE_LD_FALSE@ $(textrel_check)
%.os: %.c %.o
diff --git a/elfutils/src/addr2line.c b/elfutils/src/addr2line.c
index 1229ce48..e133e7af 100644
--- a/elfutils/src/addr2line.c
+++ b/elfutils/src/addr2line.c
@@ -1,5 +1,5 @@
/* Locate source files and line information for given addresses
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -186,7 +186,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/ar.c b/elfutils/src/ar.c
new file mode 100644
index 00000000..37fa3e03
--- /dev/null
+++ b/elfutils/src/ar.c
@@ -0,0 +1,1521 @@
+/* Create, modify, and extract from archives.
+ Copyright (C) 2005, 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2005.
+
+ Red Hat elfutils 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; version 2 of the License.
+
+ Red Hat elfutils 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 Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <argp.h>
+#include <assert.h>
+#include <error.h>
+#include <fcntl.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <locale.h>
+#include <mcheck.h>
+#include <search.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* Name and version of program. */
+static void print_version (FILE *stream, struct argp_state *state);
+void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
+/* Prototypes for local functions. */
+static int do_oper_extract (int oper, const char *arfname, char **argv,
+ int argc, long int instance);
+static int do_oper_delete (const char *arfname, char **argv, int argc,
+ long int instance);
+static int do_oper_insert (int oper, const char *arfname, char **argv,
+ int argc, const char *member);
+
+
+/* Bug report address. */
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+
+
+/* Definitions of arguments for argp functions. */
+static const struct argp_option options[] =
+{
+ { NULL, 0, NULL, 0, N_("Commands:"), 0 },
+ { NULL, 'd', NULL, 0, N_("Delete files from archive."), 0 },
+ { NULL, 'm', NULL, 0, N_("Move files in archive."), 0 },
+ { NULL, 'p', NULL, 0, N_("Print files in archive."), 0 },
+ { NULL, 'q', NULL, 0, N_("Quick append files to archive."), 0 },
+ { NULL, 'r', NULL, 0,
+ N_("Replace existing or insert new file into archive."), 0 },
+ { NULL, 't', NULL, 0, N_("Display content of archive."), 0 },
+ { NULL, 'x', NULL, 0, N_("Extract files from archive."), 0 },
+
+ { NULL, 0, NULL, 0, N_("Command Modifiers:"), 0 },
+ { NULL, 'o', NULL, 0, N_("Preserve original dates."), 0 },
+ { NULL, 'N', NULL, 0, N_("Use instance [COUNT] of name."), 0 },
+ { NULL, 'C', NULL, 0,
+ N_("Do not replace existing files with extracted files."), 0 },
+ { NULL, 'T', NULL, 0, N_("Allow filename to be truncated if necessary."),
+ 0 },
+ { NULL, 'v', NULL, 0, N_("Provide verbose output."), 0 },
+ { NULL, 's', NULL, 0, N_("Force regeneration of symbol table."), 0 },
+ { NULL, 'a', NULL, 0, N_("Insert file after [MEMBER]."), 0 },
+ { NULL, 'b', NULL, 0, N_("Insert file before [MEMBER]."), 0 },
+ { NULL, 'i', NULL, 0, N_("Same as -b."), 0 },
+ { NULL, 'c', NULL, 0, N_("Suppress message when library has to be created."),
+ 0 },
+ { NULL, 'P', NULL, 0, N_("Use full path for file matching."), 0 },
+ { NULL, 'u', NULL, 0, N_("Update only older files in archive."), 0 },
+
+ { NULL, 0, NULL, 0, NULL, 0 }
+};
+
+/* Short description of program. */
+static const char doc[] = N_("Create, modify, and extract from archives.");
+
+/* Strings for arguments in help texts. */
+static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]");
+
+/* Prototype for option handler. */
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+/* Data structure to communicate with argp functions. */
+static struct argp argp =
+{
+ options, parse_opt, args_doc, doc, NULL, NULL, NULL
+};
+
+
+/* What operation to perform. */
+static enum
+ {
+ oper_none,
+ oper_delete,
+ oper_move,
+ oper_print,
+ oper_qappend,
+ oper_replace,
+ oper_list,
+ oper_extract
+ } operation;
+
+/* Modifiers. */
+static bool verbose;
+static bool preserve_dates;
+static bool instance_specifed;
+static bool dont_replace_existing;
+static bool allow_truncate_fname;
+static bool force_symtab;
+static bool suppress_create_msg;
+static bool full_path;
+static bool update_newer;
+static enum { ipos_none, ipos_before, ipos_after } ipos;
+
+
+int
+main (int argc, char *argv[])
+{
+ /* Make memory leak detection possible. */
+ mtrace ();
+
+ /* We use no threads here which can interfere with handling a stream. */
+ (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
+ (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
+ (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
+
+ /* Set locale. */
+ (void) setlocale (LC_ALL, "");
+
+ /* Make sure the message catalog can be found. */
+ (void) bindtextdomain (PACKAGE, LOCALEDIR);
+
+ /* Initialize the message catalog. */
+ (void) textdomain (PACKAGE);
+
+ /* For historical reasons the options in the first parameter need
+ not be preceded by a dash. Add it now if necessary. */
+ if (argc > 1 && argv[1][0] != '-')
+ {
+ size_t len = strlen (argv[1]) + 1;
+ char *newp = alloca (len + 1);
+ newp[0] = '-';
+ memcpy (&newp[1], argv[1], len);
+ argv[1] = newp;
+ }
+
+ /* Parse and process arguments. */
+ int remaining;
+ (void) argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
+
+ /* Tell the library which version we are expecting. */
+ (void) elf_version (EV_CURRENT);
+
+ /* Handle the [MEMBER] parameter. */
+ const char *member = NULL;
+ if (ipos != ipos_none)
+ {
+ /* Only valid for certain operations. */
+ if (operation == oper_extract && operation == oper_delete)
+ error (1, 0, gettext ("\
+'a', 'b', and 'i' are only allowed with the 'm' and 'r' options"));
+
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("MEMBER parameter required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ member = argv[remaining++];
+ }
+
+ /* Handle the [COUNT] parameter. */
+ long int instance = -1;
+ if (instance_specifed)
+ {
+ /* Only valid for certain operations. */
+ if (operation == oper_extract && operation == oper_delete)
+ error (1, 0, gettext ("\
+'N' is only meaningful with the 'x' and 'd' options"));
+
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("COUNT parameter required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ char *endp;
+ errno = 0;
+ if (((instance = strtol (argv[remaining], &endp, 10)) == LONG_MAX
+ && errno == ERANGE)
+ || instance <= 0
+ || *endp != '\0')
+ error (1, 0, gettext ("invalid COUNT parameter %s"), argv[remaining]);
+
+ ++remaining;
+ }
+
+ if ((dont_replace_existing || allow_truncate_fname)
+ && unlikely (operation != oper_extract))
+ error (1, 0, gettext ("'%' is only meaningful with the 'x' option"),
+ dont_replace_existing ? 'C' : 'T');
+
+ /* There must at least be one more parameter specifying the archive. */
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("Archive name required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ const char *arfname = argv[remaining++];
+ argv += remaining;
+ argc -= remaining;
+
+ int status;
+ switch (operation)
+ {
+ case oper_list:
+ case oper_print:
+ status = do_oper_extract (operation, arfname, argv, argc, -1);
+ break;
+
+ case oper_extract:
+ status = do_oper_extract (operation, arfname, argv, argc, instance);
+ break;
+
+ case oper_delete:
+ status = do_oper_delete (arfname, argv, argc, instance);
+ break;
+
+ case oper_move:
+ case oper_qappend:
+ case oper_replace:
+ status = do_oper_insert (operation, arfname, argv, argc, member);
+ break;
+
+ default:
+ assert (! "should not happen");
+ status = 1;
+ break;
+ }
+
+ return status;
+}
+
+
+/* Print the version information. */
+static void
+print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
+{
+ fprintf (stream, "ar (%s) %s\n", PACKAGE_NAME, VERSION);
+ fprintf (stream, gettext ("\
+Copyright (C) %s Red Hat, Inc.\n\
+This is free software; see the source for copying conditions. There is NO\n\
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
+"), "2007");
+ fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
+}
+
+
+/* Handle program arguments. */
+static error_t
+parse_opt (int key, char *arg __attribute__ ((unused)),
+ struct argp_state *state __attribute__ ((unused)))
+{
+ switch (key)
+ {
+ case 'd':
+ case 'm':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'x':
+ if (operation != oper_none)
+ {
+ error (0, 0, gettext ("More than one operation specified"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ switch (key)
+ {
+ case 'd':
+ operation = oper_delete;
+ break;
+ case 'm':
+ operation = oper_move;
+ break;
+ case 'p':
+ operation = oper_print;
+ break;
+ case 'q':
+ operation = oper_qappend;
+ break;
+ case 'r':
+ operation = oper_replace;
+ break;
+ case 't':
+ operation = oper_list;
+ break;
+ case 'x':
+ operation = oper_extract;
+ break;
+ }
+ break;
+
+ case 'a':
+ ipos = ipos_after;
+ break;
+
+ case 'b':
+ case 'i':
+ ipos = ipos_before;
+ break;
+
+ case 'c':
+ suppress_create_msg = true;
+ break;
+
+ case 'C':
+ dont_replace_existing = true;
+ break;
+
+ case 'N':
+ instance_specifed = true;
+ break;
+
+ case 'o':
+ preserve_dates = true;
+ break;
+
+ case 'P':
+ full_path = true;
+ break;
+
+ case 's':
+ force_symtab = true;
+ break;
+
+ case 'T':
+ allow_truncate_fname = true;
+ break;
+
+ case 'v':
+ verbose = true;
+ break;
+
+ default:
+ return ARGP_ERR_UNKNOWN;
+ }
+ return 0;
+}
+
+
+static int
+open_archive (const char *arfname, int flags, int mode, Elf **elf,
+ struct stat *st, bool miss_allowed)
+{
+ int fd = open (arfname, flags, mode);
+ if (fd == -1)
+ {
+ if (miss_allowed)
+ return -1;
+
+ error (EXIT_FAILURE, errno, gettext ("cannot open archive '%s'"),
+ arfname);
+ }
+
+ if (elf != NULL)
+ {
+ Elf_Cmd cmd = flags == O_RDONLY ? ELF_C_READ_MMAP : ELF_C_RDWR_MMAP;
+
+ *elf = elf_begin (fd, cmd, NULL);
+ if (*elf == NULL)
+ error (EXIT_FAILURE, 0, gettext ("cannot open archive '%s': %s"),
+ arfname, elf_errmsg (-1));
+
+ if (flags == O_RDONLY && elf_kind (*elf) != ELF_K_AR)
+ error (EXIT_FAILURE, 0, gettext ("%s: not an archive file"), arfname);
+ }
+
+ if (st != NULL && fstat (fd, st) != 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot stat archive '%s'"),
+ arfname);
+
+ return fd;
+}
+
+
+static void
+not_found (int argc, char *argv[argc], bool found[argc])
+{
+ for (int i = 0; i < argc; ++i)
+ if (!found[i])
+ printf (gettext ("no entry %s in archive\n"), argv[i]);
+}
+
+
+static int
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
+{
+ size_t len;
+ char *rawfile = elf_rawfile (elf, &len);
+
+ assert (off + n <= len);
+
+ /* Tell the kernel we will read all the pages sequentially. */
+ size_t ps = sysconf (_SC_PAGESIZE);
+ if (n > 2 * ps)
+ posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
+
+ return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
+}
+
+
+static int
+do_oper_extract (int oper, const char *arfname, char **argv, int argc,
+ long int instance)
+{
+ bool found[argc];
+ memset (found, '\0', sizeof (found));
+
+ struct statfs f;
+ f.f_namelen = 0;
+
+ off_t index_off = -1;
+ size_t index_size = 0;
+ off_t cur_off = SARMAG;
+
+ int status = 0;
+ Elf *elf;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, NULL, false);
+
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+
+ struct stat st;
+ if (force_symtab)
+ {
+ if (fstat (fd, &st) != 0)
+ {
+ error (0, errno, gettext ("cannot stat '%s'"), arfname);
+ close (fd);
+ return 1;
+ }
+ arlib_init ();
+ }
+
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ if (strcmp (arhdr->ar_name, "/") == 0)
+ {
+ index_off = elf_getaroff (subelf);
+ index_size = arhdr->ar_size;
+ goto next;
+ }
+ if (strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ if (force_symtab)
+ {
+ arlib_add_symbols (elf, arfname, arhdr->ar_name, cur_off);
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
+
+ bool do_extract = argc <= 0;
+ if (!do_extract)
+ {
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && (instance < 0 || instance-- == 0)
+ && !found[(char **) res->data - argv])
+ found[(char **) res->data - argv] = do_extract = true;
+ }
+
+ if (do_extract)
+ {
+ if (verbose)
+ {
+ if (oper == oper_print)
+ {
+ printf ("\n<%s>\n\n", arhdr->ar_name);
+
+ /* We have to flush now because now we use the descriptor
+ directly. */
+ fflush (stdout);
+ }
+ else if (oper == oper_list)
+ {
+ char datestr[100];
+ strftime (datestr, sizeof (datestr), "%b %e %H:%M %Y",
+ localtime (&arhdr->ar_date));
+
+ printf ("%c%c%c%c%c%c%c%c%c %u/%u %6ju %s %s\n",
+ (arhdr->ar_mode & S_IRUSR) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWUSR) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXUSR)
+ ? ((arhdr->ar_mode & S_ISUID) ? 's' : 'x')
+ : ((arhdr->ar_mode & S_ISUID) ? 'S' : '-'),
+ (arhdr->ar_mode & S_IRGRP) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWGRP) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXGRP)
+ ? ((arhdr->ar_mode & S_ISGID) ? 's' : 'x')
+ : ((arhdr->ar_mode & S_ISGID) ? 'S' : '-'),
+ (arhdr->ar_mode & S_IROTH) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWOTH) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXOTH)
+ ? ((arhdr->ar_mode & S_ISVTX) ? 't' : 'x')
+ : ((arhdr->ar_mode & S_ISVTX) ? 'T' : '-'),
+ arhdr->ar_uid,
+ arhdr->ar_gid,
+ (uintmax_t) arhdr->ar_size,
+ datestr,
+ arhdr->ar_name);
+ }
+ else
+ printf ("x - %s\n", arhdr->ar_name);
+ }
+
+ if (oper == oper_list)
+ {
+ if (!verbose)
+ puts (arhdr->ar_name);
+
+ goto next;
+ }
+
+ size_t nleft;
+ char *data = elf_rawfile (subelf, &nleft);
+ if (data == NULL)
+ {
+ error (0, 0, gettext ("cannot read content of %s: %s"),
+ arhdr->ar_name, elf_errmsg (-1));
+ status = 1;
+ goto next;
+ }
+
+ int xfd;
+ char tempfname[] = "XXXXXX";
+ bool use_mkstemp = true;
+
+ if (oper == oper_print)
+ xfd = STDOUT_FILENO;
+ else
+ {
+ xfd = mkstemp (tempfname);
+ if (unlikely (xfd == -1))
+ {
+ /* We cannot create a temporary file. Try to overwrite
+ the file or create it if it does not exist. */
+ int flags = O_WRONLY | O_CREAT;
+ if (dont_replace_existing)
+ flags |= O_EXCL;
+ else
+ flags |= O_TRUNC;
+ xfd = open (arhdr->ar_name, flags, 0600);
+ if (unlikely (xfd == -1))
+ {
+ int printlen = INT_MAX;
+
+ if (errno == ENAMETOOLONG && allow_truncate_fname
+ && (f.f_namelen != 0 || statfs (".", &f) == 0))
+ {
+ /* Try to truncate the name. First find out by how
+ much. */
+ printlen = f.f_namelen;
+ char truncfname[f.f_namelen + 1];
+ *((char *) mempcpy (truncfname, arhdr->ar_name,
+ f.f_namelen)) = '\0';
+
+ xfd = open (truncfname, flags, 0600);
+ }
+
+ if (xfd == -1)
+ {
+ error (0, errno, gettext ("cannot open %.*s"),
+ (int) printlen, arhdr->ar_name);
+ status = 1;
+ goto next;
+ }
+ }
+
+ use_mkstemp = false;
+ }
+ }
+
+ ssize_t n;
+ while ((n = TEMP_FAILURE_RETRY (write (xfd, data, nleft))) != -1)
+ {
+ nleft -= n;
+ if (nleft == 0)
+ break;
+ data += n;
+ }
+
+ if (unlikely (n == -1))
+ {
+ error (0, errno, gettext ("failed to write %s"), arhdr->ar_name);
+ status = 1;
+ unlink (tempfname);
+ close (xfd);
+ goto next;
+ }
+
+ if (oper != oper_print)
+ {
+ /* Fix up the mode. */
+ if (unlikely (fchmod (xfd, arhdr->ar_mode) != 0))
+ {
+ error (0, errno, gettext ("cannot change mode of %s"),
+ arhdr->ar_name);
+ status = 0;
+ }
+
+ if (preserve_dates)
+ {
+ struct timeval tv[2];
+ tv[0].tv_sec = arhdr->ar_date;
+ tv[0].tv_usec = 0;
+ tv[1].tv_sec = arhdr->ar_date;
+ tv[1].tv_usec = 0;
+
+ if (unlikely (futimes (xfd, tv) != 0))
+ {
+ error (0, errno,
+ gettext ("cannot change modification time of %s"),
+ arhdr->ar_name);
+ status = 1;
+ }
+ }
+
+ /* If we used a temporary file, move it do the right
+ name now. */
+ if (use_mkstemp)
+ {
+ int r;
+
+ if (dont_replace_existing)
+ {
+ r = link (tempfname, arhdr->ar_name);
+ if (likely (r == 0))
+ unlink (tempfname);
+ }
+ else
+ r = rename (tempfname, arhdr->ar_name);
+
+ if (unlikely (r) != 0)
+ {
+ int printlen = INT_MAX;
+
+ if (errno == ENAMETOOLONG && allow_truncate_fname
+ && (f.f_namelen != 0 || statfs (".", &f) == 0))
+ {
+ /* Try to truncate the name. First find out by how
+ much. */
+ printlen = f.f_namelen;
+ char truncfname[f.f_namelen + 1];
+ *((char *) mempcpy (truncfname, arhdr->ar_name,
+ f.f_namelen)) = '\0';
+
+ if (dont_replace_existing)
+ {
+ r = link (tempfname, truncfname);
+ if (likely (r == 0))
+ unlink (tempfname);
+ }
+ else
+ r = rename (tempfname, truncfname);
+ }
+
+ if (r != 0)
+ {
+ error (0, errno, gettext ("\
+cannot rename temporary file to %.*s"),
+ printlen, arhdr->ar_name);
+ unlink (tempfname);
+ status = 1;
+ }
+ }
+ }
+
+ close (xfd);
+ }
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ hdestroy ();
+
+ if (force_symtab)
+ {
+ arlib_finalize ();
+
+ if (symtab.symsnamelen != 0
+ /* We have to rewrite the file also if it initially had an index
+ but now does not need one anymore. */
+ || (symtab.symsnamelen == 0 && index_size != 0))
+ {
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd = mkstemp (tmpfname);
+ if (unlikely (newfd == -1))
+ {
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ }
+ else
+ {
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ // XXX Use /prof/self/fd/%d ???
+ nonew_unlink:
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ goto nonew;
+ }
+
+ /* Create the new file. There are three parts as far we are
+ concerned: 1. original context before the index, 2. the
+ new index, 3. everything after the new index. */
+ off_t rest_off;
+ if (index_off != -1)
+ rest_off = (index_off + sizeof (struct ar_hdr)
+ + ((index_size + 1) & ~1ul));
+ else
+ rest_off = SARMAG;
+
+ if ((symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff,
+ symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname,
+ symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ /* Even if the original file had content before the
+ symbol table, we write it in the correct order. */
+ || (index_off != SARMAG
+ && copy_content (elf, newfd, SARMAG, index_off - SARMAG))
+ || copy_content (elf, newfd, rest_off, st.st_size - rest_off)
+ /* Set the mode of the new file to the same values the
+ original file has. */
+ || fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (({asm ("" :: "r" (fchown (newfd, st.st_uid,
+ st.st_gid))); }),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0))
+ goto nonew_unlink;
+ }
+ }
+ }
+
+ elf_end (elf);
+
+ close (fd);
+
+ not_found (argc, argv, found);
+
+ return status;
+}
+
+
+struct armem
+{
+ off_t off;
+ off_t old_off;
+ size_t size;
+ long int long_name_off;
+ struct armem *next;
+ void *mem;
+ time_t sec;
+ uid_t uid;
+ gid_t gid;
+ mode_t mode;
+ const char *name;
+ Elf *elf;
+};
+
+
+static int
+write_member (struct armem *memb, off_t *startp, off_t *lenp, Elf *elf,
+ off_t end_off, int newfd)
+{
+ struct ar_hdr arhdr;
+ char tmpbuf[sizeof (arhdr.ar_name) + 1];
+
+ bool changed_header = memb->long_name_off != -1;
+ if (changed_header)
+ {
+ /* In case of a long file name we assume the archive header
+ changed and we write it here. */
+ memcpy (&arhdr, elf_rawfile (elf, NULL) + *startp, sizeof (arhdr));
+
+ snprintf (tmpbuf, sizeof (tmpbuf), "/%-*ld",
+ (int) sizeof (arhdr.ar_name), memb->long_name_off);
+ changed_header = memcmp (arhdr.ar_name, tmpbuf,
+ sizeof (arhdr.ar_name)) != 0;
+ }
+
+ /* If the files are adjacent in the old file extend the range. */
+ if (*startp != -1 && !changed_header && *startp + *lenp == memb->old_off)
+ {
+ /* Extend the current range. */
+ *lenp += (memb->next != NULL
+ ? memb->next->off : end_off) - memb->off;
+ return 0;
+ }
+
+ /* Write out the old range. */
+ if (*startp != -1 && copy_content (elf, newfd, *startp, *lenp))
+ return -1;
+
+ *startp = memb->old_off;
+ *lenp = (memb->next != NULL ? memb->next->off : end_off) - memb->off;
+
+ if (changed_header)
+ {
+ memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+
+ if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+ != sizeof (arhdr)))
+ return -1;
+
+ *startp += sizeof (struct ar_hdr);
+ assert ((size_t) *lenp >= sizeof (struct ar_hdr));
+ *lenp -= sizeof (struct ar_hdr);
+ }
+
+ return 0;
+}
+
+
+static int
+do_oper_delete (const char *arfname, char **argv, int argc,
+ long int instance)
+{
+ bool *found = alloca (sizeof (bool) * argc);
+ memset (found, '\0', sizeof (found));
+
+ /* List of the files we keep. */
+ struct armem *to_copy = NULL;
+
+ int status = 0;
+ Elf *elf;
+ struct stat st;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, false);
+
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+
+ arlib_init ();
+
+ off_t cur_off = SARMAG;
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ /* Ignore the symbol table and the long file name table here. */
+ if (strcmp (arhdr->ar_name, "/") == 0
+ || strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ bool do_delete = argc <= 0;
+ if (!do_delete)
+ {
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && (instance < 0 || instance-- == 0)
+ && !found[(char **) res->data - argv])
+ found[(char **) res->data - argv] = do_delete = true;
+ }
+
+ if (do_delete)
+ {
+ if (verbose)
+ printf ("d - %s\n", arhdr->ar_name);
+ }
+ else
+ {
+ struct armem *newp = alloca (sizeof (struct armem));
+ newp->old_off = elf_getaroff (subelf);
+ newp->off = cur_off;
+
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+
+ if (to_copy == NULL)
+ to_copy = newp->next = newp;
+ else
+ {
+ newp->next = to_copy->next;
+ to_copy = to_copy->next = newp;
+ }
+
+ /* If we recreate the symbol table read the file's symbol
+ table now. */
+ arlib_add_symbols (subelf, arfname, arhdr->ar_name, newp->off);
+
+ /* Remember long file names. */
+ size_t ar_namelen = strlen (arhdr->ar_name);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ newp->long_name_off = arlib_add_long_name (arhdr->ar_name,
+ ar_namelen);
+ else
+ newp->long_name_off = -1l;
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ arlib_finalize ();
+
+ hdestroy ();
+
+ /* Create a new, temporary file in the same directory as the
+ original file. */
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd = mkstemp (tmpfname);
+ if (unlikely (newfd == -1))
+ goto nonew;
+
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ // XXX Use /prof/self/fd/%d ???
+ nonew_unlink:
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ goto errout;
+ }
+
+ /* If the archive is empty that is all we have to do. */
+ if (likely (to_copy != NULL))
+ {
+ /* Write the symbol table or the long file name table or both. */
+ if (symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ goto nonew_unlink;
+
+ if (symtab.longnameslen > sizeof (struct ar_hdr)
+ && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+ != (ssize_t) symtab.longnameslen))
+ goto nonew_unlink;
+
+ /* NULL-terminate the list of files to copy. */
+ struct armem *last = to_copy;
+ to_copy = to_copy->next;
+ last->next = NULL;
+
+ off_t start = -1;
+ off_t len = -1;
+
+ do
+ if (write_member (to_copy, &start, &len, elf, cur_off, newfd) != 0)
+ goto nonew_unlink;
+ while ((to_copy = to_copy->next) != NULL);
+
+ /* Write the last part. */
+ if (copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+ }
+
+ /* Set the mode of the new file to the same values the original file
+ has. */
+ if (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0))
+ goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini ();
+
+ close (fd);
+#endif
+
+ not_found (argc, argv, found);
+
+ return status;
+}
+
+
+static void
+no0print (bool ofmt, char *buf, int bufsize, long int val)
+{
+ char tmpbuf[bufsize + 1];
+ snprintf (tmpbuf, sizeof (tmpbuf), ofmt ? "%-*lo" : "%-*ld", bufsize, val);
+ memcpy (buf, tmpbuf, bufsize);
+}
+
+
+static int
+do_oper_insert (int oper, const char *arfname, char **argv, int argc,
+ const char *member)
+{
+ int status = 0;
+ Elf *elf;
+ struct stat st;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, oper != oper_move);
+
+ /* List of the files we keep. */
+ struct armem *all = NULL;
+ struct armem *after_memberelem = NULL;
+ struct armem **found = alloca (sizeof (*found) * argc);
+ memset (found, '\0', sizeof (*found) * argc);
+
+ arlib_init ();
+
+ if (fd == -1)
+ {
+ if (!suppress_create_msg)
+ fprintf (stderr, "%s: creating %s\n", AR, arfname);
+
+ goto no_old;
+ }
+
+ /* Store the names of all files from the command line in a hash
+ table so that we can match it. Note that when no file name is
+ given we are basically doing nothing except recreating the
+ index. */
+ if (oper != oper_qappend)
+ {
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry;
+ entry.key = full_path ? argv[cnt] : basename (argv[cnt]);
+ entry.data = &argv[cnt];
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+ }
+
+ /* While iterating over the current content of the archive we must
+ determine a number of things: which archive members to keep,
+ which are replaced, and where to insert the new members. */
+ off_t cur_off = SARMAG;
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ /* Ignore the symbol table and the long file name table here. */
+ if (strcmp (arhdr->ar_name, "/") == 0
+ || strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ struct armem *newp = alloca (sizeof (struct armem));
+ newp->old_off = elf_getaroff (subelf);
+ newp->size = arhdr->ar_size;
+ newp->sec = arhdr->ar_date;
+ newp->mem = NULL;
+
+ /* Remember long file names. */
+ size_t ar_namelen = strlen (arhdr->ar_name);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ newp->long_name_off = arlib_add_long_name (arhdr->ar_name, ar_namelen);
+ else
+ newp->long_name_off = -1l;
+
+ /* Check whether this is a file we are looking for. */
+ if (oper != oper_qappend)
+ {
+ /* Check whether this is the member used as the insert point. */
+ if (member != NULL && strcmp (arhdr->ar_name, member) == 0)
+ {
+ /* Note that all == NULL means insert at the beginning. */
+ if (ipos == ipos_before)
+ after_memberelem = all;
+ else
+ after_memberelem = newp;
+ member = NULL;
+ }
+
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && found[(char **) res->data - argv] == NULL)
+ {
+ found[(char **) res->data - argv] = newp;
+
+ /* If we insert before or after a certain element move
+ all files to a special list. */
+ if (unlikely (ipos != ipos_none || oper == oper_move))
+ {
+ if (after_memberelem == newp)
+ /* Since we remove this element even though we should
+ insert everything after it, we in fact insert
+ everything after the previous element. */
+ after_memberelem = all;
+
+ goto next;
+ }
+ }
+ }
+
+ if (all == NULL)
+ all = newp->next = newp;
+ else
+ {
+ newp->next = all->next;
+ all = all->next = newp;
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ if (oper != oper_qappend)
+ hdestroy ();
+
+ no_old:
+ if (member != NULL)
+ error (EXIT_FAILURE, 0, gettext ("position member %s not found"),
+ member);
+
+ if (oper == oper_move)
+ {
+ /* Make sure all requested elements are found in the archive. */
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ if (found[cnt] == NULL)
+ {
+ fprintf (stderr, gettext ("%s: no entry %s in archive!\n"),
+ AR, argv[cnt]);
+ status = 1;
+ }
+
+ if (verbose)
+ printf ("m - %s\n", argv[cnt]);
+ }
+ }
+ else
+ {
+ /* Open all the new files, get their sizes and add all symbols. */
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ const char *bname = basename (argv[cnt]);
+ if (found[cnt] == NULL)
+ {
+ found[cnt] = alloca (sizeof (struct armem));
+ found[cnt]->old_off = -1;
+
+ size_t ar_namelen = strlen (argv[cnt]);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ found[cnt]->long_name_off = arlib_add_long_name (bname,
+ ar_namelen);
+ else
+ found[cnt]->long_name_off = -1l;
+ }
+
+ struct stat newst;
+ Elf *newelf;
+ int newfd = open (argv[cnt], O_RDONLY);
+ if (newfd == -1)
+ {
+ error (0, errno, gettext ("cannot open %s"), argv[cnt]);
+ status = 1;
+ }
+ else if (fstat (newfd, &newst) == -1)
+ {
+ error (0, errno, gettext ("cannot stat %s"), argv[cnt]);
+ close (newfd);
+ status = 1;
+ }
+ else if (!S_ISREG (newst.st_mode))
+ {
+ error (0, errno, gettext ("%s is no regular file"), argv[cnt]);
+ close (newfd);
+ status = 1;
+ }
+ else if (update_newer
+ && found[cnt]->old_off != -1l
+ && found[cnt]->sec > st.st_mtime)
+ /* Do nothing, the file in the archive is younger. */
+ close (newfd);
+ else if ((newelf = elf_begin (newfd, ELF_C_READ_MMAP, NULL))
+ == NULL)
+ {
+ fprintf (stderr,
+ gettext ("cannot get ELF descriptor for %s: %s\n"),
+ argv[cnt], elf_errmsg (-1));
+ status = 1;
+ }
+ else
+ {
+ if (verbose)
+ printf ("%c - %s\n",
+ found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]);
+
+#ifdef DEBUG
+ found[cnt]->elf = newelf;
+#endif
+ found[cnt]->sec = newst.st_mtime;
+ found[cnt]->uid = newst.st_uid;
+ found[cnt]->gid = newst.st_gid;
+ found[cnt]->mode = newst.st_mode;
+ found[cnt]->name = basename (argv[cnt]);
+
+ found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size);
+ if (found[cnt] == NULL || elf_cntl (newelf, ELF_C_FDDONE) != 0)
+ error (EXIT_FAILURE, 0, gettext ("cannot read %s: %s"),
+ argv[cnt], elf_errmsg (-1));
+
+ close (newfd);
+
+ /* Remember long file names. */
+ size_t bnamelen = strlen (bname);
+ if (bnamelen > MAX_AR_NAME_LEN)
+ found[cnt]->long_name_off = arlib_add_long_name (bname,
+ bnamelen);
+ else
+ found[cnt]->long_name_off = -1l;
+ }
+ }
+ }
+
+ if (status != 0)
+ {
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini ();
+
+ close (fd);
+#endif
+
+ return status;
+ }
+
+ /* If we have no entry point so far add at the end. AFTER_MEMBERELEM
+ being NULL when adding before an entry means add at the beginning. */
+ if (ipos != ipos_before && after_memberelem == NULL)
+ after_memberelem = all;
+
+ /* Convert the circular list into a normal list first. */
+ if (all != NULL)
+ {
+ struct armem *tmp = all;
+ all = all->next;
+ tmp->next = NULL;
+ }
+
+ struct armem *last_added = after_memberelem;
+ for (int cnt = 0; cnt < argc; ++cnt)
+ if (oper != oper_replace || found[cnt]->old_off == -1)
+ {
+ if (last_added == NULL)
+ {
+ found[cnt]->next = all;
+ last_added = all = found[cnt];
+ }
+ else
+ {
+ found[cnt]->next = last_added->next;
+ last_added = last_added->next = found[cnt];
+ }
+ }
+
+ /* Finally compute the offset and add the symbols for the files
+ after the insert point. */
+ if (likely (all != NULL))
+ for (struct armem *memp = all; memp != NULL; memp = memp->next)
+ {
+ memp->off = cur_off;
+
+ if (memp->mem == NULL)
+ {
+ Elf_Arhdr *arhdr;
+ /* Fake initializing arhdr and subelf to keep gcc calm. */
+ asm ("" : "=m" (arhdr), "=m" (subelf));
+ if (elf_rand (elf, memp->old_off) == 0
+ || (subelf = elf_begin (fd, ELF_C_READ_MMAP, elf)) == NULL
+ || (arhdr = elf_getarhdr (subelf)) == NULL)
+ /* This should never happen since we already looked at the
+ archive content. But who knows... */
+ error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+
+ arlib_add_symbols (subelf, arfname, arhdr->ar_name, cur_off);
+
+ elf_end (subelf);
+ }
+ else
+ arlib_add_symbols (memp->elf, arfname, memp->name, cur_off);
+
+ cur_off += (((memp->size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
+
+ /* Now we have all the information for the symbol table and long
+ file name table. Construct the final layout. */
+ arlib_finalize ();
+
+ /* Create a new, temporary file in the same directory as the
+ original file. */
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd;
+ if (fd != -1)
+ newfd = mkstemp (tmpfname);
+ else
+ {
+ newfd = open (arfname, O_RDWR | O_CREAT | O_EXCL, DEFFILEMODE);
+ if (newfd == -1 && errno == EEXIST)
+ /* Bah, first the file did not exist, now it does. Restart. */
+ return do_oper_insert (oper, arfname, argv, argc, member);
+ }
+ if (unlikely (newfd == -1))
+ goto nonew;
+
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ nonew_unlink:
+ if (fd != -1)
+ {
+ // XXX Use /prof/self/fd/%d ???
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ }
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ goto errout;
+ }
+
+ /* If the new archive is not empty we actually have something to do. */
+ if (likely (all != NULL))
+ {
+ /* Write the symbol table or the long file name table or both. */
+ if (symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ goto nonew_unlink;
+
+ if (symtab.longnameslen > sizeof (struct ar_hdr)
+ && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+ != (ssize_t) symtab.longnameslen))
+ goto nonew_unlink;
+
+ off_t start = -1;
+ off_t len = -1;
+
+ while (all != NULL)
+ {
+ if (all->mem != NULL)
+ {
+ /* This is a new file. If there is anything from the
+ archive left to be written do it now. */
+ if (start != -1 && copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+
+ start = -1;
+ len = -1;
+
+ /* Create the header. */
+ struct ar_hdr arhdr;
+ char tmpbuf[sizeof (arhdr.ar_name) + 1];
+ if (all->long_name_off == -1)
+ {
+ size_t namelen = strlen (all->name);
+ memset (mempcpy (arhdr.ar_name, all->name, namelen),
+ ' ', sizeof (arhdr.ar_name) - namelen);
+ }
+ else
+ {
+ snprintf (tmpbuf, sizeof (arhdr.ar_name) + 1, "/%-*ld",
+ (int) sizeof (arhdr.ar_name), all->long_name_off);
+ memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+ }
+
+ no0print (false, arhdr.ar_date, sizeof (arhdr.ar_date),
+ all->sec);
+ no0print (false, arhdr.ar_uid, sizeof (arhdr.ar_uid), all->uid);
+ no0print (false, arhdr.ar_gid, sizeof (arhdr.ar_gid), all->gid);
+ no0print (true, arhdr.ar_mode, sizeof (arhdr.ar_mode),
+ all->mode);
+ no0print (false, arhdr.ar_size, sizeof (arhdr.ar_size),
+ all->size);
+ memcpy (arhdr.ar_fmag, ARFMAG, sizeof (arhdr.ar_fmag));
+
+ if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+ != sizeof (arhdr)))
+ goto nonew_unlink;
+
+ /* Now the file itself. */
+ if (unlikely (write_retry (newfd, all->mem, all->size)
+ != (off_t) all->size))
+ goto nonew_unlink;
+
+ /* Pad the file if its size is odd. */
+ if ((all->size & 1) != 0)
+ if (write (newfd, "\n", 1) != 1)
+ goto nonew_unlink;
+ }
+ else
+ {
+ /* This is a member from the archive. */
+ if (write_member (all, &start, &len, elf, cur_off, newfd)
+ != 0)
+ goto nonew_unlink;
+ }
+
+ all = all->next;
+ }
+
+ /* Write the last part. */
+ if (start != -1 && copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+ }
+
+ /* Set the mode of the new file to the same values the original file
+ has. */
+ if (fd != -1
+ && (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0)))
+ goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini ();
+
+ close (fd);
+#endif
+
+ return status;
+}
diff --git a/elfutils/src/arlib.c b/elfutils/src/arlib.c
new file mode 100644
index 00000000..1b8785e4
--- /dev/null
+++ b/elfutils/src/arlib.c
@@ -0,0 +1,272 @@
+/* Functions to handle creation of Linux archives.
+ Copyright (C) 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+ Red Hat elfutils 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; version 2 of the License.
+
+ Red Hat elfutils 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 Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <assert.h>
+#include <error.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* The one symbol table we hanble. */
+struct arlib_symtab symtab;
+
+
+/* Initialize ARLIB_SYMTAB structure. */
+void
+arlib_init (void)
+{
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+ obstack_init (&symtab.symsoffob);
+ obstack_init (&symtab.symsnameob);
+ obstack_init (&symtab.longnamesob);
+
+ /* We add the archive header here as well, that avoids allocating
+ another memory block. */
+ struct ar_hdr ar_hdr;
+ memcpy (ar_hdr.ar_name, "/ ", sizeof (ar_hdr.ar_name));
+ /* Using snprintf here has a problem: the call always wants to add a
+ NUL byte. We could use a trick whereby we specify the target
+ buffer size longer than it is and this would not actually fail,
+ since all the fields are consecutive and we fill them in in
+ sequence (i.e., the NUL byte gets overwritten). But
+ _FORTIFY_SOURCE=2 would not let us play these games. Therefore
+ we play it safe. */
+ char tmpbuf[sizeof (ar_hdr.ar_date) + 1];
+ memcpy (ar_hdr.ar_date, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
+ (int) sizeof (ar_hdr.ar_date),
+ (long long int) time (NULL)));
+ assert ((sizeof (struct ar_hdr) % sizeof (uint32_t)) == 0);
+
+ /* Note the string for the ar_uid and ar_gid cases is longer than
+ necessary. This does not matter since we copy only as much as
+ necessary but it helps the compiler to use the same string for
+ the ar_mode case. */
+ memcpy (ar_hdr.ar_uid, "0 ", sizeof (ar_hdr.ar_uid));
+ memcpy (ar_hdr.ar_gid, "0 ", sizeof (ar_hdr.ar_gid));
+ memcpy (ar_hdr.ar_mode, "0 ", sizeof (ar_hdr.ar_mode));
+ memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
+
+ /* Add the archive header to the file content. */
+ obstack_grow (&symtab.symsoffob, &ar_hdr, sizeof (ar_hdr));
+
+ /* The first word in the offset table specifies the size. Create
+ such an entry now. The real value will be filled-in later. For
+ all supported platforms the following is true. */
+ assert (sizeof (uint32_t) == sizeof (int));
+ obstack_int_grow (&symtab.symsoffob, 0);
+
+ /* The long name obstack also gets its archive header. As above,
+ some of the input strings are longer than required but we only
+ copy the necessary part. */
+ memcpy (ar_hdr.ar_name, "// ", sizeof (ar_hdr.ar_name));
+ memcpy (ar_hdr.ar_date, " ", sizeof (ar_hdr.ar_date));
+ memcpy (ar_hdr.ar_uid, " ", sizeof (ar_hdr.ar_uid));
+ memcpy (ar_hdr.ar_gid, " ", sizeof (ar_hdr.ar_gid));
+ memcpy (ar_hdr.ar_mode, " ", sizeof (ar_hdr.ar_mode));
+ /* The ar_size field will be filled in later and ar_fmag is already OK. */
+ obstack_grow (&symtab.longnamesob, &ar_hdr, sizeof (ar_hdr));
+
+ /* All other members are zero. */
+ symtab.symsofflen = 0;
+ symtab.symsoff = NULL;
+ symtab.symsnamelen = 0;
+ symtab.symsname = NULL;
+}
+
+
+/* Finalize ARLIB_SYMTAB content. */
+void
+arlib_finalize (void)
+{
+ char tmpbuf[sizeof (((struct ar_hdr *) NULL)->ar_size) + 1];
+
+ symtab.longnameslen = obstack_object_size (&symtab.longnamesob);
+ if (symtab.longnameslen != sizeof (struct ar_hdr))
+ {
+ symtab.longnames = obstack_finish (&symtab.longnamesob);
+
+ memcpy (&((struct ar_hdr *) symtab.longnames)->ar_size, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+ (int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+ symtab.longnameslen - sizeof (struct ar_hdr)));
+ }
+
+ symtab.symsofflen = obstack_object_size (&symtab.symsoffob);
+ assert (symtab.symsofflen % sizeof (uint32_t) == 0);
+ if (symtab.symsofflen != 0)
+ {
+ symtab.symsoff = (uint32_t *) obstack_finish (&symtab.symsoffob);
+
+ /* Fill in the number of offsets now. */
+ symtab.symsoff[AR_HDR_WORDS] = le_bswap_32 ((symtab.symsofflen
+ - sizeof (struct ar_hdr))
+ / sizeof (uint32_t) - 1);
+ }
+
+ symtab.symsnamelen = obstack_object_size (&symtab.symsnameob);
+ if ((symtab.symsnamelen & 1) != 0)
+ {
+ /* Add one more NUL byte to make length even. */
+ obstack_grow (&symtab.symsnameob, "", 1);
+ ++symtab.symsnamelen;
+ }
+ symtab.symsname = obstack_finish (&symtab.symsnameob);
+
+ /* Determine correction for the offsets in the symbol table. */
+ off_t disp = 0;
+ if (symtab.symsnamelen > 0)
+ disp = symtab.symsofflen + symtab.symsnamelen;
+ if (symtab.longnameslen > sizeof (struct ar_hdr))
+ disp += symtab.longnameslen;
+
+ if (disp != 0 && symtab.symsoff != NULL)
+ {
+ uint32_t nsyms = le_bswap_32 (symtab.symsoff[AR_HDR_WORDS]);
+
+ for (uint32_t cnt = 1; cnt <= nsyms; ++cnt)
+ {
+ uint32_t val = le_bswap_32 (symtab.symsoff[AR_HDR_WORDS + cnt]);
+ val += disp;
+ symtab.symsoff[AR_HDR_WORDS + cnt] = le_bswap_32 (val);
+ }
+ }
+
+ /* See comment for ar_date above. */
+ memcpy (&((struct ar_hdr *) symtab.symsoff)->ar_size, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+ (int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+ symtab.symsofflen + symtab.symsnamelen
+ - sizeof (struct ar_hdr)));
+}
+
+
+/* Free resources for ARLIB_SYMTAB. */
+void
+arlib_fini (void)
+{
+ obstack_free (&symtab.symsoffob, NULL);
+ obstack_free (&symtab.symsnameob, NULL);
+ obstack_free (&symtab.longnamesob, NULL);
+}
+
+
+/* Add name a file offset of a symbol. */
+void
+arlib_add_symref (const char *symname, off_t symoff)
+{
+ /* For all supported platforms the following is true. */
+ assert (sizeof (uint32_t) == sizeof (int));
+ obstack_int_grow (&symtab.symsoffob, (int) le_bswap_32 (symoff));
+
+ size_t symname_len = strlen (symname) + 1;
+ obstack_grow (&symtab.symsnameob, symname, symname_len);
+}
+
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB. */
+void
+arlib_add_symbols (Elf *elf, const char *arfname, const char *membername,
+ off_t off)
+{
+ if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
+ /* The archive is too big. */
+ error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"),
+ arfname);
+
+ /* We only add symbol tables for ELF files. It makes not much sense
+ to add symbols from executables but we do so for compatibility.
+ For DSOs and executables we use the dynamic symbol table, for
+ relocatable files all the DT_SYMTAB tables. */
+ if (elf_kind (elf) != ELF_K_ELF)
+ return;
+
+ GElf_Ehdr ehdr_mem;
+ GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
+ if (ehdr == NULL)
+ error (EXIT_FAILURE, 0, gettext ("cannot read ELF header of %s(%s): %s"),
+ arfname, membername, elf_errmsg (-1));
+
+ GElf_Word symtype;
+ if (ehdr->e_type == ET_REL)
+ symtype = SHT_SYMTAB;
+ else if (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
+ symtype = SHT_DYNSYM;
+ else
+ /* We do not handle that type. */
+ return;
+
+ /* Iterate over all sections. */
+ Elf_Scn *scn = NULL;
+ while ((scn = elf_nextscn (elf, scn)) != NULL)
+ {
+ /* Get the section header. */
+ GElf_Shdr shdr_mem;
+ GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+ if (shdr == NULL)
+ continue;
+
+ if (shdr->sh_type != symtype)
+ continue;
+
+ Elf_Data *data = elf_getdata (scn, NULL);
+ if (data == NULL)
+ continue;
+
+ int nsyms = shdr->sh_size / shdr->sh_entsize;
+ for (int ndx = shdr->sh_info; ndx < nsyms; ++ndx)
+ {
+ GElf_Sym sym_mem;
+ GElf_Sym *sym = gelf_getsym (data, ndx, &sym_mem);
+ if (sym == NULL)
+ continue;
+
+ /* Ignore undefined symbols. */
+ if (sym->st_shndx == SHN_UNDEF)
+ continue;
+
+ /* Use this symbol. */
+ const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
+ if (symname != NULL)
+ arlib_add_symref (symname, off);
+ }
+
+ /* Only relocatable files can have more than one symbol table. */
+ if (ehdr->e_type != ET_REL)
+ break;
+ }
+}
diff --git a/elfutils/src/arlib.h b/elfutils/src/arlib.h
new file mode 100644
index 00000000..af8e8e42
--- /dev/null
+++ b/elfutils/src/arlib.h
@@ -0,0 +1,95 @@
+/* Copyright (C) 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+ Red Hat elfutils 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; version 2 of the License.
+
+ Red Hat elfutils 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 Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifndef _ARLIB_H
+#define _ARLIB_H 1
+
+#include <ar.h>
+#include <byteswap.h>
+#include <endian.h>
+#include <libelf.h>
+#include <obstack.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+
+/* Maximum length of a file name that fits directly into the ar header. */
+#define MAX_AR_NAME_LEN (sizeof (((struct ar_hdr *) NULL)->ar_name))
+
+
+/* Words matching in size to archive header. */
+#define AR_HDR_WORDS (sizeof (struct ar_hdr) / sizeof (uint32_t))
+
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+# define le_bswap_32(val) bswap_32 (val)
+#else
+# define le_bswap_32(val) (val)
+#endif
+
+
+/* Symbol table type. */
+struct arlib_symtab
+{
+ /* Symbol table handling. */
+ struct obstack symsoffob;
+ struct obstack symsnameob;
+ size_t symsofflen;
+ uint32_t *symsoff;
+ size_t symsnamelen;
+ char *symsname;
+
+ /* Long filename handling. */
+ struct obstack longnamesob;
+ size_t longnameslen;
+ char *longnames;
+};
+
+
+/* Global variable with symbol table. */
+extern struct arlib_symtab symtab;
+
+
+/* Initialize ARLIB_SYMTAB structure. */
+extern void arlib_init (void);
+
+/* Finalize ARLIB_SYMTAB content. */
+extern void arlib_finalize (void);
+
+/* Free resources for ARLIB_SYMTAB. */
+extern void arlib_fini (void);
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB. */
+extern void arlib_add_symbols (Elf *elf, const char *arfname,
+ const char *membername, off_t off);
+
+/* Add name a file offset of a symbol. */
+extern void arlib_add_symref (const char *symname, off_t symoff);
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+ SYMTAB. Return the offset into the long file name table. */
+extern long int arlib_add_long_name (const char *filename, size_t filenamelen);
+
+#endif /* arlib.h */
diff --git a/elfutils/src/arlib2.c b/elfutils/src/arlib2.c
new file mode 100644
index 00000000..47edb356
--- /dev/null
+++ b/elfutils/src/arlib2.c
@@ -0,0 +1,50 @@
+/* Functions to handle creation of Linux archives.
+ Copyright (C) 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+ Red Hat elfutils 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; version 2 of the License.
+
+ Red Hat elfutils 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 Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <error.h>
+#include <libintl.h>
+#include <limits.h>
+#include <string.h>
+#include <sys/param.h>
+
+#include "arlib.h"
+
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+ SYMTAB. Return the offset into the long file name table. */
+long int
+arlib_add_long_name (const char *filename, size_t filenamelen)
+{
+ int retval = obstack_object_size (&symtab.longnamesob);
+
+ obstack_grow (&symtab.longnamesob, filename, filenamelen);
+ obstack_grow (&symtab.longnamesob, "/\n", 2);
+
+ return retval;
+}
diff --git a/elfutils/src/elfcmp.c b/elfutils/src/elfcmp.c
index 0bfd0869..c5023b9e 100644
--- a/elfutils/src/elfcmp.c
+++ b/elfutils/src/elfcmp.c
@@ -1,5 +1,5 @@
/* Compare relevant content of two ELF files.
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -507,7 +507,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/elflint.c b/elfutils/src/elflint.c
index 57dd716a..09c7fbd2 100644
--- a/elfutils/src/elflint.c
+++ b/elfutils/src/elflint.c
@@ -1,5 +1,5 @@
/* Pedantic checking of ELF files compliance with gABI/psABI spec.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2001.
@@ -233,7 +233,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
@@ -731,9 +731,22 @@ section [%2d] '%s': symbol %zu: function in COMMON section is nonsense\n"),
{
if ((sym->st_value - destshdr->sh_addr)
> destshdr->sh_size)
- ERROR (gettext ("\
+ {
+ /* GNU ld has severe bugs. When it decides to remove
+ empty sections it leaves symbols referencing them
+ behind. These are symbols in .symtab. */
+ if (!gnuld
+ || strcmp (section_name (ebl, idx), ".symtab")
+ || (strcmp (name, "__preinit_array_start") != 0
+ && strcmp (name, "__preinit_array_end") != 0
+ && strcmp (name, "__init_array_start") != 0
+ && strcmp (name, "__init_array_end") != 0
+ && strcmp (name, "__fini_array_start") != 0
+ && strcmp (name, "__fini_array_end") != 0))
+ ERROR (gettext ("\
section [%2d] '%s': symbol %zu: st_value out of bounds\n"),
- idx, section_name (ebl, idx), cnt);
+ idx, section_name (ebl, idx), cnt);
+ }
else if ((sym->st_value - destshdr->sh_addr
+ sym->st_size) > destshdr->sh_size)
ERROR (gettext ("\
@@ -2162,6 +2175,141 @@ section [%2d] '%s': hash table has not even room for initial administrative entr
}
+/* Compare content of both hash tables, it must be identical. */
+static void
+compare_hash_gnu_hash (Ebl *ebl, GElf_Ehdr *ehdr, size_t hash_idx,
+ size_t gnu_hash_idx)
+{
+ Elf_Scn *hash_scn = elf_getscn (ebl->elf, hash_idx);
+ Elf_Data *hash_data = elf_getdata (hash_scn, NULL);
+ GElf_Shdr hash_shdr_mem;
+ GElf_Shdr *hash_shdr = gelf_getshdr (hash_scn, &hash_shdr_mem);
+ Elf_Scn *gnu_hash_scn = elf_getscn (ebl->elf, gnu_hash_idx);
+ Elf_Data *gnu_hash_data = elf_getdata (gnu_hash_scn, NULL);
+ GElf_Shdr gnu_hash_shdr_mem;
+ GElf_Shdr *gnu_hash_shdr = gelf_getshdr (gnu_hash_scn, &gnu_hash_shdr_mem);
+
+ if (hash_shdr == NULL || gnu_hash_shdr == NULL
+ || hash_data == NULL || gnu_hash_data == NULL)
+ /* None of these pointers should be NULL since we used the
+ sections already. We are careful nonetheless. */
+ return;
+
+ /* The link must point to the same symbol table. */
+ if (hash_shdr->sh_link != gnu_hash_shdr->sh_link)
+ {
+ ERROR (gettext ("\
+sh_link in hash sections [%2zu] '%s' and [%2zu] '%s' not identical\n"),
+ hash_idx, elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name),
+ gnu_hash_idx,
+ elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
+ return;
+ }
+
+ Elf_Scn *sym_scn = elf_getscn (ebl->elf, hash_shdr->sh_link);
+ Elf_Data *sym_data = elf_getdata (sym_scn, NULL);
+ GElf_Shdr sym_shdr_mem;
+ GElf_Shdr *sym_shdr = gelf_getshdr (sym_scn, &sym_shdr_mem);
+
+ if (sym_data == NULL || sym_shdr == NULL)
+ return;
+
+ int nentries = sym_shdr->sh_size / sym_shdr->sh_entsize;
+ char *used = alloca (nentries);
+ memset (used, '\0', nentries);
+
+ /* First go over the GNU_HASH table and mark the entries as used. */
+ const Elf32_Word *gnu_hasharr = (Elf32_Word *) gnu_hash_data->d_buf;
+ Elf32_Word gnu_nbucket = gnu_hasharr[0];
+ const int bitmap_factor = ehdr->e_ident[EI_CLASS] == ELFCLASS32 ? 1 : 2;
+ const Elf32_Word *gnu_bucket = (gnu_hasharr
+ + (4 + gnu_hasharr[2] * bitmap_factor));
+ const Elf32_Word *gnu_chain = gnu_bucket + gnu_hasharr[0] - gnu_hasharr[1];
+
+ for (Elf32_Word cnt = 0; cnt < gnu_nbucket; ++cnt)
+ {
+ Elf32_Word symidx = gnu_bucket[cnt];
+ if (symidx != STN_UNDEF)
+ do
+ used[symidx] |= 1;
+ while ((gnu_chain[symidx++] & 1u) == 0);
+ }
+
+ /* Now go over the old hash table and check that we cover the same
+ entries. */
+ if (hash_shdr->sh_entsize == sizeof (Elf32_Word))
+ {
+ const Elf32_Word *hasharr = (Elf32_Word *) hash_data->d_buf;
+ Elf32_Word nbucket = hasharr[0];
+ const Elf32_Word *bucket = &hasharr[2];
+ const Elf32_Word *chain = &hasharr[2 + nbucket];
+
+ for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
+ {
+ Elf32_Word symidx = bucket[cnt];
+ while (symidx != STN_UNDEF)
+ {
+ used[symidx] |= 2;
+ symidx = chain[symidx];
+ }
+ }
+ }
+ else
+ {
+ const Elf64_Xword *hasharr = (Elf64_Xword *) hash_data->d_buf;
+ Elf64_Xword nbucket = hasharr[0];
+ const Elf64_Xword *bucket = &hasharr[2];
+ const Elf64_Xword *chain = &hasharr[2 + nbucket];
+
+ for (Elf64_Xword cnt = 0; cnt < nbucket; ++cnt)
+ {
+ Elf64_Xword symidx = bucket[cnt];
+ while (symidx != STN_UNDEF)
+ {
+ used[symidx] |= 2;
+ symidx = chain[symidx];
+ }
+ }
+ }
+
+ /* Now see which entries are not set in one or both hash tables
+ (unless the symbol is undefined in which case it can be omitted
+ in the new table format). */
+ if ((used[0] & 1) != 0)
+ ERROR (gettext ("section [%2zu] '%s': reference to symbol index 0\n"),
+ gnu_hash_idx,
+ elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
+ if ((used[0] & 2) != 0)
+ ERROR (gettext ("section [%2zu] '%s': reference to symbol index 0\n"),
+ hash_idx, elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name));
+
+ for (int cnt = 1; cnt < nentries; ++cnt)
+ if (used[cnt] != 0 && used[cnt] != 3)
+ {
+ if (used[cnt] == 1)
+ ERROR (gettext ("\
+symbol %d referenced in new hash table in [%2zu] '%s' but not in old hash table in [%2zu] '%s'\n"),
+ cnt, gnu_hash_idx,
+ elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name),
+ hash_idx,
+ elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name));
+ else
+ {
+ GElf_Sym sym_mem;
+ GElf_Sym *sym = gelf_getsym (sym_data, cnt, &sym_mem);
+
+ if (sym != NULL && sym->st_shndx != STN_UNDEF)
+ ERROR (gettext ("\
+symbol %d referenced in old hash table in [%2zu] '%s' but not in new hash table in [%2zu] '%s'\n"),
+ cnt, hash_idx,
+ elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name),
+ gnu_hash_idx,
+ elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
+ }
+ }
+}
+
+
static void
check_null (Ebl *ebl, GElf_Shdr *shdr, int idx)
{
@@ -3026,6 +3174,9 @@ zeroth section has nonzero link value while ELF header does not signal overflow
bool dot_interp_section = false;
+ size_t hash_idx = 0;
+ size_t gnu_hash_idx = 0;
+
size_t versym_scnndx = 0;
for (size_t cnt = 1; cnt < shnum; ++cnt)
{
@@ -3187,12 +3338,25 @@ section [%2zu] '%s': size not multiple of entry size\n"),
#define ALL_SH_FLAGS (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR | SHF_MERGE \
| SHF_STRINGS | SHF_INFO_LINK | SHF_LINK_ORDER \
| SHF_OS_NONCONFORMING | SHF_GROUP | SHF_TLS)
- if (shdr->sh_flags & ~ALL_SH_FLAGS)
- ERROR (gettext ("section [%2zu] '%s' contains unknown flag(s)"
- " %#" PRIx64 "\n"),
- cnt, section_name (ebl, cnt),
- (uint64_t) shdr->sh_flags & ~(uint64_t) ALL_SH_FLAGS);
- else if (shdr->sh_flags & SHF_TLS)
+ if (shdr->sh_flags & ~(GElf_Xword) ALL_SH_FLAGS)
+ {
+ GElf_Xword sh_flags = shdr->sh_flags & ~(GElf_Xword) ALL_SH_FLAGS;
+ if (sh_flags & SHF_MASKPROC)
+ {
+ if (!ebl_machine_section_flag_check (ebl,
+ sh_flags & SHF_MASKPROC))
+ ERROR (gettext ("section [%2zu] '%s'"
+ " contains invalid processor-specific flag(s)"
+ " %#" PRIx64 "\n"),
+ cnt, section_name (ebl, cnt), sh_flags & SHF_MASKPROC);
+ sh_flags &= ~(GElf_Xword) SHF_MASKPROC;
+ }
+ if (sh_flags != 0)
+ ERROR (gettext ("section [%2zu] '%s' contains unknown flag(s)"
+ " %#" PRIx64 "\n"),
+ cnt, section_name (ebl, cnt), sh_flags);
+ }
+ if (shdr->sh_flags & SHF_TLS)
{
// XXX Correct?
if (shdr->sh_addr != 0 && !gnuld)
@@ -3313,8 +3477,13 @@ section [%2zu] '%s': relocatable files cannot have dynamic symbol tables\n"),
break;
case SHT_HASH:
+ check_hash (shdr->sh_type, ebl, ehdr, shdr, cnt);
+ hash_idx = cnt;
+ break;
+
case SHT_GNU_HASH:
check_hash (shdr->sh_type, ebl, ehdr, shdr, cnt);
+ gnu_hash_idx = cnt;
break;
case SHT_NULL:
@@ -3384,6 +3553,9 @@ no .gnu.versym section present but .gnu.versym_d or .gnu.versym_r section exist\
ERROR (gettext ("\
.gnu.versym section present without .gnu.versym_d or .gnu.versym_r\n"));
+ if (hash_idx != 0 && gnu_hash_idx != 0)
+ compare_hash_gnu_hash (ebl, ehdr, hash_idx, gnu_hash_idx);
+
free (scnref);
}
@@ -3683,7 +3855,8 @@ loadable segment GNU_RELRO applies to is executable\n"));
program header offset in ELF header and PHDR entry do not match"));
}
- if (phdr->p_filesz > phdr->p_memsz)
+ if (phdr->p_filesz > phdr->p_memsz
+ && (phdr->p_memsz != 0 || phdr->p_type != PT_NOTE))
ERROR (gettext ("\
program header entry %d: file size greater than memory size\n"),
cnt);
diff --git a/elfutils/src/findtextrel.c b/elfutils/src/findtextrel.c
index 0acb0cc0..189da8d5 100644
--- a/elfutils/src/findtextrel.c
+++ b/elfutils/src/findtextrel.c
@@ -1,5 +1,5 @@
/* Locate source files or functions which caused text relocations.
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -169,7 +169,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/ld.c b/elfutils/src/ld.c
index 61627e58..b1020a53 100644
--- a/elfutils/src/ld.c
+++ b/elfutils/src/ld.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+/* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2001.
@@ -870,7 +870,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/ldscript.c b/elfutils/src/ldscript.c
index 063b792e..84bac4cd 100644
--- a/elfutils/src/ldscript.c
+++ b/elfutils/src/ldscript.c
@@ -1,7 +1,9 @@
-/* A Bison parser, made by GNU Bison 2.1. */
+/* A Bison parser, made by GNU Bison 2.3. */
-/* Skeleton parser for Yacc-like parsing with Bison,
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 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
@@ -18,13 +20,21 @@
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
-/* As a special exception, when this file is copied by Bison into a
- Bison output file, you may use that output file without restriction.
- This special exception was added by the Free Software Foundation
- in version 1.24 of Bison. */
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
-/* Written by Richard Stallman by simplifying the original so called
- ``semantic'' parser. */
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
@@ -37,7 +47,7 @@
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "2.1"
+#define YYBISON_VERSION "2.3"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
@@ -215,9 +225,10 @@ extern int yylex (void);
# define YYTOKEN_TABLE 0
#endif
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
#line 71 "/home/drepper/devel/elfutils/src/ldscript.y"
-typedef union YYSTYPE {
+{
uintmax_t num;
enum expression_tag op;
char *str;
@@ -230,9 +241,10 @@ typedef union YYSTYPE {
struct filename_list *filename_list;
struct version *version;
struct id_list *id_list;
-} YYSTYPE;
-/* Line 196 of yacc.c. */
-#line 236 "ldscript.c"
+}
+/* Line 193 of yacc.c. */
+#line 247 "ldscript.c"
+ YYSTYPE;
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
@@ -243,23 +255,56 @@ typedef union YYSTYPE {
/* Copy the second part of user declarations. */
-/* Line 219 of yacc.c. */
-#line 248 "ldscript.c"
+/* Line 216 of yacc.c. */
+#line 260 "ldscript.c"
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
#endif
-#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
#endif
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
#ifndef YY_
# if YYENABLE_NLS
# if ENABLE_NLS
@@ -272,7 +317,32 @@ typedef union YYSTYPE {
# endif
#endif
-#if ! defined (yyoverflow) || YYERROR_VERBOSE
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions. */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+ int i;
+#endif
+{
+ return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
@@ -280,64 +350,76 @@ typedef union YYSTYPE {
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
-# if defined (__STDC__) || defined (__cplusplus)
+# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# define YYINCLUDED_STDLIB_H
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
- /* Pacify GCC's `empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
-# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
-# ifdef __cplusplus
-extern "C" {
+# if (defined __cplusplus && ! defined _STDLIB_H \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
-# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
- && (defined (__STDC__) || defined (__cplusplus)))
+# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
-# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
- && (defined (__STDC__) || defined (__cplusplus)))
+# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
-# ifdef __cplusplus
-}
-# endif
# endif
-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-#if (! defined (yyoverflow) \
- && (! defined (__cplusplus) \
- || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
- short int yyss;
+ yytype_int16 yyss;
YYSTYPE yyvs;
};
@@ -347,13 +429,13 @@ union yyalloc
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
- ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
/* Copy COUNT objects from FROM to TO. The source and destination do
not overlap. */
# ifndef YYCOPY
-# if defined (__GNUC__) && 1 < __GNUC__
+# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
@@ -364,7 +446,7 @@ union yyalloc
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
- while (0)
+ while (YYID (0))
# endif
# endif
@@ -382,28 +464,22 @@ union yyalloc
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
- while (0)
+ while (YYID (0))
#endif
-#if defined (__STDC__) || defined (__cplusplus)
- typedef signed char yysigned_char;
-#else
- typedef short int yysigned_char;
-#endif
-
-/* YYFINAL -- State number of the termination state. */
+/* YYFINAL -- State number of the termination state. */
#define YYFINAL 32
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 226
-/* YYNTOKENS -- Number of terminals. */
+/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 40
-/* YYNNTS -- Number of nonterminals. */
+/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 23
-/* YYNRULES -- Number of rules. */
+/* YYNRULES -- Number of rules. */
#define YYNRULES 66
-/* YYNRULES -- Number of states. */
+/* YYNRULES -- Number of states. */
#define YYNSTATES 159
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
@@ -414,7 +490,7 @@ union yyalloc
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
-static const unsigned char yytranslate[] =
+static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -450,7 +526,7 @@ static const unsigned char yytranslate[] =
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-static const unsigned char yyprhs[] =
+static const yytype_uint8 yyprhs[] =
{
0, 0, 3, 5, 8, 11, 13, 19, 25, 31,
37, 43, 49, 54, 59, 64, 69, 74, 77, 79,
@@ -461,8 +537,8 @@ static const unsigned char yyprhs[] =
224, 227, 231, 234, 236, 238, 240
};
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const yysigned_char yyrhs[] =
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yytype_int8 yyrhs[] =
{
41, 0, -1, 42, -1, 27, 56, -1, 42, 43,
-1, 43, -1, 6, 33, 11, 34, 35, -1, 22,
@@ -492,7 +568,7 @@ static const yysigned_char yyrhs[] =
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
-static const unsigned short int yyrline[] =
+static const yytype_uint16 yyrline[] =
{
0, 143, 143, 144, 148, 149, 152, 157, 161, 166,
172, 176, 182, 193, 195, 197, 199, 203, 208, 212,
@@ -506,7 +582,7 @@ static const unsigned short int yyrline[] =
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "kADD_OP", "kALIGN", "kAS_NEEDED",
@@ -527,7 +603,7 @@ static const char *const yytname[] =
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
-static const unsigned short int yytoknum[] =
+static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
@@ -537,7 +613,7 @@ static const unsigned short int yytoknum[] =
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const unsigned char yyr1[] =
+static const yytype_uint8 yyr1[] =
{
0, 40, 41, 41, 42, 42, 43, 43, 43, 43,
43, 43, 43, 43, 43, 43, 43, 44, 44, 45,
@@ -549,7 +625,7 @@ static const unsigned char yyr1[] =
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
-static const unsigned char yyr2[] =
+static const yytype_uint8 yyr2[] =
{
0, 2, 1, 2, 2, 1, 5, 5, 5, 5,
5, 5, 4, 4, 4, 4, 4, 2, 1, 2,
@@ -563,7 +639,7 @@ static const unsigned char yyr2[] =
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
means the default is an error. */
-static const unsigned char yydefact[] =
+static const yytype_uint8 yydefact[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 2, 5, 0, 0, 0, 0, 0,
@@ -583,8 +659,8 @@ static const unsigned char yydefact[] =
0, 34, 23, 0, 0, 29, 32, 0, 31
};
-/* YYDEFGOTO[NTERM-NUM]. */
-static const short int yydefgoto[] =
+/* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
{
-1, 12, 13, 14, 69, 70, 71, 106, 107, 108,
150, 137, 116, 36, 59, 37, 29, 30, 51, 52,
@@ -594,7 +670,7 @@ static const short int yydefgoto[] =
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -86
-static const short int yypact[] =
+static const yytype_int16 yypact[] =
{
111, -18, -14, 23, 45, 70, 75, 85, 92, 97,
91, 19, 128, 134, -86, 162, 96, 162, 162, 5,
@@ -615,7 +691,7 @@ static const short int yypact[] =
};
/* YYPGOTO[NTERM-NUM]. */
-static const short int yypgoto[] =
+static const yytype_int16 yypgoto[] =
{
-86, -86, -86, 192, 168, 80, -85, -86, 102, 89,
-86, -86, 33, -16, -86, 153, 186, 38, 170, -39,
@@ -627,7 +703,7 @@ static const short int yypgoto[] =
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -1
-static const unsigned char yytable[] =
+static const yytype_uint8 yytable[] =
{
31, 40, 41, 128, 38, 105, 38, 38, 42, 43,
128, 45, 80, 26, 31, 15, 27, 129, 31, 16,
@@ -654,7 +730,7 @@ static const unsigned char yytable[] =
0, 0, 0, 0, 81, 0, 78
};
-static const short int yycheck[] =
+static const yytype_int16 yycheck[] =
{
11, 17, 18, 3, 15, 90, 17, 18, 19, 20,
3, 22, 51, 8, 25, 33, 11, 17, 29, 33,
@@ -683,7 +759,7 @@ static const short int yycheck[] =
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
-static const unsigned char yystos[] =
+static const yytype_uint8 yystos[] =
{
0, 5, 6, 10, 12, 13, 19, 20, 22, 23,
26, 27, 41, 42, 43, 33, 33, 33, 33, 33,
@@ -728,7 +804,7 @@ do \
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
- YYPOPSTACK; \
+ YYPOPSTACK (1); \
goto yybackup; \
} \
else \
@@ -736,7 +812,7 @@ do \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
-while (0)
+while (YYID (0))
#define YYTERROR 1
@@ -751,7 +827,7 @@ while (0)
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
- if (N) \
+ if (YYID (N)) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
@@ -765,7 +841,7 @@ while (0)
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
- while (0)
+ while (YYID (0))
#endif
@@ -777,8 +853,8 @@ while (0)
# if YYLTYPE_IS_TRIVIAL
# define YY_LOCATION_PRINT(File, Loc) \
fprintf (File, "%d.%d-%d.%d", \
- (Loc).first_line, (Loc).first_column, \
- (Loc).last_line, (Loc).last_column)
+ (Loc).first_line, (Loc).first_column, \
+ (Loc).last_line, (Loc).last_column)
# else
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
@@ -805,36 +881,96 @@ while (0)
do { \
if (yydebug) \
YYFPRINTF Args; \
-} while (0)
+} while (YYID (0))
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yysymprint (stderr, \
- Type, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+#endif
+{
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+ YYUSE (yyoutput);
+# endif
+ switch (yytype)
+ {
+ default:
+ break;
+ }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+#endif
+{
+ if (yytype < YYNTOKENS)
+ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ else
+ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+ YYFPRINTF (yyoutput, ")");
+}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
-yy_stack_print (short int *bottom, short int *top)
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
#else
static void
yy_stack_print (bottom, top)
- short int *bottom;
- short int *top;
+ yytype_int16 *bottom;
+ yytype_int16 *top;
#endif
{
YYFPRINTF (stderr, "Stack now");
- for (/* Nothing. */; bottom <= top; ++bottom)
+ for (; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
YYFPRINTF (stderr, "\n");
}
@@ -843,37 +979,45 @@ yy_stack_print (bottom, top)
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
-} while (0)
+} while (YYID (0))
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
-yy_reduce_print (int yyrule)
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
-yy_reduce_print (yyrule)
+yy_reduce_print (yyvsp, yyrule)
+ YYSTYPE *yyvsp;
int yyrule;
#endif
{
+ int yynrhs = yyr2[yyrule];
int yyi;
unsigned long int yylno = yyrline[yyrule];
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
- yyrule - 1, yylno);
- /* Print the symbols being reduced, and their result. */
- for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
- YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
- YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ fprintf (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ );
+ fprintf (stderr, "\n");
+ }
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
- yy_reduce_print (Rule); \
-} while (0)
+ yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
@@ -907,42 +1051,44 @@ int yydebug;
#if YYERROR_VERBOSE
# ifndef yystrlen
-# if defined (__GLIBC__) && defined (_STRING_H)
+# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
-# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
-# else
+#else
+static YYSIZE_T
yystrlen (yystr)
- const char *yystr;
-# endif
+ const char *yystr;
+#endif
{
- const char *yys = yystr;
-
- while (*yys++ != '\0')
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
continue;
-
- return yys - yystr - 1;
+ return yylen;
}
# endif
# endif
# ifndef yystpcpy
-# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static char *
-# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
-# else
+#else
+static char *
yystpcpy (yydest, yysrc)
- char *yydest;
- const char *yysrc;
-# endif
+ char *yydest;
+ const char *yysrc;
+#endif
{
char *yyd = yydest;
const char *yys = yysrc;
@@ -968,7 +1114,7 @@ yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
- size_t yyn = 0;
+ YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
@@ -1003,53 +1149,123 @@ yytnamerr (char *yyres, const char *yystr)
}
# endif
-#endif /* YYERROR_VERBOSE */
-
-
-
-#if YYDEBUG
-/*--------------------------------.
-| Print this symbol on YYOUTPUT. |
-`--------------------------------*/
-
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yysymprint (yyoutput, yytype, yyvaluep)
- FILE *yyoutput;
- int yytype;
- YYSTYPE *yyvaluep;
-#endif
+/* Copy into YYRESULT an error message about the unexpected token
+ YYCHAR while in state YYSTATE. Return the number of bytes copied,
+ including the terminating null byte. If YYRESULT is null, do not
+ copy anything; just return the number of bytes that would be
+ copied. As a special case, return 0 if an ordinary "syntax error"
+ message will do. Return YYSIZE_MAXIMUM if overflow occurs during
+ size calculation. */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
{
- /* Pacify ``unused variable'' warnings. */
- (void) yyvaluep;
+ int yyn = yypact[yystate];
- if (yytype < YYNTOKENS)
- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+ return 0;
else
- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+ {
+ int yytype = YYTRANSLATE (yychar);
+ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+ YYSIZE_T yysize = yysize0;
+ YYSIZE_T yysize1;
+ int yysize_overflow = 0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ int yyx;
+
+# if 0
+ /* This is so xgettext sees the translatable formats that are
+ constructed on the fly. */
+ YY_("syntax error, unexpected %s");
+ YY_("syntax error, unexpected %s, expecting %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+ char *yyfmt;
+ char const *yyf;
+ static char const yyunexpected[] = "syntax error, unexpected %s";
+ static char const yyexpecting[] = ", expecting %s";
+ static char const yyor[] = " or %s";
+ char yyformat[sizeof yyunexpected
+ + sizeof yyexpecting - 1
+ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+ * (sizeof yyor - 1))];
+ char const *yyprefix = yyexpecting;
+
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yycount = 1;
+
+ yyarg[0] = yytname[yytype];
+ yyfmt = yystpcpy (yyformat, yyunexpected);
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ yyformat[sizeof yyunexpected - 1] = '\0';
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
+ yyfmt = yystpcpy (yyfmt, yyprefix);
+ yyprefix = yyor;
+ }
+ yyf = YY_(yyformat);
+ yysize1 = yysize + yystrlen (yyf);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
-# ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# endif
- switch (yytype)
- {
- default:
- break;
+ if (yysize_overflow)
+ return YYSIZE_MAXIMUM;
+
+ if (yyresult)
+ {
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ char *yyp = yyresult;
+ int yyi = 0;
+ while ((*yyp = *yyf) != '\0')
+ {
+ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyf += 2;
+ }
+ else
+ {
+ yyp++;
+ yyf++;
+ }
+ }
+ }
+ return yysize;
}
- YYFPRINTF (yyoutput, ")");
}
+#endif /* YYERROR_VERBOSE */
+
-#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
-#if defined (__STDC__) || defined (__cplusplus)
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
@@ -1060,8 +1276,7 @@ yydestruct (yymsg, yytype, yyvaluep)
YYSTYPE *yyvaluep;
#endif
{
- /* Pacify ``unused variable'' warnings. */
- (void) yyvaluep;
+ YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
@@ -1071,7 +1286,7 @@ yydestruct (yymsg, yytype, yyvaluep)
{
default:
- break;
+ break;
}
}
@@ -1079,13 +1294,13 @@ yydestruct (yymsg, yytype, yyvaluep)
/* Prevent warnings from -Wmissing-prototypes. */
#ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
-# else
+#else
int yyparse ();
-# endif
+#endif
#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
@@ -1110,14 +1325,18 @@ int yynerrs;
`----------*/
#ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void *YYPARSE_PARAM)
-# else
-int yyparse (YYPARSE_PARAM)
- void *YYPARSE_PARAM;
-# endif
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+ void *YYPARSE_PARAM;
+#endif
#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
@@ -1135,6 +1354,12 @@ yyparse ()
int yyerrstatus;
/* Look-ahead token as an internal (translated) token number. */
int yytoken = 0;
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
/* Three stacks and their tools:
`yyss': related to states,
@@ -1145,9 +1370,9 @@ yyparse ()
to reallocate them elsewhere. */
/* The state stack. */
- short int yyssa[YYINITDEPTH];
- short int *yyss = yyssa;
- short int *yyssp;
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss = yyssa;
+ yytype_int16 *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
@@ -1156,7 +1381,7 @@ yyparse ()
-#define YYPOPSTACK (yyvsp--, yyssp--)
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
YYSIZE_T yystacksize = YYINITDEPTH;
@@ -1165,9 +1390,9 @@ yyparse ()
YYSTYPE yyval;
- /* When reducing, the number of symbols on the RHS of the reduced
- rule. */
- int yylen;
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
YYDPRINTF ((stderr, "Starting parse\n"));
@@ -1191,8 +1416,7 @@ yyparse ()
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
- have just been pushed. so pushing a state here evens the stacks.
- */
+ have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
@@ -1205,11 +1429,11 @@ yyparse ()
#ifdef yyoverflow
{
- /* Give user a chance to reallocate the stack. Use copies of
+ /* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
- short int *yyss1 = yyss;
+ yytype_int16 *yyss1 = yyss;
/* Each stack pointer address is followed by the size of the
@@ -1237,7 +1461,7 @@ yyparse ()
yystacksize = YYMAXDEPTH;
{
- short int *yyss1 = yyss;
+ yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
@@ -1272,12 +1496,10 @@ yyparse ()
`-----------*/
yybackup:
-/* Do appropriate processing given the current state. */
-/* Read a look-ahead token if we need one and don't already have one. */
-/* yyresume: */
+ /* Do appropriate processing given the current state. Read a
+ look-ahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to look-ahead token. */
-
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
@@ -1319,22 +1541,21 @@ yybackup:
if (yyn == YYFINAL)
YYACCEPT;
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
/* Shift the look-ahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- /* Discard the token being shifted unless it is eof. */
+ /* Discard the shifted token unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
+ yystate = yyn;
*++yyvsp = yylval;
-
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- yystate = yyn;
goto yynewstate;
@@ -1371,21 +1592,21 @@ yyreduce:
{
case 3:
#line 145 "/home/drepper/devel/elfutils/src/ldscript.y"
- { add_versions ((yyvsp[0].version)); }
+ { add_versions ((yyvsp[(2) - (2)].version)); }
break;
case 6:
#line 153 "/home/drepper/devel/elfutils/src/ldscript.y"
{
if (likely (ld_state.entry == NULL))
- ld_state.entry = (yyvsp[-2].str);
+ ld_state.entry = (yyvsp[(3) - (5)].str);
}
break;
case 7:
#line 158 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- ld_new_searchdir ((yyvsp[-2].str));
+ ld_new_searchdir ((yyvsp[(3) - (5)].str));
}
break;
@@ -1393,7 +1614,7 @@ yyreduce:
#line 162 "/home/drepper/devel/elfutils/src/ldscript.y"
{
if (likely (ld_state.pagesize == 0))
- ld_state.pagesize = (yyvsp[-2].num);
+ ld_state.pagesize = (yyvsp[(3) - (5)].num);
}
break;
@@ -1402,14 +1623,14 @@ yyreduce:
{
if (likely (ld_state.interp == NULL)
&& ld_state.file_type != dso_file_type)
- ld_state.interp = (yyvsp[-2].str);
+ ld_state.interp = (yyvsp[(3) - (5)].str);
}
break;
case 10:
#line 173 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- new_segment ((yyvsp[-3].num), (yyvsp[-1].output_rule));
+ new_segment ((yyvsp[(2) - (5)].num), (yyvsp[(4) - (5)].output_rule));
}
break;
@@ -1418,7 +1639,7 @@ yyreduce:
{
fputs_unlocked (gettext ("mode for segment invalid\n"),
stderr);
- new_segment (0, (yyvsp[-1].output_rule));
+ new_segment (0, (yyvsp[(4) - (5)].output_rule));
}
break;
@@ -1427,28 +1648,28 @@ yyreduce:
{
/* First little optimization. If there is only one
file in the group don't do anything. */
- if ((yyvsp[-1].filename_list) != (yyvsp[-1].filename_list)->next)
+ if ((yyvsp[(3) - (4)].filename_list) != (yyvsp[(3) - (4)].filename_list)->next)
{
- (yyvsp[-1].filename_list)->next->group_start = 1;
- (yyvsp[-1].filename_list)->group_end = 1;
+ (yyvsp[(3) - (4)].filename_list)->next->group_start = 1;
+ (yyvsp[(3) - (4)].filename_list)->group_end = 1;
}
- add_inputfiles ((yyvsp[-1].filename_list));
+ add_inputfiles ((yyvsp[(3) - (4)].filename_list));
}
break;
case 13:
#line 194 "/home/drepper/devel/elfutils/src/ldscript.y"
- { add_inputfiles ((yyvsp[-1].filename_list)); }
+ { add_inputfiles ((yyvsp[(3) - (4)].filename_list)); }
break;
case 14:
#line 196 "/home/drepper/devel/elfutils/src/ldscript.y"
- { add_inputfiles (mark_as_needed ((yyvsp[-1].filename_list))); }
+ { add_inputfiles (mark_as_needed ((yyvsp[(3) - (4)].filename_list))); }
break;
case 15:
#line 198 "/home/drepper/devel/elfutils/src/ldscript.y"
- { add_versions ((yyvsp[-1].version)); }
+ { add_versions ((yyvsp[(3) - (4)].version)); }
break;
case 16:
@@ -1459,21 +1680,21 @@ yyreduce:
case 17:
#line 204 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[0].output_rule)->next = (yyvsp[-1].output_rule)->next;
- (yyval.output_rule) = (yyvsp[-1].output_rule)->next = (yyvsp[0].output_rule);
+ (yyvsp[(2) - (2)].output_rule)->next = (yyvsp[(1) - (2)].output_rule)->next;
+ (yyval.output_rule) = (yyvsp[(1) - (2)].output_rule)->next = (yyvsp[(2) - (2)].output_rule);
}
break;
case 18:
#line 209 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.output_rule) = (yyvsp[0].output_rule); }
+ { (yyval.output_rule) = (yyvsp[(1) - (1)].output_rule); }
break;
case 19:
#line 213 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.output_rule) = new_output_rule (output_assignment);
- (yyval.output_rule)->val.assignment = (yyvsp[-1].assignment);
+ (yyval.output_rule)->val.assignment = (yyvsp[(1) - (2)].assignment);
}
break;
@@ -1481,14 +1702,14 @@ yyreduce:
#line 218 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.output_rule) = new_output_rule (output_section);
- (yyval.output_rule)->val.section.name = (yyvsp[-3].str);
- (yyval.output_rule)->val.section.input = (yyvsp[-1].input_rule)->next;
+ (yyval.output_rule)->val.section.name = (yyvsp[(1) - (4)].str);
+ (yyval.output_rule)->val.section.input = (yyvsp[(3) - (4)].input_rule)->next;
if (ld_state.strip == strip_debug
- && ebl_debugscn_p (ld_state.ebl, (yyvsp[-3].str)))
+ && ebl_debugscn_p (ld_state.ebl, (yyvsp[(1) - (4)].str)))
(yyval.output_rule)->val.section.ignored = true;
else
(yyval.output_rule)->val.section.ignored = false;
- (yyvsp[-1].input_rule)->next = NULL;
+ (yyvsp[(3) - (4)].input_rule)->next = NULL;
}
break;
@@ -1497,7 +1718,7 @@ yyreduce:
{
/* This is a short cut for "ID { *(ID) }". */
(yyval.output_rule) = new_output_rule (output_section);
- (yyval.output_rule)->val.section.name = (yyvsp[-1].str);
+ (yyval.output_rule)->val.section.name = (yyvsp[(1) - (2)].str);
(yyval.output_rule)->val.section.input = new_input_rule (input_section);
(yyval.output_rule)->val.section.input->next = NULL;
(yyval.output_rule)->val.section.input->val.section =
@@ -1507,10 +1728,10 @@ yyreduce:
(yyval.output_rule)->val.section.input->val.section->filemask = NULL;
(yyval.output_rule)->val.section.input->val.section->excludemask = NULL;
(yyval.output_rule)->val.section.input->val.section->section_name =
- new_input_section_name ((yyvsp[-1].str), false);
+ new_input_section_name ((yyvsp[(1) - (2)].str), false);
(yyval.output_rule)->val.section.input->val.section->keep_flag = false;
if (ld_state.strip == strip_debug
- && ebl_debugscn_p (ld_state.ebl, (yyvsp[-1].str)))
+ && ebl_debugscn_p (ld_state.ebl, (yyvsp[(1) - (2)].str)))
(yyval.output_rule)->val.section.ignored = true;
else
(yyval.output_rule)->val.section.ignored = false;
@@ -1519,42 +1740,42 @@ yyreduce:
case 22:
#line 254 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.assignment) = new_assignment ((yyvsp[-2].str), (yyvsp[0].expr), false); }
+ { (yyval.assignment) = new_assignment ((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].expr), false); }
break;
case 23:
#line 256 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.assignment) = new_assignment ((yyvsp[-3].str), (yyvsp[-1].expr), true); }
+ { (yyval.assignment) = new_assignment ((yyvsp[(3) - (6)].str), (yyvsp[(5) - (6)].expr), true); }
break;
case 24:
#line 260 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[0].input_rule)->next = (yyvsp[-1].input_rule)->next;
- (yyval.input_rule) = (yyvsp[-1].input_rule)->next = (yyvsp[0].input_rule);
+ (yyvsp[(2) - (2)].input_rule)->next = (yyvsp[(1) - (2)].input_rule)->next;
+ (yyval.input_rule) = (yyvsp[(1) - (2)].input_rule)->next = (yyvsp[(2) - (2)].input_rule);
}
break;
case 25:
#line 265 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.input_rule) = (yyvsp[0].input_rule); }
+ { (yyval.input_rule) = (yyvsp[(1) - (1)].input_rule); }
break;
case 26:
#line 269 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.input_rule) = new_input_rule (input_section);
- (yyval.input_rule)->val.section = (yyvsp[0].filemask_section_name);
+ (yyval.input_rule)->val.section = (yyvsp[(1) - (1)].filemask_section_name);
}
break;
case 27:
#line 274 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[-1].filemask_section_name)->keep_flag = true;
+ (yyvsp[(3) - (4)].filemask_section_name)->keep_flag = true;
(yyval.input_rule) = new_input_rule (input_section);
- (yyval.input_rule)->val.section = (yyvsp[-1].filemask_section_name);
+ (yyval.input_rule)->val.section = (yyvsp[(3) - (4)].filemask_section_name);
}
break;
@@ -1562,7 +1783,7 @@ yyreduce:
#line 281 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.input_rule) = new_input_rule (input_assignment);
- (yyval.input_rule)->val.assignment = (yyvsp[-1].assignment);
+ (yyval.input_rule)->val.assignment = (yyvsp[(1) - (2)].assignment);
}
break;
@@ -1571,26 +1792,26 @@ yyreduce:
{
(yyval.filemask_section_name) = (struct filemask_section_name *)
obstack_alloc (&ld_state.smem, sizeof (*(yyval.filemask_section_name)));
- (yyval.filemask_section_name)->filemask = (yyvsp[-4].str);
- (yyval.filemask_section_name)->excludemask = (yyvsp[-2].str);
- (yyval.filemask_section_name)->section_name = (yyvsp[-1].sectionname);
+ (yyval.filemask_section_name)->filemask = (yyvsp[(1) - (5)].str);
+ (yyval.filemask_section_name)->excludemask = (yyvsp[(3) - (5)].str);
+ (yyval.filemask_section_name)->section_name = (yyvsp[(4) - (5)].sectionname);
(yyval.filemask_section_name)->keep_flag = false;
}
break;
case 30:
#line 299 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.sectionname) = new_input_section_name ((yyvsp[0].str), false); }
+ { (yyval.sectionname) = new_input_section_name ((yyvsp[(1) - (1)].str), false); }
break;
case 31:
#line 301 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.sectionname) = new_input_section_name ((yyvsp[-1].str), true); }
+ { (yyval.sectionname) = new_input_section_name ((yyvsp[(3) - (4)].str), true); }
break;
case 32:
#line 305 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.str) = (yyvsp[-1].str); }
+ { (yyval.str) = (yyvsp[(3) - (4)].str); }
break;
case 33:
@@ -1602,39 +1823,39 @@ yyreduce:
#line 311 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_align);
- (yyval.expr)->val.child = (yyvsp[-1].expr);
+ (yyval.expr)->val.child = (yyvsp[(3) - (4)].expr);
}
break;
case 35:
#line 316 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.expr) = (yyvsp[-1].expr); }
+ { (yyval.expr) = (yyvsp[(2) - (3)].expr); }
break;
case 36:
#line 318 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_mult);
- (yyval.expr)->val.binary.left = (yyvsp[-2].expr);
- (yyval.expr)->val.binary.right = (yyvsp[0].expr);
+ (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr);
+ (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr);
}
break;
case 37:
#line 324 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyval.expr) = new_expr ((yyvsp[-1].op));
- (yyval.expr)->val.binary.left = (yyvsp[-2].expr);
- (yyval.expr)->val.binary.right = (yyvsp[0].expr);
+ (yyval.expr) = new_expr ((yyvsp[(2) - (3)].op));
+ (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr);
+ (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr);
}
break;
case 38:
#line 330 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyval.expr) = new_expr ((yyvsp[-1].op));
- (yyval.expr)->val.binary.left = (yyvsp[-2].expr);
- (yyval.expr)->val.binary.right = (yyvsp[0].expr);
+ (yyval.expr) = new_expr ((yyvsp[(2) - (3)].op));
+ (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr);
+ (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr);
}
break;
@@ -1642,8 +1863,8 @@ yyreduce:
#line 336 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_and);
- (yyval.expr)->val.binary.left = (yyvsp[-2].expr);
- (yyval.expr)->val.binary.right = (yyvsp[0].expr);
+ (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr);
+ (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr);
}
break;
@@ -1651,8 +1872,8 @@ yyreduce:
#line 342 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_or);
- (yyval.expr)->val.binary.left = (yyvsp[-2].expr);
- (yyval.expr)->val.binary.right = (yyvsp[0].expr);
+ (yyval.expr)->val.binary.left = (yyvsp[(1) - (3)].expr);
+ (yyval.expr)->val.binary.right = (yyvsp[(3) - (3)].expr);
}
break;
@@ -1660,7 +1881,7 @@ yyreduce:
#line 348 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_num);
- (yyval.expr)->val.num = (yyvsp[0].num);
+ (yyval.expr)->val.num = (yyvsp[(1) - (1)].num);
}
break;
@@ -1668,7 +1889,7 @@ yyreduce:
#line 353 "/home/drepper/devel/elfutils/src/ldscript.y"
{
(yyval.expr) = new_expr (exp_id);
- (yyval.expr)->val.str = (yyvsp[0].str);
+ (yyval.expr)->val.str = (yyvsp[(1) - (1)].str);
}
break;
@@ -1685,14 +1906,14 @@ yyreduce:
case 45:
#line 364 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[0].filename_list)->next = (yyvsp[-2].filename_list)->next;
- (yyval.filename_list) = (yyvsp[-2].filename_list)->next = (yyvsp[0].filename_list);
+ (yyvsp[(3) - (3)].filename_list)->next = (yyvsp[(1) - (3)].filename_list)->next;
+ (yyval.filename_list) = (yyvsp[(1) - (3)].filename_list)->next = (yyvsp[(3) - (3)].filename_list);
}
break;
case 46:
#line 369 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.filename_list) = (yyvsp[0].filename_list); }
+ { (yyval.filename_list) = (yyvsp[(1) - (1)].filename_list); }
break;
case 49:
@@ -1700,112 +1921,112 @@ yyreduce:
{
/* First little optimization. If there is only one
file in the group don't do anything. */
- if ((yyvsp[-1].filename_list) != (yyvsp[-1].filename_list)->next)
+ if ((yyvsp[(3) - (4)].filename_list) != (yyvsp[(3) - (4)].filename_list)->next)
{
- (yyvsp[-1].filename_list)->next->group_start = 1;
- (yyvsp[-1].filename_list)->group_end = 1;
+ (yyvsp[(3) - (4)].filename_list)->next->group_start = 1;
+ (yyvsp[(3) - (4)].filename_list)->group_end = 1;
}
- (yyval.filename_list) = (yyvsp[-1].filename_list);
+ (yyval.filename_list) = (yyvsp[(3) - (4)].filename_list);
}
break;
case 50:
#line 388 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.filename_list) = mark_as_needed ((yyvsp[-1].filename_list)); }
+ { (yyval.filename_list) = mark_as_needed ((yyvsp[(3) - (4)].filename_list)); }
break;
case 51:
#line 390 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.filename_list) = new_filename_listelem ((yyvsp[0].str)); }
+ { (yyval.filename_list) = new_filename_listelem ((yyvsp[(1) - (1)].str)); }
break;
case 52:
#line 395 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[0].version)->next = (yyvsp[-1].version)->next;
- (yyval.version) = (yyvsp[-1].version)->next = (yyvsp[0].version);
+ (yyvsp[(2) - (2)].version)->next = (yyvsp[(1) - (2)].version)->next;
+ (yyval.version) = (yyvsp[(1) - (2)].version)->next = (yyvsp[(2) - (2)].version);
}
break;
case 53:
#line 400 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.version) = (yyvsp[0].version); }
+ { (yyval.version) = (yyvsp[(1) - (1)].version); }
break;
case 54:
#line 404 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[-2].version)->versionname = "";
- (yyvsp[-2].version)->parentname = NULL;
- (yyval.version) = (yyvsp[-2].version);
+ (yyvsp[(2) - (4)].version)->versionname = "";
+ (yyvsp[(2) - (4)].version)->parentname = NULL;
+ (yyval.version) = (yyvsp[(2) - (4)].version);
}
break;
case 55:
#line 410 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[-2].version)->versionname = (yyvsp[-4].str);
- (yyvsp[-2].version)->parentname = NULL;
- (yyval.version) = (yyvsp[-2].version);
+ (yyvsp[(3) - (5)].version)->versionname = (yyvsp[(1) - (5)].str);
+ (yyvsp[(3) - (5)].version)->parentname = NULL;
+ (yyval.version) = (yyvsp[(3) - (5)].version);
}
break;
case 56:
#line 416 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- (yyvsp[-3].version)->versionname = (yyvsp[-5].str);
- (yyvsp[-3].version)->parentname = (yyvsp[-1].str);
- (yyval.version) = (yyvsp[-3].version);
+ (yyvsp[(3) - (6)].version)->versionname = (yyvsp[(1) - (6)].str);
+ (yyvsp[(3) - (6)].version)->parentname = (yyvsp[(5) - (6)].str);
+ (yyval.version) = (yyvsp[(3) - (6)].version);
}
break;
case 57:
#line 425 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.version) = merge_versions ((yyvsp[-1].version), (yyvsp[0].version)); }
+ { (yyval.version) = merge_versions ((yyvsp[(1) - (2)].version), (yyvsp[(2) - (2)].version)); }
break;
case 58:
#line 427 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.version) = (yyvsp[0].version); }
+ { (yyval.version) = (yyvsp[(1) - (1)].version); }
break;
case 59:
#line 431 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.version) = new_version (NULL, (yyvsp[0].id_list)); }
+ { (yyval.version) = new_version (NULL, (yyvsp[(2) - (2)].id_list)); }
break;
case 60:
#line 433 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.version) = new_version ((yyvsp[0].id_list), NULL); }
+ { (yyval.version) = new_version ((yyvsp[(2) - (2)].id_list), NULL); }
break;
case 61:
#line 438 "/home/drepper/devel/elfutils/src/ldscript.y"
{
- struct id_list *newp = new_id_listelem ((yyvsp[-1].str));
- newp->next = (yyvsp[-2].id_list)->next;
- (yyval.id_list) = (yyvsp[-2].id_list)->next = newp;
+ struct id_list *newp = new_id_listelem ((yyvsp[(2) - (3)].str));
+ newp->next = (yyvsp[(1) - (3)].id_list)->next;
+ (yyval.id_list) = (yyvsp[(1) - (3)].id_list)->next = newp;
}
break;
case 62:
#line 444 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.id_list) = new_id_listelem ((yyvsp[-1].str)); }
+ { (yyval.id_list) = new_id_listelem ((yyvsp[(1) - (2)].str)); }
break;
case 63:
#line 448 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.str) = (yyvsp[0].str); }
+ { (yyval.str) = (yyvsp[(1) - (1)].str); }
break;
case 64:
#line 450 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.str) = (yyvsp[0].str); }
+ { (yyval.str) = (yyvsp[(1) - (1)].str); }
break;
case 65:
#line 454 "/home/drepper/devel/elfutils/src/ldscript.y"
- { (yyval.str) = (yyvsp[0].str); }
+ { (yyval.str) = (yyvsp[(1) - (1)].str); }
break;
case 66:
@@ -1814,16 +2035,14 @@ yyreduce:
break;
+/* Line 1267 of yacc.c. */
+#line 2040 "ldscript.c"
default: break;
}
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-/* Line 1126 of yacc.c. */
-#line 1822 "ldscript.c"
-
- yyvsp -= yylen;
- yyssp -= yylen;
-
-
+ YYPOPSTACK (yylen);
+ yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
@@ -1852,110 +2071,41 @@ yyerrlab:
if (!yyerrstatus)
{
++yynerrs;
-#if YYERROR_VERBOSE
- yyn = yypact[yystate];
-
- if (YYPACT_NINF < yyn && yyn < YYLAST)
- {
- int yytype = YYTRANSLATE (yychar);
- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
- YYSIZE_T yysize = yysize0;
- YYSIZE_T yysize1;
- int yysize_overflow = 0;
- char *yymsg = 0;
-# define YYERROR_VERBOSE_ARGS_MAXIMUM 5
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- int yyx;
-
-#if 0
- /* This is so xgettext sees the translatable formats that are
- constructed on the fly. */
- YY_("syntax error, unexpected %s");
- YY_("syntax error, unexpected %s, expecting %s");
- YY_("syntax error, unexpected %s, expecting %s or %s");
- YY_("syntax error, unexpected %s, expecting %s or %s or %s");
- YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
-#endif
- char *yyfmt;
- char const *yyf;
- static char const yyunexpected[] = "syntax error, unexpected %s";
- static char const yyexpecting[] = ", expecting %s";
- static char const yyor[] = " or %s";
- char yyformat[sizeof yyunexpected
- + sizeof yyexpecting - 1
- + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
- * (sizeof yyor - 1))];
- char const *yyprefix = yyexpecting;
-
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yycount = 1;
-
- yyarg[0] = yytname[yytype];
- yyfmt = yystpcpy (yyformat, yyunexpected);
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+#if ! YYERROR_VERBOSE
+ yyerror (YY_("syntax error"));
+#else
+ {
+ YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+ if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+ {
+ YYSIZE_T yyalloc = 2 * yysize;
+ if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+ yyalloc = YYSTACK_ALLOC_MAXIMUM;
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+ if (yymsg)
+ yymsg_alloc = yyalloc;
+ else
{
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- yyformat[sizeof yyunexpected - 1] = '\0';
- break;
- }
- yyarg[yycount++] = yytname[yyx];
- yysize1 = yysize + yytnamerr (0, yytname[yyx]);
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
- yyfmt = yystpcpy (yyfmt, yyprefix);
- yyprefix = yyor;
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
}
+ }
- yyf = YY_(yyformat);
- yysize1 = yysize + yystrlen (yyf);
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
-
- if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
- yymsg = (char *) YYSTACK_ALLOC (yysize);
- if (yymsg)
- {
- /* Avoid sprintf, as that infringes on the user's name space.
- Don't have undefined behavior even if the translation
- produced a string with the wrong number of "%s"s. */
- char *yyp = yymsg;
- int yyi = 0;
- while ((*yyp = *yyf))
- {
- if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyf += 2;
- }
- else
- {
- yyp++;
- yyf++;
- }
- }
- yyerror (yymsg);
- YYSTACK_FREE (yymsg);
- }
- else
- {
- yyerror (YY_("syntax error"));
+ if (0 < yysize && yysize <= yymsg_alloc)
+ {
+ (void) yysyntax_error (yymsg, yystate, yychar);
+ yyerror (yymsg);
+ }
+ else
+ {
+ yyerror (YY_("syntax error"));
+ if (yysize != 0)
goto yyexhaustedlab;
- }
- }
- else
-#endif /* YYERROR_VERBOSE */
- yyerror (YY_("syntax error"));
+ }
+ }
+#endif
}
@@ -1966,14 +2116,15 @@ yyerrlab:
error, discard it. */
if (yychar <= YYEOF)
- {
+ {
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
- }
+ }
else
{
- yydestruct ("Error: discarding", yytoken, &yylval);
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
yychar = YYEMPTY;
}
}
@@ -1991,11 +2142,14 @@ yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code. */
- if (0)
+ if (/*CONSTCOND*/ 0)
goto yyerrorlab;
-yyvsp -= yylen;
- yyssp -= yylen;
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
@@ -2025,8 +2179,9 @@ yyerrlab1:
YYABORT;
- yydestruct ("Error: popping", yystos[yystate], yyvsp);
- YYPOPSTACK;
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp);
+ YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
@@ -2037,7 +2192,7 @@ yyerrlab1:
*++yyvsp = yylval;
- /* Shift the error token. */
+ /* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
@@ -2072,17 +2227,26 @@ yyreturn:
if (yychar != YYEOF && yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp);
- YYPOPSTACK;
+ YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
- return yyresult;
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ /* Make sure YYID is used. */
+ return YYID (yyresult);
}
diff --git a/elfutils/src/ldscript.h b/elfutils/src/ldscript.h
index 338690cf..3445c87d 100644
--- a/elfutils/src/ldscript.h
+++ b/elfutils/src/ldscript.h
@@ -1,7 +1,9 @@
-/* A Bison parser, made by GNU Bison 2.1. */
+/* A Bison parser, made by GNU Bison 2.3. */
-/* Skeleton parser for Yacc-like parsing with Bison,
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 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
@@ -18,10 +20,18 @@
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
-/* As a special exception, when this file is copied by Bison into a
- Bison output file, you may use that output file without restriction.
- This special exception was added by the Free Software Foundation
- in version 1.24 of Bison. */
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
/* Tokens. */
#ifndef YYTOKENTYPE
@@ -90,9 +100,10 @@
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
#line 71 "/home/drepper/devel/elfutils/src/ldscript.y"
-typedef union YYSTYPE {
+{
uintmax_t num;
enum expression_tag op;
char *str;
@@ -105,9 +116,10 @@ typedef union YYSTYPE {
struct filename_list *filename_list;
struct version *version;
struct id_list *id_list;
-} YYSTYPE;
-/* Line 1447 of yacc.c. */
-#line 111 "ldscript.h"
+}
+/* Line 1529 of yacc.c. */
+#line 122 "ldscript.h"
+ YYSTYPE;
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
@@ -115,5 +127,3 @@ typedef union YYSTYPE {
extern YYSTYPE ldlval;
-
-
diff --git a/elfutils/src/nm.c b/elfutils/src/nm.c
index cf47f224..8558c277 100644
--- a/elfutils/src/nm.c
+++ b/elfutils/src/nm.c
@@ -1,5 +1,5 @@
/* Print symbol information from ELF file in human-readable form.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2000.
@@ -254,7 +254,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/objdump.c b/elfutils/src/objdump.c
index d968fa7a..373c85b3 100644
--- a/elfutils/src/objdump.c
+++ b/elfutils/src/objdump.c
@@ -1,5 +1,5 @@
/* Print information from ELF file in human-readable form.
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -182,7 +182,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/ranlib.c b/elfutils/src/ranlib.c
index adb99881..d86a8e39 100644
--- a/elfutils/src/ranlib.c
+++ b/elfutils/src/ranlib.c
@@ -1,5 +1,5 @@
/* Generate an index to speed access to archives.
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -31,8 +31,6 @@
#include <ar.h>
#include <argp.h>
#include <assert.h>
-#include <byteswap.h>
-#include <endian.h>
#include <errno.h>
#include <error.h>
#include <fcntl.h>
@@ -44,19 +42,14 @@
#include <stdlib.h>
#include <stdio.h>
#include <stdio_ext.h>
-#include <time.h>
#include <unistd.h>
+#include <sys/mman.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <system.h>
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-# define le_bswap_32(val) bswap_32 (val)
-#else
-# define le_bswap_32(val) (val)
-#endif
+#include "arlib.h"
/* Prototypes for local functions. */
@@ -83,13 +76,10 @@ static const char doc[] = N_("Generate an index to speed access to archives.");
/* Strings for arguments in help texts. */
static const char args_doc[] = N_("ARCHIVE");
-/* Prototype for option handler. */
-static error_t parse_opt (int key, char *arg, struct argp_state *state);
-
/* Data structure to communicate with argp functions. */
-static struct argp argp =
+static const struct argp argp =
{
- options, parse_opt, args_doc, doc, NULL, NULL, NULL
+ options, NULL, args_doc, doc, NULL, NULL, NULL
};
@@ -147,146 +137,25 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
-/* Handle program arguments. */
-static error_t
-parse_opt (int key, char *arg __attribute__ ((unused)),
- struct argp_state *state __attribute__ ((unused)))
-{
- switch (key)
- {
- default:
- return ARGP_ERR_UNKNOWN;
- }
- return 0;
-}
-
-
-static struct obstack offsob;
-size_t offs_len;
-static struct obstack namesob;
-size_t names_len;
-
-
-/* Add all exported, defined symbols from the given section to the table. */
-static void
-add_symbols (Elf *elf, const char *fname, off_t off, Elf_Scn *scn,
- GElf_Shdr *shdr)
-{
- if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
- /* The archive is too big. */
- error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"), fname);
-
- Elf_Data *data = elf_getdata (scn, NULL);
- assert (data->d_size == shdr->sh_size);
-
- /* We can skip the local symbols in the table. */
- for (int cnt = shdr->sh_info; cnt < (int) (shdr->sh_size / shdr->sh_entsize);
- ++cnt)
- {
- GElf_Sym sym_mem;
- GElf_Sym *sym = gelf_getsym (data, cnt, &sym_mem);
- if (sym == NULL)
- /* Should never happen. */
- continue;
-
- /* Ignore undefined symbols. */
- if (sym->st_shndx == SHN_UNDEF)
- continue;
-
- /* For all supported platforms the following is true. */
- assert (sizeof (uint32_t) == sizeof (int));
- obstack_int_grow (&offsob, (int) le_bswap_32 (off));
- offs_len += sizeof (uint32_t);
-
- const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
- size_t symname_len = strlen (symname) + 1;
- obstack_grow (&namesob, symname, symname_len);
- names_len += symname_len;
- }
-}
-
-
-/* Look through ELF file and collect all symbols available for
- linking. If available, we use the dynamic symbol section.
- Otherwise the normal one. Relocatable files are allowed to have
- multiple symbol tables. */
-static void
-handle_elf (Elf *elf, const char *arfname, off_t off)
-{
- GElf_Ehdr ehdr_mem;
- GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
- assert (ehdr != NULL);
-
- if (ehdr->e_type == ET_REL)
- {
- Elf_Scn *scn = NULL;
- while ((scn = elf_nextscn (elf, scn)) != NULL)
- {
- GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- if (shdr != NULL && shdr->sh_type == SHT_SYMTAB)
- add_symbols (elf, arfname, off, scn, shdr);
- }
- }
- else
- {
- Elf_Scn *symscn = NULL;
- GElf_Shdr *symshdr = NULL;
- Elf_Scn *scn = NULL;
- GElf_Shdr shdr_mem;
- while ((scn = elf_nextscn (elf, scn)) != NULL)
- {
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- symshdr = NULL;
- if (shdr != NULL)
- {
- if (shdr->sh_type == SHT_DYNSYM)
- {
- symscn = scn;
- symshdr = shdr;
- break;
- }
- if (shdr->sh_type == SHT_SYMTAB)
- {
- /* There better be only one symbol table in
- executables in DSOs. */
- assert (symscn == NULL);
- symscn = scn;
- symshdr = shdr;
- }
- }
- }
-
- add_symbols (elf, arfname, off, symscn,
- symshdr ?: gelf_getshdr (scn, &shdr_mem));
- }
-}
-
-
static int
-copy_content (int oldfd, int newfd, off_t off, size_t n)
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
{
- while (n > 0)
- {
- char buf[32768];
+ size_t len;
+ char *rawfile = elf_rawfile (elf, &len);
- ssize_t nread = pread_retry (oldfd, buf, MIN (sizeof (buf), n), off);
- if (unlikely (nread <= 0))
- return 1;
+ assert (off + n <= len);
- if (write_retry (newfd, buf, nread) != nread)
- return 1;
-
- n -= nread;
- off += nread;
- }
+ /* Tell the kernel we will read all the pages sequentially. */
+ size_t ps = sysconf (_SC_PAGESIZE);
+ if (n > 2 * ps)
+ posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
- return 0;
+ return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
}
@@ -328,84 +197,63 @@ handle_file (const char *fname)
return 1;
}
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
- obstack_init (&offsob);
- offs_len = 0;
- obstack_init (&namesob);
- names_len = 0;
-
- /* The first word in the offset table specifies the size. Create
- such an entry now. The real value will be filled-in later. For
- all supported platforms the following is true. */
- assert (sizeof (uint32_t) == sizeof (int));
- obstack_int_grow (&offsob, 0);
- offs_len += sizeof (uint32_t);
+ arlib_init ();
/* Iterate over the content of the archive. */
off_t index_off = -1;
size_t index_size = 0;
+ off_t cur_off = SARMAG;
Elf *elf;
Elf_Cmd cmd = ELF_C_READ_MMAP;
while ((elf = elf_begin (fd, cmd, arelf)) != NULL)
{
Elf_Arhdr *arhdr = elf_getarhdr (elf);
assert (arhdr != NULL);
- off_t off = elf_getaroff (elf);
- Elf_Kind kind = elf_kind (elf);
- if (kind == ELF_K_ELF)
- handle_elf (elf, fname, off);
-#if 0
- else if (kind == ELF_K_AR)
- {
- // XXX Should we implement this?
- }
-#endif
/* If this is the index, remember the location. */
- else if (strcmp (arhdr->ar_name, "/") == 0)
+ if (strcmp (arhdr->ar_name, "/") == 0)
{
- index_off = off;
+ index_off = elf_getaroff (elf);
index_size = arhdr->ar_size;
}
+ else
+ {
+ arlib_add_symbols (elf, fname, arhdr->ar_name, cur_off);
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
/* Get next archive element. */
cmd = elf_next (elf);
if (elf_end (elf) != 0)
- error (0, 0,
- gettext (" error while freeing sub-ELF descriptor: %s\n"),
+ error (0, 0, gettext ("error while freeing sub-ELF descriptor: %s"),
elf_errmsg (-1));
}
- elf_end (arelf);
- uint32_t *offs_arr = obstack_finish (&offsob);
- assert (offs_len % sizeof (uint32_t) == 0);
- if ((names_len & 1) != 0)
- {
- /* Add one more NUL byte to make length even. */
- obstack_grow (&namesob, "", 1);
- ++names_len;
- }
- const char *names_str = obstack_finish (&namesob);
+ arlib_finalize ();
/* If the file contains no symbols we need not do anything. */
- if (names_len != 0
+ int status = 0;
+ if (symtab.symsnamelen != 0
/* We have to rewrite the file also if it initially had an index
but now does not need one anymore. */
- || (names_len == 0 && index_off != -1))
+ || (symtab.symsnamelen == 0 && index_size != 0))
{
/* Create a new, temporary file in the same directory as the
original file. */
- char tmpfname[strlen (fname) + 8];
- strcpy (stpcpy (tmpfname, fname), ".XXXXXX");
+ char tmpfname[strlen (fname) + 7];
+ strcpy (stpcpy (tmpfname, fname), "XXXXXX");
int newfd = mkstemp (tmpfname);
- if (newfd == -1)
- nonew:
- error (0, errno, gettext ("cannot create new file"));
+ if (unlikely (newfd == -1))
+ {
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ }
else
{
/* Create the header. */
- if (write_retry (newfd, ARMAG, SARMAG) != SARMAG)
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
{
// XXX Use /prof/self/fd/%d ???
nonew_unlink:
@@ -415,62 +263,6 @@ handle_file (const char *fname)
goto nonew;
}
- struct ar_hdr ar_hdr;
- memcpy (ar_hdr.ar_name, "/ ", sizeof (ar_hdr.ar_name));
- /* Using snprintf here has a problem: the call always wants
- to add a NUL byte. We could use a trick whereby we
- specify the target buffer size longer than it is and this
- would not actually fail, since all the fields are
- consecutive and we fill them in in sequence (i.e., the
- NUL byte gets overwritten). But _FORTIFY_SOURCE=2 would
- not let us play these games. Therefore we play it
- safe. */
- char tmpbuf[MAX (sizeof (ar_hdr.ar_date), sizeof (ar_hdr.ar_size))
- + 1];
- memcpy (ar_hdr.ar_date, tmpbuf,
- snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
- (int) sizeof (ar_hdr.ar_date),
- (long long int) time (NULL)));
-
- /* Note the string for the ar_uid and ar_gid cases is longer
- than necessary. This does not matter since we copy only as
- much as necessary but it helps the compiler to use the same
- string for the ar_mode case. */
- memcpy (ar_hdr.ar_uid, "0 ", sizeof (ar_hdr.ar_uid));
- memcpy (ar_hdr.ar_gid, "0 ", sizeof (ar_hdr.ar_gid));
- memcpy (ar_hdr.ar_mode, "0 ", sizeof (ar_hdr.ar_mode));
-
- /* See comment for ar_date above. */
- memcpy (ar_hdr.ar_size, tmpbuf,
- snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
- (int) sizeof (ar_hdr.ar_size),
- offs_len + names_len));
- memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
-
- /* Fill in the number of offsets now. */
- offs_arr[0] = le_bswap_32 (offs_len / sizeof (uint32_t) - 1);
-
- /* Adjust the offset values for the name index size (if
- necessary). */
- off_t disp = (offs_len + ((names_len + 1) & ~1ul)
- - ((index_size + 1) & ~1ul));
- /* If there was no index so far but one is needed now we
- have to take the archive header into account. */
- if (index_off == -1 && names_len != 0)
- disp += sizeof (struct ar_hdr);
- if (disp != 0)
- for (size_t cnt = 1; cnt < offs_len / sizeof (uint32_t); ++cnt)
- {
- uint32_t val;
- val = le_bswap_32 (offs_arr[cnt]);
-
- if (val > index_off)
- {
- val += disp;
- offs_arr[cnt] = le_bswap_32 (val);
- }
- }
-
/* Create the new file. There are three parts as far we are
concerned: 1. original context before the index, 2. the
new index, 3. everything after the new index. */
@@ -481,30 +273,34 @@ handle_file (const char *fname)
else
rest_off = SARMAG;
- if ((index_off > SARMAG
- && copy_content (fd, newfd, SARMAG, index_off - SARMAG))
- || (names_len != 0
- && ((write_retry (newfd, &ar_hdr, sizeof (ar_hdr))
- != sizeof (ar_hdr))
- || (write_retry (newfd, offs_arr, offs_len)
- != (ssize_t) offs_len)
- || (write_retry (newfd, names_str, names_len)
- != (ssize_t) names_len)))
- || copy_content (fd, newfd, rest_off, st.st_size - rest_off)
+ if ((symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff,
+ symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname,
+ symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ /* Even if the original file had content before the
+ symbol table, we write it in the correct order. */
+ || (index_off > SARMAG
+ && copy_content (arelf, newfd, SARMAG, index_off - SARMAG))
+ || copy_content (arelf, newfd, rest_off, st.st_size - rest_off)
/* Set the mode of the new file to the same values the
original file has. */
|| fchmod (newfd, st.st_mode & ALLPERMS) != 0
- || fchown (newfd, st.st_uid, st.st_gid) != 0
- || close (newfd) != 0
+ /* Never complain about fchown failing. */
+ || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }),
+ close (newfd) != 0)
|| (newfd = -1, rename (tmpfname, fname) != 0))
goto nonew_unlink;
}
}
- obstack_free (&offsob, NULL);
- obstack_free (&namesob, NULL);
+ elf_end (arelf);
+
+ arlib_fini ();
close (fd);
- return 0;
+ return status;
}
diff --git a/elfutils/src/readelf.c b/elfutils/src/readelf.c
index b592c72b..fd61b369 100644
--- a/elfutils/src/readelf.c
+++ b/elfutils/src/readelf.c
@@ -1,5 +1,5 @@
/* Print information from ELF file in human-readable form.
- Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 1999.
@@ -369,7 +369,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/size.c b/elfutils/src/size.c
index 051479ff..57549e8f 100644
--- a/elfutils/src/size.c
+++ b/elfutils/src/size.c
@@ -1,5 +1,5 @@
/* Print size information from ELF file.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2000.
@@ -220,7 +220,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/strings.c b/elfutils/src/strings.c
index 0317c21d..87e5d8ef 100644
--- a/elfutils/src/strings.c
+++ b/elfutils/src/strings.c
@@ -1,5 +1,5 @@
/* Print the strings of printable characters in files.
- Copyright (C) 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2005.
@@ -228,7 +228,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
diff --git a/elfutils/src/strip.c b/elfutils/src/strip.c
index fc6ddf50..511321ff 100644
--- a/elfutils/src/strip.c
+++ b/elfutils/src/strip.c
@@ -1,5 +1,5 @@
/* Discard section not used at runtime from object files.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Ulrich Drepper <drepper@redhat.com>, 2000.
@@ -204,7 +204,7 @@ print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
Copyright (C) %s Red Hat, Inc.\n\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
-"), "2006");
+"), "2007");
fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}
@@ -344,9 +344,9 @@ process_file (const char *fname)
case ELF_K_AR:
/* It is not possible to strip the content of an archive direct
the output to a specific file. */
- if (unlikely (output_fname != NULL))
+ if (unlikely (output_fname != NULL || debug_fname != NULL))
{
- error (0, 0, gettext ("%s: cannot use -o when stripping archive"),
+ error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"),
fname);
result = 1;
}
View Lorry Controller Status