[ignition] Inline the binary op TurboFan code stubs in the bytecode handlers.

src/code-stubs.cc

 // 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.
 
 #include "src/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 480 matching lines @@
 
 void StringLengthStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   compiler::Node* value = assembler->Parameter(0);
   compiler::Node* string =
       assembler->LoadObjectField(value, JSValue::kValueOffset);
   compiler::Node* result =
       assembler->LoadObjectField(string, String::kLengthOffset);
   assembler->Return(result);
 }
 
-void AddStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
+                                  compiler::Node* left, compiler::Node* right,
+                                  compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* context = assembler->Parameter(2);
-
   // Shared entry for floating point addition.
-  Label do_fadd(assembler);
+  Label do_fadd(assembler), end(assembler);
   Variable var_fadd_lhs(assembler, MachineRepresentation::kFloat64),
       var_fadd_rhs(assembler, MachineRepresentation::kFloat64);
 
   // We might need to loop several times due to ToPrimitive, ToString and/or
   // ToNumber conversions.
   Variable var_lhs(assembler, MachineRepresentation::kTagged),
-      var_rhs(assembler, MachineRepresentation::kTagged);
+      var_rhs(assembler, MachineRepresentation::kTagged),
+      var_result(assembler, MachineRepresentation::kTagged);
   Variable* loop_vars[2] = {&var_lhs, &var_rhs};
   Label loop(assembler, 2, loop_vars);
-  var_lhs.Bind(assembler->Parameter(0));
-  var_rhs.Bind(assembler->Parameter(1));
+  var_lhs.Bind(left);
+  var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     // Load the current {lhs} and {rhs} values.
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     // Check if the {lhs} is a Smi or a HeapObject.
     Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
     assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
@@ skipping 16 matching lines @@
         assembler->Branch(overflow, &if_overflow, &if_notoverflow);
 
         assembler->Bind(&if_overflow);
         {
           var_fadd_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fadd_rhs.Bind(assembler->SmiToFloat64(rhs));
           assembler->Goto(&do_fadd);
         }
 
         assembler->Bind(&if_notoverflow);
-        assembler->Return(assembler->Projection(0, pair));
+        var_result.Bind(assembler->Projection(0, pair));
+        assembler->Goto(&end);
       }
 
       assembler->Bind(&if_rhsisnotsmi);
       {
         // Load the map of {rhs}.
         Node* rhs_map = assembler->LoadObjectField(rhs, HeapObject::kMapOffset);
 
         // Check if the {rhs} is a HeapNumber.
         Label if_rhsisnumber(assembler),
             if_rhsisnotnumber(assembler, Label::kDeferred);
@@ skipping 20 matching lines @@
                                 rhs_instance_type,
                                 assembler->Int32Constant(FIRST_NONSTRING_TYPE)),
                             &if_rhsisstring, &if_rhsisnotstring);
 
           assembler->Bind(&if_rhsisstring);
           {
             // Convert {lhs}, which is a Smi, to a String and concatenate the
             // resulting string with the String {rhs}.
             Callable callable = CodeFactory::StringAdd(
                 assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
-            assembler->TailCallStub(callable, context, lhs, rhs);
+            var_result.Bind(assembler->CallStub(callable, context, lhs, rhs));
+            assembler->Goto(&end);
           }
 
           assembler->Bind(&if_rhsisnotstring);
           {
             // Check if {rhs} is a JSReceiver.
             Label if_rhsisreceiver(assembler, Label::kDeferred),
                 if_rhsisnotreceiver(assembler, Label::kDeferred);
             assembler->Branch(
                 assembler->Int32LessThanOrEqual(
                     assembler->Int32Constant(FIRST_JS_RECEIVER_TYPE),
@@ skipping 33 matching lines @@
                             lhs_instance_type,
                             assembler->Int32Constant(FIRST_NONSTRING_TYPE)),
                         &if_lhsisstring, &if_lhsisnotstring);
 
       assembler->Bind(&if_lhsisstring);
       {
         // Convert {rhs} to a String (using the sequence of ToPrimitive with
         // no hint followed by ToString) and concatenate the strings.
         Callable callable = CodeFactory::StringAdd(
             assembler->isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED);
-        assembler->TailCallStub(callable, context, lhs, rhs);
+        var_result.Bind(assembler->CallStub(callable, context, lhs, rhs));
+        assembler->Goto(&end);
       }
 
       assembler->Bind(&if_lhsisnotstring);
       {
         // Check if {rhs} is a Smi.
         Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler);
         assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi,
                           &if_rhsisnotsmi);
 
         assembler->Bind(&if_rhsissmi);
@@ skipping 57 matching lines @@
                                 rhs_instance_type,
                                 assembler->Int32Constant(FIRST_NONSTRING_TYPE)),
                             &if_rhsisstring, &if_rhsisnotstring);
 
           assembler->Bind(&if_rhsisstring);
           {
             // Convert {lhs} to a String (using the sequence of ToPrimitive with
             // no hint followed by ToString) and concatenate the strings.
             Callable callable = CodeFactory::StringAdd(
                 assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
-            assembler->TailCallStub(callable, context, lhs, rhs);
+            var_result.Bind(assembler->CallStub(callable, context, lhs, rhs));
+            assembler->Goto(&end);
           }
 
           assembler->Bind(&if_rhsisnotstring);
           {
             // Check if {lhs} is a HeapNumber.
             Label if_lhsisnumber(assembler), if_lhsisnotnumber(assembler);
             assembler->Branch(assembler->Word32Equal(
                                   lhs_instance_type,
                                   assembler->Int32Constant(HEAP_NUMBER_TYPE)),
                               &if_lhsisnumber, &if_lhsisnotnumber);
@@ skipping 101 matching lines @@
         }
       }
     }
   }
 
   assembler->Bind(&do_fadd);
   {
     Node* lhs_value = var_fadd_lhs.value();
     Node* rhs_value = var_fadd_rhs.value();
     Node* value = assembler->Float64Add(lhs_value, rhs_value);
-    Node* result = assembler->ChangeFloat64ToTagged(value);
-    assembler->Return(result);
+    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    assembler->Goto(&end);
   }
+  assembler->Bind(&end);
+  return var_result.value();
 }
 
-void SubtractStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
+                                       compiler::Node* left,
+                                       compiler::Node* right,
+                                       compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* context = assembler->Parameter(2);
-
   // Shared entry for floating point subtraction.
-  Label do_fsub(assembler);
+  Label do_fsub(assembler), end(assembler);
   Variable var_fsub_lhs(assembler, MachineRepresentation::kFloat64),
       var_fsub_rhs(assembler, MachineRepresentation::kFloat64);
 
   // We might need to loop several times due to ToPrimitive and/or ToNumber
   // conversions.
   Variable var_lhs(assembler, MachineRepresentation::kTagged),
-      var_rhs(assembler, MachineRepresentation::kTagged);
+      var_rhs(assembler, MachineRepresentation::kTagged),
+      var_result(assembler, MachineRepresentation::kTagged);
   Variable* loop_vars[2] = {&var_lhs, &var_rhs};
   Label loop(assembler, 2, loop_vars);
-  var_lhs.Bind(assembler->Parameter(0));
-  var_rhs.Bind(assembler->Parameter(1));
+  var_lhs.Bind(left);
+  var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     // Load the current {lhs} and {rhs} values.
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     // Check if the {lhs} is a Smi or a HeapObject.
     Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler);
     assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
@@ skipping 17 matching lines @@
 
         assembler->Bind(&if_overflow);
         {
           // The result doesn't fit into Smi range.
           var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fsub_rhs.Bind(assembler->SmiToFloat64(rhs));
           assembler->Goto(&do_fsub);
         }
 
         assembler->Bind(&if_notoverflow);
-        assembler->Return(assembler->Projection(0, pair));
+        var_result.Bind(assembler->Projection(0, pair));
+        assembler->Goto(&end);
       }
 
       assembler->Bind(&if_rhsisnotsmi);
       {
         // Load the map of the {rhs}.
         Node* rhs_map = assembler->LoadMap(rhs);
 
         // Check if {rhs} is a HeapNumber.
         Label if_rhsisnumber(assembler),
             if_rhsisnotnumber(assembler, Label::kDeferred);
         Node* number_map = assembler->HeapNumberMapConstant();
         assembler->Branch(assembler->WordEqual(rhs_map, number_map),
                           &if_rhsisnumber, &if_rhsisnotnumber);
 
         assembler->Bind(&if_rhsisnumber);
         {
           // Perform a floating point subtraction.
           var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs));
           var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
           assembler->Goto(&do_fsub);
         }
 
         assembler->Bind(&if_rhsisnotnumber);
         {
           // Convert the {rhs} to a Number first.
-          Callable callable = CodeFactory::NonNumberToNumber(isolate());
+          Callable callable =
+              CodeFactory::NonNumberToNumber(assembler->isolate());
           var_rhs.Bind(assembler->CallStub(callable, context, rhs));
           assembler->Goto(&loop);
         }
       }
     }
 
     assembler->Bind(&if_lhsisnotsmi);
     {
       // Load the map of the {lhs}.
       Node* lhs_map = assembler->LoadMap(lhs);
@@ skipping 35 matching lines @@
           {
             // Perform a floating point subtraction.
             var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs));
             var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs));
             assembler->Goto(&do_fsub);
           }
 
           assembler->Bind(&if_rhsisnotnumber);
           {
             // Convert the {rhs} to a Number first.
-            Callable callable = CodeFactory::NonNumberToNumber(isolate());
+            Callable callable =
+                CodeFactory::NonNumberToNumber(assembler->isolate());
             var_rhs.Bind(assembler->CallStub(callable, context, rhs));
             assembler->Goto(&loop);
           }
         }
       }
 
       assembler->Bind(&if_lhsisnotnumber);
       {
         // Convert the {lhs} to a Number first.
-        Callable callable = CodeFactory::NonNumberToNumber(isolate());
+        Callable callable =
+            CodeFactory::NonNumberToNumber(assembler->isolate());
         var_lhs.Bind(assembler->CallStub(callable, context, lhs));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fsub);
   {
     Node* lhs_value = var_fsub_lhs.value();
     Node* rhs_value = var_fsub_rhs.value();
     Node* value = assembler->Float64Sub(lhs_value, rhs_value);
-    Node* result = assembler->ChangeFloat64ToTagged(value);
-    assembler->Return(result);
+    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    assembler->Goto(&end);
   }
+  assembler->Bind(&end);
+  return var_result.value();
 }
 
-void MultiplyStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+// static
+compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
+                                       compiler::Node* left,
+                                       compiler::Node* right,
+                                       compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* context = assembler->Parameter(2);
-
   // Shared entry point for floating point multiplication.
   Label do_fmul(assembler);
   Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64),
       var_rhs_float64(assembler, MachineRepresentation::kFloat64);
 
   Node* number_map = assembler->HeapNumberMapConstant();
 
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_lhs(assembler, MachineRepresentation::kTagged),
       var_rhs(assembler, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_lhs, &var_rhs};
   Label loop(assembler, 2, loop_variables);
-  var_lhs.Bind(assembler->Parameter(0));
-  var_rhs.Bind(assembler->Parameter(1));
+  var_lhs.Bind(left);
+  var_rhs.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* lhs = var_lhs.value();
     Node* rhs = var_rhs.value();
 
     Label lhs_is_smi(assembler), lhs_is_not_smi(assembler);
     assembler->Branch(assembler->WordIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
 
     assembler->Bind(&lhs_is_smi);
@@ skipping 89 matching lines @@
             var_lhs.Bind(rhs);
             var_rhs.Bind(lhs);
             assembler->Goto(&loop);
           }
         }
       }
 
       assembler->Bind(&lhs_is_not_number);
       {
         // Convert {lhs} to a Number and loop.
-        Callable callable = CodeFactory::NonNumberToNumber(isolate());
+        Callable callable =
+            CodeFactory::NonNumberToNumber(assembler->isolate());
         var_lhs.Bind(assembler->CallStub(callable, context, lhs));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fmul);
   {
     Node* value =
         assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
     Node* result = assembler->ChangeFloat64ToTagged(value);
-    assembler->Return(result);
+    return result;
   }
 }
 
-void DivideStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+// static
+compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
+                                     compiler::Node* left,
+                                     compiler::Node* right,
+                                     compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* context = assembler->Parameter(2);
-
   // Shared entry point for floating point division.
-  Label do_fdiv(assembler);
+  Label do_fdiv(assembler), end(assembler);
   Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
       var_divisor_float64(assembler, MachineRepresentation::kFloat64);
 
   Node* number_map = assembler->HeapNumberMapConstant();
 
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_dividend(assembler, MachineRepresentation::kTagged),
-      var_divisor(assembler, MachineRepresentation::kTagged);
+      var_divisor(assembler, MachineRepresentation::kTagged),
+      var_result(assembler, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_dividend, &var_divisor};
   Label loop(assembler, 2, loop_variables);
-  var_dividend.Bind(assembler->Parameter(0));
-  var_divisor.Bind(assembler->Parameter(1));
+  var_dividend.Bind(left);
+  var_divisor.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* dividend = var_dividend.value();
     Node* divisor = var_divisor.value();
 
     Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
     assembler->Branch(assembler->WordIsSmi(dividend), &dividend_is_smi,
                       &dividend_is_not_smi);
 
@@ skipping 53 matching lines @@
 
         // TODO(epertoso): consider adding a machine instruction that returns
         // both the result and the remainder.
         Node* untagged_result =
             assembler->Int32Div(untagged_dividend, untagged_divisor);
         Node* truncated =
             assembler->IntPtrMul(untagged_result, untagged_divisor);
         // Do floating point division if the remainder is not 0.
         assembler->GotoIf(
             assembler->Word32NotEqual(untagged_dividend, truncated), &bailout);
-        assembler->Return(assembler->SmiTag(untagged_result));
+        var_result.Bind(assembler->SmiTag(untagged_result));
+        assembler->Goto(&end);
 
         // Bailout: convert {dividend} and {divisor} to double and do double
         // division.
         assembler->Bind(&bailout);
         {
           var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
           var_divisor_float64.Bind(assembler->SmiToFloat64(divisor));
           assembler->Goto(&do_fdiv);
         }
       }
@@ skipping 13 matching lines @@
           // Convert {dividend} to a double and divide it with the value of
           // {divisor}.
           var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
           var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
           assembler->Goto(&do_fdiv);
         }
 
         assembler->Bind(&divisor_is_not_number);
         {
           // Convert {divisor} to a number and loop.
-          Callable callable = CodeFactory::NonNumberToNumber(isolate());
+          Callable callable =
+              CodeFactory::NonNumberToNumber(assembler->isolate());
           var_divisor.Bind(assembler->CallStub(callable, context, divisor));
           assembler->Goto(&loop);
         }
       }
     }
 
     assembler->Bind(&dividend_is_not_smi);
     {
       Node* dividend_map = assembler->LoadMap(dividend);
 
@@ skipping 34 matching lines @@
             // Both {dividend} and {divisor} are HeapNumbers. Load their values
             // and divide them.
             var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
             var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
             assembler->Goto(&do_fdiv);
           }
 
           assembler->Bind(&divisor_is_not_number);
           {
             // Convert {divisor} to a number and loop.
-            Callable callable = CodeFactory::NonNumberToNumber(isolate());
+            Callable callable =
+                CodeFactory::NonNumberToNumber(assembler->isolate());
             var_divisor.Bind(assembler->CallStub(callable, context, divisor));
             assembler->Goto(&loop);
           }
         }
       }
 
       assembler->Bind(&dividend_is_not_number);
       {
         // Convert {dividend} to a Number and loop.
-        Callable callable = CodeFactory::NonNumberToNumber(isolate());
+        Callable callable =
+            CodeFactory::NonNumberToNumber(assembler->isolate());
         var_dividend.Bind(assembler->CallStub(callable, context, dividend));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fdiv);
   {
     Node* value = assembler->Float64Div(var_dividend_float64.value(),
                                         var_divisor_float64.value());
-    Node* result = assembler->ChangeFloat64ToTagged(value);
-    assembler->Return(result);
+    var_result.Bind(assembler->ChangeFloat64ToTagged(value));
+    assembler->Goto(&end);
   }
+  assembler->Bind(&end);
+  return var_result.value();
 }
 
-void BitwiseAndStub::GenerateAssembly(CodeStubAssembler* assembler) const {
-  using compiler::Node;
-
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
-  Node* value = assembler->Word32And(lhs_value, rhs_value);
-  Node* result = assembler->ChangeInt32ToTagged(value);
-  assembler->Return(result);
-}
-
-void ModulusStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+// static
+compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
+                                      compiler::Node* left,
+                                      compiler::Node* right,
+                                      compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* context = assembler->Parameter(2);
-
   // Shared entry point for floating point modulus.
   Label do_fmod(assembler);
   Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
       var_divisor_float64(assembler, MachineRepresentation::kFloat64);
 
   Node* number_map = assembler->HeapNumberMapConstant();
 
   // We might need to loop one or two times due to ToNumber conversions.
   Variable var_dividend(assembler, MachineRepresentation::kTagged),
       var_divisor(assembler, MachineRepresentation::kTagged);
   Variable* loop_variables[] = {&var_dividend, &var_divisor};
   Label loop(assembler, 2, loop_variables);
-  var_dividend.Bind(assembler->Parameter(0));
-  var_divisor.Bind(assembler->Parameter(1));
+  var_dividend.Bind(left);
+  var_divisor.Bind(right);
   assembler->Goto(&loop);
   assembler->Bind(&loop);
   {
     Node* dividend = var_dividend.value();
     Node* divisor = var_divisor.value();
 
     Label dividend_is_smi(assembler), dividend_is_not_smi(assembler);
     assembler->Branch(assembler->WordIsSmi(dividend), &dividend_is_smi,
                       &dividend_is_not_smi);
 
@@ skipping 26 matching lines @@
           // Convert {dividend} to a double and compute its modulus with the
           // value of {dividend}.
           var_dividend_float64.Bind(assembler->SmiToFloat64(dividend));
           var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
           assembler->Goto(&do_fmod);
         }
 
         assembler->Bind(&divisor_is_not_number);
         {
           // Convert {divisor} to a number and loop.
-          Callable callable = CodeFactory::NonNumberToNumber(isolate());
+          Callable callable =
+              CodeFactory::NonNumberToNumber(assembler->isolate());
           var_divisor.Bind(assembler->CallStub(callable, context, divisor));
           assembler->Goto(&loop);
         }
       }
     }
 
     assembler->Bind(&dividend_is_not_smi);
     {
       Node* dividend_map = assembler->LoadMap(dividend);
 
@@ skipping 34 matching lines @@
             // Both {dividend} and {divisor} are HeapNumbers. Load their values
             // and compute their modulus.
             var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend));
             var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor));
             assembler->Goto(&do_fmod);
           }
 
           assembler->Bind(&divisor_is_not_number);
           {
             // Convert {divisor} to a number and loop.
-            Callable callable = CodeFactory::NonNumberToNumber(isolate());
+            Callable callable =
+                CodeFactory::NonNumberToNumber(assembler->isolate());
             var_divisor.Bind(assembler->CallStub(callable, context, divisor));
             assembler->Goto(&loop);
           }
         }
       }
 
       assembler->Bind(&dividend_is_not_number);
       {
         // Convert {dividend} to a Number and loop.
-        Callable callable = CodeFactory::NonNumberToNumber(isolate());
+        Callable callable =
+            CodeFactory::NonNumberToNumber(assembler->isolate());
         var_dividend.Bind(assembler->CallStub(callable, context, dividend));
         assembler->Goto(&loop);
       }
     }
   }
 
   assembler->Bind(&do_fmod);
   {
     Node* value = assembler->Float64Mod(var_dividend_float64.value(),
                                         var_divisor_float64.value());
     Node* result = assembler->ChangeFloat64ToTagged(value);
-    assembler->Return(result);
+    return result;
   }
 }
 
-void ShiftLeftStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+// static
+compiler::Node* ShiftLeftStub::Generate(CodeStubAssembler* assembler,
+                                        compiler::Node* left,
+                                        compiler::Node* right,
+                                        compiler::Node* context) {
   using compiler::Node;
 
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
   Node* value = assembler->Word32Shl(lhs_value, shift_count);
   Node* result = assembler->ChangeInt32ToTagged(value);
-  assembler->Return(result);
+  return result;
 }
 
-void ShiftRightStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+compiler::Node* ShiftRightStub::Generate(CodeStubAssembler* assembler,
+                                         compiler::Node* left,
+                                         compiler::Node* right,
+                                         compiler::Node* context) {
   using compiler::Node;
 
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
   Node* value = assembler->Word32Sar(lhs_value, shift_count);
   Node* result = assembler->ChangeInt32ToTagged(value);
-  assembler->Return(result);
+  return result;
 }
 
-void ShiftRightLogicalStub::GenerateAssembly(
-    CodeStubAssembler* assembler) const {
+compiler::Node* ShiftRightLogicalStub::Generate(CodeStubAssembler* assembler,
+                                                compiler::Node* left,
+                                                compiler::Node* right,
+                                                compiler::Node* context) {
   using compiler::Node;
 
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
   Node* value = assembler->Word32Shr(lhs_value, shift_count);
   Node* result = assembler->ChangeUint32ToTagged(value);
-  assembler->Return(result);
+  return result;
 }
 
-void BitwiseOrStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+compiler::Node* BitwiseAndStub::Generate(CodeStubAssembler* assembler,
+                                         compiler::Node* left,
+                                         compiler::Node* right,
+                                         compiler::Node* context) {
   using compiler::Node;
 
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
+  Node* value = assembler->Word32And(lhs_value, rhs_value);
+  Node* result = assembler->ChangeInt32ToTagged(value);
+  return result;
+}
+
+compiler::Node* BitwiseOrStub::Generate(CodeStubAssembler* assembler,
+                                        compiler::Node* left,
+                                        compiler::Node* right,
+                                        compiler::Node* context) {
+  using compiler::Node;
+
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* value = assembler->Word32Or(lhs_value, rhs_value);
   Node* result = assembler->ChangeInt32ToTagged(value);
-  assembler->Return(result);
+  return result;
 }
 
-void BitwiseXorStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+compiler::Node* BitwiseXorStub::Generate(CodeStubAssembler* assembler,
+                                         compiler::Node* left,
+                                         compiler::Node* right,
+                                         compiler::Node* context) {
   using compiler::Node;
-
-  Node* lhs = assembler->Parameter(0);
-  Node* rhs = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
-  Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
-  Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* value = assembler->Word32Xor(lhs_value, rhs_value);
   Node* result = assembler->ChangeInt32ToTagged(value);
-  assembler->Return(result);
+  return result;
 }
 
 namespace {
 
 enum RelationalComparisonMode {
   kLessThan,
   kLessThanOrEqual,
   kGreaterThan,
   kGreaterThanOrEqual
 };
@@ skipping 2494 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8