[turbofan] remove one level of indirection in phi inputs

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"
 
 namespace v8 {
 namespace internal {
@@ skipping 319 matching lines @@
     case Constant::kHeapObject:
       return os << Brief(*constant.ToHeapObject());
     case Constant::kRpoNumber:
       return os << "RPO" << constant.ToRpoNumber().ToInt();
   }
   UNREACHABLE();
   return os;
 }
 
 
+PhiInstruction::PhiInstruction(Zone* zone, int virtual_register,
+                               size_t input_count)
+    : virtual_register_(virtual_register),
+      output_(UnallocatedOperand(UnallocatedOperand::NONE, virtual_register)),
+      operands_(input_count, zone),
+      inputs_(input_count, zone) {}
+
+
+void PhiInstruction::SetInput(size_t offset, int virtual_register) {
+  DCHECK(inputs_[offset].IsInvalid());
+  auto input = UnallocatedOperand(UnallocatedOperand::ANY, virtual_register);
+  inputs_[offset] = input;
+  operands_[offset] = virtual_register;
+}
+
+
 InstructionBlock::InstructionBlock(Zone* zone, BasicBlock::Id id,
                                    BasicBlock::RpoNumber rpo_number,
                                    BasicBlock::RpoNumber loop_header,
                                    BasicBlock::RpoNumber loop_end,
                                    bool deferred)
     : successors_(zone),
       predecessors_(zone),
       phis_(zone),
       id_(id),
       ao_number_(rpo_number),
@@ skipping 309 matching lines @@
        << block->code_end() << ")\n  predecessors:";
 
     for (auto pred : block->predecessors()) {
       const InstructionBlock* pred_block = code.InstructionBlockAt(pred);
       os << " B" << pred_block->id();
     }
     os << "\n";
 
     for (auto phi : block->phis()) {
       PrintableInstructionOperand printable_op = {
-          printable.register_configuration_, phi->output()};
+          printable.register_configuration_, &phi->output()};
       os << "     phi: " << printable_op << " =";
       for (auto input : phi->inputs()) {
-        printable_op.op_ = input;
+        printable_op.op_ = &input;
         os << " " << printable_op;
       }
       os << "\n";
     }
 
     ScopedVector<char> buf(32);
     PrintableInstruction printable_instr;
     printable_instr.register_configuration_ = printable.register_configuration_;
     for (int j = block->first_instruction_index();
          j <= block->last_instruction_index(); j++) {
       // TODO(svenpanne) Add some basic formatting to our streams.
       SNPrintF(buf, "%5d", j);
       printable_instr.instr_ = code.InstructionAt(j);
       os << "   " << buf.start() << ": " << printable_instr << "\n";
     }
 
     for (auto succ : block->successors()) {
       const InstructionBlock* succ_block = code.InstructionBlockAt(succ);
       os << " B" << succ_block->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8