Handlify DeoptimizedFrameInfo, remove custom GC iteration.

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 "src/accessors.h"
 #include "src/ast/prettyprinter.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
@@ skipping 18 matching lines @@
                                   NOT_EXECUTABLE,
 #else
                                   EXECUTABLE,
 #endif
                                   NULL);
 }
 
 
 DeoptimizerData::DeoptimizerData(MemoryAllocator* allocator)
     : allocator_(allocator),
-      deoptimized_frame_info_(NULL),
       current_(NULL) {
   for (int i = 0; i < Deoptimizer::kBailoutTypesWithCodeEntry; ++i) {
     deopt_entry_code_entries_[i] = -1;
     deopt_entry_code_[i] = AllocateCodeChunk(allocator);
   }
 }
 
 
 DeoptimizerData::~DeoptimizerData() {
   for (int i = 0; i < Deoptimizer::kBailoutTypesWithCodeEntry; ++i) {
     allocator_->Free(deopt_entry_code_[i]);
     deopt_entry_code_[i] = NULL;
   }
 }
 
 
-void DeoptimizerData::Iterate(ObjectVisitor* v) {
-  if (deoptimized_frame_info_ != NULL) {
-    deoptimized_frame_info_->Iterate(v);
-  }
-}
-
-
 Code* Deoptimizer::FindDeoptimizingCode(Address addr) {
   if (function_->IsHeapObject()) {
     // Search all deoptimizing code in the native context of the function.
     Context* native_context = function_->context()->native_context();
     Object* element = native_context->DeoptimizedCodeListHead();
     while (!element->IsUndefined()) {
       Code* code = Code::cast(element);
       CHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
       if (code->contains(addr)) return code;
       element = code->next_code_link();
@@ skipping 61 matching lines @@
 
   return frame_index - 1;
 }
 
 
 DeoptimizedFrameInfo* Deoptimizer::DebuggerInspectableFrame(
     JavaScriptFrame* frame,
     int jsframe_index,
     Isolate* isolate) {
   CHECK(frame->is_optimized());
-  CHECK(isolate->deoptimizer_data()->deoptimized_frame_info_ == NULL);
 
   // Get the function and code from the frame.
   JSFunction* function = frame->function();
   Code* code = frame->LookupCode();
 
   // Locate the deoptimization point in the code. As we are at a call the
   // return address must be at a place in the code with deoptimization support.
   SafepointEntry safepoint_entry = code->GetSafepointEntry(frame->pc());
   int deoptimization_index = safepoint_entry.deoptimization_index();
   CHECK_NE(deoptimization_index, Safepoint::kNoDeoptimizationIndex);
@@ skipping 35 matching lines @@
   int construct_offset = has_arguments_adaptor ? 2 : 1;
   bool has_construct_stub =
       frame_index >= construct_offset &&
       deoptimizer->output_[frame_index - construct_offset]->GetFrameType() ==
       StackFrame::CONSTRUCT;
 
   DeoptimizedFrameInfo* info = new DeoptimizedFrameInfo(deoptimizer,
                                                         frame_index,
                                                         has_arguments_adaptor,
                                                         has_construct_stub);
-  isolate->deoptimizer_data()->deoptimized_frame_info_ = info;
 
   // Done with the GC-unsafe frame descriptions. This re-enables allocation.
   deoptimizer->DeleteFrameDescriptions();
 
   // Allocate a heap number for the doubles belonging to this frame.
   deoptimizer->MaterializeHeapNumbersForDebuggerInspectableFrame(
       frame_index, info->parameters_count(), info->expression_count(), info);
 
   // Finished using the deoptimizer instance.
   delete deoptimizer;
 
   return info;
 }
 
 
 void Deoptimizer::DeleteDebuggerInspectableFrame(DeoptimizedFrameInfo* info,
                                                  Isolate* isolate) {
-  CHECK_EQ(isolate->deoptimizer_data()->deoptimized_frame_info_, info);
   delete info;
-  isolate->deoptimizer_data()->deoptimized_frame_info_ = NULL;
 }
 
 
 void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
                                                 int count,
                                                 BailoutType type) {
   TableEntryGenerator generator(masm, type, count);
   generator.Generate();
 }
 
@@ skipping 1682 matching lines @@
     }
   } else {
     CHECK_EQ(frame_arg_count, parameter_count);
   }
 
   TranslatedFrame::iterator arg_iter = argument_frame->begin();
   arg_iter++;  // Skip the function.
   arg_iter++;  // Skip the receiver.
   for (int i = 0; i < parameter_count; i++, arg_iter++) {
     if (!arg_iter->IsMaterializedObject()) {
-      info->SetParameter(i, *(arg_iter->GetValue()));
+      info->SetParameter(i, arg_iter->GetValue());
     }
   }
 
   TranslatedFrame::iterator iter = frame->begin();
   // Skip the function, receiver, context and arguments.
   for (int i = 0; i < frame_arg_count + 3; i++, iter++) {
   }
 
   for (int i = 0; i < expression_count; i++, iter++) {
     if (!iter->IsMaterializedObject()) {
-      info->SetExpression(i, *(iter->GetValue()));
+      info->SetExpression(i, iter->GetValue());
     }
   }
 }
 
 
 void Deoptimizer::WriteTranslatedValueToOutput(
     TranslatedFrame::iterator* iterator, int* input_index, int frame_index,
     unsigned output_offset, const char* debug_hint_string,
     Address output_address_for_materialization) {
   Object* value = (*iterator)->GetRawValue();
@@ skipping 556 matching lines @@
   isolate()->heap()->SetRootMaterializedObjects(*new_array);
   return new_array;
 }
 
 
 DeoptimizedFrameInfo::DeoptimizedFrameInfo(Deoptimizer* deoptimizer,
                                            int frame_index,
                                            bool has_arguments_adaptor,
                                            bool has_construct_stub) {
   FrameDescription* output_frame = deoptimizer->output_[frame_index];
-  function_ = output_frame->GetFunction();
-  context_ = reinterpret_cast<Object*>(output_frame->GetContext());
+  function_ =
+      Handle<JSFunction>(output_frame->GetFunction(), deoptimizer->isolate());
+  context_ =
+      Handle<Object>(reinterpret_cast<Object*>(output_frame->GetContext()),
+                     deoptimizer->isolate());
   has_construct_stub_ = has_construct_stub;
-  expression_count_ = output_frame->GetExpressionCount();
-  expression_stack_ = new Object* [expression_count_];
+  expression_stack_.resize(
+      static_cast<size_t>(output_frame->GetExpressionCount()));
   // Get the source position using the unoptimized code.
   Address pc = reinterpret_cast<Address>(output_frame->GetPc());
   Code* code = Code::cast(deoptimizer->isolate()->FindCodeObject(pc));
   int offset = static_cast<int>(pc - code->instruction_start());
   source_position_ = code->SourcePosition(offset);
 
-  for (int i = 0; i < expression_count_; i++) {
+  for (int i = 0; i < static_cast<int>(expression_count()); i++) {
     Object* value = output_frame->GetExpression(i);
     // Replace materialization markers with the undefined value.
     if (value == deoptimizer->isolate()->heap()->arguments_marker()) {
       value = deoptimizer->isolate()->heap()->undefined_value();
     }
-    SetExpression(i, value);
+    SetExpression(i, Handle<Object>(value, deoptimizer->isolate()));
   }
 
   if (has_arguments_adaptor) {
     output_frame = deoptimizer->output_[frame_index - 1];
     CHECK_EQ(output_frame->GetFrameType(), StackFrame::ARGUMENTS_ADAPTOR);
   }
 
-  parameters_count_ = output_frame->ComputeParametersCount();
-  parameters_ = new Object* [parameters_count_];
-  for (int i = 0; i < parameters_count_; i++) {
+  parameters_.resize(
+      static_cast<size_t>(output_frame->ComputeParametersCount()));
+  for (int i = 0; i < output_frame->ComputeParametersCount(); i++) {
     Object* value = output_frame->GetParameter(i);
     // Replace materialization markers with the undefined value.
     if (value == deoptimizer->isolate()->heap()->arguments_marker()) {
       value = deoptimizer->isolate()->heap()->undefined_value();
     }
-    SetParameter(i, value);
+    SetParameter(i, Handle<Object>(value, deoptimizer->isolate()));
   }
 }
 
 
-DeoptimizedFrameInfo::~DeoptimizedFrameInfo() {
-  delete[] expression_stack_;
-  delete[] parameters_;
-}
-
-
-void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
-  v->VisitPointer(bit_cast<Object**>(&function_));
-  v->VisitPointer(&context_);
-  v->VisitPointers(parameters_, parameters_ + parameters_count_);
-  v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
-}
-
-
 const char* Deoptimizer::GetDeoptReason(DeoptReason deopt_reason) {
   DCHECK(deopt_reason < kLastDeoptReason);
 #define DEOPT_MESSAGES_TEXTS(C, T) T,
   static const char* deopt_messages_[] = {
       DEOPT_MESSAGES_LIST(DEOPT_MESSAGES_TEXTS)};
 #undef DEOPT_MESSAGES_TEXTS
   return deopt_messages_[deopt_reason];
 }
 
 
@@ skipping 1135 matching lines @@
       DCHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8