[turbofan] smash GapInstruction into Instruction

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 92 matching lines @@
   DCHECK_IMPLIES(replacement == to_eliminate, replacement == nullptr);
   if (replacement != nullptr) move->set_source(replacement->source());
   return to_eliminate;
 }
 
 
 Instruction::Instruction(InstructionCode opcode)
     : opcode_(opcode),
       bit_field_(OutputCountField::encode(0) | InputCountField::encode(0) |
                  TempCountField::encode(0) | IsCallField::encode(false)),
-      pointer_map_(NULL) {}
+      pointer_map_(NULL) {
+  parallel_moves_[0] = nullptr;
+  parallel_moves_[1] = nullptr;
+}
 
 
 Instruction::Instruction(InstructionCode opcode, size_t output_count,
                          InstructionOperand* outputs, size_t input_count,
                          InstructionOperand* inputs, size_t temp_count,
                          InstructionOperand* temps)
     : opcode_(opcode),
       bit_field_(OutputCountField::encode(output_count) |
                  InputCountField::encode(input_count) |
                  TempCountField::encode(temp_count) |
                  IsCallField::encode(false)),
       pointer_map_(NULL) {
+  parallel_moves_[0] = nullptr;
+  parallel_moves_[1] = nullptr;
   size_t offset = 0;
   for (size_t i = 0; i < output_count; ++i) {
     DCHECK(!outputs[i].IsInvalid());
     operands_[offset++] = outputs[i];
   }
   for (size_t i = 0; i < input_count; ++i) {
     DCHECK(!inputs[i].IsInvalid());
     operands_[offset++] = inputs[i];
   }
   for (size_t i = 0; i < temp_count; ++i) {
     DCHECK(!temps[i].IsInvalid());
     operands_[offset++] = temps[i];
   }
 }
 
 
-bool GapInstruction::IsRedundant() const {
-  for (int i = GapInstruction::FIRST_INNER_POSITION;
-       i <= GapInstruction::LAST_INNER_POSITION; i++) {
-    if (parallel_moves_[i] != NULL && !parallel_moves_[i]->IsRedundant())
+bool Instruction::AreMovesRedundant() const {
+  for (int i = Instruction::FIRST_GAP_POSITION;
+       i <= Instruction::LAST_GAP_POSITION; i++) {
+    if (parallel_moves_[i] != nullptr && !parallel_moves_[i]->IsRedundant()) {
       return false;
+    }
   }
   return true;
 }
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableParallelMove& printable) {
   const ParallelMove& pm = *printable.parallel_move_;
   bool first = true;
   for (ZoneList<MoveOperands>::iterator move = pm.move_operands()->begin();
@@ skipping 125 matching lines @@
   UNREACHABLE();
   return os;
 }
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstruction& printable) {
   const Instruction& instr = *printable.instr_;
   PrintableInstructionOperand printable_op = {printable.register_configuration_,
                                               NULL};
+  os << "gap ";
+  for (int i = Instruction::FIRST_GAP_POSITION;
+       i <= Instruction::LAST_GAP_POSITION; i++) {
+    os << "(";
+    if (instr.parallel_moves()[i] != NULL) {
+      PrintableParallelMove ppm = {printable.register_configuration_,
+                                   instr.parallel_moves()[i]};
+      os << ppm;
+    }
+    os << ") ";
+  }
+  os << "\n          ";
+
   if (instr.OutputCount() > 1) os << "(";
   for (size_t i = 0; i < instr.OutputCount(); i++) {
     if (i > 0) os << ", ";
     printable_op.op_ = instr.OutputAt(i);
     os << printable_op;
   }
 
   if (instr.OutputCount() > 1) os << ") = ";
   if (instr.OutputCount() == 1) os << " = ";
 
-  if (instr.IsGapMoves()) {
-    const GapInstruction* gap = GapInstruction::cast(&instr);
-    os << "gap ";
-    for (int i = GapInstruction::FIRST_INNER_POSITION;
-         i <= GapInstruction::LAST_INNER_POSITION; i++) {
-      os << "(";
-      if (gap->parallel_moves_[i] != NULL) {
-        PrintableParallelMove ppm = {printable.register_configuration_,
-                                     gap->parallel_moves_[i]};
-        os << ppm;
-      }
-      os << ") ";
-    }
-  } else if (instr.IsSourcePosition()) {
+  if (instr.IsSourcePosition()) {
     const SourcePositionInstruction* pos =
         SourcePositionInstruction::cast(&instr);
     os << "position (" << pos->source_position().raw() << ")";
   } else {
     os << ArchOpcodeField::decode(instr.opcode());
     AddressingMode am = AddressingModeField::decode(instr.opcode());
     if (am != kMode_None) {
       os << " : " << AddressingModeField::decode(instr.opcode());
     }
     FlagsMode fm = FlagsModeField::decode(instr.opcode());
@@ skipping 161 matching lines @@
 }
 
 
 int InstructionSequence::NextVirtualRegister() {
   int virtual_register = next_virtual_register_++;
   CHECK_NE(virtual_register, InstructionOperand::kInvalidVirtualRegister);
   return virtual_register;
 }
 
 
-GapInstruction* InstructionSequence::GetBlockStart(RpoNumber rpo) const {
+Instruction* InstructionSequence::GetBlockStart(RpoNumber rpo) const {
   const InstructionBlock* block = InstructionBlockAt(rpo);
-  return GapInstruction::cast(InstructionAt(block->code_start()));
+  return InstructionAt(block->code_start());
 }
 
 
 void InstructionSequence::StartBlock(RpoNumber rpo) {
   DCHECK(block_starts_.size() == rpo.ToSize());
   InstructionBlock* block = InstructionBlockAt(rpo);
   int code_start = static_cast<int>(instructions_.size());
   block->set_code_start(code_start);
   block_starts_.push_back(code_start);
 }
 
 
 void InstructionSequence::EndBlock(RpoNumber rpo) {
   int end = static_cast<int>(instructions_.size());
   InstructionBlock* block = InstructionBlockAt(rpo);
   if (block->code_start() == end) {  // Empty block.  Insert a nop.
     AddInstruction(Instruction::New(zone(), kArchNop));
     end = static_cast<int>(instructions_.size());
   }
   DCHECK(block->code_start() >= 0 && block->code_start() < end);
   block->set_code_end(end);
 }
 
 
 int InstructionSequence::AddInstruction(Instruction* instr) {
-  GapInstruction* gap = GapInstruction::New(zone());
-  instructions_.push_back(gap);
   int index = static_cast<int>(instructions_.size());
   instructions_.push_back(instr);
   if (instr->NeedsPointerMap()) {
     DCHECK(instr->pointer_map() == NULL);
     PointerMap* pointer_map = new (zone()) PointerMap(zone());
     pointer_map->set_instruction_position(index);
     instr->set_pointer_map(pointer_map);
     pointer_maps_.push_back(pointer_map);
   }
   return index;
@@ skipping 27 matching lines @@
 void InstructionSequence::MarkAsReference(int virtual_register) {
   references_.insert(virtual_register);
 }
 
 
 void InstructionSequence::MarkAsDouble(int virtual_register) {
   doubles_.insert(virtual_register);
 }
 
 
-void InstructionSequence::AddGapMove(int index, InstructionOperand* from,
-                                     InstructionOperand* to) {
-  GapAt(index)->GetOrCreateParallelMove(GapInstruction::START, zone())->AddMove(
-      from, to, zone());
-}
-
-
 InstructionSequence::StateId InstructionSequence::AddFrameStateDescriptor(
     FrameStateDescriptor* descriptor) {
   int deoptimization_id = static_cast<int>(deoptimization_entries_.size());
   deoptimization_entries_.push_back(descriptor);
   return StateId::FromInt(deoptimization_id);
 }
 
 FrameStateDescriptor* InstructionSequence::GetFrameStateDescriptor(
     InstructionSequence::StateId state_id) {
   return deoptimization_entries_[state_id.ToInt()];
@@ skipping 140 matching lines @@
       os << " B" << succ.ToInt();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8