From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pg1-x532.google.com (mail-pg1-x532.google.com [IPv6:2607:f8b0:4864:20::532]) by sourceware.org (Postfix) with ESMTPS id 5B4EB384AB54 for ; Fri, 17 May 2024 08:23:56 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 5B4EB384AB54 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 5B4EB384AB54 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::532 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1715934240; cv=none; b=AFLXBDQ5B2rL327z12021uA9/g0ECCkmnWJBat05Nyd27OBlIkFvMXGfiU3llWPLCE09Vb354aAwSizYdMtJrPAWoDAQ9n5hgQyMGks8maQKADCm0SYOHoshpNk4o5g5DTS2+fBdsXhCm0uH9ISyDJ2PftOjVjDRHrBwau/9cA0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1715934240; c=relaxed/simple; bh=JYaFV5Ozq7SMcMXXrcZa4mw/OeLwWF+VxRL6sPOcZ04=; h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To; b=b40U4eYH7bF3a4NUVqTEONfnIccoPtrUP/n+j+Q0I+U6/+z7CQKfv/rEy25TX6Z7K6or5HLLtxVhplcf+RrIGeZpjuLWEhXv7RfHlTXALx1SG8bmNhPt/jPb85tA+6q+yGfaeI92+sMQJ/W2GtZTcVlOisypeHmXfBiNBMo5dXo= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-pg1-x532.google.com with SMTP id 41be03b00d2f7-5f80aa2d4a3so962665a12.0 for ; Fri, 17 May 2024 01:23:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vrull.eu; s=google; t=1715934235; x=1716539035; darn=gcc.gnu.org; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:from:to:cc:subject:date :message-id:reply-to; bh=GRM9LiR3uEPoVQpePYgv0gw/Jy7X7m8i+0EKVcrnDjQ=; b=NkIBIFYziCoxlXpS5do5IBBCLZQ8SwPZ3oGAEL402iu280JK+LvoDMSWlYdtautK5b mxElYlzwPT/AgcHNl0Uhh8y8grXQCEK9+/pxXTZ6yeqTuV97tjonV3vAM4yJ6YZ9rG6n sFEwrOewcHR0D9yN+Yg7uZP03w24ihZdYqk8OkHbpi/Xh1M+mGWZxwSXleqt9XTcm3L7 RsR58gx0tbm5mo7znuYyaKWWwT8sDSaaLdrfM398dV156aspaQzzxau+SCHU8Cw4nbvC Zgs5YHWCyMM5kQL2D9aGprUpcG3L+co/qLIn8I88a3Y/97v2Rz9lQ6bkullfmD2+1nex 3wrQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1715934235; x=1716539035; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GRM9LiR3uEPoVQpePYgv0gw/Jy7X7m8i+0EKVcrnDjQ=; b=hVGUboNUEwf9ZyCy9yslHtxQ4xmPs5MEoEs0LEYNnL2eNGHrPj/QbmtpXMgYD7c26B 6Lm5W+JgAfx97QzOrB1o2EJgNrw2uIOS/YlRA7c6+C8ccQaxakRZcOr7oecPaTpHq2f3 5LY2Yud/EMv6djJzKq951wZCpSvTiP4dpQeA2kI1m8pjTUfIP6hK1h+j1zheIvZo2/1k T8mpc5hltiM9ww/R4VHzr3vCr/dWvOo8B+wlwfkBMOXElgzk5JXzhvWc22wQvl+9jn8Q +QS/gzFl2cENSTxuBewJm1SkQLm4OiEWcSm3YQDQ/AqRcRmjRqjm1rN0ItnzKzyTHT7k aQJw== X-Gm-Message-State: AOJu0Yz3gmItCwceBatLi/jVfsjWa8MGFnfYc1XYJWgef5D9nWoiUWbf aexG6t7w1cl6l8DQly5EasnqSaHFYT2UWKseZPZbBb2odA+ETqbh2CAq+mOtix//K0jm95/upES 4joDDqqA0GdqNRANuj409gczBmNbOMPRSY1KotQ== X-Google-Smtp-Source: AGHT+IF0ewVB2xc3nffXsU2TtEXdkoISgc1OBFdCd9a149QtxAXy10GoRSpDltJFeu4EjQGDpJ3ejoTKrE/KOc/yzYE= X-Received: by 2002:a17:90a:6886:b0:2ae:6e16:da91 with SMTP id 98e67ed59e1d1-2b6cc97d217mr18643873a91.29.1715934235103; Fri, 17 May 2024 01:23:55 -0700 (PDT) MIME-Version: 1.0 References: <20240423103336.4024491-1-manolis.tsamis@vrull.eu> In-Reply-To: From: Manolis Tsamis Date: Fri, 17 May 2024 11:23:18 +0300 Message-ID: Subject: Re: [PATCH] MATCH: Maybe expand (T)(A + C1) * C2 and (T)(A + C1) * C2 + C3 [PR109393] To: Richard Biener Cc: gcc-patches@gcc.gnu.org, Richard Biener , Jiangning Liu , Philipp Tomsich , Andrew Pinski Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-9.5 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,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 List-Id: Hi Richard, While I was re-testing the latest version of this patch I noticed that it FAILs an AArch64 test, gcc.target/aarch64/subsp.c. With the patch we generate one instruction more: sbfiz x1, x1, 4, 32 stp x29, x30, [sp, -16]! add x1, x1, 16 mov x29, sp sub sp, sp, x1 mov x0, sp bl foo Instead of: stp x29, x30, [sp, -16]! add w1, w1, 1 mov x29, sp sub sp, sp, w1, sxtw 4 mov x0, sp bl foo I've looked at it but can't really find a way to solve the regression. Any thoughts on this? Thanks, Manolis On Thu, May 16, 2024 at 11:15=E2=80=AFAM Richard Biener wrote: > > On Tue, May 14, 2024 at 10:58=E2=80=AFAM Manolis Tsamis wrote: > > > > New patch with the requested changes can be found below. > > > > I don't know how much this affects SCEV, but I do believe that we > > should incorporate this change somehow. I've seen various cases of > > suboptimal address calculation codegen that boil down to this. > > This misses the ChangeLog (I assume it's unchanged) and indent > of the match.pd part is now off. > > Please fix that, the patch is OK with that change. > > Thanks, > Richard. > > > gcc/match.pd | 31 +++++++++++++++++++++++++++++++ > > gcc/testsuite/gcc.dg/pr109393.c | 16 ++++++++++++++++ > > 2 files changed, 47 insertions(+) > > create mode 100644 gcc/testsuite/gcc.dg/pr109393.c > > > > diff --git a/gcc/match.pd b/gcc/match.pd > > index 07e743ae464..1d642c205f0 100644 > > --- a/gcc/match.pd > > +++ b/gcc/match.pd > > @@ -3650,6 +3650,37 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) > > (plus (convert @0) (op @2 (convert @1)))))) > > #endif > > +/* ((T)(A + CST1)) * CST2 + CST3 > > + -> ((T)(A) * CST2) + ((T)CST1 * CST2 + CST3) > > + Where (A + CST1) doesn't need to have a single use. */ > > +#if GIMPLE > > + (for op (plus minus) > > + (simplify > > + (plus (mult:s (convert:s (op @0 INTEGER_CST@1)) INTEGER_CST@2) > > + INTEGER_CST@3) > > + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) > > + && INTEGRAL_TYPE_P (type) > > + && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (@0)) > > + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)) > > + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0)) > > + && TYPE_OVERFLOW_WRAPS (type)) > > + (op (mult (convert @0) @2) (plus (mult (convert @1) @2) @3))))) > > +#endif > > + > > +/* ((T)(A + CST1)) * CST2 -> ((T)(A) * CST2) + ((T)CST1 * CST2) */ > > +#if GIMPLE > > + (for op (plus minus) > > + (simplify > > + (mult (convert:s (op:s @0 INTEGER_CST@1)) INTEGER_CST@2) > > + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) > > + && INTEGRAL_TYPE_P (type) > > + && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (@0)) > > + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)) > > + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0)) > > + && TYPE_OVERFLOW_WRAPS (type)) > > + (op (mult (convert @0) @2) (mult (convert @1) @2))))) > > +#endif > > + > > /* (T)(A) +- (T)(B) -> (T)(A +- B) only when (A +- B) could be simplifi= ed > > to a simple value. */ > > (for op (plus minus) > > diff --git a/gcc/testsuite/gcc.dg/pr109393.c b/gcc/testsuite/gcc.dg/pr1= 09393.c > > new file mode 100644 > > index 00000000000..e9051273672 > > --- /dev/null > > +++ b/gcc/testsuite/gcc.dg/pr109393.c > > @@ -0,0 +1,16 @@ > > +/* PR tree-optimization/109393 */ > > +/* { dg-do compile } */ > > +/* { dg-options "-O2 -fdump-tree-optimized" } */ > > +/* { dg-final { scan-tree-dump-times "return 1;" 2 "optimized" } } */ > > + > > +int foo(int *a, int j) > > +{ > > + int k =3D j - 1; > > + return a[j - 1] =3D=3D a[k]; > > +} > > + > > +int bar(int *a, int j) > > +{ > > + int k =3D j - 1; > > + return (&a[j + 1] - 2) =3D=3D &a[k]; > > +} > > -- > > 2.44.0 > > > > > > On Tue, Apr 23, 2024 at 1:33=E2=80=AFPM Manolis Tsamis wrote: > > > > > > The original motivation for this pattern was that the following funct= ion does > > > not fold to 'return 1': > > > > > > int foo(int *a, int j) > > > { > > > int k =3D j - 1; > > > return a[j - 1] =3D=3D a[k]; > > > } > > > > > > The expression ((unsigned long) (X +- C1) * C2) appears frequently as= part of > > > address calculations (e.g. arrays). These patterns help fold and simp= lify more > > > expressions. > > > > > > PR tree-optimization/109393 > > > > > > gcc/ChangeLog: > > > > > > * match.pd: Add new patterns for ((T)(A +- CST1)) * CST2 and > > > ((T)(A +- CST1)) * CST2 + CST3. > > > > > > gcc/testsuite/ChangeLog: > > > > > > * gcc.dg/pr109393.c: New test. > > > > > > Signed-off-by: Manolis Tsamis > > > --- > > > > > > gcc/match.pd | 30 ++++++++++++++++++++++++++++++ > > > gcc/testsuite/gcc.dg/pr109393.c | 16 ++++++++++++++++ > > > 2 files changed, 46 insertions(+) > > > create mode 100644 gcc/testsuite/gcc.dg/pr109393.c > > > > > > diff --git a/gcc/match.pd b/gcc/match.pd > > > index d401e7503e6..13c828ba70d 100644 > > > --- a/gcc/match.pd > > > +++ b/gcc/match.pd > > > @@ -3650,6 +3650,36 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) > > > (plus (convert @0) (op @2 (convert @1)))))) > > > #endif > > > > > > +/* ((T)(A + CST1)) * CST2 + CST3 > > > + -> ((T)(A) * CST2) + ((T)CST1 * CST2 + CST3) > > > + Where (A + CST1) doesn't need to have a single use. */ > > > +#if GIMPLE > > > + (for op (plus minus) > > > + (simplify > > > + (plus (mult (convert:s (op @0 INTEGER_CST@1)) INTEGER_CST@2) INT= EGER_CST@3) > > > + (if (TREE_CODE (TREE_TYPE (@0)) =3D=3D INTEGER_TYPE > > > + && TREE_CODE (type) =3D=3D INTEGER_TYPE > > > + && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (@0)) > > > + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)) > > > + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0)) > > > + && TYPE_OVERFLOW_WRAPS (type)) > > > + (op (mult @2 (convert @0)) (plus (mult @2 (convert @1)) @3)))= )) > > > +#endif > > > + > > > +/* ((T)(A + CST1)) * CST2 -> ((T)(A) * CST2) + ((T)CST1 * CST2) */ > > > +#if GIMPLE > > > + (for op (plus minus) > > > + (simplify > > > + (mult (convert:s (op:s @0 INTEGER_CST@1)) INTEGER_CST@2) > > > + (if (TREE_CODE (TREE_TYPE (@0)) =3D=3D INTEGER_TYPE > > > + && TREE_CODE (type) =3D=3D INTEGER_TYPE > > > + && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (@0)) > > > + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)) > > > + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0)) > > > + && TYPE_OVERFLOW_WRAPS (type)) > > > + (op (mult @2 (convert @0)) (mult @2 (convert @1)))))) > > > +#endif > > > + > > > /* (T)(A) +- (T)(B) -> (T)(A +- B) only when (A +- B) could be simpl= ified > > > to a simple value. */ > > > (for op (plus minus) > > > diff --git a/gcc/testsuite/gcc.dg/pr109393.c b/gcc/testsuite/gcc.dg/p= r109393.c > > > new file mode 100644 > > > index 00000000000..e9051273672 > > > --- /dev/null > > > +++ b/gcc/testsuite/gcc.dg/pr109393.c > > > @@ -0,0 +1,16 @@ > > > +/* PR tree-optimization/109393 */ > > > +/* { dg-do compile } */ > > > +/* { dg-options "-O2 -fdump-tree-optimized" } */ > > > +/* { dg-final { scan-tree-dump-times "return 1;" 2 "optimized" } } *= / > > > + > > > +int foo(int *a, int j) > > > +{ > > > + int k =3D j - 1; > > > + return a[j - 1] =3D=3D a[k]; > > > +} > > > + > > > +int bar(int *a, int j) > > > +{ > > > + int k =3D j - 1; > > > + return (&a[j + 1] - 2) =3D=3D &a[k]; > > > +} > > > -- > > > 2.34.1 > > >