[crankshaft] Fixing ES6 tail call elimination.

test/mjsunit/es6/tail-call-megatest.js

 // Copyright 2016 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.
 
 // Flags: --allow-natives-syntax --harmony-tailcalls
-// TODO(v8:4698), TODO(ishell): support these cases.
-// Flags: --turbo --nostress-opt
 
 
 Error.prepareStackTrace = (error,stack) => {
   error.strace = stack;
   return error.message + "\n    at " + stack.join("\n    at ");
 }
 
 
 function checkStackTrace(expected) {
   var e = new Error();
@@ skipping 34 matching lines @@
     var lines = [
       `  assertEquals_(${expected_name}.length, arguments.length);`,
       `  for (var i = 0; i < ${expected_name}.length; i++) {`,
       `    assertEquals_(${expected_name}[i], arguments[i]);`,
       `  }`,
     ];
     return lines.join("\n");
   }
   var check_arguments = check_arguments_template("expected_args");
 
+  function deopt_template(deopt_mode) {
+    switch(deopt_mode) {
+      case "none":
+        return "  // Don't deoptimize";
+      case "f":
+      case "g":
+      case "test":
+        return `  %DeoptimizeFunction(${deopt_mode});`;
+      default:
+        assertUnreachable();
+    }
+  }
+
   var f_cfg_sloppy = {
     func_name: 'f',
     source_template: function(cfg) {
       var receiver = cfg.f_receiver != undefined ? cfg.f_receiver
                                                  : "global";
       var do_checks = [
         `  assertEquals_(${receiver}, this);`,
-        `  assertEquals_(undefined, new.target);`,
+        `  ${!cfg.check_new_target ? "// " : ""}assertEquals_(undefined, new.target);`,
         check_arguments,
         `  checkStackTrace_([f, test]);`,
       ].join("\n");
 
       var lines = [
         `function f(a) {`,
         `  ${inlinable_comment(cfg.f_inlinable)}`,
+        `  counter++;`,
         `  var expected_args = [${cfg.f_args}];`,
         do_checks,
-        `  %DeoptimizeNow();`,
+        deopt_template(cfg.deopt_mode),
         do_checks,
         `  return 42;`,
         `}`,
       ];
       return lines.join("\n");
     },
   };
 
   var f_cfg_strict = {
     func_name: 'f',
     source_template: function(cfg) {
       var receiver = cfg.f_receiver != undefined ? cfg.f_receiver
                                                  : "undefined";
       var do_checks = [
         `  assertEquals_(${receiver}, this);`,
-        `  assertEquals_(undefined, new.target);`,
+        `  ${!cfg.check_new_target ? "// " : ""}assertEquals_(undefined, new.target);`,
         check_arguments,
         `  checkStackTrace_([f, test]);`,
       ].join("\n");
 
       var lines = [
         `function f(a) {`,
         `  "use strict";`,
         `  ${inlinable_comment(cfg.f_inlinable)}`,
+        `  counter++;`,
         `  var expected_args = [${cfg.f_args}];`,
         do_checks,
-        `  %DeoptimizeNow();`,
+        deopt_template(cfg.deopt_mode),
         do_checks,
         `  return 42;`,
         `}`,
       ];
       return lines.join("\n");
     },
   };
 
   var f_cfg_possibly_eval = {
     func_name: 'eval',
     source_template: function(cfg) {
       var receiver = cfg.f_receiver != undefined ? cfg.f_receiver
                                                  : "global";
       var do_checks = [
         `  assertEquals_(${receiver}, this);`,
-        `  assertEquals_(undefined, new.target);`,
+        `  ${!cfg.check_new_target ? "// " : ""}assertEquals_(undefined, new.target);`,
         check_arguments,
         `  checkStackTrace_([f, test]);`,
       ].join("\n");
 
       var lines = [
         `function f(a) {`,
         `  ${inlinable_comment(cfg.f_inlinable)}`,
+        `  counter++;`,
         `  var expected_args = [${cfg.f_args}];`,
         do_checks,
-        `  %DeoptimizeNow();`,
+        deopt_template(cfg.deopt_mode),
         do_checks,
         `  return 42;`,
         `}`,
         `var eval = f;`,
       ];
       return lines.join("\n");
     },
   };
 
   var f_cfg_bound = {
     func_name: 'bound',
     source_template: function(cfg) {
       var do_checks = [
         `  assertEquals_(receiver, this);`,
-        `  assertEquals_(undefined, new.target);`,
+        `  ${!cfg.check_new_target ? "// " : ""}assertEquals_(undefined, new.target);`,
         check_arguments,
         `  checkStackTrace_([f, test]);`,
       ].join("\n");
 
       var lines = [
         `function f(a) {`,
         `  "use strict";`,
         `  ${inlinable_comment(cfg.f_inlinable)}`,
+        `  counter++;`,
         `  var expected_args = [${cfg.f_args}];`,
         do_checks,
-        `  %DeoptimizeNow();`,
+        deopt_template(cfg.deopt_mode),
         do_checks,
         `  return 42;`,
         `}`,
         `var receiver = {a: 153};`,
         `var bound = f.bind(receiver);`,
       ];
       return lines.join("\n");
     },
   };
 
   var f_cfg_proxy = {
     func_name: 'p',
     source_template: function(cfg) {
       var receiver = cfg.f_receiver != undefined ? cfg.f_receiver
                                                  : "global";
       var do_checks = [
         `  assertEquals_(${receiver}, this);`,
-        `  assertEquals_(undefined, new.target);`,
+        `  ${!cfg.check_new_target ? "// " : ""}assertEquals_(undefined, new.target);`,
         check_arguments,
         `  checkStackTrace_([f, test]);`,
       ].join("\n");
 
       var lines = [
         `function f(a) {`,
         `  ${inlinable_comment(cfg.f_inlinable)}`,
+        `  counter++;`,
         `  var expected_args = [${cfg.f_args}];`,
         do_checks,
-        `  %DeoptimizeNow();`,
+        deopt_template(cfg.deopt_mode),
         do_checks,
         `  return 42;`,
         `}`,
         `var p = new Proxy(f, {});`,
       ];
       return lines.join("\n");
     },
   };
 
   var g_cfg_normal = {
     receiver: undefined,
     source_template: function(cfg) {
       var lines = [
         `function g(a) {`,
         `  "use strict";`,
         `  ${inlinable_comment(cfg.g_inlinable)}`,
         `  var expected_args = [${cfg.g_args}];`,
         check_arguments,
         `  return ${cfg.f_name}(${cfg.f_args});`,
         `}`,
       ];
       return lines.join("\n");
     },
   };
 
 
+  var g_cfg_reflect_apply = {
+    receiver: "the_receiver",
+    source_template: function(cfg) {
+      var lines = [
+        `function g(a) {`,
+        `  "use strict";`,
+        `  ${inlinable_comment(cfg.g_inlinable)}`,
+        `  var expected_args = [${cfg.g_args}];`,
+        check_arguments,
+        `  return Reflect.apply(${cfg.f_name}, the_receiver, [${cfg.f_args}]);`,
+        `}`,
+      ];
+      return lines.join("\n");
+    },
+  };
+
+
   var g_cfg_function_apply = {
     receiver: "the_receiver",
     source_template: function(cfg) {
       var lines = [
         `function g(a) {`,
         `  "use strict";`,
         `  ${inlinable_comment(cfg.g_inlinable)}`,
         `  var expected_args = [${cfg.g_args}];`,
         check_arguments,
         `  return ${cfg.f_name}.apply(the_receiver, [${cfg.f_args}]);`,
@@ skipping 52 matching lines @@
     f_source = ident_source(f_source, 2);
 
     var lines = [
       `(function() {`,
       `  // Avoid bailing out because of "Reference to a variable which requires dynamic lookup".`,
       `  var assertEquals_ = assertEquals;`,
       `  var checkStackTrace_ = checkStackTrace;`,
       `  var undefined = void 0;`,
       `  var global = Function('return this')();`,
       `  var the_receiver = {receiver: 1};`,
+      `  var counter = 0;`,
       ``,
       `  // Don't inline helper functions`,
       `  %NeverOptimizeFunction(assertEquals);`,
       `  %NeverOptimizeFunction(checkStackTrace);`,
       ``,
       f_source,
       g_source,
       `  function test() {`,
       `    "use strict";`,
       `    assertEquals_(42, g(${cfg.g_args}));`,
       `  }`,
-      `  ${cfg.f_inlinable ? "%SetForceInlineFlag(f)" : ""};`,
-      `  ${cfg.g_inlinable ? "%SetForceInlineFlag(g)" : ""};`,
       `  ${"test();".repeat(cfg.test_warmup_count)}`,
+      `  ${cfg.f_inlinable ? "%SetForceInlineFlag(f)" : "%OptimizeFunctionOnNextCall(f)"};`,
+      `  ${cfg.g_inlinable ? "%SetForceInlineFlag(g)" : "%OptimizeFunctionOnNextCall(g)"};`,
       `  %OptimizeFunctionOnNextCall(test);`,
-      `  %OptimizeFunctionOnNextCall(f);`,
-      `  %OptimizeFunctionOnNextCall(g);`,
       `  test();`,
+      `  assertEquals(${1 + cfg.test_warmup_count}, counter);`,
       `})();`,
       ``,
     ];
     var source = lines.join("\n");
     return source;
   }
 
   var f_args_variants = ["", "1", "1, 2"];
   var g_args_variants = ["", "10", "10, 20"];
   var f_inlinable_variants = [true, false];
   var g_inlinable_variants = [true, false];
+  // This is to avoid bailing out because of referencing new.target.
+  var check_new_target_variants = [true, false];
+  var deopt_mode_variants = ["none", "f", "g", "test"];
   var f_variants = [
       f_cfg_sloppy,
       f_cfg_strict,
       f_cfg_bound,
       f_cfg_proxy,
       f_cfg_possibly_eval,
   ];
   var g_variants = [
       g_cfg_normal,
-      g_cfg_function_call,
+      g_cfg_reflect_apply,
       g_cfg_function_apply,
       g_cfg_function_apply_arguments_object,
+      g_cfg_function_call,
   ];
   var test_warmup_counts = [0, 1, 2];
 
   var iter = 0;
+  var tests_executed = 0;
   if (shard !== undefined) {
     print("Running shard #" + shard);
   }
   f_variants.forEach((f_cfg) => {
-    g_variants.forEach((g_cfg) => {
-      f_args_variants.forEach((f_args) => {
-        g_args_variants.forEach((g_args) => {
-          f_inlinable_variants.forEach((f_inlinable) => {
-            g_inlinable_variants.forEach((g_inlinable) => {
-              test_warmup_counts.forEach((test_warmup_count) => {
-                if (shard !== undefined && (iter++) % SHARDS_COUNT != shard) {
-                  print("skipping...");
-                  return;
-                }
-                var cfg = {
-                  f_source_template: f_cfg.source_template,
-                  f_inlinable,
-                  f_args,
-                  f_name: f_cfg.func_name,
-                  f_receiver: g_cfg.receiver,
-                  g_source_template: g_cfg.source_template,
-                  g_inlinable,
-                  g_args,
-                  test_warmup_count,
-                };
-                var source = test_template(cfg);
-                print("====================");
-                print(source);
-                eval(source);
+    check_new_target_variants.forEach((check_new_target) => {
+      deopt_mode_variants.forEach((deopt_mode) => {
+        g_variants.forEach((g_cfg) => {
+          f_args_variants.forEach((f_args) => {
+            g_args_variants.forEach((g_args) => {
+              f_inlinable_variants.forEach((f_inlinable) => {
+                g_inlinable_variants.forEach((g_inlinable) => {
+                  test_warmup_counts.forEach((test_warmup_count) => {
+                    if (shard !== undefined && (iter++) % SHARDS_COUNT != shard) {
+                      print("skipping...");
+                      return;
+                    }
+                    tests_executed++;
+                    var cfg = {
+                      f_source_template: f_cfg.source_template,
+                      f_inlinable,
+                      f_args,
+                      f_name: f_cfg.func_name,
+                      f_receiver: g_cfg.receiver,
+                      g_source_template: g_cfg.source_template,
+                      g_inlinable,
+                      g_args,
+                      test_warmup_count,
+                      check_new_target,
+                      deopt_mode,
+                    };
+                    var source = test_template(cfg);
+                    print("====================");
+                    print(source);
+                    eval(source);
+                  });
+                });
               });
             });
           });
         });
       });
     });
   });
+  print("Number of tests executed: " + tests_executed);
 }
 
 // Uncomment to run all the tests at once or use shard runners.
 //run_tests();