Introduce model of global initializers in Subzero.

crosstest/test_global.cpp

Index: crosstest/test_global.cpp
diff --git a/crosstest/test_global.cpp b/crosstest/test_global.cpp
index a670ff222528ea402055bac951735e74f0939b63..a093f491be9ca9742e1c3cc69320de3759cf1335 100644
--- a/crosstest/test_global.cpp
+++ b/crosstest/test_global.cpp
@@ -16,63 +16,73 @@
 
 #include "test_global.h"
 
+// Note: The following take advantage of the fact that external global
+// names are not mangled with the --prefix CL argument. Hence, they
+// should have the same relocation value for both clang and Subzero.

[Jim Stichnoth, 2014/10/06 18:16:37]

clang --> llc

[Karl, 2014/10/06 22:44:04]

Done.

+extern uint8_t *ExternName1;
+extern uint8_t *ExternName2;
+extern uint8_t *ExternName3;
+extern uint8_t *ExternName4;
+extern uint8_t *ExternName5;
+
 // Partially initialized array
-int ArrayInitPartial[10] = { 60, 70, 80, 90, 100 };
-int ArrayInitFull[] = { 10, 20, 30, 40, 50 };
-const int ArrayConst[] = { -10, -20, -30 };
+static int ArrayInitPartial[10] = {60, 70, 80, 90, 100};

[Jim Stichnoth, 2014/10/06 18:16:37]

Is it necessary to change all these to static?  IIRC, I originally made them
non-static so that the various combinations of asm directives would be
exercised.  I realize that the PNaCl bitcode doesn't allow non-static, but this
mechanism is still somewhat important for cross testing, bisection debugging,
etc.

[Karl, 2014/10/06 22:44:04]

Removed static keyword.

+static int ArrayInitFull[] = {10, 20, 30, 40, 50};
+static const int ArrayConst[] = {-10, -20, -30};
 static double ArrayDouble[10] = { 0.5, 1.5, 2.5, 3.5 };
 
 #if 0
+// TODO(kschimpf) Add this example once we know how to not mangle

[Jim Stichnoth, 2014/10/06 18:16:37]

Could you add a reference to the part in IceTargetLoweringX8632.cpp where the
.long is emitted, to make it clearer what this TODO means?

[Karl, 2014/10/06 22:44:03]

Done.

+// uninitialized, external globals (so that we can compare that
+// the same, unmangled relocations are used).
+static struct {
+  int Array1[5];
+  uint8_t *Pointer1;
+  double Array2[3];
+  uint8_t *Pointer2;
+  struct {
+    uint8_t *Pointer3;
+    int Array1[3];
+    uint8_t *Pointer4;
+  } NestedStuff;
+  uint8_t *Pointer5;
+} StructEx = {
+  { 10, 20, 30, 40, 50 },
+  ExternName1,
+  { 0.5, 1.5, 2.5 },
+  ExternName4,
+  { ExternName3, {1000, 1010, 1020}, ExternName2 },
+  ExternName5,
+};
+#endif
+
 #define ARRAY(a)                                                               \
   { (uint8_t *)(a), sizeof(a) }
 
+// Note: By embedding the array addresses in this table, we are indirectly
+// testing relocations (i.e. getArray would return the wrong address if
+// relocations are broken).
 struct {
   uint8_t *ArrayAddress;
   size_t ArraySizeInBytes;
 } Arrays[] = {
-  ARRAY(ArrayInitPartial),
-  ARRAY(ArrayInitFull),
-  ARRAY(ArrayConst),
-  ARRAY(ArrayDouble),
+      ARRAY(ArrayInitPartial),
+      ARRAY(ArrayInitFull),
+      ARRAY(ArrayConst),
+      ARRAY(ArrayDouble),
+      {(uint8_t *)(ArrayInitPartial + 2),
+       sizeof(ArrayInitPartial) - 2 * sizeof(int)},
+      // { (uint8_t*)(&StructEx), sizeof(StructEx) },
 };
 size_t NumArraysElements = sizeof(Arrays) / sizeof(*Arrays);
-#endif // 0
 
-size_t getNumArrays() {
-  return 4;
-  // return NumArraysElements;
-}
+size_t getNumArrays() { return NumArraysElements; }
 
 const uint8_t *getArray(size_t WhichArray, size_t &Len) {
-  // Using a switch statement instead of a table lookup because such a
-  // table is represented as a kind of initializer that Subzero
-  // doesn't yet support.  Specifically, the table becomes constant
-  // aggregate data, and it contains relocations.  TODO(stichnot):
-  // switch over to the cleaner table-based method when global
-  // initializers are fully implemented.
-  switch (WhichArray) {
-  default:
-    Len = -1;
-    return NULL;
-  case 0:
-    Len = sizeof(ArrayInitPartial);
-    return (uint8_t *)&ArrayInitPartial;
-  case 1:
-    Len = sizeof(ArrayInitFull);
-    return (uint8_t *)&ArrayInitFull;
-  case 2:
-    Len = sizeof(ArrayConst);
-    return (uint8_t *)&ArrayConst;
-  case 3:
-    Len = sizeof(ArrayDouble);
-    return (uint8_t *)&ArrayDouble;
-  }
-#if 0
   if (WhichArray >= NumArraysElements) {
     Len = -1;
     return NULL;
   }
   Len = Arrays[WhichArray].ArraySizeInBytes;
   return Arrays[WhichArray].ArrayAddress;
-#endif // 0
 }