Disable more crashing / failing wasm tests.

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/utils/random-number-generator.h"
 
@@ skipping 1839 matching lines @@
   memory[0] = 11111111;
   memory[1] = 22222222;
   memory[2] = 33333333;
   memory[3] = 44444444;
   CHECK_EQ(22222222, r.Call(0));
   CHECK_EQ(33333333, r.Call(4));
   CHECK_EQ(44444444, r.Call(8));
 }
 
 
+// TODO(titzer): Fix for mips and re-enable.
+#if !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
+
 TEST(Run_Wasm_LoadMemI32_const_oob) {
   TestingModule module;
   const int kMemSize = 12;
   module.AddMemoryElems<byte>(kMemSize);
 
   for (int offset = 0; offset < kMemSize + 5; offset++) {
     for (int index = 0; index < kMemSize + 5; index++) {
       WasmRunner<int32_t> r;
       r.env()->module = &module;
       module.RandomizeMemory();
 
       BUILD(r,
             WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
 
       if ((offset + index) <= (kMemSize - sizeof(int32_t))) {
         CHECK_EQ(module.raw_val_at<int32_t>(offset + index), r.Call());
       } else {
         CHECK_TRAP(r.Call());
       }
     }
   }
 }
 
+#endif
+
 
 TEST(Run_Wasm_StoreMemI32_offset) {
   WasmRunner<int32_t> r(MachineType::Int32());
   const int32_t kWritten = 0xaabbccdd;
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
   r.env()->module = &module;
 
   BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0),
                                  WASM_I32(kWritten)));
@@ skipping 743 matching lines @@
   // Build the calling function.
   WasmRunner<int32_t> r;
   r.env()->module = &module;
   BUILD(r, WASM_CALL_FUNCTION0(index));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
 
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
 TEST(Run_WasmCallF32StackParameter) {
   // Build the target function.
   LocalType param_types[20];
   for (int i = 0; i < 20; i++) param_types[i] = kAstF32;
   FunctionSig sig(1, 19, param_types);
   TestingModule module;
   WasmFunctionCompiler t(&sig);
   BUILD(t, WASM_GET_LOCAL(17));
   uint32_t index = t.CompileAndAdd(&module);
 
@@ skipping 31 matching lines @@
                               WASM_F64(32.0), WASM_F64(64.0), WASM_F64(128.0),
                               WASM_F64(256.0), WASM_F64(1.5), WASM_F64(2.5),
                               WASM_F64(4.5), WASM_F64(8.5), WASM_F64(16.5),
                               WASM_F64(32.5), WASM_F64(64.5), WASM_F64(128.5),
                               WASM_F64(256.5), WASM_F64(512.5)));
 
   float result = r.Call();
   CHECK_EQ(256.5, result);
 }
 
+#endif
+
 
 TEST(Run_WasmCallVoid) {
   const byte kMemOffset = 8;
   const int32_t kElemNum = kMemOffset / sizeof(int32_t);
   const int32_t kExpected = -414444;
   // Build the target function.
   TestSignatures sigs;
   TestingModule module;
   module.AddMemory(16);
   module.RandomizeMemory();
@@ skipping 834 matching lines @@
 TEST(Run_Wasm_F64CopySign) {
   WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
   BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(copysign(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
 TEST(Run_Wasm_F32CopySign) {
   WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
   BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) { CheckFloatEq(copysign(*i, *j), r.Call(*i, *j)); }
   }
 }
+
+#endif