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
11namespace v8 {
12namespace internal {
13namespace compiler {
14
15// Forward declarations.
16class CommonOperatorBuilder;
17class EscapeStatusAnalysis;
18class MergeCache;
19class VirtualState;
20class VirtualObject;
21
22// EscapeObjectAnalysis simulates stores to determine values of loads if
23// an object is virtual and eliminated.
24class 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