[turbofan] escape analysis supports arguments object and rest elements

src/compiler/simplified-operator.cc

 // Copyright 2012 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.
 
 #include "src/compiler/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 370 matching lines @@
          op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
          op->opcode() == IrOpcode::kSpeculativeNumberEqual ||
          op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
          op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual);
   return OpParameter<NumberOperationHint>(op);
 }
 
-int ParameterCountOf(const Operator* op) {
-  DCHECK(op->opcode() == IrOpcode::kNewUnmappedArgumentsElements ||
-         op->opcode() == IrOpcode::kNewRestParameterElements);
-  return OpParameter<int>(op);
-}
-
 PretenureFlag PretenureFlagOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
   return OpParameter<PretenureFlag>(op);
 }
 
 UnicodeEncoding UnicodeEncodingOf(const Operator* op) {
   DCHECK(op->opcode() == IrOpcode::kStringFromCodePoint);
   return OpParameter<UnicodeEncoding>(op);
 }
 
@@ skipping 150 matching lines @@
   StringFromCodePointOperator<UnicodeEncoding::UTF32>
       kStringFromCodePointOperatorUTF32;
 
   struct ArrayBufferWasNeuteredOperator final : public Operator {
     ArrayBufferWasNeuteredOperator()
         : Operator(IrOpcode::kArrayBufferWasNeutered, Operator::kEliminatable,
                    "ArrayBufferWasNeutered", 1, 1, 1, 1, 1, 0) {}
   };
   ArrayBufferWasNeuteredOperator kArrayBufferWasNeutered;
 
+  struct ArgumentsFrameOperator final : public Operator {
+    ArgumentsFrameOperator()
+        : Operator(IrOpcode::kArgumentsFrame, Operator::kPure, "ArgumentsFrame",
+                   0, 0, 0, 1, 0, 0) {}
+  };
+  ArgumentsFrameOperator kArgumentsFrame;
+
+  struct NewUnmappedArgumentsElementsOperator final : public Operator {
+    NewUnmappedArgumentsElementsOperator()
+        : Operator(IrOpcode::kNewUnmappedArgumentsElements,
+                   Operator::kEliminatable, "NewUnmappedArgumentsElements", 2,
+                   1, 0, 1, 1, 0) {}
+  };
+  NewUnmappedArgumentsElementsOperator kNewUnmappedArgumentsElements;
+
   template <CheckForMinusZeroMode kMode>
   struct CheckedInt32MulOperator final
       : public Operator1<CheckForMinusZeroMode> {
     CheckedInt32MulOperator()
         : Operator1<CheckForMinusZeroMode>(
               IrOpcode::kCheckedInt32Mul,
               Operator::kFoldable | Operator::kNoThrow, "CheckedInt32Mul", 2, 1,
               1, 1, 1, 0, kMode) {}
   };
   CheckedInt32MulOperator<CheckForMinusZeroMode::kCheckForMinusZero>
@@ skipping 124 matching lines @@
 
 
 SimplifiedOperatorBuilder::SimplifiedOperatorBuilder(Zone* zone)
     : cache_(kCache.Get()), zone_(zone) {}
 
 #define GET_FROM_CACHE(Name, ...) \
   const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
 PURE_OP_LIST(GET_FROM_CACHE)
 CHECKED_OP_LIST(GET_FROM_CACHE)
 GET_FROM_CACHE(ArrayBufferWasNeutered)
+GET_FROM_CACHE(ArgumentsFrame)
+GET_FROM_CACHE(NewUnmappedArgumentsElements)
 #undef GET_FROM_CACHE
 
 const Operator* SimplifiedOperatorBuilder::CheckedInt32Mul(
     CheckForMinusZeroMode mode) {
   switch (mode) {
     case CheckForMinusZeroMode::kCheckForMinusZero:
       return &cache_.kCheckedInt32MulCheckForMinusZeroOperator;
     case CheckForMinusZeroMode::kDontCheckForMinusZero:
       return &cache_.kCheckedInt32MulDontCheckForMinusZeroOperator;
   }
@@ skipping 77 matching lines @@
 const Operator* SimplifiedOperatorBuilder::TransitionElementsKind(
     ElementsTransition transition) {
   return new (zone()) Operator1<ElementsTransition>(  // --
       IrOpcode::kTransitionElementsKind,              // opcode
       Operator::kNoDeopt | Operator::kNoThrow,        // flags
       "TransitionElementsKind",                       // name
       1, 1, 1, 0, 1, 0,                               // counts
       transition);                                    // parameter
 }
 
-const Operator* SimplifiedOperatorBuilder::NewUnmappedArgumentsElements(
-    int parameter_count) {
-  return new (zone()) Operator1<int>(           // --
-      IrOpcode::kNewUnmappedArgumentsElements,  // opcode
-      Operator::kEliminatable,                  // flags
-      "NewUnmappedArgumentsElements",           // name
-      0, 1, 0, 1, 1, 0,                         // counts
-      parameter_count);                         // parameter
+namespace {
+
+struct ArgumentsLengthParameters {
+  int formal_parameter_count;
+  bool is_rest_length;
+};
+
+bool operator==(ArgumentsLengthParameters first,
+                ArgumentsLengthParameters second) {
+  return first.formal_parameter_count == second.formal_parameter_count &&
+         first.is_rest_length == second.is_rest_length;
 }
 
-const Operator* SimplifiedOperatorBuilder::NewRestParameterElements(
-    int parameter_count) {
-  return new (zone()) Operator1<int>(       // --
-      IrOpcode::kNewRestParameterElements,  // opcode
-      Operator::kEliminatable,              // flags
-      "NewRestParameterElements",           // name
-      0, 1, 0, 1, 1, 0,                     // counts
-      parameter_count);                     // parameter
+size_t hash_value(ArgumentsLengthParameters param) {
+  return base::hash_combine(param.formal_parameter_count, param.is_rest_length);
+}
+
+std::ostream& operator<<(std::ostream& os, ArgumentsLengthParameters param) {
+  return os << param.formal_parameter_count << ", "
+            << (param.is_rest_length ? "rest length" : "not rest length");
+}
+
+}  // namespace
+
+const Operator* SimplifiedOperatorBuilder::ArgumentsLength(
+    int formal_parameter_count, bool is_rest_length) {
+  return new (zone()) Operator1<ArgumentsLengthParameters>(  // --
+      IrOpcode::kArgumentsLength,                            // opcode
+      Operator::kPure,                                       // flags
+      "ArgumentsLength",                                     // name
+      1, 0, 0, 1, 0, 0,                                      // counts
+      ArgumentsLengthParameters{formal_parameter_count,
+                                is_rest_length});  // parameter
+}
+
+int FormalParameterCountOf(const Operator* op) {
+  DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
+  return OpParameter<ArgumentsLengthParameters>(op).formal_parameter_count;
+}
+
+bool IsRestLengthOf(const Operator* op) {
+  DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
+  return OpParameter<ArgumentsLengthParameters>(op).is_rest_length;
 }
 
 const Operator* SimplifiedOperatorBuilder::Allocate(PretenureFlag pretenure) {
   switch (pretenure) {
     case NOT_TENURED:
       return &cache_.kAllocateNotTenuredOperator;
     case TENURED:
       return &cache_.kAllocateTenuredOperator;
   }
   UNREACHABLE();
@@ skipping 72 matching lines @@
                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8