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 };

[jvoung (off chromium), 2014/06/28 17:00:32]

I think these will essentially be static as well, if you leave out check for
IsInternal and .global from the emitter code.

In the test it happens to not matter though, because it's not checked by the
main.cpp.

+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
+}