Hydrogen: fix keyed loads with string keys

src/ic/ic-compiler.cc

Index: src/ic/ic-compiler.cc
diff --git a/src/ic/ic-compiler.cc b/src/ic/ic-compiler.cc
index 1f6eb4e0794777b90dfc239c930c3519335d3f2b..e95d4eda9e29e5928ab5667c705a69af175592e7 100644
--- a/src/ic/ic-compiler.cc
+++ b/src/ic/ic-compiler.cc
@@ -63,6 +63,11 @@ Handle<Code> PropertyICCompiler::ComputeMonomorphic(
         KeyedStoreIC::IcCheckTypeField::update(extra_ic_state, PROPERTY);
     DCHECK(STANDARD_STORE ==
            KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
+  } else if (kind == Code::KEYED_LOAD_IC) {
+    // Update key type

[Jakob Kummerow, 2014/12/10 15:21:18]

nit: punctuation (but see comment on next line).

+    IcCheckType key_type = name->IsString() ? PROPERTY : ELEMENT;

[Jakob Kummerow, 2014/12/10 15:21:18]

This distinction doesn't make sense, we only ever come here to compile PROPERTY
handlers.
Also, when name is not a string, then it's a symbol, and treating symbol lookups
as elements accesses is clearly wrong.
See the KEYED_STORE_IC path right above -- when we're here, it's always a
property access.

+
+    extra_ic_state = KeyedLoadIC::ComputeExtraICState(key_type);
   }
 
   Handle<Code> ic;
@@ -84,16 +89,19 @@ Handle<Code> PropertyICCompiler::ComputeMonomorphic(
 
 
 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
-    Handle<Map> receiver_map) {
+    Handle<Map> receiver_map, IcCheckType key_type) {
   Isolate* isolate = receiver_map->GetIsolate();
-  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
+  ExtraICState extra_state =
+      KeyedLoadIC::ComputeExtraICState(key_type);
+  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC,
+                                                    extra_state);
   Handle<Name> name = isolate->factory()->KeyedLoadMonomorphic_string();
 
   Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   Handle<Code> stub = ComputeKeyedLoadMonomorphicHandler(receiver_map);
-  PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
+  PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC, extra_state);
   Handle<Code> code =
       compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
                                   isolate->factory()->empty_string(), ELEMENT);
@@ -253,9 +261,13 @@ Handle<Code> PropertyICCompiler::ComputeCompareNil(Handle<Map> receiver_map,
 
 // TODO(verwaest): Change this method so it takes in a TypeHandleList.
 Handle<Code> PropertyICCompiler::ComputeKeyedLoadPolymorphic(
-    MapHandleList* receiver_maps) {
+    MapHandleList* receiver_maps, IcCheckType key_type) {
   Isolate* isolate = receiver_maps->at(0)->GetIsolate();
-  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
+  ExtraICState extra_state =
+      KeyedLoadIC::ComputeExtraICState(key_type);
+  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC,
+                                         POLYMORPHIC,
+                                         extra_state);
   Handle<PolymorphicCodeCache> cache =
       isolate->factory()->polymorphic_code_cache();
   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
@@ -268,10 +280,10 @@ Handle<Code> PropertyICCompiler::ComputeKeyedLoadPolymorphic(
   CodeHandleList handlers(receiver_maps->length());
   ElementHandlerCompiler compiler(isolate);
   compiler.CompileElementHandlers(receiver_maps, &handlers);
-  PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC);
+  PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC, extra_state);
   Handle<Code> code = ic_compiler.CompilePolymorphic(
       &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
-      ELEMENT);
+      key_type);
 
   isolate->counters()->keyed_load_polymorphic_stubs()->Increment();