[turbofan] escape analysis supports arguments object and rest elements

src/compiler/instruction.h

 // Copyright 2014 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_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 1104 matching lines @@
 };
 
 
 std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 
 // Forward declarations.
 class FrameStateDescriptor;
 
 enum class StateValueKind : uint8_t {
-  kArguments,
+  kArgumentsElements,
   kPlain,
   kOptimizedOut,
   kNested,
   kDuplicate
 };
 
 class StateValueDescriptor {
  public:
   StateValueDescriptor()
-      : kind_(StateValueKind::kPlain),
-        type_(MachineType::AnyTagged()),
-        id_(0) {}
+      : kind_(StateValueKind::kPlain), type_(MachineType::AnyTagged()) {}
 
-  static StateValueDescriptor Arguments() {
-    return StateValueDescriptor(StateValueKind::kArguments,
-                                MachineType::AnyTagged(), 0);
+  static StateValueDescriptor ArgumentsElements(bool is_rest) {
+    StateValueDescriptor descr(StateValueKind::kArgumentsElements,
+                               MachineType::AnyTagged());
+    descr.is_rest_ = is_rest;
+    return descr;
   }
   static StateValueDescriptor Plain(MachineType type) {
-    return StateValueDescriptor(StateValueKind::kPlain, type, 0);
+    return StateValueDescriptor(StateValueKind::kPlain, type);
   }
   static StateValueDescriptor OptimizedOut() {
     return StateValueDescriptor(StateValueKind::kOptimizedOut,
-                                MachineType::AnyTagged(), 0);
+                                MachineType::AnyTagged());
   }
   static StateValueDescriptor Recursive(size_t id) {
-    return StateValueDescriptor(StateValueKind::kNested,
-                                MachineType::AnyTagged(), id);
+    StateValueDescriptor descr(StateValueKind::kNested,
+                               MachineType::AnyTagged());
+    descr.id_ = id;
+    return descr;
   }
   static StateValueDescriptor Duplicate(size_t id) {
-    return StateValueDescriptor(StateValueKind::kDuplicate,
-                                MachineType::AnyTagged(), id);
+    StateValueDescriptor descr(StateValueKind::kDuplicate,
+                               MachineType::AnyTagged());
+    descr.id_ = id;
+    return descr;
   }
 
-  bool IsArguments() const { return kind_ == StateValueKind::kArguments; }
+  bool IsArgumentsElements() const {
+    return kind_ == StateValueKind::kArgumentsElements;
+  }
   bool IsPlain() const { return kind_ == StateValueKind::kPlain; }
   bool IsOptimizedOut() const { return kind_ == StateValueKind::kOptimizedOut; }
   bool IsNested() const { return kind_ == StateValueKind::kNested; }
   bool IsDuplicate() const { return kind_ == StateValueKind::kDuplicate; }
   MachineType type() const { return type_; }
-  size_t id() const { return id_; }
+  size_t id() const {
+    DCHECK(kind_ == StateValueKind::kDuplicate ||
+           kind_ == StateValueKind::kNested);
+    return id_;
+  }
+  int is_rest() const {
+    DCHECK(kind_ == StateValueKind::kArgumentsElements);
+    return is_rest_;
+  }
 
  private:
-  StateValueDescriptor(StateValueKind kind, MachineType type, size_t id)
-      : kind_(kind), type_(type), id_(id) {}
+  StateValueDescriptor(StateValueKind kind, MachineType type)
+      : kind_(kind), type_(type) {}
 
   StateValueKind kind_;
   MachineType type_;
-  size_t id_;
+  union {
+    size_t id_;
+    bool is_rest_;
+  };
 };
 
 class StateValueList {
  public:
   explicit StateValueList(Zone* zone) : fields_(zone), nested_(zone) {}
 
   size_t size() { return fields_.size(); }
 
   struct Value {
     StateValueDescriptor* desc;
@@ skipping 38 matching lines @@
 
   void ReserveSize(size_t size) { fields_.reserve(size); }
 
   StateValueList* PushRecursiveField(Zone* zone, size_t id) {
     fields_.push_back(StateValueDescriptor::Recursive(id));
     StateValueList* nested =
         new (zone->New(sizeof(StateValueList))) StateValueList(zone);
     nested_.push_back(nested);
     return nested;
   }
-  void PushArguments() { fields_.push_back(StateValueDescriptor::Arguments()); }
+  void PushArgumentsElements(int skip) {

[Jarin, 2017/02/27 13:24:34]

How about 

int skip ==> bool is_rest

?

+    fields_.push_back(StateValueDescriptor::ArgumentsElements(skip));
+  }
   void PushDuplicate(size_t id) {
     fields_.push_back(StateValueDescriptor::Duplicate(id));
   }
   void PushPlain(MachineType type) {
     fields_.push_back(StateValueDescriptor::Plain(type));
   }
   void PushOptimizedOut() {
     fields_.push_back(StateValueDescriptor::OptimizedOut());
   }
 
@@ skipping 393 matching lines @@
 };
 
 V8_EXPORT_PRIVATE std::ostream& operator<<(
     std::ostream& os, const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_