Line data    Source code

       1             : // Copyright 2014 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 V8_CCTEST_COMPILER_CALL_TESTER_H_
       6             : #define V8_CCTEST_COMPILER_CALL_TESTER_H_
       7             : 
       8             : #include "src/handles.h"
       9             : #include "src/objects/code.h"
      10             : #include "src/simulator.h"
      11             : #include "test/cctest/compiler/c-signature.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : namespace compiler {
      16             : 
      17             : template <typename R>
      18             : class CallHelper {
      19             :  public:
      20             :   explicit CallHelper(Isolate* isolate, MachineSignature* csig)
      21     9793056 :       : csig_(csig), isolate_(isolate) {
      22             :     USE(isolate_);
      23             :   }
      24     9793056 :   virtual ~CallHelper() = default;
      25             : 
      26             :   template <typename... Params>
      27    57994988 :   R Call(Params... args) {
      28    57994988 :     CSignature::VerifyParams<Params...>(csig_);
      29    61119940 :     Address entry = Generate();
      30             :     auto fn = GeneratedCode<R, Params...>::FromAddress(isolate_, entry);
      31    57994988 :     return fn.Call(args...);
      32             :   }
      33             : 
      34             :  protected:
      35             :   MachineSignature* csig_;
      36             : 
      37             :   virtual Address Generate() = 0;
      38             : 
      39             :  private:
      40             :   Isolate* isolate_;
      41             : };
      42             : 
      43             : template <>
      44             : template <typename... Params>
      45          24 : Object CallHelper<Object>::Call(Params... args) {
      46          24 :   CSignature::VerifyParams<Params...>(csig_);
      47         192 :   Address entry = Generate();
      48             :   auto fn = GeneratedCode<Address, Params...>::FromAddress(isolate_, entry);
      49          24 :   return Object(fn.Call(args...));
      50             : }
      51             : 
      52             : // A call helper that calls the given code object assuming C calling convention.
      53             : template <typename T>
      54             : class CodeRunner : public CallHelper<T> {
      55             :  public:
      56             :   CodeRunner(Isolate* isolate, Handle<Code> code, MachineSignature* csig)
      57     9628540 :       : CallHelper<T>(isolate, csig), code_(code) {}
      58     9633356 :   ~CodeRunner() override = default;
      59             : 
      60    51694040 :   Address Generate() override { return code_->entry(); }
      61             : 
      62             :  private:
      63             :   Handle<Code> code_;
      64             : };
      65             : 
      66             : 
      67             : }  // namespace compiler
      68             : }  // namespace internal
      69             : }  // namespace v8
      70             : 
      71             : #endif  // V8_CCTEST_COMPILER_CALL_TESTER_H_