OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 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 <stdint.h> | 5 #include <stdint.h> |
6 #include <stdlib.h> | 6 #include <stdlib.h> |
7 #include <string.h> | 7 #include <string.h> |
8 | 8 |
9 #include "src/base/bits.h" | 9 #include "src/base/bits.h" |
10 #include "src/wasm/wasm-macro-gen.h" | 10 #include "src/wasm/wasm-macro-gen.h" |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 | 85 |
86 #define DECLARE_CONST(name, cond) static const bool kSupported_##name = cond; | 86 #define DECLARE_CONST(name, cond) static const bool kSupported_##name = cond; |
87 FOREACH_I64_OPERATOR(DECLARE_CONST) | 87 FOREACH_I64_OPERATOR(DECLARE_CONST) |
88 #undef DECLARE_CONST | 88 #undef DECLARE_CONST |
89 | 89 |
90 #define REQUIRE(name) \ | 90 #define REQUIRE(name) \ |
91 if (!WASM_64 && !kSupported_##name) return | 91 if (!WASM_64 && !kSupported_##name) return |
92 | 92 |
93 WASM_EXEC_TEST(I64Const) { | 93 WASM_EXEC_TEST(I64Const) { |
94 REQUIRE(I64Const); | 94 REQUIRE(I64Const); |
95 WasmRunner<int64_t> r; | 95 WasmRunner<int64_t> r(execution_mode); |
96 const int64_t kExpectedValue = 0x1122334455667788LL; | 96 const int64_t kExpectedValue = 0x1122334455667788LL; |
97 // return(kExpectedValue) | 97 // return(kExpectedValue) |
98 BUILD(r, WASM_I64V_9(kExpectedValue)); | 98 BUILD(r, WASM_I64V_9(kExpectedValue)); |
99 CHECK_EQ(kExpectedValue, r.Call()); | 99 CHECK_EQ(kExpectedValue, r.Call()); |
100 } | 100 } |
101 | 101 |
102 WASM_EXEC_TEST(I64Const_many) { | 102 WASM_EXEC_TEST(I64Const_many) { |
103 REQUIRE(I64Const); | 103 REQUIRE(I64Const); |
104 int cntr = 0; | 104 int cntr = 0; |
105 FOR_INT32_INPUTS(i) { | 105 FOR_INT32_INPUTS(i) { |
106 WasmRunner<int64_t> r; | 106 WasmRunner<int64_t> r(execution_mode); |
107 const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr; | 107 const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr; |
108 // return(kExpectedValue) | 108 // return(kExpectedValue) |
109 BUILD(r, WASM_I64V(kExpectedValue)); | 109 BUILD(r, WASM_I64V(kExpectedValue)); |
110 CHECK_EQ(kExpectedValue, r.Call()); | 110 CHECK_EQ(kExpectedValue, r.Call()); |
111 cntr++; | 111 cntr++; |
112 } | 112 } |
113 } | 113 } |
114 | 114 |
115 WASM_EXEC_TEST(Return_I64) { | 115 WASM_EXEC_TEST(Return_I64) { |
116 REQUIRE(I64Return); | 116 REQUIRE(I64Return); |
117 WasmRunner<int64_t> r(MachineType::Int64()); | 117 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
118 | 118 |
119 BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0))); | 119 BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0))); |
120 | 120 |
121 FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } | 121 FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } |
122 } | 122 } |
123 | 123 |
124 WASM_EXEC_TEST(I64Add) { | 124 WASM_EXEC_TEST(I64Add) { |
125 REQUIRE(I64Add); | 125 REQUIRE(I64Add); |
126 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 126 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 127 MachineType::Int64()); |
127 BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 128 BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
128 FOR_INT64_INPUTS(i) { | 129 FOR_INT64_INPUTS(i) { |
129 FOR_INT64_INPUTS(j) { CHECK_EQ(*i + *j, r.Call(*i, *j)); } | 130 FOR_INT64_INPUTS(j) { CHECK_EQ(*i + *j, r.Call(*i, *j)); } |
130 } | 131 } |
131 } | 132 } |
132 | 133 |
133 WASM_EXEC_TEST(I64Sub) { | 134 WASM_EXEC_TEST(I64Sub) { |
134 REQUIRE(I64Sub); | 135 REQUIRE(I64Sub); |
135 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 136 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 137 MachineType::Int64()); |
136 BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 138 BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
137 FOR_INT64_INPUTS(i) { | 139 FOR_INT64_INPUTS(i) { |
138 FOR_INT64_INPUTS(j) { CHECK_EQ(*i - *j, r.Call(*i, *j)); } | 140 FOR_INT64_INPUTS(j) { CHECK_EQ(*i - *j, r.Call(*i, *j)); } |
139 } | 141 } |
140 } | 142 } |
141 | 143 |
142 WASM_EXEC_TEST(I64DivS) { | 144 WASM_EXEC_TEST(I64DivS) { |
143 REQUIRE(I64DivS); | 145 REQUIRE(I64DivS); |
144 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 146 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 147 MachineType::Int64()); |
145 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 148 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
146 FOR_INT64_INPUTS(i) { | 149 FOR_INT64_INPUTS(i) { |
147 FOR_INT64_INPUTS(j) { | 150 FOR_INT64_INPUTS(j) { |
148 if (*j == 0) { | 151 if (*j == 0) { |
149 CHECK_TRAP64(r.Call(*i, *j)); | 152 CHECK_TRAP64(r.Call(*i, *j)); |
150 } else if (*j == -1 && *i == std::numeric_limits<int64_t>::min()) { | 153 } else if (*j == -1 && *i == std::numeric_limits<int64_t>::min()) { |
151 CHECK_TRAP64(r.Call(*i, *j)); | 154 CHECK_TRAP64(r.Call(*i, *j)); |
152 } else { | 155 } else { |
153 CHECK_EQ(*i / *j, r.Call(*i, *j)); | 156 CHECK_EQ(*i / *j, r.Call(*i, *j)); |
154 } | 157 } |
155 } | 158 } |
156 } | 159 } |
157 } | 160 } |
158 | 161 |
159 WASM_EXEC_TEST(I64DivS_Trap) { | 162 WASM_EXEC_TEST(I64DivS_Trap) { |
160 REQUIRE(I64DivS); | 163 REQUIRE(I64DivS); |
161 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 164 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 165 MachineType::Int64()); |
162 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 166 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
163 CHECK_EQ(0, r.Call(asi64(0), asi64(100))); | 167 CHECK_EQ(0, r.Call(asi64(0), asi64(100))); |
164 CHECK_TRAP64(r.Call(asi64(100), asi64(0))); | 168 CHECK_TRAP64(r.Call(asi64(100), asi64(0))); |
165 CHECK_TRAP64(r.Call(asi64(-1001), asi64(0))); | 169 CHECK_TRAP64(r.Call(asi64(-1001), asi64(0))); |
166 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(-1))); | 170 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(-1))); |
167 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0))); | 171 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0))); |
168 } | 172 } |
169 | 173 |
170 WASM_EXEC_TEST(I64DivS_Byzero_Const) { | 174 WASM_EXEC_TEST(I64DivS_Byzero_Const) { |
171 REQUIRE(I64DivS); | 175 REQUIRE(I64DivS); |
172 for (int8_t denom = -2; denom < 8; denom++) { | 176 for (int8_t denom = -2; denom < 8; denom++) { |
173 WasmRunner<int64_t> r(MachineType::Int64()); | 177 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
174 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom))); | 178 BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom))); |
175 for (int64_t val = -7; val < 8; val++) { | 179 for (int64_t val = -7; val < 8; val++) { |
176 if (denom == 0) { | 180 if (denom == 0) { |
177 CHECK_TRAP64(r.Call(val)); | 181 CHECK_TRAP64(r.Call(val)); |
178 } else { | 182 } else { |
179 CHECK_EQ(val / denom, r.Call(val)); | 183 CHECK_EQ(val / denom, r.Call(val)); |
180 } | 184 } |
181 } | 185 } |
182 } | 186 } |
183 } | 187 } |
184 | 188 |
185 WASM_EXEC_TEST(I64DivU) { | 189 WASM_EXEC_TEST(I64DivU) { |
186 REQUIRE(I64DivU); | 190 REQUIRE(I64DivU); |
187 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 191 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 192 MachineType::Uint64()); |
188 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 193 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
189 FOR_UINT64_INPUTS(i) { | 194 FOR_UINT64_INPUTS(i) { |
190 FOR_UINT64_INPUTS(j) { | 195 FOR_UINT64_INPUTS(j) { |
191 if (*j == 0) { | 196 if (*j == 0) { |
192 CHECK_TRAP64(r.Call(*i, *j)); | 197 CHECK_TRAP64(r.Call(*i, *j)); |
193 } else { | 198 } else { |
194 CHECK_EQ(*i / *j, r.Call(*i, *j)); | 199 CHECK_EQ(*i / *j, r.Call(*i, *j)); |
195 } | 200 } |
196 } | 201 } |
197 } | 202 } |
198 } | 203 } |
199 | 204 |
200 WASM_EXEC_TEST(I64DivU_Trap) { | 205 WASM_EXEC_TEST(I64DivU_Trap) { |
201 REQUIRE(I64DivU); | 206 REQUIRE(I64DivU); |
202 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 207 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 208 MachineType::Uint64()); |
203 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 209 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
204 CHECK_EQ(0, r.Call(asu64(0), asu64(100))); | 210 CHECK_EQ(0, r.Call(asu64(0), asu64(100))); |
205 CHECK_TRAP64(r.Call(asu64(100), asu64(0))); | 211 CHECK_TRAP64(r.Call(asu64(100), asu64(0))); |
206 CHECK_TRAP64(r.Call(asu64(1001), asu64(0))); | 212 CHECK_TRAP64(r.Call(asu64(1001), asu64(0))); |
207 CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0))); | 213 CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0))); |
208 } | 214 } |
209 | 215 |
210 WASM_EXEC_TEST(I64DivU_Byzero_Const) { | 216 WASM_EXEC_TEST(I64DivU_Byzero_Const) { |
211 REQUIRE(I64DivU); | 217 REQUIRE(I64DivU); |
212 for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) { | 218 for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) { |
213 WasmRunner<uint64_t> r(MachineType::Uint64()); | 219 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64()); |
214 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom))); | 220 BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom))); |
215 | 221 |
216 for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) { | 222 for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) { |
217 if (denom == 0) { | 223 if (denom == 0) { |
218 CHECK_TRAP64(r.Call(val)); | 224 CHECK_TRAP64(r.Call(val)); |
219 } else { | 225 } else { |
220 CHECK_EQ(val / denom, r.Call(val)); | 226 CHECK_EQ(val / denom, r.Call(val)); |
221 } | 227 } |
222 } | 228 } |
223 } | 229 } |
224 } | 230 } |
225 | 231 |
226 WASM_EXEC_TEST(I64RemS) { | 232 WASM_EXEC_TEST(I64RemS) { |
227 REQUIRE(I64RemS); | 233 REQUIRE(I64RemS); |
228 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 234 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 235 MachineType::Int64()); |
229 BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 236 BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
230 FOR_INT64_INPUTS(i) { | 237 FOR_INT64_INPUTS(i) { |
231 FOR_INT64_INPUTS(j) { | 238 FOR_INT64_INPUTS(j) { |
232 if (*j == 0) { | 239 if (*j == 0) { |
233 CHECK_TRAP64(r.Call(*i, *j)); | 240 CHECK_TRAP64(r.Call(*i, *j)); |
234 } else { | 241 } else { |
235 CHECK_EQ(*i % *j, r.Call(*i, *j)); | 242 CHECK_EQ(*i % *j, r.Call(*i, *j)); |
236 } | 243 } |
237 } | 244 } |
238 } | 245 } |
239 } | 246 } |
240 | 247 |
241 WASM_EXEC_TEST(I64RemS_Trap) { | 248 WASM_EXEC_TEST(I64RemS_Trap) { |
242 REQUIRE(I64RemS); | 249 REQUIRE(I64RemS); |
243 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 250 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 251 MachineType::Int64()); |
244 BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 252 BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
245 CHECK_EQ(33, r.Call(asi64(133), asi64(100))); | 253 CHECK_EQ(33, r.Call(asi64(133), asi64(100))); |
246 CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), asi64(-1))); | 254 CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), asi64(-1))); |
247 CHECK_TRAP64(r.Call(asi64(100), asi64(0))); | 255 CHECK_TRAP64(r.Call(asi64(100), asi64(0))); |
248 CHECK_TRAP64(r.Call(asi64(-1001), asi64(0))); | 256 CHECK_TRAP64(r.Call(asi64(-1001), asi64(0))); |
249 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0))); | 257 CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0))); |
250 } | 258 } |
251 | 259 |
252 WASM_EXEC_TEST(I64RemU) { | 260 WASM_EXEC_TEST(I64RemU) { |
253 REQUIRE(I64RemU); | 261 REQUIRE(I64RemU); |
254 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 262 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 263 MachineType::Uint64()); |
255 BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 264 BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
256 FOR_UINT64_INPUTS(i) { | 265 FOR_UINT64_INPUTS(i) { |
257 FOR_UINT64_INPUTS(j) { | 266 FOR_UINT64_INPUTS(j) { |
258 if (*j == 0) { | 267 if (*j == 0) { |
259 CHECK_TRAP64(r.Call(*i, *j)); | 268 CHECK_TRAP64(r.Call(*i, *j)); |
260 } else { | 269 } else { |
261 CHECK_EQ(*i % *j, r.Call(*i, *j)); | 270 CHECK_EQ(*i % *j, r.Call(*i, *j)); |
262 } | 271 } |
263 } | 272 } |
264 } | 273 } |
265 } | 274 } |
266 | 275 |
267 WASM_EXEC_TEST(I64RemU_Trap) { | 276 WASM_EXEC_TEST(I64RemU_Trap) { |
268 REQUIRE(I64RemU); | 277 REQUIRE(I64RemU); |
269 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 278 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 279 MachineType::Uint64()); |
270 BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 280 BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
271 CHECK_EQ(17, r.Call(asu64(217), asu64(100))); | 281 CHECK_EQ(17, r.Call(asu64(217), asu64(100))); |
272 CHECK_TRAP64(r.Call(asu64(100), asu64(0))); | 282 CHECK_TRAP64(r.Call(asu64(100), asu64(0))); |
273 CHECK_TRAP64(r.Call(asu64(1001), asu64(0))); | 283 CHECK_TRAP64(r.Call(asu64(1001), asu64(0))); |
274 CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0))); | 284 CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0))); |
275 } | 285 } |
276 | 286 |
277 WASM_EXEC_TEST(I64And) { | 287 WASM_EXEC_TEST(I64And) { |
278 REQUIRE(I64And); | 288 REQUIRE(I64And); |
279 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 289 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 290 MachineType::Int64()); |
280 BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 291 BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
281 FOR_INT64_INPUTS(i) { | 292 FOR_INT64_INPUTS(i) { |
282 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) & (*j), r.Call(*i, *j)); } | 293 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) & (*j), r.Call(*i, *j)); } |
283 } | 294 } |
284 } | 295 } |
285 | 296 |
286 WASM_EXEC_TEST(I64Ior) { | 297 WASM_EXEC_TEST(I64Ior) { |
287 REQUIRE(I64Ior); | 298 REQUIRE(I64Ior); |
288 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 299 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 300 MachineType::Int64()); |
289 BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 301 BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
290 FOR_INT64_INPUTS(i) { | 302 FOR_INT64_INPUTS(i) { |
291 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) | (*j), r.Call(*i, *j)); } | 303 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) | (*j), r.Call(*i, *j)); } |
292 } | 304 } |
293 } | 305 } |
294 | 306 |
295 WASM_EXEC_TEST(I64Xor) { | 307 WASM_EXEC_TEST(I64Xor) { |
296 REQUIRE(I64Xor); | 308 REQUIRE(I64Xor); |
297 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 309 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 310 MachineType::Int64()); |
298 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 311 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
299 FOR_INT64_INPUTS(i) { | 312 FOR_INT64_INPUTS(i) { |
300 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); } | 313 FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); } |
301 } | 314 } |
302 } | 315 } |
303 | 316 |
304 WASM_EXEC_TEST(I64Shl) { | 317 WASM_EXEC_TEST(I64Shl) { |
305 REQUIRE(I64Shl); | 318 REQUIRE(I64Shl); |
306 { | 319 { |
307 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 320 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 321 MachineType::Uint64()); |
308 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 322 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
309 | 323 |
310 FOR_UINT64_INPUTS(i) { | 324 FOR_UINT64_INPUTS(i) { |
311 FOR_UINT64_INPUTS(j) { | 325 FOR_UINT64_INPUTS(j) { |
312 uint64_t expected = (*i) << (*j & 0x3f); | 326 uint64_t expected = (*i) << (*j & 0x3f); |
313 CHECK_EQ(expected, r.Call(*i, *j)); | 327 CHECK_EQ(expected, r.Call(*i, *j)); |
314 } | 328 } |
315 } | 329 } |
316 } | 330 } |
317 { | 331 { |
318 WasmRunner<int64_t> r(MachineType::Int64()); | 332 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
319 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0))); | 333 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0))); |
320 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); } | 334 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); } |
321 } | 335 } |
322 { | 336 { |
323 WasmRunner<int64_t> r(MachineType::Int64()); | 337 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
324 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32))); | 338 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32))); |
325 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); } | 339 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); } |
326 } | 340 } |
327 { | 341 { |
328 WasmRunner<int64_t> r(MachineType::Int64()); | 342 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
329 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20))); | 343 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20))); |
330 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); } | 344 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); } |
331 } | 345 } |
332 { | 346 { |
333 WasmRunner<int64_t> r(MachineType::Int64()); | 347 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
334 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40))); | 348 BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40))); |
335 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); } | 349 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); } |
336 } | 350 } |
337 } | 351 } |
338 | 352 |
339 WASM_EXEC_TEST(I64ShrU) { | 353 WASM_EXEC_TEST(I64ShrU) { |
340 REQUIRE(I64ShrU); | 354 REQUIRE(I64ShrU); |
341 { | 355 { |
342 WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64()); | 356 WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(), |
| 357 MachineType::Uint64()); |
343 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 358 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
344 | 359 |
345 FOR_UINT64_INPUTS(i) { | 360 FOR_UINT64_INPUTS(i) { |
346 FOR_UINT64_INPUTS(j) { | 361 FOR_UINT64_INPUTS(j) { |
347 uint64_t expected = (*i) >> (*j & 0x3f); | 362 uint64_t expected = (*i) >> (*j & 0x3f); |
348 CHECK_EQ(expected, r.Call(*i, *j)); | 363 CHECK_EQ(expected, r.Call(*i, *j)); |
349 } | 364 } |
350 } | 365 } |
351 } | 366 } |
352 { | 367 { |
353 WasmRunner<int64_t> r(MachineType::Int64()); | 368 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
354 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); | 369 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); |
355 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } | 370 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } |
356 } | 371 } |
357 { | 372 { |
358 WasmRunner<int64_t> r(MachineType::Int64()); | 373 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
359 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); | 374 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); |
360 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } | 375 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } |
361 } | 376 } |
362 { | 377 { |
363 WasmRunner<int64_t> r(MachineType::Int64()); | 378 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
364 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); | 379 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); |
365 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } | 380 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } |
366 } | 381 } |
367 { | 382 { |
368 WasmRunner<int64_t> r(MachineType::Int64()); | 383 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
369 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); | 384 BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); |
370 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } | 385 FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } |
371 } | 386 } |
372 } | 387 } |
373 | 388 |
374 WASM_EXEC_TEST(I64ShrS) { | 389 WASM_EXEC_TEST(I64ShrS) { |
375 REQUIRE(I64ShrS); | 390 REQUIRE(I64ShrS); |
376 { | 391 { |
377 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 392 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 393 MachineType::Int64()); |
378 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 394 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
379 | 395 |
380 FOR_INT64_INPUTS(i) { | 396 FOR_INT64_INPUTS(i) { |
381 FOR_INT64_INPUTS(j) { | 397 FOR_INT64_INPUTS(j) { |
382 int64_t expected = (*i) >> (*j & 0x3f); | 398 int64_t expected = (*i) >> (*j & 0x3f); |
383 CHECK_EQ(expected, r.Call(*i, *j)); | 399 CHECK_EQ(expected, r.Call(*i, *j)); |
384 } | 400 } |
385 } | 401 } |
386 } | 402 } |
387 { | 403 { |
388 WasmRunner<int64_t> r(MachineType::Int64()); | 404 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
389 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); | 405 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0))); |
390 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } | 406 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); } |
391 } | 407 } |
392 { | 408 { |
393 WasmRunner<int64_t> r(MachineType::Int64()); | 409 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
394 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); | 410 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(32))); |
395 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } | 411 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); } |
396 } | 412 } |
397 { | 413 { |
398 WasmRunner<int64_t> r(MachineType::Int64()); | 414 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
399 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); | 415 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(20))); |
400 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } | 416 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); } |
401 } | 417 } |
402 { | 418 { |
403 WasmRunner<int64_t> r(MachineType::Int64()); | 419 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
404 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); | 420 BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(40))); |
405 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } | 421 FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); } |
406 } | 422 } |
407 } | 423 } |
408 | 424 |
409 WASM_EXEC_TEST(I64Eq) { | 425 WASM_EXEC_TEST(I64Eq) { |
410 REQUIRE(I64Eq); | 426 REQUIRE(I64Eq); |
411 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 427 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 428 MachineType::Int64()); |
412 BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 429 BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
413 FOR_INT64_INPUTS(i) { | 430 FOR_INT64_INPUTS(i) { |
414 FOR_INT64_INPUTS(j) { CHECK_EQ(*i == *j ? 1 : 0, r.Call(*i, *j)); } | 431 FOR_INT64_INPUTS(j) { CHECK_EQ(*i == *j ? 1 : 0, r.Call(*i, *j)); } |
415 } | 432 } |
416 } | 433 } |
417 | 434 |
418 WASM_EXEC_TEST(I64Ne) { | 435 WASM_EXEC_TEST(I64Ne) { |
419 REQUIRE(I64Ne); | 436 REQUIRE(I64Ne); |
420 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 437 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 438 MachineType::Int64()); |
421 BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 439 BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
422 FOR_INT64_INPUTS(i) { | 440 FOR_INT64_INPUTS(i) { |
423 FOR_INT64_INPUTS(j) { CHECK_EQ(*i != *j ? 1 : 0, r.Call(*i, *j)); } | 441 FOR_INT64_INPUTS(j) { CHECK_EQ(*i != *j ? 1 : 0, r.Call(*i, *j)); } |
424 } | 442 } |
425 } | 443 } |
426 | 444 |
427 WASM_EXEC_TEST(I64LtS) { | 445 WASM_EXEC_TEST(I64LtS) { |
428 REQUIRE(I64LtS); | 446 REQUIRE(I64LtS); |
429 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 447 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 448 MachineType::Int64()); |
430 BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 449 BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
431 FOR_INT64_INPUTS(i) { | 450 FOR_INT64_INPUTS(i) { |
432 FOR_INT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); } | 451 FOR_INT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); } |
433 } | 452 } |
434 } | 453 } |
435 | 454 |
436 WASM_EXEC_TEST(I64LeS) { | 455 WASM_EXEC_TEST(I64LeS) { |
437 REQUIRE(I64LeS); | 456 REQUIRE(I64LeS); |
438 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 457 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 458 MachineType::Int64()); |
439 BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 459 BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
440 FOR_INT64_INPUTS(i) { | 460 FOR_INT64_INPUTS(i) { |
441 FOR_INT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); } | 461 FOR_INT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); } |
442 } | 462 } |
443 } | 463 } |
444 | 464 |
445 WASM_EXEC_TEST(I64LtU) { | 465 WASM_EXEC_TEST(I64LtU) { |
446 REQUIRE(I64LtU); | 466 REQUIRE(I64LtU); |
447 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 467 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 468 MachineType::Int64()); |
448 BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 469 BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
449 FOR_UINT64_INPUTS(i) { | 470 FOR_UINT64_INPUTS(i) { |
450 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); } | 471 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); } |
451 } | 472 } |
452 } | 473 } |
453 | 474 |
454 WASM_EXEC_TEST(I64LeU) { | 475 WASM_EXEC_TEST(I64LeU) { |
455 REQUIRE(I64LeU); | 476 REQUIRE(I64LeU); |
456 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 477 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 478 MachineType::Int64()); |
457 BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 479 BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
458 FOR_UINT64_INPUTS(i) { | 480 FOR_UINT64_INPUTS(i) { |
459 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); } | 481 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); } |
460 } | 482 } |
461 } | 483 } |
462 | 484 |
463 WASM_EXEC_TEST(I64GtS) { | 485 WASM_EXEC_TEST(I64GtS) { |
464 REQUIRE(I64GtS); | 486 REQUIRE(I64GtS); |
465 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 487 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 488 MachineType::Int64()); |
466 BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 489 BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
467 FOR_INT64_INPUTS(i) { | 490 FOR_INT64_INPUTS(i) { |
468 FOR_INT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); } | 491 FOR_INT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); } |
469 } | 492 } |
470 } | 493 } |
471 | 494 |
472 WASM_EXEC_TEST(I64GeS) { | 495 WASM_EXEC_TEST(I64GeS) { |
473 REQUIRE(I64GeS); | 496 REQUIRE(I64GeS); |
474 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 497 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 498 MachineType::Int64()); |
475 BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 499 BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
476 FOR_INT64_INPUTS(i) { | 500 FOR_INT64_INPUTS(i) { |
477 FOR_INT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); } | 501 FOR_INT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); } |
478 } | 502 } |
479 } | 503 } |
480 | 504 |
481 WASM_EXEC_TEST(I64GtU) { | 505 WASM_EXEC_TEST(I64GtU) { |
482 REQUIRE(I64GtU); | 506 REQUIRE(I64GtU); |
483 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 507 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 508 MachineType::Int64()); |
484 BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 509 BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
485 FOR_UINT64_INPUTS(i) { | 510 FOR_UINT64_INPUTS(i) { |
486 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); } | 511 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); } |
487 } | 512 } |
488 } | 513 } |
489 | 514 |
490 WASM_EXEC_TEST(I64GeU) { | 515 WASM_EXEC_TEST(I64GeU) { |
491 REQUIRE(I64GeU); | 516 REQUIRE(I64GeU); |
492 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 517 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 518 MachineType::Int64()); |
493 BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 519 BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
494 FOR_UINT64_INPUTS(i) { | 520 FOR_UINT64_INPUTS(i) { |
495 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); } | 521 FOR_UINT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); } |
496 } | 522 } |
497 } | 523 } |
498 | 524 |
499 WASM_EXEC_TEST(I32ConvertI64) { | 525 WASM_EXEC_TEST(I32ConvertI64) { |
500 REQUIRE(I32ConvertI64); | 526 REQUIRE(I32ConvertI64); |
501 FOR_INT64_INPUTS(i) { | 527 FOR_INT64_INPUTS(i) { |
502 WasmRunner<int32_t> r; | 528 WasmRunner<int32_t> r(execution_mode); |
503 BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i))); | 529 BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i))); |
504 CHECK_EQ(static_cast<int32_t>(*i), r.Call()); | 530 CHECK_EQ(static_cast<int32_t>(*i), r.Call()); |
505 } | 531 } |
506 } | 532 } |
507 | 533 |
508 WASM_EXEC_TEST(I64SConvertI32) { | 534 WASM_EXEC_TEST(I64SConvertI32) { |
509 REQUIRE(I64SConvertI32); | 535 REQUIRE(I64SConvertI32); |
510 WasmRunner<int64_t> r(MachineType::Int32()); | 536 WasmRunner<int64_t> r(execution_mode, MachineType::Int32()); |
511 BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0))); | 537 BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0))); |
512 FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); } | 538 FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); } |
513 } | 539 } |
514 | 540 |
515 WASM_EXEC_TEST(I64UConvertI32) { | 541 WASM_EXEC_TEST(I64UConvertI32) { |
516 REQUIRE(I64UConvertI32); | 542 REQUIRE(I64UConvertI32); |
517 WasmRunner<int64_t> r(MachineType::Uint32()); | 543 WasmRunner<int64_t> r(execution_mode, MachineType::Uint32()); |
518 BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0))); | 544 BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0))); |
519 FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); } | 545 FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); } |
520 } | 546 } |
521 | 547 |
522 WASM_EXEC_TEST(I64Popcnt) { | 548 WASM_EXEC_TEST(I64Popcnt) { |
523 struct { | 549 struct { |
524 int64_t expected; | 550 int64_t expected; |
525 uint64_t input; | 551 uint64_t input; |
526 } values[] = {{64, 0xffffffffffffffff}, | 552 } values[] = {{64, 0xffffffffffffffff}, |
527 {0, 0x0000000000000000}, | 553 {0, 0x0000000000000000}, |
528 {2, 0x0000080000008000}, | 554 {2, 0x0000080000008000}, |
529 {26, 0x1123456782345678}, | 555 {26, 0x1123456782345678}, |
530 {38, 0xffedcba09edcba09}}; | 556 {38, 0xffedcba09edcba09}}; |
531 | 557 |
532 WasmRunner<int64_t> r(MachineType::Uint64()); | 558 WasmRunner<int64_t> r(execution_mode, MachineType::Uint64()); |
533 BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0))); | 559 BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0))); |
534 for (size_t i = 0; i < arraysize(values); i++) { | 560 for (size_t i = 0; i < arraysize(values); i++) { |
535 CHECK_EQ(values[i].expected, r.Call(values[i].input)); | 561 CHECK_EQ(values[i].expected, r.Call(values[i].input)); |
536 } | 562 } |
537 } | 563 } |
538 | 564 |
539 WASM_EXEC_TEST(F32SConvertI64) { | 565 WASM_EXEC_TEST(F32SConvertI64) { |
540 REQUIRE(F32SConvertI64); | 566 REQUIRE(F32SConvertI64); |
541 WasmRunner<float> r(MachineType::Int64()); | 567 WasmRunner<float> r(execution_mode, MachineType::Int64()); |
542 BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0))); | 568 BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0))); |
543 FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); } | 569 FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); } |
544 } | 570 } |
545 | 571 |
546 WASM_EXEC_TEST(F32UConvertI64) { | 572 WASM_EXEC_TEST(F32UConvertI64) { |
547 REQUIRE(F32UConvertI64); | 573 REQUIRE(F32UConvertI64); |
548 struct { | 574 struct { |
549 uint64_t input; | 575 uint64_t input; |
550 uint32_t expected; | 576 uint32_t expected; |
551 } values[] = {{0x0, 0x0}, | 577 } values[] = {{0x0, 0x0}, |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
617 {0x3fffffffffff, 0x56800000}, | 643 {0x3fffffffffff, 0x56800000}, |
618 {0x1fffffffffff, 0x56000000}, | 644 {0x1fffffffffff, 0x56000000}, |
619 {0xfffffffffff, 0x55800000}, | 645 {0xfffffffffff, 0x55800000}, |
620 {0x7ffffffffff, 0x55000000}, | 646 {0x7ffffffffff, 0x55000000}, |
621 {0x3ffffffffff, 0x54800000}, | 647 {0x3ffffffffff, 0x54800000}, |
622 {0x1ffffffffff, 0x54000000}, | 648 {0x1ffffffffff, 0x54000000}, |
623 {0x8000008000000000, 0x5f000000}, | 649 {0x8000008000000000, 0x5f000000}, |
624 {0x8000008000000001, 0x5f000001}, | 650 {0x8000008000000001, 0x5f000001}, |
625 {0x8000000000000400, 0x5f000000}, | 651 {0x8000000000000400, 0x5f000000}, |
626 {0x8000000000000401, 0x5f000000}}; | 652 {0x8000000000000401, 0x5f000000}}; |
627 WasmRunner<float> r(MachineType::Uint64()); | 653 WasmRunner<float> r(execution_mode, MachineType::Uint64()); |
628 BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0))); | 654 BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0))); |
629 for (size_t i = 0; i < arraysize(values); i++) { | 655 for (size_t i = 0; i < arraysize(values); i++) { |
630 CHECK_EQ(bit_cast<float>(values[i].expected), r.Call(values[i].input)); | 656 CHECK_EQ(bit_cast<float>(values[i].expected), r.Call(values[i].input)); |
631 } | 657 } |
632 } | 658 } |
633 | 659 |
634 WASM_EXEC_TEST(F64SConvertI64) { | 660 WASM_EXEC_TEST(F64SConvertI64) { |
635 REQUIRE(F64SConvertI64); | 661 REQUIRE(F64SConvertI64); |
636 WasmRunner<double> r(MachineType::Int64()); | 662 WasmRunner<double> r(execution_mode, MachineType::Int64()); |
637 BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))); | 663 BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))); |
638 FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); } | 664 FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); } |
639 } | 665 } |
640 | 666 |
641 WASM_EXEC_TEST(F64UConvertI64) { | 667 WASM_EXEC_TEST(F64UConvertI64) { |
642 REQUIRE(F64UConvertI64); | 668 REQUIRE(F64UConvertI64); |
643 struct { | 669 struct { |
644 uint64_t input; | 670 uint64_t input; |
645 uint64_t expected; | 671 uint64_t expected; |
646 } values[] = {{0x0, 0x0}, | 672 } values[] = {{0x0, 0x0}, |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
711 {0x3fffffffffff, 0x42cfffffffffff80}, | 737 {0x3fffffffffff, 0x42cfffffffffff80}, |
712 {0x1fffffffffff, 0x42bfffffffffff00}, | 738 {0x1fffffffffff, 0x42bfffffffffff00}, |
713 {0xfffffffffff, 0x42affffffffffe00}, | 739 {0xfffffffffff, 0x42affffffffffe00}, |
714 {0x7ffffffffff, 0x429ffffffffffc00}, | 740 {0x7ffffffffff, 0x429ffffffffffc00}, |
715 {0x3ffffffffff, 0x428ffffffffff800}, | 741 {0x3ffffffffff, 0x428ffffffffff800}, |
716 {0x1ffffffffff, 0x427ffffffffff000}, | 742 {0x1ffffffffff, 0x427ffffffffff000}, |
717 {0x8000008000000000, 0x43e0000010000000}, | 743 {0x8000008000000000, 0x43e0000010000000}, |
718 {0x8000008000000001, 0x43e0000010000000}, | 744 {0x8000008000000001, 0x43e0000010000000}, |
719 {0x8000000000000400, 0x43e0000000000000}, | 745 {0x8000000000000400, 0x43e0000000000000}, |
720 {0x8000000000000401, 0x43e0000000000001}}; | 746 {0x8000000000000401, 0x43e0000000000001}}; |
721 WasmRunner<double> r(MachineType::Uint64()); | 747 WasmRunner<double> r(execution_mode, MachineType::Uint64()); |
722 BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0))); | 748 BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0))); |
723 for (size_t i = 0; i < arraysize(values); i++) { | 749 for (size_t i = 0; i < arraysize(values); i++) { |
724 CHECK_EQ(bit_cast<double>(values[i].expected), r.Call(values[i].input)); | 750 CHECK_EQ(bit_cast<double>(values[i].expected), r.Call(values[i].input)); |
725 } | 751 } |
726 } | 752 } |
727 | 753 |
728 WASM_EXEC_TEST(I64SConvertF32a) { | 754 WASM_EXEC_TEST(I64SConvertF32a) { |
729 WasmRunner<int64_t> r(MachineType::Float32()); | 755 WasmRunner<int64_t> r(execution_mode, MachineType::Float32()); |
730 BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0))); | 756 BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0))); |
731 | 757 |
732 FOR_FLOAT32_INPUTS(i) { | 758 FOR_FLOAT32_INPUTS(i) { |
733 if (*i < static_cast<float>(std::numeric_limits<int64_t>::max()) && | 759 if (*i < static_cast<float>(std::numeric_limits<int64_t>::max()) && |
734 *i >= static_cast<float>(std::numeric_limits<int64_t>::min())) { | 760 *i >= static_cast<float>(std::numeric_limits<int64_t>::min())) { |
735 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); | 761 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); |
736 } else { | 762 } else { |
737 CHECK_TRAP64(r.Call(*i)); | 763 CHECK_TRAP64(r.Call(*i)); |
738 } | 764 } |
739 } | 765 } |
740 } | 766 } |
741 | 767 |
742 WASM_EXEC_TEST(I64SConvertF64a) { | 768 WASM_EXEC_TEST(I64SConvertF64a) { |
743 WasmRunner<int64_t> r(MachineType::Float64()); | 769 WasmRunner<int64_t> r(execution_mode, MachineType::Float64()); |
744 BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))); | 770 BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))); |
745 | 771 |
746 FOR_FLOAT64_INPUTS(i) { | 772 FOR_FLOAT64_INPUTS(i) { |
747 if (*i < static_cast<double>(std::numeric_limits<int64_t>::max()) && | 773 if (*i < static_cast<double>(std::numeric_limits<int64_t>::max()) && |
748 *i >= static_cast<double>(std::numeric_limits<int64_t>::min())) { | 774 *i >= static_cast<double>(std::numeric_limits<int64_t>::min())) { |
749 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); | 775 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); |
750 } else { | 776 } else { |
751 CHECK_TRAP64(r.Call(*i)); | 777 CHECK_TRAP64(r.Call(*i)); |
752 } | 778 } |
753 } | 779 } |
754 } | 780 } |
755 | 781 |
756 WASM_EXEC_TEST(I64UConvertF32a) { | 782 WASM_EXEC_TEST(I64UConvertF32a) { |
757 WasmRunner<uint64_t> r(MachineType::Float32()); | 783 WasmRunner<uint64_t> r(execution_mode, MachineType::Float32()); |
758 BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0))); | 784 BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0))); |
759 | 785 |
760 FOR_FLOAT32_INPUTS(i) { | 786 FOR_FLOAT32_INPUTS(i) { |
761 if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && | 787 if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && |
762 *i > -1) { | 788 *i > -1) { |
763 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); | 789 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); |
764 } else { | 790 } else { |
765 CHECK_TRAP64(r.Call(*i)); | 791 CHECK_TRAP64(r.Call(*i)); |
766 } | 792 } |
767 } | 793 } |
768 } | 794 } |
769 | 795 |
770 WASM_EXEC_TEST(I64UConvertF64a) { | 796 WASM_EXEC_TEST(I64UConvertF64a) { |
771 WasmRunner<uint64_t> r(MachineType::Float64()); | 797 WasmRunner<uint64_t> r(execution_mode, MachineType::Float64()); |
772 BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0))); | 798 BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0))); |
773 | 799 |
774 FOR_FLOAT64_INPUTS(i) { | 800 FOR_FLOAT64_INPUTS(i) { |
775 if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && | 801 if (*i < static_cast<float>(std::numeric_limits<uint64_t>::max()) && |
776 *i > -1) { | 802 *i > -1) { |
777 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); | 803 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); |
778 } else { | 804 } else { |
779 CHECK_TRAP64(r.Call(*i)); | 805 CHECK_TRAP64(r.Call(*i)); |
780 } | 806 } |
781 } | 807 } |
782 } | 808 } |
783 | 809 |
784 WASM_EXEC_TEST(CallI64Parameter) { | 810 WASM_EXEC_TEST(CallI64Parameter) { |
785 // Build the target function. | 811 // Build the target function. |
786 LocalType param_types[20]; | 812 LocalType param_types[20]; |
787 for (int i = 0; i < 20; i++) param_types[i] = kAstI64; | 813 for (int i = 0; i < 20; i++) param_types[i] = kAstI64; |
788 param_types[3] = kAstI32; | 814 param_types[3] = kAstI32; |
789 param_types[4] = kAstI32; | 815 param_types[4] = kAstI32; |
790 FunctionSig sig(1, 19, param_types); | 816 FunctionSig sig(1, 19, param_types); |
791 for (int i = 0; i < 19; i++) { | 817 for (int i = 0; i < 19; i++) { |
792 TestingModule module; | 818 TestingModule module(execution_mode); |
793 WasmFunctionCompiler t(&sig, &module); | 819 WasmFunctionCompiler t(&sig, &module); |
794 if (i == 2 || i == 3) { | 820 if (i == 2 || i == 3) { |
795 continue; | 821 continue; |
796 } else { | 822 } else { |
797 BUILD(t, WASM_GET_LOCAL(i)); | 823 BUILD(t, WASM_GET_LOCAL(i)); |
798 } | 824 } |
799 uint32_t index = t.CompileAndAdd(); | 825 uint32_t index = t.CompileAndAdd(); |
800 | 826 |
801 // Build the calling function. | 827 // Build the calling function. |
802 WasmRunner<int32_t> r(&module); | 828 WasmRunner<int32_t> r(&module); |
803 BUILD( | 829 BUILD( |
804 r, | 830 r, |
805 WASM_I32_CONVERT_I64(WASM_CALL_FUNCTIONN( | 831 WASM_I32_CONVERT_I64(WASM_CALL_FUNCTIONN( |
806 19, index, WASM_I64V_9(0xbcd12340000000b), | 832 19, index, WASM_I64V_9(0xbcd12340000000b), |
807 WASM_I64V_9(0xbcd12340000000c), WASM_I32V_1(0xd), | 833 WASM_I64V_9(0xbcd12340000000c), WASM_I32V_1(0xd), |
808 WASM_I32_CONVERT_I64(WASM_I64V_9(0xbcd12340000000e)), | 834 WASM_I32_CONVERT_I64(WASM_I64V_9(0xbcd12340000000e)), |
809 WASM_I64V_9(0xbcd12340000000f), WASM_I64V_10(0xbcd1234000000010), | 835 WASM_I64V_9(0xbcd12340000000f), WASM_I64V_10(0xbcd1234000000010), |
810 WASM_I64V_10(0xbcd1234000000011), WASM_I64V_10(0xbcd1234000000012), | 836 WASM_I64V_10(0xbcd1234000000011), WASM_I64V_10(0xbcd1234000000012), |
811 WASM_I64V_10(0xbcd1234000000013), WASM_I64V_10(0xbcd1234000000014), | 837 WASM_I64V_10(0xbcd1234000000013), WASM_I64V_10(0xbcd1234000000014), |
812 WASM_I64V_10(0xbcd1234000000015), WASM_I64V_10(0xbcd1234000000016), | 838 WASM_I64V_10(0xbcd1234000000015), WASM_I64V_10(0xbcd1234000000016), |
813 WASM_I64V_10(0xbcd1234000000017), WASM_I64V_10(0xbcd1234000000018), | 839 WASM_I64V_10(0xbcd1234000000017), WASM_I64V_10(0xbcd1234000000018), |
814 WASM_I64V_10(0xbcd1234000000019), WASM_I64V_10(0xbcd123400000001a), | 840 WASM_I64V_10(0xbcd1234000000019), WASM_I64V_10(0xbcd123400000001a), |
815 WASM_I64V_10(0xbcd123400000001b), WASM_I64V_10(0xbcd123400000001c), | 841 WASM_I64V_10(0xbcd123400000001b), WASM_I64V_10(0xbcd123400000001c), |
816 WASM_I64V_10(0xbcd123400000001d)))); | 842 WASM_I64V_10(0xbcd123400000001d)))); |
817 | 843 |
818 CHECK_EQ(i + 0xb, r.Call()); | 844 CHECK_EQ(i + 0xb, r.Call()); |
819 } | 845 } |
820 } | 846 } |
821 | 847 |
822 void TestI64Binop(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) { | 848 void TestI64Binop(WasmExecutionMode execution_mode, WasmOpcode opcode, |
| 849 int64_t expected, int64_t a, int64_t b) { |
823 { | 850 { |
824 WasmRunner<int64_t> r; | 851 WasmRunner<int64_t> r(execution_mode); |
825 // return K op K | 852 // return K op K |
826 BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b))); | 853 BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b))); |
827 CHECK_EQ(expected, r.Call()); | 854 CHECK_EQ(expected, r.Call()); |
828 } | 855 } |
829 { | 856 { |
830 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 857 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 858 MachineType::Int64()); |
831 // return a op b | 859 // return a op b |
832 BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 860 BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
833 CHECK_EQ(expected, r.Call(a, b)); | 861 CHECK_EQ(expected, r.Call(a, b)); |
834 } | 862 } |
835 } | 863 } |
836 | 864 |
837 void TestI64Cmp(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) { | 865 void TestI64Cmp(WasmExecutionMode execution_mode, WasmOpcode opcode, |
| 866 int64_t expected, int64_t a, int64_t b) { |
838 { | 867 { |
839 WasmRunner<int32_t> r; | 868 WasmRunner<int32_t> r(execution_mode); |
840 // return K op K | 869 // return K op K |
841 BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b))); | 870 BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b))); |
842 CHECK_EQ(expected, r.Call()); | 871 CHECK_EQ(expected, r.Call()); |
843 } | 872 } |
844 { | 873 { |
845 WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64()); | 874 WasmRunner<int32_t> r(execution_mode, MachineType::Int64(), |
| 875 MachineType::Int64()); |
846 // return a op b | 876 // return a op b |
847 BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 877 BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
848 CHECK_EQ(expected, r.Call(a, b)); | 878 CHECK_EQ(expected, r.Call(a, b)); |
849 } | 879 } |
850 } | 880 } |
851 | 881 |
852 #define TEST_I64_BINOP(name, expected, a, b) \ | 882 #define TEST_I64_BINOP(name, expected, a, b) \ |
853 do { \ | 883 do { \ |
854 if (WASM_64 || kSupported_##name) \ | 884 if (WASM_64 || kSupported_##name) \ |
855 TestI64Binop(kExpr##name, expected, a, b); \ | 885 TestI64Binop(execution_mode, kExpr##name, expected, a, b); \ |
856 } while (false) | 886 } while (false) |
857 | 887 |
858 WASM_EXEC_TEST(I64Binops) { | 888 WASM_EXEC_TEST(I64Binops) { |
859 TEST_I64_BINOP(I64Add, -5586332274295447011, 0x501b72ebabc26847, | 889 TEST_I64_BINOP(I64Add, -5586332274295447011, 0x501b72ebabc26847, |
860 0x625de9793d8f79d6); | 890 0x625de9793d8f79d6); |
861 TEST_I64_BINOP(I64Sub, 9001903251710731490, 0xf24fe6474640002e, | 891 TEST_I64_BINOP(I64Sub, 9001903251710731490, 0xf24fe6474640002e, |
862 0x7562b6f711991b4c); | 892 0x7562b6f711991b4c); |
863 TEST_I64_BINOP(I64Mul, -4569547818546064176, 0x231a263c2cbc6451, | 893 TEST_I64_BINOP(I64Mul, -4569547818546064176, 0x231a263c2cbc6451, |
864 0xead44de6bd3e23d0); | 894 0xead44de6bd3e23d0); |
865 TEST_I64_BINOP(I64Mul, -25963122347507043, 0x4da1fa47c9352b73, | 895 TEST_I64_BINOP(I64Mul, -25963122347507043, 0x4da1fa47c9352b73, |
(...skipping 14 matching lines...) Expand all Loading... |
880 0x76ff4da6c80688bf); | 910 0x76ff4da6c80688bf); |
881 TEST_I64_BINOP(I64Shl, -7240704056088331264, 0xef4dc1ed030e8ffe, 9); | 911 TEST_I64_BINOP(I64Shl, -7240704056088331264, 0xef4dc1ed030e8ffe, 9); |
882 TEST_I64_BINOP(I64ShrU, 12500673744059159, 0xb1a52fa7deec5d14, 10); | 912 TEST_I64_BINOP(I64ShrU, 12500673744059159, 0xb1a52fa7deec5d14, 10); |
883 TEST_I64_BINOP(I64ShrS, 1725103446999874, 0x3107c791461a112b, 11); | 913 TEST_I64_BINOP(I64ShrS, 1725103446999874, 0x3107c791461a112b, 11); |
884 TEST_I64_BINOP(I64Ror, -8960135652432576946, 0x73418d1717e4e83a, 12); | 914 TEST_I64_BINOP(I64Ror, -8960135652432576946, 0x73418d1717e4e83a, 12); |
885 TEST_I64_BINOP(I64Ror, 7617662827409989779, 0xebff67cf0c126d36, 13); | 915 TEST_I64_BINOP(I64Ror, 7617662827409989779, 0xebff67cf0c126d36, 13); |
886 TEST_I64_BINOP(I64Rol, -2097714064174346012, 0x43938b8db0b0f230, 14); | 916 TEST_I64_BINOP(I64Rol, -2097714064174346012, 0x43938b8db0b0f230, 14); |
887 TEST_I64_BINOP(I64Rol, 8728493013947314237, 0xe07af243ac4d219d, 15); | 917 TEST_I64_BINOP(I64Rol, 8728493013947314237, 0xe07af243ac4d219d, 15); |
888 } | 918 } |
889 | 919 |
890 #define TEST_I64_CMP(name, expected, a, b) \ | 920 #define TEST_I64_CMP(name, expected, a, b) \ |
891 do { \ | 921 do { \ |
892 if (WASM_64 || kSupported_##name) TestI64Cmp(kExpr##name, expected, a, b); \ | 922 if (WASM_64 || kSupported_##name) \ |
| 923 TestI64Cmp(execution_mode, kExpr##name, expected, a, b); \ |
893 } while (false) | 924 } while (false) |
894 | 925 |
895 WASM_EXEC_TEST(I64Compare) { | 926 WASM_EXEC_TEST(I64Compare) { |
896 TEST_I64_CMP(I64Eq, 0, 0xB915D8FA494064F0, 0x04D700B2536019A3); | 927 TEST_I64_CMP(I64Eq, 0, 0xB915D8FA494064F0, 0x04D700B2536019A3); |
897 TEST_I64_CMP(I64Ne, 1, 0xC2FAFAAAB0446CDC, 0x52A3328F780C97A3); | 928 TEST_I64_CMP(I64Ne, 1, 0xC2FAFAAAB0446CDC, 0x52A3328F780C97A3); |
898 TEST_I64_CMP(I64LtS, 0, 0x673636E6306B0578, 0x028EC9ECA78F7227); | 929 TEST_I64_CMP(I64LtS, 0, 0x673636E6306B0578, 0x028EC9ECA78F7227); |
899 TEST_I64_CMP(I64LeS, 1, 0xAE5214114B86A0FA, 0x7C1D21DA3DFD0CCF); | 930 TEST_I64_CMP(I64LeS, 1, 0xAE5214114B86A0FA, 0x7C1D21DA3DFD0CCF); |
900 TEST_I64_CMP(I64LtU, 0, 0x7D52166381EC1CE0, 0x59F4A6A9E78CD3D8); | 931 TEST_I64_CMP(I64LtU, 0, 0x7D52166381EC1CE0, 0x59F4A6A9E78CD3D8); |
901 TEST_I64_CMP(I64LeU, 1, 0xE4169A385C7EA0E0, 0xFBDBED2C8781E5BC); | 932 TEST_I64_CMP(I64LeU, 1, 0xE4169A385C7EA0E0, 0xFBDBED2C8781E5BC); |
902 TEST_I64_CMP(I64GtS, 0, 0x9D08FF8FB5F42E81, 0xD4E5C9D7FE09F621); | 933 TEST_I64_CMP(I64GtS, 0, 0x9D08FF8FB5F42E81, 0xD4E5C9D7FE09F621); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
937 {48, 0x0000000000008040}, {49, 0x0000000000004005}, | 968 {48, 0x0000000000008040}, {49, 0x0000000000004005}, |
938 {50, 0x0000000000002050}, {51, 0x0000000000001700}, | 969 {50, 0x0000000000002050}, {51, 0x0000000000001700}, |
939 {52, 0x0000000000000870}, {53, 0x0000000000000405}, | 970 {52, 0x0000000000000870}, {53, 0x0000000000000405}, |
940 {54, 0x0000000000000203}, {55, 0x0000000000000101}, | 971 {54, 0x0000000000000203}, {55, 0x0000000000000101}, |
941 {56, 0x0000000000000089}, {57, 0x0000000000000041}, | 972 {56, 0x0000000000000089}, {57, 0x0000000000000041}, |
942 {58, 0x0000000000000022}, {59, 0x0000000000000013}, | 973 {58, 0x0000000000000022}, {59, 0x0000000000000013}, |
943 {60, 0x0000000000000008}, {61, 0x0000000000000004}, | 974 {60, 0x0000000000000008}, {61, 0x0000000000000004}, |
944 {62, 0x0000000000000002}, {63, 0x0000000000000001}, | 975 {62, 0x0000000000000002}, {63, 0x0000000000000001}, |
945 {64, 0x0000000000000000}}; | 976 {64, 0x0000000000000000}}; |
946 | 977 |
947 WasmRunner<int64_t> r(MachineType::Uint64()); | 978 WasmRunner<int64_t> r(execution_mode, MachineType::Uint64()); |
948 BUILD(r, WASM_I64_CLZ(WASM_GET_LOCAL(0))); | 979 BUILD(r, WASM_I64_CLZ(WASM_GET_LOCAL(0))); |
949 for (size_t i = 0; i < arraysize(values); i++) { | 980 for (size_t i = 0; i < arraysize(values); i++) { |
950 CHECK_EQ(values[i].expected, r.Call(values[i].input)); | 981 CHECK_EQ(values[i].expected, r.Call(values[i].input)); |
951 } | 982 } |
952 } | 983 } |
953 | 984 |
954 WASM_EXEC_TEST(I64Ctz) { | 985 WASM_EXEC_TEST(I64Ctz) { |
955 REQUIRE(I64Ctz); | 986 REQUIRE(I64Ctz); |
956 struct { | 987 struct { |
957 int64_t expected; | 988 int64_t expected; |
(...skipping 25 matching lines...) Expand all Loading... |
983 {16, 0x00000000b8f10000}, {15, 0x000000003b9f8000}, | 1014 {16, 0x00000000b8f10000}, {15, 0x000000003b9f8000}, |
984 {14, 0x00000000db4c4000}, {13, 0x00000000e9a32000}, | 1015 {14, 0x00000000db4c4000}, {13, 0x00000000e9a32000}, |
985 {12, 0x00000000fca61000}, {11, 0x000000006c8a7800}, | 1016 {12, 0x00000000fca61000}, {11, 0x000000006c8a7800}, |
986 {10, 0x000000008ce5a400}, {9, 0x00000000cb7d0200}, | 1017 {10, 0x000000008ce5a400}, {9, 0x00000000cb7d0200}, |
987 {8, 0x00000000cb4dc100}, {7, 0x00000000dfbec580}, | 1018 {8, 0x00000000cb4dc100}, {7, 0x00000000dfbec580}, |
988 {6, 0x0000000027a9db40}, {5, 0x00000000de3bcb20}, | 1019 {6, 0x0000000027a9db40}, {5, 0x00000000de3bcb20}, |
989 {4, 0x00000000d7e8a610}, {3, 0x000000009afdbc88}, | 1020 {4, 0x00000000d7e8a610}, {3, 0x000000009afdbc88}, |
990 {2, 0x000000009afdbc84}, {1, 0x000000009afdbc82}, | 1021 {2, 0x000000009afdbc84}, {1, 0x000000009afdbc82}, |
991 {0, 0x000000009afdbc81}}; | 1022 {0, 0x000000009afdbc81}}; |
992 | 1023 |
993 WasmRunner<int64_t> r(MachineType::Uint64()); | 1024 WasmRunner<int64_t> r(execution_mode, MachineType::Uint64()); |
994 BUILD(r, WASM_I64_CTZ(WASM_GET_LOCAL(0))); | 1025 BUILD(r, WASM_I64_CTZ(WASM_GET_LOCAL(0))); |
995 for (size_t i = 0; i < arraysize(values); i++) { | 1026 for (size_t i = 0; i < arraysize(values); i++) { |
996 CHECK_EQ(values[i].expected, r.Call(values[i].input)); | 1027 CHECK_EQ(values[i].expected, r.Call(values[i].input)); |
997 } | 1028 } |
998 } | 1029 } |
999 | 1030 |
1000 WASM_EXEC_TEST(I64Popcnt2) { | 1031 WASM_EXEC_TEST(I64Popcnt2) { |
1001 REQUIRE(I64Popcnt); | 1032 REQUIRE(I64Popcnt); |
1002 struct { | 1033 struct { |
1003 int64_t expected; | 1034 int64_t expected; |
1004 uint64_t input; | 1035 uint64_t input; |
1005 } values[] = {{64, 0xffffffffffffffff}, | 1036 } values[] = {{64, 0xffffffffffffffff}, |
1006 {0, 0x0000000000000000}, | 1037 {0, 0x0000000000000000}, |
1007 {2, 0x0000080000008000}, | 1038 {2, 0x0000080000008000}, |
1008 {26, 0x1123456782345678}, | 1039 {26, 0x1123456782345678}, |
1009 {38, 0xffedcba09edcba09}}; | 1040 {38, 0xffedcba09edcba09}}; |
1010 | 1041 |
1011 WasmRunner<int64_t> r(MachineType::Uint64()); | 1042 WasmRunner<int64_t> r(execution_mode, MachineType::Uint64()); |
1012 BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0))); | 1043 BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0))); |
1013 for (size_t i = 0; i < arraysize(values); i++) { | 1044 for (size_t i = 0; i < arraysize(values); i++) { |
1014 CHECK_EQ(values[i].expected, r.Call(values[i].input)); | 1045 CHECK_EQ(values[i].expected, r.Call(values[i].input)); |
1015 } | 1046 } |
1016 } | 1047 } |
1017 | 1048 |
1018 // Test the WasmRunner with an Int64 return value and different numbers of | 1049 // Test the WasmRunner with an Int64 return value and different numbers of |
1019 // Int64 parameters. | 1050 // Int64 parameters. |
1020 TEST(Run_TestI64WasmRunner) { | 1051 WASM_EXEC_TEST(I64WasmRunner) { |
1021 REQUIRE(I64Param); | 1052 REQUIRE(I64Param); |
1022 REQUIRE(I64Xor); | 1053 REQUIRE(I64Xor); |
1023 {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r; | 1054 {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r(execution_mode); |
1024 BUILD(r, WASM_I64V(*i)); | 1055 BUILD(r, WASM_I64V(*i)); |
1025 CHECK_EQ(*i, r.Call()); | 1056 CHECK_EQ(*i, r.Call()); |
1026 } | 1057 } |
1027 } | 1058 } |
1028 { | 1059 { |
1029 WasmRunner<int64_t> r(MachineType::Int64()); | 1060 WasmRunner<int64_t> r(execution_mode, MachineType::Int64()); |
1030 BUILD(r, WASM_GET_LOCAL(0)); | 1061 BUILD(r, WASM_GET_LOCAL(0)); |
1031 FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } | 1062 FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); } |
1032 } | 1063 } |
1033 { | 1064 { |
1034 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 1065 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 1066 MachineType::Int64()); |
1035 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 1067 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
1036 FOR_INT64_INPUTS(i) { | 1068 FOR_INT64_INPUTS(i) { |
1037 FOR_INT64_INPUTS(j) { CHECK_EQ(*i ^ *j, r.Call(*i, *j)); } | 1069 FOR_INT64_INPUTS(j) { CHECK_EQ(*i ^ *j, r.Call(*i, *j)); } |
1038 } | 1070 } |
1039 } | 1071 } |
1040 { | 1072 { |
1041 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(), | 1073 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
1042 MachineType::Int64()); | 1074 MachineType::Int64(), MachineType::Int64()); |
1043 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), | 1075 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), |
1044 WASM_I64_XOR(WASM_GET_LOCAL(1), WASM_GET_LOCAL(2)))); | 1076 WASM_I64_XOR(WASM_GET_LOCAL(1), WASM_GET_LOCAL(2)))); |
1045 FOR_INT64_INPUTS(i) { | 1077 FOR_INT64_INPUTS(i) { |
1046 FOR_INT64_INPUTS(j) { | 1078 FOR_INT64_INPUTS(j) { |
1047 CHECK_EQ(*i ^ *j ^ *j, r.Call(*i, *j, *j)); | 1079 CHECK_EQ(*i ^ *j ^ *j, r.Call(*i, *j, *j)); |
1048 CHECK_EQ(*j ^ *i ^ *j, r.Call(*j, *i, *j)); | 1080 CHECK_EQ(*j ^ *i ^ *j, r.Call(*j, *i, *j)); |
1049 CHECK_EQ(*j ^ *j ^ *i, r.Call(*j, *j, *i)); | 1081 CHECK_EQ(*j ^ *j ^ *i, r.Call(*j, *j, *i)); |
1050 } | 1082 } |
1051 } | 1083 } |
1052 } | 1084 } |
1053 { | 1085 { |
1054 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(), | 1086 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
1055 MachineType::Int64(), MachineType::Int64()); | 1087 MachineType::Int64(), MachineType::Int64(), |
| 1088 MachineType::Int64()); |
1056 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), | 1089 BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), |
1057 WASM_I64_XOR(WASM_GET_LOCAL(1), | 1090 WASM_I64_XOR(WASM_GET_LOCAL(1), |
1058 WASM_I64_XOR(WASM_GET_LOCAL(2), | 1091 WASM_I64_XOR(WASM_GET_LOCAL(2), |
1059 WASM_GET_LOCAL(3))))); | 1092 WASM_GET_LOCAL(3))))); |
1060 FOR_INT64_INPUTS(i) { | 1093 FOR_INT64_INPUTS(i) { |
1061 FOR_INT64_INPUTS(j) { | 1094 FOR_INT64_INPUTS(j) { |
1062 CHECK_EQ(*i ^ *j ^ *j ^ *j, r.Call(*i, *j, *j, *j)); | 1095 CHECK_EQ(*i ^ *j ^ *j ^ *j, r.Call(*i, *j, *j, *j)); |
1063 CHECK_EQ(*j ^ *i ^ *j ^ *j, r.Call(*j, *i, *j, *j)); | 1096 CHECK_EQ(*j ^ *i ^ *j ^ *j, r.Call(*j, *i, *j, *j)); |
1064 CHECK_EQ(*j ^ *j ^ *i ^ *j, r.Call(*j, *j, *i, *j)); | 1097 CHECK_EQ(*j ^ *j ^ *i ^ *j, r.Call(*j, *j, *i, *j)); |
1065 CHECK_EQ(*j ^ *j ^ *j ^ *i, r.Call(*j, *j, *j, *i)); | 1098 CHECK_EQ(*j ^ *j ^ *j ^ *i, r.Call(*j, *j, *j, *i)); |
1066 } | 1099 } |
1067 } | 1100 } |
1068 } | 1101 } |
1069 } | 1102 } |
1070 | 1103 |
1071 WASM_EXEC_TEST(Call_Int64Sub) { | 1104 WASM_EXEC_TEST(Call_Int64Sub) { |
1072 REQUIRE(I64Sub); | 1105 REQUIRE(I64Sub); |
1073 // Build the target function. | 1106 // Build the target function. |
1074 TestSignatures sigs; | 1107 TestSignatures sigs; |
1075 TestingModule module; | 1108 TestingModule module(execution_mode); |
1076 WasmFunctionCompiler t(sigs.l_ll(), &module); | 1109 WasmFunctionCompiler t(sigs.l_ll(), &module); |
1077 BUILD(t, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 1110 BUILD(t, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
1078 uint32_t index = t.CompileAndAdd(); | 1111 uint32_t index = t.CompileAndAdd(); |
1079 | 1112 |
1080 // Build the caller function. | 1113 // Build the caller function. |
1081 WasmRunner<int64_t> r(&module, MachineType::Int64(), MachineType::Int64()); | 1114 WasmRunner<int64_t> r(&module, MachineType::Int64(), MachineType::Int64()); |
1082 BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 1115 BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
1083 | 1116 |
1084 FOR_INT32_INPUTS(i) { | 1117 FOR_INT32_INPUTS(i) { |
1085 FOR_INT32_INPUTS(j) { | 1118 FOR_INT32_INPUTS(j) { |
1086 int64_t a = static_cast<int64_t>(*i) << 32 | | 1119 int64_t a = static_cast<int64_t>(*i) << 32 | |
1087 (static_cast<int64_t>(*j) | 0xFFFFFFFF); | 1120 (static_cast<int64_t>(*j) | 0xFFFFFFFF); |
1088 int64_t b = static_cast<int64_t>(*j) << 32 | | 1121 int64_t b = static_cast<int64_t>(*j) << 32 | |
1089 (static_cast<int64_t>(*i) | 0xFFFFFFFF); | 1122 (static_cast<int64_t>(*i) | 0xFFFFFFFF); |
1090 | 1123 |
1091 int64_t expected = static_cast<int64_t>(static_cast<uint64_t>(a) - | 1124 int64_t expected = static_cast<int64_t>(static_cast<uint64_t>(a) - |
1092 static_cast<uint64_t>(b)); | 1125 static_cast<uint64_t>(b)); |
1093 CHECK_EQ(expected, r.Call(a, b)); | 1126 CHECK_EQ(expected, r.Call(a, b)); |
1094 } | 1127 } |
1095 } | 1128 } |
1096 } | 1129 } |
1097 | 1130 |
1098 WASM_EXEC_TEST(LoadStoreI64_sx) { | 1131 WASM_EXEC_TEST(LoadStoreI64_sx) { |
1099 REQUIRE(I64LoadStore); | 1132 REQUIRE(I64LoadStore); |
1100 REQUIRE(DepthFirst); | 1133 REQUIRE(DepthFirst); |
1101 byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S, | 1134 byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S, |
1102 kExprI64LoadMem}; | 1135 kExprI64LoadMem}; |
1103 | 1136 |
1104 for (size_t m = 0; m < arraysize(loads); m++) { | 1137 for (size_t m = 0; m < arraysize(loads); m++) { |
1105 TestingModule module; | 1138 TestingModule module(execution_mode); |
1106 byte* memory = module.AddMemoryElems<byte>(16); | 1139 byte* memory = module.AddMemoryElems<byte>(16); |
1107 WasmRunner<int64_t> r(&module); | 1140 WasmRunner<int64_t> r(&module); |
1108 | 1141 |
1109 byte code[] = { | 1142 byte code[] = { |
1110 kExprI8Const, 8, // -- | 1143 kExprI8Const, 8, // -- |
1111 kExprI8Const, 0, // -- | 1144 kExprI8Const, 0, // -- |
1112 loads[m], // -- | 1145 loads[m], // -- |
1113 ZERO_ALIGNMENT, // -- | 1146 ZERO_ALIGNMENT, // -- |
1114 ZERO_OFFSET, // -- | 1147 ZERO_OFFSET, // -- |
1115 kExprI64StoreMem, // -- | 1148 kExprI64StoreMem, // -- |
(...skipping 15 matching lines...) Expand all Loading... |
1131 CHECK_EQ(static_cast<byte>(i), memory[8 + size - 1]); | 1164 CHECK_EQ(static_cast<byte>(i), memory[8 + size - 1]); |
1132 for (int j = size; j < 8; j++) { | 1165 for (int j = size; j < 8; j++) { |
1133 CHECK_EQ(255, memory[8 + j]); | 1166 CHECK_EQ(255, memory[8 + j]); |
1134 } | 1167 } |
1135 } | 1168 } |
1136 } | 1169 } |
1137 } | 1170 } |
1138 | 1171 |
1139 WASM_EXEC_TEST(I64SConvertF32b) { | 1172 WASM_EXEC_TEST(I64SConvertF32b) { |
1140 REQUIRE(I64SConvertF32); | 1173 REQUIRE(I64SConvertF32); |
1141 WasmRunner<int64_t> r(MachineType::Float32()); | 1174 WasmRunner<int64_t> r(execution_mode, MachineType::Float32()); |
1142 BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0))); | 1175 BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0))); |
1143 | 1176 |
1144 FOR_FLOAT32_INPUTS(i) { | 1177 FOR_FLOAT32_INPUTS(i) { |
1145 if (*i < static_cast<float>(INT64_MAX) && | 1178 if (*i < static_cast<float>(INT64_MAX) && |
1146 *i >= static_cast<float>(INT64_MIN)) { | 1179 *i >= static_cast<float>(INT64_MIN)) { |
1147 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); | 1180 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); |
1148 } else { | 1181 } else { |
1149 CHECK_TRAP64(r.Call(*i)); | 1182 CHECK_TRAP64(r.Call(*i)); |
1150 } | 1183 } |
1151 } | 1184 } |
1152 } | 1185 } |
1153 | 1186 |
1154 WASM_EXEC_TEST(I64SConvertF64b) { | 1187 WASM_EXEC_TEST(I64SConvertF64b) { |
1155 REQUIRE(I64SConvertF64); | 1188 REQUIRE(I64SConvertF64); |
1156 WasmRunner<int64_t> r(MachineType::Float64()); | 1189 WasmRunner<int64_t> r(execution_mode, MachineType::Float64()); |
1157 BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))); | 1190 BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))); |
1158 | 1191 |
1159 FOR_FLOAT64_INPUTS(i) { | 1192 FOR_FLOAT64_INPUTS(i) { |
1160 if (*i < static_cast<double>(INT64_MAX) && | 1193 if (*i < static_cast<double>(INT64_MAX) && |
1161 *i >= static_cast<double>(INT64_MIN)) { | 1194 *i >= static_cast<double>(INT64_MIN)) { |
1162 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); | 1195 CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); |
1163 } else { | 1196 } else { |
1164 CHECK_TRAP64(r.Call(*i)); | 1197 CHECK_TRAP64(r.Call(*i)); |
1165 } | 1198 } |
1166 } | 1199 } |
1167 } | 1200 } |
1168 | 1201 |
1169 WASM_EXEC_TEST(I64UConvertF32b) { | 1202 WASM_EXEC_TEST(I64UConvertF32b) { |
1170 REQUIRE(I64UConvertF32); | 1203 REQUIRE(I64UConvertF32); |
1171 WasmRunner<uint64_t> r(MachineType::Float32()); | 1204 WasmRunner<uint64_t> r(execution_mode, MachineType::Float32()); |
1172 BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0))); | 1205 BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0))); |
1173 | 1206 |
1174 FOR_FLOAT32_INPUTS(i) { | 1207 FOR_FLOAT32_INPUTS(i) { |
1175 if (*i < static_cast<float>(UINT64_MAX) && *i > -1) { | 1208 if (*i < static_cast<float>(UINT64_MAX) && *i > -1) { |
1176 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); | 1209 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); |
1177 } else { | 1210 } else { |
1178 CHECK_TRAP64(r.Call(*i)); | 1211 CHECK_TRAP64(r.Call(*i)); |
1179 } | 1212 } |
1180 } | 1213 } |
1181 } | 1214 } |
1182 | 1215 |
1183 WASM_EXEC_TEST(I64UConvertF64b) { | 1216 WASM_EXEC_TEST(I64UConvertF64b) { |
1184 REQUIRE(I64UConvertF64); | 1217 REQUIRE(I64UConvertF64); |
1185 WasmRunner<uint64_t> r(MachineType::Float64()); | 1218 WasmRunner<uint64_t> r(execution_mode, MachineType::Float64()); |
1186 BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0))); | 1219 BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0))); |
1187 | 1220 |
1188 FOR_FLOAT64_INPUTS(i) { | 1221 FOR_FLOAT64_INPUTS(i) { |
1189 if (*i < static_cast<float>(UINT64_MAX) && *i > -1) { | 1222 if (*i < static_cast<float>(UINT64_MAX) && *i > -1) { |
1190 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); | 1223 CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); |
1191 } else { | 1224 } else { |
1192 CHECK_TRAP64(r.Call(*i)); | 1225 CHECK_TRAP64(r.Call(*i)); |
1193 } | 1226 } |
1194 } | 1227 } |
1195 } | 1228 } |
1196 | 1229 |
1197 WASM_EXEC_TEST(I64ReinterpretF64) { | 1230 WASM_EXEC_TEST(I64ReinterpretF64) { |
1198 REQUIRE(I64ReinterpretF64); | 1231 REQUIRE(I64ReinterpretF64); |
1199 TestingModule module; | 1232 TestingModule module(execution_mode); |
1200 int64_t* memory = module.AddMemoryElems<int64_t>(8); | 1233 int64_t* memory = module.AddMemoryElems<int64_t>(8); |
1201 WasmRunner<int64_t> r(&module); | 1234 WasmRunner<int64_t> r(&module); |
1202 | 1235 |
1203 BUILD(r, WASM_I64_REINTERPRET_F64( | 1236 BUILD(r, WASM_I64_REINTERPRET_F64( |
1204 WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO))); | 1237 WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO))); |
1205 | 1238 |
1206 FOR_INT32_INPUTS(i) { | 1239 FOR_INT32_INPUTS(i) { |
1207 int64_t expected = static_cast<int64_t>(*i) * 0x300010001; | 1240 int64_t expected = static_cast<int64_t>(*i) * 0x300010001; |
1208 memory[0] = expected; | 1241 memory[0] = expected; |
1209 CHECK_EQ(expected, r.Call()); | 1242 CHECK_EQ(expected, r.Call()); |
1210 } | 1243 } |
1211 } | 1244 } |
1212 | 1245 |
1213 WASM_EXEC_TEST(F64ReinterpretI64) { | 1246 WASM_EXEC_TEST(F64ReinterpretI64) { |
1214 REQUIRE(F64ReinterpretI64); | 1247 REQUIRE(F64ReinterpretI64); |
1215 TestingModule module; | 1248 TestingModule module(execution_mode); |
1216 int64_t* memory = module.AddMemoryElems<int64_t>(8); | 1249 int64_t* memory = module.AddMemoryElems<int64_t>(8); |
1217 WasmRunner<int64_t> r(&module, MachineType::Int64()); | 1250 WasmRunner<int64_t> r(&module, MachineType::Int64()); |
1218 | 1251 |
1219 BUILD(r, WASM_BLOCK( | 1252 BUILD(r, WASM_BLOCK( |
1220 2, WASM_STORE_MEM(MachineType::Float64(), WASM_ZERO, | 1253 2, WASM_STORE_MEM(MachineType::Float64(), WASM_ZERO, |
1221 WASM_F64_REINTERPRET_I64(WASM_GET_LOCAL(0))), | 1254 WASM_F64_REINTERPRET_I64(WASM_GET_LOCAL(0))), |
1222 WASM_GET_LOCAL(0))); | 1255 WASM_GET_LOCAL(0))); |
1223 | 1256 |
1224 FOR_INT32_INPUTS(i) { | 1257 FOR_INT32_INPUTS(i) { |
1225 int64_t expected = static_cast<int64_t>(*i) * 0x300010001; | 1258 int64_t expected = static_cast<int64_t>(*i) * 0x300010001; |
1226 CHECK_EQ(expected, r.Call(expected)); | 1259 CHECK_EQ(expected, r.Call(expected)); |
1227 CHECK_EQ(expected, memory[0]); | 1260 CHECK_EQ(expected, memory[0]); |
1228 } | 1261 } |
1229 } | 1262 } |
1230 | 1263 |
1231 WASM_EXEC_TEST(LoadMemI64) { | 1264 WASM_EXEC_TEST(LoadMemI64) { |
1232 REQUIRE(I64LoadStore); | 1265 REQUIRE(I64LoadStore); |
1233 TestingModule module; | 1266 TestingModule module(execution_mode); |
1234 int64_t* memory = module.AddMemoryElems<int64_t>(8); | 1267 int64_t* memory = module.AddMemoryElems<int64_t>(8); |
1235 module.RandomizeMemory(1111); | 1268 module.RandomizeMemory(1111); |
1236 WasmRunner<int64_t> r(&module); | 1269 WasmRunner<int64_t> r(&module); |
1237 | 1270 |
1238 BUILD(r, WASM_LOAD_MEM(MachineType::Int64(), WASM_I8(0))); | 1271 BUILD(r, WASM_LOAD_MEM(MachineType::Int64(), WASM_I8(0))); |
1239 | 1272 |
1240 memory[0] = 0xaabbccdd00112233LL; | 1273 memory[0] = 0xaabbccdd00112233LL; |
1241 CHECK_EQ(0xaabbccdd00112233LL, r.Call()); | 1274 CHECK_EQ(0xaabbccdd00112233LL, r.Call()); |
1242 | 1275 |
1243 memory[0] = 0x33aabbccdd001122LL; | 1276 memory[0] = 0x33aabbccdd001122LL; |
1244 CHECK_EQ(0x33aabbccdd001122LL, r.Call()); | 1277 CHECK_EQ(0x33aabbccdd001122LL, r.Call()); |
1245 | 1278 |
1246 memory[0] = 77777777; | 1279 memory[0] = 77777777; |
1247 CHECK_EQ(77777777, r.Call()); | 1280 CHECK_EQ(77777777, r.Call()); |
1248 } | 1281 } |
1249 | 1282 |
1250 WASM_EXEC_TEST(Run_Wasm_LoadMemI64_alignment) { | 1283 WASM_EXEC_TEST(LoadMemI64_alignment) { |
1251 REQUIRE(I64LoadStore); | 1284 REQUIRE(I64LoadStore); |
1252 TestingModule module; | 1285 TestingModule module(execution_mode); |
1253 int64_t* memory = module.AddMemoryElems<int64_t>(8); | 1286 int64_t* memory = module.AddMemoryElems<int64_t>(8); |
1254 for (byte alignment = 0; alignment <= 3; alignment++) { | 1287 for (byte alignment = 0; alignment <= 3; alignment++) { |
1255 module.RandomizeMemory(1111); | 1288 module.RandomizeMemory(1111); |
1256 WasmRunner<int64_t> r(&module); | 1289 WasmRunner<int64_t> r(&module); |
1257 | 1290 |
1258 BUILD(r, | 1291 BUILD(r, |
1259 WASM_LOAD_MEM_ALIGNMENT(MachineType::Int64(), WASM_I8(0), alignment)); | 1292 WASM_LOAD_MEM_ALIGNMENT(MachineType::Int64(), WASM_I8(0), alignment)); |
1260 | 1293 |
1261 memory[0] = 0xaabbccdd00112233LL; | 1294 memory[0] = 0xaabbccdd00112233LL; |
1262 CHECK_EQ(0xaabbccdd00112233LL, r.Call()); | 1295 CHECK_EQ(0xaabbccdd00112233LL, r.Call()); |
1263 | 1296 |
1264 memory[0] = 0x33aabbccdd001122LL; | 1297 memory[0] = 0x33aabbccdd001122LL; |
1265 CHECK_EQ(0x33aabbccdd001122LL, r.Call()); | 1298 CHECK_EQ(0x33aabbccdd001122LL, r.Call()); |
1266 | 1299 |
1267 memory[0] = 77777777; | 1300 memory[0] = 77777777; |
1268 CHECK_EQ(77777777, r.Call()); | 1301 CHECK_EQ(77777777, r.Call()); |
1269 } | 1302 } |
1270 } | 1303 } |
1271 | 1304 |
1272 WASM_EXEC_TEST(Run_Wasm_MemI64_Sum) { | 1305 WASM_EXEC_TEST(MemI64_Sum) { |
1273 REQUIRE(I64LoadStore); | 1306 REQUIRE(I64LoadStore); |
1274 REQUIRE(I64Add); | 1307 REQUIRE(I64Add); |
1275 REQUIRE(I64Sub); | 1308 REQUIRE(I64Sub); |
1276 REQUIRE(I64Phi); | 1309 REQUIRE(I64Phi); |
1277 const int kNumElems = 20; | 1310 const int kNumElems = 20; |
1278 TestingModule module; | 1311 TestingModule module(execution_mode); |
1279 uint64_t* memory = module.AddMemoryElems<uint64_t>(kNumElems); | 1312 uint64_t* memory = module.AddMemoryElems<uint64_t>(kNumElems); |
1280 WasmRunner<uint64_t> r(&module, MachineType::Int32()); | 1313 WasmRunner<uint64_t> r(&module, MachineType::Int32()); |
1281 const byte kSum = r.AllocateLocal(kAstI64); | 1314 const byte kSum = r.AllocateLocal(kAstI64); |
1282 | 1315 |
1283 BUILD(r, WASM_BLOCK( | 1316 BUILD(r, WASM_BLOCK( |
1284 2, WASM_WHILE( | 1317 2, WASM_WHILE( |
1285 WASM_GET_LOCAL(0), | 1318 WASM_GET_LOCAL(0), |
1286 WASM_BLOCK( | 1319 WASM_BLOCK( |
1287 2, WASM_SET_LOCAL( | 1320 2, WASM_SET_LOCAL( |
1288 kSum, WASM_I64_ADD( | 1321 kSum, WASM_I64_ADD( |
1289 WASM_GET_LOCAL(kSum), | 1322 WASM_GET_LOCAL(kSum), |
1290 WASM_LOAD_MEM(MachineType::Int64(), | 1323 WASM_LOAD_MEM(MachineType::Int64(), |
1291 WASM_GET_LOCAL(0)))), | 1324 WASM_GET_LOCAL(0)))), |
1292 WASM_SET_LOCAL( | 1325 WASM_SET_LOCAL( |
1293 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(8))))), | 1326 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(8))))), |
1294 WASM_GET_LOCAL(1))); | 1327 WASM_GET_LOCAL(1))); |
1295 | 1328 |
1296 // Run 4 trials. | 1329 // Run 4 trials. |
1297 for (int i = 0; i < 3; i++) { | 1330 for (int i = 0; i < 3; i++) { |
1298 module.RandomizeMemory(i * 33); | 1331 module.RandomizeMemory(i * 33); |
1299 uint64_t expected = 0; | 1332 uint64_t expected = 0; |
1300 for (size_t j = kNumElems - 1; j > 0; j--) { | 1333 for (size_t j = kNumElems - 1; j > 0; j--) { |
1301 expected += memory[j]; | 1334 expected += memory[j]; |
1302 } | 1335 } |
1303 uint64_t result = r.Call(8 * (kNumElems - 1)); | 1336 uint64_t result = r.Call(8 * (kNumElems - 1)); |
1304 CHECK_EQ(expected, result); | 1337 CHECK_EQ(expected, result); |
1305 } | 1338 } |
1306 } | 1339 } |
1307 | 1340 |
1308 WASM_EXEC_TEST(Run_Wasm_StoreMemI64_alignment) { | 1341 WASM_EXEC_TEST(StoreMemI64_alignment) { |
1309 TestingModule module; | 1342 TestingModule module(execution_mode); |
1310 int64_t* memory = module.AddMemoryElems<int64_t>(4); | 1343 int64_t* memory = module.AddMemoryElems<int64_t>(4); |
1311 const int64_t kWritten = 0x12345678abcd0011ll; | 1344 const int64_t kWritten = 0x12345678abcd0011ll; |
1312 | 1345 |
1313 for (byte i = 0; i <= 3; i++) { | 1346 for (byte i = 0; i <= 3; i++) { |
1314 WasmRunner<int64_t> r(&module, MachineType::Int64()); | 1347 WasmRunner<int64_t> r(&module, MachineType::Int64()); |
1315 BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int64(), WASM_ZERO, i, | 1348 BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int64(), WASM_ZERO, i, |
1316 WASM_GET_LOCAL(0))); | 1349 WASM_GET_LOCAL(0))); |
1317 module.RandomizeMemory(1111); | 1350 module.RandomizeMemory(1111); |
1318 memory[0] = 0; | 1351 memory[0] = 0; |
1319 | 1352 |
1320 CHECK_EQ(kWritten, r.Call(kWritten)); | 1353 CHECK_EQ(kWritten, r.Call(kWritten)); |
1321 CHECK_EQ(kWritten, memory[0]); | 1354 CHECK_EQ(kWritten, memory[0]); |
1322 } | 1355 } |
1323 } | 1356 } |
1324 | 1357 |
1325 WASM_EXEC_TEST(Run_Wasm_I64Global) { | 1358 WASM_EXEC_TEST(I64Global) { |
1326 REQUIRE(I64LoadStore); | 1359 REQUIRE(I64LoadStore); |
1327 REQUIRE(I64SConvertI32); | 1360 REQUIRE(I64SConvertI32); |
1328 REQUIRE(I64And); | 1361 REQUIRE(I64And); |
1329 REQUIRE(DepthFirst); | 1362 REQUIRE(DepthFirst); |
1330 TestingModule module; | 1363 TestingModule module(execution_mode); |
1331 int64_t* global = module.AddGlobal<int64_t>(MachineType::Int64()); | 1364 int64_t* global = module.AddGlobal<int64_t>(MachineType::Int64()); |
1332 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1365 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1333 // global = global + p0 | 1366 // global = global + p0 |
1334 BUILD(r, B2(WASM_STORE_GLOBAL( | 1367 BUILD(r, B2(WASM_STORE_GLOBAL( |
1335 0, WASM_I64_AND(WASM_LOAD_GLOBAL(0), | 1368 0, WASM_I64_AND(WASM_LOAD_GLOBAL(0), |
1336 WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)))), | 1369 WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)))), |
1337 WASM_ZERO)); | 1370 WASM_ZERO)); |
1338 | 1371 |
1339 *global = 0xFFFFFFFFFFFFFFFFLL; | 1372 *global = 0xFFFFFFFFFFFFFFFFLL; |
1340 for (int i = 9; i < 444444; i += 111111) { | 1373 for (int i = 9; i < 444444; i += 111111) { |
1341 int64_t expected = *global & i; | 1374 int64_t expected = *global & i; |
1342 r.Call(i); | 1375 r.Call(i); |
1343 CHECK_EQ(expected, *global); | 1376 CHECK_EQ(expected, *global); |
1344 } | 1377 } |
1345 } | 1378 } |
1346 | 1379 |
1347 WASM_EXEC_TEST(I64Eqz) { | 1380 WASM_EXEC_TEST(I64Eqz) { |
1348 REQUIRE(I64Eq); | 1381 REQUIRE(I64Eq); |
1349 | 1382 |
1350 WasmRunner<int32_t> r(MachineType::Int64()); | 1383 WasmRunner<int32_t> r(execution_mode, MachineType::Int64()); |
1351 BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0))); | 1384 BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0))); |
1352 | 1385 |
1353 FOR_INT64_INPUTS(i) { | 1386 FOR_INT64_INPUTS(i) { |
1354 int32_t result = *i == 0 ? 1 : 0; | 1387 int32_t result = *i == 0 ? 1 : 0; |
1355 CHECK_EQ(result, r.Call(*i)); | 1388 CHECK_EQ(result, r.Call(*i)); |
1356 } | 1389 } |
1357 } | 1390 } |
1358 | 1391 |
1359 WASM_EXEC_TEST(I64Ror) { | 1392 WASM_EXEC_TEST(I64Ror) { |
1360 REQUIRE(I64Ror); | 1393 REQUIRE(I64Ror); |
1361 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 1394 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 1395 MachineType::Int64()); |
1362 BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 1396 BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
1363 | 1397 |
1364 FOR_UINT64_INPUTS(i) { | 1398 FOR_UINT64_INPUTS(i) { |
1365 FOR_UINT64_INPUTS(j) { | 1399 FOR_UINT64_INPUTS(j) { |
1366 int64_t expected = bits::RotateRight64(*i, *j & 0x3f); | 1400 int64_t expected = bits::RotateRight64(*i, *j & 0x3f); |
1367 CHECK_EQ(expected, r.Call(*i, *j)); | 1401 CHECK_EQ(expected, r.Call(*i, *j)); |
1368 } | 1402 } |
1369 } | 1403 } |
1370 } | 1404 } |
1371 | 1405 |
1372 WASM_EXEC_TEST(I64Rol) { | 1406 WASM_EXEC_TEST(I64Rol) { |
1373 REQUIRE(I64Rol); | 1407 REQUIRE(I64Rol); |
1374 WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64()); | 1408 WasmRunner<int64_t> r(execution_mode, MachineType::Int64(), |
| 1409 MachineType::Int64()); |
1375 BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 1410 BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
1376 | 1411 |
1377 FOR_UINT64_INPUTS(i) { | 1412 FOR_UINT64_INPUTS(i) { |
1378 FOR_UINT64_INPUTS(j) { | 1413 FOR_UINT64_INPUTS(j) { |
1379 int64_t expected = bits::RotateLeft64(*i, *j & 0x3f); | 1414 int64_t expected = bits::RotateLeft64(*i, *j & 0x3f); |
1380 CHECK_EQ(expected, r.Call(*i, *j)); | 1415 CHECK_EQ(expected, r.Call(*i, *j)); |
1381 } | 1416 } |
1382 } | 1417 } |
1383 } | 1418 } |
OLD | NEW |