Parameterize object_unittest to work for whatever target types are

supported.

diff --git a/gold/target-select.cc b/gold/target-select.cc
index 085270f61245fcff87b3671becf740cc06ee5176..0cfa02bc6add1996f01ec019c525f9ba3b198108 100644 (file)
--- a/gold/target-select.cc
+++ b/gold/target-select.cc
@@ -41,8 +41,8 @@ namespace gold
 // list.  This runs at global constructor time, so we want it to be
 // fast.
 
-Target_selector::Target_selector(int machine, int size, bool big_endian)
-  : machine_(machine), size_(size), big_endian_(big_endian)
+Target_selector::Target_selector(int machine, int size, bool is_big_endian)
+  : machine_(machine), size_(size), is_big_endian_(is_big_endian)
 {
   this->next_ = target_selectors;
   target_selectors = this;
@@ -51,15 +51,15 @@ Target_selector::Target_selector(int machine, int size, bool big_endian)
 // Find the target for an ELF file.
 
 extern Target*
-select_target(int machine, int size, bool big_endian, int osabi,
+select_target(int machine, int size, bool is_big_endian, int osabi,
              int abiversion)
 {
   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
     {
       int pmach = p->machine();
       if ((pmach == machine || pmach == elfcpp::EM_NONE)
-         && p->size() == size
-         && p->big_endian() ? big_endian : !big_endian)
+         && p->get_size() == size
+         && (p->is_big_endian() ? is_big_endian : !is_big_endian))
        {
          Target* ret = p->recognize(machine, osabi, abiversion);
          if (ret != NULL)

diff --git a/gold/target-select.h b/gold/target-select.h
index b339714deda34a970f655ffc1c9f4c928825e2b7..da27bd4df9cb3c133f66edb753bb196a68465578 100644 (file)
--- a/gold/target-select.h
+++ b/gold/target-select.h
@@ -42,7 +42,7 @@ class Target_selector
   // Create a target selector for a specific machine number, size (32
   // or 64), and endianness.  The machine number can be EM_NONE to
   // test for any machine number.
-  Target_selector(int machine, int size, bool big_endian);
+  Target_selector(int machine, int size, bool is_big_endian);
 
   virtual ~Target_selector()
   { }
@@ -64,18 +64,18 @@ class Target_selector
 
   // Return the size this is looking for (32 or 64).
   int
-  size() const
+  get_size() const
   { return this->size_; }
 
   // Return the endianness this is looking for.
   bool
-  big_endian() const
-  { return this->big_endian_; }
+  is_big_endian() const
+  { return this->is_big_endian_; }
 
  private:
   int machine_;
   int size_;
-  bool big_endian_;
+  bool is_big_endian_;
   Target_selector* next_;
 };
 

diff --git a/gold/testsuite/object_unittest.cc b/gold/testsuite/object_unittest.cc
index e95ea3273ab9e479665183584ca0a7af98cabe33..9b03425eea7b4a84cef0786b8e2efdfa81bf4ddf 100644 (file)
--- a/gold/testsuite/object_unittest.cc
+++ b/gold/testsuite/object_unittest.cc
@@ -34,12 +34,14 @@ using namespace gold;
 
 // Test basic Object functionality.
 
+template<int size, bool big_endian>
 bool
-Object_test(Test_report*)
+Sized_object_test(const unsigned char* test_file, unsigned int test_file_size,
+                 Target* target_test_pointer)
 {
-  Input_file input_file("test.o", test_file_1, test_file_1_size);
+  Input_file input_file("test.o", test_file, test_file_size);
   Object* object = make_elf_object("test.o", &input_file, 0,
-                                  test_file_1, test_file_1_size);
+                                  test_file, test_file_size);
   CHECK(object->name() == "test.o");
   CHECK(!object->is_dynamic());
   CHECK(object->target() == target_test_pointer);
@@ -56,6 +58,42 @@ Object_test(Test_report*)
   return true;
 }
 
+bool
+Object_test(Test_report*)
+{
+  int fail = 0;
+
+#ifdef HAVE_TARGET_32_LITTLE
+  if (!Sized_object_test<32, false>(test_file_1_32_little,
+                                   test_file_1_size_32_little,
+                                   target_test_pointer_32_little))
+    ++fail;
+#endif
+
+#ifdef HAVE_TARGET_32_BIG
+  if (!Sized_object_test<32, true>(test_file_1_32_big,
+                                  test_file_1_size_32_big,
+                                  target_test_pointer_32_big))
+    ++fail;
+#endif
+
+#ifdef HAVE_TARGET_64_LITTLE
+  if (!Sized_object_test<64, false>(test_file_1_64_little,
+                                   test_file_1_size_64_little,
+                                   target_test_pointer_64_little))
+    ++fail;
+#endif
+
+#ifdef HAVE_TARGET_64_BIG
+  if (!Sized_object_test<64, true>(test_file_1_64_big,
+                                  test_file_1_size_64_big,
+                                  target_test_pointer_64_big))
+    ++fail;
+#endif
+
+  return fail == 0;
+}
+
 Register_test object_register("Object", Object_test);
 
 } // End namespace gold_testsuite.

diff --git a/gold/testsuite/test.cc b/gold/testsuite/test.cc
index 6eec33952152c02aaa5f5a3aa31e667c52c2cc6d..4f16da071b43607019b89bef527f31349307e380 100644 (file)
--- a/gold/testsuite/test.cc
+++ b/gold/testsuite/test.cc
@@ -61,13 +61,22 @@ Test_framework::run(const char *name, bool (*pfn)(Test_report*))
   this->testname_ = NULL;
 }
 
+// Report a failure.
+
+void
+Test_framework::fail(const char* filename, int lineno)
+{
+  printf("FAIL: %s: %s: %d\n", this->testname_, filename, lineno);
+  this->current_fail_ = true;
+}
+
 // Let a test report an error.
 
 void
 Test_framework::error(const char* message)
 {
   printf("ERROR: %s: %s\n", this->testname_, message);
-  this->fail();
+  this->current_fail_ = true;
 }
 
 // Register_test methods.

diff --git a/gold/testsuite/test.h b/gold/testsuite/test.h
index cd2628ff16f30e7cc96a1c9c830c804af0bfc97f..1672d40d7a78f6eb349ab750ddc5281b0ea03d46 100644 (file)
--- a/gold/testsuite/test.h
+++ b/gold/testsuite/test.h
@@ -57,8 +57,7 @@ class Test_framework
 
   // Cause the current test to fail.
   void
-  fail()
-  { ++this->current_fail_ = true; }
+  fail(const char* filename, int lineno);
 
   // Report an error from the current test.
   void
@@ -89,8 +88,8 @@ public:
 
   // Mark the test as failing.
   void
-  fail()
-  { this->tf_->fail(); }
+  fail(const char* filename, int lineno)
+  { this->tf_->fail(filename, lineno); }
 
   // Report an error.
   void
@@ -131,8 +130,13 @@ class Register_test
 
 // Check that a condition is true.  If it is false, report a failure.
 
-#define CHECK(cond) \
-  ((cond) ? 0 : (::gold_testsuite::Test_framework::report()->fail(), 0))
+#define CHECK(cond)                                                    \
+  ((void)                                                              \
+   ((cond)                                                             \
+    ? 0                                                                        \
+    : (::gold_testsuite::Test_framework::report()->fail(__FILE__,      \
+                                                       __LINE__),      \
+       0)))
 
 // Report an error during a test.
 

diff --git a/gold/testsuite/testfile.cc b/gold/testsuite/testfile.cc
index bb2da76b1127b08e32740b13aedeefdd2c590f15..0404ce6d409eca207d7ed9de5aa2fc1ef32105dd 100644 (file)
--- a/gold/testsuite/testfile.cc
+++ b/gold/testsuite/testfile.cc
@@ -35,33 +35,35 @@ using namespace gold;
 
 // A Target used for testing purposes.
 
-class Target_test : public Sized_target<32, false>
+template<int size, bool big_endian>
+class Target_test : public Sized_target<size, big_endian>
 {
  public:
   Target_test()
-    : Sized_target<32, false>(&test_target_info)
+    : Sized_target<size, big_endian>(&test_target_info)
   { }
 
   void
   scan_relocs(const General_options&, Symbol_table*, Layout*,
-             Sized_relobj<32, false>*, unsigned int, unsigned int,
-             const unsigned char*, size_t, size_t, const unsigned char*,
-             Symbol**)
+             Sized_relobj<size, big_endian>*, unsigned int,
+             unsigned int, const unsigned char*, size_t, size_t,
+             const unsigned char*, Symbol**)
   { ERROR("call to Target_test::scan_relocs"); }
 
   void
-  relocate_section(const Relocate_info<32, false>*, unsigned int,
+  relocate_section(const Relocate_info<size, big_endian>*, unsigned int,
                   const unsigned char*, size_t, unsigned char*,
-                  elfcpp::Elf_types<32>::Elf_Addr, off_t)
+                  typename elfcpp::Elf_types<size>::Elf_Addr, off_t)
   { ERROR("call to Target_test::relocate_section"); }
 
   static const Target::Target_info test_target_info;
 };
 
-const Target::Target_info Target_test::test_target_info =
+template<int size, bool big_endian>
+const Target::Target_info Target_test<size, big_endian>::test_target_info =
 {
-  32,                                  // size
-  false,                               // is_big_endian
+  size,                                        // size
+  big_endian,                          // is_big_endian
   static_cast<elfcpp::EM>(0xffff),     // machine_code
   false,                               // has_make_symbol
   false,                               // has_resolve
@@ -72,36 +74,103 @@ const Target::Target_info Target_test::test_target_info =
   0x1000                               // common_pagesize
 };
 
-// The single test target.
+// The test targets.
 
-Target_test target_test;
+#ifdef HAVE_TARGET_32_LITTLE
+Target_test<32, false> target_test_32_little;
+#endif
 
-// A pointer to the test target.  This is used in CHECKs.
+#ifdef HAVE_TARGET_32_BIG
+Target_test<32, true> target_test_32_big;
+#endif
 
-Target* target_test_pointer = &target_test;
+#ifdef HAVE_TARGET_64_LITTLE
+Target_test<64, false> target_test_64_little;
+#endif
 
-// Select the test target.
+#ifdef HAVE_TARGET_64_BIG
+Target_test<64, true> target_test_64_big;
+#endif
 
+// A pointer to the test targets.  This is used in CHECKs.
+
+#ifdef HAVE_TARGET_32_LITTLE
+Target* target_test_pointer_32_little = &target_test_32_little;
+#endif
+
+#ifdef HAVE_TARGET_32_BIG
+Target* target_test_pointer_32_big = &target_test_32_big;
+#endif
+
+#ifdef HAVE_TARGET_64_LITTLE
+Target* target_test_pointer_64_little = &target_test_64_little;
+#endif
+
+#ifdef HAVE_TARGET_64_BIG
+Target* target_test_pointer_64_big = &target_test_64_big;
+#endif
+
+// Select the test targets.
+
+template<int size, bool big_endian>
 class Target_selector_test : public Target_selector
 {
  public:
   Target_selector_test()
-    : Target_selector(0xffff, 32, false)
+    : Target_selector(0xffff, size, big_endian)
   { }
 
   Target*
   recognize(int, int, int)
-  { return &target_test; }
+  {
+    if (size == 32)
+      {
+       if (!big_endian)
+         {
+#ifdef HAVE_TARGET_32_LITTLE
+           return &target_test_32_little;
+#endif
+         }
+       else
+         {
+#ifdef HAVE_TARGET_32_BIG
+           return &target_test_32_big;
+#endif
+         }
+      }
+    else
+      {
+       if (!big_endian)
+         {
+#ifdef HAVE_TARGET_64_LITTLE
+           return &target_test_64_little;
+#endif
+         }
+       else
+         {
+#ifdef HAVE_TARGET_64_BIG
+           return &target_test_64_big;
+#endif
+         }
+      }
+
+    return NULL;
+  }
 };
 
-// Register the test target selector.
+// Register the test target selectors.  These don't need to be
+// conditionally compiled, as they will return NULL if there is no
+// support for them.
 
-Target_selector_test target_selector_test;
+Target_selector_test<32, false> target_selector_test_32_little;
+Target_selector_test<32, true> target_selector_test_32_big;
+Target_selector_test<64, false> target_selector_test_64_little;
+Target_selector_test<64, true> target_selector_test_64_big;
 
 // A simple ELF object with one empty section, named ".test" and one
 // globally visible symbol named "test".
 
-const unsigned char test_file_1[] =
+const unsigned char test_file_1_32_little[] =
 {
   // Ehdr
   // EI_MAG[0-3]
@@ -277,6 +346,552 @@ const unsigned char test_file_1[] =
   '.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', '\0'
 };
 
-const unsigned int test_file_1_size = sizeof test_file_1;
+const unsigned int test_file_1_size_32_little = sizeof test_file_1_32_little;
+
+// 32-bit big-endian version of test_file_1_32_little.
+
+const unsigned char test_file_1_32_big[] =
+{
+  // Ehdr
+  // EI_MAG[0-3]
+  0x7f, 'E', 'L', 'F',
+  // EI_CLASS: 32 bit.
+  1,
+  // EI_DATA: big endian
+  2,
+  // EI_VERSION
+  1,
+  // EI_OSABI
+  0,
+  // EI_ABIVERSION
+  0,
+  // EI_PAD
+  0, 0, 0, 0, 0, 0, 0,
+  // e_type: ET_REL
+  0, 1,
+  // e_machine: a magic value used for testing.
+  0xff, 0xff,
+  // e_version
+  0, 0, 0, 1,
+  // e_entry
+  0, 0, 0, 0,
+  // e_phoff
+  0, 0, 0, 0,
+  // e_shoff: starts right after file header
+  0, 0, 0, 52,
+  // e_flags
+  0, 0, 0, 0,
+  // e_ehsize
+  0, 52,
+  // e_phentsize
+  0, 32,
+  // e_phnum
+  0, 0,
+  // e_shentsize
+  0, 40,
+  // e_shnum: dummy, .test, .symtab, .strtab, .shstrtab
+  0, 5,
+  // e_shstrndx
+  0, 4,
+
+  // Offset 52
+  // Shdr 0: dummy entry
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 92
+  // Shdr 1: .test
+  // sh_name: after initial null
+  0, 0, 0, 1,
+  // sh_type: SHT_PROGBITS
+  0, 0, 0, 1,
+  // sh_flags: SHF_ALLOC
+  0, 0, 0, 2,
+  // sh_addr
+  0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers
+  0, 0, 0, 252,
+  // sh_size
+  0, 0, 0, 0,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0,
+
+  // Offset 132
+  // Shdr 2: .symtab
+  // sh_name: 1 null byte + ".test\0"
+  0, 0, 0, 7,
+  // sh_type: SHT_SYMTAB
+  0, 0, 0, 2,
+  // sh_flags
+  0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers + empty section
+  0, 0, 0, 252,
+  // sh_size: two symbols: dummy symbol + test symbol
+  0, 0, 0, 32,
+  // sh_link: to .strtab
+  0, 0, 0, 3,
+  // sh_info: one local symbol, the dummy symbol
+  0, 0, 0, 1,
+  // sh_addralign
+  0, 0, 0, 4,
+  // sh_entsize: size of symbol
+  0, 0, 0, 16,
+
+  // Offset 172
+  // Shdr 3: .strtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0"
+  0, 0, 0, 15,
+  // sh_type: SHT_STRTAB
+  0, 0, 0, 3,
+  // sh_flags
+  0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0,
+  // sh_offset: after .symtab section.  284 == 0x11c
+  0, 0, 0x1, 0x1c,
+  // sh_size: 1 null byte + "test\0"
+  0, 0, 0, 6,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0,
+
+  // Offset 212
+  // Shdr 4: .shstrtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0" + ".strtab\0"
+  0, 0, 0, 23,
+  // sh_type: SHT_STRTAB
+  0, 0, 0, 3,
+  // sh_flags
+  0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0,
+  // sh_offset: after .strtab section.  290 == 0x122
+  0, 0, 0x1, 0x22,
+  // sh_size: all section names
+  0, 0, 0, 33,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0,
+
+  // Offset 252
+  // Contents of .symtab section
+  // Symbol 0
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 268
+  // Symbol 1
+  // st_name
+  0, 0, 0, 1,
+  // st_value
+  0, 0, 0, 0,
+  // st_size
+  0, 0, 0, 0,
+  // st_info: STT_NOTYPE, STB_GLOBAL
+  0x10,
+  // st_other
+  0,
+  // st_shndx: In .test
+  0, 1,
+
+  // Offset 284
+  // Contents of .strtab section
+  '\0',
+  't', 'e', 's', 't', '\0',
+
+  // Offset 290
+  // Contents of .shstrtab section
+  '\0',
+  '.', 't', 'e', 's', 't', '\0',
+  '.', 's', 'y', 'm', 't', 'a', 'b', '\0',
+  '.', 's', 't', 'r', 't', 'a', 'b', '\0',
+  '.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', '\0'
+};
+
+const unsigned int test_file_1_size_32_big = sizeof test_file_1_32_big;
+
+// 64-bit little-endian version of test_file_1_32_little.
+
+const unsigned char test_file_1_64_little[] =
+{
+  // Ehdr
+  // EI_MAG[0-3]
+  0x7f, 'E', 'L', 'F',
+  // EI_CLASS: 64 bit.
+  2,
+  // EI_DATA: little endian
+  1,
+  // EI_VERSION
+  1,
+  // EI_OSABI
+  0,
+  // EI_ABIVERSION
+  0,
+  // EI_PAD
+  0, 0, 0, 0, 0, 0, 0,
+  // e_type: ET_REL
+  1, 0,
+  // e_machine: a magic value used for testing.
+  0xff, 0xff,
+  // e_version
+  1, 0, 0, 0,
+  // e_entry
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // e_phoff
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // e_shoff: starts right after file header
+  64, 0, 0, 0, 0, 0, 0, 0,
+  // e_flags
+  0, 0, 0, 0,
+  // e_ehsize
+  64, 0,
+  // e_phentsize
+  56, 0,
+  // e_phnum
+  0, 0,
+  // e_shentsize
+  64, 0,
+  // e_shnum: dummy, .test, .symtab, .strtab, .shstrtab
+  5, 0,
+  // e_shstrndx
+  4, 0,
+
+  // Offset 64
+  // Shdr 0: dummy entry
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 128
+  // Shdr 1: .test
+  // sh_name: after initial null
+  1, 0, 0, 0,
+  // sh_type: SHT_PROGBITS
+  1, 0, 0, 0,
+  // sh_flags: SHF_ALLOC
+  2, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers.  384 == 0x180.
+  0x80, 0x1, 0, 0, 0, 0, 0, 0,
+  // sh_size
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  1, 0, 0, 0, 0, 0, 0, 0,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 192
+  // Shdr 2: .symtab
+  // sh_name: 1 null byte + ".test\0"
+  7, 0, 0, 0,
+  // sh_type: SHT_SYMTAB
+  2, 0, 0, 0,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers + empty section
+  // 384 == 0x180.
+  0x80, 0x1, 0, 0, 0, 0, 0, 0,
+  // sh_size: two symbols: dummy symbol + test symbol
+  48, 0, 0, 0, 0, 0, 0, 0,
+  // sh_link: to .strtab
+  3, 0, 0, 0,
+  // sh_info: one local symbol, the dummy symbol
+  1, 0, 0, 0,
+  // sh_addralign
+  8, 0, 0, 0, 0, 0, 0, 0,
+  // sh_entsize: size of symbol
+  24, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 256
+  // Shdr 3: .strtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0"
+  15, 0, 0, 0,
+  // sh_type: SHT_STRTAB
+  3, 0, 0, 0,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after .symtab section.  432 == 0x1b0
+  0xb0, 0x1, 0, 0, 0, 0, 0, 0,
+  // sh_size: 1 null byte + "test\0"
+  6, 0, 0, 0, 0, 0, 0, 0,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  1, 0, 0, 0, 0, 0, 0, 0,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 320
+  // Shdr 4: .shstrtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0" + ".strtab\0"
+  23, 0, 0, 0,
+  // sh_type: SHT_STRTAB
+  3, 0, 0, 0,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after .strtab section.  438 == 0x1b6
+  0xb6, 0x1, 0, 0, 0, 0, 0, 0,
+  // sh_size: all section names
+  33, 0, 0, 0, 0, 0, 0, 0,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  1, 0, 0, 0, 0, 0, 0, 0,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 384
+  // Contents of .symtab section
+  // Symbol 0
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 408
+  // Symbol 1
+  // st_name
+  1, 0, 0, 0,
+  // st_info: STT_NOTYPE, STB_GLOBAL
+  0x10,
+  // st_other
+  0,
+  // st_shndx: In .test
+  1, 0,
+  // st_value
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // st_size
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 432
+  // Contents of .strtab section
+  '\0',
+  't', 'e', 's', 't', '\0',
+
+  // Offset 438
+  // Contents of .shstrtab section
+  '\0',
+  '.', 't', 'e', 's', 't', '\0',
+  '.', 's', 'y', 'm', 't', 'a', 'b', '\0',
+  '.', 's', 't', 'r', 't', 'a', 'b', '\0',
+  '.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', '\0'
+};
+
+const unsigned int test_file_1_size_64_little = sizeof test_file_1_64_little;
+
+// 64-bit big-endian version of test_file_1_32_little.
+
+const unsigned char test_file_1_64_big[] =
+{
+  // Ehdr
+  // EI_MAG[0-3]
+  0x7f, 'E', 'L', 'F',
+  // EI_CLASS: 64 bit.
+  2,
+  // EI_DATA: big endian
+  2,
+  // EI_VERSION
+  1,
+  // EI_OSABI
+  0,
+  // EI_ABIVERSION
+  0,
+  // EI_PAD
+  0, 0, 0, 0, 0, 0, 0,
+  // e_type: ET_REL
+  0, 1,
+  // e_machine: a magic value used for testing.
+  0xff, 0xff,
+  // e_version
+  0, 0, 0, 1,
+  // e_entry
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // e_phoff
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // e_shoff: starts right after file header
+  0, 0, 0, 0, 0, 0, 0, 64,
+  // e_flags
+  0, 0, 0, 0,
+  // e_ehsize
+  0, 64,
+  // e_phentsize
+  0, 56,
+  // e_phnum
+  0, 0,
+  // e_shentsize
+  0, 64,
+  // e_shnum: dummy, .test, .symtab, .strtab, .shstrtab
+  0, 5,
+  // e_shstrndx
+  0, 4,
+
+  // Offset 64
+  // Shdr 0: dummy entry
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 128
+  // Shdr 1: .test
+  // sh_name: after initial null
+  0, 0, 0, 1,
+  // sh_type: SHT_PROGBITS
+  0, 0, 0, 1,
+  // sh_flags: SHF_ALLOC
+  0, 0, 0, 0, 0, 0, 0, 2,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers.  384 == 0x180.
+  0, 0, 0, 0, 0, 0, 0x1, 0x80,
+  // sh_size
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 0, 0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 192
+  // Shdr 2: .symtab
+  // sh_name: 1 null byte + ".test\0"
+  0, 0, 0, 7,
+  // sh_type: SHT_SYMTAB
+  0, 0, 0, 2,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after file header + 5 section headers + empty section
+  // 384 == 0x180.
+  0, 0, 0, 0, 0, 0, 0x1, 0x80,
+  // sh_size: two symbols: dummy symbol + test symbol
+  0, 0, 0, 0, 0, 0, 0, 48,
+  // sh_link: to .strtab
+  0, 0, 0, 3,
+  // sh_info: one local symbol, the dummy symbol
+  0, 0, 0, 1,
+  // sh_addralign
+  0, 0, 0, 0, 0, 0, 0, 8,
+  // sh_entsize: size of symbol
+  0, 0, 0, 0, 0, 0, 0, 24,
+
+  // Offset 256
+  // Shdr 3: .strtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0"
+  0, 0, 0, 15,
+  // sh_type: SHT_STRTAB
+  0, 0, 0, 3,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after .symtab section.  432 == 0x1b0
+  0, 0, 0, 0, 0, 0, 0x1, 0xb0,
+  // sh_size: 1 null byte + "test\0"
+  0, 0, 0, 0, 0, 0, 0, 6,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 0, 0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 320
+  // Shdr 4: .shstrtab
+  // sh_name: 1 null byte + ".test\0" + ".symtab\0" + ".strtab\0"
+  0, 0, 0, 23,
+  // sh_type: SHT_STRTAB
+  0, 0, 0, 3,
+  // sh_flags
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_addr
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // sh_offset: after .strtab section.  438 == 0x1b6
+  0, 0, 0, 0, 0, 0, 0x1, 0xb6,
+  // sh_size: all section names
+  0, 0, 0, 0, 0, 0, 0, 33,
+  // sh_link
+  0, 0, 0, 0,
+  // sh_info
+  0, 0, 0, 0,
+  // sh_addralign
+  0, 0, 0, 0, 0, 0, 0, 1,
+  // sh_entsize
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 384
+  // Contents of .symtab section
+  // Symbol 0
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 408
+  // Symbol 1
+  // st_name
+  0, 0, 0, 1,
+  // st_info: STT_NOTYPE, STB_GLOBAL
+  0x10,
+  // st_other
+  0,
+  // st_shndx: In .test
+  0, 1,
+  // st_value
+  0, 0, 0, 0, 0, 0, 0, 0,
+  // st_size
+  0, 0, 0, 0, 0, 0, 0, 0,
+
+  // Offset 432
+  // Contents of .strtab section
+  '\0',
+  't', 'e', 's', 't', '\0',
+
+  // Offset 438
+  // Contents of .shstrtab section
+  '\0',
+  '.', 't', 'e', 's', 't', '\0',
+  '.', 's', 'y', 'm', 't', 'a', 'b', '\0',
+  '.', 's', 't', 'r', 't', 'a', 'b', '\0',
+  '.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', '\0'
+};
+
+const unsigned int test_file_1_size_64_big = sizeof test_file_1_64_big;
 
 } // End namespace gold_testsuite.

diff --git a/gold/testsuite/testfile.h b/gold/testsuite/testfile.h
index 9a5fbc387588146eac03171031f4f7d4077b5ebd..b7bafcb4d5edabd189560d376181a9f315e46f0d 100644 (file)
--- a/gold/testsuite/testfile.h
+++ b/gold/testsuite/testfile.h
@@ -31,9 +31,18 @@ class Target;
 namespace gold_testsuite
 {
 
-extern gold::Target* target_test_pointer;
-extern const unsigned char test_file_1[];
-extern const unsigned int test_file_1_size;
+extern gold::Target* target_test_pointer_32_little;
+extern gold::Target* target_test_pointer_32_big;
+extern gold::Target* target_test_pointer_64_little;
+extern gold::Target* target_test_pointer_64_big;
+extern const unsigned char test_file_1_32_little[];
+extern const unsigned int test_file_1_size_32_little;
+extern const unsigned char test_file_1_32_big[];
+extern const unsigned int test_file_1_size_32_big;
+extern const unsigned char test_file_1_64_little[];
+extern const unsigned int test_file_1_size_64_little;
+extern const unsigned char test_file_1_64_big[];
+extern const unsigned int test_file_1_size_64_big;
 
 }; // End namespace gold_testsuite.