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_ESCAPE_ANALYSIS_H_ 6 #define V8_COMPILER_ESCAPE_ANALYSIS_H_ 7 8 #include "src/compiler/graph.h" 9 #include "src/globals.h" 10 11 namespace v8 { 12 namespace internal { 13 namespace compiler { 14 15 // Forward declarations. 16 class CommonOperatorBuilder; 17 class EscapeStatusAnalysis; 18 class MergeCache; 19 class VirtualState; 20 class VirtualObject; 21 22 // EscapeObjectAnalysis simulates stores to determine values of loads if 23 // an object is virtual and eliminated. 24 class V8_EXPORT_PRIVATE EscapeAnalysis { 25 public: 26 EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone); 27 ~EscapeAnalysis(); 28 29 bool Run(); 30 31 Node* GetReplacement(Node* node); 32 Node* ResolveReplacement(Node* node); 33 bool IsVirtual(Node* node); 34 bool IsEscaped(Node* node); 35 bool CompareVirtualObjects(Node* left, Node* right); 36 Node* GetOrCreateObjectState(Node* effect, Node* node); 37 bool IsCyclicObjectState(Node* effect, Node* node); 38 bool ExistsVirtualAllocate(); 39 bool SetReplacement(Node* node, Node* rep); 40 41 private: 42 void RunObjectAnalysis(); 43 bool Process(Node* node); 44 void ProcessLoadField(Node* node); 45 void ProcessStoreField(Node* node); 46 void ProcessLoadElement(Node* node); 47 void ProcessStoreElement(Node* node); 48 void ProcessAllocationUsers(Node* node); 49 void ProcessAllocation(Node* node); 50 void ProcessFinishRegion(Node* node); 51 void ProcessCall(Node* node); 52 void ProcessStart(Node* node); 53 bool ProcessEffectPhi(Node* node); 54 void ProcessLoadFromPhi(int offset, Node* from, Node* node, 55 VirtualState* states); 56 57 void ForwardVirtualState(Node* node); 58 VirtualState* CopyForModificationAt(VirtualState* state, Node* node); 59 VirtualObject* CopyForModificationAt(VirtualObject* obj, VirtualState* state, 60 Node* node); 61 62 Node* replacement(Node* node); 63 bool UpdateReplacement(VirtualState* state, Node* node, Node* rep); 64 65 VirtualObject* GetVirtualObject(VirtualState* state, Node* node); 66 67 void DebugPrint(); 68 void DebugPrintState(VirtualState* state); 69 70 Graph* graph() const; zone()71 Zone* zone() const { return zone_; } common()72 CommonOperatorBuilder* common() const { return common_; } 73 74 Zone* const zone_; 75 Node* const slot_not_analyzed_; 76 CommonOperatorBuilder* const common_; 77 EscapeStatusAnalysis* status_analysis_; 78 ZoneVector<VirtualState*> virtual_states_; 79 ZoneVector<Node*> replacements_; 80 ZoneSet<VirtualObject*> cycle_detection_; 81 MergeCache* cache_; 82 83 DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis); 84 }; 85 86 } // namespace compiler 87 } // namespace internal 88 } // namespace v8 89 90 #endif // V8_COMPILER_ESCAPE_ANALYSIS_H_ 91