[{"id":3675837,"web_url":"http://patchwork.ozlabs.org/comment/3675837/","msgid":"<39q41058-o96q-r064-5o6q-p44934n3po76@fhfr.qr>","list_archive_url":null,"date":"2026-04-10T11:29:09","subject":"Re: [PATCH v5] x86: Rewrite ix86_find_max_used_stack_alignment","submitter":{"id":4338,"url":"http://patchwork.ozlabs.org/api/people/4338/","name":"Richard Biener","email":"rguenther@suse.de"},"content":"On Fri, 10 Apr 2026, H.J. Lu wrote:\n\n> On Thu, Apr 9, 2026 at 5:13 PM Richard Biener wrote:\n> >\n> > On Thu, 9 Apr 2026, H.J. Lu wrote:\n> >\n> > > On Wed, Apr 8, 2026 at 7:46 PM Richard Biener wrote:\n> > > >\n> > > > On Wed, 8 Apr 2026, H.J. Lu wrote:\n> > > >\n> > > > > On Wed, Apr 8, 2026 at 2:00 AM Richard Biener\n> > > > > wrote:\n> > > > > >\n> > > > > > On Tue, Apr 7, 2026 at 5:18 PM H.J. Lu wrote:\n> > > > > > >\n> > > > > ...\n> > > > > > > How about something like this:\n> > > > > > >\n> > > > > > > /* Update the maximum stack slot alignment from memory alignment if\n> > > > > > > OP is stack memory. */\n> > > > > > >\n> > > > > > > static void\n> > > > > > > ix86_update_stack_alignment_2 (const_rtx op, unsigned int &alignment)\n> > > > > > > {\n> > > > > > > /* Skip if OP is a memory operand with SYMBOLIC_CONST. */\n> > > > > > > rtx x = XEXP (op, 0);\n> > > > > > > if (SYMBOLIC_CONST (x))\n> > > > > > > return;\n> > > > > > >\n> > > > > > > unsigned int mem_align = MEM_ALIGN (op);\n> > > > > > > tree mem_expr = MEM_EXPR (op);\n> > > > > > > if (!mem_expr)\n> > > > > > > {\n> > > > > > > /* If MEM_EXPR is NULL, assume that OP is a memory operand. */\n> > > > > > > check_alignment:\n> > > > > > > if (mem_align > alignment)\n> > > > > > > alignment = mem_align;\n> > > > > > > return;\n> > > > > > > }\n> > > > > > >\n> > > > > > > tree var = get_base_address (mem_expr);\n> > > > > > >\n> > > > > > > /* Skip if OP references an argument passed on stack. */\n> > > > > > > if (TREE_CODE (var) == PARM_DECL)\n> > > > > > > return;\n> > > > > > >\n> > > > > > > if (TREE_CODE (var) == MEM_REF || TREE_CODE (var) == TARGET_MEM_REF)\n> > > > > > > {\n> > > > > > > var = TREE_OPERAND (var, 0);\n> > > > > > > /* Skip if OP is a memory operand from SSA_NAME. */\n> > > > > > > if (TREE_CODE (var) == SSA_NAME)\n> > > > > > > return;\n> > > > > > > goto check_alignment;\n> > > > > > > }\n> > > > > > >\n> > > > > > > if (!VAR_P (var) || !DECL_RTL_SET_P (var))\n> > > > > > > goto check_alignment;\n> > > > > > >\n> > > > > > > x = DECL_RTL (var);\n> > > > > > > if (!MEM_P (x))\n> > > > > > > goto check_alignment;\n> > > > > > >\n> > > > > > > x = XEXP (x, 0);\n> > > > > > > if (SYMBOLIC_CONST (x))\n> > > > > > > return;\n> > > > > > >\n> > > > > > > goto check_alignment;\n> > > > > > > }\n> > > > > > >\n> > > > > > > /* Update the maximum stack slot alignment from memory alignment if\n> > > > > > > SET references stack memory. */\n> > > > > > >\n> > > > > > > static void\n> > > > > > > ix86_update_stack_alignment_1 (rtx set, unsigned int &alignment)\n> > > > > > > {\n> > > > > > > rtx dest = SET_DEST (set);\n> > > > > > >\n> > > > > > > if (MEM_P (dest))\n> > > > > > > return ix86_update_stack_alignment_2 (dest, alignment);\n> > > > > > >\n> > > > > > > const_rtx src = SET_SRC (set);\n> > > > > > >\n> > > > > > > subrtx_iterator::array_type array;\n> > > > > > > FOR_EACH_SUBRTX (iter, array, src, ALL)\n> > > > > > > {\n> > > > > > > auto op = *iter;\n> > > > > > >\n> > > > > > > if (MEM_P (op))\n> > > > > > > return ix86_update_stack_alignment_2 (op, alignment);\n> > > > > > > }\n> > > > > > > }\n> > > > > > >\n> > > > > > > /* Update the maximum stack slot alignment from memory alignment if\n> > > > > > > INSN references stack memory. */\n> > > > > > >\n> > > > > > > static void\n> > > > > > > ix86_update_stack_alignment (rtx_insn *insn, unsigned int &alignment)\n> > > > > > > {\n> > > > > > > rtx set = single_set (insn);\n> > > > > > > if (set)\n> > > > > > > return ix86_update_stack_alignment_1 (set, alignment);\n> > > > > > >\n> > > > > > > rtx pat = PATTERN (insn);\n> > > > > > > if (GET_CODE (pat) != PARALLEL)\n> > > > > > > return;\n> > > > > > >\n> > > > > > > for (int i = 0; i < XVECLEN (pat, 0); i++)\n> > > > > > > {\n> > > > > > > rtx exp = XVECEXP (pat, 0, i);\n> > > > > > >\n> > > > > > > if (GET_CODE (exp) == SET)\n> > > > > > > ix86_update_stack_alignment_1 (exp, alignment);\n> > > > > > > }\n> > > > > > > }\n> > > > > > >\n> > > > > > > /* Set stack_frame_required to false if stack frame isn't required.\n> > > > > > > Update STACK_ALIGNMENT to the largest alignment, in bits, of stack\n> > > > > > > slot used if stack frame is required and CHECK_STACK_SLOT is true. */\n> > > > > > >\n> > > > > > > static void\n> > > > > > > ix86_find_max_used_stack_alignment (unsigned int &stack_alignment,\n> > > > > > > bool check_stack_slot)\n> > > > > > > {\n> > > > > > > HARD_REG_SET set_up_by_prologue, prologue_used;\n> > > > > > > basic_block bb;\n> > > > > > >\n> > > > > > > CLEAR_HARD_REG_SET (prologue_used);\n> > > > > > > CLEAR_HARD_REG_SET (set_up_by_prologue);\n> > > > > > > add_to_hard_reg_set (&set_up_by_prologue, Pmode, STACK_POINTER_REGNUM);\n> > > > > > > add_to_hard_reg_set (&set_up_by_prologue, Pmode, ARG_POINTER_REGNUM);\n> > > > > > > add_to_hard_reg_set (&set_up_by_prologue, Pmode,\n> > > > > > > HARD_FRAME_POINTER_REGNUM);\n> > > > > > >\n> > > > > > > bool require_stack_frame = false;\n> > > > > > >\n> > > > > > > /* The preferred stack alignment is the minimum stack alignment. */\n> > > > > > > if (check_stack_slot\n> > > > > > > && stack_alignment > crtl->preferred_stack_boundary)\n> > > > > > > stack_alignment = crtl->preferred_stack_boundary;\n> > > > > > >\n> > > > > > > FOR_EACH_BB_FN (bb, cfun)\n> > > > > > > {\n> > > > > > > rtx_insn *insn;\n> > > > > > > FOR_BB_INSNS (bb, insn)\n> > > > > > > if (NONDEBUG_INSN_P (insn))\n> > > > > > > {\n> > > > > > > if (!require_stack_frame\n> > > > > > > && requires_stack_frame_p (insn, prologue_used,\n> > > > > > > set_up_by_prologue))\n> > > > > > > {\n> > > > > > > require_stack_frame = true;\n> > > > > > >\n> > > > > > > /* Stop if we don't need to check stack slot. */\n> > > > > > > if (!check_stack_slot)\n> > > > > > > break;\n> > > > > > > }\n> > > > > > >\n> > > > > > > if (!check_stack_slot || !NONJUMP_INSN_P (insn))\n> > > > > > > continue;\n> > > > > > >\n> > > > > > > ix86_update_stack_alignment (insn, stack_alignment);\n> > > > > > > }\n> > > > > > > }\n> > > > > > >\n> > > > > > > cfun->machine->stack_frame_required = require_stack_frame;\n> > > > > > > }\n> > > > > >\n> > > > > > AFAICS this considers almost all MEMs to be stack accesses and thus\n> > > > > > should be conservative. The tracking of which regs point to the stack\n> > > > > > is gone?\n> > > > >\n> > > > > Yes.\n> > > > >\n> > > > > > FOR_EACH_BB_FN visits block in no particular order, init_alias_analysis\n> > > > > > properly iterates to compute what a reg points to, but with multiple defs\n> > > > > > I belive it gives up. But it is probably most closely equivalent to what\n> > > > > > your current code does (just more correct and faster).\n> > > > > >\n> > > > >\n> > > > > Here is the patch to rewrite ix86_find_max_used_stack_alignment.\n> > > > > There are no regressions.\n> > > > >\n> > > > > OK for master?\n> > > >\n> > > > if (TREE_CODE (var) == MEM_REF || TREE_CODE (var) == TARGET_MEM_REF)\n> > > > {\n> > > > var = TREE_OPERAND (var, 0);\n> > > > /* Skip if OP is a memory operand from SSA_NAME. */\n> > > > if (TREE_CODE (var) == SSA_NAME)\n> > > > return;\n> > > >\n> > > > So this seems wrong, we ignore all indirect memory accesses as\n> > > > not belonging to the stack here.\n> > > >\n> > > > The \"else\" should be unreachable due to how get_base_address\n> > > > works.\n> > > >\n> > > > goto check_alignment;\n> > > > }\n> > > >\n> > > > if (!VAR_P (var) || !DECL_RTL_SET_P (var))\n> > > > goto check_alignment;\n> > > >\n> > > > The gotos are ugly, some else if / nesting should get rid of\n> > > > them with duplicating the check_alignment out at the end.\n> > > >\n> > > > I do wonder whether the above would be more precise written as\n> > > >\n> > > > static void\n> > > > ix86_update_stack_alignment_2 (const_rtx op, unsigned int &alignment)\n> > > > {\n> > > > rtx base = find_base_term (XEXP (op, 0));\n> > > >\n> > > > /* Skip if OP references an argument slot. */\n> > > > if (base == static_reg_base_value[ARG_POINTER_REGNUM])\n> > > > return;\n> > > >\n> > > > if (!base\n> > > ^^^^^^^^^^^^^^^\n> > >\n> > > For\n> > >\n> > > char c, d;\n> > > _BitInt(2048) b;\n> > >\n> > > void\n> > > foo (__int128, _BitInt(1024) a)\n> > > {\n> > > b *= 0;\n> > > c %= (char)(a ?: d);\n> > > }\n> > >\n> > > we got\n> > >\n> > > (gdb) call debug (insn)\n> > > (insn 14 12 65 3 (set (mem:V4DI (reg:DI 0 ax [orig:112 ivtmp.23 ]\n> > > [112]) [1 MEM [(_BitInt(2048) *)_34]+0 S32\n> > > A256])\n> > > (reg:V4DI 20 xmm0 [117])) \"x.c\":7:5 discrim 33280 2461\n> > > {movv4di_internal}\n> > > (nil))\n> > > (gdb)\n> > >\n> > > and\n> > >\n> > > (gdb) call debug (op)\n> > > (mem:V4DI (reg:DI 0 ax [orig:112 ivtmp.23 ] [112]) [1 MEM > > unsigned long> [(_BitInt(2048) *)_34]+0 S32 A256])\n> > > (gdb) next\n> > > 8607 if (base != static_reg_base_value[ARG_POINTER_REGNUM]\n> > > (gdb) p base\n> > > $4 = (rtx) 0x0\n> > > (gdb)\n> > >\n> > > if base is 0, we can't assume that it accesses stack.\n> >\n> > Well, base == 0 means \"don't know\", so we have to conservatively\n> > _assume_ it accesses the stack, no? Similar to your\n> > SSA_NAME early out I commented on.\n> >\n> > But sure, RTL points-to analysis leaves a lot to be desired.\n> >\n> > > > || base == static_reg_base_value[STACK_POINTER_REGNUM]\n> > > > || base == static_reg_base_value[FRAME_POINTER_REGNUM])\n> > > > alignment = MAX (MEM_ALIGN (op), alignment);\n> > > > }\n> > > >\n> > > > using RTL points-to. I belive that is what your ix86_find_all_reg_uses\n> > > > attempted to compute.\n> > > >\n> > > > Note find_base_term and friends are not exported from alias.cc so\n> > > > the predicate part would need to be split out into a new predicate\n> > > > there, alongside the existing may_be_sp_based_p (). As said you'll\n> > > > need to call init_alias_analysis from the pass the above is\n> > >\n> > > Isn't init_alias_analysis called from backend_init_target?\n> > > Why should it be called again?\n> >\n> > Because the RTL IL changes and reg_base_value[] needs to be computed\n> > to get accurate (and correct) info.\n> >\n> > Richard.\n> \n> Revert changes in ix86_find_max_used_stack_alignment\n> \n> 7b39d7b3b84 Correct x86: Call ix86_access_stack_p only for larger alignment\n> c8a84242e4b Update x86: Call ix86_access_stack_p only for larger alignment\n> f511bf93f94 x86: Call ix86_access_stack_p only for larger alignment\n> a7cce1afee8 x86: Call ix86_access_stack_p only with symbolic constant load\n> b54533a2863 x86: Update stack alignment only if stack is used\n> b9ea3b2ef98 x86: Properly find the maximum stack slot alignment\n> \n> Rewrite ix86_find_max_used_stack_alignment based on RTL points-to info\n> with find_base_term and static_reg_base_value. If RTL points-to info\n> isn't available,\n> \n> 1. Use ix86_decompose_address to check for symbolic displacement.\n> 2. Check MEM_EXPR for stack argument reference, memory reference and\n> local variable reference.\n> \n> Update the maximum stack slot alignment from memory alignment only if its\n> base may point to stack or frame pointers.\n> \n> The compile times of PR target/124165 and PR target/124684 test are\n> unchanged.\n> \n> PR target/109780\n> PR target/109093\n> PR target/123210\n> PR target/124098\n> PR target/124165\n> PR target/124684\n> PR target/124759\n> PR target/124789\n> * alias.cc (static_reg_base_value): Moved to rtl.h.\n> (find_base_term): Remove static.\n> * function.cc (thread_prologue_and_epilogue_insns): Call\n> init_alias_analysis and end_alias_analysis.\n> * rtl.h (static_reg_base_value): Moved from alias.cc.\n> (find_base_term): New prototype.\n\nPlease put the find_base_term declaration into alias.h given the\nimplementation is in alias.cc\n\n+ix86_update_stack_alignment_2 (const_rtx op, unsigned int &alignment)\n {\n...\n /* Check RTL points-to info. */\n rtx base = find_base_term (XEXP (op, 0));\n if (!base)\n...\n\nI think it's better to use RTL points-to like the rest - as\npositive early out. Thus\n\n /* Skip if RTL points-to says OP cannot access the stack. */\n rtx base = find_base_term (XEXP (op, 0));\n if (base\n && base != static_reg_base_value[STACK_POINTER_REGNUM]\n && base != static_reg_base_value[FRAME_POINTER_REGNUM])\n return;\n\nand then continue with the code you have in if (!base) unconditionally,\nrewriting\n\n /* Handle the case that OP is a stack memory operand in\n\n (set (mem/c:V16QI (reg/f:DI 1 dx [114]) [0 MEM \n [(void *)&k]+0 S16 A128])\n (reg:V16QI 21 xmm1 [orig:116 MEM [(void \n*)&k] ] [116]))\n\n from gcc.target/i386/pr109093-1.c. */\n rtx x = DECL_RTL (var);\n if (MEM_P (x))\n base = find_base_term (XEXP (x, 0));\n\nto be the same \"positive\" check. But then I think the above\ncase might be done entirely on decl devel by using\n\n if (auto_var_in_fn (var, current_function_decl))\n return;\n\nno need to dispatch through DECL_RTL?\n\nand the end of the function should have the conservative fallback:\n\n alignment = mem_align;\n}\n\nThanks,\nRichard.\n\n> * config/i386/i386.cc (stack_access_data): Removed.\n> (ix86_find_all_reg_uses_1): Likewise.\n> (ix86_find_all_reg_uses): Likewise.\n> (ix86_access_stack_p): Likewise.\n> (ix86_need_alignment_p_2): Likewise.\n> (ix86_need_alignment_p_1): Likewise.\n> (ix86_need_alignment_p): Likewise.\n> (ix86_update_stack_alignment_2): New function.\n> (ix86_update_stack_alignment_1): Likewise.\n> (ix86_update_stack_alignment): Rewrite.\n> (ix86_find_max_used_stack_alignment): If check_stack_slot is\n> true, call ix86_update_stack_alignment on each INSN.\n> \n> Signed-off-by: H.J. Lu \n> Co-Authored-By: Richard Biener \n> \n> \n>","headers":{"Return-Path":"","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (1024-bit key;\n unprotected) header.d=suse.de header.i=@suse.de header.a=rsa-sha256\n header.s=susede2_rsa header.b=Uduub5L5;\n\tdkim=pass header.d=suse.de header.i=@suse.de header.a=ed25519-sha256\n header.s=susede2_ed25519 header.b=B90MNF69;\n\tdkim=pass (1024-bit key) header.d=suse.de header.i=@suse.de\n header.a=rsa-sha256 header.s=susede2_rsa header.b=WmjYpbXy;\n\tdkim=neutral header.d=suse.de header.i=@suse.de header.a=ed25519-sha256\n header.s=susede2_ed25519 header.b=uTEqSXTV;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=2620:52:6:3111::32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)","sourceware.org;\n\tdkim=pass (1024-bit key,\n unprotected) header.d=suse.de header.i=@suse.de header.a=rsa-sha256\n header.s=susede2_rsa header.b=Uduub5L5;\n\tdkim=pass header.d=suse.de header.i=@suse.de header.a=ed25519-sha256\n header.s=susede2_ed25519 header.b=B90MNF69;\n\tdkim=pass (1024-bit key) header.d=suse.de header.i=@suse.de\n header.a=rsa-sha256 header.s=susede2_rsa header.b=WmjYpbXy;\n\tdkim=neutral header.d=suse.de header.i=@suse.de header.a=ed25519-sha256\n header.s=susede2_ed25519 header.b=uTEqSXTV","sourceware.org;\n dmarc=pass (p=none dis=none) header.from=suse.de","sourceware.org; spf=pass smtp.mailfrom=suse.de","server2.sourceware.org;\n arc=none smtp.remote-ip=195.135.223.131","smtp-out2.suse.de;\n\tnone"],"Received":["from vm01.sourceware.org (vm01.sourceware.org\n [IPv6:2620:52:6:3111::32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4fsZMz6zNxz1yGb\n\tfor ; Fri, 10 Apr 2026 21:29:49 +1000 (AEST)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 5155C4BA23E6\n\tfor ; Fri, 10 Apr 2026 11:29:47 +0000 (GMT)","from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131])\n by sourceware.org (Postfix) with ESMTPS id 89C114BA23D3\n for ; Fri, 10 Apr 2026 11:29:12 +0000 (GMT)","from murzim.nue2.suse.org (unknown [10.168.4.243])\n (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest\n SHA256)\n (No client certificate requested)\n by smtp-out2.suse.de (Postfix) with ESMTPS id CA1BA5BD33;\n Fri, 10 Apr 2026 11:29:09 +0000 (UTC)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 5155C4BA23E6","OpenDKIM Filter v2.11.0 sourceware.org 89C114BA23D3"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org 89C114BA23D3","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org 89C114BA23D3","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1775820552; cv=none;\n b=OT07WDXKQ4FDQBEjzMEXCTRDaoOCFxy+ylc+vpLDgfOemZkHqPDKS0nXUHO0pY1eiTqywYHlU8R5VOpatIWJhrhfzsVv3WUW8qMcWjlcT8NZEH8N5ARsn5FW18facVCUZnpWLDni0zd++GlSnNrtMkLS5LQAOR64B2tvG0jWLH4=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1775820552; c=relaxed/simple;\n bh=q5DYH51y/EvcsdwfTu2umzvb+8PaLdJylBl8Qitd/JU=;\n h=DKIM-Signature:DKIM-Signature:DKIM-Signature:DKIM-Signature:Date:\n From:To:Subject:Message-ID:MIME-Version;\n b=Ic7X4xwRvPU/tDngAvisy/nSU6/57LAvx+Cv5YxBPhEzSo8SVN+MeJAuhSemryLZktz5SsM+kZhYwtV0EH9D+bH3lhOZI3EZBPsq8HNZtLYlO+OVl21Xsvcb+CeIgIqN/zOlB9j6AMuOsRAfG6w9+ab4hGU8R15cbXSZOXFvDHU=","ARC-Authentication-Results":"i=1; server2.sourceware.org","DKIM-Signature":["v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de;\n s=susede2_rsa;\n t=1775820551;\n h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc:\n mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=KBfKsptcU4FeHlzs1tTztD+qcjVB5SAs8UvzHxCXvLI=;\n b=Uduub5L5qYUSMTuUKJ7frfvDs64VKA6Gx8vQ0DIut7WxeL2T329RTBf5HyUW/SnVJd9yBB\n epjLNlgmFQcqxnpcv5Qb+6a6JBBr3jZiFEkCLbhvL9BTy93CY76gBVwRf92e6djC/4q5v+\n 1PAeiKA9uAq/oU6/s788qV5SE6rk1ps=","v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de;\n s=susede2_ed25519; t=1775820551;\n h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc:\n mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=KBfKsptcU4FeHlzs1tTztD+qcjVB5SAs8UvzHxCXvLI=;\n b=B90MNF69GzxSCxI5Eg1XpMINNUsVh1UZYfjEZr9MucUbJwPvEhO1hHfQPyfpYDDw97CzrK\n VsLl71b8s8RYmxCw==","v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de;\n s=susede2_rsa;\n t=1775820549;\n h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc:\n mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=KBfKsptcU4FeHlzs1tTztD+qcjVB5SAs8UvzHxCXvLI=;\n b=WmjYpbXyf6UMHvZFUFcsqWmoK4IvrjKuYsK7/hJCVNxTIaAi0zRQ3zNmIMNy1tKY2DeDVy\n 4NXsk/N1C0S4+pzueDip69jEctAZ1s6TktftVKV7njt1Fg15I5KCXXpjq5CPUAsgoJA0Iu\n T2V5gLPLvoblqZdU6MyBa9nHsSE/KSU=","v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de;\n s=susede2_ed25519; t=1775820549;\n h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc:\n mime-version:mime-version:content-type:content-type:\n in-reply-to:in-reply-to:references:references;\n bh=KBfKsptcU4FeHlzs1tTztD+qcjVB5SAs8UvzHxCXvLI=;\n b=uTEqSXTV1pTWArZ/L3/JdveiYbLit/p9mXytkDqeaV2WP3n8PecYhw0pJNQ2n/oirLglXI\n VELD7Rhe5lp15NDw=="],"Date":"Fri, 10 Apr 2026 13:29:09 +0200 (CEST)","From":"Richard Biener ","To":"\"H.J. Lu\" ","cc":"GCC Patches , Uros Bizjak ,\n Hongtao Liu , Sam James ,\n Richard Sandiford ","Subject":"Re: [PATCH v5] x86: Rewrite ix86_find_max_used_stack_alignment","In-Reply-To":"\n ","Message-ID":"<39q41058-o96q-r064-5o6q-p44934n3po76@fhfr.qr>","References":"\n \n \n \n \n \n <0305rr41-n79q-q3po-222p-0p6468979827@fhfr.qr>\n \n <8900r718-2q5q-7613-nsp5-o0s313r8p007@fhfr.qr>\n \n \n \n <4369013r-62p8-s3n6-7s47-3rss9r034304@fhfr.qr>\n \n <16nn5044-ooro-2sos-1o7o-9rnr833no6or@fhfr.qr>\n ","MIME-Version":"1.0","Content-Type":"multipart/mixed;\n boundary=\"-1475677436-871218570-1775820549=:28865\"","X-Spamd-Result":"default: False [-1.80 / 50.00]; BAYES_HAM(-3.00)[100.00%];\n SUSPICIOUS_RECIPS(1.50)[]; NEURAL_HAM_LONG(-1.00)[-1.000];\n CTYPE_MIXED_BOGUS(1.00)[]; NEURAL_HAM_SHORT(-0.20)[-1.000];\n MIME_GOOD(-0.10)[multipart/mixed,text/plain];\n MISSING_XM_UA(0.00)[]; FUZZY_RATELIMITED(0.00)[rspamd.com];\n TAGGED_RCPT(0.00)[]; MIME_TRACE(0.00)[0:+,1:+]; ARC_NA(0.00)[];\n RCVD_COUNT_ZERO(0.00)[0]; FREEMAIL_ENVRCPT(0.00)[gmail.com];\n RCPT_COUNT_FIVE(0.00)[6]; FROM_HAS_DN(0.00)[];\n FREEMAIL_CC(0.00)[gcc.gnu.org,gmail.com,intel.com,gentoo.org,googlemail.com];\n FREEMAIL_TO(0.00)[gmail.com]; FROM_EQ_ENVFROM(0.00)[];\n TO_DN_ALL(0.00)[]; TO_MATCH_ENVRCPT_ALL(0.00)[];\n DKIM_SIGNED(0.00)[suse.de:s=susede2_rsa,suse.de:s=susede2_ed25519];\n DBL_BLOCKED_OPENRESOLVER(0.00)[suse.de:email, function.cc:url, fhfr.qr:mid,\n murzim.nue2.suse.org:helo, alias.cc:url, gcc.target:url]","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"}}]