OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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 2012-05-02 16:41:48 +00:00
parent 63dc7fbee0
commit 355a767352
30 changed files with 1074 additions and 738 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
gcc/ChangeLog
View File

@ -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.

6
gcc/cgraphbuild.c
View File

@ -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);
}

2
gcc/cgraphunit.c
View File

@ -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);

5
gcc/coretypes.h
View File

@ -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;

2
gcc/function.h
View File

@ -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;

16
gcc/gimple-fold.c
View File

@ -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

228
gcc/gimple-iterator.c
View File

@ -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 ();
}

37
gcc/gimple-low.c
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

24
gcc/gimplify.c
View File

@ -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);
}

29
gcc/graphite-sese-to-poly.c
View File

@ -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));

2
gcc/ipa-prop.c
View File

@ -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,

2
gcc/lto-streamer-in.c
View File

@ -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
View File

@ -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;

12
gcc/trans-mem.c
View File

@ -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;
}

13
gcc/tree-cfg.c
View File

@ -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;
}

11
gcc/tree-complex.c
View File

@ -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);
}

88
gcc/tree-eh.c
View File

@ -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;

9
gcc/tree-flow-inline.h
View File

@ -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

2
gcc/tree-inline.c
View File

@ -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;

10
gcc/tree-mudflap.c
View File

@ -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;

65
gcc/tree-nested.c
View File

@ -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:

47
gcc/tree-phinodes.c
View File

@ -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);

8
gcc/tree-sra.c
View File

@ -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);
}

4
gcc/tree-ssa-dce.c
View File

@ -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);

2
gcc/tree-ssa-dse.c
View File

@ -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);
}

29
gcc/tree-ssa-forwprop.c
View File

@ -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);

2
gcc/tree-ssa-loop-im.c
View File

@ -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);
}
}

8
gcc/tree-vect-loop.c
View File

@ -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;
}
}