Merger of git branch "gimple-classes-v2-option-3"

gcc/ChangeLog:
	Merger of git branch "gimple-classes-v2-option-3".

	* ChangeLog.gimple-classes: New.

	* coretypes.h (struct gcond): Add forward decl.
	(struct gdebug): Likewise.
	(struct ggoto): Likewise.
	(struct glabel): Likewise.
	(struct gswitch): Likewise.
	(struct gassign): Likewise.
	(struct gasm): Likewise.
	(struct gcall): Likewise.
	(struct gtransaction): Likewise.
	(struct greturn): Likewise.
	(struct gbind): Likewise.
	(struct gcatch): Likewise.
	(struct geh_filter): Likewise.
	(struct geh_mnt): Likewise.
	(struct geh_else): Likewise.
	(struct gresx): Likewise.
	(struct geh_dispatch): Likewise.
	(struct gphi): Likewise.
	(struct gtry): Likewise.
	(struct gomp_atomic_load): Likewise.
	(struct gomp_atomic_store): Likewise.
	(struct gomp_continue): Likewise.
	(struct gomp_critical): Likewise.
	(struct gomp_for): Likewise.
	(struct gomp_parallel): Likewise.
	(struct gomp_task): Likewise.
	(struct gomp_sections): Likewise.
	(struct gomp_single): Likewise.
	(struct gomp_target): Likewise.
	(struct gomp_teams): Likewise.

	* doc/gimple.texi (Class hierarchy of GIMPLE statements): Update
	for renaming of gimple subclasses.

	* gdbhooks.py: Update.

	* gimple-iterator.c (gsi_for_phi): New.
	(gsi_start_phis): Strengthen return type from gimple_stmt_iterator
	to gphi_iterator.
	* gimple-iterator.h (struct gphi_iterator): New subclass of
	gimple_stmt_iterator.
	(gsi_for_phi): New prototype.
	(gsi_start_phis): Strengthen return type from gimple_stmt_iterator
	to gphi_iterator.
	(gsi_next_nonvirtual_phi): Strengthen param from
	gimple_stmt_iterator * to gphi_iterator *, and local "phi" from
	gimple to gphi *.

	* gsstruct.def: Update for renamings of classes.

	* gimple.c (gimple_build_return): Strengthen return type from
	gimple to greturn *.
	(gimple_call_reset_alias_info): Strengthen param to gcall *.
	(gimple_build_call_1): Strengthen return type from gimple to
	gcall *.
	(gimple_build_call_vec): Likewise.
	(gimple_build_call): Likewise.
	(gimple_build_call_valist): Likewise.
	(gimple_build_call_internal_1): Likewise.
	(gimple_build_call_internal): Likewise.
	(gimple_build_call_internal_vec): Likewise.
	(gimple_build_call_from_tree): Likewise.
	(gimple_build_assign_stat): Strengthen return type from gimple to
	gassign *.
	(gimple_build_assign_with_ops): Likewise.
	(gimple_build_assign_with_ops): Likewise.
	(gimple_build_cond): Strengthen return type from gimple to
	gcond *.
	(gimple_build_cond_from_tree): Likewise.
	(gimple_cond_set_condition_from_tree): Require a gcond *.
	(gimple_build_label): Strengthen return type from gimple to
	glabel *.
	(gimple_build_goto): Strengthen return type from gimple to
	ggoto *.
	(gimple_build_bind): Strengthen return type from gimple to
	gbind *.
	(gimple_build_asm_1): Strengthen return type from gimple to
	gasm *.
	(gimple_build_asm_vec): Likewise.
	(gimple_build_catch): Strengthen return type from gimple to
	gcatch *.
	(gimple_build_eh_filter): Strengthen return type from gimple to
	geh_filter *.
	(gimple_build_eh_must_not_throw): Strengthen return type from
	gimple to geh_mnt *.
	(gimple_build_eh_else): Strengthen return type from gimple to
	geh_else *.
	(gimple_build_try): Update for renaming of gimple_statement_try to
	gtry.
	(gimple_build_resx): Strengthen return type from gimple to
	gresx *.
	(gimple_build_switch_nlabels): Strengthen return type from gimple
	to gswitch *.
	(gimple_build_switch): Likewise.
	(gimple_build_eh_dispatch): Strengthen return type from gimple to
	geh_dispatch *.
	(gimple_build_debug_bind_stat): Strengthen return type from gimple
	to gdebug *.
	(gimple_build_debug_source_bind_stat): Strengthen return type from
	gimple to gdebug *.
	(gimple_build_omp_critical): Strengthen return type from gimple to
	gomp_critical *.
	(gimple_build_omp_for): Strengthen return type from gimple to
	gomp_for *.
	(gimple_build_omp_parallel): Strengthen return type from gimple to
	gomp_parallel *.
	(gimple_build_omp_task): Strengthen return type from gimple to
	gomp_task *.
	(gimple_build_omp_continue): Strengthen return type from gimple to
	gomp_continue *.
	(gimple_build_omp_sections): Strengthen return type from gimple to
	gomp_sections *.
	(gimple_build_omp_single): Strengthen return type from gimple to
	gomp_single *.
	(gimple_build_omp_target): Strengthen return type from gimple to
	gomp_target *.
	(gimple_build_omp_teams): Strengthen return type from gimple to
	gomp_teams *.
	(gimple_build_omp_atomic_load): Strengthen return type from gimple
	to gomp_atomic_load *.
	(gimple_build_omp_atomic_store): Strengthen return type from gimple
	to gomp_atomic_store *.
	(gimple_build_transaction): Strengthen return type from gimple
	to gtransaction *.
	(empty_stmt_p): Replace check for GIMPLE_BIND with a dyn_cast.
	(gimple_call_fnspec): Require a const gcall *.
	(gimple_call_arg_flags): Likewise.
	(gimple_call_return_flags): Likewise.
	(gimple_set_bb): Add a checked cast.
	(gimple_copy): Within the cases, add locals of the appropriate
	subclass and use in place of "stmt" and "copy" for typesafety.
	(gimple_has_side_effects): Add a checked cast.
	(gimple_could_trap_p_1): Likewise.
	(gimple_call_copy_skip_args): Require a gcall *, and return one.
	(gimple_asm_clobbers_memory_p): Require a const gasm *.
	(infer_nonnull_range): Replace a check for GIMPLE_RETURN with a
	dyn_cast, introducing local "return_stmt" and using ti in place
	of "stmt".

	* gimple.h (gimple_vec): Eliminate this typedef.
	(struct gimple_statement_call): Rename to...
	(struct gcall): ...this.
	(struct gimple_statement_bind): Rename to...
	(struct gbind): ...this.
	(struct gimple_statement_catch): Rename to...
	(struct gcatch): ...this.
	(struct gimple_statement_eh_filter): Rename to...
	(struct geh_filter): ...this.
	(struct gimple_statement_eh_else): Rename to...
	(struct geh_else): ...this.
	(struct gimple_statement_eh_mnt): Rename to...
	(struct geh_mnt): ...this.
	(struct gimple_statement_phi): Rename to...
	(struct gphi): ...this.
	(struct gimple_statement_resx): Rename to...
	(struct gresx): ...this.
	(struct gimple_statement_eh_dispatch): Rename to...
	(struct geh_dispatch): ...this.
	(struct gimple_statement_try): Rename to...
	(struct gtry): ...this.
	(struct gimple_statement_asm): Rename to...
	(struct gasm): ...this.
	(struct gimple_statement_omp_critical): Rename to...
	(struct gomp_critical): ...this.
	(struct gimple_statement_omp_for): Rename to...
	(struct gomp_for): ...this.
	(struct gimple_statement_omp_parallel): Rename to...
	(struct gomp_parallel): ...this.
	(struct gimple_statement_omp_target): Rename to...
	(struct gomp_target): ...this.
	(struct gimple_statement_omp_task): Rename to...
	(struct gomp_task): ...this.
	(struct gimple_statement_omp_sections): Rename to...
	(struct gomp_sections): ...this.
	(struct gimple_statement_omp_continue): Rename to...
	(struct gomp_continue): ...this.
	(struct gimple_statement_omp_single): Rename to...
	(struct gomp_single): ...this.
	(struct gimple_statement_omp_teams): Rename to...
	(struct gomp_teams): ...this.
	(struct gimple_statement_omp_atomic_load): Rename to...
	(struct gomp_atomic_load): ...this.
	(struct gimple_statement_omp_atomic_store :): Rename to...
	(struct gomp_atomic_store :): ...this.
	(struct gimple_statement_transaction): Rename to...
	(struct gtransaction): ...this.
	(struct gcond): New subclass.
	(struct gdebug): New subclass.
	(struct ggoto): New subclass.
	(struct glabel): New subclass.
	(struct gswitch): New subclass.
	(struct gassign): New subclass.
	(struct greturn): New subclass.
	(is_a_helper <gimple_statement_asm *>::test): Rename to...
	(is_a_helper <gasm *>::test): ...this.
	(is_a_helper <gimple_statement_bind *>::test): Rename to...
	(is_a_helper <gbind *>::test): ...this.
	(is_a_helper <gassign *>::test): New.
	(is_a_helper <gimple_statement_call *>::test): Rename to...
	(is_a_helper <gcall *>::test): ...this.
	(is_a_helper <gimple_statement_catch *>::test): Rename to...
	(is_a_helper <gcatch *>::test): ...this.
	(is_a_helper <gimple_statement_resx *>::test): Rename to...
	(is_a_helper <gresx *>::test): ...this.
	(is_a_helper <gcond *>::test): New.
	(is_a_helper <gdebug *>::test): New.
	(is_a_helper <ggoto *>::test): New.
	(is_a_helper <glabel *>::test): New.
	(is_a_helper <gimple_statement_eh_dispatch *>::test): Rename to...
	(is_a_helper <geh_dispatch *>::test): ...this.
	(is_a_helper <gimple_statement_eh_else *>::test): Rename to...
	(is_a_helper <geh_else *>::test): ...this.
	(is_a_helper <gimple_statement_eh_filter *>::test): Rename to...
	(is_a_helper <geh_filter *>::test): ...this.
	(is_a_helper <gimple_statement_eh_mnt *>::test): Rename to...
	(is_a_helper <geh_mnt *>::test): ...this.
	(is_a_helper <gimple_statement_omp_atomic_load *>::test): Rename to...
	(is_a_helper <gomp_atomic_load *>::test): ...this.
	(is_a_helper <gimple_statement_omp_atomic_store *>::test): Rename to...
	(is_a_helper <gomp_atomic_store *>::test): ...this.
	(is_a_helper <gimple_statement_omp_continue *>::test): Rename to...
	(is_a_helper <gomp_continue *>::test): ...this.
	(is_a_helper <gimple_statement_omp_critical *>::test): Rename to...
	(is_a_helper <gomp_critical *>::test): ...this.
	(is_a_helper <gimple_statement_omp_for *>::test): Rename to...
	(is_a_helper <gomp_for *>::test): ...this.
	(is_a_helper <gimple_statement_omp_parallel *>::test): Rename to...
	(is_a_helper <gomp_parallel *>::test): ...this.
	(is_a_helper <gimple_statement_omp_target *>::test): Rename to...
	(is_a_helper <gomp_target *>::test): ...this.
	(is_a_helper <gimple_statement_omp_sections *>::test): Rename to...
	(is_a_helper <gomp_sections *>::test): ...this.
	(is_a_helper <gimple_statement_omp_single *>::test): Rename to...
	(is_a_helper <gomp_single *>::test): ...this.
	(is_a_helper <gimple_statement_omp_teams *>::test): Rename to...
	(is_a_helper <gomp_teams *>::test): ...this.
	(is_a_helper <gimple_statement_omp_task *>::test): Rename to...
	(is_a_helper <gomp_task *>::test): ...this.
	(is_a_helper <gimple_statement_phi *>::test): Rename to...
	(is_a_helper <gphi *>::test): ...this.
	(is_a_helper <gimple_statement_transaction *>::test): Rename to...
	(is_a_helper <gtransaction *>::test): ...this.
	(is_a_helper <greturn *>::test): New.
	(is_a_helper <gswitch *>::test): New.
	(is_a_helper <gimple_statement_try *>::test): Rename to...
	(is_a_helper <gtry *>::test): ...this.
	(is_a_helper <const gimple_statement_asm *>::test): Rename to...
	(is_a_helper <const gasm *>::test): ...this.
	(is_a_helper <const gimple_statement_bind *>::test): Rename to...
	(is_a_helper <const gbind *>::test): ...this.
	(is_a_helper <const gimple_statement_call *>::test): Rename to...
	(is_a_helper <const gcall *>::test): ...this.
	(is_a_helper <const gimple_statement_catch *>::test): Rename to...
	(is_a_helper <const gcatch *>::test): ...this.
	(is_a_helper <const gimple_statement_resx *>::test): Rename to...
	(is_a_helper <const gresx *>::test): ...this.
	(is_a_helper <const gimple_statement_eh_dispatch *>::test): Rename to...
	(is_a_helper <const geh_dispatch *>::test): ...this.
	(is_a_helper <const gimple_statement_eh_filter *>::test): Rename to...
	(is_a_helper <const geh_filter *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_atomic_load *>::test):
	Rename to...
	(is_a_helper <const gomp_atomic_load *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_atomic_store *>::test):
	Rename to...
	(is_a_helper <const gomp_atomic_store *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_continue *>::test):
	Rename to...
	(is_a_helper <const gomp_continue *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_critical *>::test):
	Rename to...
	(is_a_helper <const gomp_critical *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_for *>::test): Rename to...
	(is_a_helper <const gomp_for *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_parallel *>::test):
	Rename to...
	(is_a_helper <const gomp_parallel *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_target *>::test): Rename to...
	(is_a_helper <const gomp_target *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_sections *>::test):
	Rename to...
	(is_a_helper <const gomp_sections *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_single *>::test): Rename to...
	(is_a_helper <const gomp_single *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_teams *>::test): Rename to...
	(is_a_helper <const gomp_teams *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_task *>::test): Rename to...
	(is_a_helper <const gomp_task *>::test): ...this.
	(is_a_helper <const gimple_statement_phi *>::test): Rename to...
	(is_a_helper <const gphi *>::test): ...this.
	(is_a_helper <const gimple_statement_transaction *>::test): Rename to...
	(is_a_helper <const gtransaction *>::test): ...this.
	(gimple_build_return): Strengthen return type to greturn *.
	(gimple_call_reset_alias_info): Require a gcall *.
	(gimple_build_call_vec): Return a gcall *.
	(gimple_build_call): Likewise.
	(gimple_build_call_valist): Likewise.
	(gimple_build_call_internal): Likewise.
	(gimple_build_call_internal_vec): Likewise.
	(gimple_build_call_from_tree): Likewise.
	(gimple_build_assign_stat): Return a gassign *.
	(gimple_build_assign_with_ops): Likewise.
	(gimple_build_cond): Return a gcond *.
	(gimple_build_cond_from_tree): Likewise.
	(gimple_cond_set_condition_from_tree): Require a gcond *.
	(gimple_build_label): Return a glabel *.
	(gimple_build_goto): Return a ggoto *.
	(gimple_build_bind): Return a gbind *.
	(gimple_build_asm_vec): Return a gasm *.
	(gimple_build_catch): Return a gcatch *.
	(gimple_build_eh_filter): Return a geh_filter *.
	(gimple_build_eh_must_not_throw): Return a geh_mnt *.
	(gimple_build_eh_else): Return a geh_else *.
	(gimple_build_try): Return a gtry *.
	(gimple_build_resx): Return a gresx *.
	(gimple_build_switch_nlabels): Return a gswitch *.
	(gimple_build_switch): Return a gswitch *.
	(gimple_build_eh_dispatch): Return a geh_dispatch *.
	(gimple_build_debug_bind_stat): Return a gdebug *.
	(gimple_build_debug_source_bind_stat): Return a gdebug *.
	(gimple_build_omp_critical): Return a gomp_critical *.
	(gimple_build_omp_for): Return a gomp_for *.
	(gimple_build_omp_parallel): Return a gomp_parallel *.
	(gimple_build_omp_task): Return a gomp_task *.
	(gimple_build_omp_continue): Return a gomp_continue *.
	(gimple_build_omp_sections): Return a gomp_sections *.
	(gimple_build_omp_single): Return a gomp_single *.
	(gimple_build_omp_target): Return a gomp_target *.
	(gimple_build_omp_teams): Return a gomp_teams *.
	(gimple_build_omp_atomic_load): Return a gomp_atomic_load *.
	(gimple_build_omp_atomic_store): Return a gomp_atomic_store *.
	(gimple_build_transaction): Return a gtransaction *.
	(gimple_call_arg_flags): Require a const gcall *.
	(gimple_call_return_flags): Likewise.
	(gimple_call_copy_skip_args): Require and return a gcall *.
	(gimple_asm_clobbers_memory_p): Require a const gasm *.
	(gimple_seq_first_stmt_as_a_bind): New.
	(gimple_assign_nontemporal_move_p): Require a const gassign *
	rather than a const_gimple.
	(gimple_call_internal_fn): Update for renaming to gcall.
	(gimple_call_fntype): Likewise.
	(gimple_call_set_fntype): Require a gcall * rather than a gimple.
	(gimple_call_set_fn): Likewise.
	(gimple_call_set_internal_fn): Likewise.
	(gimple_call_set_chain): Likewise.
	(gimple_call_set_tail): Likewise.
	(gimple_call_tail_p): Likewise.
	(gimple_call_set_return_slot_opt): Likewise.
	(gimple_call_return_slot_opt_p): Likewise.
	(gimple_call_set_from_thunk): Likewise.
	(gimple_call_from_thunk_p): Likewise.
	(gimple_call_set_va_arg_pack): Likewise.
	(gimple_call_va_arg_pack_p): Likewise.
	(gimple_call_set_nothrow): Likewise.
	(gimple_call_nothrow_p): Likewise.
	(gimple_call_set_alloca_for_var): Likewise.
	(gimple_call_alloca_for_var_p): Likewise.
	(gimple_call_use_set): Likewise.
	(gimple_call_clobber_set): Likewise.
	(gimple_call_return_type): Require a const gcall * rather than a
	const_gimple.
	(gimple_call_chain_ptr): Likewise.
	(gimple_call_copy_flags): Require a pair of gcall *.
	(gimple_cond_set_code): Require a gcond * rather than a gimple
	(gimple_cond_set_lhs): Likewise.
	(gimple_cond_set_rhs): Likewise.
	(gimple_cond_set_true_label): Likewise.
	(gimple_cond_set_false_label): Likewise.
	(gimple_cond_make_false): Likewise.
	(gimple_cond_make_true): Likewise.
	(gimple_cond_lhs_ptr): Require a const gcond * rather than a
	const_gimple.
	(gimple_cond_rhs_ptr): Likewise.
	(gimple_cond_true_label): Likewise.
	(gimple_cond_false_label): Likewise.
	(gimple_cond_true_p): Likewise.
	(gimple_cond_false_p): Likewise.
	(gimple_cond_set_condition): Likewise.
	(gimple_label_label): Require a const glabel *.
	(gimple_label_set_label): Require a glabel *.
	(gimple_goto_set_dest): Require a ggoto *.
	(gimple_bind_vars): Require a const gbind *.
	(gimple_bind_block): Likewise.
	(gimple_bind_set_vars): Require a gbind *.
	(gimple_bind_append_vars): Likewise.
	(gimple_bind_body_ptr): Likewise.
	(gimple_bind_body): Likewise.
	(gimple_bind_set_body): Likewise.
	(gimple_bind_add_stmt): Likewise.
	(gimple_bind_add_seq): Likewise.
	(gimple_bind_set_block): Likewise.
	(gimple_asm_ninputs): Require a const gasm *.
	(gimple_asm_noutputs): Likewise.
	(gimple_asm_nclobbers): Likewise.
	(gimple_asm_nlabels): Likewise.
	(gimple_asm_input_op): Likewise.
	(gimple_asm_input_op_ptr): Likewise.
	(gimple_asm_output_op): Likewise.
	(gimple_asm_output_op_ptr): Likewise.
	(gimple_asm_clobber_op): Likewise.
	(gimple_asm_label_op): Likewise.
	(gimple_asm_string): Likewise.
	(gimple_asm_volatile_p): Likewise.
	(gimple_asm_input_p): Likewise.
	(gimple_asm_set_input_op): Require a gasm *.
	(gimple_asm_set_output_op): Likewise.
	(gimple_asm_set_clobber_op): Likewise.
	(gimple_asm_set_label_op): Likewise.
	(gimple_asm_set_volatile): Likewise.
	(gimple_asm_set_input): Likewise.
	(gimple_catch_types): Require a const gcatch *.
	(gimple_catch_types_ptr): Require a gcatch *.
	(gimple_catch_handler_ptr): Likewise.
	(gimple_catch_handler): Likewise.
	(gimple_catch_set_types): Likewise.
	(gimple_catch_set_handler): Likewise.
	(gimple_eh_filter_types): Update for renaming of subclass to
	geh_filter.
	(gimple_eh_filter_types_ptr): Likewise.
	(gimple_eh_filter_failure_ptr): Likewise.
	(gimple_eh_filter_set_types): Require a geh_filter *.
	(gimple_eh_filter_set_failure): Likewise.
	(gimple_eh_must_not_throw_fndecl): Require a geh_mnt *.
	(gimple_eh_must_not_throw_set_fndecl): Likewise.
	(gimple_eh_else_n_body_ptr): Require a geh_else *.
	(gimple_eh_else_n_body): Likewise.
	(gimple_eh_else_e_body_ptr): Likewise.
	(gimple_eh_else_e_body): Likewise.
	(gimple_eh_else_set_n_body): Likewise.
	(gimple_eh_else_set_e_body): Likewise.
	(gimple_try_set_kind): Require a gtry *.
	(gimple_try_set_catch_is_cleanup): Likewise.
	(gimple_try_set_eval): Likewise.
	(gimple_try_set_cleanup): Likewise.
	(gimple_try_eval_ptr): Update for renaming of subclass to gtry.
	(gimple_try_cleanup_ptr): Likewise.
	(gimple_phi_capacity): Update for renaming of subclass to gphi.
	(gimple_phi_num_args): Likewise.
	(gimple_phi_result): Likewise.
	(gimple_phi_result_ptr): Likewise.
	(gimple_phi_arg): Likewise.
	(gimple_phi_set_result): Require a gphi *.
	(gimple_phi_set_arg): Likewise.
	(gimple_phi_arg_def_ptr): Likewise.
	(gimple_phi_arg_edge): Likewise.
	(gimple_phi_arg_location): Likewise.
	(gimple_phi_arg_location_from_edge): Likewise.
	(gimple_phi_arg_set_location): Likewise.
	(gimple_phi_arg_has_location): Likewise.
	(gimple_resx_region): Require a const gresx *.
	(gimple_resx_set_region): Require a gresx *.
	(gimple_eh_dispatch_region): Require a const geh_dispatch *.
	(gimple_eh_dispatch_set_region): Require a geh_dispatch *.
	(gimple_switch_num_labels): Require a const gswitch *.
	(gimple_switch_set_num_labels): Likewise.
	(gimple_switch_index): Likewise.
	(gimple_switch_index_ptr): Likewise.
	(gimple_switch_label): Likewise.
	(gimple_switch_default_label): Likewise.
	(gimple_switch_set_index): Require a gswitch *.
	(gimple_switch_set_label): Likewise.
	(gimple_switch_set_default_label): Likewise.
	(gimple_omp_critical_name): Require a const gomp_critical *.
	(gimple_omp_critical_name_ptr): Require a gomp_critical *.
	(gimple_omp_critical_set_name): Likewise.
	(gimple_omp_for_set_kind): Require a gomp_for *.
	(gimple_omp_for_set_combined_p): Likewise.
	(gimple_omp_for_set_combined_into_p): Likewise.
	(gimple_omp_for_clauses): Update for renaming of subclass to
	gomp_for.
	(gimple_omp_for_clauses_ptr): Likewise.
	(gimple_omp_for_set_clauses): Likewise.
	(gimple_omp_for_collapse): Likewise.
	(gimple_omp_for_index): Likewise.
	(gimple_omp_for_index_ptr): Likewise.
	(gimple_omp_for_set_index): Likewise.
	(gimple_omp_for_initial): Likewise.
	(gimple_omp_for_initial_ptr): Likewise.
	(gimple_omp_for_set_initial): Likewise.
	(gimple_omp_for_final): Likewise.
	(gimple_omp_for_final_ptr): Likewise.
	(gimple_omp_for_set_final): Likewise.
	(gimple_omp_for_incr): Likewise.
	(gimple_omp_for_incr_ptr): Likewise.
	(gimple_omp_for_set_incr): Likewise.
	(gimple_omp_for_pre_body): Likewise.
	(gimple_omp_for_set_pre_body): Likewise.
	(gimple_omp_parallel_clauses): Update for renaming of subclass to
	gomp_parallel.
	(gimple_omp_parallel_clauses_ptr): Require a gomp_parallel *.
	(gimple_omp_parallel_set_clauses): Likewise.
	(gimple_omp_parallel_child_fn_ptr): Likewise.
	(gimple_omp_parallel_set_child_fn): Likewise.
	(gimple_omp_parallel_data_arg_ptr): Likewise.
	(gimple_omp_parallel_set_data_arg): Likewise.
	(gimple_omp_parallel_child_fn): Require a const gomp_parallel *.
	(gimple_omp_parallel_data_arg): Likewise.
	(gimple_omp_task_clauses): Update for renaming of subclass to
	gomp_task.
	(gimple_omp_task_clauses_ptr): Likewise.
	(gimple_omp_task_set_clauses): Likewise.
	(gimple_omp_task_child_fn): Likewise.
	(gimple_omp_task_child_fn_ptr): Likewise.
	(gimple_omp_task_set_child_fn): Likewise.
	(gimple_omp_task_data_arg): Likewise.
	(gimple_omp_task_data_arg_ptr): Likewise.
	(gimple_omp_task_set_data_arg): Likewise.
	(gimple_omp_taskreg_clauses): Whitespace fixes.
	(gimple_omp_taskreg_clauses_ptr): Likewise.
	(gimple_omp_taskreg_set_clauses): Likewise.
	(gimple_omp_taskreg_child_fn): Likewise.
	(gimple_omp_taskreg_child_fn_ptr): Likewise.
	(gimple_omp_taskreg_set_child_fn): Likewise.
	(gimple_omp_taskreg_data_arg): Likewise.
	(gimple_omp_taskreg_data_arg_ptr): Likewise.
	(gimple_omp_taskreg_set_data_arg): Likewise.
	(gimple_omp_task_copy_fn): Update for renaming of subclass to
	gomp_task.
	(gimple_omp_task_copy_fn_ptr): Likewise.
	(gimple_omp_task_set_copy_fn): Likewise.
	(gimple_omp_task_arg_size): Likewise.
	(gimple_omp_task_arg_size_ptr): Likewise.
	(gimple_omp_task_set_arg_size): Likewise.
	(gimple_omp_task_arg_align): Likewise.
	(gimple_omp_task_arg_align_ptr): Likewise.
	(gimple_omp_task_set_arg_align): Likewise.
	(gimple_omp_single_clauses): Update for renaming of subclass to
	gomp_single.
	(gimple_omp_single_clauses_ptr): Likewise.
	(gimple_omp_single_set_clauses): Likewise.
	(gimple_omp_target_clauses): Update for renaming of subclass to
	gomp_target.
	(gimple_omp_target_clauses_ptr): Likewise.
	(gimple_omp_target_set_clauses): Require a gomp_target *.
	(gimple_omp_target_set_kind): Likewise.
	(gimple_omp_target_child_fn_ptr): Likewise.
	(gimple_omp_target_set_child_fn): Likewise.
	(gimple_omp_target_data_arg_ptr): Likewise.
	(gimple_omp_target_set_data_arg): Likewise.
	(gimple_omp_target_child_fn): Require a const gomp_target *.
	(gimple_omp_target_data_arg): Likewise.
	(gimple_omp_teams_clauses): Update for renaming of subclass to
	gomp_teams.
	(gimple_omp_teams_clauses_ptr): Likewise.
	(gimple_omp_teams_set_clauses): Require a gomp_teams *.
	(gimple_omp_sections_clauses): Update for renaming of subclass to
	gomp_sections.
	(gimple_omp_sections_clauses_ptr): Likewise.
	(gimple_omp_sections_set_clauses): Likewise.
	(gimple_omp_sections_control): Likewise.
	(gimple_omp_sections_control_ptr): Likewise.
	(gimple_omp_sections_set_control): Likewise.
	(gimple_omp_for_set_cond): Likewise.
	(gimple_omp_for_cond): Likewise.
	(gimple_omp_atomic_store_set_val): Require a gomp_atomic_store *.
	(gimple_omp_atomic_store_val_ptr): Likewise.
	(gimple_omp_atomic_load_set_lhs): Likewise.
	(gimple_omp_atomic_store_val): Require a const gomp_atomic_store *.
	(gimple_omp_atomic_load_lhs): Likewise.
	(gimple_omp_atomic_load_rhs): Likewise.
	(gimple_omp_atomic_load_lhs_ptr): Require a gomp_atomic_load *.
	(gimple_omp_atomic_load_set_rhs): Likewise.
	(gimple_omp_atomic_load_rhs_ptr): Likewise.
	(gimple_omp_continue_control_def): Require a const gomp_continue *.
	(gimple_omp_continue_control_use): Likewise.
	(gimple_omp_continue_control_def_ptr): Require a gomp_continue *.
	(gimple_omp_continue_set_control_def): Likewise.
	(gimple_omp_continue_control_use_ptr): Likewise.
	(gimple_omp_continue_set_control_use): Likewise.
	(gimple_transaction_body_ptr): Require a gtransaction *.
	(gimple_transaction_body): Likewise.
	(gimple_transaction_label_ptr): Likewise.
	(gimple_transaction_label): Require a const gtransaction *.
	(gimple_transaction_subcode): Likewise.
	(gimple_transaction_set_body): Require a gtransaction *.
	(gimple_transaction_set_label): Likewise.
	(gimple_transaction_set_subcode): Likewise.
	(gimple_return_retval_ptr): Require a const greturn *.
	(gimple_return_retval): Likewise.
	(gimple_return_set_retval): Require a greturn *.
	(gimple_expr_type): Introduce local "call_stmt" and use in place of
	"stmt" for typesafety.

	* asan.c: Use gimple subclasses.
	* auto-profile.c: Likewise.
	* builtins.c: Likewise.
	* builtins.h: Likewise.
	* cfgexpand.c: Likewise.
	* cfgloop.c: Likewise.
	* cfgloopmanip.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* cgraphbuild.c: Likewise.
	* cgraphclones.c: Likewise.
	* cgraphunit.c: Likewise.
	* expr.h: Likewise.
	* gimple-builder.c: Likewise.
	* gimple-builder.h: Likewise.
	* gimple-fold.c: Likewise.
	* gimple-low.c: Likewise.
	* gimple-pretty-print.c: Likewise.
	* gimple-ssa-isolate-paths.c: Likewise.
	* gimple-ssa-strength-reduction.c: Likewise.
	* gimple-streamer-in.c: Likewise.
	* gimple-streamer-out.c: Likewise.
	* gimple-walk.c: Likewise.
	* gimplify-me.c: Likewise.
	* gimplify.c: Likewise.
	* gimplify.h: Likewise.
	* graphite-scop-detection.c: Likewise.
	* graphite-sese-to-poly.c: Likewise.
	* internal-fn.c: Likewise.
	* internal-fn.def:: Likewise.
	* internal-fn.h: Likewise.
	* ipa-icf-gimple.c: Likewise.
	* ipa-icf-gimple.h: Likewise.
	* ipa-icf.c: Likewise.
	* ipa-inline-analysis.c: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-prop.h: Likewise.
	* ipa-pure-const.c: Likewise.
	* ipa-split.c: Likewise.
	* lto-streamer-in.c: Likewise.
	* lto-streamer-out.c: Likewise.
	* omp-low.c: Likewise.
	* predict.c: Likewise.
	* sanopt.c: Likewise.
	* sese.c: Likewise.
	* ssa-iterators.h: Likewise.
	* stmt.c: Likewise.
	* trans-mem.c: Likewise.
	* tree-call-cdce.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-cfg.h: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-chkp.c: Likewise.
	* tree-chkp.h: Likewise.
	* tree-complex.c: Likewise.
	* tree-data-ref.c: Likewise.
	* tree-dfa.c: Likewise.
	* tree-eh.c: Likewise.
	* tree-eh.h: Likewise.
	* tree-emutls.c: Likewise.
	* tree-if-conv.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-inline.h: Likewise.
	* tree-into-ssa.c: Likewise.
	* tree-into-ssa.h: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-nrv.c: Likewise.
	* tree-object-size.c: Likewise.
	* tree-outof-ssa.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-phinodes.c: Likewise.
	* tree-phinodes.h: Likewise.
	* tree-predcom.c: Likewise.
	* tree-profile.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-scalar-evolution.h
	* tree-sra.cn_function):
	* tree-ssa-alias.c: Likewise.
	* tree-ssa-alias.h: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-coalesce.c: Likewise.
	* tree-ssa-copy.c: Likewise.
	* tree-ssa-copyrename.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-ifcombine.c: Likewise.
	* tree-ssa-live.c: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-ssa-loop-unswitch.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-operands.c: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-propagate.h: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-sccvn.h: Likewise.
	* tree-ssa-sink.c: Likewise.
	* tree-ssa-strlen.c
	* tree-ssa-structalias.c
	* tree-ssa-tail-merge.c: Likewise.
	* tree-ssa-ter.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* tree-ssa-threadedge.h: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-uncprop.c: Likewise.
	* tree-ssa-uninit.c: Likewise.
	* tree-ssa.c: Likewise.
	* tree-stdarg.c: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-tailcall.c: Likewise.
	* tree-vect-data-refs.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-vect-loop-manip.c: Likewise.
	* tree-vect-loop.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-vect-slp.c: Likewise.
	* tree-vect-stmts.c: Likewise.
	* tree-vectorizer.h: Likewise.
	* tree-vrp.c: Likewise.
	* tree.c: Likewise.
	* ubsan.c: Likewise.
	* value-prof.c: Likewise.
	* value-prof.h: Likewise.
	* vtable-verify.c: Likewise.

gcc/c-family/ChangeLog:
	Merger of git branch "gimple-classes-v2-option-3".
	* ChangeLog.gimple-classes: New.
	* c-gimplify.c (add_block_to_enclosing): Strengthen local "stack"
	from being just a vec<gimple> to a vec<gbind *>.

gcc/java/ChangeLog:
	Merger of git branch "gimple-classes-v2-option-3".
	* ChangeLog.gimple-classes: New.
	* java-gimplify.c (java_gimplify_block): Strengthen local "outer"
	from gimple to gbind *.

From-SVN: r217787

1 files changed, 198 insertions, 151 deletions

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 6f21fdd..69cac22 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -191,10 +191,12 @@ gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
 
 /* Build a GIMPLE_RETURN statement returning RETVAL.  */
 
-gimple
+greturn *
 gimple_build_return (tree retval)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 2);
+  greturn *s
+    = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
+					       2));
   if (retval)
     gimple_return_set_retval (s, retval);
   return s;
@@ -203,7 +205,7 @@ gimple_build_return (tree retval)
 /* Reset alias information on call S.  */
 
 void
-gimple_call_reset_alias_info (gimple s)
+gimple_call_reset_alias_info (gcall *s)
 {
   if (gimple_call_flags (s) & ECF_CONST)
     memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
@@ -220,10 +222,12 @@ gimple_call_reset_alias_info (gimple s)
    components of a GIMPLE_CALL statement to function FN with NARGS
    arguments.  */
 
-static inline gimple
+static inline gcall *
 gimple_build_call_1 (tree fn, unsigned nargs)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
+  gcall *s
+    = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
+					     nargs + 3));
   if (TREE_CODE (fn) == FUNCTION_DECL)
     fn = build_fold_addr_expr (fn);
   gimple_set_op (s, 1, fn);
@@ -236,12 +240,12 @@ gimple_build_call_1 (tree fn, unsigned nargs)
 /* Build a GIMPLE_CALL statement to function FN with the arguments
    specified in vector ARGS.  */
 
-gimple
+gcall *
 gimple_build_call_vec (tree fn, vec<tree> args)
 {
   unsigned i;
   unsigned nargs = args.length ();
-  gimple call = gimple_build_call_1 (fn, nargs);
+  gcall *call = gimple_build_call_1 (fn, nargs);
 
   for (i = 0; i < nargs; i++)
     gimple_call_set_arg (call, i, args[i]);
@@ -253,11 +257,11 @@ gimple_build_call_vec (tree fn, vec<tree> args)
 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
    arguments.  The ... are the arguments.  */
 
-gimple
+gcall *
 gimple_build_call (tree fn, unsigned nargs, ...)
 {
   va_list ap;
-  gimple call;
+  gcall *call;
   unsigned i;
 
   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
@@ -276,10 +280,10 @@ gimple_build_call (tree fn, unsigned nargs, ...)
 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
    arguments.  AP contains the arguments.  */
 
-gimple
+gcall *
 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
 {
-  gimple call;
+  gcall *call;
   unsigned i;
 
   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
@@ -297,10 +301,12 @@ gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
    Build the basic components of a GIMPLE_CALL statement to internal
    function FN with NARGS arguments.  */
 
-static inline gimple
+static inline gcall *
 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
+  gcall *s
+    = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
+					     nargs + 3));
   s->subcode |= GF_CALL_INTERNAL;
   gimple_call_set_internal_fn (s, fn);
   gimple_call_reset_alias_info (s);
@@ -311,11 +317,11 @@ gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
 /* Build a GIMPLE_CALL statement to internal function FN.  NARGS is
    the number of arguments.  The ... are the arguments.  */
 
-gimple
+gcall *
 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
 {
   va_list ap;
-  gimple call;
+  gcall *call;
   unsigned i;
 
   call = gimple_build_call_internal_1 (fn, nargs);
@@ -331,11 +337,11 @@ gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
    specified in vector ARGS.  */
 
-gimple
+gcall *
 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
 {
   unsigned i, nargs;
-  gimple call;
+  gcall *call;
 
   nargs = args.length ();
   call = gimple_build_call_internal_1 (fn, nargs);
@@ -350,11 +356,11 @@ gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
    assumed to be in GIMPLE form already.  Minimal checking is done of
    this fact.  */
 
-gimple
+gcall *
 gimple_build_call_from_tree (tree t)
 {
   unsigned i, nargs;
-  gimple call;
+  gcall *call;
   tree fndecl = get_callee_fndecl (t);
 
   gcc_assert (TREE_CODE (t) == CALL_EXPR);
@@ -392,7 +398,7 @@ gimple_build_call_from_tree (tree t)
    LHS of the assignment.
    RHS of the assignment which can be unary or binary.  */
 
-gimple
+gassign *
 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
 {
   enum tree_code subcode;
@@ -408,19 +414,20 @@ gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
    OP1 and OP2.  If OP2 is NULL then SUBCODE must be of class
    GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS.  */
 
-gimple
+gassign *
 gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
 			      tree op2, tree op3 MEM_STAT_DECL)
 {
   unsigned num_ops;
-  gimple p;
+  gassign *p;
 
   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
      code).  */
   num_ops = get_gimple_rhs_num_ops (subcode) + 1;
 
-  p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
-  			          PASS_MEM_STAT);
+  p = as_a <gassign *> (
+        gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
+				    PASS_MEM_STAT));
   gimple_assign_set_lhs (p, lhs);
   gimple_assign_set_rhs1 (p, op1);
   if (op2)
@@ -438,7 +445,7 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
   return p;
 }
 
-gimple
+gassign *
 gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
 			      tree op2 MEM_STAT_DECL)
 {
@@ -446,7 +453,7 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
 				       PASS_MEM_STAT);
 }
 
-gimple
+gassign *
 gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1
 			      MEM_STAT_DECL)
 {
@@ -461,14 +468,14 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1
    T_LABEL is the label to jump to if the condition is true.
    F_LABEL is the label to jump to otherwise.  */
 
-gimple
+gcond *
 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
 		   tree t_label, tree f_label)
 {
-  gimple p;
+  gcond *p;
 
   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
-  p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
+  p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
   gimple_cond_set_lhs (p, lhs);
   gimple_cond_set_rhs (p, rhs);
   gimple_cond_set_true_label (p, t_label);
@@ -479,7 +486,7 @@ gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
 /* Build a GIMPLE_COND statement from the conditional expression tree
    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
 
-gimple
+gcond *
 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
 {
   enum tree_code code;
@@ -493,7 +500,7 @@ gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
    boolean expression tree COND.  */
 
 void
-gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
+gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
 {
   enum tree_code code;
   tree lhs, rhs;
@@ -504,20 +511,22 @@ gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
 
 /* Build a GIMPLE_LABEL statement for LABEL.  */
 
-gimple
+glabel *
 gimple_build_label (tree label)
 {
-  gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
+  glabel *p
+    = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
   gimple_label_set_label (p, label);
   return p;
 }
 
 /* Build a GIMPLE_GOTO statement to label DEST.  */
 
-gimple
+ggoto *
 gimple_build_goto (tree dest)
 {
-  gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
+  ggoto *p
+    = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
   gimple_goto_set_dest (p, dest);
   return p;
 }
@@ -536,10 +545,10 @@ gimple_build_nop (void)
    VARS are the variables in BODY.
    BLOCK is the containing block.  */
 
-gimple
+gbind *
 gimple_build_bind (tree vars, gimple_seq body, tree block)
 {
-  gimple p = gimple_alloc (GIMPLE_BIND, 0);
+  gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
   gimple_bind_set_vars (p, vars);
   if (body)
     gimple_bind_set_body (p, body);
@@ -556,18 +565,18 @@ gimple_build_bind (tree vars, gimple_seq body, tree block)
    NCLOBBERS is the number of clobbered registers.
    */
 
-static inline gimple
+static inline gasm *
 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
                     unsigned nclobbers, unsigned nlabels)
 {
-  gimple_statement_asm *p;
+  gasm *p;
   int size = strlen (string);
 
   /* ASMs with labels cannot have outputs.  This should have been
      enforced by the front end.  */
   gcc_assert (nlabels == 0 || noutputs == 0);
 
-  p = as_a <gimple_statement_asm *> (
+  p = as_a <gasm *> (
         gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
 			       ninputs + noutputs + nclobbers + nlabels));
 
@@ -594,12 +603,12 @@ gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
    CLOBBERS is a vector of the clobbered register parameters.
    LABELS is a vector of destination labels.  */
 
-gimple
+gasm *
 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
                       vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
 		      vec<tree, va_gc> *labels)
 {
-  gimple p;
+  gasm *p;
   unsigned i;
 
   p = gimple_build_asm_1 (string,
@@ -628,10 +637,10 @@ gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
   TYPES are the catch types.
   HANDLER is the exception handler.  */
 
-gimple
+gcatch *
 gimple_build_catch (tree types, gimple_seq handler)
 {
-  gimple p = gimple_alloc (GIMPLE_CATCH, 0);
+  gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
   gimple_catch_set_types (p, types);
   if (handler)
     gimple_catch_set_handler (p, handler);
@@ -644,10 +653,10 @@ gimple_build_catch (tree types, gimple_seq handler)
    TYPES are the filter's types.
    FAILURE is the filter's failure action.  */
 
-gimple
+geh_filter *
 gimple_build_eh_filter (tree types, gimple_seq failure)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
+  geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
   gimple_eh_filter_set_types (p, types);
   if (failure)
     gimple_eh_filter_set_failure (p, failure);
@@ -657,10 +666,10 @@ gimple_build_eh_filter (tree types, gimple_seq failure)
 
 /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
 
-gimple
+geh_mnt *
 gimple_build_eh_must_not_throw (tree decl)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
+  geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
 
   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
   gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
@@ -671,10 +680,10 @@ gimple_build_eh_must_not_throw (tree decl)
 
 /* Build a GIMPLE_EH_ELSE statement.  */
 
-gimple
+geh_else *
 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_ELSE, 0);
+  geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
   gimple_eh_else_set_n_body (p, n_body);
   gimple_eh_else_set_e_body (p, e_body);
   return p;
@@ -687,14 +696,14 @@ gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
    KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
    whether this is a try/catch or a try/finally respectively.  */
 
-gimple_statement_try *
+gtry *
 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
     		  enum gimple_try_flags kind)
 {
-  gimple_statement_try *p;
+  gtry *p;
 
   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
-  p = as_a <gimple_statement_try *> (gimple_alloc (GIMPLE_TRY, 0));
+  p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
   gimple_set_subcode (p, kind);
   if (eval)
     gimple_try_set_eval (p, eval);
@@ -721,12 +730,11 @@ gimple_build_wce (gimple_seq cleanup)
 
 /* Build a GIMPLE_RESX statement.  */
 
-gimple
+gresx *
 gimple_build_resx (int region)
 {
-  gimple_statement_resx *p =
-    as_a <gimple_statement_resx *> (
-      gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
+  gresx *p
+    = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
   p->region = region;
   return p;
 }
@@ -737,13 +745,14 @@ gimple_build_resx (int region)
    NLABELS is the number of labels in the switch excluding the default.
    DEFAULT_LABEL is the default label for the switch statement.  */
 
-gimple
+gswitch *
 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
 {
   /* nlabels + 1 default label + 1 index.  */
   gcc_checking_assert (default_label);
-  gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
-				    1 + 1 + nlabels);
+  gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
+							ERROR_MARK,
+							1 + 1 + nlabels));
   gimple_switch_set_index (p, index);
   gimple_switch_set_default_label (p, default_label);
   return p;
@@ -755,12 +764,12 @@ gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
    DEFAULT_LABEL is the default label
    ARGS is a vector of labels excluding the default.  */
 
-gimple
+gswitch *
 gimple_build_switch (tree index, tree default_label, vec<tree> args)
 {
   unsigned i, nlabels = args.length ();
 
-  gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
+  gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
 
   /* Copy the labels from the vector to the switch statement.  */
   for (i = 0; i < nlabels; i++)
@@ -771,12 +780,12 @@ gimple_build_switch (tree index, tree default_label, vec<tree> args)
 
 /* Build a GIMPLE_EH_DISPATCH statement.  */
 
-gimple
+geh_dispatch *
 gimple_build_eh_dispatch (int region)
 {
-  gimple_statement_eh_dispatch *p =
-    as_a <gimple_statement_eh_dispatch *> (
-      gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
+  geh_dispatch *p
+    = as_a <geh_dispatch *> (
+	gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
   p->region = region;
   return p;
 }
@@ -785,13 +794,13 @@ gimple_build_eh_dispatch (int region)
 
    VAR is bound to VALUE; block and location are taken from STMT.  */
 
-gimple
+gdebug *
 gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
 {
-  gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
-					 (unsigned)GIMPLE_DEBUG_BIND, 2
-					 PASS_MEM_STAT);
-
+  gdebug *p
+    = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
+						   (unsigned)GIMPLE_DEBUG_BIND, 2
+						   PASS_MEM_STAT));
   gimple_debug_bind_set_var (p, var);
   gimple_debug_bind_set_value (p, value);
   if (stmt)
@@ -805,13 +814,15 @@ gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
 
    VAR is bound to VALUE; block and location are taken from STMT.  */
 
-gimple
+gdebug *
 gimple_build_debug_source_bind_stat (tree var, tree value,
 				     gimple stmt MEM_STAT_DECL)
 {
-  gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
-					 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
-					 PASS_MEM_STAT);
+  gdebug *p
+    = as_a <gdebug *> (
+        gimple_build_with_ops_stat (GIMPLE_DEBUG,
+				    (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
+				    PASS_MEM_STAT));
 
   gimple_debug_source_bind_set_var (p, var);
   gimple_debug_source_bind_set_value (p, value);
@@ -827,10 +838,11 @@ gimple_build_debug_source_bind_stat (tree var, tree value,
    BODY is the sequence of statements for which only one thread can execute.
    NAME is optional identifier for this critical block.  */
 
-gimple
+gomp_critical *
 gimple_build_omp_critical (gimple_seq body, tree name)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
+  gomp_critical *p
+    = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
   gimple_omp_critical_set_name (p, name);
   if (body)
     gimple_omp_set_body (p, body);
@@ -847,12 +859,11 @@ gimple_build_omp_critical (gimple_seq body, tree name)
    COLLAPSE is the collapse count.
    PRE_BODY is the sequence of statements that are loop invariant.  */
 
-gimple
+gomp_for *
 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
 		      gimple_seq pre_body)
 {
-  gimple_statement_omp_for *p =
-    as_a <gimple_statement_omp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
+  gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_for_set_clauses (p, clauses);
@@ -874,11 +885,12 @@ gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
    CHILD_FN is the function created for the parallel threads to execute.
    DATA_ARG are the shared data argument(s).  */
 
-gimple
+gomp_parallel *
 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
 			   tree data_arg)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
+  gomp_parallel *p
+    = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_parallel_set_clauses (p, clauses);
@@ -898,12 +910,12 @@ gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
    COPY_FN is the optional function for firstprivate initialization.
    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
 
-gimple
+gomp_task *
 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
 		       tree data_arg, tree copy_fn, tree arg_size,
 		       tree arg_align)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
+  gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_task_set_clauses (p, clauses);
@@ -968,10 +980,11 @@ gimple_build_omp_taskgroup (gimple_seq body)
    CONTROL_DEF is the definition of the control variable.
    CONTROL_USE is the use of the control variable.  */
 
-gimple
+gomp_continue *
 gimple_build_omp_continue (tree control_def, tree control_use)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
+  gomp_continue *p
+    = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
   gimple_omp_continue_set_control_def (p, control_def);
   gimple_omp_continue_set_control_use (p, control_use);
   return p;
@@ -1013,10 +1026,11 @@ gimple_build_omp_return (bool wait_p)
    CLAUSES are any of the OMP sections contsruct's clauses: private,
    firstprivate, lastprivate, reduction, and nowait.  */
 
-gimple
+gomp_sections *
 gimple_build_omp_sections (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
+  gomp_sections *p
+    = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_sections_set_clauses (p, clauses);
@@ -1040,10 +1054,11 @@ gimple_build_omp_sections_switch (void)
    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
    copyprivate, nowait.  */
 
-gimple
+gomp_single *
 gimple_build_omp_single (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
+  gomp_single *p
+    = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_single_set_clauses (p, clauses);
@@ -1057,10 +1072,11 @@ gimple_build_omp_single (gimple_seq body, tree clauses)
    BODY is the sequence of statements that will be executed.
    CLAUSES are any of the OMP target construct's clauses.  */
 
-gimple
+gomp_target *
 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TARGET, 0);
+  gomp_target *p
+    = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_target_set_clauses (p, clauses);
@@ -1075,10 +1091,10 @@ gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
    BODY is the sequence of statements that will be executed.
    CLAUSES are any of the OMP teams construct's clauses.  */
 
-gimple
+gomp_teams *
 gimple_build_omp_teams (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TEAMS, 0);
+  gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_teams_set_clauses (p, clauses);
@@ -1089,10 +1105,11 @@ gimple_build_omp_teams (gimple_seq body, tree clauses)
 
 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
 
-gimple
+gomp_atomic_load *
 gimple_build_omp_atomic_load (tree lhs, tree rhs)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
+  gomp_atomic_load *p
+    = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
   gimple_omp_atomic_load_set_lhs (p, lhs);
   gimple_omp_atomic_load_set_rhs (p, rhs);
   return p;
@@ -1102,20 +1119,22 @@ gimple_build_omp_atomic_load (tree lhs, tree rhs)
 
    VAL is the value we are storing.  */
 
-gimple
+gomp_atomic_store *
 gimple_build_omp_atomic_store (tree val)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
+  gomp_atomic_store *p
+    = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
   gimple_omp_atomic_store_set_val (p, val);
   return p;
 }
 
 /* Build a GIMPLE_TRANSACTION statement.  */
 
-gimple
+gtransaction *
 gimple_build_transaction (gimple_seq body, tree label)
 {
-  gimple p = gimple_alloc (GIMPLE_TRANSACTION, 0);
+  gtransaction *p
+    = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
   gimple_transaction_set_body (p, body);
   gimple_transaction_set_label (p, label);
   return p;
@@ -1283,8 +1302,8 @@ empty_stmt_p (gimple stmt)
 {
   if (gimple_code (stmt) == GIMPLE_NOP)
     return true;
-  if (gimple_code (stmt) == GIMPLE_BIND)
-    return empty_body_p (gimple_bind_body (stmt));
+  if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
+    return empty_body_p (gimple_bind_body (bind_stmt));
   return false;
 }
 
@@ -1366,7 +1385,7 @@ gimple_call_flags (const_gimple stmt)
 /* Return the "fn spec" string for call STMT.  */
 
 static const_tree
-gimple_call_fnspec (const_gimple stmt)
+gimple_call_fnspec (const gcall *stmt)
 {
   tree type, attr;
 
@@ -1387,7 +1406,7 @@ gimple_call_fnspec (const_gimple stmt)
 /* Detects argument flags for argument number ARG on call STMT.  */
 
 int
-gimple_call_arg_flags (const_gimple stmt, unsigned arg)
+gimple_call_arg_flags (const gcall *stmt, unsigned arg)
 {
   const_tree attr = gimple_call_fnspec (stmt);
 
@@ -1421,7 +1440,7 @@ gimple_call_arg_flags (const_gimple stmt, unsigned arg)
 /* Detects return flags for the call STMT.  */
 
 int
-gimple_call_return_flags (const_gimple stmt)
+gimple_call_return_flags (const gcall *stmt)
 {
   const_tree attr;
 
@@ -1513,7 +1532,7 @@ gimple_set_bb (gimple stmt, basic_block bb)
       tree t;
       int uid;
 
-      t = gimple_label_label (stmt);
+      t = gimple_label_label (as_a <glabel *> (stmt));
       uid = LABEL_DECL_UID (t);
       if (uid == -1)
 	{
@@ -1662,38 +1681,60 @@ gimple_copy (gimple stmt)
       switch (gimple_code (stmt))
 	{
 	case GIMPLE_BIND:
-	  new_seq = gimple_seq_copy (gimple_bind_body (stmt));
-	  gimple_bind_set_body (copy, new_seq);
-	  gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
-	  gimple_bind_set_block (copy, gimple_bind_block (stmt));
+	  {
+	    gbind *bind_stmt = as_a <gbind *> (stmt);
+	    gbind *bind_copy = as_a <gbind *> (copy);
+	    new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
+	    gimple_bind_set_body (bind_copy, new_seq);
+	    gimple_bind_set_vars (bind_copy,
+				  unshare_expr (gimple_bind_vars (bind_stmt)));
+	    gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
+	  }
 	  break;
 
 	case GIMPLE_CATCH:
-	  new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
-	  gimple_catch_set_handler (copy, new_seq);
-	  t = unshare_expr (gimple_catch_types (stmt));
-	  gimple_catch_set_types (copy, t);
+	  {
+	    gcatch *catch_stmt = as_a <gcatch *> (stmt);
+	    gcatch *catch_copy = as_a <gcatch *> (copy);
+	    new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
+	    gimple_catch_set_handler (catch_copy, new_seq);
+	    t = unshare_expr (gimple_catch_types (catch_stmt));
+	    gimple_catch_set_types (catch_copy, t);
+	  }
 	  break;
 
 	case GIMPLE_EH_FILTER:
-	  new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
-	  gimple_eh_filter_set_failure (copy, new_seq);
-	  t = unshare_expr (gimple_eh_filter_types (stmt));
-	  gimple_eh_filter_set_types (copy, t);
+	  {
+	    geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
+	    geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
+	    new_seq
+	      = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
+	    gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
+	    t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
+	    gimple_eh_filter_set_types (eh_filter_copy, t);
+	  }
 	  break;
 
 	case GIMPLE_EH_ELSE:
-	  new_seq = gimple_seq_copy (gimple_eh_else_n_body (stmt));
-	  gimple_eh_else_set_n_body (copy, new_seq);
-	  new_seq = gimple_seq_copy (gimple_eh_else_e_body (stmt));
-	  gimple_eh_else_set_e_body (copy, new_seq);
+	  {
+	    geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+	    geh_else *eh_else_copy = as_a <geh_else *> (copy);
+	    new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
+	    gimple_eh_else_set_n_body (eh_else_copy, new_seq);
+	    new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
+	    gimple_eh_else_set_e_body (eh_else_copy, new_seq);
+	  }
 	  break;
 
 	case GIMPLE_TRY:
-	  new_seq = gimple_seq_copy (gimple_try_eval (stmt));
-	  gimple_try_set_eval (copy, new_seq);
-	  new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
-	  gimple_try_set_cleanup (copy, new_seq);
+	  {
+	    gtry *try_stmt = as_a <gtry *> (stmt);
+	    gtry *try_copy = as_a <gtry *> (copy);
+	    new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
+	    gimple_try_set_eval (try_copy, new_seq);
+	    new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
+	    gimple_try_set_cleanup (try_copy, new_seq);
+	  }
 	  break;
 
 	case GIMPLE_OMP_FOR:
@@ -1702,8 +1743,7 @@ gimple_copy (gimple stmt)
 	  t = unshare_expr (gimple_omp_for_clauses (stmt));
 	  gimple_omp_for_set_clauses (copy, t);
 	  {
-	    gimple_statement_omp_for *omp_for_copy =
-	      as_a <gimple_statement_omp_for *> (copy);
+	    gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
 	    omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
 	      ( gimple_omp_for_collapse (stmt));
           }
@@ -1723,12 +1763,16 @@ gimple_copy (gimple stmt)
 	  goto copy_omp_body;
 
 	case GIMPLE_OMP_PARALLEL:
-	  t = unshare_expr (gimple_omp_parallel_clauses (stmt));
-	  gimple_omp_parallel_set_clauses (copy, t);
-	  t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
-	  gimple_omp_parallel_set_child_fn (copy, t);
-	  t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
-	  gimple_omp_parallel_set_data_arg (copy, t);
+	  {
+	    gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
+	    gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
+	    t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
+	    gimple_omp_parallel_set_clauses (omp_par_copy, t);
+	    t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
+	    gimple_omp_parallel_set_child_fn (omp_par_copy, t);
+	    t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
+	    gimple_omp_parallel_set_data_arg (omp_par_copy, t);
+	  }
 	  goto copy_omp_body;
 
 	case GIMPLE_OMP_TASK:
@@ -1747,8 +1791,9 @@ gimple_copy (gimple stmt)
 	  goto copy_omp_body;
 
 	case GIMPLE_OMP_CRITICAL:
-	  t = unshare_expr (gimple_omp_critical_name (stmt));
-	  gimple_omp_critical_set_name (copy, t);
+	  t = unshare_expr (gimple_omp_critical_name (
+			      as_a <gomp_critical *> (stmt)));
+	  gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
 	  goto copy_omp_body;
 
 	case GIMPLE_OMP_SECTIONS:
@@ -1771,8 +1816,10 @@ gimple_copy (gimple stmt)
 	  break;
 
 	case GIMPLE_TRANSACTION:
-	  new_seq = gimple_seq_copy (gimple_transaction_body (stmt));
-	  gimple_transaction_set_body (copy, new_seq);
+	  new_seq = gimple_seq_copy (gimple_transaction_body (
+				       as_a <gtransaction *> (stmt)));
+	  gimple_transaction_set_body (as_a <gtransaction *> (copy),
+				       new_seq);
 	  break;
 
 	case GIMPLE_WITH_CLEANUP_EXPR:
@@ -1827,7 +1874,7 @@ gimple_has_side_effects (const_gimple s)
     return true;
 
   if (gimple_code (s) == GIMPLE_ASM
-      && gimple_asm_volatile_p (s))
+      && gimple_asm_volatile_p (as_a <const gasm *> (s)))
     return true;
 
   if (is_gimple_call (s))
@@ -1868,7 +1915,7 @@ gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
   switch (gimple_code (s))
     {
     case GIMPLE_ASM:
-      return gimple_asm_volatile_p (s);
+      return gimple_asm_volatile_p (as_a <gasm *> (s));
 
     case GIMPLE_CALL:
       t = gimple_call_fndecl (s);
@@ -2041,13 +2088,13 @@ canonicalize_cond_expr_cond (tree t)
 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
    the positions marked by the set ARGS_TO_SKIP.  */
 
-gimple
-gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+gcall *
+gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
 {
   int i;
   int nargs = gimple_call_num_args (stmt);
   auto_vec<tree> vargs (nargs);
-  gimple new_stmt;
+  gcall *new_stmt;
 
   for (i = 0; i < nargs; i++)
     if (!bitmap_bit_p (args_to_skip, i))
@@ -2493,7 +2540,7 @@ gimple_call_builtin_p (const_gimple stmt, enum built_in_function code)
    GIMPLE_ASM.  */
 
 bool
-gimple_asm_clobbers_memory_p (const_gimple stmt)
+gimple_asm_clobbers_memory_p (const gasm *stmt)
 {
   unsigned i;
 
@@ -2652,13 +2699,13 @@ infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
 
   /* If this function is marked as returning non-null, then we can
      infer OP is non-null if it is used in the return statement.  */
-  if (attribute
-      && gimple_code (stmt) == GIMPLE_RETURN
-      && gimple_return_retval (stmt)
-      && operand_equal_p (gimple_return_retval (stmt), op, 0)
-      && lookup_attribute ("returns_nonnull",
-			   TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
-    return true;
+  if (attribute)
+    if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
+      if (gimple_return_retval (return_stmt)
+	  && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
+	  && lookup_attribute ("returns_nonnull",
+			       TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
+	return true;
 
   return false;
 }