OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "src/assembler-inl.h" | |
6 #include "src/wasm/wasm-macro-gen.h" | |
7 #include "test/cctest/cctest.h" | |
8 #include "test/cctest/compiler/value-helper.h" | |
9 #include "test/cctest/wasm/wasm-run-utils.h" | |
10 | |
11 typedef float (*FloatUnOp)(float); | |
12 typedef float (*FloatBinOp)(float, float); | |
13 typedef int32_t (*FloatCompareOp)(float, float); | |
14 typedef int32_t (*Int32UnOp)(int32_t); | |
15 typedef int32_t (*Int32BinOp)(int32_t, int32_t); | |
16 typedef int32_t (*Int32ShiftOp)(int32_t, int); | |
17 typedef int16_t (*Int16UnOp)(int16_t); | |
18 typedef int16_t (*Int16BinOp)(int16_t, int16_t); | |
19 typedef int16_t (*Int16ShiftOp)(int16_t, int); | |
20 typedef int8_t (*Int8UnOp)(int8_t); | |
21 typedef int8_t (*Int8BinOp)(int8_t, int8_t); | |
22 typedef int8_t (*Int8ShiftOp)(int8_t, int); | |
23 | |
24 // Generic expected value functions. | |
25 template <typename T> | |
26 T Negate(T a) { | |
27 return -a; | |
28 } | |
29 | |
30 template <typename T> | |
31 T Add(T a, T b) { | |
32 return a + b; | |
33 } | |
34 | |
35 template <typename T> | |
36 T Sub(T a, T b) { | |
37 return a - b; | |
38 } | |
39 | |
40 template <typename T> | |
41 T Mul(T a, T b) { | |
42 return a * b; | |
43 } | |
44 | |
45 template <typename T> | |
46 T Div(T a, T b) { | |
47 return a / b; | |
48 } | |
49 | |
50 template <typename T> | |
51 T Minimum(T a, T b) { | |
52 return a <= b ? a : b; | |
53 } | |
54 | |
55 template <typename T> | |
56 T Maximum(T a, T b) { | |
57 return a >= b ? a : b; | |
58 } | |
59 | |
60 template <typename T> | |
61 T UnsignedMinimum(T a, T b) { | |
62 using UnsignedT = typename std::make_unsigned<T>::type; | |
63 return static_cast<UnsignedT>(a) <= static_cast<UnsignedT>(b) ? a : b; | |
64 } | |
65 | |
66 template <typename T> | |
67 T UnsignedMaximum(T a, T b) { | |
68 using UnsignedT = typename std::make_unsigned<T>::type; | |
69 return static_cast<UnsignedT>(a) >= static_cast<UnsignedT>(b) ? a : b; | |
70 } | |
71 | |
72 template <typename T> | |
73 T Equal(T a, T b) { | |
74 return a == b ? 1 : 0; | |
75 } | |
76 | |
77 template <typename T> | |
78 T NotEqual(T a, T b) { | |
79 return a != b ? 1 : 0; | |
80 } | |
81 | |
82 template <typename T> | |
83 T Greater(T a, T b) { | |
84 return a > b ? 1 : 0; | |
85 } | |
86 | |
87 template <typename T> | |
88 T GreaterEqual(T a, T b) { | |
89 return a >= b ? 1 : 0; | |
90 } | |
91 | |
92 template <typename T> | |
93 T Less(T a, T b) { | |
94 return a < b ? 1 : 0; | |
95 } | |
96 | |
97 template <typename T> | |
98 T LessEqual(T a, T b) { | |
99 return a <= b ? 1 : 0; | |
100 } | |
101 | |
102 template <typename T> | |
103 T UnsignedGreater(T a, T b) { | |
104 using UnsignedT = typename std::make_unsigned<T>::type; | |
105 return static_cast<UnsignedT>(a) > static_cast<UnsignedT>(b) ? 1 : 0; | |
106 } | |
107 | |
108 template <typename T> | |
109 T UnsignedGreaterEqual(T a, T b) { | |
110 using UnsignedT = typename std::make_unsigned<T>::type; | |
111 return static_cast<UnsignedT>(a) >= static_cast<UnsignedT>(b) ? 1 : 0; | |
112 } | |
113 | |
114 template <typename T> | |
115 T UnsignedLess(T a, T b) { | |
116 using UnsignedT = typename std::make_unsigned<T>::type; | |
117 return static_cast<UnsignedT>(a) < static_cast<UnsignedT>(b) ? 1 : 0; | |
118 } | |
119 | |
120 template <typename T> | |
121 T UnsignedLessEqual(T a, T b) { | |
122 using UnsignedT = typename std::make_unsigned<T>::type; | |
123 return static_cast<UnsignedT>(a) <= static_cast<UnsignedT>(b) ? 1 : 0; | |
124 } | |
125 | |
126 template <typename T> | |
127 T LogicalShiftLeft(T a, int shift) { | |
128 return a << shift; | |
129 } | |
130 | |
131 template <typename T> | |
132 T LogicalShiftRight(T a, int shift) { | |
133 using UnsignedT = typename std::make_unsigned<T>::type; | |
134 return static_cast<UnsignedT>(a) >> shift; | |
135 } | |
136 | |
137 template <typename T> | |
138 int64_t Widen(T value) { | |
139 static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller"); | |
140 return static_cast<int64_t>(value); | |
141 } | |
142 | |
143 template <typename T> | |
144 int64_t UnsignedWiden(T value) { | |
145 static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller"); | |
146 using UnsignedT = typename std::make_unsigned<T>::type; | |
147 return static_cast<int64_t>(static_cast<UnsignedT>(value)); | |
148 } | |
149 | |
150 template <typename T> | |
151 T Clamp(int64_t value) { | |
152 static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller"); | |
153 int64_t min = static_cast<int64_t>(std::numeric_limits<T>::min()); | |
154 int64_t max = static_cast<int64_t>(std::numeric_limits<T>::max()); | |
155 int64_t clamped = std::max(min, std::min(max, value)); | |
156 return static_cast<T>(clamped); | |
157 } | |
158 | |
159 template <typename T> | |
160 T AddSaturate(T a, T b) { | |
161 return Clamp<T>(Widen(a) + Widen(b)); | |
162 } | |
163 | |
164 template <typename T> | |
165 T SubSaturate(T a, T b) { | |
166 return Clamp<T>(Widen(a) - Widen(b)); | |
167 } | |
168 | |
169 template <typename T> | |
170 T UnsignedAddSaturate(T a, T b) { | |
171 using UnsignedT = typename std::make_unsigned<T>::type; | |
172 return Clamp<UnsignedT>(UnsignedWiden(a) + UnsignedWiden(b)); | |
173 } | |
174 | |
175 template <typename T> | |
176 T UnsignedSubSaturate(T a, T b) { | |
177 using UnsignedT = typename std::make_unsigned<T>::type; | |
178 return Clamp<UnsignedT>(UnsignedWiden(a) - UnsignedWiden(b)); | |
179 } | |
180 | |
181 template <typename T> | |
182 T And(T a, T b) { | |
183 return a & b; | |
184 } | |
185 | |
186 template <typename T> | |
187 T Or(T a, T b) { | |
188 return a | b; | |
189 } | |
190 | |
191 template <typename T> | |
192 T Xor(T a, T b) { | |
193 return a ^ b; | |
194 } | |
195 | |
196 template <typename T> | |
197 T Not(T a) { | |
198 return ~a; | |
199 } | |
200 | |
201 #define WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lane_value, lane_index) \ | |
202 WASM_IF(WASM_##LANE_TYPE##_NE(WASM_GET_LOCAL(lane_value), \ | |
203 WASM_SIMD_##TYPE##_EXTRACT_LANE( \ | |
204 lane_index, WASM_GET_LOCAL(value))), \ | |
205 WASM_RETURN1(WASM_ZERO)) | |
206 | |
207 #define WASM_SIMD_CHECK4(TYPE, value, LANE_TYPE, lv0, lv1, lv2, lv3) \ | |
208 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv0, 0) \ | |
209 , WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv1, 1), \ | |
210 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv2, 2), \ | |
211 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv3, 3) | |
212 | |
213 #define WASM_SIMD_CHECK_SPLAT4(TYPE, value, LANE_TYPE, lv) \ | |
214 WASM_SIMD_CHECK4(TYPE, value, LANE_TYPE, lv, lv, lv, lv) | |
215 | |
216 #define WASM_SIMD_CHECK8(TYPE, value, LANE_TYPE, lv0, lv1, lv2, lv3, lv4, lv5, \ | |
217 lv6, lv7) \ | |
218 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv0, 0) \ | |
219 , WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv1, 1), \ | |
220 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv2, 2), \ | |
221 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv3, 3), \ | |
222 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv4, 4), \ | |
223 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv5, 5), \ | |
224 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv6, 6), \ | |
225 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv7, 7) | |
226 | |
227 #define WASM_SIMD_CHECK_SPLAT8(TYPE, value, LANE_TYPE, lv) \ | |
228 WASM_SIMD_CHECK8(TYPE, value, LANE_TYPE, lv, lv, lv, lv, lv, lv, lv, lv) | |
229 | |
230 #define WASM_SIMD_CHECK16(TYPE, value, LANE_TYPE, lv0, lv1, lv2, lv3, lv4, \ | |
231 lv5, lv6, lv7, lv8, lv9, lv10, lv11, lv12, lv13, \ | |
232 lv14, lv15) \ | |
233 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv0, 0) \ | |
234 , WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv1, 1), \ | |
235 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv2, 2), \ | |
236 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv3, 3), \ | |
237 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv4, 4), \ | |
238 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv5, 5), \ | |
239 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv6, 6), \ | |
240 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv7, 7), \ | |
241 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv8, 8), \ | |
242 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv9, 9), \ | |
243 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv10, 10), \ | |
244 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv11, 11), \ | |
245 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv12, 12), \ | |
246 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv13, 13), \ | |
247 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv14, 14), \ | |
248 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv15, 15) | |
249 | |
250 #define WASM_SIMD_CHECK_SPLAT16(TYPE, value, LANE_TYPE, lv) \ | |
251 WASM_SIMD_CHECK16(TYPE, value, LANE_TYPE, lv, lv, lv, lv, lv, lv, lv, lv, \ | |
252 lv, lv, lv, lv, lv, lv, lv, lv) | |
253 | |
254 #define WASM_SIMD_CHECK_F32_LANE(TYPE, value, lane_value, lane_index) \ | |
255 WASM_IF( \ | |
256 WASM_I32_NE(WASM_I32_REINTERPRET_F32(WASM_GET_LOCAL(lane_value)), \ | |
257 WASM_I32_REINTERPRET_F32(WASM_SIMD_##TYPE##_EXTRACT_LANE( \ | |
258 lane_index, WASM_GET_LOCAL(value)))), \ | |
259 WASM_RETURN1(WASM_ZERO)) | |
260 | |
261 #define WASM_SIMD_CHECK4_F32(TYPE, value, lv0, lv1, lv2, lv3) \ | |
262 WASM_SIMD_CHECK_F32_LANE(TYPE, value, lv0, 0) \ | |
263 , WASM_SIMD_CHECK_F32_LANE(TYPE, value, lv1, 1), \ | |
264 WASM_SIMD_CHECK_F32_LANE(TYPE, value, lv2, 2), \ | |
265 WASM_SIMD_CHECK_F32_LANE(TYPE, value, lv3, 3) | |
266 | |
267 #define WASM_SIMD_CHECK_SPLAT4_F32(TYPE, value, lv) \ | |
268 WASM_SIMD_CHECK4_F32(TYPE, value, lv, lv, lv, lv) | |
269 | |
270 #define TO_BYTE(val) static_cast<byte>(val) | |
271 #define WASM_SIMD_OP(op) kSimdPrefix, TO_BYTE(op) | |
272 #define WASM_SIMD_SPLAT(Type, x) x, WASM_SIMD_OP(kExpr##Type##Splat) | |
273 #define WASM_SIMD_UNOP(op, x) x, WASM_SIMD_OP(op) | |
274 #define WASM_SIMD_BINOP(op, x, y) x, y, WASM_SIMD_OP(op) | |
275 #define WASM_SIMD_SHIFT_OP(op, shift, x) x, WASM_SIMD_OP(op), TO_BYTE(shift) | |
276 #define WASM_SIMD_SELECT(format, x, y, z) \ | |
277 x, y, z, WASM_SIMD_OP(kExprS##format##Select) | |
278 // Since boolean vectors can't be checked directly, materialize them into | |
279 // integer vectors using a Select operation. | |
280 #define WASM_SIMD_MATERIALIZE_BOOLS(format, x) \ | |
281 x, WASM_SIMD_I##format##_SPLAT(WASM_ONE), \ | |
282 WASM_SIMD_I##format##_SPLAT(WASM_ZERO), \ | |
283 WASM_SIMD_OP(kExprS##format##Select) | |
284 | |
285 #define WASM_SIMD_I16x8_SPLAT(x) x, WASM_SIMD_OP(kExprI16x8Splat) | |
286 #define WASM_SIMD_I16x8_EXTRACT_LANE(lane, x) \ | |
287 x, WASM_SIMD_OP(kExprI16x8ExtractLane), TO_BYTE(lane) | |
288 #define WASM_SIMD_I16x8_REPLACE_LANE(lane, x, y) \ | |
289 x, y, WASM_SIMD_OP(kExprI16x8ReplaceLane), TO_BYTE(lane) | |
290 #define WASM_SIMD_I8x16_SPLAT(x) x, WASM_SIMD_OP(kExprI8x16Splat) | |
291 #define WASM_SIMD_I8x16_EXTRACT_LANE(lane, x) \ | |
292 x, WASM_SIMD_OP(kExprI8x16ExtractLane), TO_BYTE(lane) | |
293 #define WASM_SIMD_I8x16_REPLACE_LANE(lane, x, y) \ | |
294 x, y, WASM_SIMD_OP(kExprI8x16ReplaceLane), TO_BYTE(lane) | |
295 | |
296 #define WASM_SIMD_F32x4_FROM_I32x4(x) x, WASM_SIMD_OP(kExprF32x4SConvertI32x4) | |
297 #define WASM_SIMD_F32x4_FROM_U32x4(x) x, WASM_SIMD_OP(kExprF32x4UConvertI32x4) | |
298 #define WASM_SIMD_I32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4SConvertF32x4) | |
299 #define WASM_SIMD_U32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4UConvertF32x4) | |
300 | |
301 class TestWasmSimdCommon { | |
gdeepti
2017/02/24 13:31:23
Maybe use a namespace here instead of a class with
aseemgarg
2017/02/24 14:19:42
Done.
| |
302 public: | |
303 static void RunF32x4SplatTest(); | |
304 static void RunF32x4ReplaceLaneTest(); | |
305 static void RunF32x4BinOpTest(WasmOpcode simd_op, FloatBinOp expected_op, | |
306 bool skip_zero_inputs = false); | |
307 static void RunI32x4SplatTest(); | |
308 static void RunI32x4ReplaceLaneTest(); | |
309 static void RunI32x4BinOpTest(WasmOpcode simd_op, Int32BinOp expected_op); | |
310 }; | |
OLD | NEW |