Handle arguments objects in frame when materializing arguments

src/deoptimizer.h

 // Copyright 2012 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 776 matching lines @@
     TAGGED,
     INT32,
     UINT32,
     DOUBLE,
     LITERAL,
     DEFERRED_OBJECT,   // Object captured by the escape analysis.
                        // The number of nested objects can be obtained
                        // with the DeferredObjectLength() method
                        // (the SlotRefs of the nested objects follow
                        // this SlotRef in the depth-first order.)
-    DUPLICATE_OBJECT   // Duplicated object of a deferred object.
+    DUPLICATE_OBJECT,  // Duplicated object of a deferred object.
+    ARGUMENTS_OBJECT   // Arguments object - only used to keep indexing
+                       // in sync, it should not be materialized.
   };
 
   SlotRef()
       : addr_(NULL), representation_(UNKNOWN) { }
 
   SlotRef(Address addr, SlotRepresentation representation)
       : addr_(addr), representation_(representation) { }
 
   SlotRef(Isolate* isolate, Object* literal)
       : literal_(literal, isolate), representation_(LITERAL) { }
 
+  static SlotRef NewArgumentsObject(int length) {
+    SlotRef slot;
+    slot.representation_ = ARGUMENTS_OBJECT;
+    slot.deferred_object_length_ = length;
+    return slot;
+  }
+
   static SlotRef NewDeferredObject(int length) {
     SlotRef slot;
     slot.representation_ = DEFERRED_OBJECT;
     slot.deferred_object_length_ = length;
     return slot;
   }
 
   SlotRepresentation Representation() { return representation_; }
 
   static SlotRef NewDuplicateObject(int id) {
     SlotRef slot;
     slot.representation_ = DUPLICATE_OBJECT;
     slot.duplicate_object_id_ = id;
     return slot;
   }
 
-  int DeferredObjectLength() { return deferred_object_length_; }
+  int GetChildrenCount() {
+    if (representation_ == DEFERRED_OBJECT ||
+        representation_ == ARGUMENTS_OBJECT) {
+      return deferred_object_length_;
+    } else {
+      return 0;
+    }
+  }
 
   int DuplicateObjectId() { return duplicate_object_id_; }
 
   Handle<Object> GetValue(Isolate* isolate);
 
  private:
   Address addr_;
   Handle<Object> literal_;
   SlotRepresentation representation_;
   int deferred_object_length_;
@@ skipping 137 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_