Revert of [turbofan] add MachineType to AllocatedOperand

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 35 matching lines @@
                 << "]";
     case InstructionOperand::IMMEDIATE: {
       auto imm = ImmediateOperand::cast(op);
       switch (imm.type()) {
         case ImmediateOperand::INLINE:
           return os << "#" << imm.inline_value();
         case ImmediateOperand::INDEXED:
           return os << "[immediate:" << imm.indexed_value() << "]";
       }
     }
-    case InstructionOperand::ALLOCATED: {
-      auto allocated = AllocatedOperand::cast(op);
-      switch (allocated.allocated_kind()) {
+    case InstructionOperand::ALLOCATED:
+      switch (AllocatedOperand::cast(op).allocated_kind()) {
         case AllocatedOperand::STACK_SLOT:
-          os << "[stack:" << StackSlotOperand::cast(op).index();
-          break;
+          return os << "[stack:" << StackSlotOperand::cast(op).index() << "]";
         case AllocatedOperand::DOUBLE_STACK_SLOT:
-          os << "[double_stack:" << DoubleStackSlotOperand::cast(op).index();
-          break;
+          return os << "[double_stack:"
+                    << DoubleStackSlotOperand::cast(op).index() << "]";
         case AllocatedOperand::REGISTER:
-          os << "["
-             << conf->general_register_name(RegisterOperand::cast(op).index())
-             << "|R";
-          break;
+          return os << "["
+                    << conf->general_register_name(
+                           RegisterOperand::cast(op).index()) << "|R]";
         case AllocatedOperand::DOUBLE_REGISTER:
-          os << "["
-             << conf->double_register_name(
-                    DoubleRegisterOperand::cast(op).index()) << "|R";
-          break;
+          return os << "["
+                    << conf->double_register_name(
+                           DoubleRegisterOperand::cast(op).index()) << "|R]";
       }
-      switch (allocated.machine_type()) {
-        case kRepWord32:
-          os << "|w32";
-          break;
-        case kRepWord64:
-          os << "|w64";
-          break;
-        case kRepFloat32:
-          os << "|f32";
-          break;
-        case kRepFloat64:
-          os << "|f64";
-          break;
-        case kRepTagged:
-          os << "|t";
-          break;
-        default:
-          os << "|?";
-          break;
-      }
-      return os << "]";
-    }
     case InstructionOperand::INVALID:
       return os << "(x)";
   }
   UNREACHABLE();
   return os;
 }
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableMoveOperands& printable) {
   const MoveOperands& mo = *printable.move_operands_;
   PrintableInstructionOperand printable_op = {printable.register_configuration_,
                                               mo.destination()};
   os << printable_op;
-  if (!mo.source().Equals(mo.destination())) {
+  if (mo.source() != mo.destination()) {
     printable_op.op_ = mo.source();
     os << " = " << printable_op;
   }
   return os << ";";
 }
 
 
 bool ParallelMove::IsRedundant() const {
   for (auto move : *this) {
     if (!move->IsRedundant()) return false;
   }
   return true;
 }
 
 
 MoveOperands* ParallelMove::PrepareInsertAfter(MoveOperands* move) const {
   MoveOperands* replacement = nullptr;
   MoveOperands* to_eliminate = nullptr;
   for (auto curr : *this) {
     if (curr->IsEliminated()) continue;
-    if (curr->destination().EqualsModuloType(move->source())) {
+    if (curr->destination() == move->source()) {
       DCHECK(!replacement);
       replacement = curr;
       if (to_eliminate != nullptr) break;
-    } else if (curr->destination().EqualsModuloType(move->destination())) {
+    } else if (curr->destination() == move->destination()) {
       DCHECK(!to_eliminate);
       to_eliminate = curr;
       if (replacement != nullptr) break;
     }
   }
   DCHECK_IMPLIES(replacement == to_eliminate, replacement == nullptr);
   if (replacement != nullptr) move->set_source(replacement->source());
   return to_eliminate;
 }
 
@@ skipping 350 matching lines @@
       zone_(instruction_zone),
       instruction_blocks_(instruction_blocks),
       source_positions_(zone()),
       block_starts_(zone()),
       constants_(ConstantMap::key_compare(),
                  ConstantMap::allocator_type(zone())),
       immediates_(zone()),
       instructions_(zone()),
       next_virtual_register_(0),
       reference_maps_(zone()),
-      representations_(zone()),
+      doubles_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
+      references_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
       deoptimization_entries_(zone()) {
   block_starts_.reserve(instruction_blocks_->size());
 }
 
 
 int InstructionSequence::NextVirtualRegister() {
   int virtual_register = next_virtual_register_++;
   CHECK_NE(virtual_register, InstructionOperand::kInvalidVirtualRegister);
   return virtual_register;
 }
@@ skipping 47 matching lines @@
   auto end = std::lower_bound(begin, block_starts_.end(), instruction_index,
                               std::less_equal<int>());
   size_t index = std::distance(begin, end) - 1;
   auto block = instruction_blocks_->at(index);
   DCHECK(block->code_start() <= instruction_index &&
          instruction_index < block->code_end());
   return block;
 }
 
 
-static MachineType FilterRepresentation(MachineType rep) {
-  DCHECK_EQ(rep, RepresentationOf(rep));
-  switch (rep) {
-    case kRepBit:
-    case kRepWord8:
-    case kRepWord16:
-      return InstructionSequence::DefaultRepresentation();
-    case kRepWord32:
-    case kRepWord64:
-    case kRepFloat32:
-    case kRepFloat64:
-    case kRepTagged:
-      return rep;
-    default:
-      break;
-  }
-  UNREACHABLE();
-  return kMachNone;
+bool InstructionSequence::IsReference(int virtual_register) const {
+  return references_.find(virtual_register) != references_.end();
 }
 
 
-MachineType InstructionSequence::GetRepresentation(int virtual_register) const {
-  DCHECK_LE(0, virtual_register);
-  DCHECK_LT(virtual_register, VirtualRegisterCount());
-  if (virtual_register >= static_cast<int>(representations_.size())) {
-    return DefaultRepresentation();
-  }
-  return representations_[virtual_register];
+bool InstructionSequence::IsDouble(int virtual_register) const {
+  return doubles_.find(virtual_register) != doubles_.end();
 }
 
 
-void InstructionSequence::MarkAsRepresentation(MachineType machine_type,
-                                               int virtual_register) {
-  DCHECK_LE(0, virtual_register);
-  DCHECK_LT(virtual_register, VirtualRegisterCount());
-  if (virtual_register >= static_cast<int>(representations_.size())) {
-    representations_.resize(VirtualRegisterCount(), DefaultRepresentation());
-  }
-  machine_type = FilterRepresentation(machine_type);
-  DCHECK_IMPLIES(representations_[virtual_register] != machine_type,
-                 representations_[virtual_register] == DefaultRepresentation());
-  representations_[virtual_register] = machine_type;
+void InstructionSequence::MarkAsReference(int virtual_register) {
+  references_.insert(virtual_register);
 }
 
 
+void InstructionSequence::MarkAsDouble(int virtual_register) {
+  doubles_.insert(virtual_register);
+}
+
+
 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 166 matching lines @@
       os << " B" << succ.ToInt();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8