Subzero: Partial implementation of global initializers.

crosstest/test_global.cpp

+#include <stdint.h>
+#include <cstdlib>
+
+#include "test_global.h"
+
+// 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 double ArrayDouble[10] = { 0.5, 1.5, 2.5, 3.5 };
+
+#if 0
+#define ARRAY(a)                                                               \
+  { (uint8_t *)(a), sizeof(a) }
+
+struct {
+  uint8_t *ArrayAddress;
+  size_t ArraySizeInBytes;
+} Arrays[] = {
+  ARRAY(ArrayInitPartial),
+  ARRAY(ArrayInitFull),
+  ARRAY(ArrayConst),
+  ARRAY(ArrayDouble),
+};
+size_t NumArraysElements = sizeof(Arrays) / sizeof(*Arrays);
+#endif // 0
+
+size_t getNumArrays() {
+  return 4;
+  // 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
+}