summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorLuca Barbato <lu_zero@gentoo.org>2003-11-07 01:22:24 +0000
committerLuca Barbato <lu_zero@gentoo.org>2003-11-07 01:22:24 +0000
commit4142c573090c76d6032ada12c1f459602facf625 (patch)
treecf4549c5934a5ccdc5ff3d318c78ab321642af20 /sys-devel
parent~ppc, fix #32755 (diff)
downloadhistorical-4142c573090c76d6032ada12c1f459602facf625.tar.gz
historical-4142c573090c76d6032ada12c1f459602facf625.tar.bz2
historical-4142c573090c76d6032ada12c1f459602facf625.zip
~ppc, fix #32755
Diffstat (limited to 'sys-devel')
-rw-r--r--sys-devel/binutils/Manifest4
-rw-r--r--sys-devel/binutils/binutils-2.14.90.0.7-r1.ebuild199
-rw-r--r--sys-devel/binutils/files/2.14/binutils-2.14.90.0.7-ppc-reloc.patch6673
-rw-r--r--sys-devel/binutils/files/digest-binutils-2.14.90.0.7-r11
4 files changed, 6875 insertions, 2 deletions
diff --git a/sys-devel/binutils/Manifest b/sys-devel/binutils/Manifest
index b008d3285200..669b2f16df8a 100644
--- a/sys-devel/binutils/Manifest
+++ b/sys-devel/binutils/Manifest
@@ -3,8 +3,8 @@ MD5 0605cad192892662d9ab7bcf4292a278 binutils-2.11.92.0.12.3-r2.ebuild 3047
MD5 b7ddfee30d6b7884c1b9088c6fde759d binutils-2.13.90.0.16-r1.ebuild 4661
MD5 d7774659828753b66eedf647ed63a6f6 binutils-2.14.90.0.7.ebuild 5482
MD5 1b11085f74185bfe7061a6fb01d62ebd binutils-2.12.90.0.15.ebuild 3501
-MD5 df6b75234c842e371111bfab0437d01f ChangeLog 19248
-MD5 e741e83d7f9e62eba31eb62ba61d5901 binutils-2.14.90.0.7-r1.ebuild 5522
+MD5 743f2087155d5bd2768bd5f00f6775e7 ChangeLog 19248
+MD5 de7af19f48e189e180aaf0542dda06e5 binutils-2.14.90.0.7-r1.ebuild 5525
MD5 81a6c0292284ac5066b7c452dba54b57 binutils-2.14.90.0.2.ebuild 5583
MD5 e56840c0286c1b40a114e80ced64dc45 binutils-2.13.90.0.18.ebuild 4572
MD5 92e0fa5133dbba4ffefc25a217f28686 binutils-2.14.90.0.5-r1.ebuild 5781
diff --git a/sys-devel/binutils/binutils-2.14.90.0.7-r1.ebuild b/sys-devel/binutils/binutils-2.14.90.0.7-r1.ebuild
new file mode 100644
index 000000000000..ba3b5a3cf6cf
--- /dev/null
+++ b/sys-devel/binutils/binutils-2.14.90.0.7-r1.ebuild
@@ -0,0 +1,199 @@
+# Copyright 1999-2003 Gentoo Technologies, Inc.
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/sys-devel/binutils/binutils-2.14.90.0.7-r1.ebuild,v 1.1 2003/11/07 01:21:05 lu_zero Exp $
+
+IUSE="nls bootstrap build"
+
+# NOTE to Maintainer: ChangeLog states that it no longer use perl to build
+# the manpages, but seems this is incorrect ....
+
+inherit eutils libtool flag-o-matic
+
+# Generate borked binaries. Bug #6730
+filter-flags "-fomit-frame-pointer -fssa"
+
+S="${WORKDIR}/${P}"
+DESCRIPTION="Tools necessary to build programs"
+SRC_URI="mirror://kernel/linux/devel/binutils/${P}.tar.bz2
+ mirror://kernel/linux/devel/binutils/test/${P}.tar.bz2"
+HOMEPAGE="http://sources.redhat.com/binutils/"
+
+SLOT="0"
+LICENSE="GPL-2 | LGPL-2"
+KEYWORDS="~ppc"
+
+DEPEND="virtual/glibc
+ nls? ( sys-devel/gettext )
+ !build? ( !bootstrap? ( dev-lang/perl ) )"
+
+
+src_unpack() {
+
+ unpack ${A}
+
+ cd ${S}
+ epatch ${FILESDIR}/2.13/${PN}-2.13.90.0.10-glibc21.patch
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.4-sparc-nonpic.patch
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.6-eh-frame-ro-2.patch
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.4-ltconfig-multilib.patch
+# Might think of adding the Prescott stuff later on
+# epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.4-pni.patch
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.5-s390-pie.patch
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.5-ppc64-pie.patch
+ epatch ${FILESDIR}/2.13/${PN}-2.13.90.0.10-x86_64-testsuite.patch
+ epatch ${FILESDIR}/2.13/${PN}-2.13.90.0.10-x86_64-gotpcrel.patch
+ epatch ${FILESDIR}/2.13/${PN}-2.13.90.0.18-testsuite-Wall-fixes.patch
+
+# This one seems to be partly merged, will need to check later on why
+# some bits to bfd/elf-strtab.c was not merged ...
+ # This increase c++ linking 2 to 3 times, bug #27540.
+# epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.6-merge-speedup.patch
+
+ # Some IA64 patches
+ epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.6-ia64-speedup.patch
+
+ if [ "${ARCH}" = "amd64" ]
+ then
+ epatch ${FILESDIR}/${PN}-2.14.amd64-32bit-path-fix.patch
+ fi
+
+ use x86 &> /dev/null \
+ && epatch ${FILESDIR}/2.13/${PN}-2.13.90.0.20-array-sects-compat.patch
+
+ use ppc &> /dev/null \
+ && epatch ${FILESDIR}/2.14/${PN}-2.14.90.0.7-ppc-reloc.patch
+
+
+ # Libtool is broken (Redhat).
+ for x in ${S}/opcodes/Makefile.{am,in}
+ do
+ cp ${x} ${x}.orig
+ gawk '
+ {
+ if ($0 ~ /LIBADD/)
+ gsub("../bfd/libbfd.la", "-L../bfd/.libs ../bfd/libbfd.la")
+
+ print
+ }' ${x}.orig > ${x}
+ rm -rf ${x}.orig
+ done
+}
+
+src_compile() {
+ local myconf=
+
+ use nls && \
+ myconf="${myconf} --without-included-gettext" || \
+ myconf="${myconf} --disable-nls"
+
+ # Filter CFLAGS=".. -O2 .." on arm
+ if [ "${ARCH}" = "arm" ]
+ then
+ CFLAGS="$(echo "${CFLAGS}" | sed -e 's,-O[2-9] ,-O1 ,')"
+ fi
+
+ # Fix /usr/lib/libbfd.la
+ elibtoolize --portage
+
+ ./configure --enable-shared \
+ --enable-64-bit-bfd \
+ --prefix=/usr \
+ --mandir=/usr/share/man \
+ --infodir=/usr/share/info \
+ --host=${CHOST} \
+ ${myconf} || die
+
+ make configure-bfd || die
+ make headers -C bfd || die
+ emake tooldir="${ROOT}/usr/bin" \
+ all || die
+
+ if [ -z "`use build`" ]
+ then
+ if [ -z "`use bootstrap`" ]
+ then
+ # Nuke the manpages to recreate them (only use this if we have perl)
+ find . -name '*.1' -exec rm -f {} \; || :
+ fi
+ # Make the info pages (makeinfo included with gcc is used)
+ make info || die
+ fi
+}
+
+src_install() {
+
+ make prefix=${D}/usr \
+ mandir=${D}/usr/share/man \
+ infodir=${D}/usr/share/info \
+ install || die
+
+ insinto /usr/include
+ doins include/libiberty.h
+
+ # c++filt is included with gcc -- what are these GNU people thinking?
+ # but not the manpage, so leave that!
+# We install it now, as gcc-3.3 do not have it any longer ...
+# rm -f ${D}/usr/bin/c++filt #${D}/usr/share/man/man1/c++filt*
+
+ # By default strip has a symlink going from /usr/${CHOST}/bin/strip to
+ # /usr/bin/strip we should reverse it:
+
+ rm ${D}/usr/${CHOST}/bin/strip; mv ${D}/usr/bin/strip ${D}/usr/${CHOST}/bin/strip
+ # The strip symlink gets created in the loop below
+
+ # By default ar, as, ld, nm, ranlib and strip are in two places; create
+ # symlinks. This will reduce the size of the tbz2 significantly. We also
+ # move all the stuff in /usr/bin to /usr/${CHOST}/bin and create the
+ # appropriate symlinks. Things are cleaner that way.
+ cd ${D}/usr/bin
+ local x=
+ for x in * strip
+ do
+ if [ ! -e ../${CHOST}/bin/${x} ]
+ then
+ mv ${x} ../${CHOST}/bin/${x}
+ else
+ rm -f ${x}
+ fi
+ ln -s ../${CHOST}/bin/${x} ${x}
+ done
+
+ if [ -n "${PROFILE_ARCH}" ] && \
+ [ "${PROFILE_ARCH/64}" != "${PROFILE_ARCH}" ]
+ then
+ dosym ${CHOST} /usr/${CHOST/-/64-}
+
+ for x in `ls ${D}/usr/${CHOST/-/64-}/bin/`
+ do
+ dosym ../${CHOST/-/64-}/bin/${x} /usr/bin/${CHOST/-/64-}-${x}
+ done
+ fi
+
+ cd ${S}
+ if [ -z "`use build`" ]
+ then
+ make prefix=${D}/usr \
+ mandir=${D}/usr/share/man \
+ infodir=${D}/usr/share/info \
+ install-info || die
+
+ dodoc COPYING* README
+ docinto bfd
+ dodoc bfd/ChangeLog* bfd/COPYING bfd/README bfd/PORTING bfd/TODO
+ docinto binutils
+ dodoc binutils/ChangeLog binutils/NEWS binutils/README
+ docinto gas
+ dodoc gas/ChangeLog* gas/CONTRIBUTORS gas/COPYING gas/NEWS gas/README*
+ docinto gprof
+ dodoc gprof/ChangeLog* gprof/TEST gprof/TODO
+ docinto ld
+ dodoc ld/ChangeLog* ld/README ld/NEWS ld/TODO
+ docinto libiberty
+ dodoc libiberty/ChangeLog* libiberty/COPYING.LIB libiberty/README
+ docinto opcodes
+ dodoc opcodes/ChangeLog*
+ # Install pre-generated manpages .. currently we do not ...
+ else
+ rm -rf ${D}/usr/share/man
+ fi
+}
diff --git a/sys-devel/binutils/files/2.14/binutils-2.14.90.0.7-ppc-reloc.patch b/sys-devel/binutils/files/2.14/binutils-2.14.90.0.7-ppc-reloc.patch
new file mode 100644
index 000000000000..6c14a3708128
--- /dev/null
+++ b/sys-devel/binutils/files/2.14/binutils-2.14.90.0.7-ppc-reloc.patch
@@ -0,0 +1,6673 @@
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf-bfd.h binutils-2.14.90.0.7/bfd/elf-bfd.h
+--- binutils-2.14.90.0.7.orig/bfd/elf-bfd.h 2003-11-07 00:11:22.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf-bfd.h 2003-11-07 00:21:15.000000000 +0100
+@@ -1303,7 +1303,7 @@
+ extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
+ (const Elf_Internal_Rela *);
+ extern bfd_vma _bfd_elf_rela_local_sym
+- (bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *);
++ (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
+ extern bfd_vma _bfd_elf_rel_local_sym
+ (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
+ extern bfd_vma _bfd_elf_section_offset
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf-bfd.h.orig binutils-2.14.90.0.7/bfd/elf-bfd.h.orig
+--- binutils-2.14.90.0.7.orig/bfd/elf-bfd.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf-bfd.h.orig 2003-11-07 00:20:18.000000000 +0100
+@@ -0,0 +1,1751 @@
++/* BFD back-end data structures for ELF files.
++ Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
++ 2002, 2003 Free Software Foundation, Inc.
++ Written by Cygnus Support.
++
++ This file is part of BFD, the Binary File Descriptor library.
++
++ This program is free software; you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation; either version 2 of the License, or
++ (at your option) any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with this program; if not, write to the Free Software
++ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++#ifndef _LIBELF_H_
++#define _LIBELF_H_ 1
++
++#include "elf/common.h"
++#include "elf/internal.h"
++#include "elf/external.h"
++#include "bfdlink.h"
++
++/* The number of entries in a section is its size divided by the size
++ of a single entry. This is normally only applicable to reloc and
++ symbol table sections. */
++#define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_size / (shdr)->sh_entsize)
++
++/* If size isn't specified as 64 or 32, NAME macro should fail. */
++#ifndef NAME
++#if ARCH_SIZE == 64
++#define NAME(x, y) x ## 64 ## _ ## y
++#endif
++#if ARCH_SIZE == 32
++#define NAME(x, y) x ## 32 ## _ ## y
++#endif
++#endif
++
++#ifndef NAME
++#define NAME(x, y) x ## NOSIZE ## _ ## y
++#endif
++
++#define ElfNAME(X) NAME(Elf,X)
++#define elfNAME(X) NAME(elf,X)
++
++/* Information held for an ELF symbol. The first field is the
++ corresponding asymbol. Every symbol is an ELF file is actually a
++ pointer to this structure, although it is often handled as a
++ pointer to an asymbol. */
++
++typedef struct
++{
++ /* The BFD symbol. */
++ asymbol symbol;
++ /* ELF symbol information. */
++ Elf_Internal_Sym internal_elf_sym;
++ /* Backend specific information. */
++ union
++ {
++ unsigned int hppa_arg_reloc;
++ void *mips_extr;
++ void *any;
++ }
++ tc_data;
++
++ /* Version information. This is from an Elf_Internal_Versym
++ structure in a SHT_GNU_versym section. It is zero if there is no
++ version information. */
++ unsigned short version;
++
++} elf_symbol_type;
++
++struct elf_strtab_hash;
++struct got_entry;
++struct plt_entry;
++
++/* ELF linker hash table entries. */
++
++struct elf_link_hash_entry
++{
++ struct bfd_link_hash_entry root;
++
++ /* Symbol index in output file. This is initialized to -1. It is
++ set to -2 if the symbol is used by a reloc. */
++ long indx;
++
++ /* Symbol index as a dynamic symbol. Initialized to -1, and remains
++ -1 if this is not a dynamic symbol. */
++ /* ??? Note that this is consistently used as a synonym for tests
++ against whether we can perform various simplifying transformations
++ to the code. (E.g. changing a pc-relative jump to a PLT entry
++ into a pc-relative jump to the target function.) That test, which
++ is often relatively complex, and someplaces wrong or incomplete,
++ should really be replaced by a predicate in elflink.c.
++
++ End result: this field -1 does not indicate that the symbol is
++ not in the dynamic symbol table, but rather that the symbol is
++ not visible outside this DSO. */
++ long dynindx;
++
++ /* String table index in .dynstr if this is a dynamic symbol. */
++ unsigned long dynstr_index;
++
++ /* Hash value of the name computed using the ELF hash function. */
++ unsigned long elf_hash_value;
++
++ /* If this is a weak defined symbol from a dynamic object, this
++ field points to a defined symbol with the same value, if there is
++ one. Otherwise it is NULL. */
++ struct elf_link_hash_entry *weakdef;
++
++ /* Version information. */
++ union
++ {
++ /* This field is used for a symbol which is not defined in a
++ regular object. It points to the version information read in
++ from the dynamic object. */
++ Elf_Internal_Verdef *verdef;
++ /* This field is used for a symbol which is defined in a regular
++ object. It is set up in size_dynamic_sections. It points to
++ the version information we should write out for this symbol. */
++ struct bfd_elf_version_tree *vertree;
++ } verinfo;
++
++ /* Virtual table entry use information. This array is nominally of size
++ size/sizeof(target_void_pointer), though we have to be able to assume
++ and track a size while the symbol is still undefined. It is indexed
++ via offset/sizeof(target_void_pointer). */
++ size_t vtable_entries_size;
++ bfd_boolean *vtable_entries_used;
++
++ /* Virtual table derivation info. */
++ struct elf_link_hash_entry *vtable_parent;
++
++ /* If this symbol requires an entry in the global offset table, the
++ processor specific backend uses this field to track usage and
++ final offset. Two schemes are supported: The first assumes that
++ a symbol may only have one GOT entry, and uses REFCOUNT until
++ size_dynamic_sections, at which point the contents of the .got is
++ fixed. Afterward, if OFFSET is -1, then the symbol does not
++ require a global offset table entry. The second scheme allows
++ multiple GOT entries per symbol, managed via a linked list
++ pointed to by GLIST. */
++ union gotplt_union
++ {
++ bfd_signed_vma refcount;
++ bfd_vma offset;
++ struct got_entry *glist;
++ struct plt_entry *plist;
++ } got;
++
++ /* Same, but tracks a procedure linkage table entry. */
++ union gotplt_union plt;
++
++ /* Symbol size. */
++ bfd_size_type size;
++
++ /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.). */
++ char type;
++
++ /* Symbol st_other value, symbol visibility. */
++ unsigned char other;
++
++ /* Some flags; legal values follow. */
++ unsigned short elf_link_hash_flags;
++ /* Symbol is referenced by a non-shared object. */
++#define ELF_LINK_HASH_REF_REGULAR 01
++ /* Symbol is defined by a non-shared object. */
++#define ELF_LINK_HASH_DEF_REGULAR 02
++ /* Symbol is referenced by a shared object. */
++#define ELF_LINK_HASH_REF_DYNAMIC 04
++ /* Symbol is defined by a shared object. */
++#define ELF_LINK_HASH_DEF_DYNAMIC 010
++ /* Symbol has a non-weak reference from a non-shared object. */
++#define ELF_LINK_HASH_REF_REGULAR_NONWEAK 020
++ /* Dynamic symbol has been adjustd. */
++#define ELF_LINK_HASH_DYNAMIC_ADJUSTED 040
++ /* Symbol needs a copy reloc. */
++#define ELF_LINK_HASH_NEEDS_COPY 0100
++ /* Symbol needs a procedure linkage table entry. */
++#define ELF_LINK_HASH_NEEDS_PLT 0200
++ /* Symbol appears in a non-ELF input file. */
++#define ELF_LINK_NON_ELF 0400
++ /* Symbol should be marked as hidden in the version information. */
++#define ELF_LINK_HIDDEN 01000
++ /* Symbol was forced to local scope due to a version script file. */
++#define ELF_LINK_FORCED_LOCAL 02000
++ /* Symbol was marked during garbage collection. */
++#define ELF_LINK_HASH_MARK 04000
++ /* Symbol is referenced by a non-GOT/non-PLT relocation. This is
++ not currently set by all the backends. */
++#define ELF_LINK_NON_GOT_REF 010000
++ /* Symbol has a definition in a shared object. */
++#define ELF_LINK_DYNAMIC_DEF 020000
++ /* Symbol is weak in all shared objects. */
++#define ELF_LINK_DYNAMIC_WEAK 040000
++};
++
++/* Will references to this symbol always reference the symbol
++ in this object? STV_PROTECTED is excluded from the visibility test
++ here so that function pointer comparisons work properly. Since
++ function symbols not defined in an app are set to their .plt entry,
++ it's necessary for shared libs to also reference the .plt even
++ though the symbol is really local to the shared lib. */
++#define SYMBOL_REFERENCES_LOCAL(INFO, H) \
++ _bfd_elf_symbol_refs_local_p (H, INFO, 0)
++
++/* Will _calls_ to this symbol always call the version in this object? */
++#define SYMBOL_CALLS_LOCAL(INFO, H) \
++ _bfd_elf_symbol_refs_local_p (H, INFO, 1)
++
++/* Records local symbols to be emitted in the dynamic symbol table. */
++
++struct elf_link_local_dynamic_entry
++{
++ struct elf_link_local_dynamic_entry *next;
++
++ /* The input bfd this symbol came from. */
++ bfd *input_bfd;
++
++ /* The index of the local symbol being copied. */
++ long input_indx;
++
++ /* The index in the outgoing dynamic symbol table. */
++ long dynindx;
++
++ /* A copy of the input symbol. */
++ Elf_Internal_Sym isym;
++};
++
++struct elf_link_loaded_list
++{
++ struct elf_link_loaded_list *next;
++ bfd *abfd;
++};
++
++/* Structures used by the eh_frame optimization code. */
++struct cie_header
++{
++ unsigned int length;
++ unsigned int id;
++};
++
++struct cie
++{
++ struct cie_header hdr;
++ unsigned char version;
++ unsigned char augmentation[20];
++ unsigned int code_align;
++ int data_align;
++ unsigned int ra_column;
++ unsigned int augmentation_size;
++ struct elf_link_hash_entry *personality;
++ unsigned char per_encoding;
++ unsigned char lsda_encoding;
++ unsigned char fde_encoding;
++ unsigned char initial_insn_length;
++ unsigned char make_relative;
++ unsigned char make_lsda_relative;
++ unsigned char initial_instructions[50];
++};
++
++struct eh_cie_fde
++{
++ unsigned int offset;
++ unsigned int size;
++ asection *sec;
++ unsigned int new_offset;
++ unsigned char fde_encoding;
++ unsigned char lsda_encoding;
++ unsigned char lsda_offset;
++ unsigned char cie : 1;
++ unsigned char removed : 1;
++ unsigned char make_relative : 1;
++ unsigned char make_lsda_relative : 1;
++ unsigned char per_encoding_relative : 1;
++};
++
++struct eh_frame_sec_info
++{
++ unsigned int count;
++ unsigned int alloced;
++ struct eh_cie_fde entry[1];
++};
++
++struct eh_frame_array_ent
++{
++ bfd_vma initial_loc;
++ bfd_vma fde;
++};
++
++struct eh_frame_hdr_info
++{
++ struct cie last_cie;
++ asection *last_cie_sec;
++ asection *hdr_sec;
++ unsigned int last_cie_offset;
++ unsigned int fde_count, array_count;
++ struct eh_frame_array_ent *array;
++ /* TRUE if .eh_frame_hdr should contain the sorted search table.
++ We build it if we successfully read all .eh_frame input sections
++ and recognize them. */
++ bfd_boolean table;
++};
++
++/* Cached start, size and alignment of PT_TLS segment. */
++struct elf_link_tls_segment
++{
++ bfd_vma start;
++ bfd_size_type size;
++ unsigned int align;
++};
++
++/* ELF linker hash table. */
++
++struct elf_link_hash_table
++{
++ struct bfd_link_hash_table root;
++
++ /* Whether we have created the special dynamic sections required
++ when linking against or generating a shared object. */
++ bfd_boolean dynamic_sections_created;
++
++ /* The BFD used to hold special sections created by the linker.
++ This will be the first BFD found which requires these sections to
++ be created. */
++ bfd *dynobj;
++
++ /* The value to use when initialising got.refcount/offset and
++ plt.refcount/offset in an elf_link_hash_entry. Set to zero when
++ the values are refcounts. Set to init_offset in
++ size_dynamic_sections when the values may be offsets. */
++ union gotplt_union init_refcount;
++
++ /* The value to use for got.refcount/offset and plt.refcount/offset
++ when the values may be offsets. Normally (bfd_vma) -1. */
++ union gotplt_union init_offset;
++
++ /* The number of symbols found in the link which must be put into
++ the .dynsym section. */
++ bfd_size_type dynsymcount;
++
++ /* The string table of dynamic symbols, which becomes the .dynstr
++ section. */
++ struct elf_strtab_hash *dynstr;
++
++ /* The number of buckets in the hash table in the .hash section.
++ This is based on the number of dynamic symbols. */
++ bfd_size_type bucketcount;
++
++ /* A linked list of DT_NEEDED names found in dynamic objects
++ included in the link. */
++ struct bfd_link_needed_list *needed;
++
++ /* The _GLOBAL_OFFSET_TABLE_ symbol. */
++ struct elf_link_hash_entry *hgot;
++
++ /* A pointer to information used to link stabs in sections. */
++ void *stab_info;
++
++ /* A pointer to information used to merge SEC_MERGE sections. */
++ void *merge_info;
++
++ /* Used by eh_frame code when editing .eh_frame. */
++ struct eh_frame_hdr_info eh_info;
++
++ /* A linked list of local symbols to be added to .dynsym. */
++ struct elf_link_local_dynamic_entry *dynlocal;
++
++ /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
++ objects included in the link. */
++ struct bfd_link_needed_list *runpath;
++
++ /* Cached start, size and alignment of PT_TLS segment. */
++ struct elf_link_tls_segment *tls_segment;
++
++ /* A linked list of BFD's loaded in the link. */
++ struct elf_link_loaded_list *loaded;
++};
++
++/* Look up an entry in an ELF linker hash table. */
++
++#define elf_link_hash_lookup(table, string, create, copy, follow) \
++ ((struct elf_link_hash_entry *) \
++ bfd_link_hash_lookup (&(table)->root, (string), (create), \
++ (copy), (follow)))
++
++/* Traverse an ELF linker hash table. */
++
++#define elf_link_hash_traverse(table, func, info) \
++ (bfd_link_hash_traverse \
++ (&(table)->root, \
++ (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
++ (info)))
++
++/* Get the ELF linker hash table from a link_info structure. */
++
++#define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
++
++/* Returns TRUE if the hash table is a struct elf_link_hash_table. */
++#define is_elf_hash_table(p) \
++ ((p)->hash->type == bfd_link_elf_hash_table)
++
++/* Used by bfd_section_from_r_symndx to cache a small number of local
++ symbol to section mappings. */
++#define LOCAL_SYM_CACHE_SIZE 32
++struct sym_sec_cache
++{
++ bfd *abfd;
++ unsigned long indx[LOCAL_SYM_CACHE_SIZE];
++ asection *sec[LOCAL_SYM_CACHE_SIZE];
++};
++
++/* Constant information held for an ELF backend. */
++
++struct elf_size_info {
++ unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
++ unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
++
++ /* The size of entries in the .hash section. */
++ unsigned char sizeof_hash_entry;
++
++ /* The number of internal relocations to allocate per external
++ relocation entry. */
++ unsigned char int_rels_per_ext_rel;
++ /* We use some fixed size arrays. This should be large enough to
++ handle all back-ends. */
++#define MAX_INT_RELS_PER_EXT_REL 3
++
++ unsigned char arch_size, log_file_align;
++ unsigned char elfclass, ev_current;
++ int (*write_out_phdrs)
++ (bfd *, const Elf_Internal_Phdr *, unsigned int);
++ bfd_boolean
++ (*write_shdrs_and_ehdr) (bfd *);
++ void (*write_relocs)
++ (bfd *, asection *, void *);
++ void (*swap_symbol_in)
++ (bfd *, const void *, const void *, Elf_Internal_Sym *);
++ void (*swap_symbol_out)
++ (bfd *, const Elf_Internal_Sym *, void *, void *);
++ bfd_boolean (*slurp_reloc_table)
++ (bfd *, asection *, asymbol **, bfd_boolean);
++ long (*slurp_symbol_table)
++ (bfd *, asymbol **, bfd_boolean);
++ void (*swap_dyn_in)
++ (bfd *, const void *, Elf_Internal_Dyn *);
++ void (*swap_dyn_out)
++ (bfd *, const Elf_Internal_Dyn *, void *);
++
++ /* This function is called to swap in a REL relocation. If an
++ external relocation corresponds to more than one internal
++ relocation, then all relocations are swapped in at once. */
++ void (*swap_reloc_in)
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++
++ /* This function is called to swap out a REL relocation. */
++ void (*swap_reloc_out)
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++
++ /* This function is called to swap in a RELA relocation. If an
++ external relocation corresponds to more than one internal
++ relocation, then all relocations are swapped in at once. */
++ void (*swap_reloca_in)
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++
++ /* This function is called to swap out a RELA relocation. */
++ void (*swap_reloca_out)
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++};
++
++#define elf_symbol_from(ABFD,S) \
++ (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
++ && (S)->the_bfd->tdata.elf_obj_data != 0) \
++ ? (elf_symbol_type *) (S) \
++ : 0)
++
++enum elf_reloc_type_class {
++ reloc_class_normal,
++ reloc_class_relative,
++ reloc_class_plt,
++ reloc_class_copy
++};
++
++struct elf_reloc_cookie
++{
++ Elf_Internal_Rela *rels, *rel, *relend;
++ Elf_Internal_Sym *locsyms;
++ bfd *abfd;
++ size_t locsymcount;
++ size_t extsymoff;
++ struct elf_link_hash_entry **sym_hashes;
++ bfd_boolean bad_symtab;
++};
++
++/* The level of IRIX compatibility we're striving for. */
++
++typedef enum {
++ ict_none,
++ ict_irix5,
++ ict_irix6
++} irix_compat_t;
++
++/* Mapping of ELF section names and types. */
++struct bfd_elf_special_section
++{
++ const char *prefix;
++ int prefix_length;
++ /* 0 means name must match PREFIX exactly.
++ -1 means name must start with PREFIX followed by an arbitrary string.
++ -2 means name must match PREFIX exactly or consist of PREFIX followed
++ by a dot then anything.
++ > 0 means name must start with the first PREFIX_LENGTH chars of
++ PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX. */
++ int suffix_length;
++ int type;
++ int attr;
++};
++
++struct elf_backend_data
++{
++ /* The architecture for this backend. */
++ enum bfd_architecture arch;
++
++ /* The ELF machine code (EM_xxxx) for this backend. */
++ int elf_machine_code;
++
++ /* The maximum page size for this backend. */
++ bfd_vma maxpagesize;
++
++ /* A function to translate an ELF RELA relocation to a BFD arelent
++ structure. */
++ void (*elf_info_to_howto)
++ (bfd *, arelent *, Elf_Internal_Rela *);
++
++ /* A function to translate an ELF REL relocation to a BFD arelent
++ structure. */
++ void (*elf_info_to_howto_rel)
++ (bfd *, arelent *, Elf_Internal_Rela *);
++
++ /* A function to determine whether a symbol is global when
++ partitioning the symbol table into local and global symbols.
++ This should be NULL for most targets, in which case the correct
++ thing will be done. MIPS ELF, at least on the Irix 5, has
++ special requirements. */
++ bfd_boolean (*elf_backend_sym_is_global)
++ (bfd *, asymbol *);
++
++ /* The remaining functions are hooks which are called only if they
++ are not NULL. */
++
++ /* A function to permit a backend specific check on whether a
++ particular BFD format is relevant for an object file, and to
++ permit the backend to set any global information it wishes. When
++ this is called elf_elfheader is set, but anything else should be
++ used with caution. If this returns FALSE, the check_format
++ routine will return a bfd_error_wrong_format error. */
++ bfd_boolean (*elf_backend_object_p)
++ (bfd *);
++
++ /* A function to do additional symbol processing when reading the
++ ELF symbol table. This is where any processor-specific special
++ section indices are handled. */
++ void (*elf_backend_symbol_processing)
++ (bfd *, asymbol *);
++
++ /* A function to do additional symbol processing after reading the
++ entire ELF symbol table. */
++ bfd_boolean (*elf_backend_symbol_table_processing)
++ (bfd *, elf_symbol_type *, unsigned int);
++
++ /* A function to set the type of the info field. Processor-specific
++ types should be handled here. */
++ int (*elf_backend_get_symbol_type)
++ (Elf_Internal_Sym *, int);
++
++ /* A function to do additional processing on the ELF section header
++ just before writing it out. This is used to set the flags and
++ type fields for some sections, or to actually write out data for
++ unusual sections. */
++ bfd_boolean (*elf_backend_section_processing)
++ (bfd *, Elf_Internal_Shdr *);
++
++ /* A function to handle unusual section types when creating BFD
++ sections from ELF sections. */
++ bfd_boolean (*elf_backend_section_from_shdr)
++ (bfd *, Elf_Internal_Shdr *, const char *);
++
++ /* A function to convert machine dependent section header flags to
++ BFD internal section header flags. */
++ bfd_boolean (*elf_backend_section_flags)
++ (flagword *, Elf_Internal_Shdr *);
++
++ /* A function to handle unusual program segment types when creating BFD
++ sections from ELF program segments. */
++ bfd_boolean (*elf_backend_section_from_phdr)
++ (bfd *, Elf_Internal_Phdr *, int);
++
++ /* A function to set up the ELF section header for a BFD section in
++ preparation for writing it out. This is where the flags and type
++ fields are set for unusual sections. */
++ bfd_boolean (*elf_backend_fake_sections)
++ (bfd *, Elf_Internal_Shdr *, asection *);
++
++ /* A function to get the ELF section index for a BFD section. If
++ this returns TRUE, the section was found. If it is a normal ELF
++ section, *RETVAL should be left unchanged. If it is not a normal
++ ELF section *RETVAL should be set to the SHN_xxxx index. */
++ bfd_boolean (*elf_backend_section_from_bfd_section)
++ (bfd *, asection *, int *retval);
++
++ /* If this field is not NULL, it is called by the add_symbols phase
++ of a link just before adding a symbol to the global linker hash
++ table. It may modify any of the fields as it wishes. If *NAME
++ is set to NULL, the symbol will be skipped rather than being
++ added to the hash table. This function is responsible for
++ handling all processor dependent symbol bindings and section
++ indices, and must set at least *FLAGS and *SEC for each processor
++ dependent case; failure to do so will cause a link error. */
++ bfd_boolean (*elf_add_symbol_hook)
++ (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *,
++ const char **name, flagword *flags, asection **sec, bfd_vma *value);
++
++ /* If this field is not NULL, it is called by the elf_link_output_sym
++ phase of a link for each symbol which will appear in the object file. */
++ bfd_boolean (*elf_backend_link_output_symbol_hook)
++ (bfd *, struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
++ asection *);
++
++ /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
++ linker the first time it encounters a dynamic object in the link.
++ This function must create any sections required for dynamic
++ linking. The ABFD argument is a dynamic object. The .interp,
++ .dynamic, .dynsym, .dynstr, and .hash functions have already been
++ created, and this function may modify the section flags if
++ desired. This function will normally create the .got and .plt
++ sections, but different backends have different requirements. */
++ bfd_boolean (*elf_backend_create_dynamic_sections)
++ (bfd *abfd, struct bfd_link_info *info);
++
++ /* The CHECK_RELOCS function is called by the add_symbols phase of
++ the ELF backend linker. It is called once for each section with
++ relocs of an object file, just after the symbols for the object
++ file have been added to the global linker hash table. The
++ function must look through the relocs and do any special handling
++ required. This generally means allocating space in the global
++ offset table, and perhaps allocating space for a reloc. The
++ relocs are always passed as Rela structures; if the section
++ actually uses Rel structures, the r_addend field will always be
++ zero. */
++ bfd_boolean (*check_relocs)
++ (bfd *abfd, struct bfd_link_info *info, asection *o,
++ const Elf_Internal_Rela *relocs);
++
++ /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
++ linker for every symbol which is defined by a dynamic object and
++ referenced by a regular object. This is called after all the
++ input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
++ function has been called. The hash table entry should be
++ bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
++ defined in a section from a dynamic object. Dynamic object
++ sections are not included in the final link, and this function is
++ responsible for changing the value to something which the rest of
++ the link can deal with. This will normally involve adding an
++ entry to the .plt or .got or some such section, and setting the
++ symbol to point to that. */
++ bfd_boolean (*elf_backend_adjust_dynamic_symbol)
++ (struct bfd_link_info *info, struct elf_link_hash_entry *h);
++
++ /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
++ after all the linker input files have been seen but before the
++ section sizes have been set. This is called after
++ ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */
++ bfd_boolean (*elf_backend_always_size_sections)
++ (bfd *output_bfd, struct bfd_link_info *info);
++
++ /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
++ linker after all the linker input files have been seen but before
++ the sections sizes have been set. This is called after
++ ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
++ It is only called when linking against a dynamic object. It must
++ set the sizes of the dynamic sections, and may fill in their
++ contents as well. The generic ELF linker can handle the .dynsym,
++ .dynstr and .hash sections. This function must handle the
++ .interp section and any sections created by the
++ CREATE_DYNAMIC_SECTIONS entry point. */
++ bfd_boolean (*elf_backend_size_dynamic_sections)
++ (bfd *output_bfd, struct bfd_link_info *info);
++
++ /* The RELOCATE_SECTION function is called by the ELF backend linker
++ to handle the relocations for a section.
++
++ The relocs are always passed as Rela structures; if the section
++ actually uses Rel structures, the r_addend field will always be
++ zero.
++
++ This function is responsible for adjust the section contents as
++ necessary, and (if using Rela relocs and generating a
++ relocatable output file) adjusting the reloc addend as
++ necessary.
++
++ This function does not have to worry about setting the reloc
++ address or the reloc symbol index.
++
++ LOCAL_SYMS is a pointer to the swapped in local symbols.
++
++ LOCAL_SECTIONS is an array giving the section in the input file
++ corresponding to the st_shndx field of each local symbol.
++
++ The global hash table entry for the global symbols can be found
++ via elf_sym_hashes (input_bfd).
++
++ When generating relocatable output, this function must handle
++ STB_LOCAL/STT_SECTION symbols specially. The output symbol is
++ going to be the section symbol corresponding to the output
++ section, which means that the addend must be adjusted
++ accordingly. */
++ bfd_boolean (*elf_backend_relocate_section)
++ (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
++ asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
++ Elf_Internal_Sym *local_syms, asection **local_sections);
++
++ /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
++ linker just before it writes a symbol out to the .dynsym section.
++ The processor backend may make any required adjustment to the
++ symbol. It may also take the opportunity to set contents of the
++ dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on
++ all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
++ on those symbols which are defined by a dynamic object. */
++ bfd_boolean (*elf_backend_finish_dynamic_symbol)
++ (bfd *output_bfd, struct bfd_link_info *info,
++ struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
++
++ /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
++ linker just before it writes all the dynamic sections out to the
++ output file. The FINISH_DYNAMIC_SYMBOL will have been called on
++ all dynamic symbols. */
++ bfd_boolean (*elf_backend_finish_dynamic_sections)
++ (bfd *output_bfd, struct bfd_link_info *info);
++
++ /* A function to do any beginning processing needed for the ELF file
++ before building the ELF headers and computing file positions. */
++ void (*elf_backend_begin_write_processing)
++ (bfd *, struct bfd_link_info *);
++
++ /* A function to do any final processing needed for the ELF file
++ before writing it out. The LINKER argument is TRUE if this BFD
++ was created by the ELF backend linker. */
++ void (*elf_backend_final_write_processing)
++ (bfd *, bfd_boolean linker);
++
++ /* This function is called by get_program_header_size. It should
++ return the number of additional program segments which this BFD
++ will need. It should return -1 on error. */
++ int (*elf_backend_additional_program_headers)
++ (bfd *);
++
++ /* This function is called to modify an existing segment map in a
++ backend specific fashion. */
++ bfd_boolean (*elf_backend_modify_segment_map)
++ (bfd *);
++
++ /* This function is called during section gc to discover the section a
++ particular relocation refers to. */
++ asection * (*gc_mark_hook)
++ (asection *sec, struct bfd_link_info *, Elf_Internal_Rela *,
++ struct elf_link_hash_entry *h, Elf_Internal_Sym *);
++
++ /* This function, if defined, is called during the sweep phase of gc
++ in order that a backend might update any data structures it might
++ be maintaining. */
++ bfd_boolean (*gc_sweep_hook)
++ (bfd *abfd, struct bfd_link_info *info, asection *o,
++ const Elf_Internal_Rela *relocs);
++
++ /* This function, if defined, is called after the ELF headers have
++ been created. This allows for things like the OS and ABI versions
++ to be changed. */
++ void (*elf_backend_post_process_headers)
++ (bfd *, struct bfd_link_info *);
++
++ /* This function, if defined, prints a symbol to file and returns the
++ name of the symbol to be printed. It should return NULL to fall
++ back to default symbol printing. */
++ const char *(*elf_backend_print_symbol_all)
++ (bfd *, void *, asymbol *);
++
++ /* This function, if defined, is called after all local symbols and
++ global symbols converted to locals are emited into the symtab
++ section. It allows the backend to emit special global symbols
++ not handled in the hash table. */
++ bfd_boolean (*elf_backend_output_arch_syms)
++ (bfd *, struct bfd_link_info *, void *,
++ bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *));
++
++ /* Copy any information related to dynamic linking from a pre-existing
++ symbol to a newly created symbol. Also called to copy flags and
++ other back-end info to a weakdef, in which case the symbol is not
++ newly created and plt/got refcounts and dynamic indices should not
++ be copied. */
++ void (*elf_backend_copy_indirect_symbol)
++ (const struct elf_backend_data *, struct elf_link_hash_entry *,
++ struct elf_link_hash_entry *);
++
++ /* Modify any information related to dynamic linking such that the
++ symbol is not exported. */
++ void (*elf_backend_hide_symbol)
++ (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
++
++ /* Merge the backend specific symbol attribute. */
++ void (*elf_backend_merge_symbol_attribute)
++ (struct elf_link_hash_entry *, const Elf_Internal_Sym *, bfd_boolean,
++ bfd_boolean);
++
++ /* Emit relocations. Overrides default routine for emitting relocs,
++ except during a relocatable link, or if all relocs are being emitted. */
++ bfd_boolean (*elf_backend_emit_relocs)
++ (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
++
++ /* Count relocations. Not called for relocatable links
++ or if all relocs are being preserved in the output. */
++ unsigned int (*elf_backend_count_relocs)
++ (asection *, Elf_Internal_Rela *);
++
++ /* This function, if defined, is called when an NT_PRSTATUS note is found
++ in a core file. */
++ bfd_boolean (*elf_backend_grok_prstatus)
++ (bfd *, Elf_Internal_Note *);
++
++ /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
++ note is found in a core file. */
++ bfd_boolean (*elf_backend_grok_psinfo)
++ (bfd *, Elf_Internal_Note *);
++
++ /* Functions to print VMAs. Special code to handle 64 bit ELF files. */
++ void (* elf_backend_sprintf_vma)
++ (bfd *, char *, bfd_vma);
++ void (* elf_backend_fprintf_vma)
++ (bfd *, void *, bfd_vma);
++
++ /* This function returns class of a reloc type. */
++ enum elf_reloc_type_class (*elf_backend_reloc_type_class)
++ (const Elf_Internal_Rela *);
++
++ /* This function, if defined, removes information about discarded functions
++ from other sections which mention them. */
++ bfd_boolean (*elf_backend_discard_info)
++ (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
++
++ /* This function, if defined, signals that the function above has removed
++ the discarded relocations for this section. */
++ bfd_boolean (*elf_backend_ignore_discarded_relocs)
++ (asection *);
++
++ /* This function, if defined, may write out the given section.
++ Returns TRUE if it did so and FALSE if the caller should. */
++ bfd_boolean (*elf_backend_write_section)
++ (bfd *, asection *, bfd_byte *);
++
++ /* The level of IRIX compatibility we're striving for.
++ MIPS ELF specific function. */
++ irix_compat_t (*elf_backend_mips_irix_compat)
++ (bfd *);
++
++ reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
++ (unsigned int, bfd_boolean);
++
++ /* The swapping table to use when dealing with ECOFF information.
++ Used for the MIPS ELF .mdebug section. */
++ const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
++
++ /* This function implements `bfd_elf_bfd_from_remote_memory';
++ see elf.c, elfcode.h. */
++ bfd *(*elf_backend_bfd_from_remote_memory)
++ (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
++ int (*target_read_memory) (bfd_vma vma, char *myaddr, int len));
++
++ /* Alternate EM_xxxx machine codes for this backend. */
++ int elf_machine_alt1;
++ int elf_machine_alt2;
++
++ const struct elf_size_info *s;
++
++ /* An array of target specific special section map. */
++ const struct bfd_elf_special_section *special_sections;
++
++ /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the
++ .got section */
++ bfd_vma got_symbol_offset;
++
++ /* The size in bytes of the headers for the GOT and PLT. This includes
++ the so-called reserved entries on some systems. */
++ bfd_vma got_header_size;
++ bfd_vma plt_header_size;
++
++ /* This is TRUE if the linker should act like collect and gather
++ global constructors and destructors by name. This is TRUE for
++ MIPS ELF because the Irix 5 tools can not handle the .init
++ section. */
++ unsigned collect : 1;
++
++ /* This is TRUE if the linker should ignore changes to the type of a
++ symbol. This is TRUE for MIPS ELF because some Irix 5 objects
++ record undefined functions as STT_OBJECT although the definitions
++ are STT_FUNC. */
++ unsigned type_change_ok : 1;
++
++ /* Whether the backend may use REL relocations. (Some backends use
++ both REL and RELA relocations, and this flag is set for those
++ backends.) */
++ unsigned may_use_rel_p : 1;
++
++ /* Whether the backend may use RELA relocations. (Some backends use
++ both REL and RELA relocations, and this flag is set for those
++ backends.) */
++ unsigned may_use_rela_p : 1;
++
++ /* Whether the default relocation type is RELA. If a backend with
++ this flag set wants REL relocations for a particular section,
++ it must note that explicitly. Similarly, if this flag is clear,
++ and the backend wants RELA relocations for a particular
++ section. */
++ unsigned default_use_rela_p : 1;
++
++ /* Set if RELA relocations for a relocatable link can be handled by
++ generic code. Backends that set this flag need do nothing in the
++ backend relocate_section routine for relocatable linking. */
++ unsigned rela_normal : 1;
++
++ /* TRUE if addresses "naturally" sign extend. This is used when
++ swapping in from Elf32 when BFD64. */
++ unsigned sign_extend_vma : 1;
++
++ unsigned want_got_plt : 1;
++ unsigned plt_readonly : 1;
++ unsigned want_plt_sym : 1;
++ unsigned plt_not_loaded : 1;
++ unsigned plt_alignment : 4;
++ unsigned can_gc_sections : 1;
++ unsigned can_refcount : 1;
++ unsigned want_got_sym : 1;
++ unsigned want_dynbss : 1;
++ /* Targets which do not support physical addressing often require
++ that the p_paddr field in the section header to be set to zero.
++ This field indicates whether this behavior is required. */
++ unsigned want_p_paddr_set_to_zero : 1;
++};
++
++/* Information stored for each BFD section in an ELF file. This
++ structure is allocated by elf_new_section_hook. */
++
++struct bfd_elf_section_data
++{
++ /* The ELF header for this section. */
++ Elf_Internal_Shdr this_hdr;
++
++ /* The ELF header for the reloc section associated with this
++ section, if any. */
++ Elf_Internal_Shdr rel_hdr;
++
++ /* If there is a second reloc section associated with this section,
++ as can happen on Irix 6, this field points to the header. */
++ Elf_Internal_Shdr *rel_hdr2;
++
++ /* The number of relocations currently assigned to REL_HDR. */
++ unsigned int rel_count;
++
++ /* The number of relocations currently assigned to REL_HDR2. */
++ unsigned int rel_count2;
++
++ /* The ELF section number of this section. Only used for an output
++ file. */
++ int this_idx;
++
++ /* The ELF section number of the reloc section indicated by
++ REL_HDR if any. Only used for an output file. */
++ int rel_idx;
++
++ /* The ELF section number of the reloc section indicated by
++ REL_HDR2 if any. Only used for an output file. */
++ int rel_idx2;
++
++ /* Used by the backend linker when generating a shared library to
++ record the dynamic symbol index for a section symbol
++ corresponding to this section. A value of 0 means that there is
++ no dynamic symbol for this section. */
++ int dynindx;
++
++ /* Used by the backend linker to store the symbol hash table entries
++ associated with relocs against global symbols. */
++ struct elf_link_hash_entry **rel_hashes;
++
++ /* A pointer to the swapped relocs. If the section uses REL relocs,
++ rather than RELA, all the r_addend fields will be zero. This
++ pointer may be NULL. It is used by the backend linker. */
++ Elf_Internal_Rela *relocs;
++
++ /* A pointer to a linked list tracking dynamic relocs copied for
++ local symbols. */
++ void *local_dynrel;
++
++ /* A pointer to the bfd section used for dynamic relocs. */
++ asection *sreloc;
++
++ union {
++ /* Group name, if this section is a member of a group. */
++ const char *name;
++
++ /* Group signature sym, if this is the SHT_GROUP section. */
++ struct symbol_cache_entry *id;
++ } group;
++
++ /* A linked list of sections in the group. Circular when used by
++ the linker. */
++ asection *next_in_group;
++
++ /* A pointer used for various section optimizations. */
++ void *sec_info;
++};
++
++#define elf_section_data(sec) ((struct bfd_elf_section_data*)sec->used_by_bfd)
++#define elf_section_type(sec) (elf_section_data(sec)->this_hdr.sh_type)
++#define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
++#define elf_group_name(sec) (elf_section_data(sec)->group.name)
++#define elf_group_id(sec) (elf_section_data(sec)->group.id)
++#define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
++
++/* Return TRUE if section has been discarded. */
++#define elf_discarded_section(sec) \
++ (!bfd_is_abs_section (sec) \
++ && bfd_is_abs_section ((sec)->output_section) \
++ && sec->sec_info_type != ELF_INFO_TYPE_MERGE \
++ && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)
++
++#define get_elf_backend_data(abfd) \
++ ((const struct elf_backend_data *) (abfd)->xvec->backend_data)
++
++/* This struct is used to pass information to routines called via
++ elf_link_hash_traverse which must return failure. */
++
++struct elf_info_failed
++{
++ bfd_boolean failed;
++ struct bfd_link_info *info;
++ struct bfd_elf_version_tree *verdefs;
++};
++
++/* This structure is used to pass information to
++ _bfd_elf_link_assign_sym_version. */
++
++struct elf_assign_sym_version_info
++{
++ /* Output BFD. */
++ bfd *output_bfd;
++ /* General link information. */
++ struct bfd_link_info *info;
++ /* Version tree. */
++ struct bfd_elf_version_tree *verdefs;
++ /* Whether we had a failure. */
++ bfd_boolean failed;
++};
++
++/* This structure is used to pass information to
++ _bfd_elf_link_find_version_dependencies. */
++
++struct elf_find_verdep_info
++{
++ /* Output BFD. */
++ bfd *output_bfd;
++ /* General link information. */
++ struct bfd_link_info *info;
++ /* The number of dependencies. */
++ unsigned int vers;
++ /* Whether we had a failure. */
++ bfd_boolean failed;
++};
++
++/* Some private data is stashed away for future use using the tdata pointer
++ in the bfd structure. */
++
++struct elf_obj_tdata
++{
++ Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */
++ Elf_Internal_Shdr **elf_sect_ptr;
++ Elf_Internal_Phdr *phdr;
++ struct elf_segment_map *segment_map;
++ struct elf_strtab_hash *strtab_ptr;
++ int num_locals;
++ int num_globals;
++ unsigned int num_elf_sections; /* elf_sect_ptr size */
++ int num_section_syms;
++ asymbol **section_syms; /* STT_SECTION symbols for each section */
++ Elf_Internal_Shdr symtab_hdr;
++ Elf_Internal_Shdr shstrtab_hdr;
++ Elf_Internal_Shdr strtab_hdr;
++ Elf_Internal_Shdr dynsymtab_hdr;
++ Elf_Internal_Shdr dynstrtab_hdr;
++ Elf_Internal_Shdr dynversym_hdr;
++ Elf_Internal_Shdr dynverref_hdr;
++ Elf_Internal_Shdr dynverdef_hdr;
++ Elf_Internal_Shdr symtab_shndx_hdr;
++ unsigned int symtab_section, shstrtab_section;
++ unsigned int strtab_section, dynsymtab_section;
++ unsigned int symtab_shndx_section;
++ unsigned int dynversym_section, dynverdef_section, dynverref_section;
++ file_ptr next_file_pos;
++ bfd_vma gp; /* The gp value */
++ unsigned int gp_size; /* The gp size */
++
++ Elf_Internal_Shdr **group_sect_ptr;
++ int num_group;
++
++ /* Information grabbed from an elf core file. */
++ int core_signal;
++ int core_pid;
++ int core_lwpid;
++ char* core_program;
++ char* core_command;
++
++ /* This is set to TRUE if the object was created by the backend
++ linker. */
++ bfd_boolean linker;
++
++ /* A mapping from external symbols to entries in the linker hash
++ table, used when linking. This is indexed by the symbol index
++ minus the sh_info field of the symbol table header. */
++ struct elf_link_hash_entry **sym_hashes;
++
++ /* Track usage and final offsets of GOT entries for local symbols.
++ This array is indexed by symbol index. Elements are used
++ identically to "got" in struct elf_link_hash_entry. */
++ union
++ {
++ bfd_signed_vma *refcounts;
++ bfd_vma *offsets;
++ struct got_entry **ents;
++ } local_got;
++
++ /* The linker ELF emulation code needs to let the backend ELF linker
++ know what filename should be used for a dynamic object if the
++ dynamic object is found using a search. The emulation code then
++ sometimes needs to know what name was actually used. Until the
++ file has been added to the linker symbol table, this field holds
++ the name the linker wants. After it has been added, it holds the
++ name actually used, which will be the DT_SONAME entry if there is
++ one. */
++ const char *dt_name;
++
++ /* When a reference in a regular object is resolved by a shared
++ object is loaded into via the DT_NEEDED entries by the linker
++ ELF emulation code, we need to add the shared object to the
++ DT_NEEDED list of the resulting binary to indicate the dependency
++ as if the -l option is passed to the linker. This field holds the
++ name of the loaded shared object. */
++ const char *dt_soname;
++
++ /* Irix 5 often screws up the symbol table, sorting local symbols
++ after global symbols. This flag is set if the symbol table in
++ this BFD appears to be screwed up. If it is, we ignore the
++ sh_info field in the symbol table header, and always read all the
++ symbols. */
++ bfd_boolean bad_symtab;
++
++ /* Records the result of `get_program_header_size'. */
++ bfd_size_type program_header_size;
++
++ /* Used by find_nearest_line entry point. */
++ void *line_info;
++
++ /* Used by MIPS ELF find_nearest_line entry point. The structure
++ could be included directly in this one, but there's no point to
++ wasting the memory just for the infrequently called
++ find_nearest_line. */
++ struct mips_elf_find_line *find_line_info;
++
++ /* A place to stash dwarf1 info for this bfd. */
++ struct dwarf1_debug *dwarf1_find_line_info;
++
++ /* A place to stash dwarf2 info for this bfd. */
++ void *dwarf2_find_line_info;
++
++ /* An array of stub sections indexed by symbol number, used by the
++ MIPS ELF linker. FIXME: We should figure out some way to only
++ include this field for a MIPS ELF target. */
++ asection **local_stubs;
++
++ /* Used to determine if PT_GNU_EH_FRAME segment header should be
++ created. */
++ asection *eh_frame_hdr;
++
++ /* Used to determine if the e_flags field has been initialized */
++ bfd_boolean flags_init;
++
++ /* Number of symbol version definitions we are about to emit. */
++ unsigned int cverdefs;
++
++ /* Number of symbol version references we are about to emit. */
++ unsigned int cverrefs;
++
++ /* Segment flags for the PT_GNU_STACK segment. */
++ unsigned int stack_flags;
++
++ /* Symbol version definitions in external objects. */
++ Elf_Internal_Verdef *verdef;
++
++ /* Symbol version references to external objects. */
++ Elf_Internal_Verneed *verref;
++
++ /* The Irix 5 support uses two virtual sections, which represent
++ text/data symbols defined in dynamic objects. */
++ asymbol *elf_data_symbol;
++ asymbol *elf_text_symbol;
++ asection *elf_data_section;
++ asection *elf_text_section;
++};
++
++#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
++#define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
++#define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
++#define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections)
++#define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr)
++#define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
++#define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section)
++#define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section)
++#define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section)
++#define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section)
++#define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section)
++#define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals)
++#define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals)
++#define elf_section_syms(bfd) (elf_tdata(bfd) -> section_syms)
++#define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
++#define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
++#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
++#define elf_gp(bfd) (elf_tdata(bfd) -> gp)
++#define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size)
++#define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes)
++#define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
++#define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
++#define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
++#define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name)
++#define elf_dt_soname(bfd) (elf_tdata(bfd) -> dt_soname)
++#define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab)
++#define elf_flags_init(bfd) (elf_tdata(bfd) -> flags_init)
++
++extern void _bfd_elf_swap_verdef_in
++ (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
++extern void _bfd_elf_swap_verdef_out
++ (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
++extern void _bfd_elf_swap_verdaux_in
++ (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
++extern void _bfd_elf_swap_verdaux_out
++ (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
++extern void _bfd_elf_swap_verneed_in
++ (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
++extern void _bfd_elf_swap_verneed_out
++ (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
++extern void _bfd_elf_swap_vernaux_in
++ (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
++extern void _bfd_elf_swap_vernaux_out
++ (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
++extern void _bfd_elf_swap_versym_in
++ (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
++extern void _bfd_elf_swap_versym_out
++ (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
++
++extern int _bfd_elf_section_from_bfd_section
++ (bfd *, asection *);
++extern char *bfd_elf_string_from_elf_section
++ (bfd *, unsigned, unsigned);
++extern char *bfd_elf_get_str_section
++ (bfd *, unsigned);
++extern Elf_Internal_Sym *bfd_elf_get_elf_syms
++ (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
++ Elf_External_Sym_Shndx *);
++extern const char *bfd_elf_local_sym_name
++ (bfd *, Elf_Internal_Sym *);
++
++extern bfd_boolean _bfd_elf_copy_private_bfd_data
++ (bfd *, bfd *);
++extern bfd_boolean _bfd_elf_print_private_bfd_data
++ (bfd *, void *);
++extern void bfd_elf_print_symbol
++ (bfd *, void *, asymbol *, bfd_print_symbol_type);
++
++#define elf_string_from_elf_strtab(abfd, strindex) \
++ bfd_elf_string_from_elf_section (abfd, elf_elfheader(abfd)->e_shstrndx, \
++ strindex)
++
++#define bfd_elf32_print_symbol bfd_elf_print_symbol
++#define bfd_elf64_print_symbol bfd_elf_print_symbol
++
++extern void _bfd_elf_sprintf_vma
++ (bfd *, char *, bfd_vma);
++extern void _bfd_elf_fprintf_vma
++ (bfd *, void *, bfd_vma);
++
++extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
++ (const Elf_Internal_Rela *);
++extern bfd_vma _bfd_elf_rela_local_sym
++ (bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *);
++extern bfd_vma _bfd_elf_rel_local_sym
++ (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
++extern bfd_vma _bfd_elf_section_offset
++ (bfd *, struct bfd_link_info *, asection *, bfd_vma);
++
++extern unsigned long bfd_elf_hash
++ (const char *);
++
++extern bfd_reloc_status_type bfd_elf_generic_reloc
++ (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
++extern bfd_boolean bfd_elf_mkobject
++ (bfd *);
++extern bfd_boolean bfd_elf_mkcorefile
++ (bfd *);
++extern Elf_Internal_Shdr *bfd_elf_find_section
++ (bfd *, char *);
++extern bfd_boolean _bfd_elf_make_section_from_shdr
++ (bfd *, Elf_Internal_Shdr *, const char *);
++extern bfd_boolean _bfd_elf_make_section_from_phdr
++ (bfd *, Elf_Internal_Phdr *, int, const char *);
++extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
++ (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
++extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
++ (bfd *);
++extern void _bfd_elf_link_hash_copy_indirect
++ (const struct elf_backend_data *, struct elf_link_hash_entry *,
++ struct elf_link_hash_entry *);
++extern void _bfd_elf_link_hash_hide_symbol
++ (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
++extern bfd_boolean _bfd_elf_link_hash_table_init
++ (struct elf_link_hash_table *, bfd *,
++ struct bfd_hash_entry *(*)
++ (struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
++extern bfd_boolean _bfd_elf_slurp_version_tables
++ (bfd *);
++extern bfd_boolean _bfd_elf_merge_sections
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean bfd_elf_discard_group
++ (bfd *, struct bfd_section *);
++extern void bfd_elf_set_group_contents
++ (bfd *, asection *, void *);
++extern void _bfd_elf_link_just_syms
++ (asection *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf_copy_private_symbol_data
++ (bfd *, asymbol *, bfd *, asymbol *);
++extern bfd_boolean _bfd_elf_copy_private_section_data
++ (bfd *, asection *, bfd *, asection *);
++extern bfd_boolean _bfd_elf_write_object_contents
++ (bfd *);
++extern bfd_boolean _bfd_elf_write_corefile_contents
++ (bfd *);
++extern bfd_boolean _bfd_elf_set_section_contents
++ (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);
++extern long _bfd_elf_get_symtab_upper_bound
++ (bfd *);
++extern long _bfd_elf_canonicalize_symtab
++ (bfd *, asymbol **);
++extern long _bfd_elf_get_dynamic_symtab_upper_bound
++ (bfd *);
++extern long _bfd_elf_canonicalize_dynamic_symtab
++ (bfd *, asymbol **);
++extern long _bfd_elf_get_reloc_upper_bound
++ (bfd *, sec_ptr);
++extern long _bfd_elf_canonicalize_reloc
++ (bfd *, sec_ptr, arelent **, asymbol **);
++extern long _bfd_elf_get_dynamic_reloc_upper_bound
++ (bfd *);
++extern long _bfd_elf_canonicalize_dynamic_reloc
++ (bfd *, arelent **, asymbol **);
++extern asymbol *_bfd_elf_make_empty_symbol
++ (bfd *);
++extern void _bfd_elf_get_symbol_info
++ (bfd *, asymbol *, symbol_info *);
++extern bfd_boolean _bfd_elf_is_local_label_name
++ (bfd *, const char *);
++extern alent *_bfd_elf_get_lineno
++ (bfd *, asymbol *);
++extern bfd_boolean _bfd_elf_set_arch_mach
++ (bfd *, enum bfd_architecture, unsigned long);
++extern bfd_boolean _bfd_elf_find_nearest_line
++ (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,
++ unsigned int *);
++#define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
++#define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
++extern int _bfd_elf_sizeof_headers
++ (bfd *, bfd_boolean);
++extern bfd_boolean _bfd_elf_new_section_hook
++ (bfd *, asection *);
++extern bfd_boolean _bfd_elf_init_reloc_shdr
++ (bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean);
++extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
++ (bfd *, const char *);
++
++/* If the target doesn't have reloc handling written yet: */
++extern void _bfd_elf_no_info_to_howto
++ (bfd *, arelent *, Elf_Internal_Rela *);
++
++extern bfd_boolean bfd_section_from_shdr
++ (bfd *, unsigned int shindex);
++extern bfd_boolean bfd_section_from_phdr
++ (bfd *, Elf_Internal_Phdr *, int);
++
++extern int _bfd_elf_symbol_from_bfd_symbol
++ (bfd *, asymbol **);
++
++extern asection *bfd_section_from_r_symndx
++ (bfd *, struct sym_sec_cache *, asection *, unsigned long);
++extern asection *bfd_section_from_elf_index
++ (bfd *, unsigned int);
++extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
++ (void);
++
++extern struct elf_strtab_hash * _bfd_elf_strtab_init
++ (void);
++extern void _bfd_elf_strtab_free
++ (struct elf_strtab_hash *);
++extern bfd_size_type _bfd_elf_strtab_add
++ (struct elf_strtab_hash *, const char *, bfd_boolean);
++extern void _bfd_elf_strtab_addref
++ (struct elf_strtab_hash *, bfd_size_type);
++extern void _bfd_elf_strtab_delref
++ (struct elf_strtab_hash *, bfd_size_type);
++extern void _bfd_elf_strtab_clear_all_refs
++ (struct elf_strtab_hash *);
++extern bfd_size_type _bfd_elf_strtab_size
++ (struct elf_strtab_hash *);
++extern bfd_size_type _bfd_elf_strtab_offset
++ (struct elf_strtab_hash *, bfd_size_type);
++extern bfd_boolean _bfd_elf_strtab_emit
++ (bfd *, struct elf_strtab_hash *);
++extern void _bfd_elf_strtab_finalize
++ (struct elf_strtab_hash *);
++
++extern bfd_boolean _bfd_elf_discard_section_eh_frame
++ (bfd *, struct bfd_link_info *, asection *,
++ bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
++extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
++ (bfd *, struct bfd_link_info *);
++extern bfd_vma _bfd_elf_eh_frame_section_offset
++ (bfd *, asection *, bfd_vma);
++extern bfd_boolean _bfd_elf_write_section_eh_frame
++ (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
++extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
++ (struct bfd_link_info *);
++
++extern bfd_boolean _bfd_elf_merge_symbol
++ (bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
++ asection **, bfd_vma *, struct elf_link_hash_entry **, bfd_boolean *,
++ bfd_boolean *, bfd_boolean *, bfd_boolean *, bfd_boolean);
++
++extern bfd_boolean _bfd_elf_add_default_symbol
++ (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
++ const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
++ bfd_boolean *, bfd_boolean, bfd_boolean);
++
++extern bfd_boolean _bfd_elf_export_symbol
++ (struct elf_link_hash_entry *, void *);
++
++extern bfd_boolean _bfd_elf_link_find_version_dependencies
++ (struct elf_link_hash_entry *, void *);
++
++extern bfd_boolean _bfd_elf_link_assign_sym_version
++ (struct elf_link_hash_entry *, void *);
++
++extern bfd_boolean _bfd_elf_link_record_dynamic_symbol
++ (struct bfd_link_info *, struct elf_link_hash_entry *);
++extern long _bfd_elf_link_lookup_local_dynindx
++ (struct bfd_link_info *, bfd *, long);
++extern bfd_boolean _bfd_elf_compute_section_file_positions
++ (bfd *, struct bfd_link_info *);
++extern void _bfd_elf_assign_file_positions_for_relocs
++ (bfd *);
++extern file_ptr _bfd_elf_assign_file_position_for_section
++ (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
++
++extern bfd_boolean _bfd_elf_validate_reloc
++ (bfd *, arelent *);
++
++extern bfd_boolean _bfd_elf_link_create_dynamic_sections
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf_create_dynamic_sections
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf_create_got_section
++ (bfd *, struct bfd_link_info *);
++extern unsigned long _bfd_elf_link_renumber_dynsyms
++ (bfd *, struct bfd_link_info *);
++
++extern bfd_boolean _bfd_elfcore_make_pseudosection
++ (bfd *, char *, size_t, ufile_ptr);
++extern char *_bfd_elfcore_strndup
++ (bfd *, char *, size_t);
++
++extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
++ (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
++
++extern bfd_boolean _bfd_elf_link_size_reloc_section
++ (bfd *, Elf_Internal_Shdr *, asection *);
++
++extern bfd_boolean _bfd_elf_link_output_relocs
++ (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
++
++extern bfd_boolean _bfd_elf_fix_symbol_flags
++ (struct elf_link_hash_entry *, struct elf_info_failed *);
++
++extern bfd_boolean _bfd_elf_adjust_dynamic_symbol
++ (struct elf_link_hash_entry *, void *);
++
++extern bfd_boolean _bfd_elf_link_sec_merge_syms
++ (struct elf_link_hash_entry *, void *);
++
++extern bfd_boolean _bfd_elf_dynamic_symbol_p
++ (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
++
++extern bfd_boolean _bfd_elf_symbol_refs_local_p
++ (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
++
++extern const bfd_target *bfd_elf32_object_p
++ (bfd *);
++extern const bfd_target *bfd_elf32_core_file_p
++ (bfd *);
++extern char *bfd_elf32_core_file_failing_command
++ (bfd *);
++extern int bfd_elf32_core_file_failing_signal
++ (bfd *);
++extern bfd_boolean bfd_elf32_core_file_matches_executable_p
++ (bfd *, bfd *);
++
++extern bfd_boolean bfd_elf32_bfd_link_add_symbols
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean bfd_elf32_bfd_final_link
++ (bfd *, struct bfd_link_info *);
++
++extern void bfd_elf32_swap_symbol_in
++ (bfd *, const void *, const void *, Elf_Internal_Sym *);
++extern void bfd_elf32_swap_symbol_out
++ (bfd *, const Elf_Internal_Sym *, void *, void *);
++extern void bfd_elf32_swap_reloc_in
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++extern void bfd_elf32_swap_reloc_out
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++extern void bfd_elf32_swap_reloca_in
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++extern void bfd_elf32_swap_reloca_out
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++extern void bfd_elf32_swap_phdr_in
++ (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
++extern void bfd_elf32_swap_phdr_out
++ (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
++extern void bfd_elf32_swap_dyn_in
++ (bfd *, const void *, Elf_Internal_Dyn *);
++extern void bfd_elf32_swap_dyn_out
++ (bfd *, const Elf_Internal_Dyn *, void *);
++extern long bfd_elf32_slurp_symbol_table
++ (bfd *, asymbol **, bfd_boolean);
++extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
++ (bfd *);
++extern int bfd_elf32_write_out_phdrs
++ (bfd *, const Elf_Internal_Phdr *, unsigned int);
++extern void bfd_elf32_write_relocs
++ (bfd *, asection *, void *);
++extern bfd_boolean bfd_elf32_slurp_reloc_table
++ (bfd *, asection *, asymbol **, bfd_boolean);
++extern bfd_boolean bfd_elf32_add_dynamic_entry
++ (struct bfd_link_info *, bfd_vma, bfd_vma);
++
++extern const bfd_target *bfd_elf64_object_p
++ (bfd *);
++extern const bfd_target *bfd_elf64_core_file_p
++ (bfd *);
++extern char *bfd_elf64_core_file_failing_command
++ (bfd *);
++extern int bfd_elf64_core_file_failing_signal
++ (bfd *);
++extern bfd_boolean bfd_elf64_core_file_matches_executable_p
++ (bfd *, bfd *);
++extern bfd_boolean bfd_elf64_bfd_link_add_symbols
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean bfd_elf64_bfd_final_link
++ (bfd *, struct bfd_link_info *);
++
++extern void bfd_elf64_swap_symbol_in
++ (bfd *, const void *, const void *, Elf_Internal_Sym *);
++extern void bfd_elf64_swap_symbol_out
++ (bfd *, const Elf_Internal_Sym *, void *, void *);
++extern void bfd_elf64_swap_reloc_in
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++extern void bfd_elf64_swap_reloc_out
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++extern void bfd_elf64_swap_reloca_in
++ (bfd *, const bfd_byte *, Elf_Internal_Rela *);
++extern void bfd_elf64_swap_reloca_out
++ (bfd *, const Elf_Internal_Rela *, bfd_byte *);
++extern void bfd_elf64_swap_phdr_in
++ (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
++extern void bfd_elf64_swap_phdr_out
++ (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
++extern void bfd_elf64_swap_dyn_in
++ (bfd *, const void *, Elf_Internal_Dyn *);
++extern void bfd_elf64_swap_dyn_out
++ (bfd *, const Elf_Internal_Dyn *, void *);
++extern long bfd_elf64_slurp_symbol_table
++ (bfd *, asymbol **, bfd_boolean);
++extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
++ (bfd *);
++extern int bfd_elf64_write_out_phdrs
++ (bfd *, const Elf_Internal_Phdr *, unsigned int);
++extern void bfd_elf64_write_relocs
++ (bfd *, asection *, void *);
++extern bfd_boolean bfd_elf64_slurp_reloc_table
++ (bfd *, asection *, asymbol **, bfd_boolean);
++extern bfd_boolean bfd_elf64_add_dynamic_entry
++ (struct bfd_link_info *, bfd_vma, bfd_vma);
++
++#define bfd_elf32_link_record_dynamic_symbol \
++ _bfd_elf_link_record_dynamic_symbol
++#define bfd_elf64_link_record_dynamic_symbol \
++ _bfd_elf_link_record_dynamic_symbol
++
++extern int elf_link_record_local_dynamic_symbol
++ (struct bfd_link_info *, bfd *, long);
++#define _bfd_elf32_link_record_local_dynamic_symbol \
++ elf_link_record_local_dynamic_symbol
++#define _bfd_elf64_link_record_local_dynamic_symbol \
++ elf_link_record_local_dynamic_symbol
++
++extern bfd_boolean _bfd_elf_close_and_cleanup
++ (bfd *);
++extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
++ (bfd *, arelent *, struct symbol_cache_entry *, void *,
++ asection *, bfd *, char **);
++
++extern bfd_boolean _bfd_elf32_gc_sections
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf32_gc_common_finalize_got_offsets
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf32_gc_common_final_link
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf32_gc_record_vtinherit
++ (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
++extern bfd_boolean _bfd_elf32_gc_record_vtentry
++ (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
++
++extern bfd_boolean _bfd_elf64_gc_sections
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf64_gc_common_finalize_got_offsets
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf64_gc_common_final_link
++ (bfd *, struct bfd_link_info *);
++extern bfd_boolean _bfd_elf64_gc_record_vtinherit
++ (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
++extern bfd_boolean _bfd_elf64_gc_record_vtentry
++ (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
++
++extern bfd_boolean _bfd_elf32_reloc_symbol_deleted_p
++ (bfd_vma, void *);
++extern bfd_boolean _bfd_elf64_reloc_symbol_deleted_p
++ (bfd_vma, void *);
++
++/* Exported interface for writing elf corefile notes. */
++extern char *elfcore_write_note
++ (bfd *, char *, int *, const char *, int, const void *, int);
++extern char *elfcore_write_prpsinfo
++ (bfd *, char *, int *, const char *, const char *);
++extern char *elfcore_write_prstatus
++ (bfd *, char *, int *, long, int, const void *);
++extern char * elfcore_write_pstatus
++ (bfd *, char *, int *, long, int, const void *);
++extern char *elfcore_write_prfpreg
++ (bfd *, char *, int *, const void *, int);
++extern char *elfcore_write_prxfpreg
++ (bfd *, char *, int *, const void *, int);
++extern char *elfcore_write_lwpstatus
++ (bfd *, char *, int *, long, int, const void *);
++
++extern bfd *_bfd_elf32_bfd_from_remote_memory
++ (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
++ int (*target_read_memory) (bfd_vma, char *, int));
++extern bfd *_bfd_elf64_bfd_from_remote_memory
++ (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
++ int (*target_read_memory) (bfd_vma, char *, int));
++
++/* SH ELF specific routine. */
++
++extern bfd_boolean _sh_elf_set_mach_from_flags
++ (bfd *);
++
++/* This macro is to avoid lots of duplicated code in the body
++ of xxx_relocate_section() in the various elfxx-xxxx.c files. */
++#define RELOC_FOR_GLOBAL_SYMBOL(h, sym_hashes, r_symndx, symtab_hdr, relocation, sec, unresolved_reloc, info, warned) \
++ do \
++ { \
++ /* It seems this can happen with erroneous or unsupported \
++ input (mixing a.out and elf in an archive, for example.) */ \
++ if (sym_hashes == NULL) \
++ return FALSE; \
++ \
++ h = sym_hashes[r_symndx - symtab_hdr->sh_info]; \
++ \
++ while (h->root.type == bfd_link_hash_indirect \
++ || h->root.type == bfd_link_hash_warning) \
++ h = (struct elf_link_hash_entry *) h->root.u.i.link; \
++ \
++ warned = FALSE; \
++ unresolved_reloc = FALSE; \
++ relocation = 0; \
++ if (h->root.type == bfd_link_hash_defined \
++ || h->root.type == bfd_link_hash_defweak) \
++ { \
++ sec = h->root.u.def.section; \
++ if (sec == NULL \
++ || sec->output_section == NULL) \
++ /* Set a flag that will be cleared later if we find a \
++ relocation value for this symbol. output_section \
++ is typically NULL for symbols satisfied by a shared \
++ library. */ \
++ unresolved_reloc = TRUE; \
++ else \
++ relocation = (h->root.u.def.value \
++ + sec->output_section->vma \
++ + sec->output_offset); \
++ } \
++ else if (h->root.type == bfd_link_hash_undefweak) \
++ ; \
++ else if (!info->executable \
++ && info->unresolved_syms_in_objects == RM_IGNORE \
++ && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) \
++ ; \
++ else \
++ { \
++ if (! info->callbacks->undefined_symbol \
++ (info, h->root.root.string, input_bfd, \
++ input_section, rel->r_offset, \
++ ((info->shared && info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR) \
++ || (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR) \
++ || ELF_ST_VISIBILITY (h->other)) \
++ )) \
++ return FALSE; \
++ warned = TRUE; \
++ } \
++ } \
++ while (0)
++
++#endif /* _LIBELF_H_ */
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf-hppa.h binutils-2.14.90.0.7/bfd/elf-hppa.h
+--- binutils-2.14.90.0.7.orig/bfd/elf-hppa.h 2003-11-07 00:11:17.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf-hppa.h 2003-11-07 00:21:15.000000000 +0100
+@@ -1346,7 +1346,7 @@
+ /* This is a local symbol. */
+ sym = local_syms + r_symndx;
+ sym_sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
+
+ /* If this symbol has an entry in the PA64 dynamic hash
+ table, then get it. */
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf-m10200.c binutils-2.14.90.0.7/bfd/elf-m10200.c
+--- binutils-2.14.90.0.7.orig/bfd/elf-m10200.c 2003-11-07 00:11:14.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf-m10200.c 2003-11-07 00:21:15.000000000 +0100
+@@ -373,7 +373,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf-m10300.c binutils-2.14.90.0.7/bfd/elf-m10300.c
+--- binutils-2.14.90.0.7.orig/bfd/elf-m10300.c 2003-11-07 00:11:15.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf-m10300.c 2003-11-07 00:21:15.000000000 +0100
+@@ -1574,7 +1574,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf.c binutils-2.14.90.0.7/bfd/elf.c
+--- binutils-2.14.90.0.7.orig/bfd/elf.c 2003-11-07 00:11:20.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf.c 2003-11-07 00:21:15.000000000 +0100
+@@ -7367,9 +7367,10 @@
+ bfd_vma
+ _bfd_elf_rela_local_sym (bfd *abfd,
+ Elf_Internal_Sym *sym,
+- asection *sec,
++ asection **psec,
+ Elf_Internal_Rela *rel)
+ {
++ asection *sec = *psec;
+ bfd_vma relocation;
+
+ relocation = (sec->output_section->vma
+@@ -7379,16 +7380,14 @@
+ && ELF_ST_TYPE (sym->st_info) == STT_SECTION
+ && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
+ {
+- asection *msec;
+-
+- msec = sec;
+ rel->r_addend =
+- _bfd_merged_section_offset (abfd, &msec,
++ _bfd_merged_section_offset (abfd, psec,
+ elf_section_data (sec)->sec_info,
+ sym->st_value + rel->r_addend,
+- 0)
+- - relocation;
+- rel->r_addend += msec->output_section->vma + msec->output_offset;
++ 0);
++ sec = *psec;
++ rel->r_addend -= relocation;
++ rel->r_addend += sec->output_section->vma + sec->output_offset;
+ }
+ return relocation;
+ }
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-arm.h binutils-2.14.90.0.7/bfd/elf32-arm.h
+--- binutils-2.14.90.0.7.orig/bfd/elf32-arm.h 2003-11-07 00:11:24.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-arm.h 2003-11-07 00:21:15.000000000 +0100
+@@ -1958,7 +1958,7 @@
+ bfd_put_32 (input_bfd, value, contents + rel->r_offset);
+ }
+ #else
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ #endif
+ }
+ else
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-arm.h.orig binutils-2.14.90.0.7/bfd/elf32-arm.h.orig
+--- binutils-2.14.90.0.7.orig/bfd/elf32-arm.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-arm.h.orig 2003-11-07 00:20:18.000000000 +0100
+@@ -0,0 +1,3739 @@
++/* 32-bit ELF support for ARM
++ Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
++
++ This file is part of BFD, the Binary File Descriptor library.
++
++ This program is free software; you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation; either version 2 of the License, or
++ (at your option) any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with this program; if not, write to the Free Software
++ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
++
++#ifndef USE_REL
++#define USE_REL 0
++#endif
++
++typedef unsigned long int insn32;
++typedef unsigned short int insn16;
++
++static bfd_boolean elf32_arm_set_private_flags
++ PARAMS ((bfd *, flagword));
++static bfd_boolean elf32_arm_copy_private_bfd_data
++ PARAMS ((bfd *, bfd *));
++static bfd_boolean elf32_arm_merge_private_bfd_data
++ PARAMS ((bfd *, bfd *));
++static bfd_boolean elf32_arm_print_private_bfd_data
++ PARAMS ((bfd *, PTR));
++static int elf32_arm_get_symbol_type
++ PARAMS (( Elf_Internal_Sym *, int));
++static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
++ PARAMS ((bfd *));
++static bfd_reloc_status_type elf32_arm_final_link_relocate
++ PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
++ Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
++ const char *, int, struct elf_link_hash_entry *));
++static insn32 insert_thumb_branch
++ PARAMS ((insn32, int));
++static struct elf_link_hash_entry *find_thumb_glue
++ PARAMS ((struct bfd_link_info *, const char *, bfd *));
++static struct elf_link_hash_entry *find_arm_glue
++ PARAMS ((struct bfd_link_info *, const char *, bfd *));
++static void elf32_arm_post_process_headers
++ PARAMS ((bfd *, struct bfd_link_info *));
++static int elf32_arm_to_thumb_stub
++ PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
++ bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
++static int elf32_thumb_to_arm_stub
++ PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
++ bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
++static bfd_boolean elf32_arm_relocate_section
++ PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
++ Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
++static asection * elf32_arm_gc_mark_hook
++ PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
++ struct elf_link_hash_entry *, Elf_Internal_Sym *));
++static bfd_boolean elf32_arm_gc_sweep_hook
++ PARAMS ((bfd *, struct bfd_link_info *, asection *,
++ const Elf_Internal_Rela *));
++static bfd_boolean elf32_arm_check_relocs
++ PARAMS ((bfd *, struct bfd_link_info *, asection *,
++ const Elf_Internal_Rela *));
++static bfd_boolean elf32_arm_find_nearest_line
++ PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
++ const char **, unsigned int *));
++static bfd_boolean elf32_arm_adjust_dynamic_symbol
++ PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
++static bfd_boolean elf32_arm_size_dynamic_sections
++ PARAMS ((bfd *, struct bfd_link_info *));
++static bfd_boolean elf32_arm_finish_dynamic_symbol
++ PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
++ Elf_Internal_Sym *));
++static bfd_boolean elf32_arm_finish_dynamic_sections
++ PARAMS ((bfd *, struct bfd_link_info *));
++static struct bfd_hash_entry * elf32_arm_link_hash_newfunc
++ PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
++#if USE_REL
++static void arm_add_to_rel
++ PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
++#endif
++static enum elf_reloc_type_class elf32_arm_reloc_type_class
++ PARAMS ((const Elf_Internal_Rela *));
++static bfd_boolean elf32_arm_object_p
++ PARAMS ((bfd *));
++
++#ifndef ELFARM_NABI_C_INCLUDED
++static void record_arm_to_thumb_glue
++ PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
++static void record_thumb_to_arm_glue
++ PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
++bfd_boolean bfd_elf32_arm_allocate_interworking_sections
++ PARAMS ((struct bfd_link_info *));
++bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
++ PARAMS ((bfd *, struct bfd_link_info *));
++bfd_boolean bfd_elf32_arm_process_before_allocation
++ PARAMS ((bfd *, struct bfd_link_info *, int));
++#endif
++
++
++#define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
++
++/* The linker script knows the section names for placement.
++ The entry_names are used to do simple name mangling on the stubs.
++ Given a function name, and its type, the stub can be found. The
++ name can be changed. The only requirement is the %s be present. */
++#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
++#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
++
++#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
++#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
++
++/* The name of the dynamic interpreter. This is put in the .interp
++ section. */
++#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
++
++/* The size in bytes of an entry in the procedure linkage table. */
++#define PLT_ENTRY_SIZE 16
++
++/* The first entry in a procedure linkage table looks like
++ this. It is set up so that any shared library function that is
++ called before the relocation has been set up calls the dynamic
++ linker first. */
++static const bfd_vma elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
++ {
++ 0xe52de004, /* str lr, [sp, #-4]! */
++ 0xe59fe010, /* ldr lr, [pc, #16] */
++ 0xe08fe00e, /* add lr, pc, lr */
++ 0xe5bef008 /* ldr pc, [lr, #8]! */
++ };
++
++/* Subsequent entries in a procedure linkage table look like
++ this. */
++static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
++ {
++ 0xe59fc004, /* ldr ip, [pc, #4] */
++ 0xe08fc00c, /* add ip, pc, ip */
++ 0xe59cf000, /* ldr pc, [ip] */
++ 0x00000000 /* offset to symbol in got */
++ };
++
++/* The ARM linker needs to keep track of the number of relocs that it
++ decides to copy in check_relocs for each symbol. This is so that
++ it can discard PC relative relocs if it doesn't need them when
++ linking with -Bsymbolic. We store the information in a field
++ extending the regular ELF linker hash table. */
++
++/* This structure keeps track of the number of PC relative relocs we
++ have copied for a given symbol. */
++struct elf32_arm_pcrel_relocs_copied
++ {
++ /* Next section. */
++ struct elf32_arm_pcrel_relocs_copied * next;
++ /* A section in dynobj. */
++ asection * section;
++ /* Number of relocs copied in this section. */
++ bfd_size_type count;
++ };
++
++/* Arm ELF linker hash entry. */
++struct elf32_arm_link_hash_entry
++ {
++ struct elf_link_hash_entry root;
++
++ /* Number of PC relative relocs copied for this symbol. */
++ struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
++ };
++
++/* Declare this now that the above structures are defined. */
++static bfd_boolean elf32_arm_discard_copies
++ PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
++
++/* Traverse an arm ELF linker hash table. */
++#define elf32_arm_link_hash_traverse(table, func, info) \
++ (elf_link_hash_traverse \
++ (&(table)->root, \
++ (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
++ (info)))
++
++/* Get the ARM elf linker hash table from a link_info structure. */
++#define elf32_arm_hash_table(info) \
++ ((struct elf32_arm_link_hash_table *) ((info)->hash))
++
++/* ARM ELF linker hash table. */
++struct elf32_arm_link_hash_table
++ {
++ /* The main hash table. */
++ struct elf_link_hash_table root;
++
++ /* The size in bytes of the section containg the Thumb-to-ARM glue. */
++ bfd_size_type thumb_glue_size;
++
++ /* The size in bytes of the section containg the ARM-to-Thumb glue. */
++ bfd_size_type arm_glue_size;
++
++ /* An arbitary input BFD chosen to hold the glue sections. */
++ bfd * bfd_of_glue_owner;
++
++ /* A boolean indicating whether knowledge of the ARM's pipeline
++ length should be applied by the linker. */
++ int no_pipeline_knowledge;
++ };
++
++/* Create an entry in an ARM ELF linker hash table. */
++
++static struct bfd_hash_entry *
++elf32_arm_link_hash_newfunc (entry, table, string)
++ struct bfd_hash_entry * entry;
++ struct bfd_hash_table * table;
++ const char * string;
++{
++ struct elf32_arm_link_hash_entry * ret =
++ (struct elf32_arm_link_hash_entry *) entry;
++
++ /* Allocate the structure if it has not already been allocated by a
++ subclass. */
++ if (ret == (struct elf32_arm_link_hash_entry *) NULL)
++ ret = ((struct elf32_arm_link_hash_entry *)
++ bfd_hash_allocate (table,
++ sizeof (struct elf32_arm_link_hash_entry)));
++ if (ret == (struct elf32_arm_link_hash_entry *) NULL)
++ return (struct bfd_hash_entry *) ret;
++
++ /* Call the allocation method of the superclass. */
++ ret = ((struct elf32_arm_link_hash_entry *)
++ _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
++ table, string));
++ if (ret != (struct elf32_arm_link_hash_entry *) NULL)
++ ret->pcrel_relocs_copied = NULL;
++
++ return (struct bfd_hash_entry *) ret;
++}
++
++/* Create an ARM elf linker hash table. */
++
++static struct bfd_link_hash_table *
++elf32_arm_link_hash_table_create (abfd)
++ bfd *abfd;
++{
++ struct elf32_arm_link_hash_table *ret;
++ bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
++
++ ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
++ if (ret == (struct elf32_arm_link_hash_table *) NULL)
++ return NULL;
++
++ if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
++ elf32_arm_link_hash_newfunc))
++ {
++ free (ret);
++ return NULL;
++ }
++
++ ret->thumb_glue_size = 0;
++ ret->arm_glue_size = 0;
++ ret->bfd_of_glue_owner = NULL;
++ ret->no_pipeline_knowledge = 0;
++
++ return &ret->root.root;
++}
++
++/* Locate the Thumb encoded calling stub for NAME. */
++
++static struct elf_link_hash_entry *
++find_thumb_glue (link_info, name, input_bfd)
++ struct bfd_link_info *link_info;
++ const char *name;
++ bfd *input_bfd;
++{
++ char *tmp_name;
++ struct elf_link_hash_entry *hash;
++ struct elf32_arm_link_hash_table *hash_table;
++
++ /* We need a pointer to the armelf specific hash table. */
++ hash_table = elf32_arm_hash_table (link_info);
++
++ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
++ + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
++
++ BFD_ASSERT (tmp_name);
++
++ sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
++
++ hash = elf_link_hash_lookup
++ (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
++
++ if (hash == NULL)
++ /* xgettext:c-format */
++ (*_bfd_error_handler) (_("%s: unable to find THUMB glue '%s' for `%s'"),
++ bfd_archive_filename (input_bfd), tmp_name, name);
++
++ free (tmp_name);
++
++ return hash;
++}
++
++/* Locate the ARM encoded calling stub for NAME. */
++
++static struct elf_link_hash_entry *
++find_arm_glue (link_info, name, input_bfd)
++ struct bfd_link_info *link_info;
++ const char *name;
++ bfd *input_bfd;
++{
++ char *tmp_name;
++ struct elf_link_hash_entry *myh;
++ struct elf32_arm_link_hash_table *hash_table;
++
++ /* We need a pointer to the elfarm specific hash table. */
++ hash_table = elf32_arm_hash_table (link_info);
++
++ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
++ + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
++
++ BFD_ASSERT (tmp_name);
++
++ sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
++
++ myh = elf_link_hash_lookup
++ (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
++
++ if (myh == NULL)
++ /* xgettext:c-format */
++ (*_bfd_error_handler) (_("%s: unable to find ARM glue '%s' for `%s'"),
++ bfd_archive_filename (input_bfd), tmp_name, name);
++
++ free (tmp_name);
++
++ return myh;
++}
++
++/* ARM->Thumb glue:
++
++ .arm
++ __func_from_arm:
++ ldr r12, __func_addr
++ bx r12
++ __func_addr:
++ .word func @ behave as if you saw a ARM_32 reloc. */
++
++#define ARM2THUMB_GLUE_SIZE 12
++static const insn32 a2t1_ldr_insn = 0xe59fc000;
++static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
++static const insn32 a2t3_func_addr_insn = 0x00000001;
++
++/* Thumb->ARM: Thumb->(non-interworking aware) ARM
++
++ .thumb .thumb
++ .align 2 .align 2
++ __func_from_thumb: __func_from_thumb:
++ bx pc push {r6, lr}
++ nop ldr r6, __func_addr
++ .arm mov lr, pc
++ __func_change_to_arm: bx r6
++ b func .arm
++ __func_back_to_thumb:
++ ldmia r13! {r6, lr}
++ bx lr
++ __func_addr:
++ .word func */
++
++#define THUMB2ARM_GLUE_SIZE 8
++static const insn16 t2a1_bx_pc_insn = 0x4778;
++static const insn16 t2a2_noop_insn = 0x46c0;
++static const insn32 t2a3_b_insn = 0xea000000;
++
++#ifndef ELFARM_NABI_C_INCLUDED
++bfd_boolean
++bfd_elf32_arm_allocate_interworking_sections (info)
++ struct bfd_link_info * info;
++{
++ asection * s;
++ bfd_byte * foo;
++ struct elf32_arm_link_hash_table * globals;
++
++ globals = elf32_arm_hash_table (info);
++
++ BFD_ASSERT (globals != NULL);
++
++ if (globals->arm_glue_size != 0)
++ {
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
++ ARM2THUMB_GLUE_SECTION_NAME);
++
++ BFD_ASSERT (s != NULL);
++
++ foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
++ globals->arm_glue_size);
++
++ s->_raw_size = s->_cooked_size = globals->arm_glue_size;
++ s->contents = foo;
++ }
++
++ if (globals->thumb_glue_size != 0)
++ {
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ s = bfd_get_section_by_name
++ (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
++
++ BFD_ASSERT (s != NULL);
++
++ foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
++ globals->thumb_glue_size);
++
++ s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
++ s->contents = foo;
++ }
++
++ return TRUE;
++}
++
++static void
++record_arm_to_thumb_glue (link_info, h)
++ struct bfd_link_info * link_info;
++ struct elf_link_hash_entry * h;
++{
++ const char * name = h->root.root.string;
++ asection * s;
++ char * tmp_name;
++ struct elf_link_hash_entry * myh;
++ struct bfd_link_hash_entry * bh;
++ struct elf32_arm_link_hash_table * globals;
++ bfd_vma val;
++
++ globals = elf32_arm_hash_table (link_info);
++
++ BFD_ASSERT (globals != NULL);
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ s = bfd_get_section_by_name
++ (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
++
++ BFD_ASSERT (s != NULL);
++
++ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
++ + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
++
++ BFD_ASSERT (tmp_name);
++
++ sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
++
++ myh = elf_link_hash_lookup
++ (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
++
++ if (myh != NULL)
++ {
++ /* We've already seen this guy. */
++ free (tmp_name);
++ return;
++ }
++
++ /* The only trick here is using hash_table->arm_glue_size as the value. Even
++ though the section isn't allocated yet, this is where we will be putting
++ it. */
++ bh = NULL;
++ val = globals->arm_glue_size + 1;
++ _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
++ tmp_name, BSF_GLOBAL, s, val,
++ NULL, TRUE, FALSE, &bh);
++
++ free (tmp_name);
++
++ globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
++
++ return;
++}
++
++static void
++record_thumb_to_arm_glue (link_info, h)
++ struct bfd_link_info *link_info;
++ struct elf_link_hash_entry *h;
++{
++ const char *name = h->root.root.string;
++ asection *s;
++ char *tmp_name;
++ struct elf_link_hash_entry *myh;
++ struct bfd_link_hash_entry *bh;
++ struct elf32_arm_link_hash_table *hash_table;
++ char bind;
++ bfd_vma val;
++
++ hash_table = elf32_arm_hash_table (link_info);
++
++ BFD_ASSERT (hash_table != NULL);
++ BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
++
++ s = bfd_get_section_by_name
++ (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
++
++ BFD_ASSERT (s != NULL);
++
++ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
++ + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
++
++ BFD_ASSERT (tmp_name);
++
++ sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
++
++ myh = elf_link_hash_lookup
++ (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
++
++ if (myh != NULL)
++ {
++ /* We've already seen this guy. */
++ free (tmp_name);
++ return;
++ }
++
++ bh = NULL;
++ val = hash_table->thumb_glue_size + 1;
++ _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
++ tmp_name, BSF_GLOBAL, s, val,
++ NULL, TRUE, FALSE, &bh);
++
++ /* If we mark it 'Thumb', the disassembler will do a better job. */
++ myh = (struct elf_link_hash_entry *) bh;
++ bind = ELF_ST_BIND (myh->type);
++ myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
++
++ free (tmp_name);
++
++#define CHANGE_TO_ARM "__%s_change_to_arm"
++#define BACK_FROM_ARM "__%s_back_from_arm"
++
++ /* Allocate another symbol to mark where we switch to Arm mode. */
++ tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
++ + strlen (CHANGE_TO_ARM) + 1);
++
++ BFD_ASSERT (tmp_name);
++
++ sprintf (tmp_name, CHANGE_TO_ARM, name);
++
++ bh = NULL;
++ val = hash_table->thumb_glue_size + 4,
++ _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
++ tmp_name, BSF_LOCAL, s, val,
++ NULL, TRUE, FALSE, &bh);
++
++ free (tmp_name);
++
++ hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
++
++ return;
++}
++
++/* Add the glue sections to ABFD. This function is called from the
++ linker scripts in ld/emultempl/{armelf}.em. */
++
++bfd_boolean
++bfd_elf32_arm_add_glue_sections_to_bfd (abfd, info)
++ bfd *abfd;
++ struct bfd_link_info *info;
++{
++ flagword flags;
++ asection *sec;
++
++ /* If we are only performing a partial
++ link do not bother adding the glue. */
++ if (info->relocatable)
++ return TRUE;
++
++ sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
++
++ if (sec == NULL)
++ {
++ /* Note: we do not include the flag SEC_LINKER_CREATED, as this
++ will prevent elf_link_input_bfd() from processing the contents
++ of this section. */
++ flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
++
++ sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
++
++ if (sec == NULL
++ || !bfd_set_section_flags (abfd, sec, flags)
++ || !bfd_set_section_alignment (abfd, sec, 2))
++ return FALSE;
++
++ /* Set the gc mark to prevent the section from being removed by garbage
++ collection, despite the fact that no relocs refer to this section. */
++ sec->gc_mark = 1;
++ }
++
++ sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
++
++ if (sec == NULL)
++ {
++ flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
++
++ sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
++
++ if (sec == NULL
++ || !bfd_set_section_flags (abfd, sec, flags)
++ || !bfd_set_section_alignment (abfd, sec, 2))
++ return FALSE;
++
++ sec->gc_mark = 1;
++ }
++
++ return TRUE;
++}
++
++/* Select a BFD to be used to hold the sections used by the glue code.
++ This function is called from the linker scripts in ld/emultempl/
++ {armelf/pe}.em */
++
++bfd_boolean
++bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
++ bfd *abfd;
++ struct bfd_link_info *info;
++{
++ struct elf32_arm_link_hash_table *globals;
++
++ /* If we are only performing a partial link
++ do not bother getting a bfd to hold the glue. */
++ if (info->relocatable)
++ return TRUE;
++
++ globals = elf32_arm_hash_table (info);
++
++ BFD_ASSERT (globals != NULL);
++
++ if (globals->bfd_of_glue_owner != NULL)
++ return TRUE;
++
++ /* Save the bfd for later use. */
++ globals->bfd_of_glue_owner = abfd;
++
++ return TRUE;
++}
++
++bfd_boolean
++bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
++ bfd *abfd;
++ struct bfd_link_info *link_info;
++ int no_pipeline_knowledge;
++{
++ Elf_Internal_Shdr *symtab_hdr;
++ Elf_Internal_Rela *internal_relocs = NULL;
++ Elf_Internal_Rela *irel, *irelend;
++ bfd_byte *contents = NULL;
++
++ asection *sec;
++ struct elf32_arm_link_hash_table *globals;
++
++ /* If we are only performing a partial link do not bother
++ to construct any glue. */
++ if (link_info->relocatable)
++ return TRUE;
++
++ /* Here we have a bfd that is to be included on the link. We have a hook
++ to do reloc rummaging, before section sizes are nailed down. */
++ globals = elf32_arm_hash_table (link_info);
++
++ BFD_ASSERT (globals != NULL);
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ globals->no_pipeline_knowledge = no_pipeline_knowledge;
++
++ /* Rummage around all the relocs and map the glue vectors. */
++ sec = abfd->sections;
++
++ if (sec == NULL)
++ return TRUE;
++
++ for (; sec != NULL; sec = sec->next)
++ {
++ if (sec->reloc_count == 0)
++ continue;
++
++ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
++
++ /* Load the relocs. */
++ internal_relocs
++ = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
++ (Elf_Internal_Rela *) NULL, FALSE);
++
++ if (internal_relocs == NULL)
++ goto error_return;
++
++ irelend = internal_relocs + sec->reloc_count;
++ for (irel = internal_relocs; irel < irelend; irel++)
++ {
++ long r_type;
++ unsigned long r_index;
++
++ struct elf_link_hash_entry *h;
++
++ r_type = ELF32_R_TYPE (irel->r_info);
++ r_index = ELF32_R_SYM (irel->r_info);
++
++ /* These are the only relocation types we care about. */
++ if ( r_type != R_ARM_PC24
++ && r_type != R_ARM_THM_PC22)
++ continue;
++
++ /* Get the section contents if we haven't done so already. */
++ if (contents == NULL)
++ {
++ /* Get cached copy if it exists. */
++ if (elf_section_data (sec)->this_hdr.contents != NULL)
++ contents = elf_section_data (sec)->this_hdr.contents;
++ else
++ {
++ /* Go get them off disk. */
++ contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
++ if (contents == NULL)
++ goto error_return;
++
++ if (!bfd_get_section_contents (abfd, sec, contents,
++ (file_ptr) 0, sec->_raw_size))
++ goto error_return;
++ }
++ }
++
++ /* If the relocation is not against a symbol it cannot concern us. */
++ h = NULL;
++
++ /* We don't care about local symbols. */
++ if (r_index < symtab_hdr->sh_info)
++ continue;
++
++ /* This is an external symbol. */
++ r_index -= symtab_hdr->sh_info;
++ h = (struct elf_link_hash_entry *)
++ elf_sym_hashes (abfd)[r_index];
++
++ /* If the relocation is against a static symbol it must be within
++ the current section and so cannot be a cross ARM/Thumb relocation. */
++ if (h == NULL)
++ continue;
++
++ switch (r_type)
++ {
++ case R_ARM_PC24:
++ /* This one is a call from arm code. We need to look up
++ the target of the call. If it is a thumb target, we
++ insert glue. */
++ if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
++ record_arm_to_thumb_glue (link_info, h);
++ break;
++
++ case R_ARM_THM_PC22:
++ /* This one is a call from thumb code. We look
++ up the target of the call. If it is not a thumb
++ target, we insert glue. */
++ if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
++ record_thumb_to_arm_glue (link_info, h);
++ break;
++
++ default:
++ break;
++ }
++ }
++
++ if (contents != NULL
++ && elf_section_data (sec)->this_hdr.contents != contents)
++ free (contents);
++ contents = NULL;
++
++ if (internal_relocs != NULL
++ && elf_section_data (sec)->relocs != internal_relocs)
++ free (internal_relocs);
++ internal_relocs = NULL;
++ }
++
++ return TRUE;
++
++error_return:
++ if (contents != NULL
++ && elf_section_data (sec)->this_hdr.contents != contents)
++ free (contents);
++ if (internal_relocs != NULL
++ && elf_section_data (sec)->relocs != internal_relocs)
++ free (internal_relocs);
++
++ return FALSE;
++}
++#endif
++
++/* The thumb form of a long branch is a bit finicky, because the offset
++ encoding is split over two fields, each in it's own instruction. They
++ can occur in any order. So given a thumb form of long branch, and an
++ offset, insert the offset into the thumb branch and return finished
++ instruction.
++
++ It takes two thumb instructions to encode the target address. Each has
++ 11 bits to invest. The upper 11 bits are stored in one (identifed by
++ H-0.. see below), the lower 11 bits are stored in the other (identified
++ by H-1).
++
++ Combine together and shifted left by 1 (it's a half word address) and
++ there you have it.
++
++ Op: 1111 = F,
++ H-0, upper address-0 = 000
++ Op: 1111 = F,
++ H-1, lower address-0 = 800
++
++ They can be ordered either way, but the arm tools I've seen always put
++ the lower one first. It probably doesn't matter. krk@cygnus.com
++
++ XXX: Actually the order does matter. The second instruction (H-1)
++ moves the computed address into the PC, so it must be the second one
++ in the sequence. The problem, however is that whilst little endian code
++ stores the instructions in HI then LOW order, big endian code does the
++ reverse. nickc@cygnus.com. */
++
++#define LOW_HI_ORDER 0xF800F000
++#define HI_LOW_ORDER 0xF000F800
++
++static insn32
++insert_thumb_branch (br_insn, rel_off)
++ insn32 br_insn;
++ int rel_off;
++{
++ unsigned int low_bits;
++ unsigned int high_bits;
++
++ BFD_ASSERT ((rel_off & 1) != 1);
++
++ rel_off >>= 1; /* Half word aligned address. */
++ low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
++ high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
++
++ if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
++ br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
++ else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
++ br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
++ else
++ /* FIXME: abort is probably not the right call. krk@cygnus.com */
++ abort (); /* error - not a valid branch instruction form. */
++
++ return br_insn;
++}
++
++/* Thumb code calling an ARM function. */
++
++static int
++elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
++ hit_data, sym_sec, offset, addend, val)
++ struct bfd_link_info * info;
++ const char * name;
++ bfd * input_bfd;
++ bfd * output_bfd;
++ asection * input_section;
++ bfd_byte * hit_data;
++ asection * sym_sec;
++ bfd_vma offset;
++ bfd_signed_vma addend;
++ bfd_vma val;
++{
++ asection * s = 0;
++ bfd_vma my_offset;
++ unsigned long int tmp;
++ long int ret_offset;
++ struct elf_link_hash_entry * myh;
++ struct elf32_arm_link_hash_table * globals;
++
++ myh = find_thumb_glue (info, name, input_bfd);
++ if (myh == NULL)
++ return FALSE;
++
++ globals = elf32_arm_hash_table (info);
++
++ BFD_ASSERT (globals != NULL);
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ my_offset = myh->root.u.def.value;
++
++ s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
++ THUMB2ARM_GLUE_SECTION_NAME);
++
++ BFD_ASSERT (s != NULL);
++ BFD_ASSERT (s->contents != NULL);
++ BFD_ASSERT (s->output_section != NULL);
++
++ if ((my_offset & 0x01) == 0x01)
++ {
++ if (sym_sec != NULL
++ && sym_sec->owner != NULL
++ && !INTERWORK_FLAG (sym_sec->owner))
++ {
++ (*_bfd_error_handler)
++ (_("%s(%s): warning: interworking not enabled."),
++ bfd_archive_filename (sym_sec->owner), name);
++ (*_bfd_error_handler)
++ (_(" first occurrence: %s: thumb call to arm"),
++ bfd_archive_filename (input_bfd));
++
++ return FALSE;
++ }
++
++ --my_offset;
++ myh->root.u.def.value = my_offset;
++
++ bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
++ s->contents + my_offset);
++
++ bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
++ s->contents + my_offset + 2);
++
++ ret_offset =
++ /* Address of destination of the stub. */
++ ((bfd_signed_vma) val)
++ - ((bfd_signed_vma)
++ /* Offset from the start of the current section to the start of the stubs. */
++ (s->output_offset
++ /* Offset of the start of this stub from the start of the stubs. */
++ + my_offset
++ /* Address of the start of the current section. */
++ + s->output_section->vma)
++ /* The branch instruction is 4 bytes into the stub. */
++ + 4
++ /* ARM branches work from the pc of the instruction + 8. */
++ + 8);
++
++ bfd_put_32 (output_bfd,
++ (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
++ s->contents + my_offset + 4);
++ }
++
++ BFD_ASSERT (my_offset <= globals->thumb_glue_size);
++
++ /* Now go back and fix up the original BL insn to point to here. */
++ ret_offset =
++ /* Address of where the stub is located. */
++ (s->output_section->vma + s->output_offset + my_offset)
++ /* Address of where the BL is located. */
++ - (input_section->output_section->vma + input_section->output_offset + offset)
++ /* Addend in the relocation. */
++ - addend
++ /* Biassing for PC-relative addressing. */
++ - 8;
++
++ tmp = bfd_get_32 (input_bfd, hit_data
++ - input_section->vma);
++
++ bfd_put_32 (output_bfd,
++ (bfd_vma) insert_thumb_branch (tmp, ret_offset),
++ hit_data - input_section->vma);
++
++ return TRUE;
++}
++
++/* Arm code calling a Thumb function. */
++
++static int
++elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
++ hit_data, sym_sec, offset, addend, val)
++ struct bfd_link_info * info;
++ const char * name;
++ bfd * input_bfd;
++ bfd * output_bfd;
++ asection * input_section;
++ bfd_byte * hit_data;
++ asection * sym_sec;
++ bfd_vma offset;
++ bfd_signed_vma addend;
++ bfd_vma val;
++{
++ unsigned long int tmp;
++ bfd_vma my_offset;
++ asection * s;
++ long int ret_offset;
++ struct elf_link_hash_entry * myh;
++ struct elf32_arm_link_hash_table * globals;
++
++ myh = find_arm_glue (info, name, input_bfd);
++ if (myh == NULL)
++ return FALSE;
++
++ globals = elf32_arm_hash_table (info);
++
++ BFD_ASSERT (globals != NULL);
++ BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
++
++ my_offset = myh->root.u.def.value;
++ s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
++ ARM2THUMB_GLUE_SECTION_NAME);
++ BFD_ASSERT (s != NULL);
++ BFD_ASSERT (s->contents != NULL);
++ BFD_ASSERT (s->output_section != NULL);
++
++ if ((my_offset & 0x01) == 0x01)
++ {
++ if (sym_sec != NULL
++ && sym_sec->owner != NULL
++ && !INTERWORK_FLAG (sym_sec->owner))
++ {
++ (*_bfd_error_handler)
++ (_("%s(%s): warning: interworking not enabled."),
++ bfd_archive_filename (sym_sec->owner), name);
++ (*_bfd_error_handler)
++ (_(" first occurrence: %s: arm call to thumb"),
++ bfd_archive_filename (input_bfd));
++ }
++
++ --my_offset;
++ myh->root.u.def.value = my_offset;
++
++ bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
++ s->contents + my_offset);
++
++ bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
++ s->contents + my_offset + 4);
++
++ /* It's a thumb address. Add the low order bit. */
++ bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
++ s->contents + my_offset + 8);
++ }
++
++ BFD_ASSERT (my_offset <= globals->arm_glue_size);
++
++ tmp = bfd_get_32 (input_bfd, hit_data);
++ tmp = tmp & 0xFF000000;
++
++ /* Somehow these are both 4 too far, so subtract 8. */
++ ret_offset = (s->output_offset
++ + my_offset
++ + s->output_section->vma
++ - (input_section->output_offset
++ + input_section->output_section->vma
++ + offset + addend)
++ - 8);
++
++ tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
++
++ bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
++
++ return TRUE;
++}
++
++/* This is the condition under which elf32_arm_finish_dynamic_symbol
++ will be called from elflink.h. If elflink.h doesn't call our
++ finish_dynamic_symbol routine, we'll need to do something about
++ initializing any .plt and .got entries in elf32_arm_relocate_section
++ and elf32_arm_final_link_relocate. */
++#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
++ ((DYN) \
++ && ((SHARED) \
++ || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
++ && ((H)->dynindx != -1 \
++ || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
++
++/* Perform a relocation as part of a final link. */
++
++static bfd_reloc_status_type
++elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
++ input_section, contents, rel, value,
++ info, sym_sec, sym_name, sym_flags, h)
++ reloc_howto_type * howto;
++ bfd * input_bfd;
++ bfd * output_bfd;
++ asection * input_section;
++ bfd_byte * contents;
++ Elf_Internal_Rela * rel;
++ bfd_vma value;
++ struct bfd_link_info * info;
++ asection * sym_sec;
++ const char * sym_name;
++ int sym_flags;
++ struct elf_link_hash_entry * h;
++{
++ unsigned long r_type = howto->type;
++ unsigned long r_symndx;
++ bfd_byte * hit_data = contents + rel->r_offset;
++ bfd * dynobj = NULL;
++ Elf_Internal_Shdr * symtab_hdr;
++ struct elf_link_hash_entry ** sym_hashes;
++ bfd_vma * local_got_offsets;
++ asection * sgot = NULL;
++ asection * splt = NULL;
++ asection * sreloc = NULL;
++ bfd_vma addend;
++ bfd_signed_vma signed_addend;
++ struct elf32_arm_link_hash_table * globals;
++
++ /* If the start address has been set, then set the EF_ARM_HASENTRY
++ flag. Setting this more than once is redundant, but the cost is
++ not too high, and it keeps the code simple.
++
++ The test is done here, rather than somewhere else, because the
++ start address is only set just before the final link commences.
++
++ Note - if the user deliberately sets a start address of 0, the
++ flag will not be set. */
++ if (bfd_get_start_address (output_bfd) != 0)
++ elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
++
++ globals = elf32_arm_hash_table (info);
++
++ dynobj = elf_hash_table (info)->dynobj;
++ if (dynobj)
++ {
++ sgot = bfd_get_section_by_name (dynobj, ".got");
++ splt = bfd_get_section_by_name (dynobj, ".plt");
++ }
++ symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
++ sym_hashes = elf_sym_hashes (input_bfd);
++ local_got_offsets = elf_local_got_offsets (input_bfd);
++ r_symndx = ELF32_R_SYM (rel->r_info);
++
++#if USE_REL
++ addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
++
++ if (addend & ((howto->src_mask + 1) >> 1))
++ {
++ signed_addend = -1;
++ signed_addend &= ~ howto->src_mask;
++ signed_addend |= addend;
++ }
++ else
++ signed_addend = addend;
++#else
++ addend = signed_addend = rel->r_addend;
++#endif
++
++ switch (r_type)
++ {
++ case R_ARM_NONE:
++ return bfd_reloc_ok;
++
++ case R_ARM_PC24:
++ case R_ARM_ABS32:
++ case R_ARM_REL32:
++#ifndef OLD_ARM_ABI
++ case R_ARM_XPC25:
++#endif
++ /* When generating a shared object, these relocations are copied
++ into the output file to be resolved at run time. */
++ if (info->shared
++ && r_symndx != 0
++ && (r_type != R_ARM_PC24
++ || (h != NULL
++ && h->dynindx != -1
++ && (! info->symbolic
++ || (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_REGULAR) == 0))))
++ {
++ Elf_Internal_Rela outrel;
++ bfd_byte *loc;
++ bfd_boolean skip, relocate;
++
++ if (sreloc == NULL)
++ {
++ const char * name;
++
++ name = (bfd_elf_string_from_elf_section
++ (input_bfd,
++ elf_elfheader (input_bfd)->e_shstrndx,
++ elf_section_data (input_section)->rel_hdr.sh_name));
++ if (name == NULL)
++ return bfd_reloc_notsupported;
++
++ BFD_ASSERT (strncmp (name, ".rel", 4) == 0
++ && strcmp (bfd_get_section_name (input_bfd,
++ input_section),
++ name + 4) == 0);
++
++ sreloc = bfd_get_section_by_name (dynobj, name);
++ BFD_ASSERT (sreloc != NULL);
++ }
++
++ skip = FALSE;
++ relocate = FALSE;
++
++ outrel.r_offset =
++ _bfd_elf_section_offset (output_bfd, info, input_section,
++ rel->r_offset);
++ if (outrel.r_offset == (bfd_vma) -1)
++ skip = TRUE;
++ else if (outrel.r_offset == (bfd_vma) -2)
++ skip = TRUE, relocate = TRUE;
++ outrel.r_offset += (input_section->output_section->vma
++ + input_section->output_offset);
++
++ if (skip)
++ memset (&outrel, 0, sizeof outrel);
++ else if (r_type == R_ARM_PC24)
++ {
++ BFD_ASSERT (h != NULL && h->dynindx != -1);
++ if ((input_section->flags & SEC_ALLOC) == 0)
++ relocate = TRUE;
++ outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
++ }
++ else
++ {
++ if (h == NULL
++ || ((info->symbolic || h->dynindx == -1)
++ && (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_REGULAR) != 0))
++ {
++ relocate = TRUE;
++ outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
++ }
++ else
++ {
++ BFD_ASSERT (h->dynindx != -1);
++ if ((input_section->flags & SEC_ALLOC) == 0)
++ relocate = TRUE;
++ outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
++ }
++ }
++
++ loc = sreloc->contents;
++ loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
++ bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
++
++ /* If this reloc is against an external symbol, we do not want to
++ fiddle with the addend. Otherwise, we need to include the symbol
++ value so that it becomes an addend for the dynamic reloc. */
++ if (! relocate)
++ return bfd_reloc_ok;
++
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++ }
++ else switch (r_type)
++ {
++#ifndef OLD_ARM_ABI
++ case R_ARM_XPC25: /* Arm BLX instruction. */
++#endif
++ case R_ARM_PC24: /* Arm B/BL instruction */
++#ifndef OLD_ARM_ABI
++ if (r_type == R_ARM_XPC25)
++ {
++ /* Check for Arm calling Arm function. */
++ /* FIXME: Should we translate the instruction into a BL
++ instruction instead ? */
++ if (sym_flags != STT_ARM_TFUNC)
++ (*_bfd_error_handler) (_("\
++%s: Warning: Arm BLX instruction targets Arm function '%s'."),
++ bfd_archive_filename (input_bfd),
++ h ? h->root.root.string : "(local)");
++ }
++ else
++#endif
++ {
++ /* Check for Arm calling Thumb function. */
++ if (sym_flags == STT_ARM_TFUNC)
++ {
++ elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
++ input_section, hit_data, sym_sec, rel->r_offset,
++ signed_addend, value);
++ return bfd_reloc_ok;
++ }
++ }
++
++ if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
++ || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
++ {
++ /* The old way of doing things. Trearing the addend as a
++ byte sized field and adding in the pipeline offset. */
++ value -= (input_section->output_section->vma
++ + input_section->output_offset);
++ value -= rel->r_offset;
++ value += addend;
++
++ if (! globals->no_pipeline_knowledge)
++ value -= 8;
++ }
++ else
++ {
++ /* The ARM ELF ABI says that this reloc is computed as: S - P + A
++ where:
++ S is the address of the symbol in the relocation.
++ P is address of the instruction being relocated.
++ A is the addend (extracted from the instruction) in bytes.
++
++ S is held in 'value'.
++ P is the base address of the section containing the instruction
++ plus the offset of the reloc into that section, ie:
++ (input_section->output_section->vma +
++ input_section->output_offset +
++ rel->r_offset).
++ A is the addend, converted into bytes, ie:
++ (signed_addend * 4)
++
++ Note: None of these operations have knowledge of the pipeline
++ size of the processor, thus it is up to the assembler to encode
++ this information into the addend. */
++ value -= (input_section->output_section->vma
++ + input_section->output_offset);
++ value -= rel->r_offset;
++ value += (signed_addend << howto->size);
++
++ /* Previous versions of this code also used to add in the pipeline
++ offset here. This is wrong because the linker is not supposed
++ to know about such things, and one day it might change. In order
++ to support old binaries that need the old behaviour however, so
++ we attempt to detect which ABI was used to create the reloc. */
++ if (! globals->no_pipeline_knowledge)
++ {
++ Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
++
++ i_ehdrp = elf_elfheader (input_bfd);
++
++ if (i_ehdrp->e_ident[EI_OSABI] == 0)
++ value -= 8;
++ }
++ }
++
++ signed_addend = value;
++ signed_addend >>= howto->rightshift;
++
++ /* It is not an error for an undefined weak reference to be
++ out of range. Any program that branches to such a symbol
++ is going to crash anyway, so there is no point worrying
++ about getting the destination exactly right. */
++ if (! h || h->root.type != bfd_link_hash_undefweak)
++ {
++ /* Perform a signed range check. */
++ if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
++ || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
++ return bfd_reloc_overflow;
++ }
++
++#ifndef OLD_ARM_ABI
++ /* If necessary set the H bit in the BLX instruction. */
++ if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
++ value = (signed_addend & howto->dst_mask)
++ | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
++ | (1 << 24);
++ else
++#endif
++ value = (signed_addend & howto->dst_mask)
++ | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
++ break;
++
++ case R_ARM_ABS32:
++ value += addend;
++ if (sym_flags == STT_ARM_TFUNC)
++ value |= 1;
++ break;
++
++ case R_ARM_REL32:
++ value -= (input_section->output_section->vma
++ + input_section->output_offset + rel->r_offset);
++ value += addend;
++ break;
++ }
++
++ bfd_put_32 (input_bfd, value, hit_data);
++ return bfd_reloc_ok;
++
++ case R_ARM_ABS8:
++ value += addend;
++ if ((long) value > 0x7f || (long) value < -0x80)
++ return bfd_reloc_overflow;
++
++ bfd_put_8 (input_bfd, value, hit_data);
++ return bfd_reloc_ok;
++
++ case R_ARM_ABS16:
++ value += addend;
++
++ if ((long) value > 0x7fff || (long) value < -0x8000)
++ return bfd_reloc_overflow;
++
++ bfd_put_16 (input_bfd, value, hit_data);
++ return bfd_reloc_ok;
++
++ case R_ARM_ABS12:
++ /* Support ldr and str instruction for the arm */
++ /* Also thumb b (unconditional branch). ??? Really? */
++ value += addend;
++
++ if ((long) value > 0x7ff || (long) value < -0x800)
++ return bfd_reloc_overflow;
++
++ value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
++ bfd_put_32 (input_bfd, value, hit_data);
++ return bfd_reloc_ok;
++
++ case R_ARM_THM_ABS5:
++ /* Support ldr and str instructions for the thumb. */
++#if USE_REL
++ /* Need to refetch addend. */
++ addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
++ /* ??? Need to determine shift amount from operand size. */
++ addend >>= howto->rightshift;
++#endif
++ value += addend;
++
++ /* ??? Isn't value unsigned? */
++ if ((long) value > 0x1f || (long) value < -0x10)
++ return bfd_reloc_overflow;
++
++ /* ??? Value needs to be properly shifted into place first. */
++ value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
++ bfd_put_16 (input_bfd, value, hit_data);
++ return bfd_reloc_ok;
++
++#ifndef OLD_ARM_ABI
++ case R_ARM_THM_XPC22:
++#endif
++ case R_ARM_THM_PC22:
++ /* Thumb BL (branch long instruction). */
++ {
++ bfd_vma relocation;
++ bfd_boolean overflow = FALSE;
++ bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
++ bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
++ bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
++ bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
++ bfd_vma check;
++ bfd_signed_vma signed_check;
++
++#if USE_REL
++ /* Need to refetch the addend and squish the two 11 bit pieces
++ together. */
++ {
++ bfd_vma upper = upper_insn & 0x7ff;
++ bfd_vma lower = lower_insn & 0x7ff;
++ upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
++ addend = (upper << 12) | (lower << 1);
++ signed_addend = addend;
++ }
++#endif
++#ifndef OLD_ARM_ABI
++ if (r_type == R_ARM_THM_XPC22)
++ {
++ /* Check for Thumb to Thumb call. */
++ /* FIXME: Should we translate the instruction into a BL
++ instruction instead ? */
++ if (sym_flags == STT_ARM_TFUNC)
++ (*_bfd_error_handler) (_("\
++%s: Warning: Thumb BLX instruction targets thumb function '%s'."),
++ bfd_archive_filename (input_bfd),
++ h ? h->root.root.string : "(local)");
++ }
++ else
++#endif
++ {
++ /* If it is not a call to Thumb, assume call to Arm.
++ If it is a call relative to a section name, then it is not a
++ function call at all, but rather a long jump. */
++ if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
++ {
++ if (elf32_thumb_to_arm_stub
++ (info, sym_name, input_bfd, output_bfd, input_section,
++ hit_data, sym_sec, rel->r_offset, signed_addend, value))
++ return bfd_reloc_ok;
++ else
++ return bfd_reloc_dangerous;
++ }
++ }
++
++ relocation = value + signed_addend;
++
++ relocation -= (input_section->output_section->vma
++ + input_section->output_offset
++ + rel->r_offset);
++
++ if (! globals->no_pipeline_knowledge)
++ {
++ Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
++
++ i_ehdrp = elf_elfheader (input_bfd);
++
++ /* Previous versions of this code also used to add in the pipline
++ offset here. This is wrong because the linker is not supposed
++ to know about such things, and one day it might change. In order
++ to support old binaries that need the old behaviour however, so
++ we attempt to detect which ABI was used to create the reloc. */
++ if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
++ || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
++ || i_ehdrp->e_ident[EI_OSABI] == 0)
++ relocation += 4;
++ }
++
++ check = relocation >> howto->rightshift;
++
++ /* If this is a signed value, the rightshift just dropped
++ leading 1 bits (assuming twos complement). */
++ if ((bfd_signed_vma) relocation >= 0)
++ signed_check = check;
++ else
++ signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
++
++ /* Assumes two's complement. */
++ if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
++ overflow = TRUE;
++
++#ifndef OLD_ARM_ABI
++ if (r_type == R_ARM_THM_XPC22
++ && ((lower_insn & 0x1800) == 0x0800))
++ /* For a BLX instruction, make sure that the relocation is rounded up
++ to a word boundary. This follows the semantics of the instruction
++ which specifies that bit 1 of the target address will come from bit
++ 1 of the base address. */
++ relocation = (relocation + 2) & ~ 3;
++#endif
++ /* Put RELOCATION back into the insn. */
++ upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
++ lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
++
++ /* Put the relocated value back in the object file: */
++ bfd_put_16 (input_bfd, upper_insn, hit_data);
++ bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
++
++ return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
++ }
++ break;
++
++ case R_ARM_THM_PC11:
++ /* Thumb B (branch) instruction). */
++ {
++ bfd_signed_vma relocation;
++ bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
++ bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
++ bfd_signed_vma signed_check;
++
++#if USE_REL
++ /* Need to refetch addend. */
++ addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
++ if (addend & ((howto->src_mask + 1) >> 1))
++ {
++ signed_addend = -1;
++ signed_addend &= ~ howto->src_mask;
++ signed_addend |= addend;
++ }
++ else
++ signed_addend = addend;
++ /* The value in the insn has been right shifted. We need to
++ undo this, so that we can perform the address calculation
++ in terms of bytes. */
++ signed_addend <<= howto->rightshift;
++#endif
++ relocation = value + signed_addend;
++
++ relocation -= (input_section->output_section->vma
++ + input_section->output_offset
++ + rel->r_offset);
++
++ relocation >>= howto->rightshift;
++ signed_check = relocation;
++ relocation &= howto->dst_mask;
++ relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
++
++ bfd_put_16 (input_bfd, relocation, hit_data);
++
++ /* Assumes two's complement. */
++ if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
++ return bfd_reloc_overflow;
++
++ return bfd_reloc_ok;
++ }
++
++ case R_ARM_GNU_VTINHERIT:
++ case R_ARM_GNU_VTENTRY:
++ return bfd_reloc_ok;
++
++ case R_ARM_COPY:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_GLOB_DAT:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_JUMP_SLOT:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RELATIVE:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_GOTOFF:
++ /* Relocation is relative to the start of the
++ global offset table. */
++
++ BFD_ASSERT (sgot != NULL);
++ if (sgot == NULL)
++ return bfd_reloc_notsupported;
++
++ /* If we are addressing a Thumb function, we need to adjust the
++ address by one, so that attempts to call the function pointer will
++ correctly interpret it as Thumb code. */
++ if (sym_flags == STT_ARM_TFUNC)
++ value += 1;
++
++ /* Note that sgot->output_offset is not involved in this
++ calculation. We always want the start of .got. If we
++ define _GLOBAL_OFFSET_TABLE in a different way, as is
++ permitted by the ABI, we might have to change this
++ calculation. */
++ value -= sgot->output_section->vma;
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ case R_ARM_GOTPC:
++ /* Use global offset table as symbol value. */
++ BFD_ASSERT (sgot != NULL);
++
++ if (sgot == NULL)
++ return bfd_reloc_notsupported;
++
++ value = sgot->output_section->vma;
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ case R_ARM_GOT32:
++ /* Relocation is to the entry for this symbol in the
++ global offset table. */
++ if (sgot == NULL)
++ return bfd_reloc_notsupported;
++
++ if (h != NULL)
++ {
++ bfd_vma off;
++ bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
++
++ off = h->got.offset;
++ BFD_ASSERT (off != (bfd_vma) -1);
++
++ if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
++ || (info->shared
++ && (info->symbolic || h->dynindx == -1
++ || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
++ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
++ {
++ /* This is actually a static link, or it is a -Bsymbolic link
++ and the symbol is defined locally. We must initialize this
++ entry in the global offset table. Since the offset must
++ always be a multiple of 4, we use the least significant bit
++ to record whether we have initialized it already.
++
++ When doing a dynamic link, we create a .rel.got relocation
++ entry to initialize the value. This is done in the
++ finish_dynamic_symbol routine. */
++ if ((off & 1) != 0)
++ off &= ~1;
++ else
++ {
++ /* If we are addressing a Thumb function, we need to
++ adjust the address by one, so that attempts to
++ call the function pointer will correctly
++ interpret it as Thumb code. */
++ if (sym_flags == STT_ARM_TFUNC)
++ value |= 1;
++
++ bfd_put_32 (output_bfd, value, sgot->contents + off);
++ h->got.offset |= 1;
++ }
++ }
++
++ value = sgot->output_offset + off;
++ }
++ else
++ {
++ bfd_vma off;
++
++ BFD_ASSERT (local_got_offsets != NULL &&
++ local_got_offsets[r_symndx] != (bfd_vma) -1);
++
++ off = local_got_offsets[r_symndx];
++
++ /* The offset must always be a multiple of 4. We use the
++ least significant bit to record whether we have already
++ generated the necessary reloc. */
++ if ((off & 1) != 0)
++ off &= ~1;
++ else
++ {
++ bfd_put_32 (output_bfd, value, sgot->contents + off);
++
++ if (info->shared)
++ {
++ asection * srelgot;
++ Elf_Internal_Rela outrel;
++ bfd_byte *loc;
++
++ srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
++ BFD_ASSERT (srelgot != NULL);
++
++ outrel.r_offset = (sgot->output_section->vma
++ + sgot->output_offset
++ + off);
++ outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
++ loc = srelgot->contents;
++ loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
++ bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
++ }
++
++ local_got_offsets[r_symndx] |= 1;
++ }
++
++ value = sgot->output_offset + off;
++ }
++
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ case R_ARM_PLT32:
++ /* Relocation is to the entry for this symbol in the
++ procedure linkage table. */
++
++ /* Resolve a PLT32 reloc against a local symbol directly,
++ without using the procedure linkage table. */
++ if (h == NULL)
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ if (h->plt.offset == (bfd_vma) -1)
++ /* We didn't make a PLT entry for this symbol. This
++ happens when statically linking PIC code, or when
++ using -Bsymbolic. */
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ BFD_ASSERT(splt != NULL);
++ if (splt == NULL)
++ return bfd_reloc_notsupported;
++
++ value = (splt->output_section->vma
++ + splt->output_offset
++ + h->plt.offset);
++ return _bfd_final_link_relocate (howto, input_bfd, input_section,
++ contents, rel->r_offset, value,
++ (bfd_vma) 0);
++
++ case R_ARM_SBREL32:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_AMP_VCALL9:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RSBREL32:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_THM_RPC22:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RREL32:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RABS32:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RPC24:
++ return bfd_reloc_notsupported;
++
++ case R_ARM_RBASE:
++ return bfd_reloc_notsupported;
++
++ default:
++ return bfd_reloc_notsupported;
++ }
++}
++
++#if USE_REL
++/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
++static void
++arm_add_to_rel (abfd, address, howto, increment)
++ bfd * abfd;
++ bfd_byte * address;
++ reloc_howto_type * howto;
++ bfd_signed_vma increment;
++{
++ bfd_signed_vma addend;
++
++ if (howto->type == R_ARM_THM_PC22)
++ {
++ int upper_insn, lower_insn;
++ int upper, lower;
++
++ upper_insn = bfd_get_16 (abfd, address);
++ lower_insn = bfd_get_16 (abfd, address + 2);
++ upper = upper_insn & 0x7ff;
++ lower = lower_insn & 0x7ff;
++
++ addend = (upper << 12) | (lower << 1);
++ addend += increment;
++ addend >>= 1;
++
++ upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
++ lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
++
++ bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
++ bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
++ }
++ else
++ {
++ bfd_vma contents;
++
++ contents = bfd_get_32 (abfd, address);
++
++ /* Get the (signed) value from the instruction. */
++ addend = contents & howto->src_mask;
++ if (addend & ((howto->src_mask + 1) >> 1))
++ {
++ bfd_signed_vma mask;
++
++ mask = -1;
++ mask &= ~ howto->src_mask;
++ addend |= mask;
++ }
++
++ /* Add in the increment, (which is a byte value). */
++ switch (howto->type)
++ {
++ default:
++ addend += increment;
++ break;
++
++ case R_ARM_PC24:
++ addend <<= howto->size;
++ addend += increment;
++
++ /* Should we check for overflow here ? */
++
++ /* Drop any undesired bits. */
++ addend >>= howto->rightshift;
++ break;
++ }
++
++ contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
++
++ bfd_put_32 (abfd, contents, address);
++ }
++}
++#endif /* USE_REL */
++
++/* Relocate an ARM ELF section. */
++static bfd_boolean
++elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
++ contents, relocs, local_syms, local_sections)
++ bfd *output_bfd;
++ struct bfd_link_info *info;
++ bfd *input_bfd;
++ asection *input_section;
++ bfd_byte *contents;
++ Elf_Internal_Rela *relocs;
++ Elf_Internal_Sym *local_syms;
++ asection **local_sections;
++{
++ Elf_Internal_Shdr *symtab_hdr;
++ struct elf_link_hash_entry **sym_hashes;
++ Elf_Internal_Rela *rel;
++ Elf_Internal_Rela *relend;
++ const char *name;
++
++#if !USE_REL
++ if (info->relocatable)
++ return TRUE;
++#endif
++
++ symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
++ sym_hashes = elf_sym_hashes (input_bfd);
++
++ rel = relocs;
++ relend = relocs + input_section->reloc_count;
++ for (; rel < relend; rel++)
++ {
++ int r_type;
++ reloc_howto_type * howto;
++ unsigned long r_symndx;
++ Elf_Internal_Sym * sym;
++ asection * sec;
++ struct elf_link_hash_entry * h;
++ bfd_vma relocation;
++ bfd_reloc_status_type r;
++ arelent bfd_reloc;
++
++ r_symndx = ELF32_R_SYM (rel->r_info);
++ r_type = ELF32_R_TYPE (rel->r_info);
++
++ if ( r_type == R_ARM_GNU_VTENTRY
++ || r_type == R_ARM_GNU_VTINHERIT)
++ continue;
++
++ elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
++ howto = bfd_reloc.howto;
++
++#if USE_REL
++ if (info->relocatable)
++ {
++ /* This is a relocatable link. We don't have to change
++ anything, unless the reloc is against a section symbol,
++ in which case we have to adjust according to where the
++ section symbol winds up in the output section. */
++ if (r_symndx < symtab_hdr->sh_info)
++ {
++ sym = local_syms + r_symndx;
++ if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
++ {
++ sec = local_sections[r_symndx];
++ arm_add_to_rel (input_bfd, contents + rel->r_offset,
++ howto,
++ (bfd_signed_vma) (sec->output_offset
++ + sym->st_value));
++ }
++ }
++
++ continue;
++ }
++#endif
++
++ /* This is a final link. */
++ h = NULL;
++ sym = NULL;
++ sec = NULL;
++
++ if (r_symndx < symtab_hdr->sh_info)
++ {
++ sym = local_syms + r_symndx;
++ sec = local_sections[r_symndx];
++#if USE_REL
++ relocation = (sec->output_section->vma
++ + sec->output_offset
++ + sym->st_value);
++ if ((sec->flags & SEC_MERGE)
++ && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
++ {
++ asection *msec;
++ bfd_vma addend, value;
++
++ if (howto->rightshift)
++ {
++ (*_bfd_error_handler)
++ (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
++ bfd_archive_filename (input_bfd),
++ bfd_get_section_name (input_bfd, input_section),
++ (long) rel->r_offset, howto->name);
++ return FALSE;
++ }
++
++ value = bfd_get_32 (input_bfd, contents + rel->r_offset);
++
++ /* Get the (signed) value from the instruction. */
++ addend = value & howto->src_mask;
++ if (addend & ((howto->src_mask + 1) >> 1))
++ {
++ bfd_signed_vma mask;
++
++ mask = -1;
++ mask &= ~ howto->src_mask;
++ addend |= mask;
++ }
++ msec = sec;
++ addend =
++ _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
++ - relocation;
++ addend += msec->output_section->vma + msec->output_offset;
++ value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
++ bfd_put_32 (input_bfd, value, contents + rel->r_offset);
++ }
++#else
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++#endif
++ }
++ else
++ {
++ bfd_boolean warned;
++ bfd_boolean unresolved_reloc;
++
++ RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx,
++ symtab_hdr, relocation,
++ sec, unresolved_reloc, info,
++ warned);
++
++ if (unresolved_reloc || relocation != 0)
++ {
++ /* In these cases, we don't need the relocation value.
++ We check specially because in some obscure cases
++ sec->output_section will be NULL. */
++ switch (r_type)
++ {
++ case R_ARM_PC24:
++ case R_ARM_ABS32:
++ case R_ARM_THM_PC22:
++ if (info->shared
++ && (
++ (!info->symbolic && h->dynindx != -1)
++ || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
++ )
++ && ((input_section->flags & SEC_ALLOC) != 0
++ /* DWARF will emit R_ARM_ABS32 relocations in its
++ sections against symbols defined externally
++ in shared libraries. We can't do anything
++ with them here. */
++ || ((input_section->flags & SEC_DEBUGGING) != 0
++ && (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
++ )
++ relocation = 0;
++ break;
++
++ case R_ARM_GOTPC:
++ relocation = 0;
++ break;
++
++ case R_ARM_GOT32:
++ if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
++ (elf_hash_table (info)->dynamic_sections_created,
++ info->shared, h))
++ && (!info->shared
++ || (!info->symbolic && h->dynindx != -1)
++ || (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_REGULAR) == 0))
++ relocation = 0;
++ break;
++
++ case R_ARM_PLT32:
++ if (h->plt.offset != (bfd_vma)-1)
++ relocation = 0;
++ break;
++
++ default:
++ if (unresolved_reloc)
++ _bfd_error_handler
++ (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
++ bfd_archive_filename (input_bfd),
++ r_type,
++ h->root.root.string,
++ bfd_get_section_name (input_bfd, input_section));
++ break;
++ }
++ }
++ }
++
++ if (h != NULL)
++ name = h->root.root.string;
++ else
++ {
++ name = (bfd_elf_string_from_elf_section
++ (input_bfd, symtab_hdr->sh_link, sym->st_name));
++ if (name == NULL || *name == '\0')
++ name = bfd_section_name (input_bfd, sec);
++ }
++
++ r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
++ input_section, contents, rel,
++ relocation, info, sec, name,
++ (h ? ELF_ST_TYPE (h->type) :
++ ELF_ST_TYPE (sym->st_info)), h);
++
++ if (r != bfd_reloc_ok)
++ {
++ const char * msg = (const char *) 0;
++
++ switch (r)
++ {
++ case bfd_reloc_overflow:
++ /* If the overflowing reloc was to an undefined symbol,
++ we have already printed one error message and there
++ is no point complaining again. */
++ if ((! h ||
++ h->root.type != bfd_link_hash_undefined)
++ && (!((*info->callbacks->reloc_overflow)
++ (info, name, howto->name, (bfd_vma) 0,
++ input_bfd, input_section, rel->r_offset))))
++ return FALSE;
++ break;
++
++ case bfd_reloc_undefined:
++ if (!((*info->callbacks->undefined_symbol)
++ (info, name, input_bfd, input_section,
++ rel->r_offset, TRUE)))
++ return FALSE;
++ break;
++
++ case bfd_reloc_outofrange:
++ msg = _("internal error: out of range error");
++ goto common_error;
++
++ case bfd_reloc_notsupported:
++ msg = _("internal error: unsupported relocation error");
++ goto common_error;
++
++ case bfd_reloc_dangerous:
++ msg = _("internal error: dangerous error");
++ goto common_error;
++
++ default:
++ msg = _("internal error: unknown error");
++ /* fall through */
++
++ common_error:
++ if (!((*info->callbacks->warning)
++ (info, msg, name, input_bfd, input_section,
++ rel->r_offset)))
++ return FALSE;
++ break;
++ }
++ }
++ }
++
++ return TRUE;
++}
++
++/* Set the right machine number. */
++
++static bfd_boolean
++elf32_arm_object_p (abfd)
++ bfd *abfd;
++{
++ unsigned int mach;
++
++ mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
++
++ if (mach != bfd_mach_arm_unknown)
++ bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
++
++ else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
++ bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
++
++ else
++ bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
++
++ return TRUE;
++}
++
++/* Function to keep ARM specific flags in the ELF header. */
++static bfd_boolean
++elf32_arm_set_private_flags (abfd, flags)
++ bfd *abfd;
++ flagword flags;
++{
++ if (elf_flags_init (abfd)
++ && elf_elfheader (abfd)->e_flags != flags)
++ {
++ if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
++ {
++ if (flags & EF_ARM_INTERWORK)
++ (*_bfd_error_handler) (_("\
++Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
++ bfd_archive_filename (abfd));
++ else
++ _bfd_error_handler (_("\
++Warning: Clearing the interworking flag of %s due to outside request"),
++ bfd_archive_filename (abfd));
++ }
++ }
++ else
++ {
++ elf_elfheader (abfd)->e_flags = flags;
++ elf_flags_init (abfd) = TRUE;
++ }
++
++ return TRUE;
++}
++
++/* Copy backend specific data from one object module to another. */
++
++static bfd_boolean
++elf32_arm_copy_private_bfd_data (ibfd, obfd)
++ bfd *ibfd;
++ bfd *obfd;
++{
++ flagword in_flags;
++ flagword out_flags;
++
++ if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
++ || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
++ return TRUE;
++
++ in_flags = elf_elfheader (ibfd)->e_flags;
++ out_flags = elf_elfheader (obfd)->e_flags;
++
++ if (elf_flags_init (obfd)
++ && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
++ && in_flags != out_flags)
++ {
++ /* Cannot mix APCS26 and APCS32 code. */
++ if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
++ return FALSE;
++
++ /* Cannot mix float APCS and non-float APCS code. */
++ if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
++ return FALSE;
++
++ /* If the src and dest have different interworking flags
++ then turn off the interworking bit. */
++ if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
++ {
++ if (out_flags & EF_ARM_INTERWORK)
++ _bfd_error_handler (_("\
++Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
++ bfd_get_filename (obfd),
++ bfd_archive_filename (ibfd));
++
++ in_flags &= ~EF_ARM_INTERWORK;
++ }
++
++ /* Likewise for PIC, though don't warn for this case. */
++ if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
++ in_flags &= ~EF_ARM_PIC;
++ }
++
++ elf_elfheader (obfd)->e_flags = in_flags;
++ elf_flags_init (obfd) = TRUE;
++
++ return TRUE;
++}
++
++/* Merge backend specific data from an object file to the output
++ object file when linking. */
++
++static bfd_boolean
++elf32_arm_merge_private_bfd_data (ibfd, obfd)
++ bfd * ibfd;
++ bfd * obfd;
++{
++ flagword out_flags;
++ flagword in_flags;
++ bfd_boolean flags_compatible = TRUE;
++ asection *sec;
++
++ /* Check if we have the same endianess. */
++ if (! _bfd_generic_verify_endian_match (ibfd, obfd))
++ return FALSE;
++
++ if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
++ || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
++ return TRUE;
++
++ /* The input BFD must have had its flags initialised. */
++ /* The following seems bogus to me -- The flags are initialized in
++ the assembler but I don't think an elf_flags_init field is
++ written into the object. */
++ /* BFD_ASSERT (elf_flags_init (ibfd)); */
++
++ in_flags = elf_elfheader (ibfd)->e_flags;
++ out_flags = elf_elfheader (obfd)->e_flags;
++
++ if (!elf_flags_init (obfd))
++ {
++ /* If the input is the default architecture and had the default
++ flags then do not bother setting the flags for the output
++ architecture, instead allow future merges to do this. If no
++ future merges ever set these flags then they will retain their
++ uninitialised values, which surprise surprise, correspond
++ to the default values. */
++ if (bfd_get_arch_info (ibfd)->the_default
++ && elf_elfheader (ibfd)->e_flags == 0)
++ return TRUE;
++
++ elf_flags_init (obfd) = TRUE;
++ elf_elfheader (obfd)->e_flags = in_flags;
++
++ if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
++ && bfd_get_arch_info (obfd)->the_default)
++ return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
++
++ return TRUE;
++ }
++
++ /* Determine what should happen if the input ARM architecture
++ does not match the output ARM architecture. */
++ if (! bfd_arm_merge_machines (ibfd, obfd))
++ return FALSE;
++
++ /* Identical flags must be compatible. */
++ if (in_flags == out_flags)
++ return TRUE;
++
++ /* Check to see if the input BFD actually contains any sections. If
++ not, its flags may not have been initialised either, but it
++ cannot actually cause any incompatibility. Do not short-circuit
++ dynamic objects; their section list may be emptied by
++ elf_link_add_object_symbols. */
++
++ if (!(ibfd->flags & DYNAMIC))
++ {
++ bfd_boolean null_input_bfd = TRUE;
++
++ for (sec = ibfd->sections; sec != NULL; sec = sec->next)
++ {
++ /* Ignore synthetic glue sections. */
++ if (strcmp (sec->name, ".glue_7")
++ && strcmp (sec->name, ".glue_7t"))
++ {
++ null_input_bfd = FALSE;
++ break;
++ }
++ }
++ if (null_input_bfd)
++ return TRUE;
++ }
++
++ /* Complain about various flag mismatches. */
++ if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
++ {
++ _bfd_error_handler (_("\
++ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
++ bfd_archive_filename (ibfd),
++ (in_flags & EF_ARM_EABIMASK) >> 24,
++ bfd_get_filename (obfd),
++ (out_flags & EF_ARM_EABIMASK) >> 24);
++ return FALSE;
++ }
++
++ /* Not sure what needs to be checked for EABI versions >= 1. */
++ if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
++ {
++ if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
++ {
++ _bfd_error_handler (_("\
++ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
++ bfd_archive_filename (ibfd),
++ in_flags & EF_ARM_APCS_26 ? 26 : 32,
++ bfd_get_filename (obfd),
++ out_flags & EF_ARM_APCS_26 ? 26 : 32);
++ flags_compatible = FALSE;
++ }
++
++ if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
++ {
++ if (in_flags & EF_ARM_APCS_FLOAT)
++ _bfd_error_handler (_("\
++ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ else
++ _bfd_error_handler (_("\
++ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++
++ flags_compatible = FALSE;
++ }
++
++ if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
++ {
++ if (in_flags & EF_ARM_VFP_FLOAT)
++ _bfd_error_handler (_("\
++ERROR: %s uses VFP instructions, whereas %s does not"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ else
++ _bfd_error_handler (_("\
++ERROR: %s uses FPA instructions, whereas %s does not"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++
++ flags_compatible = FALSE;
++ }
++
++ if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
++ {
++ if (in_flags & EF_ARM_MAVERICK_FLOAT)
++ _bfd_error_handler (_("\
++ERROR: %s uses Maverick instructions, whereas %s does not"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ else
++ _bfd_error_handler (_("\
++ERROR: %s does not use Maverick instructions, whereas %s does"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++
++ flags_compatible = FALSE;
++ }
++
++#ifdef EF_ARM_SOFT_FLOAT
++ if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
++ {
++ /* We can allow interworking between code that is VFP format
++ layout, and uses either soft float or integer regs for
++ passing floating point arguments and results. We already
++ know that the APCS_FLOAT flags match; similarly for VFP
++ flags. */
++ if ((in_flags & EF_ARM_APCS_FLOAT) != 0
++ || (in_flags & EF_ARM_VFP_FLOAT) == 0)
++ {
++ if (in_flags & EF_ARM_SOFT_FLOAT)
++ _bfd_error_handler (_("\
++ERROR: %s uses software FP, whereas %s uses hardware FP"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ else
++ _bfd_error_handler (_("\
++ERROR: %s uses hardware FP, whereas %s uses software FP"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++
++ flags_compatible = FALSE;
++ }
++ }
++#endif
++
++ /* Interworking mismatch is only a warning. */
++ if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
++ {
++ if (in_flags & EF_ARM_INTERWORK)
++ {
++ _bfd_error_handler (_("\
++Warning: %s supports interworking, whereas %s does not"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ }
++ else
++ {
++ _bfd_error_handler (_("\
++Warning: %s does not support interworking, whereas %s does"),
++ bfd_archive_filename (ibfd),
++ bfd_get_filename (obfd));
++ }
++ }
++ }
++
++ return flags_compatible;
++}
++
++/* Display the flags field. */
++
++static bfd_boolean
++elf32_arm_print_private_bfd_data (abfd, ptr)
++ bfd *abfd;
++ PTR ptr;
++{
++ FILE * file = (FILE *) ptr;
++ unsigned long flags;
++
++ BFD_ASSERT (abfd != NULL && ptr != NULL);
++
++ /* Print normal ELF private data. */
++ _bfd_elf_print_private_bfd_data (abfd, ptr);
++
++ flags = elf_elfheader (abfd)->e_flags;
++ /* Ignore init flag - it may not be set, despite the flags field
++ containing valid data. */
++
++ /* xgettext:c-format */
++ fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
++
++ switch (EF_ARM_EABI_VERSION (flags))
++ {
++ case EF_ARM_EABI_UNKNOWN:
++ /* The following flag bits are GNU extenstions and not part of the
++ official ARM ELF extended ABI. Hence they are only decoded if
++ the EABI version is not set. */
++ if (flags & EF_ARM_INTERWORK)
++ fprintf (file, _(" [interworking enabled]"));
++
++ if (flags & EF_ARM_APCS_26)
++ fprintf (file, " [APCS-26]");
++ else
++ fprintf (file, " [APCS-32]");
++
++ if (flags & EF_ARM_VFP_FLOAT)
++ fprintf (file, _(" [VFP float format]"));
++ else if (flags & EF_ARM_MAVERICK_FLOAT)
++ fprintf (file, _(" [Maverick float format]"));
++ else
++ fprintf (file, _(" [FPA float format]"));
++
++ if (flags & EF_ARM_APCS_FLOAT)
++ fprintf (file, _(" [floats passed in float registers]"));
++
++ if (flags & EF_ARM_PIC)
++ fprintf (file, _(" [position independent]"));
++
++ if (flags & EF_ARM_NEW_ABI)
++ fprintf (file, _(" [new ABI]"));
++
++ if (flags & EF_ARM_OLD_ABI)
++ fprintf (file, _(" [old ABI]"));
++
++ if (flags & EF_ARM_SOFT_FLOAT)
++ fprintf (file, _(" [software FP]"));
++
++ flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
++ | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
++ | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
++ | EF_ARM_MAVERICK_FLOAT);
++ break;
++
++ case EF_ARM_EABI_VER1:
++ fprintf (file, _(" [Version1 EABI]"));
++
++ if (flags & EF_ARM_SYMSARESORTED)
++ fprintf (file, _(" [sorted symbol table]"));
++ else
++ fprintf (file, _(" [unsorted symbol table]"));
++
++ flags &= ~ EF_ARM_SYMSARESORTED;
++ break;
++
++ case EF_ARM_EABI_VER2:
++ fprintf (file, _(" [Version2 EABI]"));
++
++ if (flags & EF_ARM_SYMSARESORTED)
++ fprintf (file, _(" [sorted symbol table]"));
++ else
++ fprintf (file, _(" [unsorted symbol table]"));
++
++ if (flags & EF_ARM_DYNSYMSUSESEGIDX)
++ fprintf (file, _(" [dynamic symbols use segment index]"));
++
++ if (flags & EF_ARM_MAPSYMSFIRST)
++ fprintf (file, _(" [mapping symbols precede others]"));
++
++ flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
++ | EF_ARM_MAPSYMSFIRST);
++ break;
++
++ default:
++ fprintf (file, _(" <EABI version unrecognised>"));
++ break;
++ }
++
++ flags &= ~ EF_ARM_EABIMASK;
++
++ if (flags & EF_ARM_RELEXEC)
++ fprintf (file, _(" [relocatable executable]"));
++
++ if (flags & EF_ARM_HASENTRY)
++ fprintf (file, _(" [has entry point]"));
++
++ flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
++
++ if (flags)
++ fprintf (file, _("<Unrecognised flag bits set>"));
++
++ fputc ('\n', file);
++
++ return TRUE;
++}
++
++static int
++elf32_arm_get_symbol_type (elf_sym, type)
++ Elf_Internal_Sym * elf_sym;
++ int type;
++{
++ switch (ELF_ST_TYPE (elf_sym->st_info))
++ {
++ case STT_ARM_TFUNC:
++ return ELF_ST_TYPE (elf_sym->st_info);
++
++ case STT_ARM_16BIT:
++ /* If the symbol is not an object, return the STT_ARM_16BIT flag.
++ This allows us to distinguish between data used by Thumb instructions
++ and non-data (which is probably code) inside Thumb regions of an
++ executable. */
++ if (type != STT_OBJECT)
++ return ELF_ST_TYPE (elf_sym->st_info);
++ break;
++
++ default:
++ break;
++ }
++
++ return type;
++}
++
++static asection *
++elf32_arm_gc_mark_hook (sec, info, rel, h, sym)
++ asection *sec;
++ struct bfd_link_info *info ATTRIBUTE_UNUSED;
++ Elf_Internal_Rela *rel;
++ struct elf_link_hash_entry *h;
++ Elf_Internal_Sym *sym;
++{
++ if (h != NULL)
++ {
++ switch (ELF32_R_TYPE (rel->r_info))
++ {
++ case R_ARM_GNU_VTINHERIT:
++ case R_ARM_GNU_VTENTRY:
++ break;
++
++ default:
++ switch (h->root.type)
++ {
++ case bfd_link_hash_defined:
++ case bfd_link_hash_defweak:
++ return h->root.u.def.section;
++
++ case bfd_link_hash_common:
++ return h->root.u.c.p->section;
++
++ default:
++ break;
++ }
++ }
++ }
++ else
++ return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
++
++ return NULL;
++}
++
++/* Update the got entry reference counts for the section being removed. */
++
++static bfd_boolean
++elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
++ bfd *abfd ATTRIBUTE_UNUSED;
++ struct bfd_link_info *info ATTRIBUTE_UNUSED;
++ asection *sec ATTRIBUTE_UNUSED;
++ const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
++{
++ /* We don't support garbage collection of GOT and PLT relocs yet. */
++ return TRUE;
++}
++
++/* Look through the relocs for a section during the first phase. */
++
++static bfd_boolean
++elf32_arm_check_relocs (abfd, info, sec, relocs)
++ bfd *abfd;
++ struct bfd_link_info *info;
++ asection *sec;
++ const Elf_Internal_Rela *relocs;
++{
++ Elf_Internal_Shdr *symtab_hdr;
++ struct elf_link_hash_entry **sym_hashes;
++ struct elf_link_hash_entry **sym_hashes_end;
++ const Elf_Internal_Rela *rel;
++ const Elf_Internal_Rela *rel_end;
++ bfd *dynobj;
++ asection *sgot, *srelgot, *sreloc;
++ bfd_vma *local_got_offsets;
++
++ if (info->relocatable)
++ return TRUE;
++
++ sgot = srelgot = sreloc = NULL;
++
++ dynobj = elf_hash_table (info)->dynobj;
++ local_got_offsets = elf_local_got_offsets (abfd);
++
++ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
++ sym_hashes = elf_sym_hashes (abfd);
++ sym_hashes_end = sym_hashes
++ + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
++
++ if (!elf_bad_symtab (abfd))
++ sym_hashes_end -= symtab_hdr->sh_info;
++
++ rel_end = relocs + sec->reloc_count;
++ for (rel = relocs; rel < rel_end; rel++)
++ {
++ struct elf_link_hash_entry *h;
++ unsigned long r_symndx;
++
++ r_symndx = ELF32_R_SYM (rel->r_info);
++ if (r_symndx < symtab_hdr->sh_info)
++ h = NULL;
++ else
++ h = sym_hashes[r_symndx - symtab_hdr->sh_info];
++
++ /* Some relocs require a global offset table. */
++ if (dynobj == NULL)
++ {
++ switch (ELF32_R_TYPE (rel->r_info))
++ {
++ case R_ARM_GOT32:
++ case R_ARM_GOTOFF:
++ case R_ARM_GOTPC:
++ elf_hash_table (info)->dynobj = dynobj = abfd;
++ if (! _bfd_elf_create_got_section (dynobj, info))
++ return FALSE;
++ break;
++
++ default:
++ break;
++ }
++ }
++
++ switch (ELF32_R_TYPE (rel->r_info))
++ {
++ case R_ARM_GOT32:
++ /* This symbol requires a global offset table entry. */
++ if (sgot == NULL)
++ {
++ sgot = bfd_get_section_by_name (dynobj, ".got");
++ BFD_ASSERT (sgot != NULL);
++ }
++
++ /* Get the got relocation section if necessary. */
++ if (srelgot == NULL
++ && (h != NULL || info->shared))
++ {
++ srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
++
++ /* If no got relocation section, make one and initialize. */
++ if (srelgot == NULL)
++ {
++ srelgot = bfd_make_section (dynobj, ".rel.got");
++ if (srelgot == NULL
++ || ! bfd_set_section_flags (dynobj, srelgot,
++ (SEC_ALLOC
++ | SEC_LOAD
++ | SEC_HAS_CONTENTS
++ | SEC_IN_MEMORY
++ | SEC_LINKER_CREATED
++ | SEC_READONLY))
++ || ! bfd_set_section_alignment (dynobj, srelgot, 2))
++ return FALSE;
++ }
++ }
++
++ if (h != NULL)
++ {
++ if (h->got.offset != (bfd_vma) -1)
++ /* We have already allocated space in the .got. */
++ break;
++
++ h->got.offset = sgot->_raw_size;
++
++ /* Make sure this symbol is output as a dynamic symbol. */
++ if (h->dynindx == -1)
++ if (! bfd_elf32_link_record_dynamic_symbol (info, h))
++ return FALSE;
++
++ srelgot->_raw_size += sizeof (Elf32_External_Rel);
++ }
++ else
++ {
++ /* This is a global offset table entry for a local
++ symbol. */
++ if (local_got_offsets == NULL)
++ {
++ bfd_size_type size;
++ unsigned int i;
++
++ size = symtab_hdr->sh_info;
++ size *= sizeof (bfd_vma);
++ local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
++ if (local_got_offsets == NULL)
++ return FALSE;
++ elf_local_got_offsets (abfd) = local_got_offsets;
++ for (i = 0; i < symtab_hdr->sh_info; i++)
++ local_got_offsets[i] = (bfd_vma) -1;
++ }
++
++ if (local_got_offsets[r_symndx] != (bfd_vma) -1)
++ /* We have already allocated space in the .got. */
++ break;
++
++ local_got_offsets[r_symndx] = sgot->_raw_size;
++
++ if (info->shared)
++ /* If we are generating a shared object, we need to
++ output a R_ARM_RELATIVE reloc so that the dynamic
++ linker can adjust this GOT entry. */
++ srelgot->_raw_size += sizeof (Elf32_External_Rel);
++ }
++
++ sgot->_raw_size += 4;
++ break;
++
++ case R_ARM_PLT32:
++ /* This symbol requires a procedure linkage table entry. We
++ actually build the entry in adjust_dynamic_symbol,
++ because this might be a case of linking PIC code which is
++ never referenced by a dynamic object, in which case we
++ don't need to generate a procedure linkage table entry
++ after all. */
++
++ /* If this is a local symbol, we resolve it directly without
++ creating a procedure linkage table entry. */
++ if (h == NULL)
++ continue;
++
++ h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
++ break;
++
++ case R_ARM_ABS32:
++ case R_ARM_REL32:
++ case R_ARM_PC24:
++ /* If we are creating a shared library, and this is a reloc
++ against a global symbol, or a non PC relative reloc
++ against a local symbol, then we need to copy the reloc
++ into the shared library. However, if we are linking with
++ -Bsymbolic, we do not need to copy a reloc against a
++ global symbol which is defined in an object we are
++ including in the link (i.e., DEF_REGULAR is set). At
++ this point we have not seen all the input files, so it is
++ possible that DEF_REGULAR is not set now but will be set
++ later (it is never cleared). We account for that
++ possibility below by storing information in the
++ pcrel_relocs_copied field of the hash table entry. */
++ if (info->shared
++ && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
++ || (h != NULL
++ && (! info->symbolic
++ || (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_REGULAR) == 0))))
++ {
++ /* When creating a shared object, we must copy these
++ reloc types into the output file. We create a reloc
++ section in dynobj and make room for this reloc. */
++ if (sreloc == NULL)
++ {
++ const char * name;
++
++ name = (bfd_elf_string_from_elf_section
++ (abfd,
++ elf_elfheader (abfd)->e_shstrndx,
++ elf_section_data (sec)->rel_hdr.sh_name));
++ if (name == NULL)
++ return FALSE;
++
++ BFD_ASSERT (strncmp (name, ".rel", 4) == 0
++ && strcmp (bfd_get_section_name (abfd, sec),
++ name + 4) == 0);
++
++ sreloc = bfd_get_section_by_name (dynobj, name);
++ if (sreloc == NULL)
++ {
++ flagword flags;
++
++ sreloc = bfd_make_section (dynobj, name);
++ flags = (SEC_HAS_CONTENTS | SEC_READONLY
++ | SEC_IN_MEMORY | SEC_LINKER_CREATED);
++ if ((sec->flags & SEC_ALLOC) != 0)
++ flags |= SEC_ALLOC | SEC_LOAD;
++ if (sreloc == NULL
++ || ! bfd_set_section_flags (dynobj, sreloc, flags)
++ || ! bfd_set_section_alignment (dynobj, sreloc, 2))
++ return FALSE;
++ }
++ if (sec->flags & SEC_READONLY)
++ info->flags |= DF_TEXTREL;
++ }
++
++ sreloc->_raw_size += sizeof (Elf32_External_Rel);
++ /* If we are linking with -Bsymbolic, and this is a
++ global symbol, we count the number of PC relative
++ relocations we have entered for this symbol, so that
++ we can discard them again if the symbol is later
++ defined by a regular object. Note that this function
++ is only called if we are using an elf_i386 linker
++ hash table, which means that h is really a pointer to
++ an elf_i386_link_hash_entry. */
++ if (h != NULL && info->symbolic
++ && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
++ {
++ struct elf32_arm_link_hash_entry * eh;
++ struct elf32_arm_pcrel_relocs_copied * p;
++
++ eh = (struct elf32_arm_link_hash_entry *) h;
++
++ for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
++ if (p->section == sreloc)
++ break;
++
++ if (p == NULL)
++ {
++ p = ((struct elf32_arm_pcrel_relocs_copied *)
++ bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
++ if (p == NULL)
++ return FALSE;
++ p->next = eh->pcrel_relocs_copied;
++ eh->pcrel_relocs_copied = p;
++ p->section = sreloc;
++ p->count = 0;
++ }
++
++ ++p->count;
++ }
++ }
++ break;
++
++ /* This relocation describes the C++ object vtable hierarchy.
++ Reconstruct it for later use during GC. */
++ case R_ARM_GNU_VTINHERIT:
++ if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
++ return FALSE;
++ break;
++
++ /* This relocation describes which C++ vtable entries are actually
++ used. Record for later use during GC. */
++ case R_ARM_GNU_VTENTRY:
++ if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
++ return FALSE;
++ break;
++ }
++ }
++
++ return TRUE;
++}
++
++/* Find the nearest line to a particular section and offset, for error
++ reporting. This code is a duplicate of the code in elf.c, except
++ that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
++
++static bfd_boolean
++elf32_arm_find_nearest_line
++ (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
++ bfd *abfd;
++ asection *section;
++ asymbol **symbols;
++ bfd_vma offset;
++ const char **filename_ptr;
++ const char **functionname_ptr;
++ unsigned int *line_ptr;
++{
++ bfd_boolean found;
++ const char *filename;
++ asymbol *func;
++ bfd_vma low_func;
++ asymbol **p;
++
++ if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
++ filename_ptr, functionname_ptr,
++ line_ptr, 0,
++ &elf_tdata (abfd)->dwarf2_find_line_info))
++ return TRUE;
++
++ if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
++ &found, filename_ptr,
++ functionname_ptr, line_ptr,
++ &elf_tdata (abfd)->line_info))
++ return FALSE;
++
++ if (found)
++ return TRUE;
++
++ if (symbols == NULL)
++ return FALSE;
++
++ filename = NULL;
++ func = NULL;
++ low_func = 0;
++
++ for (p = symbols; *p != NULL; p++)
++ {
++ elf_symbol_type *q;
++
++ q = (elf_symbol_type *) *p;
++
++ if (bfd_get_section (&q->symbol) != section)
++ continue;
++
++ switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
++ {
++ default:
++ break;
++ case STT_FILE:
++ filename = bfd_asymbol_name (&q->symbol);
++ break;
++ case STT_NOTYPE:
++ case STT_FUNC:
++ case STT_ARM_TFUNC:
++ if (q->symbol.section == section
++ && q->symbol.value >= low_func
++ && q->symbol.value <= offset)
++ {
++ func = (asymbol *) q;
++ low_func = q->symbol.value;
++ }
++ break;
++ }
++ }
++
++ if (func == NULL)
++ return FALSE;
++
++ *filename_ptr = filename;
++ *functionname_ptr = bfd_asymbol_name (func);
++ *line_ptr = 0;
++
++ return TRUE;
++}
++
++/* Adjust a symbol defined by a dynamic object and referenced by a
++ regular object. The current definition is in some section of the
++ dynamic object, but we're not including those sections. We have to
++ change the definition to something the rest of the link can
++ understand. */
++
++static bfd_boolean
++elf32_arm_adjust_dynamic_symbol (info, h)
++ struct bfd_link_info * info;
++ struct elf_link_hash_entry * h;
++{
++ bfd * dynobj;
++ asection * s;
++ unsigned int power_of_two;
++
++ dynobj = elf_hash_table (info)->dynobj;
++
++ /* Make sure we know what is going on here. */
++ BFD_ASSERT (dynobj != NULL
++ && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
++ || h->weakdef != NULL
++ || ((h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_DYNAMIC) != 0
++ && (h->elf_link_hash_flags
++ & ELF_LINK_HASH_REF_REGULAR) != 0
++ && (h->elf_link_hash_flags
++ & ELF_LINK_HASH_DEF_REGULAR) == 0)));
++
++ /* If this is a function, put it in the procedure linkage table. We
++ will fill in the contents of the procedure linkage table later,
++ when we know the address of the .got section. */
++ if (h->type == STT_FUNC
++ || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
++ {
++ /* If we link a program (not a DSO), we'll get rid of unnecessary
++ PLT entries; we point to the actual symbols -- even for pic
++ relocs, because a program built with -fpic should have the same
++ result as one built without -fpic, specifically considering weak
++ symbols.
++ FIXME: m68k and i386 differ here, for unclear reasons. */
++ if (! info->shared
++ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
++ {
++ /* This case can occur if we saw a PLT32 reloc in an input
++ file, but the symbol was not defined by a dynamic object.
++ In such a case, we don't actually need to build a
++ procedure linkage table, and we can just do a PC32 reloc
++ instead. */
++ BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
++ h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
++ return TRUE;
++ }
++
++ /* Make sure this symbol is output as a dynamic symbol. */
++ if (h->dynindx == -1)
++ {
++ if (! bfd_elf32_link_record_dynamic_symbol (info, h))
++ return FALSE;
++ }
++
++ s = bfd_get_section_by_name (dynobj, ".plt");
++ BFD_ASSERT (s != NULL);
++
++ /* If this is the first .plt entry, make room for the special
++ first entry. */
++ if (s->_raw_size == 0)
++ s->_raw_size += PLT_ENTRY_SIZE;
++
++ /* If this symbol is not defined in a regular file, and we are
++ not generating a shared library, then set the symbol to this
++ location in the .plt. This is required to make function
++ pointers compare as equal between the normal executable and
++ the shared library. */
++ if (! info->shared
++ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
++ {
++ h->root.u.def.section = s;
++ h->root.u.def.value = s->_raw_size;
++ }
++
++ h->plt.offset = s->_raw_size;
++
++ /* Make room for this entry. */
++ s->_raw_size += PLT_ENTRY_SIZE;
++
++ /* We also need to make an entry in the .got.plt section, which
++ will be placed in the .got section by the linker script. */
++ s = bfd_get_section_by_name (dynobj, ".got.plt");
++ BFD_ASSERT (s != NULL);
++ s->_raw_size += 4;
++
++ /* We also need to make an entry in the .rel.plt section. */
++
++ s = bfd_get_section_by_name (dynobj, ".rel.plt");
++ BFD_ASSERT (s != NULL);
++ s->_raw_size += sizeof (Elf32_External_Rel);
++
++ return TRUE;
++ }
++
++ /* If this is a weak symbol, and there is a real definition, the
++ processor independent code will have arranged for us to see the
++ real definition first, and we can just use the same value. */
++ if (h->weakdef != NULL)
++ {
++ BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
++ || h->weakdef->root.type == bfd_link_hash_defweak);
++ h->root.u.def.section = h->weakdef->root.u.def.section;
++ h->root.u.def.value = h->weakdef->root.u.def.value;
++ return TRUE;
++ }
++
++ /* This is a reference to a symbol defined by a dynamic object which
++ is not a function. */
++
++ /* If we are creating a shared library, we must presume that the
++ only references to the symbol are via the global offset table.
++ For such cases we need not do anything here; the relocations will
++ be handled correctly by relocate_section. */
++ if (info->shared)
++ return TRUE;
++
++ /* We must allocate the symbol in our .dynbss section, which will
++ become part of the .bss section of the executable. There will be
++ an entry for this symbol in the .dynsym section. The dynamic
++ object will contain position independent code, so all references
++ from the dynamic object to this symbol will go through the global
++ offset table. The dynamic linker will use the .dynsym entry to
++ determine the address it must put in the global offset table, so
++ both the dynamic object and the regular object will refer to the
++ same memory location for the variable. */
++ s = bfd_get_section_by_name (dynobj, ".dynbss");
++ BFD_ASSERT (s != NULL);
++
++ /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
++ copy the initial value out of the dynamic object and into the
++ runtime process image. We need to remember the offset into the
++ .rel.bss section we are going to use. */
++ if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
++ {
++ asection *srel;
++
++ srel = bfd_get_section_by_name (dynobj, ".rel.bss");
++ BFD_ASSERT (srel != NULL);
++ srel->_raw_size += sizeof (Elf32_External_Rel);
++ h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
++ }
++
++ /* We need to figure out the alignment required for this symbol. I
++ have no idea how ELF linkers handle this. */
++ power_of_two = bfd_log2 (h->size);
++ if (power_of_two > 3)
++ power_of_two = 3;
++
++ /* Apply the required alignment. */
++ s->_raw_size = BFD_ALIGN (s->_raw_size,
++ (bfd_size_type) (1 << power_of_two));
++ if (power_of_two > bfd_get_section_alignment (dynobj, s))
++ {
++ if (! bfd_set_section_alignment (dynobj, s, power_of_two))
++ return FALSE;
++ }
++
++ /* Define the symbol as being at this point in the section. */
++ h->root.u.def.section = s;
++ h->root.u.def.value = s->_raw_size;
++
++ /* Increment the section size to make room for the symbol. */
++ s->_raw_size += h->size;
++
++ return TRUE;
++}
++
++/* Set the sizes of the dynamic sections. */
++
++static bfd_boolean
++elf32_arm_size_dynamic_sections (output_bfd, info)
++ bfd * output_bfd ATTRIBUTE_UNUSED;
++ struct bfd_link_info * info;
++{
++ bfd * dynobj;
++ asection * s;
++ bfd_boolean plt;
++ bfd_boolean relocs;
++
++ dynobj = elf_hash_table (info)->dynobj;
++ BFD_ASSERT (dynobj != NULL);
++
++ if (elf_hash_table (info)->dynamic_sections_created)
++ {
++ /* Set the contents of the .interp section to the interpreter. */
++ if (! info->shared)
++ {
++ s = bfd_get_section_by_name (dynobj, ".interp");
++ BFD_ASSERT (s != NULL);
++ s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
++ s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
++ }
++ }
++ else
++ {
++ /* We may have created entries in the .rel.got section.
++ However, if we are not creating the dynamic sections, we will
++ not actually use these entries. Reset the size of .rel.got,
++ which will cause it to get stripped from the output file
++ below. */
++ s = bfd_get_section_by_name (dynobj, ".rel.got");
++ if (s != NULL)
++ s->_raw_size = 0;
++ }
++
++ /* If this is a -Bsymbolic shared link, then we need to discard all
++ PC relative relocs against symbols defined in a regular object.
++ We allocated space for them in the check_relocs routine, but we
++ will not fill them in in the relocate_section routine. */
++ if (info->shared && info->symbolic)
++ elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
++ elf32_arm_discard_copies,
++ (PTR) NULL);
++
++ /* The check_relocs and adjust_dynamic_symbol entry points have
++ determined the sizes of the various dynamic sections. Allocate
++ memory for them. */
++ plt = FALSE;
++ relocs = FALSE;
++ for (s = dynobj->sections; s != NULL; s = s->next)
++ {
++ const char * name;
++ bfd_boolean strip;
++
++ if ((s->flags & SEC_LINKER_CREATED) == 0)
++ continue;
++
++ /* It's OK to base decisions on the section name, because none
++ of the dynobj section names depend upon the input files. */
++ name = bfd_get_section_name (dynobj, s);
++
++ strip = FALSE;
++
++ if (strcmp (name, ".plt") == 0)
++ {
++ if (s->_raw_size == 0)
++ {
++ /* Strip this section if we don't need it; see the
++ comment below. */
++ strip = TRUE;
++ }
++ else
++ {
++ /* Remember whether there is a PLT. */
++ plt = TRUE;
++ }
++ }
++ else if (strncmp (name, ".rel", 4) == 0)
++ {
++ if (s->_raw_size == 0)
++ {
++ /* If we don't need this section, strip it from the
++ output file. This is mostly to handle .rel.bss and
++ .rel.plt. We must create both sections in
++ create_dynamic_sections, because they must be created
++ before the linker maps input sections to output
++ sections. The linker does that before
++ adjust_dynamic_symbol is called, and it is that
++ function which decides whether anything needs to go
++ into these sections. */
++ strip = TRUE;
++ }
++ else
++ {
++ /* Remember whether there are any reloc sections other
++ than .rel.plt. */
++ if (strcmp (name, ".rel.plt") != 0)
++ relocs = TRUE;
++
++ /* We use the reloc_count field as a counter if we need
++ to copy relocs into the output file. */
++ s->reloc_count = 0;
++ }
++ }
++ else if (strncmp (name, ".got", 4) != 0)
++ {
++ /* It's not one of our sections, so don't allocate space. */
++ continue;
++ }
++
++ if (strip)
++ {
++ _bfd_strip_section_from_output (info, s);
++ continue;
++ }
++
++ /* Allocate memory for the section contents. */
++ s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
++ if (s->contents == NULL && s->_raw_size != 0)
++ return FALSE;
++ }
++
++ if (elf_hash_table (info)->dynamic_sections_created)
++ {
++ /* Add some entries to the .dynamic section. We fill in the
++ values later, in elf32_arm_finish_dynamic_sections, but we
++ must add the entries now so that we get the correct size for
++ the .dynamic section. The DT_DEBUG entry is filled in by the
++ dynamic linker and used by the debugger. */
++#define add_dynamic_entry(TAG, VAL) \
++ bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
++
++ if (!info->shared)
++ {
++ if (!add_dynamic_entry (DT_DEBUG, 0))
++ return FALSE;
++ }
++
++ if (plt)
++ {
++ if ( !add_dynamic_entry (DT_PLTGOT, 0)
++ || !add_dynamic_entry (DT_PLTRELSZ, 0)
++ || !add_dynamic_entry (DT_PLTREL, DT_REL)
++ || !add_dynamic_entry (DT_JMPREL, 0))
++ return FALSE;
++ }
++
++ if (relocs)
++ {
++ if ( !add_dynamic_entry (DT_REL, 0)
++ || !add_dynamic_entry (DT_RELSZ, 0)
++ || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
++ return FALSE;
++ }
++
++ if ((info->flags & DF_TEXTREL) != 0)
++ {
++ if (!add_dynamic_entry (DT_TEXTREL, 0))
++ return FALSE;
++ info->flags |= DF_TEXTREL;
++ }
++ }
++#undef add_synamic_entry
++
++ return TRUE;
++}
++
++/* This function is called via elf32_arm_link_hash_traverse if we are
++ creating a shared object with -Bsymbolic. It discards the space
++ allocated to copy PC relative relocs against symbols which are
++ defined in regular objects. We allocated space for them in the
++ check_relocs routine, but we won't fill them in in the
++ relocate_section routine. */
++
++static bfd_boolean
++elf32_arm_discard_copies (h, ignore)
++ struct elf32_arm_link_hash_entry * h;
++ PTR ignore ATTRIBUTE_UNUSED;
++{
++ struct elf32_arm_pcrel_relocs_copied * s;
++
++ if (h->root.root.type == bfd_link_hash_warning)
++ h = (struct elf32_arm_link_hash_entry *) h->root.root.u.i.link;
++
++ /* We only discard relocs for symbols defined in a regular object. */
++ if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
++ return TRUE;
++
++ for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
++ s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
++
++ return TRUE;
++}
++
++/* Finish up dynamic symbol handling. We set the contents of various
++ dynamic sections here. */
++
++static bfd_boolean
++elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
++ bfd * output_bfd;
++ struct bfd_link_info * info;
++ struct elf_link_hash_entry * h;
++ Elf_Internal_Sym * sym;
++{
++ bfd * dynobj;
++
++ dynobj = elf_hash_table (info)->dynobj;
++
++ if (h->plt.offset != (bfd_vma) -1)
++ {
++ asection * splt;
++ asection * sgot;
++ asection * srel;
++ bfd_vma plt_index;
++ bfd_vma got_offset;
++ Elf_Internal_Rela rel;
++ bfd_byte *loc;
++
++ /* This symbol has an entry in the procedure linkage table. Set
++ it up. */
++
++ BFD_ASSERT (h->dynindx != -1);
++
++ splt = bfd_get_section_by_name (dynobj, ".plt");
++ sgot = bfd_get_section_by_name (dynobj, ".got.plt");
++ srel = bfd_get_section_by_name (dynobj, ".rel.plt");
++ BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
++
++ /* Get the index in the procedure linkage table which
++ corresponds to this symbol. This is the index of this symbol
++ in all the symbols for which we are making plt entries. The
++ first entry in the procedure linkage table is reserved. */
++ plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
++
++ /* Get the offset into the .got table of the entry that
++ corresponds to this function. Each .got entry is 4 bytes.
++ The first three are reserved. */
++ got_offset = (plt_index + 3) * 4;
++
++ /* Fill in the entry in the procedure linkage table. */
++ bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
++ splt->contents + h->plt.offset + 0);
++ bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
++ splt->contents + h->plt.offset + 4);
++ bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
++ splt->contents + h->plt.offset + 8);
++ bfd_put_32 (output_bfd,
++ (sgot->output_section->vma
++ + sgot->output_offset
++ + got_offset
++ - splt->output_section->vma
++ - splt->output_offset
++ - h->plt.offset - 12),
++ splt->contents + h->plt.offset + 12);
++
++ /* Fill in the entry in the global offset table. */
++ bfd_put_32 (output_bfd,
++ (splt->output_section->vma
++ + splt->output_offset),
++ sgot->contents + got_offset);
++
++ /* Fill in the entry in the .rel.plt section. */
++ rel.r_offset = (sgot->output_section->vma
++ + sgot->output_offset
++ + got_offset);
++ rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
++ loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
++ bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
++
++ if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
++ {
++ /* Mark the symbol as undefined, rather than as defined in
++ the .plt section. Leave the value alone. */
++ sym->st_shndx = SHN_UNDEF;
++ /* If the symbol is weak, we do need to clear the value.
++ Otherwise, the PLT entry would provide a definition for
++ the symbol even if the symbol wasn't defined anywhere,
++ and so the symbol would never be NULL. */
++ if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
++ == 0)
++ sym->st_value = 0;
++ }
++ }
++
++ if (h->got.offset != (bfd_vma) -1)
++ {
++ asection * sgot;
++ asection * srel;
++ Elf_Internal_Rela rel;
++ bfd_byte *loc;
++
++ /* This symbol has an entry in the global offset table. Set it
++ up. */
++ sgot = bfd_get_section_by_name (dynobj, ".got");
++ srel = bfd_get_section_by_name (dynobj, ".rel.got");
++ BFD_ASSERT (sgot != NULL && srel != NULL);
++
++ rel.r_offset = (sgot->output_section->vma
++ + sgot->output_offset
++ + (h->got.offset &~ (bfd_vma) 1));
++
++ /* If this is a -Bsymbolic link, and the symbol is defined
++ locally, we just want to emit a RELATIVE reloc. The entry in
++ the global offset table will already have been initialized in
++ the relocate_section function. */
++ if (info->shared
++ && (info->symbolic || h->dynindx == -1)
++ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
++ rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
++ else
++ {
++ bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
++ rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
++ }
++
++ loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
++ bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
++ }
++
++ if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
++ {
++ asection * s;
++ Elf_Internal_Rela rel;
++ bfd_byte *loc;
++
++ /* This symbol needs a copy reloc. Set it up. */
++ BFD_ASSERT (h->dynindx != -1
++ && (h->root.type == bfd_link_hash_defined
++ || h->root.type == bfd_link_hash_defweak));
++
++ s = bfd_get_section_by_name (h->root.u.def.section->owner,
++ ".rel.bss");
++ BFD_ASSERT (s != NULL);
++
++ rel.r_offset = (h->root.u.def.value
++ + h->root.u.def.section->output_section->vma
++ + h->root.u.def.section->output_offset);
++ rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
++ loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
++ bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
++ }
++
++ /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
++ if (strcmp (h->root.root.string, "_DYNAMIC") == 0
++ || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
++ sym->st_shndx = SHN_ABS;
++
++ return TRUE;
++}
++
++/* Finish up the dynamic sections. */
++
++static bfd_boolean
++elf32_arm_finish_dynamic_sections (output_bfd, info)
++ bfd * output_bfd;
++ struct bfd_link_info * info;
++{
++ bfd * dynobj;
++ asection * sgot;
++ asection * sdyn;
++
++ dynobj = elf_hash_table (info)->dynobj;
++
++ sgot = bfd_get_section_by_name (dynobj, ".got.plt");
++ BFD_ASSERT (sgot != NULL);
++ sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
++
++ if (elf_hash_table (info)->dynamic_sections_created)
++ {
++ asection *splt;
++ Elf32_External_Dyn *dyncon, *dynconend;
++
++ splt = bfd_get_section_by_name (dynobj, ".plt");
++ BFD_ASSERT (splt != NULL && sdyn != NULL);
++
++ dyncon = (Elf32_External_Dyn *) sdyn->contents;
++ dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
++
++ for (; dyncon < dynconend; dyncon++)
++ {
++ Elf_Internal_Dyn dyn;
++ const char * name;
++ asection * s;
++
++ bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
++
++ switch (dyn.d_tag)
++ {
++ default:
++ break;
++
++ case DT_PLTGOT:
++ name = ".got";
++ goto get_vma;
++ case DT_JMPREL:
++ name = ".rel.plt";
++ get_vma:
++ s = bfd_get_section_by_name (output_bfd, name);
++ BFD_ASSERT (s != NULL);
++ dyn.d_un.d_ptr = s->vma;
++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
++ break;
++
++ case DT_PLTRELSZ:
++ s = bfd_get_section_by_name (output_bfd, ".rel.plt");
++ BFD_ASSERT (s != NULL);
++ if (s->_cooked_size != 0)
++ dyn.d_un.d_val = s->_cooked_size;
++ else
++ dyn.d_un.d_val = s->_raw_size;
++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
++ break;
++
++ case DT_RELSZ:
++ /* My reading of the SVR4 ABI indicates that the
++ procedure linkage table relocs (DT_JMPREL) should be
++ included in the overall relocs (DT_REL). This is
++ what Solaris does. However, UnixWare can not handle
++ that case. Therefore, we override the DT_RELSZ entry
++ here to make it not include the JMPREL relocs. Since
++ the linker script arranges for .rel.plt to follow all
++ other relocation sections, we don't have to worry
++ about changing the DT_REL entry. */
++ s = bfd_get_section_by_name (output_bfd, ".rel.plt");
++ if (s != NULL)
++ {
++ if (s->_cooked_size != 0)
++ dyn.d_un.d_val -= s->_cooked_size;
++ else
++ dyn.d_un.d_val -= s->_raw_size;
++ }
++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
++ break;
++
++ /* Set the bottom bit of DT_INIT/FINI if the
++ corresponding function is Thumb. */
++ case DT_INIT:
++ name = info->init_function;
++ goto get_sym;
++ case DT_FINI:
++ name = info->fini_function;
++ get_sym:
++ /* If it wasn't set by elf_bfd_final_link
++ then there is nothing to ajdust. */
++ if (dyn.d_un.d_val != 0)
++ {
++ struct elf_link_hash_entry * eh;
++
++ eh = elf_link_hash_lookup (elf_hash_table (info), name,
++ FALSE, FALSE, TRUE);
++ if (eh != (struct elf_link_hash_entry *) NULL
++ && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
++ {
++ dyn.d_un.d_val |= 1;
++ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
++ }
++ }
++ break;
++ }
++ }
++
++ /* Fill in the first entry in the procedure linkage table. */
++ if (splt->_raw_size > 0)
++ {
++ bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
++ bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
++ bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
++ bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
++ }
++
++ /* UnixWare sets the entsize of .plt to 4, although that doesn't
++ really seem like the right value. */
++ elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
++ }
++
++ /* Fill in the first three entries in the global offset table. */
++ if (sgot->_raw_size > 0)
++ {
++ if (sdyn == NULL)
++ bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
++ else
++ bfd_put_32 (output_bfd,
++ sdyn->output_section->vma + sdyn->output_offset,
++ sgot->contents);
++ bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
++ bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
++ }
++
++ elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
++
++ return TRUE;
++}
++
++static void
++elf32_arm_post_process_headers (abfd, link_info)
++ bfd * abfd;
++ struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
++{
++ Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
++
++ i_ehdrp = elf_elfheader (abfd);
++
++ i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
++ i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
++}
++
++static enum elf_reloc_type_class
++elf32_arm_reloc_type_class (rela)
++ const Elf_Internal_Rela *rela;
++{
++ switch ((int) ELF32_R_TYPE (rela->r_info))
++ {
++ case R_ARM_RELATIVE:
++ return reloc_class_relative;
++ case R_ARM_JUMP_SLOT:
++ return reloc_class_plt;
++ case R_ARM_COPY:
++ return reloc_class_copy;
++ default:
++ return reloc_class_normal;
++ }
++}
++
++static bfd_boolean elf32_arm_section_flags PARAMS ((flagword *, Elf_Internal_Shdr *));
++static void elf32_arm_final_write_processing PARAMS ((bfd *, bfd_boolean));
++
++/* Set the right machine number for an Arm ELF file. */
++
++static bfd_boolean
++elf32_arm_section_flags (flags, hdr)
++ flagword *flags;
++ Elf_Internal_Shdr *hdr;
++{
++ if (hdr->sh_type == SHT_NOTE)
++ *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
++
++ return TRUE;
++}
++
++void
++elf32_arm_final_write_processing (abfd, linker)
++ bfd *abfd;
++ bfd_boolean linker ATTRIBUTE_UNUSED;
++{
++ bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
++}
++
++#define ELF_ARCH bfd_arch_arm
++#define ELF_MACHINE_CODE EM_ARM
++#ifdef __QNXTARGET__
++#define ELF_MAXPAGESIZE 0x1000
++#else
++#define ELF_MAXPAGESIZE 0x8000
++#endif
++
++#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
++#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
++#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
++#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
++#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
++#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
++#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
++
++#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
++#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
++#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
++#define elf_backend_check_relocs elf32_arm_check_relocs
++#define elf_backend_relocate_section elf32_arm_relocate_section
++#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
++#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
++#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
++#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
++#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
++#define elf_backend_post_process_headers elf32_arm_post_process_headers
++#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
++#define elf_backend_object_p elf32_arm_object_p
++#define elf_backend_section_flags elf32_arm_section_flags
++#define elf_backend_final_write_processing elf32_arm_final_write_processing
++
++#define elf_backend_can_gc_sections 1
++#define elf_backend_plt_readonly 1
++#define elf_backend_want_got_plt 1
++#define elf_backend_want_plt_sym 0
++#if !USE_REL
++#define elf_backend_rela_normal 1
++#endif
++
++#define elf_backend_got_header_size 12
++#define elf_backend_plt_header_size PLT_ENTRY_SIZE
++
++#include "elf32-target.h"
++
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-avr.c binutils-2.14.90.0.7/bfd/elf32-avr.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-avr.c 2003-11-07 00:11:15.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-avr.c 2003-11-07 00:21:15.000000000 +0100
+@@ -750,7 +750,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-cris.c binutils-2.14.90.0.7/bfd/elf32-cris.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-cris.c 2003-11-07 00:11:19.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-cris.c 2003-11-07 00:21:15.000000000 +0100
+@@ -847,7 +847,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ symname = (bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name));
+@@ -1292,16 +1292,7 @@
+ {
+ long indx;
+
+- if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-fr30.c binutils-2.14.90.0.7/bfd/elf32-fr30.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-fr30.c 2003-11-07 00:11:22.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-fr30.c 2003-11-07 00:21:15.000000000 +0100
+@@ -552,7 +552,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-frv.c binutils-2.14.90.0.7/bfd/elf32-frv.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-frv.c 2003-11-07 00:11:13.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-frv.c 2003-11-07 00:21:15.000000000 +0100
+@@ -724,7 +724,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-h8300.c binutils-2.14.90.0.7/bfd/elf32-h8300.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-h8300.c 2003-11-07 00:11:18.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-h8300.c 2003-11-07 00:21:15.000000000 +0100
+@@ -435,7 +435,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-hppa.c binutils-2.14.90.0.7/bfd/elf32-hppa.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-hppa.c 2003-11-07 00:11:23.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-hppa.c 2003-11-07 00:21:15.000000000 +0100
+@@ -3408,7 +3408,7 @@
+ /* This is a local symbol, h defaults to NULL. */
+ sym = local_syms + r_symndx;
+ sym_sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-i370.c binutils-2.14.90.0.7/bfd/elf32-i370.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-i370.c 2003-11-07 00:11:22.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-i370.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1210,7 +1210,7 @@
+ sec = local_sections[r_symndx];
+ sym_name = "<local symbol>";
+
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ addend = rel->r_addend;
+ }
+ else
+@@ -1363,16 +1363,7 @@
+ {
+ long indx;
+
+- if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-i860.c binutils-2.14.90.0.7/bfd/elf32-i860.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-i860.c 2003-11-07 00:11:16.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-i860.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1104,7 +1104,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-m32r.c binutils-2.14.90.0.7/bfd/elf32-m32r.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-m32r.c 2003-11-07 00:11:22.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-m32r.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1107,7 +1107,7 @@
+ sec = local_sections[r_symndx];
+ sym_name = "<local symbol>";
+ #if !USE_REL
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ addend = rel->r_addend;
+ #else
+ /* FIXME: This won't handle local relocations against SEC_MERGE
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-m68k.c binutils-2.14.90.0.7/bfd/elf32-m68k.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-m68k.c 2003-11-07 00:11:22.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-m68k.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1403,7 +1403,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+@@ -1657,16 +1657,7 @@
+ {
+ long indx;
+
+- if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-mcore.c binutils-2.14.90.0.7/bfd/elf32-mcore.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-mcore.c 2003-11-07 00:11:15.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-mcore.c 2003-11-07 00:21:16.000000000 +0100
+@@ -467,7 +467,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ addend = rel->r_addend;
+ }
+ else
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-msp430.c binutils-2.14.90.0.7/bfd/elf32-msp430.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-msp430.c 2003-11-07 00:11:24.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-msp430.c 2003-11-07 00:21:16.000000000 +0100
+@@ -449,7 +449,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-openrisc.c binutils-2.14.90.0.7/bfd/elf32-openrisc.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-openrisc.c 2003-11-07 00:11:23.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-openrisc.c 2003-11-07 00:21:16.000000000 +0100
+@@ -375,7 +375,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-ppc.c binutils-2.14.90.0.7/bfd/elf32-ppc.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-ppc.c 2003-11-07 00:11:21.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-ppc.c 2003-11-07 00:27:00.000000000 +0100
+@@ -1534,7 +1534,7 @@
+ 0xffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+- /* Phony reloc to handle branch stubs. */
++ /* Phony relocs to handle branch stubs. */
+ HOWTO (R_PPC_RELAX32, /* type */
+ 0, /* rightshift */
+ 0, /* size */
+@@ -1549,6 +1549,20 @@
+ 0, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
++ HOWTO (R_PPC_RELAX32PC, /* type */
++ 0, /* rightshift */
++ 0, /* size */
++ 0, /* bitsize */
++ FALSE, /* pc_relative */
++ 0, /* bitpos */
++ complain_overflow_dont, /* complain_on_overflow */
++ bfd_elf_generic_reloc, /* special_function */
++ "R_PPC_RELAX32PC", /* name */
++ FALSE, /* partial_inplace */
++ 0, /* src_mask */
++ 0, /* dst_mask */
++ FALSE), /* pcrel_offset */
++
+ /* GNU extension to record C++ vtable hierarchy. */
+ HOWTO (R_PPC_GNU_VTINHERIT, /* type */
+ 0, /* rightshift */
+@@ -1614,90 +1628,26 @@
+ }
+ }
+
+-static bfd_reloc_status_type
+-ppc_elf_install_value (bfd *abfd,
+- bfd_byte *hit_addr,
+- bfd_vma v,
+- unsigned int r_type)
+-{
+- bfd_vma t0, t1;
+-#ifdef BFD_HOST_U_64_BIT
+- BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
+-#else
+- bfd_vma val = v;
+-#endif
+-
+- switch (r_type)
+- {
+- case R_PPC_RELAX32:
+- /* Do stuff here. */
+- t0 = bfd_get_32 (abfd, hit_addr);
+- t1 = bfd_get_32 (abfd, hit_addr + 4);
+-
+- /* We're clearing the bits for R_PPC_ADDR16_HA
+- and R_PPC_ADDR16_LO here. */
+- t0 &= ~0xffff;
+- t1 &= ~0xffff;
+-
+- /* t0 is HA, t1 is lo */
+- t0 |= ((val + 0x8000) >> 16) & 0xffff;
+- t1 |= val & 0xffff;
+-
+- bfd_put_32 (abfd, t0, hit_addr);
+- bfd_put_32 (abfd, t1, hit_addr + 4);
+- break;
+-
+- case R_PPC_REL24:
+- t0 = bfd_get_32 (abfd, hit_addr);
+- t0 &= ~0x3fffffc;
+- t0 |= val & 0x3fffffc;
+- bfd_put_32 (abfd, t0, hit_addr);
+- break;
+-
+- case R_PPC_REL14:
+- case R_PPC_REL14_BRTAKEN:
+- case R_PPC_REL14_BRNTAKEN:
+- t0 = bfd_get_32 (abfd, hit_addr);
+- t0 &= ~0xfffc;
+- t0 |= val & 0xfffc;
+- bfd_put_32 (abfd, t0, hit_addr);
+- break;
+-
+- case R_PPC_LOCAL24PC:
+- case R_PPC_PLTREL24:
+- t0 = bfd_get_32 (abfd, hit_addr);
+- t0 &= ~0x3fffffc;
+- t0 |= val & 0x3fffffc;
+- bfd_put_32 (abfd, t0, hit_addr);
+- break;
+-
+- default:
+- return bfd_reloc_notsupported;
+- }
++#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
+
+- return bfd_reloc_ok;
+-}
+-
+-static const bfd_byte shared_stub_entry[] =
++static const int shared_stub_entry[] =
+ {
+- 0x48, 0x00, 0x00, 0x24, /* b .+36 */
+- 0x7c, 0x08, 0x02, 0xa6, /* mflr 0 */
+- 0x42, 0x9f, 0x00, 0x05, /* bcl 20, 31, .Lxxx */
+- 0x7d, 0x68, 0x02, 0xa6, /* mflr 11 */
+- 0x3d, 0x60, 0x00, 0x00, /* addis 11, 11, (xxx-.Lxxx)@ha */
+- 0x39, 0x6b, 0x00, 0x18, /* addi 11, 11, (xxx-.Lxxx)@l */
+- 0x7c, 0x08, 0x03, 0xa6, /* mtlr 0 */
+- 0x7d, 0x69, 0x03, 0xa6, /* mtctr 11 */
+- 0x4e, 0x80, 0x04, 0x20, /* bctr */
++ 0x7c0802a6, /* mflr 0 */
++ 0x429f0005, /* bcl 20, 31, .Lxxx */
++ 0x7d6802a6, /* mflr 11 */
++ 0x3d6b0000, /* addis 11, 11, (xxx-.Lxxx)@ha */
++ 0x396b0018, /* addi 11, 11, (xxx-.Lxxx)@l */
++ 0x7c0803a6, /* mtlr 0 */
++ 0x7d6903a6, /* mtctr 11 */
++ 0x4e800420, /* bctr */
+ };
+
+-static const bfd_byte stub_entry[] =
++static const int stub_entry[] =
+ {
+- 0x48, 0x00, 0x00, 0x14, /* b .+20 */
+- 0x3d, 0x60, 0x00, 0x00, /* lis 11,xxx@ha */
+- 0x39, 0x6b, 0x00, 0x00, /* addi 11,11,xxx@l */
+- 0x7d, 0x69, 0x03, 0xa6, /* mtctr 11 */
+- 0x4e, 0x80, 0x04, 0x20, /* bctr */
++ 0x3d600000, /* lis 11,xxx@ha */
++ 0x396b0000, /* addi 11,11,xxx@l */
++ 0x7d6903a6, /* mtctr 11 */
++ 0x4e800420, /* bctr */
+ };
+
+
+@@ -1721,9 +1671,9 @@
+ Elf_Internal_Rela *internal_relocs = NULL;
+ Elf_Internal_Rela *irel, *irelend;
+ struct one_fixup *fixups = NULL;
+- bfd_boolean changed_contents = FALSE;
+- bfd_boolean changed_relocs = FALSE;
++ bfd_boolean changed;
+ struct ppc_elf_link_hash_table *ppc_info;
++ bfd_size_type trampoff;
+
+ *again = FALSE;
+
+@@ -1738,6 +1688,10 @@
+ if (isec->_cooked_size == 0)
+ isec->_cooked_size = isec->_raw_size;
+
++ trampoff = (isec->_cooked_size + 3) & (bfd_vma) -4;
++ /* Space for a branch around any trampolines. */
++ trampoff += 4;
++
+ symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+
+ /* Get a copy of the native relocations. */
+@@ -1767,21 +1721,26 @@
+ for (irel = internal_relocs; irel < irelend; irel++)
+ {
+ unsigned long r_type = ELF32_R_TYPE (irel->r_info);
+- bfd_vma symaddr, reladdr, trampoff, toff, roff;
++ bfd_vma symaddr, reladdr, toff, roff;
+ asection *tsec;
+- bfd_size_type amt;
+ struct one_fixup *f;
+ size_t insn_offset = 0;
+- bfd_vma max_branch_offset;
++ bfd_vma max_branch_offset, val;
++ bfd_byte *hit_addr;
++ unsigned long t0;
+
+ switch (r_type)
+ {
+ case R_PPC_REL24:
+ case R_PPC_LOCAL24PC:
++ case R_PPC_PLTREL24:
++ max_branch_offset = 1 << 25;
++ break;
++
+ case R_PPC_REL14:
+ case R_PPC_REL14_BRTAKEN:
+ case R_PPC_REL14_BRNTAKEN:
+- case R_PPC_PLTREL24:
++ max_branch_offset = 1 << 15;
+ break;
+
+ default:
+@@ -1819,7 +1778,7 @@
+ }
+ else
+ {
+- /* Need dynamic symbol handling. */
++ /* Global symbol handling. */
+ unsigned long indx;
+ struct elf_link_hash_entry *h;
+
+@@ -1830,62 +1789,34 @@
+ || h->root.type == bfd_link_hash_warning)
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+- if (r_type == R_PPC_PLTREL24)
++ if (r_type == R_PPC_PLTREL24
++ && ppc_info->plt != NULL
++ && h->plt.offset != (bfd_vma) -1)
+ {
+- Elf_Internal_Sym *isym;
+-
+- if (h->plt.offset == (bfd_vma) -1
+- || ppc_info->plt == NULL)
+- {
+-
+- /* Read this BFD's local symbols. */
+- if (isymbuf == NULL)
+- {
+- isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+- if (isymbuf == NULL)
+- isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
+- symtab_hdr->sh_info, 0,
+- NULL, NULL, NULL);
+- if (isymbuf == 0)
+- goto error_return;
+- }
+- isym = isymbuf + ELF32_R_SYM (irel->r_info);
+-
+- if (isym->st_shndx == SHN_UNDEF)
+- /* We can't do anthing with undefined symbols. */
+- continue;
+- else if (isym->st_shndx == SHN_ABS)
+- tsec = bfd_abs_section_ptr;
+- else if (isym->st_shndx == SHN_COMMON)
+- tsec = bfd_com_section_ptr;
+- else
+- tsec = h->root.u.def.section;
+-
+- toff = h->root.u.def.value;
+- }
+- else
+- {
+- tsec = ppc_info->plt;
+- toff = h->plt.offset;
+- }
++ tsec = ppc_info->plt;
++ toff = h->plt.offset;
+ }
+- else if (h->root.type == bfd_link_hash_undefined
+- || h->root.type == bfd_link_hash_undefweak)
+- continue;
+-
+- else
++ else if (h->root.type == bfd_link_hash_defined
++ || h->root.type == bfd_link_hash_defweak)
+ {
+ tsec = h->root.u.def.section;
+ toff = h->root.u.def.value;
+ }
++ else
++ continue;
+ }
+
++ /* If the branch and target are in the same section, you have
++ no hope of adding stubs. We'll error out later should the
++ branch overflow. */
++ if (tsec == isec)
++ continue;
++
++ toff += irel->r_addend;
+ if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
+ toff = _bfd_merged_section_offset (abfd, &tsec,
+ elf_section_data (tsec)->sec_info,
+- toff + irel->r_addend, 0);
+- else
+- toff += irel->r_addend;
++ toff, 0);
+
+ symaddr = tsec->output_section->vma + tsec->output_offset + toff;
+
+@@ -1893,22 +1824,10 @@
+
+ reladdr = (isec->output_section->vma
+ + isec->output_offset
+- + roff) & (bfd_vma) -4;
++ + roff);
+
+ /* If the branch is in range, no need to do anything. */
+- max_branch_offset = 1 << 25;
+- if (r_type != R_PPC_REL24
+- && r_type != R_PPC_LOCAL24PC
+- && r_type != R_PPC_PLTREL24)
+- max_branch_offset = 1 << 15;
+-
+- if ((bfd_vma) (symaddr - reladdr) + max_branch_offset
+- <= 2 * max_branch_offset)
+- continue;
+-
+- /* If the branch and target are in the same section, you have
+- no hope. We'll error out later. */
+- if (tsec == isec)
++ if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset)
+ continue;
+
+ /* Look for an existing fixup to this address. */
+@@ -1919,40 +1838,31 @@
+ if (f == NULL)
+ {
+ size_t size;
++ unsigned long stub_rtype;
+
+- if (link_info->shared
+- || tsec == ppc_info->plt
+- || r_type == R_PPC_LOCAL24PC)
++ val = trampoff - roff;
++ if (val >= max_branch_offset)
++ /* Oh dear, we can't reach a trampoline. Don't try to add
++ one. We'll report an error later. */
++ continue;
++
++ if (link_info->shared)
+ {
+- size = sizeof (shared_stub_entry);
+- insn_offset = 16;
++ size = 4 * ARRAY_SIZE (shared_stub_entry);
++ insn_offset = 12;
++ stub_rtype = R_PPC_RELAX32PC;
+ }
+ else
+ {
+- size = sizeof (stub_entry);
+- insn_offset = 4;
++ size = 4 * ARRAY_SIZE (stub_entry);
++ insn_offset = 0;
++ stub_rtype = R_PPC_RELAX32;
+ }
+
+- /* Resize the current section to make room for the new branch. */
+- trampoff = (isec->_cooked_size + 3) & (bfd_vma) - 4;
+- amt = trampoff + size;
+- contents = bfd_realloc (contents, amt);
+- if (contents == NULL)
+- abort ();
+-
+- isec->_cooked_size = amt;
+-
+- if (link_info->shared
+- || tsec == ppc_info->plt
+- || r_type == R_PPC_LOCAL24PC)
+- memcpy (contents + trampoff, shared_stub_entry, size);
+- else
+- memcpy (contents + trampoff, stub_entry, size);
+-
+ /* Hijack the old relocation. Since we need two
+ relocations for this use a "composite" reloc. */
+ irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+- R_PPC_RELAX32);
++ stub_rtype);
+ irel->r_offset = trampoff + insn_offset;
+
+ /* Record the fixup so we don't do it again this section. */
+@@ -1962,31 +1872,95 @@
+ f->toff = toff;
+ f->trampoff = trampoff;
+ fixups = f;
++
++ trampoff += size;
+ }
+ else
+ {
++ val = f->trampoff - roff;
++ if (val >= max_branch_offset)
++ continue;
++
+ /* Nop out the reloc, since we're finalizing things here. */
+ irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
+ }
+
+- /* Fix up the existing branch to hit the trampoline. Hope like
+- hell this doesn't overflow too. */
+- if (ppc_elf_install_value (abfd, contents + roff,
+- f->trampoff - (roff & (bfd_vma) -3) + 4,
+- r_type) != bfd_reloc_ok)
+- abort ();
++ /* Fix up the existing branch to hit the trampoline. */
++ hit_addr = contents + roff;
++ switch (r_type)
++ {
++ case R_PPC_REL24:
++ case R_PPC_LOCAL24PC:
++ case R_PPC_PLTREL24:
++ t0 = bfd_get_32 (abfd, hit_addr);
++ t0 &= ~0x3fffffc;
++ t0 |= val & 0x3fffffc;
++ bfd_put_32 (abfd, t0, hit_addr);
++ break;
+
+- changed_contents = TRUE;
+- changed_relocs = TRUE;
++ case R_PPC_REL14:
++ case R_PPC_REL14_BRTAKEN:
++ case R_PPC_REL14_BRNTAKEN:
++ t0 = bfd_get_32 (abfd, hit_addr);
++ t0 &= ~0xfffc;
++ t0 |= val & 0xfffc;
++ bfd_put_32 (abfd, t0, hit_addr);
++ break;
++ }
+ }
+
+- /* Clean up. */
+- while (fixups)
++ /* Write out the trampolines. */
++ changed = fixups != NULL;
++ if (fixups != NULL)
+ {
+- struct one_fixup *f = fixups;
+- fixups = fixups->next;
+- free (f);
++ const int *stub;
++ bfd_byte *dest;
++ bfd_vma val;
++ int i, size;
++
++ do
++ {
++ struct one_fixup *f = fixups;
++ fixups = fixups->next;
++ free (f);
++ }
++ while (fixups);
++
++ contents = bfd_realloc (contents, trampoff);
++ if (contents == NULL)
++ goto error_return;
++
++ isec->_cooked_size = (isec->_cooked_size + 3) & (bfd_vma) -4;
++ /* Branch around the trampolines. */
++ val = trampoff - isec->_cooked_size + 0x48000000;
++ dest = contents + isec->_cooked_size;
++ isec->_cooked_size = trampoff;
++ bfd_put_32 (abfd, val, dest);
++ dest += 4;
++
++ if (link_info->shared)
++ {
++ stub = shared_stub_entry;
++ size = ARRAY_SIZE (shared_stub_entry);
++ }
++ else
++ {
++ stub = stub_entry;
++ size = ARRAY_SIZE (stub_entry);
++ }
++
++ i = 0;
++ while (dest < contents + trampoff)
++ {
++ bfd_put_32 (abfd, stub[i], dest);
++ i++;
++ if (i == size)
++ i = 0;
++ dest += 4;
++ }
++ BFD_ASSERT (i == 0);
+ }
++
+ if (isymbuf != NULL
+ && symtab_hdr->contents != (unsigned char *) isymbuf)
+ {
+@@ -2002,7 +1976,7 @@
+ if (contents != NULL
+ && elf_section_data (isec)->this_hdr.contents != contents)
+ {
+- if (!changed_contents && !link_info->keep_memory)
++ if (!changed && !link_info->keep_memory)
+ free (contents);
+ else
+ {
+@@ -2013,13 +1987,13 @@
+
+ if (elf_section_data (isec)->relocs != internal_relocs)
+ {
+- if (!changed_relocs)
++ if (!changed)
+ free (internal_relocs);
+ else
+ elf_section_data (isec)->relocs = internal_relocs;
+ }
+
+- *again = changed_contents || changed_relocs;
++ *again = changed;
+ return TRUE;
+
+ error_return:
+@@ -4727,7 +4701,7 @@
+ sec = local_sections[r_symndx];
+ sym_name = bfd_elf_local_sym_name (input_bfd, sym);
+
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+@@ -5454,45 +5428,33 @@
+ }
+ break;
+
++ case R_PPC_RELAX32PC:
++ relocation -= (input_section->output_section->vma
++ + input_section->output_offset
++ + rel->r_offset - 4);
++ /* Fall thru */
+ case R_PPC_RELAX32:
+ {
+- unsigned long r_symndx;
+- Elf_Internal_Sym *sym;
+- asection *sym_sec;
+- bfd_byte *hit_addr = 0;
+- bfd_vma value = 0;
++ unsigned long t0;
++ unsigned long t1;
+
+- r_symndx = ELF32_R_SYM (rel->r_info);
+-
+- if (r_symndx < symtab_hdr->sh_info)
+- {
+- sym = local_syms + r_symndx;
+- sym_sec = local_sections[r_symndx];
+-
+- value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
+- }
+- else
+- {
+- bfd_boolean warned;
+- bfd_boolean unresolved_reloc;
++ t0 = bfd_get_32 (output_bfd, contents + rel->r_offset);
++ t1 = bfd_get_32 (output_bfd, contents + rel->r_offset + 4);
+
+- RELOC_FOR_GLOBAL_SYMBOL (h, elf_sym_hashes (input_bfd),
+- r_symndx, symtab_hdr,
+- value, sym_sec,
+- unresolved_reloc, info,
+- warned);
+- if (warned)
+- continue;
+- }
+- hit_addr = contents + rel->r_offset;
+- value += rel->r_addend;
++ /* We're clearing the bits for R_PPC_ADDR16_HA
++ and R_PPC_ADDR16_LO here. */
++ t0 &= ~0xffff;
++ t1 &= ~0xffff;
++
++ /* t0 is HA, t1 is LO */
++ relocation += addend;
++ t0 |= ((relocation + 0x8000) >> 16) & 0xffff;
++ t1 |= relocation & 0xffff;
+
+- r = ppc_elf_install_value (output_bfd, hit_addr, value, r_type);
+- if (r != bfd_reloc_ok)
+- break;
+- else
+- continue;
++ bfd_put_32 (output_bfd, t0, contents + rel->r_offset);
++ bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4);
+ }
++ continue;
+
+ /* Indirect .sdata relocation. */
+ case R_PPC_EMB_SDAI16:
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-s390.c binutils-2.14.90.0.7/bfd/elf32-s390.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-s390.c 2003-11-07 00:11:15.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-s390.c 2003-11-07 00:21:16.000000000 +0100
+@@ -2325,7 +2325,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-sh.c binutils-2.14.90.0.7/bfd/elf32-sh.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-sh.c 2003-11-07 00:11:14.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-sh.c 2003-11-07 00:21:16.000000000 +0100
+@@ -4805,7 +4805,7 @@
+ }
+ else if (! howto->partial_inplace)
+ {
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ addend = rel->r_addend;
+ }
+ else if ((sec->flags & SEC_MERGE)
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-sparc.c binutils-2.14.90.0.7/bfd/elf32-sparc.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-sparc.c 2003-11-07 00:11:25.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-sparc.c 2003-11-07 00:21:16.000000000 +0100
+@@ -2460,16 +2460,8 @@
+
+ if (is_plt)
+ sec = htab->splt;
+- else if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-v850.c binutils-2.14.90.0.7/bfd/elf32-v850.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-v850.c 2003-11-07 00:11:24.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-v850.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1681,7 +1681,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ #if 0
+ {
+ char * name;
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-vax.c binutils-2.14.90.0.7/bfd/elf32-vax.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-vax.c 2003-11-07 00:11:13.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-vax.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1483,7 +1483,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+@@ -1737,16 +1737,7 @@
+ {
+ long indx;
+
+- if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-xstormy16.c binutils-2.14.90.0.7/bfd/elf32-xstormy16.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-xstormy16.c 2003-11-07 00:11:15.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-xstormy16.c 2003-11-07 00:21:16.000000000 +0100
+@@ -845,7 +845,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf32-xtensa.c binutils-2.14.90.0.7/bfd/elf32-xtensa.c
+--- binutils-2.14.90.0.7.orig/bfd/elf32-xtensa.c 2003-11-07 00:11:17.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf32-xtensa.c 2003-11-07 00:21:16.000000000 +0100
+@@ -2004,7 +2004,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-alpha.c binutils-2.14.90.0.7/bfd/elf64-alpha.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-alpha.c 2003-11-07 00:11:16.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-alpha.c 2003-11-07 00:21:16.000000000 +0100
+@@ -4394,9 +4394,11 @@
+
+ if (r_symndx < symtab_hdr->sh_info)
+ {
++ asection *msec;
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ msec = sec;
++ value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
+
+ /* If this is a tp-relative relocation against sym 0,
+ this is hackery from relax_section. Force the value to
+@@ -4424,7 +4426,6 @@
+ && !gotent->reloc_xlated)
+ {
+ struct alpha_elf_got_entry *ent;
+- asection *msec;
+
+ for (ent = gotent; ent; ent = ent->next)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-mmix.c binutils-2.14.90.0.7/bfd/elf64-mmix.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-mmix.c 2003-11-07 00:11:14.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-mmix.c 2003-11-07 00:21:16.000000000 +0100
+@@ -1472,7 +1472,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections [r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+
+ name = bfd_elf_string_from_elf_section
+ (input_bfd, symtab_hdr->sh_link, sym->st_name);
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-ppc.c binutils-2.14.90.0.7/bfd/elf64-ppc.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-ppc.c 2003-11-07 00:11:18.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-ppc.c 2003-11-07 00:21:17.000000000 +0100
+@@ -7385,7 +7385,7 @@
+ sec = local_sections[r_symndx];
+ sym_name = bfd_elf_local_sym_name (input_bfd, sym);
+ sym_type = ELF64_ST_TYPE (sym->st_info);
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ if (elf_section_data (sec) != NULL)
+ {
+ long *opd_sym_adjust;
+@@ -8178,7 +8178,9 @@
+ relocation = TOCstart;
+ if (r_symndx == 0)
+ relocation += htab->stub_group[input_section->id].toc_off;
+- else if (sec != NULL && !unresolved_reloc)
++ else if (unresolved_reloc)
++ ;
++ else if (sec != NULL && sec->id <= htab->top_id)
+ relocation += htab->stub_group[sec->id].toc_off;
+ else
+ unresolved_reloc = TRUE;
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-s390.c binutils-2.14.90.0.7/bfd/elf64-s390.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-s390.c 2003-11-07 00:11:16.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-s390.c 2003-11-07 00:21:17.000000000 +0100
+@@ -2295,7 +2295,7 @@
+ {
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-sh64.c binutils-2.14.90.0.7/bfd/elf64-sh64.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-sh64.c 2003-11-07 00:11:21.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-sh64.c 2003-11-07 00:21:17.000000000 +0100
+@@ -1582,7 +1582,7 @@
+ }
+ else if (! howto->partial_inplace)
+ {
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
+ }
+ else if ((sec->flags & SEC_MERGE)
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-sparc.c binutils-2.14.90.0.7/bfd/elf64-sparc.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-sparc.c 2003-11-07 00:11:24.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-sparc.c 2003-11-07 00:26:02.000000000 +0100
+@@ -2071,7 +2071,7 @@
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+ orig_addend = rel->r_addend;
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+@@ -2248,16 +2248,8 @@
+
+ if (is_plt)
+ sec = splt;
+- else if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++
++ if (bfd_is_abs_section (sec))
+ indx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elf64-x86-64.c binutils-2.14.90.0.7/bfd/elf64-x86-64.c
+--- binutils-2.14.90.0.7.orig/bfd/elf64-x86-64.c 2003-11-07 00:11:23.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elf64-x86-64.c 2003-11-07 00:21:17.000000000 +0100
+@@ -1823,7 +1823,7 @@
+ sym = local_syms + r_symndx;
+ sec = local_sections[r_symndx];
+
+- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
++ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
+ }
+ else
+ {
+@@ -2048,16 +2048,7 @@
+ {
+ long sindx;
+
+- if (h == NULL)
+- sec = local_sections[r_symndx];
+- else
+- {
+- BFD_ASSERT (h->root.type == bfd_link_hash_defined
+- || (h->root.type
+- == bfd_link_hash_defweak));
+- sec = h->root.u.def.section;
+- }
+- if (sec != NULL && bfd_is_abs_section (sec))
++ if (bfd_is_abs_section (sec))
+ sindx = 0;
+ else if (sec == NULL || sec->owner == NULL)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/bfd/elfxx-ia64.c binutils-2.14.90.0.7/bfd/elfxx-ia64.c
+--- binutils-2.14.90.0.7.orig/bfd/elfxx-ia64.c 2003-11-07 00:11:25.000000000 +0100
++++ binutils-2.14.90.0.7/bfd/elfxx-ia64.c 2003-11-07 00:21:17.000000000 +0100
+@@ -3848,9 +3848,11 @@
+ if (r_symndx < symtab_hdr->sh_info)
+ {
+ /* Reloc against local symbol. */
++ asection *msec;
+ sym = local_syms + r_symndx;
+ sym_sec = local_sections[r_symndx];
+- value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
++ msec = sym_sec;
++ value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
+ if ((sym_sec->flags & SEC_MERGE)
+ && ELF_ST_TYPE (sym->st_info) == STT_SECTION
+ && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
+@@ -3861,7 +3863,6 @@
+ if (loc_h && ! loc_h->sec_merge_done)
+ {
+ struct elfNN_ia64_dyn_sym_info *dynent;
+- asection *msec;
+
+ for (dynent = loc_h->info; dynent; dynent = dynent->next)
+ {
+diff -ruN binutils-2.14.90.0.7.orig/include/elf/ppc.h binutils-2.14.90.0.7/include/elf/ppc.h
+--- binutils-2.14.90.0.7.orig/include/elf/ppc.h 2003-11-07 00:10:33.000000000 +0100
++++ binutils-2.14.90.0.7/include/elf/ppc.h 2003-11-07 00:26:52.000000000 +0100
+@@ -120,9 +120,10 @@
+ RELOC_NUMBER (R_PPC_EMB_BIT_FLD, 115)
+ RELOC_NUMBER (R_PPC_EMB_RELSDA, 116)
+
+-/* Fake relocation for branch stubs. This will keep them
++/* Fake relocations for branch stubs. This will keep them
+ together. */
+ #define R_PPC_RELAX32 251
++#define R_PPC_RELAX32PC 252
+
+ /* These are GNU extensions to enable C++ vtable garbage collection. */
+ RELOC_NUMBER (R_PPC_GNU_VTINHERIT, 253)
diff --git a/sys-devel/binutils/files/digest-binutils-2.14.90.0.7-r1 b/sys-devel/binutils/files/digest-binutils-2.14.90.0.7-r1
new file mode 100644
index 000000000000..07f652ab2119
--- /dev/null
+++ b/sys-devel/binutils/files/digest-binutils-2.14.90.0.7-r1
@@ -0,0 +1 @@
+MD5 b5b1608f7308c487c0f3af8e4592a71a binutils-2.14.90.0.7.tar.bz2 10575077