[Turbofan] Allow FP operands and vregs in InstructionSequenceTest.

test/unittests/compiler/instruction-sequence-unittest.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_UNITTESTS_COMPILER_INSTRUCTION_SEQUENCE_UNITTEST_H_
 #define V8_UNITTESTS_COMPILER_INSTRUCTION_SEQUENCE_UNITTEST_H_
 
 #include <memory>
 
 #include "src/compiler/instruction.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class InstructionSequenceTest : public TestWithIsolateAndZone {
  public:
   static const int kDefaultNRegs = 8;
   static const int kNoValue = kMinInt;
+  static const MachineRepresentation kNoRep = MachineRepresentation::kNone;
+  static const MachineRepresentation kFloat64 = MachineRepresentation::kFloat64;
 
   typedef RpoNumber Rpo;
 
   struct VReg {
     VReg() : value_(kNoValue) {}
     VReg(PhiInstruction* phi) : value_(phi->virtual_register()) {}  // NOLINT
-    explicit VReg(int value) : value_(value) {}
+    explicit VReg(int value, MachineRepresentation rep = kNoRep)
+        : value_(value), rep_(rep) {}
     int value_;
+    MachineRepresentation rep_ = kNoRep;
   };
 
   typedef std::pair<VReg, VReg> VRegPair;
 
   enum TestOperandType {
     kInvalid,
     kSameAsFirst,
     kRegister,
     kFixedRegister,
     kSlot,
     kFixedSlot,
     kExplicit,
     kImmediate,
     kNone,
     kConstant,
     kUnique,
     kUniqueRegister
   };
 
   struct TestOperand {
-    TestOperand() : type_(kInvalid), vreg_(), value_(kNoValue) {}
-    TestOperand(TestOperandType type, int imm)
-        : type_(type), vreg_(), value_(imm) {}
+    TestOperand() : type_(kInvalid), vreg_(), value_(kNoValue), rep_(kNoRep) {}
+    explicit TestOperand(TestOperandType type)
+        : type_(type), vreg_(), value_(kNoValue), rep_(kNoRep) {}
+    // For tests that do register allocation.
     TestOperand(TestOperandType type, VReg vreg, int value = kNoValue)
-        : type_(type), vreg_(vreg), value_(value) {}
+        : type_(type), vreg_(vreg), value_(value), rep_(vreg.rep_) {}
+    // For immediates, constants, and tests that don't do register allocation.
+    TestOperand(TestOperandType type, int value,
+                MachineRepresentation rep = kNoRep)
+        : type_(type), vreg_(), value_(value), rep_(rep) {}
 
     TestOperandType type_;
     VReg vreg_;
     int value_;
+    MachineRepresentation rep_;
   };
 
-  static TestOperand Same() { return TestOperand(kSameAsFirst, VReg()); }
+  static TestOperand Same() { return TestOperand(kSameAsFirst); }
 
   static TestOperand ExplicitReg(int index) {
     TestOperandType type = kExplicit;
-    return TestOperand(type, VReg(), index);
+    return TestOperand(type, index);
+  }
+
+  static TestOperand ExplicitFPReg(int index,
+                                   MachineRepresentation rep = kFloat64) {
+    TestOperandType type = kExplicit;
+    return TestOperand(type, index, rep);
   }
 
   static TestOperand Reg(VReg vreg, int index = kNoValue) {
-    TestOperandType type = kRegister;
-    if (index != kNoValue) type = kFixedRegister;
+    TestOperandType type = (index == kNoValue) ? kRegister : kFixedRegister;
     return TestOperand(type, vreg, index);
   }
 
-  static TestOperand Reg(int index = kNoValue) { return Reg(VReg(), index); }
+  static TestOperand Reg(int index = kNoValue,
+                         MachineRepresentation rep = kNoRep) {
+    return Reg(VReg(kNoValue, rep), index);
+  }
+
+  static TestOperand FPReg(int index = kNoValue,
+                           MachineRepresentation rep = kFloat64) {
+    return Reg(index, rep);
+  }
 
   static TestOperand Slot(VReg vreg, int index = kNoValue) {
-    TestOperandType type = kSlot;
-    if (index != kNoValue) type = kFixedSlot;
+    TestOperandType type = (index == kNoValue) ? kSlot : kFixedSlot;
     return TestOperand(type, vreg, index);
   }
 
-  static TestOperand Slot(int index = kNoValue) { return Slot(VReg(), index); }
+  static TestOperand Slot(int index = kNoValue,
+                          MachineRepresentation rep = kNoRep) {
+    return Slot(VReg(kNoValue, rep), index);
+  }
 
   static TestOperand Const(int index) {
     CHECK_NE(kNoValue, index);
-    return TestOperand(kConstant, VReg(), index);
+    return TestOperand(kConstant, index);
   }
 
   static TestOperand Use(VReg vreg) { return TestOperand(kNone, vreg); }
 
   static TestOperand Use() { return Use(VReg()); }
 
   static TestOperand Unique(VReg vreg) { return TestOperand(kUnique, vreg); }
 
   static TestOperand UniqueReg(VReg vreg) {
     return TestOperand(kUniqueRegister, vreg);
@@ skipping 25 matching lines @@
   }
 
   static BlockCompletion Last() {
     BlockCompletion completion = {kBlockEnd, TestOperand(), kNoValue, kNoValue};
     return completion;
   }
 
   InstructionSequenceTest();
 
   void SetNumRegs(int num_general_registers, int num_double_registers);
+  int GetNumRegs(MachineRepresentation rep);
+  int GetAllocatableCode(int index, MachineRepresentation rep = kNoRep);
   RegisterConfiguration* config();
   InstructionSequence* sequence();
 
   void StartLoop(int loop_blocks);
   void EndLoop();
   void StartBlock(bool deferred = false);
   Instruction* EndBlock(BlockCompletion completion = FallThrough());
 
   TestOperand Imm(int32_t imm = 0);
   VReg Define(TestOperand output_op);
   VReg Parameter(TestOperand output_op = Reg()) { return Define(output_op); }
+  VReg FPParameter(MachineRepresentation rep = kFloat64) {
+    return Parameter(FPReg(kNoValue, rep));
+  }
+
+  MachineRepresentation GetCanonicalRep(TestOperand op) {
+    return IsFloatingPoint(op.rep_) ? op.rep_
+                                    : sequence()->DefaultRepresentation();
+  }
 
   Instruction* Return(TestOperand input_op_0);
   Instruction* Return(VReg vreg) { return Return(Reg(vreg, 0)); }
 
   PhiInstruction* Phi(VReg incoming_vreg_0 = VReg(),
                       VReg incoming_vreg_1 = VReg(),
                       VReg incoming_vreg_2 = VReg(),
                       VReg incoming_vreg_3 = VReg());
   PhiInstruction* Phi(VReg incoming_vreg_0, size_t input_count);
   void SetInput(PhiInstruction* phi, size_t input, VReg vreg);
@@ skipping 17 matching lines @@
                    TestOperand input_op_1 = TestOperand(),
                    TestOperand input_op_2 = TestOperand(),
                    TestOperand input_op_3 = TestOperand());
   VReg EmitCall(TestOperand output_op, size_t input_size, TestOperand* inputs);
   VReg EmitCall(TestOperand output_op, TestOperand input_op_0 = TestOperand(),
                 TestOperand input_op_1 = TestOperand(),
                 TestOperand input_op_2 = TestOperand(),
                 TestOperand input_op_3 = TestOperand());
 
   InstructionBlock* current_block() const { return current_block_; }
-  int num_general_registers() const { return num_general_registers_; }
-  int num_double_registers() const { return num_double_registers_; }
 
   // Called after all instructions have been inserted.
   void WireBlocks();
 
  private:
-  VReg NewReg() { return VReg(sequence()->NextVirtualRegister()); }
+  virtual bool DoesRegisterAllocation() const { return true; }
 
-  static TestOperand Invalid() { return TestOperand(kInvalid, VReg()); }
+  VReg NewReg(TestOperand op = TestOperand()) {
+    int vreg = sequence()->NextVirtualRegister();
+    if (IsFloatingPoint(op.rep_))
+      sequence()->MarkAsRepresentation(op.rep_, vreg);
+    return VReg(vreg, op.rep_);
+  }
+
+  static TestOperand Invalid() { return TestOperand(kInvalid); }
 
   Instruction* EmitBranch(TestOperand input_op);
   Instruction* EmitFallThrough();
   Instruction* EmitJump();
   Instruction* NewInstruction(InstructionCode code, size_t outputs_size,
                               InstructionOperand* outputs,
                               size_t inputs_size = 0,
                               InstructionOperand* inputs = nullptr,
                               size_t temps_size = 0,
                               InstructionOperand* temps = nullptr);
@@ skipping 45 matching lines @@
   bool block_returns_;
 
   DISALLOW_COPY_AND_ASSIGN(InstructionSequenceTest);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UNITTESTS_COMPILER_INSTRUCTION_SEQUENCE_UNITTEST_H_