[turbofan] compute arguments length in deoptimizer

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 1108 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 
 // Forward declarations.
 class FrameStateDescriptor;
 
 enum class StateValueKind : uint8_t {
   kArgumentsElements,
+  kArgumentsLength,
   kPlain,
   kOptimizedOut,
   kNested,
   kDuplicate
 };
 
 class StateValueDescriptor {
  public:
   StateValueDescriptor()
       : kind_(StateValueKind::kPlain), type_(MachineType::AnyTagged()) {}
 
   static StateValueDescriptor ArgumentsElements(bool is_rest) {
     StateValueDescriptor descr(StateValueKind::kArgumentsElements,
                                MachineType::AnyTagged());
     descr.is_rest_ = is_rest;
     return descr;
   }
+  static StateValueDescriptor ArgumentsLength(bool is_rest) {
+    StateValueDescriptor descr(StateValueKind::kArgumentsLength,
+                               MachineType::AnyTagged());
+    descr.is_rest_ = is_rest;
+    return descr;
+  }
   static StateValueDescriptor Plain(MachineType type) {
     return StateValueDescriptor(StateValueKind::kPlain, type);
   }
   static StateValueDescriptor OptimizedOut() {
     return StateValueDescriptor(StateValueKind::kOptimizedOut,
                                 MachineType::AnyTagged());
   }
   static StateValueDescriptor Recursive(size_t id) {
     StateValueDescriptor descr(StateValueKind::kNested,
                                MachineType::AnyTagged());
     descr.id_ = id;
     return descr;
   }
   static StateValueDescriptor Duplicate(size_t id) {
     StateValueDescriptor descr(StateValueKind::kDuplicate,
                                MachineType::AnyTagged());
     descr.id_ = id;
     return descr;
   }
 
   bool IsArgumentsElements() const {
     return kind_ == StateValueKind::kArgumentsElements;
   }
+  bool IsArgumentsLength() const {
+    return kind_ == StateValueKind::kArgumentsLength;
+  }
   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 {
     DCHECK(kind_ == StateValueKind::kDuplicate ||
            kind_ == StateValueKind::kNested);
     return id_;
   }
   int is_rest() const {
-    DCHECK(kind_ == StateValueKind::kArgumentsElements);
+    DCHECK(kind_ == StateValueKind::kArgumentsElements ||
+           kind_ == StateValueKind::kArgumentsLength);
     return is_rest_;
   }
 
  private:
   StateValueDescriptor(StateValueKind kind, MachineType type)
       : kind_(kind), type_(type) {}
 
   StateValueKind kind_;
   MachineType type_;
   union {
@@ skipping 54 matching lines @@
   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 PushArgumentsElements(bool is_rest) {
     fields_.push_back(StateValueDescriptor::ArgumentsElements(is_rest));
   }
+  void PushArgumentsLength(bool is_rest) {
+    fields_.push_back(StateValueDescriptor::ArgumentsLength(is_rest));
+  }
   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_