[stubs] Call interface descriptors cleanup.

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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 403 matching lines @@
   CodeStubAssembler assembler(isolate(), &zone, descriptor, GetCodeFlags(),
                               name);
   GenerateAssembly(&assembler);
   return assembler.GenerateCode();
 }
 
 void LoadICTrampolineTFStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
-  Node* receiver = assembler->Parameter(0);
-  Node* name = assembler->Parameter(1);
-  Node* slot = assembler->Parameter(2);
-  Node* context = assembler->Parameter(3);
+  Node* receiver = assembler->Parameter(Descriptor::kReceiver);
+  Node* name = assembler->Parameter(Descriptor::kName);
+  Node* slot = assembler->Parameter(Descriptor::kSlot);
+  Node* context = assembler->Parameter(Descriptor::kContext);
   Node* vector = assembler->LoadTypeFeedbackVectorForStub();
 
   CodeStubAssembler::LoadICParameters p(context, receiver, name, slot, vector);
   assembler->LoadIC(&p);
 }
 
 void LoadICTFStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
-  Node* receiver = assembler->Parameter(0);
-  Node* name = assembler->Parameter(1);
-  Node* slot = assembler->Parameter(2);
-  Node* vector = assembler->Parameter(3);
-  Node* context = assembler->Parameter(4);
+  Node* receiver = assembler->Parameter(Descriptor::kReceiver);
+  Node* name = assembler->Parameter(Descriptor::kName);
+  Node* slot = assembler->Parameter(Descriptor::kSlot);
+  Node* vector = assembler->Parameter(Descriptor::kVector);
+  Node* context = assembler->Parameter(Descriptor::kContext);
 
   CodeStubAssembler::LoadICParameters p(context, receiver, name, slot, vector);
   assembler->LoadIC(&p);
 }
 
 void LoadGlobalICTrampolineStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
-  Node* slot = assembler->Parameter(0);
-  Node* context = assembler->Parameter(1);
+  Node* slot = assembler->Parameter(Descriptor::kSlot);
+  Node* context = assembler->Parameter(Descriptor::kContext);
   Node* vector = assembler->LoadTypeFeedbackVectorForStub();
 
   CodeStubAssembler::LoadICParameters p(context, nullptr, nullptr, slot,
                                         vector);
   assembler->LoadGlobalIC(&p);
 }
 
 void LoadGlobalICStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
-  Node* slot = assembler->Parameter(0);
-  Node* vector = assembler->Parameter(1);
-  Node* context = assembler->Parameter(2);
+  Node* slot = assembler->Parameter(Descriptor::kSlot);
+  Node* vector = assembler->Parameter(Descriptor::kVector);
+  Node* context = assembler->Parameter(Descriptor::kContext);
 
   CodeStubAssembler::LoadICParameters p(context, nullptr, nullptr, slot,
                                         vector);
   assembler->LoadGlobalIC(&p);
 }
 
 void AllocateHeapNumberStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
@@ skipping 3076 matching lines @@
   assembler->Return(assembler->BooleanConstant(mode == kDontNegateResult));
 
   assembler->Bind(&if_notequal);
   assembler->Return(assembler->BooleanConstant(mode == kNegateResult));
 }
 
 }  // namespace
 
 void LoadApiGetterStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
-  Node* context = assembler->Parameter(3);
-  Node* receiver = assembler->Parameter(0);
+  Node* context = assembler->Parameter(Descriptor::kContext);
+  Node* receiver = assembler->Parameter(Descriptor::kReceiver);
   // For now we only support receiver_is_holder.
   DCHECK(receiver_is_holder());
   Node* holder = receiver;
   Node* map = assembler->LoadMap(receiver);
   Node* descriptors = assembler->LoadMapDescriptors(map);
   Node* offset =
       assembler->Int32Constant(DescriptorArray::ToValueIndex(index()));
   Node* callback = assembler->LoadFixedArrayElement(descriptors, offset);
   assembler->TailCallStub(CodeFactory::ApiGetter(isolate()), context, receiver,
                           holder, callback);
@@ skipping 224 matching lines @@
     assembler->Return(var_arg.value());
 
     assembler->Bind(&return_zero);
     assembler->Return(assembler->SmiConstant(Smi::FromInt(0)));
   }
 }
 
 void StoreInterceptorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
-  Node* receiver = assembler->Parameter(0);
-  Node* name = assembler->Parameter(1);
-  Node* value = assembler->Parameter(2);
-  // Node* slot = assembler->Parameter(3);
-  // Node* vector = assembler->Parameter(4);
-  Node* context = assembler->Parameter(5);
+
+  Node* receiver = assembler->Parameter(Descriptor::kReceiver);
+  Node* name = assembler->Parameter(Descriptor::kName);
+  Node* value = assembler->Parameter(Descriptor::kValue);
+  Node* context = assembler->Parameter(Descriptor::kContext);
   assembler->TailCallRuntime(Runtime::kStorePropertyWithInterceptor, context,
                              receiver, name, value);
 }
 
 void LoadIndexedInterceptorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
-  Node* receiver = assembler->Parameter(0);
-  Node* key = assembler->Parameter(1);
-  Node* slot = assembler->Parameter(2);
-  Node* vector = assembler->Parameter(3);
-  Node* context = assembler->Parameter(4);
+
+  Node* receiver = assembler->Parameter(Descriptor::kReceiver);
+  Node* key = assembler->Parameter(Descriptor::kName);
+  Node* slot = assembler->Parameter(Descriptor::kSlot);
+  Node* vector = assembler->Parameter(Descriptor::kVector);
+  Node* context = assembler->Parameter(Descriptor::kContext);
 
   Label if_keyispositivesmi(assembler), if_keyisinvalid(assembler);
   assembler->Branch(assembler->WordIsPositiveSmi(key), &if_keyispositivesmi,
                     &if_keyisinvalid);
   assembler->Bind(&if_keyispositivesmi);
   assembler->TailCallRuntime(Runtime::kLoadElementWithInterceptor, context,
                              receiver, key);
 
   assembler->Bind(&if_keyisinvalid);
   assembler->TailCallRuntime(Runtime::kKeyedLoadIC_Miss, context, receiver, key,
@@ skipping 221 matching lines @@
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       FUNCTION_ADDR(Runtime_ElementsTransitionAndStoreIC_Miss));
 }
 
 
 void ToObjectStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(Runtime::FunctionForId(Runtime::kToObject)->entry);
 }
 
-
-CallInterfaceDescriptor StoreTransitionStub::GetCallInterfaceDescriptor()
-    const {
-  return VectorStoreTransitionDescriptor(isolate());
-}
-
-
-CallInterfaceDescriptor
-ElementsTransitionAndStoreStub::GetCallInterfaceDescriptor() const {
-  return VectorStoreTransitionDescriptor(isolate());
+void StoreTransitionStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
+  descriptor->Initialize(
+      FUNCTION_ADDR(Runtime_TransitionStoreIC_MissFromStubFailure));
 }
 
 void TypeofStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {}
 
 void NumberToStringStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kNumberToString)->entry);
 }
 
 
@@ skipping 404 matching lines @@
 }
 
 void FastNewFunctionContextStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
 
   int length = slots() + Context::MIN_CONTEXT_SLOTS;
   int size = length * kPointerSize + FixedArray::kHeaderSize;
 
   // Get the function
-  Node* function =
-      assembler->Parameter(FastNewFunctionContextDescriptor::kFunctionIndex);
-  Node* context =
-      assembler->Parameter(FastNewFunctionContextDescriptor::kContextIndex);
+  Node* function = assembler->Parameter(Descriptor::kFunction);
+  Node* context = assembler->Parameter(Descriptor::kContext);
 
   // Create a new closure from the given function info in new space
   Node* function_context = assembler->Allocate(size);
 
   assembler->StoreMapNoWriteBarrier(
       function_context,
       assembler->HeapConstant(isolate()->factory()->function_context_map()));
   assembler->StoreObjectFieldNoWriteBarrier(
       function_context, Context::kLengthOffset,
       assembler->SmiConstant(Smi::FromInt(length)));
@@ skipping 169 matching lines @@
                                                Isolate* isolate) {
   FunctionEntryHook entry_hook = isolate->function_entry_hook();
   DCHECK(entry_hook != NULL);
   entry_hook(function, stack_pointer);
 }
 
 void ArrayNoArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* native_context = assembler->LoadObjectField(
-      assembler->Parameter(
-          ArrayNoArgumentConstructorDescriptor::kFunctionIndex),
-      JSFunction::kContextOffset);
+      assembler->Parameter(Descriptor::kFunction), JSFunction::kContextOffset);
   bool track_allocation_site =
       AllocationSite::GetMode(elements_kind()) == TRACK_ALLOCATION_SITE &&
       override_mode() != DISABLE_ALLOCATION_SITES;
   Node* allocation_site =
-      track_allocation_site
-          ? assembler->Parameter(
-                ArrayNoArgumentConstructorDescriptor::kAllocationSiteIndex)
-          : nullptr;
+      track_allocation_site ? assembler->Parameter(Descriptor::kAllocationSite)
+                            : nullptr;
   Node* array_map =
       assembler->LoadJSArrayElementsMap(elements_kind(), native_context);
   Node* array = assembler->AllocateJSArray(
       elements_kind(), array_map,
       assembler->IntPtrConstant(JSArray::kPreallocatedArrayElements),
       assembler->IntPtrConstant(0), allocation_site);
   assembler->Return(array);
 }
 
 void InternalArrayNoArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
-  Node* array_map = assembler->LoadObjectField(
-      assembler->Parameter(
-          ArrayNoArgumentConstructorDescriptor::kFunctionIndex),
-      JSFunction::kPrototypeOrInitialMapOffset);
+  Node* array_map =
+      assembler->LoadObjectField(assembler->Parameter(Descriptor::kFunction),
+                                 JSFunction::kPrototypeOrInitialMapOffset);
   Node* array = assembler->AllocateJSArray(
       elements_kind(), array_map,
       assembler->IntPtrConstant(JSArray::kPreallocatedArrayElements),
       assembler->IntPtrConstant(0), nullptr);
   assembler->Return(array);
 }
 
 namespace {
 
+template <typename Descriptor>
 void SingleArgumentConstructorCommon(CodeStubAssembler* assembler,
                                      ElementsKind elements_kind,
                                      compiler::Node* array_map,
                                      compiler::Node* allocation_site,
                                      AllocationSiteMode mode) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
 
   Label ok(assembler);
   Label smi_size(assembler);
   Label small_smi_size(assembler);
   Label call_runtime(assembler, Label::kDeferred);
 
-  Node* size = assembler->Parameter(
-      ArraySingleArgumentConstructorDescriptor::kArraySizeSmiParameterIndex);
+  Node* size = assembler->Parameter(Descriptor::kArraySizeSmiParameter);
   assembler->Branch(assembler->WordIsSmi(size), &smi_size, &call_runtime);
 
   assembler->Bind(&smi_size);
 
   if (IsFastPackedElementsKind(elements_kind)) {
     Label abort(assembler, Label::kDeferred);
     assembler->Branch(
         assembler->SmiEqual(size, assembler->SmiConstant(Smi::FromInt(0))),
         &small_smi_size, &abort);
 
     assembler->Bind(&abort);
     Node* reason =
         assembler->SmiConstant(Smi::FromInt(kAllocatingNonEmptyPackedArray));
-    Node* context = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kContextIndex);
+    Node* context = assembler->Parameter(Descriptor::kContext);
     assembler->TailCallRuntime(Runtime::kAbort, context, reason);
   } else {
     int element_size =
         IsFastDoubleElementsKind(elements_kind) ? kDoubleSize : kPointerSize;
     int max_fast_elements =
         (Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize -
          JSArray::kSize - AllocationMemento::kSize) /
         element_size;
     assembler->Branch(
         assembler->SmiAboveOrEqual(
             size, assembler->SmiConstant(Smi::FromInt(max_fast_elements))),
         &call_runtime, &small_smi_size);
   }
 
   assembler->Bind(&small_smi_size);
   {
     Node* array = assembler->AllocateJSArray(
         elements_kind, array_map, size, size,
         mode == DONT_TRACK_ALLOCATION_SITE ? nullptr : allocation_site,
         CodeStubAssembler::SMI_PARAMETERS);
     assembler->Return(array);
   }
 
   assembler->Bind(&call_runtime);
   {
-    Node* context = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kContextIndex);
-    Node* function = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
-    Node* array_size = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kArraySizeSmiParameterIndex);
-    Node* allocation_site = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kAllocationSiteIndex);
+    Node* context = assembler->Parameter(Descriptor::kContext);
+    Node* function = assembler->Parameter(Descriptor::kFunction);
+    Node* array_size = assembler->Parameter(Descriptor::kArraySizeSmiParameter);
+    Node* allocation_site = assembler->Parameter(Descriptor::kAllocationSite);
     assembler->TailCallRuntime(Runtime::kNewArray, context, function,
                                array_size, function, allocation_site);
   }
 }
 }  // namespace
 
 void ArraySingleArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
-  Node* function = assembler->Parameter(
-      ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
+  Node* function = assembler->Parameter(Descriptor::kFunction);
   Node* native_context =
       assembler->LoadObjectField(function, JSFunction::kContextOffset);
   Node* array_map =
       assembler->LoadJSArrayElementsMap(elements_kind(), native_context);
   AllocationSiteMode mode = override_mode() == DISABLE_ALLOCATION_SITES
                                 ? DONT_TRACK_ALLOCATION_SITE
                                 : AllocationSite::GetMode(elements_kind());
-  Node* allocation_site = assembler->Parameter(
-      ArrayNoArgumentConstructorDescriptor::kAllocationSiteIndex);
-  SingleArgumentConstructorCommon(assembler, elements_kind(), array_map,
-                                  allocation_site, mode);
+  Node* allocation_site = assembler->Parameter(Descriptor::kAllocationSite);
+  SingleArgumentConstructorCommon<Descriptor>(assembler, elements_kind(),
+                                              array_map, allocation_site, mode);
 }
 
 void InternalArraySingleArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
-  Node* function = assembler->Parameter(
-      ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
+  Node* function = assembler->Parameter(Descriptor::kFunction);
   Node* array_map = assembler->LoadObjectField(
       function, JSFunction::kPrototypeOrInitialMapOffset);
-  SingleArgumentConstructorCommon(assembler, elements_kind(), array_map,
-                                  assembler->UndefinedConstant(),
-                                  DONT_TRACK_ALLOCATION_SITE);
+  SingleArgumentConstructorCommon<Descriptor>(
+      assembler, elements_kind(), array_map, assembler->UndefinedConstant(),
+      DONT_TRACK_ALLOCATION_SITE);
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {
   minor_key_ = ArgumentCountBits::encode(ANY);
 }
 
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate,
                                            int argument_count)
@@ skipping 24 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8