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