[SimplifyCFG] Switch to use paramHasNonNullAttr

Author: dtcxzyw

llvm/include/llvm/IR/InstrTypes.h

@@ -1823,7 +1823,11 @@ class CallBase : public Instruction {
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
   uint64_t getParamDereferenceableBytes(unsigned i) const {
-    return Attrs.getParamDereferenceableBytes(i);
+    uint64_t Bytes = Attrs.getParamDereferenceableBytes(i);
+    if (const Function *F = getCalledFunction())
+      Bytes =
+          std::max(Bytes, F->getAttributes().getParamDereferenceableBytes(i));
+    return Bytes;
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a call
@@ -1841,7 +1845,11 @@ class CallBase : public Instruction {
   /// Extract the number of dereferenceable_or_null bytes for a
   /// parameter (0=unknown).
   uint64_t getParamDereferenceableOrNullBytes(unsigned i) const {
-    return Attrs.getParamDereferenceableOrNullBytes(i);
+    uint64_t Bytes = Attrs.getParamDereferenceableOrNullBytes(i);
+    if (const Function *F = getCalledFunction())
+      Bytes = std::max(
+          Bytes, F->getAttributes().getParamDereferenceableOrNullBytes(i));
+    return Bytes;
   }
 
   /// Extract a test mask for disallowed floating-point value classes for the

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

@@ -8276,15 +8276,17 @@ static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I, bool PtrValu
         return true;
 
       if (C->isNullValue()) {
-        for (const llvm::Use &Arg : CB->args())
-          if (Arg == I) {
-            unsigned ArgIdx = CB->getArgOperandNo(&Arg);
-            if (CB->isPassingUndefUB(ArgIdx) &&
-                CB->paramHasAttr(ArgIdx, Attribute::NonNull)) {
-              // Passing null to a nonnnull+noundef argument is undefined.
-              return !PtrValueMayBeModified;
+        if (C->getType()->isPointerTy()) {
+          for (const llvm::Use &Arg : CB->args())
+            if (Arg == I) {
+              unsigned ArgIdx = CB->getArgOperandNo(&Arg);
+              if (CB->paramHasNonNullAttr(ArgIdx,
+                                          /*AllowUndefOrPoison=*/false)) {
+                // Passing null to a nonnnull+noundef argument is undefined.
+                return !PtrValueMayBeModified;
+              }
             }
-          }
+        }
       } else if (isa<UndefValue>(C)) {
         // Passing undef to a noundef argument is undefined.
         for (const llvm::Use &Arg : CB->args())

llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll

@@ -238,7 +238,7 @@ else:
 }
 
 declare ptr @fn_nonnull_noundef_arg(ptr nonnull noundef %p)
-declare ptr @fn_nonnull_deref_arg(ptr nonnull dereferenceable(4) %p)
+declare ptr @fn_deref_arg(ptr dereferenceable(4) %p)
 declare ptr @fn_nonnull_deref_or_null_arg(ptr nonnull dereferenceable_or_null(4) %p)
 declare ptr @fn_nonnull_arg(ptr nonnull %p)
 declare ptr @fn_noundef_arg(ptr noundef %p)
@@ -271,7 +271,7 @@ define void @test9_deref(i1 %X, ptr %Y) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = xor i1 [[X:%.*]], true
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP0]])
-; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @fn_nonnull_deref_arg(ptr [[Y:%.*]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @fn_deref_arg(ptr [[Y:%.*]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
@@ -282,17 +282,16 @@ if:
 
 else:
   %phi = phi ptr [ %Y, %entry ], [ null, %if ]
-  call ptr @fn_nonnull_deref_arg(ptr %phi)
+  call ptr @fn_deref_arg(ptr %phi)
   ret void
 }
 
 ; Optimizing this code should produce assume.
 define void @test9_deref_or_null(i1 %X, ptr %Y) {
 ; CHECK-LABEL: @test9_deref_or_null(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = xor i1 [[X:%.*]], true
-; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP0]])
-; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @fn_nonnull_deref_or_null_arg(ptr [[Y:%.*]])
+; CHECK-NEXT:    [[Y:%.*]] = select i1 [[X:%.*]], ptr null, ptr [[Y1:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @fn_nonnull_deref_or_null_arg(ptr [[Y]])
 ; CHECK-NEXT:    ret void
 ;
 entry: