| // Copyright 2014 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 V8_CCTEST_COMPILER_CALL_TESTER_H_ |
| #define V8_CCTEST_COMPILER_CALL_TESTER_H_ |
| |
| #include "src/v8.h" |
| |
| #include "src/simulator.h" |
| |
| #if V8_TARGET_ARCH_IA32 |
| #if __GNUC__ |
| #define V8_CDECL __attribute__((cdecl)) |
| #else |
| #define V8_CDECL __cdecl |
| #endif |
| #else |
| #define V8_CDECL |
| #endif |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| // TODO(titzer): use c-signature.h instead of ReturnValueTraits |
| template <typename R> |
| struct ReturnValueTraits { |
| static R Cast(uintptr_t r) { return reinterpret_cast<R>(r); } |
| static MachineType Representation() { |
| // TODO(dcarney): detect when R is of a subclass of Object* instead of this |
| // type check. |
| while (false) { |
| *(static_cast<Object* volatile*>(0)) = static_cast<R>(0); |
| } |
| return kMachAnyTagged; |
| } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<int32_t*> { |
| static int32_t* Cast(uintptr_t r) { return reinterpret_cast<int32_t*>(r); } |
| static MachineType Representation() { return kMachPtr; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<void> { |
| static void Cast(uintptr_t r) {} |
| static MachineType Representation() { return kMachPtr; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<bool> { |
| static bool Cast(uintptr_t r) { return static_cast<bool>(r); } |
| static MachineType Representation() { return kRepBit; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<int32_t> { |
| static int32_t Cast(uintptr_t r) { return static_cast<int32_t>(r); } |
| static MachineType Representation() { return kMachInt32; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<uint32_t> { |
| static uint32_t Cast(uintptr_t r) { return static_cast<uint32_t>(r); } |
| static MachineType Representation() { return kMachUint32; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<int64_t> { |
| static int64_t Cast(uintptr_t r) { return static_cast<int64_t>(r); } |
| static MachineType Representation() { return kMachInt64; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<uint64_t> { |
| static uint64_t Cast(uintptr_t r) { return static_cast<uint64_t>(r); } |
| static MachineType Representation() { return kMachUint64; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<int16_t> { |
| static int16_t Cast(uintptr_t r) { return static_cast<int16_t>(r); } |
| static MachineType Representation() { return kMachInt16; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<uint16_t> { |
| static uint16_t Cast(uintptr_t r) { return static_cast<uint16_t>(r); } |
| static MachineType Representation() { return kMachUint16; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<int8_t> { |
| static int8_t Cast(uintptr_t r) { return static_cast<int8_t>(r); } |
| static MachineType Representation() { return kMachInt8; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<uint8_t> { |
| static uint8_t Cast(uintptr_t r) { return static_cast<uint8_t>(r); } |
| static MachineType Representation() { return kMachUint8; } |
| }; |
| |
| template <> |
| struct ReturnValueTraits<double> { |
| static double Cast(uintptr_t r) { |
| UNREACHABLE(); |
| return 0.0; |
| } |
| static MachineType Representation() { return kMachFloat64; } |
| }; |
| |
| |
| template <typename R> |
| struct ParameterTraits { |
| static uintptr_t Cast(R r) { return static_cast<uintptr_t>(r); } |
| }; |
| |
| template <> |
| struct ParameterTraits<int*> { |
| static uintptr_t Cast(int* r) { return reinterpret_cast<uintptr_t>(r); } |
| }; |
| |
| template <typename T> |
| struct ParameterTraits<T*> { |
| static uintptr_t Cast(void* r) { return reinterpret_cast<uintptr_t>(r); } |
| }; |
| |
| class CallHelper { |
| public: |
| explicit CallHelper(Isolate* isolate, MachineSignature* machine_sig) |
| : machine_sig_(machine_sig), isolate_(isolate) { |
| USE(isolate_); |
| } |
| virtual ~CallHelper() {} |
| |
| static MachineSignature* MakeMachineSignature( |
| Zone* zone, MachineType return_type, MachineType p0 = kMachNone, |
| MachineType p1 = kMachNone, MachineType p2 = kMachNone, |
| MachineType p3 = kMachNone, MachineType p4 = kMachNone) { |
| // Count the number of parameters. |
| size_t param_count = 5; |
| MachineType types[] = {p0, p1, p2, p3, p4}; |
| while (param_count > 0 && types[param_count - 1] == kMachNone) |
| param_count--; |
| size_t return_count = return_type == kMachNone ? 0 : 1; |
| |
| // Build the machine signature. |
| MachineSignature::Builder builder(zone, return_count, param_count); |
| if (return_count > 0) builder.AddReturn(return_type); |
| for (size_t i = 0; i < param_count; i++) { |
| builder.AddParam(types[i]); |
| } |
| return builder.Build(); |
| } |
| |
| protected: |
| MachineSignature* machine_sig_; |
| void VerifyParameters(size_t parameter_count, MachineType* parameter_types) { |
| CHECK(machine_sig_->parameter_count() == parameter_count); |
| for (size_t i = 0; i < parameter_count; i++) { |
| CHECK_EQ(machine_sig_->GetParam(i), parameter_types[i]); |
| } |
| } |
| virtual byte* Generate() = 0; |
| |
| private: |
| #if USE_SIMULATOR && V8_TARGET_ARCH_ARM64 |
| uintptr_t CallSimulator(byte* f, Simulator::CallArgument* args) { |
| Simulator* simulator = Simulator::current(isolate_); |
| return static_cast<uintptr_t>(simulator->CallInt64(f, args)); |
| } |
| |
| template <typename R, typename F> |
| R DoCall(F* f) { |
| Simulator::CallArgument args[] = {Simulator::CallArgument::End()}; |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args)); |
| } |
| template <typename R, typename F, typename P1> |
| R DoCall(F* f, P1 p1) { |
| Simulator::CallArgument args[] = {Simulator::CallArgument(p1), |
| Simulator::CallArgument::End()}; |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args)); |
| } |
| template <typename R, typename F, typename P1, typename P2> |
| R DoCall(F* f, P1 p1, P2 p2) { |
| Simulator::CallArgument args[] = {Simulator::CallArgument(p1), |
| Simulator::CallArgument(p2), |
| Simulator::CallArgument::End()}; |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args)); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3) { |
| Simulator::CallArgument args[] = { |
| Simulator::CallArgument(p1), Simulator::CallArgument(p2), |
| Simulator::CallArgument(p3), Simulator::CallArgument::End()}; |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args)); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3, |
| typename P4> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) { |
| Simulator::CallArgument args[] = { |
| Simulator::CallArgument(p1), Simulator::CallArgument(p2), |
| Simulator::CallArgument(p3), Simulator::CallArgument(p4), |
| Simulator::CallArgument::End()}; |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args)); |
| } |
| #elif USE_SIMULATOR && (V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_MIPS) |
| uintptr_t CallSimulator(byte* f, int32_t p1 = 0, int32_t p2 = 0, |
| int32_t p3 = 0, int32_t p4 = 0) { |
| Simulator* simulator = Simulator::current(isolate_); |
| return static_cast<uintptr_t>(simulator->Call(f, 4, p1, p2, p3, p4)); |
| } |
| template <typename R, typename F> |
| R DoCall(F* f) { |
| return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f))); |
| } |
| template <typename R, typename F, typename P1> |
| R DoCall(F* f, P1 p1) { |
| return ReturnValueTraits<R>::Cast( |
| CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1))); |
| } |
| template <typename R, typename F, typename P1, typename P2> |
| R DoCall(F* f, P1 p1, P2 p2) { |
| return ReturnValueTraits<R>::Cast( |
| CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1), |
| ParameterTraits<P2>::Cast(p2))); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3) { |
| return ReturnValueTraits<R>::Cast(CallSimulator( |
| FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1), |
| ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3))); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3, |
| typename P4> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) { |
| return ReturnValueTraits<R>::Cast(CallSimulator( |
| FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1), |
| ParameterTraits<P2>::Cast(p2), ParameterTraits<P3>::Cast(p3), |
| ParameterTraits<P4>::Cast(p4))); |
| } |
| #else |
| template <typename R, typename F> |
| R DoCall(F* f) { |
| return f(); |
| } |
| template <typename R, typename F, typename P1> |
| R DoCall(F* f, P1 p1) { |
| return f(p1); |
| } |
| template <typename R, typename F, typename P1, typename P2> |
| R DoCall(F* f, P1 p1, P2 p2) { |
| return f(p1, p2); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3) { |
| return f(p1, p2, p3); |
| } |
| template <typename R, typename F, typename P1, typename P2, typename P3, |
| typename P4> |
| R DoCall(F* f, P1 p1, P2 p2, P3 p3, P4 p4) { |
| return f(p1, p2, p3, p4); |
| } |
| #endif |
| |
| #ifndef DEBUG |
| void VerifyParameters0() {} |
| |
| template <typename P1> |
| void VerifyParameters1() {} |
| |
| template <typename P1, typename P2> |
| void VerifyParameters2() {} |
| |
| template <typename P1, typename P2, typename P3> |
| void VerifyParameters3() {} |
| |
| template <typename P1, typename P2, typename P3, typename P4> |
| void VerifyParameters4() {} |
| #else |
| void VerifyParameters0() { VerifyParameters(0, NULL); } |
| |
| template <typename P1> |
| void VerifyParameters1() { |
| MachineType parameters[] = {ReturnValueTraits<P1>::Representation()}; |
| VerifyParameters(arraysize(parameters), parameters); |
| } |
| |
| template <typename P1, typename P2> |
| void VerifyParameters2() { |
| MachineType parameters[] = {ReturnValueTraits<P1>::Representation(), |
| ReturnValueTraits<P2>::Representation()}; |
| VerifyParameters(arraysize(parameters), parameters); |
| } |
| |
| template <typename P1, typename P2, typename P3> |
| void VerifyParameters3() { |
| MachineType parameters[] = {ReturnValueTraits<P1>::Representation(), |
| ReturnValueTraits<P2>::Representation(), |
| ReturnValueTraits<P3>::Representation()}; |
| VerifyParameters(arraysize(parameters), parameters); |
| } |
| |
| template <typename P1, typename P2, typename P3, typename P4> |
| void VerifyParameters4() { |
| MachineType parameters[] = {ReturnValueTraits<P1>::Representation(), |
| ReturnValueTraits<P2>::Representation(), |
| ReturnValueTraits<P3>::Representation(), |
| ReturnValueTraits<P4>::Representation()}; |
| VerifyParameters(arraysize(parameters), parameters); |
| } |
| #endif |
| |
| // TODO(dcarney): replace Call() in CallHelper2 with these. |
| template <typename R> |
| R Call0() { |
| typedef R V8_CDECL FType(); |
| VerifyParameters0(); |
| return DoCall<R>(FUNCTION_CAST<FType*>(Generate())); |
| } |
| |
| template <typename R, typename P1> |
| R Call1(P1 p1) { |
| typedef R V8_CDECL FType(P1); |
| VerifyParameters1<P1>(); |
| return DoCall<R>(FUNCTION_CAST<FType*>(Generate()), p1); |
| } |
| |
| template <typename R, typename P1, typename P2> |
| R Call2(P1 p1, P2 p2) { |
| typedef R V8_CDECL FType(P1, P2); |
| VerifyParameters2<P1, P2>(); |
| return DoCall<R>(FUNCTION_CAST<FType*>(Generate()), p1, p2); |
| } |
| |
| template <typename R, typename P1, typename P2, typename P3> |
| R Call3(P1 p1, P2 p2, P3 p3) { |
| typedef R V8_CDECL FType(P1, P2, P3); |
| VerifyParameters3<P1, P2, P3>(); |
| return DoCall<R>(FUNCTION_CAST<FType*>(Generate()), p1, p2, p3); |
| } |
| |
| template <typename R, typename P1, typename P2, typename P3, typename P4> |
| R Call4(P1 p1, P2 p2, P3 p3, P4 p4) { |
| typedef R V8_CDECL FType(P1, P2, P3, P4); |
| VerifyParameters4<P1, P2, P3, P4>(); |
| return DoCall<R>(FUNCTION_CAST<FType*>(Generate()), p1, p2, p3, p4); |
| } |
| |
| template <typename R, typename C> |
| friend class CallHelper2; |
| Isolate* isolate_; |
| }; |
| |
| |
| // TODO(dcarney): replace CallHelper with CallHelper2 and rename. |
| template <typename R, typename C> |
| class CallHelper2 { |
| public: |
| R Call() { return helper()->template Call0<R>(); } |
| |
| template <typename P1> |
| R Call(P1 p1) { |
| return helper()->template Call1<R>(p1); |
| } |
| |
| template <typename P1, typename P2> |
| R Call(P1 p1, P2 p2) { |
| return helper()->template Call2<R>(p1, p2); |
| } |
| |
| template <typename P1, typename P2, typename P3> |
| R Call(P1 p1, P2 p2, P3 p3) { |
| return helper()->template Call3<R>(p1, p2, p3); |
| } |
| |
| template <typename P1, typename P2, typename P3, typename P4> |
| R Call(P1 p1, P2 p2, P3 p3, P4 p4) { |
| return helper()->template Call4<R>(p1, p2, p3, p4); |
| } |
| |
| private: |
| CallHelper* helper() { return static_cast<C*>(this); } |
| }; |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_CCTEST_COMPILER_CALL_TESTER_H_ |
