Home | History | Annotate | Download | only in compiler 
      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;
     71   Zone* zone() const { return zone_; }
     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