[AArch64, ILP32] 2/6 Parametrize elfnn-aarch64.c and add basic support in ld

and gas.

bfd/

	* Makefile.am (BFD64_BACKENDS): Add elf32-aarch64.lo.
	(BUILD_CFILES): Add elf32-aarch64.c.
	(elf32-aarch64.c): New rule for generating from elfnn-aarch64.c.
	* Makefile.in: Re-generated.
	* archures.c (bfd_mach_aarch64_ilp32): New define.
	* bfd-in.h (bfd_elf32_aarch64_init_maps): New declaration.
	(bfd_elf32_aarch64_set_options): Ditto.
	(elf32_aarch64_setup_section_lists): Ditto.
	(elf32_aarch64_next_input_section): Ditto.
	(elf32_aarch64_size_stubs): Ditto.
	(elf32_aarch64_build_stubs): Ditto.
	* bfd-in2.h: Re-generated.
	* config.bfd (aarch64-*-elf): Add bfd_elf32_littleaarch64_vec
	and bfd_elf32_bigaarch64_vec.
	(aarch64-*-linux*): Likewise.
	(aarch64_be-*-elf): Likewise.
	(aarch64_be-*-linux*): Likewise.
	* configure.in (bfd_elf32_bigaarch64_vec)
	(bfd_elf32_littleaarch64_vec): New.
	* configure: Re-generated.
	* cpu-aarch64.c (compatible): Don't allow mixing ilp32 objects with
	lp64 ones.
	(bfd_aarch64_arch_ilp32): New.
	(bfd_aarch64_arch): Link to bfd_aarch64_arch_ilp32.
	* elfnn-aarch64.c (ARCH_SIZE): New define.
	(AARCH64_R, AARCH64_R_STR, LOG_FILE_ALIGN): New defines.
	(GOT_ENTRY_SIZE): Re-define as (ARCH_SIZE / 8).
	(elf64_aarch64_*): Rename to elfNN_aarch64_*.
	(ELF64_R_*): Rename to ELFNN_R_*.
	Plus other paramaterization.
	* targets.c (bfd_elf32_bigaarch64_vec, bfd_elf32_littleaarch64_vec):
	New declarations.
	(_bfd_target_vector): Add bfd_elf32_bigaarch64_vec and
	bfd_elf32_littleaarch64_vec.

gas/

	* config/tc-aarch64.c (ilp32_p): New static variable.
	(elf64_aarch64_target_format): Return the target according to the
	value of 'ilp32_p'.
	(md_begin): Determine 'mach' according to the value of 'ilp32_p'.
	(aarch64_opts): Add support for options '-milp32' and '-mlp64'.
	(aarch64_dwarf2_addr_size): New function.
	* config/tc-aarch64.h (aarch64_dwarf2_addr_size): New declaration.
	(DWARF2_ADDR_SIZE): New define.

ld/

	* Makefile.am (ALL_64_EMULATION_SOURCES): Add eaarch64elf32.c.
	(eaarch64elf32.c): New dependency and rule.
	* Makefile.in: Re-generated.
	* configure.tgt (aarch64-*-elf): Add aarch64elf32.
	(aarch64_be-*-elf, aarch64_be-*-linux*, aarch64-*-linux*): Likewise.
	* emulparams/aarch64elf32.sh: New file.

12 files changed, 527 insertions, 395 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index e521553..68f306f 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,5 +1,42 @@
 2013-06-26  Yufeng Zhang  <yufeng.zhang@arm.com>
 
+	* Makefile.am (BFD64_BACKENDS): Add elf32-aarch64.lo.
+	(BUILD_CFILES): Add elf32-aarch64.c.
+	(elf32-aarch64.c): New rule for generating from elfnn-aarch64.c.
+	* Makefile.in: Re-generated.
+	* archures.c (bfd_mach_aarch64_ilp32): New define.
+	* bfd-in.h (bfd_elf32_aarch64_init_maps): New declaration.
+	(bfd_elf32_aarch64_set_options): Ditto.
+	(elf32_aarch64_setup_section_lists): Ditto.
+	(elf32_aarch64_next_input_section): Ditto.
+	(elf32_aarch64_size_stubs): Ditto.
+	(elf32_aarch64_build_stubs): Ditto.
+	* bfd-in2.h: Re-generated.
+	* config.bfd (aarch64-*-elf): Add bfd_elf32_littleaarch64_vec
+	and bfd_elf32_bigaarch64_vec.
+	(aarch64-*-linux*): Likewise.
+	(aarch64_be-*-elf): Likewise.
+	(aarch64_be-*-linux*): Likewise.
+	* configure.in (bfd_elf32_bigaarch64_vec)
+	(bfd_elf32_littleaarch64_vec): New.
+	* configure: Re-generated.
+	* cpu-aarch64.c (compatible): Don't allow mixing ilp32 objects with
+	lp64 ones.
+	(bfd_aarch64_arch_ilp32): New.
+	(bfd_aarch64_arch): Link to bfd_aarch64_arch_ilp32.
+	* elfnn-aarch64.c (ARCH_SIZE): New define.
+	(AARCH64_R, AARCH64_R_STR, LOG_FILE_ALIGN): New defines.
+	(GOT_ENTRY_SIZE): Re-define as (ARCH_SIZE / 8).
+	(elf64_aarch64_*): Rename to elfNN_aarch64_*.
+	(ELF64_R_*): Rename to ELFNN_R_*.
+	Plus other paramaterization.
+	* targets.c (bfd_elf32_bigaarch64_vec, bfd_elf32_littleaarch64_vec):
+	New declarations.
+	(_bfd_target_vector): Add bfd_elf32_bigaarch64_vec and
+	bfd_elf32_littleaarch64_vec.
+
+2013-06-26  Yufeng Zhang  <yufeng.zhang@arm.com>
+
 	* Makefile.am (BFD64_BACKENDS_CFILES): Remove elf64-aarch64.c.
 	(BUILD_CFILES): Add elf64-aarch64.c.
 	(elf64-aarch64.c): New rule for generating from elfnn-aarch64.c.
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index 5ed9bc7..58fb6d6 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -638,6 +638,7 @@ BFD32_BACKENDS_CFILES = \
 # elf32-ia64.c requires a 64-bit bfd_vma, and hence can not be put in
 # BFD32_BACKENDS.
 BFD64_BACKENDS = \
+	elf32-aarch64.lo \
 	elf64-aarch64.lo \
 	aix5ppc-core.lo \
 	aout64.lo \
@@ -763,7 +764,7 @@ SOURCE_CFILES = \
 	$(OPTIONAL_BACKENDS_CFILES)
 
 BUILD_CFILES = \
-	elf64-aarch64.c \
+	elf32-aarch64.c elf64-aarch64.c \
 	elf32-ia64.c elf64-ia64.c peigen.c pepigen.c pex64igen.c
 
 CFILES = $(SOURCE_CFILES) $(BUILD_CFILES)
@@ -912,6 +913,11 @@ elf64-target.h : elfxx-target.h
 	sed -e s/NN/64/g < $(srcdir)/elfxx-target.h > elf64-target.new
 	mv -f elf64-target.new elf64-target.h
 
+elf32-aarch64.c : elfnn-aarch64.c
+	rm -f elf32-aarch64.c
+	sed -e s/NN/32/g < $(srcdir)/elfnn-aarch64.c > elf32-aarch64.new
+	mv -f elf32-aarch64.new elf32-aarch64.c
+
 elf64-aarch64.c : elfnn-aarch64.c
 	rm -f elf64-aarch64.c
 	sed -e s/NN/64/g < $(srcdir)/elfnn-aarch64.c > elf64-aarch64.new
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index d212ca5..2ad992f 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -941,6 +941,7 @@ BFD32_BACKENDS_CFILES = \
 # elf32-ia64.c requires a 64-bit bfd_vma, and hence can not be put in
 # BFD32_BACKENDS.
 BFD64_BACKENDS = \
+	elf32-aarch64.lo \
 	elf64-aarch64.lo \
 	aix5ppc-core.lo \
 	aout64.lo \
@@ -1068,7 +1069,7 @@ SOURCE_CFILES = \
 	$(OPTIONAL_BACKENDS_CFILES)
 
 BUILD_CFILES = \
-	elf64-aarch64.c \
+	elf32-aarch64.c elf64-aarch64.c \
 	elf32-ia64.c elf64-ia64.c peigen.c pepigen.c pex64igen.c
 
 CFILES = $(SOURCE_CFILES) $(BUILD_CFILES)
@@ -1397,6 +1398,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf-strtab.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf-vxworks.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-aarch64.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-am33lin.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-arc.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf32-arm.Plo@am__quote@
@@ -1989,6 +1991,11 @@ elf64-target.h : elfxx-target.h
 	sed -e s/NN/64/g < $(srcdir)/elfxx-target.h > elf64-target.new
 	mv -f elf64-target.new elf64-target.h
 
+elf32-aarch64.c : elfnn-aarch64.c
+	rm -f elf32-aarch64.c
+	sed -e s/NN/32/g < $(srcdir)/elfnn-aarch64.c > elf32-aarch64.new
+	mv -f elf32-aarch64.new elf32-aarch64.c
+
 elf64-aarch64.c : elfnn-aarch64.c
 	rm -f elf64-aarch64.c
 	sed -e s/NN/64/g < $(srcdir)/elfnn-aarch64.c > elf64-aarch64.new
diff --git a/bfd/archures.c b/bfd/archures.c
index f7cef8b..d00b0e1 100644
--- a/bfd/archures.c
+++ b/bfd/archures.c
@@ -475,6 +475,7 @@ DESCRIPTION
 .#define bfd_mach_tilegx32  2
 .  bfd_arch_aarch64,   {* AArch64  *}
 .#define bfd_mach_aarch64 0
+.#define bfd_mach_aarch64_ilp32	32
 .  bfd_arch_nios2,
 .#define bfd_mach_nios2	0
 .  bfd_arch_last
diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h
index 03cac6e..579b007 100644
--- a/bfd/bfd-in.h
+++ b/bfd/bfd-in.h
@@ -933,9 +933,15 @@ extern unsigned int _bfd_elf_ppc_at_tprel_transform
 extern void bfd_elf64_aarch64_init_maps
   (bfd *);
 
+extern void bfd_elf32_aarch64_init_maps
+  (bfd *);
+
 extern void bfd_elf64_aarch64_set_options
   (bfd *, struct bfd_link_info *, int, int, int);
 
+extern void bfd_elf32_aarch64_set_options
+  (bfd *, struct bfd_link_info *, int, int, int);
+
 /* ELF AArch64 mapping symbol support.  */
 #define BFD_AARCH64_SPECIAL_SYM_TYPE_MAP	(1 << 0)
 #define BFD_AARCH64_SPECIAL_SYM_TYPE_TAG	(1 << 1)
@@ -944,7 +950,7 @@ extern void bfd_elf64_aarch64_set_options
 extern bfd_boolean bfd_is_aarch64_special_symbol_name
   (const char * name, int type);
 
-/* AArch64 stub generation support.  Called from the linker.  */
+/* AArch64 stub generation support for ELF64.  Called from the linker.  */
 extern int elf64_aarch64_setup_section_lists
   (bfd *, struct bfd_link_info *);
 extern void elf64_aarch64_next_input_section
@@ -955,6 +961,18 @@ extern bfd_boolean elf64_aarch64_size_stubs
    void (*) (void));
 extern bfd_boolean elf64_aarch64_build_stubs
   (struct bfd_link_info *);
+/* AArch64 stub generation support for ELF32.  Called from the linker.  */
+extern int elf32_aarch64_setup_section_lists
+  (bfd *, struct bfd_link_info *);
+extern void elf32_aarch64_next_input_section
+  (struct bfd_link_info *, struct bfd_section *);
+extern bfd_boolean elf32_aarch64_size_stubs
+  (bfd *, bfd *, struct bfd_link_info *, bfd_signed_vma,
+   struct bfd_section * (*) (const char *, struct bfd_section *),
+   void (*) (void));
+extern bfd_boolean elf32_aarch64_build_stubs
+  (struct bfd_link_info *);
+
 
 /* TI COFF load page support.  */
 extern void bfd_ticoff_set_section_load_page
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index a20abc0..e4a5dcc 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -940,9 +940,15 @@ extern unsigned int _bfd_elf_ppc_at_tprel_transform
 extern void bfd_elf64_aarch64_init_maps
   (bfd *);
 
+extern void bfd_elf32_aarch64_init_maps
+  (bfd *);
+
 extern void bfd_elf64_aarch64_set_options
   (bfd *, struct bfd_link_info *, int, int, int);
 
+extern void bfd_elf32_aarch64_set_options
+  (bfd *, struct bfd_link_info *, int, int, int);
+
 /* ELF AArch64 mapping symbol support.  */
 #define BFD_AARCH64_SPECIAL_SYM_TYPE_MAP	(1 << 0)
 #define BFD_AARCH64_SPECIAL_SYM_TYPE_TAG	(1 << 1)
@@ -951,7 +957,7 @@ extern void bfd_elf64_aarch64_set_options
 extern bfd_boolean bfd_is_aarch64_special_symbol_name
   (const char * name, int type);
 
-/* AArch64 stub generation support.  Called from the linker.  */
+/* AArch64 stub generation support for ELF64.  Called from the linker.  */
 extern int elf64_aarch64_setup_section_lists
   (bfd *, struct bfd_link_info *);
 extern void elf64_aarch64_next_input_section
@@ -962,6 +968,18 @@ extern bfd_boolean elf64_aarch64_size_stubs
    void (*) (void));
 extern bfd_boolean elf64_aarch64_build_stubs
   (struct bfd_link_info *);
+/* AArch64 stub generation support for ELF32.  Called from the linker.  */
+extern int elf32_aarch64_setup_section_lists
+  (bfd *, struct bfd_link_info *);
+extern void elf32_aarch64_next_input_section
+  (struct bfd_link_info *, struct bfd_section *);
+extern bfd_boolean elf32_aarch64_size_stubs
+  (bfd *, bfd *, struct bfd_link_info *, bfd_signed_vma,
+   struct bfd_section * (*) (const char *, struct bfd_section *),
+   void (*) (void));
+extern bfd_boolean elf32_aarch64_build_stubs
+  (struct bfd_link_info *);
+
 
 /* TI COFF load page support.  */
 extern void bfd_ticoff_set_section_load_page
@@ -2214,6 +2232,7 @@ enum bfd_architecture
 #define bfd_mach_tilegx32  2
   bfd_arch_aarch64,   /* AArch64  */
 #define bfd_mach_aarch64 0
+#define bfd_mach_aarch64_ilp32 32
   bfd_arch_nios2,
 #define bfd_mach_nios2 0
   bfd_arch_last
diff --git a/bfd/config.bfd b/bfd/config.bfd
index 8fb1bb8..5324d39 100644
--- a/bfd/config.bfd
+++ b/bfd/config.bfd
@@ -164,22 +164,22 @@ case "${targ}" in
 #ifdef BFD64
   aarch64-*-elf)
     targ_defvec=bfd_elf64_littleaarch64_vec
-    targ_selvecs="bfd_elf64_bigaarch64_vec bfd_elf32_littlearm_vec bfd_elf32_bigarm_vec"
+    targ_selvecs="bfd_elf64_bigaarch64_vec bfd_elf32_littleaarch64_vec bfd_elf32_bigaarch64_vec bfd_elf32_littlearm_vec bfd_elf32_bigarm_vec"
     want64=true
     ;;
   aarch64_be-*-elf)
     targ_defvec=bfd_elf64_bigaarch64_vec
-    targ_selvecs="bfd_elf64_littleaarch64_vec bfd_elf32_bigarm_vec bfd_elf32_littlearm_vec"
+    targ_selvecs="bfd_elf64_littleaarch64_vec bfd_elf32_littleaarch64_vec bfd_elf32_bigaarch64_vec bfd_elf32_bigarm_vec bfd_elf32_littlearm_vec"
     want64=true
     ;;
   aarch64-*-linux*)
     targ_defvec=bfd_elf64_littleaarch64_vec
-    targ_selvecs="bfd_elf64_bigaarch64_vec bfd_elf32_littlearm_vec bfd_elf32_bigarm_vec"
+    targ_selvecs="bfd_elf64_bigaarch64_vec bfd_elf32_littleaarch64_vec bfd_elf32_bigaarch64_vec bfd_elf32_littlearm_vec bfd_elf32_bigarm_vec"
     want64=true
     ;;
   aarch64_be-*-linux*)
     targ_defvec=bfd_elf64_bigaarch64_vec
-    targ_selvecs="bfd_elf64_littleaarch64_vec bfd_elf32_bigarm_vec bfd_elf32_littlearm_vec"
+    targ_selvecs="bfd_elf64_littleaarch64_vec bfd_elf32_littleaarch64_vec bfd_elf32_bigaarch64_vec bfd_elf32_bigarm_vec bfd_elf32_littlearm_vec"
     want64=true
     ;;
   alpha*-*-freebsd* | alpha*-*-kfreebsd*-gnu)
diff --git a/bfd/configure b/bfd/configure
index 090f981..5ae4b0a 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -15365,6 +15365,7 @@ do
     bfd_elf64_alpha_freebsd_vec) tb="$tb elf64-alpha.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_alpha_vec)	tb="$tb elf64-alpha.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_bigaarch64_vec)	tb="$tb elf64-aarch64.lo elf64.lo $elf"; target_size=64 ;;
+    bfd_elf32_bigaarch64_vec)	tb="$tb elf32-aarch64.lo elf32.lo $elf"; target_size=64 ;;
     bfd_elf64_big_generic_vec) 	tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_bigmips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_hppa_linux_vec)	tb="$tb elf64-hppa.lo elf64.lo $elf"; target_size=64 ;;
@@ -15374,6 +15375,7 @@ do
     bfd_elf64_ia64_little_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;
     bfd_elf64_littleaarch64_vec)tb="$tb elf64-aarch64.lo elf64.lo $elf"; target_size=64 ;;
+    bfd_elf32_littleaarch64_vec)tb="$tb elf32-aarch64.lo elf32.lo $elf"; target_size=64 ;;
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_littlemips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_mmix_vec) 	tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;;
diff --git a/bfd/configure.in b/bfd/configure.in
index ff14270..1cf71f4 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -860,6 +860,7 @@ do
     bfd_elf64_alpha_freebsd_vec) tb="$tb elf64-alpha.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_alpha_vec)	tb="$tb elf64-alpha.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_bigaarch64_vec)	tb="$tb elf64-aarch64.lo elf64.lo $elf"; target_size=64 ;;
+    bfd_elf32_bigaarch64_vec)	tb="$tb elf32-aarch64.lo elf32.lo $elf"; target_size=64 ;;
     bfd_elf64_big_generic_vec) 	tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_bigmips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_hppa_linux_vec)	tb="$tb elf64-hppa.lo elf64.lo $elf"; target_size=64 ;;
@@ -869,6 +870,7 @@ do
     bfd_elf64_ia64_little_vec)	tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_ia64_vms_vec)	tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;;    
     bfd_elf64_littleaarch64_vec)tb="$tb elf64-aarch64.lo elf64.lo $elf"; target_size=64 ;;
+    bfd_elf32_littleaarch64_vec)tb="$tb elf32-aarch64.lo elf32.lo $elf"; target_size=64 ;;
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;;
     bfd_elf64_littlemips_vec) 	tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;;
     bfd_elf64_mmix_vec) 	tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;;
diff --git a/bfd/cpu-aarch64.c b/bfd/cpu-aarch64.c
index 8162037..9ec18a0 100644
--- a/bfd/cpu-aarch64.c
+++ b/bfd/cpu-aarch64.c
@@ -38,6 +38,10 @@ compatible (const bfd_arch_info_type * a, const bfd_arch_info_type * b)
   if (a->mach == b->mach)
     return a;
 
+  /* Don't allow mixing ilp32 with lp64.  */
+  if ((a->mach & bfd_mach_aarch64_ilp32) != (b->mach & bfd_mach_aarch64_ilp32))
+    return NULL;
+
   /* Otherwise if either a or b is the 'default' machine
      then it can be polymorphed into the other.  */
   if (a->the_default)
@@ -101,9 +105,11 @@ scan (const struct bfd_arch_info *info, const char *string)
     "aarch64", PRINT, 4, DEFAULT, compatible, scan,		\
     bfd_arch_default_fill, NEXT }
 
-const bfd_arch_info_type bfd_aarch64_arch =
-  N (0, "aarch64", TRUE, NULL);
+static const bfd_arch_info_type bfd_aarch64_arch_ilp32 =
+  N (bfd_mach_aarch64_ilp32, "aarch64:ilp32", FALSE, NULL);
 
+const bfd_arch_info_type bfd_aarch64_arch =
+  N (0, "aarch64", TRUE, &bfd_aarch64_arch_ilp32);
 
 bfd_boolean
 bfd_is_aarch64_special_symbol_name (const char *name, int type)
diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index 5d926a4..60a8558 100644
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -1,5 +1,5 @@
-/* ELF support for AArch64.
-   Copyright 2009-2013 Free Software Foundation, Inc.
+/* AArch64-specific support for NN-bit ELF.
+   Copyright 2009-2013  Free Software Foundation, Inc.
    Contributed by ARM Ltd.
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -92,7 +92,7 @@
 
   The flow:
 
-  aarch64_check_relocs()
+  elfNN_aarch64_check_relocs()
 
   This function is invoked for each relocation.
 
@@ -104,7 +104,7 @@
   The reference count for a symbol is incremented.  The GOT type for
   each symbol is marked as general dynamic.
 
-  elf64_aarch64_allocate_dynrelocs ()
+  elfNN_aarch64_allocate_dynrelocs ()
 
   For each global with positive reference count we allocate a double
   GOT slot. For a traditional TLS symbol we allocate space for two
@@ -112,16 +112,16 @@
   allocate space for one relocation on the slot. Record the GOT offset
   for this symbol.
 
-  elf64_aarch64_size_dynamic_sections ()
+  elfNN_aarch64_size_dynamic_sections ()
 
   Iterate all input BFDS, look for in the local symbol data structure
   constructed earlier for local TLS symbols and allocate them double
   GOT slots along with space for a single GOT relocation. Update the
   local symbol structure to record the GOT offset allocated.
 
-  elf64_aarch64_relocate_section ()
+  elfNN_aarch64_relocate_section ()
 
-  Calls elf64_aarch64_final_link_relocate ()
+  Calls elfNN_aarch64_final_link_relocate ()
 
   Emit the relevant TLS relocations against the GOT for each TLS
   symbol. For local TLS symbols emit the GOT offset directly. The GOT
@@ -131,7 +131,7 @@
   emitted. All of the TLS code that uses the GOT offset needs to take
   care to mask out this flag bit before using the offset.
 
-  elf64_aarch64_final_link_relocate ()
+  elfNN_aarch64_final_link_relocate ()
 
   Fixup the R_AARCH64_TLSGD_{ADR_PREL21, ADD_LO12_NC} relocations.  */
 
@@ -144,6 +144,20 @@
 #include "bfdlink.h"
 #include "elf/aarch64.h"
 
+#define ARCH_SIZE	NN
+
+#if ARCH_SIZE == 64
+#define AARCH64_R(NAME)		R_AARCH64_ ## NAME
+#define AARCH64_R_STR(NAME)	"R_AARCH64_" #NAME
+#define LOG_FILE_ALIGN	3
+#endif
+
+#if ARCH_SIZE == 32
+#define AARCH64_R(NAME)		R_AARCH64_P32_ ## NAME
+#define AARCH64_R_STR(NAME)	"R_AARCH64_P32_" #NAME
+#define LOG_FILE_ALIGN	2
+#endif
+
 static bfd_reloc_status_type
 bfd_elf_aarch64_put_addend (bfd *abfd,
 			    bfd_byte *address,
@@ -186,11 +200,11 @@ bfd_elf_aarch64_put_addend (bfd *abfd,
 #define ELIMINATE_COPY_RELOCS 0
 
 /* Return size of a relocation entry.  HTAB is the bfd's
-   elf64_aarch64_link_hash_entry.  */
-#define RELOC_SIZE(HTAB) (sizeof (Elf64_External_Rela))
+   elf_aarch64_link_hash_entry.  */
+#define RELOC_SIZE(HTAB) (sizeof (ElfNN_External_Rela))
 
-/* GOT Entry size - 8 bytes.  */
-#define GOT_ENTRY_SIZE                  (8)
+/* GOT Entry size - 8 bytes in ELF64 and 4 bytes in ELF32.  */
+#define GOT_ENTRY_SIZE                  (ARCH_SIZE / 8)
 #define PLT_ENTRY_SIZE                  (32)
 #define PLT_SMALL_ENTRY_SIZE            (16)
 #define PLT_TLSDESC_ENTRY_SIZE          (32)
@@ -210,8 +224,8 @@ bfd_elf_aarch64_put_addend (bfd *abfd,
    if the distance between the PLTGOT and the PLT is < 4GB use
    these PLT entries. Note that the dynamic linker gets &PLTGOT[2]
    in x16 and needs to work out PLTGOT[1] by using an address of
-   [x16,#-8].  */
-static const bfd_byte elf64_aarch64_small_plt0_entry[PLT_ENTRY_SIZE] =
+   [x16,#-GOT_ENTRY_SIZE].  */
+static const bfd_byte elfNN_aarch64_small_plt0_entry[PLT_ENTRY_SIZE] =
 {
   0xf0, 0x7b, 0xbf, 0xa9,	/* stp x16, x30, [sp, #-16]!  */
   0x10, 0x00, 0x00, 0x90,	/* adrp x16, (GOT+16)  */
@@ -226,7 +240,7 @@ static const bfd_byte elf64_aarch64_small_plt0_entry[PLT_ENTRY_SIZE] =
 /* Per function entry in a procedure linkage table looks like this
    if the distance between the PLTGOT and the PLT is < 4GB use
    these PLT entries.  */
-static const bfd_byte elf64_aarch64_small_plt_entry[PLT_SMALL_ENTRY_SIZE] =
+static const bfd_byte elfNN_aarch64_small_plt_entry[PLT_SMALL_ENTRY_SIZE] =
 {
   0x10, 0x00, 0x00, 0x90,	/* adrp x16, PLTGOT + n * 8  */
   0x11, 0x02, 0x40, 0xf9,	/* ldr x17, [x16, PLTGOT + n * 8] */
@@ -235,7 +249,7 @@ static const bfd_byte elf64_aarch64_small_plt_entry[PLT_SMALL_ENTRY_SIZE] =
 };
 
 static const bfd_byte
-elf64_aarch64_tlsdesc_small_plt_entry[PLT_TLSDESC_ENTRY_SIZE] =
+elfNN_aarch64_tlsdesc_small_plt_entry[PLT_TLSDESC_ENTRY_SIZE] =
 {
   0xe2, 0x0f, 0xbf, 0xa9,	/* stp x2, x3, [sp, #-16]! */
   0x02, 0x00, 0x00, 0x90,	/* adrp x2, 0 */
@@ -247,8 +261,8 @@ elf64_aarch64_tlsdesc_small_plt_entry[PLT_TLSDESC_ENTRY_SIZE] =
   0x1f, 0x20, 0x03, 0xd5,	/* nop */
 };
 
-#define elf_info_to_howto               elf64_aarch64_info_to_howto
-#define elf_info_to_howto_rel           elf64_aarch64_info_to_howto
+#define elf_info_to_howto               elfNN_aarch64_info_to_howto
+#define elf_info_to_howto_rel           elfNN_aarch64_info_to_howto
 
 #define AARCH64_ELF_ABI_VERSION		0
 
@@ -929,8 +943,8 @@ static reloc_howto_type elf64_aarch64_howto_table[] =
 	 0x1fffff,		/* dst_mask */
 	 TRUE),			/* pcrel_offset */
 
-  /* LD64: GOT offset G(S) & 0xff8 */
-  HOWTO (R_AARCH64_LD64_GOT_LO12_NC,	/* type */
+  /* LDNN: GOT offset G(S) & 0xff8 */
+  HOWTO (R_AARCH64_LDNN_GOT_LO12_NC,	/* type */
 	 3,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 12,			/* bitsize */
@@ -938,7 +952,7 @@ static reloc_howto_type elf64_aarch64_howto_table[] =
 	 0,			/* bitpos */
 	 complain_overflow_dont,	/* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
-	 "R_AARCH64_LD64_GOT_LO12_NC",	/* name */
+	 "R_AARCH64_LDNN_GOT_LO12_NC",	/* name */
 	 FALSE,			/* partial_inplace */
 	 0xff8,			/* src_mask */
 	 0xff8,			/* dst_mask */
@@ -1336,8 +1350,16 @@ static reloc_howto_type elf64_aarch64_tlsdesc_howto_table[] =
 };
 
 static reloc_howto_type *
-elf64_aarch64_howto_from_type (unsigned int r_type)
+elfNN_aarch64_howto_from_type (unsigned int r_type)
 {
+#if ARCH_SIZE == 32
+  if (r_type > 256)
+    {
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
+#endif
+
   if (r_type >= R_AARCH64_static_min && r_type < R_AARCH64_static_max)
     return &elf64_aarch64_howto_table[r_type - R_AARCH64_static_min];
 
@@ -1361,13 +1383,13 @@ elf64_aarch64_howto_from_type (unsigned int r_type)
 }
 
 static void
-elf64_aarch64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
+elfNN_aarch64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
 			     Elf_Internal_Rela *elf_reloc)
 {
   unsigned int r_type;
 
-  r_type = ELF64_R_TYPE (elf_reloc->r_info);
-  bfd_reloc->howto = elf64_aarch64_howto_from_type (r_type);
+  r_type = ELFNN_R_TYPE (elf_reloc->r_info);
+  bfd_reloc->howto = elfNN_aarch64_howto_from_type (r_type);
 }
 
 struct elf64_aarch64_reloc_map
@@ -1474,7 +1496,7 @@ static const struct elf64_aarch64_reloc_map elf64_aarch64_reloc_map[] =
 };
 
 static reloc_howto_type *
-elf64_aarch64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+elfNN_aarch64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 				 bfd_reloc_code_real_type code)
 {
   unsigned int i;
@@ -1489,7 +1511,7 @@ elf64_aarch64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 }
 
 static reloc_howto_type *
-elf64_aarch64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+elfNN_aarch64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 				 const char *r_name)
 {
   unsigned int i;
@@ -1536,10 +1558,10 @@ elf64_aarch64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 					  size, note->descpos + offset);
 }
 
-#define TARGET_LITTLE_SYM               bfd_elf64_littleaarch64_vec
-#define TARGET_LITTLE_NAME              "elf64-littleaarch64"
-#define TARGET_BIG_SYM                  bfd_elf64_bigaarch64_vec
-#define TARGET_BIG_NAME                 "elf64-bigaarch64"
+#define TARGET_LITTLE_SYM               bfd_elfNN_littleaarch64_vec
+#define TARGET_LITTLE_NAME              "elfNN-littleaarch64"
+#define TARGET_BIG_SYM                  bfd_elfNN_bigaarch64_vec
+#define TARGET_BIG_NAME                 "elfNN-bigaarch64"
 
 #define elf_backend_grok_prstatus	elf64_aarch64_grok_prstatus
 
@@ -1589,12 +1611,16 @@ static const uint32_t aarch64_adrp_branch_stub [] =
 
 static const uint32_t aarch64_long_branch_stub[] =
 {
+#if ARCH_SIZE == 64
   0x58000090,			/*	ldr   ip0, 1f */
+#else
+  0x18000090,			/*	ldr   wip0, 1f */
+#endif
   0x10000011,			/*	adr   ip1, #0 */
   0x8b110210,			/*	add   ip0, ip0, ip1 */
   0xd61f0200,			/*	br	ip0 */
-  0x00000000,			/* 1:	.xword
-				   R_AARCH64_PREL64(X) + 12
+  0x00000000,			/* 1:	.xword or .word
+				   R_AARCH64_PRELNN(X) + 12
 				 */
   0x00000000,
 };
@@ -1603,14 +1629,14 @@ static const uint32_t aarch64_long_branch_stub[] =
    string.  */
 #define STUB_SUFFIX ".stub"
 
-enum elf64_aarch64_stub_type
+enum elf_aarch64_stub_type
 {
   aarch64_stub_none,
   aarch64_stub_adrp_branch,
   aarch64_stub_long_branch,
 };
 
-struct elf64_aarch64_stub_hash_entry
+struct elf_aarch64_stub_hash_entry
 {
   /* Base hash table entry structure.  */
   struct bfd_hash_entry root;
@@ -1626,10 +1652,10 @@ struct elf64_aarch64_stub_hash_entry
   bfd_vma target_value;
   asection *target_section;
 
-  enum elf64_aarch64_stub_type stub_type;
+  enum elf_aarch64_stub_type stub_type;
 
   /* The symbol table entry, if any, that this was derived from.  */
-  struct elf64_aarch64_link_hash_entry *h;
+  struct elf_aarch64_link_hash_entry *h;
 
   /* Destination symbol type */
   unsigned char st_type;
@@ -1647,12 +1673,12 @@ struct elf64_aarch64_stub_hash_entry
 /* Used to build a map of a section.  This is required for mixed-endian
    code/data.  */
 
-typedef struct elf64_elf_section_map
+typedef struct elf_elf_section_map
 {
   bfd_vma vma;
   char type;
 }
-elf64_aarch64_section_map;
+elf_aarch64_section_map;
 
 
 typedef struct _aarch64_elf_section_data
@@ -1660,11 +1686,11 @@ typedef struct _aarch64_elf_section_data
   struct bfd_elf_section_data elf;
   unsigned int mapcount;
   unsigned int mapsize;
-  elf64_aarch64_section_map *map;
+  elf_aarch64_section_map *map;
 }
 _aarch64_elf_section_data;
 
-#define elf64_aarch64_section_data(sec) \
+#define elf_aarch64_section_data(sec) \
   ((_aarch64_elf_section_data *) elf_section_data (sec))
 
 /* The size of the thread control block.  */
@@ -1702,7 +1728,7 @@ struct elf_aarch64_obj_tdata
 #define elf_aarch64_tdata(bfd)				\
   ((struct elf_aarch64_obj_tdata *) (bfd)->tdata.any)
 
-#define elf64_aarch64_locals(bfd) (elf_aarch64_tdata (bfd)->locals)
+#define elf_aarch64_locals(bfd) (elf_aarch64_tdata (bfd)->locals)
 
 #define is_aarch64_elf(bfd)				\
   (bfd_get_flavour (bfd) == bfd_target_elf_flavour	\
@@ -1710,14 +1736,14 @@ struct elf_aarch64_obj_tdata
    && elf_object_id (bfd) == AARCH64_ELF_DATA)
 
 static bfd_boolean
-elf64_aarch64_mkobject (bfd *abfd)
+elfNN_aarch64_mkobject (bfd *abfd)
 {
   return bfd_elf_allocate_object (abfd, sizeof (struct elf_aarch64_obj_tdata),
 				  AARCH64_ELF_DATA);
 }
 
-#define elf64_aarch64_hash_entry(ent) \
-  ((struct elf64_aarch64_link_hash_entry *)(ent))
+#define elf_aarch64_hash_entry(ent) \
+  ((struct elf_aarch64_link_hash_entry *)(ent))
 
 #define GOT_UNKNOWN    0
 #define GOT_NORMAL     1
@@ -1728,7 +1754,7 @@ elf64_aarch64_mkobject (bfd *abfd)
 #define GOT_TLS_GD_ANY_P(type)	((type & GOT_TLS_GD) || (type & GOT_TLSDESC_GD))
 
 /* AArch64 ELF linker hash entry.  */
-struct elf64_aarch64_link_hash_entry
+struct elf_aarch64_link_hash_entry
 {
   struct elf_link_hash_entry root;
 
@@ -1746,7 +1772,7 @@ struct elf64_aarch64_link_hash_entry
 
   /* A pointer to the most recently used stub hash entry against this
      symbol.  */
-  struct elf64_aarch64_stub_hash_entry *stub_cache;
+  struct elf_aarch64_stub_hash_entry *stub_cache;
 
   /* Offset of the GOTPLT entry reserved for the TLS descriptor.  The offset
      is from the end of the jump table and reserved entries within the PLTGOT.
@@ -1757,29 +1783,29 @@ struct elf64_aarch64_link_hash_entry
 };
 
 static unsigned int
-elf64_aarch64_symbol_got_type (struct elf_link_hash_entry *h,
+elfNN_aarch64_symbol_got_type (struct elf_link_hash_entry *h,
 			       bfd *abfd,
 			       unsigned long r_symndx)
 {
   if (h)
-    return elf64_aarch64_hash_entry (h)->got_type;
+    return elf_aarch64_hash_entry (h)->got_type;
 
-  if (! elf64_aarch64_locals (abfd))
+  if (! elf_aarch64_locals (abfd))
     return GOT_UNKNOWN;
 
-  return elf64_aarch64_locals (abfd)[r_symndx].got_type;
+  return elf_aarch64_locals (abfd)[r_symndx].got_type;
 }
 
 /* Get the AArch64 elf linker hash table from a link_info structure.  */
-#define elf64_aarch64_hash_table(info)					\
-  ((struct elf64_aarch64_link_hash_table *) ((info)->hash))
+#define elf_aarch64_hash_table(info)					\
+  ((struct elf_aarch64_link_hash_table *) ((info)->hash))
 
 #define aarch64_stub_hash_lookup(table, string, create, copy)		\
-  ((struct elf64_aarch64_stub_hash_entry *)				\
+  ((struct elf_aarch64_stub_hash_entry *)				\
    bfd_hash_lookup ((table), (string), (create), (copy)))
 
 /* AArch64 ELF linker hash table.  */
-struct elf64_aarch64_link_hash_table
+struct elf_aarch64_link_hash_table
 {
   /* The main hash table.  */
   struct elf_link_hash_table root;
@@ -1828,7 +1854,7 @@ struct elf64_aarch64_link_hash_table
     asection *stub_sec;
   } *stub_group;
 
-  /* Assorted information used by elf64_aarch64_size_stubs.  */
+  /* Assorted information used by elfNN_aarch64_size_stubs.  */
   unsigned int bfd_count;
   int top_index;
   asection **input_list;
@@ -1884,23 +1910,23 @@ aarch64_signed_overflow (bfd_vma value, unsigned int bits)
 /* Create an entry in an AArch64 ELF linker hash table.  */
 
 static struct bfd_hash_entry *
-elf64_aarch64_link_hash_newfunc (struct bfd_hash_entry *entry,
+elfNN_aarch64_link_hash_newfunc (struct bfd_hash_entry *entry,
 				 struct bfd_hash_table *table,
 				 const char *string)
 {
-  struct elf64_aarch64_link_hash_entry *ret =
-    (struct elf64_aarch64_link_hash_entry *) entry;
+  struct elf_aarch64_link_hash_entry *ret =
+    (struct elf_aarch64_link_hash_entry *) entry;
 
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   if (ret == NULL)
     ret = bfd_hash_allocate (table,
-			     sizeof (struct elf64_aarch64_link_hash_entry));
+			     sizeof (struct elf_aarch64_link_hash_entry));
   if (ret == NULL)
     return (struct bfd_hash_entry *) ret;
 
   /* Call the allocation method of the superclass.  */
-  ret = ((struct elf64_aarch64_link_hash_entry *)
+  ret = ((struct elf_aarch64_link_hash_entry *)
 	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 				     table, string));
   if (ret != NULL)
@@ -1927,7 +1953,7 @@ stub_hash_newfunc (struct bfd_hash_entry *entry,
     {
       entry = bfd_hash_allocate (table,
 				 sizeof (struct
-					 elf64_aarch64_stub_hash_entry));
+					 elf_aarch64_stub_hash_entry));
       if (entry == NULL)
 	return entry;
     }
@@ -1936,10 +1962,10 @@ stub_hash_newfunc (struct bfd_hash_entry *entry,
   entry = bfd_hash_newfunc (entry, table, string);
   if (entry != NULL)
     {
-      struct elf64_aarch64_stub_hash_entry *eh;
+      struct elf_aarch64_stub_hash_entry *eh;
 
       /* Initialize the local fields.  */
-      eh = (struct elf64_aarch64_stub_hash_entry *) entry;
+      eh = (struct elf_aarch64_stub_hash_entry *) entry;
       eh->stub_sec = NULL;
       eh->stub_offset = 0;
       eh->target_value = 0;
@@ -1956,14 +1982,14 @@ stub_hash_newfunc (struct bfd_hash_entry *entry,
 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 
 static void
-elf64_aarch64_copy_indirect_symbol (struct bfd_link_info *info,
+elfNN_aarch64_copy_indirect_symbol (struct bfd_link_info *info,
 				    struct elf_link_hash_entry *dir,
 				    struct elf_link_hash_entry *ind)
 {
-  struct elf64_aarch64_link_hash_entry *edir, *eind;
+  struct elf_aarch64_link_hash_entry *edir, *eind;
 
-  edir = (struct elf64_aarch64_link_hash_entry *) dir;
-  eind = (struct elf64_aarch64_link_hash_entry *) ind;
+  edir = (struct elf_aarch64_link_hash_entry *) dir;
+  eind = (struct elf_aarch64_link_hash_entry *) ind;
 
   if (eind->dyn_relocs != NULL)
     {
@@ -2012,18 +2038,18 @@ elf64_aarch64_copy_indirect_symbol (struct bfd_link_info *info,
 /* Create an AArch64 elf linker hash table.  */
 
 static struct bfd_link_hash_table *
-elf64_aarch64_link_hash_table_create (bfd *abfd)
+elfNN_aarch64_link_hash_table_create (bfd *abfd)
 {
-  struct elf64_aarch64_link_hash_table *ret;
-  bfd_size_type amt = sizeof (struct elf64_aarch64_link_hash_table);
+  struct elf_aarch64_link_hash_table *ret;
+  bfd_size_type amt = sizeof (struct elf_aarch64_link_hash_table);
 
   ret = bfd_zmalloc (amt);
   if (ret == NULL)
     return NULL;
 
   if (!_bfd_elf_link_hash_table_init
-      (&ret->root, abfd, elf64_aarch64_link_hash_newfunc,
-       sizeof (struct elf64_aarch64_link_hash_entry), AARCH64_ELF_DATA))
+      (&ret->root, abfd, elfNN_aarch64_link_hash_newfunc,
+       sizeof (struct elf_aarch64_link_hash_entry), AARCH64_ELF_DATA))
     {
       free (ret);
       return NULL;
@@ -2035,7 +2061,7 @@ elf64_aarch64_link_hash_table_create (bfd *abfd)
   ret->dt_tlsdesc_got = (bfd_vma) - 1;
 
   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
-			    sizeof (struct elf64_aarch64_stub_hash_entry)))
+			    sizeof (struct elf_aarch64_stub_hash_entry)))
     {
       free (ret);
       return NULL;
@@ -2047,10 +2073,10 @@ elf64_aarch64_link_hash_table_create (bfd *abfd)
 /* Free the derived linker hash table.  */
 
 static void
-elf64_aarch64_hash_table_free (struct bfd_link_hash_table *hash)
+elfNN_aarch64_hash_table_free (struct bfd_link_hash_table *hash)
 {
-  struct elf64_aarch64_link_hash_table *ret
-    = (struct elf64_aarch64_link_hash_table *) hash;
+  struct elf_aarch64_link_hash_table *ret
+    = (struct elf_aarch64_link_hash_table *) hash;
 
   bfd_hash_table_free (&ret->stub_hash_table);
   _bfd_elf_link_hash_table_free (hash);
@@ -2163,7 +2189,7 @@ aarch64_relocate (unsigned int r_type, bfd *input_bfd, asection *input_section,
   reloc_howto_type *howto;
   bfd_vma place;
 
-  howto = elf64_aarch64_howto_from_type (r_type);
+  howto = elfNN_aarch64_howto_from_type (r_type);
   place = (input_section->output_section->vma + input_section->output_offset
 	   + offset);
   value = aarch64_resolve_relocation (r_type, place, value, 0, FALSE);
@@ -2172,7 +2198,7 @@ aarch64_relocate (unsigned int r_type, bfd *input_bfd, asection *input_section,
 				     howto, value);
 }
 
-static enum elf64_aarch64_stub_type
+static enum elf_aarch64_stub_type
 aarch64_select_branch_stub (bfd_vma value, bfd_vma place)
 {
   if (aarch64_valid_for_adrp_p (value, place))
@@ -2182,25 +2208,25 @@ aarch64_select_branch_stub (bfd_vma value, bfd_vma place)
 
 /* Determine the type of stub needed, if any, for a call.  */
 
-static enum elf64_aarch64_stub_type
+static enum elf_aarch64_stub_type
 aarch64_type_of_stub (struct bfd_link_info *info,
 		      asection *input_sec,
 		      const Elf_Internal_Rela *rel,
 		      unsigned char st_type,
-		      struct elf64_aarch64_link_hash_entry *hash,
+		      struct elf_aarch64_link_hash_entry *hash,
 		      bfd_vma destination)
 {
   bfd_vma location;
   bfd_signed_vma branch_offset;
   unsigned int r_type;
-  struct elf64_aarch64_link_hash_table *globals;
-  enum elf64_aarch64_stub_type stub_type = aarch64_stub_none;
+  struct elf_aarch64_link_hash_table *globals;
+  enum elf_aarch64_stub_type stub_type = aarch64_stub_none;
   bfd_boolean via_plt_p;
 
   if (st_type != STT_FUNC)
     return stub_type;
 
-  globals = elf64_aarch64_hash_table (info);
+  globals = elf_aarch64_hash_table (info);
   via_plt_p = (globals->root.splt != NULL && hash != NULL
 	       && hash->root.plt.offset != (bfd_vma) - 1);
 
@@ -2213,7 +2239,7 @@ aarch64_type_of_stub (struct bfd_link_info *info,
 
   branch_offset = (bfd_signed_vma) (destination - location);
 
-  r_type = ELF64_R_TYPE (rel->r_info);
+  r_type = ELFNN_R_TYPE (rel->r_info);
 
   /* We don't want to redirect any old unconditional jump in this way,
      only one which is being used for a sibcall, where it is
@@ -2231,9 +2257,9 @@ aarch64_type_of_stub (struct bfd_link_info *info,
 /* Build a name for an entry in the stub hash table.  */
 
 static char *
-elf64_aarch64_stub_name (const asection *input_section,
+elfNN_aarch64_stub_name (const asection *input_section,
 			 const asection *sym_sec,
-			 const struct elf64_aarch64_link_hash_entry *hash,
+			 const struct elf_aarch64_link_hash_entry *hash,
 			 const Elf_Internal_Rela *rel)
 {
   char *stub_name;
@@ -2257,7 +2283,7 @@ elf64_aarch64_stub_name (const asection *input_section,
 	snprintf (stub_name, len, "%08x_%x:%x+%" BFD_VMA_FMT "x",
 		  (unsigned int) input_section->id,
 		  (unsigned int) sym_sec->id,
-		  (unsigned int) ELF64_R_SYM (rel->r_info),
+		  (unsigned int) ELFNN_R_SYM (rel->r_info),
 		  rel->r_addend);
     }
 
@@ -2267,16 +2293,16 @@ elf64_aarch64_stub_name (const asection *input_section,
 /* Look up an entry in the stub hash.  Stub entries are cached because
    creating the stub name takes a bit of time.  */
 
-static struct elf64_aarch64_stub_hash_entry *
-elf64_aarch64_get_stub_entry (const asection *input_section,
+static struct elf_aarch64_stub_hash_entry *
+elfNN_aarch64_get_stub_entry (const asection *input_section,
 			      const asection *sym_sec,
 			      struct elf_link_hash_entry *hash,
 			      const Elf_Internal_Rela *rel,
-			      struct elf64_aarch64_link_hash_table *htab)
+			      struct elf_aarch64_link_hash_table *htab)
 {
-  struct elf64_aarch64_stub_hash_entry *stub_entry;
-  struct elf64_aarch64_link_hash_entry *h =
-    (struct elf64_aarch64_link_hash_entry *) hash;
+  struct elf_aarch64_stub_hash_entry *stub_entry;
+  struct elf_aarch64_link_hash_entry *h =
+    (struct elf_aarch64_link_hash_entry *) hash;
   const asection *id_sec;
 
   if ((input_section->flags & SEC_CODE) == 0)
@@ -2298,7 +2324,7 @@ elf64_aarch64_get_stub_entry (const asection *input_section,
     {
       char *stub_name;
 
-      stub_name = elf64_aarch64_stub_name (id_sec, sym_sec, h, rel);
+      stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, h, rel);
       if (stub_name == NULL)
 	return NULL;
 
@@ -2316,14 +2342,14 @@ elf64_aarch64_get_stub_entry (const asection *input_section,
 /* Add a new stub entry to the stub hash.  Not all fields of the new
    stub entry are initialised.  */
 
-static struct elf64_aarch64_stub_hash_entry *
-elf64_aarch64_add_stub (const char *stub_name,
+static struct elf_aarch64_stub_hash_entry *
+elfNN_aarch64_add_stub (const char *stub_name,
 			asection *section,
-			struct elf64_aarch64_link_hash_table *htab)
+			struct elf_aarch64_link_hash_table *htab)
 {
   asection *link_sec;
   asection *stub_sec;
-  struct elf64_aarch64_stub_hash_entry *stub_entry;
+  struct elf_aarch64_stub_hash_entry *stub_entry;
 
   link_sec = htab->stub_group[section->id].link_sec;
   stub_sec = htab->stub_group[section->id].stub_sec;
@@ -2373,7 +2399,7 @@ static bfd_boolean
 aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
 			void *in_arg ATTRIBUTE_UNUSED)
 {
-  struct elf64_aarch64_stub_hash_entry *stub_entry;
+  struct elf_aarch64_stub_hash_entry *stub_entry;
   asection *stub_sec;
   bfd *stub_bfd;
   bfd_byte *loc;
@@ -2383,7 +2409,7 @@ aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
   unsigned int i;
 
   /* Massage our args to the form they really have.  */
-  stub_entry = (struct elf64_aarch64_stub_hash_entry *) gen_entry;
+  stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
 
   stub_sec = stub_entry->stub_sec;
 
@@ -2442,7 +2468,7 @@ aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
 	BFD_FAIL ();
 
       _bfd_final_link_relocate
-	(elf64_aarch64_howto_from_type (R_AARCH64_ADD_ABS_LO12_NC),
+	(elfNN_aarch64_howto_from_type (R_AARCH64_ADD_ABS_LO12_NC),
 	 stub_bfd,
 	 stub_sec,
 	 stub_sec->contents,
@@ -2454,7 +2480,7 @@ aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
     case aarch64_stub_long_branch:
       /* We want the value relative to the address 12 bytes back from the
          value itself.  */
-      _bfd_final_link_relocate (elf64_aarch64_howto_from_type
+      _bfd_final_link_relocate (elfNN_aarch64_howto_from_type
 				(R_AARCH64_PREL64), stub_bfd, stub_sec,
 				stub_sec->contents,
 				stub_entry->stub_offset + 16,
@@ -2474,11 +2500,11 @@ static bfd_boolean
 aarch64_size_one_stub (struct bfd_hash_entry *gen_entry,
 		       void *in_arg ATTRIBUTE_UNUSED)
 {
-  struct elf64_aarch64_stub_hash_entry *stub_entry;
+  struct elf_aarch64_stub_hash_entry *stub_entry;
   int size;
 
   /* Massage our args to the form they really have.  */
-  stub_entry = (struct elf64_aarch64_stub_hash_entry *) gen_entry;
+  stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
 
   switch (stub_entry->stub_type)
     {
@@ -2506,7 +2532,7 @@ aarch64_size_one_stub (struct bfd_hash_entry *gen_entry,
    0 when no stubs will be needed, and 1 on success.  */
 
 int
-elf64_aarch64_setup_section_lists (bfd *output_bfd,
+elfNN_aarch64_setup_section_lists (bfd *output_bfd,
 				   struct bfd_link_info *info)
 {
   bfd *input_bfd;
@@ -2515,8 +2541,8 @@ elf64_aarch64_setup_section_lists (bfd *output_bfd,
   asection *section;
   asection **input_list, **list;
   bfd_size_type amt;
-  struct elf64_aarch64_link_hash_table *htab =
-    elf64_aarch64_hash_table (info);
+  struct elf_aarch64_link_hash_table *htab =
+    elf_aarch64_hash_table (info);
 
   if (!is_elf_hash_table (htab))
     return 0;
@@ -2574,7 +2600,7 @@ elf64_aarch64_setup_section_lists (bfd *output_bfd,
   return 1;
 }
 
-/* Used by elf64_aarch64_next_input_section and group_sections.  */
+/* Used by elfNN_aarch64_next_input_section and group_sections.  */
 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
 
 /* The linker repeatedly calls this function for each input section,
@@ -2583,10 +2609,10 @@ elf64_aarch64_setup_section_lists (bfd *output_bfd,
    we may insert linker stubs.  */
 
 void
-elf64_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
+elfNN_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
 {
-  struct elf64_aarch64_link_hash_table *htab =
-    elf64_aarch64_hash_table (info);
+  struct elf_aarch64_link_hash_table *htab =
+    elf_aarch64_hash_table (info);
 
   if (isec->output_section->index <= htab->top_index)
     {
@@ -2611,7 +2637,7 @@ elf64_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
    the middle of a function is not a good idea.  */
 
 static void
-group_sections (struct elf64_aarch64_link_hash_table *htab,
+group_sections (struct elf_aarch64_link_hash_table *htab,
 		bfd_size_type stub_group_size,
 		bfd_boolean stubs_always_before_branch)
 {
@@ -2683,7 +2709,7 @@ group_sections (struct elf64_aarch64_link_hash_table *htab,
    instruction.  */
 
 bfd_boolean
-elf64_aarch64_size_stubs (bfd *output_bfd,
+elfNN_aarch64_size_stubs (bfd *output_bfd,
 			  bfd *stub_bfd,
 			  struct bfd_link_info *info,
 			  bfd_signed_vma group_size,
@@ -2694,7 +2720,7 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
   bfd_size_type stub_group_size;
   bfd_boolean stubs_always_before_branch;
   bfd_boolean stub_changed = 0;
-  struct elf64_aarch64_link_hash_table *htab = elf64_aarch64_hash_table (info);
+  struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info);
 
   /* Propagate mach to stub bfd, because it may not have been
      finalized when we created stub_bfd.  */
@@ -2770,20 +2796,20 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
 	      for (; irela < irelaend; irela++)
 		{
 		  unsigned int r_type, r_indx;
-		  enum elf64_aarch64_stub_type stub_type;
-		  struct elf64_aarch64_stub_hash_entry *stub_entry;
+		  enum elf_aarch64_stub_type stub_type;
+		  struct elf_aarch64_stub_hash_entry *stub_entry;
 		  asection *sym_sec;
 		  bfd_vma sym_value;
 		  bfd_vma destination;
-		  struct elf64_aarch64_link_hash_entry *hash;
+		  struct elf_aarch64_link_hash_entry *hash;
 		  const char *sym_name;
 		  char *stub_name;
 		  const asection *id_sec;
 		  unsigned char st_type;
 		  bfd_size_type len;
 
-		  r_type = ELF64_R_TYPE (irela->r_info);
-		  r_indx = ELF64_R_SYM (irela->r_info);
+		  r_type = ELFNN_R_TYPE (irela->r_info);
+		  r_indx = ELFNN_R_SYM (irela->r_info);
 
 		  if (r_type >= (unsigned int) R_AARCH64_end)
 		    {
@@ -2850,19 +2876,19 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
 		      int e_indx;
 
 		      e_indx = r_indx - symtab_hdr->sh_info;
-		      hash = ((struct elf64_aarch64_link_hash_entry *)
+		      hash = ((struct elf_aarch64_link_hash_entry *)
 			      elf_sym_hashes (input_bfd)[e_indx]);
 
 		      while (hash->root.root.type == bfd_link_hash_indirect
 			     || hash->root.root.type == bfd_link_hash_warning)
-			hash = ((struct elf64_aarch64_link_hash_entry *)
+			hash = ((struct elf_aarch64_link_hash_entry *)
 				hash->root.root.u.i.link);
 
 		      if (hash->root.root.type == bfd_link_hash_defined
 			  || hash->root.root.type == bfd_link_hash_defweak)
 			{
-			  struct elf64_aarch64_link_hash_table *globals =
-			    elf64_aarch64_hash_table (info);
+			  struct elf_aarch64_link_hash_table *globals =
+			    elf_aarch64_hash_table (info);
 			  sym_sec = hash->root.root.u.def.section;
 			  sym_value = hash->root.root.u.def.value;
 			  /* For a destination in a shared library,
@@ -2893,8 +2919,8 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
 			     target address to decide whether a long
 			     branch stub is needed.
 			     For absolute code, they cannot be handled.  */
-			  struct elf64_aarch64_link_hash_table *globals =
-			    elf64_aarch64_hash_table (info);
+			  struct elf_aarch64_link_hash_table *globals =
+			    elf_aarch64_hash_table (info);
 
 			  if (globals->root.splt != NULL && hash != NULL
 			      && hash->root.plt.offset != (bfd_vma) - 1)
@@ -2929,7 +2955,7 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
 		  id_sec = htab->stub_group[section->id].link_sec;
 
 		  /* Get the name of this stub.  */
-		  stub_name = elf64_aarch64_stub_name (id_sec, sym_sec, hash,
+		  stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, hash,
 						       irela);
 		  if (!stub_name)
 		    goto error_ret_free_internal;
@@ -2944,7 +2970,7 @@ elf64_aarch64_size_stubs (bfd *output_bfd,
 		      continue;
 		    }
 
-		  stub_entry = elf64_aarch64_add_stub (stub_name, section,
+		  stub_entry = elfNN_aarch64_add_stub (stub_name, section,
 						       htab);
 		  if (stub_entry == NULL)
 		    {
@@ -3009,13 +3035,13 @@ error_ret_free_local:
    linker.  */
 
 bfd_boolean
-elf64_aarch64_build_stubs (struct bfd_link_info *info)
+elfNN_aarch64_build_stubs (struct bfd_link_info *info)
 {
   asection *stub_sec;
   struct bfd_hash_table *table;
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
 
   for (stub_sec = htab->stub_bfd->sections;
        stub_sec != NULL; stub_sec = stub_sec->next)
@@ -3045,15 +3071,15 @@ elf64_aarch64_build_stubs (struct bfd_link_info *info)
 /* Add an entry to the code/data map for section SEC.  */
 
 static void
-elf64_aarch64_section_map_add (asection *sec, char type, bfd_vma vma)
+elfNN_aarch64_section_map_add (asection *sec, char type, bfd_vma vma)
 {
   struct _aarch64_elf_section_data *sec_data =
-    elf64_aarch64_section_data (sec);
+    elf_aarch64_section_data (sec);
   unsigned int newidx;
 
   if (sec_data->map == NULL)
     {
-      sec_data->map = bfd_malloc (sizeof (elf64_aarch64_section_map));
+      sec_data->map = bfd_malloc (sizeof (elf_aarch64_section_map));
       sec_data->mapcount = 0;
       sec_data->mapsize = 1;
     }
@@ -3064,7 +3090,7 @@ elf64_aarch64_section_map_add (asection *sec, char type, bfd_vma vma)
     {
       sec_data->mapsize *= 2;
       sec_data->map = bfd_realloc_or_free
-	(sec_data->map, sec_data->mapsize * sizeof (elf64_aarch64_section_map));
+	(sec_data->map, sec_data->mapsize * sizeof (elf_aarch64_section_map));
     }
 
   if (sec_data->map)
@@ -3077,7 +3103,7 @@ elf64_aarch64_section_map_add (asection *sec, char type, bfd_vma vma)
 
 /* Initialise maps of insn/data for input BFDs.  */
 void
-bfd_elf64_aarch64_init_maps (bfd *abfd)
+bfd_elfNN_aarch64_init_maps (bfd *abfd)
 {
   Elf_Internal_Sym *isymbuf;
   Elf_Internal_Shdr *hdr;
@@ -3116,21 +3142,21 @@ bfd_elf64_aarch64_init_maps (bfd *abfd)
 
 	  if (bfd_is_aarch64_special_symbol_name
 	      (name, BFD_AARCH64_SPECIAL_SYM_TYPE_MAP))
-	    elf64_aarch64_section_map_add (sec, name[1], isym->st_value);
+	    elfNN_aarch64_section_map_add (sec, name[1], isym->st_value);
 	}
     }
 }
 
 /* Set option values needed during linking.  */
 void
-bfd_elf64_aarch64_set_options (struct bfd *output_bfd,
+bfd_elfNN_aarch64_set_options (struct bfd *output_bfd,
 			       struct bfd_link_info *link_info,
 			       int no_enum_warn,
 			       int no_wchar_warn, int pic_veneer)
 {
-  struct elf64_aarch64_link_hash_table *globals;
+  struct elf_aarch64_link_hash_table *globals;
 
-  globals = elf64_aarch64_hash_table (link_info);
+  globals = elf_aarch64_hash_table (link_info);
   globals->pic_veneer = pic_veneer;
 
   BFD_ASSERT (is_aarch64_elf (output_bfd));
@@ -3451,7 +3477,7 @@ bfd_elf_aarch64_put_addend (bfd *abfd,
 
 static bfd_vma
 aarch64_calculate_got_entry_vma (struct elf_link_hash_entry *h,
-				 struct elf64_aarch64_link_hash_table
+				 struct elf_aarch64_link_hash_table
 				 *globals, struct bfd_link_info *info,
 				 bfd_vma value, bfd *output_bfd,
 				 bfd_boolean *unresolved_reloc_p)
@@ -3482,7 +3508,7 @@ aarch64_calculate_got_entry_vma (struct elf_link_hash_entry *h,
 	    off &= ~1;
 	  else
 	    {
-	      bfd_put_64 (output_bfd, value, basegot->contents + off);
+	      bfd_put_NN (output_bfd, value, basegot->contents + off);
 	      h->got.offset |= 1;
 	    }
 	}
@@ -3581,7 +3607,7 @@ aarch64_can_relax_tls (bfd *input_bfd,
   if (! IS_AARCH64_TLS_RELOC (r_type))
     return FALSE;
 
-  symbol_got_type = elf64_aarch64_symbol_got_type (h, input_bfd, r_symndx);
+  symbol_got_type = elfNN_aarch64_symbol_got_type (h, input_bfd, r_symndx);
   reloc_got_type = aarch64_reloc_got_type (r_type);
 
   if (symbol_got_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (reloc_got_type))
@@ -3651,7 +3677,7 @@ symbol_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h,
       /* local symbol */
       struct elf_aarch64_local_symbol *l;
 
-      l = elf64_aarch64_locals (input_bfd);
+      l = elf_aarch64_locals (input_bfd);
       return &l[r_symndx].got_offset;
     }
 }
@@ -3692,8 +3718,8 @@ symbol_tlsdesc_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h,
      referred to in h.  */
   if (h != NULL)
     {
-      struct elf64_aarch64_link_hash_entry *eh;
-      eh = (struct elf64_aarch64_link_hash_entry *) h;
+      struct elf_aarch64_link_hash_entry *eh;
+      eh = (struct elf_aarch64_link_hash_entry *) h;
       return &eh->tlsdesc_got_jump_table_offset;
     }
   else
@@ -3701,7 +3727,7 @@ symbol_tlsdesc_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h,
       /* local symbol */
       struct elf_aarch64_local_symbol *l;
 
-      l = elf64_aarch64_locals (input_bfd);
+      l = elf_aarch64_locals (input_bfd);
       return &l[r_symndx].tlsdesc_got_jump_table_offset;
     }
 }
@@ -3737,7 +3763,7 @@ symbol_tlsdesc_got_offset (bfd *input_bfd, struct elf_link_hash_entry *h,
 
 /* Perform a relocation as part of a final link.  */
 static bfd_reloc_status_type
-elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
+elfNN_aarch64_final_link_relocate (reloc_howto_type *howto,
 				   bfd *input_bfd,
 				   bfd *output_bfd,
 				   asection *input_section,
@@ -3756,21 +3782,21 @@ elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
   bfd_byte *hit_data = contents + rel->r_offset;
   bfd_vma place;
   bfd_signed_vma signed_addend;
-  struct elf64_aarch64_link_hash_table *globals;
+  struct elf_aarch64_link_hash_table *globals;
   bfd_boolean weak_undef_p;
 
-  globals = elf64_aarch64_hash_table (info);
+  globals = elf_aarch64_hash_table (info);
 
   BFD_ASSERT (is_aarch64_elf (input_bfd));
 
-  r_symndx = ELF64_R_SYM (rel->r_info);
+  r_symndx = ELFNN_R_SYM (rel->r_info);
 
   /* It is possible to have linker relaxations on some TLS access
      models.  Update our information here.  */
   r_type = aarch64_tls_transition (input_bfd, info, r_type, h, r_symndx);
 
   if (r_type != howto->type)
-    howto = elf64_aarch64_howto_from_type (r_type);
+    howto = elfNN_aarch64_howto_from_type (r_type);
 
   place = input_section->output_section->vma
     + input_section->output_offset + rel->r_offset;
@@ -3836,7 +3862,7 @@ elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
 	  else if (h != NULL
 		   && h->dynindx != -1
 		   && (!info->shared || !info->symbolic || !h->def_regular))
-	    outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
+	    outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
 	  else
 	    {
 	      int symbol;
@@ -3845,12 +3871,12 @@ elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
 		 relocate the text and data segments independently,
 		 so the symbol does not matter.  */
 	      symbol = 0;
-	      outrel.r_info = ELF64_R_INFO (symbol, R_AARCH64_RELATIVE);
+	      outrel.r_info = ELFNN_R_INFO (symbol, R_AARCH64_RELATIVE);
 	      outrel.r_addend += value;
 	    }
 
 	  loc = sreloc->contents + sreloc->reloc_count++ * RELOC_SIZE (htab);
-	  bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
+	  bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
 
 	  if (sreloc->reloc_count * RELOC_SIZE (htab) > sreloc->size)
 	    {
@@ -3913,8 +3939,8 @@ elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
 	      {
 		/* The target is out of reach, so redirect the branch to
 		   the local stub for this function.  */
-		struct elf64_aarch64_stub_hash_entry *stub_entry;
-		stub_entry = elf64_aarch64_get_stub_entry (input_section,
+		struct elf_aarch64_stub_hash_entry *stub_entry;
+		stub_entry = elfNN_aarch64_get_stub_entry (input_section,
 							   sym_sec, h,
 							   rel, globals);
 		if (stub_entry != NULL)
@@ -4045,12 +4071,12 @@ elf64_aarch64_final_link_relocate (reloc_howto_type *howto,
    case of error.  */
 
 static bfd_reloc_status_type
-elf64_aarch64_tls_relax (struct elf64_aarch64_link_hash_table *globals,
+elfNN_aarch64_tls_relax (struct elf_aarch64_link_hash_table *globals,
 			 bfd *input_bfd, bfd_byte *contents,
 			 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h)
 {
   bfd_boolean is_local = h == NULL;
-  unsigned int r_type = ELF64_R_TYPE (rel->r_info);
+  unsigned int r_type = ELFNN_R_TYPE (rel->r_info);
   unsigned long insn;
 
   BFD_ASSERT (globals && input_bfd && contents && rel);
@@ -4111,7 +4137,7 @@ elf64_aarch64_tls_relax (struct elf64_aarch64_link_hash_table *globals,
 
 	  /* First kill the tls_get_addr reloc on the bl instruction.  */
 	  BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
-	  rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_AARCH64_NONE);
+	  rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
 
 	  bfd_putl32 (0xf2800000, contents + rel->r_offset);
 	  bfd_putl32 (0xd53bd041, contents + rel->r_offset + 4);
@@ -4127,10 +4153,10 @@ elf64_aarch64_tls_relax (struct elf64_aarch64_link_hash_table *globals,
 	     NOP                        => add  x0, x1, x0
 	   */
 
-	  BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_AARCH64_CALL26);
+	  BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == R_AARCH64_CALL26);
 
 	  /* Remove the relocation on the BL instruction.  */
-	  rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_AARCH64_NONE);
+	  rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
 
 	  bfd_putl32 (0xf9400000, contents + rel->r_offset);
 
@@ -4183,7 +4209,7 @@ elf64_aarch64_tls_relax (struct elf64_aarch64_link_hash_table *globals,
 /* Relocate an AArch64 ELF section.  */
 
 static bfd_boolean
-elf64_aarch64_relocate_section (bfd *output_bfd,
+elfNN_aarch64_relocate_section (bfd *output_bfd,
 				struct bfd_link_info *info,
 				bfd *input_bfd,
 				asection *input_section,
@@ -4197,11 +4223,11 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
   const char *name;
-  struct elf64_aarch64_link_hash_table *globals;
+  struct elf_aarch64_link_hash_table *globals;
   bfd_boolean save_addend = FALSE;
   bfd_vma addend = 0;
 
-  globals = elf64_aarch64_hash_table (info);
+  globals = elf_aarch64_hash_table (info);
 
   symtab_hdr = &elf_symtab_hdr (input_bfd);
   sym_hashes = elf_sym_hashes (input_bfd);
@@ -4224,10 +4250,10 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
       bfd_boolean unresolved_reloc = FALSE;
       char *error_message = NULL;
 
-      r_symndx = ELF64_R_SYM (rel->r_info);
-      r_type = ELF64_R_TYPE (rel->r_info);
+      r_symndx = ELFNN_R_SYM (rel->r_info);
+      r_type = ELFNN_R_TYPE (rel->r_info);
 
-      bfd_reloc.howto = elf64_aarch64_howto_from_type (r_type);
+      bfd_reloc.howto = elfNN_aarch64_howto_from_type (r_type);
       howto = bfd_reloc.howto;
 
       if (howto == NULL)
@@ -4245,7 +4271,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
       if (r_symndx < symtab_hdr->sh_info)
 	{
 	  sym = local_syms + r_symndx;
-	  sym_type = ELF64_ST_TYPE (sym->st_info);
+	  sym_type = ELFNN_ST_TYPE (sym->st_info);
 	  sec = local_sections[r_symndx];
 
 	  /* An object file might have a reference to a local
@@ -4320,7 +4346,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 
       /* We relax only if we can see that there can be a valid transition
          from a reloc type to another.
-         We call elf64_aarch64_final_link_relocate unless we're completely
+         We call elfNN_aarch64_final_link_relocate unless we're completely
          done, i.e., the relaxation produced the final output we want.  */
 
       relaxed_r_type = aarch64_tls_transition (input_bfd, info, r_type,
@@ -4328,9 +4354,9 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
       if (relaxed_r_type != r_type)
 	{
 	  r_type = relaxed_r_type;
-	  howto = elf64_aarch64_howto_from_type (r_type);
+	  howto = elfNN_aarch64_howto_from_type (r_type);
 
-	  r = elf64_aarch64_tls_relax (globals, input_bfd, contents, rel, h);
+	  r = elfNN_aarch64_tls_relax (globals, input_bfd, contents, rel, h);
 	  unresolved_reloc = 0;
 	}
       else
@@ -4341,14 +4367,14 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
          output of each relocation as the addend for the next.  */
       if (rel + 1 < relend
 	  && rel->r_offset == rel[1].r_offset
-	  && ELF64_R_TYPE (rel[1].r_info) != R_AARCH64_NONE
-	  && ELF64_R_TYPE (rel[1].r_info) != R_AARCH64_NULL)
+	  && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NONE
+	  && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NULL)
 	save_addend = TRUE;
       else
 	save_addend = FALSE;
 
       if (r == bfd_reloc_continue)
-	r = elf64_aarch64_final_link_relocate (howto, input_bfd, output_bfd,
+	r = elfNN_aarch64_final_link_relocate (howto, input_bfd, output_bfd,
 					       input_section, contents, rel,
 					       relocation, info, sec,
 					       h, &unresolved_reloc,
@@ -4379,7 +4405,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 	      if (need_relocs)
 		{
 		  Elf_Internal_Rela rela;
-		  rela.r_info = ELF64_R_INFO (indx, R_AARCH64_TLS_DTPMOD64);
+		  rela.r_info = ELFNN_R_INFO (indx, R_AARCH64_TLS_DTPMOD64);
 		  rela.r_addend = 0;
 		  rela.r_offset = globals->root.sgot->output_section->vma +
 		    globals->root.sgot->output_offset + off;
@@ -4388,11 +4414,11 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		  loc = globals->root.srelgot->contents;
 		  loc += globals->root.srelgot->reloc_count++
 		    * RELOC_SIZE (htab);
-		  bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+		  bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
 
 		  if (indx == 0)
 		    {
-		      bfd_put_64 (output_bfd,
+		      bfd_put_NN (output_bfd,
 				  relocation - dtpoff_base (info),
 				  globals->root.sgot->contents + off
 				  + GOT_ENTRY_SIZE);
@@ -4403,7 +4429,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 			 relocation to fixup the tls offset at load
 			 time.  */
 		      rela.r_info =
-			ELF64_R_INFO (indx, R_AARCH64_TLS_DTPREL64);
+			ELFNN_R_INFO (indx, R_AARCH64_TLS_DTPREL64);
 		      rela.r_addend = 0;
 		      rela.r_offset =
 			(globals->root.sgot->output_section->vma
@@ -4413,17 +4439,17 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		      loc = globals->root.srelgot->contents;
 		      loc += globals->root.srelgot->reloc_count++
 			* RELOC_SIZE (globals);
-		      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
-		      bfd_put_64 (output_bfd, (bfd_vma) 0,
+		      bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
+		      bfd_put_NN (output_bfd, (bfd_vma) 0,
 				  globals->root.sgot->contents + off
 				  + GOT_ENTRY_SIZE);
 		    }
 		}
 	      else
 		{
-		  bfd_put_64 (output_bfd, (bfd_vma) 1,
+		  bfd_put_NN (output_bfd, (bfd_vma) 1,
 			      globals->root.sgot->contents + off);
-		  bfd_put_64 (output_bfd,
+		  bfd_put_NN (output_bfd,
 			      relocation - dtpoff_base (info),
 			      globals->root.sgot->contents + off
 			      + GOT_ENTRY_SIZE);
@@ -4463,7 +4489,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		  else
 		    rela.r_addend = 0;
 
-		  rela.r_info = ELF64_R_INFO (indx, R_AARCH64_TLS_TPREL64);
+		  rela.r_info = ELFNN_R_INFO (indx, R_AARCH64_TLS_TPREL64);
 		  rela.r_offset = globals->root.sgot->output_section->vma +
 		    globals->root.sgot->output_offset + off;
 
@@ -4471,13 +4497,13 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		  loc += globals->root.srelgot->reloc_count++
 		    * RELOC_SIZE (htab);
 
-		  bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+		  bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
 
-		  bfd_put_64 (output_bfd, rela.r_addend,
+		  bfd_put_NN (output_bfd, rela.r_addend,
 			      globals->root.sgot->contents + off);
 		}
 	      else
-		bfd_put_64 (output_bfd, relocation - tpoff_base (info),
+		bfd_put_NN (output_bfd, relocation - tpoff_base (info),
 			    globals->root.sgot->contents + off);
 
 	      symbol_got_offset_mark (input_bfd, h, r_symndx);
@@ -4514,7 +4540,7 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		{
 		  bfd_byte *loc;
 		  Elf_Internal_Rela rela;
-		  rela.r_info = ELF64_R_INFO (indx, R_AARCH64_TLSDESC);
+		  rela.r_info = ELFNN_R_INFO (indx, R_AARCH64_TLSDESC);
 		  rela.r_addend = 0;
 		  rela.r_offset = (globals->root.sgotplt->output_section->vma
 				   + globals->root.sgotplt->output_offset
@@ -4535,12 +4561,12 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 		  loc += globals->root.srelplt->reloc_count++
 		    * RELOC_SIZE (globals);
 
-		  bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+		  bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
 
-		  bfd_put_64 (output_bfd, (bfd_vma) 0,
+		  bfd_put_NN (output_bfd, (bfd_vma) 0,
 			      globals->root.sgotplt->contents + off +
 			      globals->sgotplt_jump_table_size);
-		  bfd_put_64 (output_bfd, (bfd_vma) 0,
+		  bfd_put_NN (output_bfd, (bfd_vma) 0,
 			      globals->root.sgotplt->contents + off +
 			      globals->sgotplt_jump_table_size +
 			      GOT_ENTRY_SIZE);
@@ -4629,16 +4655,20 @@ elf64_aarch64_relocate_section (bfd *output_bfd,
 /* Set the right machine number.  */
 
 static bfd_boolean
-elf64_aarch64_object_p (bfd *abfd)
+elfNN_aarch64_object_p (bfd *abfd)
 {
+#if ARCH_SIZE == 32
+  bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64_ilp32);
+#else
   bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64);
+#endif
   return TRUE;
 }
 
 /* Function to keep AArch64 specific flags in the ELF header.  */
 
 static bfd_boolean
-elf64_aarch64_set_private_flags (bfd *abfd, flagword flags)
+elfNN_aarch64_set_private_flags (bfd *abfd, flagword flags)
 {
   if (elf_flags_init (abfd) && elf_elfheader (abfd)->e_flags != flags)
     {
@@ -4655,7 +4685,7 @@ elf64_aarch64_set_private_flags (bfd *abfd, flagword flags)
 /* Copy backend specific data from one object module to another.  */
 
 static bfd_boolean
-elf64_aarch64_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
+elfNN_aarch64_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 {
   flagword in_flags;
 
@@ -4681,7 +4711,7 @@ elf64_aarch64_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
    object file when linking.  */
 
 static bfd_boolean
-elf64_aarch64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+elfNN_aarch64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 {
   flagword out_flags;
   flagword in_flags;
@@ -4767,7 +4797,7 @@ elf64_aarch64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 /* Display the flags field.  */
 
 static bfd_boolean
-elf64_aarch64_print_private_bfd_data (bfd *abfd, void *ptr)
+elfNN_aarch64_print_private_bfd_data (bfd *abfd, void *ptr)
 {
   FILE *file = (FILE *) ptr;
   unsigned long flags;
@@ -4795,12 +4825,12 @@ elf64_aarch64_print_private_bfd_data (bfd *abfd, void *ptr)
 /* Update the got entry reference counts for the section being removed.  */
 
 static bfd_boolean
-elf64_aarch64_gc_sweep_hook (bfd *abfd,
+elfNN_aarch64_gc_sweep_hook (bfd *abfd,
 			     struct bfd_link_info *info,
 			     asection *sec,
 			     const Elf_Internal_Rela * relocs)
 {
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
   struct elf_aarch64_local_symbol *locals;
@@ -4809,7 +4839,7 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
   if (info->relocatable)
     return TRUE;
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
 
   if (htab == NULL)
     return FALSE;
@@ -4819,7 +4849,7 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
   symtab_hdr = &elf_symtab_hdr (abfd);
   sym_hashes = elf_sym_hashes (abfd);
 
-  locals = elf64_aarch64_locals (abfd);
+  locals = elf_aarch64_locals (abfd);
 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; rel++)
@@ -4828,11 +4858,11 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
       unsigned int r_type;
       struct elf_link_hash_entry *h = NULL;
 
-      r_symndx = ELF64_R_SYM (rel->r_info);
+      r_symndx = ELFNN_R_SYM (rel->r_info);
 
       if (r_symndx >= symtab_hdr->sh_info)
 	{
-	  struct elf64_aarch64_link_hash_entry *eh;
+	  struct elf_aarch64_link_hash_entry *eh;
 	  struct elf_dyn_relocs **pp;
 	  struct elf_dyn_relocs *p;
 
@@ -4840,7 +4870,7 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
 	  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;
-	  eh = (struct elf64_aarch64_link_hash_entry *) h;
+	  eh = (struct elf_aarch64_link_hash_entry *) h;
 
 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
 	    {
@@ -4863,7 +4893,7 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
 	    return FALSE;
 	}
 
-      r_type = ELF64_R_TYPE (rel->r_info);
+      r_type = ELFNN_R_TYPE (rel->r_info);
       r_type = aarch64_tls_transition (abfd,info, r_type, h ,r_symndx);
       switch (r_type)
 	{
@@ -4925,7 +4955,7 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
 		h->plt.refcount -= 1;
 	    }
 	  break;
-        
+
 	default:
 	  break;
 	}
@@ -4941,10 +4971,10 @@ elf64_aarch64_gc_sweep_hook (bfd *abfd,
    understand.	*/
 
 static bfd_boolean
-elf64_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info,
+elfNN_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info,
 				     struct elf_link_hash_entry *h)
 {
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
   asection *s;
 
   /* If this is a function, put it in the procedure linkage table.  We
@@ -5020,7 +5050,7 @@ elf64_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info,
      both the dynamic object and the regular object will refer to the
      same memory location for the variable.  */
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
 
   /* We must generate a R_AARCH64_COPY reloc to tell the dynamic linker
      to copy the initial value out of the dynamic object and into the
@@ -5038,17 +5068,17 @@ elf64_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info,
 }
 
 static bfd_boolean
-elf64_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
+elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
 {
   struct elf_aarch64_local_symbol *locals;
-  locals = elf64_aarch64_locals (abfd);
+  locals = elf_aarch64_locals (abfd);
   if (locals == NULL)
     {
       locals = (struct elf_aarch64_local_symbol *)
 	bfd_zalloc (abfd, number * sizeof (struct elf_aarch64_local_symbol));
       if (locals == NULL)
 	return FALSE;
-      elf64_aarch64_locals (abfd) = locals;
+      elf_aarch64_locals (abfd) = locals;
     }
   return TRUE;
 }
@@ -5056,7 +5086,7 @@ elf64_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
 /* Look through the relocs for a section during the first phase.  */
 
 static bfd_boolean
-elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
+elfNN_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
 			    asection *sec, const Elf_Internal_Rela *relocs)
 {
   Elf_Internal_Shdr *symtab_hdr;
@@ -5065,14 +5095,14 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
   const Elf_Internal_Rela *rel_end;
   asection *sreloc;
 
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
 
   if (info->relocatable)
     return TRUE;
 
   BFD_ASSERT (is_aarch64_elf (abfd));
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
   sreloc = NULL;
 
   symtab_hdr = &elf_symtab_hdr (abfd);
@@ -5085,8 +5115,8 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
       unsigned long r_symndx;
       unsigned int r_type;
 
-      r_symndx = ELF64_R_SYM (rel->r_info);
-      r_type = ELF64_R_TYPE (rel->r_info);
+      r_symndx = ELFNN_R_SYM (rel->r_info);
+      r_type = ELFNN_R_TYPE (rel->r_info);
 
       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 	{
@@ -5158,8 +5188,8 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	       relocations we need for this symbol.  */
 	    if (h != NULL)
 	      {
-		struct elf64_aarch64_link_hash_entry *eh;
-		eh = (struct elf64_aarch64_link_hash_entry *) h;
+		struct elf_aarch64_link_hash_entry *eh;
+		eh = (struct elf_aarch64_link_hash_entry *) h;
 		head = &eh->dyn_relocs;
 	      }
 	    else
@@ -5234,17 +5264,17 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	    if (h)
 	      {
 		h->got.refcount += 1;
-		old_got_type = elf64_aarch64_hash_entry (h)->got_type;
+		old_got_type = elf_aarch64_hash_entry (h)->got_type;
 	      }
 	    else
 	      {
 		struct elf_aarch64_local_symbol *locals;
 
-		if (!elf64_aarch64_allocate_local_symbols
+		if (!elfNN_aarch64_allocate_local_symbols
 		    (abfd, symtab_hdr->sh_info))
 		  return FALSE;
 
-		locals = elf64_aarch64_locals (abfd);
+		locals = elf_aarch64_locals (abfd);
 		BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
 		locals[r_symndx].got_refcount += 1;
 		old_got_type = locals[r_symndx].got_type;
@@ -5272,11 +5302,11 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	    if (old_got_type != got_type)
 	      {
 		if (h != NULL)
-		  elf64_aarch64_hash_entry (h)->got_type = got_type;
+		  elf_aarch64_hash_entry (h)->got_type = got_type;
 		else
 		  {
 		    struct elf_aarch64_local_symbol *locals;
-		    locals = elf64_aarch64_locals (abfd);
+		    locals = elf_aarch64_locals (abfd);
 		    BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
 		    locals[r_symndx].got_type = got_type;
 		  }
@@ -5330,7 +5360,7 @@ elf64_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
 /* Treat mapping symbols as special target symbols.  */
 
 static bfd_boolean
-elf64_aarch64_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED,
+elfNN_aarch64_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 					asymbol *sym)
 {
   return bfd_is_aarch64_special_symbol_name (sym->name,
@@ -5401,7 +5431,7 @@ aarch64_elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
    that it uses aarch64_elf_find_function.  */
 
 static bfd_boolean
-elf64_aarch64_find_nearest_line (bfd *abfd,
+elfNN_aarch64_find_nearest_line (bfd *abfd,
 				 asection *section,
 				 asymbol **symbols,
 				 bfd_vma offset,
@@ -5449,7 +5479,7 @@ elf64_aarch64_find_nearest_line (bfd *abfd,
 }
 
 static bfd_boolean
-elf64_aarch64_find_inliner_info (bfd *abfd,
+elfNN_aarch64_find_inliner_info (bfd *abfd,
 				 const char **filename_ptr,
 				 const char **functionname_ptr,
 				 unsigned int *line_ptr)
@@ -5463,7 +5493,7 @@ elf64_aarch64_find_inliner_info (bfd *abfd,
 
 
 static void
-elf64_aarch64_post_process_headers (bfd *abfd,
+elfNN_aarch64_post_process_headers (bfd *abfd,
 				    struct bfd_link_info *link_info
 				    ATTRIBUTE_UNUSED)
 {
@@ -5475,11 +5505,11 @@ elf64_aarch64_post_process_headers (bfd *abfd,
 }
 
 static enum elf_reloc_type_class
-elf64_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+elfNN_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
 				const asection *rel_sec ATTRIBUTE_UNUSED,
 				const Elf_Internal_Rela *rela)
 {
-  switch ((int) ELF64_R_TYPE (rela->r_info))
+  switch ((int) ELFNN_R_TYPE (rela->r_info))
     {
     case R_AARCH64_RELATIVE:
       return reloc_class_relative;
@@ -5495,7 +5525,7 @@ elf64_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSE
 /* Set the right machine number for an AArch64 ELF file.  */
 
 static bfd_boolean
-elf64_aarch64_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
+elfNN_aarch64_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
 {
   if (hdr->sh_type == SHT_NOTE)
     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
@@ -5508,7 +5538,7 @@ elf64_aarch64_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
    type.  */
 
 static bfd_boolean
-elf64_aarch64_section_from_shdr (bfd *abfd,
+elfNN_aarch64_section_from_shdr (bfd *abfd,
 				 Elf_Internal_Shdr *hdr,
 				 const char *name, int shindex)
 {
@@ -5544,7 +5574,7 @@ section_list;
 
 /* Unfortunately we need to keep a list of sections for which
    an _aarch64_elf_section_data structure has been allocated.  This
-   is because it is possible for functions like elf64_aarch64_write_section
+   is because it is possible for functions like elfNN_aarch64_write_section
    to be called on a section which has had an elf_data_structure
    allocated for it (and so the used_by_bfd field is valid) but
    for which the AArch64 extended version of this structure - the
@@ -5641,7 +5671,7 @@ enum map_symbol_type
 /* Output a single mapping symbol.  */
 
 static bfd_boolean
-elf64_aarch64_output_map_sym (output_arch_syminfo *osi,
+elfNN_aarch64_output_map_sym (output_arch_syminfo *osi,
 			      enum map_symbol_type type, bfd_vma offset)
 {
   static const char *names[2] = { "$x", "$d" };
@@ -5661,7 +5691,7 @@ elf64_aarch64_output_map_sym (output_arch_syminfo *osi,
 /* Output mapping symbols for PLT entries associated with H.  */
 
 static bfd_boolean
-elf64_aarch64_output_plt_map (struct elf_link_hash_entry *h, void *inf)
+elfNN_aarch64_output_plt_map (struct elf_link_hash_entry *h, void *inf)
 {
   output_arch_syminfo *osi = (output_arch_syminfo *) inf;
   bfd_vma addr;
@@ -5681,7 +5711,7 @@ elf64_aarch64_output_plt_map (struct elf_link_hash_entry *h, void *inf)
   addr = h->plt.offset;
   if (addr == 32)
     {
-      if (!elf64_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
+      if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
 	return FALSE;
     }
   return TRUE;
@@ -5691,7 +5721,7 @@ elf64_aarch64_output_plt_map (struct elf_link_hash_entry *h, void *inf)
 /* Output a single local symbol for a generated stub.  */
 
 static bfd_boolean
-elf64_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name,
+elfNN_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name,
 			       bfd_vma offset, bfd_vma size)
 {
   Elf_Internal_Sym sym;
@@ -5708,14 +5738,14 @@ elf64_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name,
 static bfd_boolean
 aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
 {
-  struct elf64_aarch64_stub_hash_entry *stub_entry;
+  struct elf_aarch64_stub_hash_entry *stub_entry;
   asection *stub_sec;
   bfd_vma addr;
   char *stub_name;
   output_arch_syminfo *osi;
 
   /* Massage our args to the form they really have.  */
-  stub_entry = (struct elf64_aarch64_stub_hash_entry *) gen_entry;
+  stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
   osi = (output_arch_syminfo *) in_arg;
 
   stub_sec = stub_entry->stub_sec;
@@ -5732,19 +5762,19 @@ aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
   switch (stub_entry->stub_type)
     {
     case aarch64_stub_adrp_branch:
-      if (!elf64_aarch64_output_stub_sym (osi, stub_name, addr,
+      if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
 					  sizeof (aarch64_adrp_branch_stub)))
 	return FALSE;
-      if (!elf64_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
+      if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
 	return FALSE;
       break;
     case aarch64_stub_long_branch:
-      if (!elf64_aarch64_output_stub_sym
+      if (!elfNN_aarch64_output_stub_sym
 	  (osi, stub_name, addr, sizeof (aarch64_long_branch_stub)))
 	return FALSE;
-      if (!elf64_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
+      if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
 	return FALSE;
-      if (!elf64_aarch64_output_map_sym (osi, AARCH64_MAP_DATA, addr + 16))
+      if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_DATA, addr + 16))
 	return FALSE;
       break;
     default:
@@ -5757,7 +5787,7 @@ aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
 /* Output mapping symbols for linker generated sections.  */
 
 static bfd_boolean
-elf64_aarch64_output_arch_local_syms (bfd *output_bfd,
+elfNN_aarch64_output_arch_local_syms (bfd *output_bfd,
 				      struct bfd_link_info *info,
 				      void *finfo,
 				      int (*func) (void *, const char *,
@@ -5767,9 +5797,9 @@ elf64_aarch64_output_arch_local_syms (bfd *output_bfd,
 						   *))
 {
   output_arch_syminfo osi;
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
 
   osi.finfo = finfo;
   osi.info = info;
@@ -5806,7 +5836,7 @@ elf64_aarch64_output_arch_local_syms (bfd *output_bfd,
     (output_bfd, htab->root.splt->output_section);
   osi.sec = htab->root.splt;
 
-  elf_link_hash_traverse (&htab->root, elf64_aarch64_output_plt_map,
+  elf_link_hash_traverse (&htab->root, elfNN_aarch64_output_plt_map,
 			  (void *) &osi);
 
   return TRUE;
@@ -5816,7 +5846,7 @@ elf64_aarch64_output_arch_local_syms (bfd *output_bfd,
 /* Allocate target specific section data.  */
 
 static bfd_boolean
-elf64_aarch64_new_section_hook (bfd *abfd, asection *sec)
+elfNN_aarch64_new_section_hook (bfd *abfd, asection *sec)
 {
   if (!sec->used_by_bfd)
     {
@@ -5844,7 +5874,7 @@ unrecord_section_via_map_over_sections (bfd *abfd ATTRIBUTE_UNUSED,
 }
 
 static bfd_boolean
-elf64_aarch64_close_and_cleanup (bfd *abfd)
+elfNN_aarch64_close_and_cleanup (bfd *abfd)
 {
   if (abfd->sections)
     bfd_map_over_sections (abfd,
@@ -5854,7 +5884,7 @@ elf64_aarch64_close_and_cleanup (bfd *abfd)
 }
 
 static bfd_boolean
-elf64_aarch64_bfd_free_cached_info (bfd *abfd)
+elfNN_aarch64_bfd_free_cached_info (bfd *abfd)
 {
   if (abfd->sections)
     bfd_map_over_sections (abfd,
@@ -5864,7 +5894,7 @@ elf64_aarch64_bfd_free_cached_info (bfd *abfd)
 }
 
 static bfd_boolean
-elf64_aarch64_is_function_type (unsigned int type)
+elfNN_aarch64_is_function_type (unsigned int type)
 {
   return type == STT_FUNC;
 }
@@ -5874,16 +5904,16 @@ elf64_aarch64_is_function_type (unsigned int type)
    standard part of the bfd elf backend.  */
 
 static bfd_boolean
-elf64_aarch64_create_dynamic_sections (bfd *dynobj,
+elfNN_aarch64_create_dynamic_sections (bfd *dynobj,
 				       struct bfd_link_info *info)
 {
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
   struct elf_link_hash_entry *h;
 
   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
     return FALSE;
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
   if (!info->shared)
     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
@@ -5909,11 +5939,11 @@ elf64_aarch64_create_dynamic_sections (bfd *dynobj,
    dynamic relocs.  */
 
 static bfd_boolean
-elf64_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+elfNN_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 {
   struct bfd_link_info *info;
-  struct elf64_aarch64_link_hash_table *htab;
-  struct elf64_aarch64_link_hash_entry *eh;
+  struct elf_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_entry *eh;
   struct elf_dyn_relocs *p;
 
   /* An example of a bfd_link_hash_indirect symbol is versioned
@@ -5922,7 +5952,7 @@ elf64_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 
      There is no need to process bfd_link_hash_indirect symbols here
      because we will also be presented with the concrete instance of
-     the symbol and elf64_aarch64_copy_indirect_symbol () will have been
+     the symbol and elfNN_aarch64_copy_indirect_symbol () will have been
      called to copy all relevant data from the generic to the concrete
      symbol instance.
    */
@@ -5933,7 +5963,7 @@ elf64_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   info = (struct bfd_link_info *) inf;
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
 
   if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
     {
@@ -6006,13 +6036,13 @@ elf64_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
       h->needs_plt = 0;
     }
 
-  eh = (struct elf64_aarch64_link_hash_entry *) h;
+  eh = (struct elf_aarch64_link_hash_entry *) h;
   eh->tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
 
   if (h->got.refcount > 0)
     {
       bfd_boolean dyn;
-      unsigned got_type = elf64_aarch64_hash_entry (h)->got_type;
+      unsigned got_type = elf_aarch64_hash_entry (h)->got_type;
 
       h->got.offset = (bfd_vma) - 1;
 
@@ -6191,21 +6221,19 @@ elf64_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 }
 
 
-
-
 /* This is the most important function of all . Innocuosly named
    though !  */
 static bfd_boolean
-elf64_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
+elfNN_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 				     struct bfd_link_info *info)
 {
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
   bfd *dynobj;
   asection *s;
   bfd_boolean relocs;
   bfd *ibfd;
 
-  htab = elf64_aarch64_hash_table ((info));
+  htab = elf_aarch64_hash_table ((info));
   dynobj = htab->root.dynobj;
 
   BFD_ASSERT (dynobj != NULL);
@@ -6259,7 +6287,7 @@ elf64_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	    }
 	}
 
-      locals = elf64_aarch64_locals (ibfd);
+      locals = elf_aarch64_locals (ibfd);
       if (!locals)
 	continue;
 
@@ -6327,7 +6355,7 @@ elf64_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
   /* Allocate global sym .plt and .got entries, and space for global
      sym dynamic relocs.  */
-  elf_link_hash_traverse (&htab->root, elf64_aarch64_allocate_dynrelocs,
+  elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_dynrelocs,
 			  info);
 
 
@@ -6422,7 +6450,7 @@ elf64_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   if (htab->root.dynamic_sections_created)
     {
       /* Add some entries to the .dynamic section.  We fill in the
-         values later, in elf64_aarch64_finish_dynamic_sections, but we
+         values later, in elfNN_aarch64_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.  */
@@ -6478,13 +6506,13 @@ elf64_aarch64_update_plt_entry (bfd *output_bfd,
 				bfd_byte *plt_entry, bfd_vma value)
 {
   reloc_howto_type *howto;
-  howto = elf64_aarch64_howto_from_type (r_type);
+  howto = elfNN_aarch64_howto_from_type (r_type);
   bfd_elf_aarch64_put_addend (output_bfd, plt_entry, howto, value);
 }
 
 static void
-elf64_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
-				       struct elf64_aarch64_link_hash_table
+elfNN_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
+				       struct elf_aarch64_link_hash_table
 				       *htab, bfd *output_bfd)
 {
   bfd_byte *plt_entry;
@@ -6498,7 +6526,7 @@ elf64_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
   plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
 
   /* Offset in the GOT is PLT index plus got GOT headers(3)
-     times 8.  */
+     times GOT_ENTRY_SIZE.  */
   got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
   plt_entry = htab->root.splt->contents + h->plt.offset;
   plt_entry_address = htab->root.splt->output_section->vma
@@ -6507,7 +6535,7 @@ elf64_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
     htab->root.sgotplt->output_offset + got_offset;
 
   /* Copy in the boiler-plate for the PLTn entry.  */
-  memcpy (plt_entry, elf64_aarch64_small_plt_entry, PLT_SMALL_ENTRY_SIZE);
+  memcpy (plt_entry, elfNN_aarch64_small_plt_entry, PLT_SMALL_ENTRY_SIZE);
 
   /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8.
      ADRP:   ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */
@@ -6527,28 +6555,28 @@ elf64_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
 				  PG_OFFSET (gotplt_entry_address));
 
   /* All the GOTPLT Entries are essentially initialized to PLT0.  */
-  bfd_put_64 (output_bfd,
+  bfd_put_NN (output_bfd,
 	      (htab->root.splt->output_section->vma
 	       + htab->root.splt->output_offset),
 	      htab->root.sgotplt->contents + got_offset);
 
   /* Fill in the entry in the .rela.plt section.  */
   rela.r_offset = gotplt_entry_address;
-  rela.r_info = ELF64_R_INFO (h->dynindx, R_AARCH64_JUMP_SLOT);
+  rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (JUMP_SLOT));
   rela.r_addend = 0;
 
   /* Compute the relocation entry to used based on PLT index and do
      not adjust reloc_count. The reloc_count has already been adjusted
      to account for this entry.  */
   loc = htab->root.srelplt->contents + plt_index * RELOC_SIZE (htab);
-  bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+  bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
 }
 
 /* Size sections even though they're not dynamic.  We use it to setup
    _TLS_MODULE_BASE_, if needed.  */
 
 static bfd_boolean
-elf64_aarch64_always_size_sections (bfd *output_bfd,
+elfNN_aarch64_always_size_sections (bfd *output_bfd,
 				    struct bfd_link_info *info)
 {
   asection *tls_sec;
@@ -6590,13 +6618,13 @@ elf64_aarch64_always_size_sections (bfd *output_bfd,
 /* Finish up dynamic symbol handling.  We set the contents of various
    dynamic sections here.  */
 static bfd_boolean
-elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
+elfNN_aarch64_finish_dynamic_symbol (bfd *output_bfd,
 				     struct bfd_link_info *info,
 				     struct elf_link_hash_entry *h,
 				     Elf_Internal_Sym *sym)
 {
-  struct elf64_aarch64_link_hash_table *htab;
-  htab = elf64_aarch64_hash_table (info);
+  struct elf_aarch64_link_hash_table *htab;
+  htab = elf_aarch64_hash_table (info);
 
   if (h->plt.offset != (bfd_vma) - 1)
     {
@@ -6608,7 +6636,7 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
 	  || htab->root.sgotplt == NULL || htab->root.srelplt == NULL)
 	abort ();
 
-      elf64_aarch64_create_small_pltn_entry (h, htab, output_bfd);
+      elfNN_aarch64_create_small_pltn_entry (h, htab, output_bfd);
       if (!h->def_regular)
 	{
 	  /* Mark the symbol as undefined, rather than as defined in
@@ -6621,7 +6649,7 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
     }
 
   if (h->got.offset != (bfd_vma) - 1
-      && elf64_aarch64_hash_entry (h)->got_type == GOT_NORMAL)
+      && elf_aarch64_hash_entry (h)->got_type == GOT_NORMAL)
     {
       Elf_Internal_Rela rela;
       bfd_byte *loc;
@@ -6641,7 +6669,7 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
 	    return FALSE;
 
 	  BFD_ASSERT ((h->got.offset & 1) != 0);
-	  rela.r_info = ELF64_R_INFO (0, R_AARCH64_RELATIVE);
+	  rela.r_info = ELFNN_R_INFO (0, R_AARCH64_RELATIVE);
 	  rela.r_addend = (h->root.u.def.value
 			   + h->root.u.def.section->output_section->vma
 			   + h->root.u.def.section->output_offset);
@@ -6649,15 +6677,15 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
       else
 	{
 	  BFD_ASSERT ((h->got.offset & 1) == 0);
-	  bfd_put_64 (output_bfd, (bfd_vma) 0,
+	  bfd_put_NN (output_bfd, (bfd_vma) 0,
 		      htab->root.sgot->contents + h->got.offset);
-	  rela.r_info = ELF64_R_INFO (h->dynindx, R_AARCH64_GLOB_DAT);
+	  rela.r_info = ELFNN_R_INFO (h->dynindx, R_AARCH64_GLOB_DAT);
 	  rela.r_addend = 0;
 	}
 
       loc = htab->root.srelgot->contents;
       loc += htab->root.srelgot->reloc_count++ * RELOC_SIZE (htab);
-      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+      bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
     }
 
   if (h->needs_copy)
@@ -6676,11 +6704,11 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
       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_AARCH64_COPY);
+      rela.r_info = ELFNN_R_INFO (h->dynindx, R_AARCH64_COPY);
       rela.r_addend = 0;
       loc = htab->srelbss->contents;
       loc += htab->srelbss->reloc_count++ * RELOC_SIZE (htab);
-      bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
+      bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
     }
 
   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  SYM may
@@ -6694,15 +6722,15 @@ elf64_aarch64_finish_dynamic_symbol (bfd *output_bfd,
 }
 
 static void
-elf64_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
-				     struct elf64_aarch64_link_hash_table
+elfNN_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
+				     struct elf_aarch64_link_hash_table
 				     *htab)
 {
   /* Fill in PLT0. Fixme:RR Note this doesn't distinguish between
      small and large plts and at the minute just generates
      the small PLT.  */
 
-  /* PLT0 of the small PLT looks like this -
+  /* PLT0 of the small PLT looks like this in ELF64 -
      stp x16, x30, [sp, #-16]!		// Save the reloc and lr on stack.
      adrp x16, PLT_GOT + 16		// Get the page base of the GOTPLT
      ldr  x17, [x16, #:lo12:PLT_GOT+16] // Load the address of the
@@ -6710,12 +6738,14 @@ elf64_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
      add  x16, x16, #:lo12:PLT_GOT+16   // Load the lo12 bits of the
 					// GOTPLT entry for this.
      br   x17
+     PLT0 will be slightly different in ELF32 due to different got entry
+     size.
    */
   bfd_vma plt_got_base;
   bfd_vma plt_base;
 
 
-  memcpy (htab->root.splt->contents, elf64_aarch64_small_plt0_entry,
+  memcpy (htab->root.splt->contents, elfNN_aarch64_small_plt0_entry,
 	  PLT_ENTRY_SIZE);
   elf_section_data (htab->root.splt->output_section)->this_hdr.sh_entsize =
     PLT_ENTRY_SIZE;
@@ -6742,32 +6772,32 @@ elf64_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
 }
 
 static bfd_boolean
-elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
+elfNN_aarch64_finish_dynamic_sections (bfd *output_bfd,
 				       struct bfd_link_info *info)
 {
-  struct elf64_aarch64_link_hash_table *htab;
+  struct elf_aarch64_link_hash_table *htab;
   bfd *dynobj;
   asection *sdyn;
 
-  htab = elf64_aarch64_hash_table (info);
+  htab = elf_aarch64_hash_table (info);
   dynobj = htab->root.dynobj;
   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
 
   if (htab->root.dynamic_sections_created)
     {
-      Elf64_External_Dyn *dyncon, *dynconend;
+      ElfNN_External_Dyn *dyncon, *dynconend;
 
       if (sdyn == NULL || htab->root.sgot == NULL)
 	abort ();
 
-      dyncon = (Elf64_External_Dyn *) sdyn->contents;
-      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
+      dyncon = (ElfNN_External_Dyn *) sdyn->contents;
+      dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
       for (; dyncon < dynconend; dyncon++)
 	{
 	  Elf_Internal_Dyn dyn;
 	  asection *s;
 
-	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
+	  bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
 
 	  switch (dyn.d_tag)
 	    {
@@ -6816,7 +6846,7 @@ elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
 	      break;
 	    }
 
-	  bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
+	  bfd_elfNN_swap_dyn_out (output_bfd, &dyn, dyncon);
 	}
 
     }
@@ -6824,7 +6854,7 @@ elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
   /* Fill in the special first entry in the procedure linkage table.  */
   if (htab->root.splt && htab->root.splt->size > 0)
     {
-      elf64_aarch64_init_small_plt0_entry (output_bfd, htab);
+      elfNN_aarch64_init_small_plt0_entry (output_bfd, htab);
 
       elf_section_data (htab->root.splt->output_section)->
 	this_hdr.sh_entsize = htab->plt_entry_size;
@@ -6832,12 +6862,12 @@ elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
 
       if (htab->tlsdesc_plt)
 	{
-	  bfd_put_64 (output_bfd, (bfd_vma) 0,
+	  bfd_put_NN (output_bfd, (bfd_vma) 0,
 		      htab->root.sgot->contents + htab->dt_tlsdesc_got);
 
 	  memcpy (htab->root.splt->contents + htab->tlsdesc_plt,
-		  elf64_aarch64_tlsdesc_small_plt_entry,
-		  sizeof (elf64_aarch64_tlsdesc_small_plt_entry));
+		  elfNN_aarch64_tlsdesc_small_plt_entry,
+		  sizeof (elfNN_aarch64_tlsdesc_small_plt_entry));
 
 	  {
 	    bfd_vma adrp1_addr =
@@ -6912,17 +6942,17 @@ elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
 	  /* Set the first entry in the global offset table to the address of
 	     the dynamic section.  */
 	  if (sdyn == NULL)
-	    bfd_put_64 (output_bfd, (bfd_vma) 0,
+	    bfd_put_NN (output_bfd, (bfd_vma) 0,
 			htab->root.sgotplt->contents);
 	  else
-	    bfd_put_64 (output_bfd,
+	    bfd_put_NN (output_bfd,
 			sdyn->output_section->vma + sdyn->output_offset,
 			htab->root.sgotplt->contents);
 	  /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
-	  bfd_put_64 (output_bfd,
+	  bfd_put_NN (output_bfd,
 		      (bfd_vma) 0,
 		      htab->root.sgotplt->contents + GOT_ENTRY_SIZE);
-	  bfd_put_64 (output_bfd,
+	  bfd_put_NN (output_bfd,
 		      (bfd_vma) 0,
 		      htab->root.sgotplt->contents + GOT_ENTRY_SIZE * 2);
 	}
@@ -6942,7 +6972,7 @@ elf64_aarch64_finish_dynamic_sections (bfd *output_bfd,
    or (bfd_vma) -1 if it should not be included.  */
 
 static bfd_vma
-elf64_aarch64_plt_sym_val (bfd_vma i, const asection *plt,
+elfNN_aarch64_plt_sym_val (bfd_vma i, const asection *plt,
 			   const arelent *rel ATTRIBUTE_UNUSED)
 {
   return plt->vma + PLT_ENTRY_SIZE + i * PLT_SMALL_ENTRY_SIZE;
@@ -6952,35 +6982,35 @@ elf64_aarch64_plt_sym_val (bfd_vma i, const asection *plt,
 /* We use this so we can override certain functions
    (though currently we don't).  */
 
-const struct elf_size_info elf64_aarch64_size_info =
+const struct elf_size_info elfNN_aarch64_size_info =
 {
-  sizeof (Elf64_External_Ehdr),
-  sizeof (Elf64_External_Phdr),
-  sizeof (Elf64_External_Shdr),
-  sizeof (Elf64_External_Rel),
-  sizeof (Elf64_External_Rela),
-  sizeof (Elf64_External_Sym),
-  sizeof (Elf64_External_Dyn),
+  sizeof (ElfNN_External_Ehdr),
+  sizeof (ElfNN_External_Phdr),
+  sizeof (ElfNN_External_Shdr),
+  sizeof (ElfNN_External_Rel),
+  sizeof (ElfNN_External_Rela),
+  sizeof (ElfNN_External_Sym),
+  sizeof (ElfNN_External_Dyn),
   sizeof (Elf_External_Note),
   4,				/* Hash table entry size.  */
   1,				/* Internal relocs per external relocs.  */
-  64,				/* Arch size.  */
-  3,				/* Log_file_align.  */
-  ELFCLASS64, EV_CURRENT,
-  bfd_elf64_write_out_phdrs,
-  bfd_elf64_write_shdrs_and_ehdr,
-  bfd_elf64_checksum_contents,
-  bfd_elf64_write_relocs,
-  bfd_elf64_swap_symbol_in,
-  bfd_elf64_swap_symbol_out,
-  bfd_elf64_slurp_reloc_table,
-  bfd_elf64_slurp_symbol_table,
-  bfd_elf64_swap_dyn_in,
-  bfd_elf64_swap_dyn_out,
-  bfd_elf64_swap_reloc_in,
-  bfd_elf64_swap_reloc_out,
-  bfd_elf64_swap_reloca_in,
-  bfd_elf64_swap_reloca_out
+  ARCH_SIZE,			/* Arch size.  */
+  LOG_FILE_ALIGN,		/* Log_file_align.  */
+  ELFCLASSNN, EV_CURRENT,
+  bfd_elfNN_write_out_phdrs,
+  bfd_elfNN_write_shdrs_and_ehdr,
+  bfd_elfNN_checksum_contents,
+  bfd_elfNN_write_relocs,
+  bfd_elfNN_swap_symbol_in,
+  bfd_elfNN_swap_symbol_out,
+  bfd_elfNN_slurp_reloc_table,
+  bfd_elfNN_slurp_symbol_table,
+  bfd_elfNN_swap_dyn_in,
+  bfd_elfNN_swap_dyn_out,
+  bfd_elfNN_swap_reloc_in,
+  bfd_elfNN_swap_reloc_out,
+  bfd_elfNN_swap_reloca_in,
+  bfd_elfNN_swap_reloca_out
 };
 
 #define ELF_ARCH			bfd_arch_aarch64
@@ -6989,112 +7019,112 @@ const struct elf_size_info elf64_aarch64_size_info =
 #define ELF_MINPAGESIZE			0x1000
 #define ELF_COMMONPAGESIZE		0x1000
 
-#define bfd_elf64_close_and_cleanup             \
-  elf64_aarch64_close_and_cleanup
+#define bfd_elfNN_close_and_cleanup             \
+  elfNN_aarch64_close_and_cleanup
 
-#define bfd_elf64_bfd_copy_private_bfd_data	\
-  elf64_aarch64_copy_private_bfd_data
+#define bfd_elfNN_bfd_copy_private_bfd_data	\
+  elfNN_aarch64_copy_private_bfd_data
 
-#define bfd_elf64_bfd_free_cached_info          \
-  elf64_aarch64_bfd_free_cached_info
+#define bfd_elfNN_bfd_free_cached_info          \
+  elfNN_aarch64_bfd_free_cached_info
 
-#define bfd_elf64_bfd_is_target_special_symbol	\
-  elf64_aarch64_is_target_special_symbol
+#define bfd_elfNN_bfd_is_target_special_symbol	\
+  elfNN_aarch64_is_target_special_symbol
 
-#define bfd_elf64_bfd_link_hash_table_create    \
-  elf64_aarch64_link_hash_table_create
+#define bfd_elfNN_bfd_link_hash_table_create    \
+  elfNN_aarch64_link_hash_table_create
 
-#define bfd_elf64_bfd_link_hash_table_free      \
-  elf64_aarch64_hash_table_free
+#define bfd_elfNN_bfd_link_hash_table_free      \
+  elfNN_aarch64_hash_table_free
 
-#define bfd_elf64_bfd_merge_private_bfd_data	\
-  elf64_aarch64_merge_private_bfd_data
+#define bfd_elfNN_bfd_merge_private_bfd_data	\
+  elfNN_aarch64_merge_private_bfd_data
 
-#define bfd_elf64_bfd_print_private_bfd_data	\
-  elf64_aarch64_print_private_bfd_data
+#define bfd_elfNN_bfd_print_private_bfd_data	\
+  elfNN_aarch64_print_private_bfd_data
 
-#define bfd_elf64_bfd_reloc_type_lookup		\
-  elf64_aarch64_reloc_type_lookup
+#define bfd_elfNN_bfd_reloc_type_lookup		\
+  elfNN_aarch64_reloc_type_lookup
 
-#define bfd_elf64_bfd_reloc_name_lookup		\
-  elf64_aarch64_reloc_name_lookup
+#define bfd_elfNN_bfd_reloc_name_lookup		\
+  elfNN_aarch64_reloc_name_lookup
 
-#define bfd_elf64_bfd_set_private_flags		\
-  elf64_aarch64_set_private_flags
+#define bfd_elfNN_bfd_set_private_flags		\
+  elfNN_aarch64_set_private_flags
 
-#define bfd_elf64_find_inliner_info		\
-  elf64_aarch64_find_inliner_info
+#define bfd_elfNN_find_inliner_info		\
+  elfNN_aarch64_find_inliner_info
 
-#define bfd_elf64_find_nearest_line		\
-  elf64_aarch64_find_nearest_line
+#define bfd_elfNN_find_nearest_line		\
+  elfNN_aarch64_find_nearest_line
 
-#define bfd_elf64_mkobject			\
-  elf64_aarch64_mkobject
+#define bfd_elfNN_mkobject			\
+  elfNN_aarch64_mkobject
 
-#define bfd_elf64_new_section_hook		\
-  elf64_aarch64_new_section_hook
+#define bfd_elfNN_new_section_hook		\
+  elfNN_aarch64_new_section_hook
 
 #define elf_backend_adjust_dynamic_symbol	\
-  elf64_aarch64_adjust_dynamic_symbol
+  elfNN_aarch64_adjust_dynamic_symbol
 
 #define elf_backend_always_size_sections	\
-  elf64_aarch64_always_size_sections
+  elfNN_aarch64_always_size_sections
 
 #define elf_backend_check_relocs		\
-  elf64_aarch64_check_relocs
+  elfNN_aarch64_check_relocs
 
 #define elf_backend_copy_indirect_symbol	\
-  elf64_aarch64_copy_indirect_symbol
+  elfNN_aarch64_copy_indirect_symbol
 
 /* Create .dynbss, and .rela.bss sections in DYNOBJ, and set up shortcuts
    to them in our hash.  */
 #define elf_backend_create_dynamic_sections	\
-  elf64_aarch64_create_dynamic_sections
+  elfNN_aarch64_create_dynamic_sections
 
 #define elf_backend_init_index_section		\
   _bfd_elf_init_2_index_sections
 
 #define elf_backend_is_function_type		\
-  elf64_aarch64_is_function_type
+  elfNN_aarch64_is_function_type
 
 #define elf_backend_finish_dynamic_sections	\
-  elf64_aarch64_finish_dynamic_sections
+  elfNN_aarch64_finish_dynamic_sections
 
 #define elf_backend_finish_dynamic_symbol	\
-  elf64_aarch64_finish_dynamic_symbol
+  elfNN_aarch64_finish_dynamic_symbol
 
 #define elf_backend_gc_sweep_hook		\
-  elf64_aarch64_gc_sweep_hook
+  elfNN_aarch64_gc_sweep_hook
 
 #define elf_backend_object_p			\
-  elf64_aarch64_object_p
+  elfNN_aarch64_object_p
 
 #define elf_backend_output_arch_local_syms      \
-  elf64_aarch64_output_arch_local_syms
+  elfNN_aarch64_output_arch_local_syms
 
 #define elf_backend_plt_sym_val			\
-  elf64_aarch64_plt_sym_val
+  elfNN_aarch64_plt_sym_val
 
 #define elf_backend_post_process_headers	\
-  elf64_aarch64_post_process_headers
+  elfNN_aarch64_post_process_headers
 
 #define elf_backend_relocate_section		\
-  elf64_aarch64_relocate_section
+  elfNN_aarch64_relocate_section
 
 #define elf_backend_reloc_type_class		\
-  elf64_aarch64_reloc_type_class
+  elfNN_aarch64_reloc_type_class
 
 #define elf_backend_section_flags		\
-  elf64_aarch64_section_flags
+  elfNN_aarch64_section_flags
 
 #define elf_backend_section_from_shdr		\
-  elf64_aarch64_section_from_shdr
+  elfNN_aarch64_section_from_shdr
 
 #define elf_backend_size_dynamic_sections	\
-  elf64_aarch64_size_dynamic_sections
+  elfNN_aarch64_size_dynamic_sections
 
 #define elf_backend_size_info			\
-  elf64_aarch64_size_info
+  elfNN_aarch64_size_info
 
 #define elf_backend_can_refcount       1
 #define elf_backend_can_gc_sections    1
@@ -7110,4 +7140,4 @@ const struct elf_size_info elf64_aarch64_size_info =
 #undef  elf_backend_obj_attrs_section
 #define elf_backend_obj_attrs_section		".ARM.attributes"
 
-#include "elf64-target.h"
+#include "elfNN-target.h"
diff --git a/bfd/targets.c b/bfd/targets.c
index e716c3b..b117bfe 100644
--- a/bfd/targets.c
+++ b/bfd/targets.c
@@ -736,6 +736,7 @@ extern const bfd_target bfd_elf64_alpha_vec;
 extern const bfd_target bfd_elf64_big_generic_vec;
 extern const bfd_target bfd_elf64_bigmips_vec;
 extern const bfd_target bfd_elf64_bigaarch64_vec;
+extern const bfd_target bfd_elf32_bigaarch64_vec;
 extern const bfd_target bfd_elf64_hppa_linux_vec;
 extern const bfd_target bfd_elf64_hppa_vec;
 extern const bfd_target bfd_elf64_ia64_big_vec;
@@ -745,6 +746,7 @@ extern const bfd_target bfd_elf64_ia64_vms_vec;
 extern const bfd_target bfd_elf64_little_generic_vec;
 extern const bfd_target bfd_elf64_littlemips_vec;
 extern const bfd_target bfd_elf64_littleaarch64_vec;
+extern const bfd_target bfd_elf32_littleaarch64_vec;
 extern const bfd_target bfd_elf64_mmix_vec;
 extern const bfd_target bfd_elf64_powerpc_vec;
 extern const bfd_target bfd_elf64_powerpcle_vec;
@@ -1125,6 +1127,7 @@ static const bfd_target * const _bfd_target_vector[] =
 	&bfd_elf64_big_generic_vec,
 	&bfd_elf64_bigmips_vec,
 	&bfd_elf64_bigaarch64_vec,
+	&bfd_elf32_bigaarch64_vec,
 	&bfd_elf64_hppa_linux_vec,
 	&bfd_elf64_hppa_vec,
 	&bfd_elf64_ia64_big_vec,
@@ -1134,6 +1137,7 @@ static const bfd_target * const _bfd_target_vector[] =
 	&bfd_elf64_little_generic_vec,
 	&bfd_elf64_littlemips_vec,
 	&bfd_elf64_littleaarch64_vec,
+	&bfd_elf32_littleaarch64_vec,
 	&bfd_elf64_mmix_vec,
 	&bfd_elf64_powerpc_vec,
 	&bfd_elf64_powerpcle_vec,