[turbofan] Add CalleeSavedFPRegisters to CallDescriptor.

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_
 
 #include "src/code-stubs.h"
 #include "src/compiler/osr.h"
 
@@ skipping 52 matching lines @@
     LinkageLocation target_loc = regloc(LinkageTraits::JSCallFunctionReg());
     return new (zone) CallDescriptor(     // --
         CallDescriptor::kCallJSFunction,  // 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
+        kNoCalleeSaved,                   // callee-saved fp
         flags,                            // flags
         "js-call");
   }
 
 
   // TODO(turbofan): cache call descriptors for runtime calls.
   static CallDescriptor* GetRuntimeCallDescriptor(
       Zone* zone, Runtime::FunctionId function_id, int js_parameter_count,
       Operator::Properties properties) {
     const size_t function_count = 1;
@@ skipping 41 matching lines @@
     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
         properties,                       // properties
         kNoCalleeSaved,                   // callee-saved
+        kNoCalleeSaved,                   // callee-saved fp
         flags,                            // flags
         function->name);                  // debug name
   }
 
 
   // TODO(all): Add support for return representations/locations to
   // CallInterfaceDescriptor.
   // TODO(turbofan): cache call descriptors for code stub calls.
   static CallDescriptor* GetStubCallDescriptor(
       Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
@@ skipping 40 matching lines @@
     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
         properties,                       // properties
         kNoCalleeSaved,                   // callee-saved registers
+        kNoCalleeSaved,                   // callee-saved fp
         flags,                            // flags
         descriptor.DebugName(isolate));
   }
 
   static CallDescriptor* GetSimplifiedCDescriptor(
       Zone* zone, const 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).
     const int parameter_count = static_cast<int>(msig->parameter_count());
     int stack_offset = LinkageTraits::CStackBackingStoreLength();
     for (int i = 0; i < parameter_count; i++) {
       if (i < LinkageTraits::CRegisterParametersLength()) {
         locations.AddParam(regloc(LinkageTraits::CRegisterParameter(i)));
       } else {
         locations.AddParam(stackloc(-1 - stack_offset));
         stack_offset++;
       }
     }
 
     // The target for C calls is always an address (i.e. machine pointer).
     MachineType target_type = kMachPtr;
     LinkageLocation target_loc = LinkageLocation::AnyRegister();
-    return new (zone) CallDescriptor(           // --
-        CallDescriptor::kCallAddress,           // kind
-        target_type,                            // target MachineType
-        target_loc,                             // target location
-        msig,                                   // machine_sig
-        locations.Build(),                      // location_sig
-        0,                                      // js_parameter_count
-        Operator::kNoProperties,                // properties
-        LinkageTraits::CCalleeSaveRegisters(),  // callee-saved registers
-        CallDescriptor::kNoFlags,               // flags
+    return new (zone) CallDescriptor(             // --
+        CallDescriptor::kCallAddress,             // kind
+        target_type,                              // target MachineType
+        target_loc,                               // target location
+        msig,                                     // machine_sig
+        locations.Build(),                        // location_sig
+        0,                                        // js_parameter_count
+        Operator::kNoProperties,                  // properties
+        LinkageTraits::CCalleeSaveRegisters(),    // callee-saved registers
+        LinkageTraits::CCalleeSaveFPRegisters(),  // callee-saved fp regs
+        CallDescriptor::kNoFlags,                 // flags
         "c-call");
   }
 
   static LinkageLocation regloc(Register reg) {
     return LinkageLocation(Register::ToAllocationIndex(reg));
   }
 
   static LinkageLocation stackloc(int i) {
     DCHECK_LT(i, 0);
     return LinkageLocation(i);
@@ skipping 46 matching lines @@
     int parameter_index = 1 + index;  // skip index 0, which is the target.
     return incoming_->GetInputLocation(parameter_index);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_