Move extra_ic_state to the PropertyICCompiler

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 177 matching lines @@
   Handle<Map> current_map = stub_holder_map;
   Handle<JSObject> last(JSObject::cast(receiver_map->prototype()));
   while (true) {
     if (current_map->is_dictionary_map()) cache_name = name;
     if (current_map->prototype()->IsNull()) break;
     last = handle(JSObject::cast(current_map->prototype()));
     current_map = handle(last->map());
   }
   // Compile the stub that is either shared for all names or
   // name specific if there are global objects involved.
-  Code::Kind handler_kind = Code::LOAD_IC;
   Handle<Code> handler = PropertyHandlerCompiler::Find(
-      cache_name, stub_holder_map, handler_kind, flag, Code::FAST);
+      cache_name, stub_holder_map, Code::LOAD_IC, flag, Code::FAST);
   if (!handler.is_null()) return handler;
 
-  NamedLoadHandlerCompiler compiler(isolate_, handler_kind, kNoExtraICState,
-                                    flag);
+  NamedLoadHandlerCompiler compiler(isolate_, flag);
   handler = compiler.CompileLoadNonexistent(type, last, cache_name);
   Map::UpdateCodeCache(stub_holder_map, cache_name, handler);
   return handler;
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadElement(Handle<Map> receiver_map) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
   Handle<Name> name =
       isolate()->factory()->KeyedLoadElementMonomorphic_string();
@@ skipping 915 matching lines @@
     ASSERT_EQ(Code::KEYED_STORE_IC, kind);
     return keyed_store_calling_convention();
   }
 }
 
 
 Handle<Code> PropertyICCompiler::GetCode(Code::Kind kind, Code::StubType type,
                                          Handle<Name> name,
                                          InlineCacheState state) {
   Code::Flags flags =
-      Code::ComputeFlags(kind, state, extra_state(), type, cache_holder());
+      Code::ComputeFlags(kind, state, extra_ic_state_, type, cache_holder());
   Handle<Code> code = GetCodeWithFlags(flags, name);
   IC::RegisterWeakMapDependency(code);
   PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
   return code;
 }
 
 
 Handle<Code> PropertyHandlerCompiler::GetCode(Code::Kind kind,
                                               Code::StubType type,
                                               Handle<Name> name) {
-  ASSERT_EQ(kNoExtraICState, extra_state());
   Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder());
   Handle<Code> code = GetCodeWithFlags(flags, name);
   PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, *code, *name));
   return code;
 }
 
 
 void IndexedHandlerCompiler::CompileElementHandlers(
     MapHandleList* receiver_maps, CodeHandleList* handlers) {
   for (int i = 0; i < receiver_maps->length(); ++i) {
@@ skipping 196 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal