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

crosstest/test_calling_conv.cpp

Index: crosstest/test_calling_conv.cpp
diff --git a/crosstest/test_calling_conv.cpp b/crosstest/test_calling_conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30085b51664e2a8af178d4d6b00ed7d19de8f5fd
--- /dev/null
+++ b/crosstest/test_calling_conv.cpp
@@ -0,0 +1,92 @@
+//===- subzero/crosstest/test_calling_conv.cpp - Implementation for tests -===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the test functions used to check that Subzero
+// generates code compatible with the calling convention used by
+// llc. "Caller" functions test the handling of out-args, and "callee"
+// functions test the handling of in-args.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+
+#include "test_calling_conv.h"
+
+#define CALL_AS_TYPE(Ty) (reinterpret_cast<Ty *>(Callee))

[Jim Stichnoth, 2014/08/06 18:26:15]

Here and below, it would be nice to minimize the use of unbound variables in
macros.  I.e., change to:

  #define CALL_AS_TYPE(Ty, Callee) ...
  ...
  CALL_AS_TYPE(blah, Callee)(...);

[wala, 2014/08/07 18:09:21]

Done.

+
+void caller_i(void) {
+  int arg1 = 0x12345678;
+  CALL_AS_TYPE(callee_i_Ty)(arg1);
+}
+
+void caller_vvvvv(void) {
+  v4si32 arg1 = {0, 1, 2, 3};
+  v4si32 arg2 = {4, 5, 6, 7};
+  v4si32 arg3 = {8, 9, 10, 11};
+  v4si32 arg4 = {12, 13, 14, 15};
+  v4si32 arg5 = {16, 17, 18, 19};
+
+  CALL_AS_TYPE(callee_vvvvv_Ty)(arg1, arg2, arg3, arg4, arg5);
+}
+
+void caller_vlvlvfvdviv(void) {
+  v4f32 arg1 = {0, 1, 2, 3};
+  int64_t arg2 = 4;
+  v4f32 arg3 = {5, 6, 7, 8};
+  int64_t arg4 = 9;
+  v4f32 arg5 = {10, 11, 12, 13};
+  float arg6 = 14;
+  v4f32 arg7 = {15, 16, 17, 18};
+  double arg8 = 19;
+  v4f32 arg9 = {20, 21, 22, 23};
+  int arg10 = 24;
+  v4f32 arg11 = {25, 26, 27, 28};
+
+  CALL_AS_TYPE(callee_vlvlvfvdviv_Ty)(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
+                                      arg8, arg9, arg10, arg11);
+}
+
+#define HANDLE_ARG(ARGNUM)                                                     \
+  case ARGNUM:                                                                 \
+    memcpy(&Buf[0], &arg##ARGNUM, sizeof(arg##ARGNUM));                        \
+    break;
+
+void __attribute__((noinline)) callee_i(int arg1) {
+  switch (ArgNum) { HANDLE_ARG(1); }
+}
+
+void __attribute__((noinline))
+callee_vvvvv(v4si32 arg1, v4si32 arg2, v4si32 arg3, v4si32 arg4, v4si32 arg5) {
+  switch (ArgNum) {
+    HANDLE_ARG(1);
+    HANDLE_ARG(2);
+    HANDLE_ARG(3);
+    HANDLE_ARG(4);
+    HANDLE_ARG(5);
+  }
+}
+
+void __attribute__((noinline))
+callee_vlvlvfvdviv(v4f32 arg1, int64_t arg2, v4f32 arg3, int64_t arg4,
+                   v4f32 arg5, float arg6, v4f32 arg7, double arg8, v4f32 arg9,
+                   int arg10, v4f32 arg11) {
+  switch (ArgNum) {
+    HANDLE_ARG(1);
+    HANDLE_ARG(2);
+    HANDLE_ARG(3);
+    HANDLE_ARG(4);
+    HANDLE_ARG(5);
+    HANDLE_ARG(6);
+    HANDLE_ARG(7);
+    HANDLE_ARG(8);
+    HANDLE_ARG(9);
+    HANDLE_ARG(10);
+    HANDLE_ARG(11);
+  }
+}