[LangRef] Clarify that inaccessiblememonly functions are allowed noalias returns

[reames]

Summary

Confusion over this point came up in a couple of recent changes (D117180, e20b32ff3). Current tone of discussion seems to be that we think inaccessiblememonly was always legal on allocation functions, so this change takes the form of a clarification instead of a change.

[jdoerfert]

LG

llvm/docs/LangRef.rst

1643

Nit: why callee and not function? We could even say explicitly the function can write the memory it returns (before it returns it), e.g., calloc.

[nikic]

LGTM as well.

[Bryce-MW]

It was ambiguous before because this is exactly what I thought it meant. Even though the memory becomes accessible after returning, it is not accessible during the call so it should be allowed to be modified. I think this clarification makes it a lot more clear.

llvm/docs/LangRef.rst

``hot``
     placed into special subsection of the text section to improving locality.
 
     When profile feedback is enabled, this attribute has the precedence over
     the profile information. By marking a function ``hot``, users can work
     around the cases where the training input does not have good coverage
     on all the hot functions.
 ``inaccessiblememonly``
     This attribute indicates that the function may only access memory that
-    is not accessible by the module being compiled. This is a weaker form
-    of ``readnone``. If the function reads or writes other memory, the
-    behavior is undefined.
+    is not accessible by the module being compiled before return from the
+    function. This is a weaker form of ``readnone``. If the function reads
+    or writes other memory, the behavior is undefined.
+
+    For clarity, note that such functions are allowed to return new memory
+    which is ``noalias`` with respect to memory already accessible from
+    the module.  That is, a function can be both ``inaccessiblememonly`` and
+    have a ``noalias`` return which introduces a new, potentially initialized,
+    allocation.
 ``inaccessiblemem_or_argmemonly``
     This attribute indicates that the function may only access memory that is
     either not accessible by the module being compiled, or is pointed to
     by its pointer arguments. This is a weaker form of  ``argmemonly``. If the
     function reads or writes other memory, the behavior is undefined.
 ``inlinehint``
     This attribute indicates that the source code contained a hint that
     inlining this function is desirable (such as the "inline" keyword in