Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.1/patches/2222283/?format=api
{ "id": 2222283, "url": "http://patchwork.ozlabs.org/api/1.1/patches/2222283/?format=api", "web_url": "http://patchwork.ozlabs.org/project/gcc/patch/CAMe9rOohcmgwZMmTsn5orrCP6rB-+1Mzx=-AQT-uS5nz192zfg@mail.gmail.com/", "project": { "id": 17, "url": "http://patchwork.ozlabs.org/api/1.1/projects/17/?format=api", "name": "GNU Compiler Collection", "link_name": "gcc", "list_id": "gcc-patches.gcc.gnu.org", "list_email": "gcc-patches@gcc.gnu.org", "web_url": null, "scm_url": null, "webscm_url": null }, "msgid": "<CAMe9rOohcmgwZMmTsn5orrCP6rB-+1Mzx=-AQT-uS5nz192zfg@mail.gmail.com>", "date": "2026-04-11T07:06:48", "name": "[v6] x86: Rewrite ix86_find_max_used_stack_alignment", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "5bc499111816ff6b0195a292583cd77e63260e86", "submitter": { "id": 4387, "url": "http://patchwork.ozlabs.org/api/1.1/people/4387/?format=api", "name": "H.J. Lu", "email": "hjl.tools@gmail.com" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/gcc/patch/CAMe9rOohcmgwZMmTsn5orrCP6rB-+1Mzx=-AQT-uS5nz192zfg@mail.gmail.com/mbox/", "series": [ { "id": 499533, "url": "http://patchwork.ozlabs.org/api/1.1/series/499533/?format=api", "web_url": "http://patchwork.ozlabs.org/project/gcc/list/?series=499533", "date": "2026-04-11T07:06:48", "name": "[v6] x86: Rewrite ix86_find_max_used_stack_alignment", "version": 6, "mbox": "http://patchwork.ozlabs.org/series/499533/mbox/" } ], "comments": "http://patchwork.ozlabs.org/api/patches/2222283/comments/", "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2222283/checks/", "tags": {}, "headers": { "Return-Path": "<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>", "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 (2048-bit key;\n unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256\n header.s=20251104 header.b=hgX0wBPB;\n\tdkim-atps=neutral", "legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=38.145.34.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 (2048-bit key,\n unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256\n header.s=20251104 header.b=hgX0wBPB", "sourceware.org;\n dmarc=pass (p=none dis=none) header.from=gmail.com", "sourceware.org; spf=pass smtp.mailfrom=gmail.com", "server2.sourceware.org;\n arc=pass smtp.remote-ip=209.85.210.174" ], "Received": [ "from vm01.sourceware.org (vm01.sourceware.org [38.145.34.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 4ft4WS2rVRz1yGb\n\tfor <incoming@patchwork.ozlabs.org>; Sat, 11 Apr 2026 17:08:02 +1000 (AEST)", "from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 6A32E4BA23CA\n\tfor <incoming@patchwork.ozlabs.org>; Sat, 11 Apr 2026 07:08:00 +0000 (GMT)", "from mail-pf1-f174.google.com (mail-pf1-f174.google.com\n [209.85.210.174])\n by sourceware.org (Postfix) with ESMTPS id DCF4F4BA2E0D\n for <gcc-patches@gcc.gnu.org>; Sat, 11 Apr 2026 07:07:26 +0000 (GMT)", "by mail-pf1-f174.google.com with SMTP id\n d2e1a72fcca58-82c70e4654eso1266327b3a.2\n for <gcc-patches@gcc.gnu.org>; Sat, 11 Apr 2026 00:07:26 -0700 (PDT)" ], "DKIM-Filter": [ "OpenDKIM Filter v2.11.0 sourceware.org 6A32E4BA23CA", "OpenDKIM Filter v2.11.0 sourceware.org DCF4F4BA2E0D" ], "DMARC-Filter": "OpenDMARC Filter v1.4.2 sourceware.org DCF4F4BA2E0D", "ARC-Filter": "OpenARC Filter v1.0.0 sourceware.org DCF4F4BA2E0D", "ARC-Seal": [ "i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1775891247; cv=pass;\n b=rkgeHqNxjqfv7AWfKhiCOjm9NfuRny6wBWK1Z3ZN+nKzyDiiHwk8sxH0Vgn4MqFdjleIyIq1kBO3irtFhyqjytS6VSzUNjJKHLcOfTrE/p3zZQNYNDgT858an/3UqZh056r7N0gCiZRzXEBA9hymSVLNPqS/4Yok/46szWRcsnY=", "i=1; a=rsa-sha256; t=1775891245; cv=none;\n d=google.com; s=arc-20240605;\n b=YZF0aUkSMHvHl26pL7ksvRUBK2eJemajT4jNy0/K0Khnxgyku4T/0BM/keS6Pdf7vS\n O7fdXRtGB7gDKSFpbymTAUafzWqJbp5O7dLw36SJ2+MiUuTddlXfoQAcKZSCNCvFFgbz\n yNz1p94hHfNlUfeJ/cbL0bacTETCzwlUlMi16hEyKJJtodKjUCNnrW3HC5fQBTRUMY3m\n 30NXe5/cCBiy3/H9yFpVot3B4gijZMbzN/AgGFKcWBdeVKmYFAu39m8pu/iX+XAunpnR\n Wns/aZL6z8kEerCFnSCfxLD4voPH8nTtZg3GDiullIVJkQTNHFVj+gVpBNc6sSjSMLUz\n xvhw==" ], "ARC-Message-Signature": [ "i=2; a=rsa-sha256; d=sourceware.org; s=key;\n t=1775891247; c=relaxed/simple;\n bh=es/oXaYm67vUAJwXFlajJKuUUroHJGWzxfMNy9wxTxI=;\n h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To;\n b=JLwgoZfNkUBiUeiyIRgjm/a36qN/nUXpA1Osa3pLBofTRuSrpiRIYiGRZiHa2gYaSY8rKB8QHwxaTD/FxJP4rogsbi9DeVV837mEoc39EYCp/WjGNixY5Ey4bT+DWaHnYmTNC1wktTj7IiJfPcXJ5GxxryI9N8Yhyvrz1EeTMUc=", "i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com;\n s=arc-20240605;\n h=cc:to:subject:message-id:date:from:in-reply-to:references\n :mime-version:dkim-signature;\n bh=pHb9wAwaT8l2TxXM07Fl0fKj5hg/jYiZz8w92GUBBnQ=;\n fh=sFFq4wvy7UcSKlgT6RiqXOQFQjorSTnVHLzf7/o8kz4=;\n b=Iw3r7r6Ws9v0Z6muFm4p+NMLW8txPwnOBLmdlVAJzcLvVSJe+yi+sIOZ1Kizonf8pf\n 38++icqA7fTV3Fm1REqeXQeJj0EXBXCtjXUuFti85qAKeqS/SRGpXRttp7NBvnVLZg58\n BvuEAtUpXl2vq/0dZ9X98P6BZP0RY/wwq+Q+3RADAm3Ly/qIA8IelnZyO/GCzUOGsney\n j1F+Qdq9gQxHgwhZgFUGlbtPdB/cjXVWAD2AngOfqgFTyfDTFS2PGDG5u5yIHDmIjgQO\n H24U9aKfwgmQs1/K7eiFxikIrBlY3tWeJliC4plEEQqxlA1b4E5WqgdeEENtAmvxzubl\n mOpw==; darn=gcc.gnu.org" ], "ARC-Authentication-Results": [ "i=2; server2.sourceware.org", "i=1; mx.google.com; arc=none" ], "DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=gmail.com; s=20251104; t=1775891245; x=1776496045; darn=gcc.gnu.org;\n h=cc:to:subject:message-id:date:from:in-reply-to:references\n :mime-version:from:to:cc:subject:date:message-id:reply-to;\n bh=pHb9wAwaT8l2TxXM07Fl0fKj5hg/jYiZz8w92GUBBnQ=;\n b=hgX0wBPBaprwXbCz81DghJXhofiNGWrETxmkp5JRGdSKLZxpKT1xNOPzPAyr0moVkI\n 1cOs0/nAZLQ+3+TYJPNEMqu2ZFvuiWF9LTT8giPqEML1ewP48+xv5aA6FBmnsoI6qtfU\n Cb4Vabv/ZG+9KJSYUPjOqqZv06uZIBqI4PoQ0HECBWSiAeTdscA3pgxubkJJhGzWd6Or\n kikZYzUMc1kY572NMWsEbKiAFQR7MkRUMJVolPFmOLtnFwHmxIb3QdI0P95hLtDwwkql\n SY4QiTUxQXJiWjrUDmo07udqPgz/JXheRLzNLQ8L158Bv/mFMxVB0D3NxldQv3R9Eoma\n gRJQ==", "X-Google-DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20251104; t=1775891245; x=1776496045;\n h=cc:to:subject:message-id:date:from:in-reply-to:references\n :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date\n :message-id:reply-to;\n bh=pHb9wAwaT8l2TxXM07Fl0fKj5hg/jYiZz8w92GUBBnQ=;\n b=nlAWO5E6YzgYQ3DlO0LvoYeE4pCPCY2STdj4AW99b+Pp+b1kNGXvusSzx8A3diu1c3\n nzrxTuYWPCm63ojyGQYNoddwfoynJFhAdxLcZUYNaRccwrL3vNyiz0EiBCl7pEsd1HDg\n 1N+MZfv5TFX6HEH6byuXIdAVN/51OqL0Gv0kzGAem1IVYoRHm7hpqqkW+0X/VySgKY8u\n NV+YO3HL1Rmvwq/J5j8taytLaEZMPUWpiWeeswiEJoY5xcYo+fVno/VK5r0vTarW+2A3\n cCJOAhBN34cyoLmSr61Zy2gLO07Uz9fiTeyPrWmot0cfKzRoIWaM0szYkbSznGCgtbRw\n nwnA==", "X-Gm-Message-State": "AOJu0YyRaGelY1DmS2b2SJotkdJzqwqwc7OUYtFfk/iQLYC/yhfaFhtS\n +3a6H5kZ8fh51eD3EYRqbSC4jqZPIeDMt9VNyRl2ZmeXPATxSbBCREUaXWRfVRWqAMUkixQQ3YD\n Q9lDfCXIMw16jqdfavf8FF9f4CVemtac=", "X-Gm-Gg": "AeBDievWGk8R3S0MzjO3ryfj9xaaS7QN/dPRo18MRR2K5YPW6qFgqD9zf9BeqCODdyo\n BRj8uSqd38XdvN9yLvirXPTq8fpiqd4DeocKc9G8hko/s6VKhu1iVVpzhmfAIL5pvQFUOFgxcZK\n wkdmUumRpli8wXojl/RYX54Isr6jCWyAwHL0iJBG9ibZGpMCQFVkDAZhxrcjx324KQBbS9bS078\n YMe7B7z1sIEKJAhLhzs4l9o63up9ZrHI8p4nCzQBbVYiJVcdgRcsPMNz5Twea8EeTqnRtgn8h+p\n Cz9XPbg=", "X-Received": "by 2002:a05:6a00:1913:b0:82c:6f07:299f with SMTP id\n d2e1a72fcca58-82f0c272fb0mr6479705b3a.14.1775891245155; Sat, 11 Apr 2026\n 00:07:25 -0700 (PDT)", "MIME-Version": "1.0", "References": "\n <CAMe9rOqehAHY1DjMoco_vDqoPSY4-o=q=Ty6Yro9uDHOy+2CBg@mail.gmail.com>\n <CAMe9rOp-EFNdwdahM9m3y-2GneOQ2BF2P6mhkkjgXUybQXb2XA@mail.gmail.com>\n <CAMe9rOpVU1ppyO=3UfTWS8dTnbhYWmSiP0_ZsvTwo9zv8EEkoQ@mail.gmail.com>\n <nn314941-07qo-54n3-4o6s-48rnpo5r3199@fhfr.qr>\n <CAMe9rOrVGwKbHdofQ9TqBAXYObL5Yu+J4ZnTeb5bD+pNve3zPw@mail.gmail.com>\n <0305rr41-n79q-q3po-222p-0p6468979827@fhfr.qr>\n <CAMe9rOrtsUqu1AgU=M9rgV1jcUB8YO12Aaekev+o5zFfi5PQNQ@mail.gmail.com>\n <8900r718-2q5q-7613-nsp5-o0s313r8p007@fhfr.qr>\n <CAMe9rOpyurp8_kBu00epcBvtpN+wHzWRu3W6jr-7qu3+xwp=Ww@mail.gmail.com>\n <CAFiYyc3VgmggpbTkY0d+JcWyTALcHpMJWFt9W819VYdj=86xzg@mail.gmail.com>\n <CAMe9rOpioAjEe1Y-5MRm1vjaGW0DLKUpasj4_XfGb8u8-7Vc1A@mail.gmail.com>\n <4369013r-62p8-s3n6-7s47-3rss9r034304@fhfr.qr>\n <CAMe9rOqQ0MHB5FWCZM+gZZc-S=bHY5=w6D707EdsPNvLAWWLTA@mail.gmail.com>\n <16nn5044-ooro-2sos-1o7o-9rnr833no6or@fhfr.qr>\n <CAMe9rOr8BGAgU-gZsYhjrBZC7hZjNE6ys01ddNZfEXQ7yV6RRQ@mail.gmail.com>\n <39q41058-o96q-r064-5o6q-p44934n3po76@fhfr.qr>", "In-Reply-To": "<39q41058-o96q-r064-5o6q-p44934n3po76@fhfr.qr>", "From": "\"H.J. Lu\" <hjl.tools@gmail.com>", "Date": "Sat, 11 Apr 2026 15:06:48 +0800", "X-Gm-Features": "AQROBzBoDNTtBUq1DeLIvMNYRjDmmgEelQTsAxoGid67MbVI1GuYhyRQm6CGr2k", "Message-ID": "\n <CAMe9rOohcmgwZMmTsn5orrCP6rB-+1Mzx=-AQT-uS5nz192zfg@mail.gmail.com>", "Subject": "[PATCH v6] x86: Rewrite ix86_find_max_used_stack_alignment", "To": "Richard Biener <rguenther@suse.de>", "Cc": "GCC Patches <gcc-patches@gcc.gnu.org>, Uros Bizjak <ubizjak@gmail.com>,\n Hongtao Liu <hongtao.liu@intel.com>, Sam James <sam@gentoo.org>,\n Richard Sandiford <rdsandiford@googlemail.com>", "Content-Type": "multipart/mixed; boundary=\"000000000000d6d08c064f29e6e5\"", "X-BeenThere": "gcc-patches@gcc.gnu.org", "X-Mailman-Version": "2.1.30", "Precedence": "list", "List-Id": "Gcc-patches mailing list <gcc-patches.gcc.gnu.org>", "List-Unsubscribe": "<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>", "List-Archive": "<https://gcc.gnu.org/pipermail/gcc-patches/>", "List-Post": "<mailto:gcc-patches@gcc.gnu.org>", "List-Help": "<mailto:gcc-patches-request@gcc.gnu.org?subject=help>", "List-Subscribe": "<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>", "Errors-To": "gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org" }, "content": "On Fri, Apr 10, 2026 at 7:29 PM Richard Biener <rguenther@suse.de> wrote:\n>\n> On Fri, 10 Apr 2026, H.J. Lu wrote:\n>\n> > On Thu, Apr 9, 2026 at 5:13 PM Richard Biener <rguenther@suse.de> 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 <rguenther@suse.de> 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> > > > > > <richard.guenther@gmail.com> wrote:\n> > > > > > >\n> > > > > > > On Tue, Apr 7, 2026 at 5:18 PM H.J. Lu <hjl.tools@gmail.com> 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 <vector(4) unsigned long> [(_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 <vector(4)\n> > > > 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>\n> Please put the find_base_term declaration into alias.h given the\n> implementation is in alias.cc\n\nDone.\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>\n> I think it's better to use RTL points-to like the rest - as\n> positive 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\nI changed it to\n\n rtx base = find_base_term (XEXP (op, 0));\n if (base)\n {\n /* Update ALIGNMENT if RTL points-to says OP accesses stack. */\n if (base == static_reg_base_value[STACK_POINTER_REGNUM]\n || base == static_reg_base_value[FRAME_POINTER_REGNUM])\n alignment = mem_align;\n return;\n }\n\n> and then continue with the code you have in if (!base) unconditionally,\n> rewriting\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> <char[1:80]> [(void *)&k]+0 S16 A128])\n> (reg:V16QI 21 xmm1 [orig:116 MEM <char[1:80]> [(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>\n> to be the same \"positive\" check. But then I think the above\n> case might be done entirely on decl devel by using\n>\n> if (auto_var_in_fn (var, current_function_decl))\n> return;\n>\n> no need to dispatch through DECL_RTL?\n\nI changed it to\n\n else if (decl_in_symtab_p (var))\n return;\n\n> and the end of the function should have the conservative fallback:\n>\n> alignment = mem_align;\n> }\n>\n> Thanks,\n> Richard.\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 <hjl.tools@gmail.com>\n> > Co-Authored-By: Richard Biener <rguenther@suse.de>\n> >\n> >\n>\nRewrite ix86_find_max_used_stack_alignment based on RTL points-to info\nwith find_base_term and static_reg_base_value. If RTL points-to info\nisn't available,\n\n1. Use ix86_decompose_address to check for symbolic displacement.\n2. Check MEM_EXPR for stack argument reference, memory reference and\nstatic/external variable reference.\n\nUpdate the maximum stack slot alignment from memory alignment only if its\nbase may point to stack or frame pointers.\n\nThe compile times of PR target/124165 and PR target/124684 test are\nunchanged.\n\nPR target/109780\nPR target/109093\nPR target/123210\nPR target/124098\nPR target/124165\nPR target/124684\nPR target/124759\nPR 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\ninit_alias_analysis and end_alias_analysis.\n* rtl.h (static_reg_base_value): Moved from alias.cc.\n* alias.h (find_base_term): New prototype.\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\ntrue, call ix86_update_stack_alignment on each INSN.\n\nSigned-off-by: H.J. Lu <hjl.tools@gmail.com>\nCo-Authored-By: Richard Biener <rguenther@suse.de>", "diff": "From 44796c1819d0358edf27eba1dcf26092619fa145 Mon Sep 17 00:00:00 2001\nFrom: \"H.J. Lu\" <hjl.tools@gmail.com>\nDate: Tue, 7 Apr 2026 23:16:38 +0800\nSubject: [PATCH v6] x86: Rewrite ix86_find_max_used_stack_alignment\n\nRevert changes in ix86_find_max_used_stack_alignment\n\n7b39d7b3b84 Correct x86: Call ix86_access_stack_p only for larger alignment\nc8a84242e4b Update x86: Call ix86_access_stack_p only for larger alignment\nf511bf93f94 x86: Call ix86_access_stack_p only for larger alignment\na7cce1afee8 x86: Call ix86_access_stack_p only with symbolic constant load\nb54533a2863 x86: Update stack alignment only if stack is used\nb9ea3b2ef98 x86: Properly find the maximum stack slot alignment\n\nRewrite ix86_find_max_used_stack_alignment based on RTL points-to info\nwith find_base_term and static_reg_base_value. If RTL points-to info\nisn't available,\n\n1. Use ix86_decompose_address to check for symbolic displacement.\n2. Check MEM_EXPR for stack argument reference, memory reference and\nstatic/external variable reference.\n\nUpdate the maximum stack slot alignment from memory alignment only if its\nbase may point to stack or frame pointers.\n\nThe compile times of PR target/124165 and PR target/124684 test are\nunchanged.\n\n\tPR target/109780\n\tPR target/109093\n\tPR target/123210\n\tPR target/124098\n\tPR target/124165\n\tPR target/124684\n\tPR target/124759\n\tPR target/124789\n\t* alias.cc (static_reg_base_value): Moved to rtl.h.\n\t(find_base_term): Remove static.\n\t* alias.h (find_base_term): New prototype.\n\t* function.cc (thread_prologue_and_epilogue_insns): Call\n\tinit_alias_analysis and end_alias_analysis.\n\t* rtl.h (static_reg_base_value): Moved from alias.cc.\n\t* config/i386/i386.cc (stack_access_data): Removed.\n\t(ix86_find_all_reg_uses_1): Likewise.\n\t(ix86_find_all_reg_uses): Likewise.\n\t(ix86_access_stack_p): Likewise.\n\t(ix86_need_alignment_p_2): Likewise.\n\t(ix86_need_alignment_p_1): Likewise.\n\t(ix86_need_alignment_p): Likewise.\n\t(ix86_update_stack_alignment_2): New function.\n\t(ix86_update_stack_alignment_1): Likewise.\n\t(ix86_update_stack_alignment): Rewrite.\n\t(ix86_find_max_used_stack_alignment): If check_stack_slot is\n\ttrue, call ix86_update_stack_alignment on each INSN.\n\nSigned-off-by: H.J. Lu <hjl.tools@gmail.com>\nCo-Authored-By: Richard Biener <rguenther@suse.de>\n---\n gcc/alias.cc | 5 +-\n gcc/alias.h | 1 +\n gcc/config/i386/i386.cc | 393 ++++++++++++----------------------------\n gcc/function.cc | 6 +\n gcc/rtl.h | 2 +\n 5 files changed, 124 insertions(+), 283 deletions(-)\n\ndiff --git a/gcc/alias.cc b/gcc/alias.cc\nindex 6e16b21327f..cc70ce5ce40 100644\n--- a/gcc/alias.cc\n+++ b/gcc/alias.cc\n@@ -232,9 +232,6 @@ static GTY((deletable)) vec<rtx, va_gc> *old_reg_base_value;\n #define UNIQUE_BASE_VALUE_FP\t-3\n #define UNIQUE_BASE_VALUE_HFP\t-4\n \n-#define static_reg_base_value \\\n- (this_target_rtl->x_static_reg_base_value)\n-\n #define REG_BASE_VALUE(X)\t\t\t\t\t\\\n (REGNO (X) < vec_safe_length (reg_base_value)\t\t\t\\\n ? (*reg_base_value)[REGNO (X)] : 0)\n@@ -2065,7 +2062,7 @@ find_base_term (rtx x, vec<std::pair<cselib_val *,\n /* Wrapper around the worker above which removes locs from visited VALUEs\n to avoid visiting them multiple times. We unwind that changes here. */\n \n-static rtx\n+rtx\n find_base_term (rtx x)\n {\n auto_vec<std::pair<cselib_val *, struct elt_loc_list *>, 32> visited_vals;\ndiff --git a/gcc/alias.h b/gcc/alias.h\nindex 4bd49bb0fa4..1e43111f580 100644\n--- a/gcc/alias.h\n+++ b/gcc/alias.h\n@@ -42,6 +42,7 @@ int compare_base_decls (tree, tree);\n bool refs_same_for_tbaa_p (tree, tree);\n bool mems_same_for_tbaa_p (rtx, rtx);\n bool view_converted_memref_p (tree);\n+extern rtx find_base_term (rtx);\n \n /* This alias set can be used to force a memory to conflict with all\n other memories, creating a barrier across which no memory reference\ndiff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc\nindex 9d1a2af7064..d77dc1feefd 100644\n--- a/gcc/config/i386/i386.cc\n+++ b/gcc/config/i386/i386.cc\n@@ -8598,221 +8598,125 @@ output_probe_stack_range (rtx reg, rtx end)\n return \"\";\n }\n \n-/* Data passed to ix86_update_stack_alignment. */\n-struct stack_access_data\n-{\n- /* The stack access register. */\n- const_rtx reg;\n- /* Pointer to stack alignment. */\n- unsigned int *stack_alignment;\n-};\n-\n-/* Return true if OP references an argument passed on stack. */\n-\n-static bool\n-ix86_argument_passed_on_stack_p (const_rtx op)\n-{\n- tree mem_expr = MEM_EXPR (op);\n- if (mem_expr)\n- {\n- tree var = get_base_address (mem_expr);\n- return TREE_CODE (var) == PARM_DECL;\n- }\n- return false;\n-}\n-\n-/* Update the maximum stack slot alignment from memory alignment in PAT. */\n-\n-static void\n-ix86_update_stack_alignment (rtx, const_rtx pat, void *data)\n-{\n- /* This insn may reference stack slot. Update the maximum stack slot\n- alignment if the memory is referenced by the stack access register. */\n- stack_access_data *p = (stack_access_data *) data;\n-\n- subrtx_iterator::array_type array;\n- FOR_EACH_SUBRTX (iter, array, pat, ALL)\n- {\n- auto op = *iter;\n- if (MEM_P (op))\n-\t{\n-\t /* NB: Ignore arguments passed on stack since caller is\n-\t responsible to align the outgoing stack for arguments\n-\t passed on stack. */\n-\t if (reg_mentioned_p (p->reg, XEXP (op, 0))\n-\t && !ix86_argument_passed_on_stack_p (op))\n-\t {\n-\t unsigned int alignment = MEM_ALIGN (op);\n-\n-\t if (alignment > *p->stack_alignment)\n-\t\t*p->stack_alignment = alignment;\n-\t break;\n-\t }\n-\t else\n-\t iter.skip_subrtxes ();\n-\t}\n- }\n-}\n-\n-/* Helper function for ix86_find_all_reg_uses. */\n+/* Update the maximum stack slot alignment from memory alignment if\n+ OP is stack memory. */\n \n static void\n-ix86_find_all_reg_uses_1 (HARD_REG_SET ®set,\n-\t\t\t rtx set, unsigned int regno,\n-\t\t\t auto_bitmap &worklist)\n+ix86_update_stack_alignment_2 (const_rtx op, unsigned int &alignment)\n {\n- rtx dest = SET_DEST (set);\n-\n- if (!REG_P (dest))\n+ unsigned int mem_align = MEM_ALIGN (op);\n+ if (mem_align <= alignment)\n return;\n \n- /* Reject non-Pmode modes. */\n- if (GET_MODE (dest) != Pmode)\n- return;\n+ /* Skip if OP is a memory operand with CONST_INT in\n+\n+ (set (mem/v:SI (const_int 0 [0]) [14 MEM[(int *)0B]+0 S4 A256])\n+\t (const_int 0 [0]))\n \n- unsigned int dst_regno = REGNO (dest);\n+ or SYMBOLIC_CONST in\n \n- if (TEST_HARD_REG_BIT (regset, dst_regno))\n+ (set (reg:SI 0 ax [orig:118 _2 ] [118])\n+\t (sign_extend:SI (mem/c:QI (symbol_ref:DI (\"c\") [flags 0x2] <var_decl 0x7fffe960de40 c>) [0 c+0 S1 A8])))\n+ */\n+ rtx x = XEXP (op, 0);\n+ if (CONST_INT_P (x) || SYMBOLIC_CONST (x))\n return;\n \n- const_rtx src = SET_SRC (set);\n+ /* Skip if OP is function result on stack in\n \n- subrtx_iterator::array_type array;\n- FOR_EACH_SUBRTX (iter, array, src, ALL)\n+ (set (mem/c:TI (reg/f:SI 0 ax [orig:99 .result_ptr ] [99]) [2 <retval>+0 S16 A128])\n+\t (reg:TI 20 xmm0 [orig:100 x ] [100]))\n+ */\n+ tree result_decl = DECL_RESULT (current_function_decl);\n+ if (result_decl && DECL_RTL_SET_P (result_decl))\n {\n- auto op = *iter;\n-\n- if (MEM_P (op))\n-\titer.skip_subrtxes ();\n-\n- if (REG_P (op) && REGNO (op) == regno)\n-\t{\n-\t /* Add this register to register set. */\n-\t add_to_hard_reg_set (®set, Pmode, dst_regno);\n-\t bitmap_set_bit (worklist, dst_regno);\n-\t break;\n-\t}\n+ rtx result_rtl = DECL_RTL (result_decl);\n+ if (MEM_P (result_rtl) && XEXP (result_rtl, 0) == x)\n+\treturn;\n }\n-}\n-\n-/* Find all registers defined with register REGNO. */\n \n-static void\n-ix86_find_all_reg_uses (HARD_REG_SET ®set,\n-\t\t\tunsigned int regno, auto_bitmap &worklist)\n-{\n- for (df_ref ref = DF_REG_USE_CHAIN (regno);\n- ref != NULL;\n- ref = DF_REF_NEXT_REG (ref))\n+ rtx base = find_base_term (XEXP (op, 0));\n+ if (base)\n {\n- if (DF_REF_IS_ARTIFICIAL (ref))\n-\tcontinue;\n+ /* Update ALIGNMENT if RTL points-to says OP accesses stack. */\n+ if (base == static_reg_base_value[STACK_POINTER_REGNUM]\n+\t || base == static_reg_base_value[FRAME_POINTER_REGNUM])\n+\talignment = mem_align;\n+ return;\n+ }\n \n- rtx_insn *insn = DF_REF_INSN (ref);\n+ /* RTL points-to isn't available. */\n+ bool ok;\n+ struct ix86_address parts;\n+ ok = ix86_decompose_address (XEXP (op, 0), &parts);\n+ gcc_assert (ok);\n \n- if (!NONJUMP_INSN_P (insn))\n-\tcontinue;\n+ /* Skip if displacement is SYMBOLIC_CONST in\n \n- unsigned int ref_regno = DF_REF_REGNO (ref);\n+ (set (mem:V16QI (plus:SI (reg:SI 2 cx [orig:105 niters_vector_mult_vf.6 ] [105])\n+\t\t\t (symbol_ref:SI (\"perm\") [flags 0x2] <var_decl 0x7fffe9613130 perm>)) [0 MEM <vector(16) char> [(char *)vectp_perm.21_69]+0 S16 A256])\n+\t (reg:V16QI 20 xmm0 [orig:179 vect__13.18_68 ] [179]))\n \n- rtx set = single_set (insn);\n- if (set)\n-\t{\n-\t ix86_find_all_reg_uses_1 (regset, set,\n-\t\t\t\t ref_regno, worklist);\n-\t continue;\n-\t}\n+ from gcc.target/i386/pr109780-1.c. */\n+ if (parts.disp && SYMBOLIC_CONST (parts.disp))\n+ return;\n \n- rtx pat = PATTERN (insn);\n- if (GET_CODE (pat) != PARALLEL)\n-\tcontinue;\n+ tree mem_expr = MEM_EXPR (op);\n+ if (mem_expr)\n+ {\n+ tree var = get_base_address (mem_expr);\n+ /* Skip if OP references an argument passed on stack. */\n+ if (TREE_CODE (var) == PARM_DECL)\n+\treturn;\n \n- for (int i = 0; i < XVECLEN (pat, 0); i++)\n-\t{\n-\t rtx exp = XVECEXP (pat, 0, i);\n+ /* Skip if OP is a memory operand of memory reference in\n \n-\t if (GET_CODE (exp) == SET)\n-\t ix86_find_all_reg_uses_1 (regset, exp,\n-\t\t\t\t ref_regno, worklist);\n-\t}\n- }\n-}\n+\t (set (mem:V4DI (reg:DI 0 ax [orig:112 ivtmp.23 ] [112]) [1 MEM <vector(4) unsigned long> [(_BitInt(2048) *)_34]+0 S32 A256])\n+\t (reg:V4DI 20 xmm0 [117]))\n \n-/* Return true if the hard register REGNO used for a stack access is\n- defined in a basic block that dominates the block where it is used. */\n+\t from gcc.target/i386/pr124098.c,\n \n-static bool\n-ix86_access_stack_p (unsigned int regno, basic_block bb,\n-\t\t HARD_REG_SET &set_up_by_prologue,\n-\t\t HARD_REG_SET &prologue_used,\n-\t\t auto_bitmap reg_dominate_bbs_known[],\n-\t\t auto_bitmap reg_dominate_bbs[])\n-{\n- if (bitmap_bit_p (reg_dominate_bbs_known[regno], bb->index))\n- return bitmap_bit_p (reg_dominate_bbs[regno], bb->index);\n-\n- bitmap_set_bit (reg_dominate_bbs_known[regno], bb->index);\n-\n- /* Get all BBs which set REGNO and dominate the current BB from all\n- DEFs of REGNO. */\n- for (df_ref def = DF_REG_DEF_CHAIN (regno);\n- def;\n- def = DF_REF_NEXT_REG (def))\n- if (!DF_REF_IS_ARTIFICIAL (def)\n-\t&& !DF_REF_FLAGS_IS_SET (def, DF_REF_MAY_CLOBBER)\n-\t&& !DF_REF_FLAGS_IS_SET (def, DF_REF_MUST_CLOBBER))\n- {\n-\tbasic_block set_bb = DF_REF_BB (def);\n-\tif (dominated_by_p (CDI_DOMINATORS, bb, set_bb))\n-\t {\n-\t rtx_insn *insn = DF_REF_INSN (def);\n-\t /* Return true if INSN requires stack. */\n-\t if (requires_stack_frame_p (insn, prologue_used,\n-\t\t\t\t\tset_up_by_prologue))\n-\t {\n-\t\tbitmap_set_bit (reg_dominate_bbs[regno], bb->index);\n-\t\treturn true;\n-\t }\n-\t }\n- }\n+\t (set (reg:V2DI 20 xmm0 [orig:103 MEM[(const __m128i * {ref-all})s_1(D) & 4294967280B] ] [103])\n+\t (mem:V2DI (reg:SI 0 ax [102]) [0 MEM[(const __m128i * {ref-all})s_1(D) & 4294967280B]+0 S16 A128]))\n \n- /* When we get here, REGNO used in the current BB doesn't access\n- stack. */\n- return false;\n-}\n+\t from gcc.target/i386/pr53907.c and\n \n-/* Return true if OP isn't a memory operand with SYMBOLIC_CONST and\n- needs alignment > ALIGNMENT. */\n+\t (set (reg:CCC 17 flags)\n+\t (compare:CCC (plus:DI (mem:DI (reg:DI 2 cx [103]) [4 MEM[(<address-space-1> __int128 *)0B]+0 S8 A128 AS1])\n+\t\t\t\t\t (const_int 8192 [0x2000]))\n+\t\t\t (mem:DI (reg:DI 2 cx [103]) [4 MEM[(<address-space-1> __int128 *)0B]+0 S8 A128 AS1])))\n \n-static bool\n-ix86_need_alignment_p_2 (const_rtx op, unsigned int alignment)\n-{\n- bool need_alignment = MEM_ALIGN (op) > alignment;\n- tree mem_expr = MEM_EXPR (op);\n- if (!mem_expr)\n- return need_alignment;\n+\t from gcc.target/i386/apx-ndd-seg-1.c. */\n+ if (TREE_CODE (var) == MEM_REF\n+\t || TREE_CODE (var) == TARGET_MEM_REF)\n+\treturn;\n+ /* Skip if OP is a memory operand of static or external variable\n+\t in\n \n- tree var = get_base_address (mem_expr);\n- if (!VAR_P (var) || !DECL_RTL_SET_P (var))\n- return need_alignment;\n+\t (set (mem/c:DI (plus:DI (reg/f:DI 1 dx [157])\n+\t\t\t\t (reg:DI 0 ax [98])) [2 __gcov8.foo.strub.0[0]+0 S8 A256])\n+\t (ior:DI (mem/c:DI (plus:DI (reg/f:DI 1 dx [157])\n+\t\t\t\t(reg:DI 0 ax [98])) [2 __gcov8.foo.strub.0[0]+0 S8 A256])\n+\t\t (const_int 1 [0x1])))\n \n- rtx x = DECL_RTL (var);\n- if (!MEM_P (x))\n- return need_alignment;\n+\t from gcc.target/i386/pr123210.c. */\n+ else if (decl_in_symtab_p (var))\n+\treturn;\n+ }\n \n- x = XEXP (x, 0);\n- return !SYMBOLIC_CONST (x) && need_alignment;\n+ alignment = mem_align;\n }\n \n-/* Return true if SET needs alignment > ALIGNMENT. */\n+/* Update the maximum stack slot alignment from memory alignment if\n+ SET references stack memory. */\n \n-static bool\n-ix86_need_alignment_p_1 (rtx set, unsigned int alignment)\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_need_alignment_p_2 (dest, alignment);\n+ return ix86_update_stack_alignment_2 (dest, alignment);\n \n const_rtx src = SET_SRC (set);\n \n@@ -8822,35 +8726,31 @@ ix86_need_alignment_p_1 (rtx set, unsigned int alignment)\n auto op = *iter;\n \n if (MEM_P (op))\n-\treturn ix86_need_alignment_p_2 (op, alignment);\n+\treturn ix86_update_stack_alignment_2 (op, alignment);\n }\n-\n- return false;\n }\n \n-/* Return true if INSN needs alignment > ALIGNMENT. */\n+/* Update the maximum stack slot alignment from memory alignment if\n+ INSN references stack memory. */\n \n-static bool\n-ix86_need_alignment_p (rtx_insn *insn, unsigned int alignment)\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_need_alignment_p_1 (set, alignment);\n+ return ix86_update_stack_alignment_1 (set, alignment);\n \n rtx pat = PATTERN (insn);\n if (GET_CODE (pat) != PARALLEL)\n- return false;\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-\t && ix86_need_alignment_p_1 (exp, alignment))\n-\treturn true;\n+ if (GET_CODE (exp) == SET)\n+\tix86_update_stack_alignment_1 (exp, alignment);\n }\n-\n- return false;\n }\n \n /* Set stack_frame_required to false if stack frame isn't required.\n@@ -8871,103 +8771,38 @@ ix86_find_max_used_stack_alignment (unsigned int &stack_alignment,\n add_to_hard_reg_set (&set_up_by_prologue, Pmode,\n \t\t HARD_FRAME_POINTER_REGNUM);\n \n- bool require_stack_frame = false;\n+ cfun->machine->stack_frame_required = 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-\tif (NONDEBUG_INSN_P (insn)\n-\t && requires_stack_frame_p (insn, prologue_used,\n-\t\t\t\t set_up_by_prologue))\n+\tif (NONDEBUG_INSN_P (insn))\n \t {\n-\t require_stack_frame = true;\n-\t break;\n-\t }\n- }\n-\n- cfun->machine->stack_frame_required = require_stack_frame;\n-\n- /* Stop if we don't need to check stack slot. */\n- if (!check_stack_slot)\n- return;\n-\n- /* The preferred stack alignment is the minimum stack alignment. */\n- if (stack_alignment > crtl->preferred_stack_boundary)\n- stack_alignment = crtl->preferred_stack_boundary;\n-\n- HARD_REG_SET stack_slot_access;\n- CLEAR_HARD_REG_SET (stack_slot_access);\n-\n- /* Stack slot can be accessed by stack pointer, frame pointer or\n- registers defined by stack pointer or frame pointer. */\n- auto_bitmap worklist;\n-\n- add_to_hard_reg_set (&stack_slot_access, Pmode, STACK_POINTER_REGNUM);\n- bitmap_set_bit (worklist, STACK_POINTER_REGNUM);\n-\n- if (frame_pointer_needed)\n- {\n- add_to_hard_reg_set (&stack_slot_access, Pmode,\n-\t\t\t HARD_FRAME_POINTER_REGNUM);\n- bitmap_set_bit (worklist, HARD_FRAME_POINTER_REGNUM);\n- }\n-\n- /* Registers on HARD_STACK_SLOT_ACCESS always access stack. */\n- HARD_REG_SET hard_stack_slot_access = stack_slot_access;\n-\n- calculate_dominance_info (CDI_DOMINATORS);\n-\n- unsigned int regno;\n-\n- do\n- {\n- regno = bitmap_clear_first_set_bit (worklist);\n- ix86_find_all_reg_uses (stack_slot_access, regno, worklist);\n- }\n- while (!bitmap_empty_p (worklist));\n-\n- hard_reg_set_iterator hrsi;\n- stack_access_data data;\n-\n- auto_bitmap reg_dominate_bbs_known[FIRST_PSEUDO_REGISTER];\n- auto_bitmap reg_dominate_bbs[FIRST_PSEUDO_REGISTER];\n-\n- data.stack_alignment = &stack_alignment;\n-\n- EXECUTE_IF_SET_IN_HARD_REG_SET (stack_slot_access, 0, regno, hrsi)\n- {\n- for (df_ref ref = DF_REG_USE_CHAIN (regno);\n-\t ref != NULL;\n-\t ref = DF_REF_NEXT_REG (ref))\n-\t{\n-\t if (DF_REF_IS_ARTIFICIAL (ref))\n-\t continue;\n+\t if (!cfun->machine->stack_frame_required\n+\t\t&& requires_stack_frame_p (insn, prologue_used,\n+\t\t\t\t\t set_up_by_prologue))\n+\t {\n+\t\t/* Set stack_frame_required before calling\n+\t\t ix86_update_stack_alignment. */\n+\t\tcfun->machine->stack_frame_required = true;\n \n-\t rtx_insn *insn = DF_REF_INSN (ref);\n+\t\t/* Stop if we don't need to check stack slot. */\n+\t\tif (!check_stack_slot)\n+\t\t break;\n+\t }\n \n-\t if (!NONJUMP_INSN_P (insn))\n-\t continue;\n+\t if (!check_stack_slot || !NONJUMP_INSN_P (insn))\n+\t continue;\n \n-\t /* Call ix86_access_stack_p only if INSN needs alignment >\n-\t STACK_ALIGNMENT. */\n-\t if (ix86_need_alignment_p (insn, stack_alignment)\n-\t && (TEST_HARD_REG_BIT (hard_stack_slot_access, regno)\n-\t\t || ix86_access_stack_p (regno, BLOCK_FOR_INSN (insn),\n-\t\t\t\t\t set_up_by_prologue,\n-\t\t\t\t\t prologue_used,\n-\t\t\t\t\t reg_dominate_bbs_known,\n-\t\t\t\t\t reg_dominate_bbs)))\n-\t {\n-\t /* Update stack alignment if REGNO is used for stack\n-\t\t access. */\n-\t data.reg = DF_REF_REG (ref);\n-\t note_stores (insn, ix86_update_stack_alignment, &data);\n-\t }\n-\t}\n+\t ix86_update_stack_alignment (insn, stack_alignment);\n+\t }\n }\n-\n- free_dominance_info (CDI_DOMINATORS);\n }\n \n /* Finalize stack_realign_needed and frame_pointer_needed flags, which\ndiff --git a/gcc/function.cc b/gcc/function.cc\nindex 109821c16fc..dc08dc1d58a 100644\n--- a/gcc/function.cc\n+++ b/gcc/function.cc\n@@ -6091,6 +6091,9 @@ make_epilogue_seq (void)\n void\n thread_prologue_and_epilogue_insns (void)\n {\n+ /* We need alias. */\n+ init_alias_analysis ();\n+\n df_analyze ();\n \n /* Can't deal with multiple successors of the entry block at the\n@@ -6323,6 +6326,9 @@ thread_prologue_and_epilogue_insns (void)\n df_update_entry_block_defs ();\n df_update_exit_block_uses ();\n }\n+\n+ /* Clean up. */\n+ end_alias_analysis ();\n }\n \n /* Reposition the prologue-end and epilogue-begin notes after\ndiff --git a/gcc/rtl.h b/gcc/rtl.h\nindex eebcc18a4f1..d95cb8afb79 100644\n--- a/gcc/rtl.h\n+++ b/gcc/rtl.h\n@@ -4010,6 +4010,8 @@ extern struct target_rtl *this_target_rtl;\n (this_target_rtl->x_top_of_stack)\n #define mode_mem_attrs \\\n (this_target_rtl->x_mode_mem_attrs)\n+#define static_reg_base_value \\\n+ (this_target_rtl->x_static_reg_base_value)\n \n /* All references to certain hard regs, except those created\n by allocating pseudo regs into them (when that's possible),\n-- \n2.53.0\n\n", "prefixes": [ "v6" ] }