!fixup address comments, thanks!

Author: fhahn

llvm/docs/LangRef.rst

@@ -1474,11 +1474,9 @@ Currently, only the following parameter attributes are defined:
     ``null_pointer_is_valid`` function attribute is present.
     ``n`` should be a positive number. The pointer should be well defined,
     otherwise it is undefined behavior. This means ``dereferenceable(<n>)``
-    implies ``noundef``. When ``dereferenceable(<n>)`` is used in an
-    :ref:`assume operand bundls <assume_opbundles>`, the pointer is only
-    guaranteed to be dereferenceable at the point of the assumption and
-    may not be dereferenceable at later pointers, e.g. because it could have
-    been freed.
+    implies ``noundef``. When used in an assume operand bundle, more restricted
+    semantics apply. See  :ref:`assume operand bundles <assume_opbundles>` for
+    more details.
 
 ``dereferenceable_or_null(<n>)``
     This indicates that the parameter or return value isn't both
@@ -2930,6 +2928,11 @@ the behavior is undefined, unless one of the following exceptions applies:
   (including a zero alignment). If this is the case, then the pointer value
   must be a null pointer, otherwise the behavior is undefined.
 
+* ``dereferenceable(<n>)`` operand bundles only guarantee the pointer is
+    dereferenceable at the point of the assumption and may not be
+    dereferenceable at later pointers, e.g. because it could have been
+    freed.
+
 In addition to allowing operand bundles encoding function and parameter
 attributes, an assume operand bundle my also encode a ``separate_storage``
 operand bundle. This has the form:

llvm/lib/Analysis/Loads.cpp

@@ -169,6 +169,11 @@ static bool isDereferenceableAndAlignedPointer(
                                               Size, DL, CtxI, AC, DT, TLI,
                                               Visited, MaxDepth);
 
+  // Dereferenceable information from assumptions is only valid if the value
+  // cannot be freed between the assumption and use. For now just use the
+  // information for values that cannot be freed in the function.
+  // TODO: More precisely check if the pointer can be freed between assumption
+  // and use.
   if (CtxI && !V->canBeFreed()) {
     /// Look through assumes to see if both dereferencability and alignment can
     /// be proven by an assume if needed.

llvm/lib/Analysis/ValueTracking.cpp

@@ -626,7 +626,7 @@ static bool isKnownNonZeroFromAssume(const Value *V, const SimplifyQuery &Q) {
               *I, I->bundle_op_info_begin()[Elem.Index])) {
         if (RK.WasOn == V &&
             (RK.AttrKind == Attribute::NonNull ||
-             (RK.AttrKind == Attribute::Dereferenceable && !V->canBeFreed() &&
+             (RK.AttrKind == Attribute::Dereferenceable &&
               !NullPointerIsDefined(Q.CxtI->getFunction(),
                                     V->getType()->getPointerAddressSpace()))) &&
             isValidAssumeForContext(I, Q.CxtI, Q.DT))