[SLP] Ignore unreachable blocks

[hvdijk]

Summary

As the existing test unreachable.ll shows, we should be doing more
work to avoid entering unreachable blocks: we should not stop
vectorization just because a PHI incoming value from an unreachable
block cannot be vectorized. We know that particular value will never
be used so we can just replace it with poison.

[ABataev]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

2833–2834

Better to do something like this:

if (!DT->isReachableFromEntry(PH->getIncomingBlock(I))) {
  ValueList Operands(VL.size(), PoisonValue::get(PH->getType()));
  TE->setOperand(I, Operands);
  OperandsVec.push_back(Operands);
  continue;
}

and remove the change in BoUpSLP::vectorizeTree

[hvdijk]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

2833–2834

Good idea, re-ran tests with exactly what you put here, that works.

[ABataev]

LG

[hvdijk]

Thanks. Accidentally pushed without updating the commit message, linking and closing manually.

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

case Instruction::PHI: {
 
       TreeEntry *TE =
           newTreeEntry(VL, Bundle, S, UserTreeIdx, ReuseShuffleIndicies);
       LLVM_DEBUG(dbgs() << "SLP: added a vector of PHINodes.\n");
 
       // Keeps the reordered operands to avoid code duplication.
       SmallVector<ValueList, 2> OperandsVec;
       for (unsigned I = 0, E = PH->getNumIncomingValues(); I < E; ++I) {
+        if (!DT->isReachableFromEntry(PH->getIncomingBlock(I))) {
+          ValueList Operands(VL.size(), PoisonValue::get(PH->getType()));
+          TE->setOperand(I, Operands);
+          OperandsVec.push_back(Operands);
+          continue;
+        }
         ValueList Operands;
         // Prepare the operand vector.
         for (Value *V : VL)
           Operands.push_back(cast<PHINode>(V)->getIncomingValueForBlock(
               PH->getIncomingBlock(I)));
         TE->setOperand(I, Operands);
         OperandsVec.push_back(Operands);
       }

llvm/test/Transforms/SLPVectorizer/X86/unreachable.ll

 ; CHECK-NEXT:    [[T6:%.*]] = load i32, i32* [[T5]], align 4
 ; CHECK-NEXT:    [[BAD:%.*]] = fadd float [[BAD]], 0.000000e+00
 ; CHECK-NEXT:    [[T7:%.*]] = getelementptr inbounds i32, i32* [[X]], i64 6
 ; CHECK-NEXT:    [[T8:%.*]] = load i32, i32* [[T7]], align 4
 ; CHECK-NEXT:    [[T9:%.*]] = getelementptr inbounds i32, i32* [[X]], i64 7
 ; CHECK-NEXT:    [[T10:%.*]] = load i32, i32* [[T9]], align 4
 ; CHECK-NEXT:    br label [[BB2]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[T1_0:%.*]] = phi i32 [ [[T4]], [[BB1:%.*]] ], [ 2, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    [[T2_0:%.*]] = phi i32 [ [[T6]], [[BB1]] ], [ 2, [[ENTRY]] ]
-; CHECK-NEXT:    [[T3_0:%.*]] = phi i32 [ [[T8]], [[BB1]] ], [ 2, [[ENTRY]] ]
-; CHECK-NEXT:    [[T4_0:%.*]] = phi i32 [ [[T10]], [[BB1]] ], [ 2, [[ENTRY]] ]
-; CHECK-NEXT:    store i32 [[T1_0]], i32* [[X]], align 4
+; CHECK-NEXT:    [[TMP0:%.*]] = phi <4 x i32> [ poison, [[BB1:%.*]] ], [ <i32 2, i32 2, i32 2, i32 2>, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    [[T12:%.*]] = getelementptr inbounds i32, i32* [[X]], i64 1
-; CHECK-NEXT:    store i32 [[T2_0]], i32* [[T12]], align 4
 ; CHECK-NEXT:    [[T13:%.*]] = getelementptr inbounds i32, i32* [[X]], i64 2
-; CHECK-NEXT:    store i32 [[T3_0]], i32* [[T13]], align 4
 ; CHECK-NEXT:    [[T14:%.*]] = getelementptr inbounds i32, i32* [[X]], i64 3
-; CHECK-NEXT:    store i32 [[T4_0]], i32* [[T14]], align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[X]] to <4 x i32>*
+; CHECK-NEXT:    store <4 x i32> [[TMP0]], <4 x i32>* [[TMP1]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %bb2
 
 bb1:                                    ; an unreachable block
   %t3 = getelementptr inbounds i32, i32* %x, i64 4
   %t4 = load i32, i32* %t3, align 4