[turbofan] Support variable size argument popping in TF-generated functions

test/unittests/compiler/escape-analysis-unittest.cc

 // 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.
 
 #include "src/compiler/escape-analysis.h"
 #include "src/bit-vector.h"
 #include "src/compiler/escape-analysis-reducer.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties.h"
@@ skipping 101 matching lines @@
                             control);
   }
 
   Node* Return(Node* value, Node* effect = nullptr, Node* control = nullptr) {
     if (!effect) {
       effect = effect_;
     }
     if (!control) {
       control = control_;
     }
-    return control_ =
-               graph()->NewNode(common()->Return(), value, effect, control);
+    Node* zero = graph()->NewNode(common()->Int32Constant(0));
+    return control_ = graph()->NewNode(common()->Return(), zero, value, effect,
+                                       control);
   }
 
   void EndGraph() {
     for (Edge edge : graph()->end()->input_edges()) {
       if (NodeProperties::IsControlEdge(edge)) {
         edge.UpdateTo(control_);
       }
     }
   }
 
@@ skipping 83 matching lines @@
   Node* result = Return(load);
   EndGraph();
 
   Analysis();
 
   ExpectVirtual(allocation);
   ExpectReplacement(load, object1);
 
   Transformation();
 
-  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, StraightNonEscapeNonConstStore) {
   Node* object1 = Constant(1);
   Node* object2 = Constant(2);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
   Node* index =
       graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
                        object1, object2, control());
   StoreElement(MakeElementAccess(0), allocation, index, object1);
   Node* finish = FinishRegion(allocation);
   Node* load = Load(FieldAccessAtIndex(0), finish);
   Node* result = Return(load);
   EndGraph();
 
   Analysis();
 
   ExpectEscaped(allocation);
   ExpectReplacement(load, nullptr);
 
   Transformation();
 
-  ASSERT_EQ(load, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(load, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, StraightEscape) {
   Node* object1 = Constant(1);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
   Node* finish = FinishRegion(allocation);
   Node* load = Load(FieldAccessAtIndex(0), finish);
   Node* result = Return(allocation);
   EndGraph();
   graph()->end()->AppendInput(zone(), load);
 
   Analysis();
 
   ExpectEscaped(allocation);
   ExpectReplacement(load, object1);
 
   Transformation();
 
-  ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, StoreLoadEscape) {
   Node* object1 = Constant(1);
 
   BeginRegion();
   Node* allocation1 = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation1, object1);
   Node* finish1 = FinishRegion(allocation1);
 
   BeginRegion();
   Node* allocation2 = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation2, finish1);
   Node* finish2 = FinishRegion(allocation2);
 
   Node* load = Load(FieldAccessAtIndex(0), finish2);
   Node* result = Return(load);
   EndGraph();
   Analysis();
 
   ExpectEscaped(allocation1);
   ExpectVirtual(allocation2);
   ExpectReplacement(load, finish1);
 
   Transformation();
 
-  ASSERT_EQ(finish1, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(finish1, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, BranchNonEscape) {
   Node* object1 = Constant(1);
   Node* object2 = Constant(2);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
   Node* finish = FinishRegion(allocation);
@@ skipping 12 matching lines @@
   graph()->end()->AppendInput(zone(), result);
 
   Analysis();
 
   ExpectVirtual(allocation);
   ExpectReplacementPhi(load, object1, object2);
   Node* replacement_phi = escape_analysis()->GetReplacement(load);
 
   Transformation();
 
-  ASSERT_EQ(replacement_phi, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(replacement_phi, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, BranchEscapeOne) {
   Node* object1 = Constant(1);
   Node* object2 = Constant(2);
   Node* index = graph()->NewNode(common()->Parameter(0), start());
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
@@ skipping 11 matching lines @@
   Node* result = Return(load, phi);
   EndGraph();
 
   Analysis();
 
   ExpectEscaped(allocation);
   ExpectReplacement(load, nullptr);
 
   Transformation();
 
-  ASSERT_EQ(load, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(load, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, BranchEscapeThroughStore) {
   Node* object1 = Constant(1);
   Node* object2 = Constant(2);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
   FinishRegion(allocation);
@@ skipping 14 matching lines @@
   graph()->end()->AppendInput(zone(), load);
 
   Analysis();
 
   ExpectEscaped(allocation);
   ExpectEscaped(allocation2);
   ExpectReplacement(load, nullptr);
 
   Transformation();
 
-  ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, DanglingLoadOrder) {
   Node* object1 = Constant(1);
   Node* object2 = Constant(2);
   Node* allocation = Allocate(Constant(kPointerSize));
   Node* store1 = Store(FieldAccessAtIndex(0), allocation, object1);
   Node* load1 = Load(FieldAccessAtIndex(0), allocation);
   Node* store2 = Store(FieldAccessAtIndex(0), allocation, object2);
   Node* load2 = Load(FieldAccessAtIndex(0), allocation, store1);
   Node* result = Return(load2);
   EndGraph();
   graph()->end()->AppendInput(zone(), store2);
   graph()->end()->AppendInput(zone(), load1);
 
   Analysis();
 
   ExpectVirtual(allocation);
   ExpectReplacement(load1, object1);
   ExpectReplacement(load2, object1);
 
   Transformation();
 
-  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
 }
 
 
 TEST_F(EscapeAnalysisTest, DeoptReplacement) {
   Node* object1 = Constant(1);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize));
   Store(FieldAccessAtIndex(0), allocation, object1);
   Node* finish = FinishRegion(allocation);
   Node* effect1 = Store(FieldAccessAtIndex(0), allocation, object1, finish);
@@ skipping 15 matching lines @@
   Node* result = Return(load, effect1, ifTrue);
   EndGraph();
   graph()->end()->AppendInput(zone(), deopt);
   Analysis();
 
   ExpectVirtual(allocation);
   ExpectReplacement(load, object1);
 
   Transformation();
 
-  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
   Node* object_state = NodeProperties::GetValueInput(state_values1, 0);
   ASSERT_EQ(object_state->opcode(), IrOpcode::kObjectState);
   ASSERT_EQ(1, object_state->op()->ValueInputCount());
   ASSERT_EQ(object1, NodeProperties::GetValueInput(object_state, 0));
 }
 
 TEST_F(EscapeAnalysisTest, DISABLED_DeoptReplacementIdentity) {
   Node* object1 = Constant(1);
   BeginRegion();
   Node* allocation = Allocate(Constant(kPointerSize * 2));
@@ skipping 19 matching lines @@
   Node* result = Return(load, effect1, ifTrue);
   EndGraph();
   graph()->end()->AppendInput(zone(), deopt);
   Analysis();
 
   ExpectVirtual(allocation);
   ExpectReplacement(load, object1);
 
   Transformation();
 
-  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 0));
+  ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
 
   Node* object_state = NodeProperties::GetValueInput(state_values1, 0);
   ASSERT_EQ(object_state->opcode(), IrOpcode::kObjectState);
   ASSERT_EQ(2, object_state->op()->ValueInputCount());
   ASSERT_EQ(object1, NodeProperties::GetValueInput(object_state, 0));
   ASSERT_EQ(object_state, NodeProperties::GetValueInput(object_state, 1));
 
   Node* object_state2 = NodeProperties::GetValueInput(state_values1, 0);
   ASSERT_EQ(object_state, object_state2);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8