[LangRef] Memset/memcpy/memmove can take undef/poison pointer if the size is 0

[aqjune]

Summary

According to the current LangRef, Memset/memcpy/memmove can take a
null/dangling pointer if the size is zero.
(Relevant thread: http://lists.llvm.org/pipermail/llvm-dev/2017-July/115665.html )
This patch expands it and allows the functions to take undef/poison pointers
too.

This required the updates in the align attribute since it isn't specified
what is the alignment of undef/poison pointers.
This patch states that their alignment is 1.

[jdoerfert]

llvm/docs/LangRef.rst

1161

Unsure if this is needed TBH. Might be confusing.

[aqjune]

llvm/docs/LangRef.rst

1161

Would it be better if I move this next to However, they must still be appropriately aligned. for a better context?

[aqjune]

llvm/docs/LangRef.rst

1161

This sentence was added to clarify this case:

ptr = poison
memset(ptr align 1, 0, 0) // UB?

Since memset(ptr, 0, 0) is equivalent to memset(ptr align 1, 0, 0), making the latter non-UB seemed natural to me.

[efriedma]

llvm/docs/LangRef.rst

1161

I think I would rather state it more like "align 1 has no effect on non-byval arguments", rather than explicitly refer to undef values. The practical effect is the same, and I think it makes it easier to understand the expected semantics.

12654–12655

"pointers"?

[aqjune]

Updated wording about align 1

[jdoerfert]

llvm/docs/LangRef.rst

1161

Right, everything has an implicit align 1 anyway, at least that was my thinking so far. So align 1 is a "no-op" on any pointer value.

[aqjune]

Minor updates to wording

[aqjune]

llvm/docs/LangRef.rst

12654–12655

Hope this was a right fix..? :)

[efriedma]

llvm/docs/LangRef.rst

12654–12655

That's an improvement, sure. I was thinking about the existing use of "pointers" here, though, since there's only one pointer argument.

[aqjune]

Wording fix

[aqjune]

Wording fix

[efriedma]

LGTM

llvm/docs/LangRef.rst

``sret``
     to trap and to be properly aligned. This is not a valid attribute
     for return values.
 
 .. _attr_align:
 
 ``align <n>`` or ``align(<n>)``
     This indicates that the pointer value may be assumed by the optimizer to
     have the specified alignment.  If the pointer value does not have the
-    specified alignment, behavior is undefined.
+    specified alignment, behavior is undefined. ``align 1`` has no effect on
+    non-byval, non-preallocated arguments.
 
     Note that this attribute has additional semantics when combined with the
-    ``byval`` attribute, which are documented there.
+    ``byval`` or ``preallocated`` attribute, which are documented there.
 
 .. _noalias:
 
 ``noalias``
     This indicates that memory locations accessed via pointer values
     :ref:`based <pointeraliasing>` on the argument or return value are not also
     accessed, during the execution of the function, via pointer values not
     *based* on the argument or return value. This guarantee only holds for

 """"""""""
 
 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
 source location to the destination location, which are not allowed to
 overlap. It copies "len" bytes of memory over. If the argument is known
 to be aligned to some boundary, this can be specified as an attribute on
 the argument.
 
-If "len" is 0, the pointers may be NULL or dangling. However, they must still
-be appropriately aligned.
+If "len" is 0, the pointers may be NULL, dangling, ``undef``, or ``poison``
+pointers. However, they must still be appropriately aligned.
 
 .. _int_memcpy_inline:
 
 '``llvm.memcpy.inline``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 """"""""""
 
 The '``llvm.memcpy.inline.*``' intrinsics copy a block of memory from the
 source location to the destination location, which are not allowed to
 overlap. It copies "len" bytes of memory over. If the argument is known
 to be aligned to some boundary, this can be specified as an attribute on
 the argument.
 
-If "len" is 0, the pointers may be NULL or dangling. However, they must still
-be appropriately aligned.
+If "len" is 0, the pointers may be NULL, dangling, ``undef``, or ``poison``
+pointers. However, they must still be appropriately aligned.
 
 The generated code is guaranteed not to call any external functions.
 
 .. _int_memmove:
 
 '``llvm.memmove``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

 """"""""""
 
 The '``llvm.memmove.*``' intrinsics copy a block of memory from the
 source location to the destination location, which may overlap. It
 copies "len" bytes of memory over. If the argument is known to be
 aligned to some boundary, this can be specified as an attribute on
 the argument.
 
-If "len" is 0, the pointers may be NULL or dangling. However, they must still
-be appropriately aligned.
+If "len" is 0, the pointers may be NULL, dangling, ``undef``, or ``poison``
+pointers. However, they must still be appropriately aligned.
 
 .. _int_memset:
 
 '``llvm.memset.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 Semantics:
 """"""""""
 
 The '``llvm.memset.*``' intrinsics fill "len" bytes of memory starting
 at the destination location. If the argument is known to be
 aligned to some boundary, this can be specified as an attribute on
 the argument.
 
-If "len" is 0, the pointers may be NULL or dangling. However, they must still
-be appropriately aligned.
+If "len" is 0, the pointer may be NULL, dangling, ``undef``, or ``poison``
+pointer. However, it must still be appropriately aligned.
 
 '``llvm.sqrt.*``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.sqrt`` on any