[turbofan] Fixes to validator

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 44 matching lines @@
   AssessmentKind kind() const { return kind_; }
 
  protected:
   explicit Assessment(AssessmentKind kind) : kind_(kind) {}
   AssessmentKind kind_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Assessment);
 };
 
-// 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)
-      : Assessment(Final), virtual_register_(virtual_register) {}
-
-  int virtual_register() const { return virtual_register_; }
-  static const FinalAssessment* cast(const Assessment* assessment) {
-    CHECK(assessment->kind() == Final);
-    return static_cast<const FinalAssessment*>(assessment);
-  }
-
- private:
-  int virtual_register_;
-
-  DISALLOW_COPY_AND_ASSIGN(FinalAssessment);
-};
-
 // PendingAssessments are associated to operands coming from the multiple
 // predecessors of a block. We only record the operand and the block, and
 // will determine if the way the operand is defined (from the predecessors)
 // matches a particular use. This handles scenarios where multiple phis are
 // defined with identical operands, and the move optimizer moved down the moves
 // separating the 2 phis in the block defining them.
 class PendingAssessment final : public Assessment {
  public:
   explicit PendingAssessment(const InstructionBlock* origin,
                              InstructionOperand operand)
       : Assessment(Pending), origin_(origin), operand_(operand) {}
 
   static PendingAssessment* cast(Assessment* assessment) {
     CHECK(assessment->kind() == Pending);
     return static_cast<PendingAssessment*>(assessment);
   }
 
   const InstructionBlock* origin() const { return origin_; }
   InstructionOperand operand() const { return operand_; }
 
  private:
   const InstructionBlock* const origin_;
   InstructionOperand operand_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingAssessment);
 };
 
+// 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);
+  }
+
+  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:
@@ skipping 103 matching lines @@
   static void VerifyTemp(const OperandConstraint& constraint);
   static void VerifyOutput(const OperandConstraint& constraint);
 
   void BuildConstraint(const InstructionOperand* op,
                        OperandConstraint* constraint);
   void CheckConstraint(const InstructionOperand* op,
                        const OperandConstraint* constraint);
   BlockAssessments* CreateForBlock(const InstructionBlock* block);
 
   void ValidatePendingAssessment(RpoNumber block_id, InstructionOperand op,
-                                 PendingAssessment* assessment,
+                                 BlockAssessments* current_assessments,
+                                 const PendingAssessment* assessment,
                                  int virtual_register);
+  void ValidateFinalAssessment(RpoNumber block_id, InstructionOperand op,
+                               BlockAssessments* current_assessments,
+                               const FinalAssessment* assessment,
+                               int virtual_register);
   void ValidateUse(RpoNumber block_id, BlockAssessments* current_assessments,
                    InstructionOperand op, int virtual_register);
 
   Zone* const zone_;
   const RegisterConfiguration* config_;
   const InstructionSequence* const sequence_;
   Constraints constraints_;
   ZoneMap<RpoNumber, BlockAssessments*> assessments_;
   ZoneMap<RpoNumber, DelayedAssessments*> outstanding_assessments_;
 
-  // Cached structures, to avoid memory churn. Needed solely in
-  // ValidatePendingAssessment.
-  ZoneQueue<std::pair<PendingAssessment*, int>> worklist_;
-  ZoneSet<RpoNumber> seen_;
-
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorVerifier);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif