[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 690 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_ ? 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 1672 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(int skip) {
+  buffer_->Add(ARGUMENTS_ELEMENTS);
+  buffer_->Add(skip);
+}
 
 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)++;
   }
 }
 
+void TranslatedState::CreateArgumentsElementsTranslatedValues(
+    int frame_index, Address input_frame_pointer, int skip) {
+  CHECK(0 <= skip && skip <= formal_parameter_count_);
+  TranslatedFrame& frame = frames_[frame_index];
+
+  Address parent_frame_pointer = *reinterpret_cast<Address*>(
+      input_frame_pointer + StandardFrameConstants::kCallerFPOffset);
+  Object* parent_frame_type = *reinterpret_cast<Object**>(
+      parent_frame_pointer + CommonFrameConstants::kContextOrFrameTypeOffset);
+  int length;
+  Address arguments_frame;
+  if (parent_frame_type == Smi::FromInt(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;
+  }
+
+  length = std::max(0, length - skip);

[Jarin, 2017/02/15 16:17:15]

This needs explanation.

+
+  int object_index = static_cast<int>(object_positions_.size());
+  int value_index = static_cast<int>(frame.values_.size());
+  object_positions_.push_back({
+      frame_index,

[Jarin, 2017/02/15 16:17:15]

Missing value_index.

+  });
+  static_assert(FixedArray::kHeaderSize / kPointerSize == 2, "");
+  frame.Add(TranslatedValue::NewDeferredObject(this, length + 2, 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
 // deoptimization infrastracture is not GC safe.
 // Thus we build a temporary structure in malloced space.

[Jarin, 2017/02/15 16:17:15]

Add a line that explains what is the return value.

-TranslatedValue TranslatedState::CreateNextTranslatedValue(
-    int frame_index, int value_index, TranslationIterator* iterator,
-    FixedArray* literal_array, Address fp, RegisterValues* registers,
+int TranslatedState::CreateNextTranslatedValue(
+    int frame_index, TranslationIterator* iterator, FixedArray* literal_array,
+    Address fp, RegisterValues* registers, Address input_frame_pointer,
     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: {
+      int skip = iterator->Next();
+      CreateArgumentsElementsTranslatedValues(frame_index, input_frame_pointer,
+                                              skip);
+      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();

[Jarin, 2017/02/15 16:17:14]

The amount of boilerplate here and below is unfortunate, I am still thinking
that the approach with materializing manually later would not lead to this
inconsistent code, where all the translations are dumb, but one is actually
tricky. In any case, this needs some serious explaining why the boilerplate is
necessary.

     }
 
     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 children_count = CreateNextTranslatedValue(

[Jarin, 2017/02/15 16:17:15]

children_count -> nested_count (it is not children count anymore).

+          frame_index, iterator, literal_array, input_frame_pointer, registers,
+          input_frame_pointer, trace_file);

[Jarin, 2017/02/15 16:17:15]

Why is the frame pointer passed twice here?

 
       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) {
         nested_counts.push(values_to_process);
         values_to_process = children_count;
       } else {
         while (values_to_process == 0 && !nested_counts.empty()) {
           values_to_process = nested_counts.top();
           nested_counts.pop();
         }
       }
     }
@@ skipping 589 matching lines @@
       CHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8