From patchwork Wed Jul 24 13:31:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Christoph_M=C3=BCllner?= X-Patchwork-Id: 1964278 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=vrull.eu header.i=@vrull.eu header.a=rsa-sha256 header.s=google header.b=j3haZ+0X; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WTZgd5hGcz1ybY for ; Wed, 24 Jul 2024 23:32:11 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id B8DD9385841C for ; Wed, 24 Jul 2024 13:32:09 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-wm1-x32b.google.com (mail-wm1-x32b.google.com [IPv6:2a00:1450:4864:20::32b]) by sourceware.org (Postfix) with ESMTPS id 22C113858D26 for ; Wed, 24 Jul 2024 13:31:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 22C113858D26 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=vrull.eu Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=vrull.eu ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 22C113858D26 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::32b ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1721827912; cv=none; b=UuPX1LOZG3ao5iSFuZ+I1D+p8F76PPPCRJt6i7RAzT6Qg8qQpA6xqUZTn+9Wzxl/xz+XdWibmlIUHJqky6vJflurilC3iEMAp7NKCKq/pD38iHcFT3gsbVzK9yqdMpYx/be3d3o3hhHs85ZxE795vzWJp72mP16frZccyv+iRAA= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1721827912; c=relaxed/simple; bh=+U4Uql152lIOdA4Eg2Y2w0yxLqtlE23+jNRBzQEZZmU=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=IS2U70ypHheYYE9BprtDaem8IqKxevl0E4QPlPFM5J2Dq1f2gfW1EpX03tuQ++sIkF+WBAsSH8EEV/GFzOwonXgEUOFX91Cp46yi8kqqNLXgPITwzOGLPAuWoSWBjExrDX9xP6rnidInxCvQV+1EZaOiS6XYcbRtGa4kUoYPbX8= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-wm1-x32b.google.com with SMTP id 5b1f17b1804b1-42797289c8bso51642875e9.0 for ; Wed, 24 Jul 2024 06:31:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vrull.eu; s=google; t=1721827907; x=1722432707; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=vJal/8skIf8eFo70FBY0fX+IZUiGvgom8oQkkIsElh0=; b=j3haZ+0XRv/1DLrmoIAawBoSWfknvEIh5Hb5gWVllGRUNVu6nOTqIwO0fpLi0cATor rt1r5dn+dawqj+NF1RaBTN6MeUoU5kIuxGd/7PKkF9NkmBtNqMPKkGYiksNe5cKBEd8Y GK/lTRIVD89FuokTGpEDds+89vMIzvu5cq8iODtsSRI4bTkOseyn2Xgx5DkDnIsN6vWb l2zOukdcgv2y6OlgiBMkFS2w3/tkiUg3vsvhl4tNZqwKba1xrU4AzdoU5ZpmfekVaBuW DuAxViGVGDmknk5pahr0wMIgn/o2T30rYvkpSGRhV8R+1lnd91hkqCW+ILwn6f8HlJFQ zFCA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1721827907; x=1722432707; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=vJal/8skIf8eFo70FBY0fX+IZUiGvgom8oQkkIsElh0=; b=o7NSpmpNukUTB7B0CS02j0p7JjycKSq/vBUTj+dDCYMmrmMDMWyGfJYfNWKVfVXYB/ pEEcwlFssvsGwz15AP+lse3Sk0cr8d0GJieAzshmNnGB7ptdKvaHRU5mH3UGb0ue21hB nNRWJD9LJIVmQA69V1n5+qjfWyPNiB68IZEDu/j1iCgOcy6KkFiRb2kwkBLelOtiEgIU kTTvDL2jggMbKRbQLTKaMkSAIjOf7543ngfiDeeh2oSaspOn838FdeUpxetO6Sn3d2Ih zr/WUaRt0Bg9X7fOq0sEEOykScTJ8/9fElGioW3raE6UGbohJfUhj0o04EKJIZuNRLy4 ELWA== X-Gm-Message-State: AOJu0YzpyMv5qPtUSHlF8oefa9V7mt+uPCiu1UhTewR8hxTeBNnyN20w fQd5vg04d38T7EVSF9a0fi0TLuIsDjC5nFrZcdFGYDNmL+ZiQHLozYYStb+ZMyFGDgErUTBdJeR EaG8= X-Google-Smtp-Source: AGHT+IHioD0yFEuZ+kzHxX2KqXTp8dyHrrQ4bxNwphUeRqcNsU89AzLbuT/upTIaFgVNP4U2cWSLeg== X-Received: by 2002:a05:600c:4f4f:b0:426:5c34:b19b with SMTP id 5b1f17b1804b1-427f9560500mr15471015e9.20.1721827906789; Wed, 24 Jul 2024 06:31:46 -0700 (PDT) Received: from antares.fritz.box (62-178-148-172.cable.dynamic.surfer.at. [62.178.148.172]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-427f937e85csm30954245e9.15.2024.07.24.06.31.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Jul 2024 06:31:46 -0700 (PDT) From: =?utf-8?q?Christoph_M=C3=BCllner?= To: gcc-patches@gcc.gnu.org, Kito Cheng , Jim Wilson , Palmer Dabbelt , Andrew Waterman , Philipp Tomsich , Jeff Law , Patrick O'Neill Cc: =?utf-8?q?Christoph_M=C3=BCllner?= Subject: [PATCH] RISC-V: xtheadmemidx: Disable pre/post-modify addressing if RVV is enabled Date: Wed, 24 Jul 2024 15:31:42 +0200 Message-ID: <20240724133143.3904766-1-christoph.muellner@vrull.eu> X-Mailer: git-send-email 2.45.2 MIME-Version: 1.0 X-Spam-Status: No, score=-11.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_MANYTO, KAM_SHORT, LIKELY_SPAM_BODY, RCVD_IN_DNSWL_NONE, SCC_5_SHORT_WORD_LINES, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.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~incoming=patchwork.ozlabs.org@gcc.gnu.org When enabling XTheadMemIdx, we enable the pre- and post-modify addressing modes in the RISC-V backend. Unfortunately, the auto_inc_dec pass will then attempt to utilize this feature regardless of the mode class (i.e. scalar or vector). The assumption seems to be, that an enabled addressing mode for scalar instructions will also be available for vector instructions. In case of XTheadMemIdx and RVV, this is ovbiously not the case. Still, auto_inc_dec (-O3) performs optimizations like the following: (insn 23 20 27 3 (set (mem:V4QI (reg:DI 136 [ ivtmp.13 ]) [0 MEM [(char *)_39]+0 S4 A32]) (reg:V4QI 168)) "gcc/testsuite/gcc.target/riscv/pr116033.c":12:27 3183 {*movv4qi} (nil)) (insn 40 39 41 3 (set (reg:DI 136 [ ivtmp.13 ]) (plus:DI (reg:DI 136 [ ivtmp.13 ]) (const_int 20 [0x14]))) 5 {adddi3} (nil)) ====> (insn 23 20 27 3 (set (mem:V4QI (post_modify:DI (reg:DI 136 [ ivtmp.13 ]) (plus:DI (reg:DI 136 [ ivtmp.13 ]) (const_int 20 [0x14]))) [0 MEM [(char *)_39]+0 S4 A32]) (reg:V4QI 168)) "gcc/testsuite/gcc.target/riscv/pr116033.c":12:27 3183 {*movv4qi} (expr_list:REG_INC (reg:DI 136 [ ivtmp.13 ]) (nil))) The resulting memory-store with post-modify addressing cannot be lowered to an existing instruction (see PR116033). At a lower optimization level (-O2) this is currently fine, but we can't rely on that. One solution would be to introduce a target hook to check if a certain type can be used for pre-/post-modify optimizations. However, it will be hard to justify such a hook, if only a single RISC-V vendor extension requires that. Therefore, this patch takes a more drastic approach and disables pre-/post-modify addressing if TARGET_VECTOR is set. This results in not emitting pre-/post-modify instructions from XTheadMemIdx if RVV is enabled. Note, that this is not an issue with XTheadVector, because we currently don't have auto-vectorization for that extension. To ensure this won't changed without being noticed, an additional test is added. PR target/116033 gcc/ChangeLog: * config/riscv/riscv.h (HAVE_POST_MODIFY_DISP): Disable for RVV. (HAVE_PRE_MODIFY_DISP): Likewise. gcc/testsuite/ChangeLog: * gcc.target/riscv/pr116033-1.c: New test. * gcc.target/riscv/pr116033-2.c: New test. * gcc.target/riscv/pr116033-3.c: New test. Signed-off-by: Christoph Müllner --- gcc/config/riscv/riscv.h | 6 ++-- gcc/testsuite/gcc.target/riscv/pr116033-1.c | 40 +++++++++++++++++++++ gcc/testsuite/gcc.target/riscv/pr116033-2.c | 40 +++++++++++++++++++++ gcc/testsuite/gcc.target/riscv/pr116033-3.c | 38 ++++++++++++++++++++ 4 files changed, 122 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/pr116033-1.c create mode 100644 gcc/testsuite/gcc.target/riscv/pr116033-2.c create mode 100644 gcc/testsuite/gcc.target/riscv/pr116033-3.c diff --git a/gcc/config/riscv/riscv.h b/gcc/config/riscv/riscv.h index 6f040011864..e5760294506 100644 --- a/gcc/config/riscv/riscv.h +++ b/gcc/config/riscv/riscv.h @@ -1254,8 +1254,10 @@ extern void riscv_remove_unneeded_save_restore_calls (void); e.g. RVVMF64BI vs RVVMF1BI on zvl512b, which is [1, 1] vs [64, 64]. */ #define MAX_POLY_VARIANT 64 -#define HAVE_POST_MODIFY_DISP TARGET_XTHEADMEMIDX -#define HAVE_PRE_MODIFY_DISP TARGET_XTHEADMEMIDX +#define HAVE_POST_MODIFY_DISP \ + (TARGET_XTHEADMEMIDX && (!TARGET_VECTOR || TARGET_XTHEADVECTOR)) +#define HAVE_PRE_MODIFY_DISP \ + (TARGET_XTHEADMEMIDX && (!TARGET_VECTOR || TARGET_XTHEADVECTOR)) /* Check TLS Descriptors mechanism is selected. */ #define TARGET_TLSDESC (riscv_tls_dialect == TLS_DESCRIPTORS) diff --git a/gcc/testsuite/gcc.target/riscv/pr116033-1.c b/gcc/testsuite/gcc.target/riscv/pr116033-1.c new file mode 100644 index 00000000000..8dcbe6cc2b8 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr116033-1.c @@ -0,0 +1,40 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-O1" "-O2" "-Og" "-Os" "-Oz" } } */ +/* { dg-options "-march=rv64gv_xtheadmemidx" { target { rv64 } } } */ +/* { dg-options "-march=rv32gv_xtheadmemidx" { target { rv32 } } } */ + +char arr_3[20][20]; +void init() +{ + for (int i_0 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_1) + arr_3[i_0][i_1] = i_1; +} + +long +lr_reg_imm_upd_char_1 (long *rs1, long rs2) +{ + /* Register+register addressing still works. */ + *rs1 = *rs1 + (rs2 << 1); + return *(char*)(*rs1); +} + +void +char_pre_dec_load_1 (char *p) +{ + /* Missed optimization for V+XTheadMemIdx. */ + extern void fchar1(char*, long); + p = p - 1; + char x = *p; + fchar1 (p, x); +} + +/* { dg-final { scan-assembler "vse8.v\tv\[0-9\]+,\[0-9\]+\\(\[a-x0-9\]+\\)" } } */ +/* { dg-final { scan-assembler-not "vse8.v\t\[a-x0-9\]+,\\(\[a-x0-9\]+\\),\[0-9\]+,\[0-9\]+" } } */ + +/* { dg-final { scan-assembler "th.lrbu\t" } } */ + +/* Missed optimization for V+XTheadMemIdx. */ +/* { dg-final { scan-assembler "th.lbuib\t" { xfail "*-*-*" } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/pr116033-2.c b/gcc/testsuite/gcc.target/riscv/pr116033-2.c new file mode 100644 index 00000000000..92e69c17e65 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr116033-2.c @@ -0,0 +1,40 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-O1" "-O3" "-Og" "-Os" "-Oz" } } */ +/* { dg-options "-march=rv64gv_xtheadmemidx" { target { rv64 } } } */ +/* { dg-options "-march=rv32gv_xtheadmemidx" { target { rv32 } } } */ + +char arr_3[20][20]; +void init() +{ + for (int i_0 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_1) + arr_3[i_0][i_1] = i_1; +} + +long +lr_reg_imm_upd_char_1 (long *rs1, long rs2) +{ + *rs1 = *rs1 + (rs2 << 1); + return *(char*)(*rs1); +} + +void +char_pre_dec_load_1 (char *p) +{ + /* Missed optimization for V+XTheadMemIdx. */ + extern void fchar1(char*, long); + p = p - 1; + char x = *p; + fchar1 (p, x); +} + +/* No auto-vectorization for XTheadVector. */ +/* { dg-final { scan-assembler "th.srb\t\[a-x0-9\]+,\[a-x0-9\]+,\[a-x0-9\]+,\[0-9\]+" } } */ +/* { dg-final { scan-assembler-not "vse8.v" } } */ + +/* { dg-final { scan-assembler "th.lrbu\t" } } */ + +/* Missed optimization for V+XTheadMemIdx. */ +/* { dg-final { scan-assembler "th.lbuib\t" { xfail "*-*-*" } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/pr116033-3.c b/gcc/testsuite/gcc.target/riscv/pr116033-3.c new file mode 100644 index 00000000000..cc89a6a0da5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr116033-3.c @@ -0,0 +1,38 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-O1" "-Og" "-Os" "-Oz" } } */ +/* { dg-options "-march=rv64g_xtheadvector_xtheadmemidx" { target { rv64 } } } */ +/* { dg-options "-march=rv32g_xtheadvector_xtheadmemidx" { target { rv32 } } } */ + +char arr_3[20][20]; +void init() +{ + for (int i_0 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_0 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_0) + for (int i_1 = 0; i_1 < 20; ++i_1) + arr_3[i_0][i_1] = i_1; +} + +long +lr_reg_imm_upd_char_1 (long *rs1, long rs2) +{ + *rs1 = *rs1 + (rs2 << 1); + return *(char*)(*rs1); +} + +void +char_pre_dec_load_1 (char *p) +{ + extern void fchar1(char*, long); + p = p - 1; + char x = *p; + fchar1 (p, x); +} + +/* No auto-vectorization for XTheadVector. */ +/* { dg-final { scan-assembler "th.srb\t\[a-x0-9\]+,\[a-x0-9\]+,\[a-x0-9\]+,\[0-9\]+" } } */ +/* { dg-final { scan-assembler-not "vse8.v" } } */ + +/* { dg-final { scan-assembler "th.lrbu\t" } } */ + +/* { dg-final { scan-assembler "th.lbuib\t" } } */