Revert of Unify reading of deoptimization information.

src/accessors.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/contexts.h"
 #include "src/deoptimizer.h"
@@ skipping 1098 matching lines @@
 // Accessors::FunctionArguments
 //
 
 
 static Handle<Object> ArgumentsForInlinedFunction(
     JavaScriptFrame* frame,
     Handle<JSFunction> inlined_function,
     int inlined_frame_index) {
   Isolate* isolate = inlined_function->GetIsolate();
   Factory* factory = isolate->factory();
+  SlotRefValueBuilder slot_refs(
+      frame, inlined_frame_index,
+      inlined_function->shared()->internal_formal_parameter_count());
 
-  TranslatedState translated_values(frame);
-  translated_values.Prepare(false, frame->fp());
-
-  int argument_count = 0;
-  TranslatedFrame* translated_frame =
-      translated_values.GetArgumentsInfoFromJSFrameIndex(inlined_frame_index,
-                                                         &argument_count);
-  TranslatedFrame::iterator iter = translated_frame->begin();
-
-  // Skip the receiver.
-  iter++;
-  argument_count--;
-
+  int args_count = slot_refs.args_length();
   Handle<JSObject> arguments =
-      factory->NewArgumentsObject(inlined_function, argument_count);
-  Handle<FixedArray> array = factory->NewFixedArray(argument_count);
-  bool should_deoptimize = false;
-  for (int i = 0; i < argument_count; ++i) {
-    // If we materialize any object, we should deopt because we might alias
-    // an object that was eliminated by escape analysis.
-    should_deoptimize = should_deoptimize || iter->IsMaterializedObject();
-    Handle<Object> value = iter->GetValue();
+      factory->NewArgumentsObject(inlined_function, args_count);
+  Handle<FixedArray> array = factory->NewFixedArray(args_count);
+  slot_refs.Prepare(isolate);
+  for (int i = 0; i < args_count; ++i) {
+    Handle<Object> value = slot_refs.GetNext(isolate, 0);
     array->set(i, *value);
-    iter++;
   }
+  slot_refs.Finish(isolate);
   arguments->set_elements(*array);
 
-  if (should_deoptimize) {
-    translated_values.StoreMaterializedValuesAndDeopt();
-  }
-
   // Return the freshly allocated arguments object.
   return arguments;
 }
 
 
 static int FindFunctionInFrame(JavaScriptFrame* frame,
                                Handle<JSFunction> function) {
   DisallowHeapAllocation no_allocation;
   List<JSFunction*> functions(2);
   frame->GetFunctions(&functions);
@@ skipping 308 matching lines @@
   Handle<Object> getter = v8::FromCData(isolate, &ModuleGetExport);
   Handle<Object> setter = v8::FromCData(isolate, &ModuleSetExport);
   info->set_getter(*getter);
   if (!(attributes & ReadOnly)) info->set_setter(*setter);
   return info;
 }
 
 
 }  // namespace internal
 }  // namespace v8