!fixup undo nonnull assumption, clarify docs

Author: fhahn

clang/docs/LanguageExtensions.rst

@@ -2764,7 +2764,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.
 
@@ -2779,20 +2779,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

@@ -3723,7 +3723,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

@@ -2687,10 +2687,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