[stubs] Fixing issues found by machine graph verifier in code stubs.

src/builtins/builtins-number.cc

 // 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.
 
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
@@ skipping 1210 matching lines @@
     Bind(&dividend_is_smi);
     {
       Label divisor_is_smi(this), divisor_is_not_smi(this);
       Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
 
       Bind(&divisor_is_smi);
       {
         Label bailout(this);
 
         // Do floating point division if {divisor} is zero.
-        GotoIf(WordEqual(divisor, IntPtrConstant(0)), &bailout);
+        GotoIf(SmiEqual(divisor, SmiConstant(0)), &bailout);
 
         // Do floating point division {dividend} is zero and {divisor} is
         // negative.
         Label dividend_is_zero(this), dividend_is_not_zero(this);
-        Branch(WordEqual(dividend, IntPtrConstant(0)), &dividend_is_zero,
+        Branch(SmiEqual(dividend, SmiConstant(0)), &dividend_is_zero,
                &dividend_is_not_zero);
 
         Bind(&dividend_is_zero);
         {
-          GotoIf(IntPtrLessThan(divisor, IntPtrConstant(0)), &bailout);
+          GotoIf(SmiLessThan(divisor, SmiConstant(0)), &bailout);
           Goto(&dividend_is_not_zero);
         }
         Bind(&dividend_is_not_zero);
 
-        Node* untagged_divisor = SmiUntag(divisor);
-        Node* untagged_dividend = SmiUntag(dividend);
+        Node* untagged_divisor = SmiToWord32(divisor);
+        Node* untagged_dividend = SmiToWord32(dividend);
 
         // Do floating point division if {dividend} is kMinInt (or kMinInt - 1
         // if the Smi size is 31) and {divisor} is -1.
         Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);
         Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),
                &divisor_is_minus_one, &divisor_is_not_minus_one);
 
         Bind(&divisor_is_minus_one);
         {
           GotoIf(
               Word32Equal(untagged_dividend,
                           Int32Constant(kSmiValueSize == 32 ? kMinInt
                                                             : (kMinInt >> 1))),
               &bailout);
           Goto(&divisor_is_not_minus_one);
         }
         Bind(&divisor_is_not_minus_one);
 
         // TODO(epertoso): consider adding a machine instruction that returns
         // both the result and the remainder.
         Node* untagged_result = Int32Div(untagged_dividend, untagged_divisor);
         Node* truncated = Int32Mul(untagged_result, untagged_divisor);
         // Do floating point division if the remainder is not 0.
         GotoIf(Word32NotEqual(untagged_dividend, truncated), &bailout);
-        var_result.Bind(SmiTag(untagged_result));
+        var_result.Bind(SmiFromWord32(untagged_result));
         Goto(&end);
 
         // Bailout: convert {dividend} and {divisor} to double and do double
         // division.
         Bind(&bailout);
         {
           var_dividend_float64.Bind(SmiToFloat64(dividend));
           var_divisor_float64.Bind(SmiToFloat64(divisor));
           Goto(&do_fdiv);
         }
@@ skipping 323 matching lines @@
 TF_BUILTIN(StrictNotEqual, CodeStubAssembler) {
   Node* lhs = Parameter(0);
   Node* rhs = Parameter(1);
   Node* context = Parameter(2);
 
   Return(StrictEqual(kNegateResult, lhs, rhs, context));
 }
 
 }  // namespace internal
 }  // namespace v8