[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 28 matching lines @@
 // TODO(titzer): check traps more robustly in tests.
 // Currently, in tests, we just return 0xdeadbeef from the function in which
 // the trap occurs if the runtime context is not available to throw a JavaScript
 // exception.
 #define CHECK_TRAP32(x) \
   CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
 #define CHECK_TRAP64(x) \
   CHECK_EQ(0xdeadbeefdeadbeef, (bit_cast<uint64_t>(x)) & 0xFFFFFFFFFFFFFFFF)
 #define CHECK_TRAP(x) CHECK_TRAP32(x)
 
+#define WASM_RUNNER_MAX_NUM_PARAMETERS 4
 #define WASM_WRAPPER_RETURN_VALUE 8754
 
 namespace {
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
 
 inline void init_env(FunctionEnv* env, FunctionSig* sig) {
   env->module = nullptr;
@@ skipping 194 matching lines @@
 }
 
 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);
+    // One additional parameter for the pointer to the return value memory.
+    Signature<MachineType>::Builder sig_builder(
+        zone(), 1, WASM_RUNNER_MAX_NUM_PARAMETERS + 1);
 
     sig_builder.AddReturn(MachineType::Int32());
-    for (int i = 0; i < 5; i++) {
+    for (int i = 0; i < WASM_RUNNER_MAX_NUM_PARAMETERS + 1; i++) {
       sig_builder.AddParam(MachineType::Pointer());
     }
     signature_ = sig_builder.Build();
   }
 
   void Init(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);
+    Node** parameters =
+        zone()->template NewArray<Node*>(WASM_RUNNER_MAX_NUM_PARAMETERS + 3);
     graph()->SetStart(graph()->NewNode(common()->Start(6)));
     Node* effect = graph()->start();
     int parameter_count = 0;
 
     // Dummy node which gets replaced in SetInnerCode.
     inner_code_node_ = graph()->NewNode(common()->Int32Constant(0));
     parameters[parameter_count++] = inner_code_node_;
 
     if (p0 != MachineType::None()) {
       parameters[parameter_count] = graph()->NewNode(
@@ skipping 30 matching lines @@
 
     parameters[parameter_count++] = effect;
     parameters[parameter_count++] = graph()->start();
     Node* call = graph()->NewNode(common()->Call(descriptor), parameter_count,
                                   parameters);
 
     effect = graph()->NewNode(
         machine()->Store(
             StoreRepresentation(MachineTypeForC<ReturnType>().representation(),
                                 WriteBarrierKind::kNoWriteBarrier)),
-        graph()->NewNode(common()->Parameter(4), graph()->start()),
+        graph()->NewNode(common()->Parameter(WASM_RUNNER_MAX_NUM_PARAMETERS),
+                         graph()->start()),
         graph()->NewNode(common()->Int32Constant(0)), call, effect,
         graph()->start());
     Node* r = graph()->NewNode(
         common()->Return(),
         graph()->NewNode(common()->Int32Constant(WASM_WRAPPER_RETURN_VALUE)),
         effect, graph()->start());
     graph()->SetEnd(graph()->NewNode(common()->End(2), r, graph()->start()));
   }
 
   void SetInnerCode(Handle<Code> code_handle) {
     NodeProperties::ChangeOp(inner_code_node_,
                              common()->HeapConstant(code_handle));
   }
 
   Handle<Code> GetWrapperCode() {
     if (code_.is_null()) {
       Isolate* isolate = CcTest::InitIsolateOnce();
 
       CallDescriptor* descriptor =
           Linkage::GetSimplifiedCDescriptor(zone(), signature_, true);
 
+      if (kPointerSize == 4) {
+        // One additional parameter for the pointer of the return value.
+        Signature<MachineRepresentation>::Builder rep_builder(
+            zone(), 1, WASM_RUNNER_MAX_NUM_PARAMETERS + 1);
+
+        rep_builder.AddReturn(MachineRepresentation::kWord32);
+        for (int i = 0; i < WASM_RUNNER_MAX_NUM_PARAMETERS + 1; i++) {
+          rep_builder.AddParam(MachineRepresentation::kWord32);
+        }
+        Int64Lowering r(graph(), machine(), common(), zone(),
+                        rep_builder.Build());
+        r.LowerGraph();
+      }
+
       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 47 matching lines @@
   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();
+    CallDescriptor* desc = descriptor_;
+    if (kPointerSize == 4) {
+      desc = module->GetI32WasmCallDescriptor(this->zone(), desc);
+    }
     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 88 matching lines @@
 
   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;
   }
 
  private:
-  LocalType storage_[5];
+  LocalType storage_[WASM_RUNNER_MAX_NUM_PARAMETERS];
   FunctionSig signature_;
   WasmFunctionCompiler compiler_;
   WasmFunctionWrapper<ReturnType> wrapper_;
   bool compilation_done_;
 
   static size_t GetParameterCount(MachineType p0, MachineType p1,
                                   MachineType p2, MachineType p3) {
     if (p0 == MachineType::None()) return 0;
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif