middle-end: Add and use few helper methods for current_properties

While working on isel, I found that the current way of doing current_properties
in function can easily make a mistake and having to do stuff like `(a & b ) == 0`
and `a |= b;` and `a &= ~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

and use them in the source; I didn't change of the backends which has a few 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_set_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 include.
	(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_property.
	* read-rtl-function.cc (function_reader::create_function): Use set_property
	* varpool.cc: Remove tree-pass.h include as PROP_* moved to function.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_property.
	* 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::profitable_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 <quic_apinski@quicinc.com>
---
 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(-)

On Sat, Jul 27, 2024 at 4:29 AM Andrew Pinski <quic_apinski@quicinc.com> wrote:
>
> While working on isel, I found that the current way of doing current_properties
> in function can easily make a mistake and having to do stuff like `(a & b ) == 0`
> and `a |= b;` and `a &= ~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 become
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 few 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_set_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 include.
>         (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_property.
>         * read-rtl-function.cc (function_reader::create_function): Use set_property
>         * varpool.cc: Remove tree-pass.h include as PROP_* moved to function.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_property.
>         * 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::profitable_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 <quic_apinski@quicinc.com>
> ---
>  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 ATTRIBUTE_UNUSED,
>            boundaries would violate language semantics.  */
>         if (SCALAR_FLOAT_TYPE_P (type)
>             && flag_fp_contract_mode == 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 = false, neg_add = code == 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 == cdil_gimple_ssa)
>         {
>           init_ssa_operands (cfun);
> -         cfun->curr_properties |= 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 = entry_bb_count;
>        gcov_type t = 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 &parser, 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 &parser, 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, gimple_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, parser,
>                                                              &dest_index, &prob))
>         parser.push_edge (parser.current_bb->index, dest_index,
> @@ -2413,7 +2413,7 @@ c_parser_gimple_if_stmt (gimple_parser &parser, gimple_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, parser,
>                                                              &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 &= ~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 *rtx_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 &= ~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 &= ~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) != 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 something
> @@ -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 = true;
> -      cfun->curr_properties |= PROP_ssa;
> +      cfun->set_property (PROP_ssa);
>      }
>
>    DECL_INITIAL (decl) = 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) != 0)
> +               && (DECL_STRUCT_FUNCTION (node->decl)
> +                    ->prop_set_p (PROP_assumptions_done)))
>               continue;
>             error_found = 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 = NULL;
>    f->machine = NULL;
>    f->cfg = NULL;
> -  f->curr_properties &= ~PROP_cfg;
> +  f->unset_property (PROP_cfg);
>    delete f->cond_uids;
>
>    regno_reg_rtx = 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 != 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 control 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 directives */
> +#define PROP_cfglayout         (1 << 9)        /* cfglayout mode on RTL */
> +#define PROP_gimple_lcx                (1 << 10)       /* lowered complex */
> +#define PROP_loops             (1 << 11)       /* preserve loop structures */
> +#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 internal function.  */
> +#define PROP_gimple_opt_math   (1 << 15)       /* Disable canonicalization
> +                                                  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_lomp)
> +
>  /* 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) != -1);
> +    curr_properties |= 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) != -1);
> +    curr_properties &= ~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) != -1);
> +    return (curr_properties & prop) != 0;
> +  }
> +
> +  /* Returns true if the current properties is set to gimple. */
> +
> +  bool gimple_prop_p () const
> +  {
> +    return (curr_properties & PROP_gimple) != 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) == 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) == 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 = DECL_STRUCT_FUNCTION (fndecl);
> -  return (gimple_body (fndecl) || (fn && fn->cfg && !(fn->curr_properties & PROP_rtl)));
> +  return (gimple_body (fndecl) || (fn && fn->cfg && !fn->prop_set_p (PROP_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) == 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) == 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) != 0;
> +  return !cfun || cfun->prop_set_p (PROP_gimple_lvec);
>  }
>
>  /* Return true if we can still perform transformations that may introduce
> @@ -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) == 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 conditions 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) == 0)
> +      && !cfun->prop_set_p (PROP_gimple_any))
>      {
>        tree variant = omp_resolve_declare_variant (fndecl);
>        if (variant != fndecl)
> @@ -19571,7 +19571,7 @@ gimplify_function_tree (tree fndecl)
>
>    /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
>       if necessary.  */
> -  cfun->curr_properties |= PROP_gimple_lva;
> +  cfun->set_property (PROP_gimple_lva);
>
>    if (asan_sanitize_use_after_scope ())
>      asan_poisoned_variables = new hash_set<tree> ();
> @@ -19683,7 +19683,7 @@ gimplify_function_tree (tree fndecl)
>      }
>
>    DECL_SAVED_TREE (fndecl) = NULL_TREE;
> -  cfun->curr_properties |= PROP_gimple_any;
> +  cfun->set_property (PROP_gimple_any);
>
>    pop_cfun ();
>
> @@ -19776,7 +19776,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p,
>
>    /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
>       needs to be expanded.  */
> -  cfun->curr_properties &= ~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 = flow_loops_find (NULL);
> @@ -99,7 +99,7 @@ loop_optimizer_init (unsigned flags)
>        bool recorded_exits = loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS);
>        bool needs_fixup = 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 does.  */
>        calculate_dominance_info (CDI_DOMINATORS);
> @@ -155,7 +155,7 @@ loop_optimizer_finalize (struct function *fn, bool clean_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 &= ~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 &= ~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 &= ~PROP_gimple_lomp_dev;
> +      cfun->unset_property (PROP_gimple_lomp_dev);
>        is_simt = safelen_int > 1;
>      }
>    tree simt_lane = NULL_TREE, simt_maxlane = 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) == 0)
> +  if (cfun && !cfun->prop_set_p (PROP_gimple_any))
>      {
>        enum tree_code construct = 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) != 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 == OMP_TRAIT_SET_IMPLEMENTATION)
>                 {
> -                 if (cfun && (cfun->curr_properties & PROP_gimple_any) != 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 == OMP_TRAIT_SET_IMPLEMENTATION)
>                 {
> -                 if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
> +                 if (cfun && cfun->prop_set_p (PROP_gimple_any))
>                     break;
>
>                   if ((omp_requires_mask & OMP_REQUIRES_UNIFIED_ADDRESS) == 0)
> @@ -1641,7 +1641,7 @@ omp_context_selector_matches (tree ctx)
>             case OMP_TRAIT_IMPLEMENTATION_UNIFIED_SHARED_MEMORY:
>               if (set == OMP_TRAIT_SET_IMPLEMENTATION)
>                 {
> -                 if (cfun && (cfun->curr_properties & PROP_gimple_any) != 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 == OMP_TRAIT_SET_IMPLEMENTATION)
>                 {
> -                 if (cfun && (cfun->curr_properties & PROP_gimple_any) != 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 == OMP_TRAIT_SET_IMPLEMENTATION)
>                 {
> -                 if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
> +                 if (cfun && cfun->prop_set_p (PROP_gimple_any))
>                     break;
>
>                   if ((omp_requires_mask & OMP_REQUIRES_REVERSE_OFFLOAD) == 0)
> @@ -2492,7 +2492,7 @@ tree
>  omp_resolve_declare_variant (tree base)
>  {
>    tree variant1 = NULL_TREE, variant2 = NULL_TREE;
> -  if (cfun && (cfun->curr_properties & PROP_gimple_any) != 0)
> +  if (cfun && cfun->prop_set_p (PROP_gimple_any))
>      return omp_resolve_late_declare_variant (base);
>
>    auto_vec <tree, 16> 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 = 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 = g->get_dumps ();
> @@ -1842,7 +1842,7 @@ emergency_dump_function ()
>    /* Normally the passmanager will close the graphs as a pass could be wanting
>       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_flags);
>        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 = (cfun && (cfun->curr_properties & PROP_gimple)) != 0;
> +  in_gimple_form = (cfun && cfun->gimple_prop_p ()) != 0;
>
>    pass_init_dump_file (pass);
>
> @@ -2372,7 +2372,7 @@ execute_all_ipa_transforms (bool do_not_collect)
>
>    int j = 0;
>    gcc::pass_manager *passes = g->get_passes ();
> -  bool report = profile_report && (cfun->curr_properties & PROP_gimple) != 0;
> +  bool report = 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") == 0)
>      {
>        cfg_layout_rtl_register_cfg_hooks ();
> -      cfun->curr_properties |= PROP_cfglayout;
> +      cfun->set_property (PROP_cfglayout);
>      }
>    if (strcmp (pass->name, "outof_cfglayout") == 0)
>      {
>        rtl_register_cfg_hooks ();
> -      cfun->curr_properties &= ~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 function
>          are not miscounted.  */
> -      if (profile_report && cfun && (cfun->curr_properties & PROP_cfg)
> +      if (profile_report && cfun && cfun->prop_set_p (PROP_cfg)
>           && pass->type != IPA_PASS && pass->type != 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 = (cfun && (cfun->curr_properties & PROP_gimple)) != 0;
> +  in_gimple_form = 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 |= PROP_assumptions_done;
> +         cfun->set_property (PROP_assumptions_done);
>           pop_cfun ();
>           current_pass = NULL;
>           return true;
> @@ -2698,7 +2698,7 @@ execute_one_pass (opt_pass *pass)
>         ;
>        else if (pass->type == 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 != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
> -    gcc_assert (!(cfun->curr_properties & PROP_gimple)
> -               || pass->type != RTL_PASS);
> +    gcc_assert (!cfun->gimple_prop_p () || pass->type != RTL_PASS);
>
>    current_pass = 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 = current_function_decl;
>
>    /* Mark this function as being specified as __RTL.  */
> -  cfun->curr_properties |= 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 |= 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, dump_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, dump_flags_t flags)
>
>    /* When GIMPLE is lowered, the variables are no longer available in
>       BIND_EXPRs, so display them separately.  */
> -  if (fun && fun->decl == fndecl && (fun->curr_properties & PROP_gimple_lcf))
> +  if (fun && fun->decl == fndecl && fun->prop_set_p (PROP_gimple_lcf))
>      {
>        unsigned ix;
>        ignore_topmost_bind = true;
> @@ -8486,7 +8486,7 @@ dump_function_to_file (tree fndecl, FILE *file, dump_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, copy_body_data *id,
>       variables to be added to IFN_GOMP_SIMT_ENTER argument list.  */
>    dst_cfun = DECL_STRUCT_FUNCTION (id->dst_fn);
>    simtvars_save = id->dst_simt_vars;
> -  if (!(dst_cfun->curr_properties & PROP_gimple_lomp_dev)
> +  if (!dst_cfun->prop_set_p (PROP_gimple_lomp_dev)
>        && (simduid = bb->loop_father->simduid) != NULL_TREE
>        && (simduid = ssa_default_def (dst_cfun, simduid)) != NULL_TREE
>        && single_imm_use (simduid, &use, &simtenter_stmt)
> @@ -6424,9 +6424,9 @@ tree_function_versioning (tree old_decl, tree new_decl,
>    /* Set up the destination functions loop tree.  */
>    if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl)) != NULL)
>      {
> -      cfun->curr_properties &= ~PROP_loops;
> +      cfun->unset_property (PROP_loops);
>        loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
> -      cfun->curr_properties |= 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 = 0;
>    if (parallelize_loops (oacc_kernels_p))
>      {
> -      fun->curr_properties &= ~(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 control 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 directives */
> -#define PROP_cfglayout         (1 << 9)        /* cfglayout mode on RTL */
> -#define PROP_gimple_lcx                (1 << 10)       /* lowered complex */
> -#define PROP_loops             (1 << 11)       /* preserve loop structures */
> -#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 internal function.  */
> -#define PROP_gimple_opt_math   (1 << 15)       /* Disable canonicalization
> -                                                  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_lomp)
>
>  /* 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) == 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 the
> 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<vn_reference_op_s> *result)
>                        __builtin_object_size had a chance to run.  */
>                     if (TREE_CODE (orig) != 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 == ADDR_EXPR
>        && operands.last ().opcode == SSA_NAME)
>      {
> @@ -4146,7 +4146,7 @@ vn_reference_insert (tree op, tree result, tree vuse, tree vdef)
>      = 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 == ADDR_EXPR
>        && operands.last ().opcode == 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, basic_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, early_bb)
>        && !dominated_by_p (CDI_DOMINATORS, best_bb->loop_father->latch, best_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<basic_block> &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
>               >= param_max_jump_thread_duplication_stmts)))
>      {
> @@ -869,7 +869,7 @@ back_threader_profitability::profitable_path_p (const vec<basic_block> &m_path,
>       loop optimizations to fail.  Disable these threads until after
>       loop optimizations have run.  */
>    if ((m_threaded_through_latch || taken_edge->dest == 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_taken, bitmap not_reg_needs,
>             }
>         }
>        else if (TREE_CODE (TREE_TYPE (var)) == BITINT_TYPE
> -              && (cfun->curr_properties & PROP_gimple_lbitint) != 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) == 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) == 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 call, tree fndecl)
>      if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
>        fndecl = decl;
>
> -  bool gimple_form = (cfun && (cfun->curr_properties & PROP_gimple)) != 0;
> +  bool gimple_form = 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[]={"none", "emulated",
>                                       "global-dynamic", "local-dynamic",
> --
> 2.43.0
>