Handle arguments objects in frame when materializing arguments

src/deoptimizer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2980 matching lines @@
     case Translation::GETTER_STUB_FRAME:
     case Translation::SETTER_STUB_FRAME:
       // Peeled off before getting here.
       break;
 
     case Translation::DUPLICATED_OBJECT: {
       return SlotRef::NewDuplicateObject(iterator->Next());
     }
 
     case Translation::ARGUMENTS_OBJECT:
-      // This can be only emitted for local slots not for argument slots.
-      break;
+      return SlotRef::NewArgumentsObject(iterator->Next());
 
     case Translation::CAPTURED_OBJECT: {
       return SlotRef::NewDeferredObject(iterator->Next());
     }
 
     case Translation::REGISTER:
     case Translation::INT32_REGISTER:
     case Translation::UINT32_REGISTER:
     case Translation::DOUBLE_REGISTER:
       // We are at safepoint which corresponds to call.  All registers are
@@ skipping 29 matching lines @@
       int literal_index = iterator->Next();
       return SlotRef(data->GetIsolate(),
                      data->LiteralArray()->get(literal_index));
     }
 
     case Translation::COMPILED_STUB_FRAME:
       UNREACHABLE();
       break;
   }
 
-  UNREACHABLE();
+  CHECK(false);  // We should never get here

[Michael Starzinger, 2014/02/27 14:37:40]

nit: Let's use FATAL() with a short message instead.

   return SlotRef();
 }
 
 
 SlotRefValueBuilder::SlotRefValueBuilder(JavaScriptFrame* frame,
                                          int inlined_jsframe_index,
                                          int formal_parameter_count)
     : current_slot_(0), args_length_(-1), first_slot_index_(-1) {
   DisallowHeapAllocation no_gc;
 
@@ skipping 59 matching lines @@
                opcode != Translation::GETTER_STUB_FRAME &&
                opcode != Translation::SETTER_STUB_FRAME &&
                opcode != Translation::COMPILED_STUB_FRAME) {
       slot_refs_.Add(ComputeSlotForNextArgument(opcode, &it, data, frame));
 
       if (first_slot_index_ >= 0) {
         // We have found the beginning of our frame -> make sure we count
         // the nested slots of captured objects
         number_of_slots--;
         SlotRef& slot = slot_refs_.last();
-        if (slot.Representation() == SlotRef::DEFERRED_OBJECT) {
-          number_of_slots += slot.DeferredObjectLength();
-        }
+        ASSERT(slot.Representation() != SlotRef::ARGUMENTS_OBJECT);
+        number_of_slots += slot.GetChildrenCount();
         if (slot.Representation() == SlotRef::DEFERRED_OBJECT ||
             slot.Representation() == SlotRef::DUPLICATE_OBJECT) {
           should_deopt = true;
         }
       }
 
       processed = true;
     }
     if (!processed) {
       // Skip over operands to advance to the next opcode.
@@ skipping 33 matching lines @@
 
     case DOUBLE: {
       double value = read_double_value(addr_);
       return isolate->factory()->NewNumber(value);
     }
 
     case LITERAL:
       return literal_;
 
     default:
-      UNREACHABLE();
+      CHECK(false);  // We should never get here

[Michael Starzinger, 2014/02/27 14:37:40]

nit: Likewise.

       return Handle<Object>::null();
   }
 }
 
 
 void SlotRefValueBuilder::Prepare(Isolate* isolate) {
   MaterializedObjectStore* materialized_store =
       isolate->materialized_object_store();
   previously_materialized_objects_ = materialized_store->Get(stack_frame_id_);
   prev_materialized_count_ = previously_materialized_objects_.is_null()
       ? 0 : previously_materialized_objects_->length();
 
   // Skip any materialized objects of the inlined "parent" frames.
   // (Note that we still need to materialize them because they might be
   // referred to as duplicated objects.)
   while (current_slot_ < first_slot_index_) {
     GetNext(isolate, 0);
   }
   ASSERT(current_slot_ == first_slot_index_);
 }
 
 
 Handle<Object> SlotRefValueBuilder::GetPreviouslyMaterialized(
     Isolate* isolate, int length) {
   int object_index = materialized_objects_.length();
   Handle<Object> return_value = Handle<Object>(
       previously_materialized_objects_->get(object_index), isolate);
   materialized_objects_.Add(return_value);
 
-  // Now need to skip all nested objects (and possibly read them from
-  // the materialization store, too)
+  // Now need to skip all the nested objects (and possibly read them from
+  // the materialization store, too).
   for (int i = 0; i < length; i++) {
     SlotRef& slot = slot_refs_[current_slot_];
     current_slot_++;
 
-    // For nested deferred objects, we need to read its properties
-    if (slot.Representation() == SlotRef::DEFERRED_OBJECT) {
-      length += slot.DeferredObjectLength();
-    }
+    // We need to read all the nested objects - add them to the
+    // number of objects we need to process.
+    length += slot.GetChildrenCount();
 
-    // For nested deferred and duplicate objects, we need to put them into
-    // our materialization array
+    // Put the nested deferred/duplicate objects into our materialization
+    // array.
     if (slot.Representation() == SlotRef::DEFERRED_OBJECT ||
         slot.Representation() == SlotRef::DUPLICATE_OBJECT) {
       int nested_object_index = materialized_objects_.length();
       Handle<Object> nested_object = Handle<Object>(
           previously_materialized_objects_->get(nested_object_index),
           isolate);
       materialized_objects_.Add(nested_object);
     }
   }
 
   return return_value;
 }
 
 
 Handle<Object> SlotRefValueBuilder::GetNext(Isolate* isolate, int lvl) {
   SlotRef& slot = slot_refs_[current_slot_];
   current_slot_++;
   switch (slot.Representation()) {
     case SlotRef::TAGGED:
     case SlotRef::INT32:
     case SlotRef::UINT32:
     case SlotRef::DOUBLE:
     case SlotRef::LITERAL: {
       return slot.GetValue(isolate);
     }
+    case SlotRef::ARGUMENTS_OBJECT: {
+      // We should never need to materialize an arguments object,
+      // but we still need to put something into the array
+      // so that the indexing is consistent.
+      Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);

[Michael Starzinger, 2014/02/27 14:37:40]

nit: Use isolate->factory()->undefined_value() instead of a new handle.

+      materialized_objects_.Add(undefined);
+      int length = slot.GetChildrenCount();
+      for (int i = 0; i < length; ++i) {
+        // We don't need the argument, just ignore it
+        GetNext(isolate, lvl + 1);
+      }
+      return undefined;
+    }
     case SlotRef::DEFERRED_OBJECT: {
-      int length = slot.DeferredObjectLength();
+      int length = slot.GetChildrenCount();
       ASSERT(slot_refs_[current_slot_].Representation() == SlotRef::LITERAL ||
              slot_refs_[current_slot_].Representation() == SlotRef::TAGGED);
 
       int object_index = materialized_objects_.length();
       if (object_index <  prev_materialized_count_) {
         return GetPreviouslyMaterialized(isolate, length);
       }
 
       Handle<Object> map_object = slot_refs_[current_slot_].GetValue(isolate);
       Handle<Map> map = Map::GeneralizeAllFieldRepresentations(
@@ skipping 48 matching lines @@
       int object_index = slot.DuplicateObjectId();
       Handle<Object> object = materialized_objects_[object_index];
       materialized_objects_.Add(object);
       return object;
     }
     default:
       UNREACHABLE();
       break;
   }
 
-  UNREACHABLE();
+  CHECK(false);  // We should never get here

[Michael Starzinger, 2014/02/27 14:37:40]

nit: Likewise.

   return Handle<Object>::null();
 }
 
 
 void SlotRefValueBuilder::Finish(Isolate* isolate) {
   // We should have processed all slot
   ASSERT(slot_refs_.length() == current_slot_);
 
   if (materialized_objects_.length() > prev_materialized_count_) {
     // We have materialized some new objects, so we have to store them
@@ skipping 126 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal