Inline Array.prototype.forEach in TurboFan

src/compiler/frame-states.h

 // Copyright 2015 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_COMPILER_FRAME_STATES_H_
 #define V8_COMPILER_FRAME_STATES_H_
 
+#include "src/builtins/builtins.h"
 #include "src/handles.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class SharedFunctionInfo;
 
 namespace compiler {
@@ skipping 57 matching lines @@
 
 
 // The type of stack frame that a FrameState node represents.
 enum class FrameStateType {
   kJavaScriptFunction,   // Represents an unoptimized JavaScriptFrame.
   kInterpretedFunction,  // Represents an InterpretedFrame.
   kArgumentsAdaptor,     // Represents an ArgumentsAdaptorFrame.
   kTailCallerFunction,   // Represents a frame removed by tail call elimination.
   kConstructStub,        // Represents a ConstructStubFrame.
   kGetterStub,           // Represents a GetterStubFrame.
-  kSetterStub            // Represents a SetterStubFrame.
+  kSetterStub,           // Represents a SetterStubFrame.
+  kBuiltinContinuation   // Represents a continuation to a stub
 };
 
 class FrameStateFunctionInfo {
  public:
   FrameStateFunctionInfo(FrameStateType type, int parameter_count,
                          int local_count,
                          Handle<SharedFunctionInfo> shared_info)
       : type_(type),
         parameter_count_(parameter_count),
         local_count_(local_count),
@@ skipping 57 matching lines @@
 std::ostream& operator<<(std::ostream&, FrameStateInfo const&);
 
 static const int kFrameStateParametersInput = 0;
 static const int kFrameStateLocalsInput = 1;
 static const int kFrameStateStackInput = 2;
 static const int kFrameStateContextInput = 3;
 static const int kFrameStateFunctionInput = 4;
 static const int kFrameStateOuterStateInput = 5;
 static const int kFrameStateInputCount = kFrameStateOuterStateInput + 1;
 
+class JSGraph;
+class Node;
+
+enum CheckpointMode { CREATE_CHECKPOINT, DONT_CREATE_CHECKPOINT };

[Benedikt Meurer, 2017/05/18 06:32:52]

Nit: enum class ContinuationFrameStateType { kEager, kLazy };

[danno, 2017/05/22 10:28:10]

Done.

+
+std::pair<Node*, Node*> CreateStubBuiltinContinuationFrameState(

[Benedikt Meurer, 2017/05/18 06:32:52]

The effect doesn't seem to make sense here. How about just having an API here
that is responsible for creating the appropriate FrameState and then create and
wire up the CheckPoint independently at the use sites.

[danno, 2017/05/22 10:28:10]

Done.

+    JSGraph* graph, Builtins::Name name, Node* context, Node** parameters,
+    int parameter_count, Node* effect, Node* control, Node* outer_frame_state,

[Benedikt Meurer, 2017/05/18 06:32:52]

You don't need the effect, control inputs here.

[danno, 2017/05/22 10:28:10]

Done.

+    CheckpointMode mode);
+
+std::pair<Node*, Node*> CreateJavaScriptBuiltinContinuationFrameState(

[Benedikt Meurer, 2017/05/18 06:32:52]

Same as above.

[danno, 2017/05/22 10:28:10]

Done.

+    JSGraph* graph, Handle<SharedFunctionInfo> shared, Builtins::Name name,
+    Node* target, Node* context, Node** stack_parameters,
+    int stack_parameter_count, Node* effect, Node* control,
+    Node* outer_frame_state, CheckpointMode mode);
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_FRAME_STATES_H_