[LangRef] Clarify alloca of zero bytes.

[efriedma]

Summary

Let's be conservative here; it matches what we actually implement, and it should be rare in practice anyway.

[rjmccall]

LGTM.

[sanjoy]

Does this mean we can "construct" undef as:

x = alloca 0
y = alloca 0
undef = x == y  // Non-deterministically 0 or 1

? If so, this is a problem since it means even if we spec un-initialized memory as poison we still have undef in the IR (with all the problems it brings).

[nlopes]

In D49042#1155256, @sanjoy wrote:

Does this mean we can "construct" undef as:

x = alloca 0
y = alloca 0
undef = x == y  // Non-deterministically 0 or 1

? If so, this is a problem since it means even if we spec un-initialized memory as poison we still have undef in the IR (with all the problems it brings).

It's complicated...
x, y are still different objects. Comparing pointers of different objects yields false, except for the +n case, since p+n == q may be true at execution time if p,q are contiguous objects.
If x,y are zero-sized, then x == y is the +n case.

We either define p+n == q as undef or as non-deterministic value (freeze(poison) essentially). Both options have prons and cons (hard to hoist vs hard to copy), but we have to live with them, unfortunately. So alloc 0 doesn't bring any new difficulty.

llvm/trunk/docs/LangRef.rst

 """"""""""
 
 Memory is allocated; a pointer is returned. The operation is undefined
 if there is insufficient stack space for the allocation. '``alloca``'d
 memory is automatically released when the function returns. The
 '``alloca``' instruction is commonly used to represent automatic
 variables that must have an address available. When the function returns
 (either with the ``ret`` or ``resume`` instructions), the memory is
-reclaimed. Allocating zero bytes is legal, but the result is undefined.
-The order in which memory is allocated (ie., which way the stack grows)
-is not specified.
+reclaimed. Allocating zero bytes is legal, but the returned pointer may not
+be unique. The order in which memory is allocated (ie., which way the stack
+grows) is not specified.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       %ptr = alloca i32                             ; yields i32*:ptr
       %ptr = alloca i32, i32 4                      ; yields i32*:ptr