[Attributor] Introduce a helper function to deal with undef + none

[jdoerfert]

Summary

We often need to deal with the value lattice that contains none and
undef as special values. A simple helper makes this much nicer.

[jdoerfert]

ping

[kuter]

llvm/test/Transforms/Attributor/nocapture-2.ll

214

why is returned missing here ?

[jdoerfert]

llvm/test/Transforms/Attributor/nocapture-2.ll

214

Idk. I'll take a look.

[jdoerfert]

llvm/test/Transforms/Attributor/nocapture-2.ll

214

I'd suggest that we look into this after D103860 landed. A lot of the aareturnedvalue handling is going away with that one. The gist here is that we can now look through the casts in scc_A, scc_B, and scc_C and therefore follow the returned call through the argument. This confuses the "unique return" logic.

[kuter]

LGTM

llvm/include/llvm/Transforms/IPO/Attributor.h

 
 /// Abstract Attribute helper functions.
 namespace AA {
 /// Try to convert \p V to type \p Ty without introducing new instructions. If
 /// this is not possible return `nullptr`. Note: this function basically knows
 /// how to cast various constants.
 Value *getWithType(Value &V, Type &Ty);
 
+/// Return the combination of \p A and \p B such that the result is a possible
+/// value of both. \p B is potentially casted to match the type \p Ty or the
+/// type of \p A if \p Ty is null.
+///
+/// Examples:
+///        X + none  => X
+/// not_none + undef => not_none
+///          V1 + V2 => nullptr
+Optional<Value *>
+combineOptionalValuesInAAValueLatice(const Optional<Value *> &A,
+                                     const Optional<Value *> &B, Type *Ty);
 } // namespace AA
 
 /// The value passed to the line option that defines the maximal initialization
 /// chain length.
 extern unsigned MaxInitializationChainLength;
 
 ///{
 enum class ChangeStatus {

llvm/lib/Transforms/IPO/Attributor.cpp

if (auto *C = dyn_cast<Constant>(&V)) {
     if (C->getType()->isIntegerTy() && Ty.isIntegerTy())
       return ConstantExpr::getTrunc(C, &Ty, /* OnlyIfReduced */ true);
     if (C->getType()->isFloatingPointTy() && Ty.isFloatingPointTy())
       return ConstantExpr::getFPTrunc(C, &Ty, /* OnlyIfReduced */ true);
   }
   return nullptr;
 }
 
+Optional<Value *>
+AA::combineOptionalValuesInAAValueLatice(const Optional<Value *> &A,
+                                         const Optional<Value *> &B, Type *Ty) {
+  if (A == B)
+    return A;
+  if (!B.hasValue())
+    return A;
+  if (*B == nullptr)
+    return nullptr;
+  if (!A.hasValue())
+    return Ty ? getWithType(**B, *Ty) : nullptr;
+  if (*A == nullptr)
+    return nullptr;
+  if (!Ty)
+    Ty = (*A)->getType();
+  if (isa_and_nonnull<UndefValue>(*A))
+    return getWithType(**B, *Ty);
+  if (isa<UndefValue>(*B))
+    return A;
+  if (*A && *B && *A == getWithType(**B, *Ty))
+    return A;
+  return nullptr;
+}
+
 /// Return true if \p New is equal or worse than \p Old.
 static bool isEqualOrWorse(const Attribute &New, const Attribute &Old) {
   if (!Old.isIntAttribute())
     return true;
 
   return Old.getValueAsInt() >= New.getValueAsInt();
 }
 

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 Optional<Value *>
 AAReturnedValuesImpl::getAssumedUniqueReturnValue(Attributor &A) const {
   // If checkForAllReturnedValues provides a unique value, ignoring potential
   // undef values that can also be present, it is assumed to be the actual
   // return value and forwarded to the caller of this method. If there are
   // multiple, a nullptr is returned indicating there cannot be a unique
   // returned value.
   Optional<Value *> UniqueRV;
+  Type *Ty = getAssociatedFunction()->getReturnType();
 
   auto Pred = [&](Value &RV) -> bool {
-    // If we found a second returned value and neither the current nor the saved
-    // one is an undef, there is no unique returned value. Undefs are special
-    // since we can pretend they have any value.
-    if (UniqueRV.hasValue() && UniqueRV != &RV &&
-        !(isa<UndefValue>(RV) || isa<UndefValue>(UniqueRV.getValue()))) {
-      UniqueRV = nullptr;
-      return false;
-    }
-
-    // Do not overwrite a value with an undef.
-    if (!UniqueRV.hasValue() || !isa<UndefValue>(RV))
-      UniqueRV = &RV;
-
-    return true;
+    UniqueRV = AA::combineOptionalValuesInAAValueLatice(UniqueRV, &RV, Ty);
+    return UniqueRV != Optional<Value *>(nullptr);
   };
 
   if (!A.checkForAllReturnedValues(Pred, *this))
     UniqueRV = nullptr;
 
   return UniqueRV;
 }
 
static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                              Optional<Value *> &AccumulatedSimplifiedValue) {
     // FIXME: Add a typecast support.
 
     auto &ValueSimplifyAA = A.getAAFor<AAValueSimplify>(
         QueryingAA,
         IRPosition::value(QueryingValue, QueryingAA.getCallBaseContext()),
         DepClassTy::REQUIRED);
 
-    Optional<Value *> QueryingValueSimplified =
-        ValueSimplifyAA.getAssumedSimplifiedValue(A);
-
-    if (!QueryingValueSimplified.hasValue())
-      return true;
-
-    if (!QueryingValueSimplified.getValue())
+    AccumulatedSimplifiedValue = AA::combineOptionalValuesInAAValueLatice(
+        AccumulatedSimplifiedValue,
+        ValueSimplifyAA.getAssumedSimplifiedValue(A),
+        QueryingAA.getAssociatedType());
+    if (AccumulatedSimplifiedValue == Optional<Value *>(nullptr))
       return false;
 
-    Value &QueryingValueSimplifiedUnwrapped =
-        *QueryingValueSimplified.getValue();
-
-    if (AccumulatedSimplifiedValue.hasValue() &&
-        !isa<UndefValue>(AccumulatedSimplifiedValue.getValue()) &&
-        !isa<UndefValue>(QueryingValueSimplifiedUnwrapped))
-      return AccumulatedSimplifiedValue == QueryingValueSimplified;
-    if (AccumulatedSimplifiedValue.hasValue() &&
-        isa<UndefValue>(QueryingValueSimplifiedUnwrapped))
-      return true;
-
-    LLVM_DEBUG(dbgs() << "[ValueSimplify] " << QueryingValue
-                      << " is assumed to be "
-                      << QueryingValueSimplifiedUnwrapped << "\n");
-
-    AccumulatedSimplifiedValue = QueryingValueSimplified;
+    LLVM_DEBUG({
+      if (AccumulatedSimplifiedValue.hasValue())
+        dbgs() << "[ValueSimplify] " << QueryingValue << " is assumed to be "
+               << **AccumulatedSimplifiedValue << "\n";
+      else
+        dbgs() << "[ValueSimplify] " << QueryingValue
+               << " is assumed to be <none>\n";
+    });
     return true;
   }
 
   /// Returns a candidate is found or not
   template <typename AAType> bool askSimplifiedValueFor(Attributor &A) {
     if (!getAssociatedValue().getType()->isIntegerTy())
       return false;
 

llvm/test/Transforms/Attributor/nocapture-2.ll

 ; }
 ;
 ; void *scc_C(short *a) {
 ;   return scc_A((int*)(scc_A(a) ? scc_B((double*)a) : scc_C(a)));
 ; }
 define float* @scc_A(i32* dereferenceable_or_null(4) %a) {
 ; CHECK: Function Attrs: nofree nosync nounwind readnone
 ; CHECK-LABEL: define {{[^@]+}}@scc_A
-; CHECK-SAME: (i32* nofree readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-SAME: (i32* nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2:[0-9]+]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32* [[A]], null
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[A]] to i16*
 ; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP0]]) #[[ATTR2]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[CALL]] to double*
 ; CHECK-NEXT:    [[CALL1:%.*]] = call dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]]) #[[ATTR2]]
cond.end:                                         ; preds = %cond.false, %cond.true
   %cond = phi i32* [ %3, %cond.true ], [ %a, %cond.false ]
   %4 = bitcast i32* %cond to float*
   ret float* %4
 }
 
 define i64* @scc_B(double* dereferenceable_or_null(8) %a) {
 ; CHECK: Function Attrs: nofree nosync nounwind readnone
 ; CHECK-LABEL: define {{[^@]+}}@scc_B
-; CHECK-SAME: (double* nofree readnone returned dereferenceable_or_null(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (double* nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne double* [[A]], null
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast double* [[A]] to i32*
 ; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP0]]) #[[ATTR2]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float* [[CALL]] to double*
 ; CHECK-NEXT:    [[CALL1:%.*]] = call dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]]) #[[ATTR2]]
cond.end:                                         ; preds = %cond.false, %cond.true
   %cond = phi i8* [ %call2, %cond.true ], [ %3, %cond.false ]
   %4 = bitcast i8* %cond to i64*
   ret i64* %4
 }
 
 define i8* @scc_C(i16* dereferenceable_or_null(2) %a) {
 ; CHECK: Function Attrs: nofree nosync nounwind readnone
 ; CHECK-LABEL: define {{[^@]+}}@scc_C
-; CHECK-SAME: (i16* nofree readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2]] {
+; CHECK-SAME: (i16* nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i16* [[A]] to i32*
 ; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[BC]]) #[[ATTR2]]
 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast float* [[CALL]] to i8*
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i8* [[BC2]], null
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i16* [[A]] to double*

llvm/test/Transforms/Attributor/nonnull.ll

 }
 declare void @use_i8_ptr(i8* nofree nocapture readnone) nounwind
 declare void @use_i8_ptr_ret(i8* nofree nocapture readnone) nounwind willreturn
 
 define i8* @nonnull_function_ptr_1() {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@nonnull_function_ptr_1
 ; IS__TUNIT____-SAME: () #[[ATTR1]] {
-; IS__TUNIT____-NEXT:    [[BC:%.*]] = bitcast i8* ()* @nonnull_function_ptr_1 to i8*
-; IS__TUNIT____-NEXT:    ret i8* [[BC]]
+; IS__TUNIT____-NEXT:    ret i8* bitcast (i8* ()* @nonnull_function_ptr_1 to i8*)
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@nonnull_function_ptr_1
 ; IS__CGSCC____-SAME: () #[[ATTR1]] {
-; IS__CGSCC____-NEXT:    [[BC:%.*]] = bitcast i8* ()* @nonnull_function_ptr_1 to i8*
-; IS__CGSCC____-NEXT:    ret i8* [[BC]]
+; IS__CGSCC____-NEXT:    ret i8* bitcast (i8* ()* @nonnull_function_ptr_1 to i8*)
 ;
   %bc = bitcast i8*()* @nonnull_function_ptr_1 to i8*
   ret i8* %bc
 }
 
 declare i8* @function_decl()
 define i8* @nonnull_function_ptr_2() {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@nonnull_function_ptr_2
 ; IS__TUNIT____-SAME: () #[[ATTR1]] {
-; IS__TUNIT____-NEXT:    [[BC:%.*]] = bitcast i8* ()* @function_decl to i8*
-; IS__TUNIT____-NEXT:    ret i8* [[BC]]
+; IS__TUNIT____-NEXT:    ret i8* bitcast (i8* ()* @function_decl to i8*)
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@nonnull_function_ptr_2
 ; IS__CGSCC____-SAME: () #[[ATTR1]] {
-; IS__CGSCC____-NEXT:    [[BC:%.*]] = bitcast i8* ()* @function_decl to i8*
-; IS__CGSCC____-NEXT:    ret i8* [[BC]]
+; IS__CGSCC____-NEXT:    ret i8* bitcast (i8* ()* @function_decl to i8*)
 ;
   %bc = bitcast i8*()* @function_decl to i8*
   ret i8* %bc
 }
 
 ; FIXME: nonnull should not be propagated to the caller's p unless there is noundef
 define void @nonnull_caller(i8* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@nonnull_caller

llvm/test/Transforms/Attributor/returned.ll

 ;
 ; double* bitcast(int* b) {
 ;   return (double*)b;
 ; }
 ;
 define double* @bitcast(i32* %b) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bitcast
-; IS__TUNIT____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    ret double* [[BC0]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bitcast
-; IS__CGSCC____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    ret double* [[BC0]]
 ;
 entry:
   %bc0 = bitcast i32* %b to double*
   ret double* %bc0
 }
 
 
 ; TEST returned argument goes through select and phi interleaved with bitcasts
 ;
 ; double* bitcasts_select_and_phi(int* b) {
 ;   double* x = b;
 ;   if (b == 0)
 ;     x = b;
 ;   return b != 0 ? b : x;
 ; }
 ;
 define double* @bitcasts_select_and_phi(i32* %b) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bitcasts_select_and_phi
-; IS__TUNIT____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; IS__TUNIT____:       if.then:
 ; IS__TUNIT____-NEXT:    [[BC1:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    br label [[IF_END]]
 ; IS__TUNIT____:       if.end:
 ; IS__TUNIT____-NEXT:    [[PHI:%.*]] = phi double* [ [[BC1]], [[IF_THEN]] ], [ [[BC0]], [[ENTRY:%.*]] ]
 ; IS__TUNIT____-NEXT:    [[BC2:%.*]] = bitcast double* [[PHI]] to i8*
 ; IS__TUNIT____-NEXT:    [[BC3:%.*]] = bitcast i32* [[B]] to i8*
 ; IS__TUNIT____-NEXT:    [[CMP2:%.*]] = icmp ne double* [[BC0]], null
 ; IS__TUNIT____-NEXT:    [[SEL:%.*]] = select i1 [[CMP2]], i8* [[BC2]], i8* [[BC3]]
 ; IS__TUNIT____-NEXT:    [[BC4:%.*]] = bitcast i8* [[SEL]] to double*
 ; IS__TUNIT____-NEXT:    ret double* [[BC4]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bitcasts_select_and_phi
-; IS__CGSCC____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; IS__CGSCC____:       if.then:
 ; IS__CGSCC____-NEXT:    [[BC1:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    br label [[IF_END]]
 ; IS__CGSCC____:       if.end:

 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 define double* @ret_arg_arg_undef(i32* %b) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ret_arg_arg_undef
-; IS__TUNIT____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[IF_END:%.*]]
 ; IS__TUNIT____:       ret_arg0:
 ; IS__TUNIT____-NEXT:    [[BC1:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    ret double* [[BC1]]
 ; IS__TUNIT____:       if.end:
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_ARG1:%.*]], label [[RET_UNDEF:%.*]]
 ; IS__TUNIT____:       ret_arg1:
 ; IS__TUNIT____-NEXT:    ret double* [[BC0]]
 ; IS__TUNIT____:       ret_undef:
 ; IS__TUNIT____-NEXT:    ret double* undef
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ret_arg_arg_undef
-; IS__CGSCC____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[IF_END:%.*]]
 ; IS__CGSCC____:       ret_arg0:
 ; IS__CGSCC____-NEXT:    [[BC1:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    ret double* [[BC1]]
 ; IS__CGSCC____:       if.end:

 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 define double* @ret_undef_arg_arg(i32* %b) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ret_undef_arg_arg
-; IS__TUNIT____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_UNDEF:%.*]], label [[IF_END:%.*]]
 ; IS__TUNIT____:       ret_undef:
 ; IS__TUNIT____-NEXT:    ret double* undef
 ; IS__TUNIT____:       if.end:
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[RET_ARG1:%.*]]
 ; IS__TUNIT____:       ret_arg0:
 ; IS__TUNIT____-NEXT:    ret double* [[BC0]]
 ; IS__TUNIT____:       ret_arg1:
 ; IS__TUNIT____-NEXT:    [[BC1:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    ret double* [[BC1]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ret_undef_arg_arg
-; IS__CGSCC____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[RET_UNDEF:%.*]], label [[IF_END:%.*]]
 ; IS__CGSCC____:       ret_undef:
 ; IS__CGSCC____-NEXT:    ret double* undef
 ; IS__CGSCC____:       if.end:
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[RET_ARG1:%.*]]

 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 define double* @ret_undef_arg_undef(i32* %b) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ret_undef_arg_undef
-; IS__TUNIT____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__TUNIT____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_UNDEF0:%.*]], label [[IF_END:%.*]]
 ; IS__TUNIT____:       ret_undef0:
 ; IS__TUNIT____-NEXT:    ret double* undef
 ; IS__TUNIT____:       if.end:
 ; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNDEF1:%.*]]
 ; IS__TUNIT____:       ret_arg:
 ; IS__TUNIT____-NEXT:    ret double* [[BC0]]
 ; IS__TUNIT____:       ret_undef1:
 ; IS__TUNIT____-NEXT:    ret double* undef
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ret_undef_arg_undef
-; IS__CGSCC____-SAME: (i32* nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[BC0:%.*]] = bitcast i32* [[B]] to double*
 ; IS__CGSCC____-NEXT:    [[CMP:%.*]] = icmp eq double* [[BC0]], null
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[RET_UNDEF0:%.*]], label [[IF_END:%.*]]
 ; IS__CGSCC____:       ret_undef0:
 ; IS__CGSCC____-NEXT:    ret double* undef
 ; IS__CGSCC____:       if.end:
 ; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNDEF1:%.*]]
;
   ret i32 %add4
 }
 
 @G = external global i8
 define i32* @ret_const() #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ret_const
 ; IS__TUNIT____-SAME: () #[[ATTR0]] {
-; IS__TUNIT____-NEXT:    [[BC:%.*]] = bitcast i8* @G to i32*
-; IS__TUNIT____-NEXT:    ret i32* [[BC]]
+; IS__TUNIT____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ret_const
 ; IS__CGSCC____-SAME: () #[[ATTR0]] {
-; IS__CGSCC____-NEXT:    [[BC:%.*]] = bitcast i8* @G to i32*
-; IS__CGSCC____-NEXT:    ret i32* [[BC]]
+; IS__CGSCC____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
   %bc = bitcast i8* @G to i32*
   ret i32* %bc
 }
 define i32* @use_const() #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@use_const
 ; IS__TUNIT____-SAME: () #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@use_const
 ; IS__CGSCC____-SAME: () #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
   %c = call i32* @ret_const()
   ret i32* %c
 }
 define i32* @dont_use_const() #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@dont_use_const
 ; IS__TUNIT____-SAME: () #[[ATTR0]] {
-; IS__TUNIT____-NEXT:    [[C:%.*]] = musttail call i32* @ret_const() #[[ATTR5]]
-; IS__TUNIT____-NEXT:    ret i32* [[C]]
+; IS__TUNIT____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@dont_use_const
 ; IS__CGSCC____-SAME: () #[[ATTR0]] {
-; IS__CGSCC____-NEXT:    [[C:%.*]] = musttail call i32* @ret_const() #[[ATTR6]]
-; IS__CGSCC____-NEXT:    ret i32* [[C]]
+; IS__CGSCC____-NEXT:    ret i32* bitcast (i8* @G to i32*)
 ;
   %c = musttail call i32* @ret_const()
   ret i32* %c
 }
 
 ; UTC_ARGS: --disable
 ;
 ; Verify we do not derive constraints for @_Z3fooP1X as if it was returning `null`.

llvm/test/Transforms/Attributor/value-simplify.ll

 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@icmp
 ; IS__CGSCC____-SAME: () #[[ATTR1]] {
 ; IS__CGSCC____-NEXT:    ret i1 true
 ;
   %c = icmp eq i8* null, null
   ret i1 %c
 }
+
+define i1 @test_cmp_null_after_cast() {
+; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test_cmp_null_after_cast
+; IS__TUNIT____-SAME: () #[[ATTR1]] {
+; IS__TUNIT____-NEXT:    ret i1 true
+;
+; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test_cmp_null_after_cast
+; IS__CGSCC____-SAME: () #[[ATTR1]] {
+; IS__CGSCC____-NEXT:    ret i1 true
+;
+  %c = call i1 @cmp_null_after_cast(i32 0, i8 0)
+  ret i1 %c
+}
+define internal i1 @cmp_null_after_cast(i32 %a, i8 %b) {
+; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC____-LABEL: define {{[^@]+}}@cmp_null_after_cast
+; IS__CGSCC____-SAME: () #[[ATTR1]] {
+; IS__CGSCC____-NEXT:    ret i1 undef
+;
+  %t = trunc i32 %a to i8
+  %c = icmp eq i8 %t, %b
+  ret i1 %c
+}
+
 ;.
 ; IS__TUNIT_OPM: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR1]] = { nofree nosync nounwind readnone willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR2]] = { nofree nosync nounwind readnone }
 ; IS__TUNIT_OPM: attributes #[[ATTR3]] = { argmemonly nofree nosync nounwind willreturn writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR4]] = { nofree nosync nounwind readonly willreturn }
 ; IS__TUNIT_OPM: attributes #[[ATTR5]] = { argmemonly nofree nosync nounwind writeonly }
 ; IS__TUNIT_OPM: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn writeonly }