Line data Source code
1 : // Copyright 2015 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_COMPILER_JS_CALL_REDUCER_H_
6 : #define V8_COMPILER_JS_CALL_REDUCER_H_
7 :
8 : #include "src/base/flags.h"
9 : #include "src/compiler/frame-states.h"
10 : #include "src/compiler/graph-reducer.h"
11 : #include "src/deoptimize-reason.h"
12 :
13 : namespace v8 {
14 : namespace internal {
15 :
16 : // Forward declarations.
17 : class Factory;
18 : class JSGlobalProxy;
19 : class VectorSlotPair;
20 :
21 : namespace compiler {
22 :
23 : // Forward declarations.
24 : class CallFrequency;
25 : class CommonOperatorBuilder;
26 : class CompilationDependencies;
27 : struct FieldAccess;
28 : class JSGraph;
29 : class JSHeapBroker;
30 : class JSOperatorBuilder;
31 : class SimplifiedOperatorBuilder;
32 :
33 : // Performs strength reduction on {JSConstruct} and {JSCall} nodes,
34 : // which might allow inlining or other optimizations to be performed afterwards.
35 456777 : class V8_EXPORT_PRIVATE JSCallReducer final : public AdvancedReducer {
36 : public:
37 : // Flags that control the mode of operation.
38 : enum Flag { kNoFlags = 0u, kBailoutOnUninitialized = 1u << 0 };
39 : typedef base::Flags<Flag> Flags;
40 :
41 : JSCallReducer(Editor* editor, JSGraph* jsgraph, JSHeapBroker* broker,
42 : Flags flags, CompilationDependencies* dependencies)
43 : : AdvancedReducer(editor),
44 : jsgraph_(jsgraph),
45 : broker_(broker),
46 : flags_(flags),
47 456781 : dependencies_(dependencies) {}
48 :
49 18 : const char* reducer_name() const override { return "JSCallReducer"; }
50 :
51 : Reduction Reduce(Node* node) final;
52 :
53 : // Processes the waitlist gathered while the reducer was running,
54 : // and does a final attempt to reduce the nodes in the waitlist.
55 : void Finalize() final;
56 :
57 : private:
58 : Reduction ReduceArrayConstructor(Node* node);
59 : Reduction ReduceBooleanConstructor(Node* node);
60 : Reduction ReduceCallApiFunction(Node* node,
61 : const SharedFunctionInfoRef& shared);
62 : Reduction ReduceFunctionPrototypeApply(Node* node);
63 : Reduction ReduceFunctionPrototypeBind(Node* node);
64 : Reduction ReduceFunctionPrototypeCall(Node* node);
65 : Reduction ReduceFunctionPrototypeHasInstance(Node* node);
66 : Reduction ReduceObjectConstructor(Node* node);
67 : Reduction ReduceObjectGetPrototype(Node* node, Node* object);
68 : Reduction ReduceObjectGetPrototypeOf(Node* node);
69 : Reduction ReduceObjectIs(Node* node);
70 : Reduction ReduceObjectPrototypeGetProto(Node* node);
71 : Reduction ReduceObjectPrototypeHasOwnProperty(Node* node);
72 : Reduction ReduceObjectPrototypeIsPrototypeOf(Node* node);
73 : Reduction ReduceObjectCreate(Node* node);
74 : Reduction ReduceReflectApply(Node* node);
75 : Reduction ReduceReflectConstruct(Node* node);
76 : Reduction ReduceReflectGet(Node* node);
77 : Reduction ReduceReflectGetPrototypeOf(Node* node);
78 : Reduction ReduceReflectHas(Node* node);
79 : Reduction ReduceArrayForEach(Node* node, const SharedFunctionInfoRef& shared);
80 : enum class ArrayReduceDirection { kLeft, kRight };
81 : Reduction ReduceArrayReduce(Node* node, ArrayReduceDirection direction,
82 : const SharedFunctionInfoRef& shared);
83 : Reduction ReduceArrayMap(Node* node, const SharedFunctionInfoRef& shared);
84 : Reduction ReduceArrayFilter(Node* node, const SharedFunctionInfoRef& shared);
85 : enum class ArrayFindVariant { kFind, kFindIndex };
86 : Reduction ReduceArrayFind(Node* node, ArrayFindVariant variant,
87 : const SharedFunctionInfoRef& shared);
88 : Reduction ReduceArrayEvery(Node* node, const SharedFunctionInfoRef& shared);
89 : enum class SearchVariant { kIncludes, kIndexOf };
90 : Reduction ReduceArrayIndexOfIncludes(SearchVariant search_variant,
91 : Node* node);
92 : Reduction ReduceArraySome(Node* node, const SharedFunctionInfoRef& shared);
93 : Reduction ReduceArrayPrototypePush(Node* node);
94 : Reduction ReduceArrayPrototypePop(Node* node);
95 : Reduction ReduceArrayPrototypeShift(Node* node);
96 : Reduction ReduceArrayPrototypeSlice(Node* node);
97 : Reduction ReduceArrayIsArray(Node* node);
98 : enum class ArrayIteratorKind { kArray, kTypedArray };
99 : Reduction ReduceArrayIterator(Node* node, IterationKind kind);
100 : Reduction ReduceArrayIteratorPrototypeNext(Node* node);
101 : Reduction ReduceFastArrayIteratorNext(InstanceType type, Node* node,
102 : IterationKind kind);
103 :
104 : Reduction ReduceCallOrConstructWithArrayLikeOrSpread(
105 : Node* node, int arity, CallFrequency const& frequency,
106 : VectorSlotPair const& feedback);
107 : Reduction ReduceJSConstruct(Node* node);
108 : Reduction ReduceJSConstructWithArrayLike(Node* node);
109 : Reduction ReduceJSConstructWithSpread(Node* node);
110 : Reduction ReduceJSCall(Node* node);
111 : Reduction ReduceJSCall(Node* node, const SharedFunctionInfoRef& shared);
112 : Reduction ReduceJSCallWithArrayLike(Node* node);
113 : Reduction ReduceJSCallWithSpread(Node* node);
114 : Reduction ReduceRegExpPrototypeTest(Node* node);
115 : Reduction ReduceReturnReceiver(Node* node);
116 : Reduction ReduceStringPrototypeIndexOf(Node* node);
117 : Reduction ReduceStringPrototypeSubstring(Node* node);
118 : Reduction ReduceStringPrototypeSlice(Node* node);
119 : Reduction ReduceStringPrototypeSubstr(Node* node);
120 : Reduction ReduceStringPrototypeStringAt(
121 : const Operator* string_access_operator, Node* node);
122 : Reduction ReduceStringPrototypeCharAt(Node* node);
123 :
124 : #ifdef V8_INTL_SUPPORT
125 : Reduction ReduceStringPrototypeToLowerCaseIntl(Node* node);
126 : Reduction ReduceStringPrototypeToUpperCaseIntl(Node* node);
127 : #endif // V8_INTL_SUPPORT
128 :
129 : Reduction ReduceStringFromCharCode(Node* node);
130 : Reduction ReduceStringFromCodePoint(Node* node);
131 : Reduction ReduceStringPrototypeIterator(Node* node);
132 : Reduction ReduceStringIteratorPrototypeNext(Node* node);
133 : Reduction ReduceStringPrototypeConcat(Node* node);
134 :
135 : Reduction ReducePromiseConstructor(Node* node);
136 : Reduction ReducePromiseInternalConstructor(Node* node);
137 : Reduction ReducePromiseInternalReject(Node* node);
138 : Reduction ReducePromiseInternalResolve(Node* node);
139 : Reduction ReducePromisePrototypeCatch(Node* node);
140 : Reduction ReducePromisePrototypeFinally(Node* node);
141 : Reduction ReducePromisePrototypeThen(Node* node);
142 : Reduction ReducePromiseResolveTrampoline(Node* node);
143 :
144 : Reduction ReduceTypedArrayConstructor(Node* node,
145 : const SharedFunctionInfoRef& shared);
146 : Reduction ReduceTypedArrayPrototypeToStringTag(Node* node);
147 :
148 : Reduction ReduceSoftDeoptimize(Node* node, DeoptimizeReason reason);
149 :
150 : Reduction ReduceMathUnary(Node* node, const Operator* op);
151 : Reduction ReduceMathBinary(Node* node, const Operator* op);
152 : Reduction ReduceMathImul(Node* node);
153 : Reduction ReduceMathClz32(Node* node);
154 : Reduction ReduceMathMinMax(Node* node, const Operator* op, Node* empty_value);
155 :
156 : Reduction ReduceNumberIsFinite(Node* node);
157 : Reduction ReduceNumberIsInteger(Node* node);
158 : Reduction ReduceNumberIsSafeInteger(Node* node);
159 : Reduction ReduceNumberIsNaN(Node* node);
160 :
161 : Reduction ReduceGlobalIsFinite(Node* node);
162 : Reduction ReduceGlobalIsNaN(Node* node);
163 :
164 : Reduction ReduceMapPrototypeHas(Node* node);
165 : Reduction ReduceMapPrototypeGet(Node* node);
166 : Reduction ReduceCollectionIteration(Node* node,
167 : CollectionKind collection_kind,
168 : IterationKind iteration_kind);
169 : Reduction ReduceCollectionPrototypeSize(Node* node,
170 : CollectionKind collection_kind);
171 : Reduction ReduceCollectionIteratorPrototypeNext(
172 : Node* node, int entry_size, Handle<HeapObject> empty_collection,
173 : InstanceType collection_iterator_instance_type_first,
174 : InstanceType collection_iterator_instance_type_last);
175 :
176 : Reduction ReduceArrayBufferIsView(Node* node);
177 : Reduction ReduceArrayBufferViewAccessor(Node* node,
178 : InstanceType instance_type,
179 : FieldAccess const& access);
180 :
181 : enum class DataViewAccess { kGet, kSet };
182 : Reduction ReduceDataViewAccess(Node* node, DataViewAccess access,
183 : ExternalArrayType element_type);
184 :
185 : Reduction ReduceDatePrototypeGetTime(Node* node);
186 : Reduction ReduceDateNow(Node* node);
187 : Reduction ReduceNumberParseInt(Node* node);
188 :
189 : Reduction ReduceNumberConstructor(Node* node);
190 :
191 : // Returns the updated {to} node, and updates control and effect along the
192 : // way.
193 : Node* DoFilterPostCallbackWork(ElementsKind kind, Node** control,
194 : Node** effect, Node* a, Node* to,
195 : Node* element, Node* callback_value);
196 :
197 : // If {fncallback} is not callable, throw a TypeError.
198 : // {control} is altered, and new nodes {check_fail} and {check_throw} are
199 : // returned. {check_fail} is the control branch where IsCallable failed,
200 : // and {check_throw} is the call to throw a TypeError in that
201 : // branch.
202 : void WireInCallbackIsCallableCheck(Node* fncallback, Node* context,
203 : Node* check_frame_state, Node* effect,
204 : Node** control, Node** check_fail,
205 : Node** check_throw);
206 : void RewirePostCallbackExceptionEdges(Node* check_throw, Node* on_exception,
207 : Node* effect, Node** check_fail,
208 : Node** control);
209 :
210 : // Begin the central loop of a higher-order array builtin. A Loop is wired
211 : // into {control}, an EffectPhi into {effect}, and the array index {k} is
212 : // threaded into a Phi, which is returned. It's helpful to save the
213 : // value of {control} as the loop node, and of {effect} as the corresponding
214 : // EffectPhi after function return.
215 : Node* WireInLoopStart(Node* k, Node** control, Node** effect);
216 : void WireInLoopEnd(Node* loop, Node* eloop, Node* vloop, Node* k,
217 : Node* control, Node* effect);
218 :
219 : // Load receiver[k], first bounding k by receiver array length.
220 : // k is thusly changed, and the effect is changed as well.
221 : Node* SafeLoadElement(ElementsKind kind, Node* receiver, Node* control,
222 : Node** effect, Node** k,
223 : const VectorSlotPair& feedback);
224 :
225 : Node* CreateArtificialFrameState(Node* node, Node* outer_frame_state,
226 : int parameter_count, BailoutId bailout_id,
227 : FrameStateType frame_state_type,
228 : const SharedFunctionInfoRef& shared,
229 : Node* context = nullptr);
230 :
231 : Graph* graph() const;
232 : JSGraph* jsgraph() const { return jsgraph_; }
233 : JSHeapBroker* broker() const { return broker_; }
234 : Isolate* isolate() const;
235 : Factory* factory() const;
236 303868 : NativeContextRef native_context() const { return broker()->native_context(); }
237 : CommonOperatorBuilder* common() const;
238 : JSOperatorBuilder* javascript() const;
239 : SimplifiedOperatorBuilder* simplified() const;
240 : Flags flags() const { return flags_; }
241 : CompilationDependencies* dependencies() const { return dependencies_; }
242 :
243 : JSGraph* const jsgraph_;
244 : JSHeapBroker* const broker_;
245 : Flags const flags_;
246 : CompilationDependencies* const dependencies_;
247 : std::set<Node*> waitlist_;
248 : };
249 :
250 : } // namespace compiler
251 : } // namespace internal
252 : } // namespace v8
253 :
254 : #endif // V8_COMPILER_JS_CALL_REDUCER_H_
|
