Support 64-bit entry size in SHT_HASH (for s390).

gold/
	* dynobj.cc (Dynobj::create_elf_hash_table): Create hash table with
	target-specific entry size.
	(Dynobj::sized_create_elf_hash_table): Add size template parameter.
	* dynobj.h (Dynobj::sized_create_elf_hash_table): Likewise.
	* layout.cc (Layout::create_dynamic_symtab): Set entsize to
	hash_entry_size.
	* target.h (Target::hash_entry_size): New method.
	(Target::Target_info::hash_entry_size): New data member.

	* aarch64.cc (Target_aarch64::aarch64_info): Add hash_entry_size.
	* arm.cc (Target_arm::arm_info): Likewise.
	(Target_arm_nacl::arm_nacl_info): Likewise.
	* i386.cc (Target_i386::i386_info): Likewise.
	(Target_i386_nacl::i386_nacl_info): Likewise.
	(Target_iamcu::iamcu_info): Likewise.
	* mips.cc (Target_mips::mips_info): Likewise.
	(Target_mips_nacl::mips_nacl_info): Likewise.
	* powerpc.cc (Target_powerpc::powerpc_info): Likewise.
	* sparc.cc (Target_sparc::sparc_info): Likewise.
	* tilegx.cc (Target_tilegx::tilegx_info): Likewise.
	* x86_64.cc (Target_x86_64::x86_64_info): Likewise.
	(Target_x86_64_nacl::x86_64_nacl_info): Likewise.
	* testsuite/testfile.cc (Target_test::test_target_info): Likewise.

gold/dynobj.cc

@@ -946,31 +946,59 @@ Dynobj::create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
       bucket[bucketpos] = dynsym_index;
     }
 
+  int size = parameters->target().hash_entry_size();
   unsigned int hashlen = ((2
 			   + bucketcount
 			   + local_dynsym_count
 			   + dynsym_count)
-			  * 4);
+			  * size / 8);
   unsigned char* phash = new unsigned char[hashlen];
 
-  if (parameters->target().is_big_endian())
+  bool big_endian = parameters->target().is_big_endian();
+  if (size == 32)
     {
+      if (big_endian)
+	{
 #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
-      Dynobj::sized_create_elf_hash_table<true>(bucket, chain, phash,
-						hashlen);
+	  Dynobj::sized_create_elf_hash_table<32, true>(bucket, chain, phash,
+							hashlen);
 #else
-      gold_unreachable();
+	  gold_unreachable();
 #endif
+	}
+      else
+	{
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
+	  Dynobj::sized_create_elf_hash_table<32, false>(bucket, chain, phash,
+							 hashlen);
+#else
+	  gold_unreachable();
+#endif
+	}
+    }
+  else if (size == 64)
+    {
+      if (big_endian)
+	{
+#if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG)
+	  Dynobj::sized_create_elf_hash_table<64, true>(bucket, chain, phash,
+							hashlen);
+#else
+	  gold_unreachable();
+#endif
+	}
+      else
+	{
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
+	  Dynobj::sized_create_elf_hash_table<64, false>(bucket, chain, phash,
+							 hashlen);
+#else
+	  gold_unreachable();
+#endif
+	}
     }
   else
-    {
-#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE)
-      Dynobj::sized_create_elf_hash_table<false>(bucket, chain, phash,
-						 hashlen);
-#else
-      gold_unreachable();
-#endif
-    }
+    gold_unreachable();
 
   *pphash = phash;
   *phashlen = hashlen;
@@ -978,7 +1006,7 @@ Dynobj::create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
 
 // Fill in an ELF hash table.
 
-template<bool big_endian>
+template<int size, bool big_endian>
 void
 Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
 				    const std::vector<uint32_t>& chain,
@@ -990,21 +1018,21 @@ Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
   const unsigned int bucketcount = bucket.size();
   const unsigned int chaincount = chain.size();
 
-  elfcpp::Swap<32, big_endian>::writeval(p, bucketcount);
-  p += 4;
-  elfcpp::Swap<32, big_endian>::writeval(p, chaincount);
-  p += 4;
+  elfcpp::Swap<size, big_endian>::writeval(p, bucketcount);
+  p += size / 8;
+  elfcpp::Swap<size, big_endian>::writeval(p, chaincount);
+  p += size / 8;
 
   for (unsigned int i = 0; i < bucketcount; ++i)
     {
-      elfcpp::Swap<32, big_endian>::writeval(p, bucket[i]);
-      p += 4;
+      elfcpp::Swap<size, big_endian>::writeval(p, bucket[i]);
+      p += size / 8;
     }
 
   for (unsigned int i = 0; i < chaincount; ++i)
     {
-      elfcpp::Swap<32, big_endian>::writeval(p, chain[i]);
-      p += 4;
+      elfcpp::Swap<size, big_endian>::writeval(p, chain[i]);
+      p += size / 8;
     }
 
   gold_assert(static_cast<unsigned int>(p - phash) == hashlen);