Subzero: Align the stack at the point of function calls.

crosstest/test_calling_conv_main.cpp

Index: crosstest/test_calling_conv_main.cpp
diff --git a/crosstest/test_calling_conv_main.cpp b/crosstest/test_calling_conv_main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0101df7c65ccc36cb740a555f12ad1b40b2c8f63
--- /dev/null
+++ b/crosstest/test_calling_conv_main.cpp
@@ -0,0 +1,164 @@
+//===- subzero/crosstest/test_calling_conv_main.cpp - Driver for tests ----===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Driver for cross testing the compatibility of calling conventions

[Jim Stichnoth, 2014/08/05 18:09:26]

Period at end of sentence?

[wala, 2014/08/05 23:57:03]

Done.

+//
+//===----------------------------------------------------------------------===//
+
+/* crosstest.py --test=test_calling_conv.c                 \
+   --driver=test_calling_conv_main.cpp --prefix=Subzero_   \
+   --output=test_calling_conv */
+
+#include <iostream>

[Jim Stichnoth, 2014/08/05 18:09:26]

Alphabetize the includes.

[wala, 2014/08/05 23:57:03]

Done.

+#include <sstream>
+#include <cstring>
+
+#include "test_calling_conv.h"
+

[Jim Stichnoth, 2014/08/05 18:09:26]

There should be a comment here describing the big picture of how this test
works.

[wala, 2014/08/05 23:57:03]

Done.

+extern "C" {
+size_t ArgNum, Subzero_ArgNum;
+size_t DynAllocaSize, Subzero_DynAllocaSize;
+CalleePtrTy Callee, Subzero_Callee;
+char *Buf, *Subzero_Buf;
+
+void fakeUse(void *) {}
+void Subzero_fakeUse(void *) {}
+}
+
+const static size_t ALLOCA_SIZE = 7;
+const static size_t BUF_SIZE = 16;
+
+std::string bufAsString(const char Buf[BUF_SIZE]) {
+  std::ostringstream OS;
+  for (size_t i = 0; i < BUF_SIZE; ++i) {
+    if (i > 0)
+      OS << " ";
+    OS << (unsigned) Buf[i];
+  }
+  return OS.str();
+}
+
+void testCaller(size_t &TotalTests, size_t &Passes, size_t &Failures) {
+  static struct {
+    const char *CallerName, *CalleeName;
+    size_t Args;
+    void (*Caller)(void);
+    void (*Subzero_Caller)(void);
+    CalleePtrTy Callee;
+  } Funcs[] = {
+#define X(caller, callee, argc)                                                \
+  {                                                                            \
+    STR(caller), STR(callee), argc, &caller, &Subzero_##caller,                \
+        reinterpret_cast<CalleePtrTy>(&callee),                                \
+  }                                                                            \
+  ,
+    CALLER_TEST_FUNC_TABLE
+#undef X
+  };
+
+  const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
+
+  for (size_t f = 0; f < NumFuncs; ++f) {
+    char BufLlc[BUF_SIZE], BufSz[BUF_SIZE];
+    Callee = Subzero_Callee = Funcs[f].Callee;
+    DynAllocaSize = Subzero_DynAllocaSize = ALLOCA_SIZE;
+
+    for (size_t i = 0; i < Funcs[f].Args; ++i) {
+      memset(BufLlc, 0xff, sizeof(BufLlc));
+      memset(BufSz, 0xff, sizeof(BufSz));
+
+      ArgNum = Subzero_ArgNum = i;
+
+      Buf = BufLlc;
+      Funcs[f].Caller();
+
+      Buf = BufSz;
+      Funcs[f].Subzero_Caller();
+
+      ++TotalTests;
+      if (!memcmp(BufLlc, BufSz, sizeof(BufLlc))) {
+        ++Passes;
+      } else {
+        ++Failures;
+        std::cout << "testCaller(Caller=" << Funcs[f].CallerName << ", ";
+        std::cout << "Callee=" << Funcs[f].CalleeName << ", ";
+        std::cout << "ArgNum=" << ArgNum << ")\n";
+        std::cout << "sz =" << bufAsString(BufSz) << "\n";
+        std::cout << "llc=" << bufAsString(BufLlc) << "\n";
+      }
+    }
+  }
+}
+
+void testCallee(size_t &TotalTests, size_t &Passes, size_t &Failures) {
+  static struct {
+    const char *CallerName, *CalleeName;
+    size_t Args;
+    void (*Caller)(void);
+    CalleePtrTy Callee, Subzero_Callee;
+  } Funcs[] = {
+#define X(caller, callee, argc)                                                \
+  {                                                                            \
+    STR(caller), STR(callee), argc, &caller,                                   \
+        reinterpret_cast<CalleePtrTy>(&callee),                                \
+        reinterpret_cast<CalleePtrTy>(&Subzero_##callee)                       \
+  }                                                                            \
+  ,
+    CALLEE_TEST_FUNC_TABLE
+#undef X
+  };
+
+  const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
+
+  for (size_t f = 0; f < NumFuncs; ++f) {
+    char BufLlc[BUF_SIZE], BufSz[BUF_SIZE];
+    Buf = BufLlc;
+    Subzero_Buf = BufSz;
+    DynAllocaSize = Subzero_DynAllocaSize = ALLOCA_SIZE;
+
+    for (size_t i = 0; i < Funcs[f].Args; ++i) {
+      memset(BufLlc, 0xff, sizeof(BufLlc));
+      memset(BufSz, 0xff, sizeof(BufSz));
+
+      ArgNum = Subzero_ArgNum = i;
+
+      Callee = Funcs[f].Callee;
+      Funcs[f].Caller();
+
+      Callee = Funcs[f].Subzero_Callee;
+      Funcs[f].Caller();
+
+      ++TotalTests;
+      if (!memcmp(BufLlc, BufSz, sizeof(BufLlc))) {
+        ++Passes;
+      } else {
+        ++Failures;
+        std::cout << "testCallee(Caller=" << Funcs[f].CallerName << ", ";
+        std::cout << "Callee=" << Funcs[f].CalleeName << ", ";
+        std::cout << "ArgNum=" << ArgNum << ")\n";
+        std::cout << "sz =" << bufAsString(BufSz) << "\n";
+        std::cout << "llc=" << bufAsString(BufLlc) << "\n";
+      }
+    }
+  }
+}
+
+int main(int argc, char *argv[]) {
+  size_t TotalTests = 0;
+  size_t Passes = 0;
+  size_t Failures = 0;
+
+  testCaller(TotalTests, Passes, Failures);
+  testCallee(TotalTests, Passes, Failures);
+
+  std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
+            << " Failures=" << Failures << "\n";
+
+  return Failures;
+}