[turbofan] improve register allocator testing framework

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 "src/compiler/instruction.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 18 matching lines @@
 
   enum TestOperandType {
     kInvalid,
     kSameAsFirst,
     kRegister,
     kFixedRegister,
     kSlot,
     kFixedSlot,
     kImmediate,
     kNone,
-    kConstant
+    kConstant,
+    kUnique,
+    kUniqueRegister
   };
 
   struct TestOperand {
     TestOperand() : type_(kInvalid), vreg_(), value_(kNoValue) {}
     TestOperand(TestOperandType type, int imm)
         : type_(type), vreg_(), value_(imm) {}
     TestOperand(TestOperandType type, VReg vreg, int value = kNoValue)
         : type_(type), vreg_(vreg), value_(value) {}
 
     TestOperandType type_;
@@ skipping 21 matching lines @@
 
   static TestOperand Const(int index) {
     CHECK_NE(kNoValue, index);
     return TestOperand(kConstant, VReg(), 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);
+  }
+
   enum BlockCompletionType { kBlockEnd, kFallThrough, kBranch, kJump };
 
   struct BlockCompletion {
     BlockCompletionType type_;
     TestOperand op_;
     int offset_0_;
     int offset_1_;
   };
 
   static BlockCompletion FallThrough() {
@@ skipping 36 matching lines @@
   int 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());
   void Extend(PhiInstruction* phi, VReg vreg);
 
   VReg DefineConstant(int32_t imm = 0);
   int EmitNop();
-  int EmitI(TestOperand input_op_0);
-  VReg EmitOI(TestOperand output_op, TestOperand input_op_0);
-  VReg EmitOII(TestOperand output_op, TestOperand input_op_0,
-               TestOperand input_op_1);
+  int EmitI(size_t input_size, TestOperand* inputs);
+  int EmitI(TestOperand input_op_0 = TestOperand(),
+            TestOperand input_op_1 = TestOperand(),
+            TestOperand input_op_2 = TestOperand(),
+            TestOperand input_op_3 = TestOperand());
+  VReg EmitOI(TestOperand output_op, size_t input_size, TestOperand* inputs);
+  VReg EmitOI(TestOperand output_op, TestOperand input_op_0 = TestOperand(),
+              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());
 
   // Get defining instruction vreg or value returned at instruction creation
   // time when there is no return value.
   const Instruction* GetInstruction(int instruction_index);
 
@@ skipping 23 matching lines @@
                                   UnallocatedOperand::ExtendedPolicy policy);
   InstructionOperand* Unallocated(TestOperand op,
                                   UnallocatedOperand::ExtendedPolicy policy,
                                   UnallocatedOperand::Lifetime lifetime);
   InstructionOperand* Unallocated(TestOperand op,
                                   UnallocatedOperand::ExtendedPolicy policy,
                                   int index);
   InstructionOperand* Unallocated(TestOperand op,
                                   UnallocatedOperand::BasicPolicy policy,
                                   int index);
+  InstructionOperand** ConvertInputs(size_t input_size, TestOperand* inputs);
   InstructionOperand* ConvertInputOp(TestOperand op);
   InstructionOperand* ConvertOutputOp(VReg vreg, TestOperand op);
   InstructionBlock* NewBlock();
   void WireBlock(size_t block_offset, int jump_offset);
 
   int Emit(int instruction_index, InstructionCode code, size_t outputs_size = 0,
            InstructionOperand* *outputs = nullptr, size_t inputs_size = 0,
            InstructionOperand* *inputs = nullptr, size_t temps_size = 0,
            InstructionOperand* *temps = nullptr, bool is_call = false);
 
@@ skipping 21 matching lines @@
   LoopBlocks loop_blocks_;
   InstructionBlock* current_block_;
   bool block_returns_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UNITTESTS_COMPILER_INSTRUCTION_SEQUENCE_UNITTEST_H_