From patchwork Thu Jan 8 19:19:16 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Robin Dapp X-Patchwork-Id: 127657 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from vm01.sourceware.org (localhost [127.0.0.1]) by sourceware.org (Postfix) with ESMTP id A01434BA2E1E for ; Thu, 8 Jan 2026 19:20:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A01434BA2E1E Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=M75Jb1lz X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ej1-f52.google.com (mail-ej1-f52.google.com [209.85.218.52]) by sourceware.org (Postfix) with ESMTPS id 80ED24BA2E05 for ; Thu, 8 Jan 2026 19:19:23 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 80ED24BA2E05 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 80ED24BA2E05 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=209.85.218.52 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1767899963; cv=none; b=CPdC5yAhaSHKyNideM8KRDLFuxQu/ZrWUsjcLNFQgrpWRLbMbwyo+fuwXoM2xtJXteYq1UsDL7eX42vsz30aycdZYZoHvJpam2S2POXR+L94cvZfr1W0LVnp1yaxQanbWPEaN72ktnQxMMEgnsbeKpHBQpZb4Y+YGroxFcmWKuw= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1767899963; c=relaxed/simple; bh=L5gJI3tZlR2AdA6XEESjJolZIUYVyK3183dWTZFa+V0=; h=DKIM-Signature:Mime-Version:Date:Message-Id:Subject:To:From; b=UIcFjCKp+MLKbk/m/3vNe7tr8vBoZcy1TfysOVH2dmrxaSJFycpUHAiA/5yLJA9/aOYzNEYqGn/0XqjHy7aDaJrABDq9s58NIrww0FJWU536WePiyy10GA5t/KR7aCfldXgnseASFQ6mH3R4mnccWSKyVs9FisivZGH6mAHD5ZA= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 80ED24BA2E05 Received: by mail-ej1-f52.google.com with SMTP id a640c23a62f3a-b7277324204so552055066b.0 for ; Thu, 08 Jan 2026 11:19:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1767899962; x=1768504762; darn=gcc.gnu.org; h=from:to:cc:subject:message-id:date:content-transfer-encoding :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=S5DC0Io7yyAumDoQfvrbMcqWCJfzq9qTIiW8WfINX+M=; b=M75Jb1lzN9xqEMenQk4E+FEqw+1EXfICGsnc+GU7AyNhQhUqs486UXBONPMJKMjghw Jx5wbPKFjEMF+DcPdtClwEuzjeN3STiH0rsoUcLB7uHV24azmEWsNMxwe0mpXSvZPTgD uLS57S2hha8E/r6/6UMkVRSMA2ewtGUyq9zo88ti2Tk7uxW3Bx8d6TrK5TZ/8VMRz+/1 WOHfrnbULYxVl9aZOjOfN7fQGMhMW7h5HlOUP+cn0PqrvUZUGKUjxnfQ4RfUP0ySzqMl a47noHLd8w3NCamGhICSlqm8/hVmjkpuaffVm2uBd3FMbx42OyV4HjngT12EFx4ClXiA LL6A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1767899962; x=1768504762; h=from:to:cc:subject:message-id:date:content-transfer-encoding :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=S5DC0Io7yyAumDoQfvrbMcqWCJfzq9qTIiW8WfINX+M=; b=nxwBW6pcmVYR/77U7cbvSrFFKfSYDnhGceXZJGLhmKb+wLUER8+XXp25qlh3aIEeI8 tPMNqR669y1Ak7gwQ99fv5GY/p3CZr0MdzJWoFZcWpIl/8BZa4qltYo0JcH69+uREV7M r4Jtqk5PJ4t4WQe123dQYuM2y6PveCrSiODgy/4L/0dMRUhKb0VFaYIJl0oChdDtk/fS 9pxfCiS7WuHSXr9z4I8rKwAfsJnILgIPu1Yy+VGwJi8pYRiAS6Buk2xI3SYn1pZpLpjL RAcCTd8lzRi4TkTLJ2601VogZtYDb1cJagbv39EIilvVLKC6gN3Qmd6lu3FzR48oFB7t emOQ== X-Gm-Message-State: AOJu0YyX1l80ciIS0YYvcZhorrUs/7xr04oRh8f6OQyfhIcw1nPa4GQP nqnUDis6timVaRR4T5FiVvXuwfq2y6YqCyp6G+EwWzrYozN32h/u5b0kyMYIWg== X-Gm-Gg: AY/fxX5mfndIlNihxIwoinZldKnnKnyf0+kKbozhMJv7vx+CUmeW2gIUuJqCCCkC7IU bbDP7SFEWu1ZuXjaBUYlzgRMTvXoKGm8ymMhDPv0NePvwBHfeoiJO9E4SM0ebXtkeYnDwSx4iQF ZwBegFhIIk+XTB2ny3VMUt59OzOU8Br/jEZvi6BHEwGl79yrBW9JRGQR7wiNfc8eekdUEfREN6+ nijpta6Z3y/weDW17ctKml0KgQ18l+9cuDNm5GjB2VL40fdEaCuqCHWJAOrjda96Zsnbmkc1qsj iMuBpU2/r0jEu9sJ2txf1T/wAZLwG11LmJD3ws09A79wrLViWbxhW/qo3tVGWQflegIemxIwQe2 4DXC/YsmR8YTQtC8bjPeE/uiOr1rNws/UoG6hHB3MVqRpEovp1lw0UDzRBp/y6vm+dNIub4ds51 FMqkXS2pDOj6LMg3Z5NdtjzpTnET8teMCyImqDc6dKbuszYgm3GR/SynEIB1fMCbGBD8YHTAQ= X-Google-Smtp-Source: AGHT+IGgHzIWgY691erzNPTO5T0kZpApl+Wo+gTpgOnwAaJ3vJRCTmSxatkWgtCgI61YUELickHkhw== X-Received: by 2002:a17:907:970e:b0:b7c:eb19:2094 with SMTP id a640c23a62f3a-b844540a4e2mr705213766b.48.1767899957292; Thu, 08 Jan 2026 11:19:17 -0800 (PST) Received: from localhost (ip-149-172-150-237.um42.pools.vodafone-ip.de. [149.172.150.237]) by smtp.gmail.com with ESMTPSA id a640c23a62f3a-b842a2340a2sm899012366b.5.2026.01.08.11.19.16 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 08 Jan 2026 11:19:16 -0800 (PST) Mime-Version: 1.0 Date: Thu, 08 Jan 2026 20:19:16 +0100 Message-Id: Subject: [PATCH] forwprop: Check mask for type overflow [PR123414]. Cc: "Robin Dapp" To: "gcc-patches" From: "Robin Dapp" X-Spam-Status: No, score=-9.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, RCVD_IN_VALIDITY_RPBL_BLOCKED, RCVD_IN_VALIDITY_SAFE_BLOCKED, SPF_HELO_NONE, SPF_PASS, TXREP, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~patchwork=sourceware.org@gcc.gnu.org Hi, RVV's vectors can get very large with LMUL8. In the PR we have 256-element char vectors which get permuted. For permuting them we use a mask vectype that is deduced from the element type without checking if the permute indices fit this type. That leads to an invalid permute mask which gets optimized away. This patch punts if the permute index might overflow the mask type. Bootstrapped and regtested on x86, power10, and aarch64. Regtested on riscv64. Regards Robin PR tree-optimization/123414 gcc/ChangeLog: * tree-ssa-forwprop.cc (simplify_vector_constructor): Give up if the permute index might overflow the mask type. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/pr123414.c: New test. --- .../gcc.target/riscv/rvv/autovec/pr123414.c | 31 +++++++++++++++++++ gcc/tree-ssa-forwprop.cc | 13 ++++++-- 2 files changed, 41 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123414.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123414.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123414.c new file mode 100644 index 00000000000..a28ce23f058 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr123414.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvl256b -mrvv-max-lmul=m8 -O3 -fsigned-char -fno-strict-aliasing -fwrapv -fdump-tree-optimized -std=gnu99" } */ + +signed char a=2; +long long b; +long c = 93; +int e[1][9]; + +void +g (long cc, int ee[][9]) +{ + for (int i = 0; i < 4; i++) + for (int j = 0; j < 5; j++) + for (unsigned k = 0; k < 9; k++) + { + a *= cc; + for (int l = 0; l < 6; l += (ee[k] <= 0) + 2) + ; + } +} + +int main() { + g( c, e); + b = (int)a; + if (b != 34) + __builtin_abort (); +} + +/* We should have four vector constructors that must not get optimized away. + */ +/* { dg-final { scan-tree-dump-times "\[a-zA-Z_\]\[a-zA-Z0-9_\]+.=.\\\{\[a-zA-Z0-9._\]+, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1," 4 "optimized" } } */ diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc index d00f7b9004e..9435e4dc409 100644 --- a/gcc/tree-ssa-forwprop.cc +++ b/gcc/tree-ssa-forwprop.cc @@ -4177,9 +4177,16 @@ simplify_vector_constructor (gimple_stmt_iterator *gsi) machine_mode vmode = TYPE_MODE (perm_type); if (!can_vec_perm_const_p (vmode, vmode, indices)) return false; - mask_type - = build_vector_type (build_nonstandard_integer_type (elem_size, 1), - refnelts); + /* With an ELEM_SIZEd integer we can shuffle at most + (1 << ELEM_SIZE) / 2 - 1 elements. For a more fine-grained + check we could take the maximum of the element values + but for now this is sufficient. */ + if (refnelts < (HOST_WIDE_INT_1U << (elem_size - 1))) + mask_type + = build_vector_type (build_nonstandard_integer_type (elem_size, 1), + refnelts); + else + return false; if (GET_MODE_CLASS (TYPE_MODE (mask_type)) != MODE_VECTOR_INT || maybe_ne (GET_MODE_SIZE (TYPE_MODE (mask_type)), GET_MODE_SIZE (TYPE_MODE (perm_type))))