[turbofan] Make AllocatedOperand an InstructionOperand::Kind.

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 @@
 
   bool operator==(const InterpreterState& other) const {
     return values_ == other.values_;
   }
 
   bool operator!=(const InterpreterState& other) const {
     return values_ != other.values_;
   }
 
  private:
+  struct Key {
+    bool is_constant;
+    AllocatedOperand::AllocatedKind kind;
+    int index;
+
+    bool operator<(const Key& other) const {
+      if (this->is_constant != other.is_constant) {
+        return this->is_constant;
+      }
+      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;
+    }
+  };
+
   // Internally, the state is a normalized permutation of (kind,index) pairs.
-  typedef std::pair<InstructionOperand::Kind, int> Key;
   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) {
-    int v = op->IsConstant() ? ConstantOperand::cast(op)->virtual_register()
-                             : AllocatedOperand::cast(op)->index();
-    return Key(op->kind(), v);
+    bool is_constant = op->IsConstant();
+    AllocatedOperand::AllocatedKind kind;
+    int index;
+    if (!is_constant) {
+      index = AllocatedOperand::cast(op)->index();
+      kind = AllocatedOperand::cast(op)->allocated_kind();
+    } else {
+      index = ConstantOperand::cast(op)->virtual_register();
+      kind = AllocatedOperand::REGISTER;
+    }
+    Key key = {is_constant, kind, index};
+    return key;
   }
 
-  static Value ValueFor(const InstructionOperand* op) {
-    int v = op->IsConstant() ? ConstantOperand::cast(op)->virtual_register()
-                             : AllocatedOperand::cast(op)->index();
-    return Value(op->kind(), v);
-  }
+  static Value ValueFor(const InstructionOperand* op) { return KeyFor(op); }
 
   static InstructionOperand FromKey(Key key) {
-    if (key.first == InstructionOperand::CONSTANT) {
-      return ConstantOperand(key.second);
+    if (key.is_constant) {
+      return ConstantOperand(key.index);
     }
-    return AllocatedOperand(key.first, key.second);
+    return AllocatedOperand(key.kind, 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);
       MoveOperands mo(&source, &destination);
@@ skipping 98 matching lines @@
       mi1.AssembleParallelMove(pm);
 
       MoveInterpreter mi2;
       GapResolver resolver(&mi2);
       resolver.Resolve(pm);
 
       CHECK(mi1.state() == mi2.state());
     }
   }
 }