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

src/code-stub-assembler.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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 20 matching lines @@
   Label ok(this);
   Comment("[ Assert");
   GotoIf(condition, &ok);
   DebugBreak();
   Goto(&ok);
   Bind(&ok);
   Comment("] Assert");
 #endif
 }
 
-Node* CodeStubAssembler::NoContextConstant() {
-  return SmiConstant(Smi::FromInt(0));
-}
+Node* CodeStubAssembler::NoContextConstant() { return SmiConstant(Smi::kZero); }
 
 #define HEAP_CONSTANT_ACCESSOR(rootName, name)     \
   Node* CodeStubAssembler::name##Constant() {      \
     return LoadRoot(Heap::k##rootName##RootIndex); \
   }
 HEAP_CONSTANT_LIST(HEAP_CONSTANT_ACCESSOR);
 #undef HEAP_CONSTANT_ACCESSOR
 
 #define HEAP_CONSTANT_TEST(rootName, name)         \
   Node* CodeStubAssembler::Is##name(Node* value) { \
@@ skipping 553 matching lines @@
   Variable result(this, MachineRepresentation::kTagged);
   Label runtime_call(this, Label::kDeferred), no_runtime_call(this);
   Label merge_runtime(this, &result);
 
   Node* new_top = IntPtrAdd(top, size_in_bytes);
   Branch(UintPtrGreaterThanOrEqual(new_top, limit), &runtime_call,
          &no_runtime_call);
 
   Bind(&runtime_call);
   // AllocateInTargetSpace does not use the context.
-  Node* context = SmiConstant(Smi::FromInt(0));
+  Node* context = SmiConstant(Smi::kZero);
 
   Node* runtime_result;
   if (flags & kPretenured) {
     Node* runtime_flags = SmiConstant(
         Smi::FromInt(AllocateDoubleAlignFlag::encode(false) |
                      AllocateTargetSpace::encode(AllocationSpace::OLD_SPACE)));
     runtime_result = CallRuntime(Runtime::kAllocateInTargetSpace, context,
                                  SmiTag(size_in_bytes), runtime_flags);
   } else {
     runtime_result = CallRuntime(Runtime::kAllocateInNewSpace, context,
@@ skipping 1042 matching lines @@
 
 void CodeStubAssembler::CopyStringCharacters(compiler::Node* from_string,
                                              compiler::Node* to_string,
                                              compiler::Node* from_index,
                                              compiler::Node* character_count,
                                              String::Encoding encoding) {
   Label out(this);
 
   // Nothing to do for zero characters.
 
-  GotoIf(SmiLessThanOrEqual(character_count, SmiConstant(Smi::FromInt(0))),
-         &out);
+  GotoIf(SmiLessThanOrEqual(character_count, SmiConstant(Smi::kZero)), &out);
 
   // Calculate offsets into the strings.
 
   Node* from_offset;
   Node* limit_offset;
   Node* to_offset;
 
   {
     Node* byte_count = SmiUntag(character_count);
     Node* from_byte_index = SmiUntag(from_index);
@@ skipping 1035 matching lines @@
     var_result.Bind(StringFromCharCode(char_code));
     Goto(&end);
   }
 
   Bind(&original_string_or_invalid_length);
   {
     // Longer than original string's length or negative: unsafe arguments.
     GotoIf(SmiAbove(substr_length, string_length), &runtime);
 
     // Equal length - check if {from, to} == {0, str.length}.
-    GotoIf(SmiAbove(from, SmiConstant(Smi::FromInt(0))), &runtime);
+    GotoIf(SmiAbove(from, SmiConstant(Smi::kZero)), &runtime);
 
     // Return the original string (substr_length == string_length).
 
     Counters* counters = isolate()->counters();
     IncrementCounter(counters->sub_string_native(), 1);
 
     var_result.Bind(string);
     Goto(&end);
   }
 
@@ skipping 300 matching lines @@
 
     Bind(&if_argisnotheapnumber);
     {
       // Need to convert {arg} to a Number first.
       Callable callable = CodeFactory::NonNumberToNumber(isolate());
       var_arg.Bind(CallStub(callable, context, arg));
       Goto(&loop);
     }
 
     Bind(&return_zero);
-    var_arg.Bind(SmiConstant(Smi::FromInt(0)));
+    var_arg.Bind(SmiConstant(Smi::kZero));
     Goto(&out);
   }
 
   Bind(&out);
   return var_arg.value();
 }
 
 Node* CodeStubAssembler::BitFieldDecode(Node* word32, uint32_t shift,
                                         uint32_t mask) {
   return Word32Shr(Word32And(word32, Int32Constant(mask)),
@@ skipping 2571 matching lines @@
       BranchIfWordEqual(current_js_object.value(), NullConstant(), use_cache,
                         &next);
     }
   }
 
   Bind(&next);
   {
     // For all objects but the receiver, check that the cache is empty.
     current_map.Bind(LoadMap(current_js_object.value()));
     Node* enum_length = EnumLength(current_map.value());
-    Node* zero_constant = SmiConstant(Smi::FromInt(0));
+    Node* zero_constant = SmiConstant(Smi::kZero);
     BranchIf(WordEqual(enum_length, zero_constant), &loop, use_runtime);
   }
 }
 
 Node* CodeStubAssembler::CreateAllocationSiteInFeedbackVector(
     Node* feedback_vector, Node* slot) {
   Node* size = IntPtrConstant(AllocationSite::kSize);
   Node* site = Allocate(size, CodeStubAssembler::kPretenured);
 
   // Store the map
@@ skipping 1481 matching lines @@
     result.Bind(CallRuntime(Runtime::kInstanceOf, context, object, callable));
     Goto(&end);
   }
 
   Bind(&end);
   return result.value();
 }
 
 }  // namespace internal
 }  // namespace v8