* config.bfd: Add powerpc64 target. Add powerpc64 vectors to

	targ64_selvecs for 32 bit powerpc targets.
	* Makefile.am (BFD64_BACKENDS): Add elf64-ppc.lo.
	(BFD64_BACKENDS_CFILES): Add elf64-ppc.c.
	Run "make dep-am".
	* Makefile.in: Regenerate.
	* configure.in: Add elf64_powerpc vecs.
	* configure: Regenerate.
	* cpu-powerpc.c: Default to bfd_mach_ppc_620 entry for 64 bit.
	* elf.c (prep_headers): EM_PPC64 for 64 bit ppc elf target.
	* targets.c: Add bfd_elf64_powerpc_vec and bfd_elf64_powerpcle_vec.
	* elf64-ppc.c: New file.
	* reloc.c: Add powerpc64 relocs.
	* libbfd.h: Regenerate.
	* bfd-in2.h: Regenerate.

13 files changed, 3965 insertions, 34 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 960c2b5..72c921e 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,24 @@
+2001-08-27  Linus Nordberg  <linus@swox.se>
+	    Torbjorn Granlund  <tege@swox.com>
+	    Staffan Ulfberg  <staffanu@swox.se>
+	    Alan Modra  <amodra@bigpond.net.au>
+
+	* config.bfd: Add powerpc64 target.  Add powerpc64 vectors to
+	targ64_selvecs for 32 bit powerpc targets.
+	* Makefile.am (BFD64_BACKENDS): Add elf64-ppc.lo.
+	(BFD64_BACKENDS_CFILES): Add elf64-ppc.c.
+	Run "make dep-am".
+	* Makefile.in: Regenerate.
+	* configure.in: Add elf64_powerpc vecs.
+	* configure: Regenerate.
+	* cpu-powerpc.c: Default to bfd_mach_ppc_620 entry for 64 bit.
+	* elf.c (prep_headers): EM_PPC64 for 64 bit ppc elf target.
+	* targets.c: Add bfd_elf64_powerpc_vec and bfd_elf64_powerpcle_vec.
+	* elf64-ppc.c: New file.
+	* reloc.c: Add powerpc64 relocs.
+	* libbfd.h: Regenerate.
+	* bfd-in2.h: Regenerate.
+
 2001-08-27  Andreas Schwab  <schwab@suse.de>
 
 	* elf32-m68k.c (elf32_m68k_check_relocs): Set DF_TEXTREL if the
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index 94a2225..cbd5d8b 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -426,6 +426,7 @@ BFD64_BACKENDS = \
 	elf64-ia64.lo \
 	elf64-gen.lo \
 	elf64-mips.lo \
+	elf64-ppc.lo \
 	elf64-s390.lo \
 	elf64-sparc.lo \
 	elf64.lo \
@@ -444,6 +445,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-hppa.c \
 	elf64-gen.c \
 	elf64-mips.c \
+	elf64-ppc.c \
 	elf64-s390.c \
 	elf64-sparc.c \
 	elf64.c \
@@ -919,9 +921,9 @@ coff-rs6000.lo: coff-rs6000.c $(INCDIR)/filenames.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/coff/internal.h $(INCDIR)/coff/xcoff.h \
   $(INCDIR)/coff/rs6000.h libcoff.h libxcoff.h coffcode.h \
   coffswap.h
-coff-sh.lo: coff-sh.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
-  $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
-  libcoff.h coffcode.h coffswap.h
+coff-sh.lo: coff-sh.c $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
+  $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h \
+  $(INCDIR)/coff/internal.h libcoff.h coffcode.h coffswap.h
 coff-sparc.lo: coff-sparc.c $(INCDIR)/filenames.h $(INCDIR)/coff/sparc.h \
   $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
   libcoff.h $(INCDIR)/bfdlink.h coffcode.h coffswap.h
@@ -1097,7 +1099,7 @@ elf32-sparc.lo: elf32-sparc.c $(INCDIR)/filenames.h \
 elf32-v850.lo: elf32-v850.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/v850.h $(INCDIR)/elf/reloc-macros.h \
-  elf32-target.h
+  $(INCDIR)/libiberty.h elf32-target.h
 elf32.lo: elf32.c elfcode.h $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
   $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
   $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h elfcore.h \
@@ -1230,14 +1232,15 @@ pei-ppc.lo: pei-ppc.c $(INCDIR)/filenames.h coff-ppc.c \
   $(INCDIR)/coff/powerpc.h $(INCDIR)/coff/external.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/pe.h libcoff.h \
   $(INCDIR)/bfdlink.h coffcode.h peicode.h libpei.h
-pe-sh.lo: pe-sh.c $(INCDIR)/filenames.h coff-sh.c $(INCDIR)/bfdlink.h \
-  $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
-  $(INCDIR)/coff/pe.h libcoff.h coffcode.h peicode.h \
-  libpei.h
-pei-sh.lo: pei-sh.c $(INCDIR)/filenames.h coff-sh.c \
+pe-sh.lo: pe-sh.c $(INCDIR)/filenames.h coff-sh.c $(INCDIR)/libiberty.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/pe.h libcoff.h \
   coffcode.h peicode.h libpei.h
+pei-sh.lo: pei-sh.c $(INCDIR)/filenames.h coff-sh.c \
+  $(INCDIR)/libiberty.h $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h \
+  $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
+  $(INCDIR)/coff/pe.h libcoff.h coffcode.h peicode.h \
+  libpei.h
 pe-mips.lo: pe-mips.c $(INCDIR)/filenames.h $(INCDIR)/coff/mipspe.h \
   $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
   $(INCDIR)/coff/pe.h libcoff.h $(INCDIR)/bfdlink.h coffcode.h \
@@ -1327,6 +1330,10 @@ elf64-mips.lo: elf64-mips.c $(INCDIR)/filenames.h $(INCDIR)/aout/ar.h \
   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/ecoff.h $(INCDIR)/coff/alpha.h \
   ecoffswap.h elf64-target.h
+elf64-ppc.lo: elf64-ppc.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
+  elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+  $(INCDIR)/elf/external.h $(INCDIR)/elf/ppc.h $(INCDIR)/elf/reloc-macros.h \
+  elf64-target.h
 elf64-s390.lo: elf64-s390.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/s390.h $(INCDIR)/elf/reloc-macros.h \
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index 82e5594..226caff 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -114,6 +114,7 @@ WIN32LDFLAGS = @WIN32LDFLAGS@
 WIN32LIBADD = @WIN32LIBADD@
 all_backends = @all_backends@
 bfd_backends = @bfd_backends@
+bfd_default_target_size = @bfd_default_target_size@
 bfd_machines = @bfd_machines@
 l = @l@
 tdefaults = @tdefaults@
@@ -551,6 +552,7 @@ BFD64_BACKENDS = \
 	elf64-ia64.lo \
 	elf64-gen.lo \
 	elf64-mips.lo \
+	elf64-ppc.lo \
 	elf64-s390.lo \
 	elf64-sparc.lo \
 	elf64.lo \
@@ -570,6 +572,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-hppa.c \
 	elf64-gen.c \
 	elf64-mips.c \
+	elf64-ppc.c \
 	elf64-s390.c \
 	elf64-sparc.c \
 	elf64.c \
@@ -1457,9 +1460,9 @@ coff-rs6000.lo: coff-rs6000.c $(INCDIR)/filenames.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/coff/internal.h $(INCDIR)/coff/xcoff.h \
   $(INCDIR)/coff/rs6000.h libcoff.h libxcoff.h coffcode.h \
   coffswap.h
-coff-sh.lo: coff-sh.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
-  $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
-  libcoff.h coffcode.h coffswap.h
+coff-sh.lo: coff-sh.c $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
+  $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h \
+  $(INCDIR)/coff/internal.h libcoff.h coffcode.h coffswap.h
 coff-sparc.lo: coff-sparc.c $(INCDIR)/filenames.h $(INCDIR)/coff/sparc.h \
   $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
   libcoff.h $(INCDIR)/bfdlink.h coffcode.h coffswap.h
@@ -1635,7 +1638,7 @@ elf32-sparc.lo: elf32-sparc.c $(INCDIR)/filenames.h \
 elf32-v850.lo: elf32-v850.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/v850.h $(INCDIR)/elf/reloc-macros.h \
-  elf32-target.h
+  $(INCDIR)/libiberty.h elf32-target.h
 elf32.lo: elf32.c elfcode.h $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
   $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
   $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h elfcore.h \
@@ -1768,14 +1771,15 @@ pei-ppc.lo: pei-ppc.c $(INCDIR)/filenames.h coff-ppc.c \
   $(INCDIR)/coff/powerpc.h $(INCDIR)/coff/external.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/pe.h libcoff.h \
   $(INCDIR)/bfdlink.h coffcode.h peicode.h libpei.h
-pe-sh.lo: pe-sh.c $(INCDIR)/filenames.h coff-sh.c $(INCDIR)/bfdlink.h \
-  $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
-  $(INCDIR)/coff/pe.h libcoff.h coffcode.h peicode.h \
-  libpei.h
-pei-sh.lo: pei-sh.c $(INCDIR)/filenames.h coff-sh.c \
+pe-sh.lo: pe-sh.c $(INCDIR)/filenames.h coff-sh.c $(INCDIR)/libiberty.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h $(INCDIR)/coff/external.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/pe.h libcoff.h \
   coffcode.h peicode.h libpei.h
+pei-sh.lo: pei-sh.c $(INCDIR)/filenames.h coff-sh.c \
+  $(INCDIR)/libiberty.h $(INCDIR)/bfdlink.h $(INCDIR)/coff/sh.h \
+  $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
+  $(INCDIR)/coff/pe.h libcoff.h coffcode.h peicode.h \
+  libpei.h
 pe-mips.lo: pe-mips.c $(INCDIR)/filenames.h $(INCDIR)/coff/mipspe.h \
   $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \
   $(INCDIR)/coff/pe.h libcoff.h $(INCDIR)/bfdlink.h coffcode.h \
@@ -1865,6 +1869,10 @@ elf64-mips.lo: elf64-mips.c $(INCDIR)/filenames.h $(INCDIR)/aout/ar.h \
   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/ecoff.h $(INCDIR)/coff/alpha.h \
   ecoffswap.h elf64-target.h
+elf64-ppc.lo: elf64-ppc.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
+  elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+  $(INCDIR)/elf/external.h $(INCDIR)/elf/ppc.h $(INCDIR)/elf/reloc-macros.h \
+  elf64-target.h
 elf64-s390.lo: elf64-s390.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/s390.h $(INCDIR)/elf/reloc-macros.h \
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index 64c995c..63298c3 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -1870,10 +1870,12 @@ The 24-bit relocation is used in some Intel 960 configurations. */
   BFD_RELOC_HI16_GOTOFF,
   BFD_RELOC_HI16_S_GOTOFF,
   BFD_RELOC_8_GOTOFF,
+  BFD_RELOC_64_PLT_PCREL,
   BFD_RELOC_32_PLT_PCREL,
   BFD_RELOC_24_PLT_PCREL,
   BFD_RELOC_16_PLT_PCREL,
   BFD_RELOC_8_PLT_PCREL,
+  BFD_RELOC_64_PLTOFF,
   BFD_RELOC_32_PLTOFF,
   BFD_RELOC_16_PLTOFF,
   BFD_RELOC_LO16_PLTOFF,
@@ -2183,6 +2185,29 @@ to compensate for the borrow when the low bits are added. */
   BFD_RELOC_PPC_EMB_RELST_HA,
   BFD_RELOC_PPC_EMB_BIT_FLD,
   BFD_RELOC_PPC_EMB_RELSDA,
+  BFD_RELOC_PPC64_HIGHER,
+  BFD_RELOC_PPC64_HIGHER_S,
+  BFD_RELOC_PPC64_HIGHEST,
+  BFD_RELOC_PPC64_HIGHEST_S,
+  BFD_RELOC_PPC64_TOC16_LO,
+  BFD_RELOC_PPC64_TOC16_HI,
+  BFD_RELOC_PPC64_TOC16_HA,
+  BFD_RELOC_PPC64_TOC,
+  BFD_RELOC_PPC64_PLTGOT16   ,
+  BFD_RELOC_PPC64_PLTGOT16_LO,
+  BFD_RELOC_PPC64_PLTGOT16_HI,
+  BFD_RELOC_PPC64_PLTGOT16_HA,
+  BFD_RELOC_PPC64_ADDR16_DS,
+  BFD_RELOC_PPC64_ADDR16_LO_DS,
+  BFD_RELOC_PPC64_GOT16_DS,
+  BFD_RELOC_PPC64_GOT16_LO_DS,
+  BFD_RELOC_PPC64_PLT16_LO_DS,
+  BFD_RELOC_PPC64_SECTOFF_DS,
+  BFD_RELOC_PPC64_SECTOFF_LO_DS,
+  BFD_RELOC_PPC64_TOC16_DS,
+  BFD_RELOC_PPC64_TOC16_LO_DS,
+  BFD_RELOC_PPC64_PLTGOT16_DS,
+  BFD_RELOC_PPC64_PLTGOT16_LO_DS,
 
 /* IBM 370/390 relocations */
   BFD_RELOC_I370_D12,
diff --git a/bfd/config.bfd b/bfd/config.bfd
index dce8bb3..b00c06a 100644
--- a/bfd/config.bfd
+++ b/bfd/config.bfd
@@ -734,12 +734,21 @@ case "${targ}" in
     targ_defvec=rs6000coff64_vec
     targ_selvecs="rs6000coff_vec"
     ;;
+  powerpc64-*-elf* | powerpc-*-elf64* | powerpc64-*-linux*)
+    targ_defvec=bfd_elf64_powerpc_vec
+    targ_selvecs="bfd_elf64_powerpcle_vec bfd_elf32_powerpc_vec bfd_elf32_powerpcle_vec rs6000coff_vec rs6000coff64_vec"
+    ;;
+  powerpc64le-*-elf* | powerpcle-*-elf64*)
+    targ_defvec=bfd_elf64_powerpcle_vec
+    targ_selvecs="bfd_elf64_powerpc_vec bfd_elf32_powerpcle_vec bfd_elf32_powerpc_vec rs6000coff_vec rs6000coff64_vec"
+    ;;
 #endif
   powerpc-*-*bsd* | powerpc-*-elf* | powerpc-*-sysv4* | powerpc-*-eabi* | \
   powerpc-*-solaris2* | powerpc-*-linux-gnu* | powerpc-*-rtems* | \
   powerpc-*-chorus* | powerpc-*-vxworks*)
     targ_defvec=bfd_elf32_powerpc_vec
     targ_selvecs="rs6000coff_vec bfd_elf32_powerpcle_vec ppcboot_vec"
+    targ64_selvecs="bfd_elf64_powerpc_vec bfd_elf64_powerpcle_vec"
     ;;
   powerpc-*-macos* | powerpc-*-mpw*)
     targ_defvec=pmac_xcoff_vec
@@ -753,6 +762,7 @@ case "${targ}" in
   powerpcle-*-rtems*)
     targ_defvec=bfd_elf32_powerpcle_vec
     targ_selvecs="rs6000coff_vec bfd_elf32_powerpc_vec ppcboot_vec"
+    targ64_selvecs="bfd_elf64_powerpc_vec bfd_elf64_powerpcle_vec"
     ;;
 
   powerpcle-*-pe | powerpcle-*-winnt* | powerpcle-*-cygwin*)
diff --git a/bfd/configure b/bfd/configure
index 40b8c11..b76f700 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -5979,6 +5979,10 @@ do
     bfd_elf32_pjl_vec)          tb="$tb elf32-pj.lo elf32.lo $elf";;
     bfd_elf32_powerpc_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
     bfd_elf32_powerpcle_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
+    bfd_elf64_powerpc_vec)	tb="$tb elf64-ppc.lo elf64-gen.lo elf64.lo $elf"
+				target_size=64 ;;
+    bfd_elf64_powerpcle_vec)	tb="$tb elf64-ppc.lo elf64-gen.lo elf64.lo $elf"
+				target_size=64 ;;
     bfd_elf32_s390_vec)		tb="$tb elf32-s390.lo elf32.lo $elf" ;;
     bfd_elf32_sh_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shl_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
@@ -6192,17 +6196,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:6196: checking for $ac_hdr" >&5
+echo "configure:6200: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6201 "configure"
+#line 6205 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6206: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6210: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -6231,12 +6235,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6235: checking for $ac_func" >&5
+echo "configure:6239: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6240 "configure"
+#line 6244 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6259,7 +6263,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6263: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6267: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -6284,7 +6288,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:6288: checking for working mmap" >&5
+echo "configure:6292: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -6292,7 +6296,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 6296 "configure"
+#line 6300 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -6432,7 +6436,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:6436: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6440: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -6457,12 +6461,12 @@ fi
 for ac_func in madvise mprotect
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6461: checking for $ac_func" >&5
+echo "configure:6465: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6466 "configure"
+#line 6470 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6485,7 +6489,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6489: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6493: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
diff --git a/bfd/configure.in b/bfd/configure.in
index 5840f33..57f4b41 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -552,6 +552,10 @@ do
     bfd_elf32_pjl_vec)          tb="$tb elf32-pj.lo elf32.lo $elf";;
     bfd_elf32_powerpc_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
     bfd_elf32_powerpcle_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
+    bfd_elf64_powerpc_vec)	tb="$tb elf64-ppc.lo elf64-gen.lo elf64.lo $elf"
+				target_size=64 ;;
+    bfd_elf64_powerpcle_vec)	tb="$tb elf64-ppc.lo elf64-gen.lo elf64.lo $elf"
+				target_size=64 ;;
     bfd_elf32_s390_vec)		tb="$tb elf32-s390.lo elf32.lo $elf" ;;
     bfd_elf32_sh_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shl_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
diff --git a/bfd/cpu-powerpc.c b/bfd/cpu-powerpc.c
index 235ec29..3e7a51c 100644
--- a/bfd/cpu-powerpc.c
+++ b/bfd/cpu-powerpc.c
@@ -1,5 +1,5 @@
 /* BFD PowerPC CPU definition
-   Copyright 1994, 1995, 1996, 2000 Free Software Foundation, Inc.
+   Copyright 1994, 1995, 1996, 2000, 2001 Free Software Foundation, Inc.
    Contributed by Ian Lance Taylor, Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -128,7 +128,7 @@ static const bfd_arch_info_type arch_info_struct[] =
     "powerpc",
     "powerpc:620",
     3,
-    false, /* not the default */
+    BFD_DEFAULT_TARGET_SIZE == 64, /* default for 64 bit target */
     powerpc_compatible,
     bfd_default_scan,
     &arch_info_struct[6]
@@ -229,7 +229,7 @@ const bfd_arch_info_type bfd_powerpc_arch =
     "powerpc",
     "powerpc:common",
     3,
-    true, /* the default */
+    BFD_DEFAULT_TARGET_SIZE != 64, /* default for 32 bit target */
     powerpc_compatible,
     bfd_default_scan,
     &arch_info_struct[0]
diff --git a/bfd/elf.c b/bfd/elf.c
index f8cc2ee..4e6d6ef 100644
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -3393,7 +3393,10 @@ prep_headers (abfd)
       i_ehdrp->e_machine = EM_PARISC;
       break;
     case bfd_arch_powerpc:
-      i_ehdrp->e_machine = EM_PPC;
+      if (bed->s->arch_size == 64)
+	i_ehdrp->e_machine = EM_PPC64;
+      else
+	i_ehdrp->e_machine = EM_PPC;
       break;
     case bfd_arch_alpha:
       i_ehdrp->e_machine = EM_ALPHA;
diff --git a/bfd/elf64-ppc.c b/bfd/elf64-ppc.c
new file mode 100644
index 0000000..3a98bc1
--- /dev/null
+++ b/bfd/elf64-ppc.c
@@ -0,0 +1,3768 @@
+/* PowerPC64-specific support for 64-bit ELF.
+   Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+   Written by Linus Nordberg, Swox AB <info@swox.com>,
+   based on elf32-ppc.c by Ian Lance Taylor.
+
+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.  */
+
+/* This file is based on the 64-bit PowerPC ELF ABI.  It is also based
+   on the file elf32-ppc.c.  */
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "elf/ppc.h"
+
+#define USE_RELA		/* we want RELA relocations, not REL.  */
+
+
+static void ppc_howto_init
+  PARAMS ((void));
+static reloc_howto_type *ppc64_elf_reloc_type_lookup
+  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
+static void ppc64_elf_info_to_howto
+  PARAMS ((bfd *abfd, arelent *cache_ptr, Elf64_Internal_Rela *dst));
+static bfd_reloc_status_type ppc64_elf_addr16_ha_reloc
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static boolean ppc64_elf_set_private_flags
+  PARAMS ((bfd *, flagword));
+static boolean ppc64_elf_copy_private_bfd_data
+  PARAMS ((bfd *, bfd *));
+static boolean ppc64_elf_merge_private_bfd_data
+  PARAMS ((bfd *, bfd *));
+static boolean ppc64_elf_section_from_shdr
+  PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
+static boolean ppc64_elf_create_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean ppc64_elf_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
+static asection * ppc64_elf_gc_mark_hook
+  PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Rela *rel,
+	   struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
+static boolean ppc64_elf_gc_sweep_hook
+  PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
+	   const Elf_Internal_Rela *relocs));
+static boolean ppc64_elf_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static boolean ppc_adjust_dynindx
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static boolean ppc64_elf_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean ppc64_elf_final_link
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean ppc64_elf_fake_sections
+  PARAMS ((bfd *, Elf64_Internal_Shdr *, asection *));
+static boolean ppc64_elf_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
+	   Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
+	   asection **));
+static boolean ppc64_elf_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+	   Elf_Internal_Sym *));
+static boolean ppc64_elf_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+
+
+/* Branch prediction bit for branch taken relocs.  */
+#define BRANCH_PREDICT_BIT 0x200000
+
+/* Mask to set RA in memory instructions.  */
+#define RA_REGISTER_MASK 0x001f0000
+
+/* Value to shift register by to insert RA.  */
+#define RA_REGISTER_SHIFT 16
+
+/* 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 24
+
+/* The initial size of the plt reserved for the dynamic linker.  */
+#define PLT_INITIAL_ENTRY_SIZE 96
+
+/* TOC base pointers offset from start of TOC.  */
+#define TOC_BASE_OFF (0x8000)
+
+/* Global linkage stub.  The first instruction has its offset patched.  */
+/* FIXME: Need traceback table?  */
+static const unsigned int ppc64_elf_glink_code[] = {
+  0xe9820000,			/* ld    %r12,0(%r2) */
+  0xf8410028,			/* std   %r2,40(%r1) */
+  0xe80c0000,			/* ld    %r0,0(%r12) */
+  0xe84c0008,			/* ld    %r2,8(%r12) */
+  0x7c0903a6,			/* mtctr %r0         */
+  0x4e800420			/* bctr              */
+};
+
+#define PPC64_ELF_GLINK_SIZE \
+  ((sizeof ppc64_elf_glink_code / sizeof ppc64_elf_glink_code[0]) * 4)
+
+/* Relocation HOWTO's.  */
+static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC_max];
+
+static reloc_howto_type ppc64_elf_howto_raw[] = {
+  /* This reloc does nothing.  */
+  HOWTO (R_PPC64_NONE,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_NONE",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A standard 32 bit relocation.  */
+  HOWTO (R_PPC64_ADDR32,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* An absolute 26 bit branch; the lower two bits must be zero.
+     FIXME: we don't check that, we just clear them.  */
+  HOWTO (R_PPC64_ADDR24,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 26,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR24",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A standard 16 bit relocation.  */
+  HOWTO (R_PPC64_ADDR16,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 16 bit relocation without overflow.  */
+  HOWTO (R_PPC64_ADDR16_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont,/* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Bits 16-31 of an address.  */
+  HOWTO (R_PPC64_ADDR16_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Bits 16-31 of an address, plus 1 if the contents of the low 16
+     bits, treated as a signed number, is negative.  */
+  HOWTO (R_PPC64_ADDR16_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_ADDR16_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* An absolute 16 bit branch; the lower two bits must be zero.
+     FIXME: we don't check that, we just clear them.  */
+  HOWTO (R_PPC64_ADDR14,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR14",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* An absolute 16 bit branch, for which bit 10 should be set to
+     indicate that the branch is expected to be taken.  The lower two
+     bits must be zero.  */
+  HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR14_BRTAKEN",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* An absolute 16 bit branch, for which bit 10 should be set to
+     indicate that the branch is not expected to be taken.  The lower
+     two bits must be zero.  */
+  HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR14_BRNTAKEN",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A relative 26 bit branch; the lower two bits must be zero.  */
+  HOWTO (R_PPC64_REL24,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 26,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL24",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffffc,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* A relative 16 bit branch; the lower two bits must be zero.  */
+  HOWTO (R_PPC64_REL14,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL14",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
+     the branch is expected to be taken.  The lower two bits must be
+     zero.  */
+  HOWTO (R_PPC64_REL14_BRTAKEN,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL14_BRTAKEN", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
+     the branch is not expected to be taken.  The lower two bits must
+     be zero.  */
+  HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL14_BRNTAKEN",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
+     symbol.  */
+  HOWTO (R_PPC64_GOT16,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_GOT16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_GOT16_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_GOT16_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_GOT16_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont,/* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_GOT16_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_GOT16_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont,/* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_GOT16_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* This is used only by the dynamic linker.  The symbol should exist
+     both in the object being run and in some shared library.  The
+     dynamic linker copies the data addressed by the symbol from the
+     shared library into the object, because the object being
+     run has to have the data at some particular address.  */
+  HOWTO (R_PPC64_COPY,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	 /* special_function */
+	 "R_PPC64_COPY",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR64, but used when setting global offset table
+     entries.  */
+  HOWTO (R_PPC64_GLOB_DAT,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	 /* special_function */
+	 "R_PPC64_GLOB_DAT",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Created by the link editor.  Marks a procedure linkage table
+     entry for a symbol.  */
+  HOWTO (R_PPC64_JMP_SLOT,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_JMP_SLOT",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used only by the dynamic linker.  When the object is run, this
+     doubleword64 is set to the load address of the object, plus the
+     addend.  */
+  HOWTO (R_PPC64_RELATIVE,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_RELATIVE",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR32, but may be unaligned.  */
+  HOWTO (R_PPC64_UADDR32,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_UADDR32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16, but may be unaligned.  */
+  HOWTO (R_PPC64_UADDR16,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_UADDR16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32-bit PC relative.  */
+  HOWTO (R_PPC64_REL32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 /* FIXME: Verify.  Was complain_overflow_bitfield. */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 32-bit relocation to the symbol's procedure linkage table.
+     FIXME: R_PPC64_PLT32 not supported.  */
+  HOWTO (R_PPC64_PLT32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLT32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32-bit PC relative relocation to the symbol's procedure linkage table.
+     FIXME: R_PPC64_PLTREL32 not supported.  */
+  HOWTO (R_PPC64_PLTREL32,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTREL32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_PLT16_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLT16_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_PLT16_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLT16_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
+     the symbol.  */
+  HOWTO (R_PPC64_PLT16_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_PLT16_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32-bit section relative relocation.  */
+  /* FIXME: Verify R_PPC64_SECTOFF.  Seems strange with size=2 and
+     dst_mask=0.  */
+  HOWTO (R_PPC64_SECTOFF,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_SECTOFF",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 16-bit lower half section relative relocation.  */
+  HOWTO (R_PPC64_SECTOFF_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_SECTOFF_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16-bit upper half section relative relocation.  */
+  HOWTO (R_PPC64_SECTOFF_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_SECTOFF_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16-bit upper half adjusted section relative relocation.  */
+  HOWTO (R_PPC64_SECTOFF_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_SECTOFF_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_REL24 without touching the two least significant
+     bits.  */
+  /* FIXME: Verify R_PPC64_ADDR30.  */
+  HOWTO (R_PPC64_ADDR30,	/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 30,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* special_function */
+	 "R_PPC64_ADDR30",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffffffc,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
+
+  /* A standard 64-bit relocation.  */
+  HOWTO (R_PPC64_ADDR64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* The bits 32-47 of an address.  */
+  HOWTO (R_PPC64_ADDR16_HIGHER,	/* type */
+	 32,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_HIGHER", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* The bits 32-47 of an address, plus 1 if the contents of the low
+     16 bits, treated as a signed number, is negative.  */
+  HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
+	 32,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_ADDR16_HIGHERA", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* The bits 48-63 of an address.  */
+  HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
+	 48,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_HIGHEST", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* The bits 48-63 of an address, plus 1 if the contents of the low
+     16 bits, treated as a signed number, is negative.  */
+  HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
+	 48,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_ADDR16_HIGHESTA", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like ADDR64, but may be unaligned.  */
+  HOWTO (R_PPC64_UADDR64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_UADDR64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 64-bit relative relocation.  */
+  HOWTO (R_PPC64_REL64,		/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_REL64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 64-bit relocation to the symbol's procedure linkage table. */
+  /* FIXME: R_PPC64_PLT64 not supported.  */
+  HOWTO (R_PPC64_PLT64,		/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLT64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 64-bit PC relative relocation to the symbol's procedure linkage
+     table.  */
+  /* FIXME: R_PPC64_PLTREL64 not supported.  */
+  HOWTO (R_PPC64_PLTREL64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTREL64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 16 bit TOC-relative relocation.  */
+
+  /* R_PPC64_TOC16	  47	   half16*	S + A - .TOC.  */
+  HOWTO (R_PPC64_TOC16,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16 bit TOC-relative relocation without overflow.  */
+
+  /* R_PPC64_TOC16_LO	  48	   half16	 #lo (S + A - .TOC.)  */
+  HOWTO (R_PPC64_TOC16_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC16_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16 bit TOC-relative relocation, high 16 bits.  */
+
+  /* R_PPC64_TOC16_HI	  49	   half16	 #hi (S + A - .TOC.)  */
+  HOWTO (R_PPC64_TOC16_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC16_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
+     contents of the low 16 bits, treated as a signed number, is
+     negative.  */
+
+  /* R_PPC64_TOC16_HA	  50	   half16	 #ha (S + A - .TOC.)  */
+  HOWTO (R_PPC64_TOC16_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_TOC16_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 64-bit relocation; insert value of TOC base (.TOC.).  */
+
+  /* R_PPC64_TOC		  51	   doubleword64	 .TOC.  */
+  HOWTO (R_PPC64_TOC,		/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0=byte, 1=short, 2=long, 4=64 bits) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffffffffffffffff,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_GOT16, but also informs the link editor that the
+     value to relocate may (!) refer to a PLT entry which the link
+     editor (a) may replace with the symbol value.  If the link editor
+     is unable to fully resolve the symbol, it may (b) create a PLT
+     entry and store the address to the new PLT entry in the GOT.
+     This permits lazy resolution of function symbols at run time.
+     The link editor may also skip all of this and just (c) emit a
+     R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
+  /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
+    HOWTO (R_PPC64_PLTGOT16,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTGOT16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLTGOT16, but without overflow.  */
+  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
+  HOWTO (R_PPC64_PLTGOT16_LO,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTGOT16_LO",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
+  /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
+  HOWTO (R_PPC64_PLTGOT16_HI,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTGOT16_HI",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
+     1 if the contents of the low 16 bits, treated as a signed number,
+     is negative.  */
+  /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
+  HOWTO (R_PPC64_PLTGOT16_HA,	/* type */
+	 16,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont,/* complain_on_overflow */
+	 ppc64_elf_addr16_ha_reloc, /* special_function */
+	 "R_PPC64_PLTGOT16_HA",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_ADDR16_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_ADDR16_LO_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont,/* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_ADDR16_LO_DS",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_GOT16_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_GOT16_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_GOT16_LO_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_GOT16_LO_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_PLT16_LO_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLT16_LO_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
+  /* FIXME: Verify R_PPC64_SECTOFF.  Seems strange with size=2 and
+     dst_mask=0.  */
+  HOWTO (R_PPC64_SECTOFF_DS,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_SECTOFF_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_SECTOFF_LO_DS",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_TOC16_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC16_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
+  HOWTO (R_PPC64_TOC16_LO_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_TOC16_LO_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
+  /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
+    HOWTO (R_PPC64_PLTGOT16_DS,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTGOT16_DS",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
+  /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
+  HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_PPC64_PLTGOT16_LO_DS",/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfffc,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* GNU extension to record C++ vtable hierarchy.  */
+  HOWTO (R_PPC64_GNU_VTINHERIT,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 NULL,			/* special_function */
+	 "R_PPC64_GNU_VTINHERIT", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* GNU extension to record C++ vtable member usage.  */
+  HOWTO (R_PPC64_GNU_VTENTRY,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 NULL,			/* special_function */
+	 "R_PPC64_GNU_VTENTRY",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+};
+
+
+/* Initialize the ppc64_elf_howto_table, so that linear accesses can
+   be done.  */
+
+static void
+ppc_howto_init ()
+{
+  unsigned int i, type;
+
+  for (i = 0;
+       i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
+       i++)
+    {
+      type = ppc64_elf_howto_raw[i].type;
+      BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
+			  / sizeof (ppc64_elf_howto_table[0])));
+      ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
+    }
+}
+
+static reloc_howto_type *
+ppc64_elf_reloc_type_lookup (abfd, code)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
+
+  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
+    /* Initialize howto table if needed.  */
+    ppc_howto_init ();
+
+  switch ((int) code)
+    {
+    default:
+      return (reloc_howto_type *) NULL;
+
+    case BFD_RELOC_NONE:		 ppc_reloc = R_PPC64_NONE;
+      break;
+    case BFD_RELOC_32:			 ppc_reloc = R_PPC64_ADDR32;
+      break;
+    case BFD_RELOC_PPC_BA26:		 ppc_reloc = R_PPC64_ADDR24;
+      break;
+    case BFD_RELOC_16:			 ppc_reloc = R_PPC64_ADDR16;
+      break;
+    case BFD_RELOC_LO16:		 ppc_reloc = R_PPC64_ADDR16_LO;
+      break;
+    case BFD_RELOC_HI16:		 ppc_reloc = R_PPC64_ADDR16_HI;
+      break;
+    case BFD_RELOC_HI16_S:		 ppc_reloc = R_PPC64_ADDR16_HA;
+      break;
+    case BFD_RELOC_PPC_BA16:		 ppc_reloc = R_PPC64_ADDR14;
+      break;
+    case BFD_RELOC_PPC_BA16_BRTAKEN:	 ppc_reloc = R_PPC64_ADDR14_BRTAKEN;
+      break;
+    case BFD_RELOC_PPC_BA16_BRNTAKEN:	 ppc_reloc = R_PPC64_ADDR14_BRNTAKEN;
+      break;
+    case BFD_RELOC_PPC_B26:		 ppc_reloc = R_PPC64_REL24;
+      break;
+    case BFD_RELOC_PPC_B16:		 ppc_reloc = R_PPC64_REL14;
+      break;
+    case BFD_RELOC_PPC_B16_BRTAKEN:	 ppc_reloc = R_PPC64_REL14_BRTAKEN;
+      break;
+    case BFD_RELOC_PPC_B16_BRNTAKEN:	 ppc_reloc = R_PPC64_REL14_BRNTAKEN;
+      break;
+    case BFD_RELOC_16_GOTOFF:		 ppc_reloc = R_PPC64_GOT16;
+      break;
+    case BFD_RELOC_LO16_GOTOFF:		 ppc_reloc = R_PPC64_GOT16_LO;
+      break;
+    case BFD_RELOC_HI16_GOTOFF:		 ppc_reloc = R_PPC64_GOT16_HI;
+      break;
+    case BFD_RELOC_HI16_S_GOTOFF:	 ppc_reloc = R_PPC64_GOT16_HA;
+      break;
+    case BFD_RELOC_PPC_COPY:		 ppc_reloc = R_PPC64_COPY;
+      break;
+    case BFD_RELOC_PPC_GLOB_DAT:	 ppc_reloc = R_PPC64_GLOB_DAT;
+      break;
+    case BFD_RELOC_32_PCREL:		 ppc_reloc = R_PPC64_REL32;
+      break;
+    case BFD_RELOC_32_PLTOFF:		 ppc_reloc = R_PPC64_PLT32;
+      break;
+    case BFD_RELOC_32_PLT_PCREL:	 ppc_reloc = R_PPC64_PLTREL32;
+      break;
+    case BFD_RELOC_LO16_PLTOFF:		 ppc_reloc = R_PPC64_PLT16_LO;
+      break;
+    case BFD_RELOC_HI16_PLTOFF:		 ppc_reloc = R_PPC64_PLT16_HI;
+      break;
+    case BFD_RELOC_HI16_S_PLTOFF:	 ppc_reloc = R_PPC64_PLT16_HA;
+      break;
+    case BFD_RELOC_32_BASEREL:		 ppc_reloc = R_PPC64_SECTOFF;
+      break;
+    case BFD_RELOC_LO16_BASEREL:	 ppc_reloc = R_PPC64_SECTOFF_LO;
+      break;
+    case BFD_RELOC_HI16_BASEREL:	 ppc_reloc = R_PPC64_SECTOFF_HI;
+      break;
+    case BFD_RELOC_HI16_S_BASEREL:	 ppc_reloc = R_PPC64_SECTOFF_HA;
+      break;
+      /* FIXME: Is CTOR 32 or 64 bits?  Fix md_apply_fix3 in
+	 gas/config/tc-ppc.c too.  */
+    case BFD_RELOC_CTOR:		 ppc_reloc = R_PPC64_ADDR32;
+      break;
+    case BFD_RELOC_64:			 ppc_reloc = R_PPC64_ADDR64;
+      break;
+    case BFD_RELOC_PPC64_HIGHER:	 ppc_reloc = R_PPC64_ADDR16_HIGHER;
+      break;
+    case BFD_RELOC_PPC64_HIGHER_S:	 ppc_reloc = R_PPC64_ADDR16_HIGHERA;
+      break;
+    case BFD_RELOC_PPC64_HIGHEST:	 ppc_reloc = R_PPC64_ADDR16_HIGHEST;
+      break;
+    case BFD_RELOC_PPC64_HIGHEST_S:	 ppc_reloc = R_PPC64_ADDR16_HIGHESTA;
+      break;
+    case BFD_RELOC_64_PCREL:		 ppc_reloc = R_PPC64_REL64;
+      break;
+    case BFD_RELOC_64_PLTOFF:		 ppc_reloc = R_PPC64_PLT64;
+      break;
+    case BFD_RELOC_64_PLT_PCREL:	 ppc_reloc = R_PPC64_PLTREL64;
+      break;
+    case BFD_RELOC_PPC_TOC16:		 ppc_reloc = R_PPC64_TOC16;
+      break;
+    case BFD_RELOC_PPC64_TOC16_LO:	 ppc_reloc = R_PPC64_TOC16_LO;
+      break;
+    case BFD_RELOC_PPC64_TOC16_HI:	 ppc_reloc = R_PPC64_TOC16_HI;
+      break;
+    case BFD_RELOC_PPC64_TOC16_HA:	 ppc_reloc = R_PPC64_TOC16_HA;
+      break;
+    case BFD_RELOC_PPC64_TOC:		 ppc_reloc = R_PPC64_TOC;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16:	 ppc_reloc = R_PPC64_PLTGOT16;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16_LO:	 ppc_reloc = R_PPC64_PLTGOT16_LO;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16_HI:	 ppc_reloc = R_PPC64_PLTGOT16_HI;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16_HA:	 ppc_reloc = R_PPC64_PLTGOT16_HA;
+      break;
+    case BFD_RELOC_PPC64_ADDR16_DS:      ppc_reloc = R_PPC64_ADDR16_DS;
+      break;
+    case BFD_RELOC_PPC64_ADDR16_LO_DS:   ppc_reloc = R_PPC64_ADDR16_LO_DS;
+      break;
+    case BFD_RELOC_PPC64_GOT16_DS:       ppc_reloc = R_PPC64_GOT16_DS;
+      break;
+    case BFD_RELOC_PPC64_GOT16_LO_DS:    ppc_reloc = R_PPC64_GOT16_LO_DS;
+      break;
+    case BFD_RELOC_PPC64_PLT16_LO_DS:    ppc_reloc = R_PPC64_PLT16_LO_DS;
+      break;
+    case BFD_RELOC_PPC64_SECTOFF_DS:     ppc_reloc = R_PPC64_SECTOFF_DS;
+      break;
+    case BFD_RELOC_PPC64_SECTOFF_LO_DS:  ppc_reloc = R_PPC64_SECTOFF_LO_DS;
+      break;
+    case BFD_RELOC_PPC64_TOC16_DS:       ppc_reloc = R_PPC64_TOC16_DS;
+      break;
+    case BFD_RELOC_PPC64_TOC16_LO_DS:    ppc_reloc = R_PPC64_TOC16_LO_DS;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16_DS:    ppc_reloc = R_PPC64_PLTGOT16_DS;
+      break;
+    case BFD_RELOC_PPC64_PLTGOT16_LO_DS: ppc_reloc = R_PPC64_PLTGOT16_LO_DS;
+      break;
+    case BFD_RELOC_VTABLE_INHERIT:	 ppc_reloc = R_PPC64_GNU_VTINHERIT;
+      break;
+    case BFD_RELOC_VTABLE_ENTRY:	 ppc_reloc = R_PPC64_GNU_VTENTRY;
+      break;
+    }
+
+  return ppc64_elf_howto_table[(int) ppc_reloc];
+};
+
+/* Set the howto pointer for a PowerPC ELF reloc.  */
+
+static void
+ppc64_elf_info_to_howto (abfd, cache_ptr, dst)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *cache_ptr;
+     Elf64_Internal_Rela *dst;
+{
+  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
+    /* Initialize howto table if needed.  */
+    ppc_howto_init ();
+
+  BFD_ASSERT (ELF64_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
+  cache_ptr->howto = ppc64_elf_howto_table[ELF64_R_TYPE (dst->r_info)];
+}
+
+/* Handle the R_PPC_ADDR16_HA reloc.  */
+
+static bfd_reloc_status_type
+ppc64_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
+			   output_bfd, error_message)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *reloc_entry;
+     asymbol *symbol;
+     PTR data ATTRIBUTE_UNUSED;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message ATTRIBUTE_UNUSED;
+{
+  bfd_vma relocation;
+
+  if (output_bfd != NULL)
+    {
+      reloc_entry->address += input_section->output_offset;
+      return bfd_reloc_ok;
+    }
+
+  if (reloc_entry->address > input_section->_cooked_size)
+    return bfd_reloc_outofrange;
+
+  if (bfd_is_com_section (symbol->section))
+    relocation = 0;
+  else
+    relocation = symbol->value;
+
+  relocation += symbol->section->output_section->vma;
+  relocation += symbol->section->output_offset;
+  relocation += reloc_entry->addend;
+
+  reloc_entry->addend += (relocation & 0x8000) << 1;
+
+  return bfd_reloc_continue;
+}
+
+/* Function to set whether a module needs the -mrelocatable bit set.  */
+
+static boolean
+ppc64_elf_set_private_flags (abfd, flags)
+     bfd *abfd;
+     flagword flags;
+{
+  BFD_ASSERT (!elf_flags_init (abfd)
+	      || elf_elfheader (abfd)->e_flags == flags);
+
+  elf_elfheader (abfd)->e_flags = flags;
+  elf_flags_init (abfd) = true;
+  return true;
+}
+
+/* Copy backend specific data from one object module to another.  */
+static boolean
+ppc64_elf_copy_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return true;
+
+  BFD_ASSERT (!elf_flags_init (obfd)
+	      || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
+
+  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
+  elf_flags_init (obfd) = true;
+  return true;
+}
+
+/* Merge backend specific data from an object file to the output
+   object file when linking.  */
+static boolean
+ppc64_elf_merge_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  flagword old_flags;
+  flagword new_flags;
+  boolean error;
+
+  /* Check if we have the same endianess.  */
+  if (ibfd->xvec->byteorder != obfd->xvec->byteorder
+      && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
+    {
+      const char *msg;
+
+      if (bfd_big_endian (ibfd))
+	msg = _("%s: compiled for a big endian system and target is little endian");
+      else
+	msg = _("%s: compiled for a little endian system and target is big endian");
+
+      (*_bfd_error_handler) (msg, bfd_get_filename (ibfd));
+
+      bfd_set_error (bfd_error_wrong_format);
+      return false;
+    }
+
+  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return true;
+
+  new_flags = elf_elfheader (ibfd)->e_flags;
+  old_flags = elf_elfheader (obfd)->e_flags;
+  if (!elf_flags_init (obfd))
+    {
+      /* First call, no flags set.  */
+      elf_flags_init (obfd) = true;
+      elf_elfheader (obfd)->e_flags = new_flags;
+    }
+
+  else if (new_flags == old_flags)
+    /* Compatible flags are ok.  */
+    ;
+
+  else
+    {
+      /* Incompatible flags.  Warn about -mrelocatable mismatch.
+	 Allow -mrelocatable-lib to be linked with either.  */
+      error = false;
+      if ((new_flags & EF_PPC_RELOCATABLE) != 0
+	  && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
+	{
+	  error = true;
+	  (*_bfd_error_handler)
+	    (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
+	     bfd_get_filename (ibfd));
+	}
+      else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
+	       && (old_flags & EF_PPC_RELOCATABLE) != 0)
+	{
+	  error = true;
+	  (*_bfd_error_handler)
+	    (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
+	     bfd_get_filename (ibfd));
+	}
+
+      /* The output is -mrelocatable-lib iff both the input files are.  */
+      if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
+	elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
+
+      /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
+         but each input file is either -mrelocatable or -mrelocatable-lib.  */
+      if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
+	  && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
+	  && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
+	elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
+
+      /* Do not warn about eabi vs. V.4 mismatch, just or in the bit
+	 if any module uses it.  */
+      elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
+
+      new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
+      old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
+
+      /* Warn about any other mismatches.  */
+      if (new_flags != old_flags)
+	{
+	  error = true;
+	  (*_bfd_error_handler)
+	    (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
+	     bfd_get_filename (ibfd), (long) new_flags, (long) old_flags);
+	}
+
+      if (error)
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+    }
+
+  return true;
+}
+
+/* Handle a PowerPC specific section when reading an object file.  This
+   is called when elfcode.h finds a section with an unknown type.  */
+
+static boolean
+ppc64_elf_section_from_shdr (abfd, hdr, name)
+     bfd *abfd;
+     Elf64_Internal_Shdr *hdr;
+     char *name;
+{
+  asection *newsect;
+  flagword flags;
+
+  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
+    return false;
+
+  newsect = hdr->bfd_section;
+  flags = bfd_get_section_flags (abfd, newsect);
+  if (hdr->sh_flags & SHF_EXCLUDE)
+    flags |= SEC_EXCLUDE;
+
+  if (hdr->sh_type == SHT_ORDERED)
+    flags |= SEC_SORT_ENTRIES;
+
+  bfd_set_section_flags (abfd, newsect, flags);
+  return true;
+}
+
+/* The following routines are specific to the ELF linker, while
+   routines above are used generally.  They appear in this file more
+   or less in the order in which they are called from external
+   routines.  eg. ppc64_elf_check_relocs is called early in the link
+   process, ppc64_elf_finish_dynamic_sections is one of the last
+   functions called.  */
+
+/* Create the .glink section as well as the ordinary dynamic
+   sections.  */
+
+static boolean
+ppc64_elf_create_dynamic_sections (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  asection *s;
+  flagword flags;
+
+  if (!_bfd_elf_create_dynamic_sections (abfd, info))
+    return false;
+
+  /* Our .plt just contains pointers, no code.  */
+  s = bfd_get_section_by_name (abfd, ".plt");
+  if (s == NULL)
+    return false;
+  flags = bfd_get_section_flags (abfd, s);
+  flags &= ~SEC_CODE;
+  if (! bfd_set_section_flags (abfd, s, flags))
+    return false;
+
+  /* Create .glink for global linkage functions.  */
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
+	   | SEC_LINKER_CREATED);
+  s = bfd_make_section (abfd, ".glink");
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, flags)
+      || ! bfd_set_section_alignment (abfd, s, 3))
+    return false;
+
+  return true;
+}
+
+/* Look through the relocs for a section during the first phase, and
+   allocate space in the global offset table or procedure linkage
+   table.  */
+
+static boolean
+ppc64_elf_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+  bfd_signed_vma *local_got_refcounts;
+  asection *sreloc;
+  asection *sgot = NULL;
+  asection *srelgot = NULL;
+
+  if (info->relocateable)
+    return true;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_check_relocs called for section %s in %s\n",
+	   bfd_get_section_name (abfd, sec),
+	   bfd_get_filename (abfd));
+#endif
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  sym_hashes = elf_sym_hashes (abfd);
+  sym_hashes_end = (sym_hashes
+		    + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
+  if (!elf_bad_symtab (abfd))
+    sym_hashes_end -= symtab_hdr->sh_info;
+
+  sreloc = NULL;
+
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      unsigned long r_symndx;
+      struct elf_link_hash_entry *h;
+
+      r_symndx = ELF64_R_SYM (rel->r_info);
+      if (r_symndx < symtab_hdr->sh_info)
+	h = NULL;
+      else
+	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+      switch (ELF64_R_TYPE (rel->r_info))
+	{
+	  /* GOT16 relocations */
+	case R_PPC64_GOT16:
+	case R_PPC64_GOT16_LO:
+	case R_PPC64_GOT16_HI:
+	case R_PPC64_GOT16_HA:
+	case R_PPC64_GOT16_DS:
+	case R_PPC64_GOT16_LO_DS:
+	  /* This symbol requires a global offset table entry.  */
+
+	  if (sgot == NULL)
+	    {
+	      if (dynobj == NULL)
+		elf_hash_table (info)->dynobj = dynobj = abfd;
+	      if (! _bfd_elf_create_got_section (dynobj, info))
+		return false;
+	      sgot = bfd_get_section_by_name (dynobj, ".got");
+	      BFD_ASSERT (sgot != NULL);
+	    }
+
+	  if (srelgot == NULL
+	      && (h != NULL || info->shared))
+	    {
+	      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+	      if (srelgot == NULL)
+		{
+		  srelgot = bfd_make_section (dynobj, ".rela.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.refcount == -1)
+		{
+		  /* Make sure this symbol is output as a dynamic symbol.  */
+		  if (h->dynindx == -1)
+		    if (!bfd_elf64_link_record_dynamic_symbol (info, h))
+		      return false;
+
+		  /* Allocate space in the .got.  */
+		  sgot->_raw_size += 8;
+		  /* Allocate relocation space.  */
+		  srelgot->_raw_size += sizeof (Elf64_External_Rela);
+
+		  h->got.refcount = 1;
+		}
+	      else
+		h->got.refcount++;
+	    }
+	  else
+	    {
+	      /* This is a global offset table entry for a local symbol.  */
+	      if (local_got_refcounts == NULL)
+		{
+		  size_t size;
+
+		  size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
+		  local_got_refcounts = (bfd_signed_vma *)
+		    bfd_alloc (abfd, size);
+		  if (local_got_refcounts == NULL)
+		    return false;
+		  elf_local_got_refcounts (abfd) = local_got_refcounts;
+		  memset (local_got_refcounts, -1, size);
+		}
+	      if (local_got_refcounts[r_symndx] == -1)
+		{
+		  sgot->_raw_size += 8;
+
+		  /* If we are generating a shared object, we need to
+                     output a R_PPC64_RELATIVE reloc so that the
+                     dynamic linker can adjust this GOT entry.  */
+		  if (info->shared)
+		    srelgot->_raw_size += sizeof (Elf64_External_Rela);
+
+		  local_got_refcounts[r_symndx] = 1;
+		}
+	      else
+		local_got_refcounts[r_symndx]++;
+	    }
+	  break;
+
+	case R_PPC64_PLT64:
+	case R_PPC64_PLT32:
+	case R_PPC64_PLT16_LO:
+	case R_PPC64_PLT16_HI:
+	case R_PPC64_PLT16_HA:
+	case R_PPC64_PLTGOT16_DS:
+	case R_PPC64_PLTGOT16_LO_DS:
+#ifdef DEBUG
+	  fprintf (stderr, "Reloc requires a PLT entry\n");
+#endif
+	  /* 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 without
+             linking in any dynamic objects, in which case we don't
+             need to generate a procedure linkage table after all.  */
+
+	  if (h == NULL)
+	    {
+	      /* It does not make sense to have a procedure linkage
+                 table entry for a local symbol.  */
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+
+	  /* Make sure this symbol is output as a dynamic symbol.  */
+	  if (h->dynindx == -1)
+	    {
+	      if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+		return false;
+	    }
+	  if (h->plt.refcount == -1)
+	    {
+	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	      h->plt.refcount = 1;
+	    }
+	  else
+	    h->plt.refcount++;
+	  break;
+
+	  /* The following relocations don't need to propagate the
+	     relocation if linking a shared object since they are
+	     section relative.  */
+	case R_PPC64_SECTOFF:
+	case R_PPC64_SECTOFF_LO:
+	case R_PPC64_SECTOFF_HI:
+	case R_PPC64_SECTOFF_HA:
+	case R_PPC64_SECTOFF_DS:
+	case R_PPC64_SECTOFF_LO_DS:
+	case R_PPC64_TOC16:
+	case R_PPC64_TOC16_LO:
+	case R_PPC64_TOC16_HI:
+	case R_PPC64_TOC16_HA:
+	case R_PPC64_TOC16_DS:
+	case R_PPC64_TOC16_LO_DS:
+	  break;
+
+	  /* This relocation describes the C++ object vtable hierarchy.
+	     Reconstruct it for later use during GC.  */
+	case R_PPC64_GNU_VTINHERIT:
+	  if (!_bfd_elf64_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_PPC64_GNU_VTENTRY:
+	  if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+	    return false;
+	  break;
+
+	  /* When creating a shared object, we must copy these
+	     relocs into the output file.  We create a reloc
+	     section in dynobj and make room for the reloc.  */
+	case R_PPC64_REL64:
+	case R_PPC64_REL32:
+	case R_PPC64_REL24:
+	case R_PPC64_REL14:
+	case R_PPC64_REL14_BRTAKEN:
+	case R_PPC64_REL14_BRNTAKEN:
+	  if (h == NULL)
+	    break;
+	  /* fall through */
+
+	case R_PPC64_TOC:
+	  /* fall through */
+
+	default:
+	  if (info->shared)
+	    {
+#ifdef DEBUG
+	      fprintf (stderr, "ppc64_elf_check_relocs need to create relocation for %s\n",
+		       (h && h->root.root.string
+			? h->root.root.string
+			: "<unknown>"));
+#endif
+	      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, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (abfd, sec),
+					 name + 5) == 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;
+		    }
+		}
+
+	      sreloc->_raw_size += sizeof (Elf64_External_Rela);
+
+	      /* FIXME: We should here do what the m68k and i386
+		 backends do: if the reloc is pc-relative, record it
+		 in case it turns out that the reloc is unnecessary
+		 because the symbol is forced local by versioning or
+		 we are linking with -Bdynamic.  Fortunately this
+		 case is not frequent.  */
+	    }
+
+	  break;
+	}
+    }
+
+  return true;
+}
+
+/* Return the section that should be marked against GC for a given
+   relocation.  */
+
+static asection *
+ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
+     bfd *abfd;
+     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 (ELF64_R_TYPE (rel->r_info))
+	{
+	case R_PPC64_GNU_VTINHERIT:
+	case R_PPC64_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
+    {
+      if (! (elf_bad_symtab (abfd)
+	     && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+	  && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+		&& sym->st_shndx != SHN_COMMON))
+	{
+	  return bfd_section_from_elf_index (abfd, sym->st_shndx);
+	}
+    }
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+
+static boolean
+ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_signed_vma *local_got_refcounts;
+  const Elf_Internal_Rela *rel, *relend;
+  unsigned long r_symndx;
+  struct elf_link_hash_entry *h;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  relend = relocs + sec->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    switch (ELF64_R_TYPE (rel->r_info))
+      {
+      case R_PPC64_GOT16:
+      case R_PPC64_GOT16_LO:
+      case R_PPC64_GOT16_HI:
+      case R_PPC64_GOT16_HA:
+	r_symndx = ELF64_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	    if (h->got.refcount > 0)
+	      h->got.refcount--;
+	  }
+	else
+	  {
+	    if (local_got_refcounts[r_symndx] > 0)
+	      local_got_refcounts[r_symndx]--;
+	  }
+        break;
+
+      case R_PPC64_PLT32:
+      case R_PPC64_PLT16_LO:
+      case R_PPC64_PLT16_HI:
+      case R_PPC64_PLT16_HA:
+	r_symndx = ELF64_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	    if (h->plt.refcount > 0)
+	      h->plt.refcount--;
+	  }
+	break;
+
+      default:
+	break;
+      }
+
+  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 boolean
+ppc64_elf_adjust_dynamic_symbol (info, h)
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+{
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+  asection *s;
+  unsigned int power_of_two;
+  bfd_vma plt_offset;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_adjust_dynamic_symbol called for %s\n",
+	   h->root.root.string);
+#endif
+
+  /* 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, alter the symbol to refer to global
+     linkage code, which will be generated by ppc64_elf_relocate_section.
+     Also, allocate a slot in the PLT.  */
+  if (h->type == STT_FUNC
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+    {
+      asection *splt, *sglink;
+
+      if (! elf_hash_table (info)->dynamic_sections_created
+	  || ((!info->shared || info->symbolic || h->dynindx == -1)
+	      && (h->elf_link_hash_flags
+		  & ELF_LINK_HASH_DEF_REGULAR) != 0))
+	{
+	  /* A PLT entry is not required/allowed when:
+
+	     1. We are not using ld.so; because then the PLT entry
+	     can't be set up, so we can't use one.
+
+	     2. We know for certain that a symbol is defined in
+	     this object, because this object is the application,
+	     is linked with -Bsymbolic, or because the symbol is local.
+
+	     We used to end up here for GC if
+	     (info->shared && h->plt.refcount <= 0)
+	     We can't use plt.refcount here since
+	     ppc64_elf_check_relocs can't detect all needs for
+	     PLT.  FIXME: Rewrite GC.  */
+
+	  h->plt.offset = (bfd_vma) -1;
+	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  return true;
+	}
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sglink = bfd_get_section_by_name (dynobj, ".glink");
+      BFD_ASSERT (splt != NULL && sglink != NULL);
+
+      /* If it's a function entry point (the name starts with a dot)
+         (FIXME: Could it ever be anything else?), find its
+         corresponding function descriptor symbol and make sure it's
+         output as a dynamic symbol.  Create it as undefined if
+         necessary.  ppc64_elf_finish_dynamic_symbol will look it up
+         again and create a JMP_SLOT reloc for it.  FIXME: The second
+         lookup could be avoided by adding a new flag to
+         elf_link_hash_entry->elf_link_hash_flags.  */
+
+      if (h->root.root.string[0] == '.')
+	{
+	  struct elf_link_hash_entry *fdh;
+
+	  /* FIXME: Follow bfd_link_hash_indirect?  */
+	  fdh = elf_link_hash_lookup (elf_hash_table (info),
+				      h->root.root.string + 1,
+				      false, false, false);
+
+	  if (fdh == (struct elf_link_hash_entry *) NULL)
+	    {
+	      asymbol *newsym;
+
+	      /* Create it as undefined.  */
+	      newsym = bfd_make_empty_symbol (dynobj);
+	      BFD_ASSERT (newsym != NULL);
+	      /* FIXME: Need own copy of name? */
+	      newsym->name = h->root.root.string + 1;
+	      newsym->section = bfd_und_section_ptr;
+	      newsym->value = 0;
+	      newsym->flags = BSF_DYNAMIC | BSF_OBJECT;
+
+	      if ( ! (_bfd_generic_link_add_one_symbol
+		      (info, dynobj, newsym->name, newsym->flags,
+		       newsym->section, newsym->value,
+		       NULL, /* string */
+		       true, /* copy */
+		       false, /*collect*/
+		       (struct bfd_link_hash_entry **) &fdh)))
+		{
+		  /* FIXME: Print error message.  */
+		  return false;
+		}
+	      fdh->root.type = bfd_link_hash_undefined;
+#ifdef DEBUG
+	      fprintf (stderr, "\tcreated %s", newsym->name);
+#endif
+	    }
+#ifdef DEBUG
+	  else
+	    fprintf (stderr, "\tfound %s", fdh->root.root.string);
+	  fprintf (stderr, "\n");
+#endif
+
+	  BFD_ASSERT (fdh != NULL);
+
+	  /* Make sure it's output as a dynamic symbol.  */
+	  if (fdh->dynindx == -1)
+	    {
+	      if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
+		return false;
+	    }
+	  BFD_ASSERT (fdh->dynindx != -1);
+	}
+
+      /* If this is the first .plt entry, make room for the special
+	 first entry.  */
+      if (splt->_raw_size == 0)
+	splt->_raw_size = PLT_INITIAL_ENTRY_SIZE;
+
+      plt_offset = splt->_raw_size;
+
+      /* FIXME: What about function pointer comparisons in 64-bit PPC?
+	 We can't use the same trick as 32-bit PPC, since we set the
+	 symbol to the linkage function. This will make function entry
+	 point comparison work as expected within one object, but not
+	 across object boundaries.  From the ABI:
+
+ In this ABI, the address of a function is actually the address of a
+ function descriptor.  A reference to a function, other than a function
+ call, will normally load the address of the function descriptor from
+ the global offset table.  The dynamic linker will ensure that for a
+ given function, the same address is used for all references to the
+ function from any global offset table.  Thus, function address
+ comparisons will work as expected.
+
+ When making a call to the function, the code may refer to the
+ procedure linkage table entry, in order to permit lazy symbol
+ resolution at run time.  In order to support correct function address
+ comparisons, the compiler should be careful to only generate
+ references to the procedure linkage table entry for function calls.
+ For any other use of a function, the compiler should use the real
+ address.
+
+	 I don't see how this could ever work when passing a pointer to
+	 a function across an object boundary.  The compiler has no
+	 way of knowing how to find the function descriptor for a
+	 function whose entrypoint is taken as an argument.
+
+	 Or should the compiler arrange so that the function descriptor
+	 address is passed and make the callee dig out the entry point
+	 from that?  */
+#if 0
+      /* 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 = splt;
+	  h->root.u.def.value = plt_offset;
+	}
+#endif
+
+      /* FIXME: How should a linkage symbol be defined?  It shouldn't
+         be global, since it can't be used by any other object than
+         this one.  Set ELF_LINK_FORCED_LOCAL?  */
+      h->root.type = bfd_link_hash_defined;
+      h->root.u.def.section = sglink;
+      h->root.u.def.value = sglink->_raw_size;
+      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+      h->plt.offset = plt_offset;
+
+      /* Make room for global linkage code in .glink.  */
+      sglink->_raw_size += PPC64_ELF_GLINK_SIZE;
+
+      /* Make room for this entry in PLT.  */
+      splt->_raw_size += PLT_ENTRY_SIZE;
+
+      /* We also need to make an entry in the .rela.plt section.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += sizeof (Elf64_External_Rela);
+
+      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_PPC_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
+     .rela.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, ".rela.bss");
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf64_External_Rela);
+      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 > 4)
+    power_of_two = 4;
+
+  /* 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;
+}
+
+/* Increment the index of a dynamic symbol by a given amount.  Called
+   via elf_link_hash_traverse.  */
+
+static boolean
+ppc_adjust_dynindx (h, cparg)
+     struct elf_link_hash_entry *h;
+     PTR cparg;
+{
+  int *cp = (int *) cparg;
+
+#ifdef DEBUG
+  fprintf (stderr,
+	   "ppc_adjust_dynindx: h->dynindx = %ld, *cp = %d (%s)\n",
+	   h->dynindx, *cp,
+	   h->root.root.string ? h->root.root.string : "<unknown>");
+#endif
+
+  if (h->dynindx != -1)
+    h->dynindx += *cp;
+
+  return true;
+}
+
+/* Set the sizes of the dynamic sections.  */
+
+static boolean
+ppc64_elf_size_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  bfd *dynobj;
+  asection *s;
+  boolean plt;
+  boolean relocs;
+  boolean reltext;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_size_dynamic_sections called\n");
+#endif
+
+  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 .rela.got section.
+	 However, if we are not creating the dynamic sections, we will
+	 not actually use these entries.  Reset the size of .rela.got
+	 which will cause it to get stripped from the output file
+	 below.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.got");
+      if (s != NULL)
+	s->_raw_size = 0;
+    }
+
+  /* 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;
+  reltext = false;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      const char *name;
+      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, ".rela", 5) == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* If we don't need this section, strip it from the
+		 output file.  This is mostly to handle .rela.bss and
+		 .rela.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
+	    {
+	      asection *target;
+	      const char *outname;
+
+	      /* Remember whether there are any relocation sections. */
+	      relocs = true;
+
+	      /* If this relocation section applies to a read only
+		 section, then we probably need a DT_TEXTREL entry.  */
+	      outname = bfd_get_section_name (output_bfd,
+					      s->output_section);
+	      target = bfd_get_section_by_name (output_bfd, outname + 5);
+	      if (target != NULL
+		  && (target->flags & SEC_READONLY) != 0
+		  && (target->flags & SEC_ALLOC) != 0)
+		reltext = 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 (strcmp (name, ".got") != 0
+	       && strcmp (name, ".toc") != 0
+	       && strcmp (name, ".glink") != 0)
+	{
+	  /* It's not one of our sections, so don't allocate space.  */
+	  continue;
+	}
+
+      if (strip)
+	{
+	  _bfd_strip_section_from_output (info, s);
+	  continue;
+	}
+
+#ifdef DEBUG
+      fprintf (stderr, "\tallocating %lu bytes for section %s\n",
+	       (unsigned long) s->_raw_size, name);
+#endif
+
+      /* 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 ppc64_elf_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.  */
+      if (! info->shared)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
+	    return false;
+	}
+
+      if (plt)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
+	    return false;
+	}
+
+      if (relocs)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
+						sizeof (Elf64_External_Rela)))
+	    return false;
+	}
+
+      if (reltext)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
+	    return false;
+	}
+    }
+
+  /* If we are generating a shared library, we generate a section
+     symbol for each output section.  These are local symbols, which
+     means that they must come first in the dynamic symbol table.
+     That means we must increment the dynamic symbol index of every
+     other dynamic symbol.
+
+     FIXME: We assume that there will never be relocations to
+     locations in linker-created sections that do not have
+     externally-visible names. Instead, we should work out precisely
+     which sections relocations are targetted at.  */
+  if (info->shared)
+    {
+      int c;
+
+      for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
+	{
+	  if ((s->flags & SEC_LINKER_CREATED) != 0
+	      || (s->flags & SEC_ALLOC) == 0)
+	    {
+	      elf_section_data (s)->dynindx = -1;
+	      continue;
+	    }
+
+	  /* These symbols will have no names, so we don't need to
+	     fiddle with dynstr_index.  */
+
+	  elf_section_data (s)->dynindx = c + 1;
+
+	  c++;
+	}
+
+      elf_link_hash_traverse (elf_hash_table (info),
+			      ppc_adjust_dynindx,
+			      (PTR) &c);
+      elf_hash_table (info)->dynsymcount += c;
+    }
+
+  return true;
+}
+
+/* Called after we have seen all the input files/sections, but before
+   final symbol resolution and section placement has been determined.
+
+   We use this hook to provide a value for TOCstart, which we store in
+   the output bfd elf_gp, then we call the generic ELF final link
+   routine.  */
+
+static boolean
+ppc64_elf_final_link (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  if (! info->relocateable)
+    {
+      asection *s;
+      bfd_vma TOCstart;
+
+      /* The TOC consists of sections .got, .toc, .tocbss, .plt in this
+	 order.  The TOC starts where the first of these sections starts.  */
+      s = bfd_get_section_by_name (abfd, ".got");
+      if (s == NULL)
+	s = bfd_get_section_by_name (abfd, ".toc");
+      if (s == NULL)
+	s = bfd_get_section_by_name (abfd, ".tocbss");
+      if (s == NULL)
+	s = bfd_get_section_by_name (abfd, ".plt");
+      if (s == NULL)
+	{
+	  /* This may happen for
+	     o  references to TOC base (SYM@toc / TOC[tc0]) without a
+	     .toc directive
+	     o  bad linker script
+	     o --gc-sections and empty TOC sections
+
+	     FIXME: Warn user?  */
+
+	  /* Look for a likely section.  We probably won't even be
+	     using TOCstart.  */
+	  for (s = abfd->sections; s != NULL; s = s->next)
+	    if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
+		== (SEC_ALLOC | SEC_SMALL_DATA))
+	      break;
+	  if (s == NULL)
+	    for (s = abfd->sections; s != NULL; s = s->next)
+	      if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
+		  == (SEC_ALLOC | SEC_SMALL_DATA))
+		break;
+	  if (s == NULL)
+	    for (s = abfd->sections; s != NULL; s = s->next)
+	      if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
+		break;
+	  if (s == NULL)
+	    for (s = abfd->sections; s != NULL; s = s->next)
+	      if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
+		break;
+	}
+
+      TOCstart = 0;
+      if (s != NULL)
+	TOCstart = s->output_section->vma + s->output_offset;
+
+      elf_gp (abfd) = TOCstart;
+    }
+
+  /* Invoke the regular gc ELF backend linker to do all the work.  */
+  return _bfd_elf64_gc_common_final_link (abfd, info);
+}
+
+/* Set up any other section flags and such that may be necessary.  */
+
+static boolean
+ppc64_elf_fake_sections (abfd, shdr, asect)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     Elf64_Internal_Shdr *shdr;
+     asection *asect;
+{
+  if ((asect->flags & SEC_EXCLUDE) != 0)
+    shdr->sh_flags |= SHF_EXCLUDE;
+
+  if ((asect->flags & SEC_SORT_ENTRIES) != 0)
+    shdr->sh_type = SHT_ORDERED;
+
+  return true;
+}
+
+/* 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
+   relocateable 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 relocateable 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.  */
+
+static boolean
+ppc64_elf_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;
+  bfd *dynobj;
+  Elf_Internal_Rela *rel;
+  Elf_Internal_Rela *relend;
+  asection *sreloc;
+  asection *splt;
+  asection *sgot;
+  bfd_vma *local_got_offsets;
+  bfd_vma TOCstart;
+  boolean ret = true;
+  long insn;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_relocate_section called for %s section %s, %ld relocations%s\n",
+	   bfd_get_filename (input_bfd),
+	   bfd_section_name (input_bfd, input_section),
+	   (long) input_section->reloc_count,
+	   (info->relocateable) ? " (relocatable)" : "");
+#endif
+
+  if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
+    /* Initialize howto table if needed.  */
+    ppc_howto_init ();
+
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sreloc = NULL;
+  splt = NULL;
+  sgot = NULL;
+  dynobj = elf_hash_table (info)->dynobj;
+  if (dynobj != NULL)
+    {
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+    }
+  TOCstart = elf_gp (output_bfd);
+
+  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++)
+    {
+      enum elf_ppc_reloc_type r_type;
+      bfd_vma offset;
+      bfd_vma addend;
+      bfd_reloc_status_type r;
+      Elf_Internal_Sym *sym;
+      asection *sec;
+      struct elf_link_hash_entry *h;
+      const char *sym_name;
+      reloc_howto_type *howto;
+      unsigned long r_symndx;
+      bfd_vma relocation;
+
+      r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
+      offset = rel->r_offset;
+      addend = rel->r_addend;
+      r = bfd_reloc_other;
+      sym = (Elf_Internal_Sym *) 0;
+      sec = (asection *) 0;
+      h = (struct elf_link_hash_entry *) 0;
+      sym_name = (const char *) 0;
+
+      /* Unknown relocation handling.  */
+      if ((unsigned) r_type >= (unsigned) R_PPC_max
+	  || !ppc64_elf_howto_table[(int) r_type])
+	{
+	  (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
+				 bfd_get_filename (input_bfd),
+				 (int) r_type);
+	  bfd_set_error (bfd_error_bad_value);
+	  ret = false;
+	  continue;
+	}
+
+      howto = ppc64_elf_howto_table[(int) r_type];
+      r_symndx = ELF64_R_SYM (rel->r_info);
+
+      if (info->relocateable)
+	{
+	  /* 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 ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  sec = local_sections[r_symndx];
+		  addend = rel->r_addend += sec->output_offset + sym->st_value;
+		}
+	    }
+
+#ifdef DEBUG
+	  fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
+		   howto->name,
+		   (int) r_type,
+		   r_symndx,
+		   (long) offset,
+		   (long) addend);
+#endif
+	  continue;
+	}
+
+      /* This is a final link.  */
+
+      /* Set `relocation'.  */
+      if (r_type == R_PPC64_TOC)
+	{
+	  /* Relocation value is TOC base.  Symbol is ignored.  */
+	  relocation = TOCstart + TOC_BASE_OFF;
+	}
+      else if (r_symndx < symtab_hdr->sh_info)
+	{
+	  /* It's a local symbol.  */
+	  sym = local_syms + r_symndx;
+	  sec = local_sections[r_symndx];
+	  sym_name = "<local symbol>";
+
+	  relocation = (sec->output_section->vma
+			+ sec->output_offset
+			+ sym->st_value);
+	}
+      else
+	{
+	  /* It's a global symbol.  */
+	  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;
+	  sym_name = h->root.root.string;
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      sec = h->root.u.def.section;
+	      if ((r_type == R_PPC64_PLT32
+		   && h->plt.offset != (bfd_vma) -1)
+		  || ((r_type == R_PPC64_GOT16
+		       || r_type == R_PPC64_GOT16_LO
+		       || r_type == R_PPC64_GOT16_HI
+		       || r_type == R_PPC64_GOT16_HA
+		       || r_type == R_PPC64_GOT16_DS
+		       || r_type == R_PPC64_GOT16_LO_DS)
+		      && elf_hash_table (info)->dynamic_sections_created
+		      && (! info->shared
+			  || (! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		  || (info->shared
+		      && ((! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0)
+		      && (input_section->flags & SEC_ALLOC) != 0
+		      && (r_type == R_PPC64_ADDR64
+			  || r_type == R_PPC64_ADDR32
+			  || r_type == R_PPC64_ADDR24
+			  || r_type == R_PPC64_ADDR16
+			  || r_type == R_PPC64_ADDR16_LO
+			  || r_type == R_PPC64_ADDR16_DS
+			  || r_type == R_PPC64_ADDR16_LO_DS
+			  || r_type == R_PPC64_ADDR16_HI
+			  || r_type == R_PPC64_ADDR16_HA
+			  || r_type == R_PPC64_ADDR16_HIGHER
+			  || r_type == R_PPC64_ADDR16_HIGHERA
+			  || r_type == R_PPC64_ADDR16_HIGHEST
+			  || r_type == R_PPC64_ADDR16_HIGHESTA
+			  || r_type == R_PPC64_ADDR14
+			  || r_type == R_PPC64_ADDR14_BRTAKEN
+			  || r_type == R_PPC64_ADDR14_BRNTAKEN
+			  || r_type == R_PPC64_COPY
+			  || r_type == R_PPC64_GLOB_DAT
+			  || r_type == R_PPC64_JMP_SLOT
+			  || r_type == R_PPC64_UADDR64
+			  || r_type == R_PPC64_UADDR32
+			  || r_type == R_PPC64_UADDR16)))
+		{
+		  /* In these cases, we don't need the relocation
+                     value.  We check specially because in some
+                     obscure cases sec->output_section will be NULL.  */
+		  relocation = 0;
+		}
+	      else
+		relocation = (h->root.u.def.value
+			      + sec->output_section->vma
+			      + sec->output_offset);
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    relocation = 0;
+	  else if (info->shared && !info->symbolic && !info->no_undefined)
+	    relocation = 0;
+	  else
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd, input_section,
+		      rel->r_offset, (!info->shared
+				      || info->no_undefined
+				      || ELF_ST_VISIBILITY (h->other)))))
+		return false;
+	      relocation = 0;
+	    }
+	}
+
+      switch ((int) r_type)
+	{
+	case (int) R_PPC64_ADDR16_DS:
+	case (int) R_PPC64_ADDR16_LO_DS:
+	case (int) R_PPC64_GOT16_DS:
+	case (int) R_PPC64_GOT16_LO_DS:
+	case (int) R_PPC64_PLT16_LO_DS:
+	case (int) R_PPC64_SECTOFF_DS:
+	case (int) R_PPC64_SECTOFF_LO_DS:
+	case (int) R_PPC64_TOC16_DS:
+	case (int) R_PPC64_TOC16_LO_DS:
+	case (int) R_PPC64_PLTGOT16_DS:
+	case (int) R_PPC64_PLTGOT16_LO_DS:
+	  if (((relocation + addend) & 3) != 0)
+	    {
+	      (*_bfd_error_handler) (_("%s: error: relocation %s not a multiple of 4"),
+				     bfd_get_filename (input_bfd),
+				     howto->name);
+	      bfd_set_error (bfd_error_bad_value);
+	      ret = false;
+	      continue;
+	    }
+	}
+
+      /* Set `addend'.  */
+      switch ((int) r_type)
+	{
+	default:
+	  (*_bfd_error_handler) (_("%s: unknown relocation type %d for symbol %s"),
+				 bfd_get_filename (input_bfd),
+				 (int) r_type, sym_name);
+
+	  bfd_set_error (bfd_error_bad_value);
+	  ret = false;
+	  continue;
+
+	  /* Relocations that may need to be propagated if this is a shared
+	     object.  */
+	case (int) R_PPC64_REL24:
+	case (int) R_PPC64_ADDR24:
+	  /* An ADDR24 or REL24 branching to a linkage function may be
+	     followed by a nop that we have to replace with an ld in
+	     order to restore the TOC base pointer.  Only calls to
+	     shared objects need to alter the TOC base.  These are
+	     recognized by their need for a PLT entry.  */
+	  if (h != NULL
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
+	      /* Make sure that there really is an instruction after
+                 the branch that we can decode.  */
+	      && (rel->r_offset - input_section->vma + 8
+		  <= input_section->_cooked_size))
+	    {
+	      bfd_byte *pnext;
+	      unsigned long insn;
+
+	      pnext = contents + (rel->r_offset - input_section->vma) + 4;
+	      insn = bfd_get_32 (input_bfd, pnext);
+
+	      if (insn == 0x60000000	 /* nop (ori  r0,r0,0) */
+		  || insn == 0x4def7b82	 /* cror 15,15,15 */
+		  || insn == 0x4ffffb82)   /* cror 31,31,31 */
+		{
+		  bfd_put_32 (input_bfd, 0xe8410028, pnext); /* ld r2,40(r1) */
+#ifdef DEBUG
+		  fprintf (stderr, "ppc64_elf_relocate_section: " \
+			   "patched nop after call to %s\n", sym_name);
+#endif
+		}
+	    }
+	  /* fall through */
+
+	case (int) R_PPC64_REL64:
+	case (int) R_PPC64_REL32:
+	case (int) R_PPC64_REL14:
+	  /* If these relocations are not to a named symbol, they can be
+	     handled right here, no need to bother the dynamic linker.  */
+	  if (h == NULL && r_type != R_PPC64_ADDR24)
+	    break;
+	  /* fall through */
+
+	  /* Relocations that always need to be propagated if this is a shared
+	     object.  */
+	case (int) R_PPC64_NONE:
+	case (int) R_PPC64_ADDR64:
+	case (int) R_PPC64_ADDR32:
+	case (int) R_PPC64_ADDR16:
+	case (int) R_PPC64_ADDR16_LO:
+	case (int) R_PPC64_ADDR16_DS:
+	case (int) R_PPC64_ADDR16_LO_DS:
+	case (int) R_PPC64_ADDR16_HI:
+	case (int) R_PPC64_ADDR16_HA:
+	case (int) R_PPC64_ADDR16_HIGHER:
+	case (int) R_PPC64_ADDR16_HIGHERA:
+	case (int) R_PPC64_ADDR16_HIGHEST:
+	case (int) R_PPC64_ADDR16_HIGHESTA:
+	case (int) R_PPC64_ADDR14:
+	case (int) R_PPC64_UADDR64:
+	case (int) R_PPC64_UADDR32:
+	case (int) R_PPC64_UADDR16:
+	case (int) R_PPC64_TOC:
+	  if (info->shared)
+	    {
+	      Elf_Internal_Rela outrel;
+	      boolean skip;
+
+#ifdef DEBUG
+	      fprintf (stderr, "ppc64_elf_relocate_section need to create relocation for %s\n",
+		       (h && h->root.root.string
+			? h->root.root.string
+			: "<unknown>"));
+#endif
+
+	      /* When generating a shared object, these relocations
+                 are copied into the output file to be resolved at run
+                 time.  */
+
+	      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 false;
+
+		  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (input_bfd,
+							       input_section),
+					 name + 5) == 0);
+
+		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  BFD_ASSERT (sreloc != NULL);
+		}
+
+	      skip = false;
+
+	      if (elf_section_data (input_section)->stab_info == NULL)
+		outrel.r_offset = rel->r_offset;
+	      else
+		{
+		  bfd_vma off;
+
+		  off = (_bfd_stab_section_offset
+			 (output_bfd, &elf_hash_table (info)->stab_info,
+			  input_section,
+			  &elf_section_data (input_section)->stab_info,
+			  rel->r_offset));
+		  if (off == (bfd_vma) -1)
+		    skip = true;
+		  outrel.r_offset = off;
+		}
+
+	      outrel.r_offset += (input_section->output_section->vma
+				  + input_section->output_offset);
+
+	      if (skip)
+		memset (&outrel, 0, sizeof outrel);
+	      /* h->dynindx may be -1 if this symbol was marked to
+                 become local.  */
+	      else if (h != NULL
+		       && ((! info->symbolic && h->dynindx != -1)
+			   || (h->elf_link_hash_flags
+			       & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		{
+		  BFD_ASSERT (h->dynindx != -1);
+		  outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
+		  outrel.r_addend = rel->r_addend;
+		}
+	      else
+		{
+		  if (r_type == R_PPC64_ADDR64)
+		    {
+		      outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
+		      outrel.r_addend = relocation + rel->r_addend;
+		    }
+		  else
+		    {
+		      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 (r_type == R_PPC64_TOC
+			  || (sec != NULL && bfd_is_abs_section (sec)))
+			{
+			  indx = 0;
+			}
+		      else if (sec == NULL || sec->owner == NULL)
+			{
+			  bfd_set_error (bfd_error_bad_value);
+			  return false;
+			}
+		      else
+			{
+			  asection *osec;
+
+			  osec = sec->output_section;
+			  indx = elf_section_data (osec)->dynindx;
+			  BFD_ASSERT (indx > 0);
+#ifdef DEBUG
+			  if (indx <= 0)
+			    {
+			      printf ("indx=%ld section=%s flags=%08x name=%s\n",
+				      indx, osec->name, osec->flags,
+				      h->root.root.string);
+			    }
+#endif
+			}
+
+		      outrel.r_info = ELF64_R_INFO (indx, r_type);
+		      outrel.r_addend = relocation + rel->r_addend;
+		    }
+		}
+
+	      bfd_elf64_swap_reloca_out (output_bfd, &outrel,
+					 (((Elf64_External_Rela *)
+					   sreloc->contents)
+					  + sreloc->reloc_count));
+	      ++sreloc->reloc_count;
+
+	      /* This reloc will be computed at runtime, so there's no
+                 need to do anything now, unless this is a RELATIVE
+                 reloc in an unallocated section.  */
+	      if (skip
+		  || (input_section->flags & SEC_ALLOC) != 0
+		  || ELF64_R_TYPE (outrel.r_info) != R_PPC64_RELATIVE)
+		continue;
+	    }
+
+	  /* Arithmetic adjust relocations that aren't going into a
+	     shared object.  */
+	  if ((r_type == R_PPC64_ADDR16_HA
+	       || r_type == R_PPC64_ADDR16_HIGHERA
+	       || r_type == R_PPC64_ADDR16_HIGHESTA)
+	      /* It's just possible that this symbol is a weak symbol
+		 that's not actually defined anywhere. In that case,
+		 'sec' would be NULL, and we should leave the symbol
+		 alone (it will be set to zero elsewhere in the link).  */
+	      && sec != NULL)
+	    {
+	      addend += ((relocation + addend) & 0x8000) << 1;
+	    }
+	  break;
+
+	  /* Branch taken prediction relocations.  */
+	case (int) R_PPC64_ADDR14_BRTAKEN:
+	case (int) R_PPC64_REL14_BRTAKEN:
+	  insn = bfd_get_32 (output_bfd, contents + offset);
+	  if ((relocation - offset) & 0x8000)
+	    insn &= ~BRANCH_PREDICT_BIT;
+	  else
+	    insn |= BRANCH_PREDICT_BIT;
+	  bfd_put_32 (output_bfd, insn, contents + offset);
+	  break;
+
+	  /* Branch not taken predicition relocations.  */
+	case (int) R_PPC64_ADDR14_BRNTAKEN:
+	case (int) R_PPC64_REL14_BRNTAKEN:
+	  insn = bfd_get_32 (output_bfd, contents + offset);
+	  if ((relocation - offset) & 0x8000)
+	    insn |= BRANCH_PREDICT_BIT;
+	  else
+	    insn &= ~BRANCH_PREDICT_BIT;
+	  bfd_put_32 (output_bfd, insn, contents + offset);
+	  break;
+
+
+	  /* GOT16 relocations.  Like an ADDR16 using the symbol's
+	     address in the GOT as relocation value instead of the
+	     symbols value itself.  Also, create a GOT entry for the
+	     symbol and put the symbol value there.  */
+	  /* FIXME: If the symbol is not in the .got section
+	     (typically in the .toc section) we fail (h->got.offset is
+	     0).  */
+	  /* NOTE: Sets `relocation'.  */
+	case (int) R_PPC64_GOT16:
+	case (int) R_PPC64_GOT16_LO:
+	case (int) R_PPC64_GOT16_HI:
+	case (int) R_PPC64_GOT16_HA:
+	case (int) R_PPC64_GOT16_DS:
+	case (int) R_PPC64_GOT16_LO_DS:
+	  {
+	    /* Relocation is to the entry for this symbol in the global
+	       offset table.  */
+	    bfd_vma off;
+	    BFD_ASSERT (sgot != NULL);
+
+	    if (h != NULL)
+	      {
+		off = h->got.offset;
+		BFD_ASSERT (off != (bfd_vma) -1);
+
+		if (! elf_hash_table (info)->dynamic_sections_created
+		    || (info->shared
+			&& (info->symbolic || h->dynindx == -1)
+			&& (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 .rela.got
+		       relocation entry to initialize the value.  This
+		       is done in the finish_dynamic_symbol routine.  */
+		    if ((off & 1) != 0)
+		      off &= ~1;
+		    else
+		      {
+			bfd_put_64 (output_bfd, relocation,
+				    sgot->contents + off);
+			h->got.offset |= 1;
+		      }
+		  }
+	      }
+	    else
+	      {
+		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 processed this entry.  */
+		if ((off & 1) != 0)
+		  off &= ~1;
+		else
+		  {
+		    bfd_put_64 (output_bfd, relocation, sgot->contents + off);
+
+		    if (info->shared)
+		      {
+			asection *srelgot;
+			Elf_Internal_Rela outrel;
+
+			/* We need to generate a R_PPC64_RELATIVE reloc
+			   for the dynamic linker.  */
+			srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+			BFD_ASSERT (srelgot != NULL);
+
+			outrel.r_offset = (sgot->output_section->vma
+					   + sgot->output_offset
+					   + off);
+			outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
+			outrel.r_addend = relocation;
+			bfd_elf64_swap_reloca_out (output_bfd, &outrel,
+						   (((Elf64_External_Rela *)
+						     srelgot->contents)
+						    + srelgot->reloc_count));
+			++srelgot->reloc_count;
+		      }
+
+		    local_got_offsets[r_symndx] |= 1;
+		  }
+	      }
+
+	    relocation = sgot->output_offset + off;
+	    /* TOC base (r2) is TOC start plus 0x8000.  */
+	    addend -= TOC_BASE_OFF;
+	    break;
+	  }
+
+	  /* TOC16 relocs.  We want the offset relative to the TOC base,
+	     which is the address of the start of the TOC plus 0x8000.
+	     The TOC consists of sections .got, .toc, .tocbss, and .plt,
+	     in this order.  */
+
+	case (int) R_PPC64_TOC16:
+	case (int) R_PPC64_TOC16_LO:
+	case (int) R_PPC64_TOC16_HI:
+	case (int) R_PPC64_TOC16_DS:
+	case (int) R_PPC64_TOC16_LO_DS:
+	  BFD_ASSERT (sec != (asection *) 0);
+	  /* Only .got, .toc and *UND* symbols are allowed.  */
+	  BFD_ASSERT (bfd_is_und_section (sec)
+		      || strcmp (bfd_get_section_name (abfd, sec),
+				 ".got") == 0
+		      || strcmp (bfd_get_section_name (abfd, sec),
+				 ".toc") == 0);
+
+	  addend -= TOCstart + TOC_BASE_OFF;
+	  break;
+
+	case (int) R_PPC64_TOC16_HA:
+	  BFD_ASSERT (sec != (asection *) 0);
+	  BFD_ASSERT (bfd_is_und_section (sec)
+		      || strcmp (bfd_get_section_name (abfd, sec),
+				 ".got") == 0
+		      || strcmp (bfd_get_section_name (abfd, sec),
+				 ".toc") == 0);
+
+	  addend -= TOCstart + TOC_BASE_OFF;
+	  /* Add 1 to 16-bit word 16:31 if sign bit in 0:15 is set.  */
+	  addend += ((relocation + addend) & 0x8000) << 1;
+	  break;
+
+	  /* Relocate against the beginning of the section.  */
+	case (int) R_PPC64_SECTOFF:
+	case (int) R_PPC64_SECTOFF_LO:
+	case (int) R_PPC64_SECTOFF_HI:
+	case (int) R_PPC64_SECTOFF_DS:
+	case (int) R_PPC64_SECTOFF_LO_DS:
+	  BFD_ASSERT (sec != (asection *) 0);
+	  addend -= sec->output_section->vma;
+	  break;
+
+	case (int) R_PPC64_SECTOFF_HA:
+	  BFD_ASSERT (sec != (asection *) 0);
+	  addend -= sec->output_section->vma;
+	  addend += ((relocation + addend) & 0x8000) << 1;
+	  break;
+
+	case (int) R_PPC64_COPY:
+	case (int) R_PPC64_GLOB_DAT:
+	case (int) R_PPC64_JMP_SLOT:
+	case (int) R_PPC64_RELATIVE:
+	case (int) R_PPC64_PLT32:
+	case (int) R_PPC64_PLTREL32:
+	case (int) R_PPC64_PLT16_LO:
+	case (int) R_PPC64_PLT16_LO_DS:
+	case (int) R_PPC64_PLT16_HI:
+	case (int) R_PPC64_PLT16_HA:
+	case (int) R_PPC64_PLT64:
+	case (int) R_PPC64_PLTREL64:
+	case (int) R_PPC64_PLTGOT16:
+	case (int) R_PPC64_PLTGOT16_LO:
+	case (int) R_PPC64_PLTGOT16_DS:
+	case (int) R_PPC64_PLTGOT16_LO_DS:
+	case (int) R_PPC64_PLTGOT16_HI:
+	case (int) R_PPC64_PLTGOT16_HA:
+	  (*_bfd_error_handler) (_("%s: Relocation %s is not yet supported for symbol %s."),
+				 bfd_get_filename (input_bfd),
+				 ppc64_elf_howto_table[(int) r_type]->name,
+				 sym_name);
+
+	  bfd_set_error (bfd_error_invalid_operation);
+	  ret = false;
+	  continue;
+
+	case (int) R_PPC_GNU_VTINHERIT:
+	case (int) R_PPC_GNU_VTENTRY:
+	  /* These are no-ops in the end.  */
+	  continue;
+	}
+
+#ifdef DEBUG
+      fprintf (stderr, "  type = %s (%d), name = %s, sym index = %ld, offset = %ld, addend = %ld\n",
+	       howto->name,
+	       (int) r_type,
+	       sym_name,
+	       r_symndx,
+	       (long) offset,
+	       (long) addend);
+#endif
+
+      r = _bfd_final_link_relocate (howto,
+				    input_bfd,
+				    input_section,
+				    contents,
+				    offset,
+				    relocation,
+				    addend);
+
+      if (r == bfd_reloc_ok)
+	;
+      else if (r == bfd_reloc_overflow)
+	{
+	  const char *name;
+
+	  if (h != NULL)
+	    {
+	      if (h->root.type == bfd_link_hash_undefweak
+		  && howto->pc_relative)
+		{
+		  /* Assume this is a call protected by other code that
+		     detects the symbol is undefined.  If this is the case,
+		     we can safely ignore the overflow.  If not, the
+		     program is hosed anyway, and a little warning isn't
+		     going to help.  */
+
+		  continue;
+		}
+
+	      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)
+		continue;
+	      if (*name == '\0')
+		name = bfd_section_name (input_bfd, sec);
+	    }
+
+	  if (! (*info->callbacks->reloc_overflow) (info,
+						    name,
+						    howto->name,
+						    (bfd_vma) 0,
+						    input_bfd,
+						    input_section,
+						    offset))
+	    return false;
+	}
+      else
+	ret = false;
+    }
+
+#ifdef DEBUG
+  fprintf (stderr, "\n");
+#endif
+
+  return ret;
+}
+
+/* Finish up dynamic symbol handling.  We set the contents of various
+   dynamic sections here.  */
+
+static boolean
+ppc64_elf_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;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_finish_dynamic_symbol called for %s",
+	   h->root.root.string);
+#endif
+
+  dynobj = elf_hash_table (info)->dynobj;
+  BFD_ASSERT (dynobj != NULL);
+
+  if (h->plt.offset != (bfd_vma) -1)
+    {
+      asection *splt, *srela, *sglink;
+      Elf_Internal_Rela rela;
+      bfd_vma reloc_index, plt_offset;
+      struct elf_link_hash_entry *funcdesc_h;
+
+#ifdef DEBUG
+      fprintf (stderr, ", plt_offset = 0x%lx", (unsigned long) h->plt.offset);
+#endif
+
+      /* 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");
+      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (splt != NULL && srela != NULL);
+
+      /* We don't need to fill in the .plt.  The dynamic linker will
+	 fill it in.  */
+
+      /* We may need to create a linkage function. */
+      sglink = bfd_get_section_by_name (dynobj, ".glink");
+      if (sglink != NULL && h->root.u.def.section == sglink)
+	{
+	  bfd_byte *p;
+	  bfd_vma pltoff;
+	  const unsigned int *stub;
+
+	  /* Where to write it.  */
+	  p = h->root.u.def.section->contents + h->root.u.def.value;
+
+	  /* The function descriptor is in the PLT.  */
+	  pltoff = splt->output_section->vma
+	    + splt->output_section->output_offset
+	    + h->plt.offset
+	    - elf_gp (output_bfd) - TOC_BASE_OFF;
+
+	  if (pltoff + 0x8000 > 0xffff)
+	    {
+	      (*_bfd_error_handler)
+		(_("linkage table overflow against `%s'"),
+		 h->root.root.string);
+	    }
+
+	  /* Write it out.  */
+	  stub = ppc64_elf_glink_code;
+	  bfd_put_32 (output_bfd, *stub | (pltoff & 0xfffc), p);
+	  while (p += 4, ++stub < (ppc64_elf_glink_code
+				   + (sizeof (ppc64_elf_glink_code)
+				      / sizeof (*ppc64_elf_glink_code))));
+	    {
+	      bfd_put_32 (output_bfd, *stub, p);
+	    }
+#ifdef DEBUG
+	  fprintf (stderr, ", linkage function");
+#endif
+	}
+
+      /* Create a JMP_SLOT reloc to inform the dynamic linker to fix
+         the PLT entry.  */
+
+      /* Save the PLT offset, since `h' may be changed below.  */
+      plt_offset = h->plt.offset;
+
+      /* If it's a function entry point, find its corresponding
+	 function descriptor.  ppc64_elf_adjust_dynamic_symbol have
+	 already set it up for us.  */
+
+      /* FIXME: Is it safe to assume that this symbol is a function?  */
+      BFD_ASSERT (h->root.root.string[0] == '.');
+
+      /* FIXME: Follow bfd_link_hash_indirect?  */
+      funcdesc_h = elf_link_hash_lookup (elf_hash_table (info),
+					 h->root.root.string + 1,
+					 false, false, false);
+      BFD_ASSERT (funcdesc_h != NULL);
+      BFD_ASSERT (funcdesc_h->dynindx != -1);
+
+      /* FIXME: Rename the symbol for the function entry point to
+         `linkage_for_FUNC'?  */
+
+      rela.r_offset = (splt->output_section->vma
+		       + splt->output_offset
+		       + plt_offset);
+      rela.r_info = ELF64_R_INFO (funcdesc_h->dynindx, R_PPC64_JMP_SLOT);
+      rela.r_addend = 0;
+
+      reloc_index = (plt_offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) srela->contents
+				  + reloc_index));
+#ifdef DEBUG
+      fprintf (stderr, ", JMP_SLOT for %s", funcdesc_h->root.root.string);
+#endif
+
+#if 0
+      /* FIXME: Really do this?  */
+      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;
+	}
+#endif
+    }
+
+  if (h->got.offset != (bfd_vma) -1)
+    {
+      asection *sgot;
+      asection *srela;
+      Elf_Internal_Rela rela;
+
+#ifdef DEBUG
+      fprintf (stderr, ", got.offset = %08lx", (unsigned long) h->got.offset);
+#endif
+
+      /* This symbol has an entry in the global offset table.  Set it
+         up.  */
+
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+      srela = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (sgot != NULL && srela != NULL);
+
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + (h->got.offset &~ 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))
+	{
+	  rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
+	  rela.r_addend = (h->root.u.def.value
+			   + h->root.u.def.section->output_section->vma
+			   + h->root.u.def.section->output_offset);
+	}
+      else
+	{
+	  BFD_ASSERT ((h->got.offset & 1) == 0);
+	  bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+	  rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
+	  rela.r_addend = 0;
+	}
+
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) srela->contents
+				  + srela->reloc_count));
+      ++srela->reloc_count;
+    }
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+    {
+      asection *s;
+      Elf_Internal_Rela rela;
+
+      /* This symbols needs a copy reloc.  Set it up.  */
+
+#ifdef DEBUG
+      fprintf (stderr, ", copy");
+#endif
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      s = bfd_get_section_by_name (h->root.u.def.section->owner,
+				   ".rela.bss");
+      BFD_ASSERT (s != NULL);
+
+      rela.r_offset = (h->root.u.def.value
+		       + h->root.u.def.section->output_section->vma
+		       + h->root.u.def.section->output_offset);
+      rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
+      rela.r_addend = 0;
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) s->contents
+				  + s->reloc_count));
+      ++s->reloc_count;
+    }
+
+#ifdef DEBUG
+  fprintf (stderr, "\n");
+#endif
+
+  /* Mark some specially defined symbols as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
+    sym->st_shndx = SHN_ABS;
+
+  return true;
+}
+
+/* Finish up the dynamic sections.  */
+
+static boolean
+ppc64_elf_finish_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  asection *sdyn;
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+
+#ifdef DEBUG
+  fprintf (stderr, "ppc64_elf_finish_dynamic_sections called\n");
+#endif
+
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      asection *splt;
+      Elf64_External_Dyn *dyncon, *dynconend;
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      BFD_ASSERT (splt != NULL && sdyn != NULL);
+
+      dyncon = (Elf64_External_Dyn *) sdyn->contents;
+      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+      for (; dyncon < dynconend; dyncon++)
+	{
+	  Elf_Internal_Dyn dyn;
+	  const char *name;
+	  boolean size;
+
+	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
+
+	  switch (dyn.d_tag)
+	    {
+	    case DT_PLTGOT:   name = ".plt";	  size = false; break;
+	    case DT_PLTRELSZ: name = ".rela.plt"; size = true;  break;
+	    case DT_JMPREL:   name = ".rela.plt"; size = false; break;
+	    default:	      name = NULL;	  size = false; break;
+	    }
+
+	  if (name != NULL)
+	    {
+	      asection *s;
+
+	      s = bfd_get_section_by_name (output_bfd, name);
+	      if (s == NULL)
+		dyn.d_un.d_val = 0;
+	      else
+		{
+		  if (! size)
+		    dyn.d_un.d_ptr = s->vma;
+		  else
+		    {
+		      if (s->_cooked_size != 0)
+			dyn.d_un.d_val = s->_cooked_size;
+		      else
+			dyn.d_un.d_val = s->_raw_size;
+		    }
+		}
+	      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
+	    }
+	}
+    }
+
+  if (info->shared)
+    {
+      asection *sdynsym;
+      asection *s;
+      Elf_Internal_Sym sym;
+      int maxdindx = 0;
+
+      /* Set up the section symbols for the output sections.  */
+
+      sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
+      BFD_ASSERT (sdynsym != NULL);
+
+      sym.st_size = 0;
+      sym.st_name = 0;
+      sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
+      sym.st_other = 0;
+
+      for (s = output_bfd->sections; s != NULL; s = s->next)
+	{
+	  int indx, dindx;
+
+	  sym.st_value = s->vma;
+
+	  indx = elf_section_data (s)->this_idx;
+	  dindx = elf_section_data (s)->dynindx;
+	  if (dindx != -1)
+	    {
+	      BFD_ASSERT (indx > 0);
+	      BFD_ASSERT (dindx > 0);
+
+	      if (dindx > maxdindx)
+		maxdindx = dindx;
+
+	      sym.st_shndx = indx;
+
+	      bfd_elf64_swap_symbol_out (output_bfd, &sym,
+					 (PTR) (((Elf64_External_Sym *)
+						 sdynsym->contents)
+						+ dindx));
+	    }
+	}
+
+      /* Set the sh_info field of the output .dynsym section to the
+         index of the first global symbol.  */
+      elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
+	maxdindx + 1;
+    }
+
+  return true;
+}
+
+#define TARGET_LITTLE_SYM	bfd_elf64_powerpcle_vec
+#define TARGET_LITTLE_NAME	"elf64-powerpcle"
+#define TARGET_BIG_SYM		bfd_elf64_powerpc_vec
+#define TARGET_BIG_NAME		"elf64-powerpc"
+#define ELF_ARCH		bfd_arch_powerpc
+#define ELF_MACHINE_CODE	EM_PPC64
+#define ELF_MAXPAGESIZE		0x10000
+#define elf_info_to_howto	ppc64_elf_info_to_howto
+
+#ifdef  EM_CYGNUS_POWERPC
+#define ELF_MACHINE_ALT1	EM_CYGNUS_POWERPC
+#endif
+
+#ifdef EM_PPC_OLD
+#define ELF_MACHINE_ALT2	EM_PPC_OLD
+#endif
+
+#define elf_backend_want_got_sym 0
+#define elf_backend_want_plt_sym 0
+#define elf_backend_plt_alignment 3
+#define elf_backend_plt_not_loaded 1
+#define elf_backend_got_symbol_offset 0
+#define elf_backend_got_header_size 0
+#define elf_backend_can_gc_sections 1
+
+#define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
+
+#define bfd_elf64_bfd_copy_private_bfd_data	ppc64_elf_copy_private_bfd_data
+#define bfd_elf64_bfd_merge_private_bfd_data	ppc64_elf_merge_private_bfd_data
+#define bfd_elf64_bfd_reloc_type_lookup		ppc64_elf_reloc_type_lookup
+#define bfd_elf64_bfd_set_private_flags		ppc64_elf_set_private_flags
+#define bfd_elf64_bfd_final_link		ppc64_elf_final_link
+
+#define elf_backend_gc_mark_hook		ppc64_elf_gc_mark_hook
+#define elf_backend_gc_sweep_hook		ppc64_elf_gc_sweep_hook
+#define elf_backend_section_from_shdr		ppc64_elf_section_from_shdr
+#define elf_backend_relocate_section		ppc64_elf_relocate_section
+#define elf_backend_create_dynamic_sections	ppc64_elf_create_dynamic_sections
+#define elf_backend_check_relocs		ppc64_elf_check_relocs
+#define elf_backend_adjust_dynamic_symbol	ppc64_elf_adjust_dynamic_symbol
+#define elf_backend_size_dynamic_sections	ppc64_elf_size_dynamic_sections
+#define elf_backend_finish_dynamic_symbol	ppc64_elf_finish_dynamic_symbol
+#define elf_backend_finish_dynamic_sections	ppc64_elf_finish_dynamic_sections
+#define elf_backend_fake_sections		ppc64_elf_fake_sections
+
+#include "elf64-target.h"
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index d9ddc23..1755ba9 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -628,10 +628,12 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_HI16_GOTOFF",
   "BFD_RELOC_HI16_S_GOTOFF",
   "BFD_RELOC_8_GOTOFF",
+  "BFD_RELOC_64_PLT_PCREL",
   "BFD_RELOC_32_PLT_PCREL",
   "BFD_RELOC_24_PLT_PCREL",
   "BFD_RELOC_16_PLT_PCREL",
   "BFD_RELOC_8_PLT_PCREL",
+  "BFD_RELOC_64_PLTOFF",
   "BFD_RELOC_32_PLTOFF",
   "BFD_RELOC_16_PLTOFF",
   "BFD_RELOC_LO16_PLTOFF",
@@ -811,6 +813,29 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_PPC_EMB_RELST_HA",
   "BFD_RELOC_PPC_EMB_BIT_FLD",
   "BFD_RELOC_PPC_EMB_RELSDA",
+  "BFD_RELOC_PPC64_HIGHER",
+  "BFD_RELOC_PPC64_HIGHER_S",
+  "BFD_RELOC_PPC64_HIGHEST",
+  "BFD_RELOC_PPC64_HIGHEST_S",
+  "BFD_RELOC_PPC64_TOC16_LO",
+  "BFD_RELOC_PPC64_TOC16_HI",
+  "BFD_RELOC_PPC64_TOC16_HA",
+  "BFD_RELOC_PPC64_TOC",
+  "BFD_RELOC_PPC64_PLTGOT16   ",
+  "BFD_RELOC_PPC64_PLTGOT16_LO",
+  "BFD_RELOC_PPC64_PLTGOT16_HI",
+  "BFD_RELOC_PPC64_PLTGOT16_HA",
+  "BFD_RELOC_PPC64_ADDR16_DS",
+  "BFD_RELOC_PPC64_ADDR16_LO_DS",
+  "BFD_RELOC_PPC64_GOT16_DS",
+  "BFD_RELOC_PPC64_GOT16_LO_DS",
+  "BFD_RELOC_PPC64_PLT16_LO_DS",
+  "BFD_RELOC_PPC64_SECTOFF_DS",
+  "BFD_RELOC_PPC64_SECTOFF_LO_DS",
+  "BFD_RELOC_PPC64_TOC16_DS",
+  "BFD_RELOC_PPC64_TOC16_LO_DS",
+  "BFD_RELOC_PPC64_PLTGOT16_DS",
+  "BFD_RELOC_PPC64_PLTGOT16_LO_DS",
   "BFD_RELOC_I370_D12",
   "BFD_RELOC_CTOR",
   "BFD_RELOC_ARM_PCREL_BRANCH",
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 68cc75b..de3bbf4 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -1681,6 +1681,8 @@ ENUMX
 ENUMX
   BFD_RELOC_8_GOTOFF
 ENUMX
+  BFD_RELOC_64_PLT_PCREL
+ENUMX
   BFD_RELOC_32_PLT_PCREL
 ENUMX
   BFD_RELOC_24_PLT_PCREL
@@ -1689,6 +1691,8 @@ ENUMX
 ENUMX
   BFD_RELOC_8_PLT_PCREL
 ENUMX
+  BFD_RELOC_64_PLTOFF
+ENUMX
   BFD_RELOC_32_PLTOFF
 ENUMX
   BFD_RELOC_16_PLTOFF
@@ -2216,6 +2220,52 @@ ENUMX
   BFD_RELOC_PPC_EMB_BIT_FLD
 ENUMX
   BFD_RELOC_PPC_EMB_RELSDA
+ENUMX
+  BFD_RELOC_PPC64_HIGHER
+ENUMX
+  BFD_RELOC_PPC64_HIGHER_S
+ENUMX
+  BFD_RELOC_PPC64_HIGHEST
+ENUMX
+  BFD_RELOC_PPC64_HIGHEST_S
+ENUMX
+  BFD_RELOC_PPC64_TOC16_LO
+ENUMX
+  BFD_RELOC_PPC64_TOC16_HI
+ENUMX
+  BFD_RELOC_PPC64_TOC16_HA
+ENUMX
+  BFD_RELOC_PPC64_TOC
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16   
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16_LO
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16_HI
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16_HA
+ENUMX
+  BFD_RELOC_PPC64_ADDR16_DS
+ENUMX
+  BFD_RELOC_PPC64_ADDR16_LO_DS
+ENUMX
+  BFD_RELOC_PPC64_GOT16_DS
+ENUMX
+  BFD_RELOC_PPC64_GOT16_LO_DS
+ENUMX
+  BFD_RELOC_PPC64_PLT16_LO_DS
+ENUMX
+  BFD_RELOC_PPC64_SECTOFF_DS
+ENUMX
+  BFD_RELOC_PPC64_SECTOFF_LO_DS
+ENUMX
+  BFD_RELOC_PPC64_TOC16_DS
+ENUMX
+  BFD_RELOC_PPC64_TOC16_LO_DS
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16_DS
+ENUMX
+  BFD_RELOC_PPC64_PLTGOT16_LO_DS
 ENUMDOC
   Power(rs6000) and PowerPC relocations.
 
diff --git a/bfd/targets.c b/bfd/targets.c
index c46ecc3..0105ef6 100644
--- a/bfd/targets.c
+++ b/bfd/targets.c
@@ -571,6 +571,8 @@ extern const bfd_target bfd_elf64_little_generic_vec;
 extern const bfd_target bfd_elf64_littlemips_vec;
 extern const bfd_target bfd_elf64_tradbigmips_vec;
 extern const bfd_target bfd_elf64_tradlittlemips_vec;
+extern const bfd_target bfd_elf64_powerpc_vec;
+extern const bfd_target bfd_elf64_powerpcle_vec;
 extern const bfd_target bfd_elf64_s390_vec;
 extern const bfd_target bfd_elf64_sparc_vec;
 extern const bfd_target bfd_elf64_x86_64_vec;
@@ -782,6 +784,10 @@ static const bfd_target * const _bfd_target_vector[] = {
 	&bfd_elf32_pjl_vec,
 	&bfd_elf32_powerpc_vec,
 	&bfd_elf32_powerpcle_vec,
+#ifdef BFD64
+	&bfd_elf64_powerpc_vec,
+	&bfd_elf64_powerpcle_vec,
+#endif
 	&bfd_elf32_sparc_vec,
 	&bfd_elf32_v850_vec,
 	&bfd_elf32_fr30_vec,