[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 {

[Mircea Trofin, 2016/06/18 00:39:32]

Can you move this line back to where it was, since it's not a change?

[bbudge, 2016/06/18 22:15:51]

I moved it so it would be near the other getter, and would match the ordering
for PendingAssessment, where the cast function precedes the getters. But if you
want it back the way it was, I'll undo it.

     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*, OperandAsKeyLess> OperandMap;
+  typedef ZoneMap<InstructionOperand, Assessment*, CompareOperandModuloType>
+      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 ZoneMap<InstructionOperand, int, OperandAsKeyLess>& map() const {
-      return map_;
-    }
+    const OperandMap& 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:
-    ZoneMap<InstructionOperand, int, OperandAsKeyLess> map_;
+    OperandMap 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