Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(236)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/cctest/wasm/test-run-wasm-simd-lowering.cc

Issue 2498283002: [wasm] implement simd lowering for replaceLane, load, store and test for phi (Closed)
Patch Set: [wasm] implement simd lowering for replaceLane, load, store and test for phi Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/wasm/wasm-opcodes.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2016 the V8 project authors. All rights reserved. 1 // Copyright 2016 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "src/wasm/wasm-macro-gen.h" 5 #include "src/wasm/wasm-macro-gen.h"
6 #include "src/wasm/wasm-module.h" 6 #include "src/wasm/wasm-module.h"
7 7
8 #include "test/cctest/cctest.h" 8 #include "test/cctest/cctest.h"
9 #include "test/cctest/compiler/value-helper.h" 9 #include "test/cctest/compiler/value-helper.h"
10 #include "test/cctest/wasm/wasm-run-utils.h" 10 #include "test/cctest/wasm/wasm-run-utils.h"
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
87 WASM_IF_ELSE( 87 WASM_IF_ELSE(
88 WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE( 88 WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE(
89 0, WASM_SIMD_I32x4_ADD( 89 0, WASM_SIMD_I32x4_ADD(
90 WASM_SIMD_F32x4_SPLAT(WASM_F32(21.25)), 90 WASM_SIMD_F32x4_SPLAT(WASM_F32(21.25)),
91 WASM_SIMD_F32x4_SPLAT(WASM_F32(31.5)))), 91 WASM_SIMD_F32x4_SPLAT(WASM_F32(31.5)))),
92 WASM_I32_ADD(WASM_I32_REINTERPRET_F32(WASM_F32(21.25)), 92 WASM_I32_ADD(WASM_I32_REINTERPRET_F32(WASM_F32(21.25)),
93 WASM_I32_REINTERPRET_F32(WASM_F32(31.5)))), 93 WASM_I32_REINTERPRET_F32(WASM_F32(31.5)))),
94 WASM_RETURN1(WASM_I32V(1)), WASM_RETURN1(WASM_I32V(0)))); 94 WASM_RETURN1(WASM_I32V(1)), WASM_RETURN1(WASM_I32V(0))));
95 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } 95 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); }
96 } 96 }
97
98 WASM_EXEC_TEST(Simd_I32x4_Local) {
titzer 2016/11/22 12:01:52 You should just check whether the execution_mode i
aseemgarg 2016/11/23 23:07:56 Instead of checking and returning, I created a new
99 FLAG_wasm_simd_prototype = true;
100 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
101 r.AllocateLocal(kAstS128);
102 BUILD(r, WASM_BLOCK(WASM_SET_LOCAL(1, WASM_SIMD_I32x4_SPLAT(WASM_I32V(31))),
103 WASM_RETURN1(
104 WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(1)))));
105 FOR_INT32_INPUTS(i) { CHECK_EQ(31, r.Call()); }
106 }
107
108 WASM_EXEC_TEST(Simd_I32x4_Replace_Lane) {
109 FLAG_wasm_simd_prototype = true;
110 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
111 r.AllocateLocal(kAstS128);
112 BUILD(r,
113 WASM_BLOCK(
114 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_SPLAT(WASM_I32V(31))),
115 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(1),
116 WASM_I32V(53))),
117 WASM_RETURN1(WASM_SIMD_I32x4_EXTRACT_LANE(2, WASM_GET_LOCAL(1)))));
118 FOR_INT32_INPUTS(i) { CHECK_EQ(53, r.Call()); }
119 }
120
121 WASM_EXEC_TEST(Simd_F32x4_Replace_Lane) {
122 FLAG_wasm_simd_prototype = true;
123 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
124 r.AllocateLocal(kAstF32);
125 r.AllocateLocal(kAstS128);
126 BUILD(r, WASM_BLOCK(
127 WASM_SET_LOCAL(2, WASM_SIMD_F32x4_SPLAT(WASM_F32(23.5))),
128 WASM_SET_LOCAL(2, WASM_SIMD_F32x4_REPLACE_LANE(
129 3, WASM_GET_LOCAL(2), WASM_F32(65.25))),
130 WASM_SET_LOCAL(
131 1, WASM_SIMD_F32x4_EXTRACT_LANE(3, WASM_GET_LOCAL(2))),
132 WASM_IF(WASM_F32_EQ(WASM_GET_LOCAL(1), WASM_F32(65.25)),
133 WASM_RETURN1(WASM_I32V(1))),
134 WASM_RETURN1(WASM_I32V(0))));
135 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); }
136 }
137
138 WASM_EXEC_TEST(Simd_I32x4_Splat_From_Extract) {
139 FLAG_wasm_simd_prototype = true;
140 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
141 r.AllocateLocal(kAstI32);
142 r.AllocateLocal(kAstS128);
143 BUILD(r,
144 WASM_BLOCK(
145 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_EXTRACT_LANE(
146 0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(76)))),
147 WASM_SET_LOCAL(2, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(1))),
148 WASM_RETURN1(WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_LOCAL(2)))));
149 FOR_INT32_INPUTS(i) { CHECK_EQ(76, r.Call()); }
150 }
151
152 WASM_EXEC_TEST(Simd_I32x4_Get_Global) {
153 FLAG_wasm_simd_prototype = true;
154 TestingModule module(kExecuteCompiled);
155 int32_t* global = module.AddGlobal<int32_t>(kAstS128);
156 *(global) = 0;
157 *(global + 1) = 1;
158 *(global + 2) = 2;
159 *(global + 3) = 3;
160 WasmRunner<int32_t> r(&module, MachineType::Int32());
161 r.AllocateLocal(kAstI32);
162 BUILD(r, WASM_BLOCK(
163 WASM_SET_LOCAL(1, WASM_I32V(1)),
164 WASM_IF(WASM_I32_NE(WASM_I32V(0), WASM_SIMD_I32x4_EXTRACT_LANE(
165 0, WASM_GET_GLOBAL(0))),
166 WASM_SET_LOCAL(1, WASM_I32V(0))),
167 WASM_IF(WASM_I32_NE(WASM_I32V(1), WASM_SIMD_I32x4_EXTRACT_LANE(
168 1, WASM_GET_GLOBAL(0))),
169 WASM_SET_LOCAL(1, WASM_I32V(0))),
170 WASM_IF(WASM_I32_NE(WASM_I32V(2), WASM_SIMD_I32x4_EXTRACT_LANE(
171 2, WASM_GET_GLOBAL(0))),
172 WASM_SET_LOCAL(1, WASM_I32V(0))),
173 WASM_IF(WASM_I32_NE(WASM_I32V(3), WASM_SIMD_I32x4_EXTRACT_LANE(
174 3, WASM_GET_GLOBAL(0))),
175 WASM_SET_LOCAL(1, WASM_I32V(0))),
176 WASM_RETURN1(WASM_GET_LOCAL(1))));
177 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
178 }
179
180 WASM_EXEC_TEST(Simd_I32x4_Set_Global) {
181 FLAG_wasm_simd_prototype = true;
182 TestingModule module(kExecuteCompiled);
183 int32_t* global = module.AddGlobal<int32_t>(kAstS128);
184 WasmRunner<int32_t> r(&module, MachineType::Int32());
185 BUILD(r, WASM_BLOCK(
186 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(23))),
187 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(
188 1, WASM_GET_GLOBAL(0), WASM_I32V(34))),
189 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(
190 2, WASM_GET_GLOBAL(0), WASM_I32V(45))),
191 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(
192 3, WASM_GET_GLOBAL(0), WASM_I32V(56))),
193 WASM_RETURN1(WASM_I32V(1))));
194 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
195 CHECK_EQ(*global, 23);
196 CHECK_EQ(*(global + 1), 34);
197 CHECK_EQ(*(global + 2), 45);
198 CHECK_EQ(*(global + 3), 56);
199 }
200
201 WASM_EXEC_TEST(Simd_F32x4_Get_Global) {
202 FLAG_wasm_simd_prototype = true;
203 TestingModule module(kExecuteCompiled);
204 float* global = module.AddGlobal<float>(kAstS128);
205 *(global) = 0.0;
206 *(global + 1) = 1.5;
207 *(global + 2) = 2.25;
208 *(global + 3) = 3.5;
209 WasmRunner<int32_t> r(&module, MachineType::Int32());
210 r.AllocateLocal(kAstI32);
211 BUILD(r, WASM_BLOCK(
212 WASM_SET_LOCAL(1, WASM_I32V(1)),
213 WASM_IF(WASM_F32_NE(WASM_F32(0.0), WASM_SIMD_F32x4_EXTRACT_LANE(
214 0, WASM_GET_GLOBAL(0))),
215 WASM_SET_LOCAL(1, WASM_I32V(0))),
216 WASM_IF(WASM_F32_NE(WASM_F32(1.5), WASM_SIMD_F32x4_EXTRACT_LANE(
217 1, WASM_GET_GLOBAL(0))),
218 WASM_SET_LOCAL(1, WASM_I32V(0))),
219 WASM_IF(WASM_F32_NE(WASM_F32(2.25), WASM_SIMD_F32x4_EXTRACT_LANE(
220 2, WASM_GET_GLOBAL(0))),
221 WASM_SET_LOCAL(1, WASM_I32V(0))),
222 WASM_IF(WASM_F32_NE(WASM_F32(3.5), WASM_SIMD_F32x4_EXTRACT_LANE(
223 3, WASM_GET_GLOBAL(0))),
224 WASM_SET_LOCAL(1, WASM_I32V(0))),
225 WASM_RETURN1(WASM_GET_LOCAL(1))));
226 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
227 }
228
229 WASM_EXEC_TEST(Simd_F32x4_Set_Global) {
230 FLAG_wasm_simd_prototype = true;
231 TestingModule module(kExecuteCompiled);
232 float* global = module.AddGlobal<float>(kAstS128);
233 WasmRunner<int32_t> r(&module, MachineType::Int32());
234 BUILD(r, WASM_BLOCK(
235 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_SPLAT(WASM_F32(13.5))),
236 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(
237 1, WASM_GET_GLOBAL(0), WASM_F32(45.5))),
238 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(
239 2, WASM_GET_GLOBAL(0), WASM_F32(32.25))),
240 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(
241 3, WASM_GET_GLOBAL(0), WASM_F32(65.0))),
242 WASM_RETURN1(WASM_I32V(1))));
243 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); }
244 CHECK_EQ(*global, 13.5);
245 CHECK_EQ(*(global + 1), 45.5);
246 CHECK_EQ(*(global + 2), 32.25);
247 CHECK_EQ(*(global + 3), 65.0);
248 }
249
250 WASM_EXEC_TEST(Simd_I32x4_For) {
251 FLAG_wasm_simd_prototype = true;
252 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
253 r.AllocateLocal(kAstI32);
254 r.AllocateLocal(kAstS128);
255 BUILD(
256 r,
257 WASM_BLOCK(
258 WASM_SET_LOCAL(2, WASM_SIMD_I32x4_SPLAT(WASM_I32V(31))),
259 WASM_SET_LOCAL(2, WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_LOCAL(2),
260 WASM_I32V(53))),
261 WASM_SET_LOCAL(2, WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(2),
262 WASM_I32V(23))),
263 WASM_SET_LOCAL(1, WASM_I32V(0)),
264 WASM_LOOP(WASM_SET_LOCAL(2, WASM_SIMD_I32x4_ADD(
265 WASM_GET_LOCAL(2),
266 WASM_SIMD_I32x4_SPLAT(WASM_I32V(1)))),
267 WASM_IF(WASM_I32_NE(WASM_INC_LOCAL(1), WASM_I32V(5)),
268 WASM_BR(1))),
269 WASM_SET_LOCAL(1, WASM_I32V(1)),
270 WASM_IF(
271 WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(2)),
272 WASM_I32V(36)),
273 WASM_SET_LOCAL(1, WASM_I32V(0))),
274 WASM_IF(
275 WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_LOCAL(2)),
276 WASM_I32V(58)),
277 WASM_SET_LOCAL(1, WASM_I32V(0))),
278 WASM_IF(
279 WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(2, WASM_GET_LOCAL(2)),
280 WASM_I32V(28)),
281 WASM_SET_LOCAL(1, WASM_I32V(0))),
282 WASM_IF(
283 WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(3, WASM_GET_LOCAL(2)),
284 WASM_I32V(36)),
285 WASM_SET_LOCAL(1, WASM_I32V(0))),
286 WASM_RETURN1(WASM_GET_LOCAL(1))));
287 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); }
288 }
289
290 WASM_EXEC_TEST(Simd_F32x4_For) {
291 FLAG_wasm_simd_prototype = true;
292 WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
293 r.AllocateLocal(kAstI32);
294 r.AllocateLocal(kAstS128);
295 BUILD(r, WASM_BLOCK(
296 WASM_SET_LOCAL(2, WASM_SIMD_F32x4_SPLAT(WASM_F32(21.25))),
297 WASM_SET_LOCAL(2, WASM_SIMD_F32x4_REPLACE_LANE(
298 3, WASM_GET_LOCAL(2), WASM_F32(19.5))),
299 WASM_SET_LOCAL(1, WASM_I32V(0)),
300 WASM_LOOP(
301 WASM_SET_LOCAL(2, WASM_SIMD_F32x4_ADD(
302 WASM_GET_LOCAL(2),
303 WASM_SIMD_F32x4_SPLAT(WASM_F32(2.0)))),
304 WASM_IF(WASM_I32_NE(WASM_INC_LOCAL(1), WASM_I32V(3)),
305 WASM_BR(1))),
306 WASM_SET_LOCAL(1, WASM_I32V(1)),
307 WASM_IF(WASM_F32_NE(
308 WASM_SIMD_F32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(2)),
309 WASM_F32(27.25)),
310 WASM_SET_LOCAL(1, WASM_I32V(0))),
311 WASM_IF(WASM_F32_NE(
312 WASM_SIMD_F32x4_EXTRACT_LANE(3, WASM_GET_LOCAL(2)),
313 WASM_F32(25.5)),
314 WASM_SET_LOCAL(1, WASM_I32V(0))),
315 WASM_RETURN1(WASM_GET_LOCAL(1))));
316 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); }
317 }
OLDNEW
« no previous file with comments | « src/wasm/wasm-opcodes.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698