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/globals.h" 11 #include "src/compiler/graph-reducer.h" 12 #include "src/compiler/node-properties.h" 13 #include "src/deoptimizer/deoptimize-reason.h" 14 15 namespace v8 { 16 namespace internal { 17 18 // Forward declarations. 19 class Factory; 20 class JSGlobalProxy; 21 22 namespace compiler { 23 24 // Forward declarations. 25 class CallFrequency; 26 class CommonOperatorBuilder; 27 class CompilationDependencies; 28 struct FeedbackSource; 29 struct FieldAccess; 30 class JSCallReducerAssembler; 31 class JSGraph; 32 class JSHeapBroker; 33 class JSOperatorBuilder; 34 class MapInference; 35 class NodeProperties; 36 class SimplifiedOperatorBuilder; 37 38 // Performs strength reduction on {JSConstruct} and {JSCall} nodes, 39 // which might allow inlining or other optimizations to be performed afterwards. 40 class V8_EXPORT_PRIVATE JSCallReducer final : public AdvancedReducer { 41 public: 42 // Flags that control the mode of operation. 43 enum Flag { 44 kNoFlags = 0u, 45 kBailoutOnUninitialized = 1u << 0, 46 }; 47 using Flags = base::Flags<Flag>; 48 JSCallReducer(Editor * editor,JSGraph * jsgraph,JSHeapBroker * broker,Zone * temp_zone,Flags flags,CompilationDependencies * dependencies)49 JSCallReducer(Editor* editor, JSGraph* jsgraph, JSHeapBroker* broker, 50 Zone* temp_zone, Flags flags, 51 CompilationDependencies* dependencies) 52 : AdvancedReducer(editor), 53 jsgraph_(jsgraph), 54 broker_(broker), 55 temp_zone_(temp_zone), 56 flags_(flags), 57 dependencies_(dependencies) {} 58 reducer_name()59 const char* reducer_name() const override { return "JSCallReducer"; } 60 61 Reduction Reduce(Node* node) final; 62 63 // Processes the waitlist gathered while the reducer was running, 64 // and does a final attempt to reduce the nodes in the waitlist. 65 void Finalize() final; 66 67 // JSCallReducer outsources much work to a graph assembler. RevisitForGraphAssembler(Node * node)68 void RevisitForGraphAssembler(Node* node) { Revisit(node); } ZoneForGraphAssembler()69 Zone* ZoneForGraphAssembler() const { return temp_zone(); } JSGraphForGraphAssembler()70 JSGraph* JSGraphForGraphAssembler() const { return jsgraph(); } 71 72 private: 73 Reduction ReduceBooleanConstructor(Node* node); 74 Reduction ReduceCallApiFunction(Node* node, 75 const SharedFunctionInfoRef& shared); 76 Reduction ReduceFunctionPrototypeApply(Node* node); 77 Reduction ReduceFunctionPrototypeBind(Node* node); 78 Reduction ReduceFunctionPrototypeCall(Node* node); 79 Reduction ReduceFunctionPrototypeHasInstance(Node* node); 80 Reduction ReduceObjectConstructor(Node* node); 81 Reduction ReduceObjectGetPrototype(Node* node, Node* object); 82 Reduction ReduceObjectGetPrototypeOf(Node* node); 83 Reduction ReduceObjectIs(Node* node); 84 Reduction ReduceObjectPrototypeGetProto(Node* node); 85 Reduction ReduceObjectPrototypeHasOwnProperty(Node* node); 86 Reduction ReduceObjectPrototypeIsPrototypeOf(Node* node); 87 Reduction ReduceObjectCreate(Node* node); 88 Reduction ReduceReflectApply(Node* node); 89 Reduction ReduceReflectConstruct(Node* node); 90 Reduction ReduceReflectGet(Node* node); 91 Reduction ReduceReflectGetPrototypeOf(Node* node); 92 Reduction ReduceReflectHas(Node* node); 93 94 Reduction ReduceArrayConstructor(Node* node); 95 Reduction ReduceArrayEvery(Node* node, const SharedFunctionInfoRef& shared); 96 Reduction ReduceArrayFilter(Node* node, const SharedFunctionInfoRef& shared); 97 Reduction ReduceArrayFindIndex(Node* node, 98 const SharedFunctionInfoRef& shared); 99 Reduction ReduceArrayFind(Node* node, const SharedFunctionInfoRef& shared); 100 Reduction ReduceArrayForEach(Node* node, const SharedFunctionInfoRef& shared); 101 Reduction ReduceArrayIncludes(Node* node); 102 Reduction ReduceArrayIndexOf(Node* node); 103 Reduction ReduceArrayIsArray(Node* node); 104 Reduction ReduceArrayMap(Node* node, const SharedFunctionInfoRef& shared); 105 Reduction ReduceArrayPrototypePop(Node* node); 106 Reduction ReduceArrayPrototypePush(Node* node); 107 Reduction ReduceArrayPrototypeShift(Node* node); 108 Reduction ReduceArrayPrototypeSlice(Node* node); 109 Reduction ReduceArrayReduce(Node* node, const SharedFunctionInfoRef& shared); 110 Reduction ReduceArrayReduceRight(Node* node, 111 const SharedFunctionInfoRef& shared); 112 Reduction ReduceArraySome(Node* node, const SharedFunctionInfoRef& shared); 113 114 enum class ArrayIteratorKind { kArrayLike, kTypedArray }; 115 Reduction ReduceArrayIterator(Node* node, ArrayIteratorKind array_kind, 116 IterationKind iteration_kind); 117 Reduction ReduceArrayIteratorPrototypeNext(Node* node); 118 Reduction ReduceFastArrayIteratorNext(InstanceType type, Node* node, 119 IterationKind kind); 120 121 Reduction ReduceCallOrConstructWithArrayLikeOrSpread( 122 Node* node, int arraylike_or_spread_index, CallFrequency const& frequency, 123 FeedbackSource const& feedback, SpeculationMode speculation_mode, 124 CallFeedbackRelation feedback_relation); 125 Reduction ReduceJSConstruct(Node* node); 126 Reduction ReduceJSConstructWithArrayLike(Node* node); 127 Reduction ReduceJSConstructWithSpread(Node* node); 128 Reduction ReduceJSCall(Node* node); 129 Reduction ReduceJSCall(Node* node, const SharedFunctionInfoRef& shared); 130 Reduction ReduceJSCallWithArrayLike(Node* node); 131 Reduction ReduceJSCallWithSpread(Node* node); 132 Reduction ReduceRegExpPrototypeTest(Node* node); 133 Reduction ReduceReturnReceiver(Node* node); 134 Reduction ReduceStringPrototypeIndexOf(Node* node); 135 Reduction ReduceStringPrototypeSubstring(Node* node); 136 Reduction ReduceStringPrototypeSlice(Node* node); 137 Reduction ReduceStringPrototypeSubstr(Node* node); 138 Reduction ReduceStringPrototypeStringAt( 139 const Operator* string_access_operator, Node* node); 140 Reduction ReduceStringPrototypeCharAt(Node* node); 141 Reduction ReduceStringPrototypeStartsWith(Node* node); 142 143 #ifdef V8_INTL_SUPPORT 144 Reduction ReduceStringPrototypeToLowerCaseIntl(Node* node); 145 Reduction ReduceStringPrototypeToUpperCaseIntl(Node* node); 146 #endif // V8_INTL_SUPPORT 147 148 Reduction ReduceStringFromCharCode(Node* node); 149 Reduction ReduceStringFromCodePoint(Node* node); 150 Reduction ReduceStringPrototypeIterator(Node* node); 151 Reduction ReduceStringIteratorPrototypeNext(Node* node); 152 Reduction ReduceStringPrototypeConcat(Node* node); 153 154 Reduction ReducePromiseConstructor(Node* node); 155 Reduction ReducePromiseInternalConstructor(Node* node); 156 Reduction ReducePromiseInternalReject(Node* node); 157 Reduction ReducePromiseInternalResolve(Node* node); 158 Reduction ReducePromisePrototypeCatch(Node* node); 159 Reduction ReducePromisePrototypeFinally(Node* node); 160 Reduction ReducePromisePrototypeThen(Node* node); 161 Reduction ReducePromiseResolveTrampoline(Node* node); 162 163 Reduction ReduceTypedArrayConstructor(Node* node, 164 const SharedFunctionInfoRef& shared); 165 Reduction ReduceTypedArrayPrototypeToStringTag(Node* node); 166 167 Reduction ReduceForInsufficientFeedback(Node* node, DeoptimizeReason reason); 168 169 Reduction ReduceMathUnary(Node* node, const Operator* op); 170 Reduction ReduceMathBinary(Node* node, const Operator* op); 171 Reduction ReduceMathImul(Node* node); 172 Reduction ReduceMathClz32(Node* node); 173 Reduction ReduceMathMinMax(Node* node, const Operator* op, Node* empty_value); 174 175 Reduction ReduceNumberIsFinite(Node* node); 176 Reduction ReduceNumberIsInteger(Node* node); 177 Reduction ReduceNumberIsSafeInteger(Node* node); 178 Reduction ReduceNumberIsNaN(Node* node); 179 180 Reduction ReduceGlobalIsFinite(Node* node); 181 Reduction ReduceGlobalIsNaN(Node* node); 182 183 Reduction ReduceMapPrototypeHas(Node* node); 184 Reduction ReduceMapPrototypeGet(Node* node); 185 Reduction ReduceCollectionIteration(Node* node, 186 CollectionKind collection_kind, 187 IterationKind iteration_kind); 188 Reduction ReduceCollectionPrototypeSize(Node* node, 189 CollectionKind collection_kind); 190 Reduction ReduceCollectionIteratorPrototypeNext( 191 Node* node, int entry_size, Handle<HeapObject> empty_collection, 192 InstanceType collection_iterator_instance_type_first, 193 InstanceType collection_iterator_instance_type_last); 194 195 Reduction ReduceArrayBufferIsView(Node* node); 196 Reduction ReduceArrayBufferViewAccessor(Node* node, 197 InstanceType instance_type, 198 FieldAccess const& access); 199 200 enum class DataViewAccess { kGet, kSet }; 201 Reduction ReduceDataViewAccess(Node* node, DataViewAccess access, 202 ExternalArrayType element_type); 203 204 Reduction ReduceDatePrototypeGetTime(Node* node); 205 Reduction ReduceDateNow(Node* node); 206 Reduction ReduceNumberParseInt(Node* node); 207 208 Reduction ReduceNumberConstructor(Node* node); 209 Reduction ReduceBigIntAsUintN(Node* node); 210 211 // The pendant to ReplaceWithValue when using GraphAssembler-based reductions. 212 Reduction ReplaceWithSubgraph(JSCallReducerAssembler* gasm, Node* subgraph); 213 214 // Helper to verify promise receiver maps are as expected. 215 // On bailout from a reduction, be sure to return inference.NoChange(). 216 bool DoPromiseChecks(MapInference* inference); 217 218 Node* CreateClosureFromBuiltinSharedFunctionInfo(SharedFunctionInfoRef shared, 219 Node* context, Node* effect, 220 Node* control); 221 222 void CheckIfElementsKind(Node* receiver_elements_kind, ElementsKind kind, 223 Node* control, Node** if_true, Node** if_false); 224 Node* LoadReceiverElementsKind(Node* receiver, Effect* effect, 225 Control control); 226 227 bool IsBuiltinOrApiFunction(JSFunctionRef target_ref) const; 228 229 Graph* graph() const; jsgraph()230 JSGraph* jsgraph() const { return jsgraph_; } broker()231 JSHeapBroker* broker() const { return broker_; } temp_zone()232 Zone* temp_zone() const { return temp_zone_; } 233 Isolate* isolate() const; 234 Factory* factory() const; 235 NativeContextRef native_context() const; 236 CommonOperatorBuilder* common() const; 237 JSOperatorBuilder* javascript() const; 238 SimplifiedOperatorBuilder* simplified() const; flags()239 Flags flags() const { return flags_; } dependencies()240 CompilationDependencies* dependencies() const { return dependencies_; } 241 bool should_disallow_heap_access() const; 242 243 JSGraph* const jsgraph_; 244 JSHeapBroker* const broker_; 245 Zone* const temp_zone_; 246 Flags const flags_; 247 CompilationDependencies* const dependencies_; 248 std::set<Node*> waitlist_; 249 }; 250 251 } // namespace compiler 252 } // namespace internal 253 } // namespace v8 254 255 #endif // V8_COMPILER_JS_CALL_REDUCER_H_ 256