Lower the rest of the vector arithmetic operations.

The instructions emitted by the lowering operations require memory
operands to be aligned to 16 bytes. Since there is no support for
aligning memory operands in Subzero, do the arithmetic in registers for
now.

Add vector arithmetic to the arith crosstest. Pass the -mstackrealign
parameter to the crosstest clang so that llc code called back from
Subzero code (helper calls) doesn't assume that the stack is aligned at
the entry to the call.

BUG=none
R=jvoung@chromium.org, stichnot@chromium.org

Review URL: https://codereview.chromium.org/397833002

crosstest/test_arith.cpp

diff --git a/crosstest/test_arith.cpp b/crosstest/test_arith.cpp
index 18b4b57..ed6c9d3 100644
--- a/crosstest/test_arith.cpp
+++ b/crosstest/test_arith.cpp
@@ -10,7 +10,10 @@
   uint8_t test##inst(uint8_t a, uint8_t b) { return a op b; }                  \
   uint16_t test##inst(uint16_t a, uint16_t b) { return a op b; }               \
   uint32_t test##inst(uint32_t a, uint32_t b) { return a op b; }               \
-  uint64_t test##inst(uint64_t a, uint64_t b) { return a op b; }
+  uint64_t test##inst(uint64_t a, uint64_t b) { return a op b; }               \
+  v4ui32 test##inst(v4ui32 a, v4ui32 b) { return a op b; }                     \
+  v8ui16 test##inst(v8ui16 a, v8ui16 b) { return a op b; }                     \
+  v16ui8 test##inst(v16ui8 a, v16ui8 b) { return a op b; }
 UINTOP_TABLE
 #undef X
 
@@ -19,12 +22,16 @@
   int8_t test##inst(int8_t a, int8_t b) { return a op b; }                     \
   int16_t test##inst(int16_t a, int16_t b) { return a op b; }                  \
   int32_t test##inst(int32_t a, int32_t b) { return a op b; }                  \
-  int64_t test##inst(int64_t a, int64_t b) { return a op b; }
+  int64_t test##inst(int64_t a, int64_t b) { return a op b; }                  \
+  v4si32 test##inst(v4si32 a, v4si32 b) { return a op b; }                     \
+  v8si16 test##inst(v8si16 a, v8si16 b) { return a op b; }                     \
+  v16si8 test##inst(v16si8 a, v16si8 b) { return a op b; }
 SINTOP_TABLE
 #undef X
 
 #define X(inst, op, func)                                                      \
   float test##inst(float a, float b) { return func(a op b); }                  \
-  double test##inst(double a, double b) { return func(a op b); }
+  double test##inst(double a, double b) { return func(a op b); }               \
+  v4f32 test##inst(v4f32 a, v4f32 b) { return func(a op b); }
 FPOP_TABLE
 #undef X