[turbofan] compute arguments length in deoptimizer

src/deoptimizer.cc

 // Copyright 2013 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/deoptimizer.h"
 
 #include <memory>
 
 #include "src/accessors.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 2389 matching lines @@
 void Translation::BeginArgumentsObject(int args_length) {
   buffer_->Add(ARGUMENTS_OBJECT);
   buffer_->Add(args_length);
 }
 
 void Translation::ArgumentsElements(bool is_rest) {
   buffer_->Add(ARGUMENTS_ELEMENTS);
   buffer_->Add(is_rest);
 }
 
+void Translation::ArgumentsLength(bool is_rest) {
+  buffer_->Add(ARGUMENTS_LENGTH);
+  buffer_->Add(is_rest);
+}
+
 void Translation::BeginCapturedObject(int length) {
   buffer_->Add(CAPTURED_OBJECT);
   buffer_->Add(length);
 }
 
 
 void Translation::DuplicateObject(int object_index) {
   buffer_->Add(DUPLICATED_OBJECT);
   buffer_->Add(object_index);
 }
@@ skipping 113 matching lines @@
     case TAIL_CALLER_FRAME:
       return 1;
     case BEGIN:
     case ARGUMENTS_ADAPTOR_FRAME:
       return 2;
     case JS_FRAME:
     case INTERPRETED_FRAME:
     case CONSTRUCT_STUB_FRAME:
       return 3;
     case ARGUMENTS_ELEMENTS:
+    case ARGUMENTS_LENGTH:
       return 1;
   }
   FATAL("Unexpected translation type");
   return -1;
 }
 
 
 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
 
 const char* Translation::StringFor(Opcode opcode) {
@@ skipping 749 matching lines @@
                "  reading compiler stub frame => height=%d; inputs:\n", height);
       }
       return TranslatedFrame::CompiledStubFrame(height,
                                                 literal_array->GetIsolate());
     }
 
     case Translation::BEGIN:
     case Translation::DUPLICATED_OBJECT:
     case Translation::ARGUMENTS_OBJECT:
     case Translation::ARGUMENTS_ELEMENTS:
+    case Translation::ARGUMENTS_LENGTH:
     case Translation::CAPTURED_OBJECT:
     case Translation::REGISTER:
     case Translation::INT32_REGISTER:
     case Translation::UINT32_REGISTER:
     case Translation::BOOL_REGISTER:
     case Translation::FLOAT_REGISTER:
     case Translation::DOUBLE_REGISTER:
     case Translation::STACK_SLOT:
     case Translation::INT32_STACK_SLOT:
     case Translation::UINT32_STACK_SLOT:
@@ skipping 15 matching lines @@
   while (values_to_skip > 0) {
     // Consume the current element.
     values_to_skip--;
     // Add all the children.
     values_to_skip += (*iter)->GetChildrenCount();
 
     (*iter)++;
   }
 }
 
+Address TranslatedState::ComputeArgumentsPosition(Address input_frame_pointer,
+                                                  bool is_rest, int* length) {
+  Address parent_frame_pointer = *reinterpret_cast<Address*>(
+      input_frame_pointer + StandardFrameConstants::kCallerFPOffset);
+  intptr_t parent_frame_type = Memory::intptr_at(
+      parent_frame_pointer + CommonFrameConstants::kContextOrFrameTypeOffset);
+
+  Address arguments_frame;
+  if (parent_frame_type ==
+      StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)) {
+    if (length)
+      *length = Smi::cast(*reinterpret_cast<Object**>(
+                              parent_frame_pointer +
+                              ArgumentsAdaptorFrameConstants::kLengthOffset))
+                    ->value();
+    arguments_frame = parent_frame_pointer;
+  } else {
+    if (length) *length = formal_parameter_count_;
+    arguments_frame = input_frame_pointer;
+  }
+
+  if (is_rest) {
+    // If the actual number of arguments is less than the number of formal
+    // parameters, we have zero rest parameters.
+    if (length) *length = std::max(0, *length - formal_parameter_count_);
+  }
+
+  return arguments_frame;
+}
+
 // Creates translated values for an arguments backing store, or the backing
 // store for the rest parameters if {is_rest} is true. The TranslatedValue
 // objects for the fields are not read from the TranslationIterator, but instead
 // created on-the-fly based on dynamic information in the optimized frame.
 void TranslatedState::CreateArgumentsElementsTranslatedValues(
     int frame_index, Address input_frame_pointer, bool is_rest) {
   TranslatedFrame& frame = frames_[frame_index];
 
-  Address parent_frame_pointer = *reinterpret_cast<Address*>(
-      input_frame_pointer + StandardFrameConstants::kCallerFPOffset);
-  intptr_t parent_frame_type = Memory::intptr_at(
-      parent_frame_pointer + CommonFrameConstants::kContextOrFrameTypeOffset);
   int length;
-  Address arguments_frame;
-  if (parent_frame_type ==
-      StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR)) {
-    length = Smi::cast(*reinterpret_cast<Object**>(
-                           parent_frame_pointer +
-                           ArgumentsAdaptorFrameConstants::kLengthOffset))
-                 ->value();
-    arguments_frame = parent_frame_pointer;
-  } else {
-    length = formal_parameter_count_;
-    arguments_frame = input_frame_pointer;
-  }
-
-  if (is_rest) {
-    // If the actual number of arguments is less than the number of formal
-    // parameters, we have zero rest parameters.
-    length = std::max(0, length - formal_parameter_count_);
-  }
+  Address arguments_frame =
+      ComputeArgumentsPosition(input_frame_pointer, is_rest, &length);
 
   int object_index = static_cast<int>(object_positions_.size());
   int value_index = static_cast<int>(frame.values_.size());
   object_positions_.push_back({frame_index, value_index});
   frame.Add(TranslatedValue::NewDeferredObject(
       this, length + FixedArray::kHeaderSize / kPointerSize, object_index));
 
   frame.Add(
       TranslatedValue::NewTagged(this, isolate_->heap()->fixed_array_map()));
   frame.Add(TranslatedValue::NewInt32(this, length));
@@ skipping 64 matching lines @@
       frame.Add(translated_value);
       return translated_value.GetChildrenCount();
     }
 
     case Translation::ARGUMENTS_ELEMENTS: {
       bool is_rest = iterator->Next();
       CreateArgumentsElementsTranslatedValues(frame_index, fp, is_rest);
       return 0;
     }
 
+    case Translation::ARGUMENTS_LENGTH: {
+      bool is_rest = iterator->Next();
+      int length;
+      ComputeArgumentsPosition(fp, is_rest, &length);
+      frame.Add(TranslatedValue::NewInt32(this, length));
+      return 0;
+    }
+
     case Translation::CAPTURED_OBJECT: {
       int field_count = iterator->Next();
       int object_index = static_cast<int>(object_positions_.size());
       if (trace_file != nullptr) {
         PrintF(trace_file, "captured object #%d (length = %d)", object_index,
                field_count);
       }
       object_positions_.push_back({frame_index, value_index});
       TranslatedValue translated_value =
           TranslatedValue::NewDeferredObject(this, field_count, object_index);
@@ skipping 909 matching lines @@
       CHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8