[turbofan] Use a vector instead of a set in move optimizer.

src/compiler/move-optimizer.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/move-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 10 matching lines @@
       return a.destination.CompareCanonicalized(b.destination);
     }
     return a.source.CompareCanonicalized(b.source);
   }
 };
 
 typedef ZoneMap<MoveKey, unsigned, MoveKeyCompare> MoveMap;
 
 class OperandSet {
  public:
-  explicit OperandSet(Zone* zone) : set_(zone), fp_reps_(0) {}
+  explicit OperandSet(ZoneVector<InstructionOperand>* buffer)
+      : set_(buffer), fp_reps_(0) {
+    buffer->clear();
+  }
 
   void InsertOp(const InstructionOperand& op) {
-    set_.insert(op);
+    set_->push_back(op);
+
     if (!kSimpleFPAliasing && op.IsFPRegister())
       fp_reps_ |= RepBit(LocationOperand::cast(op).representation());
   }
 
+  bool Contains(const InstructionOperand& op) const {
+    for (const InstructionOperand& elem : *set_) {
+      if (elem.EqualsCanonicalized(op)) return true;
+    }
+    return false;
+  }
+
   bool ContainsOpOrAlias(const InstructionOperand& op) const {
-    if (set_.find(op) != set_.end()) return true;
+    if (Contains(op)) return true;
 
     if (!kSimpleFPAliasing && op.IsFPRegister()) {
       // Platforms where FP registers have complex aliasing need extra checks.
       const LocationOperand& loc = LocationOperand::cast(op);
       MachineRepresentation rep = loc.representation();
       // If haven't encountered mixed rep FP registers, skip the extra checks.
       if (!HasMixedFPReps(fp_reps_ | RepBit(rep))) return false;
 
       // Check register against aliasing registers of other FP representations.
       MachineRepresentation other_rep1, other_rep2;
@@ skipping 13 matching lines @@
         default:
           UNREACHABLE();
           break;
       }
       const RegisterConfiguration* config = RegisterConfiguration::Turbofan();
       int base = -1;
       int aliases =
           config->GetAliases(rep, loc.register_code(), other_rep1, &base);
       DCHECK(aliases > 0 || (aliases == 0 && base == -1));
       while (aliases--) {
-        if (set_.find(AllocatedOperand(LocationOperand::REGISTER, other_rep1,
-                                       base + aliases)) != set_.end())
+        if (Contains(AllocatedOperand(LocationOperand::REGISTER, other_rep1,
+                                      base + aliases))) {
           return true;
+        }
       }
       aliases = config->GetAliases(rep, loc.register_code(), other_rep2, &base);
       DCHECK(aliases > 0 || (aliases == 0 && base == -1));
       while (aliases--) {
-        if (set_.find(AllocatedOperand(LocationOperand::REGISTER, other_rep2,
-                                       base + aliases)) != set_.end())
+        if (Contains(AllocatedOperand(LocationOperand::REGISTER, other_rep2,
+                                      base + aliases))) {
           return true;
+        }
       }
     }
     return false;
   }
 
  private:
   static int RepBit(MachineRepresentation rep) {
     return 1 << static_cast<int>(rep);
   }
 
   static bool HasMixedFPReps(int reps) {
     return reps && !base::bits::IsPowerOfTwo32(reps);
   }
 
-  ZoneSet<InstructionOperand, CompareOperandModuloType> set_;
+  ZoneVector<InstructionOperand>* set_;
   int fp_reps_;
 };
 
 int FindFirstNonEmptySlot(const Instruction* instr) {
   int i = Instruction::FIRST_GAP_POSITION;
   for (; i <= Instruction::LAST_GAP_POSITION; i++) {
     ParallelMove* moves = instr->parallel_moves()[i];
     if (moves == nullptr) continue;
     for (MoveOperands* move : *moves) {
       if (!move->IsRedundant()) return i;
       move->Eliminate();
     }
     moves->clear();  // Clear this redundant move.
   }
   return i;
 }
 
 }  // namespace
 
-
 MoveOptimizer::MoveOptimizer(Zone* local_zone, InstructionSequence* code)
     : local_zone_(local_zone),
       code_(code),
-      local_vector_(local_zone) {}
-
+      local_vector_(local_zone),
+      operand_buffer1(local_zone),
+      operand_buffer2(local_zone) {}
 
 void MoveOptimizer::Run() {
   for (Instruction* instruction : code()->instructions()) {
     CompressGaps(instruction);
   }
   for (InstructionBlock* block : code()->instruction_blocks()) {
     CompressBlock(block);
   }
   for (InstructionBlock* block : code()->instruction_blocks()) {
     if (block->PredecessorCount() <= 1) continue;
@@ skipping 19 matching lines @@
 }
 
 void MoveOptimizer::RemoveClobberedDestinations(Instruction* instruction) {
   if (instruction->IsCall()) return;
   ParallelMove* moves = instruction->parallel_moves()[0];
   if (moves == nullptr) return;
 
   DCHECK(instruction->parallel_moves()[1] == nullptr ||
          instruction->parallel_moves()[1]->empty());
 
-  OperandSet outputs(local_zone());
-  OperandSet inputs(local_zone());
+  OperandSet outputs(&operand_buffer1);
+  OperandSet inputs(&operand_buffer2);
 
   // Outputs and temps are treated together as potentially clobbering a
   // destination operand.
   for (size_t i = 0; i < instruction->OutputCount(); ++i) {
     outputs.InsertOp(*instruction->OutputAt(i));
   }
   for (size_t i = 0; i < instruction->TempCount(); ++i) {
     outputs.InsertOp(*instruction->TempAt(i));
   }
 
@@ skipping 20 matching lines @@
     }
   }
 }
 
 void MoveOptimizer::MigrateMoves(Instruction* to, Instruction* from) {
   if (from->IsCall()) return;
 
   ParallelMove* from_moves = from->parallel_moves()[0];
   if (from_moves == nullptr || from_moves->empty()) return;
 
-  OperandSet dst_cant_be(local_zone());
-  OperandSet src_cant_be(local_zone());
+  OperandSet dst_cant_be(&operand_buffer1);
+  OperandSet src_cant_be(&operand_buffer2);
 
   // If an operand is an input to the instruction, we cannot move assignments
   // where it appears on the LHS.
   for (size_t i = 0; i < from->InputCount(); ++i) {
     dst_cant_be.InsertOp(*from->InputAt(i));
   }
   // If an operand is output to the instruction, we cannot move assignments
   // where it appears on the RHS, because we would lose its value before the
   // instruction.
   // Same for temp operands.
@@ skipping 193 matching lines @@
     }
   }
   if (move_map.empty() || correct_counts == 0) return;
 
   // Find insertion point.
   Instruction* instr = code()->instructions()[block->first_instruction_index()];
 
   if (correct_counts != move_map.size()) {
     // Moves that are unique to each predecessor won't be pushed to the common
     // successor.
-    OperandSet conflicting_srcs(local_zone());
+    OperandSet conflicting_srcs(&operand_buffer1);
     for (auto iter = move_map.begin(), end = move_map.end(); iter != end;) {
       auto current = iter;
       ++iter;
       if (current->second != block->PredecessorCount()) {
         InstructionOperand dest = current->first.destination;
         // Not all the moves in all the gaps are the same. Maybe some are. If
         // there are such moves, we could move them, but the destination of the
         // moves staying behind can't appear as a source of a common move,
         // because the move staying behind will clobber this destination.
         conflicting_srcs.InsertOp(dest);
@@ skipping 109 matching lines @@
         static_cast<Instruction::GapPosition>(1), code_zone());
     slot_1->AddMove(group_begin->destination(), load->destination());
     load->Eliminate();
   }
   loads.clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8