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

test/cctest/compiler/test-loop-analysis.cc

 // Copyright 2014 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/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
@@ skipping 98 matching lines @@
     }
     return node;
   }
 
   const Operator* op(int count, bool effect) {
     return effect ? common.EffectPhi(count)
                   : common.Phi(MachineRepresentation::kTagged, count);
   }
 
   Node* Return(Node* val, Node* effect, Node* control) {
-    Node* ret = graph.NewNode(common.Return(), val, effect, control);
+    Node* zero = graph.NewNode(common.Int32Constant(0));
+    Node* ret = graph.NewNode(common.Return(), zero, val, effect, control);
     end->ReplaceInput(0, ret);
     return ret;
   }
 
   LoopTree* GetLoopTree() {
     if (loop_tree == NULL) {
       if (FLAG_trace_turbo_graph) {
         OFStream os(stdout);
         os << AsRPO(graph);
       }
@@ skipping 559 matching lines @@
         Node* p3 = t.jsgraph.Int32Constant(33);
 
         Node* loop = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
         Node* phi = t.graph.NewNode(
             t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p1, loop);
         Node* cond = t.graph.NewNode(&kIntAdd, phi, p2);
         Node* branch = t.graph.NewNode(t.common.Branch(), cond, loop);
         Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
         Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
         loop->ReplaceInput(1, if_true);
-        Node* ret = t.graph.NewNode(t.common.Return(), p3, t.start, exit);
+        Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
+        Node* ret = t.graph.NewNode(t.common.Return(), zero, p3, t.start, exit);
         t.graph.SetEnd(ret);
 
         Node* choices[] = {p1, phi, cond};
         p1->ReplaceUses(choices[i]);
         p2->ReplaceUses(choices[j]);
         p3->ReplaceUses(choices[k]);
 
         Node* header[] = {loop, phi};
         Node* body[] = {cond, branch, if_true};
         t.CheckLoop(header, 2, body, 3);
@@ skipping 26 matching lines @@
       Node* loop2 = t.graph.NewNode(t.common.Loop(2), if_true1, t.start);
       Node* phi2 = t.graph.NewNode(
           t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p2, loop2);
       Node* cond2 = t.graph.NewNode(&kIntAdd, phi2, p3);
       Node* branch2 = t.graph.NewNode(t.common.Branch(), cond2, loop2);
       Node* if_true2 = t.graph.NewNode(t.common.IfTrue(), branch2);
       Node* exit2 = t.graph.NewNode(t.common.IfFalse(), branch2);
       loop2->ReplaceInput(1, if_true2);
       loop1->ReplaceInput(1, exit2);
 
-      Node* ret = t.graph.NewNode(t.common.Return(), phi1, t.start, exit1);
+      Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
+      Node* ret =
+          t.graph.NewNode(t.common.Return(), zero, phi1, t.start, exit1);
       t.graph.SetEnd(ret);
 
       Node* choices[] = {p1, phi1, cond1, phi2, cond2};
       p1->ReplaceUses(choices[i]);
       p2->ReplaceUses(choices[j]);
       p3->ReplaceUses(choices[k]);
 
       Node* header1[] = {loop1, phi1};
       Node* body1[] = {cond1, branch1, if_true1, exit2,   loop2,
                        phi2,  cond2,   branch2,  if_true2};
@@ skipping 66 matching lines @@
                                p3a, p3c, loop3);
   Node* cond3 = t.graph.NewNode(&kIntAdd, phi3, p3b);
   Node* branch3 = t.graph.NewNode(t.common.Branch(), cond3, loop3);
   Node* if_true3 = t.graph.NewNode(t.common.IfTrue(), branch3);
   Node* exit3 = t.graph.NewNode(t.common.IfFalse(), branch3);
 
   loop3->ReplaceInput(1, if_true3);
   loop2->ReplaceInput(1, exit3);
   loop1->ReplaceInput(1, exit2);
 
-  Node* ret = t.graph.NewNode(t.common.Return(), phi1, t.start, exit1);
+  Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
+  Node* ret = t.graph.NewNode(t.common.Return(), zero, phi1, t.start, exit1);
   t.graph.SetEnd(ret);
 
   // Mutate the graph according to the edge choices.
 
   Node* o1[] = {t.one};
   Node* o2[] = {t.one, phi1, cond1};
   Node* o3[] = {t.one, phi1, cond1, phi2, cond2};
 
   p1a->ReplaceUses(o1[c1a]);
   p1b->ReplaceUses(o1[c1b]);
@@ skipping 92 matching lines @@
     loop->ReplaceInput(1, if_true);
 
     nodes[i * 4 + 0] = loop;
     nodes[i * 4 + 1] = phi;
     nodes[i * 4 + 2] = branch;
     nodes[i * 4 + 3] = if_true;
 
     last = exit;
   }
 
-  Node* ret = t.graph.NewNode(t.common.Return(), t.p0, t.start, last);
+  Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
+  Node* ret = t.graph.NewNode(t.common.Return(), zero, t.p0, t.start, last);
   t.graph.SetEnd(ret);
 
   // Verify loops.
   for (int i = 0; i < count; i++) {
     t.CheckLoop(nodes + i * 4, 2, nodes + i * 4 + 2, 2);
   }
 }
 
 
 static void RunManyNestedLoops_i(int count) {
   LoopFinderTester t;
   Node** nodes = t.zone()->NewArray<Node*>(count * 5);
   Node* k11 = t.jsgraph.Int32Constant(11);
   Node* k12 = t.jsgraph.Int32Constant(12);
   Node* outer = nullptr;
   Node* entry = t.start;
 
   // Build loops.
+  Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
   for (int i = 0; i < count; i++) {
     Node* loop = t.graph.NewNode(t.common.Loop(2), entry, t.start);
     Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
                                 k11, k12, loop);
     Node* branch = t.graph.NewNode(t.common.Branch(), phi, loop);
     Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
     Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
 
     nodes[i * 5 + 0] = exit;     // outside
     nodes[i * 5 + 1] = loop;     // header
     nodes[i * 5 + 2] = phi;      // header
     nodes[i * 5 + 3] = branch;   // body
     nodes[i * 5 + 4] = if_true;  // body
 
     if (outer != nullptr) {
       // inner loop.
       outer->ReplaceInput(1, exit);
     } else {
       // outer loop.
-      Node* ret = t.graph.NewNode(t.common.Return(), t.p0, t.start, exit);
+      Node* ret = t.graph.NewNode(t.common.Return(), zero, t.p0, t.start, exit);
       t.graph.SetEnd(ret);
     }
     outer = loop;
     entry = if_true;
   }
   outer->ReplaceInput(1, entry);  // innermost loop.
 
   // Verify loops.
   for (int i = 0; i < count; i++) {
     int k = i * 5;
@@ skipping 19 matching lines @@
 TEST(LaManyNested_62) { RunManyNestedLoops_i(62); }
 TEST(LaManyNested_63) { RunManyNestedLoops_i(63); }
 TEST(LaManyNested_64) { RunManyNestedLoops_i(64); }
 
 
 TEST(LaPhiTangle) { LoopFinderTester t; }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8