OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_COMPILER_ESCAPE_ANALYSIS_H_ | 5 #ifndef V8_COMPILER_ESCAPE_ANALYSIS_H_ |
6 #define V8_COMPILER_ESCAPE_ANALYSIS_H_ | 6 #define V8_COMPILER_ESCAPE_ANALYSIS_H_ |
7 | 7 |
8 #include "src/base/flags.h" | 8 #include "src/base/flags.h" |
9 #include "src/compiler/graph.h" | 9 #include "src/compiler/graph.h" |
10 | 10 |
(...skipping 17 matching lines...) Expand all Loading... |
28 kUnknown = 0u, | 28 kUnknown = 0u, |
29 kVirtual = 1u << 0, | 29 kVirtual = 1u << 0, |
30 kEscaped = 1u << 1, | 30 kEscaped = 1u << 1, |
31 }; | 31 }; |
32 typedef base::Flags<EscapeStatusFlag> EscapeStatusFlags; | 32 typedef base::Flags<EscapeStatusFlag> EscapeStatusFlags; |
33 | 33 |
34 void Run(); | 34 void Run(); |
35 | 35 |
36 bool IsVirtual(Node* node); | 36 bool IsVirtual(Node* node); |
37 bool IsEscaped(Node* node); | 37 bool IsEscaped(Node* node); |
| 38 bool IsAllocation(Node* node); |
38 | 39 |
39 void DebugPrint(); | 40 void DebugPrint(); |
40 | 41 |
41 friend class EscapeAnalysis; | 42 friend class EscapeAnalysis; |
42 | 43 |
43 private: | 44 private: |
44 EscapeStatusAnalysis(EscapeAnalysis* object_analysis, Graph* graph, | 45 EscapeStatusAnalysis(EscapeAnalysis* object_analysis, Graph* graph, |
45 Zone* zone); | 46 Zone* zone); |
46 void Process(Node* node); | 47 void Process(Node* node); |
47 void ProcessAllocate(Node* node); | 48 void ProcessAllocate(Node* node); |
(...skipping 18 matching lines...) Expand all Loading... |
66 ZoneVector<EscapeStatusFlags> info_; | 67 ZoneVector<EscapeStatusFlags> info_; |
67 ZoneDeque<Node*> queue_; | 68 ZoneDeque<Node*> queue_; |
68 | 69 |
69 DISALLOW_COPY_AND_ASSIGN(EscapeStatusAnalysis); | 70 DISALLOW_COPY_AND_ASSIGN(EscapeStatusAnalysis); |
70 }; | 71 }; |
71 | 72 |
72 | 73 |
73 DEFINE_OPERATORS_FOR_FLAGS(EscapeStatusAnalysis::EscapeStatusFlags) | 74 DEFINE_OPERATORS_FOR_FLAGS(EscapeStatusAnalysis::EscapeStatusFlags) |
74 | 75 |
75 | 76 |
| 77 class MergeCache { |
| 78 public: |
| 79 explicit MergeCache(Zone* zone) |
| 80 : states_(zone), objects_(zone), fields_(zone) { |
| 81 states_.reserve(4); |
| 82 objects_.reserve(4); |
| 83 fields_.reserve(4); |
| 84 } |
| 85 ZoneVector<VirtualState*>& states() { return states_; } |
| 86 ZoneVector<VirtualObject*>& objects() { return objects_; } |
| 87 ZoneVector<Node*>& fields() { return fields_; } |
| 88 void Clear() { |
| 89 states_.clear(); |
| 90 objects_.clear(); |
| 91 fields_.clear(); |
| 92 } |
| 93 |
| 94 private: |
| 95 ZoneVector<VirtualState*> states_; |
| 96 ZoneVector<VirtualObject*> objects_; |
| 97 ZoneVector<Node*> fields_; |
| 98 }; |
| 99 |
| 100 |
76 // EscapeObjectAnalysis simulates stores to determine values of loads if | 101 // EscapeObjectAnalysis simulates stores to determine values of loads if |
77 // an object is virtual and eliminated. | 102 // an object is virtual and eliminated. |
78 class EscapeAnalysis { | 103 class EscapeAnalysis { |
79 public: | 104 public: |
80 EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone); | 105 EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone); |
81 ~EscapeAnalysis(); | 106 ~EscapeAnalysis(); |
82 | 107 |
83 void Run(); | 108 void Run(); |
84 | 109 |
85 Node* GetReplacement(Node* at, NodeId id); | 110 Node* GetReplacement(Node* at, NodeId id); |
86 bool IsVirtual(Node* node); | 111 bool IsVirtual(Node* node); |
87 bool IsEscaped(Node* node); | 112 bool IsEscaped(Node* node); |
| 113 bool IsAllocation(Node* node); |
88 | 114 |
89 private: | 115 private: |
90 void RunObjectAnalysis(); | 116 void RunObjectAnalysis(); |
91 bool Process(Node* node); | 117 bool Process(Node* node); |
92 void ProcessLoadField(Node* node); | 118 void ProcessLoadField(Node* node); |
93 void ProcessStoreField(Node* node); | 119 void ProcessStoreField(Node* node); |
94 void ProcessLoadElement(Node* node); | 120 void ProcessLoadElement(Node* node); |
95 void ProcessStoreElement(Node* node); | 121 void ProcessStoreElement(Node* node); |
96 void ProcessAllocationUsers(Node* node); | 122 void ProcessAllocationUsers(Node* node); |
97 void ProcessAllocation(Node* node); | 123 void ProcessAllocation(Node* node); |
98 void ProcessFinishRegion(Node* node); | 124 void ProcessFinishRegion(Node* node); |
99 void ProcessCall(Node* node); | 125 void ProcessCall(Node* node); |
100 void ProcessStart(Node* node); | 126 void ProcessStart(Node* node); |
101 bool ProcessEffectPhi(Node* node); | 127 bool ProcessEffectPhi(Node* node); |
102 void ProcessLoadFromPhi(int offset, Node* from, Node* node, | 128 void ProcessLoadFromPhi(int offset, Node* from, Node* node, |
103 VirtualState* states); | 129 VirtualState* states); |
104 | 130 |
105 void ForwardVirtualState(Node* node); | 131 void ForwardVirtualState(Node* node); |
106 | 132 |
107 bool IsEffectBranchPoint(Node* node); | 133 bool IsEffectBranchPoint(Node* node); |
108 bool IsDanglingEffectNode(Node* node); | 134 bool IsDanglingEffectNode(Node* node); |
109 int OffsetFromAccess(Node* node); | 135 int OffsetFromAccess(Node* node); |
110 | 136 |
111 VirtualObject* GetVirtualObject(Node* at, NodeId id); | 137 VirtualObject* GetVirtualObject(Node* at, NodeId id); |
112 | 138 |
| 139 bool SetEscaped(Node* node); |
| 140 |
113 void DebugPrint(); | 141 void DebugPrint(); |
114 void DebugPrintState(VirtualState* state); | 142 void DebugPrintState(VirtualState* state); |
115 void DebugPrintObject(VirtualObject* state, NodeId id); | 143 void DebugPrintObject(VirtualObject* state, NodeId id); |
116 | 144 |
117 Graph* graph() const { return graph_; } | 145 Graph* graph() const { return graph_; } |
118 CommonOperatorBuilder* common() const { return common_; } | 146 CommonOperatorBuilder* common() const { return common_; } |
119 Zone* zone() const { return zone_; } | 147 Zone* zone() const { return zone_; } |
120 | 148 |
121 Graph* const graph_; | 149 Graph* const graph_; |
122 CommonOperatorBuilder* const common_; | 150 CommonOperatorBuilder* const common_; |
123 Zone* const zone_; | 151 Zone* const zone_; |
124 ZoneVector<VirtualState*> virtual_states_; | 152 ZoneVector<VirtualState*> virtual_states_; |
125 EscapeStatusAnalysis escape_status_; | 153 EscapeStatusAnalysis escape_status_; |
| 154 MergeCache cache_; |
126 | 155 |
127 DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis); | 156 DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis); |
128 }; | 157 }; |
129 | 158 |
130 } // namespace compiler | 159 } // namespace compiler |
131 } // namespace internal | 160 } // namespace internal |
132 } // namespace v8 | 161 } // namespace v8 |
133 | 162 |
134 #endif // V8_COMPILER_ESCAPE_ANALYSIS_H_ | 163 #endif // V8_COMPILER_ESCAPE_ANALYSIS_H_ |
OLD | NEW |