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..7d1fa4645a8fc854687a9769a0651297cc12ce5c 100644
--- a/src/ic/ic-compiler.cc
+++ b/src/ic/ic-compiler.cc
@@ -63,6 +63,9 @@ 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) {
+    extra_ic_state = KeyedLoadIC::IcCheckTypeField::update(extra_ic_state,
+                                                           PROPERTY);
   }
 
   Handle<Code> ic;
@@ -84,16 +87,20 @@ Handle<Code> PropertyICCompiler::ComputeMonomorphic(
 
 
 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
-    Handle<Map> receiver_map) {
+    Handle<Map> receiver_map,
+    ExtraICState extra_ic_state) {

[Jakob Kummerow, 2014/12/12 10:14:27]

If you insist on keeping this additional argument, please explain to me in which
cases it changes anything. I still don't think we need it, and I don't like
adding extra code and extra parameters that don't do anything.
(Same below in the polymorphic case.)

[indutny, 2014/12/12 13:05:37]

I'd either need to pass this, or StrictMode to be able to generate
extra_ic_state here. Which do you prefer?

[Jakob Kummerow, 2014/12/12 13:34:16]

Why do you need StrictMode? Loads don't depend on strict mode. We didn't need to
pass in anything before, and we don't want to change behavior for element loads
(or the way their stubs are compiled/cached/retrieved), and we also don't want
to toggle that bit arbitrarily: valid transitions are uninitialized -> ELEMENT
-> generic and uninitialized -> PROPERTY -> generic, but never ELEMENT ->
PROPERTY -> ELEMENT -> PROPERTY -> etc.

So why would we need to pass in anything now?

   Isolate* isolate = receiver_map->GetIsolate();
-  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
+  extra_ic_state = KeyedLoadIC::IcCheckTypeField::update(extra_ic_state,
+                                                         ELEMENT);
+  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC,
+                                                    extra_ic_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_ic_state);
   Handle<Code> code =
       compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
                                   isolate->factory()->empty_string(), ELEMENT);
@@ -253,9 +260,14 @@ 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,
+    ExtraICState extra_ic_state) {
   Isolate* isolate = receiver_maps->at(0)->GetIsolate();
-  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
+  extra_ic_state = KeyedLoadIC::IcCheckTypeField::update(extra_ic_state,
+                                                         ELEMENT);
+  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC,
+                                         POLYMORPHIC,
+                                         extra_ic_state);
   Handle<PolymorphicCodeCache> cache =
       isolate->factory()->polymorphic_code_cache();
   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
@@ -268,7 +280,7 @@ 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_ic_state);
   Handle<Code> code = ic_compiler.CompilePolymorphic(
       &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
       ELEMENT);