Re-reland: Remove register index/code indirection

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 55 matching lines @@
     } else {
       values_[KeyFor(op)] = v;
     }
   }
 
   static Key KeyFor(const InstructionOperand& op) {
     bool is_constant = op.IsConstant();
     AllocatedOperand::AllocatedKind kind;
     int index;
     if (!is_constant) {
-      index = AllocatedOperand::cast(op).index();
+      if (op.IsRegister()) {
+        index = AllocatedOperand::cast(op).GetRegister().code();
+      } else if (op.IsDoubleRegister()) {
+        index = AllocatedOperand::cast(op).GetDoubleRegister().code();
+      } else {
+        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) { return KeyFor(op); }
 
   static InstructionOperand FromKey(Key key) {
     if (key.is_constant) {
       return ConstantOperand(key.index);
     }
     return AllocatedOperand(
-        key.kind, InstructionSequence::DefaultRepresentation(), key.index);
+        key.kind,
+        v8::internal::compiler::InstructionSequence::DefaultRepresentation(),
+        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 112 matching lines @@
       mi1.AssembleParallelMove(pm);
 
       MoveInterpreter mi2(pmc.main_zone());
       GapResolver resolver(&mi2);
       resolver.Resolve(pm);
 
       CHECK(mi1.state() == mi2.state());
     }
   }
 }