[turbofan] Create ExplicitOperands to specify operands without virtual registers

test/cctest/compiler/test-gap-resolver.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/compiler/gap-resolver.h"
 
 #include "src/base/utils/random-number-generator.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
@@ skipping 14 matching lines @@
     return values_ == other.values_;
   }
 
   bool operator!=(const InterpreterState& other) const {
     return values_ != other.values_;
   }
 
  private:
   struct Key {
     bool is_constant;
-    AllocatedOperand::AllocatedKind kind;
+    bool is_float;
+    LocationOperand::LocationKind kind;
     int index;
 
     bool operator<(const Key& other) const {
       if (this->is_constant != other.is_constant) {
         return this->is_constant;
       }
+      if (this->is_float != other.is_float) {
+        return this->is_float;
+      }
       if (this->kind != other.kind) {
         return this->kind < other.kind;
       }
       return this->index < other.index;
     }
 
     bool operator==(const Key& other) const {
       return this->is_constant == other.is_constant &&
              this->kind == other.kind && this->index == other.index;
     }
@@ skipping 11 matching lines @@
   void write(const InstructionOperand& op, Value v) {
     if (v == ValueFor(op)) {
       values_.erase(KeyFor(op));
     } else {
       values_[KeyFor(op)] = v;
     }
   }
 
   static Key KeyFor(const InstructionOperand& op) {
     bool is_constant = op.IsConstant();
-    AllocatedOperand::AllocatedKind kind;
+    bool is_float = false;
+    LocationOperand::LocationKind kind;
     int index;
     if (!is_constant) {
       if (op.IsRegister()) {
-        index = AllocatedOperand::cast(op).GetRegister().code();
+        index = LocationOperand::cast(op).GetRegister().code();
       } else if (op.IsDoubleRegister()) {
-        index = AllocatedOperand::cast(op).GetDoubleRegister().code();
+        index = LocationOperand::cast(op).GetDoubleRegister().code();
       } else {
-        index = AllocatedOperand::cast(op).index();
+        index = LocationOperand::cast(op).index();
       }
-      kind = AllocatedOperand::cast(op).allocated_kind();
+      is_float = IsFloatingPoint(LocationOperand::cast(op).machine_type());
+      kind = LocationOperand::cast(op).location_kind();
     } else {
       index = ConstantOperand::cast(op).virtual_register();
-      kind = AllocatedOperand::REGISTER;
+      kind = LocationOperand::REGISTER;
     }
-    Key key = {is_constant, kind, index};
+    Key key = {is_constant, is_float, kind, index};
     return key;
   }
 
   static Value ValueFor(const InstructionOperand& op) { return KeyFor(op); }
 
   static InstructionOperand FromKey(Key key) {
     if (key.is_constant) {
       return ConstantOperand(key.index);
     }
     return AllocatedOperand(
@@ skipping 86 matching lines @@
     return kMachNone;
   }
 
   MachineType RandomDoubleType() {
     int index = rng_->NextInt(2);
     if (index == 0) return kRepFloat64;
     return kRepFloat32;
   }
 
   InstructionOperand CreateRandomOperand(bool is_source) {
-    int index = rng_->NextInt(6);
+    int index = rng_->NextInt(7);
     // destination can't be Constant.
-    switch (rng_->NextInt(is_source ? 5 : 4)) {
+    switch (rng_->NextInt(is_source ? 7 : 6)) {
       case 0:
-        return StackSlotOperand(RandomType(), index);
+        return AllocatedOperand(LocationOperand::STACK_SLOT, RandomType(),
+                                index);
       case 1:
-        return DoubleStackSlotOperand(RandomDoubleType(), index);
+        return AllocatedOperand(LocationOperand::STACK_SLOT, RandomDoubleType(),
+                                index);
       case 2:
-        return RegisterOperand(RandomType(), index);
+        return AllocatedOperand(LocationOperand::REGISTER, RandomType(), index);
       case 3:
-        return DoubleRegisterOperand(RandomDoubleType(), index);
+        return AllocatedOperand(LocationOperand::REGISTER, RandomDoubleType(),
+                                index);
       case 4:
+        return ExplicitOperand(LocationOperand::REGISTER, RandomType(), 1);
+      case 5:
+        return ExplicitOperand(LocationOperand::STACK_SLOT, RandomType(),
+                               index);
+      case 6:
         return ConstantOperand(index);
     }
     UNREACHABLE();
     return InstructionOperand();
   }
 
  private:
   v8::base::RandomNumberGenerator* rng_;
 };
 
 
 TEST(FuzzResolver) {
   ParallelMoveCreator pmc;
   for (int size = 0; size < 20; ++size) {
     for (int repeat = 0; repeat < 50; ++repeat) {
       ParallelMove* pm = pmc.Create(size);
 
       // Note: The gap resolver modifies the ParallelMove, so interpret first.
       MoveInterpreter mi1(pmc.main_zone());
       mi1.AssembleParallelMove(pm);
 
       MoveInterpreter mi2(pmc.main_zone());
       GapResolver resolver(&mi2);
       resolver.Resolve(pm);
 
       CHECK(mi1.state() == mi2.state());
     }
   }
 }