Basic support for tracking smi-only arrays on ia32.

src/elements.cc

 // 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 209 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ElementsAccessorBase);
 };
 
 
 class FastElementsAccessor
     : public ElementsAccessorBase<FastElementsAccessor, FixedArray> {
  public:
   static MaybeObject* DeleteCommon(JSObject* obj,
                                    uint32_t key) {
-    ASSERT(obj->HasFastElements() || obj->HasFastArgumentsElements());
+    ASSERT(obj->HasFastElements() ||
+           obj->HasFastSmiOnlyElements() ||
+           obj->HasFastArgumentsElements());
     Heap* heap = obj->GetHeap();
     FixedArray* backing_store = FixedArray::cast(obj->elements());
     if (backing_store->map() == heap->non_strict_arguments_elements_map()) {
       backing_store = FixedArray::cast(backing_store->get(1));
     } else {
       Object* writable;
       MaybeObject* maybe = obj->EnsureWritableFastElements();
       if (!maybe->ToObject(&writable)) return maybe;
       backing_store = FixedArray::cast(writable);
     }
@@ skipping 348 matching lines @@
       return elements_accessors_[EXTERNAL_PIXEL_ELEMENTS];
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void ElementsAccessor::InitializeOncePerProcess() {
   static struct ConcreteElementsAccessors {
+    // Use the fast element handler for smi-only arrays. The implementation is
+    // currently identical.
+    FastElementsAccessor fast_smi_elements_handler;
     FastElementsAccessor fast_elements_handler;
     FastDoubleElementsAccessor fast_double_elements_handler;
     DictionaryElementsAccessor dictionary_elements_handler;
     NonStrictArgumentsElementsAccessor non_strict_arguments_elements_handler;
     ExternalByteElementsAccessor byte_elements_handler;
     ExternalUnsignedByteElementsAccessor unsigned_byte_elements_handler;
     ExternalShortElementsAccessor short_elements_handler;
     ExternalUnsignedShortElementsAccessor unsigned_short_elements_handler;
     ExternalIntElementsAccessor int_elements_handler;
     ExternalUnsignedIntElementsAccessor unsigned_int_elements_handler;
     ExternalFloatElementsAccessor float_elements_handler;
     ExternalDoubleElementsAccessor double_elements_handler;
     PixelElementsAccessor pixel_elements_handler;
   } element_accessors;
 
   static ElementsAccessor* accessor_array[] = {
+    &element_accessors.fast_smi_elements_handler,
     &element_accessors.fast_elements_handler,
     &element_accessors.fast_double_elements_handler,
     &element_accessors.dictionary_elements_handler,
     &element_accessors.non_strict_arguments_elements_handler,
     &element_accessors.byte_elements_handler,
     &element_accessors.unsigned_byte_elements_handler,
     &element_accessors.short_elements_handler,
     &element_accessors.unsigned_short_elements_handler,
     &element_accessors.int_elements_handler,
     &element_accessors.unsigned_int_elements_handler,
     &element_accessors.float_elements_handler,
     &element_accessors.double_elements_handler,
     &element_accessors.pixel_elements_handler
   };
 
+  STATIC_ASSERT((sizeof(accessor_array) / sizeof(*accessor_array)) ==
+                kElementsKindCount);
+
   elements_accessors_ = accessor_array;
 }
 
 
 } }  // namespace v8::internal