On Wed, Nov 11, 2026 at 8:38 PM Igor Shevlyakov
<[email protected]> wrote:
>
> instantiate_new_reg replaced virtual_cfa_rtx with the argument pointer
> plus cfa_offset.  In a frame realigned with a dynamic realign argument
> pointer (DRAP) the argument pointer is at no fixed offset from SP or the
> hard frame pointer.  On x86 it is eliminated to a fake location, the copy
> of the return address pushed after realignment, so __builtin_dwarf_cfa
> returns the wrong address.  On a target that doesn't push such a copy it
> can't be eliminated at all.
>
> virtual_incoming_args_rtx already uses crtl->args.internal_arg_pointer,
> the DRAP pseudo, in this case: the DRAP holds arg_pointer_rtx +
> in_arg_offset.  Do the same for virtual_cfa_rtx, at offset
> cfa_offset - in_arg_offset.  On x86, the only target that currently
> reaches this path, in_arg_offset is 0; subtracting it keeps the
> instantiation correct for a target where FIRST_PARM_OFFSET is not 0.
>
> The FRAME_POINTER_CFA_OFFSET branch is left alone.  Of the targets that
> define it, only nvptx also provides a DRAP (TARGET_GET_DRAP_RTX), and
> there is no CFA-based unwinding on PTX to check it against.
>
> dwarf-cfa-1.c compares the CFA seen by a realigned and a plain function
> called from the same frame.  Without this change it aborts on x86_64
> and i686 whenever the frame is realigned with a DRAP: in the
> -mforce-drap variants of stackalign.exp, and with -m32 unless
> -maccumulate-outgoing-args is given.
>
> Assisted-by: Claude Opus 5.5
>
> gcc/ChangeLog:
>
>         PR middle-end/128611
>         * function.cc (instantiate_new_reg): Instantiate virtual_cfa_rtx
>         from the DRAP pseudo in a realigned frame.
>
> gcc/testsuite/ChangeLog:
>
>         PR middle-end/128611
>         * gcc.dg/torture/stackalign/dwarf-cfa-1.c: New test.

LGTM from the x86 side, with a comment inline.

Acked-by: Uros Bizjak <[email protected]>

Thanks,
Uros.

>
> Signed-off-by: Igor Shevlyakov <[email protected]>
> ---
> Not fully regtested: verdict for 06a7392e236e is stale.
>
> Changes since v1:
> v2 addresses review comments on v1 received off-list.
>
> - No change in generated code; v1 and v2 give identical assembly for
>   the testcase across -m32/-m64, -O0/-O2/-Os, with and without
>   -mforce-drap.
> - function.cc: the DRAP arm now uses braces and separate statements, as
>   the virtual_incoming_args_rtx arm above it does.  The comment says
>   that the DRAP pseudo holds arg_pointer_rtx + in_arg_offset, hence the
>   cfa_offset - in_arg_offset.
> - Commit message: in_arg_offset is 0 on x86, the only target that
>   currently reaches this path, so the subtraction is for targets where
>   FIRST_PARM_OFFSET is not 0.  The FRAME_POINTER_CFA_OFFSET branch is
>   left alone on purpose: of the targets that define it only nvptx also
>   has a DRAP, and PTX has no CFA-based unwinding to check against.
> - dwarf-cfa-1.c: comment explaining why the two CFAs must be equal and
>   which variants use a DRAP.  stackalign.exp already adds -mforce-drap
>   (and -mforce-drap -fpic) variants on targets with automatic stack
>   alignment: in the v1 regtest, 14 of the 28 runs of the test on each
>   board (unix and unix/-m32) used -mforce-drap (-O0, -O1, -O2, -O3 -g,
>   -Os and both -flto variants, each with and without -fpic), and all of
>   these abort without the patch.  No dg-additional-options
>   "-mforce-drap" there, so the torture runs keep covering frames
>   without a DRAP as well.
> - Commit message: Assisted-by: Claude Opus 5.5.
>
> Testcase before (gcc 16.2) and after (this patch) on x86_64-linux;
> every configuration that realigns with a DRAP aborts before and passes
> after, the others pass both times:
>
>   -m64 / -m32, -mforce-drap                         abort -> pass
>   -m32, -mno-accumulate-outgoing-args (DRAP)        abort -> pass
>   -m32, -maccumulate-outgoing-args (no DRAP)        pass  -> pass
>   -m64, no -mforce-drap (no DRAP)                   pass  -> pass
>
> (each at -O0 and -O2).
>
> realigned () on x86_64 at -O2 -mforce-drap with the patch; the CFA now
> comes from the DRAP (%r10), where before it was 16(%rbp):
>
>         leaq    8(%rsp), %r10
>         andq    $-64, %rsp
>         pushq   -8(%r10)
>         pushq   %rbp
>         movq    %rsp, %rbp
>         pushq   %r10
>         pushq   %rbx
>         leaq    -112(%rbp), %rdi
>         movq    %r10, %rbx
>         subq    $96, %rsp
>         call    sink
>         addq    $96, %rsp
>         movq    %rbx, %rax
>         popq    %rbx
>         popq    %r10
>         popq    %rbp
>         leaq    -8(%r10), %rsp
>         ret
>
> v1 was bootstrapped and regtested on
> x86_64-pc-linux-gnu (-m32/-m64) with no new regressions; for v2
> stackalign.exp was rerun on both boards with no failures.
>
>  gcc/function.cc                               | 16 ++++++--
>  .../gcc.dg/torture/stackalign/dwarf-cfa-1.c   | 38 +++++++++++++++++++
>  2 files changed, 51 insertions(+), 3 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.dg/torture/stackalign/dwarf-cfa-1.c
>
> diff --git a/gcc/function.cc b/gcc/function.cc
> index 0ff9f676b81..21753d56484 100644
> --- a/gcc/function.cc
> +++ b/gcc/function.cc
> @@ -1539,11 +1539,21 @@ instantiate_new_reg (rtx x, poly_int64 *poffset)
>    else if (x == virtual_cfa_rtx)
>      {
>  #ifdef FRAME_POINTER_CFA_OFFSET
> -      new_rtx = frame_pointer_rtx;
> +      new_rtx = frame_pointer_rtx, offset = cfa_offset;
>  #else
> -      new_rtx = arg_pointer_rtx;
> +      if (stack_realign_drap)
> +       {
> +         /* As for virtual_incoming_args_rtx: if DRAP is used to realign
> +            the stack, the argument pointer is at no fixed offset from SP
> +            or the hard frame pointer.  The DRAP pseudo holds the address
> +            of the incoming arguments (arg_pointer_rtx + in_arg_offset),
> +            so the CFA is at cfa_offset - in_arg_offset from it.  */
> +         new_rtx = crtl->args.internal_arg_pointer;
> +         offset = cfa_offset - in_arg_offset;
> +       }
> +      else
> +       new_rtx = arg_pointer_rtx, offset = cfa_offset;

No comma operators, please.

>  #endif
> -      offset = cfa_offset;
>      }
>    else if (x == virtual_preferred_stack_boundary_rtx)
>      {
> diff --git a/gcc/testsuite/gcc.dg/torture/stackalign/dwarf-cfa-1.c 
> b/gcc/testsuite/gcc.dg/torture/stackalign/dwarf-cfa-1.c
> new file mode 100644
> index 00000000000..78c95021522
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/torture/stackalign/dwarf-cfa-1.c
> @@ -0,0 +1,38 @@
> +/* __builtin_dwarf_cfa must give the CFA even in a function that realigns
> +   its frame.  PLAIN and REALIGNED take no arguments and are called from
> +   the same frame of MAIN, so both must see the same CFA: the stack
> +   pointer before the call.  On x86 REALIGNED is realigned with a DRAP
> +   in the -mforce-drap variants that stackalign.exp adds, and also by
> +   default with -m32.  */
> +
> +/* { dg-do run } */
> +
> +extern void abort (void);
> +
> +__attribute__ ((noipa)) void
> +sink (volatile char *p)
> +{
> +  p[0] = 0;
> +}
> +
> +__attribute__ ((noipa)) void *
> +plain (void)
> +{
> +  return __builtin_dwarf_cfa ();
> +}
> +
> +__attribute__ ((noipa)) void *
> +realigned (void)
> +{
> +  volatile char buf[64] __attribute__ ((aligned (64)));
> +  sink (buf);
> +  return __builtin_dwarf_cfa ();
> +}
> +
> +int
> +main (void)
> +{
> +  if (plain () != realigned ())
> +    abort ();
> +  return 0;
> +}
> --
> 2.55.0
>

Reply via email to