[SimplifyCFG] Select the first instruction that we can handle in passingValueIsAlwaysUndefined

Author: dianqk

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

@@ -7573,13 +7573,25 @@ static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I, bool PtrValu
     return false;
 
   if (C->isNullValue() || isa<UndefValue>(C)) {
-    // Only look at the first use, avoid hurting compile time with long uselists
-    auto *Use = cast<Instruction>(*I->user_begin());
-    // Bail out if Use is not in the same BB as I or Use == I or Use comes
-    // before I in the block. The latter two can be the case if Use is a PHI
-    // node.
-    if (Use->getParent() != I->getParent() || Use == I || Use->comesBefore(I))
+    // Only look at the first use we can hanle, avoid hurting compile time with
+    // long uselists
+    auto FindUse = llvm::find_if(I->users(), [&I](auto *U) {
+      auto *Use = cast<Instruction>(U);
+      // Bail out if Use is not in the same BB as I or Use == I or Use comes
+      // before I in the block. The latter two can be the case if Use is a
+      // PHI node.
+      if (Use->getParent() != I->getParent() || Use == I || Use->comesBefore(I))
+        return false;
+      // Change this list when we want to add new instructions.
+      if (!isa<GetElementPtrInst>(Use) && !isa<ReturnInst>(Use) &&
+          !isa<BitCastInst>(Use) && !isa<LoadInst>(Use) &&
+          !isa<StoreInst>(Use) && !isa<AssumeInst>(Use) && !isa<CallBase>(Use))
+        return false;
+      return true;
+    });
+    if (FindUse == I->user_end())
       return false;
+    auto *Use = cast<Instruction>(*FindUse);
 
     // Now make sure that there are no instructions in between that can alter
     // control flow (eg. calls)

llvm/test/Transforms/PhaseOrdering/pr98799-inline-simplifycfg-ub.ll

@@ -20,34 +20,26 @@ bb4:
 define i32 @foo(ptr %arg, i1 %arg1) {
 ; CUSTOM-LABEL: define i32 @foo(
 ; CUSTOM-SAME: ptr [[ARG:%.*]], i1 [[ARG1:%.*]]) {
-; CUSTOM-NEXT:  [[BB:.*]]:
-; CUSTOM-NEXT:    br i1 [[ARG1]], label %[[BAR_EXIT:.*]], label %[[BB2_I:.*]]
-; CUSTOM:       [[BB2_I]]:
+; CUSTOM-NEXT:  [[BB:.*:]]
+; CUSTOM-NEXT:    [[TMP0:%.*]] = xor i1 [[ARG1]], true
+; CUSTOM-NEXT:    call void @llvm.assume(i1 [[TMP0]])
 ; CUSTOM-NEXT:    [[I_I:%.*]] = load ptr, ptr [[ARG]], align 8
 ; CUSTOM-NEXT:    [[I3_I:%.*]] = getelementptr inbounds i8, ptr [[I_I]], i64 1
 ; CUSTOM-NEXT:    store ptr [[I3_I]], ptr [[ARG]], align 8
-; CUSTOM-NEXT:    br label %[[BAR_EXIT]]
-; CUSTOM:       [[BAR_EXIT]]:
-; CUSTOM-NEXT:    [[I5_I:%.*]] = phi ptr [ [[I_I]], %[[BB2_I]] ], [ null, %[[BB]] ]
-; CUSTOM-NEXT:    [[I2:%.*]] = icmp ne ptr [[I5_I]], null
+; CUSTOM-NEXT:    [[I2:%.*]] = icmp ne ptr [[I_I]], null
 ; CUSTOM-NEXT:    call void @llvm.assume(i1 [[I2]])
-; CUSTOM-NEXT:    [[I3:%.*]] = load i32, ptr [[I5_I]], align 4
+; CUSTOM-NEXT:    [[I3:%.*]] = load i32, ptr [[I_I]], align 4
 ; CUSTOM-NEXT:    ret i32 [[I3]]
 ;
 ; O2-LABEL: define i32 @foo(
 ; O2-SAME: ptr nocapture [[ARG:%.*]], i1 [[ARG1:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] {
-; O2-NEXT:  [[BB:.*]]:
-; O2-NEXT:    br i1 [[ARG1]], label %[[BAR_EXIT:.*]], label %[[BB2_I:.*]]
-; O2:       [[BB2_I]]:
-; O2-NEXT:    [[I_I:%.*]] = load ptr, ptr [[ARG]], align 8
+; O2-NEXT:  [[BB:.*:]]
+; O2-NEXT:    [[TMP0:%.*]] = xor i1 [[ARG1]], true
+; O2-NEXT:    tail call void @llvm.assume(i1 [[TMP0]])
+; O2-NEXT:    [[I_I:%.*]] = load ptr, ptr [[ARG]], align 8, !nonnull [[META0:![0-9]+]], !noundef [[META0]]
 ; O2-NEXT:    [[I3_I:%.*]] = getelementptr inbounds i8, ptr [[I_I]], i64 1
 ; O2-NEXT:    store ptr [[I3_I]], ptr [[ARG]], align 8
-; O2-NEXT:    br label %[[BAR_EXIT]]
-; O2:       [[BAR_EXIT]]:
-; O2-NEXT:    [[I5_I:%.*]] = phi ptr [ [[I_I]], %[[BB2_I]] ], [ null, %[[BB]] ]
-; O2-NEXT:    [[I2:%.*]] = icmp ne ptr [[I5_I]], null
-; O2-NEXT:    tail call void @llvm.assume(i1 [[I2]])
-; O2-NEXT:    [[I3:%.*]] = load i32, ptr [[I5_I]], align 4
+; O2-NEXT:    [[I3:%.*]] = load i32, ptr [[I_I]], align 4
 ; O2-NEXT:    ret i32 [[I3]]
 ;
 bb:
@@ -59,3 +51,6 @@ bb:
 }
 
 declare void @llvm.assume(i1)
+;.
+; O2: [[META0]] = !{}
+;.

llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll

@@ -857,20 +857,17 @@ exit:
   ret i32 %res
 }
 
-; FIXME: From bb to bb5 is UB.
+; From bb to bb5 is UB.
 define i32 @test9_null_user_order_1(ptr %arg, i1 %arg1, ptr %arg2) {
 ; CHECK-LABEL: @test9_null_user_order_1(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    br i1 [[ARG1:%.*]], label [[BB5:%.*]], label [[BB3:%.*]]
-; CHECK:       bb3:
+; CHECK-NEXT:    [[TMP0:%.*]] = xor i1 [[ARG1:%.*]], true
+; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP0]])
 ; CHECK-NEXT:    [[I:%.*]] = load ptr, ptr [[ARG:%.*]], align 8
 ; CHECK-NEXT:    [[I4:%.*]] = getelementptr inbounds i8, ptr [[I]], i64 1
 ; CHECK-NEXT:    store ptr [[I4]], ptr [[ARG]], align 8
-; CHECK-NEXT:    br label [[BB5]]
-; CHECK:       bb5:
-; CHECK-NEXT:    [[I6:%.*]] = phi ptr [ [[I]], [[BB3]] ], [ null, [[BB:%.*]] ]
-; CHECK-NEXT:    [[I7:%.*]] = load i32, ptr [[I6]], align 4
-; CHECK-NEXT:    [[I8:%.*]] = icmp ne ptr [[I6]], [[ARG2:%.*]]
+; CHECK-NEXT:    [[I7:%.*]] = load i32, ptr [[I]], align 4
+; CHECK-NEXT:    [[I8:%.*]] = icmp ne ptr [[I]], [[ARG2:%.*]]
 ; CHECK-NEXT:    call void @fn_ptr_arg(i1 [[I8]])
 ; CHECK-NEXT:    ret i32 [[I7]]
 ;