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

src/type-feedback-vector.cc

 // Copyright 2014 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/type-feedback-vector.h"
 
 #include "src/code-stubs.h"
 #include "src/ic/ic.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 73 matching lines @@
       DCHECK_EQ(FeedbackVectorSlotKind::INVALID, kind);
     }
     i += entry_size;
   }
 #endif
 
   Handle<FixedArray> array = factory->NewFixedArray(length, TENURED);
   array->set(kSlotsCountIndex, Smi::FromInt(slot_count));
   // Fill the bit-vector part with zeros.
   for (int i = 0; i < slot_kinds_length; i++) {
-    array->set(kReservedIndexCount + i, Smi::kZero);
+    array->set(kReservedIndexCount + i, Smi::FromInt(0));
   }
 
   Handle<TypeFeedbackMetadata> metadata =
       Handle<TypeFeedbackMetadata>::cast(array);
 
   // Add names to NamesTable.
   const int name_count = spec->name_count();
 
   Handle<UnseededNumberDictionary> names;
   if (name_count) {
     names = UnseededNumberDictionary::New(isolate, name_count, TENURED);
   }
 
   int name_index = 0;
   for (int i = 0; i < slot_count; i++) {
     FeedbackVectorSlotKind kind = spec->GetKind(i);
     metadata->SetKind(FeedbackVectorSlot(i), kind);
     if (SlotRequiresName(kind)) {
       Handle<String> name = spec->GetName(name_index);
       DCHECK(!name.is_null());
       Handle<UnseededNumberDictionary> new_names =
           UnseededNumberDictionary::AtNumberPut(names, i, name);
       DCHECK_EQ(*new_names, *names);
       names = new_names;
       name_index++;
     }
   }
   DCHECK_EQ(name_count, name_index);
   metadata->set(kNamesTableIndex,
-                name_count ? static_cast<Object*>(*names) : Smi::kZero);
+                name_count ? static_cast<Object*>(*names) : Smi::FromInt(0));
 
   // It's important that the TypeFeedbackMetadata have a COW map, since it's
   // pointed to by both a SharedFunctionInfo and indirectly by closures through
   // the TypeFeedbackVector. The serializer uses the COW map type to decide
   // this object belongs in the startup snapshot and not the partial
   // snapshot(s).
   metadata->set_map(isolate->heap()->fixed_cow_array_map());
 
   return metadata;
 }
@@ skipping 99 matching lines @@
 
   const int slot_count = metadata->slot_count();
   const int length = slot_count + kReservedIndexCount;
   if (length == kReservedIndexCount) {
     return Handle<TypeFeedbackVector>::cast(
         factory->empty_type_feedback_vector());
   }
 
   Handle<FixedArray> array = factory->NewFixedArray(length, TENURED);
   array->set(kMetadataIndex, *metadata);
-  array->set(kInvocationCountIndex, Smi::kZero);
+  array->set(kInvocationCountIndex, Smi::FromInt(0));
 
   DisallowHeapAllocation no_gc;
 
   // Ensure we can skip the write barrier
   Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
   DCHECK_EQ(*factory->uninitialized_symbol(), *uninitialized_sentinel);
   for (int i = 0; i < slot_count;) {
     FeedbackVectorSlot slot(i);
     FeedbackVectorSlotKind kind = metadata->GetKind(slot);
     int index = TypeFeedbackVector::GetIndex(slot);
     int entry_size = TypeFeedbackMetadata::GetSlotSize(kind);
 
     Object* value;
     if (kind == FeedbackVectorSlotKind::LOAD_GLOBAL_IC) {
       value = *factory->empty_weak_cell();
     } else if (kind == FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC ||
                kind == FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC) {
-      value = Smi::kZero;
+      value = Smi::FromInt(0);
     } else {
       value = *uninitialized_sentinel;
     }
     array->set(index, value, SKIP_WRITE_BARRIER);
 
-    value = kind == FeedbackVectorSlotKind::CALL_IC ? Smi::kZero
+    value = kind == FeedbackVectorSlotKind::CALL_IC ? Smi::FromInt(0)
                                                     : *uninitialized_sentinel;
     for (int j = 1; j < entry_size; j++) {
       array->set(index + j, value, SKIP_WRITE_BARRIER);
     }
     i += entry_size;
   }
   return Handle<TypeFeedbackVector>::cast(array);
 }
 
 
@@ skipping 65 matching lines @@
         }
         case FeedbackVectorSlotKind::KEYED_STORE_IC: {
           KeyedStoreICNexus nexus(this, slot);
           nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::INTERPRETER_BINARYOP_IC:
         case FeedbackVectorSlotKind::INTERPRETER_COMPARE_IC: {
           DCHECK(Get(slot)->IsSmi());
           // don't clear these smi slots.
-          // Set(slot, Smi::kZero);
+          // Set(slot, Smi::FromInt(0));
           break;
         }
         case FeedbackVectorSlotKind::GENERAL: {
           if (obj->IsHeapObject()) {
             InstanceType instance_type =
                 HeapObject::cast(obj)->map()->instance_type();
             // AllocationSites are exempt from clearing. They don't store Maps
             // or Code pointers which can cause memory leaks if not cleared
             // regularly.
             if (instance_type != ALLOCATION_SITE_TYPE) {
@@ skipping 285 matching lines @@
   double const call_count = ExtractCallCount();
   return static_cast<float>(call_count / invocation_count);
 }
 
 void CallICNexus::Clear(Code* host) { CallIC::Clear(GetIsolate(), host, this); }
 
 void CallICNexus::ConfigureUninitialized() {
   Isolate* isolate = GetIsolate();
   SetFeedback(*TypeFeedbackVector::UninitializedSentinel(isolate),
               SKIP_WRITE_BARRIER);
-  SetFeedbackExtra(Smi::kZero, SKIP_WRITE_BARRIER);
+  SetFeedbackExtra(Smi::FromInt(0), SKIP_WRITE_BARRIER);
 }
 
 void CallICNexus::ConfigureMonomorphicArray() {
   Object* feedback = GetFeedback();
   if (!feedback->IsAllocationSite()) {
     Handle<AllocationSite> new_site =
         GetIsolate()->factory()->NewAllocationSite();
     SetFeedback(*new_site);
   }
   SetFeedbackExtra(Smi::FromInt(1), SKIP_WRITE_BARRIER);
@@ skipping 409 matching lines @@
   return BinaryOperationHintFromFeedback(feedback);
 }
 
 CompareOperationHint CompareICNexus::GetCompareOperationFeedback() const {
   int feedback = Smi::cast(GetFeedback())->value();
   return CompareOperationHintFromFeedback(feedback);
 }
 
 }  // namespace internal
 }  // namespace v8