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_FUNCTION_TESTER_H_
6 : #define V8_CCTEST_COMPILER_FUNCTION_TESTER_H_
7 :
8 : #include "src/execution.h"
9 : #include "src/handles.h"
10 : #include "test/cctest/cctest.h"
11 :
12 : namespace v8 {
13 : namespace internal {
14 :
15 : class CallInterfaceDescriptor;
16 : class Isolate;
17 :
18 : namespace compiler {
19 :
20 : class Graph;
21 :
22 1488 : class FunctionTester : public InitializedHandleScope {
23 : public:
24 : explicit FunctionTester(const char* source, uint32_t flags = 0);
25 :
26 : FunctionTester(Graph* graph, int param_count);
27 :
28 : FunctionTester(Handle<Code> code, int param_count);
29 :
30 : // Assumes VoidDescriptor call interface.
31 : explicit FunctionTester(Handle<Code> code);
32 :
33 : Isolate* isolate;
34 : CanonicalHandleScope canonical;
35 : Handle<JSFunction> function;
36 :
37 500 : MaybeHandle<Object> Call() {
38 1000 : return Execution::Call(isolate, function, undefined(), 0, nullptr);
39 : }
40 :
41 : template <typename Arg1, typename... Args>
42 313296 : MaybeHandle<Object> Call(Arg1 arg1, Args... args) {
43 : const int nof_args = sizeof...(Args) + 1;
44 294940 : Handle<Object> call_args[] = {arg1, args...};
45 331940 : return Execution::Call(isolate, function, undefined(), nof_args, call_args);
46 : }
47 :
48 : template <typename T, typename... Args>
49 348 : Handle<T> CallChecked(Args... args) {
50 696 : Handle<Object> result = Call(args...).ToHandleChecked();
51 348 : return Handle<T>::cast(result);
52 : }
53 :
54 : void CheckThrows(Handle<Object> a);
55 : void CheckThrows(Handle<Object> a, Handle<Object> b);
56 : v8::Local<v8::Message> CheckThrowsReturnMessage(Handle<Object> a,
57 : Handle<Object> b);
58 : void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
59 : Handle<Object> c, Handle<Object> d);
60 :
61 : void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
62 : Handle<Object> c) {
63 289588 : return CheckCall(expected, a, b, c, undefined());
64 : }
65 :
66 264180 : void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b) {
67 528360 : return CheckCall(expected, a, b, undefined());
68 : }
69 :
70 : void CheckCall(Handle<Object> expected, Handle<Object> a) {
71 262332 : CheckCall(expected, a, undefined());
72 : }
73 :
74 128 : void CheckCall(Handle<Object> expected) { CheckCall(expected, undefined()); }
75 :
76 128 : void CheckCall(double expected, double a, double b) {
77 128 : CheckCall(Val(expected), Val(a), Val(b));
78 128 : }
79 :
80 32 : void CheckTrue(Handle<Object> a) { CheckCall(true_value(), a); }
81 :
82 : void CheckTrue(Handle<Object> a, Handle<Object> b) {
83 132 : CheckCall(true_value(), a, b);
84 : }
85 :
86 25408 : void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c) {
87 25408 : CheckCall(true_value(), a, b, c);
88 25408 : }
89 :
90 : void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c,
91 : Handle<Object> d) {
92 4972 : CheckCall(true_value(), a, b, c, d);
93 : }
94 :
95 64 : void CheckTrue(double a, double b) {
96 64 : CheckCall(true_value(), Val(a), Val(b));
97 64 : }
98 :
99 144 : void CheckFalse(Handle<Object> a) { CheckCall(false_value(), a); }
100 :
101 : void CheckFalse(Handle<Object> a, Handle<Object> b) {
102 124 : CheckCall(false_value(), a, b);
103 : }
104 :
105 64 : void CheckFalse(double a, double b) {
106 64 : CheckCall(false_value(), Val(a), Val(b));
107 64 : }
108 :
109 : Handle<JSFunction> NewFunction(const char* source);
110 : Handle<JSObject> NewObject(const char* source);
111 :
112 : Handle<String> Val(const char* string);
113 : Handle<Object> Val(double value);
114 : Handle<Object> infinity();
115 : Handle<Object> minus_infinity();
116 : Handle<Object> nan();
117 : Handle<Object> undefined();
118 : Handle<Object> null();
119 : Handle<Object> true_value();
120 : Handle<Object> false_value();
121 :
122 : static Handle<JSFunction> ForMachineGraph(Graph* graph, int param_count);
123 :
124 : private:
125 : uint32_t flags_;
126 :
127 : Handle<JSFunction> Compile(Handle<JSFunction> function);
128 872 : std::string BuildFunction(int param_count) {
129 872 : std::string function_string = "(function(";
130 872 : if (param_count > 0) {
131 : function_string += 'a';
132 1172 : for (int i = 1; i < param_count; i++) {
133 : function_string += ',';
134 408 : function_string += static_cast<char>('a' + i);
135 : }
136 : }
137 : function_string += "){})";
138 872 : return function_string;
139 : }
140 :
141 : // Compile the given machine graph instead of the source of the function
142 : // and replace the JSFunction's code with the result.
143 : Handle<JSFunction> CompileGraph(Graph* graph);
144 : };
145 : } // namespace compiler
146 : } // namespace internal
147 : } // namespace v8
148 :
149 : #endif // V8_CCTEST_COMPILER_FUNCTION_TESTER_H_
|