Subzero: Add basic ELFObjectWriter (text section, symtab, strtab, headers)

unittest/IceELFSectionTest.cpp

Index: unittest/IceELFSectionTest.cpp
diff --git a/unittest/IceELFSectionTest.cpp b/unittest/IceELFSectionTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..96e6d5f2dd3954e31ae7f3175516534961b277cf
--- /dev/null
+++ b/unittest/IceELFSectionTest.cpp
@@ -0,0 +1,134 @@
+//===- unittest/IceELFSectionTest.cpp - ELF Section unit tests ------------===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+
+#include "IceDefs.h"
+#include "IceELFSection.h"
+#include "gtest/gtest.h"

[Jim Stichnoth, 2014/11/21 21:32:23]

Should this include go before the Ice*.h includes?  (and after the <> includes)

[jvoung (off chromium), 2014/11/24 21:35:47]

Done.

+
+namespace Ice {
+namespace {
+
+// Test string table layout for various permutations. Test that pop,
+// lollipop, and lipop are able to share data, while the other strings do not.

[jvoung (off chromium), 2014/11/21 00:11:55]

Not sure how you guys feel about adding another type of test suite.

This isn't terribly important, and the elf_container.ll test will at least make
sure the strings make sense to llvm-readobj, but it seemed easier to test for
sharing this way.

+void CheckStringTablePermLayout(const ELFStringTableSection &Strtab) {
+  size_t pop_index = Strtab.getIndex("pop");
+  size_t pop_size = IceString("pop").size();
+  size_t lollipop_index = Strtab.getIndex("lollipop");
+  size_t lollipop_size = IceString("lollipop").size();
+  size_t lipop_index = Strtab.getIndex("lipop");
+  size_t lipop_size = IceString("lipop").size();
+  size_t pops_index = Strtab.getIndex("pops");
+  size_t pops_size = IceString("pops").size();
+  size_t unpop_index = Strtab.getIndex("unpop");
+  size_t unpop_size = IceString("unpop").size();
+  size_t popular_index = Strtab.getIndex("popular");
+  size_t popular_size = IceString("popular").size();
+  size_t strtab_index = Strtab.getIndex(".strtab");
+  size_t strtab_size = IceString(".strtab").size();
+  size_t shstrtab_index = Strtab.getIndex(".shstrtab");
+  size_t shstrtab_size = IceString(".shstrtab").size();
+  size_t symtab_index = Strtab.getIndex(".symtab");
+  size_t symtab_size = IceString(".symtab").size();
+
+  // Check that some sharing exists.
+  EXPECT_EQ(pop_index, lollipop_index + (lollipop_size - pop_size));
+  EXPECT_EQ(lipop_index, lollipop_index + (lollipop_size - lipop_size));
+
+  // Check that .strtab does not share with .shstrtab (the dot throws it off).
+  EXPECT_NE(strtab_index, shstrtab_index + (shstrtab_size - strtab_size));
+
+  // Check contents make sense.
+  EXPECT_EQ(Strtab.getSectionData().slice(pop_index, pop_index + pop_size),
+            llvm::StringRef("pop"));
+  EXPECT_EQ(Strtab.getSectionData().slice(lollipop_index,
+                                          lollipop_index + lollipop_size),
+            llvm::StringRef("lollipop"));
+  EXPECT_EQ(Strtab.getSectionData().slice(pops_index,
+                                          pops_index + pops_size),
+            llvm::StringRef("pops"));
+  EXPECT_EQ(Strtab.getSectionData().slice(unpop_index,
+                                          unpop_index + unpop_size),
+            llvm::StringRef("unpop"));
+  EXPECT_EQ(Strtab.getSectionData().slice(popular_index,
+                                          popular_index + popular_size),
+            llvm::StringRef("popular"));
+  EXPECT_EQ(Strtab.getSectionData().slice(strtab_index,
+                                          strtab_index + strtab_size),
+            llvm::StringRef(".strtab"));
+  EXPECT_EQ(Strtab.getSectionData().slice(shstrtab_index,
+                                          shstrtab_index + shstrtab_size),
+            llvm::StringRef(".shstrtab"));
+  EXPECT_EQ(Strtab.getSectionData().slice(symtab_index,
+                                          symtab_index + symtab_size),
+            llvm::StringRef(".symtab"));
+}
+
+// Test that the order in which strings are added doesn't matter.
+TEST(IceELFSectionTest, StringTableBuilderPermSeveral) {
+  std::vector<IceString> Strings;
+  Strings.push_back("pop");
+  Strings.push_back("lollipop");
+  Strings.push_back("lipop");
+  Strings.push_back("pops");
+  Strings.push_back("unpop");
+  Strings.push_back("popular");
+  Strings.push_back("a");
+  Strings.push_back("z");
+  Strings.push_back("foo");
+  Strings.push_back("bar");
+  Strings.push_back(".text");
+  Strings.push_back(".symtab");
+  Strings.push_back(".strtab");
+  Strings.push_back(".shstrtab");
+  Strings.push_back("_start");
+  const SizeT NumTests = 128;
+  for (SizeT i = 0; i < NumTests; ++i) {
+    std::random_shuffle(Strings.begin(), Strings.end());
+    ELFStringTableSection Strtab(".strtab", SHT_STRTAB, 0, 1, 0);
+    for (auto &S : Strings) {
+      Strtab.add(S);
+    }
+    Strtab.doLayout();
+    CheckStringTablePermLayout(Strtab);
+  }
+}
+
+// Test that adding duplicate strings is fine.
+TEST(IceELFSectionTest, StringTableBuilderDuplicates) {
+  ELFStringTableSection Strtab(".strtab", SHT_STRTAB, 0, 1, 0);
+  Strtab.add("unpop");
+  Strtab.add("pop");
+  Strtab.add("lollipop");
+  Strtab.add("a");
+  Strtab.add("popular");
+  Strtab.add("pops");
+  Strtab.add("lipop");
+  Strtab.add(".strtab");
+  Strtab.add(".shstrtab");
+  Strtab.add(".symtab");
+
+  Strtab.add(".symtab");
+  Strtab.add(".shstrtab");
+  Strtab.add(".strtab");
+  Strtab.add("lipop");
+  Strtab.add("pops");
+  Strtab.add("popular");
+  Strtab.add("a");
+  Strtab.add("lollipop");
+  Strtab.add("pop");
+  Strtab.add("unpop");
+
+  Strtab.doLayout();
+  CheckStringTablePermLayout(Strtab);
+}
+
+} // end of anonymous namespace
+} // end of namespace Ice