Add Smi::Zero and replace all Smi::FromInt(0) calls

src/builtins/builtins-string.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.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 
 namespace v8 {
@@ skipping 787 matching lines @@
 // and provide the proper functionality, so this is just a fallback.
 BUILTIN(StringPrototypeLocaleCompare) {
   HandleScope handle_scope(isolate);
   DCHECK_EQ(2, args.length());
 
   TO_THIS_STRING(str1, "String.prototype.localeCompare");
   Handle<String> str2;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, str2, Object::ToString(isolate, args.at<Object>(1)));
 
-  if (str1.is_identical_to(str2)) return Smi::FromInt(0);  // Equal.
+  if (str1.is_identical_to(str2)) return Smi::kZero;  // Equal.
   int str1_length = str1->length();
   int str2_length = str2->length();
 
   // Decide trivial cases without flattening.
   if (str1_length == 0) {
-    if (str2_length == 0) return Smi::FromInt(0);  // Equal.
+    if (str2_length == 0) return Smi::kZero;  // Equal.
     return Smi::FromInt(-str2_length);
   } else {
     if (str2_length == 0) return Smi::FromInt(str1_length);
   }
 
   int end = str1_length < str2_length ? str1_length : str2_length;
 
   // No need to flatten if we are going to find the answer on the first
   // character. At this point we know there is at least one character
   // in each string, due to the trivial case handling above.
@@ skipping 59 matching lines @@
   Label out(a), handle_length(a);
 
   Variable var_start(a, MachineRepresentation::kTagged);
   Variable var_length(a, MachineRepresentation::kTagged);
 
   Node* const receiver = a->Parameter(0);
   Node* const start = a->Parameter(1);
   Node* const length = a->Parameter(2);
   Node* const context = a->Parameter(5);
 
-  Node* const zero = a->SmiConstant(Smi::FromInt(0));
+  Node* const zero = a->SmiConstant(Smi::kZero);
 
   // Check that {receiver} is coercible to Object and convert it to a String.
   Node* const string =
       a->ToThisString(context, receiver, "String.prototype.substr");
 
   Node* const string_length = a->LoadStringLength(string);
 
   // Conversions and bounds-checks for {start}.
   {
     Node* const start_int =
@@ skipping 118 matching lines @@
     a->Branch(a->SmiAbove(value_int, limit), &if_isoutofbounds, &if_isinbounds);
 
     a->Bind(&if_isinbounds);
     {
       var_result.Bind(value_int);
       a->Goto(&out);
     }
 
     a->Bind(&if_isoutofbounds);
     {
-      Node* const zero = a->SmiConstant(Smi::FromInt(0));
+      Node* const zero = a->SmiConstant(Smi::kZero);
       var_result.Bind(a->Select(a->SmiLessThan(value_int, zero), zero, limit));
       a->Goto(&out);
     }
   }
 
   a->Bind(&if_isnotsmi);
   {
     // {value} is a heap number - in this case, it is definitely out of bounds.
     a->Assert(a->WordEqual(a->LoadMap(value_int), a->HeapNumberMapConstant()));
 
     Node* const float_zero = a->Float64Constant(0.);
-    Node* const smi_zero = a->SmiConstant(Smi::FromInt(0));
+    Node* const smi_zero = a->SmiConstant(Smi::kZero);
     Node* const value_float = a->LoadHeapNumberValue(value_int);
     var_result.Bind(a->Select(a->Float64LessThan(value_float, float_zero),
                               smi_zero, limit));
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
@@ skipping 112 matching lines @@
       assembler->IntPtrConstant(Context::STRING_ITERATOR_MAP_INDEX), 0,
       CodeStubAssembler::INTPTR_PARAMETERS);
   Node* iterator = assembler->Allocate(JSStringIterator::kSize);
   assembler->StoreMapNoWriteBarrier(iterator, map);
   assembler->StoreObjectFieldRoot(iterator, JSValue::kPropertiesOffset,
                                   Heap::kEmptyFixedArrayRootIndex);
   assembler->StoreObjectFieldRoot(iterator, JSObject::kElementsOffset,
                                   Heap::kEmptyFixedArrayRootIndex);
   assembler->StoreObjectFieldNoWriteBarrier(
       iterator, JSStringIterator::kStringOffset, string);
-  Node* index = assembler->SmiConstant(Smi::FromInt(0));
+  Node* index = assembler->SmiConstant(Smi::kZero);
   assembler->StoreObjectFieldNoWriteBarrier(
       iterator, JSStringIterator::kNextIndexOffset, index);
   assembler->Return(iterator);
 }
 
 namespace {
 
 // Return the |word32| codepoint at {index}. Supports SeqStrings and
 // ExternalStrings.
 compiler::Node* LoadSurrogatePairInternal(CodeStubAssembler* assembler,
@@ skipping 152 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler->HeapConstant(assembler->factory()->NewStringFromAsciiChecked(
             "String Iterator.prototype.next", TENURED)),
         iterator);
     assembler->Return(result);  // Never reached.
   }
 }
 
 }  // namespace internal
 }  // namespace v8