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



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@217787 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 160 insertions, 119 deletions

diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index 36ebc866c1b..8180ff7e6e0 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -190,7 +190,7 @@ struct finally_tree_node
      tree) leaves the TRY block, its necessary to record a tree in
      this field.  Thus a treemple is used. */
   treemple child;
-  gimple parent;
+  gtry *parent;
 };
 
 /* Hashtable helpers.  */
@@ -219,7 +219,7 @@ finally_tree_hasher::equal (const value_type *v, const compare_type *c)
 static hash_table<finally_tree_hasher> *finally_tree;
 
 static void
-record_in_finally_tree (treemple child, gimple parent)
+record_in_finally_tree (treemple child, gtry *parent)
 {
   struct finally_tree_node *n;
   finally_tree_node **slot;
@@ -234,13 +234,13 @@ record_in_finally_tree (treemple child, gimple parent)
 }
 
 static void
-collect_finally_tree (gimple stmt, gimple region);
+collect_finally_tree (gimple stmt, gtry *region);
 
 /* Go through the gimple sequence.  Works with collect_finally_tree to
    record all GIMPLE_LABEL and GIMPLE_TRY statements. */
 
 static void
-collect_finally_tree_1 (gimple_seq seq, gimple region)
+collect_finally_tree_1 (gimple_seq seq, gtry *region)
 {
   gimple_stmt_iterator gsi;
 
@@ -249,14 +249,14 @@ collect_finally_tree_1 (gimple_seq seq, gimple region)
 }
 
 static void
-collect_finally_tree (gimple stmt, gimple region)
+collect_finally_tree (gimple stmt, gtry *region)
 {
   treemple temp;
 
   switch (gimple_code (stmt))
     {
     case GIMPLE_LABEL:
-      temp.t = gimple_label_label (stmt);
+      temp.t = gimple_label_label (as_a <glabel *> (stmt));
       record_in_finally_tree (temp, region);
       break;
 
@@ -265,7 +265,8 @@ collect_finally_tree (gimple stmt, gimple region)
         {
           temp.g = stmt;
           record_in_finally_tree (temp, region);
-          collect_finally_tree_1 (gimple_try_eval (stmt), stmt);
+          collect_finally_tree_1 (gimple_try_eval (stmt),
+				  as_a <gtry *> (stmt));
 	  collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
         }
       else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
@@ -276,7 +277,9 @@ collect_finally_tree (gimple stmt, gimple region)
       break;
 
     case GIMPLE_CATCH:
-      collect_finally_tree_1 (gimple_catch_handler (stmt), region);
+      collect_finally_tree_1 (gimple_catch_handler (
+				 as_a <gcatch *> (stmt)),
+			      region);
       break;
 
     case GIMPLE_EH_FILTER:
@@ -284,8 +287,11 @@ collect_finally_tree (gimple stmt, gimple region)
       break;
 
     case GIMPLE_EH_ELSE:
-      collect_finally_tree_1 (gimple_eh_else_n_body (stmt), region);
-      collect_finally_tree_1 (gimple_eh_else_e_body (stmt), region);
+      {
+	geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+	collect_finally_tree_1 (gimple_eh_else_n_body (eh_else_stmt), region);
+	collect_finally_tree_1 (gimple_eh_else_e_body (eh_else_stmt), region);
+      }
       break;
 
     default:
@@ -377,8 +383,8 @@ struct leh_tf_state
      try_finally_expr is the original GIMPLE_TRY_FINALLY.  We need to retain
      this so that outside_finally_tree can reliably reference the tree used
      in the collect_finally_tree data structures.  */
-  gimple try_finally_expr;
-  gimple top_p;
+  gtry *try_finally_expr;
+  gtry *top_p;
 
   /* While lowering a top_p usually it is expanded into multiple statements,
      thus we need the following field to store them. */
@@ -418,7 +424,7 @@ struct leh_tf_state
   bool may_throw;
 };
 
-static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
+static gimple_seq lower_eh_must_not_throw (struct leh_state *, gtry *);
 
 /* Search for STMT in the goto queue.  Return the replacement,
    or null if the statement isn't in the queue.  */
@@ -532,14 +538,21 @@ replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
       replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf);
       break;
     case GIMPLE_CATCH:
-      replace_goto_queue_stmt_list (gimple_catch_handler_ptr (stmt), tf);
+      replace_goto_queue_stmt_list (gimple_catch_handler_ptr (
+				      as_a <gcatch *> (stmt)),
+				    tf);
       break;
     case GIMPLE_EH_FILTER:
       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_ptr (stmt), tf);
-      replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (stmt), tf);
+      {
+	geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+	replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (eh_else_stmt),
+				      tf);
+	replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (eh_else_stmt),
+				      tf);
+      }
       break;
 
     default:
@@ -671,12 +684,17 @@ maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
   switch (gimple_code (stmt))
     {
     case GIMPLE_COND:
-      new_stmt.tp = gimple_op_ptr (stmt, 2);
-      record_in_goto_queue_label (tf, new_stmt, gimple_cond_true_label (stmt),
-				  EXPR_LOCATION (*new_stmt.tp));
-      new_stmt.tp = gimple_op_ptr (stmt, 3);
-      record_in_goto_queue_label (tf, new_stmt, gimple_cond_false_label (stmt),
-				  EXPR_LOCATION (*new_stmt.tp));
+      {
+	gcond *cond_stmt = as_a <gcond *> (stmt);
+	new_stmt.tp = gimple_op_ptr (cond_stmt, 2);
+	record_in_goto_queue_label (tf, new_stmt,
+				    gimple_cond_true_label (cond_stmt),
+				    EXPR_LOCATION (*new_stmt.tp));
+	new_stmt.tp = gimple_op_ptr (cond_stmt, 3);
+	record_in_goto_queue_label (tf, new_stmt,
+				    gimple_cond_false_label (cond_stmt),
+				    EXPR_LOCATION (*new_stmt.tp));
+      }
       break;
     case GIMPLE_GOTO:
       new_stmt.g = stmt;
@@ -702,7 +720,8 @@ maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
    of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this.  */
 
 static void
-verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
+verify_norecord_switch_expr (struct leh_state *state,
+			     gswitch *switch_expr)
 {
   struct leh_tf_state *tf = state->tf;
   size_t i, n;
@@ -768,7 +787,7 @@ static void
 do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
 		     struct leh_tf_state *tf)
 {
-  gimple x;
+  ggoto *x;
 
   gcc_assert (q->is_label);
 
@@ -788,7 +807,7 @@ static void
 emit_post_landing_pad (gimple_seq *seq, eh_region region)
 {
   eh_landing_pad lp = region->landing_pads;
-  gimple x;
+  glabel *x;
 
   if (lp == NULL)
     lp = gen_eh_landing_pad (region);
@@ -805,7 +824,7 @@ emit_post_landing_pad (gimple_seq *seq, eh_region region)
 static void
 emit_resx (gimple_seq *seq, eh_region region)
 {
-  gimple x = gimple_build_resx (region->index);
+  gresx *x = gimple_build_resx (region->index);
   gimple_seq_add_stmt (seq, x);
   if (region->outer)
     record_stmt_eh_region (region->outer, x);
@@ -816,7 +835,7 @@ emit_resx (gimple_seq *seq, eh_region region)
 static void
 emit_eh_dispatch (gimple_seq *seq, eh_region region)
 {
-  gimple x = gimple_build_eh_dispatch (region->index);
+  geh_dispatch *x = gimple_build_eh_dispatch (region->index);
   gimple_seq_add_stmt (seq, x);
 }
 
@@ -861,7 +880,7 @@ eh_region_may_contain_throw (eh_region r)
    an existing label that should be put at the exit, or NULL.  */
 
 static gimple_seq
-frob_into_branch_around (gimple tp, eh_region region, tree over)
+frob_into_branch_around (gtry *tp, eh_region region, tree over)
 {
   gimple x;
   gimple_seq cleanup, result;
@@ -898,7 +917,7 @@ static gimple_seq
 lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state,
 			     location_t loc)
 {
-  gimple region = NULL;
+  gtry *region = NULL;
   gimple_seq new_seq;
   gimple_stmt_iterator gsi;
 
@@ -948,14 +967,14 @@ lower_try_finally_fallthru_label (struct leh_tf_state *tf)
 /* A subroutine of lower_try_finally.  If FINALLY consits of a
    GIMPLE_EH_ELSE node, return it.  */
 
-static inline gimple
+static inline geh_else *
 get_eh_else (gimple_seq finally)
 {
   gimple x = gimple_seq_first_stmt (finally);
   if (gimple_code (x) == GIMPLE_EH_ELSE)
     {
       gcc_assert (gimple_seq_singleton_p (finally));
-      return x;
+      return as_a <geh_else *> (x);
     }
   return NULL;
 }
@@ -989,7 +1008,10 @@ honor_protect_cleanup_actions (struct leh_state *outer_state,
   gimple_stmt_iterator gsi;
   bool finally_may_fallthru;
   gimple_seq finally;
-  gimple x, eh_else;
+  gimple x;
+  geh_mnt *eh_mnt;
+  gtry *try_stmt;
+  geh_else *eh_else;
 
   /* First check for nothing to do.  */
   if (lang_hooks.eh_protect_cleanup_actions == NULL)
@@ -1031,10 +1053,10 @@ honor_protect_cleanup_actions (struct leh_state *outer_state,
     }
 
   /* Wrap the block with protect_cleanup_actions as the action.  */
-  x = gimple_build_eh_must_not_throw (protect_cleanup_actions);
-  x = gimple_build_try (finally, gimple_seq_alloc_with_stmt (x),
-			GIMPLE_TRY_CATCH);
-  finally = lower_eh_must_not_throw (outer_state, x);
+  eh_mnt = gimple_build_eh_must_not_throw (protect_cleanup_actions);
+  try_stmt = gimple_build_try (finally, gimple_seq_alloc_with_stmt (eh_mnt),
+			       GIMPLE_TRY_CATCH);
+  finally = lower_eh_must_not_throw (outer_state, try_stmt);
 
   /* Drop all of this into the exception sequence.  */
   emit_post_landing_pad (&eh_seq, tf->region);
@@ -1057,7 +1079,8 @@ lower_try_finally_nofallthru (struct leh_state *state,
 			      struct leh_tf_state *tf)
 {
   tree lab;
-  gimple x, eh_else;
+  gimple x;
+  geh_else *eh_else;
   gimple_seq finally;
   struct goto_queue_node *q, *qe;
 
@@ -1121,6 +1144,8 @@ static void
 lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
 {
   struct goto_queue_node *q, *qe;
+  geh_else *eh_else;
+  glabel *label_stmt;
   gimple x;
   gimple_seq finally;
   gimple_stmt_iterator gsi;
@@ -1133,13 +1158,13 @@ lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
   /* Since there's only one destination, and the destination edge can only
      either be EH or non-EH, that implies that all of our incoming edges
      are of the same type.  Therefore we can lower EH_ELSE immediately.  */
-  x = get_eh_else (finally);
-  if (x)
+  eh_else = get_eh_else (finally);
+  if (eh_else)
     {
       if (tf->may_throw)
-	finally = gimple_eh_else_e_body (x);
+	finally = gimple_eh_else_e_body (eh_else);
       else
-	finally = gimple_eh_else_n_body (x);
+	finally = gimple_eh_else_n_body (eh_else);
     }
 
   lower_eh_constructs_1 (state, &finally);
@@ -1174,8 +1199,8 @@ lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
     }
 
   finally_label = create_artificial_label (loc);
-  x = gimple_build_label (finally_label);
-  gimple_seq_add_stmt (&tf->top_p_seq, x);
+  label_stmt = gimple_build_label (finally_label);
+  gimple_seq_add_stmt (&tf->top_p_seq, label_stmt);
 
   gimple_seq_add_seq (&tf->top_p_seq, finally);
 
@@ -1223,7 +1248,8 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
   gimple_seq finally;
   gimple_seq new_stmt;
   gimple_seq seq;
-  gimple x, eh_else;
+  gimple x;
+  geh_else *eh_else;
   tree tmp;
   location_t tf_loc = gimple_location (tf->try_finally_expr);
 
@@ -1356,7 +1382,8 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
   tree last_case;
   vec<tree> case_label_vec;
   gimple_seq switch_body = NULL;
-  gimple x, eh_else;
+  gimple x;
+  geh_else *eh_else;
   tree tmp;
   gimple switch_stmt;
   gimple_seq finally;
@@ -1568,7 +1595,7 @@ static bool
 decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally)
 {
   int f_estimate, sw_estimate;
-  gimple eh_else;
+  geh_else *eh_else;
 
   /* If there's an EH_ELSE involved, the exception path is separate
      and really doesn't come into play for this computation.  */
@@ -1634,7 +1661,7 @@ cleanup_is_dead_in (eh_region reg)
    arrange for the FINALLY block to be executed on all exits.  */
 
 static gimple_seq
-lower_try_finally (struct leh_state *state, gimple tp)
+lower_try_finally (struct leh_state *state, gtry *tp)
 {
   struct leh_tf_state this_tf;
   struct leh_state this_state;
@@ -1741,7 +1768,7 @@ lower_try_finally (struct leh_state *state, gimple tp)
    exception region trees that records all the magic.  */
 
 static gimple_seq
-lower_catch (struct leh_state *state, gimple tp)
+lower_catch (struct leh_state *state, gtry *tp)
 {
   eh_region try_region = NULL;
   struct leh_state this_state = *state;
@@ -1776,13 +1803,13 @@ lower_catch (struct leh_state *state, gimple tp)
        gsi_next (&gsi))
     {
       eh_catch c;
-      gimple gcatch;
+      gcatch *catch_stmt;
       gimple_seq handler;
 
-      gcatch = gsi_stmt (gsi);
-      c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch));
+      catch_stmt = as_a <gcatch *> (gsi_stmt (gsi));
+      c = gen_eh_region_catch (try_region, gimple_catch_types (catch_stmt));
 
-      handler = gimple_catch_handler (gcatch);
+      handler = gimple_catch_handler (catch_stmt);
       lower_eh_constructs_1 (&this_state, &handler);
 
       c->label = create_artificial_label (UNKNOWN_LOCATION);
@@ -1813,7 +1840,7 @@ lower_catch (struct leh_state *state, gimple tp)
    region trees that record all the magic.  */
 
 static gimple_seq
-lower_eh_filter (struct leh_state *state, gimple tp)
+lower_eh_filter (struct leh_state *state, gtry *tp)
 {
   struct leh_state this_state = *state;
   eh_region this_region = NULL;
@@ -1858,7 +1885,7 @@ lower_eh_filter (struct leh_state *state, gimple tp)
    plus the exception region trees that record all the magic.  */
 
 static gimple_seq
-lower_eh_must_not_throw (struct leh_state *state, gimple tp)
+lower_eh_must_not_throw (struct leh_state *state, gtry *tp)
 {
   struct leh_state this_state = *state;
 
@@ -1869,7 +1896,8 @@ lower_eh_must_not_throw (struct leh_state *state, gimple tp)
 
       this_region = gen_eh_region_must_not_throw (state->cur_region);
       this_region->u.must_not_throw.failure_decl
-	= gimple_eh_must_not_throw_fndecl (inner);
+	= gimple_eh_must_not_throw_fndecl (
+	    as_a <geh_mnt *> (inner));
       this_region->u.must_not_throw.failure_loc
 	= LOCATION_LOCUS (gimple_location (tp));
 
@@ -1890,7 +1918,7 @@ lower_eh_must_not_throw (struct leh_state *state, gimple tp)
    except that we only execute the cleanup block for exception edges.  */
 
 static gimple_seq
-lower_cleanup (struct leh_state *state, gimple tp)
+lower_cleanup (struct leh_state *state, gtry *tp)
 {
   struct leh_state this_state = *state;
   eh_region this_region = NULL;
@@ -2041,40 +2069,43 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
       break;
 
     case GIMPLE_SWITCH:
-      verify_norecord_switch_expr (state, stmt);
+      verify_norecord_switch_expr (state, as_a <gswitch *> (stmt));
       break;
 
     case GIMPLE_TRY:
-      if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
-	replace = lower_try_finally (state, stmt);
-      else
-	{
-	  x = gimple_seq_first_stmt (gimple_try_cleanup (stmt));
-	  if (!x)
-	    {
-	      replace = gimple_try_eval (stmt);
-	      lower_eh_constructs_1 (state, &replace);
-	    }
-	  else
-	    switch (gimple_code (x))
+      {
+	gtry *try_stmt = as_a <gtry *> (stmt);
+	if (gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
+	  replace = lower_try_finally (state, try_stmt);
+	else
+	  {
+	    x = gimple_seq_first_stmt (gimple_try_cleanup (try_stmt));
+	    if (!x)
 	      {
+		replace = gimple_try_eval (try_stmt);
+		lower_eh_constructs_1 (state, &replace);
+	      }
+	    else
+	      switch (gimple_code (x))
+		{
 		case GIMPLE_CATCH:
-		    replace = lower_catch (state, stmt);
-		    break;
+		  replace = lower_catch (state, try_stmt);
+		  break;
 		case GIMPLE_EH_FILTER:
-		    replace = lower_eh_filter (state, stmt);
-		    break;
+		  replace = lower_eh_filter (state, try_stmt);
+		  break;
 		case GIMPLE_EH_MUST_NOT_THROW:
-		    replace = lower_eh_must_not_throw (state, stmt);
-		    break;
+		  replace = lower_eh_must_not_throw (state, try_stmt);
+		  break;
 		case GIMPLE_EH_ELSE:
-		    /* This code is only valid with GIMPLE_TRY_FINALLY.  */
-		    gcc_unreachable ();
+		  /* This code is only valid with GIMPLE_TRY_FINALLY.  */
+		  gcc_unreachable ();
 		default:
-		    replace = lower_cleanup (state, stmt);
-		    break;
-	      }
-	}
+		  replace = lower_cleanup (state, try_stmt);
+		  break;
+		}
+	  }
+      }
 
       /* Remove the old stmt and insert the transformed sequence
 	 instead. */
@@ -2190,7 +2221,7 @@ make_pass_lower_eh (gcc::context *ctxt)
    no fallthru edge; false if there is.  */
 
 bool
-make_eh_dispatch_edges (gimple stmt)
+make_eh_dispatch_edges (geh_dispatch *stmt)
 {
   eh_region r;
   eh_catch c;
@@ -2348,7 +2379,7 @@ redirect_eh_edge (edge edge_in, basic_block new_bb)
    The actual edge update will happen in the caller.  */
 
 void
-redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb)
+redirect_eh_dispatch_edge (geh_dispatch *stmt, edge e, basic_block new_bb)
 {
   tree new_lab = gimple_block_label (new_bb);
   bool any_changed = false;
@@ -2763,7 +2794,7 @@ stmt_could_throw_p (gimple stmt)
       return true;
 
     case GIMPLE_CALL:
-      return !gimple_call_nothrow_p (stmt);
+      return !gimple_call_nothrow_p (as_a <gcall *> (stmt));
 
     case GIMPLE_ASSIGN:
     case GIMPLE_COND:
@@ -2774,7 +2805,7 @@ stmt_could_throw_p (gimple stmt)
     case GIMPLE_ASM:
       if (!cfun->can_throw_non_call_exceptions)
         return false;
-      return gimple_asm_volatile_p (stmt);
+      return gimple_asm_volatile_p (as_a <gasm *> (stmt));
 
     default:
       return false;
@@ -3000,7 +3031,7 @@ same_handler_p (gimple_seq oneh, gimple_seq twoh)
    temporary used in the initializer for A.  */
 
 static void
-optimize_double_finally (gimple one, gimple two)
+optimize_double_finally (gtry *one, gtry *two)
 {
   gimple oneh;
   gimple_stmt_iterator gsi;
@@ -3047,13 +3078,12 @@ refactor_eh_r (gimple_seq seq)
 	two = NULL;
       else
 	two = gsi_stmt (gsi);
-      if (one
-	  && two
-	  && gimple_code (one) == GIMPLE_TRY
-	  && gimple_code (two) == GIMPLE_TRY
-	  && gimple_try_kind (one) == GIMPLE_TRY_FINALLY
-	  && gimple_try_kind (two) == GIMPLE_TRY_FINALLY)
-	optimize_double_finally (one, two);
+      if (one && two)
+	if (gtry *try_one = dyn_cast <gtry *> (one))
+	  if (gtry *try_two = dyn_cast <gtry *> (two))
+	    if (gimple_try_kind (try_one) == GIMPLE_TRY_FINALLY
+		&& gimple_try_kind (try_two) == GIMPLE_TRY_FINALLY)
+	      optimize_double_finally (try_one, try_two);
       if (one)
 	switch (gimple_code (one))
 	  {
@@ -3062,14 +3092,17 @@ refactor_eh_r (gimple_seq seq)
 	    refactor_eh_r (gimple_try_cleanup (one));
 	    break;
 	  case GIMPLE_CATCH:
-	    refactor_eh_r (gimple_catch_handler (one));
+	    refactor_eh_r (gimple_catch_handler (as_a <gcatch *> (one)));
 	    break;
 	  case GIMPLE_EH_FILTER:
 	    refactor_eh_r (gimple_eh_filter_failure (one));
 	    break;
 	  case GIMPLE_EH_ELSE:
-	    refactor_eh_r (gimple_eh_else_n_body (one));
-	    refactor_eh_r (gimple_eh_else_e_body (one));
+	    {
+	      geh_else *eh_else_stmt = as_a <geh_else *> (one);
+	      refactor_eh_r (gimple_eh_else_n_body (eh_else_stmt));
+	      refactor_eh_r (gimple_eh_else_e_body (eh_else_stmt));
+	    }
 	    break;
 	  default:
 	    break;
@@ -3124,7 +3157,8 @@ make_pass_refactor_eh (gcc::context *ctxt)
 /* At the end of gimple optimization, we can lower RESX.  */
 
 static bool
-lower_resx (basic_block bb, gimple stmt, hash_map<eh_region, tree> *mnt_map)
+lower_resx (basic_block bb, gresx *stmt,
+	    hash_map<eh_region, tree> *mnt_map)
 {
   int lp_nr;
   eh_region src_r, dst_r;
@@ -3312,7 +3346,8 @@ pass_lower_resx::execute (function *fun)
       gimple last = last_stmt (bb);
       if (last && is_gimple_resx (last))
 	{
-	  dominance_invalidated |= lower_resx (bb, last, &mnt_map);
+	  dominance_invalidated |=
+	    lower_resx (bb, as_a <gresx *> (last), &mnt_map);
 	  any_rewritten = true;
 	}
     }
@@ -3436,14 +3471,15 @@ sink_clobbers (basic_block bb)
 
   /* See if there is a virtual PHI node to take an updated virtual
      operand from.  */
-  gimple vphi = NULL;
+  gphi *vphi = NULL;
   tree vuse = NULL_TREE;
-  for (gsi = gsi_start_phis (succbb); !gsi_end_p (gsi); gsi_next (&gsi))
+  for (gphi_iterator gpi = gsi_start_phis (succbb);
+       !gsi_end_p (gpi); gsi_next (&gpi))
     {
-      tree res = gimple_phi_result (gsi_stmt (gsi));
+      tree res = gimple_phi_result (gpi.phi ());
       if (virtual_operand_p (res))
 	{
-	  vphi = gsi_stmt (gsi);
+	  vphi = gpi.phi ();
 	  vuse = res;
 	  break;
 	}
@@ -3521,7 +3557,7 @@ sink_clobbers (basic_block bb)
    we have found some duplicate labels and removed some edges.  */
 
 static bool
-lower_eh_dispatch (basic_block src, gimple stmt)
+lower_eh_dispatch (basic_block src, geh_dispatch *stmt)
 {
   gimple_stmt_iterator gsi;
   int region_nr;
@@ -3709,7 +3745,8 @@ pass_lower_eh_dispatch::execute (function *fun)
 	continue;
       if (gimple_code (last) == GIMPLE_EH_DISPATCH)
 	{
-	  redirected |= lower_eh_dispatch (bb, last);
+	  redirected |= lower_eh_dispatch (bb,
+					   as_a <geh_dispatch *> (last));
 	  flags |= TODO_update_ssa_only_virtuals;
 	}
       else if (gimple_code (last) == GIMPLE_RESX)
@@ -3797,10 +3834,13 @@ mark_reachable_handlers (sbitmap *r_reachablep, sbitmap *lp_reachablep)
 	  switch (gimple_code (stmt))
 	    {
 	    case GIMPLE_RESX:
-	      bitmap_set_bit (r_reachable, gimple_resx_region (stmt));
+	      bitmap_set_bit (r_reachable,
+			      gimple_resx_region (as_a <gresx *> (stmt)));
 	      break;
 	    case GIMPLE_EH_DISPATCH:
-	      bitmap_set_bit (r_reachable, gimple_eh_dispatch_region (stmt));
+	      bitmap_set_bit (r_reachable,
+			      gimple_eh_dispatch_region (
+                                as_a <geh_dispatch *> (stmt)));
 	      break;
 	    default:
 	      break;
@@ -3971,13 +4011,13 @@ unsplit_eh (eh_landing_pad lp)
      for a different region.  */
   for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
       tree lab;
       int lp_nr;
 
-      if (gimple_code (stmt) != GIMPLE_LABEL)
+      if (!label_stmt)
 	break;
-      lab = gimple_label_label (stmt);
+      lab = gimple_label_label (label_stmt);
       lp_nr = EH_LANDING_PAD_NR (lab);
       if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
 	return false;
@@ -3994,9 +4034,10 @@ unsplit_eh (eh_landing_pad lp)
      that doesn't appear to handle virtuals.  Propagate by hand.  */
   if (!gimple_seq_empty_p (phi_nodes (bb)))
     {
-      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
+      for (gphi_iterator gpi = gsi_start_phis (bb); !gsi_end_p (gpi); )
 	{
-	  gimple use_stmt, phi = gsi_stmt (gsi);
+	  gimple use_stmt;
+	  gphi *phi = gpi.phi ();
 	  tree lhs = gimple_phi_result (phi);
 	  tree rhs = gimple_phi_arg_def (phi, 0);
 	  use_operand_p use_p;
@@ -4011,7 +4052,7 @@ unsplit_eh (eh_landing_pad lp)
 	  if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
 	    SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1;
 
-	  remove_phi_node (&gsi, true);
+	  remove_phi_node (&gpi, true);
 	}
     }
 
@@ -4060,7 +4101,7 @@ static bool
 cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
 			     edge old_bb_out, bool change_region)
 {
-  gimple_stmt_iterator ngsi, ogsi;
+  gphi_iterator ngsi, ogsi;
   edge_iterator ei;
   edge e;
   bitmap ophi_handled;
@@ -4090,7 +4131,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
      for the edges we're going to move.  */
   for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi))
     {
-      gimple ophi, nphi = gsi_stmt (ngsi);
+      gphi *ophi, *nphi = ngsi.phi ();
       tree nresult, nop;
 
       nresult = gimple_phi_result (nphi);
@@ -4101,7 +4142,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
       ophi = NULL;
       for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
 	{
-	  ophi = gsi_stmt (ogsi);
+	  ophi = ogsi.phi ();
 	  if (gimple_phi_result (ophi) == nop)
 	    break;
 	  ophi = NULL;
@@ -4154,7 +4195,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
      we don't know what values from the other edges into NEW_BB to use.  */
   for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
     {
-      gimple ophi = gsi_stmt (ogsi);
+      gphi *ophi = ogsi.phi ();
       tree oresult = gimple_phi_result (ophi);
       if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult)))
 	goto fail;
@@ -4242,10 +4283,10 @@ cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp)
   lab = NULL;
   for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      glabel *stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
       int lp_nr;
 
-      if (gimple_code (stmt) != GIMPLE_LABEL)
+      if (!stmt)
 	break;
       lab = gimple_label_label (stmt);
       lp_nr = EH_LANDING_PAD_NR (lab);
@@ -4642,7 +4683,7 @@ verify_eh_edges (gimple stmt)
 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically.  */
 
 DEBUG_FUNCTION bool
-verify_eh_dispatch_edge (gimple stmt)
+verify_eh_dispatch_edge (geh_dispatch *stmt)
 {
   eh_region r;
   eh_catch c;