Clean up code stubs and ensure distinct major keys.

src/code-stubs.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/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/cpu-profiler.h"
 #include "src/factory.h"
@@ skipping 250 matching lines @@
     os << "_CheckLeft";
   } else if ((flags() & STRING_ADD_CHECK_RIGHT) == STRING_ADD_CHECK_RIGHT) {
     os << "_CheckRight";
   }
   if (pretenure_flag() == TENURED) {
     os << "_Tenured";
   }
 }
 
 
-InlineCacheState ICCompareStub::GetICState() const {
+InlineCacheState CompareICStub::GetICState() const {
   CompareIC::State state = Max(left(), right());
   switch (state) {
     case CompareIC::UNINITIALIZED:
       return ::v8::internal::UNINITIALIZED;
     case CompareIC::SMI:
     case CompareIC::NUMBER:
     case CompareIC::INTERNALIZED_STRING:
     case CompareIC::STRING:
     case CompareIC::UNIQUE_NAME:
     case CompareIC::OBJECT:
     case CompareIC::KNOWN_OBJECT:
       return MONOMORPHIC;
     case CompareIC::GENERIC:
       return ::v8::internal::GENERIC;
   }
   UNREACHABLE();
   return ::v8::internal::UNINITIALIZED;
 }
 
 
-void ICCompareStub::AddToSpecialCache(Handle<Code> new_object) {
+void CompareICStub::AddToSpecialCache(Handle<Code> new_object) {
   DCHECK(*known_map_ != NULL);
   Isolate* isolate = new_object->GetIsolate();
   Factory* factory = isolate->factory();
   return Map::UpdateCodeCache(known_map_,
                               strict() ?
                                   factory->strict_compare_ic_string() :
                                   factory->compare_ic_string(),
                               new_object);
 }
 
 
-bool ICCompareStub::FindCodeInSpecialCache(Code** code_out) {
+bool CompareICStub::FindCodeInSpecialCache(Code** code_out) {
   Factory* factory = isolate()->factory();
   Code::Flags flags = Code::ComputeFlags(
       GetCodeKind(),
       UNINITIALIZED);
   DCHECK(op() == Token::EQ || op() == Token::EQ_STRICT);
   Handle<Object> probe(
       known_map_->FindInCodeCache(
         strict() ?
             *factory->strict_compare_ic_string() :
             *factory->compare_ic_string(),
         flags),
       isolate());
   if (probe->IsCode()) {
     *code_out = Code::cast(*probe);
 #ifdef DEBUG
-    ICCompareStub decode((*code_out)->stub_key());
+    CompareICStub decode((*code_out)->stub_key());
     DCHECK(op() == decode.op());
     DCHECK(left() == decode.left());
     DCHECK(right() == decode.right());
     DCHECK(state() == decode.state());
 #endif
     return true;
   }
   return false;
 }
 
 
-void ICCompareStub::Generate(MacroAssembler* masm) {
+void CompareICStub::Generate(MacroAssembler* masm) {
   switch (state()) {
     case CompareIC::UNINITIALIZED:
       GenerateMiss(masm);
       break;
     case CompareIC::SMI:
       GenerateSmis(masm);
       break;
     case CompareIC::NUMBER:
       GenerateNumbers(masm);
       break;
@@ skipping 369 matching lines @@
 
 
 void StringAddStub::InitializeInterfaceDescriptor(
     CodeStubInterfaceDescriptor* descriptor) {
   StringAddDescriptor call_descriptor(isolate());
   descriptor->Initialize(MajorKey(), call_descriptor,
                          Runtime::FunctionForId(Runtime::kStringAdd)->entry);
 }
 
 
-void LoadDictionaryElementPlatformStub::Generate(MacroAssembler* masm) {
-  ElementHandlerCompiler::GenerateLoadDictionaryElement(masm);
-}
-
-
 void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateAllocationSiteStub stub(isolate);
   stub.GetCode();
 }
 
 
 void StoreElementStub::Generate(MacroAssembler* masm) {
   switch (elements_kind()) {
     case FAST_ELEMENTS:
     case FAST_HOLEY_ELEMENTS:
@@ skipping 324 matching lines @@
   InstallDescriptor(isolate, &stub3);
 }
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(
     Isolate* isolate) : PlatformCodeStub(isolate) {
   InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
 } }  // namespace v8::internal