[turbofan] improve register allocator testing framework

test/unittests/compiler/instruction-sequence-unittest.cc

 // 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.
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/compiler/pipeline.h"
 #include "test/unittests/compiler/instruction-sequence-unittest.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ skipping 166 matching lines @@
   sequence()->AddConstant(vreg.value_, Constant(imm));
   InstructionOperand* outputs[1]{ConstantOperand::Create(vreg.value_, zone())};
   Emit(vreg.value_, kArchNop, 1, outputs);
   return vreg;
 }
 
 
 int InstructionSequenceTest::EmitNop() { return Emit(NewIndex(), kArchNop); }
 
 
-int InstructionSequenceTest::EmitI(TestOperand input_op_0) {
-  InstructionOperand* inputs[1]{ConvertInputOp(input_op_0)};
-  return Emit(NewIndex(), kArchNop, 0, nullptr, 1, inputs);
+static size_t CountInputs(size_t size,
+                          InstructionSequenceTest::TestOperand* inputs) {
+  size_t i = 0;
+  for (; i < size; ++i) {
+    if (inputs[i].type_ == InstructionSequenceTest::kInvalid) break;
+  }
+  return i;
+}
+
+
+int InstructionSequenceTest::EmitI(size_t input_size, TestOperand* inputs) {
+  InstructionOperand** mapped_inputs = ConvertInputs(input_size, inputs);
+  return Emit(NewIndex(), kArchNop, 0, nullptr, input_size, mapped_inputs);
+}
+
+
+int InstructionSequenceTest::EmitI(TestOperand input_op_0,
+                                   TestOperand input_op_1,
+                                   TestOperand input_op_2,
+                                   TestOperand input_op_3) {
+  TestOperand inputs[] = {input_op_0, input_op_1, input_op_2, input_op_3};
+  return EmitI(CountInputs(arraysize(inputs), inputs), inputs);
 }
 
 
 InstructionSequenceTest::VReg InstructionSequenceTest::EmitOI(
-    TestOperand output_op, TestOperand input_op_0) {
+    TestOperand output_op, size_t input_size, TestOperand* inputs) {
   VReg output_vreg = NewReg();
   InstructionOperand* outputs[1]{ConvertOutputOp(output_vreg, output_op)};
-  InstructionOperand* inputs[1]{ConvertInputOp(input_op_0)};
-  Emit(output_vreg.value_, kArchNop, 1, outputs, 1, inputs);
+  InstructionOperand** mapped_inputs = ConvertInputs(input_size, inputs);
+  Emit(output_vreg.value_, kArchNop, 1, outputs, input_size, mapped_inputs);
   return output_vreg;
 }
 
 
-InstructionSequenceTest::VReg InstructionSequenceTest::EmitOII(
-    TestOperand output_op, TestOperand input_op_0, TestOperand input_op_1) {
-  VReg output_vreg = NewReg();
-  InstructionOperand* outputs[1]{ConvertOutputOp(output_vreg, output_op)};
-  InstructionOperand* inputs[2]{ConvertInputOp(input_op_0),
-                                ConvertInputOp(input_op_1)};
-  Emit(output_vreg.value_, kArchNop, 1, outputs, 2, inputs);
-  return output_vreg;
+InstructionSequenceTest::VReg InstructionSequenceTest::EmitOI(
+    TestOperand output_op, TestOperand input_op_0, TestOperand input_op_1,
+    TestOperand input_op_2, TestOperand input_op_3) {
+  TestOperand inputs[] = {input_op_0, input_op_1, input_op_2, input_op_3};
+  return EmitOI(output_op, CountInputs(arraysize(inputs), inputs), inputs);
 }
 
 
 InstructionSequenceTest::VReg InstructionSequenceTest::EmitCall(
     TestOperand output_op, size_t input_size, TestOperand* inputs) {
   VReg output_vreg = NewReg();
   InstructionOperand* outputs[1]{ConvertOutputOp(output_vreg, output_op)};
   CHECK(UnallocatedOperand::cast(outputs[0])->HasFixedPolicy());
-  InstructionOperand** mapped_inputs =
-      zone()->NewArray<InstructionOperand*>(static_cast<int>(input_size));
-  for (size_t i = 0; i < input_size; ++i) {
-    mapped_inputs[i] = ConvertInputOp(inputs[i]);
-  }
+  InstructionOperand** mapped_inputs = ConvertInputs(input_size, inputs);
   Emit(output_vreg.value_, kArchCallCodeObject, 1, outputs, input_size,
        mapped_inputs, 0, nullptr, true);
   return output_vreg;
 }
 
 
 InstructionSequenceTest::VReg InstructionSequenceTest::EmitCall(
     TestOperand output_op, TestOperand input_op_0, TestOperand input_op_1,
     TestOperand input_op_2, TestOperand input_op_3) {
   TestOperand inputs[] = {input_op_0, input_op_1, input_op_2, input_op_3};
-  size_t size = 0;
-  for (; size < arraysize(inputs); ++size) {
-    if (inputs[size].type_ == kInvalid) break;
-  }
-  return EmitCall(output_op, size, inputs);
+  return EmitCall(output_op, CountInputs(arraysize(inputs), inputs), inputs);
 }
 
 
 const Instruction* InstructionSequenceTest::GetInstruction(
     int instruction_index) {
   auto it = instructions_.find(instruction_index);
   CHECK(it != instructions_.end());
   return it->second;
 }
 
@@ skipping 59 matching lines @@
 
 
 InstructionOperand* InstructionSequenceTest::Unallocated(
     TestOperand op, UnallocatedOperand::BasicPolicy policy, int index) {
   auto unallocated = new (zone()) UnallocatedOperand(policy, index);
   unallocated->set_virtual_register(op.vreg_.value_);
   return unallocated;
 }
 
 
+InstructionOperand** InstructionSequenceTest::ConvertInputs(
+    size_t input_size, TestOperand* inputs) {
+  InstructionOperand** mapped_inputs =
+      zone()->NewArray<InstructionOperand*>(static_cast<int>(input_size));
+  for (size_t i = 0; i < input_size; ++i) {
+    mapped_inputs[i] = ConvertInputOp(inputs[i]);
+  }
+  return mapped_inputs;
+}
+
+
 InstructionOperand* InstructionSequenceTest::ConvertInputOp(TestOperand op) {
   if (op.type_ == kImmediate) {
     CHECK_EQ(op.vreg_.value_, kNoValue);
     return ImmediateOperand::Create(op.value_, zone());
   }
   CHECK_NE(op.vreg_.value_, kNoValue);
   switch (op.type_) {
     case kNone:
       return Unallocated(op, UnallocatedOperand::NONE,
                          UnallocatedOperand::USED_AT_START);
+    case kUnique:
+      return Unallocated(op, UnallocatedOperand::NONE);
+    case kUniqueRegister:
+      return Unallocated(op, UnallocatedOperand::MUST_HAVE_REGISTER);
     case kRegister:
       return Unallocated(op, UnallocatedOperand::MUST_HAVE_REGISTER,
                          UnallocatedOperand::USED_AT_START);
     case kFixedRegister:
       CHECK(0 <= op.value_ && op.value_ < num_general_registers_);
       return Unallocated(op, UnallocatedOperand::FIXED_REGISTER, op.value_);
     case kFixedSlot:
       return Unallocated(op, UnallocatedOperand::FIXED_SLOT, op.value_);
     default:
       break;
@@ skipping 105 matching lines @@
 
 int InstructionSequenceTest::AddInstruction(int instruction_index,
                                             Instruction* instruction) {
   sequence()->AddInstruction(instruction);
   return instruction_index;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8