[wasm] Fix simple graph building tests by enabling all optional operators.

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 179 matching lines @@
     if (module == nullptr) {
       module = new WasmModule();
       module->globals = nullptr;
       module->functions = nullptr;
       module->data_segments = nullptr;
     }
   }
 };
 
 
+static void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, FunctionEnv* env,
+                              const byte* start, const byte* end) {
+  compiler::WasmGraphBuilder builder(zone, jsgraph, env->sig);
+  TreeResult result = BuildTFGraph(&builder, env, start, end);
+  if (result.failed()) {
+    ptrdiff_t pc = result.error_pc - result.start;
+    ptrdiff_t pt = result.error_pt - result.start;
+    std::ostringstream str;
+    str << "Verification failed: " << result.error_code << " pc = +" << pc;
+    if (result.error_pt) str << ", pt = +" << pt;
+    str << ", msg = " << result.error_msg.get();
+    FATAL(str.str().c_str());
+  }
+  if (FLAG_trace_turbo_graph) {
+    OFStream os(stdout);
+    os << AsRPO(*jsgraph->graph());
+  }
+}
+
+
 // A helper for compiling functions that are only internally callable WASM code.
 class WasmFunctionCompiler : public HandleAndZoneScope,
                              private GraphAndBuilders {
  public:
   explicit WasmFunctionCompiler(FunctionSig* sig)
       : GraphAndBuilders(main_zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         descriptor_(nullptr) {
     init_env(&env, sig);
   }
 
   JSGraph jsgraph;
   FunctionEnv env;
   // The call descriptor is initialized when the function is compiled.
   CallDescriptor* descriptor_;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   CallDescriptor* descriptor() { return descriptor_; }
 
   void Build(const byte* start, const byte* end) {
-    compiler::WasmGraphBuilder builder(main_zone(), &jsgraph, env.sig);
-    TreeResult result = BuildTFGraph(&builder, &env, start, end);
-    if (result.failed()) {
-      ptrdiff_t pc = result.error_pc - result.start;
-      ptrdiff_t pt = result.error_pt - result.start;
-      std::ostringstream str;
-      str << "Verification failed: " << result.error_code << " pc = +" << pc;
-      if (result.error_pt) str << ", pt = +" << pt;
-      str << ", msg = " << result.error_msg.get();
-      FATAL(str.str().c_str());
-    }
-    if (FLAG_trace_turbo_graph) {
-      OFStream os(stdout);
-      os << AsRPO(*jsgraph.graph());
-    }
+    TestBuildingGraph(main_zone(), &jsgraph, &env, start, end);
   }
 
   byte AllocateLocal(LocalType type) {
     int result = static_cast<int>(env.total_locals);
     env.AddLocals(type, 1);
     byte b = static_cast<byte>(result);
     CHECK_EQ(result, b);
     return b;
   }
 
@@ skipping 2080 matching lines @@
 
 TEST(Run_Wasm_Infinite_Loop_not_taken2_brif) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_I8(45)),
                       WASM_INFINITE_LOOP));
   // Run the code, but don't go into the infinite loop.
   CHECK_EQ(45, r.Call(1));
 }
 
 
-// TODO(titzer): Fix for nosee4 and re-enable.
-#if 0
+static void TestBuildGraphForSimpleExpression(WasmOpcode opcode) {
+  if (!WasmOpcodes::IsSupported(opcode)) return;
 
-static void TestBuildGraphForUnop(WasmOpcode opcode, FunctionSig* sig) {
-  WasmRunner<int32_t> r(MachineType::Int32());
-  init_env(r.env(), sig);
-  BUILD(r, static_cast<byte>(opcode), kExprGetLocal, 0);
-}
+  Zone zone;
+  Isolate* isolate = CcTest::InitIsolateOnce();
+  HandleScope scope(isolate);
+  // Enable all optional operators.
+  CommonOperatorBuilder common(&zone);
+  MachineOperatorBuilder machine(&zone, MachineType::PointerRepresentation(),
+                                 MachineOperatorBuilder::kAllOptionalOps);
+  Graph graph(&zone);
+  JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
+  FunctionEnv env;
+  FunctionSig* sig = WasmOpcodes::Signature(opcode);
+  init_env(&env, sig);
 
-
-static void TestBuildGraphForBinop(WasmOpcode opcode, FunctionSig* sig) {
-  WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
-  init_env(r.env(), sig);
-  BUILD(r, static_cast<byte>(opcode), kExprGetLocal, 0, kExprGetLocal, 1);
+  if (sig->parameter_count() == 1) {
+    byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0};
+    TestBuildingGraph(&zone, &jsgraph, &env, code, code + arraysize(code));
+  } else {
+    CHECK_EQ(2, sig->parameter_count());
+    byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0, kExprGetLocal,
+                   1};
+    TestBuildingGraph(&zone, &jsgraph, &env, code, code + arraysize(code));
+  }
 }
 
 
 TEST(Build_Wasm_SimpleExprs) {
 // Test that the decoder can build a graph for all supported simple expressions.
-#define GRAPH_BUILD_TEST(name, opcode, sig)                 \
-  if (WasmOpcodes::IsSupported(kExpr##name)) {              \
-    FunctionSig* sig = WasmOpcodes::Signature(kExpr##name); \
-    printf("expression: " #name "\n");                      \
-    if (sig->parameter_count() == 1) {                      \
-      TestBuildGraphForUnop(kExpr##name, sig);              \
-    } else {                                                \
-      TestBuildGraphForBinop(kExpr##name, sig);             \
-    }                                                       \
-  }
+#define GRAPH_BUILD_TEST(name, opcode, sig) \
+  TestBuildGraphForSimpleExpression(kExpr##name);
 
   FOREACH_SIMPLE_OPCODE(GRAPH_BUILD_TEST);
 
 #undef GRAPH_BUILD_TEST
 }
 
-#endif
-
 
 TEST(Run_Wasm_Int32LoadInt8_signext) {
   TestingModule module;
   const int kNumElems = 16;
   int8_t* memory = module.AddMemoryElems<int8_t>(kNumElems);
   module.RandomizeMemory();
   memory[0] = -1;
   WasmRunner<int32_t> r(MachineType::Int32());
   r.env()->module = &module;
   BUILD(r, WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0)));
@@ skipping 1222 matching lines @@
 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