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 |
11 namespace v8 { | 11 namespace v8 { |
12 namespace internal { | 12 namespace internal { |
13 namespace compiler { | 13 namespace compiler { |
14 | 14 |
15 // Forward declarations. | 15 // Forward declarations. |
16 class CommonOperatorBuilder; | 16 class CommonOperatorBuilder; |
17 class EscapeObjectAnalysis; | 17 class EscapeAnalysis; |
18 class VirtualState; | 18 class VirtualState; |
19 | 19 |
20 | 20 |
21 // EscapeStatusAnalysis determines for each allocation whether it escapes. | 21 // EscapeStatusAnalysis determines for each allocation whether it escapes. |
22 class EscapeStatusAnalysis { | 22 class EscapeStatusAnalysis { |
23 public: | 23 public: |
24 EscapeStatusAnalysis(EscapeObjectAnalysis* object_analysis, Graph* graph, | |
25 Zone* zone); | |
26 ~EscapeStatusAnalysis(); | 24 ~EscapeStatusAnalysis(); |
27 | 25 |
28 enum EscapeStatusFlag { | 26 enum EscapeStatusFlag { |
29 kUnknown = 0u, | 27 kUnknown = 0u, |
30 kVirtual = 1u << 0, | 28 kVirtual = 1u << 0, |
31 kEscaped = 1u << 1, | 29 kEscaped = 1u << 1, |
32 }; | 30 }; |
33 typedef base::Flags<EscapeStatusFlag> EscapeStatusFlags; | 31 typedef base::Flags<EscapeStatusFlag> EscapeStatusFlags; |
34 | 32 |
35 void Run(); | 33 void Run(); |
36 | 34 |
37 bool HasEntry(Node* node); | |
38 bool IsVirtual(Node* node); | 35 bool IsVirtual(Node* node); |
39 bool IsEscaped(Node* node); | 36 bool IsEscaped(Node* node); |
40 | 37 |
41 void DebugPrint(); | 38 void DebugPrint(); |
42 | 39 |
| 40 friend class EscapeAnalysis; |
| 41 |
43 private: | 42 private: |
| 43 EscapeStatusAnalysis(EscapeAnalysis* object_analysis, Graph* graph, |
| 44 Zone* zone); |
44 void Process(Node* node); | 45 void Process(Node* node); |
45 void ProcessAllocate(Node* node); | 46 void ProcessAllocate(Node* node); |
46 void ProcessFinishRegion(Node* node); | 47 void ProcessFinishRegion(Node* node); |
47 void ProcessStoreField(Node* node); | 48 void ProcessStoreField(Node* node); |
48 bool CheckUsesForEscape(Node* node) { return CheckUsesForEscape(node, node); } | 49 bool CheckUsesForEscape(Node* node) { return CheckUsesForEscape(node, node); } |
49 bool CheckUsesForEscape(Node* node, Node* rep); | 50 bool CheckUsesForEscape(Node* node, Node* rep); |
50 void RevisitUses(Node* node); | 51 void RevisitUses(Node* node); |
51 void RevisitInputs(Node* node); | 52 void RevisitInputs(Node* node); |
52 bool SetEscaped(Node* node); | 53 bool SetEscaped(Node* node); |
| 54 bool HasEntry(Node* node); |
53 | 55 |
54 Graph* graph() const { return graph_; } | 56 Graph* graph() const { return graph_; } |
55 Zone* zone() const { return zone_; } | 57 Zone* zone() const { return zone_; } |
56 | 58 |
57 EscapeObjectAnalysis* object_analysis_; | 59 EscapeAnalysis* object_analysis_; |
58 Graph* const graph_; | 60 Graph* const graph_; |
59 Zone* const zone_; | 61 Zone* const zone_; |
60 ZoneVector<EscapeStatusFlags> info_; | 62 ZoneVector<EscapeStatusFlags> info_; |
61 ZoneDeque<Node*> queue_; | 63 ZoneDeque<Node*> queue_; |
62 | 64 |
63 DISALLOW_COPY_AND_ASSIGN(EscapeStatusAnalysis); | 65 DISALLOW_COPY_AND_ASSIGN(EscapeStatusAnalysis); |
64 }; | 66 }; |
65 | 67 |
66 | 68 |
67 DEFINE_OPERATORS_FOR_FLAGS(EscapeStatusAnalysis::EscapeStatusFlags) | 69 DEFINE_OPERATORS_FOR_FLAGS(EscapeStatusAnalysis::EscapeStatusFlags) |
68 | 70 |
69 | 71 |
70 // EscapeObjectAnalysis simulates stores to determine values of loads if | 72 // EscapeObjectAnalysis simulates stores to determine values of loads if |
71 // an object is virtual and eliminated. | 73 // an object is virtual and eliminated. |
72 class EscapeObjectAnalysis { | 74 class EscapeAnalysis { |
73 public: | 75 public: |
74 EscapeObjectAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone); | 76 EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone); |
75 ~EscapeObjectAnalysis(); | 77 ~EscapeAnalysis(); |
76 | 78 |
77 void Run(); | 79 void Run(); |
78 | 80 |
79 Node* GetReplacement(Node* at, NodeId id); | 81 Node* GetReplacement(Node* at, NodeId id); |
| 82 bool IsVirtual(Node* node); |
| 83 bool IsEscaped(Node* node); |
80 | 84 |
81 private: | 85 private: |
| 86 void RunObjectAnalysis(); |
82 bool Process(Node* node); | 87 bool Process(Node* node); |
83 void ProcessLoadField(Node* node); | 88 void ProcessLoadField(Node* node); |
84 void ProcessStoreField(Node* node); | 89 void ProcessStoreField(Node* node); |
85 void ProcessAllocation(Node* node); | 90 void ProcessAllocation(Node* node); |
86 void ProcessFinishRegion(Node* node); | 91 void ProcessFinishRegion(Node* node); |
87 void ProcessCall(Node* node); | 92 void ProcessCall(Node* node); |
88 void ProcessStart(Node* node); | 93 void ProcessStart(Node* node); |
89 bool ProcessEffectPhi(Node* node); | 94 bool ProcessEffectPhi(Node* node); |
90 void ForwardVirtualState(Node* node); | 95 void ForwardVirtualState(Node* node); |
91 bool IsEffectBranchPoint(Node* node); | 96 bool IsEffectBranchPoint(Node* node); |
92 bool IsDanglingEffectNode(Node* node); | 97 bool IsDanglingEffectNode(Node* node); |
93 int OffsetFromAccess(Node* node); | 98 int OffsetFromAccess(Node* node); |
94 | 99 |
95 void DebugPrint(); | 100 void DebugPrint(); |
96 | 101 |
97 Graph* graph() const { return graph_; } | 102 Graph* graph() const { return graph_; } |
98 CommonOperatorBuilder* common() const { return common_; } | 103 CommonOperatorBuilder* common() const { return common_; } |
99 Zone* zone() const { return zone_; } | 104 Zone* zone() const { return zone_; } |
100 | 105 |
101 Graph* const graph_; | 106 Graph* const graph_; |
102 CommonOperatorBuilder* const common_; | 107 CommonOperatorBuilder* const common_; |
103 Zone* const zone_; | 108 Zone* const zone_; |
104 ZoneVector<VirtualState*> virtual_states_; | 109 ZoneVector<VirtualState*> virtual_states_; |
| 110 EscapeStatusAnalysis escape_status_; |
105 | 111 |
106 DISALLOW_COPY_AND_ASSIGN(EscapeObjectAnalysis); | 112 DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis); |
107 }; | 113 }; |
108 | 114 |
109 } // namespace compiler | 115 } // namespace compiler |
110 } // namespace internal | 116 } // namespace internal |
111 } // namespace v8 | 117 } // namespace v8 |
112 | 118 |
113 #endif // V8_COMPILER_ESCAPE_ANALYSIS_H_ | 119 #endif // V8_COMPILER_ESCAPE_ANALYSIS_H_ |
OLD | NEW |