wip

Author: nikic

llvm/lib/Analysis/ValueTracking.cpp

@@ -457,7 +457,7 @@ static bool isEphemeralValueOf(const Instruction *I, const Value *E) {
       continue;
 
     // If all uses of this value are ephemeral, then so is this value.
-    if (llvm::all_of(V->users(), [&](const User *U) {
+    if (V == I || llvm::any_of(V->users(), [&](const User *U) {
                                    return EphValues.count(U);
                                  })) {
       if (V == E)

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

@@ -3217,7 +3217,7 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
                                         m_Zero())) &&
         LHS->getOpcode() == Instruction::Load &&
         LHS->getType()->isPointerTy() &&
-        isValidAssumeForContext(II, LHS, &DT)) {
+        isValidAssumeForContext(II, LHS, &DT, /*AllowEphemeral=*/true)) {
       MDNode *MD = MDNode::get(II->getContext(), {});
       LHS->setMetadata(LLVMContext::MD_nonnull, MD);
       LHS->setMetadata(LLVMContext::MD_noundef, MD);

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

@@ -432,7 +432,8 @@ struct AssumeSimplify {
                 continue;
               }
             if (isValidAssumeForContext(
-                    Assume, &*F.getEntryBlock().getFirstInsertionPt()) ||
+                    Assume, &*F.getEntryBlock().getFirstInsertionPt(),
+                    /*DT=*/nullptr, /*AllowEphemeral=*/true) ||
                 Assume == &*F.getEntryBlock().getFirstInsertionPt()) {
               if (HasSameKindAttr)
                 Arg->removeAttr(RK.AttrKind);

llvm/test/Analysis/ScalarEvolution/trunc-simplify.ll

@@ -41,15 +41,15 @@ define i8 @trunc_to_assumed_zeros(ptr %p) {
 ; CHECK-LABEL: 'trunc_to_assumed_zeros'
 ; CHECK-NEXT:  Classifying expressions for: @trunc_to_assumed_zeros
 ; CHECK-NEXT:    %a = load i32, ptr %p, align 4
-; CHECK-NEXT:    --> %a U: [0,-255) S: [-2147483648,2147483393)
+; CHECK-NEXT:    --> %a U: full-set S: full-set
 ; CHECK-NEXT:    %and = and i32 %a, 255
-; CHECK-NEXT:    --> 0 U: [0,1) S: [0,1)
+; CHECK-NEXT:    --> (zext i8 (trunc i32 %a to i8) to i32) U: [0,256) S: [0,256)
 ; CHECK-NEXT:    %c = trunc i32 %a to i8
-; CHECK-NEXT:    --> 0 U: [0,1) S: [0,1)
+; CHECK-NEXT:    --> (trunc i32 %a to i8) U: full-set S: full-set
 ; CHECK-NEXT:    %d = trunc i32 %a to i1
-; CHECK-NEXT:    --> false U: [0,-1) S: [0,-1)
+; CHECK-NEXT:    --> (trunc i32 %a to i1) U: full-set S: full-set
 ; CHECK-NEXT:    %e = trunc i32 %a to i16
-; CHECK-NEXT:    --> (trunc i32 %a to i16) U: [0,-255) S: [-32768,32513)
+; CHECK-NEXT:    --> (trunc i32 %a to i16) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @trunc_to_assumed_zeros
 ;
   %a = load i32, ptr %p

llvm/test/Analysis/ValueTracking/numsignbits-from-assume.ll

@@ -48,7 +48,7 @@ define i32 @computeNumSignBits_sub1(i32 %in) {
 
 define i32 @computeNumSignBits_sub2(i32 %in) {
 ; CHECK-LABEL: @computeNumSignBits_sub2(
-; CHECK-NEXT:    [[SUB:%.*]] = add nsw i32 [[IN:%.*]], -1
+; CHECK-NEXT:    [[SUB:%.*]] = add i32 [[IN:%.*]], -1
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[SUB]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[SUB]], 3

llvm/test/Transforms/InstCombine/assume.ll

@@ -502,10 +502,9 @@ define i1 @nonnull3B(ptr %a, i1 %control) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 ; CHECK:       taken:
-; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
-; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]]) [ "nonnull"(ptr [[LOAD]]) ]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8, !nonnull [[META6]], !noundef [[META6]]
+; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-NEXT:    ret i1 true
 ; CHECK:       not_taken:
 ; CHECK-NEXT:    ret i1 false
 ;

llvm/test/Transforms/InstCombine/zext-or-icmp.ll

@@ -180,11 +180,11 @@ define i8 @PR49475_infloop(i32 %t0, i16 %insert, i64 %e, i8 %i162) "instcombine-
 ; CHECK-NEXT:    [[SEXT:%.*]] = shl i64 [[SUB17]], 32
 ; CHECK-NEXT:    [[CONV18:%.*]] = ashr exact i64 [[SEXT]], 32
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i64 [[XOR]], [[CONV18]]
-; CHECK-NEXT:    [[TRUNC44:%.*]] = zext i1 [[CMP]] to i8
-; CHECK-NEXT:    [[INC:%.*]] = add i8 [[I162]], [[TRUNC44]]
-; CHECK-NEXT:    [[TOBOOL23_NOT:%.*]] = xor i1 [[CMP]], true
+; CHECK-NEXT:    [[CONV19:%.*]] = zext i1 [[CMP]] to i16
+; CHECK-NEXT:    [[OR21:%.*]] = or i16 [[INSERT]], [[CONV19]]
+; CHECK-NEXT:    [[TOBOOL23_NOT:%.*]] = icmp eq i16 [[OR21]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TOBOOL23_NOT]])
-; CHECK-NEXT:    ret i8 [[INC]]
+; CHECK-NEXT:    ret i8 [[I162]]
 ;
   %b = icmp eq i32 %t0, 0
   %b2 = icmp eq i16 %insert, 0