coretypes.h (gimple_seq, [...]): Typedef as gimple.
* coretypes.h (gimple_seq, const_gimple_seq): Typedef as gimple. * gimple.h (struct gimple_seq_node_d, struct gimple_seq_d): Remove. (const_gimple_seq_node): Remove. (gimple_seq_node): Typedef as gimple. (struct gimple_statement_base): Add next and prev members, adjust all WORD markers in using structs. (union gimple_statement_d): Link via gsbase.next field for GC and PCH. (gimple_seq_first, gimple_seq_first_stmt, gimple_seq_last, gimple_seq_last_stmt): Adjust as gimple_seq, gimple_seq_node and gimple are the same. (gimple_seq_set_last, gimple_seq_set_first): Don't allocate gimple_seq, adjust. (gimple_init_singleton): New function. (gsi_start_1, gsi_last_1, gsi_end_p, gsi_one_before_end_p): Adjust. (gsi_next, gsi_prev): Adjust, handle prev cyclic list correctly. (gsi_stmt): Adjust. (gsi_stmt_ptr): Remove. (enum gimple_alloc_kind): Remove gimple_alloc_kind_seq member. * gimple-iterator.c (update_bb_for_stmts): Take last parameter again, adjust for above changes. (update_call_edge_frequencies): Adjust for above changes. (gsi_insert_seq_nodes_before): Rewrite for new data structure. (gsi_insert_seq_nodes_after): Ditto. (gsi_split_seq_after): Ditto. (gsi_set_stmt): Ditto. (gsi_split_seq_before): Ditto. (gsi_remove): Ditto. (gsi_insert_seq_before_without_update): Don't free sequence. (gsi_insert_seq_after_without_update): Ditto. (gsi_replace): Assert some more invariants. (gsi_insert_before_without_update, gsi_insert_after_without_update): Tidy. (gsi_for_stmt): Don't search for stmt. (gsi_insert_on_edge_immediate): Tidy. * gimple.c (gimple_alloc_k): Remove "sequences". (gimple_seq_cache): Remove. (gimple_alloc_stat): Make stmt a singleton sequence. (gimple_seq_alloc, gimple_seq_free): Remove. (gimple_assign_set_rhs_with_ops_1): Ensure new stmt is a singleton. (gimple_copy): Ditto. * gimplify.c (gimplify_cleanup_point_expr): Use gsi_set_stmt, create iterator from correct sequence. * tree-phinodes.c (make_phi_node): Make stmt a singleton. * gimple.h (gimple_stmt_iterator <seq>): Make it be pointer to gimple_seq. (gimple_seq_set_last, gimple_seq_set_first): Take pointer to sequence, lazily allocate it. (bb_seq_addr): New function. (gsi_start_1): Rename from gsi_start, but take pointer to sequence. (gsi_start): Macro to wrap gsi_start_1 taking pointer of argument. (gsi_none): New function. (gsi_start_bb): Adjust. (gsi_last_1): Rename from gsi_last, but take pointer to sequence. (gsi_last): Macro to wrap gsi_last_1 taking pointer of argument. (gsi_last_bb): Adjust. (gsi_seq): Adjust. * tree-flow-inline.h (phi_nodes_ptr): New function. * gimple-iterator.c (gsi_insert_seq_nodes_before): Adjust to datastructure and interface change. (gsi_insert_seq_before_without_update): Ditto. (gsi_insert_seq_nodes_after): Ditto. (gsi_insert_seq_after_without_update): Ditto. (gsi_split_seq_after): Ditto, don't use gimple_seq_alloc. (gsi_split_seq_before): Ditto. (gsi_start_phis): Adjust. * tree-vect-loop.c (vect_determine_vectorization_factor): Use gsi_none. (vect_transform_loop): Ditto. * gimple.c (gimple_seq_add_stmt, gimple_seq_add_seq, gimple_seq_copy): Don't use gimple_seq_alloc. * gimplify.c (gimple_seq_add_stmt_without_update): Ditto. (gimplify_seq_add_seq): Ditto. * lto-streamer-in.c (make_new_block): Ditto. * tree-cfg.c (create_bb): Ditto. * tree-sra.c (initialize_parameter_reductions): Ditto. * gimple.h (gimple_seq_first, gimple_seq_first_stmt, gimple_seq_last, gimple_seq_last_stmt, gimple_seq_set_last, gimple_seq_set_first, gimple_seq_empty_p, gimple_seq_alloc_with_stmt, bb_seq, set_bb_seq): Move down to after gimple_statement_d definition. * gimple-fold.c (gimplify_and_update_call_from_tree): Use gsi_replace_with_seq, instead of inserting itself. * gimple-iterator.c (gsi_replace_with_seq): New function. * tree-ssa-forwprop.c (forward_propagate_comparison): Take iterator instead of statement, advance it. (ssa_forward_propagate_and_combine): Adjust call to above. * tree-phinodes.c (add_phi_node_to_bb): Tidy, don't use gimple_seq_alloc. * omp-low.c (finalize_task_copyfn): Don't use gimple_seq_alloc. * tree-nested.c (walk_gimple_omp_for): Ditto. * trans-mem.c (lower_transaction): Ditto. * tree-eh.c (do_return_redirection): Ditto. (do_goto_redirection): Ditto. (lower_try_finally_switch): Ditto. * gimplify.c (gimplify_stmt): Ditto. (gimplify_scan_omp_clauses): Ditto. (gimplify_omp_for): Ditto. (gimplify_function_tree): Ditto. * gimple-fold.c (gimplify_and_update_call_from_tree): Ditto. * tree-mudflap.c (mf_decl_cache_locals): Ditto. (mf_build_check_statement_for): Ditto. (mx_register_decls): Ditto. * graphite-sese-to-poly.c (remove_invariant_phi): Ditto, and don't use itertors to append. (insert_stmts): Ditto. (insert_out_of_ssa_copy): Ditto. (insert_out_of_ssa_copy_on_edge): Ditto. * gimple.h (gimple_bind_body_ptr): New function. (gimple_bind_body): Use it. (gimple_catch_handler): Use gimple_catch_handler_ptr. (gimple_eh_filter_failure_ptr): New function. (gimple_eh_filter_failure): Use it. (gimple_eh_else_n_body_ptr): New function. (gimple_eh_else_n_body): Use it. (gimple_eh_else_e_body_ptr): New function. (gimple_eh_else_e_body): Use it. (gimple_try_eval_ptr): New function. (gimple_try_eval): Use it. (gimple_try_cleanup_ptr): New function. (gimple_try_cleanup): Use it. (gimple_wce_cleanup_ptr): New function. (gimple_wce_cleanup): Use it. (gimple_omp_body_ptr): New function. (gimple_omp_body): Use it. (gimple_omp_for_pre_body_ptr): New function. (gimple_omp_for_pre_body): Use it. (gimple_transaction_body_ptr): New function. (gimple_transaction_body): Use it. (gsi_split_seq_before): Adjust to return nothing and take pointer to sequence. (gsi_set_stmt): Declare. (gsi_replace_with_seq): Declare. (walk_gimple_seq_mod): Declare. * function.h (struct function <gimple_body>): Use typedef gimple_seq. * gimple-iterator.c (gsi_set_stmt): New function. (gsi_split_seq_before): Return new sequence via pointer argument. (gsi_replace): Use gsi_set_stmt. * tree-ssa-loop-im.c (move_computations_stmt): First remove then insert stmt. * tree-complex.c (update_complex_components_on_edge): Don't copy gsi. * tree-phinodes.c (resize_phi_node): Don't resize stmt in-place, return new stmt. (reserve_phi_args_for_new_edge): Change call to above, use gsi_set_stmt. * omp-low.c (lower_omp): Change prototype to take pointer to sequence. (lower_rec_input_clauses): Use gimple_seq_add_seq instead of iterators. Adjust call to lower_omp. (lower_lastprivate_clauses): Adjust call to lower_omp. (lower_reduction_clauses): Ditto. (expand_omp_taskreg): Nullify non-cfg body of child_fn. (lower_omp_sections): Don't explicitely count sequence length, nullify lowered bodies earlier, ensure stmts are part of only one sequence, adjust call to lower_omp. (lower_omp_single): Ensure stmts are part of only one sequence, adjust call to lower_omp. (lower_omp_master): Ditto. (lower_omp_ordered): Ditto. (lower_omp_critical): Ditto. (lower_omp_for): Ditto. (lower_omp_taskreg): Ditto, tidy. (lower_omp_1): Adjust calls to lower_omp. (execute_lower_omp): Ditto. (lower_omp): Adjust to take pointer to sequence. (diagnose_sb_2): Use walk_gimple_seq_mod. (diagnose_omp_structured_block_errors): Ditto and set possibly changed function body. * gimple-low.c (lower_function_body): Set function body after it stabilizes. (lower_sequence): Adjust to take pointer to sequence. (lower_omp_directive): Ensure stmt isn't put twice into the sequence, adjust call to lower_sequence. (lower_stmt): Adjust calls to lower_sequence. (lower_gimple_bind): Ditto. (gimple_try_catch_may_fallthru): Call gsi_start with lvalue. * tree-nested.c (walk_body): Take pointer to sequence, use walk_gimple_seq_mod. (walk_function): Adjust call to walk_body, set possibly changed body. (walk_gimple_omp_for): Adjust calls to walk_body. (convert_nonlocal_omp_clauses): Ditto. (convert_nonlocal_reference_stmt): Ditto. (convert_local_omp_clauses): Ditto. (convert_local_reference_stmt): Ditto. (convert_tramp_reference_stmt): Ditto. (convert_gimple_call): Ditto. (convert_nl_goto_reference): Use local iterator copy. * gimple.c (walk_gimple_seq_mod): Renamed from walk_gimple_seq, but taking pointer to sequence, ensure gsi_start is called with callers lvalue. (walk_gimple_seq): New wrapper around walk_gimple_seq_mod, asserting that the sequence head didn't change. (walk_gimple_stmt): Replace all calls to walk_gimple_seq with walk_gimple_seq_mod. * trans-mem.c (lower_transaction): Use walk_gimple_seq_mod. (execute_lower_tm): Ditto, and set possibly changed body. * tree-eh.c (lower_eh_constructs_1): Take pointer to sequence, call gsi_start with that lvalue. (replace_goto_queue_stmt_list): Ditto. (replace_goto_queue_1): Adjust calls to replace_goto_queue_stmt_list. (replace_goto_queue): Ditto. (lower_try_finally_nofallthru): Adjust calls to lower_eh_constructs_1. (lower_try_finally_onedest): Ditto. (lower_try_finally_copy): Ditto. (lower_try_finally_switch): Ditto. (lower_try_finally): Ditto. (lower_eh_filter): Ditto. (lower_eh_must_not_throw): Ditto. (lower_cleanup): Ditto. (lower_eh_constructs_2): Ditto. (lower_catch): Ditto, and ensure gsi_start is called with lvalue. (lower_eh_constructs): Adjust calls to lower_eh_constructs_1, and set possibly changed body. (optimize_double_finally): Call gsi_start with lvalue. * tree-cfg.c (make_blocks): Adjust call to gsi_split_seq_before. (gimple_split_block): Ditto. (gimple_merge_blocks): Use gsi_start_phis. (move_stmt_r): Use walk_gimple_seq_mod. * tree-ssa-dse.c (dse_enter_block): Use gsi_last_bb. * cgraphbuild.c (build_cgraph_edges): Use gsi_start_phis. (rebuild_cgraph_edges): Ditto. (cgraph_rebuild_references): Ditto. * ipa-prop.c (ipa_analyze_params_uses): Ditto. * tree-inline.c (copy_phis_for_bb): Ditto. * tree-ssa-dce.c: Ditto. * cgraphunit.c (cgraph_analyze_function): Use gimple_has_body_p. From-SVN: r187053
This commit is contained in:
Michael Matz
parent
63dc7fbee0
commit
355a767352
30 changed files with 1074 additions and 738 deletions
254
gcc/ChangeLog
254
gcc/ChangeLog
|
|
@ -1,7 +1,259 @@
|
|||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* coretypes.h (gimple_seq, const_gimple_seq): Typedef as gimple.
|
||||
* gimple.h (struct gimple_seq_node_d, struct gimple_seq_d): Remove.
|
||||
(const_gimple_seq_node): Remove.
|
||||
(gimple_seq_node): Typedef as gimple.
|
||||
(struct gimple_statement_base): Add next and prev members,
|
||||
adjust all WORD markers in using structs.
|
||||
(union gimple_statement_d): Link via gsbase.next field for GC and PCH.
|
||||
(gimple_seq_first, gimple_seq_first_stmt, gimple_seq_last,
|
||||
gimple_seq_last_stmt): Adjust as gimple_seq, gimple_seq_node and
|
||||
gimple are the same.
|
||||
(gimple_seq_set_last, gimple_seq_set_first): Don't allocate
|
||||
gimple_seq, adjust.
|
||||
(gimple_init_singleton): New function.
|
||||
(gsi_start_1, gsi_last_1, gsi_end_p, gsi_one_before_end_p): Adjust.
|
||||
(gsi_next, gsi_prev): Adjust, handle prev cyclic list correctly.
|
||||
(gsi_stmt): Adjust.
|
||||
(gsi_stmt_ptr): Remove.
|
||||
(enum gimple_alloc_kind): Remove gimple_alloc_kind_seq member.
|
||||
|
||||
* gimple-iterator.c (update_bb_for_stmts): Take last parameter
|
||||
again, adjust for above changes.
|
||||
(update_call_edge_frequencies): Adjust for above changes.
|
||||
(gsi_insert_seq_nodes_before): Rewrite for new data structure.
|
||||
(gsi_insert_seq_nodes_after): Ditto.
|
||||
(gsi_split_seq_after): Ditto.
|
||||
(gsi_set_stmt): Ditto.
|
||||
(gsi_split_seq_before): Ditto.
|
||||
(gsi_remove): Ditto.
|
||||
(gsi_insert_seq_before_without_update): Don't free sequence.
|
||||
(gsi_insert_seq_after_without_update): Ditto.
|
||||
(gsi_replace): Assert some more invariants.
|
||||
(gsi_insert_before_without_update, gsi_insert_after_without_update):
|
||||
Tidy.
|
||||
(gsi_for_stmt): Don't search for stmt.
|
||||
(gsi_insert_on_edge_immediate): Tidy.
|
||||
|
||||
* gimple.c (gimple_alloc_k): Remove "sequences".
|
||||
(gimple_seq_cache): Remove.
|
||||
(gimple_alloc_stat): Make stmt a singleton sequence.
|
||||
(gimple_seq_alloc, gimple_seq_free): Remove.
|
||||
(gimple_assign_set_rhs_with_ops_1): Ensure new stmt is a singleton.
|
||||
(gimple_copy): Ditto.
|
||||
* gimplify.c (gimplify_cleanup_point_expr): Use gsi_set_stmt,
|
||||
create iterator from correct sequence.
|
||||
* tree-phinodes.c (make_phi_node): Make stmt a singleton.
|
||||
|
||||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* gimple.h (gimple_stmt_iterator <seq>): Make it be pointer to
|
||||
gimple_seq.
|
||||
(gimple_seq_set_last, gimple_seq_set_first): Take pointer to
|
||||
sequence, lazily allocate it.
|
||||
(bb_seq_addr): New function.
|
||||
(gsi_start_1): Rename from gsi_start, but take pointer to sequence.
|
||||
(gsi_start): Macro to wrap gsi_start_1 taking pointer of argument.
|
||||
(gsi_none): New function.
|
||||
(gsi_start_bb): Adjust.
|
||||
(gsi_last_1): Rename from gsi_last, but take pointer to sequence.
|
||||
(gsi_last): Macro to wrap gsi_last_1 taking pointer of argument.
|
||||
(gsi_last_bb): Adjust.
|
||||
(gsi_seq): Adjust.
|
||||
* tree-flow-inline.h (phi_nodes_ptr): New function.
|
||||
|
||||
* gimple-iterator.c (gsi_insert_seq_nodes_before): Adjust to
|
||||
datastructure and interface change.
|
||||
(gsi_insert_seq_before_without_update): Ditto.
|
||||
(gsi_insert_seq_nodes_after): Ditto.
|
||||
(gsi_insert_seq_after_without_update): Ditto.
|
||||
(gsi_split_seq_after): Ditto, don't use gimple_seq_alloc.
|
||||
(gsi_split_seq_before): Ditto.
|
||||
(gsi_start_phis): Adjust.
|
||||
* tree-vect-loop.c (vect_determine_vectorization_factor): Use
|
||||
gsi_none.
|
||||
(vect_transform_loop): Ditto.
|
||||
* gimple.c (gimple_seq_add_stmt, gimple_seq_add_seq,
|
||||
gimple_seq_copy): Don't use gimple_seq_alloc.
|
||||
* gimplify.c (gimple_seq_add_stmt_without_update): Ditto.
|
||||
(gimplify_seq_add_seq): Ditto.
|
||||
* lto-streamer-in.c (make_new_block): Ditto.
|
||||
* tree-cfg.c (create_bb): Ditto.
|
||||
* tree-sra.c (initialize_parameter_reductions): Ditto.
|
||||
|
||||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* gimple.h (gimple_seq_first, gimple_seq_first_stmt, gimple_seq_last,
|
||||
gimple_seq_last_stmt, gimple_seq_set_last, gimple_seq_set_first,
|
||||
gimple_seq_empty_p, gimple_seq_alloc_with_stmt, bb_seq,
|
||||
set_bb_seq): Move down to after gimple_statement_d definition.
|
||||
|
||||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* gimple-fold.c (gimplify_and_update_call_from_tree): Use
|
||||
gsi_replace_with_seq, instead of inserting itself.
|
||||
* gimple-iterator.c (gsi_replace_with_seq): New function.
|
||||
* tree-ssa-forwprop.c (forward_propagate_comparison): Take
|
||||
iterator instead of statement, advance it.
|
||||
(ssa_forward_propagate_and_combine): Adjust call to above.
|
||||
|
||||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* tree-phinodes.c (add_phi_node_to_bb): Tidy, don't use
|
||||
gimple_seq_alloc.
|
||||
* omp-low.c (finalize_task_copyfn): Don't use gimple_seq_alloc.
|
||||
* tree-nested.c (walk_gimple_omp_for): Ditto.
|
||||
* trans-mem.c (lower_transaction): Ditto.
|
||||
* tree-eh.c (do_return_redirection): Ditto.
|
||||
(do_goto_redirection): Ditto.
|
||||
(lower_try_finally_switch): Ditto.
|
||||
* gimplify.c (gimplify_stmt): Ditto.
|
||||
(gimplify_scan_omp_clauses): Ditto.
|
||||
(gimplify_omp_for): Ditto.
|
||||
(gimplify_function_tree): Ditto.
|
||||
* gimple-fold.c (gimplify_and_update_call_from_tree): Ditto.
|
||||
* tree-mudflap.c (mf_decl_cache_locals): Ditto.
|
||||
(mf_build_check_statement_for): Ditto.
|
||||
(mx_register_decls): Ditto.
|
||||
* graphite-sese-to-poly.c (remove_invariant_phi): Ditto,
|
||||
and don't use itertors to append.
|
||||
(insert_stmts): Ditto.
|
||||
(insert_out_of_ssa_copy): Ditto.
|
||||
(insert_out_of_ssa_copy_on_edge): Ditto.
|
||||
|
||||
2012-05-02 Michael Matz <matz@suse.de>
|
||||
|
||||
* gimple.h (gimple_bind_body_ptr): New function.
|
||||
(gimple_bind_body): Use it.
|
||||
(gimple_catch_handler): Use gimple_catch_handler_ptr.
|
||||
(gimple_eh_filter_failure_ptr): New function.
|
||||
(gimple_eh_filter_failure): Use it.
|
||||
(gimple_eh_else_n_body_ptr): New function.
|
||||
(gimple_eh_else_n_body): Use it.
|
||||
(gimple_eh_else_e_body_ptr): New function.
|
||||
(gimple_eh_else_e_body): Use it.
|
||||
(gimple_try_eval_ptr): New function.
|
||||
(gimple_try_eval): Use it.
|
||||
(gimple_try_cleanup_ptr): New function.
|
||||
(gimple_try_cleanup): Use it.
|
||||
(gimple_wce_cleanup_ptr): New function.
|
||||
(gimple_wce_cleanup): Use it.
|
||||
(gimple_omp_body_ptr): New function.
|
||||
(gimple_omp_body): Use it.
|
||||
(gimple_omp_for_pre_body_ptr): New function.
|
||||
(gimple_omp_for_pre_body): Use it.
|
||||
(gimple_transaction_body_ptr): New function.
|
||||
(gimple_transaction_body): Use it.
|
||||
(gsi_split_seq_before): Adjust to return nothing and take pointer
|
||||
to sequence.
|
||||
(gsi_set_stmt): Declare.
|
||||
(gsi_replace_with_seq): Declare.
|
||||
(walk_gimple_seq_mod): Declare.
|
||||
* function.h (struct function <gimple_body>): Use typedef gimple_seq.
|
||||
|
||||
* gimple-iterator.c (gsi_set_stmt): New function.
|
||||
(gsi_split_seq_before): Return new sequence via pointer argument.
|
||||
(gsi_replace): Use gsi_set_stmt.
|
||||
|
||||
* tree-ssa-loop-im.c (move_computations_stmt): First remove
|
||||
then insert stmt.
|
||||
* tree-complex.c (update_complex_components_on_edge): Don't
|
||||
copy gsi.
|
||||
* tree-phinodes.c (resize_phi_node): Don't resize stmt in-place,
|
||||
return new stmt.
|
||||
(reserve_phi_args_for_new_edge): Change call to above,
|
||||
use gsi_set_stmt.
|
||||
|
||||
* omp-low.c (lower_omp): Change prototype to take pointer to
|
||||
sequence.
|
||||
(lower_rec_input_clauses): Use gimple_seq_add_seq instead of
|
||||
iterators. Adjust call to lower_omp.
|
||||
(lower_lastprivate_clauses): Adjust call to lower_omp.
|
||||
(lower_reduction_clauses): Ditto.
|
||||
(expand_omp_taskreg): Nullify non-cfg body of child_fn.
|
||||
(lower_omp_sections): Don't explicitely count sequence length,
|
||||
nullify lowered bodies earlier, ensure stmts are part of only
|
||||
one sequence, adjust call to lower_omp.
|
||||
(lower_omp_single): Ensure stmts are part of only one sequence,
|
||||
adjust call to lower_omp.
|
||||
(lower_omp_master): Ditto.
|
||||
(lower_omp_ordered): Ditto.
|
||||
(lower_omp_critical): Ditto.
|
||||
(lower_omp_for): Ditto.
|
||||
(lower_omp_taskreg): Ditto, tidy.
|
||||
(lower_omp_1): Adjust calls to lower_omp.
|
||||
(execute_lower_omp): Ditto.
|
||||
(lower_omp): Adjust to take pointer to sequence.
|
||||
(diagnose_sb_2): Use walk_gimple_seq_mod.
|
||||
(diagnose_omp_structured_block_errors): Ditto and set possibly
|
||||
changed function body.
|
||||
* gimple-low.c (lower_function_body): Set function body after
|
||||
it stabilizes.
|
||||
(lower_sequence): Adjust to take pointer to sequence.
|
||||
(lower_omp_directive): Ensure stmt isn't put twice into the
|
||||
sequence, adjust call to lower_sequence.
|
||||
(lower_stmt): Adjust calls to lower_sequence.
|
||||
(lower_gimple_bind): Ditto.
|
||||
(gimple_try_catch_may_fallthru): Call gsi_start with lvalue.
|
||||
* tree-nested.c (walk_body): Take pointer to sequence, use
|
||||
walk_gimple_seq_mod.
|
||||
(walk_function): Adjust call to walk_body, set possibly changed
|
||||
body.
|
||||
(walk_gimple_omp_for): Adjust calls to walk_body.
|
||||
(convert_nonlocal_omp_clauses): Ditto.
|
||||
(convert_nonlocal_reference_stmt): Ditto.
|
||||
(convert_local_omp_clauses): Ditto.
|
||||
(convert_local_reference_stmt): Ditto.
|
||||
(convert_tramp_reference_stmt): Ditto.
|
||||
(convert_gimple_call): Ditto.
|
||||
(convert_nl_goto_reference): Use local iterator copy.
|
||||
* gimple.c (walk_gimple_seq_mod): Renamed from walk_gimple_seq,
|
||||
but taking pointer to sequence, ensure gsi_start is called with
|
||||
callers lvalue.
|
||||
(walk_gimple_seq): New wrapper around walk_gimple_seq_mod,
|
||||
asserting that the sequence head didn't change.
|
||||
(walk_gimple_stmt): Replace all calls to walk_gimple_seq with
|
||||
walk_gimple_seq_mod.
|
||||
* trans-mem.c (lower_transaction): Use walk_gimple_seq_mod.
|
||||
(execute_lower_tm): Ditto, and set possibly changed body.
|
||||
* tree-eh.c (lower_eh_constructs_1): Take pointer to sequence,
|
||||
call gsi_start with that lvalue.
|
||||
(replace_goto_queue_stmt_list): Ditto.
|
||||
(replace_goto_queue_1): Adjust calls to replace_goto_queue_stmt_list.
|
||||
(replace_goto_queue): Ditto.
|
||||
(lower_try_finally_nofallthru): Adjust calls to lower_eh_constructs_1.
|
||||
(lower_try_finally_onedest): Ditto.
|
||||
(lower_try_finally_copy): Ditto.
|
||||
(lower_try_finally_switch): Ditto.
|
||||
(lower_try_finally): Ditto.
|
||||
(lower_eh_filter): Ditto.
|
||||
(lower_eh_must_not_throw): Ditto.
|
||||
(lower_cleanup): Ditto.
|
||||
(lower_eh_constructs_2): Ditto.
|
||||
(lower_catch): Ditto, and ensure gsi_start is called with lvalue.
|
||||
(lower_eh_constructs): Adjust calls to lower_eh_constructs_1, and
|
||||
set possibly changed body.
|
||||
(optimize_double_finally): Call gsi_start with lvalue.
|
||||
|
||||
* tree-cfg.c (make_blocks): Adjust call to gsi_split_seq_before.
|
||||
(gimple_split_block): Ditto.
|
||||
(gimple_merge_blocks): Use gsi_start_phis.
|
||||
(move_stmt_r): Use walk_gimple_seq_mod.
|
||||
* tree-ssa-dse.c (dse_enter_block): Use gsi_last_bb.
|
||||
* cgraphbuild.c (build_cgraph_edges): Use gsi_start_phis.
|
||||
(rebuild_cgraph_edges): Ditto.
|
||||
(cgraph_rebuild_references): Ditto.
|
||||
* ipa-prop.c (ipa_analyze_params_uses): Ditto.
|
||||
* tree-inline.c (copy_phis_for_bb): Ditto.
|
||||
* tree-ssa-dce.c: Ditto.
|
||||
|
||||
* cgraphunit.c (cgraph_analyze_function): Use gimple_has_body_p.
|
||||
|
||||
2012-05-02 Kirill Yukhin <kirill.yukhin@intel.com>
|
||||
Andi Kleen <ak@linux.intel.com>
|
||||
|
||||
* coretypes (MEMMODEL_MASK): New.
|
||||
* coretypes.h (MEMMODEL_MASK): New.
|
||||
* builtins.c (get_memmodel): Add val. Call target.memmodel_check
|
||||
and return new variable.
|
||||
(expand_builtin_atomic_exchange): Mask memmodel values.
|
||||
|
|
|
|||
|
|
@ -348,7 +348,7 @@ build_cgraph_edges (void)
|
|||
IPA_REF_ADDR, stmt);
|
||||
}
|
||||
}
|
||||
for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
walk_stmt_load_store_addr_ops (gsi_stmt (gsi), node,
|
||||
mark_load, mark_store, mark_address);
|
||||
}
|
||||
|
|
@ -440,7 +440,7 @@ rebuild_cgraph_edges (void)
|
|||
mark_store, mark_address);
|
||||
|
||||
}
|
||||
for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
walk_stmt_load_store_addr_ops (gsi_stmt (gsi), node,
|
||||
mark_load, mark_store, mark_address);
|
||||
}
|
||||
|
|
@ -474,7 +474,7 @@ cgraph_rebuild_references (void)
|
|||
mark_store, mark_address);
|
||||
|
||||
}
|
||||
for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
walk_stmt_load_store_addr_ops (gsi_stmt (gsi), node,
|
||||
mark_load, mark_store, mark_address);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -646,7 +646,7 @@ cgraph_analyze_function (struct cgraph_node *node)
|
|||
function we lower it, which will require gimplified nested
|
||||
functions, so we can end up here with an already gimplified
|
||||
body. */
|
||||
if (!gimple_body (decl))
|
||||
if (!gimple_has_body_p (decl))
|
||||
gimplify_function_tree (decl);
|
||||
dump_function (TDI_generic, decl);
|
||||
|
||||
|
|
|
|||
|
|
@ -72,9 +72,8 @@ struct cl_decoded_option;
|
|||
struct cl_option_handlers;
|
||||
struct diagnostic_context;
|
||||
typedef struct diagnostic_context diagnostic_context;
|
||||
struct gimple_seq_d;
|
||||
typedef struct gimple_seq_d *gimple_seq;
|
||||
typedef const struct gimple_seq_d *const_gimple_seq;
|
||||
typedef gimple gimple_seq;
|
||||
typedef gimple const_gimple_seq;
|
||||
|
||||
/* Address space number for named address space support. */
|
||||
typedef unsigned char addr_space_t;
|
||||
|
|
|
|||
|
|
@ -507,7 +507,7 @@ struct GTY(()) function {
|
|||
struct control_flow_graph *cfg;
|
||||
|
||||
/* GIMPLE body for this function. */
|
||||
struct gimple_seq_d *gimple_body;
|
||||
gimple_seq gimple_body;
|
||||
|
||||
/* SSA and dataflow information. */
|
||||
struct gimple_df *gimple_df;
|
||||
|
|
|
|||
|
|
@ -549,9 +549,8 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
|||
tree lhs;
|
||||
gimple stmt, new_stmt;
|
||||
gimple_stmt_iterator i;
|
||||
gimple_seq stmts = gimple_seq_alloc();
|
||||
gimple_seq stmts = NULL;
|
||||
struct gimplify_ctx gctx;
|
||||
gimple last;
|
||||
gimple laststore;
|
||||
tree reaching_vuse;
|
||||
|
||||
|
|
@ -620,17 +619,9 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
|||
|
||||
/* Second iterate over the statements forward, assigning virtual
|
||||
operands to their uses. */
|
||||
last = NULL;
|
||||
reaching_vuse = gimple_vuse (stmt);
|
||||
for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
|
||||
{
|
||||
/* Do not insert the last stmt in this loop but remember it
|
||||
for replacing the original statement. */
|
||||
if (last)
|
||||
{
|
||||
gsi_insert_before (si_p, last, GSI_NEW_STMT);
|
||||
gsi_next (si_p);
|
||||
}
|
||||
new_stmt = gsi_stmt (i);
|
||||
/* The replacement can expose previously unreferenced variables. */
|
||||
if (gimple_in_ssa_p (cfun))
|
||||
|
|
@ -642,7 +633,6 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
|||
gimple_set_modified (new_stmt, true);
|
||||
if (gimple_vdef (new_stmt))
|
||||
reaching_vuse = gimple_vdef (new_stmt);
|
||||
last = new_stmt;
|
||||
}
|
||||
|
||||
/* If the new sequence does not do a store release the virtual
|
||||
|
|
@ -659,8 +649,8 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
|
|||
}
|
||||
}
|
||||
|
||||
/* Finally replace rhe original statement with the last. */
|
||||
gsi_replace (si_p, last, false);
|
||||
/* Finally replace the original statement with the sequence. */
|
||||
gsi_replace_with_seq (si_p, stmts, false);
|
||||
}
|
||||
|
||||
/* Return the string length, maximum string length or maximum value of
|
||||
|
|
|
|||
|
|
@ -57,12 +57,17 @@ update_modified_stmts (gimple_seq seq)
|
|||
starting at FIRST and LAST. */
|
||||
|
||||
static void
|
||||
update_bb_for_stmts (gimple_seq_node first, basic_block bb)
|
||||
update_bb_for_stmts (gimple_seq_node first, gimple_seq_node last,
|
||||
basic_block bb)
|
||||
{
|
||||
gimple_seq_node n;
|
||||
|
||||
for (n = first; n; n = n->next)
|
||||
gimple_set_bb (n->stmt, bb);
|
||||
for (n = first; n; n = n->gsbase.next)
|
||||
{
|
||||
gimple_set_bb (n, bb);
|
||||
if (n == last)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Set the frequencies for the cgraph_edges for each of the calls
|
||||
|
|
@ -75,8 +80,8 @@ update_call_edge_frequencies (gimple_seq_node first, basic_block bb)
|
|||
int bb_freq = 0;
|
||||
gimple_seq_node n;
|
||||
|
||||
for (n = first; n ; n = n->next)
|
||||
if (is_gimple_call (n->stmt))
|
||||
for (n = first; n ; n = n->gsbase.next)
|
||||
if (is_gimple_call (n))
|
||||
{
|
||||
struct cgraph_edge *e;
|
||||
|
||||
|
|
@ -89,7 +94,7 @@ update_call_edge_frequencies (gimple_seq_node first, basic_block bb)
|
|||
(current_function_decl, bb));
|
||||
}
|
||||
|
||||
e = cgraph_edge (cfun_node, n->stmt);
|
||||
e = cgraph_edge (cfun_node, n);
|
||||
if (e != NULL)
|
||||
e->frequency = bb_freq;
|
||||
}
|
||||
|
|
@ -113,32 +118,37 @@ gsi_insert_seq_nodes_before (gimple_stmt_iterator *i,
|
|||
basic_block bb;
|
||||
gimple_seq_node cur = i->ptr;
|
||||
|
||||
gcc_assert (!cur || cur->gsbase.prev);
|
||||
|
||||
if ((bb = gsi_bb (*i)) != NULL)
|
||||
update_bb_for_stmts (first, bb);
|
||||
update_bb_for_stmts (first, last, bb);
|
||||
|
||||
/* Link SEQ before CUR in the sequence. */
|
||||
if (cur)
|
||||
{
|
||||
first->prev = cur->prev;
|
||||
if (first->prev)
|
||||
first->prev->next = first;
|
||||
first->gsbase.prev = cur->gsbase.prev;
|
||||
if (first->gsbase.prev->gsbase.next)
|
||||
first->gsbase.prev->gsbase.next = first;
|
||||
else
|
||||
gimple_seq_set_first (i->seq, first);
|
||||
last->next = cur;
|
||||
cur->prev = last;
|
||||
last->gsbase.next = cur;
|
||||
cur->gsbase.prev = last;
|
||||
}
|
||||
else
|
||||
{
|
||||
gimple_seq_node itlast = gimple_seq_last (i->seq);
|
||||
gimple_seq_node itlast = gimple_seq_last (*i->seq);
|
||||
|
||||
/* If CUR is NULL, we link at the end of the sequence (this case happens
|
||||
when gsi_after_labels is called for a basic block that contains only
|
||||
labels, so it returns an iterator after the end of the block, and
|
||||
we need to insert before it; it might be cleaner to add a flag to the
|
||||
iterator saying whether we are at the start or end of the list). */
|
||||
first->prev = itlast;
|
||||
last->gsbase.next = NULL;
|
||||
if (itlast)
|
||||
itlast->next = first;
|
||||
{
|
||||
first->gsbase.prev = itlast;
|
||||
itlast->gsbase.next = first;
|
||||
}
|
||||
else
|
||||
gimple_seq_set_first (i->seq, first);
|
||||
gimple_seq_set_last (i->seq, last);
|
||||
|
|
@ -178,15 +188,11 @@ gsi_insert_seq_before_without_update (gimple_stmt_iterator *i, gimple_seq seq,
|
|||
return;
|
||||
|
||||
/* Don't allow inserting a sequence into itself. */
|
||||
gcc_assert (seq != i->seq);
|
||||
gcc_assert (seq != *i->seq);
|
||||
|
||||
first = gimple_seq_first (seq);
|
||||
last = gimple_seq_last (seq);
|
||||
|
||||
gimple_seq_set_first (seq, NULL);
|
||||
gimple_seq_set_last (seq, NULL);
|
||||
gimple_seq_free (seq);
|
||||
|
||||
/* Empty sequences need no work. */
|
||||
if (!first || !last)
|
||||
{
|
||||
|
|
@ -230,25 +236,30 @@ gsi_insert_seq_nodes_after (gimple_stmt_iterator *i,
|
|||
basic_block bb;
|
||||
gimple_seq_node cur = i->ptr;
|
||||
|
||||
gcc_assert (!cur || cur->gsbase.prev);
|
||||
|
||||
/* If the iterator is inside a basic block, we need to update the
|
||||
basic block information for all the nodes between FIRST and LAST. */
|
||||
if ((bb = gsi_bb (*i)) != NULL)
|
||||
update_bb_for_stmts (first, bb);
|
||||
update_bb_for_stmts (first, last, bb);
|
||||
|
||||
/* Link SEQ after CUR. */
|
||||
if (cur)
|
||||
{
|
||||
last->next = cur->next;
|
||||
if (last->next)
|
||||
last->next->prev = last;
|
||||
last->gsbase.next = cur->gsbase.next;
|
||||
if (last->gsbase.next)
|
||||
{
|
||||
last->gsbase.next->gsbase.prev = last;
|
||||
}
|
||||
else
|
||||
gimple_seq_set_last (i->seq, last);
|
||||
first->prev = cur;
|
||||
cur->next = first;
|
||||
first->gsbase.prev = cur;
|
||||
cur->gsbase.next = first;
|
||||
}
|
||||
else
|
||||
{
|
||||
gcc_assert (!gimple_seq_last (i->seq));
|
||||
gcc_assert (!gimple_seq_last (*i->seq));
|
||||
last->gsbase.next = NULL;
|
||||
gimple_seq_set_first (i->seq, first);
|
||||
gimple_seq_set_last (i->seq, last);
|
||||
}
|
||||
|
|
@ -289,15 +300,11 @@ gsi_insert_seq_after_without_update (gimple_stmt_iterator *i, gimple_seq seq,
|
|||
return;
|
||||
|
||||
/* Don't allow inserting a sequence into itself. */
|
||||
gcc_assert (seq != i->seq);
|
||||
gcc_assert (seq != *i->seq);
|
||||
|
||||
first = gimple_seq_first (seq);
|
||||
last = gimple_seq_last (seq);
|
||||
|
||||
gimple_seq_set_first (seq, NULL);
|
||||
gimple_seq_set_last (seq, NULL);
|
||||
gimple_seq_free (seq);
|
||||
|
||||
/* Empty sequences need no work. */
|
||||
if (!first || !last)
|
||||
{
|
||||
|
|
@ -329,59 +336,81 @@ gimple_seq
|
|||
gsi_split_seq_after (gimple_stmt_iterator i)
|
||||
{
|
||||
gimple_seq_node cur, next;
|
||||
gimple_seq old_seq, new_seq;
|
||||
gimple_seq *pold_seq, new_seq;
|
||||
|
||||
cur = i.ptr;
|
||||
|
||||
/* How can we possibly split after the end, or before the beginning? */
|
||||
gcc_assert (cur && cur->next);
|
||||
next = cur->next;
|
||||
gcc_assert (cur && cur->gsbase.next);
|
||||
next = cur->gsbase.next;
|
||||
|
||||
old_seq = i.seq;
|
||||
new_seq = gimple_seq_alloc ();
|
||||
pold_seq = i.seq;
|
||||
|
||||
gimple_seq_set_first (new_seq, next);
|
||||
gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
|
||||
gimple_seq_set_last (old_seq, cur);
|
||||
cur->next = NULL;
|
||||
next->prev = NULL;
|
||||
gimple_seq_set_first (&new_seq, next);
|
||||
gimple_seq_set_last (&new_seq, gimple_seq_last (*pold_seq));
|
||||
gimple_seq_set_last (pold_seq, cur);
|
||||
cur->gsbase.next = NULL;
|
||||
|
||||
return new_seq;
|
||||
}
|
||||
|
||||
|
||||
/* Set the statement to which GSI points to STMT. This only updates
|
||||
the iterator and the gimple sequence, it doesn't do the bookkeeping
|
||||
of gsi_replace. */
|
||||
|
||||
void
|
||||
gsi_set_stmt (gimple_stmt_iterator *gsi, gimple stmt)
|
||||
{
|
||||
gimple orig_stmt = gsi_stmt (*gsi);
|
||||
gimple prev, next;
|
||||
|
||||
stmt->gsbase.next = next = orig_stmt->gsbase.next;
|
||||
stmt->gsbase.prev = prev = orig_stmt->gsbase.prev;
|
||||
/* Note how we don't clear next/prev of orig_stmt. This is so that
|
||||
copies of *GSI our callers might still hold (to orig_stmt)
|
||||
can be advanced as if they too were replaced. */
|
||||
if (prev->gsbase.next)
|
||||
prev->gsbase.next = stmt;
|
||||
else
|
||||
gimple_seq_set_first (gsi->seq, stmt);
|
||||
if (next)
|
||||
next->gsbase.prev = stmt;
|
||||
else
|
||||
gimple_seq_set_last (gsi->seq, stmt);
|
||||
|
||||
gsi->ptr = stmt;
|
||||
}
|
||||
|
||||
|
||||
/* Move all statements in the sequence before I to a new sequence.
|
||||
Return this new sequence. I is set to the head of the new list. */
|
||||
|
||||
gimple_seq
|
||||
gsi_split_seq_before (gimple_stmt_iterator *i)
|
||||
void
|
||||
gsi_split_seq_before (gimple_stmt_iterator *i, gimple_seq *pnew_seq)
|
||||
{
|
||||
gimple_seq_node cur, prev;
|
||||
gimple_seq old_seq, new_seq;
|
||||
gimple_seq old_seq;
|
||||
|
||||
cur = i->ptr;
|
||||
|
||||
/* How can we possibly split after the end? */
|
||||
gcc_assert (cur);
|
||||
prev = cur->prev;
|
||||
prev = cur->gsbase.prev;
|
||||
|
||||
old_seq = i->seq;
|
||||
new_seq = gimple_seq_alloc ();
|
||||
i->seq = new_seq;
|
||||
old_seq = *i->seq;
|
||||
if (!prev->gsbase.next)
|
||||
*i->seq = NULL;
|
||||
i->seq = pnew_seq;
|
||||
|
||||
/* Set the limits on NEW_SEQ. */
|
||||
gimple_seq_set_first (new_seq, cur);
|
||||
gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
|
||||
gimple_seq_set_first (pnew_seq, cur);
|
||||
gimple_seq_set_last (pnew_seq, gimple_seq_last (old_seq));
|
||||
|
||||
/* Cut OLD_SEQ before I. */
|
||||
gimple_seq_set_last (old_seq, prev);
|
||||
cur->prev = NULL;
|
||||
if (prev)
|
||||
prev->next = NULL;
|
||||
else
|
||||
gimple_seq_set_first (old_seq, NULL);
|
||||
|
||||
return new_seq;
|
||||
gimple_seq_set_last (&old_seq, prev);
|
||||
if (prev->gsbase.next)
|
||||
prev->gsbase.next = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -416,12 +445,38 @@ gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info)
|
|||
gimple_remove_stmt_histograms (cfun, orig_stmt);
|
||||
delink_stmt_imm_use (orig_stmt);
|
||||
|
||||
*gsi_stmt_ptr (gsi) = stmt;
|
||||
gsi_set_stmt (gsi, stmt);
|
||||
gimple_set_modified (stmt, true);
|
||||
update_modified_stmt (stmt);
|
||||
}
|
||||
|
||||
|
||||
/* Replace the statement pointed-to by GSI with the sequence SEQ.
|
||||
If UPDATE_EH_INFO is true, the exception handling information of
|
||||
the original statement is moved to the last statement of the new
|
||||
sequence. If the old statement is an assignment, then so must
|
||||
be the last statement of the new sequence, and they must have the
|
||||
same LHS. */
|
||||
|
||||
void
|
||||
gsi_replace_with_seq (gimple_stmt_iterator *gsi, gimple_seq seq,
|
||||
bool update_eh_info)
|
||||
{
|
||||
gimple_stmt_iterator seqi;
|
||||
gimple last;
|
||||
if (gimple_seq_empty_p (seq))
|
||||
{
|
||||
gsi_remove (gsi, true);
|
||||
return;
|
||||
}
|
||||
seqi = gsi_last (seq);
|
||||
last = gsi_stmt (seqi);
|
||||
gsi_remove (&seqi, false);
|
||||
gsi_insert_seq_before (gsi, seq, GSI_SAME_STMT);
|
||||
gsi_replace (gsi, last, update_eh_info);
|
||||
}
|
||||
|
||||
|
||||
/* Insert statement STMT before the statement pointed-to by iterator I.
|
||||
M specifies how to update iterator I after insertion (see enum
|
||||
gsi_iterator_update).
|
||||
|
|
@ -435,12 +490,7 @@ void
|
|||
gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt,
|
||||
enum gsi_iterator_update m)
|
||||
{
|
||||
gimple_seq_node n;
|
||||
|
||||
n = ggc_alloc_gimple_seq_node_d ();
|
||||
n->prev = n->next = NULL;
|
||||
n->stmt = stmt;
|
||||
gsi_insert_seq_nodes_before (i, n, n, m);
|
||||
gsi_insert_seq_nodes_before (i, stmt, stmt, m);
|
||||
}
|
||||
|
||||
/* Insert statement STMT before the statement pointed-to by iterator I.
|
||||
|
|
@ -470,12 +520,7 @@ void
|
|||
gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt,
|
||||
enum gsi_iterator_update m)
|
||||
{
|
||||
gimple_seq_node n;
|
||||
|
||||
n = ggc_alloc_gimple_seq_node_d ();
|
||||
n->prev = n->next = NULL;
|
||||
n->stmt = stmt;
|
||||
gsi_insert_seq_nodes_after (i, n, n, m);
|
||||
gsi_insert_seq_nodes_after (i, stmt, stmt, m);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -525,19 +570,24 @@ gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
|
|||
|
||||
/* Update the iterator and re-wire the links in I->SEQ. */
|
||||
cur = i->ptr;
|
||||
next = cur->next;
|
||||
prev = cur->prev;
|
||||
|
||||
if (prev)
|
||||
prev->next = next;
|
||||
else
|
||||
gimple_seq_set_first (i->seq, next);
|
||||
next = cur->gsbase.next;
|
||||
prev = cur->gsbase.prev;
|
||||
/* See gsi_set_stmt for why we don't reset prev/next of STMT. */
|
||||
|
||||
if (next)
|
||||
next->prev = prev;
|
||||
else
|
||||
/* Cur is not last. */
|
||||
next->gsbase.prev = prev;
|
||||
else if (prev->gsbase.next)
|
||||
/* Cur is last but not first. */
|
||||
gimple_seq_set_last (i->seq, prev);
|
||||
|
||||
if (prev->gsbase.next)
|
||||
/* Cur is not first. */
|
||||
prev->gsbase.next = next;
|
||||
else
|
||||
/* Cur is first. */
|
||||
*i->seq = next;
|
||||
|
||||
i->ptr = next;
|
||||
|
||||
return require_eh_edge_purge;
|
||||
|
|
@ -557,11 +607,8 @@ gsi_for_stmt (gimple stmt)
|
|||
else
|
||||
i = gsi_start_bb (bb);
|
||||
|
||||
for (; !gsi_end_p (i); gsi_next (&i))
|
||||
if (gsi_stmt (i) == stmt)
|
||||
return i;
|
||||
|
||||
gcc_unreachable ();
|
||||
i.ptr = stmt;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -727,7 +774,6 @@ basic_block
|
|||
gsi_insert_on_edge_immediate (edge e, gimple stmt)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
struct gimple_seq_node_d node;
|
||||
basic_block new_bb = NULL;
|
||||
bool ins_after;
|
||||
|
||||
|
|
@ -735,9 +781,7 @@ gsi_insert_on_edge_immediate (edge e, gimple stmt)
|
|||
|
||||
ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb);
|
||||
|
||||
node.stmt = stmt;
|
||||
node.prev = node.next = NULL;
|
||||
update_call_edge_frequencies (&node, gsi.bb);
|
||||
update_call_edge_frequencies (stmt, gsi.bb);
|
||||
|
||||
if (ins_after)
|
||||
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
|
||||
|
|
@ -820,5 +864,7 @@ gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
|
|||
gimple_stmt_iterator
|
||||
gsi_start_phis (basic_block bb)
|
||||
{
|
||||
return gsi_start (phi_nodes (bb));
|
||||
gimple_seq *pseq = phi_nodes_ptr (bb);
|
||||
/* XXX check only necessary because ENTRY/EXIT blocks don't have il.gimple */
|
||||
return pseq ? gsi_start_1 (pseq) : gsi_none ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -112,10 +112,6 @@ lower_function_body (void)
|
|||
i = gsi_start (lowered_body);
|
||||
lower_gimple_bind (&i, &data);
|
||||
|
||||
/* Once the old body has been lowered, replace it with the new
|
||||
lowered sequence. */
|
||||
gimple_set_body (current_function_decl, lowered_body);
|
||||
|
||||
i = gsi_last (lowered_body);
|
||||
|
||||
/* If the function falls off the end, we need a null return statement.
|
||||
|
|
@ -179,6 +175,10 @@ lower_function_body (void)
|
|||
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
||||
}
|
||||
|
||||
/* Once the old body has been lowered, replace it with the new
|
||||
lowered sequence. */
|
||||
gimple_set_body (current_function_decl, lowered_body);
|
||||
|
||||
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
|
||||
BLOCK_SUBBLOCKS (data.block)
|
||||
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
|
||||
|
|
@ -305,11 +305,11 @@ gimple_check_call_matching_types (gimple call_stmt, tree callee)
|
|||
do it explicitly. DATA is passed through the recursion. */
|
||||
|
||||
static void
|
||||
lower_sequence (gimple_seq seq, struct lower_data *data)
|
||||
lower_sequence (gimple_seq *seq, struct lower_data *data)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
|
||||
for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
|
||||
for (gsi = gsi_start (*seq); !gsi_end_p (gsi); )
|
||||
lower_stmt (&gsi, data);
|
||||
}
|
||||
|
||||
|
|
@ -324,11 +324,10 @@ lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
|
|||
|
||||
stmt = gsi_stmt (*gsi);
|
||||
|
||||
lower_sequence (gimple_omp_body (stmt), data);
|
||||
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
||||
gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
|
||||
lower_sequence (gimple_omp_body_ptr (stmt), data);
|
||||
gsi_insert_seq_after (gsi, gimple_omp_body (stmt), GSI_CONTINUE_LINKING);
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
gsi_remove (gsi, false);
|
||||
gsi_next (gsi);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -376,10 +375,10 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
|
|||
case GIMPLE_TRY:
|
||||
{
|
||||
bool try_cannot_fallthru;
|
||||
lower_sequence (gimple_try_eval (stmt), data);
|
||||
lower_sequence (gimple_try_eval_ptr (stmt), data);
|
||||
try_cannot_fallthru = data->cannot_fallthru;
|
||||
data->cannot_fallthru = false;
|
||||
lower_sequence (gimple_try_cleanup (stmt), data);
|
||||
lower_sequence (gimple_try_cleanup_ptr (stmt), data);
|
||||
/* See gimple_stmt_may_fallthru for the rationale. */
|
||||
if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
|
||||
{
|
||||
|
|
@ -392,17 +391,17 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
|
|||
|
||||
case GIMPLE_CATCH:
|
||||
data->cannot_fallthru = false;
|
||||
lower_sequence (gimple_catch_handler (stmt), data);
|
||||
lower_sequence (gimple_catch_handler_ptr (stmt), data);
|
||||
break;
|
||||
|
||||
case GIMPLE_EH_FILTER:
|
||||
data->cannot_fallthru = false;
|
||||
lower_sequence (gimple_eh_filter_failure (stmt), data);
|
||||
lower_sequence (gimple_eh_filter_failure_ptr (stmt), data);
|
||||
break;
|
||||
|
||||
case GIMPLE_EH_ELSE:
|
||||
lower_sequence (gimple_eh_else_n_body (stmt), data);
|
||||
lower_sequence (gimple_eh_else_e_body (stmt), data);
|
||||
lower_sequence (gimple_eh_else_n_body_ptr (stmt), data);
|
||||
lower_sequence (gimple_eh_else_e_body_ptr (stmt), data);
|
||||
break;
|
||||
|
||||
case GIMPLE_NOP:
|
||||
|
|
@ -456,7 +455,7 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
|
|||
return;
|
||||
|
||||
case GIMPLE_TRANSACTION:
|
||||
lower_sequence (gimple_transaction_body (stmt), data);
|
||||
lower_sequence (gimple_transaction_body_ptr (stmt), data);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -505,7 +504,7 @@ lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
|
|||
}
|
||||
|
||||
record_vars (gimple_bind_vars (stmt));
|
||||
lower_sequence (gimple_bind_body (stmt), data);
|
||||
lower_sequence (gimple_bind_body_ptr (stmt), data);
|
||||
|
||||
if (new_block)
|
||||
{
|
||||
|
|
@ -585,7 +584,7 @@ gimple_try_catch_may_fallthru (gimple stmt)
|
|||
if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
|
||||
return true;
|
||||
|
||||
i = gsi_start (gimple_try_cleanup (stmt));
|
||||
i = gsi_start (*gimple_try_cleanup_ptr (stmt));
|
||||
switch (gimple_code (gsi_stmt (i)))
|
||||
{
|
||||
case GIMPLE_CATCH:
|
||||
|
|
|
|||
116
gcc/gimple.c
116
gcc/gimple.c
|
|
@ -90,16 +90,11 @@ static const char * const gimple_alloc_kind_names[] = {
|
|||
"assignments",
|
||||
"phi nodes",
|
||||
"conditionals",
|
||||
"sequences",
|
||||
"everything else"
|
||||
};
|
||||
|
||||
#endif /* GATHER_STATISTICS */
|
||||
|
||||
/* A cache of gimple_seq objects. Sequences are created and destroyed
|
||||
fairly often during gimplification. */
|
||||
static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
|
||||
|
||||
/* Private API manipulation functions shared only with some
|
||||
other files. */
|
||||
extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
|
||||
|
|
@ -154,6 +149,7 @@ gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
|
|||
/* Do not call gimple_set_modified here as it has other side
|
||||
effects and this tuple is still not completely built. */
|
||||
stmt->gsbase.modified = 1;
|
||||
gimple_init_singleton (stmt);
|
||||
|
||||
return stmt;
|
||||
}
|
||||
|
|
@ -1201,53 +1197,6 @@ gimple_check_failed (const_gimple gs, const char *file, int line,
|
|||
#endif /* ENABLE_GIMPLE_CHECKING */
|
||||
|
||||
|
||||
/* Allocate a new GIMPLE sequence in GC memory and return it. If
|
||||
there are free sequences in GIMPLE_SEQ_CACHE return one of those
|
||||
instead. */
|
||||
|
||||
gimple_seq
|
||||
gimple_seq_alloc (void)
|
||||
{
|
||||
gimple_seq seq = gimple_seq_cache;
|
||||
if (seq)
|
||||
{
|
||||
gimple_seq_cache = gimple_seq_cache->next_free;
|
||||
gcc_assert (gimple_seq_cache != seq);
|
||||
memset (seq, 0, sizeof (*seq));
|
||||
}
|
||||
else
|
||||
{
|
||||
seq = ggc_alloc_cleared_gimple_seq_d ();
|
||||
#ifdef GATHER_STATISTICS
|
||||
gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
|
||||
gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
|
||||
#endif
|
||||
}
|
||||
|
||||
return seq;
|
||||
}
|
||||
|
||||
/* Return SEQ to the free pool of GIMPLE sequences. */
|
||||
|
||||
void
|
||||
gimple_seq_free (gimple_seq seq)
|
||||
{
|
||||
if (seq == NULL)
|
||||
return;
|
||||
|
||||
gcc_assert (gimple_seq_first (seq) == NULL);
|
||||
gcc_assert (gimple_seq_last (seq) == NULL);
|
||||
|
||||
/* If this triggers, it's a sign that the same list is being freed
|
||||
twice. */
|
||||
gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
|
||||
|
||||
/* Add SEQ to the pool of free sequences. */
|
||||
seq->next_free = gimple_seq_cache;
|
||||
gimple_seq_cache = seq;
|
||||
}
|
||||
|
||||
|
||||
/* Link gimple statement GS to the end of the sequence *SEQ_P. If
|
||||
*SEQ_P is NULL, a new sequence is allocated. */
|
||||
|
||||
|
|
@ -1255,13 +1204,9 @@ void
|
|||
gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
|
||||
{
|
||||
gimple_stmt_iterator si;
|
||||
|
||||
if (gs == NULL)
|
||||
return;
|
||||
|
||||
if (*seq_p == NULL)
|
||||
*seq_p = gimple_seq_alloc ();
|
||||
|
||||
si = gsi_last (*seq_p);
|
||||
gsi_insert_after (&si, gs, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
@ -1274,13 +1219,9 @@ void
|
|||
gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
|
||||
{
|
||||
gimple_stmt_iterator si;
|
||||
|
||||
if (src == NULL)
|
||||
return;
|
||||
|
||||
if (*dst_p == NULL)
|
||||
*dst_p = gimple_seq_alloc ();
|
||||
|
||||
si = gsi_last (*dst_p);
|
||||
gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
@ -1324,7 +1265,7 @@ gimple_seq
|
|||
gimple_seq_copy (gimple_seq src)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
gimple_seq new_seq = gimple_seq_alloc ();
|
||||
gimple_seq new_seq = NULL;
|
||||
gimple stmt;
|
||||
|
||||
for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
|
|
@ -1337,7 +1278,7 @@ gimple_seq_copy (gimple_seq src)
|
|||
}
|
||||
|
||||
|
||||
/* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
|
||||
/* Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
|
||||
on each one. WI is as in walk_gimple_stmt.
|
||||
|
||||
If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
|
||||
|
|
@ -1349,12 +1290,12 @@ gimple_seq_copy (gimple_seq src)
|
|||
Otherwise, all the statements are walked and NULL returned. */
|
||||
|
||||
gimple
|
||||
walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
|
||||
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
||||
walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
|
||||
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
|
||||
for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
|
||||
for (gsi = gsi_start (*pseq); !gsi_end_p (gsi); )
|
||||
{
|
||||
tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
|
||||
if (ret)
|
||||
|
|
@ -1378,6 +1319,20 @@ walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
|
|||
}
|
||||
|
||||
|
||||
/* Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
|
||||
changed by the callbacks. */
|
||||
|
||||
gimple
|
||||
walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
|
||||
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
||||
{
|
||||
gimple_seq seq2 = seq;
|
||||
gimple ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
|
||||
gcc_assert (seq2 == seq);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
|
||||
|
||||
static tree
|
||||
|
|
@ -1808,51 +1763,51 @@ walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
|
|||
switch (gimple_code (stmt))
|
||||
{
|
||||
case GIMPLE_BIND:
|
||||
ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
ret = walk_gimple_seq_mod (gimple_bind_body_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_CATCH:
|
||||
ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
ret = walk_gimple_seq_mod (gimple_catch_handler_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_EH_FILTER:
|
||||
ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
|
||||
ret = walk_gimple_seq_mod (gimple_eh_filter_failure_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_EH_ELSE:
|
||||
ret = walk_gimple_seq (gimple_eh_else_n_body (stmt),
|
||||
ret = walk_gimple_seq_mod (gimple_eh_else_n_body_ptr (stmt),
|
||||
callback_stmt, callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
ret = walk_gimple_seq (gimple_eh_else_e_body (stmt),
|
||||
ret = walk_gimple_seq_mod (gimple_eh_else_e_body_ptr (stmt),
|
||||
callback_stmt, callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_TRY:
|
||||
ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
|
||||
ret = walk_gimple_seq_mod (gimple_try_eval_ptr (stmt), callback_stmt, callback_op,
|
||||
wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
|
||||
ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
|
||||
ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_OMP_FOR:
|
||||
ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
|
||||
ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
|
|
@ -1866,21 +1821,21 @@ walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
|
|||
case GIMPLE_OMP_TASK:
|
||||
case GIMPLE_OMP_SECTIONS:
|
||||
case GIMPLE_OMP_SINGLE:
|
||||
ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt,
|
||||
ret = walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_WITH_CLEANUP_EXPR:
|
||||
ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
|
||||
ret = walk_gimple_seq_mod (gimple_wce_cleanup_ptr (stmt), callback_stmt,
|
||||
callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
break;
|
||||
|
||||
case GIMPLE_TRANSACTION:
|
||||
ret = walk_gimple_seq (gimple_transaction_body (stmt),
|
||||
ret = walk_gimple_seq_mod (gimple_transaction_body_ptr (stmt),
|
||||
callback_stmt, callback_op, wi);
|
||||
if (ret)
|
||||
return wi->callback_result;
|
||||
|
|
@ -2181,6 +2136,7 @@ gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code
|
|||
tree lhs = gimple_assign_lhs (stmt);
|
||||
gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
|
||||
memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
|
||||
gimple_init_singleton (new_stmt);
|
||||
gsi_replace (gsi, new_stmt, true);
|
||||
stmt = new_stmt;
|
||||
|
||||
|
|
@ -2270,7 +2226,8 @@ gimple_replace_lhs (gimple stmt, tree nlhs)
|
|||
|
||||
/* Return a deep copy of statement STMT. All the operands from STMT
|
||||
are reallocated and copied using unshare_expr. The DEF, USE, VDEF
|
||||
and VUSE operand arrays are set to empty in the new copy. */
|
||||
and VUSE operand arrays are set to empty in the new copy. The new
|
||||
copy isn't part of any sequence. */
|
||||
|
||||
gimple
|
||||
gimple_copy (gimple stmt)
|
||||
|
|
@ -2282,6 +2239,7 @@ gimple_copy (gimple stmt)
|
|||
|
||||
/* Shallow copy all the fields from STMT. */
|
||||
memcpy (copy, stmt, gimple_size (code));
|
||||
gimple_init_singleton (copy);
|
||||
|
||||
/* If STMT has sub-statements, deep-copy them as well. */
|
||||
if (gimple_has_substatements (stmt))
|
||||
|
|
|
|||
638
gcc/gimple.h
638
gcc/gimple.h
File diff suppressed because it is too large
Load diff
|
|
@ -169,11 +169,7 @@ gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
|
|||
if (gs == NULL)
|
||||
return;
|
||||
|
||||
if (*seq_p == NULL)
|
||||
*seq_p = gimple_seq_alloc ();
|
||||
|
||||
si = gsi_last (*seq_p);
|
||||
|
||||
gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
|
||||
}
|
||||
|
||||
|
|
@ -200,9 +196,6 @@ gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
|
|||
if (src == NULL)
|
||||
return;
|
||||
|
||||
if (*dst_p == NULL)
|
||||
*dst_p = gimple_seq_alloc ();
|
||||
|
||||
si = gsi_last (*dst_p);
|
||||
gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
|
||||
}
|
||||
|
|
@ -5467,8 +5460,8 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
|
|||
gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
|
||||
/* Do not use gsi_replace here, as it may scan operands.
|
||||
We want to do a simple structural modification only. */
|
||||
*gsi_stmt_ptr (&iter) = gtry;
|
||||
iter = gsi_start (seq);
|
||||
gsi_set_stmt (&iter, gtry);
|
||||
iter = gsi_start (gtry->gimple_try.eval);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -5650,9 +5643,6 @@ gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
|
|||
{
|
||||
gimple_seq_node last;
|
||||
|
||||
if (!*seq_p)
|
||||
*seq_p = gimple_seq_alloc ();
|
||||
|
||||
last = gimple_seq_last (*seq_p);
|
||||
gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
|
||||
return last != gimple_seq_last (*seq_p);
|
||||
|
|
@ -6149,8 +6139,8 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
|
|||
gimplify_omp_ctxp = ctx;
|
||||
push_gimplify_context (&gctx);
|
||||
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
|
||||
|
||||
gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
|
||||
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
|
||||
|
|
@ -6486,7 +6476,7 @@ gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
|
|||
gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
|
||||
OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
|
||||
|
||||
for_body = gimple_seq_alloc ();
|
||||
for_body = NULL;
|
||||
gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
|
||||
== TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
|
||||
gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
|
||||
|
|
@ -8322,7 +8312,7 @@ gimplify_function_tree (tree fndecl)
|
|||
|
||||
/* The tree body of the function is no longer needed, replace it
|
||||
with the new GIMPLE body. */
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
gimple_seq_add_stmt (&seq, bind);
|
||||
gimple_set_body (fndecl, seq);
|
||||
|
||||
|
|
@ -8371,7 +8361,7 @@ gimplify_function_tree (tree fndecl)
|
|||
|
||||
/* Replace the current function body with the body
|
||||
wrapped in the try/finally TF. */
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
gimple_seq_add_stmt (&seq, new_bind);
|
||||
gimple_set_body (fndecl, seq);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -87,8 +87,7 @@ remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
|
|||
edge e = gimple_phi_arg_edge (phi, entry);
|
||||
tree var;
|
||||
gimple stmt;
|
||||
gimple_seq stmts;
|
||||
gimple_stmt_iterator gsi;
|
||||
gimple_seq stmts = NULL;
|
||||
|
||||
if (tree_contains_chrecs (scev, NULL))
|
||||
scev = gimple_phi_arg_def (phi, entry);
|
||||
|
|
@ -97,11 +96,7 @@ remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
|
|||
stmt = gimple_build_assign (res, var);
|
||||
remove_phi_node (psi, false);
|
||||
|
||||
if (!stmts)
|
||||
stmts = gimple_seq_alloc ();
|
||||
|
||||
gsi = gsi_last (stmts);
|
||||
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
|
||||
gimple_seq_add_stmt (&stmts, stmt);
|
||||
gsi_insert_seq_on_edge (e, stmts);
|
||||
gsi_commit_edge_inserts ();
|
||||
SSA_NAME_DEF_STMT (res) = stmt;
|
||||
|
|
@ -2088,11 +2083,7 @@ insert_stmts (scop_p scop, gimple stmt, gimple_seq stmts,
|
|||
gimple_stmt_iterator gsi;
|
||||
VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
|
||||
|
||||
if (!stmts)
|
||||
stmts = gimple_seq_alloc ();
|
||||
|
||||
gsi = gsi_last (stmts);
|
||||
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
|
||||
gimple_seq_add_stmt (&stmts, stmt);
|
||||
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
|
||||
|
||||
|
|
@ -2107,16 +2098,12 @@ static void
|
|||
insert_out_of_ssa_copy (scop_p scop, tree res, tree expr, gimple after_stmt)
|
||||
{
|
||||
gimple_seq stmts;
|
||||
gimple_stmt_iterator si;
|
||||
gimple_stmt_iterator gsi;
|
||||
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
|
||||
gimple stmt = gimple_build_assign (res, var);
|
||||
VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
|
||||
|
||||
if (!stmts)
|
||||
stmts = gimple_seq_alloc ();
|
||||
si = gsi_last (stmts);
|
||||
gsi_insert_after (&si, stmt, GSI_NEW_STMT);
|
||||
gimple_seq_add_stmt (&stmts, stmt);
|
||||
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
|
||||
|
||||
|
|
@ -2167,17 +2154,13 @@ static void
|
|||
insert_out_of_ssa_copy_on_edge (scop_p scop, edge e, tree res, tree expr)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
gimple_seq stmts;
|
||||
gimple_seq stmts = NULL;
|
||||
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
|
||||
gimple stmt = gimple_build_assign (res, var);
|
||||
basic_block bb;
|
||||
VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
|
||||
|
||||
if (!stmts)
|
||||
stmts = gimple_seq_alloc ();
|
||||
|
||||
gsi = gsi_last (stmts);
|
||||
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
|
||||
gimple_seq_add_stmt (&stmts, stmt);
|
||||
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
|
||||
|
||||
|
|
|
|||
|
|
@ -1626,7 +1626,7 @@ ipa_analyze_params_uses (struct cgraph_node *node,
|
|||
visit_ref_for_mod_analysis,
|
||||
visit_ref_for_mod_analysis);
|
||||
}
|
||||
for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
|
||||
visit_ref_for_mod_analysis,
|
||||
visit_ref_for_mod_analysis,
|
||||
|
|
|
|||
|
|
@ -602,7 +602,7 @@ make_new_block (struct function *fn, unsigned int index)
|
|||
bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
|
||||
n_basic_blocks_for_function (fn)++;
|
||||
bb->flags = 0;
|
||||
set_bb_seq (bb, gimple_seq_alloc ());
|
||||
set_bb_seq (bb, NULL);
|
||||
return bb;
|
||||
}
|
||||
|
||||
|
|
|
|||
141
gcc/omp-low.c
141
gcc/omp-low.c
|
|
@ -158,7 +158,7 @@ scan_omp_op (tree *tp, omp_context *ctx)
|
|||
return walk_tree (tp, scan_omp_1_op, &wi, NULL);
|
||||
}
|
||||
|
||||
static void lower_omp (gimple_seq, omp_context *);
|
||||
static void lower_omp (gimple_seq *, omp_context *);
|
||||
static tree lookup_decl_in_outer_ctx (tree, omp_context *);
|
||||
static tree maybe_lookup_decl_in_outer_ctx (tree, omp_context *);
|
||||
|
||||
|
|
@ -1233,7 +1233,7 @@ finalize_task_copyfn (gimple task_stmt)
|
|||
{
|
||||
struct function *child_cfun;
|
||||
tree child_fn, old_fn;
|
||||
gimple_seq seq, new_seq;
|
||||
gimple_seq seq = NULL, new_seq;
|
||||
gimple bind;
|
||||
|
||||
child_fn = gimple_omp_task_copy_fn (task_stmt);
|
||||
|
|
@ -1250,13 +1250,12 @@ finalize_task_copyfn (gimple task_stmt)
|
|||
push_cfun (child_cfun);
|
||||
current_function_decl = child_fn;
|
||||
bind = gimplify_body (child_fn, false);
|
||||
seq = gimple_seq_alloc ();
|
||||
gimple_seq_add_stmt (&seq, bind);
|
||||
new_seq = maybe_catch_exception (seq);
|
||||
if (new_seq != seq)
|
||||
{
|
||||
bind = gimple_build_bind (NULL, new_seq, NULL);
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
gimple_seq_add_stmt (&seq, bind);
|
||||
}
|
||||
gimple_set_body (child_fn, seq);
|
||||
|
|
@ -2231,14 +2230,11 @@ static void
|
|||
lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
||||
omp_context *ctx)
|
||||
{
|
||||
gimple_stmt_iterator diter;
|
||||
tree c, dtor, copyin_seq, x, ptr;
|
||||
bool copyin_by_ref = false;
|
||||
bool lastprivate_firstprivate = false;
|
||||
int pass;
|
||||
|
||||
*dlist = gimple_seq_alloc ();
|
||||
diter = gsi_start (*dlist);
|
||||
copyin_seq = NULL;
|
||||
|
||||
/* Do all the fixed sized types in the first pass, and the variable sized
|
||||
|
|
@ -2427,7 +2423,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
|
||||
dtor = x;
|
||||
gimplify_stmt (&dtor, &tseq);
|
||||
gsi_insert_seq_before (&diter, tseq, GSI_SAME_STMT);
|
||||
gimple_seq_add_seq (dlist, tseq);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -2470,7 +2466,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
|
|||
x = build_fold_addr_expr_loc (clause_loc, x);
|
||||
SET_DECL_VALUE_EXPR (placeholder, x);
|
||||
DECL_HAS_VALUE_EXPR_P (placeholder) = 1;
|
||||
lower_omp (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c), ctx);
|
||||
lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c), ctx);
|
||||
gimple_seq_add_seq (ilist,
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
|
||||
|
|
@ -2574,7 +2570,7 @@ lower_lastprivate_clauses (tree clauses, tree predicate, gimple_seq *stmt_list,
|
|||
|
||||
if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c))
|
||||
{
|
||||
lower_omp (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c), ctx);
|
||||
lower_omp (&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c), ctx);
|
||||
gimple_seq_add_seq (stmt_list,
|
||||
OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
|
||||
}
|
||||
|
|
@ -2678,7 +2674,7 @@ lower_reduction_clauses (tree clauses, gimple_seq *stmt_seqp, omp_context *ctx)
|
|||
ref = build_fold_addr_expr_loc (clause_loc, ref);
|
||||
SET_DECL_VALUE_EXPR (placeholder, ref);
|
||||
DECL_HAS_VALUE_EXPR_P (placeholder) = 1;
|
||||
lower_omp (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c), ctx);
|
||||
lower_omp (&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c), ctx);
|
||||
gimple_seq_add_seq (&sub_seq, OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
|
||||
OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = NULL;
|
||||
|
|
@ -3501,7 +3497,8 @@ expand_omp_taskreg (struct omp_region *region)
|
|||
&& !DECL_EXTERNAL (t))
|
||||
varpool_finalize_decl (t);
|
||||
DECL_SAVED_TREE (child_fn) = NULL;
|
||||
gimple_set_body (child_fn, bb_seq (single_succ (entry_bb)));
|
||||
/* We'll create a CFG for child_fn, so no gimple body is needed. */
|
||||
gimple_set_body (child_fn, NULL);
|
||||
TREE_USED (block) = 1;
|
||||
|
||||
/* Reset DECL_CONTEXT on function arguments. */
|
||||
|
|
@ -5789,9 +5786,8 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
{
|
||||
tree block, control;
|
||||
gimple_stmt_iterator tgsi;
|
||||
unsigned i, len;
|
||||
gimple stmt, new_stmt, bind, t;
|
||||
gimple_seq ilist, dlist, olist, new_body, body;
|
||||
gimple_seq ilist, dlist, olist, new_body;
|
||||
struct gimplify_ctx gctx;
|
||||
|
||||
stmt = gsi_stmt (*gsi_p);
|
||||
|
|
@ -5803,13 +5799,10 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
lower_rec_input_clauses (gimple_omp_sections_clauses (stmt),
|
||||
&ilist, &dlist, ctx);
|
||||
|
||||
tgsi = gsi_start (gimple_omp_body (stmt));
|
||||
for (len = 0; !gsi_end_p (tgsi); len++, gsi_next (&tgsi))
|
||||
continue;
|
||||
|
||||
tgsi = gsi_start (gimple_omp_body (stmt));
|
||||
body = NULL;
|
||||
for (i = 0; i < len; i++, gsi_next (&tgsi))
|
||||
new_body = gimple_omp_body (stmt);
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
tgsi = gsi_start (new_body);
|
||||
for (; !gsi_end_p (tgsi); gsi_next (&tgsi))
|
||||
{
|
||||
omp_context *sctx;
|
||||
gimple sec_start;
|
||||
|
|
@ -5818,32 +5811,33 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
sctx = maybe_lookup_ctx (sec_start);
|
||||
gcc_assert (sctx);
|
||||
|
||||
gimple_seq_add_stmt (&body, sec_start);
|
||||
|
||||
lower_omp (gimple_omp_body (sec_start), sctx);
|
||||
gimple_seq_add_seq (&body, gimple_omp_body (sec_start));
|
||||
lower_omp (gimple_omp_body_ptr (sec_start), sctx);
|
||||
gsi_insert_seq_after (&tgsi, gimple_omp_body (sec_start),
|
||||
GSI_CONTINUE_LINKING);
|
||||
gimple_omp_set_body (sec_start, NULL);
|
||||
|
||||
if (i == len - 1)
|
||||
if (gsi_one_before_end_p (tgsi))
|
||||
{
|
||||
gimple_seq l = NULL;
|
||||
lower_lastprivate_clauses (gimple_omp_sections_clauses (stmt), NULL,
|
||||
&l, ctx);
|
||||
gimple_seq_add_seq (&body, l);
|
||||
gsi_insert_seq_after (&tgsi, l, GSI_CONTINUE_LINKING);
|
||||
gimple_omp_section_set_last (sec_start);
|
||||
}
|
||||
|
||||
gimple_seq_add_stmt (&body, gimple_build_omp_return (false));
|
||||
gsi_insert_after (&tgsi, gimple_build_omp_return (false),
|
||||
GSI_CONTINUE_LINKING);
|
||||
}
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, body, block);
|
||||
bind = gimple_build_bind (NULL, new_body, block);
|
||||
|
||||
olist = NULL;
|
||||
lower_reduction_clauses (gimple_omp_sections_clauses (stmt), &olist, ctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
new_stmt = gimple_build_bind (NULL, NULL, block);
|
||||
gsi_replace (gsi_p, new_stmt, true);
|
||||
|
||||
pop_gimplify_context (new_stmt);
|
||||
gimple_bind_append_vars (new_stmt, ctx->block_vars);
|
||||
|
|
@ -5873,9 +5867,6 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
gimple_seq_add_stmt (&new_body, t);
|
||||
|
||||
gimple_bind_set_body (new_stmt, new_body);
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
|
||||
gsi_replace (gsi_p, new_stmt, true);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -6008,10 +5999,14 @@ lower_omp_single (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
|
||||
push_gimplify_context (&gctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, NULL, block);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
bind_body = NULL;
|
||||
dlist = NULL;
|
||||
lower_rec_input_clauses (gimple_omp_single_clauses (single_stmt),
|
||||
&bind_body, &dlist, ctx);
|
||||
lower_omp (gimple_omp_body (single_stmt), ctx);
|
||||
lower_omp (gimple_omp_body_ptr (single_stmt), ctx);
|
||||
|
||||
gimple_seq_add_stmt (&bind_body, single_stmt);
|
||||
|
||||
|
|
@ -6030,15 +6025,12 @@ lower_omp_single (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
(!!find_omp_clause (gimple_omp_single_clauses (single_stmt),
|
||||
OMP_CLAUSE_NOWAIT));
|
||||
gimple_seq_add_stmt (&bind_body, t);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, bind_body, block);
|
||||
gimple_bind_set_body (bind, bind_body);
|
||||
|
||||
pop_gimplify_context (bind);
|
||||
|
||||
gimple_bind_append_vars (bind, ctx->block_vars);
|
||||
BLOCK_VARS (block) = ctx->block_vars;
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
if (BLOCK_VARS (block))
|
||||
TREE_USED (block) = 1;
|
||||
}
|
||||
|
|
@ -6058,8 +6050,9 @@ lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
push_gimplify_context (&gctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, gimple_seq_alloc_with_stmt (stmt),
|
||||
block);
|
||||
bind = gimple_build_bind (NULL, NULL, block);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
gimple_bind_add_stmt (bind, stmt);
|
||||
|
||||
bfn_decl = builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM);
|
||||
x = build_call_expr_loc (loc, bfn_decl, 0);
|
||||
|
|
@ -6069,7 +6062,7 @@ lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
gimplify_and_add (x, &tseq);
|
||||
gimple_bind_add_seq (bind, tseq);
|
||||
|
||||
lower_omp (gimple_omp_body (stmt), ctx);
|
||||
lower_omp (gimple_omp_body_ptr (stmt), ctx);
|
||||
gimple_omp_set_body (stmt, maybe_catch_exception (gimple_omp_body (stmt)));
|
||||
gimple_bind_add_seq (bind, gimple_omp_body (stmt));
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
|
|
@ -6082,7 +6075,6 @@ lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
|
||||
gimple_bind_append_vars (bind, ctx->block_vars);
|
||||
BLOCK_VARS (block) = ctx->block_vars;
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -6098,14 +6090,15 @@ lower_omp_ordered (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
push_gimplify_context (&gctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, gimple_seq_alloc_with_stmt (stmt),
|
||||
block);
|
||||
bind = gimple_build_bind (NULL, NULL, block);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
gimple_bind_add_stmt (bind, stmt);
|
||||
|
||||
x = gimple_build_call (builtin_decl_explicit (BUILT_IN_GOMP_ORDERED_START),
|
||||
0);
|
||||
gimple_bind_add_stmt (bind, x);
|
||||
|
||||
lower_omp (gimple_omp_body (stmt), ctx);
|
||||
lower_omp (gimple_omp_body_ptr (stmt), ctx);
|
||||
gimple_omp_set_body (stmt, maybe_catch_exception (gimple_omp_body (stmt)));
|
||||
gimple_bind_add_seq (bind, gimple_omp_body (stmt));
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
|
|
@ -6119,7 +6112,6 @@ lower_omp_ordered (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
|
||||
gimple_bind_append_vars (bind, ctx->block_vars);
|
||||
BLOCK_VARS (block) = gimple_bind_vars (bind);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -6195,13 +6187,15 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
push_gimplify_context (&gctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
bind = gimple_build_bind (NULL, gimple_seq_alloc_with_stmt (stmt), block);
|
||||
bind = gimple_build_bind (NULL, NULL, block);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
gimple_bind_add_stmt (bind, stmt);
|
||||
|
||||
tbody = gimple_bind_body (bind);
|
||||
gimplify_and_add (lock, &tbody);
|
||||
gimple_bind_set_body (bind, tbody);
|
||||
|
||||
lower_omp (gimple_omp_body (stmt), ctx);
|
||||
lower_omp (gimple_omp_body_ptr (stmt), ctx);
|
||||
gimple_omp_set_body (stmt, maybe_catch_exception (gimple_omp_body (stmt)));
|
||||
gimple_bind_add_seq (bind, gimple_omp_body (stmt));
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
|
|
@ -6215,7 +6209,6 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
pop_gimplify_context (bind);
|
||||
gimple_bind_append_vars (bind, ctx->block_vars);
|
||||
BLOCK_VARS (block) = gimple_bind_vars (bind);
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -6283,11 +6276,15 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
|
||||
push_gimplify_context (&gctx);
|
||||
|
||||
lower_omp (gimple_omp_for_pre_body (stmt), ctx);
|
||||
lower_omp (gimple_omp_body (stmt), ctx);
|
||||
lower_omp (gimple_omp_for_pre_body_ptr (stmt), ctx);
|
||||
lower_omp (gimple_omp_body_ptr (stmt), ctx);
|
||||
|
||||
block = make_node (BLOCK);
|
||||
new_stmt = gimple_build_bind (NULL, NULL, block);
|
||||
/* Replace at gsi right away, so that 'stmt' is no member
|
||||
of a sequence anymore as we're going to add to to a different
|
||||
one below. */
|
||||
gsi_replace (gsi_p, new_stmt, true);
|
||||
|
||||
/* Move declaration of temporaries in the loop body before we make
|
||||
it go away. */
|
||||
|
|
@ -6357,7 +6354,6 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
gimple_bind_set_body (new_stmt, body);
|
||||
gimple_omp_set_body (stmt, NULL);
|
||||
gimple_omp_for_set_pre_body (stmt, NULL);
|
||||
gsi_replace (gsi_p, new_stmt, true);
|
||||
}
|
||||
|
||||
/* Callback for walk_stmts. Check if the current statement only contains
|
||||
|
|
@ -6710,7 +6706,7 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
par_olist = NULL;
|
||||
par_ilist = NULL;
|
||||
lower_rec_input_clauses (clauses, &par_ilist, &par_olist, ctx);
|
||||
lower_omp (par_body, ctx);
|
||||
lower_omp (&par_body, ctx);
|
||||
if (gimple_code (stmt) == GIMPLE_OMP_PARALLEL)
|
||||
lower_reduction_clauses (clauses, &par_olist, ctx);
|
||||
|
||||
|
|
@ -6756,15 +6752,10 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
gimple_omp_set_body (stmt, new_body);
|
||||
|
||||
bind = gimple_build_bind (NULL, NULL, gimple_bind_block (par_bind));
|
||||
gimple_bind_add_stmt (bind, stmt);
|
||||
if (ilist || olist)
|
||||
{
|
||||
gimple_seq_add_stmt (&ilist, bind);
|
||||
gimple_seq_add_seq (&ilist, olist);
|
||||
bind = gimple_build_bind (NULL, ilist, NULL);
|
||||
}
|
||||
|
||||
gsi_replace (gsi_p, bind, true);
|
||||
gimple_bind_add_seq (bind, ilist);
|
||||
gimple_bind_add_stmt (bind, stmt);
|
||||
gimple_bind_add_seq (bind, olist);
|
||||
|
||||
pop_gimplify_context (NULL);
|
||||
}
|
||||
|
|
@ -6829,17 +6820,17 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
gimple_regimplify_operands (stmt, gsi_p);
|
||||
break;
|
||||
case GIMPLE_CATCH:
|
||||
lower_omp (gimple_catch_handler (stmt), ctx);
|
||||
lower_omp (gimple_catch_handler_ptr (stmt), ctx);
|
||||
break;
|
||||
case GIMPLE_EH_FILTER:
|
||||
lower_omp (gimple_eh_filter_failure (stmt), ctx);
|
||||
lower_omp (gimple_eh_filter_failure_ptr (stmt), ctx);
|
||||
break;
|
||||
case GIMPLE_TRY:
|
||||
lower_omp (gimple_try_eval (stmt), ctx);
|
||||
lower_omp (gimple_try_cleanup (stmt), ctx);
|
||||
lower_omp (gimple_try_eval_ptr (stmt), ctx);
|
||||
lower_omp (gimple_try_cleanup_ptr (stmt), ctx);
|
||||
break;
|
||||
case GIMPLE_BIND:
|
||||
lower_omp (gimple_bind_body (stmt), ctx);
|
||||
lower_omp (gimple_bind_body_ptr (stmt), ctx);
|
||||
break;
|
||||
case GIMPLE_OMP_PARALLEL:
|
||||
case GIMPLE_OMP_TASK:
|
||||
|
|
@ -6892,11 +6883,11 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx)
|
|||
}
|
||||
|
||||
static void
|
||||
lower_omp (gimple_seq body, omp_context *ctx)
|
||||
lower_omp (gimple_seq *body, omp_context *ctx)
|
||||
{
|
||||
location_t saved_location = input_location;
|
||||
gimple_stmt_iterator gsi = gsi_start (body);
|
||||
for (gsi = gsi_start (body); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
gimple_stmt_iterator gsi;
|
||||
for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
lower_omp_1 (&gsi, ctx);
|
||||
input_location = saved_location;
|
||||
}
|
||||
|
|
@ -6926,7 +6917,7 @@ execute_lower_omp (void)
|
|||
|
||||
if (task_shared_vars)
|
||||
push_gimplify_context (&gctx);
|
||||
lower_omp (body, NULL);
|
||||
lower_omp (&body, NULL);
|
||||
if (task_shared_vars)
|
||||
pop_gimplify_context (NULL);
|
||||
}
|
||||
|
|
@ -7104,7 +7095,7 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
|
|||
case GIMPLE_OMP_ORDERED:
|
||||
case GIMPLE_OMP_CRITICAL:
|
||||
wi->info = stmt;
|
||||
walk_gimple_seq (gimple_omp_body (stmt), diagnose_sb_2, NULL, wi);
|
||||
walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), diagnose_sb_2, NULL, wi);
|
||||
wi->info = context;
|
||||
break;
|
||||
|
||||
|
|
@ -7112,9 +7103,9 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
|
|||
wi->info = stmt;
|
||||
/* gimple_omp_for_{index,initial,final} are all DECLs; no need to
|
||||
walk them. */
|
||||
walk_gimple_seq (gimple_omp_for_pre_body (stmt),
|
||||
diagnose_sb_2, NULL, wi);
|
||||
walk_gimple_seq (gimple_omp_body (stmt), diagnose_sb_2, NULL, wi);
|
||||
walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt),
|
||||
diagnose_sb_2, NULL, wi);
|
||||
walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), diagnose_sb_2, NULL, wi);
|
||||
wi->info = context;
|
||||
break;
|
||||
|
||||
|
|
@ -7187,7 +7178,9 @@ diagnose_omp_structured_block_errors (void)
|
|||
|
||||
memset (&wi, 0, sizeof (wi));
|
||||
wi.want_locations = true;
|
||||
walk_gimple_seq (body, diagnose_sb_2, NULL, &wi);
|
||||
walk_gimple_seq_mod (&body, diagnose_sb_2, NULL, &wi);
|
||||
|
||||
gimple_set_body (current_function_decl, body);
|
||||
|
||||
splay_tree_delete (all_labels);
|
||||
all_labels = NULL;
|
||||
|
|
|
|||
|
|
@ -1570,8 +1570,8 @@ lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi)
|
|||
us some idea of what we're dealing with. */
|
||||
memset (&this_wi, 0, sizeof (this_wi));
|
||||
this_wi.info = (void *) &this_state;
|
||||
walk_gimple_seq (gimple_transaction_body (stmt),
|
||||
lower_sequence_tm, NULL, &this_wi);
|
||||
walk_gimple_seq_mod (gimple_transaction_body_ptr (stmt),
|
||||
lower_sequence_tm, NULL, &this_wi);
|
||||
|
||||
/* If there was absolutely nothing transaction related inside the
|
||||
transaction, we may elide it. Likewise if this is a nested
|
||||
|
|
@ -1600,7 +1600,7 @@ lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi)
|
|||
gimple_seq n_seq, e_seq;
|
||||
|
||||
n_seq = gimple_seq_alloc_with_stmt (g);
|
||||
e_seq = gimple_seq_alloc ();
|
||||
e_seq = NULL;
|
||||
|
||||
g = gimple_build_call (builtin_decl_explicit (BUILT_IN_EH_POINTER),
|
||||
1, integer_zero_node);
|
||||
|
|
@ -1704,13 +1704,15 @@ static unsigned int
|
|||
execute_lower_tm (void)
|
||||
{
|
||||
struct walk_stmt_info wi;
|
||||
gimple_seq body;
|
||||
|
||||
/* Transactional clones aren't created until a later pass. */
|
||||
gcc_assert (!decl_is_tm_clone (current_function_decl));
|
||||
|
||||
body = gimple_body (current_function_decl);
|
||||
memset (&wi, 0, sizeof (wi));
|
||||
walk_gimple_seq (gimple_body (current_function_decl),
|
||||
lower_sequence_no_tm, NULL, &wi);
|
||||
walk_gimple_seq_mod (&body, lower_sequence_no_tm, NULL, &wi);
|
||||
gimple_set_body (current_function_decl, body);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -377,7 +377,7 @@ make_blocks (gimple_seq seq)
|
|||
if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
|
||||
{
|
||||
if (!first_stmt_of_seq)
|
||||
seq = gsi_split_seq_before (&i);
|
||||
gsi_split_seq_before (&i, &seq);
|
||||
bb = create_basic_block (seq, NULL, bb);
|
||||
start_new_block = false;
|
||||
}
|
||||
|
|
@ -439,7 +439,7 @@ create_bb (void *h, void *e, basic_block after)
|
|||
bb->index = last_basic_block;
|
||||
bb->flags = BB_NEW;
|
||||
bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
|
||||
set_bb_seq (bb, h ? (gimple_seq) h : gimple_seq_alloc ());
|
||||
set_bb_seq (bb, h ? (gimple_seq) h : NULL);
|
||||
|
||||
/* Add the new block to the linked list of blocks. */
|
||||
link_block (bb, after);
|
||||
|
|
@ -1655,7 +1655,6 @@ static void
|
|||
gimple_merge_blocks (basic_block a, basic_block b)
|
||||
{
|
||||
gimple_stmt_iterator last, gsi, psi;
|
||||
gimple_seq phis = phi_nodes (b);
|
||||
|
||||
if (dump_file)
|
||||
fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
|
||||
|
|
@ -1663,7 +1662,7 @@ gimple_merge_blocks (basic_block a, basic_block b)
|
|||
/* Remove all single-valued PHI nodes from block B of the form
|
||||
V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
|
||||
gsi = gsi_last_bb (a);
|
||||
for (psi = gsi_start (phis); !gsi_end_p (psi); )
|
||||
for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
|
||||
{
|
||||
gimple phi = gsi_stmt (psi);
|
||||
tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
|
||||
|
|
@ -5249,7 +5248,7 @@ gimple_split_block (basic_block bb, void *stmt)
|
|||
brings ugly quadratic memory consumption in the inliner.
|
||||
(We are still quadratic since we need to update stmt BB pointers,
|
||||
sadly.) */
|
||||
list = gsi_split_seq_before (&gsi);
|
||||
gsi_split_seq_before (&gsi, &list);
|
||||
set_bb_seq (new_bb, list);
|
||||
for (gsi_tgt = gsi_start (list);
|
||||
!gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
|
||||
|
|
@ -6085,8 +6084,8 @@ move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
|
|||
p->remap_decls_p = false;
|
||||
*handled_ops_p = true;
|
||||
|
||||
walk_gimple_seq (gimple_omp_body (stmt), move_stmt_r,
|
||||
move_stmt_op, wi);
|
||||
walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), move_stmt_r,
|
||||
move_stmt_op, wi);
|
||||
|
||||
p->remap_decls_p = save_remap_decls_p;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -661,17 +661,16 @@ update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
|
|||
static void
|
||||
update_complex_assignment (gimple_stmt_iterator *gsi, tree r, tree i)
|
||||
{
|
||||
gimple_stmt_iterator orig_si = *gsi;
|
||||
gimple stmt;
|
||||
|
||||
if (gimple_in_ssa_p (cfun))
|
||||
update_complex_components (gsi, gsi_stmt (*gsi), r, i);
|
||||
|
||||
gimple_assign_set_rhs_with_ops (&orig_si, COMPLEX_EXPR, r, i);
|
||||
stmt = gsi_stmt (orig_si);
|
||||
gimple_assign_set_rhs_with_ops (gsi, COMPLEX_EXPR, r, i);
|
||||
stmt = gsi_stmt (*gsi);
|
||||
update_stmt (stmt);
|
||||
if (maybe_clean_eh_stmt (stmt))
|
||||
gimple_purge_dead_eh_edges (gimple_bb (stmt));
|
||||
|
||||
if (gimple_in_ssa_p (cfun))
|
||||
update_complex_components (gsi, gsi_stmt (*gsi), r, i);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -406,7 +406,7 @@ static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
|
|||
|
||||
#define LARGE_GOTO_QUEUE 20
|
||||
|
||||
static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq);
|
||||
static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq *seq);
|
||||
|
||||
static gimple_seq
|
||||
find_goto_replacement (struct leh_tf_state *tf, treemple stmt)
|
||||
|
|
@ -481,7 +481,7 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
|
|||
/* The real work of replace_goto_queue. Returns with TSI updated to
|
||||
point to the next statement. */
|
||||
|
||||
static void replace_goto_queue_stmt_list (gimple_seq, struct leh_tf_state *);
|
||||
static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *);
|
||||
|
||||
static void
|
||||
replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
|
||||
|
|
@ -511,18 +511,18 @@ replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
|
|||
break;
|
||||
|
||||
case GIMPLE_TRY:
|
||||
replace_goto_queue_stmt_list (gimple_try_eval (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_try_cleanup (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf);
|
||||
break;
|
||||
case GIMPLE_CATCH:
|
||||
replace_goto_queue_stmt_list (gimple_catch_handler (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_catch_handler_ptr (stmt), tf);
|
||||
break;
|
||||
case GIMPLE_EH_FILTER:
|
||||
replace_goto_queue_stmt_list (gimple_eh_filter_failure (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt), tf);
|
||||
break;
|
||||
case GIMPLE_EH_ELSE:
|
||||
replace_goto_queue_stmt_list (gimple_eh_else_n_body (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_eh_else_e_body (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (stmt), tf);
|
||||
replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (stmt), tf);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -536,9 +536,9 @@ replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
|
|||
/* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */
|
||||
|
||||
static void
|
||||
replace_goto_queue_stmt_list (gimple_seq seq, struct leh_tf_state *tf)
|
||||
replace_goto_queue_stmt_list (gimple_seq *seq, struct leh_tf_state *tf)
|
||||
{
|
||||
gimple_stmt_iterator gsi = gsi_start (seq);
|
||||
gimple_stmt_iterator gsi = gsi_start (*seq);
|
||||
|
||||
while (!gsi_end_p (gsi))
|
||||
replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi);
|
||||
|
|
@ -551,8 +551,8 @@ replace_goto_queue (struct leh_tf_state *tf)
|
|||
{
|
||||
if (tf->goto_queue_active == 0)
|
||||
return;
|
||||
replace_goto_queue_stmt_list (tf->top_p_seq, tf);
|
||||
replace_goto_queue_stmt_list (eh_seq, tf);
|
||||
replace_goto_queue_stmt_list (&tf->top_p_seq, tf);
|
||||
replace_goto_queue_stmt_list (&eh_seq, tf);
|
||||
}
|
||||
|
||||
/* Add a new record to the goto queue contained in TF. NEW_STMT is the
|
||||
|
|
@ -731,9 +731,6 @@ do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod)
|
|||
|
||||
q->cont_stmt = q->stmt.g;
|
||||
|
||||
if (!q->repl_stmt)
|
||||
q->repl_stmt = gimple_seq_alloc ();
|
||||
|
||||
if (mod)
|
||||
gimple_seq_add_seq (&q->repl_stmt, mod);
|
||||
|
||||
|
|
@ -750,8 +747,6 @@ do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
|
|||
gimple x;
|
||||
|
||||
gcc_assert (q->is_label);
|
||||
if (!q->repl_stmt)
|
||||
q->repl_stmt = gimple_seq_alloc ();
|
||||
|
||||
q->cont_stmt = gimple_build_goto (VEC_index (tree, tf->dest_array, q->index));
|
||||
|
||||
|
|
@ -1050,13 +1045,13 @@ lower_try_finally_nofallthru (struct leh_state *state,
|
|||
if (eh_else)
|
||||
{
|
||||
finally = gimple_eh_else_n_body (eh_else);
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
gimple_seq_add_seq (&tf->top_p_seq, finally);
|
||||
|
||||
if (tf->may_throw)
|
||||
{
|
||||
finally = gimple_eh_else_e_body (eh_else);
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
|
||||
emit_post_landing_pad (&eh_seq, tf->region);
|
||||
gimple_seq_add_seq (&eh_seq, finally);
|
||||
|
|
@ -1064,7 +1059,7 @@ lower_try_finally_nofallthru (struct leh_state *state,
|
|||
}
|
||||
else
|
||||
{
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
gimple_seq_add_seq (&tf->top_p_seq, finally);
|
||||
|
||||
if (tf->may_throw)
|
||||
|
|
@ -1105,7 +1100,7 @@ lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
|
|||
finally = gimple_eh_else_n_body (x);
|
||||
}
|
||||
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
|
||||
if (tf->may_throw)
|
||||
{
|
||||
|
|
@ -1193,7 +1188,7 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
|
|||
if (tf->may_fallthru)
|
||||
{
|
||||
seq = lower_try_finally_dup_block (finally, state);
|
||||
lower_eh_constructs_1 (state, seq);
|
||||
lower_eh_constructs_1 (state, &seq);
|
||||
gimple_seq_add_seq (&new_stmt, seq);
|
||||
|
||||
tmp = lower_try_finally_fallthru_label (tf);
|
||||
|
|
@ -1209,7 +1204,7 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
|
|||
seq = gimple_eh_else_e_body (eh_else);
|
||||
else
|
||||
seq = lower_try_finally_dup_block (finally, state);
|
||||
lower_eh_constructs_1 (state, seq);
|
||||
lower_eh_constructs_1 (state, &seq);
|
||||
|
||||
emit_post_landing_pad (&eh_seq, tf->region);
|
||||
gimple_seq_add_seq (&eh_seq, seq);
|
||||
|
|
@ -1259,7 +1254,7 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
|
|||
gimple_seq_add_stmt (&new_stmt, x);
|
||||
|
||||
seq = lower_try_finally_dup_block (finally, state);
|
||||
lower_eh_constructs_1 (state, seq);
|
||||
lower_eh_constructs_1 (state, &seq);
|
||||
gimple_seq_add_seq (&new_stmt, seq);
|
||||
|
||||
gimple_seq_add_stmt (&new_stmt, q->cont_stmt);
|
||||
|
|
@ -1306,7 +1301,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
|
|||
int nlabels, ndests, j, last_case_index;
|
||||
tree last_case;
|
||||
VEC (tree,heap) *case_label_vec;
|
||||
gimple_seq switch_body;
|
||||
gimple_seq switch_body = NULL;
|
||||
gimple x, eh_else;
|
||||
tree tmp;
|
||||
gimple switch_stmt;
|
||||
|
|
@ -1317,7 +1312,6 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
|
|||
/* The location of the finally block. */
|
||||
location_t finally_loc;
|
||||
|
||||
switch_body = gimple_seq_alloc ();
|
||||
finally = gimple_try_cleanup (tf->top_p);
|
||||
eh_else = get_eh_else (finally);
|
||||
|
||||
|
|
@ -1331,7 +1325,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
|
|||
: tf_loc;
|
||||
|
||||
/* Lower the finally block itself. */
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
|
||||
/* Prepare for switch statement generation. */
|
||||
nlabels = VEC_length (tree, tf->dest_array);
|
||||
|
|
@ -1382,7 +1376,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
|
|||
if (tf->may_throw)
|
||||
{
|
||||
finally = gimple_eh_else_e_body (eh_else);
|
||||
lower_eh_constructs_1 (state, finally);
|
||||
lower_eh_constructs_1 (state, &finally);
|
||||
|
||||
emit_post_landing_pad (&eh_seq, tf->region);
|
||||
gimple_seq_add_seq (&eh_seq, finally);
|
||||
|
|
@ -1426,12 +1420,10 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
|
|||
entrance through a particular edge. */
|
||||
for (; q < qe; ++q)
|
||||
{
|
||||
gimple_seq mod;
|
||||
gimple_seq mod = NULL;
|
||||
int switch_id;
|
||||
unsigned int case_index;
|
||||
|
||||
mod = gimple_seq_alloc ();
|
||||
|
||||
if (q->index < 0)
|
||||
{
|
||||
x = gimple_build_assign (finally_tmp,
|
||||
|
|
@ -1623,7 +1615,7 @@ lower_try_finally (struct leh_state *state, gimple tp)
|
|||
old_eh_seq = eh_seq;
|
||||
eh_seq = NULL;
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval(tp));
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp));
|
||||
|
||||
/* Determine if the try block is escaped through the bottom. */
|
||||
this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
|
||||
|
|
@ -1706,7 +1698,7 @@ lower_catch (struct leh_state *state, gimple tp)
|
|||
struct leh_state this_state = *state;
|
||||
gimple_stmt_iterator gsi;
|
||||
tree out_label;
|
||||
gimple_seq new_seq;
|
||||
gimple_seq new_seq, cleanup;
|
||||
gimple x;
|
||||
location_t try_catch_loc = gimple_location (tp);
|
||||
|
||||
|
|
@ -1716,7 +1708,7 @@ lower_catch (struct leh_state *state, gimple tp)
|
|||
this_state.cur_region = try_region;
|
||||
}
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp));
|
||||
|
||||
if (!eh_region_may_contain_throw (try_region))
|
||||
return gimple_try_eval (tp);
|
||||
|
|
@ -1729,7 +1721,8 @@ lower_catch (struct leh_state *state, gimple tp)
|
|||
this_state.ehp_region = try_region;
|
||||
|
||||
out_label = NULL;
|
||||
for (gsi = gsi_start (gimple_try_cleanup (tp));
|
||||
cleanup = gimple_try_cleanup (tp);
|
||||
for (gsi = gsi_start (cleanup);
|
||||
!gsi_end_p (gsi);
|
||||
gsi_next (&gsi))
|
||||
{
|
||||
|
|
@ -1741,7 +1734,7 @@ lower_catch (struct leh_state *state, gimple tp)
|
|||
c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch));
|
||||
|
||||
handler = gimple_catch_handler (gcatch);
|
||||
lower_eh_constructs_1 (&this_state, handler);
|
||||
lower_eh_constructs_1 (&this_state, &handler);
|
||||
|
||||
c->label = create_artificial_label (UNKNOWN_LOCATION);
|
||||
x = gimple_build_label (c->label);
|
||||
|
|
@ -1787,7 +1780,7 @@ lower_eh_filter (struct leh_state *state, gimple tp)
|
|||
this_state.cur_region = this_region;
|
||||
}
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp));
|
||||
|
||||
if (!eh_region_may_contain_throw (this_region))
|
||||
return gimple_try_eval (tp);
|
||||
|
|
@ -1803,7 +1796,7 @@ lower_eh_filter (struct leh_state *state, gimple tp)
|
|||
x = gimple_build_label (this_region->u.allowed.label);
|
||||
gimple_seq_add_stmt (&new_seq, x);
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure (inner));
|
||||
lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure_ptr (inner));
|
||||
gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner));
|
||||
|
||||
gimple_try_set_cleanup (tp, new_seq);
|
||||
|
|
@ -1838,7 +1831,7 @@ lower_eh_must_not_throw (struct leh_state *state, gimple tp)
|
|||
this_state.cur_region = this_region;
|
||||
}
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp));
|
||||
|
||||
return gimple_try_eval (tp);
|
||||
}
|
||||
|
|
@ -1861,7 +1854,7 @@ lower_cleanup (struct leh_state *state, gimple tp)
|
|||
this_state.cur_region = this_region;
|
||||
}
|
||||
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
|
||||
lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp));
|
||||
|
||||
if (cleanup_dead || !eh_region_may_contain_throw (this_region))
|
||||
return gimple_try_eval (tp);
|
||||
|
|
@ -1881,7 +1874,7 @@ lower_cleanup (struct leh_state *state, gimple tp)
|
|||
{
|
||||
/* In this case honor_protect_cleanup_actions had nothing to do,
|
||||
and we should process this normally. */
|
||||
lower_eh_constructs_1 (state, gimple_try_cleanup (tp));
|
||||
lower_eh_constructs_1 (state, gimple_try_cleanup_ptr (tp));
|
||||
result = frob_into_branch_around (tp, this_region,
|
||||
fake_tf.fallthru_label);
|
||||
}
|
||||
|
|
@ -2010,7 +2003,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
|
|||
if (!x)
|
||||
{
|
||||
replace = gimple_try_eval (stmt);
|
||||
lower_eh_constructs_1 (state, replace);
|
||||
lower_eh_constructs_1 (state, &replace);
|
||||
}
|
||||
else
|
||||
switch (gimple_code (x))
|
||||
|
|
@ -2057,10 +2050,10 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
|
|||
/* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */
|
||||
|
||||
static void
|
||||
lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq)
|
||||
lower_eh_constructs_1 (struct leh_state *state, gimple_seq *pseq)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
for (gsi = gsi_start (seq); !gsi_end_p (gsi);)
|
||||
for (gsi = gsi_start (*pseq); !gsi_end_p (gsi);)
|
||||
lower_eh_constructs_2 (state, &gsi);
|
||||
}
|
||||
|
||||
|
|
@ -2079,7 +2072,8 @@ lower_eh_constructs (void)
|
|||
memset (&null_state, 0, sizeof (null_state));
|
||||
|
||||
collect_finally_tree_1 (bodyp, NULL);
|
||||
lower_eh_constructs_1 (&null_state, bodyp);
|
||||
lower_eh_constructs_1 (&null_state, &bodyp);
|
||||
gimple_set_body (current_function_decl, bodyp);
|
||||
|
||||
/* We assume there's a return statement, or something, at the end of
|
||||
the function, and thus ploping the EH sequence afterward won't
|
||||
|
|
@ -2874,8 +2868,10 @@ optimize_double_finally (gimple one, gimple two)
|
|||
{
|
||||
gimple oneh;
|
||||
gimple_stmt_iterator gsi;
|
||||
gimple_seq cleanup;
|
||||
|
||||
gsi = gsi_start (gimple_try_cleanup (one));
|
||||
cleanup = gimple_try_cleanup (one);
|
||||
gsi = gsi_start (cleanup);
|
||||
if (!gsi_one_before_end_p (gsi))
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -511,6 +511,15 @@ phi_nodes (const_basic_block bb)
|
|||
return bb->il.gimple->phi_nodes;
|
||||
}
|
||||
|
||||
static inline gimple_seq *
|
||||
phi_nodes_ptr (const_basic_block bb)
|
||||
{
|
||||
gcc_checking_assert (!(bb->flags & BB_RTL));
|
||||
if (!bb->il.gimple)
|
||||
return NULL;
|
||||
return &bb->il.gimple->phi_nodes;
|
||||
}
|
||||
|
||||
/* Set PHI nodes of a basic block BB to SEQ. */
|
||||
|
||||
static inline void
|
||||
|
|
|
|||
|
|
@ -1996,7 +1996,7 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id)
|
|||
edge new_edge;
|
||||
bool inserted = false;
|
||||
|
||||
for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
|
||||
for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
|
||||
{
|
||||
tree res, new_res;
|
||||
gimple new_phi;
|
||||
|
|
|
|||
|
|
@ -472,7 +472,7 @@ static void
|
|||
mf_decl_cache_locals (void)
|
||||
{
|
||||
gimple g;
|
||||
gimple_seq seq = gimple_seq_alloc ();
|
||||
gimple_seq seq = NULL;
|
||||
|
||||
/* Build the cache vars. */
|
||||
mf_cache_shift_decl_l
|
||||
|
|
@ -572,7 +572,7 @@ mf_build_check_statement_for (tree base, tree limit,
|
|||
mf_limit = make_rename_temp (mf_uintptr_type, "__mf_limit");
|
||||
|
||||
/* Build: __mf_base = (uintptr_t) <base address expression>. */
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
t = fold_convert_loc (location, mf_uintptr_type,
|
||||
unshare_expr (base));
|
||||
t = force_gimple_operand (t, &stmts, false, NULL_TREE);
|
||||
|
|
@ -683,7 +683,7 @@ mf_build_check_statement_for (tree base, tree limit,
|
|||
|
||||
This is the body of the conditional. */
|
||||
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
/* u is a string, so it is already a gimple value. */
|
||||
u = mf_file_function_line_tree (location);
|
||||
/* NB: we pass the overall [base..limit] range to mf_check. */
|
||||
|
|
@ -704,7 +704,7 @@ mf_build_check_statement_for (tree base, tree limit,
|
|||
gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
|
||||
e = split_block (then_bb, g);
|
||||
then_bb = e->dest;
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
}
|
||||
|
||||
g = gimple_build_assign (mf_cache_shift_decl_l, mf_cache_shift_decl);
|
||||
|
|
@ -1114,7 +1114,7 @@ mx_register_decls (tree decl, gimple_seq seq, location_t location)
|
|||
if (finally_stmts != NULL)
|
||||
{
|
||||
gimple stmt = gimple_build_try (seq, finally_stmts, GIMPLE_TRY_FINALLY);
|
||||
gimple_seq new_seq = gimple_seq_alloc ();
|
||||
gimple_seq new_seq = NULL;
|
||||
|
||||
gimple_seq_add_stmt (&new_seq, stmt);
|
||||
return new_seq;
|
||||
|
|
|
|||
|
|
@ -577,18 +577,18 @@ get_nl_goto_field (struct nesting_info *info)
|
|||
return field;
|
||||
}
|
||||
|
||||
/* Invoke CALLBACK on all statements of GIMPLE sequence SEQ. */
|
||||
/* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ. */
|
||||
|
||||
static void
|
||||
walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
|
||||
struct nesting_info *info, gimple_seq seq)
|
||||
struct nesting_info *info, gimple_seq *pseq)
|
||||
{
|
||||
struct walk_stmt_info wi;
|
||||
|
||||
memset (&wi, 0, sizeof (wi));
|
||||
wi.info = info;
|
||||
wi.val_only = true;
|
||||
walk_gimple_seq (seq, callback_stmt, callback_op, &wi);
|
||||
walk_gimple_seq_mod (pseq, callback_stmt, callback_op, &wi);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -598,7 +598,9 @@ static inline void
|
|||
walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
|
||||
struct nesting_info *info)
|
||||
{
|
||||
walk_body (callback_stmt, callback_op, info, gimple_body (info->context));
|
||||
gimple_seq body = gimple_body (info->context);
|
||||
walk_body (callback_stmt, callback_op, info, &body);
|
||||
gimple_set_body (info->context, body);
|
||||
}
|
||||
|
||||
/* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
|
||||
|
|
@ -613,9 +615,9 @@ walk_gimple_omp_for (gimple for_stmt,
|
|||
tree t;
|
||||
size_t i;
|
||||
|
||||
walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body (for_stmt));
|
||||
walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body_ptr (for_stmt));
|
||||
|
||||
seq = gimple_seq_alloc ();
|
||||
seq = NULL;
|
||||
memset (&wi, 0, sizeof (wi));
|
||||
wi.info = info;
|
||||
wi.gsi = gsi_last (seq);
|
||||
|
|
@ -644,9 +646,8 @@ walk_gimple_omp_for (gimple for_stmt,
|
|||
walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
|
||||
}
|
||||
|
||||
if (gimple_seq_empty_p (seq))
|
||||
gimple_seq_free (seq);
|
||||
else
|
||||
seq = gsi_seq (wi.gsi);
|
||||
if (!gimple_seq_empty_p (seq))
|
||||
{
|
||||
gimple_seq pre_body = gimple_omp_for_pre_body (for_stmt);
|
||||
annotate_all_with_location (seq, gimple_location (for_stmt));
|
||||
|
|
@ -1136,10 +1137,10 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
|
|||
= info->context;
|
||||
walk_body (convert_nonlocal_reference_stmt,
|
||||
convert_nonlocal_reference_op, info,
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
|
||||
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
|
||||
walk_body (convert_nonlocal_reference_stmt,
|
||||
convert_nonlocal_reference_op, info,
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
|
||||
&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
|
||||
DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
|
||||
= old_context;
|
||||
}
|
||||
|
|
@ -1148,7 +1149,7 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
|
|||
case OMP_CLAUSE_LASTPRIVATE:
|
||||
walk_body (convert_nonlocal_reference_stmt,
|
||||
convert_nonlocal_reference_op, info,
|
||||
OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
|
||||
&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -1261,7 +1262,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
info->new_local_var_chain = NULL;
|
||||
|
||||
walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
|
||||
if (info->new_local_var_chain)
|
||||
declare_vars (info->new_local_var_chain,
|
||||
|
|
@ -1277,7 +1278,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
walk_gimple_omp_for (stmt, convert_nonlocal_reference_stmt,
|
||||
convert_nonlocal_reference_op, info);
|
||||
walk_body (convert_nonlocal_reference_stmt,
|
||||
convert_nonlocal_reference_op, info, gimple_omp_body (stmt));
|
||||
convert_nonlocal_reference_op, info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1285,7 +1286,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
save_suppress = info->suppress_expansion;
|
||||
convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
|
||||
walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1293,7 +1294,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
save_suppress = info->suppress_expansion;
|
||||
convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
|
||||
walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1301,7 +1302,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
case GIMPLE_OMP_MASTER:
|
||||
case GIMPLE_OMP_ORDERED:
|
||||
walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
break;
|
||||
|
||||
case GIMPLE_BIND:
|
||||
|
|
@ -1635,10 +1636,10 @@ convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
|
|||
= info->context;
|
||||
walk_body (convert_local_reference_stmt,
|
||||
convert_local_reference_op, info,
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
|
||||
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
|
||||
walk_body (convert_local_reference_stmt,
|
||||
convert_local_reference_op, info,
|
||||
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
|
||||
&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
|
||||
DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
|
||||
= old_context;
|
||||
}
|
||||
|
|
@ -1647,7 +1648,7 @@ convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
|
|||
case OMP_CLAUSE_LASTPRIVATE:
|
||||
walk_body (convert_local_reference_stmt,
|
||||
convert_local_reference_op, info,
|
||||
OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
|
||||
&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -1692,7 +1693,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
info->new_local_var_chain = NULL;
|
||||
|
||||
walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
|
||||
gimple_omp_body (stmt));
|
||||
gimple_omp_body_ptr (stmt));
|
||||
|
||||
if (info->new_local_var_chain)
|
||||
declare_vars (info->new_local_var_chain,
|
||||
|
|
@ -1707,7 +1708,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
walk_gimple_omp_for (stmt, convert_local_reference_stmt,
|
||||
convert_local_reference_op, info);
|
||||
walk_body (convert_local_reference_stmt, convert_local_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1715,7 +1716,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
save_suppress = info->suppress_expansion;
|
||||
convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
|
||||
walk_body (convert_local_reference_stmt, convert_local_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1723,7 +1724,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
save_suppress = info->suppress_expansion;
|
||||
convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
|
||||
walk_body (convert_local_reference_stmt, convert_local_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
info->suppress_expansion = save_suppress;
|
||||
break;
|
||||
|
||||
|
|
@ -1731,7 +1732,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
case GIMPLE_OMP_MASTER:
|
||||
case GIMPLE_OMP_ORDERED:
|
||||
walk_body (convert_local_reference_stmt, convert_local_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
break;
|
||||
|
||||
case GIMPLE_COND:
|
||||
|
|
@ -1809,12 +1810,12 @@ convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
|
||||
/* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
|
||||
field = get_nl_goto_field (i);
|
||||
x = get_frame_field (info, target_context, field, &wi->gsi);
|
||||
x = get_frame_field (info, target_context, field, gsi);
|
||||
x = build_addr (x, target_context);
|
||||
x = gsi_gimplify_val (info, x, &wi->gsi);
|
||||
x = gsi_gimplify_val (info, x, gsi);
|
||||
call = gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO),
|
||||
2, build_addr (new_label, target_context), x);
|
||||
gsi_replace (&wi->gsi, call, false);
|
||||
gsi_replace (gsi, call, false);
|
||||
|
||||
/* We have handled all of STMT's operands, no need to keep going. */
|
||||
*handled_ops_p = true;
|
||||
|
|
@ -1979,7 +1980,7 @@ convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
save_local_var_chain = info->new_local_var_chain;
|
||||
info->new_local_var_chain = NULL;
|
||||
walk_body (convert_tramp_reference_stmt, convert_tramp_reference_op,
|
||||
info, gimple_omp_body (stmt));
|
||||
info, gimple_omp_body_ptr (stmt));
|
||||
if (info->new_local_var_chain)
|
||||
declare_vars (info->new_local_var_chain,
|
||||
gimple_seq_first_stmt (gimple_omp_body (stmt)),
|
||||
|
|
@ -2035,7 +2036,7 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
case GIMPLE_OMP_TASK:
|
||||
save_static_chain_added = info->static_chain_added;
|
||||
info->static_chain_added = 0;
|
||||
walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
|
||||
walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
|
||||
for (i = 0; i < 2; i++)
|
||||
{
|
||||
tree c, decl;
|
||||
|
|
@ -2065,7 +2066,7 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
|
||||
case GIMPLE_OMP_FOR:
|
||||
walk_body (convert_gimple_call, NULL, info,
|
||||
gimple_omp_for_pre_body (stmt));
|
||||
gimple_omp_for_pre_body_ptr (stmt));
|
||||
/* FALLTHRU */
|
||||
case GIMPLE_OMP_SECTIONS:
|
||||
case GIMPLE_OMP_SECTION:
|
||||
|
|
@ -2073,7 +2074,7 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
|
|||
case GIMPLE_OMP_MASTER:
|
||||
case GIMPLE_OMP_ORDERED:
|
||||
case GIMPLE_OMP_CRITICAL:
|
||||
walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
|
||||
walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -221,6 +221,7 @@ make_phi_node (tree var, int len)
|
|||
- sizeof (struct phi_arg_d)
|
||||
+ sizeof (struct phi_arg_d) * len));
|
||||
phi->gsbase.code = GIMPLE_PHI;
|
||||
gimple_init_singleton (phi);
|
||||
phi->gimple_phi.nargs = len;
|
||||
phi->gimple_phi.capacity = capacity;
|
||||
if (TREE_CODE (var) == SSA_NAME)
|
||||
|
|
@ -269,29 +270,29 @@ release_phi_node (gimple phi)
|
|||
/* Resize an existing PHI node. The only way is up. Return the
|
||||
possibly relocated phi. */
|
||||
|
||||
static void
|
||||
resize_phi_node (gimple *phi, size_t len)
|
||||
static gimple
|
||||
resize_phi_node (gimple phi, size_t len)
|
||||
{
|
||||
size_t old_size, i;
|
||||
gimple new_phi;
|
||||
|
||||
gcc_assert (len > gimple_phi_capacity (*phi));
|
||||
gcc_assert (len > gimple_phi_capacity (phi));
|
||||
|
||||
/* The garbage collector will not look at the PHI node beyond the
|
||||
first PHI_NUM_ARGS elements. Therefore, all we have to copy is a
|
||||
portion of the PHI node currently in use. */
|
||||
old_size = sizeof (struct gimple_statement_phi)
|
||||
+ (gimple_phi_num_args (*phi) - 1) * sizeof (struct phi_arg_d);
|
||||
+ (gimple_phi_num_args (phi) - 1) * sizeof (struct phi_arg_d);
|
||||
|
||||
new_phi = allocate_phi_node (len);
|
||||
|
||||
memcpy (new_phi, *phi, old_size);
|
||||
memcpy (new_phi, phi, old_size);
|
||||
|
||||
for (i = 0; i < gimple_phi_num_args (new_phi); i++)
|
||||
{
|
||||
use_operand_p imm, old_imm;
|
||||
imm = gimple_phi_arg_imm_use_ptr (new_phi, i);
|
||||
old_imm = gimple_phi_arg_imm_use_ptr (*phi, i);
|
||||
old_imm = gimple_phi_arg_imm_use_ptr (phi, i);
|
||||
imm->use = gimple_phi_arg_def_ptr (new_phi, i);
|
||||
relink_imm_use_stmt (imm, old_imm, new_phi);
|
||||
}
|
||||
|
|
@ -310,7 +311,7 @@ resize_phi_node (gimple *phi, size_t len)
|
|||
imm->loc.stmt = new_phi;
|
||||
}
|
||||
|
||||
*phi = new_phi;
|
||||
return new_phi;
|
||||
}
|
||||
|
||||
/* Reserve PHI arguments for a new edge to basic block BB. */
|
||||
|
|
@ -324,18 +325,18 @@ reserve_phi_args_for_new_edge (basic_block bb)
|
|||
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
{
|
||||
gimple *loc = gsi_stmt_ptr (&gsi);
|
||||
gimple stmt = gsi_stmt (gsi);
|
||||
|
||||
if (len > gimple_phi_capacity (*loc))
|
||||
if (len > gimple_phi_capacity (stmt))
|
||||
{
|
||||
gimple old_phi = *loc;
|
||||
|
||||
resize_phi_node (loc, cap);
|
||||
gimple new_phi = resize_phi_node (stmt, cap);
|
||||
|
||||
/* The result of the PHI is defined by this PHI node. */
|
||||
SSA_NAME_DEF_STMT (gimple_phi_result (*loc)) = *loc;
|
||||
SSA_NAME_DEF_STMT (gimple_phi_result (new_phi)) = new_phi;
|
||||
gsi_set_stmt (&gsi, new_phi);
|
||||
|
||||
release_phi_node (old_phi);
|
||||
release_phi_node (stmt);
|
||||
stmt = new_phi;
|
||||
}
|
||||
|
||||
/* We represent a "missing PHI argument" by placing NULL_TREE in
|
||||
|
|
@ -345,9 +346,9 @@ reserve_phi_args_for_new_edge (basic_block bb)
|
|||
example, the loop optimizer duplicates several basic blocks,
|
||||
redirects edges, and then fixes up PHI arguments later in
|
||||
batch. */
|
||||
SET_PHI_ARG_DEF (*loc, len - 1, NULL_TREE);
|
||||
SET_PHI_ARG_DEF (stmt, len - 1, NULL_TREE);
|
||||
|
||||
(*loc)->gimple_phi.nargs++;
|
||||
stmt->gimple_phi.nargs++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -356,13 +357,15 @@ reserve_phi_args_for_new_edge (basic_block bb)
|
|||
void
|
||||
add_phi_node_to_bb (gimple phi, basic_block bb)
|
||||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
gimple_seq seq = phi_nodes (bb);
|
||||
/* Add the new PHI node to the list of PHI nodes for block BB. */
|
||||
if (phi_nodes (bb) == NULL)
|
||||
set_phi_nodes (bb, gimple_seq_alloc ());
|
||||
|
||||
gsi = gsi_last (phi_nodes (bb));
|
||||
gsi_insert_after (&gsi, phi, GSI_NEW_STMT);
|
||||
if (seq == NULL)
|
||||
set_phi_nodes (bb, gimple_seq_alloc_with_stmt (phi));
|
||||
else
|
||||
{
|
||||
gimple_seq_add_stmt (&seq, phi);
|
||||
gcc_assert (seq == phi_nodes (bb));
|
||||
}
|
||||
|
||||
/* Associate BB to the PHI node. */
|
||||
gimple_set_bb (phi, bb);
|
||||
|
|
|
|||
|
|
@ -3192,6 +3192,7 @@ initialize_parameter_reductions (void)
|
|||
gimple_seq seq = NULL;
|
||||
tree parm;
|
||||
|
||||
gsi = gsi_start (seq);
|
||||
for (parm = DECL_ARGUMENTS (current_function_decl);
|
||||
parm;
|
||||
parm = DECL_CHAIN (parm))
|
||||
|
|
@ -3205,12 +3206,6 @@ initialize_parameter_reductions (void)
|
|||
if (!access_vec)
|
||||
continue;
|
||||
|
||||
if (!seq)
|
||||
{
|
||||
seq = gimple_seq_alloc ();
|
||||
gsi = gsi_start (seq);
|
||||
}
|
||||
|
||||
for (access = VEC_index (access_p, access_vec, 0);
|
||||
access;
|
||||
access = access->next_grp)
|
||||
|
|
@ -3218,6 +3213,7 @@ initialize_parameter_reductions (void)
|
|||
EXPR_LOCATION (parm));
|
||||
}
|
||||
|
||||
seq = gsi_seq (gsi);
|
||||
if (seq)
|
||||
gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR), seq);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1042,12 +1042,10 @@ static bool
|
|||
remove_dead_phis (basic_block bb)
|
||||
{
|
||||
bool something_changed = false;
|
||||
gimple_seq phis;
|
||||
gimple phi;
|
||||
gimple_stmt_iterator gsi;
|
||||
phis = phi_nodes (bb);
|
||||
|
||||
for (gsi = gsi_start (phis); !gsi_end_p (gsi);)
|
||||
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);)
|
||||
{
|
||||
stats.total_phis++;
|
||||
phi = gsi_stmt (gsi);
|
||||
|
|
|
|||
|
|
@ -277,7 +277,7 @@ dse_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
|
|||
{
|
||||
gimple_stmt_iterator gsi;
|
||||
|
||||
for (gsi = gsi_last (bb_seq (bb)); !gsi_end_p (gsi); gsi_prev (&gsi))
|
||||
for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
|
||||
dse_optimize_stmt (gsi);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1202,16 +1202,18 @@ forward_propagate_addr_expr (tree name, tree rhs)
|
|||
}
|
||||
|
||||
|
||||
/* Forward propagate the comparison defined in STMT like
|
||||
/* Forward propagate the comparison defined in *DEFGSI like
|
||||
cond_1 = x CMP y to uses of the form
|
||||
a_1 = (T')cond_1
|
||||
a_1 = !cond_1
|
||||
a_1 = cond_1 != 0
|
||||
Returns true if stmt is now unused. */
|
||||
Returns true if stmt is now unused. Advance DEFGSI to the next
|
||||
statement. */
|
||||
|
||||
static bool
|
||||
forward_propagate_comparison (gimple stmt)
|
||||
forward_propagate_comparison (gimple_stmt_iterator *defgsi)
|
||||
{
|
||||
gimple stmt = gsi_stmt (*defgsi);
|
||||
tree name = gimple_assign_lhs (stmt);
|
||||
gimple use_stmt;
|
||||
tree tmp = NULL_TREE;
|
||||
|
|
@ -1224,18 +1226,18 @@ forward_propagate_comparison (gimple stmt)
|
|||
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)))
|
||||
|| (TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME
|
||||
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt))))
|
||||
return false;
|
||||
goto bailout;
|
||||
|
||||
/* Do not un-cse comparisons. But propagate through copies. */
|
||||
use_stmt = get_prop_dest_stmt (name, &name);
|
||||
if (!use_stmt
|
||||
|| !is_gimple_assign (use_stmt))
|
||||
return false;
|
||||
goto bailout;
|
||||
|
||||
code = gimple_assign_rhs_code (use_stmt);
|
||||
lhs = gimple_assign_lhs (use_stmt);
|
||||
if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
|
||||
return false;
|
||||
goto bailout;
|
||||
|
||||
/* We can propagate the condition into a statement that
|
||||
computes the logical negation of the comparison result. */
|
||||
|
|
@ -1249,13 +1251,13 @@ forward_propagate_comparison (gimple stmt)
|
|||
enum tree_code inv_code;
|
||||
inv_code = invert_tree_comparison (gimple_assign_rhs_code (stmt), nans);
|
||||
if (inv_code == ERROR_MARK)
|
||||
return false;
|
||||
goto bailout;
|
||||
|
||||
tmp = build2 (inv_code, TREE_TYPE (lhs), gimple_assign_rhs1 (stmt),
|
||||
gimple_assign_rhs2 (stmt));
|
||||
}
|
||||
else
|
||||
return false;
|
||||
goto bailout;
|
||||
|
||||
gsi = gsi_for_stmt (use_stmt);
|
||||
gimple_assign_set_rhs_from_tree (&gsi, unshare_expr (tmp));
|
||||
|
|
@ -1271,8 +1273,16 @@ forward_propagate_comparison (gimple stmt)
|
|||
fprintf (dump_file, "'\n");
|
||||
}
|
||||
|
||||
/* When we remove stmt now the iterator defgsi goes off it's current
|
||||
sequence, hence advance it now. */
|
||||
gsi_next (defgsi);
|
||||
|
||||
/* Remove defining statements. */
|
||||
return remove_prop_source_from_use (name);
|
||||
|
||||
bailout:
|
||||
gsi_next (defgsi);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2752,9 +2762,8 @@ ssa_forward_propagate_and_combine (void)
|
|||
}
|
||||
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
||||
{
|
||||
if (forward_propagate_comparison (stmt))
|
||||
if (forward_propagate_comparison (&gsi))
|
||||
cfg_changed = true;
|
||||
gsi_next (&gsi);
|
||||
}
|
||||
else
|
||||
gsi_next (&gsi);
|
||||
|
|
|
|||
|
|
@ -1328,8 +1328,8 @@ move_computations_stmt (struct dom_walk_data *dw_data,
|
|||
}
|
||||
|
||||
mark_virtual_ops_for_renaming (stmt);
|
||||
gsi_insert_on_edge (loop_preheader_edge (level), stmt);
|
||||
gsi_remove (&bsi, false);
|
||||
gsi_insert_on_edge (loop_preheader_edge (level), stmt);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
|
|||
HOST_WIDE_INT dummy;
|
||||
gimple stmt, pattern_stmt = NULL;
|
||||
gimple_seq pattern_def_seq = NULL;
|
||||
gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
|
||||
gimple_stmt_iterator pattern_def_si = gsi_none ();
|
||||
bool analyze_pattern_stmt = false;
|
||||
|
||||
if (vect_print_dump_info (REPORT_DETAILS))
|
||||
|
|
@ -336,7 +336,7 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
|
|||
}
|
||||
else
|
||||
{
|
||||
pattern_def_si = gsi_start (NULL);
|
||||
pattern_def_si = gsi_none ();
|
||||
analyze_pattern_stmt = false;
|
||||
}
|
||||
}
|
||||
|
|
@ -5231,7 +5231,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
|
|||
gimple_seq cond_expr_stmt_list = NULL;
|
||||
gimple stmt, pattern_stmt;
|
||||
gimple_seq pattern_def_seq = NULL;
|
||||
gimple_stmt_iterator pattern_def_si = gsi_start (NULL);
|
||||
gimple_stmt_iterator pattern_def_si = gsi_none ();
|
||||
bool transform_pattern_stmt = false;
|
||||
|
||||
if (vect_print_dump_info (REPORT_DETAILS))
|
||||
|
|
@ -5409,7 +5409,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
|
|||
}
|
||||
else
|
||||
{
|
||||
pattern_def_si = gsi_start (NULL);
|
||||
pattern_def_si = gsi_none ();
|
||||
transform_pattern_stmt = false;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue