Active smi-only optimizations for large array literals.

src/objects-inl.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1288 matching lines @@
 
 
 FixedArrayBase* JSObject::elements() {
   Object* array = READ_FIELD(this, kElementsOffset);
   ASSERT(array->HasValidElements());
   return static_cast<FixedArrayBase*>(array);
 }
 
 void JSObject::ValidateSmiOnlyElements() {
 #if DEBUG
-  if (FLAG_smi_only_arrays &&
-      map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS) {
+  if (map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS) {
     Heap* heap = GetHeap();
     // Don't use elements, since integrity checks will fail if there
     // are filler pointers in the array.
     FixedArray* fixed_array =
         reinterpret_cast<FixedArray*>(READ_FIELD(this, kElementsOffset));
     Map* map = fixed_array->map();
     // Arrays that have been shifted in place can't be verified.
     if (map != heap->raw_unchecked_one_pointer_filler_map() &&
         map != heap->raw_unchecked_two_pointer_filler_map() &&
         map != heap->free_space_map()) {
       for (int i = 0; i < fixed_array->length(); i++) {
         Object* current = fixed_array->get(i);
         ASSERT(current->IsSmi() || current == heap->the_hole_value());
       }
     }
   }
 #endif
 }
 
 
 MaybeObject* JSObject::EnsureCanContainNonSmiElements() {
 #if DEBUG
   ValidateSmiOnlyElements();
 #endif
-  if (FLAG_smi_only_arrays &&
-      (map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS)) {
+  if ((map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS)) {
     Object* obj;
     MaybeObject* maybe_obj = GetElementsTransitionMap(FAST_ELEMENTS);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
     set_map(Map::cast(obj));
   }
   return this;
 }
 
 
 MaybeObject* JSObject::EnsureCanContainElements(Object** objects,
                                                 uint32_t count) {
-  if (FLAG_smi_only_arrays &&
-      map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS) {
+  if (map()->elements_kind() == FAST_SMI_ONLY_ELEMENTS) {
     for (uint32_t i = 0; i < count; ++i) {
       Object* current = *objects++;
       if (!current->IsSmi() && current != GetHeap()->the_hole_value()) {
         return EnsureCanContainNonSmiElements();
       }
     }
   }
   return this;
 }
 
 
 MaybeObject* JSObject::EnsureCanContainElements(FixedArray* elements) {
-  if (FLAG_smi_only_arrays) {
-    Object** objects = reinterpret_cast<Object**>(
-        FIELD_ADDR(elements, elements->OffsetOfElementAt(0)));
-    return EnsureCanContainElements(objects, elements->length());
-  } else {
-    return this;
-  }
+  Object** objects = reinterpret_cast<Object**>(
+      FIELD_ADDR(elements, elements->OffsetOfElementAt(0)));
+  return EnsureCanContainElements(objects, elements->length());
 }
 
 
 void JSObject::set_elements(FixedArrayBase* value, WriteBarrierMode mode) {
   ASSERT((map()->has_fast_elements() ||
           map()->has_fast_smi_only_elements()) ==
          (value->map() == GetHeap()->fixed_array_map() ||
           value->map() == GetHeap()->fixed_cow_array_map()));
   ASSERT(map()->has_fast_double_elements() ==
          value->IsFixedDoubleArray());
@@ skipping 276 matching lines @@
 }
 
 
 Object* FixedArray::get(int index) {
   ASSERT(index >= 0 && index < this->length());
   return READ_FIELD(this, kHeaderSize + index * kPointerSize);
 }
 
 
 void FixedArray::set(int index, Smi* value) {
+  static int foo = 0;

[Jakob Kummerow, 2011/10/07 17:58:13]

debugging leftover?

[danno, 2011/10/10 11:26:33]

Done.

+  ++foo;
   ASSERT(map() != HEAP->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   ASSERT(reinterpret_cast<Object*>(value)->IsSmi());
   int offset = kHeaderSize + index * kPointerSize;
   WRITE_FIELD(this, offset, value);
 }
 
 
 void FixedArray::set(int index, Object* value) {
   ASSERT(map() != HEAP->fixed_cow_array_map());
@@ skipping 2966 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_