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/platform/elapsed-timer.h" | 9 #include "src/base/platform/elapsed-timer.h" |
10 | 10 |
(...skipping 969 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
980 WASM_EXEC_TEST(F32ReinterpretI32) { | 980 WASM_EXEC_TEST(F32ReinterpretI32) { |
981 TestingModule module(execution_mode); | 981 TestingModule module(execution_mode); |
982 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 982 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
983 WasmRunner<int32_t> r(&module); | 983 WasmRunner<int32_t> r(&module); |
984 | 984 |
985 BUILD(r, WASM_I32_REINTERPRET_F32( | 985 BUILD(r, WASM_I32_REINTERPRET_F32( |
986 WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO))); | 986 WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO))); |
987 | 987 |
988 FOR_INT32_INPUTS(i) { | 988 FOR_INT32_INPUTS(i) { |
989 int32_t expected = *i; | 989 int32_t expected = *i; |
990 memory[0] = expected; | 990 module.WriteMemory(&memory[0], expected); |
991 CHECK_EQ(expected, r.Call()); | 991 CHECK_EQ(expected, r.Call()); |
992 } | 992 } |
993 } | 993 } |
994 | 994 |
995 WASM_EXEC_TEST(I32ReinterpretF32) { | 995 WASM_EXEC_TEST(I32ReinterpretF32) { |
996 TestingModule module(execution_mode); | 996 TestingModule module(execution_mode); |
997 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 997 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
998 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 998 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
999 | 999 |
1000 BUILD(r, WASM_BLOCK( | 1000 BUILD(r, WASM_BLOCK( |
1001 2, WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, | 1001 2, WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, |
1002 WASM_F32_REINTERPRET_I32(WASM_GET_LOCAL(0))), | 1002 WASM_F32_REINTERPRET_I32(WASM_GET_LOCAL(0))), |
1003 WASM_I8(107))); | 1003 WASM_I8(107))); |
1004 | 1004 |
1005 FOR_INT32_INPUTS(i) { | 1005 FOR_INT32_INPUTS(i) { |
1006 int32_t expected = *i; | 1006 int32_t expected = *i; |
1007 CHECK_EQ(107, r.Call(expected)); | 1007 CHECK_EQ(107, r.Call(expected)); |
1008 CHECK_EQ(expected, memory[0]); | 1008 CHECK_EQ(expected, module.ReadMemory(&memory[0])); |
1009 } | 1009 } |
1010 } | 1010 } |
1011 | 1011 |
1012 WASM_EXEC_TEST(ReturnStore) { | 1012 WASM_EXEC_TEST(ReturnStore) { |
1013 TestingModule module(execution_mode); | 1013 TestingModule module(execution_mode); |
1014 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 1014 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
1015 WasmRunner<int32_t> r(&module); | 1015 WasmRunner<int32_t> r(&module); |
1016 | 1016 |
1017 BUILD(r, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO, | 1017 BUILD(r, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO, |
1018 WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO))); | 1018 WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO))); |
1019 | 1019 |
1020 FOR_INT32_INPUTS(i) { | 1020 FOR_INT32_INPUTS(i) { |
1021 int32_t expected = *i; | 1021 int32_t expected = *i; |
1022 memory[0] = expected; | 1022 module.WriteMemory(&memory[0], expected); |
1023 CHECK_EQ(expected, r.Call()); | 1023 CHECK_EQ(expected, r.Call()); |
1024 } | 1024 } |
1025 } | 1025 } |
1026 | 1026 |
1027 WASM_EXEC_TEST(VoidReturn1) { | 1027 WASM_EXEC_TEST(VoidReturn1) { |
1028 // We use a wrapper function because WasmRunner<void> does not exist. | 1028 // We use a wrapper function because WasmRunner<void> does not exist. |
1029 | 1029 |
1030 // Build the test function. | 1030 // Build the test function. |
1031 TestSignatures sigs; | 1031 TestSignatures sigs; |
1032 TestingModule module(execution_mode); | 1032 TestingModule module(execution_mode); |
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1302 } | 1302 } |
1303 | 1303 |
1304 WASM_EXEC_TEST(LoadMemI32) { | 1304 WASM_EXEC_TEST(LoadMemI32) { |
1305 TestingModule module(execution_mode); | 1305 TestingModule module(execution_mode); |
1306 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 1306 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
1307 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1307 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1308 module.RandomizeMemory(1111); | 1308 module.RandomizeMemory(1111); |
1309 | 1309 |
1310 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(0))); | 1310 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(0))); |
1311 | 1311 |
1312 memory[0] = 99999999; | 1312 module.WriteMemory(&memory[0], 99999999); |
1313 CHECK_EQ(99999999, r.Call(0)); | 1313 CHECK_EQ(99999999, r.Call(0)); |
1314 | 1314 |
1315 memory[0] = 88888888; | 1315 module.WriteMemory(&memory[0], 88888888); |
1316 CHECK_EQ(88888888, r.Call(0)); | 1316 CHECK_EQ(88888888, r.Call(0)); |
1317 | 1317 |
1318 memory[0] = 77777777; | 1318 module.WriteMemory(&memory[0], 77777777); |
1319 CHECK_EQ(77777777, r.Call(0)); | 1319 CHECK_EQ(77777777, r.Call(0)); |
1320 } | 1320 } |
1321 | 1321 |
1322 WASM_EXEC_TEST(LoadMemI32_alignment) { | 1322 WASM_EXEC_TEST(LoadMemI32_alignment) { |
1323 TestingModule module(execution_mode); | 1323 TestingModule module(execution_mode); |
1324 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 1324 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
1325 for (byte alignment = 0; alignment <= 2; alignment++) { | 1325 for (byte alignment = 0; alignment <= 2; alignment++) { |
1326 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1326 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1327 module.RandomizeMemory(1111); | 1327 module.RandomizeMemory(1111); |
1328 | 1328 |
1329 BUILD(r, | 1329 BUILD(r, |
1330 WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_I8(0), alignment)); | 1330 WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_I8(0), alignment)); |
1331 | 1331 |
1332 memory[0] = 0x1a2b3c4d; | 1332 module.WriteMemory(&memory[0], 0x1a2b3c4d); |
1333 CHECK_EQ(0x1a2b3c4d, r.Call(0)); | 1333 CHECK_EQ(0x1a2b3c4d, r.Call(0)); |
1334 | 1334 |
1335 memory[0] = 0x5e6f7a8b; | 1335 module.WriteMemory(&memory[0], 0x5e6f7a8b); |
1336 CHECK_EQ(0x5e6f7a8b, r.Call(0)); | 1336 CHECK_EQ(0x5e6f7a8b, r.Call(0)); |
1337 | 1337 |
1338 memory[0] = 0x9ca0b1c2; | 1338 module.WriteMemory(&memory[0], 0x7ca0b1c2); |
1339 CHECK_EQ(0x9ca0b1c2, r.Call(0)); | 1339 CHECK_EQ(0x7ca0b1c2, r.Call(0)); |
1340 } | 1340 } |
1341 } | 1341 } |
1342 | 1342 |
1343 WASM_EXEC_TEST(LoadMemI32_oob) { | 1343 WASM_EXEC_TEST(LoadMemI32_oob) { |
1344 TestingModule module(execution_mode); | 1344 TestingModule module(execution_mode); |
1345 int32_t* memory = module.AddMemoryElems<int32_t>(8); | 1345 int32_t* memory = module.AddMemoryElems<int32_t>(8); |
1346 WasmRunner<int32_t> r(&module, MachineType::Uint32()); | 1346 WasmRunner<int32_t> r(&module, MachineType::Uint32()); |
1347 module.RandomizeMemory(1111); | 1347 module.RandomizeMemory(1111); |
1348 | 1348 |
1349 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0))); | 1349 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0))); |
1350 | 1350 |
1351 memory[0] = 88888888; | 1351 module.WriteMemory(&memory[0], 88888888); |
1352 CHECK_EQ(88888888, r.Call(0u)); | 1352 CHECK_EQ(88888888, r.Call(0u)); |
1353 for (uint32_t offset = 29; offset < 40; offset++) { | 1353 for (uint32_t offset = 29; offset < 40; offset++) { |
1354 CHECK_TRAP(r.Call(offset)); | 1354 CHECK_TRAP(r.Call(offset)); |
1355 } | 1355 } |
1356 | 1356 |
1357 for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) { | 1357 for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) { |
1358 CHECK_TRAP(r.Call(offset)); | 1358 CHECK_TRAP(r.Call(offset)); |
1359 } | 1359 } |
1360 } | 1360 } |
1361 | 1361 |
(...skipping 24 matching lines...) Expand all Loading... |
1386 } | 1386 } |
1387 | 1387 |
1388 WASM_EXEC_TEST(LoadMemI32_offset) { | 1388 WASM_EXEC_TEST(LoadMemI32_offset) { |
1389 TestingModule module(execution_mode); | 1389 TestingModule module(execution_mode); |
1390 int32_t* memory = module.AddMemoryElems<int32_t>(4); | 1390 int32_t* memory = module.AddMemoryElems<int32_t>(4); |
1391 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1391 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1392 module.RandomizeMemory(1111); | 1392 module.RandomizeMemory(1111); |
1393 | 1393 |
1394 BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0))); | 1394 BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0))); |
1395 | 1395 |
1396 memory[0] = 66666666; | 1396 module.WriteMemory(&memory[0], 66666666); |
1397 memory[1] = 77777777; | 1397 module.WriteMemory(&memory[1], 77777777); |
1398 memory[2] = 88888888; | 1398 module.WriteMemory(&memory[2], 88888888); |
1399 memory[3] = 99999999; | 1399 module.WriteMemory(&memory[3], 99999999); |
1400 CHECK_EQ(77777777, r.Call(0)); | 1400 CHECK_EQ(77777777, r.Call(0)); |
1401 CHECK_EQ(88888888, r.Call(4)); | 1401 CHECK_EQ(88888888, r.Call(4)); |
1402 CHECK_EQ(99999999, r.Call(8)); | 1402 CHECK_EQ(99999999, r.Call(8)); |
1403 | 1403 |
1404 memory[0] = 11111111; | 1404 module.WriteMemory(&memory[0], 11111111); |
1405 memory[1] = 22222222; | 1405 module.WriteMemory(&memory[1], 22222222); |
1406 memory[2] = 33333333; | 1406 module.WriteMemory(&memory[2], 33333333); |
1407 memory[3] = 44444444; | 1407 module.WriteMemory(&memory[3], 44444444); |
1408 CHECK_EQ(22222222, r.Call(0)); | 1408 CHECK_EQ(22222222, r.Call(0)); |
1409 CHECK_EQ(33333333, r.Call(4)); | 1409 CHECK_EQ(33333333, r.Call(4)); |
1410 CHECK_EQ(44444444, r.Call(8)); | 1410 CHECK_EQ(44444444, r.Call(8)); |
1411 } | 1411 } |
1412 | 1412 |
1413 WASM_EXEC_TEST(LoadMemI32_const_oob_misaligned) { | 1413 WASM_EXEC_TEST(LoadMemI32_const_oob_misaligned) { |
1414 const int kMemSize = 12; | 1414 const int kMemSize = 12; |
1415 // TODO(titzer): Fix misaligned accesses on MIPS and re-enable. | 1415 // TODO(titzer): Fix misaligned accesses on MIPS and re-enable. |
1416 for (int offset = 0; offset < kMemSize + 5; offset++) { | 1416 for (int offset = 0; offset < kMemSize + 5; offset++) { |
1417 for (int index = 0; index < kMemSize + 5; index++) { | 1417 for (int index = 0; index < kMemSize + 5; index++) { |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1461 const int32_t kWritten = 0x12345678; | 1461 const int32_t kWritten = 0x12345678; |
1462 | 1462 |
1463 for (byte i = 0; i <= 2; i++) { | 1463 for (byte i = 0; i <= 2; i++) { |
1464 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1464 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1465 BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int32(), WASM_ZERO, i, | 1465 BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int32(), WASM_ZERO, i, |
1466 WASM_GET_LOCAL(0))); | 1466 WASM_GET_LOCAL(0))); |
1467 module.RandomizeMemory(1111); | 1467 module.RandomizeMemory(1111); |
1468 memory[0] = 0; | 1468 memory[0] = 0; |
1469 | 1469 |
1470 CHECK_EQ(kWritten, r.Call(kWritten)); | 1470 CHECK_EQ(kWritten, r.Call(kWritten)); |
1471 CHECK_EQ(kWritten, memory[0]); | 1471 CHECK_EQ(kWritten, module.ReadMemory(&memory[0])); |
1472 } | 1472 } |
1473 } | 1473 } |
1474 | 1474 |
1475 WASM_EXEC_TEST(StoreMemI32_offset) { | 1475 WASM_EXEC_TEST(StoreMemI32_offset) { |
1476 TestingModule module(execution_mode); | 1476 TestingModule module(execution_mode); |
1477 int32_t* memory = module.AddMemoryElems<int32_t>(4); | 1477 int32_t* memory = module.AddMemoryElems<int32_t>(4); |
1478 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1478 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1479 const int32_t kWritten = 0xaabbccdd; | 1479 const int32_t kWritten = 0xaabbccdd; |
1480 | 1480 |
1481 BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0), | 1481 BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0), |
1482 WASM_I32V_5(kWritten))); | 1482 WASM_I32V_5(kWritten))); |
1483 | 1483 |
1484 for (int i = 0; i < 2; i++) { | 1484 for (int i = 0; i < 2; i++) { |
1485 module.RandomizeMemory(1111); | 1485 module.RandomizeMemory(1111); |
1486 memory[0] = 66666666; | 1486 module.WriteMemory(&memory[0], 66666666); |
1487 memory[1] = 77777777; | 1487 module.WriteMemory(&memory[1], 77777777); |
1488 memory[2] = 88888888; | 1488 module.WriteMemory(&memory[2], 88888888); |
1489 memory[3] = 99999999; | 1489 module.WriteMemory(&memory[3], 99999999); |
1490 CHECK_EQ(kWritten, r.Call(i * 4)); | 1490 CHECK_EQ(kWritten, r.Call(i * 4)); |
1491 CHECK_EQ(66666666, memory[0]); | 1491 CHECK_EQ(66666666, module.ReadMemory(&memory[0])); |
1492 CHECK_EQ(i == 0 ? kWritten : 77777777, memory[1]); | 1492 CHECK_EQ(i == 0 ? kWritten : 77777777, module.ReadMemory(&memory[1])); |
1493 CHECK_EQ(i == 1 ? kWritten : 88888888, memory[2]); | 1493 CHECK_EQ(i == 1 ? kWritten : 88888888, module.ReadMemory(&memory[2])); |
1494 CHECK_EQ(i == 2 ? kWritten : 99999999, memory[3]); | 1494 CHECK_EQ(i == 2 ? kWritten : 99999999, module.ReadMemory(&memory[3])); |
1495 } | 1495 } |
1496 } | 1496 } |
1497 | 1497 |
1498 WASM_EXEC_TEST(StoreMem_offset_oob) { | 1498 WASM_EXEC_TEST(StoreMem_offset_oob) { |
1499 TestingModule module(execution_mode); | 1499 TestingModule module(execution_mode); |
1500 byte* memory = module.AddMemoryElems<byte>(32); | 1500 byte* memory = module.AddMemoryElems<byte>(32); |
1501 | 1501 |
1502 #if WASM_64 | 1502 #if WASM_64 |
1503 static const MachineType machineTypes[] = { | 1503 static const MachineType machineTypes[] = { |
1504 MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(), | 1504 MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(), |
(...skipping 29 matching lines...) Expand all Loading... |
1534 WASM_EXEC_TEST(LoadMemI32_P) { | 1534 WASM_EXEC_TEST(LoadMemI32_P) { |
1535 const int kNumElems = 8; | 1535 const int kNumElems = 8; |
1536 TestingModule module(execution_mode); | 1536 TestingModule module(execution_mode); |
1537 int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems); | 1537 int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems); |
1538 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1538 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1539 module.RandomizeMemory(2222); | 1539 module.RandomizeMemory(2222); |
1540 | 1540 |
1541 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0))); | 1541 BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0))); |
1542 | 1542 |
1543 for (int i = 0; i < kNumElems; i++) { | 1543 for (int i = 0; i < kNumElems; i++) { |
1544 CHECK_EQ(memory[i], r.Call(i * 4)); | 1544 CHECK_EQ(module.ReadMemory(&memory[i]), r.Call(i * 4)); |
1545 } | 1545 } |
1546 } | 1546 } |
1547 | 1547 |
1548 WASM_EXEC_TEST(MemI32_Sum) { | 1548 WASM_EXEC_TEST(MemI32_Sum) { |
1549 const int kNumElems = 20; | 1549 const int kNumElems = 20; |
1550 TestingModule module(execution_mode); | 1550 TestingModule module(execution_mode); |
1551 uint32_t* memory = module.AddMemoryElems<uint32_t>(kNumElems); | 1551 uint32_t* memory = module.AddMemoryElems<uint32_t>(kNumElems); |
1552 WasmRunner<uint32_t> r(&module, MachineType::Int32()); | 1552 WasmRunner<uint32_t> r(&module, MachineType::Int32()); |
1553 const byte kSum = r.AllocateLocal(kAstI32); | 1553 const byte kSum = r.AllocateLocal(kAstI32); |
1554 | 1554 |
1555 BUILD(r, WASM_BLOCK( | 1555 BUILD(r, WASM_BLOCK( |
1556 2, WASM_WHILE( | 1556 2, WASM_WHILE( |
1557 WASM_GET_LOCAL(0), | 1557 WASM_GET_LOCAL(0), |
1558 WASM_BLOCK( | 1558 WASM_BLOCK( |
1559 2, WASM_SET_LOCAL( | 1559 2, WASM_SET_LOCAL( |
1560 kSum, WASM_I32_ADD( | 1560 kSum, WASM_I32_ADD( |
1561 WASM_GET_LOCAL(kSum), | 1561 WASM_GET_LOCAL(kSum), |
1562 WASM_LOAD_MEM(MachineType::Int32(), | 1562 WASM_LOAD_MEM(MachineType::Int32(), |
1563 WASM_GET_LOCAL(0)))), | 1563 WASM_GET_LOCAL(0)))), |
1564 WASM_SET_LOCAL( | 1564 WASM_SET_LOCAL( |
1565 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))), | 1565 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))), |
1566 WASM_GET_LOCAL(1))); | 1566 WASM_GET_LOCAL(1))); |
1567 | 1567 |
1568 // Run 4 trials. | 1568 // Run 4 trials. |
1569 for (int i = 0; i < 3; i++) { | 1569 for (int i = 0; i < 3; i++) { |
1570 module.RandomizeMemory(i * 33); | 1570 module.RandomizeMemory(i * 33); |
1571 uint32_t expected = 0; | 1571 uint32_t expected = 0; |
1572 for (size_t j = kNumElems - 1; j > 0; j--) { | 1572 for (size_t j = kNumElems - 1; j > 0; j--) { |
1573 expected += memory[j]; | 1573 expected += module.ReadMemory(&memory[j]); |
1574 } | 1574 } |
1575 uint32_t result = r.Call(static_cast<int>(4 * (kNumElems - 1))); | 1575 uint32_t result = r.Call(static_cast<int>(4 * (kNumElems - 1))); |
1576 CHECK_EQ(expected, result); | 1576 CHECK_EQ(expected, result); |
1577 } | 1577 } |
1578 } | 1578 } |
1579 | 1579 |
1580 WASM_EXEC_TEST(CheckMachIntsZero) { | 1580 WASM_EXEC_TEST(CheckMachIntsZero) { |
1581 const int kNumElems = 55; | 1581 const int kNumElems = 55; |
1582 TestingModule module(execution_mode); | 1582 TestingModule module(execution_mode); |
1583 module.AddMemoryElems<uint32_t>(kNumElems); | 1583 module.AddMemoryElems<uint32_t>(kNumElems); |
1584 WasmRunner<uint32_t> r(&module, MachineType::Int32()); | 1584 WasmRunner<uint32_t> r(&module, MachineType::Int32()); |
1585 | 1585 |
1586 BUILD(r, kExprLoop, kExprGetLocal, 0, kExprIf, kExprGetLocal, 0, | 1586 BUILD(r, kExprLoop, kExprGetLocal, 0, kExprIf, kExprGetLocal, 0, |
1587 kExprI32LoadMem, 0, 0, kExprIf, kExprI8Const, 255, kExprReturn, ARITY_1, | 1587 kExprI32LoadMem, 0, 0, kExprIf, kExprI8Const, 255, kExprReturn, ARITY_1, |
1588 kExprEnd, kExprGetLocal, 0, kExprI8Const, 4, kExprI32Sub, kExprSetLocal, | 1588 kExprEnd, kExprGetLocal, 0, kExprI8Const, 4, kExprI32Sub, kExprSetLocal, |
1589 0, kExprBr, ARITY_1, DEPTH_0, kExprEnd, kExprEnd, kExprI8Const, 0); | 1589 0, kExprBr, ARITY_1, DEPTH_0, kExprEnd, kExprEnd, kExprI8Const, 0); |
1590 | 1590 |
1591 module.BlankMemory(); | 1591 module.BlankMemory(); |
1592 CHECK_EQ(0, r.Call((kNumElems - 1) * 4)); | 1592 CHECK_EQ(0, r.Call((kNumElems - 1) * 4)); |
1593 } | 1593 } |
1594 | 1594 |
1595 WASM_EXEC_TEST(MemF32_Sum) { | 1595 WASM_EXEC_TEST(MemF32_Sum) { |
1596 const int kSize = 5; | 1596 const int kSize = 5; |
1597 TestingModule module(execution_mode); | 1597 TestingModule module(execution_mode); |
1598 module.AddMemoryElems<float>(kSize); | 1598 module.AddMemoryElems<float>(kSize); |
1599 float* buffer = module.raw_mem_start<float>(); | 1599 float* buffer = module.raw_mem_start<float>(); |
1600 buffer[0] = -99.25; | 1600 module.WriteMemory(&buffer[0], -99.25f); |
1601 buffer[1] = -888.25; | 1601 module.WriteMemory(&buffer[1], -888.25f); |
1602 buffer[2] = -77.25; | 1602 module.WriteMemory(&buffer[2], -77.25f); |
1603 buffer[3] = 66666.25; | 1603 module.WriteMemory(&buffer[3], 66666.25f); |
1604 buffer[4] = 5555.25; | 1604 module.WriteMemory(&buffer[4], 5555.25f); |
1605 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1605 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1606 const byte kSum = r.AllocateLocal(kAstF32); | 1606 const byte kSum = r.AllocateLocal(kAstF32); |
1607 | 1607 |
1608 BUILD(r, WASM_BLOCK( | 1608 BUILD(r, WASM_BLOCK( |
1609 3, WASM_WHILE( | 1609 3, WASM_WHILE( |
1610 WASM_GET_LOCAL(0), | 1610 WASM_GET_LOCAL(0), |
1611 WASM_BLOCK( | 1611 WASM_BLOCK( |
1612 2, WASM_SET_LOCAL( | 1612 2, WASM_SET_LOCAL( |
1613 kSum, WASM_F32_ADD( | 1613 kSum, WASM_F32_ADD( |
1614 WASM_GET_LOCAL(kSum), | 1614 WASM_GET_LOCAL(kSum), |
1615 WASM_LOAD_MEM(MachineType::Float32(), | 1615 WASM_LOAD_MEM(MachineType::Float32(), |
1616 WASM_GET_LOCAL(0)))), | 1616 WASM_GET_LOCAL(0)))), |
1617 WASM_SET_LOCAL( | 1617 WASM_SET_LOCAL( |
1618 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))), | 1618 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))), |
1619 WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, | 1619 WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, |
1620 WASM_GET_LOCAL(kSum)), | 1620 WASM_GET_LOCAL(kSum)), |
1621 WASM_GET_LOCAL(0))); | 1621 WASM_GET_LOCAL(0))); |
1622 | 1622 |
1623 CHECK_EQ(0, r.Call(4 * (kSize - 1))); | 1623 CHECK_EQ(0, r.Call(4 * (kSize - 1))); |
1624 CHECK_NE(-99.25, buffer[0]); | 1624 CHECK_NE(-99.25f, module.ReadMemory(&buffer[0])); |
1625 CHECK_EQ(71256.0f, buffer[0]); | 1625 CHECK_EQ(71256.0f, module.ReadMemory(&buffer[0])); |
1626 } | 1626 } |
1627 | 1627 |
1628 template <typename T> | 1628 template <typename T> |
1629 T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop, | 1629 T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop, |
1630 T* buffer, size_t size, LocalType astType, | 1630 T* buffer, size_t size, LocalType astType, |
1631 MachineType memType) { | 1631 MachineType memType) { |
1632 TestingModule module(execution_mode); | 1632 TestingModule module(execution_mode); |
1633 module.AddMemoryElems<T>(size); | 1633 T* memory = module.AddMemoryElems<T>(size); |
1634 for (size_t i = 0; i < size; i++) { | 1634 for (size_t i = 0; i < size; i++) { |
1635 module.raw_mem_start<T>()[i] = buffer[i]; | 1635 module.WriteMemory(&memory[i], buffer[i]); |
1636 } | 1636 } |
1637 WasmRunner<int32_t> r(&module, MachineType::Int32()); | 1637 WasmRunner<int32_t> r(&module, MachineType::Int32()); |
1638 const byte kAccum = r.AllocateLocal(astType); | 1638 const byte kAccum = r.AllocateLocal(astType); |
1639 | 1639 |
1640 BUILD( | 1640 BUILD( |
1641 r, | 1641 r, |
1642 WASM_BLOCK( | 1642 WASM_BLOCK( |
1643 4, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)), | 1643 4, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)), |
1644 WASM_WHILE( | 1644 WASM_WHILE( |
1645 WASM_GET_LOCAL(0), | 1645 WASM_GET_LOCAL(0), |
1646 WASM_BLOCK( | 1646 WASM_BLOCK( |
1647 2, WASM_SET_LOCAL( | 1647 2, WASM_SET_LOCAL( |
1648 kAccum, | 1648 kAccum, |
1649 WASM_BINOP(binop, WASM_GET_LOCAL(kAccum), | 1649 WASM_BINOP(binop, WASM_GET_LOCAL(kAccum), |
1650 WASM_LOAD_MEM(memType, WASM_GET_LOCAL(0)))), | 1650 WASM_LOAD_MEM(memType, WASM_GET_LOCAL(0)))), |
1651 WASM_SET_LOCAL( | 1651 WASM_SET_LOCAL( |
1652 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(sizeof(T)))))), | 1652 0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(sizeof(T)))))), |
1653 WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)), | 1653 WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)), |
1654 WASM_GET_LOCAL(0))); | 1654 WASM_GET_LOCAL(0))); |
1655 r.Call(static_cast<int>(sizeof(T) * (size - 1))); | 1655 r.Call(static_cast<int>(sizeof(T) * (size - 1))); |
1656 return module.raw_mem_at<double>(0); | 1656 return module.ReadMemory(&memory[0]); |
1657 } | 1657 } |
1658 | 1658 |
1659 WASM_EXEC_TEST(MemF64_Mul) { | 1659 WASM_EXEC_TEST(MemF64_Mul) { |
1660 const size_t kSize = 6; | 1660 const size_t kSize = 6; |
1661 double buffer[kSize] = {1, 2, 2, 2, 2, 2}; | 1661 double buffer[kSize] = {1, 2, 2, 2, 2, 2}; |
1662 double result = | 1662 double result = |
1663 GenerateAndRunFold<double>(execution_mode, kExprF64Mul, buffer, kSize, | 1663 GenerateAndRunFold<double>(execution_mode, kExprF64Mul, buffer, kSize, |
1664 kAstF64, MachineType::Float64()); | 1664 kAstF64, MachineType::Float64()); |
1665 CHECK_EQ(32, result); | 1665 CHECK_EQ(32, result); |
1666 } | 1666 } |
(...skipping 372 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2039 WASM_F64(32.5), WASM_F64(64.5), WASM_F64(128.5), | 2039 WASM_F64(32.5), WASM_F64(64.5), WASM_F64(128.5), |
2040 WASM_F64(256.5), WASM_F64(512.5))); | 2040 WASM_F64(256.5), WASM_F64(512.5))); |
2041 | 2041 |
2042 float result = r.Call(); | 2042 float result = r.Call(); |
2043 CHECK_EQ(256.5, result); | 2043 CHECK_EQ(256.5, result); |
2044 } | 2044 } |
2045 | 2045 |
2046 WASM_EXEC_TEST(CallVoid) { | 2046 WASM_EXEC_TEST(CallVoid) { |
2047 const byte kMemOffset = 8; | 2047 const byte kMemOffset = 8; |
2048 const int32_t kElemNum = kMemOffset / sizeof(int32_t); | 2048 const int32_t kElemNum = kMemOffset / sizeof(int32_t); |
2049 const int32_t kExpected = -414444; | 2049 const int32_t kExpected = 414444; |
2050 // Build the target function. | 2050 // Build the target function. |
2051 TestSignatures sigs; | 2051 TestSignatures sigs; |
2052 TestingModule module(execution_mode); | 2052 TestingModule module(execution_mode); |
2053 module.AddMemory(16); | 2053 int32_t* memory = module.AddMemoryElems<int32_t>(16 / sizeof(int32_t)); |
2054 module.RandomizeMemory(); | 2054 module.RandomizeMemory(); |
2055 WasmFunctionCompiler t(sigs.v_v(), &module); | 2055 WasmFunctionCompiler t(sigs.v_v(), &module); |
2056 BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I8(kMemOffset), | 2056 BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I8(kMemOffset), |
2057 WASM_I32V_3(kExpected))); | 2057 WASM_I32V_3(kExpected))); |
2058 uint32_t index = t.CompileAndAdd(); | 2058 uint32_t index = t.CompileAndAdd(); |
2059 | 2059 |
2060 // Build the calling function. | 2060 // Build the calling function. |
2061 WasmRunner<int32_t> r(&module); | 2061 WasmRunner<int32_t> r(&module); |
2062 BUILD(r, WASM_CALL_FUNCTION0(index), | 2062 BUILD(r, WASM_CALL_FUNCTION0(index), |
2063 WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kMemOffset))); | 2063 WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kMemOffset))); |
2064 | 2064 |
2065 int32_t result = r.Call(); | 2065 int32_t result = r.Call(); |
2066 CHECK_EQ(kExpected, result); | 2066 CHECK_EQ(kExpected, result); |
2067 CHECK_EQ(kExpected, module.raw_mem_start<int32_t>()[kElemNum]); | 2067 CHECK_EQ(static_cast<int64_t>(kExpected), |
| 2068 static_cast<int64_t>(module.ReadMemory(&memory[kElemNum]))); |
2068 } | 2069 } |
2069 | 2070 |
2070 WASM_EXEC_TEST(Call_Int32Add) { | 2071 WASM_EXEC_TEST(Call_Int32Add) { |
2071 // Build the target function. | 2072 // Build the target function. |
2072 TestSignatures sigs; | 2073 TestSignatures sigs; |
2073 TestingModule module(execution_mode); | 2074 TestingModule module(execution_mode); |
2074 WasmFunctionCompiler t(sigs.i_ii(), &module); | 2075 WasmFunctionCompiler t(sigs.i_ii(), &module); |
2075 BUILD(t, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | 2076 BUILD(t, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); |
2076 uint32_t index = t.CompileAndAdd(); | 2077 uint32_t index = t.CompileAndAdd(); |
2077 | 2078 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2114 BUILD(r, WASM_BLOCK( | 2115 BUILD(r, WASM_BLOCK( |
2115 2, WASM_STORE_MEM( | 2116 2, WASM_STORE_MEM( |
2116 MachineType::Float64(), WASM_ZERO, | 2117 MachineType::Float64(), WASM_ZERO, |
2117 WASM_F64_SUB( | 2118 WASM_F64_SUB( |
2118 WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO), | 2119 WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO), |
2119 WASM_LOAD_MEM(MachineType::Float64(), WASM_I8(8)))), | 2120 WASM_LOAD_MEM(MachineType::Float64(), WASM_I8(8)))), |
2120 WASM_I8(107))); | 2121 WASM_I8(107))); |
2121 | 2122 |
2122 FOR_FLOAT64_INPUTS(i) { | 2123 FOR_FLOAT64_INPUTS(i) { |
2123 FOR_FLOAT64_INPUTS(j) { | 2124 FOR_FLOAT64_INPUTS(j) { |
2124 memory[0] = *i; | 2125 module.WriteMemory(&memory[0], *i); |
2125 memory[1] = *j; | 2126 module.WriteMemory(&memory[1], *j); |
2126 double expected = *i - *j; | 2127 double expected = *i - *j; |
2127 CHECK_EQ(107, r.Call()); | 2128 CHECK_EQ(107, r.Call()); |
| 2129 |
2128 if (expected != expected) { | 2130 if (expected != expected) { |
2129 CHECK(memory[0] != memory[0]); | 2131 CHECK(module.ReadMemory(&memory[0]) != module.ReadMemory(&memory[0])); |
2130 } else { | 2132 } else { |
2131 CHECK_EQ(expected, memory[0]); | 2133 CHECK_EQ(expected, module.ReadMemory(&memory[0])); |
2132 } | 2134 } |
2133 } | 2135 } |
2134 } | 2136 } |
2135 } | 2137 } |
2136 | 2138 |
2137 #define ADD_CODE(vec, ...) \ | 2139 #define ADD_CODE(vec, ...) \ |
2138 do { \ | 2140 do { \ |
2139 byte __buf[] = {__VA_ARGS__}; \ | 2141 byte __buf[] = {__VA_ARGS__}; \ |
2140 for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \ | 2142 for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \ |
2141 } while (false) | 2143 } while (false) |
(...skipping 691 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2833 MachineType::Int32()); | 2835 MachineType::Int32()); |
2834 BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO); | 2836 BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO); |
2835 const int32_t kMin = std::numeric_limits<int32_t>::min(); | 2837 const int32_t kMin = std::numeric_limits<int32_t>::min(); |
2836 CHECK_EQ(0, r.Call(133, 100)); | 2838 CHECK_EQ(0, r.Call(133, 100)); |
2837 CHECK_EQ(0, r.Call(kMin, -1)); | 2839 CHECK_EQ(0, r.Call(kMin, -1)); |
2838 CHECK_EQ(0, r.Call(0, 1)); | 2840 CHECK_EQ(0, r.Call(0, 1)); |
2839 CHECK_TRAP(r.Call(100, 0)); | 2841 CHECK_TRAP(r.Call(100, 0)); |
2840 CHECK_TRAP(r.Call(-1001, 0)); | 2842 CHECK_TRAP(r.Call(-1001, 0)); |
2841 CHECK_TRAP(r.Call(kMin, 0)); | 2843 CHECK_TRAP(r.Call(kMin, 0)); |
2842 } | 2844 } |
OLD | NEW |