OLD | NEW |
(Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "test/unittests/test-utils.h" |
| 6 |
| 7 #include "src/v8.h" |
| 8 |
| 9 #include "test/cctest/wasm/test-signatures.h" |
| 10 |
| 11 #include "src/objects.h" |
| 12 |
| 13 #include "src/wasm/ast-decoder.h" |
| 14 #include "src/wasm/wasm-macro-gen.h" |
| 15 #include "src/wasm/wasm-module.h" |
| 16 |
| 17 namespace v8 { |
| 18 namespace internal { |
| 19 namespace wasm { |
| 20 |
| 21 static const byte kCodeGetLocal0[] = {kExprGetLocal, 0}; |
| 22 static const byte kCodeGetLocal1[] = {kExprGetLocal, 1}; |
| 23 static const byte kCodeSetLocal0[] = {kExprSetLocal, 0, kExprI8Const, 0}; |
| 24 |
| 25 static const LocalType kLocalTypes[] = {kAstI32, kAstI64, kAstF32, kAstF64}; |
| 26 static const MachineType machineTypes[] = { |
| 27 MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(), |
| 28 MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(), |
| 29 MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(), |
| 30 MachineType::Float64()}; |
| 31 |
| 32 static const WasmOpcode kInt32BinopOpcodes[] = { |
| 33 kExprI32Add, kExprI32Sub, kExprI32Mul, kExprI32DivS, kExprI32DivU, |
| 34 kExprI32RemS, kExprI32RemU, kExprI32And, kExprI32Ior, kExprI32Xor, |
| 35 kExprI32Shl, kExprI32ShrU, kExprI32ShrS, kExprI32Eq, kExprI32LtS, |
| 36 kExprI32LeS, kExprI32LtU, kExprI32LeU}; |
| 37 |
| 38 |
| 39 #define EXPECT_VERIFIES(env, x) Verify(kSuccess, env, x, x + arraysize(x)) |
| 40 |
| 41 #define EXPECT_FAILURE(env, x) Verify(kError, env, x, x + arraysize(x)) |
| 42 |
| 43 #define EXPECT_VERIFIES_INLINE(env, ...) \ |
| 44 do { \ |
| 45 static byte code[] = {__VA_ARGS__}; \ |
| 46 Verify(kSuccess, env, code, code + arraysize(code)); \ |
| 47 } while (false) |
| 48 |
| 49 |
| 50 #define EXPECT_FAILURE_INLINE(env, ...) \ |
| 51 do { \ |
| 52 static byte code[] = {__VA_ARGS__}; \ |
| 53 Verify(kError, env, code, code + arraysize(code)); \ |
| 54 } while (false) |
| 55 |
| 56 #define VERIFY(...) \ |
| 57 do { \ |
| 58 static const byte code[] = {__VA_ARGS__}; \ |
| 59 Verify(kSuccess, &env_v_i, code, code + sizeof(code)); \ |
| 60 } while (false) |
| 61 |
| 62 |
| 63 class WasmDecoderTest : public TestWithZone { |
| 64 public: |
| 65 WasmDecoderTest() : TestWithZone(), sigs() { |
| 66 init_env(&env_i_i, sigs.i_i()); |
| 67 init_env(&env_v_v, sigs.v_v()); |
| 68 init_env(&env_v_i, sigs.v_i()); |
| 69 init_env(&env_i_f, sigs.i_f()); |
| 70 init_env(&env_i_d, sigs.i_d()); |
| 71 init_env(&env_l_l, sigs.l_l()); |
| 72 init_env(&env_f_ff, sigs.f_ff()); |
| 73 init_env(&env_d_dd, sigs.d_dd()); |
| 74 } |
| 75 |
| 76 TestSignatures sigs; |
| 77 |
| 78 FunctionEnv env_i_i; |
| 79 FunctionEnv env_v_v; |
| 80 FunctionEnv env_v_i; |
| 81 FunctionEnv env_i_f; |
| 82 FunctionEnv env_i_d; |
| 83 FunctionEnv env_l_l; |
| 84 FunctionEnv env_f_ff; |
| 85 FunctionEnv env_d_dd; |
| 86 |
| 87 static void init_env(FunctionEnv* env, FunctionSig* sig) { |
| 88 env->module = nullptr; |
| 89 env->sig = sig; |
| 90 env->local_int32_count = 0; |
| 91 env->local_int64_count = 0; |
| 92 env->local_float32_count = 0; |
| 93 env->local_float64_count = 0; |
| 94 env->SumLocals(); |
| 95 } |
| 96 |
| 97 // A wrapper around VerifyWasmCode() that renders a nice failure message. |
| 98 void Verify(ErrorCode expected, FunctionEnv* env, const byte* start, |
| 99 const byte* end) { |
| 100 TreeResult result = VerifyWasmCode(env, start, end); |
| 101 if (result.error_code != expected) { |
| 102 ptrdiff_t pc = result.error_pc - result.start; |
| 103 ptrdiff_t pt = result.error_pt - result.start; |
| 104 std::ostringstream str; |
| 105 if (expected == kSuccess) { |
| 106 str << "Verification failed: " << result.error_code << " pc = +" << pc; |
| 107 if (result.error_pt) str << ", pt = +" << pt; |
| 108 str << ", msg = " << result.error_msg.get(); |
| 109 } else { |
| 110 str << "Verification expected: " << expected << ", but got " |
| 111 << result.error_code; |
| 112 if (result.error_code != kSuccess) { |
| 113 str << " pc = +" << pc; |
| 114 if (result.error_pt) str << ", pt = +" << pt; |
| 115 } |
| 116 } |
| 117 FATAL(str.str().c_str()); |
| 118 } |
| 119 } |
| 120 |
| 121 void TestBinop(WasmOpcode opcode, FunctionSig* success) { |
| 122 // op(local[0], local[1]) |
| 123 byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0, kExprGetLocal, |
| 124 1}; |
| 125 FunctionEnv env; |
| 126 init_env(&env, success); |
| 127 EXPECT_VERIFIES(&env, code); |
| 128 |
| 129 // Try all combinations of return and parameter types. |
| 130 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 131 for (size_t j = 0; j < arraysize(kLocalTypes); j++) { |
| 132 for (size_t k = 0; k < arraysize(kLocalTypes); k++) { |
| 133 LocalType types[] = {kLocalTypes[i], kLocalTypes[j], kLocalTypes[k]}; |
| 134 if (types[0] != success->GetReturn(0) || |
| 135 types[1] != success->GetParam(0) || |
| 136 types[2] != success->GetParam(1)) { |
| 137 // Test signature mismatch. |
| 138 FunctionSig sig(1, 2, types); |
| 139 init_env(&env, &sig); |
| 140 EXPECT_FAILURE(&env, code); |
| 141 } |
| 142 } |
| 143 } |
| 144 } |
| 145 } |
| 146 |
| 147 void TestUnop(WasmOpcode opcode, FunctionSig* success) { |
| 148 TestUnop(opcode, success->GetReturn(), success->GetParam(0)); |
| 149 } |
| 150 |
| 151 void TestUnop(WasmOpcode opcode, LocalType ret_type, LocalType param_type) { |
| 152 // Return(op(local[0])) |
| 153 byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0}; |
| 154 FunctionEnv env; |
| 155 { |
| 156 LocalType types[] = {ret_type, param_type}; |
| 157 FunctionSig sig(1, 1, types); |
| 158 init_env(&env, &sig); |
| 159 EXPECT_VERIFIES(&env, code); |
| 160 } |
| 161 |
| 162 // Try all combinations of return and parameter types. |
| 163 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 164 for (size_t j = 0; j < arraysize(kLocalTypes); j++) { |
| 165 LocalType types[] = {kLocalTypes[i], kLocalTypes[j]}; |
| 166 if (types[0] != ret_type || types[1] != param_type) { |
| 167 // Test signature mismatch. |
| 168 FunctionSig sig(1, 1, types); |
| 169 init_env(&env, &sig); |
| 170 EXPECT_FAILURE(&env, code); |
| 171 } |
| 172 } |
| 173 } |
| 174 } |
| 175 }; |
| 176 |
| 177 |
| 178 static FunctionEnv CreateInt32FunctionEnv(FunctionSig* sig, int count) { |
| 179 FunctionEnv env; |
| 180 env.module = nullptr; |
| 181 env.sig = sig; |
| 182 env.local_int32_count = count; |
| 183 env.local_float64_count = 0; |
| 184 env.local_float32_count = 0; |
| 185 env.total_locals = static_cast<unsigned>(count + sig->parameter_count()); |
| 186 return env; |
| 187 } |
| 188 |
| 189 |
| 190 TEST_F(WasmDecoderTest, Int8Const) { |
| 191 byte code[] = {kExprI8Const, 0}; |
| 192 for (int i = -128; i < 128; i++) { |
| 193 code[1] = static_cast<byte>(i); |
| 194 EXPECT_VERIFIES(&env_i_i, code); |
| 195 } |
| 196 } |
| 197 |
| 198 |
| 199 TEST_F(WasmDecoderTest, EmptyFunction) { |
| 200 byte code[] = {0}; |
| 201 Verify(kSuccess, &env_v_v, code, code); |
| 202 Verify(kError, &env_i_i, code, code); |
| 203 } |
| 204 |
| 205 |
| 206 TEST_F(WasmDecoderTest, IncompleteIf1) { |
| 207 byte code[] = {kExprIf}; |
| 208 EXPECT_FAILURE(&env_v_v, code); |
| 209 EXPECT_FAILURE(&env_i_i, code); |
| 210 } |
| 211 |
| 212 |
| 213 TEST_F(WasmDecoderTest, IncompleteIf2) { |
| 214 byte code[] = {kExprIf, kExprI8Const, 0}; |
| 215 EXPECT_FAILURE(&env_v_v, code); |
| 216 EXPECT_FAILURE(&env_i_i, code); |
| 217 } |
| 218 |
| 219 |
| 220 TEST_F(WasmDecoderTest, Int8Const_fallthru) { |
| 221 byte code[] = {kExprI8Const, 0, kExprI8Const, 1}; |
| 222 EXPECT_VERIFIES(&env_i_i, code); |
| 223 } |
| 224 |
| 225 |
| 226 TEST_F(WasmDecoderTest, Int32Const) { |
| 227 byte code[] = {kExprI32Const, 0, 0, 0, 0}; |
| 228 int32_t* ptr = reinterpret_cast<int32_t*>(code + 1); |
| 229 const int kInc = 4498211; |
| 230 for (int32_t i = kMinInt; i < kMaxInt - kInc; i = i + kInc) { |
| 231 *ptr = i; |
| 232 EXPECT_VERIFIES(&env_i_i, code); |
| 233 } |
| 234 } |
| 235 |
| 236 |
| 237 TEST_F(WasmDecoderTest, Int8Const_fallthru2) { |
| 238 byte code[] = {kExprI8Const, 0, kExprI32Const, 1, 2, 3, 4}; |
| 239 EXPECT_VERIFIES(&env_i_i, code); |
| 240 } |
| 241 |
| 242 |
| 243 TEST_F(WasmDecoderTest, Int64Const) { |
| 244 byte code[] = {kExprI64Const, 0, 0, 0, 0, 0, 0, 0, 0}; |
| 245 int64_t* ptr = reinterpret_cast<int64_t*>(code + 1); |
| 246 const int kInc = 4498211; |
| 247 for (int32_t i = kMinInt; i < kMaxInt - kInc; i = i + kInc) { |
| 248 *ptr = (static_cast<int64_t>(i) << 32) | i; |
| 249 EXPECT_VERIFIES(&env_l_l, code); |
| 250 } |
| 251 } |
| 252 |
| 253 |
| 254 TEST_F(WasmDecoderTest, Float32Const) { |
| 255 byte code[] = {kExprF32Const, 0, 0, 0, 0}; |
| 256 float* ptr = reinterpret_cast<float*>(code + 1); |
| 257 for (int i = 0; i < 30; i++) { |
| 258 *ptr = i * -7.75f; |
| 259 EXPECT_VERIFIES(&env_f_ff, code); |
| 260 } |
| 261 } |
| 262 |
| 263 |
| 264 TEST_F(WasmDecoderTest, Float64Const) { |
| 265 byte code[] = {kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0}; |
| 266 double* ptr = reinterpret_cast<double*>(code + 1); |
| 267 for (int i = 0; i < 30; i++) { |
| 268 *ptr = i * 33.45; |
| 269 EXPECT_VERIFIES(&env_d_dd, code); |
| 270 } |
| 271 } |
| 272 |
| 273 |
| 274 TEST_F(WasmDecoderTest, Int32Const_off_end) { |
| 275 byte code[] = {kExprI32Const, 0xaa, 0xbb, 0xcc, 0x44}; |
| 276 |
| 277 for (int size = 1; size <= 4; size++) { |
| 278 Verify(kError, &env_i_i, code, code + size); |
| 279 } |
| 280 } |
| 281 |
| 282 |
| 283 TEST_F(WasmDecoderTest, GetLocal0_param) { |
| 284 EXPECT_VERIFIES(&env_i_i, kCodeGetLocal0); |
| 285 } |
| 286 |
| 287 |
| 288 TEST_F(WasmDecoderTest, GetLocal0_local) { |
| 289 FunctionEnv env; |
| 290 init_env(&env, sigs.i_v()); |
| 291 env.AddLocals(kAstI32, 1); |
| 292 EXPECT_VERIFIES(&env, kCodeGetLocal0); |
| 293 } |
| 294 |
| 295 |
| 296 TEST_F(WasmDecoderTest, GetLocal0_param_n) { |
| 297 FunctionSig* array[] = {sigs.i_i(), sigs.i_ii(), sigs.i_iii()}; |
| 298 |
| 299 for (size_t i = 0; i < arraysize(array); i++) { |
| 300 FunctionEnv env = CreateInt32FunctionEnv(array[i], 0); |
| 301 EXPECT_VERIFIES(&env, kCodeGetLocal0); |
| 302 } |
| 303 } |
| 304 |
| 305 |
| 306 TEST_F(WasmDecoderTest, GetLocalN_local) { |
| 307 for (byte i = 1; i < 8; i++) { |
| 308 FunctionEnv env = CreateInt32FunctionEnv(sigs.i_v(), i); |
| 309 for (byte j = 0; j < i; j++) { |
| 310 byte code[] = {kExprGetLocal, j}; |
| 311 EXPECT_VERIFIES(&env, code); |
| 312 } |
| 313 } |
| 314 } |
| 315 |
| 316 |
| 317 TEST_F(WasmDecoderTest, GetLocal0_fail_no_params) { |
| 318 FunctionEnv env = CreateInt32FunctionEnv(sigs.i_v(), 0); |
| 319 |
| 320 EXPECT_FAILURE(&env, kCodeGetLocal0); |
| 321 } |
| 322 |
| 323 |
| 324 TEST_F(WasmDecoderTest, GetLocal1_fail_no_locals) { |
| 325 EXPECT_FAILURE(&env_i_i, kCodeGetLocal1); |
| 326 } |
| 327 |
| 328 |
| 329 TEST_F(WasmDecoderTest, GetLocal_off_end) { |
| 330 static const byte code[] = {kExprGetLocal}; |
| 331 EXPECT_FAILURE(&env_i_i, code); |
| 332 } |
| 333 |
| 334 |
| 335 TEST_F(WasmDecoderTest, GetLocal_varint) { |
| 336 env_i_i.local_int32_count = 1000000000; |
| 337 env_i_i.total_locals += 1000000000; |
| 338 |
| 339 { |
| 340 static const byte code[] = {kExprGetLocal, 0xFF, 0x01}; |
| 341 EXPECT_VERIFIES(&env_i_i, code); |
| 342 EXPECT_FAILURE(&env_i_f, code); |
| 343 } |
| 344 |
| 345 { |
| 346 static const byte code[] = {kExprGetLocal, 0xF0, 0x80, 0x01}; |
| 347 EXPECT_VERIFIES(&env_i_i, code); |
| 348 EXPECT_FAILURE(&env_i_f, code); |
| 349 } |
| 350 |
| 351 { |
| 352 static const byte code[] = {kExprGetLocal, 0xF2, 0x81, 0x82, 0x01}; |
| 353 EXPECT_VERIFIES(&env_i_i, code); |
| 354 EXPECT_FAILURE(&env_i_f, code); |
| 355 } |
| 356 |
| 357 { |
| 358 static const byte code[] = {kExprGetLocal, 0xF3, 0xA1, 0xB1, 0xC1, 0x01}; |
| 359 EXPECT_VERIFIES(&env_i_i, code); |
| 360 EXPECT_FAILURE(&env_i_f, code); |
| 361 } |
| 362 } |
| 363 |
| 364 |
| 365 TEST_F(WasmDecoderTest, Binops_off_end) { |
| 366 byte code1[] = {0}; // [opcode] |
| 367 for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| 368 code1[0] = kInt32BinopOpcodes[i]; |
| 369 EXPECT_FAILURE(&env_i_i, code1); |
| 370 } |
| 371 |
| 372 byte code3[] = {0, kExprGetLocal, 0}; // [opcode] [expr] |
| 373 for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| 374 code3[0] = kInt32BinopOpcodes[i]; |
| 375 EXPECT_FAILURE(&env_i_i, code3); |
| 376 } |
| 377 |
| 378 byte code4[] = {0, kExprGetLocal, 0, 0}; // [opcode] [expr] [opcode] |
| 379 for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| 380 code4[0] = kInt32BinopOpcodes[i]; |
| 381 code4[3] = kInt32BinopOpcodes[i]; |
| 382 EXPECT_FAILURE(&env_i_i, code4); |
| 383 } |
| 384 } |
| 385 |
| 386 |
| 387 //=================================================================== |
| 388 //== Statements |
| 389 //=================================================================== |
| 390 TEST_F(WasmDecoderTest, Nop) { |
| 391 static const byte code[] = {kExprNop}; |
| 392 EXPECT_VERIFIES(&env_v_v, code); |
| 393 } |
| 394 |
| 395 |
| 396 TEST_F(WasmDecoderTest, SetLocal0_param) { |
| 397 static const byte code[] = {kExprSetLocal, 0, kExprI8Const, 0}; |
| 398 EXPECT_VERIFIES(&env_i_i, code); |
| 399 } |
| 400 |
| 401 |
| 402 TEST_F(WasmDecoderTest, SetLocal0_local) { |
| 403 byte code[] = {kExprSetLocal, 0, kExprI8Const, 0}; |
| 404 FunctionEnv env = CreateInt32FunctionEnv(sigs.i_v(), 1); |
| 405 |
| 406 EXPECT_VERIFIES(&env, code); |
| 407 } |
| 408 |
| 409 |
| 410 TEST_F(WasmDecoderTest, SetLocalN_local) { |
| 411 for (byte i = 1; i < 8; i++) { |
| 412 FunctionEnv env = CreateInt32FunctionEnv(sigs.i_v(), i); |
| 413 for (byte j = 0; j < i; j++) { |
| 414 byte code[] = {kExprSetLocal, j, kExprI8Const, i}; |
| 415 EXPECT_VERIFIES(&env, code); |
| 416 } |
| 417 } |
| 418 } |
| 419 |
| 420 |
| 421 TEST_F(WasmDecoderTest, Block0) { |
| 422 static const byte code[] = {kExprBlock, 0}; |
| 423 EXPECT_VERIFIES(&env_v_v, code); |
| 424 } |
| 425 |
| 426 |
| 427 TEST_F(WasmDecoderTest, Block0_fallthru1) { |
| 428 static const byte code[] = {kExprBlock, 0, kExprBlock, 0}; |
| 429 EXPECT_VERIFIES(&env_v_v, code); |
| 430 } |
| 431 |
| 432 |
| 433 TEST_F(WasmDecoderTest, Block1) { |
| 434 static const byte code[] = {kExprBlock, 1, kExprSetLocal, 0, kExprI8Const, 0}; |
| 435 EXPECT_VERIFIES(&env_i_i, code); |
| 436 } |
| 437 |
| 438 |
| 439 TEST_F(WasmDecoderTest, Block0_fallthru2) { |
| 440 static const byte code[] = {kExprBlock, 0, kExprSetLocal, 0, kExprI8Const, 0}; |
| 441 EXPECT_VERIFIES(&env_i_i, code); |
| 442 } |
| 443 |
| 444 |
| 445 TEST_F(WasmDecoderTest, Block2) { |
| 446 static const byte code[] = {kExprBlock, 2, // -- |
| 447 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 448 kExprSetLocal, 0, kExprI8Const, 0}; // -- |
| 449 EXPECT_VERIFIES(&env_i_i, code); |
| 450 } |
| 451 |
| 452 |
| 453 TEST_F(WasmDecoderTest, Block2_fallthru) { |
| 454 static const byte code[] = {kExprBlock, 2, // -- |
| 455 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 456 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 457 kExprI8Const, 11}; // -- |
| 458 EXPECT_VERIFIES(&env_i_i, code); |
| 459 } |
| 460 |
| 461 |
| 462 TEST_F(WasmDecoderTest, BlockN) { |
| 463 byte block[] = {kExprBlock, 2}; |
| 464 |
| 465 for (size_t i = 0; i < 10; i++) { |
| 466 size_t total = sizeof(block) + sizeof(kCodeSetLocal0) * i; |
| 467 byte* code = reinterpret_cast<byte*>(malloc(total)); |
| 468 memcpy(code, block, sizeof(block)); |
| 469 code[1] = static_cast<byte>(i); |
| 470 for (size_t j = 0; j < i; j++) { |
| 471 memcpy(code + sizeof(block) + j * sizeof(kCodeSetLocal0), kCodeSetLocal0, |
| 472 sizeof(kCodeSetLocal0)); |
| 473 } |
| 474 Verify(kSuccess, &env_v_i, code, code + total); |
| 475 free(code); |
| 476 } |
| 477 } |
| 478 |
| 479 |
| 480 TEST_F(WasmDecoderTest, BlockN_off_end) { |
| 481 for (byte i = 2; i < 10; i++) { |
| 482 byte code[] = {kExprBlock, i, kExprNop}; |
| 483 EXPECT_FAILURE(&env_v_v, code); |
| 484 } |
| 485 } |
| 486 |
| 487 |
| 488 TEST_F(WasmDecoderTest, Block1_break) { |
| 489 static const byte code[] = {kExprBlock, 1, kExprBr, 0, kExprNop}; |
| 490 EXPECT_VERIFIES(&env_v_v, code); |
| 491 } |
| 492 |
| 493 |
| 494 TEST_F(WasmDecoderTest, Block2_break) { |
| 495 static const byte code[] = {kExprBlock, 2, kExprNop, kExprBr, 0, kExprNop}; |
| 496 EXPECT_VERIFIES(&env_v_v, code); |
| 497 } |
| 498 |
| 499 |
| 500 TEST_F(WasmDecoderTest, Block1_continue) { |
| 501 static const byte code[] = {kExprBlock, 1, kExprBr, 1, kExprNop}; |
| 502 EXPECT_FAILURE(&env_v_v, code); |
| 503 } |
| 504 |
| 505 |
| 506 TEST_F(WasmDecoderTest, Block2_continue) { |
| 507 static const byte code[] = {kExprBlock, 2, kExprNop, kExprBr, 1, kExprNop}; |
| 508 EXPECT_FAILURE(&env_v_v, code); |
| 509 } |
| 510 |
| 511 |
| 512 TEST_F(WasmDecoderTest, ExprBlock0) { |
| 513 static const byte code[] = {kExprBlock, 0}; |
| 514 EXPECT_VERIFIES(&env_v_v, code); |
| 515 } |
| 516 |
| 517 |
| 518 TEST_F(WasmDecoderTest, ExprBlock1a) { |
| 519 static const byte code[] = {kExprBlock, 1, kExprI8Const, 0}; |
| 520 EXPECT_VERIFIES(&env_i_i, code); |
| 521 } |
| 522 |
| 523 |
| 524 TEST_F(WasmDecoderTest, ExprBlock1b) { |
| 525 static const byte code[] = {kExprBlock, 1, kExprI8Const, 0}; |
| 526 EXPECT_FAILURE(&env_f_ff, code); |
| 527 } |
| 528 |
| 529 |
| 530 TEST_F(WasmDecoderTest, ExprBlock1c) { |
| 531 static const byte code[] = {kExprBlock, 1, kExprF32Const, 0, 0, 0, 0}; |
| 532 EXPECT_VERIFIES(&env_f_ff, code); |
| 533 } |
| 534 |
| 535 |
| 536 TEST_F(WasmDecoderTest, IfEmpty) { |
| 537 static const byte code[] = {kExprIf, kExprGetLocal, 0, kExprNop}; |
| 538 EXPECT_VERIFIES(&env_v_i, code); |
| 539 } |
| 540 |
| 541 |
| 542 TEST_F(WasmDecoderTest, IfSet) { |
| 543 static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprSetLocal, |
| 544 0, kExprI8Const, 0, kExprNop}; |
| 545 EXPECT_VERIFIES(&env_v_i, code); |
| 546 } |
| 547 |
| 548 |
| 549 TEST_F(WasmDecoderTest, IfBlock1) { |
| 550 static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprBlock, |
| 551 1, kExprSetLocal, 0, kExprI8Const, |
| 552 0, kExprNop}; |
| 553 EXPECT_VERIFIES(&env_v_i, code); |
| 554 } |
| 555 |
| 556 |
| 557 TEST_F(WasmDecoderTest, IfBlock2) { |
| 558 static const byte code[] = {kExprIf, kExprGetLocal, 0, kExprBlock, |
| 559 2, kExprSetLocal, 0, kExprI8Const, |
| 560 0, kExprSetLocal, 0, kExprI8Const, |
| 561 0}; |
| 562 EXPECT_VERIFIES(&env_v_i, code); |
| 563 } |
| 564 |
| 565 |
| 566 TEST_F(WasmDecoderTest, IfElseEmpty) { |
| 567 static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprNop, |
| 568 kExprNop}; |
| 569 EXPECT_VERIFIES(&env_v_i, code); |
| 570 } |
| 571 |
| 572 |
| 573 TEST_F(WasmDecoderTest, IfElseSet) { |
| 574 static const byte code[] = {kExprIfElse, |
| 575 kExprGetLocal, |
| 576 0, // -- |
| 577 kExprSetLocal, |
| 578 0, |
| 579 kExprI8Const, |
| 580 0, // -- |
| 581 kExprSetLocal, |
| 582 0, |
| 583 kExprI8Const, |
| 584 1}; // -- |
| 585 EXPECT_VERIFIES(&env_v_i, code); |
| 586 } |
| 587 |
| 588 |
| 589 TEST_F(WasmDecoderTest, IfElseUnreachable) { |
| 590 static const byte code[] = {kExprIfElse, kExprI8Const, 0, |
| 591 kExprUnreachable, kExprGetLocal, 0}; |
| 592 |
| 593 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 594 LocalType types[] = {kAstI32, kLocalTypes[i]}; |
| 595 FunctionEnv env; |
| 596 FunctionSig sig(1, 1, types); |
| 597 init_env(&env, &sig); |
| 598 |
| 599 if (kLocalTypes[i] == kAstI32) { |
| 600 EXPECT_VERIFIES(&env, code); |
| 601 } else { |
| 602 EXPECT_FAILURE(&env, code); |
| 603 } |
| 604 } |
| 605 } |
| 606 |
| 607 |
| 608 TEST_F(WasmDecoderTest, Loop0) { |
| 609 static const byte code[] = {kExprLoop, 0}; |
| 610 EXPECT_VERIFIES(&env_v_v, code); |
| 611 } |
| 612 |
| 613 |
| 614 TEST_F(WasmDecoderTest, Loop1) { |
| 615 static const byte code[] = {kExprLoop, 1, kExprSetLocal, 0, kExprI8Const, 0}; |
| 616 EXPECT_VERIFIES(&env_v_i, code); |
| 617 } |
| 618 |
| 619 |
| 620 TEST_F(WasmDecoderTest, Loop2) { |
| 621 static const byte code[] = {kExprLoop, 2, // -- |
| 622 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 623 kExprSetLocal, 0, kExprI8Const, 0}; // -- |
| 624 EXPECT_VERIFIES(&env_v_i, code); |
| 625 } |
| 626 |
| 627 |
| 628 TEST_F(WasmDecoderTest, Loop1_continue) { |
| 629 static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprNop}; |
| 630 EXPECT_VERIFIES(&env_v_v, code); |
| 631 } |
| 632 |
| 633 |
| 634 TEST_F(WasmDecoderTest, Loop1_break) { |
| 635 static const byte code[] = {kExprLoop, 1, kExprBr, 1, kExprNop}; |
| 636 EXPECT_VERIFIES(&env_v_v, code); |
| 637 } |
| 638 |
| 639 |
| 640 TEST_F(WasmDecoderTest, Loop2_continue) { |
| 641 static const byte code[] = {kExprLoop, 2, // -- |
| 642 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 643 kExprBr, 0, kExprNop}; // -- |
| 644 EXPECT_VERIFIES(&env_v_i, code); |
| 645 } |
| 646 |
| 647 |
| 648 TEST_F(WasmDecoderTest, Loop2_break) { |
| 649 static const byte code[] = {kExprLoop, 2, // -- |
| 650 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 651 kExprBr, 1, kExprNop}; // -- |
| 652 EXPECT_VERIFIES(&env_v_i, code); |
| 653 } |
| 654 |
| 655 |
| 656 TEST_F(WasmDecoderTest, ExprLoop0) { |
| 657 static const byte code[] = {kExprLoop, 0}; |
| 658 EXPECT_VERIFIES(&env_v_v, code); |
| 659 } |
| 660 |
| 661 |
| 662 TEST_F(WasmDecoderTest, ExprLoop1a) { |
| 663 static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprI8Const, 0}; |
| 664 EXPECT_VERIFIES(&env_i_i, code); |
| 665 } |
| 666 |
| 667 |
| 668 TEST_F(WasmDecoderTest, ExprLoop1b) { |
| 669 static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprI8Const, 0}; |
| 670 EXPECT_VERIFIES(&env_i_i, code); |
| 671 } |
| 672 |
| 673 |
| 674 TEST_F(WasmDecoderTest, ExprLoop2_unreachable) { |
| 675 static const byte code[] = {kExprLoop, 2, kExprBr, 0, |
| 676 kExprI8Const, 0, kExprNop}; |
| 677 EXPECT_VERIFIES(&env_i_i, code); |
| 678 } |
| 679 |
| 680 |
| 681 TEST_F(WasmDecoderTest, ReturnVoid1) { |
| 682 static const byte code[] = {kExprNop}; |
| 683 EXPECT_VERIFIES(&env_v_v, code); |
| 684 EXPECT_FAILURE(&env_i_i, code); |
| 685 EXPECT_FAILURE(&env_i_f, code); |
| 686 } |
| 687 |
| 688 |
| 689 TEST_F(WasmDecoderTest, ReturnVoid2) { |
| 690 static const byte code[] = {kExprBlock, 1, kExprBr, 0, kExprNop}; |
| 691 EXPECT_VERIFIES(&env_v_v, code); |
| 692 EXPECT_FAILURE(&env_i_i, code); |
| 693 EXPECT_FAILURE(&env_i_f, code); |
| 694 } |
| 695 |
| 696 |
| 697 TEST_F(WasmDecoderTest, ReturnVoid3) { |
| 698 EXPECT_VERIFIES_INLINE(&env_v_v, kExprI8Const, 0); |
| 699 EXPECT_VERIFIES_INLINE(&env_v_v, kExprI32Const, 0, 0, 0, 0); |
| 700 EXPECT_VERIFIES_INLINE(&env_v_v, kExprI64Const, 0, 0, 0, 0, 0, 0, 0, 0); |
| 701 EXPECT_VERIFIES_INLINE(&env_v_v, kExprF32Const, 0, 0, 0, 0); |
| 702 EXPECT_VERIFIES_INLINE(&env_v_v, kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0); |
| 703 |
| 704 EXPECT_VERIFIES_INLINE(&env_v_i, kExprGetLocal, 0); |
| 705 } |
| 706 |
| 707 |
| 708 TEST_F(WasmDecoderTest, Unreachable1) { |
| 709 EXPECT_VERIFIES_INLINE(&env_v_v, kExprUnreachable); |
| 710 EXPECT_VERIFIES_INLINE(&env_v_v, kExprUnreachable, kExprUnreachable); |
| 711 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(2, WASM_UNREACHABLE, WASM_ZERO)); |
| 712 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(2, WASM_BR(0), WASM_ZERO)); |
| 713 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(2, WASM_UNREACHABLE, WASM_ZERO)); |
| 714 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(2, WASM_BR(0), WASM_ZERO)); |
| 715 } |
| 716 |
| 717 |
| 718 TEST_F(WasmDecoderTest, Codeiness) { |
| 719 VERIFY(kExprLoop, 2, // -- |
| 720 kExprSetLocal, 0, kExprI8Const, 0, // -- |
| 721 kExprBr, 0, kExprNop); // -- |
| 722 } |
| 723 |
| 724 |
| 725 TEST_F(WasmDecoderTest, ExprIf1) { |
| 726 VERIFY(kExprIf, kExprGetLocal, 0, kExprI8Const, 0, kExprI8Const, 1); |
| 727 VERIFY(kExprIf, kExprGetLocal, 0, kExprGetLocal, 0, kExprGetLocal, 0); |
| 728 VERIFY(kExprIf, kExprGetLocal, 0, kExprI32Add, kExprGetLocal, 0, |
| 729 kExprGetLocal, 0, kExprI8Const, 1); |
| 730 } |
| 731 |
| 732 |
| 733 TEST_F(WasmDecoderTest, ExprIf_off_end) { |
| 734 static const byte kCode[] = {kExprIf, kExprGetLocal, 0, kExprGetLocal, |
| 735 0, kExprGetLocal, 0}; |
| 736 for (size_t len = 1; len < arraysize(kCode); len++) { |
| 737 Verify(kError, &env_i_i, kCode, kCode + len); |
| 738 } |
| 739 } |
| 740 |
| 741 |
| 742 TEST_F(WasmDecoderTest, ExprIf_type) { |
| 743 { |
| 744 // float|double ? 1 : 2 |
| 745 static const byte kCode[] = {kExprIfElse, kExprGetLocal, 0, kExprI8Const, |
| 746 1, kExprI8Const, 2}; |
| 747 EXPECT_FAILURE(&env_i_f, kCode); |
| 748 EXPECT_FAILURE(&env_i_d, kCode); |
| 749 } |
| 750 { |
| 751 // 1 ? float|double : 2 |
| 752 static const byte kCode[] = {kExprIfElse, kExprI8Const, 1, kExprGetLocal, |
| 753 0, kExprI8Const, 2}; |
| 754 EXPECT_FAILURE(&env_i_f, kCode); |
| 755 EXPECT_FAILURE(&env_i_d, kCode); |
| 756 } |
| 757 { |
| 758 // stmt ? 0 : 1 |
| 759 static const byte kCode[] = {kExprIfElse, kExprNop, kExprI8Const, |
| 760 0, kExprI8Const, 1}; |
| 761 EXPECT_FAILURE(&env_i_i, kCode); |
| 762 } |
| 763 { |
| 764 // 0 ? stmt : 1 |
| 765 static const byte kCode[] = {kExprIfElse, kExprI8Const, 0, |
| 766 kExprNop, kExprI8Const, 1}; |
| 767 EXPECT_FAILURE(&env_i_i, kCode); |
| 768 } |
| 769 { |
| 770 // 0 ? 1 : stmt |
| 771 static const byte kCode[] = {kExprIfElse, kExprI8Const, 0, kExprI8Const, 1, |
| 772 0, kExprBlock}; |
| 773 EXPECT_FAILURE(&env_i_i, kCode); |
| 774 } |
| 775 } |
| 776 |
| 777 |
| 778 TEST_F(WasmDecoderTest, Int64Local_param) { |
| 779 EXPECT_VERIFIES(&env_l_l, kCodeGetLocal0); |
| 780 } |
| 781 |
| 782 |
| 783 TEST_F(WasmDecoderTest, Int64Locals) { |
| 784 for (byte i = 1; i < 8; i++) { |
| 785 FunctionEnv env; |
| 786 init_env(&env, sigs.l_v()); |
| 787 env.AddLocals(kAstI64, i); |
| 788 for (byte j = 0; j < i; j++) { |
| 789 byte code[] = {kExprGetLocal, j}; |
| 790 EXPECT_VERIFIES(&env, code); |
| 791 } |
| 792 } |
| 793 } |
| 794 |
| 795 |
| 796 TEST_F(WasmDecoderTest, Int32Binops) { |
| 797 TestBinop(kExprI32Add, sigs.i_ii()); |
| 798 TestBinop(kExprI32Sub, sigs.i_ii()); |
| 799 TestBinop(kExprI32Mul, sigs.i_ii()); |
| 800 TestBinop(kExprI32DivS, sigs.i_ii()); |
| 801 TestBinop(kExprI32DivU, sigs.i_ii()); |
| 802 TestBinop(kExprI32RemS, sigs.i_ii()); |
| 803 TestBinop(kExprI32RemU, sigs.i_ii()); |
| 804 TestBinop(kExprI32And, sigs.i_ii()); |
| 805 TestBinop(kExprI32Ior, sigs.i_ii()); |
| 806 TestBinop(kExprI32Xor, sigs.i_ii()); |
| 807 TestBinop(kExprI32Shl, sigs.i_ii()); |
| 808 TestBinop(kExprI32ShrU, sigs.i_ii()); |
| 809 TestBinop(kExprI32ShrS, sigs.i_ii()); |
| 810 TestBinop(kExprI32Eq, sigs.i_ii()); |
| 811 TestBinop(kExprI32LtS, sigs.i_ii()); |
| 812 TestBinop(kExprI32LeS, sigs.i_ii()); |
| 813 TestBinop(kExprI32LtU, sigs.i_ii()); |
| 814 TestBinop(kExprI32LeU, sigs.i_ii()); |
| 815 } |
| 816 |
| 817 |
| 818 TEST_F(WasmDecoderTest, DoubleBinops) { |
| 819 TestBinop(kExprF64Add, sigs.d_dd()); |
| 820 TestBinop(kExprF64Sub, sigs.d_dd()); |
| 821 TestBinop(kExprF64Mul, sigs.d_dd()); |
| 822 TestBinop(kExprF64Div, sigs.d_dd()); |
| 823 |
| 824 TestBinop(kExprF64Eq, sigs.i_dd()); |
| 825 TestBinop(kExprF64Lt, sigs.i_dd()); |
| 826 TestBinop(kExprF64Le, sigs.i_dd()); |
| 827 } |
| 828 |
| 829 |
| 830 TEST_F(WasmDecoderTest, FloatBinops) { |
| 831 TestBinop(kExprF32Add, sigs.f_ff()); |
| 832 TestBinop(kExprF32Sub, sigs.f_ff()); |
| 833 TestBinop(kExprF32Mul, sigs.f_ff()); |
| 834 TestBinop(kExprF32Div, sigs.f_ff()); |
| 835 |
| 836 TestBinop(kExprF32Eq, sigs.i_ff()); |
| 837 TestBinop(kExprF32Lt, sigs.i_ff()); |
| 838 TestBinop(kExprF32Le, sigs.i_ff()); |
| 839 } |
| 840 |
| 841 |
| 842 TEST_F(WasmDecoderTest, TypeConversions) { |
| 843 TestUnop(kExprI32SConvertF32, kAstI32, kAstF32); |
| 844 TestUnop(kExprI32SConvertF64, kAstI32, kAstF64); |
| 845 TestUnop(kExprI32UConvertF32, kAstI32, kAstF32); |
| 846 TestUnop(kExprI32UConvertF64, kAstI32, kAstF64); |
| 847 TestUnop(kExprF64SConvertI32, kAstF64, kAstI32); |
| 848 TestUnop(kExprF64UConvertI32, kAstF64, kAstI32); |
| 849 TestUnop(kExprF64ConvertF32, kAstF64, kAstF32); |
| 850 TestUnop(kExprF32SConvertI32, kAstF32, kAstI32); |
| 851 TestUnop(kExprF32UConvertI32, kAstF32, kAstI32); |
| 852 TestUnop(kExprF32ConvertF64, kAstF32, kAstF64); |
| 853 } |
| 854 |
| 855 |
| 856 TEST_F(WasmDecoderTest, MacrosStmt) { |
| 857 VERIFY(WASM_SET_LOCAL(0, WASM_I32(87348))); |
| 858 VERIFY(WASM_STORE_MEM(MachineType::Int32(), WASM_I8(24), WASM_I8(40))); |
| 859 VERIFY(WASM_IF(WASM_GET_LOCAL(0), WASM_NOP)); |
| 860 VERIFY(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP)); |
| 861 VERIFY(WASM_NOP); |
| 862 VERIFY(WASM_BLOCK(1, WASM_NOP)); |
| 863 VERIFY(WASM_LOOP(1, WASM_NOP)); |
| 864 VERIFY(WASM_LOOP(1, WASM_BREAK(0))); |
| 865 VERIFY(WASM_LOOP(1, WASM_CONTINUE(0))); |
| 866 } |
| 867 |
| 868 |
| 869 TEST_F(WasmDecoderTest, MacrosBreak) { |
| 870 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BREAK(0))); |
| 871 |
| 872 EXPECT_VERIFIES_INLINE(&env_i_i, WASM_LOOP(1, WASM_BREAKV(0, WASM_ZERO))); |
| 873 EXPECT_VERIFIES_INLINE(&env_l_l, WASM_LOOP(1, WASM_BREAKV(0, WASM_I64(0)))); |
| 874 EXPECT_VERIFIES_INLINE(&env_f_ff, |
| 875 WASM_LOOP(1, WASM_BREAKV(0, WASM_F32(0.0)))); |
| 876 EXPECT_VERIFIES_INLINE(&env_d_dd, |
| 877 WASM_LOOP(1, WASM_BREAKV(0, WASM_F64(0.0)))); |
| 878 } |
| 879 |
| 880 |
| 881 TEST_F(WasmDecoderTest, MacrosContinue) { |
| 882 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_CONTINUE(0))); |
| 883 } |
| 884 |
| 885 |
| 886 TEST_F(WasmDecoderTest, MacrosVariadic) { |
| 887 VERIFY(WASM_BLOCK(2, WASM_NOP, WASM_NOP)); |
| 888 VERIFY(WASM_BLOCK(3, WASM_NOP, WASM_NOP, WASM_NOP)); |
| 889 VERIFY(WASM_LOOP(2, WASM_NOP, WASM_NOP)); |
| 890 VERIFY(WASM_LOOP(3, WASM_NOP, WASM_NOP, WASM_NOP)); |
| 891 } |
| 892 |
| 893 |
| 894 TEST_F(WasmDecoderTest, MacrosNestedBlocks) { |
| 895 VERIFY(WASM_BLOCK(2, WASM_NOP, WASM_BLOCK(2, WASM_NOP, WASM_NOP))); |
| 896 VERIFY(WASM_BLOCK(3, WASM_NOP, // -- |
| 897 WASM_BLOCK(2, WASM_NOP, WASM_NOP), // -- |
| 898 WASM_BLOCK(2, WASM_NOP, WASM_NOP))); // -- |
| 899 VERIFY(WASM_BLOCK(1, WASM_BLOCK(1, WASM_BLOCK(2, WASM_NOP, WASM_NOP)))); |
| 900 } |
| 901 |
| 902 |
| 903 TEST_F(WasmDecoderTest, MultipleReturn) { |
| 904 static LocalType kIntTypes5[] = {kAstI32, kAstI32, kAstI32, kAstI32, kAstI32}; |
| 905 FunctionSig sig_ii_v(2, 0, kIntTypes5); |
| 906 FunctionEnv env_ii_v; |
| 907 init_env(&env_ii_v, &sig_ii_v); |
| 908 EXPECT_VERIFIES_INLINE(&env_ii_v, WASM_RETURN(WASM_ZERO, WASM_ONE)); |
| 909 EXPECT_FAILURE_INLINE(&env_ii_v, WASM_RETURN(WASM_ZERO)); |
| 910 |
| 911 FunctionSig sig_iii_v(3, 0, kIntTypes5); |
| 912 FunctionEnv env_iii_v; |
| 913 init_env(&env_iii_v, &sig_iii_v); |
| 914 EXPECT_VERIFIES_INLINE(&env_iii_v, |
| 915 WASM_RETURN(WASM_ZERO, WASM_ONE, WASM_I8(44))); |
| 916 EXPECT_FAILURE_INLINE(&env_iii_v, WASM_RETURN(WASM_ZERO, WASM_ONE)); |
| 917 } |
| 918 |
| 919 |
| 920 TEST_F(WasmDecoderTest, MultipleReturn_fallthru) { |
| 921 static LocalType kIntTypes5[] = {kAstI32, kAstI32, kAstI32, kAstI32, kAstI32}; |
| 922 FunctionSig sig_ii_v(2, 0, kIntTypes5); |
| 923 FunctionEnv env_ii_v; |
| 924 init_env(&env_ii_v, &sig_ii_v); |
| 925 |
| 926 EXPECT_VERIFIES_INLINE(&env_ii_v, WASM_ZERO, WASM_ONE); |
| 927 EXPECT_FAILURE_INLINE(&env_ii_v, WASM_ZERO); |
| 928 |
| 929 FunctionSig sig_iii_v(3, 0, kIntTypes5); |
| 930 FunctionEnv env_iii_v; |
| 931 init_env(&env_iii_v, &sig_iii_v); |
| 932 EXPECT_VERIFIES_INLINE(&env_iii_v, WASM_ZERO, WASM_ONE, WASM_I8(44)); |
| 933 EXPECT_FAILURE_INLINE(&env_iii_v, WASM_ZERO, WASM_ONE); |
| 934 } |
| 935 |
| 936 |
| 937 TEST_F(WasmDecoderTest, MacrosInt32) { |
| 938 VERIFY(WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_I8(12))); |
| 939 VERIFY(WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(13))); |
| 940 VERIFY(WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_I8(14))); |
| 941 VERIFY(WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(15))); |
| 942 VERIFY(WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I8(16))); |
| 943 VERIFY(WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_I8(17))); |
| 944 VERIFY(WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_I8(18))); |
| 945 VERIFY(WASM_I32_AND(WASM_GET_LOCAL(0), WASM_I8(19))); |
| 946 VERIFY(WASM_I32_IOR(WASM_GET_LOCAL(0), WASM_I8(20))); |
| 947 VERIFY(WASM_I32_XOR(WASM_GET_LOCAL(0), WASM_I8(21))); |
| 948 VERIFY(WASM_I32_SHL(WASM_GET_LOCAL(0), WASM_I8(22))); |
| 949 VERIFY(WASM_I32_SHR(WASM_GET_LOCAL(0), WASM_I8(23))); |
| 950 VERIFY(WASM_I32_SAR(WASM_GET_LOCAL(0), WASM_I8(24))); |
| 951 VERIFY(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(25))); |
| 952 VERIFY(WASM_I32_NE(WASM_GET_LOCAL(0), WASM_I8(25))); |
| 953 |
| 954 VERIFY(WASM_I32_LTS(WASM_GET_LOCAL(0), WASM_I8(26))); |
| 955 VERIFY(WASM_I32_LES(WASM_GET_LOCAL(0), WASM_I8(27))); |
| 956 VERIFY(WASM_I32_LTU(WASM_GET_LOCAL(0), WASM_I8(28))); |
| 957 VERIFY(WASM_I32_LEU(WASM_GET_LOCAL(0), WASM_I8(29))); |
| 958 |
| 959 VERIFY(WASM_I32_GTS(WASM_GET_LOCAL(0), WASM_I8(26))); |
| 960 VERIFY(WASM_I32_GES(WASM_GET_LOCAL(0), WASM_I8(27))); |
| 961 VERIFY(WASM_I32_GTU(WASM_GET_LOCAL(0), WASM_I8(28))); |
| 962 VERIFY(WASM_I32_GEU(WASM_GET_LOCAL(0), WASM_I8(29))); |
| 963 } |
| 964 |
| 965 |
| 966 TEST_F(WasmDecoderTest, MacrosInt64) { |
| 967 FunctionEnv env_i_ll; |
| 968 FunctionEnv env_l_ll; |
| 969 init_env(&env_i_ll, sigs.i_ll()); |
| 970 init_env(&env_l_ll, sigs.l_ll()); |
| 971 |
| 972 #define VERIFY_L_LL(...) EXPECT_VERIFIES_INLINE(&env_l_ll, __VA_ARGS__) |
| 973 #define VERIFY_I_LL(...) EXPECT_VERIFIES_INLINE(&env_i_ll, __VA_ARGS__) |
| 974 |
| 975 VERIFY_L_LL(WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_I64(12))); |
| 976 VERIFY_L_LL(WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_I64(13))); |
| 977 VERIFY_L_LL(WASM_I64_MUL(WASM_GET_LOCAL(0), WASM_I64(14))); |
| 978 VERIFY_L_LL(WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64(15))); |
| 979 VERIFY_L_LL(WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64(16))); |
| 980 VERIFY_L_LL(WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_I64(17))); |
| 981 VERIFY_L_LL(WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_I64(18))); |
| 982 VERIFY_L_LL(WASM_I64_AND(WASM_GET_LOCAL(0), WASM_I64(19))); |
| 983 VERIFY_L_LL(WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_I64(20))); |
| 984 VERIFY_L_LL(WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_I64(21))); |
| 985 |
| 986 VERIFY_L_LL(WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64(22))); |
| 987 VERIFY_L_LL(WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64(23))); |
| 988 VERIFY_L_LL(WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64(24))); |
| 989 |
| 990 VERIFY_I_LL(WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_I64(26))); |
| 991 VERIFY_I_LL(WASM_I64_LES(WASM_GET_LOCAL(0), WASM_I64(27))); |
| 992 VERIFY_I_LL(WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_I64(28))); |
| 993 VERIFY_I_LL(WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_I64(29))); |
| 994 |
| 995 VERIFY_I_LL(WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_I64(26))); |
| 996 VERIFY_I_LL(WASM_I64_GES(WASM_GET_LOCAL(0), WASM_I64(27))); |
| 997 VERIFY_I_LL(WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_I64(28))); |
| 998 VERIFY_I_LL(WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_I64(29))); |
| 999 |
| 1000 VERIFY_I_LL(WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_I64(25))); |
| 1001 VERIFY_I_LL(WASM_I64_NE(WASM_GET_LOCAL(0), WASM_I64(25))); |
| 1002 } |
| 1003 |
| 1004 |
| 1005 TEST_F(WasmDecoderTest, AllSimpleExpressions) { |
| 1006 // Test all simple expressions which are described by a signature. |
| 1007 #define DECODE_TEST(name, opcode, sig) \ |
| 1008 { \ |
| 1009 FunctionSig* sig = WasmOpcodes::Signature(kExpr##name); \ |
| 1010 if (sig->parameter_count() == 1) { \ |
| 1011 TestUnop(kExpr##name, sig); \ |
| 1012 } else { \ |
| 1013 TestBinop(kExpr##name, sig); \ |
| 1014 } \ |
| 1015 } |
| 1016 |
| 1017 FOREACH_SIMPLE_OPCODE(DECODE_TEST); |
| 1018 |
| 1019 #undef DECODE_TEST |
| 1020 } |
| 1021 |
| 1022 |
| 1023 TEST_F(WasmDecoderTest, MemorySize) { |
| 1024 byte code[] = {kExprMemorySize}; |
| 1025 EXPECT_VERIFIES(&env_i_i, code); |
| 1026 EXPECT_FAILURE(&env_f_ff, code); |
| 1027 } |
| 1028 |
| 1029 |
| 1030 TEST_F(WasmDecoderTest, GrowMemory) { |
| 1031 byte code[] = {kExprGrowMemory, kExprGetLocal, 0}; |
| 1032 EXPECT_VERIFIES(&env_i_i, code); |
| 1033 EXPECT_FAILURE(&env_i_d, code); |
| 1034 } |
| 1035 |
| 1036 |
| 1037 TEST_F(WasmDecoderTest, LoadMemOffset) { |
| 1038 for (int offset = 0; offset < 128; offset += 7) { |
| 1039 byte code[] = {kExprI32LoadMem, WasmOpcodes::LoadStoreAccessOf(true), |
| 1040 static_cast<byte>(offset), kExprI8Const, 0}; |
| 1041 EXPECT_VERIFIES(&env_i_i, code); |
| 1042 } |
| 1043 } |
| 1044 |
| 1045 |
| 1046 TEST_F(WasmDecoderTest, StoreMemOffset) { |
| 1047 for (int offset = 0; offset < 128; offset += 7) { |
| 1048 byte code[] = {kExprI32StoreMem, |
| 1049 WasmOpcodes::LoadStoreAccessOf(true), |
| 1050 static_cast<byte>(offset), |
| 1051 kExprI8Const, |
| 1052 0, |
| 1053 kExprI8Const, |
| 1054 0}; |
| 1055 EXPECT_VERIFIES(&env_i_i, code); |
| 1056 } |
| 1057 } |
| 1058 |
| 1059 |
| 1060 TEST_F(WasmDecoderTest, LoadMemOffset_varint) { |
| 1061 byte code1[] = {kExprI32LoadMem, WasmOpcodes::LoadStoreAccessOf(true), 0, |
| 1062 kExprI8Const, 0}; |
| 1063 byte code2[] = {kExprI32LoadMem, |
| 1064 WasmOpcodes::LoadStoreAccessOf(true), |
| 1065 0x80, |
| 1066 1, |
| 1067 kExprI8Const, |
| 1068 0}; |
| 1069 byte code3[] = {kExprI32LoadMem, |
| 1070 WasmOpcodes::LoadStoreAccessOf(true), |
| 1071 0x81, |
| 1072 0x82, |
| 1073 5, |
| 1074 kExprI8Const, |
| 1075 0}; |
| 1076 byte code4[] = {kExprI32LoadMem, |
| 1077 WasmOpcodes::LoadStoreAccessOf(true), |
| 1078 0x83, |
| 1079 0x84, |
| 1080 0x85, |
| 1081 7, |
| 1082 kExprI8Const, |
| 1083 0}; |
| 1084 |
| 1085 EXPECT_VERIFIES(&env_i_i, code1); |
| 1086 EXPECT_VERIFIES(&env_i_i, code2); |
| 1087 EXPECT_VERIFIES(&env_i_i, code3); |
| 1088 EXPECT_VERIFIES(&env_i_i, code4); |
| 1089 } |
| 1090 |
| 1091 |
| 1092 TEST_F(WasmDecoderTest, StoreMemOffset_varint) { |
| 1093 byte code1[] = {kExprI32StoreMem, |
| 1094 WasmOpcodes::LoadStoreAccessOf(true), |
| 1095 0, |
| 1096 kExprI8Const, |
| 1097 0, |
| 1098 kExprI8Const, |
| 1099 0}; |
| 1100 byte code2[] = {kExprI32StoreMem, |
| 1101 WasmOpcodes::LoadStoreAccessOf(true), |
| 1102 0x80, |
| 1103 1, |
| 1104 kExprI8Const, |
| 1105 0, |
| 1106 kExprI8Const, |
| 1107 0}; |
| 1108 byte code3[] = {kExprI32StoreMem, |
| 1109 WasmOpcodes::LoadStoreAccessOf(true), |
| 1110 0x81, |
| 1111 0x82, |
| 1112 5, |
| 1113 kExprI8Const, |
| 1114 0, |
| 1115 kExprI8Const, |
| 1116 0}; |
| 1117 byte code4[] = {kExprI32StoreMem, |
| 1118 WasmOpcodes::LoadStoreAccessOf(true), |
| 1119 0x83, |
| 1120 0x84, |
| 1121 0x85, |
| 1122 7, |
| 1123 kExprI8Const, |
| 1124 0, |
| 1125 kExprI8Const, |
| 1126 0}; |
| 1127 |
| 1128 EXPECT_VERIFIES(&env_i_i, code1); |
| 1129 EXPECT_VERIFIES(&env_i_i, code2); |
| 1130 EXPECT_VERIFIES(&env_i_i, code3); |
| 1131 EXPECT_VERIFIES(&env_i_i, code4); |
| 1132 } |
| 1133 |
| 1134 |
| 1135 TEST_F(WasmDecoderTest, AllLoadMemCombinations) { |
| 1136 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1137 LocalType local_type = kLocalTypes[i]; |
| 1138 for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| 1139 MachineType mem_type = machineTypes[j]; |
| 1140 byte code[] = { |
| 1141 static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, false)), |
| 1142 WasmOpcodes::LoadStoreAccessOf(false), kExprI8Const, 0}; |
| 1143 FunctionEnv env; |
| 1144 FunctionSig sig(1, 0, &local_type); |
| 1145 init_env(&env, &sig); |
| 1146 if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) { |
| 1147 EXPECT_VERIFIES(&env, code); |
| 1148 } else { |
| 1149 EXPECT_FAILURE(&env, code); |
| 1150 } |
| 1151 } |
| 1152 } |
| 1153 } |
| 1154 |
| 1155 |
| 1156 TEST_F(WasmDecoderTest, AllStoreMemCombinations) { |
| 1157 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1158 LocalType local_type = kLocalTypes[i]; |
| 1159 for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| 1160 MachineType mem_type = machineTypes[j]; |
| 1161 byte code[] = { |
| 1162 static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, true)), |
| 1163 WasmOpcodes::LoadStoreAccessOf(false), |
| 1164 kExprI8Const, |
| 1165 0, |
| 1166 kExprGetLocal, |
| 1167 0}; |
| 1168 FunctionEnv env; |
| 1169 FunctionSig sig(0, 1, &local_type); |
| 1170 init_env(&env, &sig); |
| 1171 if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) { |
| 1172 EXPECT_VERIFIES(&env, code); |
| 1173 } else { |
| 1174 EXPECT_FAILURE(&env, code); |
| 1175 } |
| 1176 } |
| 1177 } |
| 1178 } |
| 1179 |
| 1180 |
| 1181 namespace { |
| 1182 // A helper for tests that require a module environment for functions and |
| 1183 // globals. |
| 1184 class TestModuleEnv : public ModuleEnv { |
| 1185 public: |
| 1186 TestModuleEnv() { |
| 1187 mem_start = 0; |
| 1188 mem_end = 0; |
| 1189 module = &mod; |
| 1190 linker = nullptr; |
| 1191 function_code = nullptr; |
| 1192 mod.globals = &globals; |
| 1193 mod.signatures = &signatures; |
| 1194 mod.functions = &functions; |
| 1195 } |
| 1196 byte AddGlobal(MachineType mem_type) { |
| 1197 globals.push_back({0, mem_type, 0, false}); |
| 1198 CHECK(globals.size() <= 127); |
| 1199 return static_cast<byte>(globals.size() - 1); |
| 1200 } |
| 1201 byte AddSignature(FunctionSig* sig) { |
| 1202 signatures.push_back(sig); |
| 1203 CHECK(signatures.size() <= 127); |
| 1204 return static_cast<byte>(signatures.size() - 1); |
| 1205 } |
| 1206 byte AddFunction(FunctionSig* sig) { |
| 1207 functions.push_back({sig, 0, 0, 0, 0, 0, 0, 0, false, false}); |
| 1208 CHECK(functions.size() <= 127); |
| 1209 return static_cast<byte>(functions.size() - 1); |
| 1210 } |
| 1211 |
| 1212 private: |
| 1213 WasmModule mod; |
| 1214 std::vector<WasmGlobal> globals; |
| 1215 std::vector<FunctionSig*> signatures; |
| 1216 std::vector<WasmFunction> functions; |
| 1217 }; |
| 1218 } // namespace |
| 1219 |
| 1220 |
| 1221 TEST_F(WasmDecoderTest, SimpleCalls) { |
| 1222 FunctionEnv* env = &env_i_i; |
| 1223 TestModuleEnv module_env; |
| 1224 env->module = &module_env; |
| 1225 |
| 1226 module_env.AddFunction(sigs.i_v()); |
| 1227 module_env.AddFunction(sigs.i_i()); |
| 1228 module_env.AddFunction(sigs.i_ii()); |
| 1229 |
| 1230 EXPECT_VERIFIES_INLINE(env, WASM_CALL_FUNCTION(0)); |
| 1231 EXPECT_VERIFIES_INLINE(env, WASM_CALL_FUNCTION(1, WASM_I8(27))); |
| 1232 EXPECT_VERIFIES_INLINE(env, WASM_CALL_FUNCTION(2, WASM_I8(37), WASM_I8(77))); |
| 1233 } |
| 1234 |
| 1235 |
| 1236 TEST_F(WasmDecoderTest, CallsWithTooFewArguments) { |
| 1237 FunctionEnv* env = &env_i_i; |
| 1238 TestModuleEnv module_env; |
| 1239 env->module = &module_env; |
| 1240 |
| 1241 module_env.AddFunction(sigs.i_i()); |
| 1242 module_env.AddFunction(sigs.i_ii()); |
| 1243 module_env.AddFunction(sigs.f_ff()); |
| 1244 |
| 1245 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION0(0)); |
| 1246 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(1, WASM_ZERO)); |
| 1247 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(2, WASM_GET_LOCAL(0))); |
| 1248 } |
| 1249 |
| 1250 |
| 1251 TEST_F(WasmDecoderTest, CallsWithSpilloverArgs) { |
| 1252 static LocalType a_i_ff[] = {kAstI32, kAstF32, kAstF32}; |
| 1253 FunctionSig sig_i_ff(1, 2, a_i_ff); |
| 1254 FunctionEnv env_i_ff; |
| 1255 init_env(&env_i_ff, &sig_i_ff); |
| 1256 |
| 1257 TestModuleEnv module_env; |
| 1258 env_i_ff.module = &module_env; |
| 1259 env_i_i.module = &module_env; |
| 1260 env_f_ff.module = &module_env; |
| 1261 |
| 1262 module_env.AddFunction(&sig_i_ff); |
| 1263 |
| 1264 EXPECT_VERIFIES_INLINE(&env_i_i, |
| 1265 WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1))); |
| 1266 |
| 1267 EXPECT_VERIFIES_INLINE(&env_i_ff, |
| 1268 WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1))); |
| 1269 |
| 1270 EXPECT_FAILURE_INLINE(&env_f_ff, |
| 1271 WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1))); |
| 1272 |
| 1273 EXPECT_FAILURE_INLINE( |
| 1274 &env_i_i, |
| 1275 WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1), WASM_F32(0.2))); |
| 1276 |
| 1277 EXPECT_VERIFIES_INLINE( |
| 1278 &env_f_ff, |
| 1279 WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1), WASM_F32(11))); |
| 1280 } |
| 1281 |
| 1282 |
| 1283 TEST_F(WasmDecoderTest, CallsWithMismatchedSigs2) { |
| 1284 FunctionEnv* env = &env_i_i; |
| 1285 TestModuleEnv module_env; |
| 1286 env->module = &module_env; |
| 1287 |
| 1288 module_env.AddFunction(sigs.i_i()); |
| 1289 |
| 1290 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_I64(17))); |
| 1291 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_F32(17.1))); |
| 1292 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_F64(17.1))); |
| 1293 } |
| 1294 |
| 1295 |
| 1296 TEST_F(WasmDecoderTest, CallsWithMismatchedSigs3) { |
| 1297 FunctionEnv* env = &env_i_i; |
| 1298 TestModuleEnv module_env; |
| 1299 env->module = &module_env; |
| 1300 |
| 1301 module_env.AddFunction(sigs.i_f()); |
| 1302 |
| 1303 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_I8(17))); |
| 1304 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_I64(27))); |
| 1305 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(0, WASM_F64(37.2))); |
| 1306 |
| 1307 module_env.AddFunction(sigs.i_d()); |
| 1308 |
| 1309 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(1, WASM_I8(16))); |
| 1310 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(1, WASM_I64(16))); |
| 1311 EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(1, WASM_F32(17.6))); |
| 1312 } |
| 1313 |
| 1314 |
| 1315 TEST_F(WasmDecoderTest, SimpleIndirectCalls) { |
| 1316 FunctionEnv* env = &env_i_i; |
| 1317 TestModuleEnv module_env; |
| 1318 env->module = &module_env; |
| 1319 |
| 1320 byte f0 = module_env.AddSignature(sigs.i_v()); |
| 1321 byte f1 = module_env.AddSignature(sigs.i_i()); |
| 1322 byte f2 = module_env.AddSignature(sigs.i_ii()); |
| 1323 |
| 1324 EXPECT_VERIFIES_INLINE(env, WASM_CALL_INDIRECT0(f0, WASM_ZERO)); |
| 1325 EXPECT_VERIFIES_INLINE(env, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I8(22))); |
| 1326 EXPECT_VERIFIES_INLINE( |
| 1327 env, WASM_CALL_INDIRECT(f2, WASM_ZERO, WASM_I8(32), WASM_I8(72))); |
| 1328 } |
| 1329 |
| 1330 |
| 1331 TEST_F(WasmDecoderTest, IndirectCallsOutOfBounds) { |
| 1332 FunctionEnv* env = &env_i_i; |
| 1333 TestModuleEnv module_env; |
| 1334 env->module = &module_env; |
| 1335 |
| 1336 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT0(0, WASM_ZERO)); |
| 1337 module_env.AddSignature(sigs.i_v()); |
| 1338 EXPECT_VERIFIES_INLINE(env, WASM_CALL_INDIRECT0(0, WASM_ZERO)); |
| 1339 |
| 1340 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(1, WASM_ZERO, WASM_I8(22))); |
| 1341 module_env.AddSignature(sigs.i_i()); |
| 1342 EXPECT_VERIFIES_INLINE(env, WASM_CALL_INDIRECT(1, WASM_ZERO, WASM_I8(27))); |
| 1343 |
| 1344 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(2, WASM_ZERO, WASM_I8(27))); |
| 1345 } |
| 1346 |
| 1347 |
| 1348 TEST_F(WasmDecoderTest, IndirectCallsWithMismatchedSigs3) { |
| 1349 FunctionEnv* env = &env_i_i; |
| 1350 TestModuleEnv module_env; |
| 1351 env->module = &module_env; |
| 1352 |
| 1353 byte f0 = module_env.AddFunction(sigs.i_f()); |
| 1354 |
| 1355 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_I8(17))); |
| 1356 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_I64(27))); |
| 1357 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_F64(37.2))); |
| 1358 |
| 1359 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT0(f0, WASM_I8(17))); |
| 1360 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT0(f0, WASM_I64(27))); |
| 1361 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT0(f0, WASM_F64(37.2))); |
| 1362 |
| 1363 byte f1 = module_env.AddFunction(sigs.i_d()); |
| 1364 |
| 1365 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I8(16))); |
| 1366 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I64(16))); |
| 1367 EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_F32(17.6))); |
| 1368 } |
| 1369 |
| 1370 |
| 1371 TEST_F(WasmDecoderTest, Int32Globals) { |
| 1372 FunctionEnv* env = &env_i_i; |
| 1373 TestModuleEnv module_env; |
| 1374 env->module = &module_env; |
| 1375 |
| 1376 module_env.AddGlobal(MachineType::Int8()); |
| 1377 module_env.AddGlobal(MachineType::Uint8()); |
| 1378 module_env.AddGlobal(MachineType::Int16()); |
| 1379 module_env.AddGlobal(MachineType::Uint16()); |
| 1380 module_env.AddGlobal(MachineType::Int32()); |
| 1381 module_env.AddGlobal(MachineType::Uint32()); |
| 1382 |
| 1383 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0)); |
| 1384 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(1)); |
| 1385 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(2)); |
| 1386 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(3)); |
| 1387 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(4)); |
| 1388 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(5)); |
| 1389 |
| 1390 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1391 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(1, WASM_GET_LOCAL(0))); |
| 1392 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(2, WASM_GET_LOCAL(0))); |
| 1393 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(3, WASM_GET_LOCAL(0))); |
| 1394 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(4, WASM_GET_LOCAL(0))); |
| 1395 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(5, WASM_GET_LOCAL(0))); |
| 1396 } |
| 1397 |
| 1398 |
| 1399 TEST_F(WasmDecoderTest, Int32Globals_fail) { |
| 1400 FunctionEnv* env = &env_i_i; |
| 1401 TestModuleEnv module_env; |
| 1402 env->module = &module_env; |
| 1403 |
| 1404 module_env.AddGlobal(MachineType::Int64()); |
| 1405 module_env.AddGlobal(MachineType::Uint64()); |
| 1406 module_env.AddGlobal(MachineType::Float32()); |
| 1407 module_env.AddGlobal(MachineType::Float64()); |
| 1408 |
| 1409 EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(0)); |
| 1410 EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(1)); |
| 1411 EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(2)); |
| 1412 EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(3)); |
| 1413 |
| 1414 EXPECT_FAILURE_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1415 EXPECT_FAILURE_INLINE(env, WASM_STORE_GLOBAL(1, WASM_GET_LOCAL(0))); |
| 1416 EXPECT_FAILURE_INLINE(env, WASM_STORE_GLOBAL(2, WASM_GET_LOCAL(0))); |
| 1417 EXPECT_FAILURE_INLINE(env, WASM_STORE_GLOBAL(3, WASM_GET_LOCAL(0))); |
| 1418 } |
| 1419 |
| 1420 |
| 1421 TEST_F(WasmDecoderTest, Int64Globals) { |
| 1422 FunctionEnv* env = &env_l_l; |
| 1423 TestModuleEnv module_env; |
| 1424 env->module = &module_env; |
| 1425 |
| 1426 module_env.AddGlobal(MachineType::Int64()); |
| 1427 module_env.AddGlobal(MachineType::Uint64()); |
| 1428 |
| 1429 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0)); |
| 1430 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(1)); |
| 1431 |
| 1432 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1433 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(1, WASM_GET_LOCAL(0))); |
| 1434 } |
| 1435 |
| 1436 |
| 1437 TEST_F(WasmDecoderTest, Float32Globals) { |
| 1438 FunctionEnv env_f_ff; |
| 1439 FunctionEnv* env = &env_f_ff; |
| 1440 init_env(env, sigs.f_ff()); |
| 1441 TestModuleEnv module_env; |
| 1442 env->module = &module_env; |
| 1443 |
| 1444 module_env.AddGlobal(MachineType::Float32()); |
| 1445 |
| 1446 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0)); |
| 1447 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1448 } |
| 1449 |
| 1450 |
| 1451 TEST_F(WasmDecoderTest, Float64Globals) { |
| 1452 FunctionEnv env_d_dd; |
| 1453 FunctionEnv* env = &env_d_dd; |
| 1454 init_env(env, sigs.d_dd()); |
| 1455 TestModuleEnv module_env; |
| 1456 env->module = &module_env; |
| 1457 |
| 1458 module_env.AddGlobal(MachineType::Float64()); |
| 1459 |
| 1460 EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0)); |
| 1461 EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1462 } |
| 1463 |
| 1464 |
| 1465 TEST_F(WasmDecoderTest, AllLoadGlobalCombinations) { |
| 1466 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1467 LocalType local_type = kLocalTypes[i]; |
| 1468 for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| 1469 MachineType mem_type = machineTypes[j]; |
| 1470 FunctionEnv env; |
| 1471 FunctionSig sig(1, 0, &local_type); |
| 1472 TestModuleEnv module_env; |
| 1473 init_env(&env, &sig); |
| 1474 env.module = &module_env; |
| 1475 module_env.AddGlobal(mem_type); |
| 1476 if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) { |
| 1477 EXPECT_VERIFIES_INLINE(&env, WASM_LOAD_GLOBAL(0)); |
| 1478 } else { |
| 1479 EXPECT_FAILURE_INLINE(&env, WASM_LOAD_GLOBAL(0)); |
| 1480 } |
| 1481 } |
| 1482 } |
| 1483 } |
| 1484 |
| 1485 |
| 1486 TEST_F(WasmDecoderTest, AllStoreGlobalCombinations) { |
| 1487 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1488 LocalType local_type = kLocalTypes[i]; |
| 1489 for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| 1490 MachineType mem_type = machineTypes[j]; |
| 1491 FunctionEnv env; |
| 1492 FunctionSig sig(0, 1, &local_type); |
| 1493 TestModuleEnv module_env; |
| 1494 init_env(&env, &sig); |
| 1495 env.module = &module_env; |
| 1496 module_env.AddGlobal(mem_type); |
| 1497 if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) { |
| 1498 EXPECT_VERIFIES_INLINE(&env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1499 } else { |
| 1500 EXPECT_FAILURE_INLINE(&env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0))); |
| 1501 } |
| 1502 } |
| 1503 } |
| 1504 } |
| 1505 |
| 1506 |
| 1507 TEST_F(WasmDecoderTest, BreakNesting1) { |
| 1508 for (int i = 0; i < 5; i++) { |
| 1509 // (block[2] (loop[2] (if (get p) break[N]) (set p 1)) p) |
| 1510 byte code[] = {WASM_BLOCK( |
| 1511 2, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(i, WASM_ZERO)), |
| 1512 WASM_SET_LOCAL(0, WASM_I8(1))), |
| 1513 WASM_GET_LOCAL(0))}; |
| 1514 if (i < 3) { |
| 1515 EXPECT_VERIFIES(&env_i_i, code); |
| 1516 } else { |
| 1517 EXPECT_FAILURE(&env_i_i, code); |
| 1518 } |
| 1519 } |
| 1520 } |
| 1521 |
| 1522 |
| 1523 TEST_F(WasmDecoderTest, BreakNesting2) { |
| 1524 env_v_v.AddLocals(kAstI32, 1); |
| 1525 for (int i = 0; i < 5; i++) { |
| 1526 // (block[2] (loop[2] (if (get p) break[N]) (set p 1)) (return p)) (11) |
| 1527 byte code[] = { |
| 1528 WASM_BLOCK(1, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(i)), |
| 1529 WASM_SET_LOCAL(0, WASM_I8(1)))), |
| 1530 WASM_I8(11)}; |
| 1531 if (i < 2) { |
| 1532 EXPECT_VERIFIES(&env_v_v, code); |
| 1533 } else { |
| 1534 EXPECT_FAILURE(&env_v_v, code); |
| 1535 } |
| 1536 } |
| 1537 } |
| 1538 |
| 1539 |
| 1540 TEST_F(WasmDecoderTest, BreakNesting3) { |
| 1541 env_v_v.AddLocals(kAstI32, 1); |
| 1542 for (int i = 0; i < 5; i++) { |
| 1543 // (block[1] (loop[1] (block[1] (if (get p) break[N]) |
| 1544 byte code[] = {WASM_BLOCK( |
| 1545 1, WASM_LOOP( |
| 1546 1, WASM_BLOCK(1, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(i)))))}; |
| 1547 if (i < 3) { |
| 1548 EXPECT_VERIFIES(&env_v_v, code); |
| 1549 } else { |
| 1550 EXPECT_FAILURE(&env_v_v, code); |
| 1551 } |
| 1552 } |
| 1553 } |
| 1554 |
| 1555 |
| 1556 TEST_F(WasmDecoderTest, BreaksWithMultipleTypes) { |
| 1557 EXPECT_FAILURE_INLINE( |
| 1558 &env_i_i, |
| 1559 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(7)), WASM_F32(7.7))); |
| 1560 EXPECT_FAILURE_INLINE(&env_i_i, |
| 1561 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(7)), |
| 1562 WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7)))); |
| 1563 EXPECT_FAILURE_INLINE(&env_i_i, |
| 1564 WASM_BLOCK(3, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(8)), |
| 1565 WASM_BRV_IF(0, WASM_ZERO, WASM_I8(0)), |
| 1566 WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7)))); |
| 1567 EXPECT_FAILURE_INLINE(&env_i_i, |
| 1568 WASM_BLOCK(3, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(9)), |
| 1569 WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7)), |
| 1570 WASM_BRV_IF(0, WASM_ZERO, WASM_I8(11)))); |
| 1571 } |
| 1572 |
| 1573 |
| 1574 TEST_F(WasmDecoderTest, BreakNesting_6_levels) { |
| 1575 for (int mask = 0; mask < 64; mask++) { |
| 1576 for (int i = 0; i < 14; i++) { |
| 1577 byte code[] = { |
| 1578 kExprBlock, 1, // -- |
| 1579 kExprBlock, 1, // -- |
| 1580 kExprBlock, 1, // -- |
| 1581 kExprBlock, 1, // -- |
| 1582 kExprBlock, 1, // -- |
| 1583 kExprBlock, 1, // -- |
| 1584 kExprBr, static_cast<byte>(i), |
| 1585 kExprNop // -- |
| 1586 }; |
| 1587 |
| 1588 int depth = 6; |
| 1589 for (int l = 0; l < 6; l++) { |
| 1590 if (mask & (1 << l)) { |
| 1591 code[l * 2] = kExprLoop; |
| 1592 depth++; |
| 1593 } |
| 1594 } |
| 1595 |
| 1596 if (i < depth) { |
| 1597 EXPECT_VERIFIES(&env_v_v, code); |
| 1598 } else { |
| 1599 EXPECT_FAILURE(&env_v_v, code); |
| 1600 } |
| 1601 } |
| 1602 } |
| 1603 } |
| 1604 |
| 1605 |
| 1606 TEST_F(WasmDecoderTest, ExprBreak_TypeCheck) { |
| 1607 FunctionEnv* envs[] = {&env_i_i, &env_l_l, &env_f_ff, &env_d_dd}; |
| 1608 for (size_t i = 0; i < arraysize(envs); i++) { |
| 1609 FunctionEnv* env = envs[i]; |
| 1610 // unify X and X => OK |
| 1611 EXPECT_VERIFIES_INLINE( |
| 1612 env, WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| 1613 WASM_GET_LOCAL(0))); |
| 1614 } |
| 1615 |
| 1616 // unify i32 and f32 => fail |
| 1617 EXPECT_FAILURE_INLINE( |
| 1618 &env_i_i, |
| 1619 WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_ZERO)), WASM_F32(1.2))); |
| 1620 |
| 1621 // unify f64 and f64 => OK |
| 1622 EXPECT_VERIFIES_INLINE( |
| 1623 &env_d_dd, |
| 1624 WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| 1625 WASM_F64(1.2))); |
| 1626 } |
| 1627 |
| 1628 |
| 1629 TEST_F(WasmDecoderTest, ExprBreak_TypeCheckAll) { |
| 1630 byte code1[] = {WASM_BLOCK(2, |
| 1631 WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| 1632 WASM_GET_LOCAL(1))}; |
| 1633 byte code2[] = {WASM_BLOCK( |
| 1634 2, WASM_IF(WASM_ZERO, WASM_BRV_IF(0, WASM_ZERO, WASM_GET_LOCAL(0))), |
| 1635 WASM_GET_LOCAL(1))}; |
| 1636 |
| 1637 |
| 1638 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1639 for (size_t j = 0; j < arraysize(kLocalTypes); j++) { |
| 1640 FunctionEnv env; |
| 1641 LocalType storage[] = {kLocalTypes[i], kLocalTypes[i], kLocalTypes[j]}; |
| 1642 FunctionSig sig(1, 2, storage); |
| 1643 init_env(&env, &sig); |
| 1644 |
| 1645 if (i == j) { |
| 1646 EXPECT_VERIFIES(&env, code1); |
| 1647 EXPECT_VERIFIES(&env, code2); |
| 1648 } else { |
| 1649 EXPECT_FAILURE(&env, code1); |
| 1650 EXPECT_FAILURE(&env, code2); |
| 1651 } |
| 1652 } |
| 1653 } |
| 1654 } |
| 1655 |
| 1656 |
| 1657 TEST_F(WasmDecoderTest, ExprBr_Unify) { |
| 1658 FunctionEnv env; |
| 1659 |
| 1660 for (int which = 0; which < 2; which++) { |
| 1661 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1662 LocalType type = kLocalTypes[i]; |
| 1663 LocalType storage[] = {kAstI32, kAstI32, type}; |
| 1664 FunctionSig sig(1, 2, storage); |
| 1665 init_env(&env, &sig); // (i32, X) -> i32 |
| 1666 |
| 1667 byte code1[] = { |
| 1668 WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(which))), |
| 1669 WASM_GET_LOCAL(which ^ 1))}; |
| 1670 byte code2[] = { |
| 1671 WASM_LOOP(2, WASM_IF(WASM_ZERO, WASM_BRV(1, WASM_GET_LOCAL(which))), |
| 1672 WASM_GET_LOCAL(which ^ 1))}; |
| 1673 |
| 1674 |
| 1675 if (type == kAstI32) { |
| 1676 EXPECT_VERIFIES(&env, code1); |
| 1677 EXPECT_VERIFIES(&env, code2); |
| 1678 } else { |
| 1679 EXPECT_FAILURE(&env, code1); |
| 1680 EXPECT_FAILURE(&env, code2); |
| 1681 } |
| 1682 } |
| 1683 } |
| 1684 } |
| 1685 |
| 1686 |
| 1687 TEST_F(WasmDecoderTest, ExprBrIf_type) { |
| 1688 EXPECT_VERIFIES_INLINE( |
| 1689 &env_i_i, |
| 1690 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)), |
| 1691 WASM_GET_LOCAL(0))); |
| 1692 EXPECT_FAILURE_INLINE( |
| 1693 &env_d_dd, |
| 1694 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)), |
| 1695 WASM_GET_LOCAL(0))); |
| 1696 |
| 1697 FunctionEnv env; |
| 1698 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1699 LocalType type = kLocalTypes[i]; |
| 1700 LocalType storage[] = {kAstI32, kAstI32, type}; |
| 1701 FunctionSig sig(1, 2, storage); |
| 1702 init_env(&env, &sig); // (i32, X) -> i32 |
| 1703 |
| 1704 byte code1[] = { |
| 1705 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), |
| 1706 WASM_GET_LOCAL(0))}; |
| 1707 |
| 1708 byte code2[] = { |
| 1709 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(1), WASM_GET_LOCAL(0)), |
| 1710 WASM_GET_LOCAL(0))}; |
| 1711 if (type == kAstI32) { |
| 1712 EXPECT_VERIFIES(&env, code1); |
| 1713 EXPECT_VERIFIES(&env, code2); |
| 1714 } else { |
| 1715 EXPECT_FAILURE(&env, code1); |
| 1716 EXPECT_FAILURE(&env, code2); |
| 1717 } |
| 1718 } |
| 1719 } |
| 1720 |
| 1721 |
| 1722 TEST_F(WasmDecoderTest, ExprBrIf_Unify) { |
| 1723 FunctionEnv env; |
| 1724 |
| 1725 for (int which = 0; which < 2; which++) { |
| 1726 for (size_t i = 0; i < arraysize(kLocalTypes); i++) { |
| 1727 LocalType type = kLocalTypes[i]; |
| 1728 LocalType storage[] = {kAstI32, kAstI32, type}; |
| 1729 FunctionSig sig(1, 2, storage); |
| 1730 init_env(&env, &sig); // (i32, X) -> i32 |
| 1731 |
| 1732 byte code1[] = { |
| 1733 WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_GET_LOCAL(which)), |
| 1734 WASM_GET_LOCAL(which ^ 1))}; |
| 1735 byte code2[] = { |
| 1736 WASM_LOOP(2, WASM_BRV_IF(1, WASM_ZERO, WASM_GET_LOCAL(which)), |
| 1737 WASM_GET_LOCAL(which ^ 1))}; |
| 1738 |
| 1739 |
| 1740 if (type == kAstI32) { |
| 1741 EXPECT_VERIFIES(&env, code1); |
| 1742 EXPECT_VERIFIES(&env, code2); |
| 1743 } else { |
| 1744 EXPECT_FAILURE(&env, code1); |
| 1745 EXPECT_FAILURE(&env, code2); |
| 1746 } |
| 1747 } |
| 1748 } |
| 1749 } |
| 1750 |
| 1751 |
| 1752 TEST_F(WasmDecoderTest, TableSwitch0) { |
| 1753 static byte code[] = {kExprTableSwitch, 0, 0, 0, 0}; |
| 1754 EXPECT_FAILURE(&env_v_v, code); |
| 1755 } |
| 1756 |
| 1757 |
| 1758 TEST_F(WasmDecoderTest, TableSwitch0b) { |
| 1759 static byte code[] = {kExprTableSwitch, 0, 0, 0, 0, kExprI8Const, 11}; |
| 1760 EXPECT_FAILURE(&env_v_v, code); |
| 1761 EXPECT_FAILURE(&env_i_i, code); |
| 1762 } |
| 1763 |
| 1764 |
| 1765 TEST_F(WasmDecoderTest, TableSwitch0c) { |
| 1766 static byte code[] = { |
| 1767 WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(0)), WASM_I8(67))}; |
| 1768 EXPECT_VERIFIES(&env_v_v, code); |
| 1769 } |
| 1770 |
| 1771 |
| 1772 TEST_F(WasmDecoderTest, TableSwitch1) { |
| 1773 static byte code[] = {WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1774 WASM_TABLESWITCH_BODY(WASM_I8(0), WASM_I8(9))}; |
| 1775 EXPECT_VERIFIES(&env_i_i, code); |
| 1776 EXPECT_VERIFIES(&env_v_v, code); |
| 1777 EXPECT_FAILURE(&env_f_ff, code); |
| 1778 EXPECT_FAILURE(&env_d_dd, code); |
| 1779 } |
| 1780 |
| 1781 |
| 1782 TEST_F(WasmDecoderTest, TableSwitch_off_end) { |
| 1783 static byte code[] = {WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1784 WASM_TABLESWITCH_BODY(WASM_I8(0), WASM_I8(9))}; |
| 1785 for (size_t len = arraysize(code) - 1; len > 0; len--) { |
| 1786 Verify(kError, &env_v_v, code, code + len); |
| 1787 } |
| 1788 } |
| 1789 |
| 1790 |
| 1791 TEST_F(WasmDecoderTest, TableSwitch2) { |
| 1792 static byte code[] = { |
| 1793 WASM_TABLESWITCH_OP(2, 2, WASM_CASE(0), WASM_CASE(1)), |
| 1794 WASM_TABLESWITCH_BODY(WASM_I8(3), WASM_I8(10), WASM_I8(11))}; |
| 1795 EXPECT_VERIFIES(&env_i_i, code); |
| 1796 EXPECT_VERIFIES(&env_v_v, code); |
| 1797 EXPECT_FAILURE(&env_f_ff, code); |
| 1798 EXPECT_FAILURE(&env_d_dd, code); |
| 1799 } |
| 1800 |
| 1801 |
| 1802 TEST_F(WasmDecoderTest, TableSwitch1b) { |
| 1803 EXPECT_VERIFIES_INLINE(&env_i_i, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1804 WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_ZERO)); |
| 1805 |
| 1806 EXPECT_VERIFIES_INLINE(&env_f_ff, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1807 WASM_TABLESWITCH_BODY(WASM_ZERO, WASM_F32(0.0))); |
| 1808 |
| 1809 EXPECT_VERIFIES_INLINE(&env_d_dd, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1810 WASM_TABLESWITCH_BODY(WASM_ZERO, WASM_F64(0.0))); |
| 1811 } |
| 1812 |
| 1813 |
| 1814 TEST_F(WasmDecoderTest, TableSwitch_br) { |
| 1815 EXPECT_VERIFIES_INLINE(&env_i_i, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(0)), |
| 1816 WASM_GET_LOCAL(0)); |
| 1817 for (int depth = 0; depth < 2; depth++) { |
| 1818 EXPECT_VERIFIES_INLINE( |
| 1819 &env_i_i, WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth)), |
| 1820 WASM_GET_LOCAL(0))); |
| 1821 } |
| 1822 } |
| 1823 |
| 1824 |
| 1825 TEST_F(WasmDecoderTest, TableSwitch_invalid_br) { |
| 1826 for (int depth = 1; depth < 4; depth++) { |
| 1827 EXPECT_FAILURE_INLINE(&env_i_i, |
| 1828 WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth)), |
| 1829 WASM_GET_LOCAL(0)); |
| 1830 EXPECT_FAILURE_INLINE( |
| 1831 &env_i_i, |
| 1832 WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth + 1)), |
| 1833 WASM_GET_LOCAL(0))); |
| 1834 } |
| 1835 } |
| 1836 |
| 1837 |
| 1838 TEST_F(WasmDecoderTest, TableSwitch_invalid_case_ref) { |
| 1839 EXPECT_FAILURE_INLINE(&env_i_i, WASM_TABLESWITCH_OP(0, 1, WASM_CASE(0)), |
| 1840 WASM_GET_LOCAL(0)); |
| 1841 EXPECT_FAILURE_INLINE(&env_i_i, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(1)), |
| 1842 WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_ZERO)); |
| 1843 } |
| 1844 |
| 1845 |
| 1846 TEST_F(WasmDecoderTest, TableSwitch1_br) { |
| 1847 EXPECT_VERIFIES_INLINE( |
| 1848 &env_i_i, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)), |
| 1849 WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_ZERO))); |
| 1850 } |
| 1851 |
| 1852 |
| 1853 TEST_F(WasmDecoderTest, TableSwitch2_br) { |
| 1854 EXPECT_VERIFIES_INLINE( |
| 1855 &env_i_i, WASM_TABLESWITCH_OP(2, 2, WASM_CASE(0), WASM_CASE(1)), |
| 1856 WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(0)), |
| 1857 WASM_BRV(0, WASM_I8(1)))); |
| 1858 |
| 1859 EXPECT_FAILURE_INLINE( |
| 1860 &env_f_ff, WASM_TABLESWITCH_OP(2, 2, WASM_CASE(0), WASM_CASE(1)), |
| 1861 WASM_TABLESWITCH_BODY(WASM_ZERO, WASM_BRV(0, WASM_I8(3)), |
| 1862 WASM_BRV(0, WASM_I8(4)))); |
| 1863 } |
| 1864 |
| 1865 |
| 1866 TEST_F(WasmDecoderTest, TableSwitch2x2) { |
| 1867 EXPECT_VERIFIES_INLINE( |
| 1868 &env_i_i, WASM_TABLESWITCH_OP(2, 4, WASM_CASE(0), WASM_CASE(1), |
| 1869 WASM_CASE(0), WASM_CASE(1)), |
| 1870 WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(3)), |
| 1871 WASM_BRV(0, WASM_I8(4)))); |
| 1872 } |
| 1873 |
| 1874 |
| 1875 TEST_F(WasmDecoderTest, ExprBreakNesting1) { |
| 1876 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(1, WASM_BRV(0, WASM_ZERO))); |
| 1877 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(1, WASM_BR(0))); |
| 1878 EXPECT_VERIFIES_INLINE(&env_v_v, |
| 1879 WASM_BLOCK(1, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO))); |
| 1880 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(1, WASM_BR_IF(0, WASM_ZERO))); |
| 1881 |
| 1882 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BRV(0, WASM_ZERO))); |
| 1883 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BR(0))); |
| 1884 EXPECT_VERIFIES_INLINE(&env_v_v, |
| 1885 WASM_LOOP(1, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO))); |
| 1886 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BR_IF(0, WASM_ZERO))); |
| 1887 |
| 1888 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BRV(1, WASM_ZERO))); |
| 1889 EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BR(1))); |
| 1890 } |
| 1891 |
| 1892 |
| 1893 TEST_F(WasmDecoderTest, Select) { |
| 1894 EXPECT_VERIFIES_INLINE( |
| 1895 &env_i_i, |
| 1896 WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0))); |
| 1897 } |
| 1898 |
| 1899 |
| 1900 TEST_F(WasmDecoderTest, Select_TypeCheck) { |
| 1901 EXPECT_FAILURE_INLINE(&env_i_i, WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), |
| 1902 WASM_GET_LOCAL(0))); |
| 1903 |
| 1904 EXPECT_FAILURE_INLINE(&env_i_i, WASM_SELECT(WASM_GET_LOCAL(0), WASM_F64(0.25), |
| 1905 WASM_GET_LOCAL(0))); |
| 1906 |
| 1907 EXPECT_FAILURE_INLINE( |
| 1908 &env_i_i, WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64(0))); |
| 1909 } |
| 1910 |
| 1911 |
| 1912 class WasmOpcodeLengthTest : public TestWithZone { |
| 1913 public: |
| 1914 WasmOpcodeLengthTest() : TestWithZone() {} |
| 1915 }; |
| 1916 |
| 1917 |
| 1918 #define EXPECT_LENGTH(expected, opcode) \ |
| 1919 { \ |
| 1920 static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0}; \ |
| 1921 EXPECT_EQ(expected, OpcodeLength(code)); \ |
| 1922 } |
| 1923 |
| 1924 |
| 1925 TEST_F(WasmOpcodeLengthTest, Statements) { |
| 1926 EXPECT_LENGTH(1, kExprNop); |
| 1927 EXPECT_LENGTH(2, kExprBlock); |
| 1928 EXPECT_LENGTH(2, kExprLoop); |
| 1929 EXPECT_LENGTH(1, kExprIf); |
| 1930 EXPECT_LENGTH(1, kExprIfElse); |
| 1931 EXPECT_LENGTH(1, kExprSelect); |
| 1932 EXPECT_LENGTH(2, kExprBr); |
| 1933 EXPECT_LENGTH(2, kExprBrIf); |
| 1934 } |
| 1935 |
| 1936 |
| 1937 TEST_F(WasmOpcodeLengthTest, MiscExpressions) { |
| 1938 EXPECT_LENGTH(2, kExprI8Const); |
| 1939 EXPECT_LENGTH(5, kExprI32Const); |
| 1940 EXPECT_LENGTH(5, kExprF32Const); |
| 1941 EXPECT_LENGTH(9, kExprI64Const); |
| 1942 EXPECT_LENGTH(9, kExprF64Const); |
| 1943 EXPECT_LENGTH(2, kExprGetLocal); |
| 1944 EXPECT_LENGTH(2, kExprSetLocal); |
| 1945 EXPECT_LENGTH(2, kExprLoadGlobal); |
| 1946 EXPECT_LENGTH(2, kExprStoreGlobal); |
| 1947 EXPECT_LENGTH(2, kExprCallFunction); |
| 1948 EXPECT_LENGTH(2, kExprCallIndirect); |
| 1949 EXPECT_LENGTH(1, kExprIf); |
| 1950 EXPECT_LENGTH(1, kExprIfElse); |
| 1951 EXPECT_LENGTH(2, kExprBlock); |
| 1952 EXPECT_LENGTH(2, kExprLoop); |
| 1953 EXPECT_LENGTH(2, kExprBr); |
| 1954 EXPECT_LENGTH(2, kExprBrIf); |
| 1955 } |
| 1956 |
| 1957 |
| 1958 TEST_F(WasmOpcodeLengthTest, VariableLength) { |
| 1959 byte size2[] = {kExprLoadGlobal, 1}; |
| 1960 byte size3[] = {kExprLoadGlobal, 1 | 0x80, 2}; |
| 1961 byte size4[] = {kExprLoadGlobal, 1 | 0x80, 2 | 0x80, 3}; |
| 1962 byte size5[] = {kExprLoadGlobal, 1 | 0x80, 2 | 0x80, 3 | 0x80, 4}; |
| 1963 byte size6[] = {kExprLoadGlobal, 1 | 0x80, 2 | 0x80, 3 | 0x80, 4 | 0x80, 5}; |
| 1964 |
| 1965 EXPECT_EQ(2, OpcodeLength(size2)); |
| 1966 EXPECT_EQ(3, OpcodeLength(size3)); |
| 1967 EXPECT_EQ(4, OpcodeLength(size4)); |
| 1968 EXPECT_EQ(5, OpcodeLength(size5)); |
| 1969 EXPECT_EQ(6, OpcodeLength(size6)); |
| 1970 } |
| 1971 |
| 1972 |
| 1973 TEST_F(WasmOpcodeLengthTest, LoadsAndStores) { |
| 1974 EXPECT_LENGTH(2, kExprI32LoadMem8S); |
| 1975 EXPECT_LENGTH(2, kExprI32LoadMem8U); |
| 1976 EXPECT_LENGTH(2, kExprI32LoadMem16S); |
| 1977 EXPECT_LENGTH(2, kExprI32LoadMem16U); |
| 1978 EXPECT_LENGTH(2, kExprI32LoadMem); |
| 1979 EXPECT_LENGTH(2, kExprI64LoadMem8S); |
| 1980 EXPECT_LENGTH(2, kExprI64LoadMem8U); |
| 1981 EXPECT_LENGTH(2, kExprI64LoadMem16S); |
| 1982 EXPECT_LENGTH(2, kExprI64LoadMem16U); |
| 1983 EXPECT_LENGTH(2, kExprI64LoadMem32S); |
| 1984 EXPECT_LENGTH(2, kExprI64LoadMem32U); |
| 1985 EXPECT_LENGTH(2, kExprI64LoadMem); |
| 1986 EXPECT_LENGTH(2, kExprF32LoadMem); |
| 1987 EXPECT_LENGTH(2, kExprF64LoadMem); |
| 1988 |
| 1989 EXPECT_LENGTH(2, kExprI32StoreMem8); |
| 1990 EXPECT_LENGTH(2, kExprI32StoreMem16); |
| 1991 EXPECT_LENGTH(2, kExprI32StoreMem); |
| 1992 EXPECT_LENGTH(2, kExprI64StoreMem8); |
| 1993 EXPECT_LENGTH(2, kExprI64StoreMem16); |
| 1994 EXPECT_LENGTH(2, kExprI64StoreMem32); |
| 1995 EXPECT_LENGTH(2, kExprI64StoreMem); |
| 1996 EXPECT_LENGTH(2, kExprF32StoreMem); |
| 1997 EXPECT_LENGTH(2, kExprF64StoreMem); |
| 1998 } |
| 1999 |
| 2000 |
| 2001 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) { |
| 2002 EXPECT_LENGTH(1, kExprMemorySize); |
| 2003 EXPECT_LENGTH(1, kExprGrowMemory); |
| 2004 } |
| 2005 |
| 2006 |
| 2007 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) { |
| 2008 EXPECT_LENGTH(1, kExprI32Add); |
| 2009 EXPECT_LENGTH(1, kExprI32Sub); |
| 2010 EXPECT_LENGTH(1, kExprI32Mul); |
| 2011 EXPECT_LENGTH(1, kExprI32DivS); |
| 2012 EXPECT_LENGTH(1, kExprI32DivU); |
| 2013 EXPECT_LENGTH(1, kExprI32RemS); |
| 2014 EXPECT_LENGTH(1, kExprI32RemU); |
| 2015 EXPECT_LENGTH(1, kExprI32And); |
| 2016 EXPECT_LENGTH(1, kExprI32Ior); |
| 2017 EXPECT_LENGTH(1, kExprI32Xor); |
| 2018 EXPECT_LENGTH(1, kExprI32Shl); |
| 2019 EXPECT_LENGTH(1, kExprI32ShrU); |
| 2020 EXPECT_LENGTH(1, kExprI32ShrS); |
| 2021 EXPECT_LENGTH(1, kExprI32Eq); |
| 2022 EXPECT_LENGTH(1, kExprI32Ne); |
| 2023 EXPECT_LENGTH(1, kExprI32LtS); |
| 2024 EXPECT_LENGTH(1, kExprI32LeS); |
| 2025 EXPECT_LENGTH(1, kExprI32LtU); |
| 2026 EXPECT_LENGTH(1, kExprI32LeU); |
| 2027 EXPECT_LENGTH(1, kExprI32GtS); |
| 2028 EXPECT_LENGTH(1, kExprI32GeS); |
| 2029 EXPECT_LENGTH(1, kExprI32GtU); |
| 2030 EXPECT_LENGTH(1, kExprI32GeU); |
| 2031 EXPECT_LENGTH(1, kExprI32Clz); |
| 2032 EXPECT_LENGTH(1, kExprI32Ctz); |
| 2033 EXPECT_LENGTH(1, kExprI32Popcnt); |
| 2034 EXPECT_LENGTH(1, kExprBoolNot); |
| 2035 EXPECT_LENGTH(1, kExprI64Add); |
| 2036 EXPECT_LENGTH(1, kExprI64Sub); |
| 2037 EXPECT_LENGTH(1, kExprI64Mul); |
| 2038 EXPECT_LENGTH(1, kExprI64DivS); |
| 2039 EXPECT_LENGTH(1, kExprI64DivU); |
| 2040 EXPECT_LENGTH(1, kExprI64RemS); |
| 2041 EXPECT_LENGTH(1, kExprI64RemU); |
| 2042 EXPECT_LENGTH(1, kExprI64And); |
| 2043 EXPECT_LENGTH(1, kExprI64Ior); |
| 2044 EXPECT_LENGTH(1, kExprI64Xor); |
| 2045 EXPECT_LENGTH(1, kExprI64Shl); |
| 2046 EXPECT_LENGTH(1, kExprI64ShrU); |
| 2047 EXPECT_LENGTH(1, kExprI64ShrS); |
| 2048 EXPECT_LENGTH(1, kExprI64Eq); |
| 2049 EXPECT_LENGTH(1, kExprI64Ne); |
| 2050 EXPECT_LENGTH(1, kExprI64LtS); |
| 2051 EXPECT_LENGTH(1, kExprI64LeS); |
| 2052 EXPECT_LENGTH(1, kExprI64LtU); |
| 2053 EXPECT_LENGTH(1, kExprI64LeU); |
| 2054 EXPECT_LENGTH(1, kExprI64GtS); |
| 2055 EXPECT_LENGTH(1, kExprI64GeS); |
| 2056 EXPECT_LENGTH(1, kExprI64GtU); |
| 2057 EXPECT_LENGTH(1, kExprI64GeU); |
| 2058 EXPECT_LENGTH(1, kExprI64Clz); |
| 2059 EXPECT_LENGTH(1, kExprI64Ctz); |
| 2060 EXPECT_LENGTH(1, kExprI64Popcnt); |
| 2061 EXPECT_LENGTH(1, kExprF32Add); |
| 2062 EXPECT_LENGTH(1, kExprF32Sub); |
| 2063 EXPECT_LENGTH(1, kExprF32Mul); |
| 2064 EXPECT_LENGTH(1, kExprF32Div); |
| 2065 EXPECT_LENGTH(1, kExprF32Min); |
| 2066 EXPECT_LENGTH(1, kExprF32Max); |
| 2067 EXPECT_LENGTH(1, kExprF32Abs); |
| 2068 EXPECT_LENGTH(1, kExprF32Neg); |
| 2069 EXPECT_LENGTH(1, kExprF32CopySign); |
| 2070 EXPECT_LENGTH(1, kExprF32Ceil); |
| 2071 EXPECT_LENGTH(1, kExprF32Floor); |
| 2072 EXPECT_LENGTH(1, kExprF32Trunc); |
| 2073 EXPECT_LENGTH(1, kExprF32NearestInt); |
| 2074 EXPECT_LENGTH(1, kExprF32Sqrt); |
| 2075 EXPECT_LENGTH(1, kExprF32Eq); |
| 2076 EXPECT_LENGTH(1, kExprF32Ne); |
| 2077 EXPECT_LENGTH(1, kExprF32Lt); |
| 2078 EXPECT_LENGTH(1, kExprF32Le); |
| 2079 EXPECT_LENGTH(1, kExprF32Gt); |
| 2080 EXPECT_LENGTH(1, kExprF32Ge); |
| 2081 EXPECT_LENGTH(1, kExprF64Add); |
| 2082 EXPECT_LENGTH(1, kExprF64Sub); |
| 2083 EXPECT_LENGTH(1, kExprF64Mul); |
| 2084 EXPECT_LENGTH(1, kExprF64Div); |
| 2085 EXPECT_LENGTH(1, kExprF64Min); |
| 2086 EXPECT_LENGTH(1, kExprF64Max); |
| 2087 EXPECT_LENGTH(1, kExprF64Abs); |
| 2088 EXPECT_LENGTH(1, kExprF64Neg); |
| 2089 EXPECT_LENGTH(1, kExprF64CopySign); |
| 2090 EXPECT_LENGTH(1, kExprF64Ceil); |
| 2091 EXPECT_LENGTH(1, kExprF64Floor); |
| 2092 EXPECT_LENGTH(1, kExprF64Trunc); |
| 2093 EXPECT_LENGTH(1, kExprF64NearestInt); |
| 2094 EXPECT_LENGTH(1, kExprF64Sqrt); |
| 2095 EXPECT_LENGTH(1, kExprF64Eq); |
| 2096 EXPECT_LENGTH(1, kExprF64Ne); |
| 2097 EXPECT_LENGTH(1, kExprF64Lt); |
| 2098 EXPECT_LENGTH(1, kExprF64Le); |
| 2099 EXPECT_LENGTH(1, kExprF64Gt); |
| 2100 EXPECT_LENGTH(1, kExprF64Ge); |
| 2101 EXPECT_LENGTH(1, kExprI32SConvertF32); |
| 2102 EXPECT_LENGTH(1, kExprI32SConvertF64); |
| 2103 EXPECT_LENGTH(1, kExprI32UConvertF32); |
| 2104 EXPECT_LENGTH(1, kExprI32UConvertF64); |
| 2105 EXPECT_LENGTH(1, kExprI32ConvertI64); |
| 2106 EXPECT_LENGTH(1, kExprI64SConvertF32); |
| 2107 EXPECT_LENGTH(1, kExprI64SConvertF64); |
| 2108 EXPECT_LENGTH(1, kExprI64UConvertF32); |
| 2109 EXPECT_LENGTH(1, kExprI64UConvertF64); |
| 2110 EXPECT_LENGTH(1, kExprI64SConvertI32); |
| 2111 EXPECT_LENGTH(1, kExprI64UConvertI32); |
| 2112 EXPECT_LENGTH(1, kExprF32SConvertI32); |
| 2113 EXPECT_LENGTH(1, kExprF32UConvertI32); |
| 2114 EXPECT_LENGTH(1, kExprF32SConvertI64); |
| 2115 EXPECT_LENGTH(1, kExprF32UConvertI64); |
| 2116 EXPECT_LENGTH(1, kExprF32ConvertF64); |
| 2117 EXPECT_LENGTH(1, kExprF32ReinterpretI32); |
| 2118 EXPECT_LENGTH(1, kExprF64SConvertI32); |
| 2119 EXPECT_LENGTH(1, kExprF64UConvertI32); |
| 2120 EXPECT_LENGTH(1, kExprF64SConvertI64); |
| 2121 EXPECT_LENGTH(1, kExprF64UConvertI64); |
| 2122 EXPECT_LENGTH(1, kExprF64ConvertF32); |
| 2123 EXPECT_LENGTH(1, kExprF64ReinterpretI64); |
| 2124 EXPECT_LENGTH(1, kExprI32ReinterpretF32); |
| 2125 EXPECT_LENGTH(1, kExprI64ReinterpretF64); |
| 2126 } |
| 2127 |
| 2128 |
| 2129 class WasmOpcodeArityTest : public TestWithZone { |
| 2130 public: |
| 2131 WasmOpcodeArityTest() : TestWithZone() {} |
| 2132 }; |
| 2133 |
| 2134 |
| 2135 #define EXPECT_ARITY(expected, ...) \ |
| 2136 { \ |
| 2137 static const byte code[] = {__VA_ARGS__}; \ |
| 2138 EXPECT_EQ(expected, OpcodeArity(&env, code)); \ |
| 2139 } |
| 2140 |
| 2141 |
| 2142 TEST_F(WasmOpcodeArityTest, Control) { |
| 2143 FunctionEnv env; |
| 2144 EXPECT_ARITY(0, kExprNop); |
| 2145 |
| 2146 EXPECT_ARITY(0, kExprBlock, 0); |
| 2147 EXPECT_ARITY(1, kExprBlock, 1); |
| 2148 EXPECT_ARITY(2, kExprBlock, 2); |
| 2149 EXPECT_ARITY(5, kExprBlock, 5); |
| 2150 EXPECT_ARITY(10, kExprBlock, 10); |
| 2151 |
| 2152 EXPECT_ARITY(0, kExprLoop, 0); |
| 2153 EXPECT_ARITY(1, kExprLoop, 1); |
| 2154 EXPECT_ARITY(2, kExprLoop, 2); |
| 2155 EXPECT_ARITY(7, kExprLoop, 7); |
| 2156 EXPECT_ARITY(11, kExprLoop, 11); |
| 2157 |
| 2158 EXPECT_ARITY(2, kExprIf); |
| 2159 EXPECT_ARITY(3, kExprIfElse); |
| 2160 EXPECT_ARITY(3, kExprSelect); |
| 2161 |
| 2162 EXPECT_ARITY(1, kExprBr); |
| 2163 EXPECT_ARITY(2, kExprBrIf); |
| 2164 |
| 2165 { |
| 2166 TestSignatures sigs; |
| 2167 FunctionEnv env; |
| 2168 WasmDecoderTest::init_env(&env, sigs.v_v()); |
| 2169 EXPECT_ARITY(0, kExprReturn); |
| 2170 WasmDecoderTest::init_env(&env, sigs.i_i()); |
| 2171 EXPECT_ARITY(1, kExprReturn); |
| 2172 } |
| 2173 } |
| 2174 |
| 2175 |
| 2176 TEST_F(WasmOpcodeArityTest, Misc) { |
| 2177 FunctionEnv env; |
| 2178 |
| 2179 EXPECT_ARITY(0, kExprI8Const); |
| 2180 EXPECT_ARITY(0, kExprI32Const); |
| 2181 EXPECT_ARITY(0, kExprF32Const); |
| 2182 EXPECT_ARITY(0, kExprI64Const); |
| 2183 EXPECT_ARITY(0, kExprF64Const); |
| 2184 EXPECT_ARITY(0, kExprGetLocal); |
| 2185 EXPECT_ARITY(1, kExprSetLocal); |
| 2186 EXPECT_ARITY(0, kExprLoadGlobal); |
| 2187 EXPECT_ARITY(1, kExprStoreGlobal); |
| 2188 } |
| 2189 |
| 2190 |
| 2191 TEST_F(WasmOpcodeArityTest, Calls) { |
| 2192 TestSignatures sigs; |
| 2193 TestModuleEnv module; |
| 2194 module.AddFunction(sigs.i_ii()); |
| 2195 module.AddFunction(sigs.i_i()); |
| 2196 |
| 2197 module.AddSignature(sigs.f_ff()); |
| 2198 module.AddSignature(sigs.i_d()); |
| 2199 |
| 2200 { |
| 2201 FunctionEnv env; |
| 2202 WasmDecoderTest::init_env(&env, sigs.i_ii()); |
| 2203 env.module = &module; |
| 2204 |
| 2205 EXPECT_ARITY(2, kExprCallFunction, 0); |
| 2206 EXPECT_ARITY(3, kExprCallIndirect, 0); |
| 2207 EXPECT_ARITY(1, kExprBr); |
| 2208 EXPECT_ARITY(2, kExprBrIf); |
| 2209 } |
| 2210 |
| 2211 { |
| 2212 FunctionEnv env; |
| 2213 WasmDecoderTest::init_env(&env, sigs.v_v()); |
| 2214 env.module = &module; |
| 2215 |
| 2216 EXPECT_ARITY(1, kExprCallFunction, 1); |
| 2217 EXPECT_ARITY(2, kExprCallIndirect, 1); |
| 2218 EXPECT_ARITY(1, kExprBr); |
| 2219 EXPECT_ARITY(2, kExprBrIf); |
| 2220 } |
| 2221 } |
| 2222 |
| 2223 |
| 2224 TEST_F(WasmOpcodeArityTest, LoadsAndStores) { |
| 2225 FunctionEnv env; |
| 2226 |
| 2227 EXPECT_ARITY(1, kExprI32LoadMem8S); |
| 2228 EXPECT_ARITY(1, kExprI32LoadMem8U); |
| 2229 EXPECT_ARITY(1, kExprI32LoadMem16S); |
| 2230 EXPECT_ARITY(1, kExprI32LoadMem16U); |
| 2231 EXPECT_ARITY(1, kExprI32LoadMem); |
| 2232 |
| 2233 EXPECT_ARITY(1, kExprI64LoadMem8S); |
| 2234 EXPECT_ARITY(1, kExprI64LoadMem8U); |
| 2235 EXPECT_ARITY(1, kExprI64LoadMem16S); |
| 2236 EXPECT_ARITY(1, kExprI64LoadMem16U); |
| 2237 EXPECT_ARITY(1, kExprI64LoadMem32S); |
| 2238 EXPECT_ARITY(1, kExprI64LoadMem32U); |
| 2239 EXPECT_ARITY(1, kExprI64LoadMem); |
| 2240 EXPECT_ARITY(1, kExprF32LoadMem); |
| 2241 EXPECT_ARITY(1, kExprF64LoadMem); |
| 2242 |
| 2243 EXPECT_ARITY(2, kExprI32StoreMem8); |
| 2244 EXPECT_ARITY(2, kExprI32StoreMem16); |
| 2245 EXPECT_ARITY(2, kExprI32StoreMem); |
| 2246 EXPECT_ARITY(2, kExprI64StoreMem8); |
| 2247 EXPECT_ARITY(2, kExprI64StoreMem16); |
| 2248 EXPECT_ARITY(2, kExprI64StoreMem32); |
| 2249 EXPECT_ARITY(2, kExprI64StoreMem); |
| 2250 EXPECT_ARITY(2, kExprF32StoreMem); |
| 2251 EXPECT_ARITY(2, kExprF64StoreMem); |
| 2252 } |
| 2253 |
| 2254 |
| 2255 TEST_F(WasmOpcodeArityTest, MiscMemExpressions) { |
| 2256 FunctionEnv env; |
| 2257 |
| 2258 EXPECT_ARITY(0, kExprMemorySize); |
| 2259 EXPECT_ARITY(1, kExprGrowMemory); |
| 2260 } |
| 2261 |
| 2262 |
| 2263 TEST_F(WasmOpcodeArityTest, SimpleExpressions) { |
| 2264 FunctionEnv env; |
| 2265 |
| 2266 EXPECT_ARITY(2, kExprI32Add); |
| 2267 EXPECT_ARITY(2, kExprI32Sub); |
| 2268 EXPECT_ARITY(2, kExprI32Mul); |
| 2269 EXPECT_ARITY(2, kExprI32DivS); |
| 2270 EXPECT_ARITY(2, kExprI32DivU); |
| 2271 EXPECT_ARITY(2, kExprI32RemS); |
| 2272 EXPECT_ARITY(2, kExprI32RemU); |
| 2273 EXPECT_ARITY(2, kExprI32And); |
| 2274 EXPECT_ARITY(2, kExprI32Ior); |
| 2275 EXPECT_ARITY(2, kExprI32Xor); |
| 2276 EXPECT_ARITY(2, kExprI32Shl); |
| 2277 EXPECT_ARITY(2, kExprI32ShrU); |
| 2278 EXPECT_ARITY(2, kExprI32ShrS); |
| 2279 EXPECT_ARITY(2, kExprI32Eq); |
| 2280 EXPECT_ARITY(2, kExprI32Ne); |
| 2281 EXPECT_ARITY(2, kExprI32LtS); |
| 2282 EXPECT_ARITY(2, kExprI32LeS); |
| 2283 EXPECT_ARITY(2, kExprI32LtU); |
| 2284 EXPECT_ARITY(2, kExprI32LeU); |
| 2285 EXPECT_ARITY(2, kExprI32GtS); |
| 2286 EXPECT_ARITY(2, kExprI32GeS); |
| 2287 EXPECT_ARITY(2, kExprI32GtU); |
| 2288 EXPECT_ARITY(2, kExprI32GeU); |
| 2289 EXPECT_ARITY(1, kExprI32Clz); |
| 2290 EXPECT_ARITY(1, kExprI32Ctz); |
| 2291 EXPECT_ARITY(1, kExprI32Popcnt); |
| 2292 EXPECT_ARITY(1, kExprBoolNot); |
| 2293 EXPECT_ARITY(2, kExprI64Add); |
| 2294 EXPECT_ARITY(2, kExprI64Sub); |
| 2295 EXPECT_ARITY(2, kExprI64Mul); |
| 2296 EXPECT_ARITY(2, kExprI64DivS); |
| 2297 EXPECT_ARITY(2, kExprI64DivU); |
| 2298 EXPECT_ARITY(2, kExprI64RemS); |
| 2299 EXPECT_ARITY(2, kExprI64RemU); |
| 2300 EXPECT_ARITY(2, kExprI64And); |
| 2301 EXPECT_ARITY(2, kExprI64Ior); |
| 2302 EXPECT_ARITY(2, kExprI64Xor); |
| 2303 EXPECT_ARITY(2, kExprI64Shl); |
| 2304 EXPECT_ARITY(2, kExprI64ShrU); |
| 2305 EXPECT_ARITY(2, kExprI64ShrS); |
| 2306 EXPECT_ARITY(2, kExprI64Eq); |
| 2307 EXPECT_ARITY(2, kExprI64Ne); |
| 2308 EXPECT_ARITY(2, kExprI64LtS); |
| 2309 EXPECT_ARITY(2, kExprI64LeS); |
| 2310 EXPECT_ARITY(2, kExprI64LtU); |
| 2311 EXPECT_ARITY(2, kExprI64LeU); |
| 2312 EXPECT_ARITY(2, kExprI64GtS); |
| 2313 EXPECT_ARITY(2, kExprI64GeS); |
| 2314 EXPECT_ARITY(2, kExprI64GtU); |
| 2315 EXPECT_ARITY(2, kExprI64GeU); |
| 2316 EXPECT_ARITY(1, kExprI64Clz); |
| 2317 EXPECT_ARITY(1, kExprI64Ctz); |
| 2318 EXPECT_ARITY(1, kExprI64Popcnt); |
| 2319 EXPECT_ARITY(2, kExprF32Add); |
| 2320 EXPECT_ARITY(2, kExprF32Sub); |
| 2321 EXPECT_ARITY(2, kExprF32Mul); |
| 2322 EXPECT_ARITY(2, kExprF32Div); |
| 2323 EXPECT_ARITY(2, kExprF32Min); |
| 2324 EXPECT_ARITY(2, kExprF32Max); |
| 2325 EXPECT_ARITY(1, kExprF32Abs); |
| 2326 EXPECT_ARITY(1, kExprF32Neg); |
| 2327 EXPECT_ARITY(2, kExprF32CopySign); |
| 2328 EXPECT_ARITY(1, kExprF32Ceil); |
| 2329 EXPECT_ARITY(1, kExprF32Floor); |
| 2330 EXPECT_ARITY(1, kExprF32Trunc); |
| 2331 EXPECT_ARITY(1, kExprF32NearestInt); |
| 2332 EXPECT_ARITY(1, kExprF32Sqrt); |
| 2333 EXPECT_ARITY(2, kExprF32Eq); |
| 2334 EXPECT_ARITY(2, kExprF32Ne); |
| 2335 EXPECT_ARITY(2, kExprF32Lt); |
| 2336 EXPECT_ARITY(2, kExprF32Le); |
| 2337 EXPECT_ARITY(2, kExprF32Gt); |
| 2338 EXPECT_ARITY(2, kExprF32Ge); |
| 2339 EXPECT_ARITY(2, kExprF64Add); |
| 2340 EXPECT_ARITY(2, kExprF64Sub); |
| 2341 EXPECT_ARITY(2, kExprF64Mul); |
| 2342 EXPECT_ARITY(2, kExprF64Div); |
| 2343 EXPECT_ARITY(2, kExprF64Min); |
| 2344 EXPECT_ARITY(2, kExprF64Max); |
| 2345 EXPECT_ARITY(1, kExprF64Abs); |
| 2346 EXPECT_ARITY(1, kExprF64Neg); |
| 2347 EXPECT_ARITY(2, kExprF64CopySign); |
| 2348 EXPECT_ARITY(1, kExprF64Ceil); |
| 2349 EXPECT_ARITY(1, kExprF64Floor); |
| 2350 EXPECT_ARITY(1, kExprF64Trunc); |
| 2351 EXPECT_ARITY(1, kExprF64NearestInt); |
| 2352 EXPECT_ARITY(1, kExprF64Sqrt); |
| 2353 EXPECT_ARITY(2, kExprF64Eq); |
| 2354 EXPECT_ARITY(2, kExprF64Ne); |
| 2355 EXPECT_ARITY(2, kExprF64Lt); |
| 2356 EXPECT_ARITY(2, kExprF64Le); |
| 2357 EXPECT_ARITY(2, kExprF64Gt); |
| 2358 EXPECT_ARITY(2, kExprF64Ge); |
| 2359 EXPECT_ARITY(1, kExprI32SConvertF32); |
| 2360 EXPECT_ARITY(1, kExprI32SConvertF64); |
| 2361 EXPECT_ARITY(1, kExprI32UConvertF32); |
| 2362 EXPECT_ARITY(1, kExprI32UConvertF64); |
| 2363 EXPECT_ARITY(1, kExprI32ConvertI64); |
| 2364 EXPECT_ARITY(1, kExprI64SConvertF32); |
| 2365 EXPECT_ARITY(1, kExprI64SConvertF64); |
| 2366 EXPECT_ARITY(1, kExprI64UConvertF32); |
| 2367 EXPECT_ARITY(1, kExprI64UConvertF64); |
| 2368 EXPECT_ARITY(1, kExprI64SConvertI32); |
| 2369 EXPECT_ARITY(1, kExprI64UConvertI32); |
| 2370 EXPECT_ARITY(1, kExprF32SConvertI32); |
| 2371 EXPECT_ARITY(1, kExprF32UConvertI32); |
| 2372 EXPECT_ARITY(1, kExprF32SConvertI64); |
| 2373 EXPECT_ARITY(1, kExprF32UConvertI64); |
| 2374 EXPECT_ARITY(1, kExprF32ConvertF64); |
| 2375 EXPECT_ARITY(1, kExprF32ReinterpretI32); |
| 2376 EXPECT_ARITY(1, kExprF64SConvertI32); |
| 2377 EXPECT_ARITY(1, kExprF64UConvertI32); |
| 2378 EXPECT_ARITY(1, kExprF64SConvertI64); |
| 2379 EXPECT_ARITY(1, kExprF64UConvertI64); |
| 2380 EXPECT_ARITY(1, kExprF64ConvertF32); |
| 2381 EXPECT_ARITY(1, kExprF64ReinterpretI64); |
| 2382 EXPECT_ARITY(1, kExprI32ReinterpretF32); |
| 2383 EXPECT_ARITY(1, kExprI64ReinterpretF64); |
| 2384 } |
| 2385 } // namespace wasm |
| 2386 } // namespace internal |
| 2387 } // namespace v8 |
OLD | NEW |