[turbofan] escape analysis supports arguments object and rest elements

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 493 matching lines @@
 
 Code* Deoptimizer::FindOptimizedCode(JSFunction* function) {
   Code* compiled_code = FindDeoptimizingCode(from_);
   return (compiled_code == NULL)
              ? static_cast<Code*>(isolate_->FindCodeObject(from_))
              : compiled_code;
 }
 
 
 void Deoptimizer::PrintFunctionName() {
-  if (function_ != nullptr && function_->IsJSFunction()) {
+  if (function_->IsHeapObject() && function_->IsJSFunction()) {
     function_->ShortPrint(trace_scope_->file());
   } else {
     PrintF(trace_scope_->file(),
            "%s", Code::Kind2String(compiled_code_->kind()));
   }
 }
 
 
 Deoptimizer::~Deoptimizer() {
   DCHECK(input_ == NULL && output_ == NULL);
@@ skipping 176 matching lines @@
 
   BailoutId node_id = input_data->AstId(bailout_id_);
   ByteArray* translations = input_data->TranslationByteArray();
   unsigned translation_index =
       input_data->TranslationIndex(bailout_id_)->value();
 
   TranslationIterator state_iterator(translations, translation_index);
   translated_state_.Init(
       input_->GetFramePointerAddress(), &state_iterator,
       input_data->LiteralArray(), input_->GetRegisterValues(),
-      trace_scope_ == nullptr ? nullptr : trace_scope_->file());
+      trace_scope_ == nullptr ? nullptr : trace_scope_->file(),
+      function_->IsHeapObject()
+          ? function_->shared()->internal_formal_parameter_count()
+          : 0);
 
   // Do the input frame to output frame(s) translation.
   size_t count = translated_state_.frames().size();
   // If we are supposed to go to the catch handler, find the catching frame
   // for the catch and make sure we only deoptimize upto that frame.
   if (deoptimizing_throw_) {
     size_t catch_handler_frame_index = count;
     for (size_t i = count; i-- > 0;) {
       catch_handler_pc_offset_ = LookupCatchHandler(
           &(translated_state_.frames()[i]), &catch_handler_data_);
@@ skipping 1670 matching lines @@
   buffer_->Add(COMPILED_STUB_FRAME);
   buffer_->Add(height);
 }
 
 
 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::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 COMPILED_STUB_FRAME:
     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:
+      return 1;
   }
   FATAL("Unexpected translation type");
   return -1;
 }
 
 
 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
 
 const char* Translation::StringFor(Opcode opcode) {
 #define TRANSLATION_OPCODE_CASE(item)   case item: return #item;
@@ skipping 238 matching lines @@
 
 // static
 TranslatedValue TranslatedValue::NewArgumentsObject(TranslatedState* container,
                                                     int length,
                                                     int object_index) {
   TranslatedValue slot(container, kArgumentsObject);
   slot.materialization_info_ = {object_index, length};
   return slot;
 }
 
-
 // static
 TranslatedValue TranslatedValue::NewDeferredObject(TranslatedState* container,
                                                    int length,
                                                    int object_index) {
   TranslatedValue slot(container, kCapturedObject);
   slot.materialization_info_ = {object_index, length};
   return slot;
 }
 
 
@@ skipping 489 matching lines @@
         PrintF(trace_file,
                "  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::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)++;
   }
 }
 
+// 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];
 
-// We can't intermix stack decoding and allocations because
-// deoptimization infrastracture is not GC safe.
+  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_);
+  }
+
+  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));
+
+  for (int i = length - 1; i >= 0; --i) {
+    Address argument_slot = arguments_frame +
+                            CommonFrameConstants::kFixedFrameSizeAboveFp +
+                            i * kPointerSize;
+    frame.Add(TranslatedValue::NewTagged(
+        this, *reinterpret_cast<Object**>(argument_slot)));
+  }
+}
+
+// We can't intermix stack decoding and allocations because the deoptimization
+// infrastracture is not GC safe.
 // Thus we build a temporary structure in malloced space.
-TranslatedValue TranslatedState::CreateNextTranslatedValue(
-    int frame_index, int value_index, TranslationIterator* iterator,
-    FixedArray* literal_array, Address fp, RegisterValues* registers,
-    FILE* trace_file) {
+// The TranslatedValue objects created correspond to the static translation
+// instructions from the TranslationIterator, except for
+// Translation::ARGUMENTS_ELEMENTS, where the number and values of the
+// FixedArray elements depend on dynamic information from the optimized frame.
+// Returns the number of expected nested translations from the
+// TranslationIterator.
+int TranslatedState::CreateNextTranslatedValue(
+    int frame_index, TranslationIterator* iterator, FixedArray* literal_array,
+    Address fp, RegisterValues* registers, FILE* trace_file) {
   disasm::NameConverter converter;
 
+  TranslatedFrame& frame = frames_[frame_index];
+  int value_index = static_cast<int>(frame.values_.size());
+
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::JS_FRAME:
     case Translation::INTERPRETED_FRAME:
     case Translation::ARGUMENTS_ADAPTOR_FRAME:
     case Translation::TAIL_CALLER_FRAME:
     case Translation::CONSTRUCT_STUB_FRAME:
     case Translation::GETTER_STUB_FRAME:
     case Translation::SETTER_STUB_FRAME:
     case Translation::COMPILED_STUB_FRAME:
       // Peeled off before getting here.
       break;
 
     case Translation::DUPLICATED_OBJECT: {
       int object_id = iterator->Next();
       if (trace_file != nullptr) {
         PrintF(trace_file, "duplicated object #%d", object_id);
       }
       object_positions_.push_back(object_positions_[object_id]);
-      return TranslatedValue::NewDuplicateObject(this, object_id);
+      TranslatedValue translated_value =
+          TranslatedValue::NewDuplicateObject(this, object_id);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::ARGUMENTS_OBJECT: {
       int arg_count = iterator->Next();
       int object_index = static_cast<int>(object_positions_.size());
       if (trace_file != nullptr) {
-        PrintF(trace_file, "argumets object #%d (length = %d)", object_index,
+        PrintF(trace_file, "arguments object #%d (length = %d)", object_index,
                arg_count);
       }
       object_positions_.push_back({frame_index, value_index});
-      return TranslatedValue::NewArgumentsObject(this, arg_count, object_index);
+      TranslatedValue translated_value =
+          TranslatedValue::NewArgumentsObject(this, arg_count, object_index);
+      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::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});
-      return TranslatedValue::NewDeferredObject(this, field_count,
-                                                object_index);
+      TranslatedValue translated_value =
+          TranslatedValue::NewDeferredObject(this, field_count, object_index);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; %s ", value,
                converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
-      return TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
+      TranslatedValue translated_value =
+          TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::INT32_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIdPTR " ; %s ", value,
                converter.NameOfCPURegister(input_reg));
       }
-      return TranslatedValue::NewInt32(this, static_cast<int32_t>(value));
+      TranslatedValue translated_value =
+          TranslatedValue::NewInt32(this, static_cast<int32_t>(value));
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::UINT32_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIuPTR " ; %s (uint)", value,
                converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
-      return TranslatedValue::NewUInt32(this, static_cast<uint32_t>(value));
+      TranslatedValue translated_value =
+          TranslatedValue::NewUInt32(this, static_cast<uint32_t>(value));
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::BOOL_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       intptr_t value = registers->GetRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%" V8PRIdPTR " ; %s (bool)", value,
                converter.NameOfCPURegister(input_reg));
       }
-      return TranslatedValue::NewBool(this, static_cast<uint32_t>(value));
+      TranslatedValue translated_value =
+          TranslatedValue::NewBool(this, static_cast<uint32_t>(value));
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::FLOAT_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       Float32 value = registers->GetFloatRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; %s (float)", value.get_scalar(),
                RegisterConfiguration::Crankshaft()->GetFloatRegisterName(
                    input_reg));
       }
-      return TranslatedValue::NewFloat(this, value);
+      TranslatedValue translated_value = TranslatedValue::NewFloat(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::DOUBLE_REGISTER: {
       int input_reg = iterator->Next();
-      if (registers == nullptr) return TranslatedValue::NewInvalid(this);
+      if (registers == nullptr) {
+        TranslatedValue translated_value = TranslatedValue::NewInvalid(this);
+        frame.Add(translated_value);
+        return translated_value.GetChildrenCount();
+      }
       Float64 value = registers->GetDoubleRegister(input_reg);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; %s (double)", value.get_scalar(),
                RegisterConfiguration::Crankshaft()->GetDoubleRegisterName(
                    input_reg));
       }
-      return TranslatedValue::NewDouble(this, value);
+      TranslatedValue translated_value =
+          TranslatedValue::NewDouble(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       intptr_t value = *(reinterpret_cast<intptr_t*>(fp + slot_offset));
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
-      return TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
+      TranslatedValue translated_value =
+          TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::INT32_STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%d ; (int) [fp %c %d] ",
                static_cast<int32_t>(value), slot_offset < 0 ? '-' : '+',
                std::abs(slot_offset));
       }
-      return TranslatedValue::NewInt32(this, value);
+      TranslatedValue translated_value = TranslatedValue::NewInt32(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::UINT32_STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%u ; (uint) [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
-      return TranslatedValue::NewUInt32(this, value);
+      TranslatedValue translated_value =
+          TranslatedValue::NewUInt32(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::BOOL_STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       uint32_t value = GetUInt32Slot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%u ; (bool) [fp %c %d] ", value,
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
-      return TranslatedValue::NewBool(this, value);
+      TranslatedValue translated_value = TranslatedValue::NewBool(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::FLOAT_STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       Float32 value = GetFloatSlot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; (float) [fp %c %d] ", value.get_scalar(),
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
-      return TranslatedValue::NewFloat(this, value);
+      TranslatedValue translated_value = TranslatedValue::NewFloat(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::DOUBLE_STACK_SLOT: {
       int slot_offset =
           OptimizedFrame::StackSlotOffsetRelativeToFp(iterator->Next());
       Float64 value = GetDoubleSlot(fp, slot_offset);
       if (trace_file != nullptr) {
         PrintF(trace_file, "%e ; (double) [fp %c %d] ", value.get_scalar(),
                slot_offset < 0 ? '-' : '+', std::abs(slot_offset));
       }
-      return TranslatedValue::NewDouble(this, value);
+      TranslatedValue translated_value =
+          TranslatedValue::NewDouble(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
 
     case Translation::LITERAL: {
       int literal_index = iterator->Next();
       Object* value = literal_array->get(literal_index);
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; (literal %d) ",
                reinterpret_cast<intptr_t>(value), literal_index);
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
 
-      return TranslatedValue::NewTagged(this, value);
+      TranslatedValue translated_value =
+          TranslatedValue::NewTagged(this, value);
+      frame.Add(translated_value);
+      return translated_value.GetChildrenCount();
     }
   }
 
   FATAL("We should never get here - unexpected deopt info.");
-  return TranslatedValue(nullptr, TranslatedValue::kInvalid);
+  TranslatedValue translated_value =
+      TranslatedValue(nullptr, TranslatedValue::kInvalid);
+  frame.Add(translated_value);
+  return translated_value.GetChildrenCount();
 }
 
 
 TranslatedState::TranslatedState(JavaScriptFrame* frame)
     : isolate_(nullptr),
       stack_frame_pointer_(nullptr),
       has_adapted_arguments_(false) {
   int deopt_index = Safepoint::kNoDeoptimizationIndex;
   DeoptimizationInputData* data =
       static_cast<OptimizedFrame*>(frame)->GetDeoptimizationData(&deopt_index);
   DCHECK(data != nullptr && deopt_index != Safepoint::kNoDeoptimizationIndex);
   TranslationIterator it(data->TranslationByteArray(),
                          data->TranslationIndex(deopt_index)->value());
   Init(frame->fp(), &it, data->LiteralArray(), nullptr /* registers */,
-       nullptr /* trace file */);
+       nullptr /* trace file */,
+       frame->function()->shared()->internal_formal_parameter_count());
 }
 
 
 TranslatedState::TranslatedState()
     : isolate_(nullptr),
       stack_frame_pointer_(nullptr),
       has_adapted_arguments_(false) {}
 
-
 void TranslatedState::Init(Address input_frame_pointer,
                            TranslationIterator* iterator,
                            FixedArray* literal_array, RegisterValues* registers,
-                           FILE* trace_file) {
+                           FILE* trace_file, int formal_parameter_count) {
   DCHECK(frames_.empty());
 
+  formal_parameter_count_ = formal_parameter_count;
+
   isolate_ = literal_array->GetIsolate();
   // Read out the 'header' translation.
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
   CHECK(opcode == Translation::BEGIN);
 
   int count = iterator->Next();
   iterator->Next();  // Drop JS frames count.
 
   frames_.reserve(count);
 
   std::stack<int> nested_counts;
 
   // Read the frames
-  for (int i = 0; i < count; i++) {
+  for (int frame_index = 0; frame_index < count; frame_index++) {
     // Read the frame descriptor.
     frames_.push_back(CreateNextTranslatedFrame(
         iterator, literal_array, input_frame_pointer, trace_file));
     TranslatedFrame& frame = frames_.back();
 
     // Read the values.
     int values_to_process = frame.GetValueCount();
     while (values_to_process > 0 || !nested_counts.empty()) {
       if (trace_file != nullptr) {
         if (nested_counts.empty()) {
           // For top level values, print the value number.
           PrintF(trace_file, "    %3i: ",
                  frame.GetValueCount() - values_to_process);
         } else {
           // Take care of indenting for nested values.
           PrintF(trace_file, "         ");
           for (size_t j = 0; j < nested_counts.size(); j++) {
             PrintF(trace_file, "  ");
           }
         }
       }
 
-      TranslatedValue value = CreateNextTranslatedValue(
-          i, static_cast<int>(frame.values_.size()), iterator, literal_array,
-          input_frame_pointer, registers, trace_file);
-      frame.Add(value);
+      int nested_count =
+          CreateNextTranslatedValue(frame_index, iterator, literal_array,
+                                    input_frame_pointer, registers, trace_file);
 
       if (trace_file != nullptr) {
         PrintF(trace_file, "\n");
       }
 
       // Update the value count and resolve the nesting.
       values_to_process--;
-      int children_count = value.GetChildrenCount();
-      if (children_count > 0) {
+      if (nested_count > 0) {
         nested_counts.push(values_to_process);
-        values_to_process = children_count;
+        values_to_process = nested_count;
       } else {
         while (values_to_process == 0 && !nested_counts.empty()) {
           values_to_process = nested_counts.top();
           nested_counts.pop();
         }
       }
     }
   }
 
   CHECK(!iterator->HasNext() ||
@@ skipping 598 matching lines @@
       CHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8