[wasm] Reenable tests that were disabled for no SSE 4.

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/wasm/wasm-macro-gen.h"
 
@@ skipping 178 matching lines @@
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) +
                                               static_cast<uint32_t>(*j));
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
 
-// TODO(titzer): Fix for nosee4 and re-enable.
-#if 0
-
 TEST(Run_WasmFloat32Add) {
   WasmRunner<int32_t> r;
   // int(11.5f + 44.5f)
   BUILD(r,
         WASM_I32_SCONVERT_F32(WASM_F32_ADD(WASM_F32(11.5f), WASM_F32(44.5f))));
   CHECK_EQ(56, r.Call());
 }
 
 
 TEST(Run_WasmFloat64Add) {
   WasmRunner<int32_t> r;
   // return int(13.5d + 43.5d)
   BUILD(r, WASM_I32_SCONVERT_F64(WASM_F64_ADD(WASM_F64(13.5), WASM_F64(43.5))));
   CHECK_EQ(57, r.Call());
 }
 
-#endif
-
 
 void TestInt32Binop(WasmOpcode opcode, int32_t expected, int32_t a, int32_t b) {
   {
     WasmRunner<int32_t> r;
     // K op K
     BUILD(r, WASM_BINOP(opcode, WASM_I32(a), WASM_I32(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
@@ skipping 572 matching lines @@
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int32_t> r(MachineType::Float64());
     // return int(op(a))
     BUILD(r, WASM_I32_SCONVERT_F64(WASM_UNOP(opcode, WASM_GET_LOCAL(0))));
     CHECK_EQ(expected, r.Call(a));
   }
 }
 
-
-// TODO(titzer): Fix for nosee4 and re-enable.
-#if 0
-
 TEST(Run_WasmFloat32Binops) {
   TestFloat32Binop(kExprF32Eq, 1, 8.125f, 8.125f);
   TestFloat32Binop(kExprF32Ne, 1, 8.125f, 8.127f);
   TestFloat32Binop(kExprF32Lt, 1, -9.5f, -9.0f);
   TestFloat32Binop(kExprF32Le, 1, -1111.0f, -1111.0f);
   TestFloat32Binop(kExprF32Gt, 1, -9.0f, -9.5f);
   TestFloat32Binop(kExprF32Ge, 1, -1111.0f, -1111.0f);
 
   TestFloat32BinopWithConvert(kExprF32Add, 10, 3.5f, 6.5f);
   TestFloat32BinopWithConvert(kExprF32Sub, 2, 44.5f, 42.5f);
   TestFloat32BinopWithConvert(kExprF32Mul, -66, -132.1f, 0.5f);
   TestFloat32BinopWithConvert(kExprF32Div, 11, 22.1f, 2.0f);
 }
 
-
 TEST(Run_WasmFloat32Unops) {
   TestFloat32UnopWithConvert(kExprF32Abs, 8, 8.125f);
   TestFloat32UnopWithConvert(kExprF32Abs, 9, -9.125f);
   TestFloat32UnopWithConvert(kExprF32Neg, -213, 213.125f);
   TestFloat32UnopWithConvert(kExprF32Sqrt, 12, 144.4f);
 }
 
-
 TEST(Run_WasmFloat64Binops) {
   TestFloat64Binop(kExprF64Eq, 1, 16.25, 16.25);
   TestFloat64Binop(kExprF64Ne, 1, 16.25, 16.15);
   TestFloat64Binop(kExprF64Lt, 1, -32.4, 11.7);
   TestFloat64Binop(kExprF64Le, 1, -88.9, -88.9);
   TestFloat64Binop(kExprF64Gt, 1, 11.7, -32.4);
   TestFloat64Binop(kExprF64Ge, 1, -88.9, -88.9);
 
   TestFloat64BinopWithConvert(kExprF64Add, 100, 43.5, 56.5);
   TestFloat64BinopWithConvert(kExprF64Sub, 200, 12200.1, 12000.1);
   TestFloat64BinopWithConvert(kExprF64Mul, -33, 134, -0.25);
   TestFloat64BinopWithConvert(kExprF64Div, -1111, -2222.3, 2);
 }
 
-
 TEST(Run_WasmFloat64Unops) {
   TestFloat64UnopWithConvert(kExprF64Abs, 108, 108.125);
   TestFloat64UnopWithConvert(kExprF64Abs, 209, -209.125);
   TestFloat64UnopWithConvert(kExprF64Neg, -209, 209.125);
   TestFloat64UnopWithConvert(kExprF64Sqrt, 13, 169.4);
 }
 
-#endif
-
-
 TEST(Run_WasmFloat32Neg) {
   WasmRunner<float> r(MachineType::Float32());
   BUILD(r, WASM_F32_NEG(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     CHECK_EQ(0x80000000,
              bit_cast<uint32_t>(*i) ^ bit_cast<uint32_t>(r.Call(*i)));
   }
 }
 
@@ skipping 2549 matching lines @@
 
 #if WASM_64
 TEST(Compile_Wasm_CallIndirect_Many_i64) { CompileCallIndirectMany(kAstI64); }
 #endif
 
 
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
 
 
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }