!fixup undo nonnull assumption, clarify docs

Author: fhahn

clang/docs/LanguageExtensions.rst

@@ -2869,7 +2869,7 @@ Query for this feature with ``__has_builtin(__builtin_assume_separate_storage)``
 ``__builtin_assume_dereferenceable``
 -------------------------------------
 
-``__builtin_assume_derefernceable`` is used to provide the optimizer with the
+``__builtin_assume_dereferenceable`` is used to provide the optimizer with the
 knowledge that the pointer argument P is dereferenceable up to the specified
 number of bytes.
 
@@ -2884,20 +2884,26 @@ number of bytes.
 .. code-block:: c++
 
   int foo(int *x, int y) {
-      __builtin_assume_dereferenceable(x, 4);
+      __builtin_assume_dereferenceable(x, sizeof(int));
       int z = 0;
       if (y == 1) {
-        // The optimizer may execute the load of x unconditionally.
+        // The optimizer may execute the load of x unconditionally due to
+        // __builtin_assume_dereferenceable guaranteeing sizeof(int) bytes can
+        // be loaded speculatively without trapping.
         z = *x;
-        }
+      }
       return z;
   }
 
 **Description**:
 
 The arguments to this function provide a start pointer ``P`` and a size ``S``.
-``P`` must be non-null and ``S`` at least 1. The optimizer may assume that
-``S`` bytes are dereferenceable starting at ``P``.
+``S`` must be at least 1 and a constant. The optimizer may assume that ``S``
+bytes are dereferenceable starting at ``P``. Note that this does not necessarily
+imply that ``P`` is non-null as ``nullptr`` can be dereferenced in some cases.
+The assumption also does not imply that ``P`` is not dereferenceable past ``S``
+bytes.
+
 
 Query for this feature with ``__has_builtin(__builtin_assume_dereferenceable)``.
 

clang/lib/CodeGen/CGBuiltin.cpp

@@ -3848,7 +3848,6 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
       SizeValue =
           Builder.CreateIntCast(SizeValue, IntPtrTy, false, "casted.size");
     Builder.CreateDereferenceableAssumption(PtrValue, SizeValue);
-    Builder.CreateNonNullAssumption(PtrValue);
     return RValue::get(nullptr);
   }
   case Builtin::BI__assume:

clang/test/CodeGen/builtin-assume-dereferenceable.c

@@ -7,7 +7,6 @@
 // CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[TMP0]], i64 10) ]
-// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[TMP0]]) ]
 // CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 0
 // CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
@@ -24,7 +23,6 @@ int test1(int *a) {
 // CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[TMP0]], i64 32) ]
-// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[TMP0]]) ]
 // CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8
 // CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 0
 // CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX]], align 4

llvm/include/llvm/IR/IRBuilder.h

@@ -2688,10 +2688,6 @@ class IRBuilderBase {
   /// Create an assume intrinsic call that represents an dereferencable
   /// assumption on the provided pointer.
   CallInst *CreateDereferenceableAssumption(Value *PtrValue, Value *SizeValue);
-
-  /// Create an assume intrinsic call that represents a nonnull assumption
-  /// on the provided pointer.
-  CallInst *CreateNonNullAssumption(Value *PtrValue);
 };
 
 /// This provides a uniform API for creating instructions and inserting