Create and use shared stub for for DictionaryValue-based elements.

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 1079 matching lines @@
 
     isolate()->stub_cache()->Set(*name, map, Code::cast(code));
   }
 
 #ifdef DEBUG
   TraceIC("LoadIC", name, state, target());
 #endif
 }
 
 
-MaybeObject* KeyedLoadIC::GetFastElementStubWithoutMapCheck(
-    bool is_js_array) {
-  return KeyedLoadFastElementStub().TryGetCode();
+MaybeObject* KeyedLoadIC::GetElementStubWithoutMapCheck(
+    bool is_js_array,
+    JSObject::ElementsKind elements_kind) {
+  return KeyedLoadElementStub(elements_kind).TryGetCode();
 }
 
 
-MaybeObject* KeyedLoadIC::GetExternalArrayStubWithoutMapCheck(
-    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,
                                                             targets);
   if (!maybe_code->ToObject(&object)) return maybe_code;
   isolate()->counters()->keyed_load_polymorphic_stubs()->Increment();
@@ skipping 546 matching lines @@
   // If there is a cached stub, use it.
   if (!maybe_cached_stub->IsUndefined()) {
     ASSERT(maybe_cached_stub->IsCode());
     return Code::cast(maybe_cached_stub);
   }
   // Collect MONOMORPHIC stubs for all target_receiver_maps.
   CodeList handler_ics(target_receiver_maps.length());
   for (int i = 0; i < target_receiver_maps.length(); ++i) {
     Map* receiver_map(target_receiver_maps.at(i));
     MaybeObject* maybe_cached_stub = ComputeMonomorphicStubWithoutMapCheck(
-        receiver_map, strict_mode, generic_stub);
+        receiver_map, strict_mode);
     Code* cached_stub;
     if (!maybe_cached_stub->To(&cached_stub)) return maybe_cached_stub;
     handler_ics.Add(cached_stub);
   }
   // Build the MEGAMORPHIC stub.
   Code* stub;
   MaybeObject* maybe_stub = ConstructMegamorphicStub(&target_receiver_maps,
                                                      &handler_ics,
                                                      strict_mode);
   if (!maybe_stub->To(&stub)) return maybe_stub;
   MaybeObject* maybe_update = cache->Update(&target_receiver_maps, flags, stub);
   if (maybe_update->IsFailure()) return maybe_update;
   return stub;
 }
 
 
 MaybeObject* KeyedIC::ComputeMonomorphicStubWithoutMapCheck(
     Map* receiver_map,
-    StrictModeFlag strict_mode,
-    Code* generic_stub) {
+    StrictModeFlag strict_mode) {
   if ((receiver_map->instance_type() & kNotStringTag) == 0) {
     ASSERT(string_stub() != NULL);
     return string_stub();
-  } else if (receiver_map->has_external_array_elements()) {
-    return GetExternalArrayStubWithoutMapCheck(receiver_map->elements_kind());
-  } else if (receiver_map->has_fast_elements()) {
+  } else {
+    ASSERT(receiver_map->has_dictionary_elements() ||
+           receiver_map->has_fast_elements() ||
+           receiver_map->has_fast_double_elements() ||
+           receiver_map->has_external_array_elements());
     bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
-    return GetFastElementStubWithoutMapCheck(is_js_array);
-  } else {
-    return generic_stub;
+    return GetElementStubWithoutMapCheck(is_js_array,
+                                         receiver_map->elements_kind());
   }
 }
 
 
 MaybeObject* KeyedIC::ComputeMonomorphicStub(JSObject* receiver,
                                              bool is_store,
                                              StrictModeFlag strict_mode,
                                              Code* generic_stub) {
   Code* result = NULL;
   if (receiver->HasFastElements() ||
       receiver->HasExternalArrayElements() ||
+      receiver->HasFastDoubleElements() ||
       receiver->HasDictionaryElements()) {
     MaybeObject* maybe_stub =
         isolate()->stub_cache()->ComputeKeyedLoadOrStoreElement(
             receiver, is_store, strict_mode);
     if (!maybe_stub->To(&result)) return maybe_stub;
   } else {
     result = generic_stub;
   }
   return result;
 }
 
 
-MaybeObject* KeyedStoreIC::GetFastElementStubWithoutMapCheck(
-    bool is_js_array) {
-  return KeyedStoreFastElementStub(is_js_array).TryGetCode();
+MaybeObject* KeyedStoreIC::GetElementStubWithoutMapCheck(
+    bool is_js_array,
+    JSObject::ElementsKind elements_kind) {
+  return KeyedStoreElementStub(is_js_array, elements_kind).TryGetCode();
 }
 
 
-MaybeObject* KeyedStoreIC::GetExternalArrayStubWithoutMapCheck(
-    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,
                                                              targets);
   if (!maybe_code->ToObject(&object)) return maybe_code;
   isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
@@ skipping 768 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal