Plumbing changes to merge various element kind implementaions.

src/ic.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 1052 matching lines @@
   }
 
 #ifdef DEBUG
   TraceIC("LoadIC", name, state, target());
 #endif
 }
 
 
 String* KeyedLoadIC::GetStubNameForCache(IC::State ic_state) {
   if (ic_state == MONOMORPHIC) {
-    return isolate()->heap()->KeyedLoadSpecializedMonomorphic_symbol();
+    return isolate()->heap()->KeyedLoadElementMonomorphic_symbol();
   } else {
     ASSERT(ic_state == MEGAMORPHIC);
-    return isolate()->heap()->KeyedLoadSpecializedPolymorphic_symbol();
+    return isolate()->heap()->KeyedLoadElementPolymorphic_symbol();
   }
 }
 
 
 MaybeObject* KeyedLoadIC::GetFastElementStubWithoutMapCheck(
     bool is_js_array) {
   return KeyedLoadFastElementStub().TryGetCode();
 }
 
 
 MaybeObject* KeyedLoadIC::GetExternalArrayStubWithoutMapCheck(
-    ExternalArrayType array_type) {
-  return KeyedLoadExternalArrayStub(array_type).TryGetCode();
+    JSObject::ElementsKind elements_kind) {
+  return KeyedLoadExternalArrayStub(elements_kind).TryGetCode();
 }
 
 
 MaybeObject* KeyedLoadIC::ConstructMegamorphicStub(
     MapList* receiver_maps,
     CodeList* targets,
     StrictModeFlag strict_mode) {
   Object* object;
   KeyedLoadStubCompiler compiler;
   MaybeObject* maybe_code = compiler.CompileLoadMegamorphic(receiver_maps,
@@ skipping 590 matching lines @@
     Code::Flags flags = Code::ComputeMonomorphicFlags(kind,
                                                       NORMAL,
                                                       strict_mode);
     String* monomorphic_name = GetStubNameForCache(MONOMORPHIC);
     Object* maybe_default_stub = receiver_map->FindInCodeCache(monomorphic_name,
                                                                flags);
     if (maybe_default_stub->IsUndefined()) {
       return generic_stub;
     }
     Code* default_stub = Code::cast(maybe_default_stub);
-    return GetExternalArrayStubWithoutMapCheck(
-        default_stub->external_array_type());
+    Map* first_map = default_stub->FindFirstMap();
+    return GetExternalArrayStubWithoutMapCheck(first_map->elements_kind());
   } else if (receiver_map->has_fast_elements()) {
     bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
     return GetFastElementStubWithoutMapCheck(is_js_array);
   } else {
     return generic_stub;
   }
 }
 
 
 MaybeObject* KeyedIC::ComputeMonomorphicStub(JSObject* receiver,
                                              bool is_store,
                                              StrictModeFlag strict_mode,
                                              Code* generic_stub) {
   Code* result = NULL;
-  if (receiver->HasExternalArrayElements()) {
+  if (receiver->HasFastElements() ||
+      receiver->HasExternalArrayElements()) {
     MaybeObject* maybe_stub =
-        isolate()->stub_cache()->ComputeKeyedLoadOrStoreExternalArray(
-            receiver, is_store, strict_mode);
-    if (!maybe_stub->To(&result)) return maybe_stub;
-  } else if (receiver->map()->has_fast_elements()) {
-    MaybeObject* maybe_stub =
-        isolate()->stub_cache()->ComputeKeyedLoadOrStoreFastElement(
+        isolate()->stub_cache()->ComputeKeyedLoadOrStoreElement(
             receiver, is_store, strict_mode);
     if (!maybe_stub->To(&result)) return maybe_stub;
   } else {
     result = generic_stub;
   }
   return result;
 }
 
 
 String* KeyedStoreIC::GetStubNameForCache(IC::State ic_state) {
   if (ic_state == MONOMORPHIC) {
-    return isolate()->heap()->KeyedStoreSpecializedMonomorphic_symbol();
+    return isolate()->heap()->KeyedStoreElementMonomorphic_symbol();
   } else {
     ASSERT(ic_state == MEGAMORPHIC);
-    return isolate()->heap()->KeyedStoreSpecializedPolymorphic_symbol();
+    return isolate()->heap()->KeyedStoreElementPolymorphic_symbol();
   }
 }
 
 
 MaybeObject* KeyedStoreIC::GetFastElementStubWithoutMapCheck(
     bool is_js_array) {
   return KeyedStoreFastElementStub(is_js_array).TryGetCode();
 }
 
 
 MaybeObject* KeyedStoreIC::GetExternalArrayStubWithoutMapCheck(
-    ExternalArrayType array_type) {
-  return KeyedStoreExternalArrayStub(array_type).TryGetCode();
+    JSObject::ElementsKind elements_kind) {
+  return KeyedStoreExternalArrayStub(elements_kind).TryGetCode();
 }
 
 
 MaybeObject* KeyedStoreIC::ConstructMegamorphicStub(
     MapList* receiver_maps,
     CodeList* targets,
     StrictModeFlag strict_mode) {
   Object* object;
   KeyedStoreStubCompiler compiler(strict_mode);
   MaybeObject* maybe_code = compiler.CompileStoreMegamorphic(receiver_maps,
@@ skipping 774 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal