[turbofan] Add CalleeSavedFPRegisters to CallDescriptor.

src/compiler/linkage.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_H_
 #define V8_COMPILER_LINKAGE_H_
 
 #include "src/base/flags.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/machine-type.h"
@@ skipping 65 matching lines @@
     kHasLocalCatchHandler = 1u << 4,
     kSupportsTailCalls = 1u << 5,
     kPatchableCallSiteWithNop = kPatchableCallSite | kNeedsNopAfterCall
   };
   typedef base::Flags<Flag> Flags;
 
   CallDescriptor(Kind kind, MachineType target_type, LinkageLocation target_loc,
                  const MachineSignature* machine_sig,
                  LocationSignature* location_sig, size_t js_param_count,
                  Operator::Properties properties,
-                 RegList callee_saved_registers, Flags flags,
+                 RegList callee_saved_registers,
+                 RegList callee_saved_fpu_registers, Flags flags,
                  const char* debug_name = "")
       : kind_(kind),
         target_type_(target_type),
         target_loc_(target_loc),
         machine_sig_(machine_sig),
         location_sig_(location_sig),
         js_param_count_(js_param_count),
         properties_(properties),
         callee_saved_registers_(callee_saved_registers),
+        callee_saved_fpu_registers_(callee_saved_fpu_registers),
         flags_(flags),
         debug_name_(debug_name) {
     DCHECK(machine_sig->return_count() == location_sig->return_count());
     DCHECK(machine_sig->parameter_count() == location_sig->parameter_count());
   }
 
   // Returns the kind of this call.
   Kind kind() const { return kind_; }
 
   // Returns {true} if this descriptor is a call to a JSFunction.
@@ skipping 37 matching lines @@
     if (index == 0) return target_type_;
     return machine_sig_->GetParam(index - 1);
   }
 
   // Operator properties describe how this call can be optimized, if at all.
   Operator::Properties properties() const { return properties_; }
 
   // Get the callee-saved registers, if any, across this call.
   RegList CalleeSavedRegisters() const { return callee_saved_registers_; }
 
+  // Get the callee-saved FPU registers, if any, across this call.
+  RegList CalleeSavedFPURegisters() const {
+    return callee_saved_fpu_registers_;
+  }
+
   const char* debug_name() const { return debug_name_; }
 
   bool UsesOnlyRegisters() const;
 
   bool HasSameReturnLocationsAs(const CallDescriptor* other) const;
 
  private:
   friend class Linkage;
 
   const Kind kind_;
   const MachineType target_type_;
   const LinkageLocation target_loc_;
   const MachineSignature* const machine_sig_;
   const LocationSignature* const location_sig_;
   const size_t js_param_count_;
   const Operator::Properties properties_;
   const RegList callee_saved_registers_;
+  const RegList callee_saved_fpu_registers_;
   const Flags flags_;
   const char* const debug_name_;
 
   DISALLOW_COPY_AND_ASSIGN(CallDescriptor);
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)
 
 std::ostream& operator<<(std::ostream& os, const CallDescriptor& d);
 std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k);
@@ skipping 77 matching lines @@
   CallDescriptor* const incoming_;
 
   DISALLOW_COPY_AND_ASSIGN(Linkage);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_H_