[stubs] Gets rid of the Smi(Add/Sub)WithOverflow macros.

This is done to introduce the correct bitcasts operator on the right nodes.

R=bmeurer@chromium.org
BUG=

Review-Url: https://codereview.chromium.org/2415133002
Cr-Commit-Position: refs/heads/master@{#40294}

src/builtins/builtins-number.cc

@@ -524,7 +524,9 @@ void Builtins::Generate_Add(CodeStubAssembler* assembler) {
       assembler->Bind(&if_rhsissmi);
       {
         // Try fast Smi addition first.
-        Node* pair = assembler->SmiAddWithOverflow(lhs, rhs);
+        Node* pair = assembler->IntPtrAddWithOverflow(
+            assembler->BitcastTaggedToWord(lhs),
+            assembler->BitcastTaggedToWord(rhs));
         Node* overflow = assembler->Projection(1, pair);
 
         // Check if the Smi additon overflowed.
@@ -539,7 +541,8 @@ void Builtins::Generate_Add(CodeStubAssembler* assembler) {
         }
 
         assembler->Bind(&if_notoverflow);
-        var_result.Bind(assembler->Projection(0, pair));
+        var_result.Bind(assembler->BitcastWordToTaggedSigned(
+            assembler->Projection(0, pair)));
         assembler->Goto(&end);
       }
 
@@ -886,7 +889,9 @@ void Builtins::Generate_Subtract(CodeStubAssembler* assembler) {
       assembler->Bind(&if_rhsissmi);
       {
         // Try a fast Smi subtraction first.
-        Node* pair = assembler->SmiSubWithOverflow(lhs, rhs);
+        Node* pair = assembler->IntPtrSubWithOverflow(
+            assembler->BitcastTaggedToWord(lhs),
+            assembler->BitcastTaggedToWord(rhs));
         Node* overflow = assembler->Projection(1, pair);
 
         // Check if the Smi subtraction overflowed.
@@ -902,7 +907,8 @@ void Builtins::Generate_Subtract(CodeStubAssembler* assembler) {
         }
 
         assembler->Bind(&if_notoverflow);
-        var_result.Bind(assembler->Projection(0, pair));
+        var_result.Bind(assembler->BitcastWordToTaggedSigned(
+            assembler->Projection(0, pair)));
         assembler->Goto(&end);
       }
 

src/code-stub-assembler.cc

@@ -296,19 +296,11 @@ Node* CodeStubAssembler::SmiAdd(Node* a, Node* b) {
       IntPtrAdd(BitcastTaggedToWord(a), BitcastTaggedToWord(b)));
 }
 
-Node* CodeStubAssembler::SmiAddWithOverflow(Node* a, Node* b) {
-  return IntPtrAddWithOverflow(BitcastTaggedToWord(a), BitcastTaggedToWord(b));
-}
-
 Node* CodeStubAssembler::SmiSub(Node* a, Node* b) {
   return BitcastWordToTaggedSigned(
       IntPtrSub(BitcastTaggedToWord(a), BitcastTaggedToWord(b)));
 }
 
-Node* CodeStubAssembler::SmiSubWithOverflow(Node* a, Node* b) {
-  return IntPtrSubWithOverflow(BitcastTaggedToWord(a), BitcastTaggedToWord(b));
-}
-
 Node* CodeStubAssembler::SmiEqual(Node* a, Node* b) {
   return WordEqual(BitcastTaggedToWord(a), BitcastTaggedToWord(b));
 }

src/code-stub-assembler.h

@@ -121,9 +121,7 @@ class CodeStubAssembler : public compiler::CodeAssembler {
 
   // Smi operations.
   compiler::Node* SmiAdd(compiler::Node* a, compiler::Node* b);
-  compiler::Node* SmiAddWithOverflow(compiler::Node* a, compiler::Node* b);
   compiler::Node* SmiSub(compiler::Node* a, compiler::Node* b);
-  compiler::Node* SmiSubWithOverflow(compiler::Node* a, compiler::Node* b);
   compiler::Node* SmiEqual(compiler::Node* a, compiler::Node* b);
   compiler::Node* SmiAbove(compiler::Node* a, compiler::Node* b);
   compiler::Node* SmiAboveOrEqual(compiler::Node* a, compiler::Node* b);

src/code-stubs.cc

@@ -692,7 +692,9 @@ compiler::Node* AddWithFeedbackStub::Generate(
     assembler->Bind(&if_rhsissmi);
     {
       // Try fast Smi addition first.
-      Node* pair = assembler->SmiAddWithOverflow(lhs, rhs);
+      Node* pair =
+          assembler->IntPtrAddWithOverflow(assembler->BitcastTaggedToWord(lhs),
+                                           assembler->BitcastTaggedToWord(rhs));
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi additon overflowed.
@@ -710,7 +712,8 @@ compiler::Node* AddWithFeedbackStub::Generate(
       {
         var_type_feedback.Bind(
             assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall));
-        var_result.Bind(assembler->Projection(0, pair));
+        var_result.Bind(assembler->BitcastWordToTaggedSigned(
+            assembler->Projection(0, pair)));
         assembler->Goto(&end);
       }
     }
@@ -852,7 +855,9 @@ compiler::Node* SubtractWithFeedbackStub::Generate(
     assembler->Bind(&if_rhsissmi);
     {
       // Try a fast Smi subtraction first.
-      Node* pair = assembler->SmiSubWithOverflow(lhs, rhs);
+      Node* pair =
+          assembler->IntPtrSubWithOverflow(assembler->BitcastTaggedToWord(lhs),
+                                           assembler->BitcastTaggedToWord(rhs));
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi subtraction overflowed.
@@ -872,7 +877,8 @@ compiler::Node* SubtractWithFeedbackStub::Generate(
       // lhs, rhs, result smi. combined - smi.
       var_type_feedback.Bind(
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall));
-      var_result.Bind(assembler->Projection(0, pair));
+      var_result.Bind(
+          assembler->BitcastWordToTaggedSigned(assembler->Projection(0, pair)));
       assembler->Goto(&end);
     }
 
@@ -1459,7 +1465,9 @@ compiler::Node* IncStub::Generate(CodeStubAssembler* assembler,
     {
       // Try fast Smi addition first.
       Node* one = assembler->SmiConstant(Smi::FromInt(1));
-      Node* pair = assembler->SmiAddWithOverflow(value, one);
+      Node* pair = assembler->IntPtrAddWithOverflow(
+          assembler->BitcastTaggedToWord(value),
+          assembler->BitcastTaggedToWord(one));
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi addition overflowed.
@@ -1470,7 +1478,8 @@ compiler::Node* IncStub::Generate(CodeStubAssembler* assembler,
       var_type_feedback.Bind(assembler->Word32Or(
           var_type_feedback.value(),
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall)));
-      result_var.Bind(assembler->Projection(0, pair));
+      result_var.Bind(
+          assembler->BitcastWordToTaggedSigned(assembler->Projection(0, pair)));
       assembler->Goto(&end);
 
       assembler->Bind(&if_overflow);
@@ -1569,7 +1578,9 @@ compiler::Node* DecStub::Generate(CodeStubAssembler* assembler,
     {
       // Try fast Smi subtraction first.
       Node* one = assembler->SmiConstant(Smi::FromInt(1));
-      Node* pair = assembler->SmiSubWithOverflow(value, one);
+      Node* pair = assembler->IntPtrSubWithOverflow(
+          assembler->BitcastTaggedToWord(value),
+          assembler->BitcastTaggedToWord(one));
       Node* overflow = assembler->Projection(1, pair);
 
       // Check if the Smi subtraction overflowed.
@@ -1580,7 +1591,8 @@ compiler::Node* DecStub::Generate(CodeStubAssembler* assembler,
       var_type_feedback.Bind(assembler->Word32Or(
           var_type_feedback.value(),
           assembler->Int32Constant(BinaryOperationFeedback::kSignedSmall)));
-      result_var.Bind(assembler->Projection(0, pair));
+      result_var.Bind(
+          assembler->BitcastWordToTaggedSigned(assembler->Projection(0, pair)));
       assembler->Goto(&end);
 
       assembler->Bind(&if_overflow);

src/interpreter/interpreter.cc

@@ -1226,7 +1226,8 @@ void Interpreter::DoAddSmi(InterpreterAssembler* assembler) {
   __ Bind(&fastpath);
   {
     // Try fast Smi addition first.
-    Node* pair = __ SmiAddWithOverflow(left, right);
+    Node* pair = __ IntPtrAddWithOverflow(__ BitcastTaggedToWord(left),
+                                          __ BitcastTaggedToWord(right));
     Node* overflow = __ Projection(1, pair);
 
     // Check if the Smi additon overflowed.
@@ -1236,7 +1237,7 @@ void Interpreter::DoAddSmi(InterpreterAssembler* assembler) {
     {
       __ UpdateFeedback(__ Int32Constant(BinaryOperationFeedback::kSignedSmall),
                         type_feedback_vector, slot_index);
-      var_result.Bind(__ Projection(0, pair));
+      var_result.Bind(__ BitcastWordToTaggedSigned(__ Projection(0, pair)));
       __ Goto(&end);
     }
   }
@@ -1279,7 +1280,8 @@ void Interpreter::DoSubSmi(InterpreterAssembler* assembler) {
   __ Bind(&fastpath);
   {
     // Try fast Smi subtraction first.
-    Node* pair = __ SmiSubWithOverflow(left, right);
+    Node* pair = __ IntPtrSubWithOverflow(__ BitcastTaggedToWord(left),
+                                          __ BitcastTaggedToWord(right));
     Node* overflow = __ Projection(1, pair);
 
     // Check if the Smi subtraction overflowed.
@@ -1289,7 +1291,7 @@ void Interpreter::DoSubSmi(InterpreterAssembler* assembler) {
     {
       __ UpdateFeedback(__ Int32Constant(BinaryOperationFeedback::kSignedSmall),
                         type_feedback_vector, slot_index);
-      var_result.Bind(__ Projection(0, pair));
+      var_result.Bind(__ BitcastWordToTaggedSigned(__ Projection(0, pair)));
       __ Goto(&end);
     }
   }