Multiple stubs can point to the same calling convention.

src/interface-descriptors.cc

Index: src/interface-descriptors.cc
diff --git a/src/interface-descriptors.cc b/src/interface-descriptors.cc
index dd0be43ae0a5a0d307fe0854d672e5fad3d8feab..2324c62eda5447a1f0ffad894a05a8b752c8c0e7 100644
--- a/src/interface-descriptors.cc
+++ b/src/interface-descriptors.cc
@@ -4,6 +4,7 @@
 
 #include "src/v8.h"
 
+#include "src/ic/ic-conventions.h"
 #include "src/interface-descriptors.h"
 
 namespace v8 {
@@ -51,5 +52,53 @@ void CallInterfaceDescriptor::Initialize(
   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