Multiple stubs can point to the same calling convention.

src/interface-descriptors.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/ic/ic-conventions.h"
 #include "src/interface-descriptors.h"
 
 namespace v8 {
 namespace internal {
 
 InterfaceDescriptor::InterfaceDescriptor() : register_param_count_(-1) {}
 
 
 void InterfaceDescriptor::Initialize(
     int register_parameter_count, Register* registers,
@@ skipping 27 matching lines @@
 }
 
 
 void CallInterfaceDescriptor::Initialize(
     int register_parameter_count, Register* registers,
     Representation* param_representations,
     PlatformInterfaceDescriptor* platform_descriptor) {
   InterfaceDescriptor::Initialize(register_parameter_count, registers,
                                   param_representations, platform_descriptor);
 }
+
+
+void CallDescriptors::InitializeForIsolateAllPlatforms(Isolate* isolate) {
+  {
+    CallInterfaceDescriptor* descriptor =
+        isolate->call_descriptor(CallDescriptorKey::LoadICCall);
+    Register registers[] = {InterfaceDescriptor::ContextRegister(),
+                            LoadConvention::ReceiverRegister(),
+                            LoadConvention::NameRegister()};
+    descriptor->Initialize(arraysize(registers), registers, NULL);
+  }
+  {
+    CallInterfaceDescriptor* descriptor =
+        isolate->call_descriptor(CallDescriptorKey::StoreICCall);
+    Register registers[] = {InterfaceDescriptor::ContextRegister(),
+                            StoreConvention::ReceiverRegister(),
+                            StoreConvention::NameRegister(),
+                            StoreConvention::ValueRegister()};
+    descriptor->Initialize(arraysize(registers), registers, NULL);
+  }
+  {
+    CallInterfaceDescriptor* descriptor = isolate->call_descriptor(
+        CallDescriptorKey::ElementTransitionAndStoreCall);
+    Register registers[] = {
+        InterfaceDescriptor::ContextRegister(),
+        StoreConvention::ValueRegister(), StoreConvention::MapRegister(),
+        StoreConvention::NameRegister(), StoreConvention::ReceiverRegister()};
+    descriptor->Initialize(arraysize(registers), registers, NULL);
+  }
+  {
+    CallInterfaceDescriptor* descriptor =
+        isolate->call_descriptor(CallDescriptorKey::InstanceofCall);
+    Register registers[] = {InterfaceDescriptor::ContextRegister(),
+                            InstanceofConvention::left(),
+                            InstanceofConvention::right()};
+    descriptor->Initialize(arraysize(registers), registers, NULL);
+  }
+  {
+    CallInterfaceDescriptor* descriptor =
+        isolate->call_descriptor(CallDescriptorKey::VectorLoadICCall);
+    Register registers[] = {InterfaceDescriptor::ContextRegister(),
+                            FullVectorLoadConvention::ReceiverRegister(),
+                            FullVectorLoadConvention::NameRegister(),
+                            FullVectorLoadConvention::SlotRegister(),
+                            FullVectorLoadConvention::VectorRegister()};
+    descriptor->Initialize(arraysize(registers), registers, NULL);
+  }
+}
 }
 }  // namespace v8::internal