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