LCOV - code coverage report
Current view: top level - test/cctest/wasm - wasm-run-utils.h (source / functions) Hit Total Coverage
Test: app.info Lines: 131 134 97.8 %
Date: 2019-02-19 Functions: 491 593 82.8 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef WASM_RUN_UTILS_H
       6             : #define WASM_RUN_UTILS_H
       7             : 
       8             : #include <setjmp.h>
       9             : #include <stdint.h>
      10             : #include <stdlib.h>
      11             : #include <string.h>
      12             : #include <array>
      13             : #include <memory>
      14             : 
      15             : #include "src/base/utils/random-number-generator.h"
      16             : #include "src/compiler/compiler-source-position-table.h"
      17             : #include "src/compiler/graph-visualizer.h"
      18             : #include "src/compiler/int64-lowering.h"
      19             : #include "src/compiler/js-graph.h"
      20             : #include "src/compiler/node.h"
      21             : #include "src/compiler/pipeline.h"
      22             : #include "src/compiler/wasm-compiler.h"
      23             : #include "src/compiler/zone-stats.h"
      24             : #include "src/trap-handler/trap-handler.h"
      25             : #include "src/wasm/function-body-decoder.h"
      26             : #include "src/wasm/local-decl-encoder.h"
      27             : #include "src/wasm/wasm-code-manager.h"
      28             : #include "src/wasm/wasm-external-refs.h"
      29             : #include "src/wasm/wasm-interpreter.h"
      30             : #include "src/wasm/wasm-js.h"
      31             : #include "src/wasm/wasm-module.h"
      32             : #include "src/wasm/wasm-objects-inl.h"
      33             : #include "src/wasm/wasm-objects.h"
      34             : #include "src/wasm/wasm-opcodes.h"
      35             : #include "src/wasm/wasm-tier.h"
      36             : #include "src/zone/accounting-allocator.h"
      37             : #include "src/zone/zone.h"
      38             : 
      39             : #include "test/cctest/cctest.h"
      40             : #include "test/cctest/compiler/call-tester.h"
      41             : #include "test/cctest/compiler/graph-builder-tester.h"
      42             : #include "test/cctest/compiler/value-helper.h"
      43             : #include "test/common/wasm/flag-utils.h"
      44             : 
      45             : namespace v8 {
      46             : namespace internal {
      47             : namespace wasm {
      48             : 
      49             : constexpr uint32_t kMaxFunctions = 10;
      50             : constexpr uint32_t kMaxGlobalsSize = 128;
      51             : 
      52             : using compiler::CallDescriptor;
      53             : using compiler::MachineTypeForC;
      54             : using compiler::Node;
      55             : 
      56             : // TODO(titzer): check traps more robustly in tests.
      57             : // Currently, in tests, we just return 0xDEADBEEF from the function in which
      58             : // the trap occurs if the runtime context is not available to throw a JavaScript
      59             : // exception.
      60             : #define CHECK_TRAP32(x) \
      61             :   CHECK_EQ(0xDEADBEEF, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
      62             : #define CHECK_TRAP64(x) \
      63             :   CHECK_EQ(0xDEADBEEFDEADBEEF, (bit_cast<uint64_t>(x)) & 0xFFFFFFFFFFFFFFFF)
      64             : #define CHECK_TRAP(x) CHECK_TRAP32(x)
      65             : 
      66             : #define WASM_WRAPPER_RETURN_VALUE 8754
      67             : 
      68             : #define BUILD(r, ...)                      \
      69             :   do {                                     \
      70             :     byte code[] = {__VA_ARGS__};           \
      71             :     r.Build(code, code + arraysize(code)); \
      72             :   } while (false)
      73             : 
      74             : // For tests that must manually import a JSFunction with source code.
      75             : struct ManuallyImportedJSFunction {
      76             :   FunctionSig* sig;
      77             :   Handle<JSFunction> js_function;
      78             : };
      79             : 
      80             : // A  Wasm module builder. Globals are pre-set, however, memory and code may be
      81             : // progressively added by a test. In turn, we piecemeal update the runtime
      82             : // objects, i.e. {WasmInstanceObject}, {WasmModuleObject} and, if necessary,
      83             : // the interpreter.
      84             : class TestingModuleBuilder {
      85             :  public:
      86             :   TestingModuleBuilder(Zone*, ManuallyImportedJSFunction*, ExecutionTier,
      87             :                        RuntimeExceptionSupport, LowerSimd);
      88             : 
      89         384 :   void ChangeOriginToAsmjs() { test_module_->origin = kAsmJsOrigin; }
      90             : 
      91             :   byte* AddMemory(uint32_t size);
      92             : 
      93             :   size_t CodeTableLength() const { return native_module_->num_functions(); }
      94             : 
      95             :   template <typename T>
      96       35492 :   T* AddMemoryElems(uint32_t count) {
      97       39908 :     AddMemory(count * sizeof(T));
      98             :     return raw_mem_start<T>();
      99             :   }
     100             : 
     101             :   template <typename T>
     102             :   T* AddGlobal(
     103         216 :       ValueType type = ValueTypes::ValueTypeFor(MachineTypeForC<T>())) {
     104       18992 :     const WasmGlobal* global = AddGlobal(type);
     105       18980 :     return reinterpret_cast<T*>(globals_data_ + global->offset);
     106             :   }
     107             : 
     108        3120 :   byte AddSignature(FunctionSig* sig) {
     109             :     DCHECK_EQ(test_module_->signatures.size(),
     110             :               test_module_->signature_ids.size());
     111       12480 :     test_module_->signatures.push_back(sig);
     112        6240 :     auto canonical_sig_num = test_module_->signature_map.FindOrInsert(*sig);
     113        3120 :     test_module_->signature_ids.push_back(canonical_sig_num);
     114        3120 :     size_t size = test_module_->signatures.size();
     115        3120 :     CHECK_GT(127, size);
     116        3120 :     return static_cast<byte>(size - 1);
     117             :   }
     118             : 
     119             :   template <typename T>
     120             :   T* raw_mem_start() {
     121             :     DCHECK(mem_start_);
     122             :     return reinterpret_cast<T*>(mem_start_);
     123             :   }
     124             : 
     125             :   template <typename T>
     126             :   T* raw_mem_end() {
     127             :     DCHECK(mem_start_);
     128       15564 :     return reinterpret_cast<T*>(mem_start_ + mem_size_);
     129             :   }
     130             : 
     131             :   template <typename T>
     132             :   T raw_mem_at(int i) {
     133             :     DCHECK(mem_start_);
     134       58560 :     return ReadMemory(&(reinterpret_cast<T*>(mem_start_)[i]));
     135             :   }
     136             : 
     137             :   template <typename T>
     138             :   T raw_val_at(int i) {
     139         792 :     return ReadMemory(reinterpret_cast<T*>(mem_start_ + i));
     140             :   }
     141             : 
     142             :   template <typename T>
     143             :   void WriteMemory(T* p, T val) {
     144             :     WriteLittleEndianValue<T>(reinterpret_cast<Address>(p), val);
     145             :   }
     146             : 
     147             :   template <typename T>
     148             :   T ReadMemory(T* p) {
     149             :     return ReadLittleEndianValue<T>(reinterpret_cast<Address>(p));
     150             :   }
     151             : 
     152             :   // Zero-initialize the memory.
     153         588 :   void BlankMemory() {
     154             :     byte* raw = raw_mem_start<byte>();
     155         588 :     memset(raw, 0, mem_size_);
     156             :   }
     157             : 
     158             :   // Pseudo-randomly intialize the memory.
     159       15564 :   void RandomizeMemory(unsigned int seed = 88) {
     160             :     byte* raw = raw_mem_start<byte>();
     161             :     byte* end = raw_mem_end<byte>();
     162       15564 :     v8::base::RandomNumberGenerator rng;
     163       15564 :     rng.SetSeed(seed);
     164       15564 :     rng.NextBytes(raw, end - raw);
     165       15564 :   }
     166             : 
     167           8 :   void SetMaxMemPages(uint32_t maximum_pages) {
     168           8 :     test_module_->maximum_pages = maximum_pages;
     169          16 :     if (instance_object()->has_memory_object()) {
     170          24 :       instance_object()->memory_object()->set_maximum_pages(maximum_pages);
     171             :     }
     172           8 :   }
     173             : 
     174        1116 :   void SetHasSharedMemory() { test_module_->has_shared_memory = true; }
     175             : 
     176             :   enum FunctionType { kImport, kWasm };
     177             :   uint32_t AddFunction(FunctionSig* sig, const char* name, FunctionType type);
     178             : 
     179             :   // Wrap the code so it can be called as a JS function.
     180             :   Handle<JSFunction> WrapCode(uint32_t index);
     181             : 
     182             :   void AddIndirectFunctionTable(const uint16_t* function_indexes,
     183             :                                 uint32_t table_size);
     184             : 
     185             :   void PopulateIndirectFunctionTable();
     186             : 
     187             :   uint32_t AddBytes(Vector<const byte> bytes);
     188             : 
     189             :   uint32_t AddException(FunctionSig* sig);
     190             : 
     191             :   WasmFunction* GetFunctionAt(int index) {
     192     1102204 :     return &test_module_->functions[index];
     193             :   }
     194             : 
     195             :   WasmInterpreter* interpreter() const { return interpreter_; }
     196             :   bool interpret() const { return interpreter_ != nullptr; }
     197             :   LowerSimd lower_simd() const { return lower_simd_; }
     198             :   Isolate* isolate() const { return isolate_; }
     199             :   Handle<WasmInstanceObject> instance_object() const {
     200             :     return instance_object_;
     201             :   }
     202             :   WasmCode* GetFunctionCode(uint32_t index) const {
     203             :     return native_module_->code(index);
     204             :   }
     205             :   Address globals_start() const {
     206             :     return reinterpret_cast<Address>(globals_data_);
     207             :   }
     208             : 
     209     9259552 :   void SetExecutable() { native_module_->SetExecutable(true); }
     210             : 
     211             :   CompilationEnv CreateCompilationEnv();
     212             : 
     213             :   ExecutionTier execution_tier() const { return execution_tier_; }
     214             : 
     215             :   RuntimeExceptionSupport runtime_exception_support() const {
     216             :     return runtime_exception_support_;
     217             :   }
     218             : 
     219             :  private:
     220             :   std::shared_ptr<WasmModule> test_module_;
     221             :   WasmModule* test_module_ptr_;
     222             :   Isolate* isolate_;
     223             :   WasmFeatures enabled_features_;
     224             :   uint32_t global_offset = 0;
     225             :   byte* mem_start_ = nullptr;
     226             :   uint32_t mem_size_ = 0;
     227             :   alignas(16) byte globals_data_[kMaxGlobalsSize];
     228             :   WasmInterpreter* interpreter_ = nullptr;
     229             :   ExecutionTier execution_tier_;
     230             :   Handle<WasmInstanceObject> instance_object_;
     231             :   NativeModule* native_module_ = nullptr;
     232             :   RuntimeExceptionSupport runtime_exception_support_;
     233             :   LowerSimd lower_simd_;
     234             : 
     235             :   const WasmGlobal* AddGlobal(ValueType type);
     236             : 
     237             :   Handle<WasmInstanceObject> InitInstanceObject();
     238             : };
     239             : 
     240             : void TestBuildingGraph(Zone* zone, compiler::JSGraph* jsgraph,
     241             :                        CompilationEnv* module, FunctionSig* sig,
     242             :                        compiler::SourcePositionTable* source_position_table,
     243             :                        const byte* start, const byte* end);
     244             : 
     245             : class WasmFunctionWrapper : private compiler::GraphAndBuilders {
     246             :  public:
     247             :   WasmFunctionWrapper(Zone* zone, int num_params);
     248             : 
     249             :   void Init(CallDescriptor* call_descriptor, MachineType return_type,
     250             :             Vector<MachineType> param_types);
     251             : 
     252             :   template <typename ReturnType, typename... ParamTypes>
     253      728952 :   void Init(CallDescriptor* call_descriptor) {
     254             :     std::array<MachineType, sizeof...(ParamTypes)> param_machine_types{
     255       16256 :         {MachineTypeForC<ParamTypes>()...}};
     256             :     Vector<MachineType> param_vec(param_machine_types.data(),
     257             :                                   param_machine_types.size());
     258      728952 :     Init(call_descriptor, MachineTypeForC<ReturnType>(), param_vec);
     259      728952 :   }
     260             : 
     261     9255320 :   void SetInnerCode(WasmCode* code) {
     262             :     intptr_t address = static_cast<intptr_t>(code->instruction_start());
     263             :     compiler::NodeProperties::ChangeOp(
     264             :         inner_code_node_,
     265     9255320 :         common()->ExternalConstant(ExternalReference::FromRawAddress(address)));
     266     9255320 :   }
     267             : 
     268      728952 :   const compiler::Operator* IntPtrConstant(intptr_t value) {
     269             :     return machine()->Is32()
     270           0 :                ? common()->Int32Constant(static_cast<int32_t>(value))
     271      728952 :                : common()->Int64Constant(static_cast<int64_t>(value));
     272             :   }
     273             : 
     274     9255320 :   void SetInstance(Handle<WasmInstanceObject> instance) {
     275             :     compiler::NodeProperties::ChangeOp(context_address_,
     276     9255320 :                                        common()->HeapConstant(instance));
     277     9255320 :   }
     278             : 
     279             :   Handle<Code> GetWrapperCode();
     280             : 
     281             :   Signature<MachineType>* signature() const { return signature_; }
     282             : 
     283             :  private:
     284             :   Node* inner_code_node_;
     285             :   Node* context_address_;
     286             :   MaybeHandle<Code> code_;
     287             :   Signature<MachineType>* signature_;
     288             : };
     289             : 
     290             : // A helper for compiling wasm functions for testing.
     291             : // It contains the internal state for compilation (i.e. TurboFan graph) and
     292             : // interpretation (by adding to the interpreter manually).
     293     1102172 : class WasmFunctionCompiler : public compiler::GraphAndBuilders {
     294             :  public:
     295             :   ~WasmFunctionCompiler();
     296             : 
     297     2193312 :   Isolate* isolate() { return builder_->isolate(); }
     298      728952 :   CallDescriptor* descriptor() {
     299      728952 :     if (descriptor_ == nullptr) {
     300     1457904 :       descriptor_ = compiler::GetWasmCallDescriptor(zone(), sig);
     301             :     }
     302      728952 :     return descriptor_;
     303             :   }
     304        7240 :   uint32_t function_index() { return function_->func_index; }
     305             : 
     306             :   void Build(const byte* start, const byte* end);
     307             : 
     308             :   byte AllocateLocal(ValueType type) {
     309      193800 :     uint32_t index = local_decls.AddLocals(1, type);
     310        5452 :     byte result = static_cast<byte>(index);
     311             :     DCHECK_EQ(index, result);
     312             :     return result;
     313             :   }
     314             : 
     315         108 :   void SetSigIndex(int sig_index) { function_->sig_index = sig_index; }
     316             : 
     317             :  private:
     318             :   friend class WasmRunnerBase;
     319             : 
     320             :   WasmFunctionCompiler(Zone* zone, FunctionSig* sig,
     321             :                        TestingModuleBuilder* builder, const char* name);
     322             : 
     323             :   compiler::JSGraph jsgraph;
     324             :   FunctionSig* sig;
     325             :   // The call descriptor is initialized when the function is compiled.
     326             :   CallDescriptor* descriptor_;
     327             :   TestingModuleBuilder* builder_;
     328             :   WasmFunction* function_;
     329             :   LocalDeclEncoder local_decls;
     330             :   compiler::SourcePositionTable source_position_table_;
     331             :   WasmInterpreter* interpreter_;
     332             : };
     333             : 
     334             : // A helper class to build a module around Wasm bytecode, generate machine
     335             : // code, and run that code.
     336     2187224 : class WasmRunnerBase : public HandleAndZoneScope {
     337             :  public:
     338     1093612 :   WasmRunnerBase(ManuallyImportedJSFunction* maybe_import,
     339             :                  ExecutionTier execution_tier, int num_params,
     340             :                  RuntimeExceptionSupport runtime_exception_support,
     341             :                  LowerSimd lower_simd)
     342             :       : zone_(&allocator_, ZONE_NAME),
     343             :         builder_(&zone_, maybe_import, execution_tier,
     344             :                  runtime_exception_support, lower_simd),
     345     2187224 :         wrapper_(&zone_, num_params) {}
     346             : 
     347             :   // Builds a graph from the given Wasm code and generates the machine
     348             :   // code and call wrapper for that graph. This method must not be called
     349             :   // more than once.
     350     1088248 :   void Build(const byte* start, const byte* end) {
     351     1088248 :     CHECK(!compiled_);
     352     1088248 :     compiled_ = true;
     353     2176496 :     functions_[0]->Build(start, end);
     354     1088248 :   }
     355             : 
     356             :   // Resets the state for building the next function.
     357             :   // The main function called will always be the first function.
     358             :   template <typename ReturnType, typename... ParamTypes>
     359     1093772 :   WasmFunctionCompiler& NewFunction(const char* name = nullptr) {
     360     1093772 :     return NewFunction(CreateSig<ReturnType, ParamTypes...>(), name);
     361             :   }
     362             : 
     363             :   // Resets the state for building the next function.
     364             :   // The main function called will be the last generated function.
     365             :   // Returns the index of the previously built function.
     366     1102172 :   WasmFunctionCompiler& NewFunction(FunctionSig* sig,
     367             :                                     const char* name = nullptr) {
     368             :     functions_.emplace_back(
     369     1102172 :         new WasmFunctionCompiler(&zone_, sig, &builder_, name));
     370     1102172 :     return *functions_.back();
     371             :   }
     372             : 
     373             :   byte AllocateLocal(ValueType type) {
     374      193792 :     return functions_[0]->AllocateLocal(type);
     375             :   }
     376             : 
     377         160 :   uint32_t function_index() { return functions_[0]->function_index(); }
     378     9265248 :   WasmFunction* function() { return functions_[0]->function_; }
     379             :   WasmInterpreter* interpreter() {
     380             :     DCHECK(interpret());
     381     9256048 :     return functions_[0]->interpreter_;
     382             :   }
     383             :   bool possible_nondeterminism() { return possible_nondeterminism_; }
     384             :   TestingModuleBuilder& builder() { return builder_; }
     385             :   Zone* zone() { return &zone_; }
     386             : 
     387    14976940 :   bool interpret() { return builder_.interpret(); }
     388             : 
     389             :   template <typename ReturnType, typename... ParamTypes>
     390     1093796 :   FunctionSig* CreateSig() {
     391             :     std::array<MachineType, sizeof...(ParamTypes)> param_machine_types{
     392       24484 :         {MachineTypeForC<ParamTypes>()...}};
     393             :     Vector<MachineType> param_vec(param_machine_types.data(),
     394             :                                   param_machine_types.size());
     395     1093796 :     return CreateSig(MachineTypeForC<ReturnType>(), param_vec);
     396             :   }
     397             : 
     398             :  private:
     399             :   FunctionSig* CreateSig(MachineType return_type,
     400             :                          Vector<MachineType> param_types);
     401             : 
     402             :  protected:
     403             :   v8::internal::AccountingAllocator allocator_;
     404             :   Zone zone_;
     405             :   TestingModuleBuilder builder_;
     406             :   std::vector<std::unique_ptr<WasmFunctionCompiler>> functions_;
     407             :   WasmFunctionWrapper wrapper_;
     408             :   bool compiled_ = false;
     409             :   bool possible_nondeterminism_ = false;
     410             : 
     411             :  public:
     412             :   // This field has to be static. Otherwise, gcc complains about the use in
     413             :   // the lambda context below.
     414             :   static bool trap_happened;
     415             : };
     416             : 
     417             : template <typename ReturnType, typename... ParamTypes>
     418     2187224 : class WasmRunner : public WasmRunnerBase {
     419             :  public:
     420     1093612 :   WasmRunner(ExecutionTier execution_tier,
     421             :              ManuallyImportedJSFunction* maybe_import = nullptr,
     422             :              const char* main_fn_name = "main",
     423             :              RuntimeExceptionSupport runtime_exception_support =
     424             :                  kNoRuntimeExceptionSupport,
     425             :              LowerSimd lower_simd = kNoLowerSimd)
     426             :       : WasmRunnerBase(maybe_import, execution_tier, sizeof...(ParamTypes),
     427     1093612 :                        runtime_exception_support, lower_simd) {
     428     1093612 :     NewFunction<ReturnType, ParamTypes...>(main_fn_name);
     429     1093612 :     if (!interpret()) {
     430     1457904 :       wrapper_.Init<ReturnType, ParamTypes...>(functions_[0]->descriptor());
     431             :     }
     432     1093612 :   }
     433             : 
     434             :   WasmRunner(ExecutionTier execution_tier, LowerSimd lower_simd)
     435             :       : WasmRunner(execution_tier, nullptr, "main", kNoRuntimeExceptionSupport,
     436       12648 :                    lower_simd) {}
     437             : 
     438    13883328 :   ReturnType Call(ParamTypes... p) {
     439             :     DCHECK(compiled_);
     440    13883328 :     if (interpret()) return CallInterpreter(p...);
     441             : 
     442     9255320 :     ReturnType return_value = static_cast<ReturnType>(0xDEADBEEFDEADBEEF);
     443     9255320 :     WasmRunnerBase::trap_happened = false;
     444             : 
     445      144624 :     auto trap_callback = []() -> void {
     446       72312 :       WasmRunnerBase::trap_happened = true;
     447       72312 :       set_trap_callback_for_testing(nullptr);
     448           0 :     };
     449     9255320 :     set_trap_callback_for_testing(trap_callback);
     450             : 
     451    37021280 :     wrapper_.SetInnerCode(builder_.GetFunctionCode(0));
     452     9255320 :     wrapper_.SetInstance(builder_.instance_object());
     453             :     builder_.SetExecutable();
     454     9255320 :     Handle<Code> wrapper_code = wrapper_.GetWrapperCode();
     455             :     compiler::CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
     456     9255320 :                                          wrapper_code, wrapper_.signature());
     457             :     int32_t result;
     458             :     {
     459             :       trap_handler::SetThreadInWasm();
     460             : 
     461     9255320 :       result = runner.Call(static_cast<void*>(&p)...,
     462             :                            static_cast<void*>(&return_value));
     463             : 
     464             :       trap_handler::ClearThreadInWasm();
     465             :     }
     466     9255320 :     CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
     467             :     return WasmRunnerBase::trap_happened
     468             :                ? static_cast<ReturnType>(0xDEADBEEFDEADBEEF)
     469     9255320 :                : return_value;
     470             :   }
     471             : 
     472     4628008 :   ReturnType CallInterpreter(ParamTypes... p) {
     473     4628008 :     WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
     474     4628008 :     thread->Reset();
     475     3855196 :     std::array<WasmValue, sizeof...(p)> args{{WasmValue(p)...}};
     476     4628008 :     thread->InitFrame(function(), args.data());
     477     4628008 :     thread->Run();
     478     9256016 :     CHECK_GT(thread->NumInterpretedCalls(), 0);
     479     4628008 :     if (thread->state() == WasmInterpreter::FINISHED) {
     480     4591848 :       WasmValue val = thread->GetReturnValue();
     481     4591848 :       possible_nondeterminism_ |= thread->PossibleNondeterminism();
     482             :       return val.to<ReturnType>();
     483       36160 :     } else if (thread->state() == WasmInterpreter::TRAPPED) {
     484             :       // TODO(titzer): return the correct trap code
     485             :       int64_t result = 0xDEADBEEFDEADBEEF;
     486             :       return static_cast<ReturnType>(result);
     487             :     } else {
     488             :       // TODO(titzer): falling off end
     489           0 :       return ReturnType{0};
     490             :     }
     491             :   }
     492             : 
     493        4284 :   void CheckCallViaJS(double expected, uint32_t function_index,
     494             :                       Handle<Object>* buffer, int count) {
     495        8568 :     Isolate* isolate = builder_.isolate();
     496       17136 :     if (jsfuncs_.size() <= function_index) {
     497        4092 :       jsfuncs_.resize(function_index + 1);
     498             :     }
     499        4284 :     if (jsfuncs_[function_index].is_null()) {
     500        4092 :       jsfuncs_[function_index] = builder_.WrapCode(function_index);
     501             :     }
     502        4284 :     Handle<JSFunction> jsfunc = jsfuncs_[function_index];
     503        8568 :     Handle<Object> global(isolate->context()->global_object(), isolate);
     504             :     MaybeHandle<Object> retval =
     505        4284 :         Execution::Call(isolate, jsfunc, global, count, buffer);
     506             : 
     507        4284 :     CHECK(!retval.is_null());
     508             :     Handle<Object> result = retval.ToHandleChecked();
     509        8568 :     if (result->IsSmi()) {
     510        4776 :       CHECK_EQ(expected, Smi::ToInt(*result));
     511             :     } else {
     512        3792 :       CHECK(result->IsHeapNumber());
     513        1896 :       CHECK_DOUBLE_EQ(expected, HeapNumber::cast(*result)->value());
     514             :     }
     515             : 
     516        4284 :     if (builder_.interpret()) {
     517        2856 :       CHECK_GT(builder_.interpreter()->GetThread(0)->NumInterpretedCalls(), 0);
     518             :     }
     519        4284 :   }
     520             : 
     521         360 :   void CheckCallViaJS(double expected, ParamTypes... p) {
     522         360 :     Isolate* isolate = builder_.isolate();
     523         360 :     uint32_t function_index = function()->func_index;
     524         360 :     Handle<Object> buffer[] = {isolate->factory()->NewNumber(p)...};
     525         360 :     CheckCallViaJS(expected, function_index, buffer, sizeof...(p));
     526         360 :   }
     527             : 
     528             :   Handle<Code> GetWrapperCode() { return wrapper_.GetWrapperCode(); }
     529             : 
     530             :  private:
     531             :   std::vector<Handle<JSFunction>> jsfuncs_;
     532             : };
     533             : 
     534             : // A macro to define tests that run in different engine configurations.
     535             : #define WASM_EXEC_TEST(name)                                                  \
     536             :   void RunWasm_##name(ExecutionTier execution_tier);                          \
     537             :   TEST(RunWasmTurbofan_##name) { RunWasm_##name(ExecutionTier::kOptimized); } \
     538             :   TEST(RunWasmLiftoff_##name) { RunWasm_##name(ExecutionTier::kBaseline); }   \
     539             :   TEST(RunWasmInterpreter_##name) {                                           \
     540             :     RunWasm_##name(ExecutionTier::kInterpreter);                              \
     541             :   }                                                                           \
     542             :   void RunWasm_##name(ExecutionTier execution_tier)
     543             : 
     544             : #define WASM_COMPILED_EXEC_TEST(name)                                         \
     545             :   void RunWasm_##name(ExecutionTier execution_tier);                          \
     546             :   TEST(RunWasmTurbofan_##name) { RunWasm_##name(ExecutionTier::kOptimized); } \
     547             :   TEST(RunWasmLiftoff_##name) { RunWasm_##name(ExecutionTier::kBaseline); }   \
     548             :   void RunWasm_##name(ExecutionTier execution_tier)
     549             : 
     550             : }  // namespace wasm
     551             : }  // namespace internal
     552             : }  // namespace v8
     553             : 
     554             : #endif

Generated by: LCOV version 1.10