From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x12b.google.com (mail-lf1-x12b.google.com [IPv6:2a00:1450:4864:20::12b]) by sourceware.org (Postfix) with ESMTPS id 7B6E7384F6D2 for ; Wed, 23 Nov 2022 20:27:59 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 7B6E7384F6D2 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-lf1-x12b.google.com with SMTP id s8so29818520lfc.8 for ; Wed, 23 Nov 2022 12:27:59 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=coZe4e+5cIwaHrd4GaFGXtjj7KTSGH4owji21opa5Do=; b=fO5E/ApzxK0PylmcN6CogCuSapPudUauEpTqP8tNNL8qzLKKdBWBU4I75YtFDalo7Q R2cqgjKxN09SyZ9Jv0zah99/KDKe+vRado2Ni/KD6lmDktWxlYbJjyok35nYhF/4N3YD vU7f+ZwobNCXcCTr6U7tOuug3qAOYP5Q1DnKbu2gIWVZmPkzYGDJw6OzF3jEw5QuDq3N YBosS44nNepTuFXDz29tEh6W2FVH1T7jCwfew7UZJRNPc6QT5hC2yE9LiBYajbZeLVQD tBwsKMjddmiUhcm1S1A6gaZKslTf4v1CwiB6l5k8QwV43GXlJMz9tnT0DQaYXq7ZoWgm YMhw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=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=coZe4e+5cIwaHrd4GaFGXtjj7KTSGH4owji21opa5Do=; b=AOAZnxvMC6QibFP/JxAKCSbQXSv9FUJi7W+k41DHo5C8hNoI++P8c17qCYx73Py7RD NbFmzS6AEgPcFDNJ77m7RLEA+cJopUQndWI+stV/nTGUQyg8pt4tDqjkorMAXFI/bFoc Hml0sXrmK0SJGyS/MKfQ3yDHGpsHrwz9R7NnKc9Y1DZyeQY0jf1Gw967QRxIkFsUO9Aa cpL5fbdeRRO4cJnToYjZs37Pf/PdGLZFFrJcc4sTy/5ftZ8xIrL6IcG83yv4EoLpMfzn QLYEQ62sNqr5B3qnSU6vvpf5iBbtiP8/Nr4QmFS5ga47YirSEoR4CERjzmeDWi2CQE8b IZ6g== X-Gm-Message-State: ANoB5pk4w2vpxm9mIao0Y5cEKjE2/CO90oKWGaomNbJQIVmQ4iZhOOxj DrTMDgtxeXxM0C/G5K9SUCcQnFIPkGhNRa7jY5s= X-Google-Smtp-Source: AA0mqf4AWHdklNivgjaA41kdhPQX2zHFMU9Z0ukvVHQVATj7q344KGw33yTonWYcnr8M+Ppm3OtdIXGDGKnI8dgVb2U= X-Received: by 2002:a19:7111:0:b0:499:b4b3:2f68 with SMTP id m17-20020a197111000000b00499b4b32f68mr3596173lfc.203.1669235277655; Wed, 23 Nov 2022 12:27:57 -0800 (PST) MIME-Version: 1.0 References: <20221122135801.1945438-1-aldyh@redhat.com> In-Reply-To: <20221122135801.1945438-1-aldyh@redhat.com> From: Richard Biener Date: Wed, 23 Nov 2022 21:27:45 +0100 Message-ID: Subject: Re: [PATCH] Remove ASSERT_EXPR. To: Aldy Hernandez Cc: GCC patches , Andrew MacLeod Content-Type: text/plain; charset="UTF-8" X-Spam-Status: No, score=-7.1 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 Tue, Nov 22, 2022 at 2:58 PM Aldy Hernandez wrote: > > This removes all uses of ASSERT_EXPR except the internal one in ipa-*. > > OK pending tests? OK. > gcc/ChangeLog: > > * doc/gimple.texi: Remove ASSERT_EXPR references. > * fold-const.cc (tree_expr_nonzero_warnv_p): Same. > (fold_binary_loc): Same. > (tree_expr_nonnegative_warnv_p): Same. > * gimple-array-bounds.cc (get_base_decl): Same. > * gimple-pretty-print.cc (dump_unary_rhs): Same. > * gimple.cc (get_gimple_rhs_num_ops): Same. > * pointer-query.cc (handle_ssa_name): Same. > * tree-cfg.cc (verify_gimple_assign_single): Same. > * tree-pretty-print.cc (dump_generic_node): Same. > * tree-scalar-evolution.cc (scev_dfs::follow_ssa_edge_expr):Same. > (interpret_rhs_expr): Same. > * tree-ssa-operands.cc (operands_scanner::get_expr_operands): Same. > * tree-ssa-propagate.cc > (substitute_and_fold_dom_walker::before_dom_children): Same. > * tree-ssa-threadedge.cc: Same. > * tree-vrp.cc (overflow_comparison_p): Same. > * tree.def (ASSERT_EXPR): Add note. > * tree.h (ASSERT_EXPR_VAR): Remove. > (ASSERT_EXPR_COND): Remove. > * vr-values.cc (simplify_using_ranges::vrp_visit_cond_stmt): > Remove comment. > --- > gcc/doc/gimple.texi | 3 +-- > gcc/fold-const.cc | 6 ----- > gcc/gimple-array-bounds.cc | 9 +------- > gcc/gimple-pretty-print.cc | 1 - > gcc/gimple.cc | 1 - > gcc/pointer-query.cc | 6 ----- > gcc/tree-cfg.cc | 11 --------- > gcc/tree-pretty-print.cc | 8 ------- > gcc/tree-scalar-evolution.cc | 15 ------------- > gcc/tree-ssa-operands.cc | 1 - > gcc/tree-ssa-propagate.cc | 5 +---- > gcc/tree-ssa-threadedge.cc | 6 ++--- > gcc/tree-vrp.cc | 7 +++--- > gcc/tree.def | 5 ++++- > gcc/tree.h | 4 ---- > gcc/vr-values.cc | 43 ------------------------------------ > 16 files changed, 13 insertions(+), 118 deletions(-) > > diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi > index 7832fa6ff90..a4263922887 100644 > --- a/gcc/doc/gimple.texi > +++ b/gcc/doc/gimple.texi > @@ -682,8 +682,7 @@ more than two slots on the RHS. For instance, a @code{COND_EXPR} > expression of the form @code{(a op b) ? x : y} could be flattened > out on the operand vector using 4 slots, but it would also > require additional processing to distinguish @code{c = a op b} > -from @code{c = a op b ? x : y}. Something similar occurs with > -@code{ASSERT_EXPR}. In time, these special case tree > +from @code{c = a op b ? x : y}. In time, these special case tree > expressions should be flattened into the operand vector. > @end itemize > > diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc > index b89cac91cae..114258fa182 100644 > --- a/gcc/fold-const.cc > +++ b/gcc/fold-const.cc > @@ -10751,7 +10751,6 @@ tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p) > case COND_EXPR: > case CONSTRUCTOR: > case OBJ_TYPE_REF: > - case ASSERT_EXPR: > case ADDR_EXPR: > case WITH_SIZE_EXPR: > case SSA_NAME: > @@ -12618,10 +12617,6 @@ fold_binary_loc (location_t loc, enum tree_code code, tree type, > : fold_convert_loc (loc, type, arg1); > return tem; > > - case ASSERT_EXPR: > - /* An ASSERT_EXPR should never be passed to fold_binary. */ > - gcc_unreachable (); > - > default: > return NULL_TREE; > } /* switch (code) */ > @@ -15117,7 +15112,6 @@ tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth) > case COND_EXPR: > case CONSTRUCTOR: > case OBJ_TYPE_REF: > - case ASSERT_EXPR: > case ADDR_EXPR: > case WITH_SIZE_EXPR: > case SSA_NAME: > diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc > index 1eafd3fd3e1..eae49ab3910 100644 > --- a/gcc/gimple-array-bounds.cc > +++ b/gcc/gimple-array-bounds.cc > @@ -75,14 +75,7 @@ get_base_decl (tree ref) > if (gimple_assign_single_p (def)) > { > base = gimple_assign_rhs1 (def); > - if (TREE_CODE (base) != ASSERT_EXPR) > - return base; > - > - base = TREE_OPERAND (base, 0); > - if (TREE_CODE (base) != SSA_NAME) > - return base; > - > - continue; > + return base; > } > > if (!gimple_nop_p (def)) > diff --git a/gcc/gimple-pretty-print.cc b/gcc/gimple-pretty-print.cc > index 7ec079f15c6..af704257633 100644 > --- a/gcc/gimple-pretty-print.cc > +++ b/gcc/gimple-pretty-print.cc > @@ -339,7 +339,6 @@ dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc, > switch (rhs_code) > { > case VIEW_CONVERT_EXPR: > - case ASSERT_EXPR: > dump_generic_node (buffer, rhs, spc, flags, false); > break; > > diff --git a/gcc/gimple.cc b/gcc/gimple.cc > index 6c23dd77609..dd054e16453 100644 > --- a/gcc/gimple.cc > +++ b/gcc/gimple.cc > @@ -2408,7 +2408,6 @@ get_gimple_rhs_num_ops (enum tree_code code) > || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \ > : ((SYM) == CONSTRUCTOR \ > || (SYM) == OBJ_TYPE_REF \ > - || (SYM) == ASSERT_EXPR \ > || (SYM) == ADDR_EXPR \ > || (SYM) == WITH_SIZE_EXPR \ > || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \ > diff --git a/gcc/pointer-query.cc b/gcc/pointer-query.cc > index 0f0100233c1..95565fd6005 100644 > --- a/gcc/pointer-query.cc > +++ b/gcc/pointer-query.cc > @@ -2144,12 +2144,6 @@ handle_ssa_name (tree ptr, bool addr, int ostype, > > tree rhs = gimple_assign_rhs1 (stmt); > > - if (code == ASSERT_EXPR) > - { > - rhs = TREE_OPERAND (rhs, 0); > - return compute_objsize_r (rhs, stmt, addr, ostype, pref, snlim, qry); > - } > - > if (code == POINTER_PLUS_EXPR > && TREE_CODE (TREE_TYPE (rhs)) == POINTER_TYPE) > { > diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc > index d982988048f..28175312afc 100644 > --- a/gcc/tree-cfg.cc > +++ b/gcc/tree-cfg.cc > @@ -4795,17 +4795,6 @@ verify_gimple_assign_single (gassign *stmt) > } > return res; > > - case ASSERT_EXPR: > - /* FIXME. */ > - rhs1 = fold (ASSERT_EXPR_COND (rhs1)); > - if (rhs1 == boolean_false_node) > - { > - error ("%qs with an always-false condition", code_name); > - debug_generic_stmt (rhs1); > - return true; > - } > - break; > - > case WITH_SIZE_EXPR: > error ("%qs RHS in assignment statement", > get_tree_code_name (rhs_code)); > diff --git a/gcc/tree-pretty-print.cc b/gcc/tree-pretty-print.cc > index e7a8c9481a6..cb2a88cbdc5 100644 > --- a/gcc/tree-pretty-print.cc > +++ b/gcc/tree-pretty-print.cc > @@ -3416,14 +3416,6 @@ dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags, > pp_greater (pp); > break; > > - case ASSERT_EXPR: > - pp_string (pp, "ASSERT_EXPR <"); > - dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false); > - pp_string (pp, ", "); > - dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false); > - pp_greater (pp); > - break; > - > case SCEV_KNOWN: > pp_string (pp, "scev_known"); > break; > diff --git a/gcc/tree-scalar-evolution.cc b/gcc/tree-scalar-evolution.cc > index 7e2a3e98661..60060337804 100644 > --- a/gcc/tree-scalar-evolution.cc > +++ b/gcc/tree-scalar-evolution.cc > @@ -1122,13 +1122,11 @@ scev_dfs::follow_ssa_edge_expr (gimple *at_stmt, tree expr, > - a PLUS_EXPR, > - a POINTER_PLUS_EXPR, > - a MINUS_EXPR, > - - an ASSERT_EXPR, > - other cases are not yet handled. */ > > /* For SSA_NAME look at the definition statement, handling > PHI nodes and otherwise expand appropriately for the expression > handling below. */ > -tail_recurse: > if (TREE_CODE (expr) == SSA_NAME) > { > gimple *def = SSA_NAME_DEF_STMT (expr); > @@ -1272,12 +1270,6 @@ tail_recurse: > return follow_ssa_edge_binary (at_stmt, type, rhs0, code, rhs1, > evolution_of_loop, limit); > > - case ASSERT_EXPR: > - /* This assignment is of the form: "a_1 = ASSERT_EXPR " > - It must be handled as a copy assignment of the form a_1 = a_2. */ > - expr = ASSERT_EXPR_VAR (rhs0); > - goto tail_recurse; > - > default: > return t_false; > } > @@ -1640,13 +1632,6 @@ interpret_rhs_expr (class loop *loop, gimple *at_stmt, > if (code == SSA_NAME) > return chrec_convert (type, analyze_scalar_evolution (loop, rhs1), > at_stmt); > - > - if (code == ASSERT_EXPR) > - { > - rhs1 = ASSERT_EXPR_VAR (rhs1); > - return chrec_convert (type, analyze_scalar_evolution (loop, rhs1), > - at_stmt); > - } > } > > switch (code) > diff --git a/gcc/tree-ssa-operands.cc b/gcc/tree-ssa-operands.cc > index 9e85998b75e..4c90197860c 100644 > --- a/gcc/tree-ssa-operands.cc > +++ b/gcc/tree-ssa-operands.cc > @@ -897,7 +897,6 @@ operands_scanner::get_expr_operands (tree *expr_p, int flags) > case BIT_INSERT_EXPR: > case COMPOUND_EXPR: > case OBJ_TYPE_REF: > - case ASSERT_EXPR: > do_binary: > { > get_expr_operands (&TREE_OPERAND (expr, 0), flags); > diff --git a/gcc/tree-ssa-propagate.cc b/gcc/tree-ssa-propagate.cc > index 9dc4bfd85bf..6660d4f7cf1 100644 > --- a/gcc/tree-ssa-propagate.cc > +++ b/gcc/tree-ssa-propagate.cc > @@ -818,10 +818,7 @@ substitute_and_fold_dom_walker::before_dom_children (basic_block bb) > && sprime != lhs > && may_propagate_copy (lhs, sprime) > && !stmt_could_throw_p (cfun, stmt) > - && !gimple_has_side_effects (stmt) > - /* We have to leave ASSERT_EXPRs around for jump-threading. */ > - && (!is_gimple_assign (stmt) > - || gimple_assign_rhs_code (stmt) != ASSERT_EXPR)) > + && !gimple_has_side_effects (stmt)) > { > if (dump_file && (dump_flags & TDF_DETAILS)) > { > diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc > index 905a98c8c68..cc7020ddbb3 100644 > --- a/gcc/tree-ssa-threadedge.cc > +++ b/gcc/tree-ssa-threadedge.cc > @@ -497,9 +497,9 @@ jump_threader::simplify_control_stmt_condition_1 > } > > /* If the condition has the form (A & B) CMP 0 or (A | B) CMP 0 then > - recurse into the LHS to see if there is a dominating ASSERT_EXPR > - of A or of B that makes this condition always true or always false > - along the edge E. */ > + recurse into the LHS to see if there is a simplification that > + makes this condition always true or always false along the edge > + E. */ > if ((cond_code == EQ_EXPR || cond_code == NE_EXPR) > && TREE_CODE (op0) == SSA_NAME > && integer_zerop (op1)) > diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc > index df2f1eae203..d29941d0f2d 100644 > --- a/gcc/tree-vrp.cc > +++ b/gcc/tree-vrp.cc > @@ -782,10 +782,9 @@ overflow_comparison_p (tree_code code, tree name, tree val, > : > __builtin_unreachable (); > : > - x_5 = ASSERT_EXPR ; > - If x_3 has no other immediate uses (checked by caller), > - var is the x_3 var from ASSERT_EXPR, we can clear low 5 bits > - from the non-zero bitmask. */ > + > + If x_3 has no other immediate uses (checked by caller), var is the > + x_3 var, we can clear low 5 bits from the non-zero bitmask. */ > > void > maybe_set_nonzero_bits (edge e, tree var) > diff --git a/gcc/tree.def b/gcc/tree.def > index 62650b6934b..69783bd44fc 100644 > --- a/gcc/tree.def > +++ b/gcc/tree.def > @@ -1025,7 +1025,10 @@ DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", tcc_expression, 2) > Use the interface in tree-iterator.h to access this node. */ > DEFTREECODE (STATEMENT_LIST, "statement_list", tcc_exceptional, 0) > > -/* Predicate assertion. Artificial expression generated by the optimizers > +/* NOTE: This code is deprecated and should only be used internally by ipa* as > + temporary construct. > + > + Predicate assertion. Artificial expression generated by the optimizers > to keep track of predicate values. This expression may only appear on > the RHS of assignments. > > diff --git a/gcc/tree.h b/gcc/tree.h > index a863d2e50e5..4a19de1c94d 100644 > --- a/gcc/tree.h > +++ b/gcc/tree.h > @@ -1406,10 +1406,6 @@ class auto_suppress_location_wrappers > #define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1) > #define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2) > > -/* ASSERT_EXPR accessors. */ > -#define ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0) > -#define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1) > - > /* CALL_EXPR accessors. */ > #define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1) > #define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2) > diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc > index 798bfdc904a..0347c29b216 100644 > --- a/gcc/vr-values.cc > +++ b/gcc/vr-values.cc > @@ -944,49 +944,6 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p) > fprintf (dump_file, "\n"); > } > > - /* Compute the value of the predicate COND by checking the known > - ranges of each of its operands. > - > - Note that we cannot evaluate all the equivalent ranges here > - because those ranges may not yet be final and with the current > - propagation strategy, we cannot determine when the value ranges > - of the names in the equivalence set have changed. > - > - For instance, given the following code fragment > - > - i_5 = PHI <8, i_13> > - ... > - i_14 = ASSERT_EXPR > - if (i_14 == 1) > - ... > - > - Assume that on the first visit to i_14, i_5 has the temporary > - range [8, 8] because the second argument to the PHI function is > - not yet executable. We derive the range ~[0, 0] for i_14 and the > - equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for > - the first time, since i_14 is equivalent to the range [8, 8], we > - determine that the predicate is always false. > - > - On the next round of propagation, i_13 is determined to be > - VARYING, which causes i_5 to drop down to VARYING. So, another > - visit to i_14 is scheduled. In this second visit, we compute the > - exact same range and equivalence set for i_14, namely ~[0, 0] and > - { i_5 }. But we did not have the previous range for i_5 > - registered, so vrp_visit_assignment thinks that the range for > - i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)' > - is not visited again, which stops propagation from visiting > - statements in the THEN clause of that if(). > - > - To properly fix this we would need to keep the previous range > - value for the names in the equivalence set. This way we would've > - discovered that from one visit to the other i_5 changed from > - range [8, 8] to VR_VARYING. > - > - However, fixing this apparent limitation may not be worth the > - additional checking. Testing on several code bases (GCC, DLV, > - MICO, TRAMP3D and SPEC2000) showed that doing this results in > - 4 more predicates folded in SPEC. */ > - > bool sop; > val = vrp_evaluate_conditional_warnv_with_ops (stmt, > gimple_cond_code (stmt), > -- > 2.38.1 >