[turbofan] escape analysis supports arguments object and rest elements

src/deoptimizer.h

 // 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.
 
 #ifndef V8_DEOPTIMIZER_H_
 #define V8_DEOPTIMIZER_H_
 
 #include "src/allocation.h"
 #include "src/deoptimize-reason.h"
 #include "src/macro-assembler.h"
@@ skipping 114 matching lines @@
     // kind kTagged. After handlification it is always nullptr.
     Object* raw_literal_;
     // kind is kUInt32 or kBoolBit.
     uint32_t uint32_value_;
     // kind is kInt32.
     int32_t int32_value_;
     // kind is kFloat
     Float32 float_value_;
     // kind is kDouble
     Float64 double_value_;
-    // kind is kDuplicatedObject or kArgumentsObject or kCapturedObject.
+    // kind is kDuplicatedObject or kArgumentsObject or
+    // kCapturedObject.
     MaterializedObjectInfo materialization_info_;
   };
 
   // Checked accessors for the union members.
   Object* raw_literal() const;
   int32_t int32_value() const;
   uint32_t uint32_value() const;
   Float32 float_value() const;
   Float64 double_value() const;
   int object_length() const;
@@ skipping 152 matching lines @@
 
   std::vector<TranslatedFrame>& frames() { return frames_; }
 
   TranslatedFrame* GetArgumentsInfoFromJSFrameIndex(int jsframe_index,
                                                     int* arguments_count);
 
   Isolate* isolate() { return isolate_; }
 
   void Init(Address input_frame_pointer, TranslationIterator* iterator,
             FixedArray* literal_array, RegisterValues* registers,
-            FILE* trace_file);
+            FILE* trace_file, int parameter_count);
 
  private:
   friend TranslatedValue;
 
   TranslatedFrame CreateNextTranslatedFrame(TranslationIterator* iterator,
                                             FixedArray* literal_array,
                                             Address fp,
                                             FILE* trace_file);
-  TranslatedValue CreateNextTranslatedValue(int frame_index, int value_index,
-                                            TranslationIterator* iterator,
-                                            FixedArray* literal_array,
-                                            Address fp,
-                                            RegisterValues* registers,
-                                            FILE* trace_file);
+  int CreateNextTranslatedValue(int frame_index, TranslationIterator* iterator,
+                                FixedArray* literal_array, Address fp,
+                                RegisterValues* registers, FILE* trace_file);
+  void CreateArgumentsElementsTranslatedValues(int frame_index,
+                                               Address input_frame_pointer,
+                                               bool is_rest);
 
   void UpdateFromPreviouslyMaterializedObjects();
   Handle<Object> MaterializeAt(int frame_index, int* value_index);
   Handle<Object> MaterializeObjectAt(int object_index);
   class CapturedObjectMaterializer;
   Handle<Object> MaterializeCapturedObjectAt(TranslatedValue* slot,
                                              int frame_index, int* value_index);
   bool GetAdaptedArguments(Handle<JSObject>* result, int frame_index);
 
   static uint32_t GetUInt32Slot(Address fp, int slot_index);
   static Float32 GetFloatSlot(Address fp, int slot_index);
   static Float64 GetDoubleSlot(Address fp, int slot_index);
 
   std::vector<TranslatedFrame> frames_;
   Isolate* isolate_;
   Address stack_frame_pointer_;
   bool has_adapted_arguments_;
+  int formal_parameter_count_;
 
   struct ObjectPosition {
     int frame_index_;
     int value_index_;
   };
   std::deque<ObjectPosition> object_positions_;
 };
 
 
 class OptimizedFunctionVisitor BASE_EMBEDDED {
@@ skipping 575 matching lines @@
   V(JS_FRAME)                      \
   V(INTERPRETED_FRAME)             \
   V(CONSTRUCT_STUB_FRAME)          \
   V(GETTER_STUB_FRAME)             \
   V(SETTER_STUB_FRAME)             \
   V(ARGUMENTS_ADAPTOR_FRAME)       \
   V(TAIL_CALLER_FRAME)             \
   V(COMPILED_STUB_FRAME)           \
   V(DUPLICATED_OBJECT)             \
   V(ARGUMENTS_OBJECT)              \
+  V(ARGUMENTS_ELEMENTS)            \
   V(CAPTURED_OBJECT)               \
   V(REGISTER)                      \
   V(INT32_REGISTER)                \
   V(UINT32_REGISTER)               \
   V(BOOL_REGISTER)                 \
   V(FLOAT_REGISTER)                \
   V(DOUBLE_REGISTER)               \
   V(STACK_SLOT)                    \
   V(INT32_STACK_SLOT)              \
   V(UINT32_STACK_SLOT)             \
@@ skipping 28 matching lines @@
   void BeginInterpretedFrame(BailoutId bytecode_offset, int literal_id,
                              unsigned height);
   void BeginCompiledStubFrame(int height);
   void BeginArgumentsAdaptorFrame(int literal_id, unsigned height);
   void BeginTailCallerFrame(int literal_id);
   void BeginConstructStubFrame(BailoutId bailout_id, int literal_id,
                                unsigned height);
   void BeginGetterStubFrame(int literal_id);
   void BeginSetterStubFrame(int literal_id);
   void BeginArgumentsObject(int args_length);
+  void ArgumentsElements(bool is_rest);
   void BeginCapturedObject(int length);
   void DuplicateObject(int object_index);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
   void StoreBoolRegister(Register reg);
   void StoreFloatRegister(FloatRegister reg);
   void StoreDoubleRegister(DoubleRegister reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
@@ skipping 106 matching lines @@
   std::vector<Handle<Object> > expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEOPTIMIZER_H_