From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lj1-x232.google.com (mail-lj1-x232.google.com [IPv6:2a00:1450:4864:20::232]) by sourceware.org (Postfix) with ESMTPS id 2ACD63858C5E for ; Fri, 11 Aug 2023 09:51:43 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 2ACD63858C5E Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-lj1-x232.google.com with SMTP id 38308e7fff4ca-2b9ab1725bbso27709281fa.0 for ; Fri, 11 Aug 2023 02:51:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1691747501; x=1692352301; 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=el3/ijg6Cbzg2WvxjL/vi98PyQvT2JZ9ta71VLx8Ge4=; b=m9hOwEsI+FMWo2zn1rc8gEytB7K6aD96ffVhHqIXT0wpw1iySlyGKnlhioqrZcki4e Tsgwupm6NO0A5A88acsjifVBMwHfZZO41fmV0/Xsx6t1AMo2W4cka6+HlEdb6HP+RQgq Itx8CtBRq6luE9FZSEtLNIBAvQqNqiT1KFeSkuH9y5BIBjhxNkZ79UDD9iCK31rv6FR0 pCBSY+G7LLTvBQr0NLYDlxEf8qSmnTm6oq3zO/P1uOiMPEmWiPoofiqfz0HTLJYHwrul L20k4re/hjmr3WgWbGnn9c/H54Ejvvb0S/HV7YHL6g+41sTCmoOT5jrOhDMDtx4DZpGn kk8w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1691747501; x=1692352301; 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=el3/ijg6Cbzg2WvxjL/vi98PyQvT2JZ9ta71VLx8Ge4=; b=WvY7thexijsnDODA38T8FpS7K9+rTNhiv4GI2UEfUiIQoVPv3xzsBHPnFDq83bcAB4 i1cABJaWaJ1HEtwreUfyMeJmVWsbPr5ssrIn12jfwT8OSXJSL+7W3JpTbHHRxmhhqmoU wpUXNfuLvwGJtM1kUr8I5/irlx6VfqcoH1ExiaMwZSsBbauy7pkMbS0tjkLo6Xrgfwmy BJF5tkK4Gfm1m3eOWrNo5E5XH4bZPz+gGsnZNF3301orwLxmHyU5FjC/B4lkiLHxSvA/ jpVV6V3B9z6NmNHFg+8uZuqR579gQ/+tYhVZiy+BnVyOdvh/FmvjrJ6Hw7V3ERRls0Ep e/VA== X-Gm-Message-State: AOJu0Yy/qZT9CSMfaiXbpu//tiv0tDCWj12+bgi7z1VYSJck6bYI9CnW 70hxQrlnucrLdcYJtumaI5fd996c1gRBa4gnTiA= X-Google-Smtp-Source: AGHT+IEHzZKuBwnKPPu+Qi8Lvmn84ZBci3IroWlYEPgFCmi6+NuOby+tMRhMx/bC5Lx5W5WHZMk8fsE+LEwL68poudE= X-Received: by 2002:a05:651c:106:b0:2b6:df25:1ab0 with SMTP id a6-20020a05651c010600b002b6df251ab0mr1178280ljb.34.1691747501210; Fri, 11 Aug 2023 02:51:41 -0700 (PDT) MIME-Version: 1.0 References: <20230811091551.2758227-1-apinski@marvell.com> <20230811091551.2758227-2-apinski@marvell.com> In-Reply-To: <20230811091551.2758227-2-apinski@marvell.com> From: Richard Biener Date: Fri, 11 Aug 2023 11:51:29 +0200 Message-ID: Subject: Re: [PATCH 2/2] VR-VALUES: Rewrite test_for_singularity using range_op_handler To: Andrew Pinski , Andrew MacLeod , Aldy Hernandez Cc: gcc-patches@gcc.gnu.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-7.3 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,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: On Fri, Aug 11, 2023 at 11:17=E2=80=AFAM Andrew Pinski via Gcc-patches wrote: > > So it turns out there was a simplier way of starting to > improve VRP to start to fix PR 110131, PR 108360, and PR 108397. > That was rewrite test_for_singularity to use range_op_handler > and Value_Range. > > This patch implements that and > > OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions. I'm hoping Andrew/Aldy can have a look here. Richard. > gcc/ChangeLog: > > * vr-values.cc (test_for_singularity): Add edge argument > and rewrite using range_op_handler. > (simplify_compare_using_range_pairs): Use Value_Range > instead of value_range and update test_for_singularity call. > > gcc/testsuite/ChangeLog: > > * gcc.dg/tree-ssa/vrp124.c: New test. > * gcc.dg/tree-ssa/vrp125.c: New test. > --- > gcc/testsuite/gcc.dg/tree-ssa/vrp124.c | 44 +++++++++++++ > gcc/testsuite/gcc.dg/tree-ssa/vrp125.c | 44 +++++++++++++ > gcc/vr-values.cc | 91 ++++++++------------------ > 3 files changed, 114 insertions(+), 65 deletions(-) > create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp124.c > create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp125.c > > diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp124.c b/gcc/testsuite/gcc.d= g/tree-ssa/vrp124.c > new file mode 100644 > index 00000000000..6ccbda35d1b > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp124.c > @@ -0,0 +1,44 @@ > +/* { dg-do compile } */ > +/* { dg-options "-O2 -fdump-tree-optimized" } */ > + > +/* Should be optimized to a =3D=3D -100 */ > +int g(int a) > +{ > + if (a =3D=3D -100 || a >=3D 0) > + ; > + else > + return 0; > + return a < 0; > +} > + > +/* Should optimize to a =3D=3D 0 */ > +int f(int a) > +{ > + if (a =3D=3D 0 || a > 100) > + ; > + else > + return 0; > + return a < 50; > +} > + > +/* Should be optimized to a =3D=3D 0. */ > +int f2(int a) > +{ > + if (a =3D=3D 0 || a > 100) > + ; > + else > + return 0; > + return a < 100; > +} > + > +/* Should optimize to a =3D=3D 100 */ > +int f1(int a) > +{ > + if (a < 0 || a =3D=3D 100) > + ; > + else > + return 0; > + return a > 50; > +} > + > +/* { dg-final { scan-tree-dump-not "goto " "optimized" } } */ > diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp125.c b/gcc/testsuite/gcc.d= g/tree-ssa/vrp125.c > new file mode 100644 > index 00000000000..f6c2f8e35f1 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp125.c > @@ -0,0 +1,44 @@ > +/* { dg-do compile } */ > +/* { dg-options "-O2 -fdump-tree-optimized" } */ > + > +/* Should be optimized to a =3D=3D -100 */ > +int g(int a) > +{ > + if (a =3D=3D -100 || a =3D=3D -50 || a >=3D 0) > + ; > + else > + return 0; > + return a < -50; > +} > + > +/* Should optimize to a =3D=3D 0 */ > +int f(int a) > +{ > + if (a =3D=3D 0 || a =3D=3D 50 || a > 100) > + ; > + else > + return 0; > + return a < 50; > +} > + > +/* Should be optimized to a =3D=3D 0. */ > +int f2(int a) > +{ > + if (a =3D=3D 0 || a =3D=3D 50 || a > 100) > + ; > + else > + return 0; > + return a < 25; > +} > + > +/* Should optimize to a =3D=3D 100 */ > +int f1(int a) > +{ > + if (a < 0 || a =3D=3D 50 || a =3D=3D 100) > + ; > + else > + return 0; > + return a > 50; > +} > + > +/* { dg-final { scan-tree-dump-not "goto " "optimized" } } */ > diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc > index a4fddd62841..7004b0224bd 100644 > --- a/gcc/vr-values.cc > +++ b/gcc/vr-values.cc > @@ -907,66 +907,30 @@ simplify_using_ranges::simplify_bit_ops_using_range= s > a known value range VR. > > If there is one and only one value which will satisfy the > - conditional, then return that value. Else return NULL. > - > - If signed overflow must be undefined for the value to satisfy > - the conditional, then set *STRICT_OVERFLOW_P to true. */ > + conditional on the EDGE, then return that value. > + Else return NULL. */ > > static tree > test_for_singularity (enum tree_code cond_code, tree op0, > - tree op1, const value_range *vr) > + tree op1, Value_Range vr, bool edge) > { > - tree min =3D NULL; > - tree max =3D NULL; > - > - /* Extract minimum/maximum values which satisfy the conditional as it = was > - written. */ > - if (cond_code =3D=3D LE_EXPR || cond_code =3D=3D LT_EXPR) > + /* This is already a singularity. */ > + if (cond_code =3D=3D NE_EXPR || cond_code =3D=3D EQ_EXPR) > + return NULL; > + auto range_op =3D range_op_handler (cond_code); > + int_range<2> op1_range (TREE_TYPE (op0)); > + wide_int w =3D wi::to_wide (op1); > + op1_range.set (TREE_TYPE (op1), w, w); > + Value_Range vr1(TREE_TYPE (op0)); > + if (range_op.op1_range (vr1, TREE_TYPE (op0), > + edge ? range_true () : range_false (), > + op1_range)) > { > - min =3D TYPE_MIN_VALUE (TREE_TYPE (op0)); > - > - max =3D op1; > - if (cond_code =3D=3D LT_EXPR) > - { > - tree one =3D build_int_cst (TREE_TYPE (op0), 1); > - max =3D fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one); > - /* Signal to compare_values_warnv this expr doesn't overflow. = */ > - if (EXPR_P (max)) > - suppress_warning (max, OPT_Woverflow); > - } > - } > - else if (cond_code =3D=3D GE_EXPR || cond_code =3D=3D GT_EXPR) > - { > - max =3D TYPE_MAX_VALUE (TREE_TYPE (op0)); > - > - min =3D op1; > - if (cond_code =3D=3D GT_EXPR) > - { > - tree one =3D build_int_cst (TREE_TYPE (op0), 1); > - min =3D fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one); > - /* Signal to compare_values_warnv this expr doesn't overflow. = */ > - if (EXPR_P (min)) > - suppress_warning (min, OPT_Woverflow); > - } > - } > - > - /* Now refine the minimum and maximum values using any > - value range information we have for op0. */ > - if (min && max) > - { > - tree type =3D TREE_TYPE (op0); > - tree tmin =3D wide_int_to_tree (type, vr->lower_bound ()); > - tree tmax =3D wide_int_to_tree (type, vr->upper_bound ()); > - if (compare_values (tmin, min) =3D=3D 1) > - min =3D tmin; > - if (compare_values (tmax, max) =3D=3D -1) > - max =3D tmax; > - > - /* If the new min/max values have converged to a single value, > - then there is only one value which can satisfy the condition, > - return that value. */ > - if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min)= ) > - return min; > + vr.intersect (vr1); > + tree newop1; > + /* If the updated range is just a singleton, then we can just do a= comparison */ > + if (vr.singleton_p (&newop1)) > + return newop1; > } > return NULL; > } > @@ -1224,9 +1188,9 @@ simplify_using_ranges::simplify_compare_using_range= s_1 (tree_code &cond_code, tr > && cond_code !=3D EQ_EXPR > && TREE_CODE (op0) =3D=3D SSA_NAME > && INTEGRAL_TYPE_P (TREE_TYPE (op0)) > - && is_gimple_min_invariant (op1)) > + && TREE_CODE (op1) =3D=3D INTEGER_CST) > { > - value_range vr; > + Value_Range vr (TREE_TYPE (op0)); > > if (!query->range_of_expr (vr, op0, stmt)) > vr.set_undefined (); > @@ -1235,20 +1199,17 @@ simplify_using_ranges::simplify_compare_using_ran= ges_1 (tree_code &cond_code, tr > able to simplify this conditional. */ > if (!vr.undefined_p () && !vr.varying_p ()) > { > - tree new_tree =3D test_for_singularity (cond_code, op0, op1, &v= r); > + tree new_tree =3D test_for_singularity (cond_code, op0, op1, vr= , > + true); > if (new_tree) > { > cond_code =3D EQ_EXPR; > op1 =3D new_tree; > happened =3D true; > } > - > - /* Try again after inverting the condition. We only deal > - with integral types here, so no need to worry about > - issues with inverting FP comparisons. */ > - new_tree =3D test_for_singularity > - (invert_tree_comparison (cond_code, false), > - op0, op1, &vr); > + /* Try again after inverting the condition. */ > + new_tree =3D test_for_singularity (cond_code, op0, op1, vr, > + false); > if (new_tree) > { > cond_code =3D NE_EXPR; > -- > 2.31.1 >