From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x12e.google.com (mail-lf1-x12e.google.com [IPv6:2a00:1450:4864:20::12e]) by sourceware.org (Postfix) with ESMTPS id B2E533858C56 for ; Tue, 30 Jul 2024 10:32:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org B2E533858C56 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 B2E533858C56 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::12e ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722335527; cv=none; b=c1yj16unxXz/T/m3rZi6gnx32pLiesFi7I55/mKSzdt1+ln+P84xVeoDbsipGRawXEtvz6OK9gUCV3eJ3LVCu6R/RBT7S/E/4uunTu0laSMMYBQdYLuQG4E6tCadDS3LrDudxsbPjfhK19RKwUwekxTbbELuHH1kpps5mnGNPgU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722335527; c=relaxed/simple; bh=gt+BDd7V+w83rnxFxbxydeBosSykoLQNOGE1f5V3WI0=; h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To; b=g5ZJ9R4BYqpF1aXQV0BKYWxeJTZcO08+Ye3lz+01ZwCTIFtPwjzVIy8zl9Jtt2THs3qwXZBqaz6N/pkNKLZrWG1UmkOTpiGrXaqKH5SoKlgJpP3SbrbkciYPLaflxg+qNvl+A+mVOSca0aruT35DduV918VdctYKKU2XcBkMftM= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-lf1-x12e.google.com with SMTP id 2adb3069b0e04-52f01afa11cso6702824e87.0 for ; Tue, 30 Jul 2024 03:32:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1722335519; x=1722940319; 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=Lefe4BIKu+Vi3N601IfiFXDmthCRAYuTfXaPFJdbqA8=; b=P+kiWST/3Zhx28lPPNaRSFGj/cl+9VBbyX3cDlqJfrTCnfAwTWAZHvVcBuqX2OgyMs 1FyvHxQke0uw7vD0o5gvvSu9+PZMOonK81cEraku660YvX5jQhCLgWqb8b36XQC5Rnj5 JPMm/1yvKUXvPt8/VEGe/wcq1qx8pJWB1SDke+eKHLPY26t/0JKMKTvcVpxzHsVmWs6F dNK3133edl14cXMU41CTpM1t/Tsv6K3kFoPJU7zQwM4IpNTRAfisuIa3RuExzAyHYTDC Z8D2TRJeUlnV1SsDFog2xnkBOWsyMGu/vRlzm4u/wY5k9If1KnqiXDEKcY7sF2zrD0pW NT8w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1722335519; x=1722940319; 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=Lefe4BIKu+Vi3N601IfiFXDmthCRAYuTfXaPFJdbqA8=; b=GiS5wFLn4kiirkKx519N5Vpi21cmyGs9OhWTPKwf5AhrpAX9JKWvHM17128Wb4Hb4U mgNKpR7hHQ0H4pDaFPOX+qAZxvKNzgPbCDML3sXfjG5RlbD8GvktHn5lPfDcCI3cOuf2 nETl/r91foIeJ5uDGT8+kt5L1ZCEE4krTAWNho3sS+lFgx8f7j2O/ZrYbq2Io4PWEOoG tAJqpNM43mr17XJvorX/lXUbKrGbrE4HzQXPaIqgyN3zZx7ENeZbRMIsKgHAJDle3vTv yRlyBf/msq2z4uujT4tf2rXX9zqdsudEaBIX2AcIsijgQtpKmYrB4jIpxAPaT26J1rPT 1+GQ== X-Gm-Message-State: AOJu0YzQCIGrGR6hMK1AQR+/J8fh7xS5IqwIgEXGUJ6R8zgDE/J0BTpM jiCUbWCWtaoCovN5OwJ+beffpxdupH2YtoNgFtYI/ebBjqJVEhymtsUAIEweOGt81VtyaHvYNWe 5tu2govS1MK5ZgUNHpkUe/3Yux0IpX61C X-Google-Smtp-Source: AGHT+IHYsydP7FDmGrEhdM1wR+SRGFuJ6Z+rGul4u3gscBSrx/j1026Y89VveOF2jct3EbDyL0MUMwPyxhHeuSZwRkI= X-Received: by 2002:a05:6512:308d:b0:52c:df6d:e52e with SMTP id 2adb3069b0e04-5309b27089bmr8794172e87.16.1722335518344; Tue, 30 Jul 2024 03:31:58 -0700 (PDT) MIME-Version: 1.0 References: <20240727022830.553897-1-quic_apinski@quicinc.com> In-Reply-To: <20240727022830.553897-1-quic_apinski@quicinc.com> From: Richard Biener Date: Tue, 30 Jul 2024 12:31:46 +0200 Message-ID: Subject: Re: [PATCH] middle-end: Add and use few helper methods for current_properties To: Andrew Pinski Cc: gcc-patches@gcc.gnu.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-7.7 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 Sat, Jul 27, 2024 at 4:29=E2=80=AFAM Andrew Pinski wrote: > > While working on isel, I found that the current way of doing current_prop= erties > in function can easily make a mistake and having to do stuff like `(a & b= ) =3D=3D 0` > and `a |=3D b;` and `a &=3D ~b;` is not so obvious what was going on. > So let's add a few helper methods to function: > * set_property > * unset_property > * prop_set_p > * gimple_prop_p We have, for cfun->cfg.x_current_loops: loops_state_satisfies_p, loops_state_set, loops_state_clear and for example gimple_set_visited (gimple *stmt, bool visited_p) The API doesn't look consistent with any existing one? Is gimple_prop_p common enough to warrant special-casing? I think the change is OK but I wanted to raise the lack of coding style for this kind of API. I'd have used property_set property_clear property_set_p not *_property vs. prop_*, prefixing the domain is better than postfixing. = And I'd have avoided gimple_prop_p (bad name anyway - gimple_property_set_p or property_gimple_set_p?) It's also the first member function in struct function ... I'd have passed = it as first argument. If it's a member function the property field should bec= ome private, otherwise it's a bit pointless IMO. Thanks, Richard. > and use them in the source; I didn't change of the backends which has a f= ew places > which could change. > > Also moves the PROP_* defines from tree-pass.h to function.h where > they should be. > > Bootstrapped and tested on x86_64-linux-gnu. > > gcc/ChangeLog: > > * tree-pass.h (PROP_gimple_any): Delete. > (PROP_gimple_lcf): Delete. > (PROP_gimple_leh): Delete. > (PROP_cfg): Delete. > (PROP_objsz): Delete. > (PROP_ssa): Delete. > (PROP_no_crit_edges): Delete. > (PROP_rtl): Delete. > (PROP_gimple_lomp): Delete. > (PROP_cfglayout): Delete. > (PROP_gimple_lcx): Delete. > (PROP_loops): Delete. > (PROP_gimple_lvec): Delete. > (PROP_gimple_eomp): Delete. > (PROP_gimple_lva): Delete. > (PROP_gimple_opt_math): Delete. > (PROP_gimple_lomp_dev): Delete. > (PROP_rtl_split_insns): Delete. > (PROP_loop_opts_done): Delete. > (PROP_assumptions_done): Delete. > (PROP_gimple_lbitint): Delete. > (PROP_gimple): Delete. > * function.h (PROP_gimple_any): Move from tree-pass.h. > (PROP_gimple_lcf): Move from tree-pass.h. > (PROP_gimple_leh): Move from tree-pass.h. > (PROP_cfg): Move from tree-pass.h. > (PROP_objsz): Move from tree-pass.h. > (PROP_ssa): Move from tree-pass.h. > (PROP_no_crit_edges): Move from tree-pass.h. > (PROP_rtl): Move from tree-pass.h. > (PROP_gimple_lomp): Move from tree-pass.h. > (PROP_cfglayout): Move from tree-pass.h. > (PROP_gimple_lcx): Move from tree-pass.h. Move from tree-pass.h. > (PROP_loops): Move from tree-pass.h. > (PROP_gimple_lvec): Move from tree-pass.h. > (PROP_gimple_eomp): Move from tree-pass.h. > (PROP_gimple_lva): Move from tree-pass.h. > (PROP_gimple_opt_math): Move from tree-pass.h. > (PROP_gimple_lomp_dev): Move from tree-pass.h. > (PROP_rtl_split_insns): Move from tree-pass.h. > (PROP_loop_opts_done): Move from tree-pass.h. > (PROP_assumptions_done): Move from tree-pass.h. > (PROP_gimple_lbitint): Move from tree-pass.h. > (PROP_gimple): Move from tree-pass.h. > (struct function): Add helper methods, set_property, > unset_property, prop_set_p, gimple_prop_p > * cfgexpand.cc (pass_expand::execute): Use unset_property. > * cfgrtl.cc (print_rtl_with_bb): Use prop_set_p. > * cgraph.cc (release_function_body): Use unset_property. > (cgraph_node::verify_node): Use prop_set_p. > * cgraphunit.cc (symtab_node::native_rtl_p): Use prop_set_p. > (init_lowered_empty_function): Use set_property. > (symbol_table::compile): Use prop_set_p. > * function.cc (free_after_compilation): Use unset_property. > * generic-match-head.cc (canonicalize_math_p): Use prop_set_p. > (optimize_vectors_before_lowering_p): Use prop_set_p. > * gimple-expr.cc (gimple_has_body_p): Use prop_set_p. > * gimple-lower-bitint.cc (pass_lower_bitint_O0::gate): Use prop_s= et_p. > * gimple-match-exports.cc (build_call_internal): Use prop_set_p. > * gimple-match-head.cc (canonicalize_math_p): Use prop_set_p. > (canonicalize_math_after_vectorization_p): Use prop_set_p. > (optimize_vectors_before_lowering_p): Use prop_set_p. > * gimplify.cc: Remove tree-pass.h include and add timevar.h inclu= de. > (gimplify_call_expr): Use prop_set_p. > (gimplify_function_tree): Use set_property. > (gimplify_va_arg_expr): Use unset_property. > * loop-init.cc (loop_optimizer_init): Use prop_set_p. > (loop_optimizer_finalize): Use prop_set_p. > (pass_loop2::gate): Use unset_property. > (pass_rtl_loop_done::execute): Use unset_property. > * passes.cc (execute_function_dump): Use gimple_prop_p. > (emergency_dump_function): Use prop_set_p. > (execute_function_todo): Use gimple_prop_p and prop_set_p. > (pass_init_dump_file): Use prop_set_p. > (execute_one_ipa_transform_pass): Use gimple_prop_p. > (execute_all_ipa_transforms): Use gimple_prop_p. > (skip_pass): Use set_property. > (execute_one_pass): Use prop_set_p, gimple_prop_p and set_propert= y. > * read-rtl-function.cc (function_reader::create_function): Use se= t_property > * varpool.cc: Remove tree-pass.h include as PROP_* moved to funct= ion.h. > * omp-expand.cc (expand_omp_simd): Use unset_property. > (pass_expand_omp_ssa::gate): Use prop_set_p. > * omp-general.cc (omp_maybe_offloaded): Use prop_set_p. > (omp_context_selector_matches): Use prop_set_p. > (omp_resolve_declare_variant): Use prop_set_p. > * omp-offload.cc (pass_omp_device_lower::gate): Use prop_set_p. > * run-rtl-passes.cc (run_rtl_passes): Use set_property. > * tree-cfg.cc (dump_function_to_file): Use prop_set_p. > * tree-complex.cc (pass_lower_complex_O0::gate): Use prop_set_p. > * tree-inline.cc (expand_call_inline): Use prop_set_p. > (tree_function_versioning): Use unset_property and set_property. > * tree-into-ssa.cc (pass_build_ssa::gate): Use prop_set_p. > * tree-parloops.cc (pass_parallelize_loops::execute): Use unset_p= roperty. > * tree-ssa-forwprop.cc (pass_forwprop::execute): Use prop_set_p. > * tree-ssa-loop-niter.cc (do_warn_aggressive_loop_optimizations):= Use prop_set_p. > * tree-ssa-sccvn.cc (copy_reference_ops_from_ref): Use prop_set_p= . > (vn_reference_lookup): Use prop_set_p. > (vn_reference_insert): Use prop_set_p. > * tree-ssa-sink.cc (do_not_sink): Use prop_set_p. > * tree-ssa-threadbackward.cc (back_threader_profitability::profit= able_path_p): > Use prop_set_p. > * tree-ssa.cc (maybe_optimize_var): Use prop_set_p. > * tree-stdarg.cc (expand_ifn_va_arg): Use prop_set_p. > (pass_lower_vaarg::gate): Use prop_set_p. > * tree-vect-generic.cc (pass_lower_vector::gate): Use prop_set_p. > * tree.cc (tree_builtin_call_types_compatible_p): Use gimple_prop= _p. > > gcc/c-family/ChangeLog: > > * c-gimplify.cc (c_gimplify_expr): Use prop_set_p. > > gcc/c/ChangeLog: > > * gimple-parser.cc (c_parser_parse_gimple_body): Use prop_set_p. > (c_parser_gimple_compound_statement): Use prop_set_p. > (c_parser_gimple_goto_stmt): Use prop_set_p. > (c_parser_gimple_if_stmt): Use prop_set_p. > > Signed-off-by: Andrew Pinski > --- > gcc/c-family/c-gimplify.cc | 2 +- > gcc/c/gimple-parser.cc | 20 +++++------ > gcc/cfgexpand.cc | 2 +- > gcc/cfgrtl.cc | 4 +-- > gcc/cgraph.cc | 4 +-- > gcc/cgraphunit.cc | 8 ++--- > gcc/function.cc | 2 +- > gcc/function.h | 65 ++++++++++++++++++++++++++++++++++ > gcc/generic-match-head.cc | 4 +-- > gcc/gimple-expr.cc | 2 +- > gcc/gimple-lower-bitint.cc | 2 +- > gcc/gimple-match-exports.cc | 2 +- > gcc/gimple-match-head.cc | 6 ++-- > gcc/gimplify.cc | 10 +++--- > gcc/loop-init.cc | 10 +++--- > gcc/omp-expand.cc | 4 +-- > gcc/omp-general.cc | 16 ++++----- > gcc/omp-offload.cc | 2 +- > gcc/passes.cc | 37 ++++++++++--------- > gcc/read-rtl-function.cc | 2 +- > gcc/run-rtl-passes.cc | 2 +- > gcc/tree-cfg.cc | 8 ++--- > gcc/tree-complex.cc | 2 +- > gcc/tree-inline.cc | 6 ++-- > gcc/tree-into-ssa.cc | 2 +- > gcc/tree-parloops.cc | 2 +- > gcc/tree-pass.h | 30 ---------------- > gcc/tree-ssa-forwprop.cc | 2 +- > gcc/tree-ssa-loop-niter.cc | 2 +- > gcc/tree-ssa-sccvn.cc | 6 ++-- > gcc/tree-ssa-sink.cc | 2 +- > gcc/tree-ssa-threadbackward.cc | 4 +-- > gcc/tree-ssa.cc | 2 +- > gcc/tree-stdarg.cc | 4 +-- > gcc/tree-vect-generic.cc | 2 +- > gcc/tree.cc | 2 +- > gcc/varpool.cc | 1 - > 37 files changed, 158 insertions(+), 125 deletions(-) > > diff --git a/gcc/c-family/c-gimplify.cc b/gcc/c-family/c-gimplify.cc > index 3e29766e092..392e2dcdba3 100644 > --- a/gcc/c-family/c-gimplify.cc > +++ b/gcc/c-family/c-gimplify.cc > @@ -781,7 +781,7 @@ c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTR= IBUTE_UNUSED, > boundaries would violate language semantics. */ > if (SCALAR_FLOAT_TYPE_P (type) > && flag_fp_contract_mode =3D=3D FP_CONTRACT_ON > - && cfun && !(cfun->curr_properties & PROP_gimple_any) > + && cfun && !cfun->prop_set_p (PROP_gimple_any) > && fma_supported_p (IFN_FMA, type)) > { > bool neg_mul =3D false, neg_add =3D code =3D=3D MINUS_EXPR; > diff --git a/gcc/c/gimple-parser.cc b/gcc/c/gimple-parser.cc > index d156d83cd37..9acdb105fc7 100644 > --- a/gcc/c/gimple-parser.cc > +++ b/gcc/c/gimple-parser.cc > @@ -246,7 +246,7 @@ c_parser_parse_gimple_body (c_parser *cparser, char *= gimple_pass, > if (cdil =3D=3D cdil_gimple_ssa) > { > init_ssa_operands (cfun); > - cfun->curr_properties |=3D PROP_ssa; > + cfun->set_property (PROP_ssa); > } > } > > @@ -360,7 +360,7 @@ c_parser_parse_gimple_body (c_parser *cparser, char *= gimple_pass, > fix_loop_structure (NULL); > } > > - if (cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg)) > { > ENTRY_BLOCK_PTR_FOR_FN (cfun)->count =3D entry_bb_count; > gcov_type t =3D param_gimple_fe_computed_hot_bb_threshold; > @@ -372,10 +372,10 @@ c_parser_parse_gimple_body (c_parser *cparser, char= *gimple_pass, > > /* Perform IL validation and if any error is found abort compilation > of this function by zapping its body. */ > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && verify_gimple_in_cfg (cfun, false, false)) > init_empty_tree_cfg (); > - else if (!(cfun->curr_properties & PROP_cfg) > + else if (!cfun->prop_set_p (PROP_cfg) > && verify_gimple_in_seq (gimple_body (current_function_decl), = false)) > gimple_set_body (current_function_decl, NULL); > > @@ -460,7 +460,7 @@ c_parser_gimple_compound_statement (gimple_parser &pa= rser, gimple_seq *seq) > if (! c_parser_require (parser, CPP_SEMICOLON, > "expected %<;%>")) > return return_p; > - if (cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg)) > parser.push_edge (parser.current_bb->index, EXIT_BLOCK, 0= , > profile_probability::uninitialized ()); > break; > @@ -484,7 +484,7 @@ c_parser_gimple_compound_statement (gimple_parser &pa= rser, gimple_seq *seq) > } > /* Basic block specification. > __BB (index, ...) */ > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && !strcmp (IDENTIFIER_POINTER > (c_parser_peek_token (parser)->value), "__BB"= )) > { > @@ -674,7 +674,7 @@ expr_stmt: > c_parser_consume_token (parser); > > /* Put stmts parsed in the current block. */ > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && !gimple_seq_empty_p (*seq)) > { > if (!parser.current_bb) > @@ -2258,7 +2258,7 @@ static void > c_parser_gimple_goto_stmt (gimple_parser &parser, > location_t loc, tree label, gimple_seq *seq) > { > - if (cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg)) > { > int dest_index; > profile_probability prob; > @@ -2376,7 +2376,7 @@ c_parser_gimple_if_stmt (gimple_parser &parser, gim= ple_seq *seq) > c_parser_consume_token (parser); > int dest_index; > profile_probability prob; > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && c_parser_gimple_parse_bb_spec_edge_probability (label, parse= r, > &dest_index,= &prob)) > parser.push_edge (parser.current_bb->index, dest_index, > @@ -2413,7 +2413,7 @@ c_parser_gimple_if_stmt (gimple_parser &parser, gim= ple_seq *seq) > c_parser_consume_token (parser); > int dest_index; > profile_probability prob; > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && c_parser_gimple_parse_bb_spec_edge_probability (label, parse= r, > &dest_index,= &prob)) > parser.push_edge (parser.current_bb->index, dest_index, > diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc > index dad3ae1b7c6..ee17c428c76 100644 > --- a/gcc/cfgexpand.cc > +++ b/gcc/cfgexpand.cc > @@ -7116,7 +7116,7 @@ pass_expand::execute (function *fun) > ICE. */ > if (rtl_dump_and_exit) > { > - cfun->curr_properties &=3D ~PROP_loops; > + cfun->unset_property (PROP_loops); > loop_optimizer_finalize (); > } > > diff --git a/gcc/cfgrtl.cc b/gcc/cfgrtl.cc > index a5dc3512159..a4643530904 100644 > --- a/gcc/cfgrtl.cc > +++ b/gcc/cfgrtl.cc > @@ -2239,13 +2239,13 @@ print_rtl_with_bb (FILE *outf, const rtx_insn *rt= x_first, dump_flags_t flags) > /* After freeing the CFG, we still have BLOCK_FOR_INSN set on most > insns, but the CFG is not maintained so the basic block info > is not reliable. Therefore it's omitted from the dumps. */ > - if (! (cfun->curr_properties & PROP_cfg)) > + if (!cfun->prop_set_p (PROP_cfg)) > flags &=3D ~TDF_BLOCKS; > > if (df) > df_dump_start (outf); > > - if (cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg)) > { > FOR_EACH_BB_REVERSE_FN (bb, cfun) > { > diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc > index 473d8410bc9..adcbcc53db6 100644 > --- a/gcc/cgraph.cc > +++ b/gcc/cgraph.cc > @@ -1800,7 +1800,7 @@ release_function_body (tree decl) > if (fn->cfg > && loops_for_fn (fn)) > { > - fn->curr_properties &=3D ~PROP_loops; > + fn->unset_property (PROP_loops); > loop_optimizer_finalize (fn); > } > if (fn->gimple_df) > @@ -3824,7 +3824,7 @@ cgraph_node::verify_node (void) > && (!DECL_EXTERNAL (decl) || inlined_to) > && !flag_wpa) > { > - if ((this_cfun->curr_properties & PROP_assumptions_done) !=3D 0) > + if (this_cfun->prop_set_p (PROP_assumptions_done)) > ; > else if (this_cfun->cfg) > { > diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc > index 2bd0289ffba..30fca8f8f2f 100644 > --- a/gcc/cgraphunit.cc > +++ b/gcc/cgraphunit.cc > @@ -230,7 +230,7 @@ symtab_node::native_rtl_p () const > return false; > if (!DECL_STRUCT_FUNCTION (decl)) > return false; > - return DECL_STRUCT_FUNCTION (decl)->curr_properties & PROP_rtl; > + return DECL_STRUCT_FUNCTION (decl)->prop_set_p (PROP_rtl); > } > > /* Determine if symbol declaration is needed. That is, visible to somet= hing > @@ -1721,7 +1721,7 @@ init_lowered_empty_function (tree decl, bool in_ssa= , profile_count count) > { > init_ssa_operands (cfun); > cfun->gimple_df->in_ssa_p =3D true; > - cfun->curr_properties |=3D PROP_ssa; > + cfun->set_property (PROP_ssa); > } > > DECL_INITIAL (decl) =3D make_node (BLOCK); > @@ -2430,8 +2430,8 @@ symbol_table::compile (void) > || gimple_has_body_p (node->decl)) > { > if (DECL_STRUCT_FUNCTION (node->decl) > - && (DECL_STRUCT_FUNCTION (node->decl)->curr_properties > - & PROP_assumptions_done) !=3D 0) > + && (DECL_STRUCT_FUNCTION (node->decl) > + ->prop_set_p (PROP_assumptions_done))) > continue; > error_found =3D true; > node->debug (); > diff --git a/gcc/function.cc b/gcc/function.cc > index a6f6de34942..606c0a25e9e 100644 > --- a/gcc/function.cc > +++ b/gcc/function.cc > @@ -215,7 +215,7 @@ free_after_compilation (struct function *f) > f->eh =3D NULL; > f->machine =3D NULL; > f->cfg =3D NULL; > - f->curr_properties &=3D ~PROP_cfg; > + f->unset_property (PROP_cfg); > delete f->cond_uids; > > regno_reg_rtx =3D NULL; > diff --git a/gcc/function.h b/gcc/function.h > index fbeadeaf410..c2c1b808eb1 100644 > --- a/gcc/function.h > +++ b/gcc/function.h > @@ -243,6 +243,38 @@ public: > (current_function_dynamic_stack_size !=3D 0 \ > || current_function_has_unbounded_dynamic_stack_size) > > + > +/* Pass properties set on function::curr_properties. */ > +#define PROP_gimple_any (1 << 0) /* entire gimple = grammar */ > +#define PROP_gimple_lcf (1 << 1) /* lowered contro= l flow */ > +#define PROP_gimple_leh (1 << 2) /* lowered eh */ > +#define PROP_cfg (1 << 3) > +#define PROP_objsz (1 << 4) /* object sizes computed = */ > +#define PROP_ssa (1 << 5) > +#define PROP_no_crit_edges (1 << 6) > +#define PROP_rtl (1 << 7) > +#define PROP_gimple_lomp (1 << 8) /* lowered OpenMP directi= ves */ > +#define PROP_cfglayout (1 << 9) /* cfglayout mode on RTL = */ > +#define PROP_gimple_lcx (1 << 10) /* lowered comple= x */ > +#define PROP_loops (1 << 11) /* preserve loop structur= es */ > +#define PROP_gimple_lvec (1 << 12) /* lowered vector */ > +#define PROP_gimple_eomp (1 << 13) /* no OpenMP directives *= / > +#define PROP_gimple_lva (1 << 14) /* No va_arg inte= rnal function. */ > +#define PROP_gimple_opt_math (1 << 15) /* Disable canonicalizati= on > + of math functions; the > + current choices have > + been optimized. */ > +#define PROP_gimple_lomp_dev (1 << 16) /* done omp_device_lower = */ > +#define PROP_rtl_split_insns (1 << 17) /* RTL has insns split. = */ > +#define PROP_loop_opts_done (1 << 18) /* SSA loop optimizations > + have completed. */ > +#define PROP_assumptions_done (1 << 19) /* Assume function kept > + around. */ > +#define PROP_gimple_lbitint (1 << 20) /* lowered large _BitInt = */ > + > +#define PROP_gimple \ > + (PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh | PROP_gimple_lom= p) > + > /* This structure can save all the important global and static variables > describing the status of the current function. */ > > @@ -449,6 +481,39 @@ struct GTY(()) function { > /* Set for artificial function created for [[assume (cond)]]. > These should be GIMPLE optimized, but not expanded to RTL. */ > unsigned int assume_function : 1; > + > + /* Sets the PROP on the current curr_properties, > + note this has to be a single property. */ > + > + void set_property (const unsigned prop) > + { > + gcc_checking_assert (exact_log2 (prop) !=3D -1); > + curr_properties |=3D prop; > + } > + > + /* Unsets the PROP on the current curr_properties, > + note this has to be a single property. */ > + > + void unset_property (const unsigned prop) > + { > + gcc_checking_assert (exact_log2 (prop) !=3D -1); > + curr_properties &=3D ~prop; > + } > + > + /* Returns true if the PROP is set on the current curr_properties. */ > + > + bool prop_set_p (unsigned prop) const > + { > + gcc_checking_assert (exact_log2 (prop) !=3D -1); > + return (curr_properties & prop) !=3D 0; > + } > + > + /* Returns true if the current properties is set to gimple. */ > + > + bool gimple_prop_p () const > + { > + return (curr_properties & PROP_gimple) !=3D 0; > + } > }; > > /* Add the decl D to the local_decls list of FUN. */ > diff --git a/gcc/generic-match-head.cc b/gcc/generic-match-head.cc > index 641d8e9b2de..30e0f1f3131 100644 > --- a/gcc/generic-match-head.cc > +++ b/gcc/generic-match-head.cc > @@ -84,7 +84,7 @@ single_use (tree t ATTRIBUTE_UNUSED) > static inline bool > canonicalize_math_p () > { > - return !cfun || (cfun->curr_properties & PROP_gimple_opt_math) =3D=3D = 0; > + return !cfun || !cfun->prop_set_p(PROP_gimple_opt_math); > } > > /* Return true if math operations that are beneficial only after > @@ -103,7 +103,7 @@ canonicalize_math_after_vectorization_p () > static inline bool > optimize_vectors_before_lowering_p () > { > - return !cfun || (cfun->curr_properties & PROP_gimple_lvec) =3D=3D 0; > + return !cfun || !cfun->prop_set_p (PROP_gimple_lvec); > } > > /* Return true if successive divisions can be optimized. > diff --git a/gcc/gimple-expr.cc b/gcc/gimple-expr.cc > index f8d7185530c..77c99188c01 100644 > --- a/gcc/gimple-expr.cc > +++ b/gcc/gimple-expr.cc > @@ -335,7 +335,7 @@ bool > gimple_has_body_p (tree fndecl) > { > struct function *fn =3D DECL_STRUCT_FUNCTION (fndecl); > - return (gimple_body (fndecl) || (fn && fn->cfg && !(fn->curr_propertie= s & PROP_rtl))); > + return (gimple_body (fndecl) || (fn && fn->cfg && !fn->prop_set_p (PRO= P_rtl))); > } > > /* Return a printable name for symbol DECL. */ > diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc > index b10593035c3..d1831434073 100644 > --- a/gcc/gimple-lower-bitint.cc > +++ b/gcc/gimple-lower-bitint.cc > @@ -7295,7 +7295,7 @@ public: > { > /* With errors, normal optimization passes are not run. If we don= 't > lower bitint operations at all, rtl expansion will abort. */ > - return !(fun->curr_properties & PROP_gimple_lbitint); > + return !fun->prop_set_p (PROP_gimple_lbitint); > } > > unsigned int execute (function *) final override > diff --git a/gcc/gimple-match-exports.cc b/gcc/gimple-match-exports.cc > index aacf3ff0414..9ea4fe713cf 100644 > --- a/gcc/gimple-match-exports.cc > +++ b/gcc/gimple-match-exports.cc > @@ -252,7 +252,7 @@ build_call_internal (internal_fn fn, gimple_match_op = *res_op) > && (TYPE_PRECISION (TREE_TYPE (res_op->ops[0])) > > MAX_FIXED_MODE_SIZE) > && cfun > - && (cfun->curr_properties & PROP_gimple_lbitint) =3D=3D= 0) > + && !cfun->prop_set_p (PROP_gimple_lbitint)) > break; > return NULL; > > diff --git a/gcc/gimple-match-head.cc b/gcc/gimple-match-head.cc > index 924d3f1e710..b60069fcca2 100644 > --- a/gcc/gimple-match-head.cc > +++ b/gcc/gimple-match-head.cc > @@ -123,7 +123,7 @@ single_use (const_tree t) > static inline bool > canonicalize_math_p () > { > - return !cfun || (cfun->curr_properties & PROP_gimple_opt_math) =3D=3D = 0; > + return !cfun || !cfun->prop_set_p (PROP_gimple_opt_math); > } > > /* Return true if math operations that are beneficial only after > @@ -132,7 +132,7 @@ canonicalize_math_p () > static inline bool > canonicalize_math_after_vectorization_p () > { > - return !cfun || (cfun->curr_properties & PROP_gimple_lvec) !=3D 0; > + return !cfun || cfun->prop_set_p (PROP_gimple_lvec); > } > > /* Return true if we can still perform transformations that may introduc= e > @@ -142,7 +142,7 @@ canonicalize_math_after_vectorization_p () > static inline bool > optimize_vectors_before_lowering_p () > { > - return !cfun || (cfun->curr_properties & PROP_gimple_lvec) =3D=3D 0; > + return !cfun || !cfun->prop_set_p (PROP_gimple_lvec); > } > > /* Return true if pow(cst, x) should be optimized into exp(log(cst) * x)= . > diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc > index ab323d764e8..9a3753a7e66 100644 > --- a/gcc/gimplify.cc > +++ b/gcc/gimplify.cc > @@ -31,7 +31,6 @@ along with GCC; see the file COPYING3. If not see > #include "tm_p.h" > #include "gimple.h" > #include "gimple-predict.h" > -#include "tree-pass.h" /* FIXME: only for PROP_gimple_any */ > #include "ssa.h" > #include "cgraph.h" > #include "tree-pretty-print.h" > @@ -70,6 +69,7 @@ along with GCC; see the file COPYING3. If not see > #include "omp-offload.h" > #include "context.h" > #include "tree-nested.h" > +#include "timevar.h" > > /* Identifier for a basic condition, mapping it to other basic condition= s of > its Boolean expression. Basic conditions given the same uid (in the = same > @@ -3974,7 +3974,7 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p= , bool want_value) > if (flag_openmp > && fndecl > && cfun > - && (cfun->curr_properties & PROP_gimple_any) =3D=3D 0) > + && !cfun->prop_set_p (PROP_gimple_any)) > { > tree variant =3D omp_resolve_declare_variant (fndecl); > if (variant !=3D fndecl) > @@ -19571,7 +19571,7 @@ gimplify_function_tree (tree fndecl) > > /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_a= rg_expr > if necessary. */ > - cfun->curr_properties |=3D PROP_gimple_lva; > + cfun->set_property (PROP_gimple_lva); > > if (asan_sanitize_use_after_scope ()) > asan_poisoned_variables =3D new hash_set (); > @@ -19683,7 +19683,7 @@ gimplify_function_tree (tree fndecl) > } > > DECL_SAVED_TREE (fndecl) =3D NULL_TREE; > - cfun->curr_properties |=3D PROP_gimple_any; > + cfun->set_property (PROP_gimple_any); > > pop_cfun (); > > @@ -19776,7 +19776,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *p= re_p, > > /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_= ARG > needs to be expanded. */ > - cfun->curr_properties &=3D ~PROP_gimple_lva; > + cfun->unset_property (PROP_gimple_lva); > > return GS_OK; > } > diff --git a/gcc/loop-init.cc b/gcc/loop-init.cc > index c46168252f8..5e67d2ef663 100644 > --- a/gcc/loop-init.cc > +++ b/gcc/loop-init.cc > @@ -89,7 +89,7 @@ loop_optimizer_init (unsigned flags) > > if (!current_loops) > { > - gcc_assert (!(cfun->curr_properties & PROP_loops)); > + gcc_assert (!cfun->prop_set_p (PROP_loops)); > > /* Find the loops. */ > current_loops =3D flow_loops_find (NULL); > @@ -99,7 +99,7 @@ loop_optimizer_init (unsigned flags) > bool recorded_exits =3D loops_state_satisfies_p (LOOPS_HAVE_RECORD= ED_EXITS); > bool needs_fixup =3D loops_state_satisfies_p (LOOPS_NEED_FIXUP); > > - gcc_assert (cfun->curr_properties & PROP_loops); > + gcc_assert (cfun->prop_set_p (PROP_loops)); > > /* Ensure that the dominators are computed, like flow_loops_find d= oes. */ > calculate_dominance_info (CDI_DOMINATORS); > @@ -155,7 +155,7 @@ loop_optimizer_finalize (struct function *fn, bool cl= ean_loop_closed_phi) > /* If we should preserve loop structure, do not free it but clear > flags that advanced properties are there as we are not preserving > that in full. */ > - if (fn->curr_properties & PROP_loops) > + if (fn->prop_set_p (PROP_loops)) > { > loops_state_clear (fn, LOOP_CLOSED_SSA > | LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS > @@ -374,7 +374,7 @@ pass_loop2::gate (function *fun) > else > { > /* No longer preserve loops, remove them now. */ > - fun->curr_properties &=3D ~PROP_loops; > + fun->unset_property (PROP_loops); > if (current_loops) > loop_optimizer_finalize (); > return false; > @@ -475,7 +475,7 @@ unsigned int > pass_rtl_loop_done::execute (function *fun) > { > /* No longer preserve loops, remove them now. */ > - fun->curr_properties &=3D ~PROP_loops; > + fun->unset_property (PROP_loops); > loop_optimizer_finalize (); > free_dominance_info (CDI_DOMINATORS); > > diff --git a/gcc/omp-expand.cc b/gcc/omp-expand.cc > index 24287826444..3c195f25827 100644 > --- a/gcc/omp-expand.cc > +++ b/gcc/omp-expand.cc > @@ -6538,7 +6538,7 @@ expand_omp_simd (struct omp_region *region, struct = omp_for_data *fd) > OMP_CLAUSE__SIMT_); > if (is_simt) > { > - cfun->curr_properties &=3D ~PROP_gimple_lomp_dev; > + cfun->unset_property (PROP_gimple_lomp_dev); > is_simt =3D safelen_int > 1; > } > tree simt_lane =3D NULL_TREE, simt_maxlane =3D NULL_TREE; > @@ -10959,7 +10959,7 @@ public: > /* opt_pass methods: */ > bool gate (function *fun) final override > { > - return !(fun->curr_properties & PROP_gimple_eomp); > + return !fun->prop_set_p (PROP_gimple_eomp); > } > unsigned int execute (function *) final override > { > diff --git a/gcc/omp-general.cc b/gcc/omp-general.cc > index 0b61335dba4..d5113ef7c9d 100644 > --- a/gcc/omp-general.cc > +++ b/gcc/omp-general.cc > @@ -1124,7 +1124,7 @@ omp_maybe_offloaded (void) > && lookup_attribute ("omp declare target", > DECL_ATTRIBUTES (current_function_decl))) > return true; > - if (cfun && (cfun->curr_properties & PROP_gimple_any) =3D=3D 0) > + if (cfun && !cfun->prop_set_p (PROP_gimple_any)) > { > enum tree_code construct =3D OMP_TARGET; > if (omp_construct_selector_matches (&construct, 1, NULL)) > @@ -1494,7 +1494,7 @@ omp_context_selector_matches (tree ctx) > constructs); > } > > - if (cfun && (cfun->curr_properties & PROP_gimple_any) !=3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > { > if (!cfun->after_inlining) > { > @@ -1548,7 +1548,7 @@ omp_context_selector_matches (tree ctx) > case OMP_TRAIT_IMPLEMENTATION_ADMO: > if (set =3D=3D OMP_TRAIT_SET_IMPLEMENTATION) > { > - if (cfun && (cfun->curr_properties & PROP_gimple_any) != =3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > break; > > enum omp_memory_order omo > @@ -1626,7 +1626,7 @@ omp_context_selector_matches (tree ctx) > case OMP_TRAIT_IMPLEMENTATION_UNIFIED_ADDRESS: > if (set =3D=3D OMP_TRAIT_SET_IMPLEMENTATION) > { > - if (cfun && (cfun->curr_properties & PROP_gimple_any) != =3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > break; > > if ((omp_requires_mask & OMP_REQUIRES_UNIFIED_ADDRESS) = =3D=3D 0) > @@ -1641,7 +1641,7 @@ omp_context_selector_matches (tree ctx) > case OMP_TRAIT_IMPLEMENTATION_UNIFIED_SHARED_MEMORY: > if (set =3D=3D OMP_TRAIT_SET_IMPLEMENTATION) > { > - if (cfun && (cfun->curr_properties & PROP_gimple_any) != =3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > break; > > if ((omp_requires_mask > @@ -1657,7 +1657,7 @@ omp_context_selector_matches (tree ctx) > case OMP_TRAIT_IMPLEMENTATION_DYNAMIC_ALLOCATORS: > if (set =3D=3D OMP_TRAIT_SET_IMPLEMENTATION) > { > - if (cfun && (cfun->curr_properties & PROP_gimple_any) != =3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > break; > > if ((omp_requires_mask > @@ -1673,7 +1673,7 @@ omp_context_selector_matches (tree ctx) > case OMP_TRAIT_IMPLEMENTATION_REVERSE_OFFLOAD: > if (set =3D=3D OMP_TRAIT_SET_IMPLEMENTATION) > { > - if (cfun && (cfun->curr_properties & PROP_gimple_any) != =3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > break; > > if ((omp_requires_mask & OMP_REQUIRES_REVERSE_OFFLOAD) = =3D=3D 0) > @@ -2492,7 +2492,7 @@ tree > omp_resolve_declare_variant (tree base) > { > tree variant1 =3D NULL_TREE, variant2 =3D NULL_TREE; > - if (cfun && (cfun->curr_properties & PROP_gimple_any) !=3D 0) > + if (cfun && cfun->prop_set_p (PROP_gimple_any)) > return omp_resolve_late_declare_variant (base); > > auto_vec variants; > diff --git a/gcc/omp-offload.cc b/gcc/omp-offload.cc > index 35313c2ecf3..7d0c3d3a41e 100644 > --- a/gcc/omp-offload.cc > +++ b/gcc/omp-offload.cc > @@ -2823,7 +2823,7 @@ public: > #else > bool offload_ind_funcs_p =3D false; > #endif > - return (!(fun->curr_properties & PROP_gimple_lomp_dev) > + return (!fun->prop_set_p (PROP_gimple_lomp_dev) > || (flag_openmp > && (cgraph_node::get (fun->decl)->calls_declare_variant= _alt > || offload_ind_funcs_p))); > diff --git a/gcc/passes.cc b/gcc/passes.cc > index d73f8ba97b6..bf91befe074 100644 > --- a/gcc/passes.cc > +++ b/gcc/passes.cc > @@ -1794,7 +1794,7 @@ execute_function_dump (function *fn, void *data) > { > push_cfun (fn); > > - if (fn->curr_properties & PROP_gimple) > + if (fn->gimple_prop_p ()) > dump_function_to_file (fn->decl, dump_file, dump_flags); > else > print_rtl_with_bb (dump_file, get_insns (), dump_flags); > @@ -1803,7 +1803,7 @@ execute_function_dump (function *fn, void *data) > close the file before aborting. */ > fflush (dump_file); > > - if ((fn->curr_properties & PROP_cfg) > + if (fn->prop_set_p (PROP_cfg) > && (dump_flags & TDF_GRAPH)) > { > gcc::dump_manager *dumps =3D g->get_dumps (); > @@ -1842,7 +1842,7 @@ emergency_dump_function () > /* Normally the passmanager will close the graphs as a pass could be w= anting > to print multiple digraphs. But during an emergency dump there can = only be > one and we must finish the graph manually. */ > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && (dump_flags & TDF_GRAPH)) > finish_graph_dump_file (dump_file_name); > > @@ -2081,22 +2081,22 @@ execute_function_todo (function *fn, void *data) > > if (flags & TODO_verify_il) > { > - if (cfun->curr_properties & PROP_gimple) > + if (cfun->gimple_prop_p ()) > { > - if (cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg)) > /* IPA passes leave stmts to be fixed up, so make sure to > not verify stmts really throw. */ > verify_gimple_in_cfg (cfun, !from_ipa_pass); > else > verify_gimple_in_seq (gimple_body (cfun->decl)); > } > - if (cfun->curr_properties & PROP_ssa) > + if (cfun->prop_set_p (PROP_ssa)) > /* IPA passes leave stmts to be fixed up, so make sure to > not verify SSA operands whose verifier will choke on that.= */ > verify_ssa (true, !from_ipa_pass); > /* IPA passes leave basic-blocks unsplit, so make sure to > not trip on that. */ > - if ((cfun->curr_properties & PROP_cfg) > + if (cfun->prop_set_p (PROP_cfg) > && !from_ipa_pass) > verify_flow_info (); > if (current_loops > @@ -2106,7 +2106,7 @@ execute_function_todo (function *fn, void *data) > if (loops_state_satisfies_p (LOOP_CLOSED_SSA)) > verify_loop_closed_ssa (false); > } > - if (cfun->curr_properties & PROP_rtl) > + if (cfun->prop_set_p (PROP_rtl)) > verify_rtl_sharing (); > } > > @@ -2231,7 +2231,7 @@ pass_init_dump_file (opt_pass *pass) > dump_function_header (dump_file, current_function_decl, dump_fla= gs); > if (initializing_dump > && dump_file && (dump_flags & TDF_GRAPH) > - && cfun && (cfun->curr_properties & PROP_cfg)) > + && cfun && cfun->prop_set_p (PROP_cfg)) > { > clean_graph_dump_file (dump_file_name); > struct dump_file_info *dfi > @@ -2319,7 +2319,7 @@ execute_one_ipa_transform_pass (struct cgraph_node = *node, > > /* Note that the folders should only create gimple expressions. > This is a hack until the new folder is ready. */ > - in_gimple_form =3D (cfun && (cfun->curr_properties & PROP_gimple)) != =3D 0; > + in_gimple_form =3D (cfun && cfun->gimple_prop_p ()) !=3D 0; > > pass_init_dump_file (pass); > > @@ -2372,7 +2372,7 @@ execute_all_ipa_transforms (bool do_not_collect) > > int j =3D 0; > gcc::pass_manager *passes =3D g->get_passes (); > - bool report =3D profile_report && (cfun->curr_properties & PROP_gimple= ) !=3D 0; > + bool report =3D profile_report && cfun->gimple_prop_p (); > > if (report) > push_cfun (DECL_STRUCT_FUNCTION (node->decl)); > @@ -2561,12 +2561,12 @@ skip_pass (opt_pass *pass) > if (strcmp (pass->name, "into_cfglayout") =3D=3D 0) > { > cfg_layout_rtl_register_cfg_hooks (); > - cfun->curr_properties |=3D PROP_cfglayout; > + cfun->set_property (PROP_cfglayout); > } > if (strcmp (pass->name, "outof_cfglayout") =3D=3D 0) > { > rtl_register_cfg_hooks (); > - cfun->curr_properties &=3D ~PROP_cfglayout; > + cfun->unset_property (PROP_cfglayout); > } > } > > @@ -2600,7 +2600,7 @@ execute_one_pass (opt_pass *pass) > { > /* Run so passes selectively disabling themselves on a given funct= ion > are not miscounted. */ > - if (profile_report && cfun && (cfun->curr_properties & PROP_cfg) > + if (profile_report && cfun && cfun->prop_set_p (PROP_cfg) > && pass->type !=3D IPA_PASS && pass->type !=3D SIMPLE_IPA_PASS) > { > check_profile_consistency (pass->static_pass_number, false); > @@ -2627,7 +2627,7 @@ execute_one_pass (opt_pass *pass) > > /* Note that the folders should only create gimple expressions. > This is a hack until the new folder is ready. */ > - in_gimple_form =3D (cfun && (cfun->curr_properties & PROP_gimple)) != =3D 0; > + in_gimple_form =3D cfun && cfun->gimple_prop_p (); > > pass_init_dump_file (pass); > > @@ -2666,7 +2666,7 @@ execute_one_pass (opt_pass *pass) > if (cfun->assume_function) > { > /* For assume functions, don't release body, keep it around. *= / > - cfun->curr_properties |=3D PROP_assumptions_done; > + cfun->set_property (PROP_assumptions_done); > pop_cfun (); > current_pass =3D NULL; > return true; > @@ -2698,7 +2698,7 @@ execute_one_pass (opt_pass *pass) > ; > else if (pass->type =3D=3D SIMPLE_IPA_PASS) > do_per_function (account_profile_1, pass); > - else if (cfun && (cfun->curr_properties & PROP_cfg)) > + else if (cfun && cfun->prop_set_p (PROP_cfg)) > { > check_profile_consistency (pass->static_pass_number, true); > account_profile (pass->static_pass_number, true); > @@ -2728,8 +2728,7 @@ execute_one_pass (opt_pass *pass) > pass_fini_dump_file (pass); > > if (pass->type !=3D SIMPLE_IPA_PASS && pass->type !=3D IPA_PASS) > - gcc_assert (!(cfun->curr_properties & PROP_gimple) > - || pass->type !=3D RTL_PASS); > + gcc_assert (!cfun->gimple_prop_p () || pass->type !=3D RTL_PASS); > > current_pass =3D NULL; > redirect_edge_var_map_empty (); > diff --git a/gcc/read-rtl-function.cc b/gcc/read-rtl-function.cc > index fa1aeb53759..70873b53146 100644 > --- a/gcc/read-rtl-function.cc > +++ b/gcc/read-rtl-function.cc > @@ -507,7 +507,7 @@ function_reader::create_function () > tree fndecl =3D current_function_decl; > > /* Mark this function as being specified as __RTL. */ > - cfun->curr_properties |=3D PROP_rtl; > + cfun->set_property (PROP_rtl); > > /* cc1 normally inits DECL_INITIAL (fndecl) to be error_mark_node. > Create a dummy block for it. */ > diff --git a/gcc/run-rtl-passes.cc b/gcc/run-rtl-passes.cc > index 5a402d61ebc..fb7852d4fcf 100644 > --- a/gcc/run-rtl-passes.cc > +++ b/gcc/run-rtl-passes.cc > @@ -74,6 +74,6 @@ run_rtl_passes (char *initial_pass_name) > execute_pass_list (cfun, clean_slate); > } > > - cfun->curr_properties |=3D PROP_rtl; > + cfun->set_property (PROP_rtl); > free (initial_pass_name); > } > diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc > index e6fd1294b95..32b0d3b356e 100644 > --- a/gcc/tree-cfg.cc > +++ b/gcc/tree-cfg.cc > @@ -8349,8 +8349,8 @@ dump_function_to_file (tree fndecl, FILE *file, dum= p_flags_t flags) > print_generic_expr (file, TREE_TYPE (TREE_TYPE (fndecl)), > dump_flags | TDF_SLIM); > fprintf (file, " __GIMPLE (%s", > - (fun->curr_properties & PROP_ssa) ? "ssa" > - : (fun->curr_properties & PROP_cfg) ? "cfg" > + fun->prop_set_p (PROP_ssa) ? "ssa" > + : fun->prop_set_p (PROP_cfg) ? "cfg" > : ""); > > if (fun && fun->cfg) > @@ -8403,7 +8403,7 @@ dump_function_to_file (tree fndecl, FILE *file, dum= p_flags_t flags) > > /* When GIMPLE is lowered, the variables are no longer available in > BIND_EXPRs, so display them separately. */ > - if (fun && fun->decl =3D=3D fndecl && (fun->curr_properties & PROP_gim= ple_lcf)) > + if (fun && fun->decl =3D=3D fndecl && fun->prop_set_p (PROP_gimple_lcf= )) > { > unsigned ix; > ignore_topmost_bind =3D true; > @@ -8486,7 +8486,7 @@ dump_function_to_file (tree fndecl, FILE *file, dum= p_flags_t flags) > > fprintf (file, "}\n"); > } > - else if (fun && (fun->curr_properties & PROP_gimple_any)) > + else if (fun && fun->prop_set_p (PROP_gimple_any)) > { > /* The function is now in GIMPLE form but the CFG has not been > built yet. Emit the single sequence of GIMPLE statements > diff --git a/gcc/tree-complex.cc b/gcc/tree-complex.cc > index dfb45b9d91c..a89d5335f78 100644 > --- a/gcc/tree-complex.cc > +++ b/gcc/tree-complex.cc > @@ -2086,7 +2086,7 @@ public: > { > /* With errors, normal optimization passes are not run. If we don= 't > lower complex operations at all, rtl expansion will abort. */ > - return !(fun->curr_properties & PROP_gimple_lcx); > + return !fun->prop_set_p (PROP_gimple_lcx); > } > > unsigned int execute (function *) final override > diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc > index f31a34ac410..9dfd370fbba 100644 > --- a/gcc/tree-inline.cc > +++ b/gcc/tree-inline.cc > @@ -5014,7 +5014,7 @@ expand_call_inline (basic_block bb, gimple *stmt, c= opy_body_data *id, > variables to be added to IFN_GOMP_SIMT_ENTER argument list. */ > dst_cfun =3D DECL_STRUCT_FUNCTION (id->dst_fn); > simtvars_save =3D id->dst_simt_vars; > - if (!(dst_cfun->curr_properties & PROP_gimple_lomp_dev) > + if (!dst_cfun->prop_set_p (PROP_gimple_lomp_dev) > && (simduid =3D bb->loop_father->simduid) !=3D NULL_TREE > && (simduid =3D ssa_default_def (dst_cfun, simduid)) !=3D NULL_TRE= E > && single_imm_use (simduid, &use, &simtenter_stmt) > @@ -6424,9 +6424,9 @@ tree_function_versioning (tree old_decl, tree new_d= ecl, > /* Set up the destination functions loop tree. */ > if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl)) !=3D NULL) > { > - cfun->curr_properties &=3D ~PROP_loops; > + cfun->unset_property (PROP_loops); > loop_optimizer_init (AVOID_CFG_MODIFICATIONS); > - cfun->curr_properties |=3D PROP_loops; > + cfun->set_property (PROP_loops); > } > > /* Copy the Function's body. */ > diff --git a/gcc/tree-into-ssa.cc b/gcc/tree-into-ssa.cc > index 5b367c35812..f26a5da3840 100644 > --- a/gcc/tree-into-ssa.cc > +++ b/gcc/tree-into-ssa.cc > @@ -2502,7 +2502,7 @@ public: > bool gate (function *fun) final override > { > /* Do nothing for functions that were produced already in SSA form= . */ > - return !(fun->curr_properties & PROP_ssa); > + return !fun->prop_set_p (PROP_ssa); > } > > unsigned int execute (function *) final override; > diff --git a/gcc/tree-parloops.cc b/gcc/tree-parloops.cc > index 888a834faf9..dc32bbf489c 100644 > --- a/gcc/tree-parloops.cc > +++ b/gcc/tree-parloops.cc > @@ -4227,7 +4227,7 @@ pass_parallelize_loops::execute (function *fun) > unsigned int todo =3D 0; > if (parallelize_loops (oacc_kernels_p)) > { > - fun->curr_properties &=3D ~(PROP_gimple_eomp); > + fun->unset_property (PROP_gimple_eomp); > > checking_verify_loop_structure (); > > diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h > index 3a0cf13089e..84376166fc7 100644 > --- a/gcc/tree-pass.h > +++ b/gcc/tree-pass.h > @@ -203,36 +203,6 @@ protected: > } > }; > > -/* Pass properties. */ > -#define PROP_gimple_any (1 << 0) /* entire gimple = grammar */ > -#define PROP_gimple_lcf (1 << 1) /* lowered contro= l flow */ > -#define PROP_gimple_leh (1 << 2) /* lowered eh */ > -#define PROP_cfg (1 << 3) > -#define PROP_objsz (1 << 4) /* object sizes computed = */ > -#define PROP_ssa (1 << 5) > -#define PROP_no_crit_edges (1 << 6) > -#define PROP_rtl (1 << 7) > -#define PROP_gimple_lomp (1 << 8) /* lowered OpenMP directi= ves */ > -#define PROP_cfglayout (1 << 9) /* cfglayout mode on RTL = */ > -#define PROP_gimple_lcx (1 << 10) /* lowered comple= x */ > -#define PROP_loops (1 << 11) /* preserve loop structur= es */ > -#define PROP_gimple_lvec (1 << 12) /* lowered vector */ > -#define PROP_gimple_eomp (1 << 13) /* no OpenMP directives *= / > -#define PROP_gimple_lva (1 << 14) /* No va_arg inte= rnal function. */ > -#define PROP_gimple_opt_math (1 << 15) /* Disable canonicalizati= on > - of math functions; the > - current choices have > - been optimized. */ > -#define PROP_gimple_lomp_dev (1 << 16) /* done omp_device_lower = */ > -#define PROP_rtl_split_insns (1 << 17) /* RTL has insns split. = */ > -#define PROP_loop_opts_done (1 << 18) /* SSA loop optimizations > - have completed. */ > -#define PROP_assumptions_done (1 << 19) /* Assume function kept > - around. */ > -#define PROP_gimple_lbitint (1 << 20) /* lowered large _BitInt = */ > - > -#define PROP_gimple \ > - (PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh | PROP_gimple_lom= p) > > /* To-do flags. */ > #define TODO_do_not_ggc_collect (1 << 1) > diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc > index 44a6b5d39aa..7e0fcf2e544 100644 > --- a/gcc/tree-ssa-forwprop.cc > +++ b/gcc/tree-ssa-forwprop.cc > @@ -3748,7 +3748,7 @@ pass_forwprop::execute (function *fun) > /* After vector lowering rewrite all loads, but > initially do not since this conflicts with > vector CONSTRUCTOR to shuffle optimization. */ > - || (fun->curr_properties & PROP_gimple_lvec)) > + || fun->prop_set_p (PROP_gimple_lvec)) > && gimple_assign_load_p (stmt) > && !gimple_has_volatile_ops (stmt) > && !stmt_can_throw_internal (fun, stmt) > diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc > index f87731ef892..c127111f89d 100644 > --- a/gcc/tree-ssa-loop-niter.cc > +++ b/gcc/tree-ssa-loop-niter.cc > @@ -3889,7 +3889,7 @@ do_warn_aggressive_loop_optimizations (class loop *= loop, > || !warn_aggressive_loop_optimizations > /* To avoid warning multiple times for the same loop, > only start warning when we preserve loops. */ > - || (cfun->curr_properties & PROP_loops) =3D=3D 0 > + || !cfun->prop_set_p (PROP_loops) > /* Only warn once per loop. */ > || loop->warned_aggressive_loop_optimizations > /* Only warn if undefined behavior gives us lower estimate than th= e > diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc > index dc377fa16ce..3bcd429f620 100644 > --- a/gcc/tree-ssa-sccvn.cc > +++ b/gcc/tree-ssa-sccvn.cc > @@ -986,7 +986,7 @@ copy_reference_ops_from_ref (tree ref, vec *result) > __builtin_object_size had a chance to run. */ > if (TREE_CODE (orig) !=3D ADDR_EXPR > || maybe_ne (off, 0) > - || (cfun->curr_properties & PROP_objsz)) > + || cfun->prop_set_p (PROP_objsz)) > off.to_shwi (&temp.off); > } > } > @@ -4002,7 +4002,7 @@ vn_reference_lookup (tree op, tree vuse, vn_lookup_= kind kind, > > /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing > this before the pass folding __builtin_object_size had a chance to = run. */ > - if ((cfun->curr_properties & PROP_objsz) > + if (cfun->prop_set_p (PROP_objsz) > && operands[0].opcode =3D=3D ADDR_EXPR > && operands.last ().opcode =3D=3D SSA_NAME) > { > @@ -4146,7 +4146,7 @@ vn_reference_insert (tree op, tree result, tree vus= e, tree vdef) > =3D valueize_shared_reference_ops_from_ref (op, &tem); > /* Handle &MEM[ptr + 5].b[1].c as POINTER_PLUS_EXPR. Avoid doing this > before the pass folding __builtin_object_size had a chance to run. = */ > - if ((cfun->curr_properties & PROP_objsz) > + if (cfun->prop_set_p (PROP_objsz) > && operands[0].opcode =3D=3D ADDR_EXPR > && operands.last ().opcode =3D=3D SSA_NAME) > { > diff --git a/gcc/tree-ssa-sink.cc b/gcc/tree-ssa-sink.cc > index 8c551e42a4d..737638591db 100644 > --- a/gcc/tree-ssa-sink.cc > +++ b/gcc/tree-ssa-sink.cc > @@ -197,7 +197,7 @@ do_not_sink (gimple *stmt, basic_block early_bb, basi= c_block best_bb) > && gimple_vuse (stmt) > && !gimple_vdef (stmt) > && flag_tree_loop_vectorize > - && !(cfun->curr_properties & PROP_loop_opts_done) > + && !cfun->prop_set_p (PROP_loop_opts_done) > && dominated_by_p (CDI_DOMINATORS, best_bb->loop_father->latch, ea= rly_bb) > && !dominated_by_p (CDI_DOMINATORS, best_bb->loop_father->latch, b= est_bb)) > return true; > diff --git a/gcc/tree-ssa-threadbackward.cc b/gcc/tree-ssa-threadbackward= .cc > index ea8d7b882d0..086d3c7016e 100644 > --- a/gcc/tree-ssa-threadbackward.cc > +++ b/gcc/tree-ssa-threadbackward.cc > @@ -824,7 +824,7 @@ back_threader_profitability::profitable_path_p (const= vec &m_path, > loop optimizations if the number of copied statement is low. */ > if (!m_threaded_multiway_branch > && *creates_irreducible_loop > - && (!(cfun->curr_properties & PROP_loop_opts_done) > + && (!cfun->prop_set_p (PROP_loop_opts_done) > || (m_n_insns * param_fsm_scale_path_stmts > >=3D param_max_jump_thread_duplication_stmts))) > { > @@ -869,7 +869,7 @@ back_threader_profitability::profitable_path_p (const= vec &m_path, > loop optimizations to fail. Disable these threads until after > loop optimizations have run. */ > if ((m_threaded_through_latch || taken_edge->dest =3D=3D loop->latch) > - && !(cfun->curr_properties & PROP_loop_opts_done) > + && !cfun->prop_set_p (PROP_loop_opts_done) > && empty_block_p (loop->latch)) > { > if (dump_file && (dump_flags & TDF_DETAILS)) > diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc > index f4fa4e98c5d..41d430c789e 100644 > --- a/gcc/tree-ssa.cc > +++ b/gcc/tree-ssa.cc > @@ -1789,7 +1789,7 @@ maybe_optimize_var (tree var, bitmap addresses_take= n, bitmap not_reg_needs, > } > } > else if (TREE_CODE (TREE_TYPE (var)) =3D=3D BITINT_TYPE > - && (cfun->curr_properties & PROP_gimple_lbitint) !=3D 0 > + && cfun->prop_set_p (PROP_gimple_lbitint) > && TYPE_PRECISION (TREE_TYPE (var)) > MAX_FIXED_MODE_SIZE) > { > /* Don't rewrite large/huge _BitInt vars after _BitInt lowering > diff --git a/gcc/tree-stdarg.cc b/gcc/tree-stdarg.cc > index 1167fd9f224..c59686cfa97 100644 > --- a/gcc/tree-stdarg.cc > +++ b/gcc/tree-stdarg.cc > @@ -1090,7 +1090,7 @@ expand_ifn_va_arg_1 (function *fun) > static void > expand_ifn_va_arg (function *fun) > { > - if ((fun->curr_properties & PROP_gimple_lva) =3D=3D 0) > + if (!fun->prop_set_p (PROP_gimple_lva)) > expand_ifn_va_arg_1 (fun); > > if (flag_checking) > @@ -1187,7 +1187,7 @@ public: > /* opt_pass methods: */ > bool gate (function *) final override > { > - return (cfun->curr_properties & PROP_gimple_lva) =3D=3D 0; > + return !cfun->prop_set_p (PROP_gimple_lva); > } > > unsigned int execute (function *) final override; > diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc > index 8336cbb8c73..2dc87eb66ea 100644 > --- a/gcc/tree-vect-generic.cc > +++ b/gcc/tree-vect-generic.cc > @@ -2440,7 +2440,7 @@ public: > /* opt_pass methods: */ > bool gate (function *fun) final override > { > - return !(fun->curr_properties & PROP_gimple_lvec); > + return !fun->prop_set_p (PROP_gimple_lvec); > } > > unsigned int execute (function *) final override > diff --git a/gcc/tree.cc b/gcc/tree.cc > index a2d431662bd..396342ff656 100644 > --- a/gcc/tree.cc > +++ b/gcc/tree.cc > @@ -8630,7 +8630,7 @@ tree_builtin_call_types_compatible_p (const_tree ca= ll, tree fndecl) > if (tree decl =3D builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)= )) > fndecl =3D decl; > > - bool gimple_form =3D (cfun && (cfun->curr_properties & PROP_gimple)) != =3D 0; > + bool gimple_form =3D cfun && cfun->gimple_prop_p (); > if (gimple_form > ? !useless_type_conversion_p (TREE_TYPE (call), > TREE_TYPE (TREE_TYPE (fndecl))) > diff --git a/gcc/varpool.cc b/gcc/varpool.cc > index e40504d1bd8..d38c52066b3 100644 > --- a/gcc/varpool.cc > +++ b/gcc/varpool.cc > @@ -35,7 +35,6 @@ along with GCC; see the file COPYING3. If not see > #include "context.h" > #include "stringpool.h" > #include "attribs.h" > -#include "tree-pass.h" > > const char * const tls_model_names[]=3D{"none", "emulated", > "global-dynamic", "local-dynamic", > -- > 2.43.0 >