[turbofan] Get rid of DefineAsDoubleRegister() and friends.

src/compiler/instruction-selector-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_INSTRUCTION_SELECTOR_IMPL_H_
 #define V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
 
 #include "src/compiler/instruction.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/linkage.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // A helper class for the instruction selector that simplifies construction of
 // Operands. This class implements a base for architecture-specific helpers.
 class OperandGenerator {
  public:
   explicit OperandGenerator(InstructionSelector* selector)
       : selector_(selector) {}
 
   InstructionOperand* DefineAsRegister(Node* node) {
     return Define(node, new (zone())
                   UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
   }
 
-  InstructionOperand* DefineAsDoubleRegister(Node* node) {
-    return Define(node, new (zone())
-                  UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
-  }
-
   InstructionOperand* DefineSameAsFirst(Node* result) {
     return Define(result, new (zone())
                   UnallocatedOperand(UnallocatedOperand::SAME_AS_FIRST_INPUT));
   }
 
   InstructionOperand* DefineAsFixed(Node* node, Register reg) {
     return Define(node, new (zone())
                   UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                      Register::ToAllocationIndex(reg)));
   }
 
-  InstructionOperand* DefineAsFixedDouble(Node* node, DoubleRegister reg) {
+  InstructionOperand* DefineAsFixed(Node* node, DoubleRegister reg) {
     return Define(node, new (zone())
                   UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                      DoubleRegister::ToAllocationIndex(reg)));
   }
 
   InstructionOperand* DefineAsConstant(Node* node) {
     selector()->MarkAsDefined(node);
     sequence()->AddConstant(node->id(), ToConstant(node));
     return ConstantOperand::Create(node->id(), zone());
   }
 
   InstructionOperand* DefineAsLocation(Node* node, LinkageLocation location) {
     return Define(node, ToUnallocatedOperand(location));
   }
 
   InstructionOperand* Use(Node* node) {
     return Use(node,
                new (zone()) UnallocatedOperand(
                    UnallocatedOperand::ANY, UnallocatedOperand::USED_AT_START));
   }
 
   InstructionOperand* UseRegister(Node* node) {
     return Use(node, new (zone())
                UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                                   UnallocatedOperand::USED_AT_START));
   }
 
-  InstructionOperand* UseDoubleRegister(Node* node) {
-    return Use(node, new (zone())
-               UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
-                                  UnallocatedOperand::USED_AT_START));
-  }
-
   // Use register or operand for the node. If a register is chosen, it won't
   // alias any temporary or output registers.
   InstructionOperand* UseUnique(Node* node) {
     return Use(node, new (zone()) UnallocatedOperand(UnallocatedOperand::ANY));
   }
 
   // Use a unique register for the node that does not alias any temporary or
   // output registers.
   InstructionOperand* UseUniqueRegister(Node* node) {
     return Use(node, new (zone())
                UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
   }
 
-  // Use a unique double register for the node that does not alias any temporary
-  // or output double registers.
-  InstructionOperand* UseUniqueDoubleRegister(Node* node) {
-    return Use(node, new (zone())
-               UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
-  }
-
   InstructionOperand* UseFixed(Node* node, Register reg) {
     return Use(node, new (zone())
                UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                   Register::ToAllocationIndex(reg)));
   }
 
-  InstructionOperand* UseFixedDouble(Node* node, DoubleRegister reg) {
+  InstructionOperand* UseFixed(Node* node, DoubleRegister reg) {
     return Use(node, new (zone())
                UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                   DoubleRegister::ToAllocationIndex(reg)));
   }
 
   InstructionOperand* UseImmediate(Node* node) {
     int index = sequence()->AddImmediate(ToConstant(node));
     return ImmediateOperand::Create(index, zone());
   }
 
@@ skipping 254 matching lines @@
   int control_count() const {
     return descriptor->CanLazilyDeoptimize() ? 2 : 0;
   }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_