Revert of [Turbofan] Clean up register allocator and verifier code.

src/compiler/register-allocator-verifier.h

 // 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.
 
 #ifndef V8_REGISTER_ALLOCATOR_VERIFIER_H_
 #define V8_REGISTER_ALLOCATOR_VERIFIER_H_
 
 #include "src/zone-containers.h"
 
 namespace v8 {
@@ skipping 81 matching lines @@
 // FinalAssessmens are associated to operands that we know to be a certain
 // virtual register.
 class FinalAssessment final : public Assessment {
  public:
   explicit FinalAssessment(int virtual_register,
                            const PendingAssessment* original_pending = nullptr)
       : Assessment(Final),
         virtual_register_(virtual_register),
         original_pending_assessment_(original_pending) {}
 
+  int virtual_register() const { return virtual_register_; }
   static const FinalAssessment* cast(const Assessment* assessment) {
     CHECK(assessment->kind() == Final);
     return static_cast<const FinalAssessment*>(assessment);
   }
 
-  int virtual_register() const { return virtual_register_; }
   const PendingAssessment* original_pending_assessment() const {
     return original_pending_assessment_;
   }
 
  private:
   int virtual_register_;
   const PendingAssessment* original_pending_assessment_;
 
   DISALLOW_COPY_AND_ASSIGN(FinalAssessment);
 };
 
+struct OperandAsKeyLess {
+  bool operator()(const InstructionOperand& a,
+                  const InstructionOperand& b) const {
+    return a.CompareCanonicalized(b);
+  }
+};
+
 // Assessments associated with a basic block.
 class BlockAssessments : public ZoneObject {
  public:
-  typedef ZoneMap<InstructionOperand, Assessment*, CompareOperandModuloType>
-      OperandMap;
+  typedef ZoneMap<InstructionOperand, Assessment*, OperandAsKeyLess> OperandMap;
   explicit BlockAssessments(Zone* zone)
       : map_(zone), map_for_moves_(zone), zone_(zone) {}
   void Drop(InstructionOperand operand) { map_.erase(operand); }
   void DropRegisters();
   void AddDefinition(InstructionOperand operand, int virtual_register) {
     auto existent = map_.find(operand);
     if (existent != map_.end()) {
       // Drop the assignment
       map_.erase(existent);
     }
@@ skipping 57 matching lines @@
   struct InstructionConstraint {
     const Instruction* instruction_;
     size_t operand_constaints_size_;
     OperandConstraint* operand_constraints_;
   };
 
   typedef ZoneVector<InstructionConstraint> Constraints;
 
   class DelayedAssessments : public ZoneObject {
    public:
-    typedef ZoneMap<InstructionOperand, int, CompareOperandModuloType>
-        OperandMap;
     explicit DelayedAssessments(Zone* zone) : map_(zone) {}
 
-    const OperandMap& map() const { return map_; }
+    const ZoneMap<InstructionOperand, int, OperandAsKeyLess>& map() const {
+      return map_;
+    }
 
     void AddDelayedAssessment(InstructionOperand op, int vreg) {
       auto it = map_.find(op);
       if (it == map_.end()) {
         map_.insert(std::make_pair(op, vreg));
       } else {
         CHECK_EQ(it->second, vreg);
       }
     }
 
    private:
-    OperandMap map_;
+    ZoneMap<InstructionOperand, int, OperandAsKeyLess> map_;
   };
 
   Zone* zone() const { return zone_; }
   const RegisterConfiguration* config() { return config_; }
   const InstructionSequence* sequence() const { return sequence_; }
   Constraints* constraints() { return &constraints_; }
 
   static void VerifyInput(const OperandConstraint& constraint);
   static void VerifyTemp(const OperandConstraint& constraint);
   static void VerifyOutput(const OperandConstraint& constraint);
@@ skipping 23 matching lines @@
   ZoneMap<RpoNumber, DelayedAssessments*> outstanding_assessments_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorVerifier);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif