Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/compiler/escape-analysis.h b/src/compiler/escape-analysis.h
new file mode 100644
index 0000000..ea7b11e
--- /dev/null
+++ b/src/compiler/escape-analysis.h
@@ -0,0 +1,169 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_COMPILER_ESCAPE_ANALYSIS_H_
+#define V8_COMPILER_ESCAPE_ANALYSIS_H_
+
+#include "src/base/flags.h"
+#include "src/compiler/graph.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// Forward declarations.
+class CommonOperatorBuilder;
+class EscapeAnalysis;
+class VirtualState;
+class VirtualObject;
+
+
+// EscapeStatusAnalysis determines for each allocation whether it escapes.
+class EscapeStatusAnalysis {
+ public:
+ ~EscapeStatusAnalysis();
+
+ enum EscapeStatusFlag {
+ kUnknown = 0u,
+ kTracked = 1u << 0,
+ kEscaped = 1u << 1,
+ kOnStack = 1u << 2,
+ kVisited = 1u << 3,
+ };
+ typedef base::Flags<EscapeStatusFlag, unsigned char> EscapeStatusFlags;
+
+ void Run();
+
+ bool IsVirtual(Node* node);
+ bool IsEscaped(Node* node);
+ bool IsAllocation(Node* node);
+
+ void DebugPrint();
+
+ friend class EscapeAnalysis;
+
+ private:
+ EscapeStatusAnalysis(EscapeAnalysis* object_analysis, Graph* graph,
+ Zone* zone);
+ void Process(Node* node);
+ void ProcessAllocate(Node* node);
+ void ProcessFinishRegion(Node* node);
+ void ProcessStoreField(Node* node);
+ void ProcessStoreElement(Node* node);
+ bool CheckUsesForEscape(Node* node, bool phi_escaping = false) {
+ return CheckUsesForEscape(node, node, phi_escaping);
+ }
+ bool CheckUsesForEscape(Node* node, Node* rep, bool phi_escaping = false);
+ void RevisitUses(Node* node);
+ void RevisitInputs(Node* node);
+ bool SetEscaped(Node* node);
+ bool HasEntry(Node* node);
+ void Resize();
+ size_t size();
+ bool IsAllocationPhi(Node* node);
+
+ Graph* graph() const { return graph_; }
+ Zone* zone() const { return zone_; }
+
+ EscapeAnalysis* object_analysis_;
+ Graph* const graph_;
+ Zone* const zone_;
+ ZoneVector<EscapeStatusFlags> status_;
+ ZoneDeque<Node*> queue_;
+
+ DISALLOW_COPY_AND_ASSIGN(EscapeStatusAnalysis);
+};
+
+
+DEFINE_OPERATORS_FOR_FLAGS(EscapeStatusAnalysis::EscapeStatusFlags)
+
+
+// Forward Declaration.
+class MergeCache;
+
+
+// EscapeObjectAnalysis simulates stores to determine values of loads if
+// an object is virtual and eliminated.
+class EscapeAnalysis {
+ public:
+ typedef NodeId Alias;
+
+ EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone);
+ ~EscapeAnalysis();
+
+ void Run();
+
+ Node* GetReplacement(Node* node);
+ bool IsVirtual(Node* node);
+ bool IsEscaped(Node* node);
+ bool CompareVirtualObjects(Node* left, Node* right);
+ Node* GetOrCreateObjectState(Node* effect, Node* node);
+
+ private:
+ void RunObjectAnalysis();
+ void AssignAliases();
+ bool Process(Node* node);
+ void ProcessLoadField(Node* node);
+ void ProcessStoreField(Node* node);
+ void ProcessLoadElement(Node* node);
+ void ProcessStoreElement(Node* node);
+ void ProcessAllocationUsers(Node* node);
+ void ProcessAllocation(Node* node);
+ void ProcessFinishRegion(Node* node);
+ void ProcessCall(Node* node);
+ void ProcessStart(Node* node);
+ bool ProcessEffectPhi(Node* node);
+ void ProcessLoadFromPhi(int offset, Node* from, Node* node,
+ VirtualState* states);
+
+ void ForwardVirtualState(Node* node);
+ bool IsEffectBranchPoint(Node* node);
+ bool IsDanglingEffectNode(Node* node);
+ int OffsetFromAccess(Node* node);
+
+ VirtualObject* GetVirtualObject(Node* at, NodeId id);
+ VirtualObject* ResolveVirtualObject(VirtualState* state, Node* node);
+ Node* GetReplacementIfSame(ZoneVector<VirtualObject*>& objs);
+
+ bool SetEscaped(Node* node);
+ Node* replacement(NodeId id);
+ Node* replacement(Node* node);
+ Node* ResolveReplacement(Node* node);
+ Node* GetReplacement(NodeId id);
+ bool SetReplacement(Node* node, Node* rep);
+ bool UpdateReplacement(VirtualState* state, Node* node, Node* rep);
+
+ VirtualObject* GetVirtualObject(VirtualState* state, Node* node);
+
+ void DebugPrint();
+ void DebugPrintState(VirtualState* state);
+ void DebugPrintObject(VirtualObject* state, Alias id);
+
+ Alias NextAlias() { return next_free_alias_++; }
+ Alias AliasCount() const { return next_free_alias_; }
+
+ Graph* graph() const { return graph_; }
+ CommonOperatorBuilder* common() const { return common_; }
+ Zone* zone() const { return zone_; }
+
+ static const Alias kNotReachable;
+ static const Alias kUntrackable;
+ Graph* const graph_;
+ CommonOperatorBuilder* const common_;
+ Zone* const zone_;
+ ZoneVector<VirtualState*> virtual_states_;
+ ZoneVector<Node*> replacements_;
+ EscapeStatusAnalysis escape_status_;
+ MergeCache* cache_;
+ ZoneVector<Alias> aliases_;
+ Alias next_free_alias_;
+
+ DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_ESCAPE_ANALYSIS_H_