[wasm] memory size is an uint32_t, not a size_t.

test/cctest/wasm/test-run-wasm.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
 
@@ skipping 33 matching lines @@
 
 WASM_EXEC_TEST(Int8Const_fallthru2) {
   WasmRunner<int32_t> r(execution_mode);
   const byte kExpectedValue = 123;
   // -99 kExpectedValue
   BUILD(r, WASM_I8(-99), WASM_I8(kExpectedValue));
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
 WASM_EXEC_TEST(Int8Const_all) {
-  for (int value = -128; value <= 127; value++) {
+  for (int value = -128; value <= 127; ++value) {
     WasmRunner<int32_t> r(execution_mode);
     // return(value)
     BUILD(r, WASM_I8(value));
     int32_t result = r.Call();
     CHECK_EQ(value, result);
   }
 }
 
 WASM_EXEC_TEST(Int32Const) {
   WasmRunner<int32_t> r(execution_mode);
@@ skipping 328 matching lines @@
   BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(17, r.Call(217, 100));
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
   CHECK_EQ(kMin, r.Call(kMin, -1));
 }
 
 WASM_EXEC_TEST(Int32DivS_byzero_const) {
-  for (int8_t denom = -2; denom < 8; denom++) {
+  for (int8_t denom = -2; denom < 8; ++denom) {
     WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
     BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
-    for (int32_t val = -7; val < 8; val++) {
+    for (int32_t val = -7; val < 8; ++val) {
       if (denom == 0) {
         CHECK_TRAP(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(Int32DivU_byzero_const) {
-  for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
+  for (uint32_t denom = 0xfffffffe; denom < 8; ++denom) {
     WasmRunner<uint32_t> r(execution_mode, MachineType::Uint32());
     BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
 
-    for (uint32_t val = 0xfffffff0; val < 8; val++) {
+    for (uint32_t val = 0xfffffff0; val < 8; ++val) {
       if (denom == 0) {
         CHECK_TRAP(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(Int32DivS_trap_effect) {
@@ skipping 452 matching lines @@
         WASM_I8(88));
   CHECK_EQ(86, r.Call(0));
   CHECK_EQ(87, r.Call(1));
   CHECK_EQ(88, r.Call(2));
   CHECK_EQ(85, r.Call(3));
   CHECK_EQ(85, r.Call(4));
   CHECK_EQ(85, r.Call(5));
 }
 
 WASM_EXEC_TEST(BrTable4) {
-  for (int i = 0; i < 4; i++) {
-    for (int t = 0; t < 4; t++) {
+  for (int i = 0; i < 4; ++i) {
+    for (int t = 0; t < 4; ++t) {
       uint32_t cases[] = {0, 1, 2, 3};
       cases[i] = t;
       byte code[] = {B2(B2(B2(B2(B1(WASM_BR_TABLE(
                                      WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                      BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                      BR_TARGET(cases[3]))),
                                  RET_I8(70)),
                               RET_I8(71)),
                            RET_I8(72)),
                         RET_I8(73)),
                      WASM_I8(75)};
 
       WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
       r.Build(code, code + arraysize(code));
 
-      for (int x = -3; x < 50; x++) {
+      for (int x = -3; x < 50; ++x) {
         int index = (x > 3 || x < 0) ? 3 : x;
         int32_t expected = 70 + cases[index];
         CHECK_EQ(expected, r.Call(x));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(BrTable4x4) {
-  for (byte a = 0; a < 4; a++) {
-    for (byte b = 0; b < 4; b++) {
-      for (byte c = 0; c < 4; c++) {
-        for (byte d = 0; d < 4; d++) {
-          for (int i = 0; i < 4; i++) {
+  for (byte a = 0; a < 4; ++a) {
+    for (byte b = 0; b < 4; ++b) {
+      for (byte c = 0; c < 4; ++c) {
+        for (byte d = 0; d < 4; ++d) {
+          for (int i = 0; i < 4; ++i) {
             uint32_t cases[] = {a, b, c, d};
             byte code[] = {
                 B2(B2(B2(B2(B1(WASM_BR_TABLE(
                                 WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                 BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                 BR_TARGET(cases[3]))),
                             RET_I8(50)),
                          RET_I8(51)),
                       RET_I8(52)),
                    RET_I8(53)),
                 WASM_I8(55)};
 
             WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
             r.Build(code, code + arraysize(code));
 
-            for (int x = -6; x < 47; x++) {
+            for (int x = -6; x < 47; ++x) {
               int index = (x > 3 || x < 0) ? 3 : x;
               int32_t expected = 50 + cases[index];
               CHECK_EQ(expected, r.Call(x));
             }
           }
         }
       }
     }
   }
 }
@@ skipping 363 matching lines @@
   memory[0] = 88888888;
   CHECK_EQ(88888888, r.Call(0));
 
   memory[0] = 77777777;
   CHECK_EQ(77777777, r.Call(0));
 }
 
 WASM_EXEC_TEST(LoadMemI32_alignment) {
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(8);
-  for (byte alignment = 0; alignment <= 2; alignment++) {
+  for (byte alignment = 0; alignment <= 2; ++alignment) {
     WasmRunner<int32_t> r(&module, MachineType::Int32());
     module.RandomizeMemory(1111);
 
     BUILD(r,
           WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_I8(0), alignment));
 
     memory[0] = 0x1a2b3c4d;
     CHECK_EQ(0x1a2b3c4d, r.Call(0));
 
     memory[0] = 0x5e6f7a8b;
     CHECK_EQ(0x5e6f7a8b, r.Call(0));
 
     memory[0] = 0x9ca0b1c2;
     CHECK_EQ(0x9ca0b1c2, r.Call(0));
   }
 }
 
 WASM_EXEC_TEST(LoadMemI32_oob) {
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(8);
   WasmRunner<int32_t> r(&module, MachineType::Uint32());
   module.RandomizeMemory(1111);
 
   BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
 
   memory[0] = 88888888;
   CHECK_EQ(88888888, r.Call(0u));
-  for (uint32_t offset = 29; offset < 40; offset++) {
+  for (uint32_t offset = 29; offset < 40; ++offset) {
     CHECK_TRAP(r.Call(offset));
   }
 
-  for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
+  for (uint32_t offset = 0x80000000; offset < 0x80000010; ++offset) {
     CHECK_TRAP(r.Call(offset));
   }
 }
 
 WASM_EXEC_TEST(LoadMem_offset_oob) {
   TestingModule module(execution_mode);
   module.AddMemoryElems<int32_t>(8);
 
   static const MachineType machineTypes[] = {
       MachineType::Int8(),   MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(), MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Int64(),  MachineType::Uint64(), MachineType::Float32(),
       MachineType::Float64()};
 
-  for (size_t m = 0; m < arraysize(machineTypes); m++) {
+  for (size_t m = 0; m < arraysize(machineTypes); ++m) {
     module.RandomizeMemory(1116 + static_cast<int>(m));
     WasmRunner<int32_t> r(&module, MachineType::Uint32());
     uint32_t boundary = 24 - WasmOpcodes::MemSize(machineTypes[m]);
 
     BUILD(r, WASM_LOAD_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0)),
           WASM_ZERO);
 
     CHECK_EQ(0, r.Call(boundary));  // in bounds.
 
-    for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
+    for (uint32_t offset = boundary + 1; offset < boundary + 19; ++offset) {
       CHECK_TRAP(r.Call(offset));  // out of bounds.
     }
   }
 }
 
 WASM_EXEC_TEST(LoadMemI32_offset) {
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   module.RandomizeMemory(1111);
@@ skipping 13 matching lines @@
   memory[2] = 33333333;
   memory[3] = 44444444;
   CHECK_EQ(22222222, r.Call(0));
   CHECK_EQ(33333333, r.Call(4));
   CHECK_EQ(44444444, r.Call(8));
 }
 
 WASM_EXEC_TEST(LoadMemI32_const_oob_misaligned) {
   const int kMemSize = 12;
   // TODO(titzer): Fix misaligned accesses on MIPS and re-enable.
-  for (int offset = 0; offset < kMemSize + 5; offset++) {
-    for (int index = 0; index < kMemSize + 5; index++) {
+  for (int offset = 0; offset < kMemSize + 5; ++offset) {
+    for (int index = 0; index < kMemSize + 5; ++index) {
       TestingModule module(execution_mode);
       module.AddMemoryElems<byte>(kMemSize);
 
       WasmRunner<int32_t> r(&module);
       module.RandomizeMemory();
 
       BUILD(r,
             WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
 
       if ((offset + index) <= (kMemSize - sizeof(int32_t))) {
@@ skipping 25 matching lines @@
       }
     }
   }
 }
 
 WASM_EXEC_TEST(StoreMemI32_alignment) {
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
   const int32_t kWritten = 0x12345678;
 
-  for (byte i = 0; i <= 2; i++) {
+  for (byte i = 0; i <= 2; ++i) {
     WasmRunner<int32_t> r(&module, MachineType::Int32());
     BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int32(), WASM_ZERO, i,
                                       WASM_GET_LOCAL(0)));
     module.RandomizeMemory(1111);
     memory[0] = 0;
 
     CHECK_EQ(kWritten, r.Call(kWritten));
     CHECK_EQ(kWritten, memory[0]);
   }
 }
 
 WASM_EXEC_TEST(StoreMemI32_offset) {
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   const int32_t kWritten = 0xaabbccdd;
 
   BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0),
                                  WASM_I32V_5(kWritten)));
 
-  for (int i = 0; i < 2; i++) {
+  for (int i = 0; i < 2; ++i) {
     module.RandomizeMemory(1111);
     memory[0] = 66666666;
     memory[1] = 77777777;
     memory[2] = 88888888;
     memory[3] = 99999999;
     CHECK_EQ(kWritten, r.Call(i * 4));
     CHECK_EQ(66666666, memory[0]);
     CHECK_EQ(i == 0 ? kWritten : 77777777, memory[1]);
     CHECK_EQ(i == 1 ? kWritten : 88888888, memory[2]);
     CHECK_EQ(i == 2 ? kWritten : 99999999, memory[3]);
   }
 }
 
 WASM_EXEC_TEST(StoreMem_offset_oob) {
   TestingModule module(execution_mode);
   byte* memory = module.AddMemoryElems<byte>(32);
 
   // 64-bit cases are handled in test-run-wasm-64.cc
   static const MachineType machineTypes[] = {
       MachineType::Int8(),    MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(),  MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Float32(), MachineType::Float64()};
 
-  for (size_t m = 0; m < arraysize(machineTypes); m++) {
+  for (size_t m = 0; m < arraysize(machineTypes); ++m) {
     module.RandomizeMemory(1119 + static_cast<int>(m));
     WasmRunner<int32_t> r(&module, MachineType::Uint32());
 
     BUILD(r, WASM_STORE_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0),
                                    WASM_LOAD_MEM(machineTypes[m], WASM_ZERO)),
           WASM_ZERO);
 
     byte memsize = WasmOpcodes::MemSize(machineTypes[m]);
     uint32_t boundary = 24 - memsize;
     CHECK_EQ(0, r.Call(boundary));  // in bounds.
     CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
 
-    for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
+    for (uint32_t offset = boundary + 1; offset < boundary + 19; ++offset) {
       CHECK_TRAP(r.Call(offset));  // out of bounds.
     }
   }
 }
 
 WASM_EXEC_TEST(LoadMemI32_P) {
   const int kNumElems = 8;
   TestingModule module(execution_mode);
   int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems);
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   module.RandomizeMemory(2222);
 
   BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
 
-  for (int i = 0; i < kNumElems; i++) {
+  for (int i = 0; i < kNumElems; ++i) {
     CHECK_EQ(memory[i], r.Call(i * 4));
   }
 }
 
 WASM_EXEC_TEST(MemI32_Sum) {
   const int kNumElems = 20;
   TestingModule module(execution_mode);
   uint32_t* memory = module.AddMemoryElems<uint32_t>(kNumElems);
   WasmRunner<uint32_t> r(&module, MachineType::Int32());
   const byte kSum = r.AllocateLocal(kAstI32);
 
   BUILD(r, WASM_BLOCK(
                2, WASM_WHILE(
                       WASM_GET_LOCAL(0),
                       WASM_BLOCK(
                           2, WASM_SET_LOCAL(
                                  kSum, WASM_I32_ADD(
                                            WASM_GET_LOCAL(kSum),
                                            WASM_LOAD_MEM(MachineType::Int32(),
                                                          WASM_GET_LOCAL(0)))),
                           WASM_SET_LOCAL(
                               0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))),
                WASM_GET_LOCAL(1)));
 
   // Run 4 trials.
-  for (int i = 0; i < 3; i++) {
+  for (int i = 0; i < 3; ++i) {
     module.RandomizeMemory(i * 33);
     uint32_t expected = 0;
-    for (size_t j = kNumElems - 1; j > 0; j--) {
+    for (size_t j = kNumElems - 1; j > 0; --j) {
       expected += memory[j];
     }
-    uint32_t result = r.Call(static_cast<int>(4 * (kNumElems - 1)));
+    uint32_t result = r.Call(4 * (kNumElems - 1));
     CHECK_EQ(expected, result);
   }
 }
 
 WASM_EXEC_TEST(CheckMachIntsZero) {
   const int kNumElems = 55;
   TestingModule module(execution_mode);
   module.AddMemoryElems<uint32_t>(kNumElems);
   WasmRunner<uint32_t> r(&module, MachineType::Int32());
 
@@ skipping 34 matching lines @@
                               WASM_GET_LOCAL(kSum)),
                WASM_GET_LOCAL(0)));
 
   CHECK_EQ(0, r.Call(4 * (kSize - 1)));
   CHECK_NE(-99.25, buffer[0]);
   CHECK_EQ(71256.0f, buffer[0]);
 }
 
 template <typename T>
 T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop,
-                     T* buffer, size_t size, LocalType astType,
+                     T* buffer, uint32_t size, LocalType astType,
                      MachineType memType) {
   TestingModule module(execution_mode);
   module.AddMemoryElems<T>(size);
-  for (size_t i = 0; i < size; i++) {
+  for (uint32_t i = 0; i < size; ++i) {
     module.raw_mem_start<T>()[i] = buffer[i];
   }
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   const byte kAccum = r.AllocateLocal(astType);
 
   BUILD(
       r,
       WASM_BLOCK(
           4, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)),
           WASM_WHILE(
@@ skipping 143 matching lines @@
 
 WASM_EXEC_TEST(Int32LoadInt8_signext) {
   TestingModule module(execution_mode);
   const int kNumElems = 16;
   int8_t* memory = module.AddMemoryElems<int8_t>(kNumElems);
   module.RandomizeMemory();
   memory[0] = -1;
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   BUILD(r, WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0)));
 
-  for (size_t i = 0; i < kNumElems; i++) {
-    CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
+  for (int i = 0; i < kNumElems; ++i) {
+    CHECK_EQ(memory[i], r.Call(i));
   }
 }
 
 WASM_EXEC_TEST(Int32LoadInt8_zeroext) {
   TestingModule module(execution_mode);
   const int kNumElems = 16;
   byte* memory = module.AddMemory(kNumElems);
   module.RandomizeMemory(77);
   memory[0] = 255;
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   BUILD(r, WASM_LOAD_MEM(MachineType::Uint8(), WASM_GET_LOCAL(0)));
 
-  for (size_t i = 0; i < kNumElems; i++) {
-    CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
+  for (int i = 0; i < kNumElems; ++i) {
+    CHECK_EQ(memory[i], r.Call(i));
   }
 }
 
 WASM_EXEC_TEST(Int32LoadInt16_signext) {
   TestingModule module(execution_mode);
   const int kNumBytes = 16;
   byte* memory = module.AddMemory(kNumBytes);
   module.RandomizeMemory(888);
   memory[1] = 200;
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   BUILD(r, WASM_LOAD_MEM(MachineType::Int16(), WASM_GET_LOCAL(0)));
 
-  for (size_t i = 0; i < kNumBytes; i += 2) {
+  for (int i = 0; i < kNumBytes; i += 2) {
     int32_t expected = memory[i] | (static_cast<int8_t>(memory[i + 1]) << 8);
-    CHECK_EQ(expected, r.Call(static_cast<int>(i)));
+    CHECK_EQ(expected, r.Call(i));
   }
 }
 
 WASM_EXEC_TEST(Int32LoadInt16_zeroext) {
   TestingModule module(execution_mode);
   const int kNumBytes = 16;
   byte* memory = module.AddMemory(kNumBytes);
   module.RandomizeMemory(9999);
   memory[1] = 204;
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   BUILD(r, WASM_LOAD_MEM(MachineType::Uint16(), WASM_GET_LOCAL(0)));
 
-  for (size_t i = 0; i < kNumBytes; i += 2) {
+  for (int i = 0; i < kNumBytes; i += 2) {
     int32_t expected = memory[i] | (memory[i + 1] << 8);
-    CHECK_EQ(expected, r.Call(static_cast<int>(i)));
+    CHECK_EQ(expected, r.Call(i));
   }
 }
 
 WASM_EXEC_TEST(Int32Global) {
   TestingModule module(execution_mode);
   int32_t* global = module.AddGlobal<int32_t>(MachineType::Int32());
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   // global = global + p0
   BUILD(r, WASM_STORE_GLOBAL(
                0, WASM_I32_ADD(WASM_LOAD_GLOBAL(0), WASM_GET_LOCAL(0))));
 
   *global = 116;
   for (int i = 9; i < 444444; i += 111111) {
     int32_t expected = *global + i;
     r.Call(i);
     CHECK_EQ(expected, *global);
   }
 }
 
 WASM_EXEC_TEST(Int32Globals_DontAlias) {
   const int kNumGlobals = 3;
   TestingModule module(execution_mode);
   int32_t* globals[] = {module.AddGlobal<int32_t>(MachineType::Int32()),
                         module.AddGlobal<int32_t>(MachineType::Int32()),
                         module.AddGlobal<int32_t>(MachineType::Int32())};
 
-  for (int g = 0; g < kNumGlobals; g++) {
+  for (int g = 0; g < kNumGlobals; ++g) {
     // global = global + p0
     WasmRunner<int32_t> r(&module, MachineType::Int32());
     BUILD(r, WASM_STORE_GLOBAL(
                  g, WASM_I32_ADD(WASM_LOAD_GLOBAL(g), WASM_GET_LOCAL(0))));
 
     // Check that reading/writing global number {g} doesn't alter the others.
     *globals[g] = 116 * g;
     int32_t before[kNumGlobals];
     for (int i = 9; i < 444444; i += 111113) {
       int32_t sum = *globals[g] + i;
-      for (int j = 0; j < kNumGlobals; j++) before[j] = *globals[j];
+      for (int j = 0; j < kNumGlobals; ++j) before[j] = *globals[j];
       r.Call(i);
-      for (int j = 0; j < kNumGlobals; j++) {
+      for (int j = 0; j < kNumGlobals; ++j) {
         int32_t expected = j == g ? sum : before[j];
         CHECK_EQ(expected, *globals[j]);
       }
     }
   }
 }
 
 WASM_EXEC_TEST(Float32Global) {
   TestingModule module(execution_mode);
   float* global = module.AddGlobal<float>(MachineType::Float32());
@@ skipping 97 matching lines @@
   WasmRunner<int32_t> r(&module);
   BUILD(r, WASM_CALL_FUNCTION0(index));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
 WASM_EXEC_TEST(CallF32StackParameter) {
   // Build the target function.
   LocalType param_types[20];
-  for (int i = 0; i < 20; i++) param_types[i] = kAstF32;
+  for (int i = 0; i < 20; ++i) param_types[i] = kAstF32;
   FunctionSig sig(1, 19, param_types);
   TestingModule module(execution_mode);
   WasmFunctionCompiler t(&sig, &module);
   BUILD(t, WASM_GET_LOCAL(17));
   uint32_t index = t.CompileAndAdd();
 
   // Build the calling function.
   WasmRunner<float> r(&module);
   BUILD(r, WASM_CALL_FUNCTIONN(
                19, index, WASM_F32(1.0f), WASM_F32(2.0f), WASM_F32(4.0f),
                WASM_F32(8.0f), WASM_F32(16.0f), WASM_F32(32.0f),
                WASM_F32(64.0f), WASM_F32(128.0f), WASM_F32(256.0f),
                WASM_F32(1.5f), WASM_F32(2.5f), WASM_F32(4.5f), WASM_F32(8.5f),
                WASM_F32(16.5f), WASM_F32(32.5f), WASM_F32(64.5f),
                WASM_F32(128.5f), WASM_F32(256.5f), WASM_F32(512.5f)));
 
   float result = r.Call();
   CHECK_EQ(256.5f, result);
 }
 
 WASM_EXEC_TEST(CallF64StackParameter) {
   // Build the target function.
   LocalType param_types[20];
-  for (int i = 0; i < 20; i++) param_types[i] = kAstF64;
+  for (int i = 0; i < 20; ++i) param_types[i] = kAstF64;
   FunctionSig sig(1, 19, param_types);
   TestingModule module(execution_mode);
   WasmFunctionCompiler t(&sig, &module);
   BUILD(t, WASM_GET_LOCAL(17));
   uint32_t index = t.CompileAndAdd();
 
   // Build the calling function.
   WasmRunner<double> r(&module);
   BUILD(r, WASM_CALL_FUNCTIONN(19, index, WASM_F64(1.0), WASM_F64(2.0),
                                WASM_F64(4.0), WASM_F64(8.0), WASM_F64(16.0),
@@ skipping 94 matching lines @@
       } else {
         CHECK_EQ(expected, memory[0]);
       }
     }
   }
 }
 
 #define ADD_CODE(vec, ...)                                              \
   do {                                                                  \
     byte __buf[] = {__VA_ARGS__};                                       \
-    for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
+    for (size_t i = 0; i < sizeof(__buf); ++i) vec.push_back(__buf[i]); \
   } while (false)
 
 static void Run_WasmMixedCall_N(WasmExecutionMode execution_mode, int start) {
   const int kExpected = 6333;
   const int kElemSize = 8;
   TestSignatures sigs;
 
   // 64-bit cases handled in test-run-wasm-64.cc.
   static MachineType mixed[] = {
       MachineType::Int32(),   MachineType::Float32(), MachineType::Float64(),
       MachineType::Float32(), MachineType::Int32(),   MachineType::Float64(),
       MachineType::Float32(), MachineType::Float64(), MachineType::Int32(),
       MachineType::Int32(),   MachineType::Int32()};
 
   int num_params = static_cast<int>(arraysize(mixed)) - start;
-  for (int which = 0; which < num_params; which++) {
+  for (int which = 0; which < num_params; ++which) {
     v8::base::AccountingAllocator allocator;
     Zone zone(&allocator);
     TestingModule module(execution_mode);
     module.AddMemory(1024);
     MachineType* memtypes = &mixed[start];
     MachineType result = memtypes[which];
 
     // =========================================================================
     // Build the selector function.
     // =========================================================================
     uint32_t index;
     FunctionSig::Builder b(&zone, 1, num_params);
     b.AddReturn(WasmOpcodes::LocalTypeFor(result));
-    for (int i = 0; i < num_params; i++) {
+    for (int i = 0; i < num_params; ++i) {
       b.AddParam(WasmOpcodes::LocalTypeFor(memtypes[i]));
     }
     WasmFunctionCompiler t(b.Build(), &module);
     BUILD(t, WASM_GET_LOCAL(which));
     index = t.CompileAndAdd();
 
     // =========================================================================
     // Build the calling function.
     // =========================================================================
     WasmRunner<int32_t> r(&module);
     std::vector<byte> code;
 
     // Load the offset for the store.
     ADD_CODE(code, WASM_ZERO);
 
     // Load the arguments.
-    for (int i = 0; i < num_params; i++) {
+    for (int i = 0; i < num_params; ++i) {
       int offset = (i + 1) * kElemSize;
       ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
     }
 
     // Call the selector function.
     ADD_CODE(code, kExprCallFunction, static_cast<byte>(num_params),
              static_cast<byte>(index));
 
     // Store the result in memory.
     ADD_CODE(code,
              static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
              ZERO_ALIGNMENT, ZERO_OFFSET);
 
     // Return the expected value.
     ADD_CODE(code, WASM_I32V_2(kExpected));
 
     r.Build(&code[0], &code[0] + code.size());
 
     // Run the code.
-    for (int t = 0; t < 10; t++) {
+    for (int t = 0; t < 10; ++t) {
       module.RandomizeMemory();
       CHECK_EQ(kExpected, r.Call());
 
       int size = WasmOpcodes::MemSize(result);
-      for (int i = 0; i < size; i++) {
+      for (int i = 0; i < size; ++i) {
         int base = (which + 1) * kElemSize;
         byte expected = module.raw_mem_at<byte>(base + i);
         byte result = module.raw_mem_at<byte>(i);
         CHECK_EQ(expected, result);
       }
     }
   }
 }
 
 WASM_EXEC_TEST(MixedCall_0) { Run_WasmMixedCall_N(execution_mode, 0); }
@@ skipping 555 matching lines @@
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(copysignf(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 static void CompileCallIndirectMany(LocalType param) {
   // Make sure we don't run out of registers when compiling indirect calls
   // with many many parameters.
   TestSignatures sigs;
-  for (byte num_params = 0; num_params < 40; num_params++) {
+  for (byte num_params = 0; num_params < 40; ++num_params) {
     v8::base::AccountingAllocator allocator;
     Zone zone(&allocator);
     HandleScope scope(CcTest::InitIsolateOnce());
     TestingModule module(kExecuteCompiled);
     FunctionSig* sig = sigs.many(&zone, kAstStmt, param, num_params);
 
     module.AddSignature(sig);
     module.AddSignature(sig);
     module.AddIndirectFunctionTable(nullptr, 0);
 
     WasmFunctionCompiler t(sig, &module);
 
     std::vector<byte> code;
     ADD_CODE(code, kExprI8Const, 0);
-    for (byte p = 0; p < num_params; p++) {
+    for (byte p = 0; p < num_params; ++p) {
       ADD_CODE(code, kExprGetLocal, p);
     }
     ADD_CODE(code, kExprCallIndirect, static_cast<byte>(num_params), 1);
 
     t.Build(&code[0], &code[0] + code.size());
     t.Compile();
   }
 }
 
 TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kAstI32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }
 
 WASM_EXEC_TEST(Int32RemS_dead) {
   WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
                         MachineType::Int32());
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }