[turbofan] Remove access to FunctionType from call interface.

src/interface-descriptors.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_CALL_INTERFACE_DESCRIPTOR_H_
 #define V8_CALL_INTERFACE_DESCRIPTOR_H_
 
 #include <memory>
 
 #include "src/assembler.h"
@@ skipping 115 matching lines @@
 
   int param_count() const { return function_type_->Arity(); }
   int register_param_count() const { return register_param_count_; }
   Register register_param(int index) const { return register_params_[index]; }
   Register* register_params() const { return register_params_.get(); }
   Type* param_type(int index) const { return function_type_->Parameter(index); }
   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     return platform_specific_descriptor_;
   }
 
-  FunctionType* function_type() const { return function_type_; }
-
  private:
   int register_param_count_;
 
   // The Register params are allocated dynamically by the
   // InterfaceDescriptor, and freed on destruction. This is because static
   // arrays of Registers cause creation of runtime static initializers
   // which we don't want.
   std::unique_ptr<Register[]> register_params_;
 
   // Specifies types for parameters and return
@@ skipping 24 matching lines @@
   CallInterfaceDescriptor(Isolate* isolate, CallDescriptors::Key key)
       : data_(isolate->call_descriptor_data(key)) {}
 
   int GetParameterCount() const { return data()->param_count(); }
 
   int GetRegisterParameterCount() const {
     return data()->register_param_count();
   }
 
   int GetStackParameterCount() const {
-    return data()->function_type()->Arity() - data()->register_param_count();
+    return data()->param_count() - data()->register_param_count();
   }
 
   Register GetRegisterParameter(int index) const {
     return data()->register_param(index);
   }
 
   Type* GetParameterType(int index) const {
     DCHECK(index < data()->param_count());
     return data()->param_type(index);
   }
 
   // Some platforms have extra information to associate with the descriptor.
   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     return data()->platform_specific_descriptor();
   }
 
-  FunctionType* GetFunctionType() const { return data()->function_type(); }
-
   static const Register ContextRegister();
 
   const char* DebugName(Isolate* isolate) const;
 
   static FunctionType* BuildDefaultFunctionType(Isolate* isolate,
                                                 int parameter_count);
 
  protected:
   const CallInterfaceDescriptorData* data() const { return data_; }
 
@@ skipping 716 matching lines @@
 }  // namespace v8
 
 
 #if V8_TARGET_ARCH_ARM64
 #include "src/arm64/interface-descriptors-arm64.h"
 #elif V8_TARGET_ARCH_ARM
 #include "src/arm/interface-descriptors-arm.h"
 #endif
 
 #endif  // V8_CALL_INTERFACE_DESCRIPTOR_H_