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

src/ia32/code-stubs-ia32.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.
 
 #if V8_TARGET_ARCH_IA32
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
@@ skipping 1044 matching lines @@
   if (cc == equal && strict()) {
     Label slow;  // Fallthrough label.
     Label not_smis;
     // If we're doing a strict equality comparison, we don't have to do
     // type conversion, so we generate code to do fast comparison for objects
     // and oddballs. Non-smi numbers and strings still go through the usual
     // slow-case code.
     // If either is a Smi (we know that not both are), then they can only
     // be equal if the other is a HeapNumber. If so, use the slow case.
     STATIC_ASSERT(kSmiTag == 0);
-    DCHECK_EQ(static_cast<Smi*>(0), Smi::FromInt(0));
+    DCHECK_EQ(static_cast<Smi*>(0), Smi::kZero);
     __ mov(ecx, Immediate(kSmiTagMask));
     __ and_(ecx, eax);
     __ test(ecx, edx);
     __ j(not_zero, &not_smis, Label::kNear);
     // One operand is a smi.
 
     // Check whether the non-smi is a heap number.
     STATIC_ASSERT(kSmiTagMask == 1);
     // ecx still holds eax & kSmiTag, which is either zero or one.
     __ sub(ecx, Immediate(0x01));
@@ skipping 2404 matching lines @@
   // - esp[16]   -- slot
   // - esp[20]   -- value
   //
   // Required stack layout for handler call (see StoreWithVectorDescriptor):
   // - esp[0]    -- return address
   // - esp[4]    -- vector
   // - esp[8]    -- slot
   // - esp[12]   -- value
   // - receiver, key, handler in registers.
   Register counter = key;
-  __ mov(counter, Immediate(Smi::FromInt(0)));
+  __ mov(counter, Immediate(Smi::kZero));
   __ bind(&next_loop);
   __ mov(cached_map, FieldOperand(feedback, counter, times_half_pointer_size,
                                   FixedArray::kHeaderSize));
   __ cmp(receiver_map, FieldOperand(cached_map, WeakCell::kValueOffset));
   __ j(not_equal, &prepare_next);
   __ mov(cached_map, FieldOperand(feedback, counter, times_half_pointer_size,
                                   FixedArray::kHeaderSize + kPointerSize));
   __ CompareRoot(cached_map, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, &transition_call);
   __ mov(feedback, FieldOperand(feedback, counter, times_half_pointer_size,
@@ skipping 702 matching lines @@
     Label allocate, done_allocate;
     __ Allocate(JSArray::kSize, eax, edx, ecx, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the rest parameter array in rax.
     __ LoadGlobalFunction(Context::JS_ARRAY_FAST_ELEMENTS_MAP_INDEX, ecx);
     __ mov(FieldOperand(eax, JSArray::kMapOffset), ecx);
     __ mov(ecx, isolate()->factory()->empty_fixed_array());
     __ mov(FieldOperand(eax, JSArray::kPropertiesOffset), ecx);
     __ mov(FieldOperand(eax, JSArray::kElementsOffset), ecx);
-    __ mov(FieldOperand(eax, JSArray::kLengthOffset),
-           Immediate(Smi::FromInt(0)));
+    __ mov(FieldOperand(eax, JSArray::kLengthOffset), Immediate(Smi::kZero));
     STATIC_ASSERT(JSArray::kSize == 4 * kPointerSize);
     __ Ret();
 
     // Fall back to %AllocateInNewSpace.
     __ bind(&allocate);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ Push(Smi::FromInt(JSArray::kSize));
       __ CallRuntime(Runtime::kAllocateInNewSpace);
     }
@@ skipping 20 matching lines @@
                         JSArray::kSize + FixedArray::kHeaderSize));
     __ Allocate(ecx, edx, edi, no_reg, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the elements array in edx.
     __ mov(FieldOperand(edx, FixedArray::kMapOffset),
            isolate()->factory()->fixed_array_map());
     __ mov(FieldOperand(edx, FixedArray::kLengthOffset), eax);
     {
       Label loop, done_loop;
-      __ Move(ecx, Smi::FromInt(0));
+      __ Move(ecx, Smi::kZero);
       __ bind(&loop);
       __ cmp(ecx, eax);
       __ j(equal, &done_loop, Label::kNear);
       __ mov(edi, Operand(ebx, 0 * kPointerSize));
       __ mov(FieldOperand(edx, ecx, times_half_pointer_size,
                           FixedArray::kHeaderSize),
              edi);
       __ sub(ebx, Immediate(1 * kPointerSize));
       __ add(ecx, Immediate(Smi::FromInt(1)));
       __ jmp(&loop);
@@ skipping 368 matching lines @@
                  JSStrictArgumentsObject::kSize + FixedArray::kHeaderSize));
   __ Allocate(ecx, edx, edi, no_reg, &allocate, NO_ALLOCATION_FLAGS);
   __ bind(&done_allocate);
 
   // Setup the elements array in edx.
   __ mov(FieldOperand(edx, FixedArray::kMapOffset),
          isolate()->factory()->fixed_array_map());
   __ mov(FieldOperand(edx, FixedArray::kLengthOffset), eax);
   {
     Label loop, done_loop;
-    __ Move(ecx, Smi::FromInt(0));
+    __ Move(ecx, Smi::kZero);
     __ bind(&loop);
     __ cmp(ecx, eax);
     __ j(equal, &done_loop, Label::kNear);
     __ mov(edi, Operand(ebx, 0 * kPointerSize));
     __ mov(FieldOperand(edx, ecx, times_half_pointer_size,
                         FixedArray::kHeaderSize),
            edi);
     __ sub(ebx, Immediate(1 * kPointerSize));
     __ add(ecx, Immediate(Smi::FromInt(1)));
     __ jmp(&loop);
@@ skipping 498 matching lines @@
   DCHECK(!AreAliased(receiver, holder, callback, scratch));
 
   __ pop(scratch);  // Pop return address to extend the frame.
   __ push(receiver);
   __ push(FieldOperand(callback, AccessorInfo::kDataOffset));
   __ PushRoot(Heap::kUndefinedValueRootIndex);  // ReturnValue
   // ReturnValue default value
   __ PushRoot(Heap::kUndefinedValueRootIndex);
   __ push(Immediate(ExternalReference::isolate_address(isolate())));
   __ push(holder);
-  __ push(Immediate(Smi::FromInt(0)));  // should_throw_on_error -> false
+  __ push(Immediate(Smi::kZero));  // should_throw_on_error -> false
   __ push(FieldOperand(callback, AccessorInfo::kNameOffset));
   __ push(scratch);  // Restore return address.
 
   // v8::PropertyCallbackInfo::args_ array and name handle.
   const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1;
 
   // Allocate v8::PropertyCallbackInfo object, arguments for callback and
   // space for optional callback address parameter (in case CPU profiler is
   // active) in non-GCed stack space.
   const int kApiArgc = 3 + 1;
@@ skipping 30 matching lines @@
                            kStackUnwindSpace, nullptr, return_value_operand,
                            NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_IA32