Get CallInterfaceDescriptor directly from CodeStub.

src/compiler/linkage-impl.h

 // Copyright 2014 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.
 
 #ifndef V8_COMPILER_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 111 matching lines @@
                                      js_parameter_count,  // js_parameter_count
                                      properties,          // properties
                                      kNoCalleeSaved,      // callee-saved
                                      flags,               // flags
                                      function->name);     // debug name
   }
 
 
   // TODO(turbofan): cache call descriptors for code stub calls.
   static CallDescriptor* GetStubCallDescriptor(
-      Zone* zone, CodeStubInterfaceDescriptor* descriptor,
-      int stack_parameter_count, CallDescriptor::Flags flags) {
+      Zone* zone, CallInterfaceDescriptor descriptor, int stack_parameter_count,
+      CallDescriptor::Flags flags) {
     const int register_parameter_count =
-        descriptor->GetEnvironmentParameterCount();
+        descriptor.GetEnvironmentParameterCount();
     const int js_parameter_count =
         register_parameter_count + stack_parameter_count;
     const int context_count = 1;
     const size_t return_count = 1;
     const size_t parameter_count =
         static_cast<size_t>(js_parameter_count + context_count);
 
     LocationSignature::Builder locations(zone, return_count, parameter_count);
     MachineSignature::Builder types(zone, return_count, parameter_count);
 
     // Add return location.
     AddReturnLocations(&locations);
     types.AddReturn(kMachAnyTagged);
 
     // Add parameters in registers and on the stack.
     for (int i = 0; i < js_parameter_count; i++) {
       if (i < register_parameter_count) {
         // The first parameters go in registers.
-        Register reg = descriptor->GetEnvironmentParameterRegister(i);
+        Register reg = descriptor.GetEnvironmentParameterRegister(i);
         locations.AddParam(regloc(reg));
       } else {
         // The rest of the parameters go on the stack.
         int stack_slot = i - register_parameter_count - stack_parameter_count;
         locations.AddParam(stackloc(stack_slot));
       }
       types.AddParam(kMachAnyTagged);
     }
     // Add context.
     locations.AddParam(regloc(LinkageTraits::ContextReg()));
     types.AddParam(kMachAnyTagged);
 
     // The target for stub calls is a code object.
     MachineType target_type = kMachAnyTagged;
     LinkageLocation target_loc = LinkageLocation::AnyRegister();
-    return new (zone)
-        CallDescriptor(CallDescriptor::kCallCodeObject,  // kind
-                       target_type,                      // target MachineType
-                       target_loc,                       // target location
-                       types.Build(),                    // machine_sig
-                       locations.Build(),                // location_sig
-                       js_parameter_count,               // js_parameter_count
-                       Operator::kNoProperties,          // properties
-                       kNoCalleeSaved,  // callee-saved registers
-                       flags,           // flags
-                       CodeStub::MajorName(descriptor->MajorKey(), false));
+    return new (zone) CallDescriptor(CallDescriptor::kCallCodeObject,  // kind
+                                     target_type,         // target MachineType
+                                     target_loc,          // target location
+                                     types.Build(),       // machine_sig
+                                     locations.Build(),   // location_sig
+                                     js_parameter_count,  // js_parameter_count
+                                     Operator::kNoProperties,  // properties
+                                     kNoCalleeSaved,  // callee-saved registers
+                                     flags,           // flags
+                                     descriptor.DebugName(zone->isolate()));
   }
 
   static CallDescriptor* GetSimplifiedCDescriptor(Zone* zone,
                                                   MachineSignature* msig) {
     LocationSignature::Builder locations(zone, msig->return_count(),
                                          msig->parameter_count());
     // Add return location(s).
     AddReturnLocations(&locations);
 
     // Add register and/or stack parameter(s).
@@ skipping 27 matching lines @@
   static LinkageLocation stackloc(int i) {
     DCHECK_LT(i, 0);
     return LinkageLocation(i);
   }
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_