[turbofan] Fix register allocator verifier to allow 1-input phis.

src/compiler/register-allocator-verifier.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/instruction.h"
 #include "src/compiler/register-allocator-verifier.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 224 matching lines @@
                    LocationMap::allocator_type(zone)),
         predecessor_intersection_(LocationMap::key_compare(),
                                   LocationMap::allocator_type(zone)) {}
 
   LocationMap* locations() { return &locations_; }
 
   void RunPhis(const InstructionSequence* sequence,
                const InstructionBlock* block, size_t phi_index) {
     // This operation is only valid in edge split form.
     size_t predecessor_index = block->predecessors()[phi_index].ToSize();
-    CHECK(sequence->instruction_blocks()[predecessor_index]->SuccessorCount() ==
+    for (const auto* phi : block->phis()) {
+      CHECK(
+          sequence->instruction_blocks()[predecessor_index]->SuccessorCount() ==
           1);
-    for (const auto* phi : block->phis()) {
       auto input = phi->inputs()[phi_index];
       CHECK(locations()->find(input) != locations()->end());
       auto it = locations()->find(phi->output());
       CHECK(it != locations()->end());
       if (input->IsConstant()) {
         CHECK_EQ(it->second, input->index());
       } else {
         CHECK_EQ(it->second, phi->operands()[phi_index]);
       }
       it->second = phi->virtual_register();
@@ skipping 52 matching lines @@
     }
   }
 
   void InitializeFromFirstPredecessor(const InstructionSequence* sequence,
                                       const OutgoingMappings* outgoing_mappings,
                                       const InstructionBlock* block) {
     if (block->predecessors().empty()) return;
     size_t predecessor_index = block->predecessors()[0].ToSize();
     CHECK(predecessor_index < block->rpo_number().ToSize());
     auto* incoming = outgoing_mappings->at(predecessor_index);
-    if (block->PredecessorCount() > 1) {
+    if (block->PredecessorCount() >= 1) {
       // Update incoming map with phis. The remaining phis will be checked later
       // as their mappings are not guaranteed to exist yet.
       incoming->RunPhis(sequence, block, 0);
     }
     // Now initialize outgoing mapping for this block with incoming mapping.
     CHECK(locations_.empty());
     locations_ = incoming->locations_;
   }
 
   void InitializeFromIntersection() { locations_ = predecessor_intersection_; }
@@ skipping 120 matching lines @@
         const auto* gap = GapInstruction::cast(instr);
         current->RunGapInstruction(zone(), gap);
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8