Re-reland: Remove register index/code indirection

src/compiler/instruction.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/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/schedule.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionOperand& printable) {
   const InstructionOperand& op = printable.op_;
   const RegisterConfiguration* conf = printable.register_configuration_;
   switch (op.kind()) {
     case InstructionOperand::UNALLOCATED: {
       const UnallocatedOperand* unalloc = UnallocatedOperand::cast(&op);
       os << "v" << unalloc->virtual_register();
       if (unalloc->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
         return os << "(=" << unalloc->fixed_slot_index() << "S)";
       }
       switch (unalloc->extended_policy()) {
         case UnallocatedOperand::NONE:
           return os;
         case UnallocatedOperand::FIXED_REGISTER:
-          return os << "(=" << conf->general_register_name(
-                                   unalloc->fixed_register_index()) << ")";
+          return os << "(="
+                    << conf->GetGeneralRegisterName(
+                           unalloc->fixed_register_index())
+                    << ")";
         case UnallocatedOperand::FIXED_DOUBLE_REGISTER:
-          return os << "(=" << conf->double_register_name(
-                                   unalloc->fixed_register_index()) << ")";
+          return os << "(="
+                    << conf->GetDoubleRegisterName(
+                           unalloc->fixed_register_index())
+                    << ")";
         case UnallocatedOperand::MUST_HAVE_REGISTER:
           return os << "(R)";
         case UnallocatedOperand::MUST_HAVE_SLOT:
           return os << "(S)";
         case UnallocatedOperand::SAME_AS_FIRST_INPUT:
           return os << "(1)";
         case UnallocatedOperand::ANY:
           return os << "(-)";
       }
     }
@@ skipping 12 matching lines @@
     case InstructionOperand::ALLOCATED: {
       auto allocated = AllocatedOperand::cast(op);
       switch (allocated.allocated_kind()) {
         case AllocatedOperand::STACK_SLOT:
           os << "[stack:" << StackSlotOperand::cast(op).index();
           break;
         case AllocatedOperand::DOUBLE_STACK_SLOT:
           os << "[double_stack:" << DoubleStackSlotOperand::cast(op).index();
           break;
         case AllocatedOperand::REGISTER:
-          os << "["
-             << conf->general_register_name(RegisterOperand::cast(op).index())
+          os << "[" << RegisterOperand::cast(op).GetRegister().ToString()
              << "|R";
           break;
         case AllocatedOperand::DOUBLE_REGISTER:
-          os << "["
-             << conf->double_register_name(
-                    DoubleRegisterOperand::cast(op).index()) << "|R";
+          os << "[" << DoubleRegisterOperand::cast(op).GetRegister().ToString()
+             << "|R";
           break;
       }
       switch (allocated.machine_type()) {
         case kRepWord32:
           os << "|w32";
           break;
         case kRepWord64:
           os << "|w64";
           break;
         case kRepFloat32:
@@ skipping 725 matching lines @@
       os << " B" << succ.ToInt();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8