[stubs] Call interface descriptors cleanup.

src/code-stubs-hydrogen.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/code-stubs.h"
 
 #include <memory>
 
 #include "src/bailout-reason.h"
 #include "src/crankshaft/hydrogen.h"
@@ skipping 171 matching lines @@
   return true;
 }
 
 
 template <class Stub>
 class CodeStubGraphBuilder: public CodeStubGraphBuilderBase {
  public:
   explicit CodeStubGraphBuilder(CompilationInfo* info, CodeStub* stub)
       : CodeStubGraphBuilderBase(info, stub) {}
 
+  typedef typename Stub::Descriptor Descriptor;
+
  protected:
   virtual HValue* BuildCodeStub() {
     if (casted_stub()->IsUninitialized()) {
       return BuildCodeUninitializedStub();
     } else {
       return BuildCodeInitializedStub();
     }
   }
 
   virtual HValue* BuildCodeInitializedStub() {
@@ skipping 78 matching lines @@
     os << "[Lazy compilation of " << stub << " took "
        << timer.Elapsed().InMillisecondsF() << " ms]" << std::endl;
   }
   return code;
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<NumberToStringStub>::BuildCodeStub() {
   info()->MarkAsSavesCallerDoubles();
-  HValue* number = GetParameter(NumberToStringStub::kNumber);
+  HValue* number = GetParameter(Descriptor::kArgument);
   return BuildNumberToString(number, Type::Number());
 }
 
 
 Handle<Code> NumberToStringStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 // Returns the type string of a value; see ECMA-262, 11.4.3 (p 47).
 template <>
 HValue* CodeStubGraphBuilder<TypeofStub>::BuildCodeStub() {
   Factory* factory = isolate()->factory();
   HConstant* number_string = Add<HConstant>(factory->number_string());
-  HValue* object = GetParameter(TypeofStub::kObject);
+  HValue* object = GetParameter(Descriptor::kObject);
 
   IfBuilder is_smi(this);
   HValue* smi_check = is_smi.If<HIsSmiAndBranch>(object);
   is_smi.Then();
   { Push(number_string); }
   is_smi.Else();
   {
     IfBuilder is_number(this);
     is_number.If<HCompareMap>(object, isolate()->factory()->heap_number_map());
     is_number.Then();
@@ skipping 84 matching lines @@
 
   return environment()->Pop();
 }
 
 
 Handle<Code> TypeofStub::GenerateCode() { return DoGenerateCode(this); }
 
 
 template <>
 HValue* CodeStubGraphBuilder<FastCloneRegExpStub>::BuildCodeStub() {
-  HValue* closure = GetParameter(0);
-  HValue* literal_index = GetParameter(1);
+  HValue* closure = GetParameter(Descriptor::kClosure);
+  HValue* literal_index = GetParameter(Descriptor::kLiteralIndex);
 
   // This stub is very performance sensitive, the generated code must be tuned
   // so that it doesn't build and eager frame.
   info()->MarkMustNotHaveEagerFrame();
 
   HValue* literals_array = Add<HLoadNamedField>(
       closure, nullptr, HObjectAccess::ForLiteralsPointer());
   HInstruction* boilerplate = Add<HLoadKeyed>(
       literals_array, literal_index, nullptr, nullptr, FAST_ELEMENTS,
       NEVER_RETURN_HOLE, LiteralsArray::kOffsetToFirstLiteral - kHeapObjectTag);
@@ skipping 38 matching lines @@
 Handle<Code> FastCloneRegExpStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<FastCloneShallowArrayStub>::BuildCodeStub() {
   Factory* factory = isolate()->factory();
   HValue* undefined = graph()->GetConstantUndefined();
   AllocationSiteMode alloc_site_mode = casted_stub()->allocation_site_mode();
-  HValue* closure = GetParameter(0);
-  HValue* literal_index = GetParameter(1);
+  HValue* closure = GetParameter(Descriptor::kClosure);
+  HValue* literal_index = GetParameter(Descriptor::kLiteralIndex);
 
   // TODO(turbofan): This codestub has regressed to need a frame on ia32 at some
   // point and wasn't caught since it wasn't built in the snapshot. We should
   // probably just replace with a TurboFan stub rather than fixing it.
 #if !(V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87)
   // This stub is very performance sensitive, the generated code must be tuned
   // so that it doesn't build and eager frame.
   info()->MarkMustNotHaveEagerFrame();
 #endif
 
@@ skipping 118 matching lines @@
   // system for weakness. For now we decided to keep it like this because having
   // an initial write barrier backed store makes this pointer strong until the
   // next GC, and allocation sites are designed to survive several GCs anyway.
   Add<HStoreNamedField>(
       object,
       HObjectAccess::ForAllocationSiteOffset(AllocationSite::kWeakNextOffset),
       site);
   Add<HStoreNamedField>(site_list, HObjectAccess::ForAllocationSiteList(),
                         object);
 
-  HInstruction* feedback_vector = GetParameter(0);
-  HInstruction* slot = GetParameter(1);
+  HInstruction* feedback_vector = GetParameter(Descriptor::kVector);
+  HInstruction* slot = GetParameter(Descriptor::kSlot);
   Add<HStoreKeyed>(feedback_vector, slot, object, nullptr, FAST_ELEMENTS,
                    INITIALIZING_STORE);
   return feedback_vector;
 }
 
 
 Handle<Code> CreateAllocationSiteStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<CreateWeakCellStub>::BuildCodeStub() {
   // This stub is performance sensitive, the generated code must be tuned
   // so that it doesn't build an eager frame.
   info()->MarkMustNotHaveEagerFrame();
 
   HValue* size = Add<HConstant>(WeakCell::kSize);
   HInstruction* object =
       Add<HAllocate>(size, HType::JSObject(), TENURED, JS_OBJECT_TYPE,
                      graph()->GetConstant0());
 
   Handle<Map> weak_cell_map = isolate()->factory()->weak_cell_map();
   AddStoreMapConstant(object, weak_cell_map);
 
-  HInstruction* value = GetParameter(CreateWeakCellDescriptor::kValueIndex);
+  HInstruction* value = GetParameter(Descriptor::kValue);
   Add<HStoreNamedField>(object, HObjectAccess::ForWeakCellValue(), value);
   Add<HStoreNamedField>(object, HObjectAccess::ForWeakCellNext(),
                         graph()->GetConstantHole());
 
-  HInstruction* feedback_vector =
-      GetParameter(CreateWeakCellDescriptor::kVectorIndex);
-  HInstruction* slot = GetParameter(CreateWeakCellDescriptor::kSlotIndex);
+  HInstruction* feedback_vector = GetParameter(Descriptor::kVector);
+  HInstruction* slot = GetParameter(Descriptor::kSlot);
   Add<HStoreKeyed>(feedback_vector, slot, object, nullptr, FAST_ELEMENTS,
                    INITIALIZING_STORE);
   return graph()->GetConstant0();
 }
 
 
 Handle<Code> CreateWeakCellStub::GenerateCode() { return DoGenerateCode(this); }
 
 
 template <>
@@ skipping 14 matching lines @@
 
 template <>
 HValue* CodeStubGraphBuilder<StoreScriptContextFieldStub>::BuildCodeStub() {
   int context_index = casted_stub()->context_index();
   int slot_index = casted_stub()->slot_index();
 
   HValue* script_context = BuildGetScriptContext(context_index);
   Add<HStoreNamedField>(script_context,
                         HObjectAccess::ForContextSlot(slot_index),
                         GetParameter(2), STORE_TO_INITIALIZED_ENTRY);
+  // TODO(ishell): Remove this unused stub.
   return GetParameter(2);
 }
 
 
 Handle<Code> StoreScriptContextFieldStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 HValue* CodeStubGraphBuilderBase::BuildPushElement(HValue* object, HValue* argc,
                                                    HValue* argument_elements,
@@ skipping 377 matching lines @@
   return DoGenerateCode(this);
 }
 
 template <>
 HValue* CodeStubGraphBuilder<GrowArrayElementsStub>::BuildCodeStub() {
   ElementsKind kind = casted_stub()->elements_kind();
   if (IsFastDoubleElementsKind(kind)) {
     info()->MarkAsSavesCallerDoubles();
   }
 
-  HValue* object = GetParameter(GrowArrayElementsDescriptor::kObjectIndex);
-  HValue* key = GetParameter(GrowArrayElementsDescriptor::kKeyIndex);
+  HValue* object = GetParameter(Descriptor::kObject);
+  HValue* key = GetParameter(Descriptor::kKey);
 
   HValue* elements = AddLoadElements(object);
   HValue* current_capacity = Add<HLoadNamedField>(
       elements, nullptr, HObjectAccess::ForFixedArrayLength());
 
   HValue* length =
       casted_stub()->is_js_array()
           ? Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
                                  HObjectAccess::ForArrayLength(kind))
           : current_capacity;
 
   return BuildCheckAndGrowElementsCapacity(object, elements, kind, length,
                                            current_capacity, key);
 }
 
 
 Handle<Code> GrowArrayElementsStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<LoadFastElementStub>::BuildCodeStub() {
   LoadKeyedHoleMode hole_mode = casted_stub()->convert_hole_to_undefined()
                                     ? CONVERT_HOLE_TO_UNDEFINED
                                     : NEVER_RETURN_HOLE;
 
   HInstruction* load = BuildUncheckedMonomorphicElementAccess(
-      GetParameter(LoadDescriptor::kReceiverIndex),
-      GetParameter(LoadDescriptor::kNameIndex), NULL,
-      casted_stub()->is_js_array(), casted_stub()->elements_kind(), LOAD,
+      GetParameter(Descriptor::kReceiver), GetParameter(Descriptor::kName),
+      NULL, casted_stub()->is_js_array(), casted_stub()->elements_kind(), LOAD,
       hole_mode, STANDARD_STORE);
   return load;
 }
 
 
 Handle<Code> LoadFastElementStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
@@ skipping 13 matching lines @@
         object, nullptr, access.WithRepresentation(Representation::Tagged()));
     // Load the double value from it.
     access = HObjectAccess::ForHeapNumberValue();
   }
   return Add<HLoadNamedField>(object, nullptr, access);
 }
 
 
 template<>
 HValue* CodeStubGraphBuilder<LoadFieldStub>::BuildCodeStub() {
-  return BuildLoadNamedField(GetParameter(0), casted_stub()->index());
+  return BuildLoadNamedField(GetParameter(Descriptor::kReceiver),
+                             casted_stub()->index());
 }
 
 
 Handle<Code> LoadFieldStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<LoadConstantStub>::BuildCodeStub() {
-  HValue* map = AddLoadMap(GetParameter(0), NULL);
+  HValue* map = AddLoadMap(GetParameter(Descriptor::kReceiver), NULL);
   HObjectAccess descriptors_access = HObjectAccess::ForObservableJSObjectOffset(
       Map::kDescriptorsOffset, Representation::Tagged());
   HValue* descriptors = Add<HLoadNamedField>(map, nullptr, descriptors_access);
   HObjectAccess value_access = HObjectAccess::ForObservableJSObjectOffset(
       DescriptorArray::GetValueOffset(casted_stub()->constant_index()));
   return Add<HLoadNamedField>(descriptors, nullptr, value_access);
 }
 
 
 Handle<Code> LoadConstantStub::GenerateCode() { return DoGenerateCode(this); }
@@ skipping 114 matching lines @@
     environment()->Push(is_load ? result : value);
   }
   in_range.End();
 
   return environment()->Pop();
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<KeyedLoadSloppyArgumentsStub>::BuildCodeStub() {
-  HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
-  HValue* key = GetParameter(LoadDescriptor::kNameIndex);
+  HValue* receiver = GetParameter(Descriptor::kReceiver);
+  HValue* key = GetParameter(Descriptor::kName);
 
   return EmitKeyedSloppyArguments(receiver, key, NULL);
 }
 
 
 Handle<Code> KeyedLoadSloppyArgumentsStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<KeyedStoreSloppyArgumentsStub>::BuildCodeStub() {
-  HValue* receiver = GetParameter(StoreDescriptor::kReceiverIndex);
-  HValue* key = GetParameter(StoreDescriptor::kNameIndex);
-  HValue* value = GetParameter(StoreDescriptor::kValueIndex);
+  HValue* receiver = GetParameter(Descriptor::kReceiver);
+  HValue* key = GetParameter(Descriptor::kName);
+  HValue* value = GetParameter(Descriptor::kValue);
 
   return EmitKeyedSloppyArguments(receiver, key, value);
 }
 
 
 Handle<Code> KeyedStoreSloppyArgumentsStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
@@ skipping 37 matching lines @@
   } else if (representation.IsHeapObject()) {
     BuildCheckHeapObject(value);
   }
 
   Add<HStoreNamedField>(object, access, value, INITIALIZING_STORE);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<StoreFieldStub>::BuildCodeStub() {
-  BuildStoreNamedField(GetParameter(0), GetParameter(2), casted_stub()->index(),
+  BuildStoreNamedField(GetParameter(Descriptor::kReceiver),
+                       GetParameter(Descriptor::kValue), casted_stub()->index(),
                        casted_stub()->representation(), false);
-  return GetParameter(2);
+  return GetParameter(Descriptor::kValue);
 }
 
 
 Handle<Code> StoreFieldStub::GenerateCode() { return DoGenerateCode(this); }
 
 
 template <>
 HValue* CodeStubGraphBuilder<StoreTransitionStub>::BuildCodeStub() {
   HValue* object = GetParameter(StoreTransitionHelper::ReceiverIndex());
   HValue* value = GetParameter(StoreTransitionHelper::ValueIndex());
@@ skipping 53 matching lines @@
 
 
 Handle<Code> StoreTransitionStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<StoreFastElementStub>::BuildCodeStub() {
   BuildUncheckedMonomorphicElementAccess(
-      GetParameter(StoreDescriptor::kReceiverIndex),
-      GetParameter(StoreDescriptor::kNameIndex),
-      GetParameter(StoreDescriptor::kValueIndex), casted_stub()->is_js_array(),
+      GetParameter(Descriptor::kReceiver), GetParameter(Descriptor::kName),
+      GetParameter(Descriptor::kValue), casted_stub()->is_js_array(),
       casted_stub()->elements_kind(), STORE, NEVER_RETURN_HOLE,
       casted_stub()->store_mode());
 
-  return GetParameter(2);
+  return GetParameter(Descriptor::kValue);
 }
 
 
 Handle<Code> StoreFastElementStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<TransitionElementsKindStub>::BuildCodeStub() {
   ElementsKind const from_kind = casted_stub()->from_kind();
   ElementsKind const to_kind = casted_stub()->to_kind();
-  HValue* const object = GetParameter(0);
-  HValue* const map = GetParameter(1);
+  HValue* const object = GetParameter(Descriptor::kObject);
+  HValue* const map = GetParameter(Descriptor::kMap);
 
   // The {object} is known to be a JSObject (otherwise it wouldn't have elements
   // anyways).
   object->set_type(HType::JSObject());
 
   info()->MarkAsSavesCallerDoubles();
 
   DCHECK_IMPLIES(IsFastHoleyElementsKind(from_kind),
                  IsFastHoleyElementsKind(to_kind));
 
@@ skipping 42 matching lines @@
 
 
 Handle<Code> TransitionElementsKindStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 template <>
 HValue* CodeStubGraphBuilder<BinaryOpICStub>::BuildCodeInitializedStub() {
   BinaryOpICState state = casted_stub()->state();
 
-  HValue* left = GetParameter(BinaryOpICStub::kLeft);
-  HValue* right = GetParameter(BinaryOpICStub::kRight);
+  HValue* left = GetParameter(Descriptor::kLeft);
+  HValue* right = GetParameter(Descriptor::kRight);
 
   Type* left_type = state.GetLeftType();
   Type* right_type = state.GetRightType();
   Type* result_type = state.GetResultType();
 
   DCHECK(!left_type->Is(Type::None()) && !right_type->Is(Type::None()) &&
          (state.HasSideEffects() || !result_type->Is(Type::None())));
 
   HValue* result = NULL;
   HAllocationMode allocation_mode(NOT_TENURED);
@@ skipping 55 matching lines @@
 
 Handle<Code> BinaryOpICStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<BinaryOpWithAllocationSiteStub>::BuildCodeStub() {
   BinaryOpICState state = casted_stub()->state();
 
-  HValue* allocation_site = GetParameter(
-      BinaryOpWithAllocationSiteStub::kAllocationSite);
-  HValue* left = GetParameter(BinaryOpWithAllocationSiteStub::kLeft);
-  HValue* right = GetParameter(BinaryOpWithAllocationSiteStub::kRight);
+  HValue* allocation_site = GetParameter(Descriptor::kAllocationSite);
+  HValue* left = GetParameter(Descriptor::kLeft);
+  HValue* right = GetParameter(Descriptor::kRight);
 
   Type* left_type = state.GetLeftType();
   Type* right_type = state.GetRightType();
   Type* result_type = state.GetResultType();
   HAllocationMode allocation_mode(allocation_site);
 
   return BuildBinaryOperation(state.op(), left, right, left_type, right_type,
                               result_type, state.fixed_right_arg(),
                               allocation_mode);
 }
@@ skipping 136 matching lines @@
   return Pop();
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<StringAddStub>::BuildCodeInitializedStub() {
   StringAddStub* stub = casted_stub();
   StringAddFlags flags = stub->flags();
   PretenureFlag pretenure_flag = stub->pretenure_flag();
 
-  HValue* left = GetParameter(StringAddStub::kLeft);
-  HValue* right = GetParameter(StringAddStub::kRight);
+  HValue* left = GetParameter(Descriptor::kLeft);
+  HValue* right = GetParameter(Descriptor::kRight);
 
   // Make sure that both arguments are strings if not known in advance.
   if ((flags & STRING_ADD_CHECK_LEFT) == STRING_ADD_CHECK_LEFT) {
     left =
         BuildToString(left, (flags & STRING_ADD_CONVERT) == STRING_ADD_CONVERT);
   }
   if ((flags & STRING_ADD_CHECK_RIGHT) == STRING_ADD_CHECK_RIGHT) {
     right = BuildToString(right,
                           (flags & STRING_ADD_CONVERT) == STRING_ADD_CONVERT);
   }
 
   return BuildStringAdd(left, right, HAllocationMode(pretenure_flag));
 }
 
 
 Handle<Code> StringAddStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 template <>
 HValue* CodeStubGraphBuilder<ToBooleanICStub>::BuildCodeInitializedStub() {
   ToBooleanICStub* stub = casted_stub();
   IfBuilder if_true(this);
-  if_true.If<HBranch>(GetParameter(0), stub->types());
+  if_true.If<HBranch>(GetParameter(Descriptor::kArgument), stub->types());
   if_true.Then();
   if_true.Return(graph()->GetConstantTrue());
   if_true.Else();
   if_true.End();
   return graph()->GetConstantFalse();
 }
 
 Handle<Code> ToBooleanICStub::GenerateCode() { return DoGenerateCode(this); }
 
 template <>
 HValue* CodeStubGraphBuilder<StoreGlobalStub>::BuildCodeInitializedStub() {
   StoreGlobalStub* stub = casted_stub();
-  HParameter* value = GetParameter(StoreDescriptor::kValueIndex);
+  HParameter* value = GetParameter(Descriptor::kValue);
   if (stub->check_global()) {
     // Check that the map of the global has not changed: use a placeholder map
     // that will be replaced later with the global object's map.
-    HParameter* proxy = GetParameter(StoreDescriptor::kReceiverIndex);
+    HParameter* proxy = GetParameter(Descriptor::kReceiver);
     HValue* proxy_map =
         Add<HLoadNamedField>(proxy, nullptr, HObjectAccess::ForMap());
     HValue* global =
         Add<HLoadNamedField>(proxy_map, nullptr, HObjectAccess::ForPrototype());
     HValue* map_cell = Add<HConstant>(isolate()->factory()->NewWeakCell(
         StoreGlobalStub::global_map_placeholder(isolate())));
     HValue* expected_map = Add<HLoadNamedField>(
         map_cell, nullptr, HObjectAccess::ForWeakCellValue());
     HValue* map =
         Add<HLoadNamedField>(global, nullptr, HObjectAccess::ForMap());
@@ skipping 102 matching lines @@
 }
 
 
 Handle<Code> ElementsTransitionAndStoreStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ToObjectStub>::BuildCodeStub() {
-  HValue* receiver = GetParameter(TypeConversionDescriptor::kArgumentIndex);
+  HValue* receiver = GetParameter(Descriptor::kArgument);
   return BuildToObject(receiver);
 }
 
 
 Handle<Code> ToObjectStub::GenerateCode() { return DoGenerateCode(this); }
 
 template <>
 HValue* CodeStubGraphBuilder<LoadDictionaryElementStub>::BuildCodeStub() {
-  HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
-  HValue* key = GetParameter(LoadDescriptor::kNameIndex);
+  HValue* receiver = GetParameter(Descriptor::kReceiver);
+  HValue* key = GetParameter(Descriptor::kName);
 
   Add<HCheckSmi>(key);
 
   HValue* elements = AddLoadElements(receiver);
 
   HValue* hash = BuildElementIndexHash(key);
 
   return BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash);
 }
 
 
 Handle<Code> LoadDictionaryElementStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template<>
 HValue* CodeStubGraphBuilder<RegExpConstructResultStub>::BuildCodeStub() {
   // Determine the parameters.
-  HValue* length = GetParameter(RegExpConstructResultStub::kLength);
-  HValue* index = GetParameter(RegExpConstructResultStub::kIndex);
-  HValue* input = GetParameter(RegExpConstructResultStub::kInput);
+  HValue* length = GetParameter(Descriptor::kLength);
+  HValue* index = GetParameter(Descriptor::kIndex);
+  HValue* input = GetParameter(Descriptor::kInput);
 
   // TODO(turbofan): This codestub has regressed to need a frame on ia32 at some
   // point and wasn't caught since it wasn't built in the snapshot. We should
   // probably just replace with a TurboFan stub rather than fixing it.
 #if !(V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87)
   info()->MarkMustNotHaveEagerFrame();
 #endif
 
   return BuildRegExpConstructResult(length, index, input);
 }
 
 
 Handle<Code> RegExpConstructResultStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 class CodeStubGraphBuilder<KeyedLoadGenericStub>
     : public CodeStubGraphBuilderBase {
  public:
   explicit CodeStubGraphBuilder(CompilationInfo* info, CodeStub* stub)
       : CodeStubGraphBuilderBase(info, stub) {}
 
+  typedef KeyedLoadGenericStub::Descriptor Descriptor;
+
  protected:
   virtual HValue* BuildCodeStub();
 
   void BuildElementsKindLimitCheck(HGraphBuilder::IfBuilder* if_builder,
                                    HValue* bit_field2,
                                    ElementsKind kind);
 
   void BuildFastElementLoad(HGraphBuilder::IfBuilder* if_builder,
                             HValue* receiver,
                             HValue* key,
@@ skipping 35 matching lines @@
   js_array_check.Else();
   Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                               false, kind,
                                               LOAD, NEVER_RETURN_HOLE,
                                               STANDARD_STORE));
   js_array_check.End();
 }
 
 
 HValue* CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildCodeStub() {
-  HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
-  HValue* key = GetParameter(LoadDescriptor::kNameIndex);
+  HValue* receiver = GetParameter(Descriptor::kReceiver);
+  HValue* key = GetParameter(Descriptor::kName);
   // Split into a smi/integer case and unique string case.
   HIfContinuation index_name_split_continuation(graph()->CreateBasicBlock(),
                                                 graph()->CreateBasicBlock());
 
   BuildKeyedIndexCheck(key, &index_name_split_continuation);
 
   IfBuilder index_name_split(this, &index_name_split_continuation);
   index_name_split.Then();
   {
     // Key is an index (number)
@@ skipping 163 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8