[SimpleLoopUnswitch] Add freeze if branch execs for partial unswitching.

[fhahn]

Summary

We cannot skip the freezing the condition if the unswitched branch
executes, if the condition is a chain of ANDs/ORs. For example, if if we
have an AND %c1, %c2 with %c1 == undef and %c2 == 0, there would be no
branch on undef in the original code, but a branch on undef if we
unswitch %c1.

[nikic]

LGTM

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

assert(UnswitchedSuccBBs.size() == 1 &&
            "Only one possible unswitched block for a branch!");
     BasicBlock *ClonedPH = ClonedPHs.begin()->second;
     // When doing a partial unswitch, we have to do a bit more work to build up
     // the branch in the split block.
     if (PartiallyInvariant)
       buildPartialInvariantUnswitchConditionalBranch(
           *SplitBB, Invariants, Direction, *ClonedPH, *LoopPH, L, MSSAU);
     else {
-      buildPartialUnswitchConditionalBranch(*SplitBB, Invariants, Direction,
-                                            *ClonedPH, *LoopPH, InsertFreeze,
-                                            BI, &AC, DT);
+      buildPartialUnswitchConditionalBranch(
+          *SplitBB, Invariants, Direction, *ClonedPH, *LoopPH,
+          FreezeLoopUnswitchCond, BI, &AC, DT);
     }
     DTUpdates.push_back({DominatorTree::Insert, SplitBB, ClonedPH});
 
     if (MSSAU) {
       DT.applyUpdates(DTUpdates);
       DTUpdates.clear();
 
       // Perform MSSA cloning updates.

llvm/test/Transforms/SimpleLoopUnswitch/nontrivial-unswitch.ll

 }
 
 ; Non-trivial partial loop unswitching of an invariant input to an 'or'.
 define i32 @test25(i1* %ptr, i1 %cond) {
 ; CHECK-LABEL: @test25(
 entry:
   br label %loop_begin
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 %cond, label %entry.split.us, label %entry.split
+; CHECK-NEXT:    [[FROZEN:%.+]] = freeze i1 %cond
+; CHECK-NEXT:    br i1 [[FROZEN]], label %entry.split.us, label %entry.split
 
 loop_begin:
   %v1 = load i1, i1* %ptr
   %cond_or = or i1 %v1, %cond
   br i1 %cond_or, label %loop_a, label %loop_b
 
 loop_a:
   call i32 @a()

 
 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `and`
 ; chain.
 define i32 @test26(i1* %ptr1, i1* %ptr2, i1* %ptr3, i1 %cond1, i1 %cond2, i1 %cond3) {
 ; CHECK-LABEL: @test26(
 entry:
   br label %loop_begin
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %[[INV_AND:.*]] = and i1 %cond3, %cond1
+; CHECK-NEXT:    [[C3_FR:%.+]] = freeze i1 %cond3
+; CHECK-NEXT:    [[C1_FR:%.+]] = freeze i1 %cond1
+; CHECK-NEXT:    %[[INV_AND:.*]] = and i1 [[C3_FR]], [[C1_FR]]
 ; CHECK-NEXT:    br i1 %[[INV_AND]], label %entry.split, label %entry.split.us
 
 loop_begin:
   %v1 = load i1, i1* %ptr1
   %v2 = load i1, i1* %ptr2
   %cond_and1 = and i1 %v1, %cond1
   %cond_or1 = or i1 %v2, %cond2
   %cond_and2 = and i1 %cond_and1, %cond_or1

 
 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `or`
 ; chain. Basically an inverted version of corresponding `and` test (test26).
 define i32 @test27(i1* %ptr1, i1* %ptr2, i1* %ptr3, i1 %cond1, i1 %cond2, i1 %cond3) {
 ; CHECK-LABEL: @test27(
 entry:
   br label %loop_begin
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %[[INV_OR:.*]] = or i1 %cond3, %cond1
+; CHECK-NEXT:    [[C3_FR:%.+]] = freeze i1 %cond3
+; CHECK-NEXT:    [[C1_FR:%.+]] = freeze i1 %cond1
+; CHECK-NEXT:    %[[INV_OR:.*]] = or i1 [[C3_FR]], [[C1_FR]]
 ; CHECK-NEXT:    br i1 %[[INV_OR]], label %entry.split.us, label %entry.split
 
 loop_begin:
   %v1 = load i1, i1* %ptr1
   %v2 = load i1, i1* %ptr2
   %cond_or1 = or i1 %v1, %cond1
   %cond_and1 = and i1 %v2, %cond2
   %cond_or2 = or i1 %cond_or1, %cond_and1

 
 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `and`
 ; chain (select version).
 define i32 @test32(i1* %ptr1, i1* %ptr2, i1* %ptr3, i1 %cond1, i1 %cond2) {
 ; CHECK-LABEL: @test32(
 entry:
   br label %loop_begin
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %[[INV_AND:.*]] = and i1 %cond2, %cond1
+; CHECK-NEXT:    [[C2_FR:%.+]] = freeze i1 %cond2
+; CHECK-NEXT:    [[C1_FR:%.+]] = freeze i1 %cond1
+; CHECK-NEXT:    %[[INV_AND:.*]] = and i1 [[C2_FR]], [[C1_FR]]
 ; CHECK-NEXT:    br i1 %[[INV_AND]], label %entry.split, label %entry.split.us
 
 loop_begin:
   %v1 = load i1, i1* %ptr1
   %v2 = load i1, i1* %ptr2
   %cond_and1 = select i1 %v1, i1 %cond1, i1 false
   %cond_and2 = select i1 %cond_and1, i1 %cond2, i1 false
   br i1 %cond_and2, label %loop_a, label %loop_b

 
 ; Non-trivial partial loop unswitching of multiple invariant inputs to an `or`
 ; chain (select version).
 define i32 @test33(i1* %ptr1, i1* %ptr2, i1* %ptr3, i1 %cond1, i1 %cond2) {
 ; CHECK-LABEL: @test33(
 entry:
   br label %loop_begin
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %[[INV_OR:.*]] = or i1 %cond2, %cond1
+; CHECK-NEXT:    [[C2_FR:%.+]] = freeze i1 %cond2
+; CHECK-NEXT:    [[C1_FR:%.+]] = freeze i1 %cond1
+; CHECK-NEXT:    %[[INV_OR:.*]] = or i1 [[C2_FR]], [[C1_FR]]
 ; CHECK-NEXT:    br i1 %[[INV_OR]], label %entry.split.us, label %entry.split
 
 loop_begin:
   %v1 = load i1, i1* %ptr1
   %v2 = load i1, i1* %ptr2
   %cond_and1 = select i1 %v1, i1 true, i1 %cond1
   %cond_and2 = select i1 %cond_and1, i1 true, i1 %cond2
   br i1 %cond_and2, label %loop_b, label %loop_a