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_NATIVE_CONTEXT_SPECIALIZATION_H_ 6 #define V8_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_ 7 8 #include "src/base/flags.h" 9 #include "src/compiler/graph-reducer.h" 10 #include "src/deoptimize-reason.h" 11 #include "src/type-feedback-vector.h" 12 13 namespace v8 { 14 namespace internal { 15 16 // Forward declarations. 17 class CompilationDependencies; 18 class Factory; 19 20 namespace compiler { 21 22 // Forward declarations. 23 enum class AccessMode; 24 class CommonOperatorBuilder; 25 class ElementAccessInfo; 26 class JSGraph; 27 class JSOperatorBuilder; 28 class MachineOperatorBuilder; 29 class PropertyAccessInfo; 30 class SimplifiedOperatorBuilder; 31 class TypeCache; 32 33 // Specializes a given JSGraph to a given native context, potentially constant 34 // folding some {LoadGlobal} nodes or strength reducing some {StoreGlobal} 35 // nodes. And also specializes {LoadNamed} and {StoreNamed} nodes according 36 // to type feedback (if available). 37 class JSNativeContextSpecialization final : public AdvancedReducer { 38 public: 39 // Flags that control the mode of operation. 40 enum Flag { 41 kNoFlags = 0u, 42 kAccessorInliningEnabled = 1u << 0, 43 kBailoutOnUninitialized = 1u << 1, 44 kDeoptimizationEnabled = 1u << 2, 45 }; 46 typedef base::Flags<Flag> Flags; 47 48 JSNativeContextSpecialization(Editor* editor, JSGraph* jsgraph, Flags flags, 49 Handle<Context> native_context, 50 CompilationDependencies* dependencies, 51 Zone* zone); 52 53 Reduction Reduce(Node* node) final; 54 55 private: 56 Reduction ReduceJSInstanceOf(Node* node); 57 Reduction ReduceJSLoadContext(Node* node); 58 Reduction ReduceJSLoadNamed(Node* node); 59 Reduction ReduceJSStoreNamed(Node* node); 60 Reduction ReduceJSLoadProperty(Node* node); 61 Reduction ReduceJSStoreProperty(Node* node); 62 63 Reduction ReduceElementAccess(Node* node, Node* index, Node* value, 64 MapHandleList const& receiver_maps, 65 AccessMode access_mode, 66 LanguageMode language_mode, 67 KeyedAccessStoreMode store_mode); 68 template <typename KeyedICNexus> 69 Reduction ReduceKeyedAccess(Node* node, Node* index, Node* value, 70 KeyedICNexus const& nexus, AccessMode access_mode, 71 LanguageMode language_mode, 72 KeyedAccessStoreMode store_mode); 73 Reduction ReduceNamedAccessFromNexus(Node* node, Node* value, 74 FeedbackNexus const& nexus, 75 Handle<Name> name, 76 AccessMode access_mode, 77 LanguageMode language_mode); 78 Reduction ReduceNamedAccess(Node* node, Node* value, 79 MapHandleList const& receiver_maps, 80 Handle<Name> name, AccessMode access_mode, 81 LanguageMode language_mode, 82 Handle<TypeFeedbackVector> vector, 83 FeedbackVectorSlot slot, Node* index = nullptr); 84 85 Reduction ReduceSoftDeoptimize(Node* node, DeoptimizeReason reason); 86 87 // A triple of nodes that represents a continuation. 88 class ValueEffectControl final { 89 public: ValueEffectControl(Node * value,Node * effect,Node * control)90 ValueEffectControl(Node* value, Node* effect, Node* control) 91 : value_(value), effect_(effect), control_(control) {} 92 value()93 Node* value() const { return value_; } effect()94 Node* effect() const { return effect_; } control()95 Node* control() const { return control_; } 96 97 private: 98 Node* const value_; 99 Node* const effect_; 100 Node* const control_; 101 }; 102 103 // Construct the appropriate subgraph for property access. 104 ValueEffectControl BuildPropertyAccess( 105 Node* receiver, Node* value, Node* context, Node* frame_state, 106 Node* effect, Node* control, Handle<Name> name, 107 PropertyAccessInfo const& access_info, AccessMode access_mode, 108 LanguageMode language_mode, Handle<TypeFeedbackVector> vector, 109 FeedbackVectorSlot slot); 110 111 // Construct the appropriate subgraph for element access. 112 ValueEffectControl BuildElementAccess(Node* receiver, Node* index, 113 Node* value, Node* effect, 114 Node* control, 115 ElementAccessInfo const& access_info, 116 AccessMode access_mode, 117 KeyedAccessStoreMode store_mode); 118 119 // Construct an appropriate map check. 120 Node* BuildCheckMaps(Node* receiver, Node* effect, Node* control, 121 std::vector<Handle<Map>> const& maps); 122 123 // Adds stability dependencies on all prototypes of every class in 124 // {receiver_type} up to (and including) the {holder}. 125 void AssumePrototypesStable(std::vector<Handle<Map>> const& receiver_maps, 126 Handle<JSObject> holder); 127 128 // Checks if we can turn the hole into undefined when loading an element 129 // from an object with one of the {receiver_maps}; sets up appropriate 130 // code dependencies and might use the array protector cell. 131 bool CanTreatHoleAsUndefined(std::vector<Handle<Map>> const& receiver_maps); 132 133 // Extract receiver maps from {nexus} and filter based on {receiver} if 134 // possible. 135 bool ExtractReceiverMaps(Node* receiver, Node* effect, 136 FeedbackNexus const& nexus, 137 MapHandleList* receiver_maps); 138 139 // Try to infer a map for the given {receiver} at the current {effect}. 140 // If a map is returned then you can be sure that the {receiver} definitely 141 // has the returned map at this point in the program (identified by {effect}). 142 MaybeHandle<Map> InferReceiverMap(Node* receiver, Node* effect); 143 // Try to infer a root map for the {receiver} independent of the current 144 // program location. 145 MaybeHandle<Map> InferReceiverRootMap(Node* receiver); 146 147 ValueEffectControl InlineApiCall( 148 Node* receiver, Node* context, Node* target, Node* frame_state, 149 ZoneVector<Node*>* stack_parameters, Node* effect, Node* control, 150 Handle<SharedFunctionInfo> shared_info, 151 Handle<FunctionTemplateInfo> function_template_info); 152 153 Graph* graph() const; jsgraph()154 JSGraph* jsgraph() const { return jsgraph_; } 155 Isolate* isolate() const; 156 Factory* factory() const; 157 CommonOperatorBuilder* common() const; 158 JSOperatorBuilder* javascript() const; 159 SimplifiedOperatorBuilder* simplified() const; 160 MachineOperatorBuilder* machine() const; flags()161 Flags flags() const { return flags_; } native_context()162 Handle<Context> native_context() const { return native_context_; } dependencies()163 CompilationDependencies* dependencies() const { return dependencies_; } zone()164 Zone* zone() const { return zone_; } 165 166 JSGraph* const jsgraph_; 167 Flags const flags_; 168 Handle<Context> native_context_; 169 CompilationDependencies* const dependencies_; 170 Zone* const zone_; 171 TypeCache const& type_cache_; 172 173 DISALLOW_COPY_AND_ASSIGN(JSNativeContextSpecialization); 174 }; 175 176 DEFINE_OPERATORS_FOR_FLAGS(JSNativeContextSpecialization::Flags) 177 178 } // namespace compiler 179 } // namespace internal 180 } // namespace v8 181 182 #endif // V8_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_ 183