Inline Array.prototype.forEach in TurboFan

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 141 matching lines @@
  public:
   enum Kind {
     kFunction,
     kInterpretedFunction,
     kGetter,
     kSetter,
     kTailCallerFunction,
     kArgumentsAdaptor,
     kConstructStub,
     kCompiledStub,
+    kBuiltinContinuation,
     kInvalid
   };
 
   int GetValueCount();
 
   Kind kind() const { return kind_; }
   BailoutId node_id() const { return node_id_; }
   Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
   int height() const { return height_; }
 
@@ skipping 51 matching lines @@
                                           SharedFunctionInfo* shared_info,
                                           int height);
   static TranslatedFrame AccessorFrame(Kind kind,
                                        SharedFunctionInfo* shared_info);
   static TranslatedFrame ArgumentsAdaptorFrame(SharedFunctionInfo* shared_info,
                                                int height);
   static TranslatedFrame TailCallerFrame(SharedFunctionInfo* shared_info);
   static TranslatedFrame ConstructStubFrame(BailoutId bailout_id,
                                             SharedFunctionInfo* shared_info,
                                             int height);
+  static TranslatedFrame BuiltinContinuationFrame(
+      BailoutId bailout_id, SharedFunctionInfo* shared_info, int height);
   static TranslatedFrame CompiledStubFrame(int height, Isolate* isolate) {
     return TranslatedFrame(kCompiledStub, isolate, nullptr, height);
   }
   static TranslatedFrame InvalidFrame() {
     return TranslatedFrame(kInvalid, nullptr);
   }
 
   static void AdvanceIterator(std::deque<TranslatedValue>::iterator* iter);
 
   TranslatedFrame(Kind kind, Isolate* isolate,
@@ skipping 318 matching lines @@
   void DoComputeArgumentsAdaptorFrame(TranslatedFrame* translated_frame,
                                       int frame_index);
   void DoComputeTailCallerFrame(TranslatedFrame* translated_frame,
                                 int frame_index);
   void DoComputeConstructStubFrame(TranslatedFrame* translated_frame,
                                    int frame_index);
   void DoComputeAccessorStubFrame(TranslatedFrame* translated_frame,
                                   int frame_index, bool is_setter_stub_frame);
   void DoComputeCompiledStubFrame(TranslatedFrame* translated_frame,
                                   int frame_index);
+  void DoComputeBuiltinContinuation(TranslatedFrame* translated_frame,
+                                    int frame_index);
 
   void WriteTranslatedValueToOutput(
       TranslatedFrame::iterator* iterator, int* input_index, int frame_index,
       unsigned output_offset, const char* debug_hint_string = nullptr,
       Address output_address_for_materialization = nullptr);
   void WriteValueToOutput(Object* value, int input_index, int frame_index,
                           unsigned output_offset,
                           const char* debug_hint_string);
   void DebugPrintOutputSlot(intptr_t value, int frame_index,
                             unsigned output_offset,
@@ skipping 337 matching lines @@
 
  private:
   ByteArray* buffer_;
   int index_;
 };
 
 #define TRANSLATION_OPCODE_LIST(V) \
   V(BEGIN)                         \
   V(JS_FRAME)                      \
   V(INTERPRETED_FRAME)             \
+  V(BUILTIN_CONTINUATION_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(ARGUMENTS_LENGTH)              \
@@ skipping 35 matching lines @@
 
   // Commands.
   void BeginJSFrame(BailoutId node_id, int literal_id, unsigned height);
   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 BeginBuiltinContinuationFrame(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 ArgumentsLength(bool is_rest);
   void BeginCapturedObject(int length);
   void DuplicateObject(int object_index);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
@@ skipping 111 matching lines @@
   std::vector<Handle<Object> > expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEOPTIMIZER_H_