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 11namespace v8 { 12namespace internal { 13 14// Forward declarations. 15class CompilationDependencies; 16class Factory; 17class FeedbackNexus; 18class TypeCache; 19 20 21namespace compiler { 22 23// Forward declarations. 24enum class AccessMode; 25class CommonOperatorBuilder; 26class JSGraph; 27class JSOperatorBuilder; 28class MachineOperatorBuilder; 29class SimplifiedOperatorBuilder; 30 31 32// Specializes a given JSGraph to a given native context, potentially constant 33// folding some {LoadGlobal} nodes or strength reducing some {StoreGlobal} 34// nodes. And also specializes {LoadNamed} and {StoreNamed} nodes according 35// to type feedback (if available). 36class JSNativeContextSpecialization final : public AdvancedReducer { 37 public: 38 // Flags that control the mode of operation. 39 enum Flag { 40 kNoFlags = 0u, 41 kDeoptimizationEnabled = 1u << 0, 42 }; 43 typedef base::Flags<Flag> Flags; 44 45 JSNativeContextSpecialization(Editor* editor, JSGraph* jsgraph, Flags flags, 46 MaybeHandle<Context> native_context, 47 CompilationDependencies* dependencies, 48 Zone* zone); 49 50 Reduction Reduce(Node* node) final; 51 52 private: 53 Reduction ReduceJSLoadNamed(Node* node); 54 Reduction ReduceJSStoreNamed(Node* node); 55 Reduction ReduceJSLoadProperty(Node* node); 56 Reduction ReduceJSStoreProperty(Node* node); 57 58 Reduction ReduceElementAccess(Node* node, Node* index, Node* value, 59 MapHandleList const& receiver_maps, 60 AccessMode access_mode, 61 LanguageMode language_mode, 62 KeyedAccessStoreMode store_mode); 63 Reduction ReduceKeyedAccess(Node* node, Node* index, Node* value, 64 FeedbackNexus const& nexus, 65 AccessMode access_mode, 66 LanguageMode language_mode, 67 KeyedAccessStoreMode store_mode); 68 Reduction ReduceNamedAccess(Node* node, Node* value, 69 MapHandleList const& receiver_maps, 70 Handle<Name> name, AccessMode access_mode, 71 LanguageMode language_mode, 72 Node* index = nullptr); 73 74 // Adds stability dependencies on all prototypes of every class in 75 // {receiver_type} up to (and including) the {holder}. 76 void AssumePrototypesStable(Type* receiver_type, 77 Handle<Context> native_context, 78 Handle<JSObject> holder); 79 80 // Assuming that {if_projection} is either IfTrue or IfFalse, adds a hint on 81 // the dominating Branch that {if_projection} is the unlikely (deferred) case. 82 void MarkAsDeferred(Node* if_projection); 83 84 // Retrieve the native context from the given {node} if known. 85 MaybeHandle<Context> GetNativeContext(Node* node); 86 87 Graph* graph() const; 88 JSGraph* jsgraph() const { return jsgraph_; } 89 Isolate* isolate() const; 90 Factory* factory() const; 91 CommonOperatorBuilder* common() const; 92 JSOperatorBuilder* javascript() const; 93 SimplifiedOperatorBuilder* simplified() const; 94 MachineOperatorBuilder* machine() const; 95 Flags flags() const { return flags_; } 96 MaybeHandle<Context> native_context() const { return native_context_; } 97 CompilationDependencies* dependencies() const { return dependencies_; } 98 Zone* zone() const { return zone_; } 99 100 JSGraph* const jsgraph_; 101 Flags const flags_; 102 MaybeHandle<Context> native_context_; 103 CompilationDependencies* const dependencies_; 104 Zone* const zone_; 105 TypeCache const& type_cache_; 106 107 DISALLOW_COPY_AND_ASSIGN(JSNativeContextSpecialization); 108}; 109 110DEFINE_OPERATORS_FOR_FLAGS(JSNativeContextSpecialization::Flags) 111 112} // namespace compiler 113} // namespace internal 114} // namespace v8 115 116#endif // V8_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_ 117