[llvm] [CodeGen] Avoid aligning alloca size. (PR #132064)

[Ulrich Weigand via llvm-commits]

================
@@ -114,7 +114,7 @@ define void @f5() {
 ; CHECK-NEXT:    lgr %r11, %r15
 ; CHECK-NEXT:    .cfi_def_cfa_register %r11
 ; CHECK-NEXT:    lgr %r1, %r15
-; CHECK-NEXT:    aghi %r1, -128
+; CHECK-NEXT:    aghi %r1, -124
 ; CHECK-NEXT:    la %r2, 280(%r1)
 ; CHECK-NEXT:    nill %r2, 65408
 ; CHECK-NEXT:    lgr %r15, %r1
----------------
uweigand wrote:

I'm not convinced that isStackRealignable() is relevant here.  That only changes the behavior for overaligned allocas with compile-time constant sizes.  For a non-constant size, we'd still have the same problem even if isStackRealignable() were true.

I think the core issue may rather be the assumption whether (or not) the result of a `DYNAMIC_STACKALLOC` is equal to the stack pointer or not.   On some targets they are the same, and therefore this one value simply needs to be aligned to the maximum of the ABI stack alignment and the alloca alignment.

But on other targets, like s390x, these are two different values - on s390x at the very bottom of the stack there is an ABI mandated area for outgoing arguments and a register save area, which is preserved even across dynamic allocations.  In this case the dynamic allocation result in *two* new values: a new stack pointer (which must respect the stack alignment) and a result pointer (which must respect the alloca alignment requirement).

I don't have a strong opinion on whether the alignment code should generated by common code or the target back-end.  However, the _interface_ should be clearly defined - specifically, what if any assumptions the back-end implementation of lowering `DYNAMIC_STACKALLOC` can make about the alignment of its size argument must be clearly documented.  That documentation currently reads:
```
  /// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
  /// to a specified boundary.  This node always has two return values: a new
  /// stack pointer value and a chain. The first operand is the token chain,
  /// the second is the number of bytes to allocate, and the third is the
  /// alignment boundary.  The size is guaranteed to be a multiple of the
  /// stack alignment, and the alignment is guaranteed to be bigger than the
  /// stack alignment (if required) or 0 to get standard stack alignment.
```
If this is no longer correct, the documentation needs to be updated (and existing code that may have relied on that documentation should be reviewed).

https://github.com/llvm/llvm-project/pull/132064