[wasm] WasmRunner can run tests with I64 parameters and return value.

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 225 matching lines @@
   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());
   }
-  builder.Int64LoweringForTesting();
+  builder.Int64LoweringForTesting(env->sig);
   if (FLAG_trace_turbo_graph) {
     OFStream os(stdout);
     os << AsRPO(*jsgraph->graph());
   }
 }
 
 template <typename ReturnType>
 class WasmFunctionWrapper : public HandleAndZoneScope,
                             private GraphAndBuilders {
  public:
   WasmFunctionWrapper()
       : GraphAndBuilders(main_zone()),
         inner_code_node_(nullptr),
         signature_(nullptr) {
     Signature<MachineType>::Builder sig_builder(zone(), 1, 5);
 
     sig_builder.AddReturn(MachineType::Int32());
     for (int i = 0; i < 5; i++) {
       sig_builder.AddParam(MachineType::Pointer());
     }
     signature_ = sig_builder.Build();
   }
 
-  void Init(CallDescriptor* descriptor, MachineType p0 = MachineType::None(),
+  void Init(const CallDescriptor* descriptor,
+            MachineType p0 = MachineType::None(),
             MachineType p1 = MachineType::None(),
             MachineType p2 = MachineType::None(),
             MachineType p3 = MachineType::None()) {
     // Create the TF graph for the wrapper. The wrapper always takes four
     // pointers as parameters, but may not pass the values of all pointers to
     // the actual test function.
 
     // Function, effect, and control.
     Node** parameters = zone()->template NewArray<Node*>(4 + 3);
     graph()->SetStart(graph()->NewNode(common()->Start(6)));
@@ skipping 60 matching lines @@
                              common()->HeapConstant(code_handle));
   }
 
   Handle<Code> GetWrapperCode() {
     if (code_.is_null()) {
       Isolate* isolate = CcTest::InitIsolateOnce();
 
       CallDescriptor* descriptor =
           Linkage::GetSimplifiedCDescriptor(zone(), signature_, true);
 
+#if !WASM_64
+
+      Signature<MachineRepresentation>::Builder rep_builder(zone(), 1, 4);
+
+      rep_builder.AddReturn(MachineRepresentation::kWord32);
+      for (int i = 0; i < 4; i++) {
+        rep_builder.AddParam(MachineRepresentation::kWord32);
+      }
+      Int64Lowering r(graph(), machine(), common(), zone(),
+                      rep_builder.Build());
+      r.LowerGraph();
+#endif
+
       CompilationInfo info("testing", isolate, graph()->zone());
       code_ =
           Pipeline::GenerateCodeForTesting(&info, descriptor, graph(), nullptr);
       CHECK(!code_.is_null());
 #ifdef ENABLE_DISASSEMBLER
       if (FLAG_print_opt_code) {
         OFStream os(stdout);
         code_->Disassemble("wasm wrapper", os);
       }
 #endif
@@ skipping 19 matching lines @@
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         descriptor_(nullptr) {
     init_env(&env, sig);
     env.module = module;
   }
 
   JSGraph jsgraph;
   FunctionEnv env;
   // The call descriptor is initialized when the function is compiled.
-  CallDescriptor* descriptor_;
+  const 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_; }
   void InitializeDescriptor() {
     if (descriptor_ == nullptr) {
       descriptor_ = env.module->GetWasmCallDescriptor(main_zone(), env.sig);
     }
   }
-  CallDescriptor* descriptor() { return descriptor_; }
+  const CallDescriptor* descriptor() { return descriptor_; }
 
   void Build(const byte* start, const byte* end) {
     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;
   }
 
   Handle<Code> Compile(ModuleEnv* module) {
     InitializeDescriptor();
+    const CallDescriptor* desc = descriptor_;
+#if !WASM_64
+    desc = module->GetI32WasmCallDescriptor(this->zone(), desc);
+#endif
     CompilationInfo info("wasm compile", this->isolate(), this->zone());
     Handle<Code> result =
-        Pipeline::GenerateCodeForTesting(&info, descriptor_, this->graph());
+        Pipeline::GenerateCodeForTesting(&info, desc, this->graph());
 #ifdef ENABLE_DISASSEMBLER
     if (!result.is_null() && FLAG_print_opt_code) {
       OFStream os(stdout);
       result->Disassemble("wasm code", os);
     }
 #endif
 
     return result;
   }
 
@@ skipping 107 matching lines @@
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif