From a3cc86235f4fce1302448bb04b467b6c016f68df Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Thu, 1 May 2014 14:05:05 -0400
Subject: [PATCH 01/29] Handwritten part of conversion of "gimple" to "gimple
 *"

gcc/
	* coretypes.h (gimple): Drop typedef.
	(const_gimple): Likewise.
	(gimple_seq): Convert from being a "gimple" to a "gimple *".

	* gimple.h (gimple_statement_base): Rename to...
	(gimple): ...this.
	(gimple_statement_with_ops_base): Rename to...
	(gimple_with_ops_base): ...this.
	(gimple_statement_with_ops): Rename to...
	(gimple_with_ops): ...this.
	(gimple_statement_with_memory_ops_base): Rename to...
	(gimple_with_memory_ops_base): ...this.
	(gimple_statement_with_memory_ops): Rename to...
	(gimple_with_memory_ops): ...this.
	(gimple_statement_call): Rename to...
	(gcall): ...this.
	(gimple_statement_omp): Rename to...
	(gomp): ...this.
	(gimple_statement_bind): Rename to...
	(gbind): ...this.
	(gimple_statement_catch): Rename to...
	(gcatch): ...this.
	(gimple_statement_eh_filter): Rename to...
	(geh_filter): ...this.
	(gimple_statement_eh_else): Rename to...
	(geh_else): ...this.
	(gimple_statement_eh_mnt): Rename to...
	(geh_mnt): ...this.
	(gimple_statement_phi): Rename to...
	(gphi): ...this.
	(gimple_statement_eh_ctrl): Rename to...
	(geh_ctrl): ...this.
	(gimple_statement_resx): Rename to...
	(gresx): ...this.
	(gimple_statement_eh_dispatch): Rename to...
	(geh_dispatch): ...this.
	(gimple_statement_try): Rename to...
	(gtry): ...this.
	(gimple_statement_wce): Rename to...
	(gwce): ...this.
	(gimple_statement_asm): Rename to...
	(gasm): ...this.
	(gimple_statement_omp_critical): Rename to...
	(gomp_critical): ...this.
	(gimple_statement_omp_for): Rename to...
	(gomp_for): ...this.
	(gimple_statement_omp_parallel_layout): Rename to...
	(gomp_parallel_layout): ...this.
	(gimple_statement_omp_taskreg): Rename to...
	(gomp_taskreg): ...this.
	(gimple_statement_omp_parallel): Rename to...
	(gomp_parallel): ...this.
	(gimple_statement_omp_target): Rename to...
	(gomp_target): ...this.
	(gimple_statement_omp_task): Rename to...
	(gomp_task): ...this.
	(gimple_statement_omp_sections): Rename to...
	(gomp_sections): ...this.
	(gimple_statement_omp_continue): Rename to...
	(gomp_continue): ...this.
	(gimple_statement_omp_single_layout): Rename to...
	(gomp_single_layout): ...this.
	(gimple_statement_omp_single): Rename to...
	(gomp_single): ...this.
	(gimple_statement_omp_teams): Rename to...
	(gomp_teams): ...this.
	(gimple_statement_omp_atomic_load): Rename to...
	(gomp_atomic_load): ...this.
	(gimple_statement_omp_atomic_store_layout): Rename to...
	(gomp_atomic_store_layout): ...this.
	(gimple_statement_omp_atomic_store): Rename to...
	(gomp_atomic_store): ...this.
	(gimple_statement_omp_return): Rename to...
	(gomp_return): ...this.
	(gimple_statement_transaction): Rename to...
	(gtransaction): ...this.

	(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 <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 <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_return *>::test): Rename to...
	(is_a_helper <gomp_return *>::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_taskreg *>::test): Rename to...
	(is_a_helper <gomp_taskreg *>::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 <gimple_statement_try *>::test): Rename to...
	(is_a_helper <gtry *>::test): ...this.
	(is_a_helper <gimple_statement_wce *>::test): Rename to...
	(is_a_helper <gwce *>::test): ...this.
	(is_a_helper <gimple_statement_with_ops *>::test): Rename to...
	(is_a_helper <gwith_ops *>::test): ...this.
	(is_a_helper <gimple_statement_with_memory_ops *>::test): Rename to...
	(is_a_helper <gwith_memory_ops *>::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_return *>::test): Rename to...
	(is_a_helper <const gomp_return *>::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_taskreg *>::test): Rename to...
	(is_a_helper <const gomp_taskreg *>::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.
	(is_a_helper <const gimple_statement_with_ops *>::test): Rename to...
	(is_a_helper <const gwith_ops *>::test): ...this.
	(is_a_helper <const gimple_statement_with_memory_ops *>::test): Rename
	to...
	(is_a_helper <const gwith_memory_ops *>::test): ...this.

	(gimple_build_try): Update for renaming of gimple statement types.
	(gimple_use_ops): Likewise.
	(gimple_set_use_ops): Likewise.
	(gimple_vuse): Likewise.
	(gimple_vuse_ptr): Likewise.
	(gimple_vdef_ptr): Likewise.
	(gimple_set_vuse): Likewise.
	(gimple_set_vdef): Likewise.
	(gimple_omp_return_set_lhs): Likewise.
	(gimple_omp_return_lhs): Likewise.
	(gimple_omp_return_lhs_ptr): Likewise.
	(gimple_call_internal_fn): Likewise.
	(gimple_call_fntype): Likewise.
	(gimple_call_set_fntype): Likewise.
	(gimple_call_set_internal_fn): Likewise.
	(gimple_call_use_set): Likewise.
	(gimple_call_clobber_set): Likewise.
	(gimple_bind_vars): Likewise.
	(gimple_bind_set_vars): Likewise.
	(gimple_bind_append_vars): Likewise.
	(gimple_bind_body_ptr): Likewise.
	(gimple_bind_set_body): Likewise.
	(gimple_bind_add_stmt): Likewise.
	(gimple_bind_add_seq): Likewise.
	(gimple_bind_block): Likewise.
	(gimple_bind_set_block): Likewise.
	(gimple_asm_ninputs): Likewise.
	(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_set_input_op): Likewise.
	(gimple_asm_output_op): Likewise.
	(gimple_asm_output_op_ptr): Likewise.
	(gimple_asm_set_output_op): Likewise.
	(gimple_asm_clobber_op): Likewise.
	(gimple_asm_set_clobber_op): Likewise.
	(gimple_asm_label_op): Likewise.
	(gimple_asm_set_label_op): Likewise.
	(gimple_asm_string): Likewise.
	(gimple_catch_types): Likewise.
	(gimple_catch_types_ptr): Likewise.
	(gimple_catch_handler_ptr): Likewise.
	(gimple_catch_set_types): Likewise.
	(gimple_catch_set_handler): Likewise.
	(gimple_eh_filter_types): Likewise.
	(gimple_eh_filter_types_ptr): Likewise.
	(gimple_eh_filter_failure_ptr)
	(gimple_eh_filter_set_types): Likewise.
	(gimple_eh_filter_set_failure): Likewise.
	(gimple_eh_must_not_throw_fndecl): Likewise.
	(gimple_eh_must_not_throw_set_fndecl): Likewise.
	(gimple_eh_else_n_body_ptr): Likewise.
	(gimple_eh_else_e_body_ptr): Likewise.
	(gimple_eh_else_set_n_body): Likewise.
	(gimple_eh_else_set_e_body): Likewise.
	(gimple_try_eval_ptr): Likewise.
	(gimple_try_cleanup_ptr): Likewise.
	(gimple_try_set_eval): Likewise.
	(gimple_try_set_cleanup): Likewise.
	(gimple_wce_cleanup_ptr): Likewise.
	(gimple_wce_set_cleanup): Likewise.
	(gimple_phi_capacity): Likewise.
	(gimple_phi_num_args): Likewise.
	(gimple_phi_result): Likewise.
	(gimple_phi_result_ptr): Likewise.
	(gimple_phi_set_result): Likewise.
	(gimple_phi_arg): Likewise.
	(gimple_phi_set_arg): Likewise.
	(gimple_resx_region): Likewise.
	(gimple_resx_set_region): Likewise.
	(gimple_eh_dispatch_region): Likewise.
	(gimple_eh_dispatch_set_region): Likewise.
	(gimple_omp_body_ptr): Likewise.
	(gimple_omp_set_body): Likewise.
	(gimple_omp_critical_name): Likewise.
	(gimple_omp_critical_name_ptr): Likewise.
	(gimple_omp_critical_set_name): Likewise.
	(gimple_omp_for_clauses): Likewise.
	(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_ptr): Likewise.
	(gimple_omp_for_set_pre_body): Likewise.
	(gimple_omp_parallel_clauses): Likewise.
	(gimple_omp_parallel_clauses_ptr): Likewise.
	(gimple_omp_parallel_set_clauses): Likewise.
	(gimple_omp_parallel_child_fn): Likewise.
	(gimple_omp_parallel_child_fn_ptr): Likewise.
	(gimple_omp_parallel_set_child_fn): Likewise.
	(gimple_omp_parallel_data_arg): Likewise.
	(gimple_omp_parallel_data_arg_ptr): Likewise.
	(gimple_omp_parallel_set_data_arg): Likewise.
	(gimple_omp_task_clauses): Likewise.
	(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): Likewise.
	(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): Likewise.
	(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): Likewise.
	(gimple_omp_single_clauses_ptr): Likewise.
	(gimple_omp_single_set_clauses): Likewise.
	(gimple_omp_target_clauses): Likewise.
	(gimple_omp_target_clauses_ptr): Likewise.
	(gimple_omp_target_set_clauses): Likewise.
	(gimple_omp_target_child_fn): Likewise.
	(gimple_omp_target_child_fn_ptr): Likewise.
	(gimple_omp_target_set_child_fn): Likewise.
	(gimple_omp_target_data_arg): Likewise.
	(gimple_omp_target_data_arg_ptr): Likewise.
	(gimple_omp_target_set_data_arg): Likewise.
	(gimple_omp_teams_clauses): Likewise.
	(gimple_omp_teams_clauses_ptr): Likewise.
	(gimple_omp_teams_set_clauses): Likewise.
	(gimple_omp_sections_clauses): Likewise.
	(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): Likewise.
	(gimple_omp_atomic_store_val): Likewise.
	(gimple_omp_atomic_store_val_ptr): Likewise.
	(gimple_omp_atomic_load_set_lhs): Likewise.
	(gimple_omp_atomic_load_lhs): Likewise.
	(gimple_omp_atomic_load_lhs_ptr): Likewise.
	(gimple_omp_atomic_load_set_rhs): Likewise.
	(gimple_omp_atomic_load_rhs): Likewise.
	(gimple_omp_atomic_load_rhs_ptr): Likewise.
	(gimple_omp_continue_control_def): Likewise.
	(gimple_omp_continue_control_def_ptr): Likewise.
	(gimple_omp_continue_set_control_def): Likewise.
	(gimple_omp_continue_control_use): Likewise.
	(gimple_omp_continue_control_use_ptr): Likewise.
	(gimple_omp_continue_set_control_use): Likewise.
	(gimple_transaction_body_ptr): Likewise.
	(gimple_transaction_label): Likewise.
	(gimple_transaction_label_ptr): Likewise.
	(gimple_transaction_set_body): Likewise.
	(gimple_transaction_set_label): Likewise.

	* gsstruct.def: Update for renamings of the gimple statement classes.

	* system.h (CONST_CAST_GIMPLE): Update for renaming of
	"gimple_statement_base" to "gimple".

	* target.def (DEFHOOK_UNDOC): Remove "const_gimple" in favor of
	"const gimple *".

	* ggc.h (ggc_alloc_cleared_gimple_statement_stat): Rename to...
	(ggc_alloc_cleared_gimple_stat): ...this, updating for renaming
	of gimple statement type.

	* gimple-pretty-print.h (debug): Update for renaming of
	"gimple_statement_base" to "gimple".
	* gimple-pretty-print.c (debug): Likewise.

	* gimple-ssa.h (gimple_vuse_op): Update for renaming of
	"gimple_statement_with_memory_ops" to "gimple_with_memory_ops".
	(gimple_vdef_op): Likewise.

	* gimple.c (gimple_alloc_stat): Update for renaming of gimple
	statement types.
	(gimple_build_asm_1): Likewise.
	(gimple_build_try): Likewise.
	(gimple_build_resx): Likewise.
	(gimple_build_eh_dispatch): Likewise.
	(gimple_build_omp_for): Likewise.
	(gimple_copy): Likewise.

	* gimple-streamer-in.c (input_gimple_stmt): Update for renaming of
	"gimple_statement_asm" to "gasm".

	* gimplify.c (gimplify_cleanup_point_expr): Likewise for
	"gimple_statement_try" to "gtry".

	* tree-dfa.c (dump_dfa_stats): Likewise for "gimple_statement_phi"
	to "gphi".

	* tree-phinodes.c (allocate_phi_node): Likewise.
	(ideal_phi_node_len): Likewise.
	(make_phi_node): Likewise.
	(resize_phi_node): Likewise.
	(reserve_phi_args_for_new_edge): Likewise.
	(remove_phi_arg_num): Likewise.
	(remove_phi_args): Likewise.

	* tree-ssa-ccp.c (gimple_htab): Likewise for renaming of
	"gimple_statement_base" to "gimple".

	* gdbhooks.py (build_pretty_printer): Update to reflect above changes.

	* doc/gimple.texi: Update to reflect the above changes, and those
	in the automated patch that follows.

gcc/testsuite/
	* g++.dg/plugin/selfassign.c (get_real_ref_rhs): Replace "gimple"
	typedef with "gimple *".
	(get_non_ssa_expr): Likewise.
	(compare_and_warn): Likewise.
	(warn_self_assign): Likewise.

	* gcc.dg/plugin/selfassign.c (get_real_ref_rhs): Likewise.
	(get_non_ssa_expr): Likewise.
	(compare_and_warn): Likewise.
	(warn_self_assign): Likewise.
---
 gcc/coretypes.h                          |   5 +-
 gcc/doc/gimple.texi                      | 808 ++++++++++++++++++-------------
 gcc/gdbhooks.py                          |   2 +-
 gcc/ggc.h                                |   6 +-
 gcc/gimple-pretty-print.c                |   4 +-
 gcc/gimple-pretty-print.h                |   4 +-
 gcc/gimple-ssa.h                         |   8 +-
 gcc/gimple-streamer-in.c                 |   2 +-
 gcc/gimple.c                             |  26 +-
 gcc/gimple.h                             | 703 +++++++++++----------------
 gcc/gimplify.c                           |   2 +-
 gcc/gsstruct.def                         |  52 +-
 gcc/system.h                             |   2 +-
 gcc/target.def                           |   2 +-
 gcc/testsuite/g++.dg/plugin/selfassign.c |   8 +-
 gcc/testsuite/gcc.dg/plugin/selfassign.c |   8 +-
 gcc/tree-dfa.c                           |   2 +-
 gcc/tree-phinodes.c                      |  35 +-
 gcc/tree-ssa-ccp.c                       |   2 +-
 19 files changed, 842 insertions(+), 839 deletions(-)

diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index 41ad1a3..9a1f172 100644
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -64,9 +64,8 @@ typedef const struct hwivec_def *const_hwivec;
 union tree_node;
 typedef union tree_node *tree;
 typedef const union tree_node *const_tree;
-typedef struct gimple_statement_base *gimple;
-typedef const struct gimple_statement_base *const_gimple;
-typedef gimple gimple_seq;
+class gimple;
+typedef gimple *gimple_seq;
 struct gimple_stmt_iterator;
 union section;
 typedef union section section;
diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi
index 1e5473d..54bad5d 100644
--- a/gcc/doc/gimple.texi
+++ b/gcc/doc/gimple.texi
@@ -92,8 +92,8 @@ groups: a header describing the instruction and its locations,
 and a variable length body with all the operands. Tuples are
 organized into a hierarchy with 3 main classes of tuples.
 
-@subsection @code{gimple_statement_base} (gsbase)
-@cindex gimple_statement_base
+@subsection @code{gimple} (gsbase)
+@cindex gimple
 
 This is the root of the hierarchy, it holds basic information
 needed by most GIMPLE statements. There are some fields that
@@ -192,12 +192,12 @@ Lexical block holding this statement.  Also used for debug
 information generation.
 @end itemize
 
-@subsection @code{gimple_statement_with_ops}
-@cindex gimple_statement_with_ops
+@subsection @code{gimple_with_ops}
+@cindex gimple_with_ops
 
 This tuple is actually split in two:
-@code{gimple_statement_with_ops_base} and
-@code{gimple_statement_with_ops}. This is needed to accommodate the
+@code{gimple_with_ops_base} and
+@code{gimple_with_ops}. This is needed to accommodate the
 way the operand vector is allocated. The operand vector is
 defined to be an array of 1 element. So, to allocate a dynamic
 number of operands, the memory allocator (@code{gimple_alloc}) simply
@@ -205,11 +205,11 @@ allocates enough memory to hold the structure itself plus @code{N
 - 1} operands which run ``off the end'' of the structure. For
 example, to allocate space for a tuple with 3 operands,
 @code{gimple_alloc} reserves @code{sizeof (struct
-gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
+gimple_with_ops) + 2 * sizeof (tree)} bytes.
 
 On the other hand, several fields in this tuple need to be shared
-with the @code{gimple_statement_with_memory_ops} tuple. So, these
-common fields are placed in @code{gimple_statement_with_ops_base} which
+with the @code{gimple_with_memory_ops} tuple. So, these
+common fields are placed in @code{gimple_with_ops_base} which
 is then inherited from the other two tuples.
 
 
@@ -223,7 +223,7 @@ is then inherited from the other two tuples.
 
 @itemize @bullet
 @item @code{gsbase}
-Inherited from @code{struct gimple_statement_base}.
+Inherited from @code{struct gimple}.
 
 @item @code{def_ops}
 Array of pointers into the operand array indicating all the slots that
@@ -239,14 +239,14 @@ Similar to @code{def_ops} but for variables read by the statement.
 Array of trees with @code{num_ops} slots.
 @end itemize
 
-@subsection @code{gimple_statement_with_memory_ops}
+@subsection @code{gimple_with_memory_ops}
 
-This tuple is essentially identical to @code{gimple_statement_with_ops},
+This tuple is essentially identical to @code{gimple_with_ops},
 except that it contains 4 additional fields to hold vectors
 related memory stores and loads.  Similar to the previous case,
 the structure is split in two to accommodate for the operand
-vector (@code{gimple_statement_with_memory_ops_base} and
-@code{gimple_statement_with_memory_ops}).
+vector (@code{gimple_with_memory_ops_base} and
+@code{gimple_with_memory_ops}).
 
 
 @multitable {@code{vdef_ops}}	{80 + 8 * @code{num_ops} bytes}
@@ -300,17 +300,17 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
 @code{GIMPLE_} values (codes):
 
 @smallexample
-   gimple_statement_base
+   gimple
      |    layout: GSS_BASE
      |    used for 4 codes: GIMPLE_ERROR_MARK
      |                      GIMPLE_NOP
      |                      GIMPLE_OMP_SECTIONS_SWITCH
      |                      GIMPLE_PREDICT
      |
-     + gimple_statement_with_ops_base
+     + gimple_with_ops_base
      |   |    (no GSS layout)
      |   |
-     |   + gimple_statement_with_ops
+     |   + gimple_with_ops
      |   |        layout: GSS_WITH_OPS
      |   |        Used for 5 codes: GIMPLE_COND
      |   |                          GIMPLE_DEBUG
@@ -318,104 +318,104 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
      |   |                          GIMPLE_LABEL
      |   |                          GIMPLE_SWITCH
      |   |
-     |   + gimple_statement_with_memory_ops_base
+     |   + gimple_with_memory_ops_base
      |       |    layout: GSS_WITH_MEM_OPS_BASE
      |       |
-     |       + gimple_statement_with_memory_ops
+     |       + gimple_with_memory_ops
      |       |        layout: GSS_WITH_MEM_OPS.
      |       |        used for codes GIMPLE_ASSIGN and GIMPLE_RETURN.
      |       |
-     |       + gimple_statement_call
+     |       + gcall
      |       |        layout: GSS_CALL, code: GIMPLE_CALL
      |       |
-     |       + gimple_statement_asm
+     |       + gasm
      |       |        layout: GSS_ASM, code: GIMPLE_ASM
      |       |
-     |       + gimple_statement_transaction
+     |       + gtransaction
      |                layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
      |
-     + gimple_statement_omp
+     + gomp
      |   |    layout: GSS_OMP.  Used for code GIMPLE_OMP_SECTION
      |   |
-     |   + gimple_statement_omp_critical
+     |   + gomp_critical
      |   |        layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
      |   |
-     |   + gimple_statement_omp_for
+     |   + gomp_for
      |   |        layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
      |   |
-     |   + gimple_statement_omp_parallel_layout
+     |   + gomp_parallel_layout
      |   |   |    layout: GSS_OMP_PARALLEL_LAYOUT
      |   |   |
-     |   |   + gimple_statement_omp_taskreg
+     |   |   + gomp_taskreg
      |   |   |   |
-     |   |   |   + gimple_statement_omp_parallel
+     |   |   |   + gomp_parallel
      |   |   |   |        code: GIMPLE_OMP_PARALLEL
      |   |   |   |
-     |   |   |   + gimple_statement_omp_task
+     |   |   |   + gomp_task
      |   |   |            code: GIMPLE_OMP_TASK
      |   |   |
-     |   |   + gimple_statement_omp_target
+     |   |   + gomp_target
      |   |            code: GIMPLE_OMP_TARGET
      |   |
-     |   + gimple_statement_omp_sections
+     |   + gomp_sections
      |   |        layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
      |   |
-     |   + gimple_statement_omp_single_layout
+     |   + gomp_single_layout
      |       |    layout: GSS_OMP_SINGLE_LAYOUT
      |       |
-     |       + gimple_statement_omp_single
+     |       + gomp_single
      |       |        code: GIMPLE_OMP_SINGLE
      |       |
-     |       + gimple_statement_omp_teams
+     |       + gomp_teams
      |                code: GIMPLE_OMP_TEAMS
      |
-     + gimple_statement_bind
+     + gbind
      |        layout: GSS_BIND, code: GIMPLE_BIND
      |
-     + gimple_statement_catch
+     + gcatch
      |        layout: GSS_CATCH, code: GIMPLE_CATCH
      |
-     + gimple_statement_eh_filter
+     + geh_filter
      |        layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
      |
-     + gimple_statement_eh_else
+     + geh_else
      |        layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
      |
-     + gimple_statement_eh_mnt
+     + geh_mnt
      |        layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
      |
-     + gimple_statement_phi
+     + gphi
      |        layout: GSS_PHI, code: GIMPLE_PHI
      |
-     + gimple_statement_eh_ctrl
+     + geh_ctrl
      |   |    layout: GSS_EH_CTRL
      |   |
-     |   + gimple_statement_resx
+     |   + gresx
      |   |        code: GIMPLE_RESX
      |   |
-     |   + gimple_statement_eh_dispatch
+     |   + geh_dispatch
      |            code: GIMPLE_EH_DISPATCH
      |
-     + gimple_statement_try
+     + gtry
      |        layout: GSS_TRY, code: GIMPLE_TRY
      |
-     + gimple_statement_wce
+     + gwce
      |        layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
      |
-     + gimple_statement_omp_continue
+     + gomp_continue
      |        layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
      |
-     + gimple_statement_omp_atomic_load
+     + gomp_atomic_load
      |        layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
      |
-     + gimple_statement_omp_atomic_store_layout
+     + gomp_atomic_store_layout
          |    layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
          |    code: GIMPLE_OMP_ATOMIC_STORE
          |
-         + gimple_statement_omp_atomic_store
+         + gomp_atomic_store
          |        code: GIMPLE_OMP_ATOMIC_STORE
          |
-         + gimple_statement_omp_return
+         + gomp_return
                   code: GIMPLE_OMP_RETURN
 @end smallexample
 
@@ -706,15 +706,15 @@ the code of a given statement, its operand vector will be at
 different offsets from the base of the structure.  To access
 tuple operands use the following accessors
 
-@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple *g)
 Returns the number of operands in statement G.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+@deftypefn {GIMPLE function} tree gimple_op (gimple *g, unsigned i)
 Returns operand @code{I} from statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple *g)
 Returns a pointer into the operand vector for statement @code{G}.  This
 is computed using an internal table called @code{gimple_ops_offset_}[].
 This table is indexed by the gimple code of @code{G}.
@@ -790,15 +790,15 @@ program is running (and which is valid in all functions).
 
 @subsection Statement validation
 
-@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_assign (gimple *g)
 Return true if the code of g is @code{GIMPLE_ASSIGN}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_call (gimple *g)
 Return true if the code of g is @code{GIMPLE_CALL}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_debug (gimple *g)
 Return true if the code of g is @code{GIMPLE_DEBUG}.
 @end deftypefn
 
@@ -807,12 +807,12 @@ Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
 operation.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple *g)
 Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
 expression to a variable.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_omp (gimple *g)
 Return true if g is any of the OpenMP codes.
 @end deftypefn
 
@@ -826,19 +826,19 @@ of the GIMPLE instructions.
 @subsection Common accessors
 The following are common accessors for gimple statements.
 
-@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple *g)
 Return the code for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
+@deftypefn {GIMPLE function} basic_block gimple_bb (gimple *g)
 Return the basic block to which statement @code{G} belongs to.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_block (gimple *g)
 Return the lexical scope block holding statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_expr_type (gimple *stmt)
 Return the type of the main expression computed by @code{STMT}. Return
 @code{void_type_node} if @code{STMT} computes nothing. This will only return
 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
@@ -846,7 +846,8 @@ something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
 @code{void_type_node}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (@
+gimple *stmt)
 Return the tree code for the expression computed by @code{STMT}.  This
 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
 @code{GIMPLE_COND}.  If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
@@ -855,139 +856,153 @@ For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
 by the @code{RHS} of the assignment.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_set_block (gimple *g, tree block)
 Set the lexical scope block of @code{G} to @code{BLOCK}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
+@deftypefn {GIMPLE function} location_t gimple_locus (gimple *g)
 Return locus information for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
+@deftypefn {GIMPLE function} void gimple_set_locus (gimple *g, @
+location_t locus)
 Set locus information for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple *g)
 Return true if @code{G} does not have locus information.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple *stmt)
 Return true if no warnings should be emitted for statement @code{STMT}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
+@deftypefn {GIMPLE function} void gimple_set_visited (gimple *stmt, @
+bool visited_p)
 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_visited_p (gimple *stmt)
 Return the visited status on statement @code{STMT}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
+@deftypefn {GIMPLE function} void gimple_set_plf (gimple *stmt, @
+enum plf_mask plf, bool val_p)
 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
+@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple *stmt, @
+enum plf_mask plf)
 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
+@deftypefn {GIMPLE function} bool gimple_has_ops (gimple *g)
 Return true if statement @code{G} has register or memory operands.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
+@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple *g)
 Return true if statement @code{G} has memory operands.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple *g)
 Return the number of operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple *g)
 Return the array of operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+@deftypefn {GIMPLE function} tree gimple_op (gimple *g, unsigned i)
 Return operand @code{I} for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
+@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple *g, unsigned i)
 Return a pointer to operand @code{I} for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
+@deftypefn {GIMPLE function} void gimple_set_op (gimple *g, unsigned i, @
+tree op)
 Set operand @code{I} of statement @code{G} to @code{OP}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
+@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple *stmt)
 Return the set of symbols that have had their address taken by
 @code{STMT}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
+@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (@
+gimple *g)
 Return the set of @code{DEF} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
+@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple *g, @
+struct def_optype_d *def)
 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
+@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (@
+gimple *g)
 Return the set of @code{USE} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
+@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple *g, @
+struct use_optype_d *use)
 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (@
+gimple *g)
 Return the set of @code{VUSE} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
+@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple *g, @
+struct voptype_d *ops)
 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (@
+gimple *g)
 Return the set of @code{VDEF} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
+@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple *g, @
+struct voptype_d *ops)
 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
+@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple *g)
 Return the set of symbols loaded by statement @code{G}.  Each element of
 the set is the @code{DECL_UID} of the corresponding symbol.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
+@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple *g)
 Return the set of symbols stored by statement @code{G}.  Each element of
 the set is the @code{DECL_UID} of the corresponding symbol.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_modified_p (gimple *g)
 Return true if statement @code{G} has operands and the modified field
 has been set.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple *stmt)
 Return true if statement @code{STMT} contains volatile operands.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (@
+gimple *stmt, bool volatilep)
 Return true if statement @code{STMT} contains volatile operands.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void update_stmt (gimple s)
+@deftypefn {GIMPLE function} void update_stmt (gimple *s)
 Mark statement @code{S} as modified, and update it.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
+@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple *s)
 Update statement @code{S} if it has been marked modified.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
+@deftypefn {GIMPLE function} gimple *gimple_copy (gimple *stmt)
 Return a deep copy of statement @code{STMT}.
 @end deftypefn
 
@@ -1031,7 +1046,8 @@ Return a deep copy of statement @code{STMT}.
 @subsection @code{GIMPLE_ASM}
 @cindex @code{GIMPLE_ASM}
 
-@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
+@deftypefn {GIMPLE function} gimple *gimple_build_asm (@
+const char *string, ninputs, noutputs, nclobbers, ...)
 Build a @code{GIMPLE_ASM} statement.  This statement is used for
 building in-line assembly constructs.  @code{STRING} is the assembly
 code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
@@ -1040,58 +1056,64 @@ registers.  The rest of the arguments trees for each input,
 output, and clobbered registers.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
+@deftypefn {GIMPLE function} gimple *gimple_build_asm_vec (@
+const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
 Identical to gimple_build_asm, but the arguments are passed in
 VECs.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple *g)
 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple *g)
 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple *g)
 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple *g, @
+unsigned index)
 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple *g, @
+unsigned index, tree in_op)
 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple *g, @
+unsigned index)
 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
+@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple *g, @
 unsigned index, tree out_op)
 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple *g, @
+unsigned index)
 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple *g, @
+unsigned index, tree clobber_op)
 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g)
+@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple *g)
 Return the string representing the assembly instruction in
 @code{GIMPLE_ASM} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple *g)
 Return true if @code{G} is an asm statement marked volatile.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
+@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple *g)
 Mark asm statement @code{G} as volatile.
 @end deftypefn
 
@@ -1099,7 +1121,8 @@ Mark asm statement @code{G} as volatile.
 @subsection @code{GIMPLE_ASSIGN}
 @cindex @code{GIMPLE_ASSIGN}
 
-@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_assign (tree lhs, @
+tree rhs)
 Build a @code{GIMPLE_ASSIGN} statement.  The left-hand side is an lvalue
 passed in lhs.  The right-hand side can be either a unary or
 binary tree expression.  The expression tree rhs will be
@@ -1113,7 +1136,8 @@ operands in separate trees, it is better to use
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
+@deftypefn {GIMPLE function} gimple *gimplify_assign (tree dst, tree src, @
+gimple_seq *seq_p)
 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
 @code{*SEQ_P}.
 @end deftypefn
@@ -1124,7 +1148,7 @@ case they will be converted to a gimple operand if necessary.
 
 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
 
-@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
+@deftypefn {GIMPLE function} gimple *gimple_build_assign_with_ops @
 (enum tree_code subcode, tree lhs, tree op1, tree op2)
 This function is similar to @code{gimple_build_assign}, but is used to
 build a @code{GIMPLE_ASSIGN} statement when the operands of the
@@ -1137,73 +1161,79 @@ are the operands.  If op2 is null, subcode must be a @code{tree_code}
 for a unary expression.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (@
+gimple *g)
 Return the code of the expression computed on the @code{RHS} of
 assignment statement @code{G}.
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (@
+gimple *g)
 Return the gimple rhs class of the code for the expression
 computed on the rhs of assignment statement @code{G}.  This will never
 return @code{GIMPLE_INVALID_RHS}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple *g)
 Return the @code{LHS} of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple *g)
 Return a pointer to the @code{LHS} of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple *g)
 Return the first operand on the @code{RHS} of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple *g)
 Return the address of the first operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple *g)
 Return the second operand on the @code{RHS} of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple *g)
 Return the address of the second operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple *g)
 Return the third operand on the @code{RHS} of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple *g)
 Return the address of the third operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple *g, @
+tree lhs)
 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple *g, @
+tree rhs)
 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple *g, @
+tree rhs)
 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple *g, @
+tree rhs)
 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple *s)
 Return true if @code{S} is a type-cast assignment.
 @end deftypefn
 
@@ -1212,49 +1242,56 @@ Return true if @code{S} is a type-cast assignment.
 @subsection @code{GIMPLE_BIND}
 @cindex @code{GIMPLE_BIND}
 
-@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_bind (tree vars, @
+gimple_seq body)
 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
 and a body of statements in sequence @code{BODY}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple *g)
 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple *g, @
+tree vars)
 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple *g, @
+tree vars)
 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple *g)
 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple *g, @
+gimple_seq seq)
 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
+@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple *gs, @
+gimple *stmt)
 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple *gs, @
+gimple_seq seq)
 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
 body.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_block (gimple *g)
 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple *g, @
+tree block)
 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
 statement @code{G}.
 @end deftypefn
@@ -1264,7 +1301,8 @@ statement @code{G}.
 @subsection @code{GIMPLE_CALL}
 @cindex @code{GIMPLE_CALL}
 
-@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
+@deftypefn {GIMPLE function} gimple *gimple_build_call (tree fn, @
+unsigned nargs, ...)
 Build a @code{GIMPLE_CALL} statement to function @code{FN}.  The argument @code{FN}
 must be either a @code{FUNCTION_DECL} or a gimple call address as
 determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
@@ -1274,7 +1312,8 @@ operand is validated with @code{is_gimple_operand}).
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_from_tree (@
+tree call_expr)
 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
 function are taken from the expression directly.  This routine
 assumes that @code{call_expr} is already in GIMPLE form.  That is, its
@@ -1283,98 +1322,105 @@ simplification.  All the call flags in @code{call_expr} are copied over
 to the new @code{GIMPLE_CALL}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_vec (tree fn, @
+@code{VEC}(tree, heap) *args)
 Identical to @code{gimple_build_call} but the arguments are stored in a
 @code{VEC}().
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple *g)
 Return the @code{LHS} of call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple *g)
 Return a pointer to the @code{LHS} of call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple *g, tree lhs)
 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_fn (gimple *g)
 Return the tree node representing the function called by call
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
+@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple *g, tree fn)
 Set @code{FN} to be the function called by call statement @code{G}.  This has
 to be a gimple value specifying the address of the called
 function.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
+@deftypefn {GIMPLE *function} tree gimple_call_fndecl (gimple *g)
 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
 Otherwise return @code{NULL}.  This function is analogous to
 @code{get_callee_fndecl} in @code{GENERIC}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
+@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple *g, @
+tree fndecl)
 Set the called function to @code{FNDECL}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple *g)
 Return the type returned by call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_chain (gimple *g)
 Return the static chain for call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
+@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple *g, @
+tree chain)
 Set @code{CHAIN} to be the static chain for call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple *g)
 Return the number of arguments used by call statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_call_arg (gimple *g, @
+unsigned index)
 Return the argument at position @code{INDEX} for call statement @code{G}.  The
 first argument is 0.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
+@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple *g, @
+unsigned index)
 Return a pointer to the argument at position @code{INDEX} for call
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
+@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple *g, @
+unsigned index, tree arg)
 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple *s)
 Mark call statement @code{S} as being a tail call (i.e., a call just
 before the exit of a function). These calls are candidate for
 tail call optimization.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple *s)
 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple *s)
 Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple *s)
 Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple *s)
 Return true if @code{S} is a noreturn call.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+@deftypefn {GIMPLE function} gimple *gimple_call_copy_skip_args (@
+gimple *stmt, bitmap args_to_skip)
 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
 in the positions marked by the set @code{ARGS_TO_SKIP}.
 @end deftypefn
@@ -1384,31 +1430,34 @@ in the positions marked by the set @code{ARGS_TO_SKIP}.
 @subsection @code{GIMPLE_CATCH}
 @cindex @code{GIMPLE_CATCH}
 
-@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
+@deftypefn {GIMPLE function} gimple *gimple_build_catch (tree types, @
+gimple_seq handler)
 Build a @code{GIMPLE_CATCH} statement.  @code{TYPES} are the tree types this
 catch handles.  @code{HANDLER} is a sequence of statements with the code
 for the handler.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_catch_types (gimple *g)
 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple *g)
 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple *g)
 Return the GIMPLE sequence representing the body of the handler
 of @code{GIMPLE_CATCH} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
+@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple *g, @
+tree t)
 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
+@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple *g, @
+gimple_seq handler)
 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
 @end deftypefn
 
@@ -1417,7 +1466,8 @@ Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
 @subsection @code{GIMPLE_COND}
 @cindex @code{GIMPLE_COND}
 
-@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond (@
+enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
 Build a @code{GIMPLE_COND} statement.  @code{A} @code{GIMPLE_COND} statement compares
 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@@ -1426,66 +1476,70 @@ the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond_from_tree (@
+tree cond, tree t_label, tree f_label)
 Build a @code{GIMPLE_COND} statement from the conditional expression
 tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple *g)
 Return the code of the predicate computed by conditional
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
+@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple *g, @
+enum tree_code code)
 Set @code{CODE} to be the predicate code for the conditional statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple *g)
 Return the @code{LHS} of the predicate computed by conditional statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple *g, tree lhs)
 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
 conditional statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple *g)
 Return the @code{RHS} operand of the predicate computed by conditional
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple *g, tree rhs)
 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
 conditional statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple *g)
 Return the label used by conditional statement @code{G} when its
 predicate evaluates to true.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple *g, @
+tree label)
 Set @code{LABEL} to be the label used by conditional statement @code{G} when
 its predicate evaluates to true.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple *g, @
+tree label)
 Set @code{LABEL} to be the label used by conditional statement @code{G} when
 its predicate evaluates to false.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple *g)
 Return the label used by conditional statement @code{G} when its
 predicate evaluates to false.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple *g)
 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple *g)
 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
 @end deftypefn
 
@@ -1494,7 +1548,8 @@ Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
 @cindex @code{GIMPLE_DEBUG}
 @cindex @code{GIMPLE_DEBUG_BIND}
 
-@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
+@deftypefn {GIMPLE function} gimple *gimple_build_debug_bind (tree var, @
+tree value, gimple *stmt)
 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
 @code{subcode}.  The effect of this statement is to tell debug
 information generation machinery that the value of user variable
@@ -1533,35 +1588,41 @@ Block and location information for the newly-created stmt are
 taken from @code{stmt}, if given.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple *stmt)
 Return the user variable @var{var} that is bound at @code{stmt}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (@
+gimple *stmt)
 Return the value expression that is bound to a user variable at
 @code{stmt}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
+@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (@
+gimple *stmt)
 Return a pointer to the value expression that is bound to a user
 variable at @code{stmt}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (@
+gimple *stmt, tree var)
 Modify the user variable bound at @code{stmt} to @var{var}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (@
+gimple *stmt, tree var)
 Modify the value bound to the user variable bound at @code{stmt} to
 @var{value}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
+@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (@
+gimple *stmt)
 Modify the value bound to the user variable bound at @code{stmt} so
 that the variable becomes unbound.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (@
+gimple *stmt)
 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
 and @code{FALSE} if it unbinds the variable.
 @end deftypefn
@@ -1570,39 +1631,46 @@ and @code{FALSE} if it unbinds the variable.
 @subsection @code{GIMPLE_EH_FILTER}
 @cindex @code{GIMPLE_EH_FILTER}
 
-@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
+@deftypefn {GIMPLE function} gimple *gimple_build_eh_filter (@
+tree types, gimple_seq failure)
 Build a @code{GIMPLE_EH_FILTER} statement.  @code{TYPES} are the filter's
 types.  @code{FAILURE} is a sequence with the filter's failure action.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple *g)
 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (@
+gimple *g)
 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (@
+gimple *g)
 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
 statement fails.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple *g, @
+tree types)
 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (@
+gimple *g, gimple_seq failure)
 Set @code{FAILURE} to be the sequence of statements to execute on
 failure for @code{GIMPLE_EH_FILTER} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
+@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (@
+gimple *g)
 Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (@
+gimple *g, bool mntp)
 Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
 @end deftypefn
 
@@ -1611,30 +1679,32 @@ Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
 @subsection @code{GIMPLE_LABEL}
 @cindex @code{GIMPLE_LABEL}
 
-@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
+@deftypefn {GIMPLE function} gimple *gimple_build_label (tree label)
 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
 label, @code{LABEL}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_label_label (gimple *g)
 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_label_set_label (gimple *g, @
+tree label)
 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
 statement @code{G}.
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
+@deftypefn {GIMPLE function} gimple *gimple_build_goto (tree dest)
 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
+@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple *g)
 Return the destination of the unconditional jump @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
+@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple *g, @
+tree dest)
 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
 @end deftypefn
 
@@ -1643,11 +1713,11 @@ Set @code{DEST} to be the destination of the unconditional jump @code{G}.
 @subsection @code{GIMPLE_NOP}
 @cindex @code{GIMPLE_NOP}
 
-@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_nop (void)
 Build a @code{GIMPLE_NOP} statement.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_nop_p (gimple *g)
 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
 @end deftypefn
 
@@ -1655,25 +1725,28 @@ Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_load (@
+tree lhs, tree rhs)
 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @code{LHS} is the left-hand
 side of the assignment.  @code{RHS} is the right-hand side of the
 assignment.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (@
+gimple *g, tree lhs)
 Set the @code{LHS} of an atomic load.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple *g)
 Get the @code{LHS} of an atomic load.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (@
+gimple *g, tree rhs)
 Set the @code{RHS} of an atomic set.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple *g)
 Get the @code{RHS} of an atomic set.
 @end deftypefn
 
@@ -1682,16 +1755,18 @@ Get the @code{RHS} of an atomic set.
 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_store (@
+tree val)
 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
 stored.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (@
+gimple *g, tree val)
 Set the value being stored in an atomic store.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple *g)
 Return the value being stored in an atomic store.
 @end deftypefn
 
@@ -1699,36 +1774,43 @@ Return the value being stored in an atomic store.
 @subsection @code{GIMPLE_OMP_CONTINUE}
 @cindex @code{GIMPLE_OMP_CONTINUE}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_continue (@
+tree control_def, tree control_use)
 Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
 definition of the control variable.  @code{CONTROL_USE} is the use of
 the control variable.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (@
+gimple *s)
 Return the definition of the control variable on a
 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (@
+gimple *s)
 Same as above, but return the pointer.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (@
+gimple *s)
 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
 statement in @code{S}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (@
+gimple *s)
 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
 in @code{S}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (@
+gimple *s)
 Same as above, but return the pointer.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (@
+gimple *s)
 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
 in @code{S}.
 @end deftypefn
@@ -1738,22 +1820,25 @@ in @code{S}.
 @subsection @code{GIMPLE_OMP_CRITICAL}
 @cindex @code{GIMPLE_OMP_CRITICAL}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_critical (@
+gimple_seq body, tree name)
 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
 statements for which only one thread can execute.  @code{NAME} is an
 optional identifier for this critical block.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple *g)
 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (@
+gimple *g)
 Return a pointer to the name associated with @code{OMP} critical
 statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
+@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (@
+gimple *g, tree name)
 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
 @end deftypefn
 
@@ -1761,7 +1846,8 @@ Set @code{NAME} to be the name associated with @code{OMP} critical statement @co
 @subsection @code{GIMPLE_OMP_FOR}
 @cindex @code{GIMPLE_OMP_FOR}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_for (@
+gimple_seq body, @
 tree clauses, tree index, tree initial, tree final, tree incr, @
 gimple_seq pre_body, enum tree_code omp_for_cond)
 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
@@ -1774,81 +1860,91 @@ final value of @code{INDEX}.  OMP_FOR_COND is the predicate used to
 compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple *g)
 Return the clauses associated with @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (@
+gimple *g)
 Return a pointer to the @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (@
+gimple *g, tree clauses)
 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple *g)
 Return the index variable for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple *g)
 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_index (@
+gimple *g, tree index)
 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple *g)
 Return the initial value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (@
+gimple *g)
 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple *g, @
+tree initial)
 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple *g)
 Return the final value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple *g)
 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple *g, @
+tree final)
 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple *g)
 Return the increment value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple *g)
 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple *g, @
+tree incr)
 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple *g)
 Return the sequence of statements to execute before the @code{OMP_FOR}
 statement @code{G} starts.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple *g, @
+gimple_seq pre_body)
 Set @code{PRE_BODY} to be the sequence of statements to execute before
 the @code{OMP_FOR} statement @code{G} starts.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple *g, @
+enum tree_code cond)
 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (@
+gimple *g)
 Return the condition code associated with @code{OMP_FOR} @code{G}.
 @end deftypefn
 
@@ -1857,7 +1953,8 @@ Return the condition code associated with @code{OMP_FOR} @code{G}.
 @subsection @code{GIMPLE_OMP_MASTER}
 @cindex @code{GIMPLE_OMP_MASTER}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_master (@
+gimple_seq body)
 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
 statements to be executed by just the master.
 @end deftypefn
@@ -1867,7 +1964,8 @@ statements to be executed by just the master.
 @subsection @code{GIMPLE_OMP_ORDERED}
 @cindex @code{GIMPLE_OMP_ORDERED}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_ordered (@
+gimple_seq body)
 Build a @code{GIMPLE_OMP_ORDERED} statement.
 @end deftypefn
 
@@ -1879,8 +1977,8 @@ executed in sequence.
 @subsection @code{GIMPLE_OMP_PARALLEL}
 @cindex @code{GIMPLE_OMP_PARALLEL}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @
-body, tree clauses, tree child_fn, tree data_arg)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_parallel (@
+gimple_seq body, tree clauses, tree child_fn, tree data_arg)
 Build a @code{GIMPLE_OMP_PARALLEL} statement.
 @end deftypefn
 
@@ -1889,61 +1987,70 @@ Build a @code{GIMPLE_OMP_PARALLEL} statement.
 the function created for the parallel threads to execute.
 @code{DATA_ARG} are the shared data argument(s).
 
-@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (@
+gimple *g)
 Return true if @code{OMP} parallel statement @code{G} has the
 @code{GF_OMP_PARALLEL_COMBINED} flag set.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (@
+gimple *g)
 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple *g)
 Return the body for the @code{OMP} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
+@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple *g, @
+gimple_seq body)
 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple *g)
 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (@
+gimple *g)
 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (@
+gimple *g, tree clauses)
 Set @code{CLAUSES} to be the list of clauses associated with
 @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple *g)
 Return the child function used to hold the body of @code{OMP_PARALLEL}
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (@
+gimple *g)
 Return a pointer to the child function used to hold the body of
 @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (@
+gimple *g, tree child_fn)
 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple *g)
 Return the artificial argument used to send variables and values
 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (@
+gimple *g)
 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (@
+gimple *g, tree data_arg)
 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
 @end deftypefn
 
@@ -1952,17 +2059,17 @@ Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
 @subsection @code{GIMPLE_OMP_RETURN}
 @cindex @code{GIMPLE_OMP_RETURN}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_return (bool wait_p)
 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
 non-waiting return.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
+@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple *s)
 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple *g)
 Return true if @code{OMP} return statement @code{G} has the
 @code{GF_OMP_RETURN_NOWAIT} flag set.
 @end deftypefn
@@ -1971,18 +2078,19 @@ Return true if @code{OMP} return statement @code{G} has the
 @subsection @code{GIMPLE_OMP_SECTION}
 @cindex @code{GIMPLE_OMP_SECTION}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_section (@
+gimple_seq body)
 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
 @end deftypefn
 
 @code{BODY} is the sequence of statements in the section.
 
-@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple *g)
 Return true if @code{OMP} section statement @code{G} has the
 @code{GF_OMP_SECTION_LAST} flag set.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple *g)
 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
 @end deftypefn
 
@@ -1990,7 +2098,8 @@ Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
 @subsection @code{GIMPLE_OMP_SECTIONS}
 @cindex @code{GIMPLE_OMP_SECTIONS}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections (@
+gimple_seq body, tree clauses)
 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
 section statements.  @code{CLAUSES} are any of the @code{OMP} sections
 construct's clauses: private, firstprivate, lastprivate,
@@ -1998,34 +2107,39 @@ reduction, and nowait.
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections_switch (@
+void)
 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple *g)
 Return the control variable associated with the
 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (@
+gimple *g)
 Return a pointer to the clauses associated with the
 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (@
+gimple *g, tree control)
 Set @code{CONTROL} to be the set of clauses associated with the
 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple *g)
 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (@
+gimple *g)
 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (@
+gimple *g, tree clauses)
 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
 @code{G}.
 @end deftypefn
@@ -2035,22 +2149,25 @@ Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
 @subsection @code{GIMPLE_OMP_SINGLE}
 @cindex @code{GIMPLE_OMP_SINGLE}
 
-@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_single (@
+gimple_seq body, tree clauses)
 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
 statements that will be executed once.  @code{CLAUSES} are any of the
 @code{OMP} single construct's clauses: private, firstprivate,
 copyprivate, nowait.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple *g)
 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (@
+gimple *g)
 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (@
+gimple *g, tree clauses)
 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
 @end deftypefn
 
@@ -2059,34 +2176,37 @@ Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
 @subsection @code{GIMPLE_PHI}
 @cindex @code{GIMPLE_PHI}
 
-@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple *g)
 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple *g)
 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
 be exactly the number of incoming edges for the basic block
 holding @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
+@deftypefn {GIMPLE function} tree gimple_phi_result (gimple *g)
 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple *g)
 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
+@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple *g, @
+tree result)
 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
+@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (@
+gimple *g, index)
 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
 @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
+@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple *g, @
+index, struct phi_arg_d * phiarg)
 Set @code{PHIARG} to be the argument corresponding to incoming edge
 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
 @end deftypefn
@@ -2095,18 +2215,19 @@ Set @code{PHIARG} to be the argument corresponding to incoming edge
 @subsection @code{GIMPLE_RESX}
 @cindex @code{GIMPLE_RESX}
 
-@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
+@deftypefn {GIMPLE function} gimple *gimple_build_resx (int region)
 Build a @code{GIMPLE_RESX} statement which is a statement.  This
 statement is a placeholder for _Unwind_Resume before we know if a
 function call or a branch is needed.  @code{REGION} is the exception
 region from which control is flowing.
 @end deftypefn
 
-@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
+@deftypefn {GIMPLE function} int gimple_resx_region (gimple *g)
 Return the region number for @code{GIMPLE_RESX} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
+@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple *g, @
+int region)
 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
 @end deftypefn
 
@@ -2114,15 +2235,16 @@ Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
 @subsection @code{GIMPLE_RETURN}
 @cindex @code{GIMPLE_RETURN}
 
-@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
+@deftypefn {GIMPLE function} gimple *gimple_build_return (tree retval)
 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
+@deftypefn {GIMPLE function} tree gimple_return_retval (gimple *g)
 Return the return value for @code{GIMPLE_RETURN} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
+@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple *g, @
+tree retval)
 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
 @end deftypefn
 
@@ -2130,50 +2252,52 @@ Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
 @subsection @code{GIMPLE_SWITCH}
 @cindex @code{GIMPLE_SWITCH}
 
-@deftypefn {GIMPLE function} gimple gimple_build_switch (tree index, tree @
-default_label, @code{VEC}(tree,heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_switch (tree index, @
+tree default_label, @code{VEC}(tree,heap) *args)
 Build a @code{GIMPLE_SWITCH} statement.  @code{INDEX} is the index variable
 to switch on, and @code{DEFAULT_LABEL} represents the default label.
 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
 non-default case labels.  Each label is a tree of code @code{CASE_LABEL_EXPR}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple *g)
 Return the number of labels associated with the switch statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @
-unsigned nlabels)
+@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (@
+gimple *g, unsigned nlabels)
 Set @code{NLABELS} to be the number of labels for the switch statement
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_index (gimple *g)
 Return the index variable used by the switch statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple *g, @
+tree index)
 Set @code{INDEX} to be the index variable for switch statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_switch_label (gimple *g, @
+unsigned index)
 Return the label numbered @code{INDEX}. The default label is 0, followed
 by any labels in a switch statement.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @
-index, tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple *g, @
+unsigned index, tree label)
 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
 label.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple *g)
 Return the default label for a switch statement.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @
-tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_default_label (@
+gimple *g, tree label)
 Set the default label for a switch statement.
 @end deftypefn
 
@@ -2182,7 +2306,7 @@ Set the default label for a switch statement.
 @subsection @code{GIMPLE_TRY}
 @cindex @code{GIMPLE_TRY}
 
-@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @
+@deftypefn {GIMPLE function} gimple *gimple_build_try (gimple_seq eval, @
 gimple_seq cleanup, unsigned int kind)
 Build a @code{GIMPLE_TRY} statement.  @code{EVAL} is a sequence with the
 expression to evaluate.  @code{CLEANUP} is a sequence of statements to
@@ -2192,36 +2316,39 @@ or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
 construct.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (@
+gimple *g)
 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
+@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple *g)
 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple *g)
 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
 @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple *g)
 Return the sequence of statements used as the cleanup body for
 @code{GIMPLE_TRY} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
-bool catch_is_cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (@
+gimple *g, bool catch_is_cleanup)
 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
+@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple *g, @
+gimple_seq eval)
 Set @code{EVAL} to be the sequence of statements to use as the body for
 @code{GIMPLE_TRY} @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple *g, @
+gimple_seq cleanup)
 Set @code{CLEANUP} to be the sequence of statements to use as the
 cleanup body for @code{GIMPLE_TRY} @code{G}.
 @end deftypefn
@@ -2230,24 +2357,26 @@ cleanup body for @code{GIMPLE_TRY} @code{G}.
 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
 
-@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
+@deftypefn {GIMPLE function} gimple *gimple_build_wce (gimple_seq cleanup)
 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
 clean-up expression.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple *g)
 Return the cleanup sequence for cleanup statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple *g, @
+gimple_seq cleanup)
 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
+@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple *g)
 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (@
+gimple *g, bool eh_only_p)
 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
 @end deftypefn
 
@@ -2274,7 +2403,8 @@ in the section entitled Sequence Iterators.
 
 Below is a list of functions to manipulate and query sequences.
 
-@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
+@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, @
+gimple *g)
 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
 not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
 @end deftypefn
@@ -2294,19 +2424,21 @@ Reverse the order of the statements in the sequence @code{SEQ}.  Return
 @code{SEQ}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_first (gimple_seq s)
 Return the first statement in sequence @code{S}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_last (gimple_seq s)
 Return the last statement in sequence @code{S}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
+@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, @
+gimple *last)
 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
+@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, @
+gimple *first)
 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
 @end deftypefn
 
@@ -2352,7 +2484,7 @@ gimple_stmt_iterator gsi;
 
 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
   @{
-    gimple g = gsi_stmt (gsi);
+    gimple *g = gsi_stmt (gsi);
     /* Do something with gimple statement @code{G}.  */
   @}
 @end smallexample
@@ -2424,7 +2556,7 @@ Advance the iterator to the next gimple statement.
 Advance the iterator to the previous gimple statement.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
+@deftypefn {GIMPLE function} gimple *gsi_stmt (gimple_stmt_iterator i)
 Return the current stmt.
 @end deftypefn
 
@@ -2433,7 +2565,8 @@ Return a block statement iterator that points to the first
 non-label statement in block @code{BB}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
+@deftypefn {GIMPLE function} {gimple **} gsi_stmt_ptr (@
+gimple_stmt_iterator *i)
 Return a pointer to the current stmt.
 @end deftypefn
 
@@ -2460,7 +2593,8 @@ by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
 after insertion (see @code{enum gsi_iterator_update} above).
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, @
+gimple *g, enum gsi_iterator_update mode)
 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
 Updates iterator @code{I} according to @code{MODE}.
 @end deftypefn
@@ -2472,7 +2606,7 @@ Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
-gimple g, enum gsi_iterator_update mode)
+gimple *g, enum gsi_iterator_update mode)
 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
 @code{MODE} is as in @code{gsi_insert_after}.
 @end deftypefn
@@ -2488,14 +2622,14 @@ Return this new sequence.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
-gimple stmt, bool update_eh_info)
+gimple *stmt, bool update_eh_info)
 Replace the statement pointed-to by @code{I} to @code{STMT}.  If @code{UPDATE_EH_INFO}
 is true, the exception handling information of the original
 statement is moved to the new statement.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
 Insert statement @code{STMT} before the statement pointed-to by iterator
 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
 specifies how to update iterator @code{I} after insertion (see enum
@@ -2508,7 +2642,7 @@ Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
 Insert statement @code{STMT} after the statement pointed-to by iterator
 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
 specifies how to update iterator @code{I} after insertion (see enum
@@ -2520,7 +2654,8 @@ gimple_seq seq, enum gsi_iterator_update mode)
 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (@
+gimple *stmt)
 Finds iterator for @code{STMT}.
 @end deftypefn
 
@@ -2541,7 +2676,7 @@ basic_block bb)
 Move the statement at @code{FROM} to the end of basic block @code{BB}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
+@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple *stmt)
 Add @code{STMT} to the pending list of edge @code{E}.  No actual insertion is
 made until a call to @code{gsi_commit_edge_inserts}() is made.
 @end deftypefn
@@ -2552,7 +2687,8 @@ Add the sequence of statements in @code{SEQ} to the pending list of edge
 @code{gsi_commit_edge_inserts}() is made.
 @end deftypefn
 
-@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
+@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (@
+edge e, gimple *stmt)
 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}.  If a new
 block has to be created, it is returned.
 @end deftypefn
@@ -2626,7 +2762,7 @@ The return value is that returned by the last call to
 @end deftypefn
 
 
-@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
+@deftypefn {GIMPLE function} tree walk_gimple_op (gimple *stmt, @
   walk_tree_fn callback_op, struct walk_stmt_info *wi)
 Use this function to walk the operands of statement @code{STMT}.  Every
 operand is walked via @code{walk_tree} with optional state information
diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py
index 85608dc..a0d94bb 100644
--- a/gcc/gdbhooks.py
+++ b/gcc/gdbhooks.py
@@ -454,7 +454,7 @@ def build_pretty_printer():
                              'tree', TreePrinter)
     pp.add_printer_for_types(['cgraph_node *'],
                              'cgraph_node', CGraphNodePrinter)
-    pp.add_printer_for_types(['gimple', 'gimple_statement_base *'],
+    pp.add_printer_for_types(['gimple *'],
                              'gimple',
                              GimplePrinter)
     pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
diff --git a/gcc/ggc.h b/gcc/ggc.h
index 55f3fe9..337d222 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -270,10 +270,10 @@ ggc_alloc_cleared_tree_node_stat (size_t s MEM_STAT_DECL)
   return (union tree_node *) ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
 }
 
-static inline struct gimple_statement_base *
-ggc_alloc_cleared_gimple_statement_stat (size_t s MEM_STAT_DECL)
+static inline gimple
+ggc_alloc_cleared_gimple_stat (size_t s MEM_STAT_DECL)
 {
-  return (struct gimple_statement_base *)
+  return (gimple)
     ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
 }
 
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 77afa20..b80ae72 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -94,13 +94,13 @@ print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
 }
 
 DEBUG_FUNCTION void
-debug (gimple_statement_base &ref)
+debug (gimple &ref)
 {
   print_gimple_stmt (stderr, &ref, 0, 0);
 }
 
 DEBUG_FUNCTION void
-debug (gimple_statement_base *ptr)
+debug (gimple *ptr)
 {
   if (ptr)
     debug (*ptr);
diff --git a/gcc/gimple-pretty-print.h b/gcc/gimple-pretty-print.h
index 37db243..82ef760 100644
--- a/gcc/gimple-pretty-print.h
+++ b/gcc/gimple-pretty-print.h
@@ -29,8 +29,8 @@ extern void debug_gimple_stmt (gimple);
 extern void debug_gimple_seq (gimple_seq);
 extern void print_gimple_seq (FILE *, gimple_seq, int, int);
 extern void print_gimple_stmt (FILE *, gimple, int, int);
-extern void debug (gimple_statement_base &ref);
-extern void debug (gimple_statement_base *ptr);
+extern void debug (gimple &ref);
+extern void debug (gimple *ptr);
 extern void print_gimple_expr (FILE *, gimple, int, int);
 extern void pp_gimple_stmt_1 (pretty_printer *, gimple, int, int);
 extern void gimple_dump_bb (FILE *, basic_block, int, int);
diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h
index 904f002..21d6426 100644
--- a/gcc/gimple-ssa.h
+++ b/gcc/gimple-ssa.h
@@ -108,8 +108,8 @@ static inline use_operand_p
 gimple_vuse_op (const_gimple g)
 {
   struct use_optype_d *ops;
-  const gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <const gimple_statement_with_memory_ops *> (g);
+  const gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <const gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_USE_OPERAND_P;
   ops = mem_ops_stmt->use_ops;
@@ -124,8 +124,8 @@ gimple_vuse_op (const_gimple g)
 static inline def_operand_p
 gimple_vdef_op (gimple g)
 {
-  gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <gimple_statement_with_memory_ops *> (g);
+  gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_DEF_OPERAND_P;
   if (mem_ops_stmt->vdef)
diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c
index f7b5d01..5c685f4 100644
--- a/gcc/gimple-streamer-in.c
+++ b/gcc/gimple-streamer-in.c
@@ -137,7 +137,7 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
     case GIMPLE_ASM:
       {
 	/* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
-	gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (stmt);
+	gasm *asm_stmt = as_a <gasm *> (stmt);
 	tree str;
 	asm_stmt->ni = streamer_read_uhwi (ib);
 	asm_stmt->no = streamer_read_uhwi (ib);
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 091467e..cba2d1b 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -132,7 +132,7 @@ gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
       gimple_alloc_sizes[(int) kind] += size;
     }
 
-  stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
+  stmt = ggc_alloc_cleared_gimple_stat (size PASS_MEM_STAT);
   gimple_set_code (stmt, code);
   gimple_set_num_ops (stmt, num_ops);
 
@@ -537,14 +537,14 @@ static inline gimple
 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));
 
@@ -664,14 +664,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);
@@ -701,8 +701,8 @@ gimple_build_wce (gimple_seq cleanup)
 gimple
 gimple_build_resx (int region)
 {
-  gimple_statement_resx *p =
-    as_a <gimple_statement_resx *> (
+  gresx *p =
+    as_a <gresx *> (
       gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
   p->region = region;
   return p;
@@ -751,8 +751,8 @@ gimple_build_switch (tree index, tree default_label, vec<tree> args)
 gimple
 gimple_build_eh_dispatch (int region)
 {
-  gimple_statement_eh_dispatch *p =
-    as_a <gimple_statement_eh_dispatch *> (
+  geh_dispatch *p =
+    as_a <geh_dispatch *> (
       gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
   p->region = region;
   return p;
@@ -828,8 +828,7 @@ gimple
 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);
@@ -1663,8 +1662,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 =
 	      static_cast <struct gimple_omp_for_iter *> (
 		  ggc_internal_vec_alloc_stat (sizeof (struct gimple_omp_for_iter),
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 9df45de..1635ab5 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -70,7 +70,7 @@ enum gimple_rhs_class
 };
 
 /* Specific flags for individual GIMPLE statements.  These flags are
-   always stored in gimple_statement_base.subcode and they may only be
+   always stored in gimple.subcode and they may only be
    defined for statement codes that do not use subcodes.
 
    Values for the masks can overlap as long as the overlapping values
@@ -136,7 +136,7 @@ enum plf_mask {
 
 struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
 	    chain_next ("%h.next"), variable_size))
-  gimple_statement_base
+  gimple
 {
   /* [ WORD 1 ]
      Main identifying code for a tuple.  */
@@ -206,7 +206,7 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
 
 /* This gimple subclass has no tag value.  */
 struct GTY(())
-  gimple_statement_with_ops_base : public gimple_statement_base
+  gimple_with_ops_base : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -222,7 +222,7 @@ struct GTY(())
 /* Statements that take register operands.  */
 
 struct GTY((tag("GSS_WITH_OPS")))
-  gimple_statement_with_ops : public gimple_statement_with_ops_base
+  gimple_with_ops : public gimple_with_ops_base
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -237,7 +237,7 @@ struct GTY((tag("GSS_WITH_OPS")))
 /* Base for statements that take both memory and register operands.  */
 
 struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
-  gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
+  gimple_with_memory_ops_base : public gimple_with_ops_base
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -252,8 +252,8 @@ struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
 /* Statements that take both memory and register operands.  */
 
 struct GTY((tag("GSS_WITH_MEM_OPS")))
-  gimple_statement_with_memory_ops :
-    public gimple_statement_with_memory_ops_base
+  gimple_with_memory_ops :
+    public gimple_with_memory_ops_base
 {
   /* [ WORD 1-9 ] : base class */
 
@@ -268,7 +268,7 @@ struct GTY((tag("GSS_WITH_MEM_OPS")))
 /* Call statements that take both memory and register operands.  */
 
 struct GTY((tag("GSS_CALL")))
-  gimple_statement_call : public gimple_statement_with_memory_ops_base
+  gcall : public gimple_with_memory_ops_base
 {
   /* [ WORD 1-9 ] : base class */
 
@@ -293,7 +293,7 @@ struct GTY((tag("GSS_CALL")))
 /* OpenMP statements (#pragma omp).  */
 
 struct GTY((tag("GSS_OMP")))
-  gimple_statement_omp : public gimple_statement_base
+  gomp : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -305,7 +305,7 @@ struct GTY((tag("GSS_OMP")))
 /* GIMPLE_BIND */
 
 struct GTY((tag("GSS_BIND")))
-  gimple_statement_bind : public gimple_statement_base
+  gbind : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -314,7 +314,7 @@ struct GTY((tag("GSS_BIND")))
   tree vars;
 
   /* [ WORD 8 ]
-     This is different than the BLOCK field in gimple_statement_base,
+     This is different than the BLOCK field in gimple,
      which is analogous to TREE_BLOCK (i.e., the lexical block holding
      this statement).  This field is the equivalent of BIND_EXPR_BLOCK
      in tree land (i.e., the lexical scope defined by this bind).  See
@@ -329,7 +329,7 @@ struct GTY((tag("GSS_BIND")))
 /* GIMPLE_CATCH */
 
 struct GTY((tag("GSS_CATCH")))
-  gimple_statement_catch : public gimple_statement_base
+  gcatch : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -344,7 +344,7 @@ struct GTY((tag("GSS_CATCH")))
 /* GIMPLE_EH_FILTER */
 
 struct GTY((tag("GSS_EH_FILTER")))
-  gimple_statement_eh_filter : public gimple_statement_base
+  geh_filter : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -360,7 +360,7 @@ struct GTY((tag("GSS_EH_FILTER")))
 /* GIMPLE_EH_ELSE */
 
 struct GTY((tag("GSS_EH_ELSE")))
-  gimple_statement_eh_else : public gimple_statement_base
+  geh_else : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -371,7 +371,7 @@ struct GTY((tag("GSS_EH_ELSE")))
 /* GIMPLE_EH_MUST_NOT_THROW */
 
 struct GTY((tag("GSS_EH_MNT")))
-  gimple_statement_eh_mnt : public gimple_statement_base
+  geh_mnt : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -382,7 +382,7 @@ struct GTY((tag("GSS_EH_MNT")))
 /* GIMPLE_PHI */
 
 struct GTY((tag("GSS_PHI")))
-  gimple_statement_phi : public gimple_statement_base
+  gphi : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -401,7 +401,7 @@ struct GTY((tag("GSS_PHI")))
 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
 
 struct GTY((tag("GSS_EH_CTRL")))
-  gimple_statement_eh_ctrl : public gimple_statement_base
+  geh_ctrl : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -411,14 +411,14 @@ struct GTY((tag("GSS_EH_CTRL")))
 };
 
 struct GTY((tag("GSS_EH_CTRL")))
-  gimple_statement_resx : public gimple_statement_eh_ctrl
+  gresx : public geh_ctrl
 {
   /* No extra fields; adds invariant:
        stmt->code == GIMPLE_RESX.  */
 };
 
 struct GTY((tag("GSS_EH_CTRL")))
-  gimple_statement_eh_dispatch : public gimple_statement_eh_ctrl
+  geh_dispatch : public geh_ctrl
 {
   /* No extra fields; adds invariant:
        stmt->code == GIMPLE_EH_DISPATH.  */
@@ -428,7 +428,7 @@ struct GTY((tag("GSS_EH_CTRL")))
 /* GIMPLE_TRY */
 
 struct GTY((tag("GSS_TRY")))
-  gimple_statement_try : public gimple_statement_base
+  gtry : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -458,7 +458,7 @@ enum gimple_try_flags
 /* GIMPLE_WITH_CLEANUP_EXPR */
 
 struct GTY((tag("GSS_WCE")))
-  gimple_statement_wce : public gimple_statement_base
+  gwce : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -476,7 +476,7 @@ struct GTY((tag("GSS_WCE")))
 /* GIMPLE_ASM  */
 
 struct GTY((tag("GSS_ASM")))
-  gimple_statement_asm : public gimple_statement_with_memory_ops_base
+  gasm : public gimple_with_memory_ops_base
 {
   /* [ WORD 1-9 ] : base class */
 
@@ -501,7 +501,7 @@ struct GTY((tag("GSS_ASM")))
 /* GIMPLE_OMP_CRITICAL */
 
 struct GTY((tag("GSS_OMP_CRITICAL")))
-  gimple_statement_omp_critical : public gimple_statement_omp
+  gomp_critical : public gomp
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -531,7 +531,7 @@ struct GTY(()) gimple_omp_for_iter {
 /* GIMPLE_OMP_FOR */
 
 struct GTY((tag("GSS_OMP_FOR")))
-  gimple_statement_omp_for : public gimple_statement_omp
+  gomp_for : public gomp
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -553,7 +553,7 @@ struct GTY((tag("GSS_OMP_FOR")))
 
 /* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET */
 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
-  gimple_statement_omp_parallel_layout : public gimple_statement_omp
+  gomp_parallel_layout : public gomp
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -572,7 +572,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
 
 /* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
-  gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
+  gomp_taskreg : public gomp_parallel_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_PARALLEL
@@ -582,14 +582,14 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
 
 /* GIMPLE_OMP_PARALLEL */
 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
-  gimple_statement_omp_parallel : public gimple_statement_omp_taskreg
+  gomp_parallel : public gomp_taskreg
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_PARALLEL.  */
 };
 
 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
-  gimple_statement_omp_target : public gimple_statement_omp_parallel_layout
+  gomp_target : public gomp_parallel_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_TARGET.  */
@@ -598,7 +598,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
 /* GIMPLE_OMP_TASK */
 
 struct GTY((tag("GSS_OMP_TASK")))
-  gimple_statement_omp_task : public gimple_statement_omp_taskreg
+  gomp_task : public gomp_taskreg
 {
   /* [ WORD 1-10 ] : base class */
 
@@ -614,13 +614,13 @@ struct GTY((tag("GSS_OMP_TASK")))
 
 
 /* GIMPLE_OMP_SECTION */
-/* Uses struct gimple_statement_omp.  */
+/* Uses struct gimple_omp.  */
 
 
 /* GIMPLE_OMP_SECTIONS */
 
 struct GTY((tag("GSS_OMP_SECTIONS")))
-  gimple_statement_omp_sections : public gimple_statement_omp
+  gomp_sections : public gomp
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -635,11 +635,11 @@ struct GTY((tag("GSS_OMP_SECTIONS")))
 
 /* GIMPLE_OMP_CONTINUE.
 
-   Note: This does not inherit from gimple_statement_omp, because we
+   Note: This does not inherit from gomp, because we
          do not need the body field.  */
 
 struct GTY((tag("GSS_OMP_CONTINUE")))
-  gimple_statement_omp_continue : public gimple_statement_base
+  gomp_continue : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -653,7 +653,7 @@ struct GTY((tag("GSS_OMP_CONTINUE")))
 /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_TEAMS */
 
 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
-  gimple_statement_omp_single_layout : public gimple_statement_omp
+  gomp_single_layout : public gomp
 {
   /* [ WORD 1-7 ] : base class */
 
@@ -662,14 +662,14 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
 };
 
 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
-  gimple_statement_omp_single : public gimple_statement_omp_single_layout
+  gomp_single : public gomp_single_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_SINGLE.  */
 };
 
 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
-  gimple_statement_omp_teams : public gimple_statement_omp_single_layout
+  gomp_teams : public gomp_single_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_TEAMS.  */
@@ -677,11 +677,11 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
 
 
 /* GIMPLE_OMP_ATOMIC_LOAD.
-   Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
+   Note: This is based on gimple, not gomp, because gomp
    contains a sequence, which we don't need here.  */
 
 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
-  gimple_statement_omp_atomic_load : public gimple_statement_base
+  gomp_atomic_load : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -693,7 +693,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
    See note on GIMPLE_OMP_ATOMIC_LOAD.  */
 
 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
-  gimple_statement_omp_atomic_store_layout : public gimple_statement_base
+  gomp_atomic_store_layout : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -702,16 +702,16 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
 };
 
 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
-  gimple_statement_omp_atomic_store :
-    public gimple_statement_omp_atomic_store_layout
+  gomp_atomic_store :
+    public gomp_atomic_store_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_ATOMIC_STORE.  */
 };
 
 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
-  gimple_statement_omp_return :
-    public gimple_statement_omp_atomic_store_layout
+  gomp_return :
+    public gomp_atomic_store_layout
 {
     /* No extra fields; adds invariant:
          stmt->code == GIMPLE_OMP_RETURN.  */
@@ -746,7 +746,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
 #define GTMA_HAS_NO_INSTRUMENTATION	(1u << 7)
 
 struct GTY((tag("GSS_TRANSACTION")))
-  gimple_statement_transaction : public gimple_statement_with_memory_ops_base
+  gtransaction : public gimple_with_memory_ops_base
 {
   /* [ WORD 1-9 ] : base class */
 
@@ -767,7 +767,7 @@ enum gimple_statement_structure_enum {
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_asm *>::test (gimple gs)
+is_a_helper <gasm *>::test (gimple gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -775,7 +775,7 @@ is_a_helper <gimple_statement_asm *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_bind *>::test (gimple gs)
+is_a_helper <gbind *>::test (gimple gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -783,7 +783,7 @@ is_a_helper <gimple_statement_bind *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_call *>::test (gimple gs)
+is_a_helper <gcall *>::test (gimple gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -791,7 +791,7 @@ is_a_helper <gimple_statement_call *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_catch *>::test (gimple gs)
+is_a_helper <gcatch *>::test (gimple gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -799,7 +799,7 @@ is_a_helper <gimple_statement_catch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_resx *>::test (gimple gs)
+is_a_helper <gresx *>::test (gimple gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -807,7 +807,7 @@ is_a_helper <gimple_statement_resx *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
+is_a_helper <geh_dispatch *>::test (gimple gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -815,7 +815,7 @@ is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
+is_a_helper <geh_else *>::test (gimple gs)
 {
   return gs->code == GIMPLE_EH_ELSE;
 }
@@ -823,7 +823,7 @@ is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
+is_a_helper <geh_filter *>::test (gimple gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -831,7 +831,7 @@ is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
+is_a_helper <geh_mnt *>::test (gimple gs)
 {
   return gs->code == GIMPLE_EH_MUST_NOT_THROW;
 }
@@ -839,7 +839,7 @@ is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
+is_a_helper <gomp_atomic_load *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -847,7 +847,7 @@ is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
+is_a_helper <gomp_atomic_store *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -855,7 +855,7 @@ is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
+is_a_helper <gomp_return *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -863,7 +863,7 @@ is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
+is_a_helper <gomp_continue *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -871,7 +871,7 @@ is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
+is_a_helper <gomp_critical *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -879,7 +879,7 @@ is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
+is_a_helper <gomp_for *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -887,7 +887,7 @@ is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
+is_a_helper <gomp_taskreg *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -895,7 +895,7 @@ is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
+is_a_helper <gomp_parallel *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -903,7 +903,7 @@ is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
+is_a_helper <gomp_target *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -911,7 +911,7 @@ is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
+is_a_helper <gomp_sections *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -919,7 +919,7 @@ is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
+is_a_helper <gomp_single *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -927,7 +927,7 @@ is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
+is_a_helper <gomp_teams *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -935,7 +935,7 @@ is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
+is_a_helper <gomp_task *>::test (gimple gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -943,7 +943,7 @@ is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_phi *>::test (gimple gs)
+is_a_helper <gphi *>::test (gimple gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -951,7 +951,7 @@ is_a_helper <gimple_statement_phi *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_transaction *>::test (gimple gs)
+is_a_helper <gtransaction *>::test (gimple gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -959,7 +959,7 @@ is_a_helper <gimple_statement_transaction *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_try *>::test (gimple gs)
+is_a_helper <gtry *>::test (gimple gs)
 {
   return gs->code == GIMPLE_TRY;
 }
@@ -967,7 +967,7 @@ is_a_helper <gimple_statement_try *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_wce *>::test (gimple gs)
+is_a_helper <gwce *>::test (gimple gs)
 {
   return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
 }
@@ -975,7 +975,7 @@ is_a_helper <gimple_statement_wce *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
+is_a_helper <const gasm *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -983,7 +983,7 @@ is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
+is_a_helper <const gbind *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -991,7 +991,7 @@ is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
+is_a_helper <const gcall *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -999,7 +999,7 @@ is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
+is_a_helper <const gcatch *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -1007,7 +1007,7 @@ is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
+is_a_helper <const gresx *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -1015,7 +1015,7 @@ is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
+is_a_helper <const geh_dispatch *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -1023,7 +1023,7 @@ is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
+is_a_helper <const geh_filter *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -1031,7 +1031,7 @@ is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -1039,7 +1039,7 @@ is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -1047,7 +1047,7 @@ is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
+is_a_helper <const gomp_return *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -1055,7 +1055,7 @@ is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
+is_a_helper <const gomp_continue *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -1063,7 +1063,7 @@ is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
+is_a_helper <const gomp_critical *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -1071,7 +1071,7 @@ is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
+is_a_helper <const gomp_for *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -1079,7 +1079,7 @@ is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
+is_a_helper <const gomp_taskreg *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -1087,7 +1087,7 @@ is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
+is_a_helper <const gomp_parallel *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -1095,7 +1095,7 @@ is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
+is_a_helper <const gomp_target *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -1103,7 +1103,7 @@ is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
+is_a_helper <const gomp_sections *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -1111,7 +1111,7 @@ is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
+is_a_helper <const gomp_single *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -1119,7 +1119,7 @@ is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
+is_a_helper <const gomp_teams *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -1127,7 +1127,7 @@ is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
+is_a_helper <const gomp_task *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -1135,7 +1135,7 @@ is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
+is_a_helper <const gphi *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -1143,7 +1143,7 @@ is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_transaction *>::test (const_gimple gs)
+is_a_helper <const gtransaction *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -1189,8 +1189,8 @@ gimple gimple_build_catch (tree, gimple_seq);
 gimple gimple_build_eh_filter (tree, gimple_seq);
 gimple gimple_build_eh_must_not_throw (tree);
 gimple gimple_build_eh_else (gimple_seq, gimple_seq);
-gimple_statement_try *gimple_build_try (gimple_seq, gimple_seq,
-					enum gimple_try_flags);
+gtry *gimple_build_try (gimple_seq, gimple_seq,
+			enum gimple_try_flags);
 gimple gimple_build_wce (gimple_seq);
 gimple gimple_build_resx (int);
 gimple gimple_build_switch_nlabels (unsigned, tree, tree);
@@ -1647,7 +1647,7 @@ gimple_has_ops (const_gimple g)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_ops *>::test (const_gimple gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1655,7 +1655,7 @@ is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_with_ops *>::test (gimple gs)
+is_a_helper <gimple_with_ops *>::test (gimple gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1671,7 +1671,7 @@ gimple_has_mem_ops (const_gimple g)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_memory_ops *>::test (const_gimple gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1679,7 +1679,7 @@ is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
+is_a_helper <gimple_with_memory_ops *>::test (gimple gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1689,8 +1689,7 @@ is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
 static inline struct use_optype_d *
 gimple_use_ops (const_gimple g)
 {
-  const gimple_statement_with_ops *ops_stmt =
-    dyn_cast <const gimple_statement_with_ops *> (g);
+  const gimple_with_ops *ops_stmt = dyn_cast <const gimple_with_ops *> (g);
   if (!ops_stmt)
     return NULL;
   return ops_stmt->use_ops;
@@ -1702,8 +1701,7 @@ gimple_use_ops (const_gimple g)
 static inline void
 gimple_set_use_ops (gimple g, struct use_optype_d *use)
 {
-  gimple_statement_with_ops *ops_stmt =
-    as_a <gimple_statement_with_ops *> (g);
+  gimple_with_ops *ops_stmt = as_a <gimple_with_ops *> (g);
   ops_stmt->use_ops = use;
 }
 
@@ -1713,8 +1711,8 @@ gimple_set_use_ops (gimple g, struct use_optype_d *use)
 static inline tree
 gimple_vuse (const_gimple g)
 {
-  const gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <const gimple_statement_with_memory_ops *> (g);
+  const gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <const gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_TREE;
   return mem_ops_stmt->vuse;
@@ -1725,8 +1723,8 @@ gimple_vuse (const_gimple g)
 static inline tree
 gimple_vdef (const_gimple g)
 {
-  const gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <const gimple_statement_with_memory_ops *> (g);
+  const gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <const gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_TREE;
   return mem_ops_stmt->vdef;
@@ -1737,8 +1735,8 @@ gimple_vdef (const_gimple g)
 static inline tree *
 gimple_vuse_ptr (gimple g)
 {
-  gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <gimple_statement_with_memory_ops *> (g);
+  gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL;
   return &mem_ops_stmt->vuse;
@@ -1749,8 +1747,8 @@ gimple_vuse_ptr (gimple g)
 static inline tree *
 gimple_vdef_ptr (gimple g)
 {
-  gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <gimple_statement_with_memory_ops *> (g);
+  gimple_with_memory_ops *mem_ops_stmt =
+     dyn_cast <gimple_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL;
   return &mem_ops_stmt->vdef;
@@ -1761,8 +1759,8 @@ gimple_vdef_ptr (gimple g)
 static inline void
 gimple_set_vuse (gimple g, tree vuse)
 {
-  gimple_statement_with_memory_ops *mem_ops_stmt =
-    as_a <gimple_statement_with_memory_ops *> (g);
+  gimple_with_memory_ops *mem_ops_stmt =
+    as_a <gimple_with_memory_ops *> (g);
   mem_ops_stmt->vuse = vuse;
 }
 
@@ -1771,8 +1769,8 @@ gimple_set_vuse (gimple g, tree vuse)
 static inline void
 gimple_set_vdef (gimple g, tree vdef)
 {
-  gimple_statement_with_memory_ops *mem_ops_stmt =
-    as_a <gimple_statement_with_memory_ops *> (g);
+  gimple_with_memory_ops *mem_ops_stmt =
+    as_a <gimple_with_memory_ops *> (g);
   mem_ops_stmt->vdef = vdef;
 }
 
@@ -1903,8 +1901,7 @@ gimple_omp_return_nowait_p (const_gimple g)
 static inline void
 gimple_omp_return_set_lhs (gimple g, tree lhs)
 {
-  gimple_statement_omp_return *omp_return_stmt =
-    as_a <gimple_statement_omp_return *> (g);
+  gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
   omp_return_stmt->val = lhs;
 }
 
@@ -1914,8 +1911,7 @@ gimple_omp_return_set_lhs (gimple g, tree lhs)
 static inline tree
 gimple_omp_return_lhs (const_gimple g)
 {
-  const gimple_statement_omp_return *omp_return_stmt =
-    as_a <const gimple_statement_omp_return *> (g);
+  const gomp_return *omp_return_stmt = as_a <const gomp_return *> (g);
   return omp_return_stmt->val;
 }
 
@@ -1925,8 +1921,7 @@ gimple_omp_return_lhs (const_gimple g)
 static inline tree *
 gimple_omp_return_lhs_ptr (gimple g)
 {
-  gimple_statement_omp_return *omp_return_stmt =
-    as_a <gimple_statement_omp_return *> (g);
+  gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
   return &omp_return_stmt->val;
 }
 
@@ -2444,7 +2439,7 @@ static inline enum internal_fn
 gimple_call_internal_fn (const_gimple gs)
 {
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
-  return static_cast <const gimple_statement_call *> (gs)->u.internal_fn;
+  return static_cast <const gcall *> (gs)->u.internal_fn;
 }
 
 
@@ -2453,8 +2448,8 @@ gimple_call_internal_fn (const_gimple gs)
 static inline tree
 gimple_call_fntype (const_gimple gs)
 {
-  const gimple_statement_call *call_stmt =
-    as_a <const gimple_statement_call *> (gs);
+  const gcall *call_stmt =
+    as_a <const gcall *> (gs);
   if (gimple_call_internal_p (gs))
     return NULL_TREE;
   return call_stmt->u.fntype;
@@ -2465,7 +2460,7 @@ gimple_call_fntype (const_gimple gs)
 static inline void
 gimple_call_set_fntype (gimple gs, tree fntype)
 {
-  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+  gcall *call_stmt = as_a <gcall *> (gs);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
   call_stmt->u.fntype = fntype;
 }
@@ -2519,7 +2514,7 @@ gimple_call_set_fndecl (gimple gs, tree decl)
 static inline void
 gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
 {
-  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+  gcall *call_stmt = as_a <gcall *> (gs);
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
   call_stmt->u.internal_fn = fn;
 }
@@ -2797,7 +2792,7 @@ gimple_call_copy_flags (gimple dest_call, gimple orig_call)
 static inline struct pt_solution *
 gimple_call_use_set (gimple call)
 {
-  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+  gcall *call_stmt = as_a <gcall *> (call);
   return &call_stmt->call_used;
 }
 
@@ -2808,7 +2803,7 @@ gimple_call_use_set (gimple call)
 static inline struct pt_solution *
 gimple_call_clobber_set (gimple call)
 {
-  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+  gcall *call_stmt = as_a <gcall *> (call);
   return &call_stmt->call_clobbered;
 }
 
@@ -3077,8 +3072,7 @@ gimple_goto_set_dest (gimple gs, tree dest)
 static inline tree
 gimple_bind_vars (const_gimple gs)
 {
-  const gimple_statement_bind *bind_stmt =
-    as_a <const gimple_statement_bind *> (gs);
+  const gbind *bind_stmt = as_a <const gbind *> (gs);
   return bind_stmt->vars;
 }
 
@@ -3089,7 +3083,7 @@ gimple_bind_vars (const_gimple gs)
 static inline void
 gimple_bind_set_vars (gimple gs, tree vars)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->vars = vars;
 }
 
@@ -3100,7 +3094,7 @@ gimple_bind_set_vars (gimple gs, tree vars)
 static inline void
 gimple_bind_append_vars (gimple gs, tree vars)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->vars = chainon (bind_stmt->vars, vars);
 }
 
@@ -3108,7 +3102,7 @@ gimple_bind_append_vars (gimple gs, tree vars)
 static inline gimple_seq *
 gimple_bind_body_ptr (gimple gs)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   return &bind_stmt->body;
 }
 
@@ -3127,7 +3121,7 @@ gimple_bind_body (gimple gs)
 static inline void
 gimple_bind_set_body (gimple gs, gimple_seq seq)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->body = seq;
 }
 
@@ -3137,7 +3131,7 @@ gimple_bind_set_body (gimple gs, gimple_seq seq)
 static inline void
 gimple_bind_add_stmt (gimple gs, gimple stmt)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   gimple_seq_add_stmt (&bind_stmt->body, stmt);
 }
 
@@ -3147,7 +3141,7 @@ gimple_bind_add_stmt (gimple gs, gimple stmt)
 static inline void
 gimple_bind_add_seq (gimple gs, gimple_seq seq)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   gimple_seq_add_seq (&bind_stmt->body, seq);
 }
 
@@ -3158,8 +3152,7 @@ gimple_bind_add_seq (gimple gs, gimple_seq seq)
 static inline tree
 gimple_bind_block (const_gimple gs)
 {
-  const gimple_statement_bind *bind_stmt =
-    as_a <const gimple_statement_bind *> (gs);
+  const gbind *bind_stmt = as_a <const gbind *> (gs);
   return bind_stmt->block;
 }
 
@@ -3170,7 +3163,7 @@ gimple_bind_block (const_gimple gs)
 static inline void
 gimple_bind_set_block (gimple gs, tree block)
 {
-  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+  gbind *bind_stmt = as_a <gbind *> (gs);
   gcc_gimple_checking_assert (block == NULL_TREE
 			      || TREE_CODE (block) == BLOCK);
   bind_stmt->block = block;
@@ -3182,8 +3175,7 @@ gimple_bind_set_block (gimple gs, tree block)
 static inline unsigned
 gimple_asm_ninputs (const_gimple gs)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->ni;
 }
 
@@ -3193,8 +3185,7 @@ gimple_asm_ninputs (const_gimple gs)
 static inline unsigned
 gimple_asm_noutputs (const_gimple gs)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->no;
 }
 
@@ -3204,8 +3195,7 @@ gimple_asm_noutputs (const_gimple gs)
 static inline unsigned
 gimple_asm_nclobbers (const_gimple gs)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->nc;
 }
 
@@ -3214,8 +3204,7 @@ gimple_asm_nclobbers (const_gimple gs)
 static inline unsigned
 gimple_asm_nlabels (const_gimple gs)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->nl;
 }
 
@@ -3224,8 +3213,7 @@ gimple_asm_nlabels (const_gimple gs)
 static inline tree
 gimple_asm_input_op (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
   return gimple_op (gs, index + asm_stmt->no);
 }
@@ -3235,8 +3223,7 @@ gimple_asm_input_op (const_gimple gs, unsigned index)
 static inline tree *
 gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
   return gimple_op_ptr (gs, index + asm_stmt->no);
 }
@@ -3247,7 +3234,7 @@ gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
 static inline void
 gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
 {
-  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+  gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni
 			      && TREE_CODE (in_op) == TREE_LIST);
   gimple_set_op (gs, index + asm_stmt->no, in_op);
@@ -3259,8 +3246,7 @@ gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
 static inline tree
 gimple_asm_output_op (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
   return gimple_op (gs, index);
 }
@@ -3270,8 +3256,7 @@ gimple_asm_output_op (const_gimple gs, unsigned index)
 static inline tree *
 gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
   return gimple_op_ptr (gs, index);
 }
@@ -3282,7 +3267,7 @@ gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
 static inline void
 gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
 {
-  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+  gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no
 			      && TREE_CODE (out_op) == TREE_LIST);
   gimple_set_op (gs, index, out_op);
@@ -3294,8 +3279,7 @@ gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
 static inline tree
 gimple_asm_clobber_op (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nc);
   return gimple_op (gs, index + asm_stmt->ni + asm_stmt->no);
 }
@@ -3306,7 +3290,7 @@ gimple_asm_clobber_op (const_gimple gs, unsigned index)
 static inline void
 gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
 {
-  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+  gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nc
 			      && TREE_CODE (clobber_op) == TREE_LIST);
   gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->no, clobber_op);
@@ -3317,8 +3301,7 @@ gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
 static inline tree
 gimple_asm_label_op (const_gimple gs, unsigned index)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nl);
   return gimple_op (gs, index + asm_stmt->ni + asm_stmt->nc);
 }
@@ -3328,7 +3311,7 @@ gimple_asm_label_op (const_gimple gs, unsigned index)
 static inline void
 gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
 {
-  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+  gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nl
 			      && TREE_CODE (label_op) == TREE_LIST);
   gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->nc, label_op);
@@ -3340,8 +3323,7 @@ gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
 static inline const char *
 gimple_asm_string (const_gimple gs)
 {
-  const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm *> (gs);
+  const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->string;
 }
 
@@ -3397,8 +3379,7 @@ gimple_asm_input_p (const_gimple gs)
 static inline tree
 gimple_catch_types (const_gimple gs)
 {
-  const gimple_statement_catch *catch_stmt =
-    as_a <const gimple_statement_catch *> (gs);
+  const gcatch *catch_stmt = as_a <const gcatch *> (gs);
   return catch_stmt->types;
 }
 
@@ -3408,7 +3389,7 @@ gimple_catch_types (const_gimple gs)
 static inline tree *
 gimple_catch_types_ptr (gimple gs)
 {
-  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+  gcatch *catch_stmt = as_a <gcatch *> (gs);
   return &catch_stmt->types;
 }
 
@@ -3419,7 +3400,7 @@ gimple_catch_types_ptr (gimple gs)
 static inline gimple_seq *
 gimple_catch_handler_ptr (gimple gs)
 {
-  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+  gcatch *catch_stmt = as_a <gcatch *> (gs);
   return &catch_stmt->handler;
 }
 
@@ -3439,7 +3420,7 @@ gimple_catch_handler (gimple gs)
 static inline void
 gimple_catch_set_types (gimple gs, tree t)
 {
-  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+  gcatch *catch_stmt = as_a <gcatch *> (gs);
   catch_stmt->types = t;
 }
 
@@ -3449,7 +3430,7 @@ gimple_catch_set_types (gimple gs, tree t)
 static inline void
 gimple_catch_set_handler (gimple gs, gimple_seq handler)
 {
-  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+  gcatch *catch_stmt = as_a <gcatch *> (gs);
   catch_stmt->handler = handler;
 }
 
@@ -3459,8 +3440,7 @@ gimple_catch_set_handler (gimple gs, gimple_seq handler)
 static inline tree
 gimple_eh_filter_types (const_gimple gs)
 {
-  const gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <const gimple_statement_eh_filter *> (gs);
+  const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
   return eh_filter_stmt->types;
 }
 
@@ -3471,8 +3451,7 @@ gimple_eh_filter_types (const_gimple gs)
 static inline tree *
 gimple_eh_filter_types_ptr (gimple gs)
 {
-  gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <gimple_statement_eh_filter *> (gs);
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->types;
 }
 
@@ -3483,8 +3462,7 @@ gimple_eh_filter_types_ptr (gimple gs)
 static inline gimple_seq *
 gimple_eh_filter_failure_ptr (gimple gs)
 {
-  gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <gimple_statement_eh_filter *> (gs);
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->failure;
 }
 
@@ -3504,8 +3482,7 @@ gimple_eh_filter_failure (gimple gs)
 static inline void
 gimple_eh_filter_set_types (gimple gs, tree types)
 {
-  gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <gimple_statement_eh_filter *> (gs);
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   eh_filter_stmt->types = types;
 }
 
@@ -3516,8 +3493,7 @@ gimple_eh_filter_set_types (gimple gs, tree types)
 static inline void
 gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
 {
-  gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <gimple_statement_eh_filter *> (gs);
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   eh_filter_stmt->failure = failure;
 }
 
@@ -3526,7 +3502,7 @@ gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
 static inline tree
 gimple_eh_must_not_throw_fndecl (gimple gs)
 {
-  gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+  geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
   return eh_mnt_stmt->fndecl;
 }
 
@@ -3535,7 +3511,7 @@ gimple_eh_must_not_throw_fndecl (gimple gs)
 static inline void
 gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
 {
-  gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+  geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
   eh_mnt_stmt->fndecl = decl;
 }
 
@@ -3544,8 +3520,7 @@ gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
 static inline gimple_seq *
 gimple_eh_else_n_body_ptr (gimple gs)
 {
-  gimple_statement_eh_else *eh_else_stmt =
-    as_a <gimple_statement_eh_else *> (gs);
+  geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   return &eh_else_stmt->n_body;
 }
 
@@ -3558,8 +3533,7 @@ gimple_eh_else_n_body (gimple gs)
 static inline gimple_seq *
 gimple_eh_else_e_body_ptr (gimple gs)
 {
-  gimple_statement_eh_else *eh_else_stmt =
-    as_a <gimple_statement_eh_else *> (gs);
+  geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   return &eh_else_stmt->e_body;
 }
 
@@ -3572,16 +3546,14 @@ gimple_eh_else_e_body (gimple gs)
 static inline void
 gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
 {
-  gimple_statement_eh_else *eh_else_stmt =
-    as_a <gimple_statement_eh_else *> (gs);
+  geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   eh_else_stmt->n_body = seq;
 }
 
 static inline void
 gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
 {
-  gimple_statement_eh_else *eh_else_stmt =
-    as_a <gimple_statement_eh_else *> (gs);
+  geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   eh_else_stmt->e_body = seq;
 }
 
@@ -3627,7 +3599,7 @@ gimple_try_catch_is_cleanup (const_gimple gs)
 static inline gimple_seq *
 gimple_try_eval_ptr (gimple gs)
 {
-  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+  gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->eval;
 }
 
@@ -3647,7 +3619,7 @@ gimple_try_eval (gimple gs)
 static inline gimple_seq *
 gimple_try_cleanup_ptr (gimple gs)
 {
-  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+  gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->cleanup;
 }
 
@@ -3681,7 +3653,7 @@ gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
 static inline void
 gimple_try_set_eval (gimple gs, gimple_seq eval)
 {
-  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+  gtry *try_stmt = as_a <gtry *> (gs);
   try_stmt->eval = eval;
 }
 
@@ -3692,7 +3664,7 @@ gimple_try_set_eval (gimple gs, gimple_seq eval)
 static inline void
 gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
 {
-  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+  gtry *try_stmt = as_a <gtry *> (gs);
   try_stmt->cleanup = cleanup;
 }
 
@@ -3702,7 +3674,7 @@ gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
 static inline gimple_seq *
 gimple_wce_cleanup_ptr (gimple gs)
 {
-  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+  gwce *wce_stmt = as_a <gwce *> (gs);
   return &wce_stmt->cleanup;
 }
 
@@ -3721,7 +3693,7 @@ gimple_wce_cleanup (gimple gs)
 static inline void
 gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
 {
-  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+  gwce *wce_stmt = as_a <gwce *> (gs);
   wce_stmt->cleanup = cleanup;
 }
 
@@ -3751,8 +3723,7 @@ gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
 static inline unsigned
 gimple_phi_capacity (const_gimple gs)
 {
-  const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi *> (gs);
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->capacity;
 }
 
@@ -3764,8 +3735,7 @@ gimple_phi_capacity (const_gimple gs)
 static inline unsigned
 gimple_phi_num_args (const_gimple gs)
 {
-  const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi *> (gs);
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->nargs;
 }
 
@@ -3775,8 +3745,7 @@ gimple_phi_num_args (const_gimple gs)
 static inline tree
 gimple_phi_result (const_gimple gs)
 {
-  const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi *> (gs);
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->result;
 }
 
@@ -3785,7 +3754,7 @@ gimple_phi_result (const_gimple gs)
 static inline tree *
 gimple_phi_result_ptr (gimple gs)
 {
-  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+  gphi *phi_stmt = as_a <gphi *> (gs);
   return &phi_stmt->result;
 }
 
@@ -3794,7 +3763,7 @@ gimple_phi_result_ptr (gimple gs)
 static inline void
 gimple_phi_set_result (gimple gs, tree result)
 {
-  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+  gphi *phi_stmt = as_a <gphi *> (gs);
   phi_stmt->result = result;
   if (result && TREE_CODE (result) == SSA_NAME)
     SSA_NAME_DEF_STMT (result) = gs;
@@ -3807,7 +3776,7 @@ gimple_phi_set_result (gimple gs, tree result)
 static inline struct phi_arg_d *
 gimple_phi_arg (gimple gs, unsigned index)
 {
-  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+  gphi *phi_stmt = as_a <gphi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->capacity);
   return &(phi_stmt->args[index]);
 }
@@ -3818,7 +3787,7 @@ gimple_phi_arg (gimple gs, unsigned index)
 static inline void
 gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
 {
-  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+  gphi *phi_stmt = as_a <gphi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->nargs);
   phi_stmt->args[index] = *phiarg;
 }
@@ -3905,8 +3874,7 @@ gimple_phi_arg_has_location (gimple gs, size_t i)
 static inline int
 gimple_resx_region (const_gimple gs)
 {
-  const gimple_statement_resx *resx_stmt =
-    as_a <const gimple_statement_resx *> (gs);
+  const gresx *resx_stmt = as_a <const gresx *> (gs);
   return resx_stmt->region;
 }
 
@@ -3915,7 +3883,7 @@ gimple_resx_region (const_gimple gs)
 static inline void
 gimple_resx_set_region (gimple gs, int region)
 {
-  gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx *> (gs);
+  gresx *resx_stmt = as_a <gresx *> (gs);
   resx_stmt->region = region;
 }
 
@@ -3924,8 +3892,7 @@ gimple_resx_set_region (gimple gs, int region)
 static inline int
 gimple_eh_dispatch_region (const_gimple gs)
 {
-  const gimple_statement_eh_dispatch *eh_dispatch_stmt =
-    as_a <const gimple_statement_eh_dispatch *> (gs);
+  const geh_dispatch *eh_dispatch_stmt = as_a <const geh_dispatch *> (gs);
   return eh_dispatch_stmt->region;
 }
 
@@ -3934,8 +3901,7 @@ gimple_eh_dispatch_region (const_gimple gs)
 static inline void
 gimple_eh_dispatch_set_region (gimple gs, int region)
 {
-  gimple_statement_eh_dispatch *eh_dispatch_stmt =
-    as_a <gimple_statement_eh_dispatch *> (gs);
+  geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (gs);
   eh_dispatch_stmt->region = region;
 }
 
@@ -4221,7 +4187,7 @@ get_lineno (const_gimple stmt)
 static inline gimple_seq *
 gimple_omp_body_ptr (gimple gs)
 {
-  return &static_cast <gimple_statement_omp *> (gs)->body;
+  return &static_cast <gomp *> (gs)->body;
 }
 
 /* Return the body for the OMP statement GS.  */
@@ -4237,7 +4203,7 @@ gimple_omp_body (gimple gs)
 static inline void
 gimple_omp_set_body (gimple gs, gimple_seq body)
 {
-  static_cast <gimple_statement_omp *> (gs)->body = body;
+  static_cast <gomp *> (gs)->body = body;
 }
 
 
@@ -4246,8 +4212,7 @@ gimple_omp_set_body (gimple gs, gimple_seq body)
 static inline tree
 gimple_omp_critical_name (const_gimple gs)
 {
-  const gimple_statement_omp_critical *omp_critical_stmt =
-    as_a <const gimple_statement_omp_critical *> (gs);
+  const gomp_critical *omp_critical_stmt = as_a <const gomp_critical *> (gs);
   return omp_critical_stmt->name;
 }
 
@@ -4257,8 +4222,7 @@ gimple_omp_critical_name (const_gimple gs)
 static inline tree *
 gimple_omp_critical_name_ptr (gimple gs)
 {
-  gimple_statement_omp_critical *omp_critical_stmt =
-    as_a <gimple_statement_omp_critical *> (gs);
+  gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
   return &omp_critical_stmt->name;
 }
 
@@ -4268,8 +4232,7 @@ gimple_omp_critical_name_ptr (gimple gs)
 static inline void
 gimple_omp_critical_set_name (gimple gs, tree name)
 {
-  gimple_statement_omp_critical *omp_critical_stmt =
-    as_a <gimple_statement_omp_critical *> (gs);
+  gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
   omp_critical_stmt->name = name;
 }
 
@@ -4350,8 +4313,7 @@ gimple_omp_for_set_combined_into_p (gimple g, bool combined_p)
 static inline tree
 gimple_omp_for_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   return omp_for_stmt->clauses;
 }
 
@@ -4361,8 +4323,7 @@ gimple_omp_for_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_for_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->clauses;
 }
 
@@ -4372,8 +4333,7 @@ gimple_omp_for_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_for_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->clauses = clauses;
 }
 
@@ -4383,8 +4343,7 @@ gimple_omp_for_set_clauses (gimple gs, tree clauses)
 static inline size_t
 gimple_omp_for_collapse (gimple gs)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return omp_for_stmt->collapse;
 }
 
@@ -4394,8 +4353,7 @@ gimple_omp_for_collapse (gimple gs)
 static inline tree
 gimple_omp_for_index (const_gimple gs, size_t i)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].index;
 }
@@ -4406,8 +4364,7 @@ gimple_omp_for_index (const_gimple gs, size_t i)
 static inline tree *
 gimple_omp_for_index_ptr (gimple gs, size_t i)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].index;
 }
@@ -4418,8 +4375,7 @@ gimple_omp_for_index_ptr (gimple gs, size_t i)
 static inline void
 gimple_omp_for_set_index (gimple gs, size_t i, tree index)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].index = index;
 }
@@ -4430,8 +4386,7 @@ gimple_omp_for_set_index (gimple gs, size_t i, tree index)
 static inline tree
 gimple_omp_for_initial (const_gimple gs, size_t i)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].initial;
 }
@@ -4442,8 +4397,7 @@ gimple_omp_for_initial (const_gimple gs, size_t i)
 static inline tree *
 gimple_omp_for_initial_ptr (gimple gs, size_t i)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].initial;
 }
@@ -4454,8 +4408,7 @@ gimple_omp_for_initial_ptr (gimple gs, size_t i)
 static inline void
 gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].initial = initial;
 }
@@ -4466,8 +4419,7 @@ gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
 static inline tree
 gimple_omp_for_final (const_gimple gs, size_t i)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].final;
 }
@@ -4478,8 +4430,7 @@ gimple_omp_for_final (const_gimple gs, size_t i)
 static inline tree *
 gimple_omp_for_final_ptr (gimple gs, size_t i)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].final;
 }
@@ -4490,8 +4441,7 @@ gimple_omp_for_final_ptr (gimple gs, size_t i)
 static inline void
 gimple_omp_for_set_final (gimple gs, size_t i, tree final)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].final = final;
 }
@@ -4502,8 +4452,7 @@ gimple_omp_for_set_final (gimple gs, size_t i, tree final)
 static inline tree
 gimple_omp_for_incr (const_gimple gs, size_t i)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].incr;
 }
@@ -4514,8 +4463,7 @@ gimple_omp_for_incr (const_gimple gs, size_t i)
 static inline tree *
 gimple_omp_for_incr_ptr (gimple gs, size_t i)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].incr;
 }
@@ -4526,8 +4474,7 @@ gimple_omp_for_incr_ptr (gimple gs, size_t i)
 static inline void
 gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].incr = incr;
 }
@@ -4539,8 +4486,7 @@ gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
 static inline gimple_seq *
 gimple_omp_for_pre_body_ptr (gimple gs)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->pre_body;
 }
 
@@ -4561,8 +4507,7 @@ gimple_omp_for_pre_body (gimple gs)
 static inline void
 gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->pre_body = pre_body;
 }
 
@@ -4572,8 +4517,8 @@ gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
 static inline tree
 gimple_omp_parallel_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <const gimple_statement_omp_parallel *> (gs);
+  const gomp_parallel *omp_parallel_stmt =
+    as_a <const gomp_parallel *> (gs);
   return omp_parallel_stmt->clauses;
 }
 
@@ -4583,8 +4528,7 @@ gimple_omp_parallel_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_parallel_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->clauses;
 }
 
@@ -4595,8 +4539,7 @@ gimple_omp_parallel_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->clauses = clauses;
 }
 
@@ -4606,8 +4549,8 @@ gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_parallel_child_fn (const_gimple gs)
 {
-  const gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <const gimple_statement_omp_parallel *> (gs);
+  const gomp_parallel *omp_parallel_stmt =
+    as_a <const gomp_parallel *> (gs);
   return omp_parallel_stmt->child_fn;
 }
 
@@ -4617,8 +4560,7 @@ gimple_omp_parallel_child_fn (const_gimple gs)
 static inline tree *
 gimple_omp_parallel_child_fn_ptr (gimple gs)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->child_fn;
 }
 
@@ -4628,8 +4570,7 @@ gimple_omp_parallel_child_fn_ptr (gimple gs)
 static inline void
 gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt =as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->child_fn = child_fn;
 }
 
@@ -4640,8 +4581,8 @@ gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
 static inline tree
 gimple_omp_parallel_data_arg (const_gimple gs)
 {
-  const gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <const gimple_statement_omp_parallel *> (gs);
+  const gomp_parallel *omp_parallel_stmt =
+    as_a <const gomp_parallel *> (gs);
   return omp_parallel_stmt->data_arg;
 }
 
@@ -4651,8 +4592,7 @@ gimple_omp_parallel_data_arg (const_gimple gs)
 static inline tree *
 gimple_omp_parallel_data_arg_ptr (gimple gs)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->data_arg;
 }
 
@@ -4662,8 +4602,7 @@ gimple_omp_parallel_data_arg_ptr (gimple gs)
 static inline void
 gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
 {
-  gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel *> (gs);
+  gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->data_arg = data_arg;
 }
 
@@ -4673,8 +4612,7 @@ gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
 static inline tree
 gimple_omp_task_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->clauses;
 }
 
@@ -4684,8 +4622,7 @@ gimple_omp_task_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_task_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->clauses;
 }
 
@@ -4696,8 +4633,7 @@ gimple_omp_task_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->clauses = clauses;
 }
 
@@ -4707,8 +4643,7 @@ gimple_omp_task_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_task_child_fn (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->child_fn;
 }
 
@@ -4718,8 +4653,7 @@ gimple_omp_task_child_fn (const_gimple gs)
 static inline tree *
 gimple_omp_task_child_fn_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->child_fn;
 }
 
@@ -4729,8 +4663,7 @@ gimple_omp_task_child_fn_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->child_fn = child_fn;
 }
 
@@ -4741,8 +4674,7 @@ gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
 static inline tree
 gimple_omp_task_data_arg (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->data_arg;
 }
 
@@ -4752,8 +4684,7 @@ gimple_omp_task_data_arg (const_gimple gs)
 static inline tree *
 gimple_omp_task_data_arg_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->data_arg;
 }
 
@@ -4763,8 +4694,7 @@ gimple_omp_task_data_arg_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->data_arg = data_arg;
 }
 
@@ -4774,8 +4704,7 @@ gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
 static inline tree
 gimple_omp_taskreg_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <const gimple_statement_omp_taskreg *> (gs);
+  const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->clauses;
 }
 
@@ -4785,8 +4714,7 @@ gimple_omp_taskreg_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_taskreg_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->clauses;
 }
 
@@ -4797,8 +4725,7 @@ gimple_omp_taskreg_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->clauses = clauses;
 }
 
@@ -4808,8 +4735,7 @@ gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_taskreg_child_fn (const_gimple gs)
 {
-  const gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <const gimple_statement_omp_taskreg *> (gs);
+  const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->child_fn;
 }
 
@@ -4819,8 +4745,7 @@ gimple_omp_taskreg_child_fn (const_gimple gs)
 static inline tree *
 gimple_omp_taskreg_child_fn_ptr (gimple gs)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->child_fn;
 }
 
@@ -4830,8 +4755,7 @@ gimple_omp_taskreg_child_fn_ptr (gimple gs)
 static inline void
 gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->child_fn = child_fn;
 }
 
@@ -4842,8 +4766,7 @@ gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
 static inline tree
 gimple_omp_taskreg_data_arg (const_gimple gs)
 {
-  const gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <const gimple_statement_omp_taskreg *> (gs);
+  const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->data_arg;
 }
 
@@ -4853,8 +4776,7 @@ gimple_omp_taskreg_data_arg (const_gimple gs)
 static inline tree *
 gimple_omp_taskreg_data_arg_ptr (gimple gs)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->data_arg;
 }
 
@@ -4864,8 +4786,7 @@ gimple_omp_taskreg_data_arg_ptr (gimple gs)
 static inline void
 gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
 {
-  gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg *> (gs);
+  gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->data_arg = data_arg;
 }
 
@@ -4875,8 +4796,7 @@ gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
 static inline tree
 gimple_omp_task_copy_fn (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->copy_fn;
 }
 
@@ -4886,8 +4806,7 @@ gimple_omp_task_copy_fn (const_gimple gs)
 static inline tree *
 gimple_omp_task_copy_fn_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->copy_fn;
 }
 
@@ -4897,8 +4816,7 @@ gimple_omp_task_copy_fn_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->copy_fn = copy_fn;
 }
 
@@ -4908,8 +4826,7 @@ gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
 static inline tree
 gimple_omp_task_arg_size (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_size;
 }
 
@@ -4919,8 +4836,7 @@ gimple_omp_task_arg_size (const_gimple gs)
 static inline tree *
 gimple_omp_task_arg_size_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_size;
 }
 
@@ -4930,8 +4846,7 @@ gimple_omp_task_arg_size_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_size = arg_size;
 }
 
@@ -4941,8 +4856,7 @@ gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
 static inline tree
 gimple_omp_task_arg_align (const_gimple gs)
 {
-  const gimple_statement_omp_task *omp_task_stmt =
-    as_a <const gimple_statement_omp_task *> (gs);
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_align;
 }
 
@@ -4952,8 +4866,7 @@ gimple_omp_task_arg_align (const_gimple gs)
 static inline tree *
 gimple_omp_task_arg_align_ptr (gimple gs)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_align;
 }
 
@@ -4963,8 +4876,7 @@ gimple_omp_task_arg_align_ptr (gimple gs)
 static inline void
 gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
 {
-  gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task *> (gs);
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_align = arg_align;
 }
 
@@ -4974,8 +4886,7 @@ gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
 static inline tree
 gimple_omp_single_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_single *omp_single_stmt =
-    as_a <const gimple_statement_omp_single *> (gs);
+  const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
   return omp_single_stmt->clauses;
 }
 
@@ -4985,8 +4896,7 @@ gimple_omp_single_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_single_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_single *omp_single_stmt =
-    as_a <gimple_statement_omp_single *> (gs);
+  gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
   return &omp_single_stmt->clauses;
 }
 
@@ -4996,8 +4906,7 @@ gimple_omp_single_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_single_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_single *omp_single_stmt =
-    as_a <gimple_statement_omp_single *> (gs);
+  gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
   omp_single_stmt->clauses = clauses;
 }
 
@@ -5007,8 +4916,7 @@ gimple_omp_single_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_target_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_target *omp_target_stmt =
-    as_a <const gimple_statement_omp_target *> (gs);
+  const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->clauses;
 }
 
@@ -5018,8 +4926,7 @@ gimple_omp_target_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_target_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->clauses;
 }
 
@@ -5029,8 +4936,7 @@ gimple_omp_target_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_target_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->clauses = clauses;
 }
 
@@ -5061,8 +4967,7 @@ gimple_omp_target_set_kind (gimple g, int kind)
 static inline tree
 gimple_omp_target_child_fn (const_gimple gs)
 {
-  const gimple_statement_omp_target *omp_target_stmt =
-    as_a <const gimple_statement_omp_target *> (gs);
+  const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->child_fn;
 }
 
@@ -5072,8 +4977,7 @@ gimple_omp_target_child_fn (const_gimple gs)
 static inline tree *
 gimple_omp_target_child_fn_ptr (gimple gs)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->child_fn;
 }
 
@@ -5083,8 +4987,7 @@ gimple_omp_target_child_fn_ptr (gimple gs)
 static inline void
 gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->child_fn = child_fn;
 }
 
@@ -5095,8 +4998,7 @@ gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
 static inline tree
 gimple_omp_target_data_arg (const_gimple gs)
 {
-  const gimple_statement_omp_target *omp_target_stmt =
-    as_a <const gimple_statement_omp_target *> (gs);
+  const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->data_arg;
 }
 
@@ -5106,8 +5008,7 @@ gimple_omp_target_data_arg (const_gimple gs)
 static inline tree *
 gimple_omp_target_data_arg_ptr (gimple gs)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->data_arg;
 }
 
@@ -5117,8 +5018,7 @@ gimple_omp_target_data_arg_ptr (gimple gs)
 static inline void
 gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
 {
-  gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target *> (gs);
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->data_arg = data_arg;
 }
 
@@ -5128,8 +5028,7 @@ gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
 static inline tree
 gimple_omp_teams_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_teams *omp_teams_stmt =
-    as_a <const gimple_statement_omp_teams *> (gs);
+  const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
   return omp_teams_stmt->clauses;
 }
 
@@ -5139,8 +5038,7 @@ gimple_omp_teams_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_teams_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_teams *omp_teams_stmt =
-    as_a <gimple_statement_omp_teams *> (gs);
+  gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
   return &omp_teams_stmt->clauses;
 }
 
@@ -5150,8 +5048,7 @@ gimple_omp_teams_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_teams_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_teams *omp_teams_stmt =
-    as_a <gimple_statement_omp_teams *> (gs);
+  gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
   omp_teams_stmt->clauses = clauses;
 }
 
@@ -5161,8 +5058,8 @@ gimple_omp_teams_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_sections_clauses (const_gimple gs)
 {
-  const gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <const gimple_statement_omp_sections *> (gs);
+  const gomp_sections *omp_sections_stmt =
+    as_a <const gomp_sections *> (gs);
   return omp_sections_stmt->clauses;
 }
 
@@ -5172,8 +5069,7 @@ gimple_omp_sections_clauses (const_gimple gs)
 static inline tree *
 gimple_omp_sections_clauses_ptr (gimple gs)
 {
-  gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections *> (gs);
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->clauses;
 }
 
@@ -5184,8 +5080,7 @@ gimple_omp_sections_clauses_ptr (gimple gs)
 static inline void
 gimple_omp_sections_set_clauses (gimple gs, tree clauses)
 {
-  gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections *> (gs);
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->clauses = clauses;
 }
 
@@ -5196,8 +5091,8 @@ gimple_omp_sections_set_clauses (gimple gs, tree clauses)
 static inline tree
 gimple_omp_sections_control (const_gimple gs)
 {
-  const gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <const gimple_statement_omp_sections *> (gs);
+  const gomp_sections *omp_sections_stmt =
+    as_a <const gomp_sections *> (gs);
   return omp_sections_stmt->control;
 }
 
@@ -5208,8 +5103,7 @@ gimple_omp_sections_control (const_gimple gs)
 static inline tree *
 gimple_omp_sections_control_ptr (gimple gs)
 {
-  gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections *> (gs);
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->control;
 }
 
@@ -5220,8 +5114,7 @@ gimple_omp_sections_control_ptr (gimple gs)
 static inline void
 gimple_omp_sections_set_control (gimple gs, tree control)
 {
-  gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections *> (gs);
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->control = control;
 }
 
@@ -5231,8 +5124,7 @@ gimple_omp_sections_set_control (gimple gs, tree control)
 static inline void
 gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
 {
-  gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for *> (gs);
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
 			      && i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].cond = cond;
@@ -5244,8 +5136,7 @@ gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
 static inline enum tree_code
 gimple_omp_for_cond (const_gimple gs, size_t i)
 {
-  const gimple_statement_omp_for *omp_for_stmt =
-    as_a <const gimple_statement_omp_for *> (gs);
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].cond;
 }
@@ -5256,8 +5147,7 @@ gimple_omp_for_cond (const_gimple gs, size_t i)
 static inline void
 gimple_omp_atomic_store_set_val (gimple g, tree val)
 {
-  gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
-    as_a <gimple_statement_omp_atomic_store *> (g);
+  gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
   omp_atomic_store_stmt->val = val;
 }
 
@@ -5267,8 +5157,8 @@ gimple_omp_atomic_store_set_val (gimple g, tree val)
 static inline tree
 gimple_omp_atomic_store_val (const_gimple g)
 {
-  const gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
-    as_a <const gimple_statement_omp_atomic_store *> (g);
+  const gomp_atomic_store *omp_atomic_store_stmt =
+    as_a <const gomp_atomic_store *> (g);
   return omp_atomic_store_stmt->val;
 }
 
@@ -5278,8 +5168,7 @@ gimple_omp_atomic_store_val (const_gimple g)
 static inline tree *
 gimple_omp_atomic_store_val_ptr (gimple g)
 {
-  gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
-    as_a <gimple_statement_omp_atomic_store *> (g);
+  gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
   return &omp_atomic_store_stmt->val;
 }
 
@@ -5289,8 +5178,7 @@ gimple_omp_atomic_store_val_ptr (gimple g)
 static inline void
 gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
 {
-  gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <gimple_statement_omp_atomic_load *> (g);
+  gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   omp_atomic_load_stmt->lhs = lhs;
 }
 
@@ -5300,8 +5188,8 @@ gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
 static inline tree
 gimple_omp_atomic_load_lhs (const_gimple g)
 {
-  const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <const gimple_statement_omp_atomic_load *> (g);
+  const gomp_atomic_load *omp_atomic_load_stmt =
+    as_a <const gomp_atomic_load *> (g);
   return omp_atomic_load_stmt->lhs;
 }
 
@@ -5311,8 +5199,7 @@ gimple_omp_atomic_load_lhs (const_gimple g)
 static inline tree *
 gimple_omp_atomic_load_lhs_ptr (gimple g)
 {
-  gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <gimple_statement_omp_atomic_load *> (g);
+  gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   return &omp_atomic_load_stmt->lhs;
 }
 
@@ -5322,8 +5209,7 @@ gimple_omp_atomic_load_lhs_ptr (gimple g)
 static inline void
 gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
 {
-  gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <gimple_statement_omp_atomic_load *> (g);
+  gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   omp_atomic_load_stmt->rhs = rhs;
 }
 
@@ -5333,8 +5219,7 @@ gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
 static inline tree
 gimple_omp_atomic_load_rhs (const_gimple g)
 {
-  const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <const gimple_statement_omp_atomic_load *> (g);
+  const gomp_atomic_load *omp_atomic_load_stmt = as_a <const gomp_atomic_load *> (g);
   return omp_atomic_load_stmt->rhs;
 }
 
@@ -5344,8 +5229,7 @@ gimple_omp_atomic_load_rhs (const_gimple g)
 static inline tree *
 gimple_omp_atomic_load_rhs_ptr (gimple g)
 {
-  gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
-    as_a <gimple_statement_omp_atomic_load *> (g);
+  gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   return &omp_atomic_load_stmt->rhs;
 }
 
@@ -5355,8 +5239,7 @@ gimple_omp_atomic_load_rhs_ptr (gimple g)
 static inline tree
 gimple_omp_continue_control_def (const_gimple g)
 {
-  const gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <const gimple_statement_omp_continue *> (g);
+  const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
   return omp_continue_stmt->control_def;
 }
 
@@ -5365,8 +5248,7 @@ gimple_omp_continue_control_def (const_gimple g)
 static inline tree *
 gimple_omp_continue_control_def_ptr (gimple g)
 {
-  gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <gimple_statement_omp_continue *> (g);
+  gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   return &omp_continue_stmt->control_def;
 }
 
@@ -5375,8 +5257,7 @@ gimple_omp_continue_control_def_ptr (gimple g)
 static inline void
 gimple_omp_continue_set_control_def (gimple g, tree def)
 {
-  gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <gimple_statement_omp_continue *> (g);
+  gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   omp_continue_stmt->control_def = def;
 }
 
@@ -5386,8 +5267,7 @@ gimple_omp_continue_set_control_def (gimple g, tree def)
 static inline tree
 gimple_omp_continue_control_use (const_gimple g)
 {
-  const gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <const gimple_statement_omp_continue *> (g);
+  const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
   return omp_continue_stmt->control_use;
 }
 
@@ -5397,8 +5277,7 @@ gimple_omp_continue_control_use (const_gimple g)
 static inline tree *
 gimple_omp_continue_control_use_ptr (gimple g)
 {
-  gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <gimple_statement_omp_continue *> (g);
+  gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   return &omp_continue_stmt->control_use;
 }
 
@@ -5408,8 +5287,7 @@ gimple_omp_continue_control_use_ptr (gimple g)
 static inline void
 gimple_omp_continue_set_control_use (gimple g, tree use)
 {
-  gimple_statement_omp_continue *omp_continue_stmt =
-    as_a <gimple_statement_omp_continue *> (g);
+  gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   omp_continue_stmt->control_use = use;
 }
 
@@ -5418,8 +5296,7 @@ gimple_omp_continue_set_control_use (gimple g, tree use)
 static inline gimple_seq *
 gimple_transaction_body_ptr (gimple gs)
 {
-  gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction *> (gs);
+  gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   return &transaction_stmt->body;
 }
 
@@ -5436,16 +5313,14 @@ gimple_transaction_body (gimple gs)
 static inline tree
 gimple_transaction_label (const_gimple gs)
 {
-  const gimple_statement_transaction *transaction_stmt =
-    as_a <const gimple_statement_transaction *> (gs);
+  const gtransaction *transaction_stmt = as_a <const gtransaction *> (gs);
   return transaction_stmt->label;
 }
 
 static inline tree *
 gimple_transaction_label_ptr (gimple gs)
 {
-  gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction *> (gs);
+  gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   return &transaction_stmt->label;
 }
 
@@ -5463,8 +5338,7 @@ gimple_transaction_subcode (const_gimple gs)
 static inline void
 gimple_transaction_set_body (gimple gs, gimple_seq body)
 {
-  gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction *> (gs);
+  gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   transaction_stmt->body = body;
 }
 
@@ -5473,8 +5347,7 @@ gimple_transaction_set_body (gimple gs, gimple_seq body)
 static inline void
 gimple_transaction_set_label (gimple gs, tree label)
 {
-  gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction *> (gs);
+  gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   transaction_stmt->label = label;
 }
 
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 3241633..cf4ac84 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -5173,7 +5173,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
 	    }
 	  else
 	    {
-	      gimple_statement_try *gtry;
+	      gtry *gtry;
 	      gimple_seq seq;
 	      enum gimple_try_flags kind;
 
diff --git a/gcc/gsstruct.def b/gcc/gsstruct.def
index c061dce..67ddcb3 100644
--- a/gcc/gsstruct.def
+++ b/gcc/gsstruct.def
@@ -25,29 +25,29 @@ along with GCC; see the file COPYING3.  If not see
    Each enum value should correspond with a single member of the union
    gimple_statement_d.  */
 
-DEFGSSTRUCT(GSS_BASE, gimple_statement_base, false)
-DEFGSSTRUCT(GSS_WITH_OPS, gimple_statement_with_ops, true)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_statement_with_memory_ops_base, false)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_statement_with_memory_ops, true)
-DEFGSSTRUCT(GSS_CALL, gimple_statement_call, true)
-DEFGSSTRUCT(GSS_ASM, gimple_statement_asm, true)
-DEFGSSTRUCT(GSS_BIND, gimple_statement_bind, false)
-DEFGSSTRUCT(GSS_PHI, gimple_statement_phi, false)
-DEFGSSTRUCT(GSS_TRY, gimple_statement_try, false)
-DEFGSSTRUCT(GSS_CATCH, gimple_statement_catch, false)
-DEFGSSTRUCT(GSS_EH_FILTER, gimple_statement_eh_filter, false)
-DEFGSSTRUCT(GSS_EH_MNT, gimple_statement_eh_mnt, false)
-DEFGSSTRUCT(GSS_EH_CTRL, gimple_statement_eh_ctrl, false)
-DEFGSSTRUCT(GSS_EH_ELSE, gimple_statement_eh_else, false)
-DEFGSSTRUCT(GSS_WCE, gimple_statement_wce, false)
-DEFGSSTRUCT(GSS_OMP, gimple_statement_omp, false)
-DEFGSSTRUCT(GSS_OMP_CRITICAL, gimple_statement_omp_critical, false)
-DEFGSSTRUCT(GSS_OMP_FOR, gimple_statement_omp_for, false)
-DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gimple_statement_omp_parallel_layout, false)
-DEFGSSTRUCT(GSS_OMP_TASK, gimple_statement_omp_task, false)
-DEFGSSTRUCT(GSS_OMP_SECTIONS, gimple_statement_omp_sections, false)
-DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gimple_statement_omp_single_layout, false)
-DEFGSSTRUCT(GSS_OMP_CONTINUE, gimple_statement_omp_continue, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gimple_statement_omp_atomic_load, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gimple_statement_omp_atomic_store, false)
-DEFGSSTRUCT(GSS_TRANSACTION, gimple_statement_transaction, false)
+DEFGSSTRUCT(GSS_BASE, gimple, false)
+DEFGSSTRUCT(GSS_WITH_OPS, gimple_with_ops, true)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_with_memory_ops_base, false)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_with_memory_ops, true)
+DEFGSSTRUCT(GSS_CALL, gcall, true)
+DEFGSSTRUCT(GSS_ASM, gasm, true)
+DEFGSSTRUCT(GSS_BIND, gbind, false)
+DEFGSSTRUCT(GSS_PHI, gphi, false)
+DEFGSSTRUCT(GSS_TRY, gtry, false)
+DEFGSSTRUCT(GSS_CATCH, gcatch, false)
+DEFGSSTRUCT(GSS_EH_FILTER, geh_filter, false)
+DEFGSSTRUCT(GSS_EH_MNT, geh_mnt, false)
+DEFGSSTRUCT(GSS_EH_CTRL, geh_ctrl, false)
+DEFGSSTRUCT(GSS_EH_ELSE, geh_else, false)
+DEFGSSTRUCT(GSS_WCE, gwce, false)
+DEFGSSTRUCT(GSS_OMP, gomp, false)
+DEFGSSTRUCT(GSS_OMP_CRITICAL, gomp_critical, false)
+DEFGSSTRUCT(GSS_OMP_FOR, gomp_for, false)
+DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gomp_parallel_layout, false)
+DEFGSSTRUCT(GSS_OMP_TASK, gomp_task, false)
+DEFGSSTRUCT(GSS_OMP_SECTIONS, gomp_sections, false)
+DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gomp_single_layout, false)
+DEFGSSTRUCT(GSS_OMP_CONTINUE, gomp_continue, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gomp_atomic_load, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gomp_atomic_store, false)
+DEFGSSTRUCT(GSS_TRANSACTION, gtransaction, false)
diff --git a/gcc/system.h b/gcc/system.h
index b20b5cf..17fb7c8 100644
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -1023,7 +1023,7 @@ helper_const_non_const_cast (const char *p)
 #define CONST_CAST_TREE(X) CONST_CAST (union tree_node *, (X))
 #define CONST_CAST_RTX(X) CONST_CAST (struct rtx_def *, (X))
 #define CONST_CAST_BB(X) CONST_CAST (struct basic_block_def *, (X))
-#define CONST_CAST_GIMPLE(X) CONST_CAST (struct gimple_statement_base *, (X))
+#define CONST_CAST_GIMPLE(X) CONST_CAST (gimple *, (X))
 
 /* Activate certain diagnostics as warnings (not errors via the
    -Werror flag).  */
diff --git a/gcc/target.def b/gcc/target.def
index dd167bb..a09ee8e 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -3500,7 +3500,7 @@ DEFHOOK_UNDOC
 "Perform architecture specific checking of statements gimplified\
  from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
  the statement doesn't need to be checked for @code{va_list} references.",
- bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
+ bool, (struct stdarg_info *ai, const gimple *stmt), NULL)
 
 /* This target hook allows the operating system to override the DECL
    that represents the external variable that contains the stack
diff --git a/gcc/testsuite/g++.dg/plugin/selfassign.c b/gcc/testsuite/g++.dg/plugin/selfassign.c
index 59bb03a..deb3c39 100644
--- a/gcc/testsuite/g++.dg/plugin/selfassign.c
+++ b/gcc/testsuite/g++.dg/plugin/selfassign.c
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
           if ((!vdecl || DECL_ARTIFICIAL (vdecl))
               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
             {
-              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
               /* We are only interested in an assignment with a single
                  rhs operand because if it is not, the original assignment
                  will not possibly be a self-assignment.  */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
           if ((!vdecl || DECL_ARTIFICIAL (vdecl))
               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
             {
-              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
               if (gimple_assign_single_p (def_stmt))
                 vdecl = gimple_assign_rhs1 (def_stmt);
             }
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
    they are the same. If so, print a warning message about self-assignment.  */
 
 static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
 {
   if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
     {
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
 /* Check and warn if STMT is a self-assign statement.  */
 
 static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
 {
   tree rhs, lhs;
 
diff --git a/gcc/testsuite/gcc.dg/plugin/selfassign.c b/gcc/testsuite/gcc.dg/plugin/selfassign.c
index 4dad0c2..41f19cd 100644
--- a/gcc/testsuite/gcc.dg/plugin/selfassign.c
+++ b/gcc/testsuite/gcc.dg/plugin/selfassign.c
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
           if ((!vdecl || DECL_ARTIFICIAL (vdecl))
               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
             {
-              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
               /* We are only interested in an assignment with a single
                  rhs operand because if it is not, the original assignment
                  will not possibly be a self-assignment.  */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
           if ((!vdecl || DECL_ARTIFICIAL (vdecl))
               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
             {
-              gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+              gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
               if (gimple_assign_single_p (def_stmt))
                 vdecl = gimple_assign_rhs1 (def_stmt);
             }
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
    they are the same. If so, print a warning message about self-assignment.  */
 
 static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
 {
   if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
     {
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
 /* Check and warn if STMT is a self-assign statement.  */
 
 static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
 {
   tree rhs, lhs;
 
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index 77f3cc0..f289cec 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -233,7 +233,7 @@ dump_dfa_stats (FILE *file)
   fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
 	   SCALE (size), LABEL (size));
 
-  size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
+  size = dfa_stats.num_phis * sizeof (struct gphi);
   total += size;
   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 	   SCALE (size), LABEL (size));
diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c
index 0be431e..03c9ebf 100644
--- a/gcc/tree-phinodes.c
+++ b/gcc/tree-phinodes.c
@@ -97,13 +97,12 @@ phinodes_print_statistics (void)
    happens to contain a PHI node with LEN arguments or more, return
    that one.  */
 
-static inline gimple_statement_phi *
+static inline gphi *
 allocate_phi_node (size_t len)
 {
-  gimple_statement_phi *phi;
+  gphi *phi;
   size_t bucket = NUM_BUCKETS - 2;
-  size_t size = sizeof (struct gimple_statement_phi)
-	        + (len - 1) * sizeof (struct phi_arg_d);
+  size_t size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);
 
   if (free_phinode_count)
     for (bucket = len - 2; bucket < NUM_BUCKETS - 2; bucket++)
@@ -115,7 +114,7 @@ allocate_phi_node (size_t len)
       && gimple_phi_capacity ((*free_phinodes[bucket])[0]) >= len)
     {
       free_phinode_count--;
-      phi = as_a <gimple_statement_phi *> (free_phinodes[bucket]->pop ());
+      phi = as_a <gphi *> (free_phinodes[bucket]->pop ());
       if (free_phinodes[bucket]->is_empty ())
 	vec_free (free_phinodes[bucket]);
       if (GATHER_STATISTICS)
@@ -123,7 +122,7 @@ allocate_phi_node (size_t len)
     }
   else
     {
-      phi = static_cast <gimple_statement_phi *> (
+      phi = static_cast <gphi *> (
 	ggc_internal_alloc_stat (size MEM_STAT_INFO));
       if (GATHER_STATISTICS)
 	{
@@ -158,8 +157,7 @@ ideal_phi_node_len (int len)
     len = 2;
 
   /* Compute the number of bytes of the original request.  */
-  size = sizeof (struct gimple_statement_phi)
-	 + (len - 1) * sizeof (struct phi_arg_d);
+  size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);
 
   /* Round it up to the next power of two.  */
   log2 = ceil_log2 (size);
@@ -176,7 +174,7 @@ ideal_phi_node_len (int len)
 static gimple
 make_phi_node (tree var, int len)
 {
-  gimple_statement_phi *phi;
+  gphi *phi;
   int capacity, i;
 
   capacity = ideal_phi_node_len (len);
@@ -186,7 +184,7 @@ make_phi_node (tree var, int len)
   /* We need to clear the entire PHI node, including the argument
      portion, because we represent a "missing PHI argument" by placing
      NULL_TREE in PHI_ARG_DEF.  */
-  memset (phi, 0, (sizeof (struct gimple_statement_phi)
+  memset (phi, 0, (sizeof (struct gphi)
 		   - sizeof (struct phi_arg_d)
 		   + sizeof (struct phi_arg_d) * len));
   phi->code = GIMPLE_PHI;
@@ -241,18 +239,18 @@ release_phi_node (gimple phi)
 /* Resize an existing PHI node.  The only way is up.  Return the
    possibly relocated phi.  */
 
-static gimple_statement_phi *
-resize_phi_node (gimple_statement_phi *phi, size_t len)
+static gphi *
+resize_phi_node (gphi *phi, size_t len)
 {
   size_t old_size, i;
-  gimple_statement_phi *new_phi;
+  gphi *new_phi;
 
   gcc_assert (len > gimple_phi_capacity (phi));
 
   /* The garbage collector will not look at the PHI node beyond the
      first PHI_NUM_ARGS elements.  Therefore, all we have to copy is a
      portion of the PHI node currently in use.  */
-  old_size = sizeof (struct gimple_statement_phi)
+  old_size = sizeof (struct gphi)
 	     + (gimple_phi_num_args (phi) - 1) * sizeof (struct phi_arg_d);
 
   new_phi = allocate_phi_node (len);
@@ -296,12 +294,11 @@ reserve_phi_args_for_new_edge (basic_block bb)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple_statement_phi *stmt =
-	as_a <gimple_statement_phi *> (gsi_stmt (gsi));
+      gphi *stmt = as_a <gphi *> (gsi_stmt (gsi));
 
       if (len > gimple_phi_capacity (stmt))
 	{
-	  gimple_statement_phi *new_phi = resize_phi_node (stmt, cap);
+	  gphi *new_phi = resize_phi_node (stmt, cap);
 
 	  /* The result of the PHI is defined by this PHI node.  */
 	  SSA_NAME_DEF_STMT (gimple_phi_result (new_phi)) = new_phi;
@@ -397,7 +394,7 @@ add_phi_arg (gimple phi, tree def, edge e, source_location locus)
    is consistent with how we remove an edge from the edge vector.  */
 
 static void
-remove_phi_arg_num (gimple_statement_phi *phi, int i)
+remove_phi_arg_num (gphi *phi, int i)
 {
   int num_elem = gimple_phi_num_args (phi);
 
@@ -436,7 +433,7 @@ remove_phi_args (edge e)
   gimple_stmt_iterator gsi;
 
   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
-    remove_phi_arg_num (as_a <gimple_statement_phi *> (gsi_stmt (gsi)),
+    remove_phi_arg_num (as_a <gphi *> (gsi_stmt (gsi)),
 			e->dest_idx);
 }
 
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index d741012..7311f5e 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1895,7 +1895,7 @@ evaluate_stmt (gimple stmt)
   return val;
 }
 
-typedef hash_table <pointer_hash <gimple_statement_base> > gimple_htab;
+typedef hash_table <pointer_hash <gimple> > gimple_htab;
 
 /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
    each matching BUILT_IN_STACK_RESTORE.  Mark visited phis in VISITED.  */
-- 
1.8.5.3

