revert r25736

R=bmeurer@chromium.org

BUG=

Review URL: https://codereview.chromium.org/803493002

Cr-Commit-Position: refs/heads/master@{#25795}

src/compiler/graph-visualizer.cc

@@ -725,7 +725,7 @@ void GraphC1Visualizer::PrintLiveRange(LiveRange* range, const char* type) {
       }
     } else if (range->IsSpilled()) {
       int index = -1;
-      if (range->TopLevel()->HasSpillRange()) {
+      if (range->TopLevel()->GetSpillRange() != nullptr) {
         index = kMaxInt;  // This hasn't been set yet.
       } else {
         index = range->TopLevel()->GetSpillOperand()->index();

src/compiler/instruction.cc

@@ -15,6 +15,8 @@ std::ostream& operator<<(std::ostream& os,
   const InstructionOperand& op = *printable.op_;
   const RegisterConfiguration* conf = printable.register_configuration_;
   switch (op.kind()) {
+    case InstructionOperand::INVALID:
+      return os << "(0)";
     case InstructionOperand::UNALLOCATED: {
       const UnallocatedOperand* unalloc = UnallocatedOperand::cast(&op);
       os << "v" << unalloc->virtual_register();

src/compiler/instruction.h

@@ -39,6 +39,7 @@ const InstructionCode kSourcePositionInstruction = -3;
 class InstructionOperand : public ZoneObject {
  public:
   enum Kind {
+    INVALID,
     UNALLOCATED,
     CONSTANT,
     IMMEDIATE,
@@ -48,6 +49,7 @@ class InstructionOperand : public ZoneObject {
     DOUBLE_REGISTER
   };
 
+  InstructionOperand() : value_(KindField::encode(INVALID)) {}
   InstructionOperand(Kind kind, int index) { ConvertTo(kind, index); }
 
   Kind kind() const { return KindField::decode(value_); }
@@ -56,6 +58,7 @@ class InstructionOperand : public ZoneObject {
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_PREDICATE)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
+  INSTRUCTION_OPERAND_PREDICATE(Ignored, INVALID, 0)
 #undef INSTRUCTION_OPERAND_PREDICATE
   bool Equals(const InstructionOperand* other) const {
     return value_ == other->value_;
@@ -288,12 +291,16 @@ class MoveOperands FINAL {
   }
 
   // A move is redundant if it's been eliminated, if its source and
-  // destination are the same, or if its destination is  constant.
+  // destination are the same, or if its destination is unneeded or constant.
   bool IsRedundant() const {
-    return IsEliminated() || source_->Equals(destination_) ||
+    return IsEliminated() || source_->Equals(destination_) || IsIgnored() ||
            (destination_ != NULL && destination_->IsConstant());
   }
 
+  bool IsIgnored() const {
+    return destination_ != NULL && destination_->IsIgnored();
+  }
+
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = NULL; }
   bool IsEliminated() const {
@@ -341,7 +348,7 @@ class SubKindOperand FINAL : public InstructionOperand {
  private:
   static SubKindOperand* cache;
 
-  SubKindOperand() : InstructionOperand(kOperandKind, 0) {}  // For the caches.
+  SubKindOperand() : InstructionOperand() {}
   explicit SubKindOperand(int index)
       : InstructionOperand(kOperandKind, index) {}
 };

src/compiler/pipeline.cc

@@ -585,15 +585,6 @@ struct ReuseSpillSlotsPhase {
 };
 
 
-struct CommitAssignmentPhase {
-  static const char* phase_name() { return "commit assignment"; }
-
-  void Run(PipelineData* data, Zone* temp_zone) {
-    data->register_allocator()->CommitAssignment();
-  }
-};
-
-
 struct PopulatePointerMapsPhase {
   static const char* phase_name() { return "populate pointer maps"; }
 
@@ -1045,7 +1036,6 @@ void Pipeline::AllocateRegisters(const RegisterConfiguration* config,
   if (FLAG_turbo_reuse_spill_slots) {
     Run<ReuseSpillSlotsPhase>();
   }
-  Run<CommitAssignmentPhase>();
   Run<PopulatePointerMapsPhase>();
   Run<ConnectRangesPhase>();
   Run<ResolveControlFlowPhase>();

src/compiler/register-allocator-verifier.cc

@@ -276,8 +276,10 @@ class RegisterAllocatorVerifier::OutgoingMapping : public ZoneObject {
     auto* moves = move->move_operands();
     for (auto i = moves->begin(); i != moves->end(); ++i) {
       if (i->IsEliminated()) continue;
+      CHECK(i->source()->kind() != InstructionOperand::INVALID);
       auto cur = locations()->find(i->source());
       CHECK(cur != locations()->end());
+      if (i->destination()->kind() == InstructionOperand::INVALID) continue;
       to_insert.insert(std::make_pair(i->destination(), cur->second));
     }
     // Drop current mappings.

src/compiler/register-allocator.h

@@ -197,7 +197,7 @@ class LiveRange FINAL : public ZoneObject {
   int assigned_register() const { return assigned_register_; }
   int spill_start_index() const { return spill_start_index_; }
   void set_assigned_register(int reg, Zone* zone);
-  void MakeSpilled();
+  void MakeSpilled(Zone* zone);
   bool is_phi() const { return is_phi_; }
   void set_is_phi(bool is_phi) { is_phi_ = is_phi; }
   bool is_non_loop_phi() const { return is_non_loop_phi_; }
@@ -260,27 +260,13 @@ class LiveRange FINAL : public ZoneObject {
     return last_interval_->end();
   }
 
-  enum class SpillType { kNoSpillType, kSpillOperand, kSpillRange };
-  SpillType spill_type() const { return spill_type_; }
-  InstructionOperand* GetSpillOperand() const {
-    return spill_type_ == SpillType::kSpillOperand ? spill_operand_ : nullptr;
-  }
-  SpillRange* GetSpillRange() const {
-    return spill_type_ == SpillType::kSpillRange ? spill_range_ : nullptr;
-  }
-  bool HasNoSpillType() const { return spill_type_ == SpillType::kNoSpillType; }
-  bool HasSpillOperand() const {
-    return spill_type_ == SpillType::kSpillOperand;
-  }
-  bool HasSpillRange() const { return spill_type_ == SpillType::kSpillRange; }
-
-  void SpillAtDefinition(Zone* zone, int gap_index,
-                         InstructionOperand* operand);
+  bool HasAllocatedSpillOperand() const;
+  InstructionOperand* GetSpillOperand() const { return spill_operand_; }
   void SetSpillOperand(InstructionOperand* operand);
-  void SetSpillRange(SpillRange* spill_range);
+
+  void SetSpillRange(SpillRange* spill_range) { spill_range_ = spill_range; }
+  SpillRange* GetSpillRange() const { return spill_range_; }
   void CommitSpillOperand(InstructionOperand* operand);
-  void CommitSpillsAtDefinition(InstructionSequence* sequence,
-                                InstructionOperand* operand);
 
   void SetSpillStartIndex(int start) {
     spill_start_index_ = Min(start, spill_start_index_);
@@ -307,14 +293,12 @@ class LiveRange FINAL : public ZoneObject {
 #endif
 
  private:
-  struct SpillAtDefinitionList;
-
+  void ConvertOperands(Zone* zone);
   void ConvertUsesToOperand(InstructionOperand* op);
   UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const;
   void AdvanceLastProcessedMarker(UseInterval* to_start_of,
                                   LifetimePosition but_not_past) const;
 
-  // TODO(dcarney): pack this structure better.
   int id_;
   bool spilled_;
   bool is_phi_;
@@ -331,13 +315,9 @@ class LiveRange FINAL : public ZoneObject {
   UsePosition* last_processed_use_;
   // This is used as a cache, it's invalid outside of BuildLiveRanges.
   InstructionOperand* current_hint_operand_;
+  InstructionOperand* spill_operand_;
   int spill_start_index_;
-  SpillType spill_type_;
-  union {
-    InstructionOperand* spill_operand_;
-    SpillRange* spill_range_;
-  };
-  SpillAtDefinitionList* spills_at_definition_;
+  SpillRange* spill_range_;
 
   friend class RegisterAllocator;  // Assigns to kind_.
 
@@ -408,16 +388,13 @@ class RegisterAllocator FINAL : public ZoneObject {
   // Phase 5: reassign spill splots for maximal reuse.
   void ReuseSpillSlots();
 
-  // Phase 6: commit assignment.
-  void CommitAssignment();
-
-  // Phase 7: compute values for pointer maps.
+  // Phase 6: compute values for pointer maps.
   void PopulatePointerMaps();  // TODO(titzer): rename to PopulateReferenceMaps.
 
-  // Phase 8: reconnect split ranges with moves.
+  // Phase 7: reconnect split ranges with moves.
   void ConnectRanges();
 
-  // Phase 9: insert moves to connect ranges across basic blocks.
+  // Phase 8: insert moves to connect ranges across basic blocks.
   void ResolveControlFlow();
 
  private: