[Turbofan] Fix GapResolver tests.

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"
 
 namespace v8 {
@@ skipping 15 matching lines @@
     return values_ == other.values_;
   }
 
   bool operator!=(const InterpreterState& other) const {
     return values_ != other.values_;
   }
 
  private:
   struct Key {
     bool is_constant;
-    bool is_float;
+    MachineRepresentation rep;
     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->rep != other.rep) {
+        return static_cast<int>(this->rep) < static_cast<int>(other.rep);
       }
       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 &&
+      return this->is_constant == other.is_constant && this->rep == other.rep &&
              this->kind == other.kind && this->index == other.index;
     }
   };
 
   // Internally, the state is a normalized permutation of (kind,index) pairs.
   typedef Key Value;
   typedef std::map<Key, Value> OperandMap;
 
   Value read(const InstructionOperand& op) const {
     OperandMap::const_iterator it = values_.find(KeyFor(op));
     return (it == values_.end()) ? ValueFor(op) : it->second;
   }
 
   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();
-    bool is_float = false;
+    MachineRepresentation rep =
+        v8::internal::compiler::InstructionSequence::DefaultRepresentation();
     LocationOperand::LocationKind kind;
     int index;
     if (!is_constant) {
-      if (op.IsRegister()) {
-        index = LocationOperand::cast(op).GetRegister().code();
-      } else if (op.IsFPRegister()) {
-        index = LocationOperand::cast(op).GetDoubleRegister().code();
+      const LocationOperand& loc_op = LocationOperand::cast(op);
+      if (loc_op.IsAnyRegister()) {
+        if (loc_op.IsFPRegister()) {
+          rep = kSimpleFPAliasing ? MachineRepresentation::kFloat64
+                                  : loc_op.representation();
+        }
+        index = loc_op.register_code();
       } else {
-        index = LocationOperand::cast(op).index();
+        index = loc_op.index();
       }
-      is_float = IsFloatingPoint(LocationOperand::cast(op).representation());
-      kind = LocationOperand::cast(op).location_kind();
+      kind = loc_op.location_kind();
     } else {
       index = ConstantOperand::cast(op).virtual_register();
       kind = LocationOperand::REGISTER;
     }
-    Key key = {is_constant, is_float, kind, index};
+    Key key = {is_constant, rep, 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(
-        key.kind,
-        v8::internal::compiler::InstructionSequence::DefaultRepresentation(),
-        key.index);
+    return AllocatedOperand(key.kind, key.rep, key.index);
   }
 
   friend std::ostream& operator<<(std::ostream& os,
                                   const InterpreterState& is) {
     for (OperandMap::const_iterator it = is.values_.begin();
          it != is.values_.end(); ++it) {
       if (it != is.values_.begin()) os << " ";
-      InstructionOperand source = FromKey(it->first);
-      InstructionOperand destination = FromKey(it->second);
+      InstructionOperand source = FromKey(it->second);
+      InstructionOperand destination = FromKey(it->first);
       MoveOperands mo(source, destination);
       PrintableMoveOperands pmo = {RegisterConfiguration::Turbofan(), &mo};
       os << pmo;
     }
     return os;
   }
 
   OperandMap values_;
 };
 
@@ skipping 30 matching lines @@
 };
 
 
 class ParallelMoveCreator : public HandleAndZoneScope {
  public:
   ParallelMoveCreator() : rng_(CcTest::random_number_generator()) {}
 
   ParallelMove* Create(int size) {
     ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone());
     std::set<InstructionOperand, CompareOperandModuloType> seen;
-    MachineRepresentation rep = RandomRepresentation();
     for (int i = 0; i < size; ++i) {
+      MachineRepresentation rep = RandomRepresentation();
       MoveOperands mo(CreateRandomOperand(true, rep),
                       CreateRandomOperand(false, rep));
       if (!mo.IsRedundant() && seen.find(mo.destination()) == seen.end()) {
         parallel_move->AddMove(mo.source(), mo.destination());
         seen.insert(mo.destination());
       }
     }
     return parallel_move;
   }
 
  private:
   MachineRepresentation RandomRepresentation() {
     int index = rng_->NextInt(5);
     switch (index) {
       case 0:
         return MachineRepresentation::kWord32;
       case 1:
         return MachineRepresentation::kWord64;
       case 2:
-        return MachineRepresentation::kFloat32;
+        // TODO(bbudge) Re-enable float operands when GapResolver correctly
+        // handles FP aliasing.
+        return kSimpleFPAliasing ? MachineRepresentation::kFloat32
+                                 : MachineRepresentation::kFloat64;
       case 3:
         return MachineRepresentation::kFloat64;
       case 4:
         return MachineRepresentation::kTagged;
     }
     UNREACHABLE();
     return MachineRepresentation::kNone;
   }
 
   InstructionOperand CreateRandomOperand(bool is_source,
@@ skipping 45 matching lines @@
       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());
+      CHECK_EQ(mi1.state(), mi2.state());
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8