[turbofan] cleanup InstructionOperand a little

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 {
@@ skipping 24 matching lines @@
           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 << "(-)";
       }
     }
     case InstructionOperand::CONSTANT:
-      return os << "[constant:" << op.index() << "]";
+      return os << "[constant:" << ConstantOperand::cast(op).virtual_register()
+                << "]";
     case InstructionOperand::IMMEDIATE:
-      return os << "[immediate:" << op.index() << "]";
+      return os << "[immediate:" << ImmediateOperand::cast(op).index() << "]";
     case InstructionOperand::STACK_SLOT:
-      return os << "[stack:" << op.index() << "]";
+      return os << "[stack:" << StackSlotOperand::cast(op).index() << "]";
     case InstructionOperand::DOUBLE_STACK_SLOT:
-      return os << "[double_stack:" << op.index() << "]";
+      return os << "[double_stack:" << DoubleStackSlotOperand::cast(op).index()
+                << "]";
     case InstructionOperand::REGISTER:
-      return os << "[" << conf->general_register_name(op.index()) << "|R]";
+      return os << "["
+                << conf->general_register_name(
+                       RegisterOperand::cast(op).index()) << "|R]";
     case InstructionOperand::DOUBLE_REGISTER:
-      return os << "[" << conf->double_register_name(op.index()) << "|R]";
+      return os << "["
+                << conf->double_register_name(
+                       DoubleRegisterOperand::cast(op).index()) << "|R]";
     case InstructionOperand::INVALID:
       return os << "(x)";
   }
   UNREACHABLE();
   return os;
 }
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableMoveOperands& printable) {
@@ skipping 100 matching lines @@
     first = false;
     PrintableMoveOperands pmo = {printable.register_configuration_, move};
     os << pmo;
   }
   return os;
 }
 
 
 void PointerMap::RecordPointer(InstructionOperand* op, Zone* zone) {
   // Do not record arguments as pointers.
-  if (op->IsStackSlot() && op->index() < 0) return;
+  if (op->IsStackSlot() && StackSlotOperand::cast(op)->index() < 0) return;
   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   pointer_operands_.Add(op, zone);
 }
 
 
 void PointerMap::RemovePointer(InstructionOperand* op) {
   // Do not record arguments as pointers.
-  if (op->IsStackSlot() && op->index() < 0) return;
+  if (op->IsStackSlot() && StackSlotOperand::cast(op)->index() < 0) return;
   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   for (int i = 0; i < pointer_operands_.length(); ++i) {
     if (pointer_operands_[i]->Equals(op)) {
       pointer_operands_.Remove(i);
       --i;
     }
   }
 }
 
 
 void PointerMap::RecordUntagged(InstructionOperand* op, Zone* zone) {
   // Do not record arguments as pointers.
-  if (op->IsStackSlot() && op->index() < 0) return;
+  if (op->IsStackSlot() && StackSlotOperand::cast(op)->index() < 0) return;
   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   untagged_operands_.Add(op, zone);
 }
 
 
 std::ostream& operator<<(std::ostream& os, const PointerMap& pm) {
   os << "{";
   for (ZoneList<InstructionOperand*>::iterator op =
            pm.pointer_operands_.begin();
        op != pm.pointer_operands_.end(); ++op) {
@@ skipping 378 matching lines @@
     InstructionSequence::StateId state_id) {
   return deoptimization_entries_[state_id.ToInt()];
 }
 
 
 int InstructionSequence::GetFrameStateDescriptorCount() {
   return static_cast<int>(deoptimization_entries_.size());
 }
 
 
+RpoNumber InstructionSequence::InputRpo(Instruction* instr, size_t index) {
+  InstructionOperand* operand = instr->InputAt(index);
+  Constant constant =
+      operand->IsImmediate()
+          ? GetImmediate(ImmediateOperand::cast(operand)->index())
+          : GetConstant(ConstantOperand::cast(operand)->virtual_register());
+  return constant.ToRpoNumber();
+}
+
+
 FrameStateDescriptor::FrameStateDescriptor(
     Zone* zone, const FrameStateCallInfo& state_info, size_t parameters_count,
     size_t locals_count, size_t stack_count, FrameStateDescriptor* outer_state)
     : type_(state_info.type()),
       bailout_id_(state_info.bailout_id()),
       frame_state_combine_(state_info.state_combine()),
       parameters_count_(parameters_count),
       locals_count_(locals_count),
       stack_count_(stack_count),
       types_(zone),
@@ skipping 122 matching lines @@
       os << " B" << succ.ToInt();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8