LCOV - code coverage report
Current view: top level - test/unittests/wasm - wasm-macro-gen-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 232 232 100.0 %
Date: 2019-04-17 Functions: 30 44 68.2 %

          Line data    Source code
       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 "test/common/wasm/wasm-macro-gen.h"
       8             : 
       9             : namespace v8 {
      10             : namespace internal {
      11             : namespace wasm {
      12             : 
      13          28 : class WasmMacroGenTest : public TestWithZone {};
      14             : 
      15             : #define EXPECT_SIZE(size, ...)                          \
      16             :   do {                                                  \
      17             :     byte code[] = {__VA_ARGS__};                        \
      18             :     USE(code);                                          \
      19             :     EXPECT_EQ(static_cast<size_t>(size), sizeof(code)); \
      20             :   } while (false)
      21             : 
      22       15444 : TEST_F(WasmMacroGenTest, Constants) {
      23           2 :   EXPECT_SIZE(2, WASM_ONE);
      24           2 :   EXPECT_SIZE(2, WASM_ZERO);
      25             : 
      26           2 :   EXPECT_SIZE(2, WASM_I32V_1(-22));
      27           2 :   EXPECT_SIZE(2, WASM_I32V_1(54));
      28             : 
      29           2 :   EXPECT_SIZE(2, WASM_I32V_1(1));
      30           2 :   EXPECT_SIZE(3, WASM_I32V_2(200));
      31           2 :   EXPECT_SIZE(4, WASM_I32V_3(10000));
      32           2 :   EXPECT_SIZE(5, WASM_I32V_4(-9828934));
      33           2 :   EXPECT_SIZE(6, WASM_I32V_5(-1119828934));
      34             : 
      35           2 :   EXPECT_SIZE(2, WASM_I64V_1(1));
      36           2 :   EXPECT_SIZE(3, WASM_I64V_2(300));
      37           2 :   EXPECT_SIZE(4, WASM_I64V_3(10000));
      38           2 :   EXPECT_SIZE(5, WASM_I64V_4(-9828934));
      39           2 :   EXPECT_SIZE(6, WASM_I64V_5(-1119828934));
      40           2 :   EXPECT_SIZE(10, WASM_I64V_9(0x123456789ABCDEF0ULL));
      41             : 
      42           2 :   EXPECT_SIZE(5, WASM_F32(1.0f));
      43           2 :   EXPECT_SIZE(5, WASM_F32(10000.0f));
      44           2 :   EXPECT_SIZE(5, WASM_F32(-9828934.0f));
      45             : 
      46           2 :   EXPECT_SIZE(9, WASM_F64(1.5));
      47           2 :   EXPECT_SIZE(9, WASM_F64(10200.0));
      48           2 :   EXPECT_SIZE(9, WASM_F64(-9818934.0));
      49           1 : }
      50             : 
      51       15444 : TEST_F(WasmMacroGenTest, Statements) {
      52           2 :   EXPECT_SIZE(1, WASM_NOP);
      53           2 :   EXPECT_SIZE(1, WASM_END);
      54             : 
      55           2 :   EXPECT_SIZE(4, WASM_SET_LOCAL(0, WASM_ZERO));
      56             : 
      57           2 :   EXPECT_SIZE(4, WASM_SET_GLOBAL(0, WASM_ZERO));
      58             : 
      59           2 :   EXPECT_SIZE(7, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO, WASM_ZERO));
      60             : 
      61           2 :   EXPECT_SIZE(6, WASM_IF(WASM_ZERO, WASM_NOP));
      62             : 
      63           2 :   EXPECT_SIZE(8, WASM_IF_ELSE(WASM_ZERO, WASM_NOP, WASM_NOP));
      64             : 
      65           2 :   EXPECT_SIZE(5, WASM_SELECT(WASM_ZERO, WASM_NOP, WASM_NOP));
      66             : 
      67           2 :   EXPECT_SIZE(2, WASM_BR(0));
      68           2 :   EXPECT_SIZE(4, WASM_BR_IF(0, WASM_ZERO));
      69             : 
      70           2 :   EXPECT_SIZE(4, WASM_BLOCK(WASM_NOP));
      71           2 :   EXPECT_SIZE(5, WASM_BLOCK(WASM_NOP, WASM_NOP));
      72           2 :   EXPECT_SIZE(6, WASM_BLOCK(WASM_NOP, WASM_NOP, WASM_NOP));
      73             : 
      74           2 :   EXPECT_SIZE(5, WASM_INFINITE_LOOP);
      75             : 
      76           2 :   EXPECT_SIZE(4, WASM_LOOP(WASM_NOP));
      77           2 :   EXPECT_SIZE(5, WASM_LOOP(WASM_NOP, WASM_NOP));
      78           2 :   EXPECT_SIZE(6, WASM_LOOP(WASM_NOP, WASM_NOP, WASM_NOP));
      79           2 :   EXPECT_SIZE(5, WASM_LOOP(WASM_BR(0)));
      80           2 :   EXPECT_SIZE(7, WASM_LOOP(WASM_BR_IF(0, WASM_ZERO)));
      81             : 
      82           2 :   EXPECT_SIZE(1, WASM_RETURN0);
      83           2 :   EXPECT_SIZE(3, WASM_RETURN1(WASM_ZERO));
      84             : 
      85           2 :   EXPECT_SIZE(1, WASM_UNREACHABLE);
      86           1 : }
      87             : 
      88       15444 : TEST_F(WasmMacroGenTest, MacroStatements) {
      89           2 :   EXPECT_SIZE(11, WASM_WHILE(WASM_ZERO, WASM_NOP));
      90           2 :   EXPECT_SIZE(7, WASM_INC_LOCAL(0));
      91           2 :   EXPECT_SIZE(7, WASM_INC_LOCAL_BY(0, 3));
      92             : 
      93           2 :   EXPECT_SIZE(2, WASM_CONTINUE(0));
      94           1 : }
      95             : 
      96       15444 : TEST_F(WasmMacroGenTest, BrTable) {
      97           2 :   EXPECT_SIZE(5, WASM_BR_TABLE(WASM_ZERO, 1, BR_TARGET(0)));
      98           2 :   EXPECT_SIZE(6, WASM_BR_TABLE(WASM_ZERO, 2, BR_TARGET(0), BR_TARGET(0)));
      99           1 : }
     100             : 
     101       15444 : TEST_F(WasmMacroGenTest, Expressions) {
     102           2 :   EXPECT_SIZE(2, WASM_GET_LOCAL(0));
     103           2 :   EXPECT_SIZE(2, WASM_GET_LOCAL(1));
     104           2 :   EXPECT_SIZE(2, WASM_GET_LOCAL(12));
     105           2 :   EXPECT_SIZE(2, WASM_GET_GLOBAL(0));
     106           2 :   EXPECT_SIZE(2, WASM_GET_GLOBAL(1));
     107           2 :   EXPECT_SIZE(2, WASM_GET_GLOBAL(12));
     108           2 :   EXPECT_SIZE(5, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO));
     109           2 :   EXPECT_SIZE(5, WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO));
     110           2 :   EXPECT_SIZE(5, WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO));
     111             : 
     112           2 :   EXPECT_SIZE(3, WASM_NOT(WASM_ZERO));
     113             : 
     114           2 :   EXPECT_SIZE(4, WASM_BRV(1, WASM_ZERO));
     115           2 :   EXPECT_SIZE(6, WASM_BRV_IF(1, WASM_ZERO, WASM_ZERO));
     116             : 
     117           2 :   EXPECT_SIZE(5, WASM_BLOCK(WASM_ZERO));
     118           2 :   EXPECT_SIZE(6, WASM_BLOCK(WASM_NOP, WASM_ZERO));
     119           2 :   EXPECT_SIZE(7, WASM_BLOCK(WASM_NOP, WASM_NOP, WASM_ZERO));
     120             : 
     121           2 :   EXPECT_SIZE(5, WASM_LOOP(WASM_ZERO));
     122           2 :   EXPECT_SIZE(6, WASM_LOOP(WASM_NOP, WASM_ZERO));
     123           2 :   EXPECT_SIZE(7, WASM_LOOP(WASM_NOP, WASM_NOP, WASM_ZERO));
     124           1 : }
     125             : 
     126       15444 : TEST_F(WasmMacroGenTest, CallFunction) {
     127           2 :   EXPECT_SIZE(2, WASM_CALL_FUNCTION0(0));
     128           2 :   EXPECT_SIZE(2, WASM_CALL_FUNCTION0(1));
     129           2 :   EXPECT_SIZE(2, WASM_CALL_FUNCTION0(11));
     130             : 
     131           2 :   EXPECT_SIZE(4, WASM_CALL_FUNCTION(0, WASM_ZERO));
     132           2 :   EXPECT_SIZE(6, WASM_CALL_FUNCTION(1, WASM_ZERO, WASM_ZERO));
     133           1 : }
     134             : 
     135       15444 : TEST_F(WasmMacroGenTest, CallIndirect) {
     136           2 :   EXPECT_SIZE(5, WASM_CALL_INDIRECT0(0, WASM_ZERO));
     137           2 :   EXPECT_SIZE(5, WASM_CALL_INDIRECT0(1, WASM_ZERO));
     138           2 :   EXPECT_SIZE(5, WASM_CALL_INDIRECT0(11, WASM_ZERO));
     139             : 
     140           2 :   EXPECT_SIZE(7, WASM_CALL_INDIRECT1(0, WASM_ZERO, WASM_ZERO));
     141           2 :   EXPECT_SIZE(9, WASM_CALL_INDIRECT2(1, WASM_ZERO, WASM_ZERO, WASM_ZERO));
     142           1 : }
     143             : 
     144       15444 : TEST_F(WasmMacroGenTest, Int32Ops) {
     145           2 :   EXPECT_SIZE(5, WASM_I32_ADD(WASM_ZERO, WASM_ZERO));
     146           2 :   EXPECT_SIZE(5, WASM_I32_SUB(WASM_ZERO, WASM_ZERO));
     147           2 :   EXPECT_SIZE(5, WASM_I32_MUL(WASM_ZERO, WASM_ZERO));
     148           2 :   EXPECT_SIZE(5, WASM_I32_DIVS(WASM_ZERO, WASM_ZERO));
     149           2 :   EXPECT_SIZE(5, WASM_I32_DIVU(WASM_ZERO, WASM_ZERO));
     150           2 :   EXPECT_SIZE(5, WASM_I32_REMS(WASM_ZERO, WASM_ZERO));
     151           2 :   EXPECT_SIZE(5, WASM_I32_REMU(WASM_ZERO, WASM_ZERO));
     152           2 :   EXPECT_SIZE(5, WASM_I32_AND(WASM_ZERO, WASM_ZERO));
     153           2 :   EXPECT_SIZE(5, WASM_I32_IOR(WASM_ZERO, WASM_ZERO));
     154           2 :   EXPECT_SIZE(5, WASM_I32_XOR(WASM_ZERO, WASM_ZERO));
     155           2 :   EXPECT_SIZE(5, WASM_I32_SHL(WASM_ZERO, WASM_ZERO));
     156           2 :   EXPECT_SIZE(5, WASM_I32_SHR(WASM_ZERO, WASM_ZERO));
     157           2 :   EXPECT_SIZE(5, WASM_I32_SAR(WASM_ZERO, WASM_ZERO));
     158           2 :   EXPECT_SIZE(5, WASM_I32_ROR(WASM_ZERO, WASM_ZERO));
     159           2 :   EXPECT_SIZE(5, WASM_I32_ROL(WASM_ZERO, WASM_ZERO));
     160           2 :   EXPECT_SIZE(5, WASM_I32_EQ(WASM_ZERO, WASM_ZERO));
     161             : 
     162           2 :   EXPECT_SIZE(5, WASM_I32_LTS(WASM_ZERO, WASM_ZERO));
     163           2 :   EXPECT_SIZE(5, WASM_I32_LES(WASM_ZERO, WASM_ZERO));
     164           2 :   EXPECT_SIZE(5, WASM_I32_LTU(WASM_ZERO, WASM_ZERO));
     165           2 :   EXPECT_SIZE(5, WASM_I32_LEU(WASM_ZERO, WASM_ZERO));
     166             : 
     167           2 :   EXPECT_SIZE(5, WASM_I32_GTS(WASM_ZERO, WASM_ZERO));
     168           2 :   EXPECT_SIZE(5, WASM_I32_GES(WASM_ZERO, WASM_ZERO));
     169           2 :   EXPECT_SIZE(5, WASM_I32_GTU(WASM_ZERO, WASM_ZERO));
     170           2 :   EXPECT_SIZE(5, WASM_I32_GEU(WASM_ZERO, WASM_ZERO));
     171             : 
     172           2 :   EXPECT_SIZE(3, WASM_I32_CLZ(WASM_ZERO));
     173           2 :   EXPECT_SIZE(3, WASM_I32_CTZ(WASM_ZERO));
     174           2 :   EXPECT_SIZE(3, WASM_I32_POPCNT(WASM_ZERO));
     175             : 
     176           2 :   EXPECT_SIZE(3, WASM_I32_EQZ(WASM_ZERO));
     177           1 : }
     178             : 
     179       15444 : TEST_F(WasmMacroGenTest, Int64Ops) {
     180           2 :   EXPECT_SIZE(5, WASM_I64_ADD(WASM_ZERO, WASM_ZERO));
     181           2 :   EXPECT_SIZE(5, WASM_I64_SUB(WASM_ZERO, WASM_ZERO));
     182           2 :   EXPECT_SIZE(5, WASM_I64_MUL(WASM_ZERO, WASM_ZERO));
     183           2 :   EXPECT_SIZE(5, WASM_I64_DIVS(WASM_ZERO, WASM_ZERO));
     184           2 :   EXPECT_SIZE(5, WASM_I64_DIVU(WASM_ZERO, WASM_ZERO));
     185           2 :   EXPECT_SIZE(5, WASM_I64_REMS(WASM_ZERO, WASM_ZERO));
     186           2 :   EXPECT_SIZE(5, WASM_I64_REMU(WASM_ZERO, WASM_ZERO));
     187           2 :   EXPECT_SIZE(5, WASM_I64_AND(WASM_ZERO, WASM_ZERO));
     188           2 :   EXPECT_SIZE(5, WASM_I64_IOR(WASM_ZERO, WASM_ZERO));
     189           2 :   EXPECT_SIZE(5, WASM_I64_XOR(WASM_ZERO, WASM_ZERO));
     190           2 :   EXPECT_SIZE(5, WASM_I64_SHL(WASM_ZERO, WASM_ZERO));
     191           2 :   EXPECT_SIZE(5, WASM_I64_SHR(WASM_ZERO, WASM_ZERO));
     192           2 :   EXPECT_SIZE(5, WASM_I64_SAR(WASM_ZERO, WASM_ZERO));
     193           2 :   EXPECT_SIZE(5, WASM_I64_ROR(WASM_ZERO, WASM_ZERO));
     194           2 :   EXPECT_SIZE(5, WASM_I64_ROL(WASM_ZERO, WASM_ZERO));
     195           2 :   EXPECT_SIZE(5, WASM_I64_EQ(WASM_ZERO, WASM_ZERO));
     196             : 
     197           2 :   EXPECT_SIZE(5, WASM_I64_LTS(WASM_ZERO, WASM_ZERO));
     198           2 :   EXPECT_SIZE(5, WASM_I64_LES(WASM_ZERO, WASM_ZERO));
     199           2 :   EXPECT_SIZE(5, WASM_I64_LTU(WASM_ZERO, WASM_ZERO));
     200           2 :   EXPECT_SIZE(5, WASM_I64_LEU(WASM_ZERO, WASM_ZERO));
     201             : 
     202           2 :   EXPECT_SIZE(5, WASM_I64_GTS(WASM_ZERO, WASM_ZERO));
     203           2 :   EXPECT_SIZE(5, WASM_I64_GES(WASM_ZERO, WASM_ZERO));
     204           2 :   EXPECT_SIZE(5, WASM_I64_GTU(WASM_ZERO, WASM_ZERO));
     205           2 :   EXPECT_SIZE(5, WASM_I64_GEU(WASM_ZERO, WASM_ZERO));
     206             : 
     207           2 :   EXPECT_SIZE(3, WASM_I64_CLZ(WASM_ZERO));
     208           2 :   EXPECT_SIZE(3, WASM_I64_CTZ(WASM_ZERO));
     209           2 :   EXPECT_SIZE(3, WASM_I64_POPCNT(WASM_ZERO));
     210             : 
     211           2 :   EXPECT_SIZE(3, WASM_I64_EQZ(WASM_ZERO));
     212           1 : }
     213             : 
     214       15444 : TEST_F(WasmMacroGenTest, Float32Ops) {
     215           2 :   EXPECT_SIZE(5, WASM_F32_ADD(WASM_ZERO, WASM_ZERO));
     216           2 :   EXPECT_SIZE(5, WASM_F32_SUB(WASM_ZERO, WASM_ZERO));
     217           2 :   EXPECT_SIZE(5, WASM_F32_MUL(WASM_ZERO, WASM_ZERO));
     218           2 :   EXPECT_SIZE(5, WASM_F32_DIV(WASM_ZERO, WASM_ZERO));
     219           2 :   EXPECT_SIZE(5, WASM_F32_MIN(WASM_ZERO, WASM_ZERO));
     220           2 :   EXPECT_SIZE(5, WASM_F32_MAX(WASM_ZERO, WASM_ZERO));
     221           2 :   EXPECT_SIZE(5, WASM_F32_COPYSIGN(WASM_ZERO, WASM_ZERO));
     222             : 
     223           2 :   EXPECT_SIZE(3, WASM_F32_ABS(WASM_ZERO));
     224           2 :   EXPECT_SIZE(3, WASM_F32_NEG(WASM_ZERO));
     225           2 :   EXPECT_SIZE(3, WASM_F32_CEIL(WASM_ZERO));
     226           2 :   EXPECT_SIZE(3, WASM_F32_FLOOR(WASM_ZERO));
     227           2 :   EXPECT_SIZE(3, WASM_F32_TRUNC(WASM_ZERO));
     228           2 :   EXPECT_SIZE(3, WASM_F32_NEARESTINT(WASM_ZERO));
     229           2 :   EXPECT_SIZE(3, WASM_F32_SQRT(WASM_ZERO));
     230             : 
     231           2 :   EXPECT_SIZE(5, WASM_F32_EQ(WASM_ZERO, WASM_ZERO));
     232           2 :   EXPECT_SIZE(5, WASM_F32_LT(WASM_ZERO, WASM_ZERO));
     233           2 :   EXPECT_SIZE(5, WASM_F32_LE(WASM_ZERO, WASM_ZERO));
     234           2 :   EXPECT_SIZE(5, WASM_F32_GT(WASM_ZERO, WASM_ZERO));
     235           2 :   EXPECT_SIZE(5, WASM_F32_GE(WASM_ZERO, WASM_ZERO));
     236           1 : }
     237             : 
     238       15444 : TEST_F(WasmMacroGenTest, Float64Ops) {
     239           2 :   EXPECT_SIZE(5, WASM_F64_ADD(WASM_ZERO, WASM_ZERO));
     240           2 :   EXPECT_SIZE(5, WASM_F64_SUB(WASM_ZERO, WASM_ZERO));
     241           2 :   EXPECT_SIZE(5, WASM_F64_MUL(WASM_ZERO, WASM_ZERO));
     242           2 :   EXPECT_SIZE(5, WASM_F64_DIV(WASM_ZERO, WASM_ZERO));
     243           2 :   EXPECT_SIZE(5, WASM_F64_MIN(WASM_ZERO, WASM_ZERO));
     244           2 :   EXPECT_SIZE(5, WASM_F64_MAX(WASM_ZERO, WASM_ZERO));
     245           2 :   EXPECT_SIZE(5, WASM_F64_COPYSIGN(WASM_ZERO, WASM_ZERO));
     246             : 
     247           2 :   EXPECT_SIZE(3, WASM_F64_ABS(WASM_ZERO));
     248           2 :   EXPECT_SIZE(3, WASM_F64_NEG(WASM_ZERO));
     249           2 :   EXPECT_SIZE(3, WASM_F64_CEIL(WASM_ZERO));
     250           2 :   EXPECT_SIZE(3, WASM_F64_FLOOR(WASM_ZERO));
     251           2 :   EXPECT_SIZE(3, WASM_F64_TRUNC(WASM_ZERO));
     252           2 :   EXPECT_SIZE(3, WASM_F64_NEARESTINT(WASM_ZERO));
     253           2 :   EXPECT_SIZE(3, WASM_F64_SQRT(WASM_ZERO));
     254             : 
     255           2 :   EXPECT_SIZE(5, WASM_F64_EQ(WASM_ZERO, WASM_ZERO));
     256           2 :   EXPECT_SIZE(5, WASM_F64_LT(WASM_ZERO, WASM_ZERO));
     257           2 :   EXPECT_SIZE(5, WASM_F64_LE(WASM_ZERO, WASM_ZERO));
     258           2 :   EXPECT_SIZE(5, WASM_F64_GT(WASM_ZERO, WASM_ZERO));
     259           2 :   EXPECT_SIZE(5, WASM_F64_GE(WASM_ZERO, WASM_ZERO));
     260           1 : }
     261             : 
     262       15444 : TEST_F(WasmMacroGenTest, Conversions) {
     263           2 :   EXPECT_SIZE(3, WASM_I32_SCONVERT_F32(WASM_ZERO));
     264           2 :   EXPECT_SIZE(3, WASM_I32_SCONVERT_F64(WASM_ZERO));
     265           2 :   EXPECT_SIZE(3, WASM_I32_UCONVERT_F32(WASM_ZERO));
     266           2 :   EXPECT_SIZE(3, WASM_I32_UCONVERT_F64(WASM_ZERO));
     267           2 :   EXPECT_SIZE(3, WASM_I32_CONVERT_I64(WASM_ZERO));
     268           2 :   EXPECT_SIZE(3, WASM_I64_SCONVERT_F32(WASM_ZERO));
     269           2 :   EXPECT_SIZE(3, WASM_I64_SCONVERT_F64(WASM_ZERO));
     270           2 :   EXPECT_SIZE(3, WASM_I64_UCONVERT_F32(WASM_ZERO));
     271           2 :   EXPECT_SIZE(3, WASM_I64_UCONVERT_F64(WASM_ZERO));
     272           2 :   EXPECT_SIZE(3, WASM_I64_SCONVERT_I32(WASM_ZERO));
     273           2 :   EXPECT_SIZE(3, WASM_I64_UCONVERT_I32(WASM_ZERO));
     274           2 :   EXPECT_SIZE(3, WASM_F32_SCONVERT_I32(WASM_ZERO));
     275           1 :   EXPECT_SIZE(3, WASM_F32_UCONVERT_I32(WASM_ZERO));
     276           2 :   EXPECT_SIZE(3, WASM_F32_SCONVERT_I64(WASM_ZERO));
     277           2 :   EXPECT_SIZE(3, WASM_F32_UCONVERT_I64(WASM_ZERO));
     278           2 :   EXPECT_SIZE(3, WASM_F32_CONVERT_F64(WASM_ZERO));
     279           2 :   EXPECT_SIZE(3, WASM_F32_REINTERPRET_I32(WASM_ZERO));
     280           2 :   EXPECT_SIZE(3, WASM_F64_SCONVERT_I32(WASM_ZERO));
     281           2 :   EXPECT_SIZE(3, WASM_F64_UCONVERT_I32(WASM_ZERO));
     282           2 :   EXPECT_SIZE(3, WASM_F64_SCONVERT_I64(WASM_ZERO));
     283           2 :   EXPECT_SIZE(3, WASM_F64_UCONVERT_I64(WASM_ZERO));
     284           2 :   EXPECT_SIZE(3, WASM_F64_CONVERT_F32(WASM_ZERO));
     285           2 :   EXPECT_SIZE(3, WASM_F64_REINTERPRET_I64(WASM_ZERO));
     286           1 : }
     287             : 
     288             : static const MachineType kMemTypes[] = {
     289             :     MachineType::Int8(),   MachineType::Uint8(),  MachineType::Int16(),
     290             :     MachineType::Uint16(), MachineType::Int32(),  MachineType::Uint32(),
     291             :     MachineType::Int64(),  MachineType::Uint64(), MachineType::Float32(),
     292             :     MachineType::Float64()};
     293             : 
     294       15444 : TEST_F(WasmMacroGenTest, LoadsAndStores) {
     295          21 :   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     296          20 :     EXPECT_SIZE(5, WASM_LOAD_MEM(kMemTypes[i], WASM_ZERO));
     297             :   }
     298          21 :   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     299          20 :     EXPECT_SIZE(7, WASM_STORE_MEM(kMemTypes[i], WASM_ZERO, WASM_GET_LOCAL(0)));
     300             :   }
     301           1 : }
     302             : 
     303       15444 : TEST_F(WasmMacroGenTest, LoadsAndStoresWithOffset) {
     304          21 :   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     305          20 :     EXPECT_SIZE(5, WASM_LOAD_MEM_OFFSET(kMemTypes[i], 11, WASM_ZERO));
     306             :   }
     307          21 :   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     308          20 :     EXPECT_SIZE(7, WASM_STORE_MEM_OFFSET(kMemTypes[i], 13, WASM_ZERO,
     309             :                                          WASM_GET_LOCAL(0)));
     310             :   }
     311           1 : }
     312             : 
     313             : #undef EXPECT_SIZE
     314             : 
     315             : }  // namespace wasm
     316             : }  // namespace internal
     317        9264 : }  // namespace v8

Generated by: LCOV version 1.10