Revert "Captured arguments object materialization"

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 417 matching lines @@
   // Array of output frame descriptions.
   FrameDescription** output_;
 
   // Deferred values to be materialized.
   List<Object*> deferred_objects_tagged_values_;
   List<HeapNumberMaterializationDescriptor<int> >
       deferred_objects_double_values_;
   List<ObjectMaterializationDescriptor> deferred_objects_;
   List<HeapNumberMaterializationDescriptor<Address> > deferred_heap_numbers_;
 
-  // Key for lookup of previously materialized objects
-  Address stack_fp_;
-  Handle<FixedArray> previously_materialized_objects_;
-  int prev_materialized_count_;
-
   // Output frame information. Only used during heap object materialization.
   List<Handle<JSFunction> > jsframe_functions_;
   List<bool> jsframe_has_adapted_arguments_;
 
   // Materialized objects. Only used during heap object materialization.
   List<Handle<Object> >* materialized_values_;
   List<Handle<Object> >* materialized_objects_;
   int materialization_value_index_;
   int materialization_object_index_;
 
@@ skipping 328 matching lines @@
 
 
 class SlotRef BASE_EMBEDDED {
  public:
   enum SlotRepresentation {
     UNKNOWN,
     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.
+    LITERAL
   };
 
   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 NewDeferredObject(int length) {
-    SlotRef slot;
-    slot.representation_ = DEFERRED_OBJECT;
-    slot.deferred_object_length_ = length;
-    return slot;
+  Handle<Object> GetValue(Isolate* isolate) {
+    switch (representation_) {
+      case TAGGED:
+        return Handle<Object>(Memory::Object_at(addr_), isolate);
+
+      case INT32: {
+        int value = Memory::int32_at(addr_);
+        if (Smi::IsValid(value)) {
+          return Handle<Object>(Smi::FromInt(value), isolate);
+        } else {
+          return isolate->factory()->NewNumberFromInt(value);
+        }
+      }
+
+      case UINT32: {
+        uint32_t value = Memory::uint32_at(addr_);
+        if (value <= static_cast<uint32_t>(Smi::kMaxValue)) {
+          return Handle<Object>(Smi::FromInt(static_cast<int>(value)), isolate);
+        } else {
+          return isolate->factory()->NewNumber(static_cast<double>(value));
+        }
+      }
+
+      case DOUBLE: {
+        double value = read_double_value(addr_);
+        return isolate->factory()->NewNumber(value);
+      }
+
+      case LITERAL:
+        return literal_;
+
+      default:
+        UNREACHABLE();
+        return Handle<Object>::null();
+    }
   }
 
-  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 DuplicateObjectId() { return duplicate_object_id_; }
-
-  Handle<Object> GetValue(Isolate* isolate);
+  static Vector<SlotRef> ComputeSlotMappingForArguments(
+      JavaScriptFrame* frame,
+      int inlined_frame_index,
+      int formal_parameter_count);
 
  private:
   Address addr_;
   Handle<Object> literal_;
   SlotRepresentation representation_;
-  int deferred_object_length_;
-  int duplicate_object_id_;
-};
-
-class SlotRefValueBuilder BASE_EMBEDDED {
- public:
-  SlotRefValueBuilder(
-      JavaScriptFrame* frame,
-      int inlined_frame_index,
-      int formal_parameter_count);
-
-  void Prepare(Isolate* isolate);
-  Handle<Object> GetNext(Isolate* isolate, int level);
-  void Finish(Isolate* isolate);
-
-  int args_length() { return args_length_; }
-
- private:
-  List<Handle<Object> > materialized_objects_;
-  Handle<FixedArray> previously_materialized_objects_;
-  int prev_materialized_count_;
-  Address stack_frame_id_;
-  List<SlotRef> slot_refs_;
-  int current_slot_;
-  int args_length_;
-  int first_slot_index_;
-
-  static SlotRef ComputeSlotForNextArgument(
-      Translation::Opcode opcode,
-      TranslationIterator* iterator,
-      DeoptimizationInputData* data,
-      JavaScriptFrame* frame);
-
-  Handle<Object> GetPreviouslyMaterialized(Isolate* isolate, int length);
 
   static Address SlotAddress(JavaScriptFrame* frame, int slot_index) {
     if (slot_index >= 0) {
       const int offset = JavaScriptFrameConstants::kLocal0Offset;
       return frame->fp() + offset - (slot_index * kPointerSize);
     } else {
       const int offset = JavaScriptFrameConstants::kLastParameterOffset;
       return frame->fp() + offset - ((slot_index + 1) * kPointerSize);
     }
   }
 
-  Handle<Object> GetDeferredObject(Isolate* isolate);
-};
+  static SlotRef ComputeSlotForNextArgument(TranslationIterator* iterator,
+                                            DeoptimizationInputData* data,
+                                            JavaScriptFrame* frame);
 
-class MaterializedObjectStore {
- public:
-  explicit MaterializedObjectStore(Isolate* isolate) : isolate_(isolate) {
-  }
-
-  Handle<FixedArray> Get(Address fp);
-  void Set(Address fp, Handle<FixedArray> materialized_objects);
-  void Remove(Address fp);
-
- private:
-  Isolate* isolate() { return isolate_; }
-  Handle<FixedArray> GetStackEntries();
-  Handle<FixedArray> EnsureStackEntries(int size);
-
-  int StackIdToIndex(Address fp);
-
-  Isolate* isolate_;
-  List<Address> frame_fps_;
+  static void ComputeSlotsForArguments(
+      Vector<SlotRef>* args_slots,
+      TranslationIterator* iterator,
+      DeoptimizationInputData* data,
+      JavaScriptFrame* frame);
 };
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 // Class used to represent an unoptimized frame when the debugger
 // needs to inspect a frame that is part of an optimized frame. The
 // internally used FrameDescription objects are not GC safe so for use
 // by the debugger frame information is copied to an object of this type.
 // Represents parameters in unadapted form so their number might mismatch
 // formal parameter count.
@@ skipping 62 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_