Prototype implementation of GET_OWN_PROPERTY intrinsic.

src/stub-cache.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/ast.h"
 #include "src/code-stubs.h"
@@ skipping 283 matching lines @@
 
 Handle<Code> PropertyICCompiler::ComputeLoad(Isolate* isolate,
                                              InlineCacheState ic_state,
                                              ExtraICState extra_state) {
   Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
   Handle<UnseededNumberDictionary> cache =
       isolate->factory()->non_monomorphic_cache();
   int entry = cache->FindEntry(isolate, flags);
   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
-  PropertyICCompiler compiler(isolate, Code::LOAD_IC);
+  PropertyICCompiler compiler(isolate, Code::LOAD_IC, extra_state);
   Handle<Code> code;
   if (ic_state == UNINITIALIZED) {
     code = compiler.CompileLoadInitialize(flags);
   } else if (ic_state == PREMONOMORPHIC) {
     code = compiler.CompileLoadPreMonomorphic(flags);
   } else if (ic_state == MEGAMORPHIC) {
     code = compiler.CompileLoadMegamorphic(flags);
   } else {
     UNREACHABLE();
   }
   FillCache(isolate, code);
   return code;
 }
 
 
+Handle<Code> PropertyICCompiler::ComputeKeyedLoad(Isolate* isolate,
+                                                  InlineCacheState ic_state,
+                                                  ExtraICState extra_state) {
+  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, ic_state, extra_state);
+  Handle<UnseededNumberDictionary> cache =
+      isolate->factory()->non_monomorphic_cache();
+  int entry = cache->FindEntry(isolate, flags);
+  if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
+
+  PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC, extra_state);
+  Handle<Code> code;
+  if (ic_state == UNINITIALIZED) {
+    code = compiler.CompileKeyedLoadInitialize(flags);
+  } else if (ic_state == PREMONOMORPHIC) {
+    code = compiler.CompileKeyedLoadPreMonomorphic(flags);
+  } else if (ic_state == GENERIC) {
+    code = compiler.CompileKeyedLoadGeneric(flags);
+  } else {
+    UNREACHABLE();
+  }
+  FillCache(isolate, code);
+  return code;
+}
+
+
 Handle<Code> PropertyICCompiler::ComputeStore(Isolate* isolate,
                                               InlineCacheState ic_state,
                                               ExtraICState extra_state) {
   Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
   Handle<UnseededNumberDictionary> cache =
       isolate->factory()->non_monomorphic_cache();
   int entry = cache->FindEntry(isolate, flags);
   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
   PropertyICCompiler compiler(isolate, Code::STORE_IC);
@@ skipping 328 matching lines @@
 
 
 Handle<Code> PropertyICCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
   LoadIC::GeneratePreMonomorphic(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0));
   return code;
 }
 
-
 Handle<Code> PropertyICCompiler::CompileLoadMegamorphic(Code::Flags flags) {
-  LoadIC::GenerateMegamorphic(masm());
+  LoadIC::GenerateMegamorphic(masm(), extra_ic_state_);
   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadMegamorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::LOAD_MEGAMORPHIC_TAG, *code, 0));
   return code;
 }
 
 
+Handle<Code> PropertyICCompiler::CompileKeyedLoadInitialize(Code::Flags flags) {
+  KeyedLoadIC::GenerateInitialize(masm());
+  Handle<Code> code = GetCodeWithFlags(flags, "CompileKeyedLoadInitialize");
+  PROFILE(isolate(),
+          CodeCreateEvent(Logger::LOAD_INITIALIZE_TAG, *code, 0)); // todo
+  return code;
+}
+
+
+Handle<Code> PropertyICCompiler::CompileKeyedLoadPreMonomorphic(Code::Flags flags) {
+  KeyedLoadIC::GeneratePreMonomorphic(masm());
+  Handle<Code> code = GetCodeWithFlags(flags, "CompileKeyedLoadPreMonomorphic");
+  PROFILE(isolate(),
+          CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0)); // todo
+  return code;
+}
+
+
+Handle<Code> PropertyICCompiler::CompileKeyedLoadGeneric(Code::Flags flags) {
+  KeyedLoadIC::GenerateGeneric(masm(), extra_ic_state_);
+  Handle<Code> code = GetCodeWithFlags(flags, "CompileKeyedGeneric");
+  PROFILE(isolate(),
+          CodeCreateEvent(Logger::LOAD_MEGAMORPHIC_TAG, *code, 0)); // todo
+  return code;
+}
+
+
 Handle<Code> PropertyICCompiler::CompileStoreInitialize(Code::Flags flags) {
   StoreIC::GenerateInitialize(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STORE_INITIALIZE_TAG, *code, 0));
   return code;
 }
 
 
 Handle<Code> PropertyICCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
@@ skipping 596 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal